Rename final_result to result and drop DepsT in some places

Author: dmontagu

Diff for: docs/agents.md

@@ -144,7 +144,7 @@ async def main():
         End(data=FinalResult(data='Paris', tool_name=None)),
     ]
     """
-    print(agent_run.final_result.data)
+    print(agent_run.result.data)
     #> Paris
 ```
 

Diff for: docs/graph.md

@@ -156,11 +156,11 @@ class Increment(BaseNode):  # (2)!
 
 
 fives_graph = Graph(nodes=[DivisibleBy5, Increment])  # (3)!
-graph_run = fives_graph.run_sync(DivisibleBy5(4))  # (4)!
-print(graph_run.result)
+result = fives_graph.run_sync(DivisibleBy5(4))  # (4)!
+print(result.output)
 #> 5
 # the full history is quite verbose (see below), so we'll just print the summary
-print([item.data_snapshot() for item in graph_run.history])
+print([item.data_snapshot() for item in result.history])
 #> [DivisibleBy5(foo=4), Increment(foo=4), DivisibleBy5(foo=5), End(data=5)]
 ```
 
@@ -464,8 +464,8 @@ async def main():
     )
     state = State(user)
     feedback_graph = Graph(nodes=(WriteEmail, Feedback))
-    graph_run = await feedback_graph.run(WriteEmail(), state=state)
-    print(graph_run.result)
+    result = await feedback_graph.run(WriteEmail(), state=state)
+    print(result.output)
     """
     Email(
         subject='Welcome to our tech blog!',
@@ -686,7 +686,7 @@ async def main():
             #> Node: CountDown()
             #> Node: CountDown()
             #> Node: End(data=0)
-    print('Final result:', run.final_result.result)  # (3)!
+    print('Final result:', run.result.output)  # (3)!
     #> Final result: 0
     print('History snapshots:', [step.data_snapshot() for step in run.history])
     """
@@ -724,7 +724,7 @@ async def main():
                 break  # (3)!
             node = await run.next(node)  # (4)!
 
-        print(run.final_result)  # (5)!
+        print(run.result)  # (5)!
         #> None
 
         for step in run.history:  # (6)!
@@ -738,7 +738,7 @@ async def main():
 2. The agent run is finished once an `End` node has been produced; instances of `End` cannot be passed to `next`.
 3. If the user decides to stop early, we break out of the loop. The graph run won't have a real final result in that case (`run.final_result` remains `None`).
 4. At each step, we call `await run.next(node)` to run it and get the next node (or an `End`).
-5. Because the run was ended early, we have no final result:
+5. Because we did not continue the run until it finished, the `result` is not set.
 6. The run's history is still populated with the steps we executed so far.
 
 ## Dependency Injection
@@ -798,11 +798,11 @@ fives_graph = Graph(nodes=[DivisibleBy5, Increment])
 async def main():
     with ProcessPoolExecutor() as executor:
         deps = GraphDeps(executor)
-        graph_run = await fives_graph.run(DivisibleBy5(3), deps=deps)
-    print(graph_run.result)
+        result = await fives_graph.run(DivisibleBy5(3), deps=deps)
+    print(result.output)
     #> 5
     # the full history is quite verbose (see below), so we'll just print the summary
-    print([item.data_snapshot() for item in graph_run.history])
+    print([item.data_snapshot() for item in result.history])
     """
     [
         DivisibleBy5(foo=3),

Diff for: pydantic_ai_slim/pydantic_ai/agent.py

@@ -13,7 +13,6 @@
 from typing_extensions import TypeVar, deprecated
 
 from pydantic_graph import BaseNode, End, Graph, GraphRun, GraphRunContext
-from pydantic_graph.graph import GraphRunResult
 
 from . import (
     _agent_graph,
@@ -215,7 +214,7 @@ async def run(
         usage_limits: _usage.UsageLimits | None = None,
         usage: _usage.Usage | None = None,
         infer_name: bool = True,
-    ) -> AgentRunResult[AgentDepsT, ResultDataT]: ...
+    ) -> AgentRunResult[ResultDataT]: ...
 
     @overload
     async def run(
@@ -230,7 +229,7 @@ async def run(
         usage_limits: _usage.UsageLimits | None = None,
         usage: _usage.Usage | None = None,
         infer_name: bool = True,
-    ) -> AgentRunResult[AgentDepsT, RunResultDataT]: ...
+    ) -> AgentRunResult[RunResultDataT]: ...
 
     async def run(
         self,
@@ -244,7 +243,7 @@ async def run(
         usage_limits: _usage.UsageLimits | None = None,
         usage: _usage.Usage | None = None,
         infer_name: bool = True,
-    ) -> AgentRunResult[AgentDepsT, Any]:
+    ) -> AgentRunResult[Any]:
         """Run the agent with a user prompt in async mode.
 
         This method builds an internal agent graph (using system prompts, tools and result schemas) and then
@@ -291,8 +290,8 @@ async def main():
         ) as agent_run:
             async for _ in agent_run:
                 pass
-        final_result = agent_run.final_result
-        assert final_result is not None, 'The graph run should have ended with a final result'
+
+        assert (final_result := agent_run.result) is not None, 'The graph run did not finish properly'
         return final_result
 
     @contextmanager
@@ -358,7 +357,7 @@ async def main():
                 End(data=FinalResult(data='Paris', tool_name=None)),
             ]
             '''
-            print(agent_run.final_result.data)
+            print(agent_run.result.data)
             #> Paris
         ```
 
@@ -460,7 +459,7 @@ def run_sync(
         usage_limits: _usage.UsageLimits | None = None,
         usage: _usage.Usage | None = None,
         infer_name: bool = True,
-    ) -> AgentRunResult[AgentDepsT, ResultDataT]: ...
+    ) -> AgentRunResult[ResultDataT]: ...
 
     @overload
     def run_sync(
@@ -475,7 +474,7 @@ def run_sync(
         usage_limits: _usage.UsageLimits | None = None,
         usage: _usage.Usage | None = None,
         infer_name: bool = True,
-    ) -> AgentRunResult[AgentDepsT, RunResultDataT]: ...
+    ) -> AgentRunResult[RunResultDataT]: ...
 
     def run_sync(
         self,
@@ -489,7 +488,7 @@ def run_sync(
         usage_limits: _usage.UsageLimits | None = None,
         usage: _usage.Usage | None = None,
         infer_name: bool = True,
-    ) -> AgentRunResult[AgentDepsT, Any]:
+    ) -> AgentRunResult[Any]:
         """Synchronously run the agent with a user prompt.
 
         This is a convenience method that wraps [`self.run`][pydantic_ai.Agent.run] with `loop.run_until_complete(...)`.
@@ -1166,8 +1165,8 @@ class AgentRun(Generic[AgentDepsT, ResultDataT]):
     You generally obtain an `AgentRun` instance by calling `with my_agent.iter(...) as agent_run:`.
 
     Once you have an instance, you can use it to iterate through the run's nodes as they execute. When an
-    [`End`][pydantic_graph.nodes.End] is reached, the run finishes and
-    [`final_result`][pydantic_ai.agent.AgentRun.final_result] becomes available.
+    [`End`][pydantic_graph.nodes.End] is reached, the run finishes and [`result`][pydantic_ai.agent.AgentRun.result]
+    becomes available.
 
     Example:
     ```python
@@ -1207,7 +1206,7 @@ async def main():
             End(data=FinalResult(data='Paris', tool_name=None)),
         ]
         '''
-        print(agent_run.final_result.data)
+        print(agent_run.result.data)
         #> Paris
     ```
 
@@ -1240,16 +1239,21 @@ def next_node(
         return self._graph_run.next_node
 
     @property
-    def final_result(self) -> AgentRunResult[AgentDepsT, ResultDataT] | None:
+    def result(self) -> AgentRunResult[ResultDataT] | None:
         """The final result of the run if it has ended, otherwise `None`.
 
-        Once the run returns an [`End`][pydantic_graph.nodes.End] node, `final_result` is populated
+        Once the run returns an [`End`][pydantic_graph.nodes.End] node, `result` is populated
         with an [`AgentRunResult`][pydantic_ai.agent.AgentRunResult].
         """
-        graph_run_result = self._graph_run.final_result
+        graph_run_result = self._graph_run.result
         if graph_run_result is None:
             return None
-        return AgentRunResult(graph_run_result)
+        return AgentRunResult(
+            graph_run_result.output.data,
+            graph_run_result.output.tool_name,
+            graph_run_result.state,
+            self._graph_run.deps.new_message_index,
+        )
 
     def __aiter__(
         self,
@@ -1345,7 +1349,7 @@ async def main():
                     End(data=FinalResult(data='Paris', tool_name=None)),
                 ]
                 '''
-                print('Final result:', agent_run.final_result.data)
+                print('Final result:', agent_run.result.data)
                 #> Final result: Paris
         ```
 
@@ -1364,47 +1368,36 @@ def usage(self) -> _usage.Usage:
         """Get usage statistics for the run so far, including token usage, model requests, and so on."""
         return self._graph_run.state.usage
 
-    def __repr__(self):
-        final_result = self._graph_run.final_result
-        result_repr = '<run not finished>' if final_result is None else repr(final_result.result)
-        kws = [f'result={result_repr}', f'usage={self.usage()}']
-        return '<{} {}>'.format(type(self).__name__, ' '.join(kws))
+    def __repr__(self) -> str:
+        result = self._graph_run.result
+        result_repr = '<run not finished>' if result is None else repr(result.output)
+        return f'<{type(self).__name__} result={result_repr} usage={self.usage()}>'
 
 
 @dataclasses.dataclass
-class AgentRunResult(Generic[AgentDepsT, ResultDataT]):
+class AgentRunResult(Generic[ResultDataT]):
     """The final result of an agent run."""
 
-    _graph_run_result: GraphRunResult[
-        _agent_graph.GraphAgentState, _agent_graph.GraphAgentDeps[AgentDepsT, Any], FinalResult[ResultDataT]
-    ]
-
-    @property
-    def _result(self) -> FinalResult[ResultDataT]:
-        return self._graph_run_result.result
-
-    @property
-    def data(self) -> ResultDataT:
-        return self._result.data
+    data: ResultDataT  # TODO: rename this to output. I'm putting this off for now mostly to reduce the size of the diff
 
-    @property
-    def _result_tool_name(self) -> str | None:
-        return self._result.tool_name
+    _result_tool_name: str | None = dataclasses.field(repr=False)
+    _state: _agent_graph.GraphAgentState = dataclasses.field(repr=False)
+    _new_message_index: int = dataclasses.field(repr=False)
 
     def _set_result_tool_return(self, return_content: str) -> list[_messages.ModelMessage]:
         """Set return content for the result tool.
 
         Useful if you want to continue the conversation and want to set the response to the result tool call.
         """
-        if not self._result.tool_name:
+        if not self._result_tool_name:
             raise ValueError('Cannot set result tool return content when the return type is `str`.')
-        messages = deepcopy(self._graph_run_result.state.message_history)
+        messages = deepcopy(self._state.message_history)
         last_message = messages[-1]
         for part in last_message.parts:
-            if isinstance(part, _messages.ToolReturnPart) and part.tool_name == self._result.tool_name:
+            if isinstance(part, _messages.ToolReturnPart) and part.tool_name == self._result_tool_name:
                 part.content = return_content
                 return messages
-        raise LookupError(f'No tool call found with tool name {self._result.tool_name!r}.')
+        raise LookupError(f'No tool call found with tool name {self._result_tool_name!r}.')
 
     def all_messages(self, *, result_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
         """Return the history of _messages.
@@ -1421,7 +1414,7 @@ def all_messages(self, *, result_tool_return_content: str | None = None) -> list
         if result_tool_return_content is not None:
             return self._set_result_tool_return(result_tool_return_content)
         else:
-            return self._graph_run_result.state.message_history
+            return self._state.message_history
 
     def all_messages_json(self, *, result_tool_return_content: str | None = None) -> bytes:
         """Return all messages from [`all_messages`][pydantic_ai.agent.AgentRunResult.all_messages] as JSON bytes.
@@ -1439,10 +1432,6 @@ def all_messages_json(self, *, result_tool_return_content: str | None = None) ->
             self.all_messages(result_tool_return_content=result_tool_return_content)
         )
 
-    @property
-    def _new_message_index(self) -> int:
-        return self._graph_run_result.deps.new_message_index
-
     def new_messages(self, *, result_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
         """Return new messages associated with this run.
 
@@ -1477,8 +1466,4 @@ def new_messages_json(self, *, result_tool_return_content: str | None = None) ->
 
     def usage(self) -> _usage.Usage:
         """Return the usage of the whole run."""
-        return self._graph_run_result.state.usage
-
-    def __repr__(self):
-        kws = [f'data={self.data!r}', f'usage={self.usage()}']
-        return '<{} {}>'.format(type(self).__name__, ' '.join(kws))
+        return self._state.usage

Diff for: pydantic_graph/README.md

@@ -50,10 +50,10 @@ class Increment(BaseNode):
 
 
 fives_graph = Graph(nodes=[DivisibleBy5, Increment])
-graph_run = fives_graph.run_sync(DivisibleBy5(4))
-print(graph_run.result)
+result = fives_graph.run_sync(DivisibleBy5(4))
+print(result.output)
 #> 5
 # the full history is quite verbose (see below), so we'll just print the summary
-print([item.data_snapshot() for item in graph_run.history])
+print([item.data_snapshot() for item in result.history])
 #> [DivisibleBy5(foo=4), Increment(foo=4), DivisibleBy5(foo=5), End(data=5)]
 ```

Diff for: pydantic_graph/pydantic_graph/graph.py

@@ -134,7 +134,7 @@ async def run(
         deps: DepsT = None,
         infer_name: bool = True,
         span: LogfireSpan | None = None,
-    ) -> GraphRunResult[StateT, DepsT, T]:
+    ) -> GraphRunResult[StateT, T]:
         """Run the graph from a starting node until it ends.
 
         Args:
@@ -177,7 +177,7 @@ async def main():
             async for _node in graph_run:
                 pass
 
-        final_result = graph_run.final_result
+        final_result = graph_run.result
         assert final_result is not None, 'GraphRun should have a final result'
         return final_result
 
@@ -242,7 +242,7 @@ def run_sync(
         state: StateT = None,
         deps: DepsT = None,
         infer_name: bool = True,
-    ) -> GraphRunResult[StateT, DepsT, T]:
+    ) -> GraphRunResult[StateT, T]:
         """Synchronously run the graph.
 
         This is a convenience method that wraps [`self.run`][pydantic_graph.Graph.run] with `loop.run_until_complete(...)`.
@@ -659,12 +659,14 @@ def next_node(self) -> BaseNode[StateT, DepsT, RunEndT] | End[RunEndT]:
         return self._next_node
 
     @property
-    def final_result(self) -> GraphRunResult[StateT, DepsT, RunEndT] | None:
+    def result(self) -> GraphRunResult[StateT, RunEndT] | None:
         """The final result of the graph run if the run is completed, otherwise `None`."""
         if not isinstance(self._next_node, End):
             return None  # The GraphRun has not finished running
         return GraphRunResult(
-            self._next_node.data, graph=self.graph, history=self.history, state=self.state, deps=self.deps
+            self._next_node.data,
+            state=self.state,
+            history=self.history,
         )
 
     async def next(
@@ -735,13 +737,14 @@ async def __anext__(self) -> BaseNode[StateT, DepsT, RunEndT] | End[RunEndT]:
             raise StopAsyncIteration
         return await self.next(self._next_node)
 
+    def __repr__(self) -> str:
+        return f'<GraphRun name={self.graph.name or "<unnamed>"} step={len(self.history) + 1}>'
+
 
 @dataclass
-class GraphRunResult(Generic[StateT, DepsT, RunEndT]):
+class GraphRunResult(Generic[StateT, RunEndT]):
     """The final result of running a graph."""
 
-    result: RunEndT
-    graph: Graph[StateT, DepsT, RunEndT] = field(repr=False)
-    history: list[HistoryStep[StateT, RunEndT]]
+    output: RunEndT
     state: StateT
-    deps: DepsT
+    history: list[HistoryStep[StateT, RunEndT]] = field(repr=False)