pydantic-ai-slim 0.4.5__tar.gz → 0.4.7__tar.gz

{pydantic_ai_slim-0.4.5 → pydantic_ai_slim-0.4.7}/.gitignore

@@ -15,7 +15,6 @@ examples/pydantic_ai_examples/.chat_app_messages.sqlite
 .vscode/
 /question_graph_history.json
 /docs-site/.wrangler/
-/CLAUDE.md
 node_modules/
 **.idea/
 .coverage*

{pydantic_ai_slim-0.4.5 → pydantic_ai_slim-0.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.4.5
+Version: 0.4.7
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>, Douwe Maan <douwe@pydantic.dev>
 License-Expression: MIT
@@ -30,7 +30,7 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.4.5
+Requires-Dist: pydantic-graph==0.4.7
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -47,23 +47,23 @@ Requires-Dist: argcomplete>=3.5.0; extra == 'cli'
 Requires-Dist: prompt-toolkit>=3; extra == 'cli'
 Requires-Dist: rich>=13; extra == 'cli'
 Provides-Extra: cohere
-Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == 'cohere'
+Requires-Dist: cohere>=5.16.0; (platform_system != 'Emscripten') and extra == 'cohere'
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.4.5; extra == 'evals'
+Requires-Dist: pydantic-evals==0.4.7; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.24.0; extra == 'google'
 Provides-Extra: groq
 Requires-Dist: groq>=0.19.0; extra == 'groq'
 Provides-Extra: huggingface
-Requires-Dist: huggingface-hub[inference]>=0.33.2; extra == 'huggingface'
+Requires-Dist: huggingface-hub[inference]>=0.33.5; extra == 'huggingface'
 Provides-Extra: logfire
 Requires-Dist: logfire>=3.11.0; extra == 'logfire'
 Provides-Extra: mcp
-Requires-Dist: mcp>=1.9.4; (python_version >= '3.10') and extra == 'mcp'
+Requires-Dist: mcp>=1.10.0; (python_version >= '3.10') and extra == 'mcp'
 Provides-Extra: mistral
-Requires-Dist: mistralai>=1.2.5; extra == 'mistral'
+Requires-Dist: mistralai>=1.9.2; extra == 'mistral'
 Provides-Extra: openai
 Requires-Dist: openai>=1.92.0; extra == 'openai'
 Provides-Extra: tavily

{pydantic_ai_slim-0.4.5 → pydantic_ai_slim-0.4.7}/pydantic_ai/_function_schema.py

@@ -96,8 +96,13 @@ def function_schema(  # noqa: C901
     config = ConfigDict(title=function.__name__, use_attribute_docstrings=True)
     config_wrapper = ConfigWrapper(config)
     gen_schema = _generate_schema.GenerateSchema(config_wrapper)
+    errors: list[str] = []
 
-    sig = signature(function)
+    try:
+        sig = signature(function)
+    except ValueError as e:
+        errors.append(str(e))
+        sig = signature(lambda: None)
 
     type_hints = _typing_extra.get_function_type_hints(function)
 
@@ -105,7 +110,6 @@ def function_schema(  # noqa: C901
     fields: dict[str, core_schema.TypedDictField] = {}
     positional_fields: list[str] = []
     var_positional_field: str | None = None
-    errors: list[str] = []
     decorators = _decorators.DecoratorInfos()
 
     description, field_descriptions = doc_descriptions(function, sig, docstring_format=docstring_format)
@@ -235,14 +239,19 @@ def _takes_ctx(function: TargetFunc[P, R]) -> TypeIs[WithCtx[P, R]]:
     Returns:
         `True` if the function takes a `RunContext` as first argument, `False` otherwise.
     """
-    sig = signature(function)
+    try:
+        sig = signature(function)
+    except ValueError:  # pragma: no cover
+        return False  # pragma: no cover
     try:
         first_param_name = next(iter(sig.parameters.keys()))
     except StopIteration:
         return False
     else:
         type_hints = _typing_extra.get_function_type_hints(function)
-        annotation = type_hints[first_param_name]
+        annotation = type_hints.get(first_param_name)
+        if annotation is None:
+            return False  # pragma: no cover
         return True is not sig.empty and _is_call_ctx(annotation)
 
 

{pydantic_ai_slim-0.4.5 → pydantic_ai_slim-0.4.7}/pydantic_ai/_output.py

@@ -69,12 +69,31 @@ DEFAULT_OUTPUT_TOOL_NAME = 'final_result'
 DEFAULT_OUTPUT_TOOL_DESCRIPTION = 'The final response which ends this conversation'
 
 
-async def execute_output_function_with_span(
+async def execute_traced_output_function(
     function_schema: _function_schema.FunctionSchema,
     run_context: RunContext[AgentDepsT],
     args: dict[str, Any] | Any,
+    wrap_validation_errors: bool = True,
 ) -> Any:
-    """Execute a function call within a traced span, automatically recording the response."""
+    """Execute an output function within a traced span with error handling.
+
+    This function executes the output function within an OpenTelemetry span for observability,
+    automatically records the function response, and handles ModelRetry exceptions by converting
+    them to ToolRetryError when wrap_validation_errors is True.
+
+    Args:
+        function_schema: The function schema containing the function to execute
+        run_context: The current run context containing tracing and tool information
+        args: Arguments to pass to the function
+        wrap_validation_errors: If True, wrap ModelRetry exceptions in ToolRetryError
+
+    Returns:
+        The result of the function execution
+
+    Raises:
+        ToolRetryError: When wrap_validation_errors is True and a ModelRetry is caught
+        ModelRetry: When wrap_validation_errors is False and a ModelRetry occurs
+    """
     # Set up span attributes
     tool_name = run_context.tool_name or getattr(function_schema.function, '__name__', 'output_function')
     attributes = {
@@ -96,7 +115,19 @@ async def execute_output_function_with_span(
         )
 
     with run_context.tracer.start_as_current_span('running output function', attributes=attributes) as span:
-        output = await function_schema.call(args, run_context)
+        try:
+            output = await function_schema.call(args, run_context)
+        except ModelRetry as r:
+            if wrap_validation_errors:
+                m = _messages.RetryPromptPart(
+                    content=r.message,
+                    tool_name=run_context.tool_name,
+                )
+                if run_context.tool_call_id:
+                    m.tool_call_id = run_context.tool_call_id  # pragma: no cover
+                raise ToolRetryError(m) from r
+            else:
+                raise
 
         # Record response if content inclusion is enabled
         if run_context.trace_include_content and span.is_recording():
@@ -663,16 +694,7 @@ class ObjectOutputProcessor(BaseOutputProcessor[OutputDataT]):
             else:
                 raise
 
-        try:
-            output = await self.call(output, run_context)
-        except ModelRetry as r:
-            if wrap_validation_errors:
-                m = _messages.RetryPromptPart(
-                    content=r.message,
-                )
-                raise ToolRetryError(m) from r
-            else:
-                raise  # pragma: no cover
+        output = await self.call(output, run_context, wrap_validation_errors)
 
         return output
 
@@ -691,12 +713,15 @@ class ObjectOutputProcessor(BaseOutputProcessor[OutputDataT]):
         self,
         output: Any,
         run_context: RunContext[AgentDepsT],
+        wrap_validation_errors: bool = True,
     ):
         if k := self.outer_typed_dict_key:
             output = output[k]
 
         if self._function_schema:
-            output = await execute_output_function_with_span(self._function_schema, run_context, output)
+            output = await execute_traced_output_function(
+                self._function_schema, run_context, output, wrap_validation_errors
+            )
 
         return output
 
@@ -856,16 +881,7 @@ class PlainTextOutputProcessor(BaseOutputProcessor[OutputDataT]):
         wrap_validation_errors: bool = True,
     ) -> OutputDataT:
         args = {self._str_argument_name: data}
-        try:
-            output = await execute_output_function_with_span(self._function_schema, run_context, args)
-        except ModelRetry as r:
-            if wrap_validation_errors:
-                m = _messages.RetryPromptPart(
-                    content=r.message,
-                )
-                raise ToolRetryError(m) from r
-            else:
-                raise  # pragma: no cover
+        output = await execute_traced_output_function(self._function_schema, run_context, args, wrap_validation_errors)
 
         return cast(OutputDataT, output)
 
@@ -975,7 +991,7 @@ class OutputToolset(AbstractToolset[AgentDepsT]):
     async def call_tool(
         self, name: str, tool_args: dict[str, Any], ctx: RunContext[AgentDepsT], tool: ToolsetTool[AgentDepsT]
     ) -> Any:
-        output = await self.processors[name].call(tool_args, ctx)
+        output = await self.processors[name].call(tool_args, ctx, wrap_validation_errors=False)
         for validator in self.output_validators:
             output = await validator.validate(output, ctx, wrap_validation_errors=False)
         return output

{pydantic_ai_slim-0.4.5 → pydantic_ai_slim-0.4.7}/pydantic_ai/_parts_manager.py

@@ -17,6 +17,7 @@ from collections.abc import Hashable
 from dataclasses import dataclass, field, replace
 from typing import Any, Union
 
+from pydantic_ai._thinking_part import END_THINK_TAG, START_THINK_TAG
 from pydantic_ai.exceptions import UnexpectedModelBehavior
 from pydantic_ai.messages import (
     ModelResponsePart,
@@ -69,9 +70,10 @@ class ModelResponsePartsManager:
     def handle_text_delta(
         self,
         *,
-        vendor_part_id: Hashable | None,
+        vendor_part_id: VendorId | None,
         content: str,
-    ) -> ModelResponseStreamEvent:
+        extract_think_tags: bool = False,
+    ) -> ModelResponseStreamEvent | None:
         """Handle incoming text content, creating or updating a TextPart in the manager as appropriate.
 
         When `vendor_part_id` is None, the latest part is updated if it exists and is a TextPart;
@@ -83,9 +85,12 @@ class ModelResponsePartsManager:
                 of text. If None, a new part will be created unless the latest part is already
                 a TextPart.
             content: The text content to append to the appropriate TextPart.
+            extract_think_tags: Whether to extract `<think>` tags from the text content and handle them as thinking parts.
 
         Returns:
-            A `PartStartEvent` if a new part was created, or a `PartDeltaEvent` if an existing part was updated.
+            - A `PartStartEvent` if a new part was created.
+            - A `PartDeltaEvent` if an existing part was updated.
+            - `None` if no new event is emitted (e.g., the first text part was all whitespace).
 
         Raises:
             UnexpectedModelBehavior: If attempting to apply text content to a part that is not a TextPart.
@@ -104,11 +109,32 @@ class ModelResponsePartsManager:
             part_index = self._vendor_id_to_part_index.get(vendor_part_id)
             if part_index is not None:
                 existing_part = self._parts[part_index]
-                if not isinstance(existing_part, TextPart):
+
+                if extract_think_tags and isinstance(existing_part, ThinkingPart):
+                    # We may be building a thinking part instead of a text part if we had previously seen a `<think>` tag
+                    if content == END_THINK_TAG:
+                        # When we see `</think>`, we're done with the thinking part and the next text delta will need a new part
+                        self._vendor_id_to_part_index.pop(vendor_part_id)
+                        return None
+                    else:
+                        return self.handle_thinking_delta(vendor_part_id=vendor_part_id, content=content)
+                elif isinstance(existing_part, TextPart):
+                    existing_text_part_and_index = existing_part, part_index
+                else:
                     raise UnexpectedModelBehavior(f'Cannot apply a text delta to {existing_part=}')
-                existing_text_part_and_index = existing_part, part_index
+
+        if extract_think_tags and content == START_THINK_TAG:
+            # When we see a `<think>` tag (which is a single token), we'll build a new thinking part instead
+            self._vendor_id_to_part_index.pop(vendor_part_id, None)
+            return self.handle_thinking_delta(vendor_part_id=vendor_part_id, content='')
 
         if existing_text_part_and_index is None:
+            # If the first text delta is all whitespace, don't emit a new part yet.
+            # This is a workaround for models that emit `<think>\n</think>\n\n` ahead of tool calls (e.g. Ollama + Qwen3),
+            # which we don't want to end up treating as a final result.
+            if content.isspace():
+                return None
+
             # There is no existing text part that should be updated, so create a new one
             new_part_index = len(self._parts)
             part = TextPart(content=content)

{pydantic_ai_slim-0.4.5 → pydantic_ai_slim-0.4.7}/pydantic_ai/ag_ui.py

@@ -291,12 +291,12 @@ class _Adapter(Generic[AgentDepsT, OutputDataT]):
             if isinstance(deps, StateHandler):
                 deps.state = run_input.state
 
-            history = _History.from_ag_ui(run_input.messages)
+            messages = _messages_from_ag_ui(run_input.messages)
 
             async with self.agent.iter(
                 user_prompt=None,
                 output_type=[output_type or self.agent.output_type, DeferredToolCalls],
-                message_history=history.messages,
+                message_history=messages,
                 model=model,
                 deps=deps,
                 model_settings=model_settings,
@@ -305,7 +305,7 @@ class _Adapter(Generic[AgentDepsT, OutputDataT]):
                 infer_name=infer_name,
                 toolsets=toolsets,
             ) as run:
-                async for event in self._agent_stream(run, history):
+                async for event in self._agent_stream(run):
                     yield encoder.encode(event)
         except _RunError as e:
             yield encoder.encode(
@@ -327,20 +327,18 @@ class _Adapter(Generic[AgentDepsT, OutputDataT]):
     async def _agent_stream(
         self,
         run: AgentRun[AgentDepsT, Any],
-        history: _History,
     ) -> AsyncGenerator[BaseEvent, None]:
         """Run the agent streaming responses using AG-UI protocol events.
 
         Args:
             run: The agent run to process.
-            history: The history of messages and tool calls to use for the run.
 
         Yields:
             AG-UI Server-Sent Events (SSE).
         """
         async for node in run:
+            stream_ctx = _RequestStreamContext()
             if isinstance(node, ModelRequestNode):
-                stream_ctx = _RequestStreamContext()
                 async with node.stream(run.ctx) as request_stream:
                     async for agent_event in request_stream:
                         async for msg in self._handle_model_request_event(stream_ctx, agent_event):
@@ -352,8 +350,8 @@ class _Adapter(Generic[AgentDepsT, OutputDataT]):
             elif isinstance(node, CallToolsNode):
                 async with node.stream(run.ctx) as handle_stream:
                     async for event in handle_stream:
-                        if isinstance(event, FunctionToolResultEvent) and isinstance(event.result, ToolReturnPart):
-                            async for msg in self._handle_tool_result_event(event.result, history.prompt_message_id):
+                        if isinstance(event, FunctionToolResultEvent):
+                            async for msg in self._handle_tool_result_event(stream_ctx, event):
                                 yield msg
 
     async def _handle_model_request_event(
@@ -382,19 +380,26 @@ class _Adapter(Generic[AgentDepsT, OutputDataT]):
                 yield TextMessageStartEvent(
                     message_id=message_id,
                 )
-                stream_ctx.part_end = TextMessageEndEvent(
-                    message_id=message_id,
-                )
                 if part.content:  # pragma: no branch
                     yield TextMessageContentEvent(
                         message_id=message_id,
                         delta=part.content,
                     )
+                stream_ctx.part_end = TextMessageEndEvent(
+                    message_id=message_id,
+                )
             elif isinstance(part, ToolCallPart):  # pragma: no branch
+                message_id = stream_ctx.message_id or stream_ctx.new_message_id()
                 yield ToolCallStartEvent(
                     tool_call_id=part.tool_call_id,
                     tool_call_name=part.tool_name,
+                    parent_message_id=message_id,
                 )
+                if part.args:
+                    yield ToolCallArgsEvent(
+                        tool_call_id=part.tool_call_id,
+                        delta=part.args if isinstance(part.args, str) else json.dumps(part.args),
+                    )
                 stream_ctx.part_end = ToolCallEndEvent(
                     tool_call_id=part.tool_call_id,
                 )
@@ -407,7 +412,7 @@ class _Adapter(Generic[AgentDepsT, OutputDataT]):
                 # used to indicate the start of thinking.
                 yield ThinkingTextMessageContentEvent(
                     type=EventType.THINKING_TEXT_MESSAGE_CONTENT,
-                    delta=part.content or '',
+                    delta=part.content,
                 )
                 stream_ctx.part_end = ThinkingTextMessageEndEvent(
                     type=EventType.THINKING_TEXT_MESSAGE_END,
@@ -435,20 +440,25 @@ class _Adapter(Generic[AgentDepsT, OutputDataT]):
 
     async def _handle_tool_result_event(
         self,
-        result: ToolReturnPart,
-        prompt_message_id: str,
+        stream_ctx: _RequestStreamContext,
+        event: FunctionToolResultEvent,
     ) -> AsyncGenerator[BaseEvent, None]:
         """Convert a tool call result to AG-UI events.
 
         Args:
-            result: The tool call result to process.
-            prompt_message_id: The message ID of the prompt that initiated the tool call.
+            stream_ctx: The request stream context to manage state.
+            event: The tool call result event to process.
 
         Yields:
             AG-UI Server-Sent Events (SSE).
         """
+        result = event.result
+        if not isinstance(result, ToolReturnPart):
+            return
+
+        message_id = stream_ctx.new_message_id()
         yield ToolCallResultEvent(
-            message_id=prompt_message_id,
+            message_id=message_id,
             type=EventType.TOOL_CALL_RESULT,
             role='tool',
             tool_call_id=result.tool_call_id,
@@ -468,75 +478,55 @@ class _Adapter(Generic[AgentDepsT, OutputDataT]):
                     yield item
 
 
-@dataclass
-class _History:
-    """A simple history representation for AG-UI protocol."""
-
-    prompt_message_id: str  # The ID of the last user message.
-    messages: list[ModelMessage]
-
-    @classmethod
-    def from_ag_ui(cls, messages: list[Message]) -> _History:
-        """Convert a AG-UI history to a Pydantic AI one.
-
-        Args:
-            messages: List of AG-UI messages to convert.
-
-        Returns:
-            List of Pydantic AI model messages.
-        """
-        prompt_message_id = ''
-        result: list[ModelMessage] = []
-        tool_calls: dict[str, str] = {}  # Tool call ID to tool name mapping.
-        for msg in messages:
-            if isinstance(msg, UserMessage):
-                prompt_message_id = msg.id
-                result.append(ModelRequest(parts=[UserPromptPart(content=msg.content)]))
-            elif isinstance(msg, AssistantMessage):
-                if msg.tool_calls:
-                    for tool_call in msg.tool_calls:
-                        tool_calls[tool_call.id] = tool_call.function.name
-
-                    result.append(
-                        ModelResponse(
-                            parts=[
-                                ToolCallPart(
-                                    tool_name=tool_call.function.name,
-                                    tool_call_id=tool_call.id,
-                                    args=tool_call.function.arguments,
-                                )
-                                for tool_call in msg.tool_calls
-                            ]
-                        )
-                    )
-
-                if msg.content:
-                    result.append(ModelResponse(parts=[TextPart(content=msg.content)]))
-            elif isinstance(msg, SystemMessage):
-                result.append(ModelRequest(parts=[SystemPromptPart(content=msg.content)]))
-            elif isinstance(msg, ToolMessage):
-                tool_name = tool_calls.get(msg.tool_call_id)
-                if tool_name is None:  # pragma: no cover
-                    raise _ToolCallNotFoundError(tool_call_id=msg.tool_call_id)
+def _messages_from_ag_ui(messages: list[Message]) -> list[ModelMessage]:
+    """Convert a AG-UI history to a Pydantic AI one."""
+    result: list[ModelMessage] = []
+    tool_calls: dict[str, str] = {}  # Tool call ID to tool name mapping.
+    for msg in messages:
+        if isinstance(msg, UserMessage):
+            result.append(ModelRequest(parts=[UserPromptPart(content=msg.content)]))
+        elif isinstance(msg, AssistantMessage):
+            if msg.tool_calls:
+                for tool_call in msg.tool_calls:
+                    tool_calls[tool_call.id] = tool_call.function.name
 
                 result.append(
-                    ModelRequest(
+                    ModelResponse(
                         parts=[
-                            ToolReturnPart(
-                                tool_name=tool_name,
-                                content=msg.content,
-                                tool_call_id=msg.tool_call_id,
+                            ToolCallPart(
+                                tool_name=tool_call.function.name,
+                                tool_call_id=tool_call.id,
+                                args=tool_call.function.arguments,
                             )
+                            for tool_call in msg.tool_calls
                         ]
                     )
                 )
-            elif isinstance(msg, DeveloperMessage):  # pragma: no branch
-                result.append(ModelRequest(parts=[SystemPromptPart(content=msg.content)]))
 
-        return cls(
-            prompt_message_id=prompt_message_id,
-            messages=result,
-        )
+            if msg.content:
+                result.append(ModelResponse(parts=[TextPart(content=msg.content)]))
+        elif isinstance(msg, SystemMessage):
+            result.append(ModelRequest(parts=[SystemPromptPart(content=msg.content)]))
+        elif isinstance(msg, ToolMessage):
+            tool_name = tool_calls.get(msg.tool_call_id)
+            if tool_name is None:  # pragma: no cover
+                raise _ToolCallNotFoundError(tool_call_id=msg.tool_call_id)
+
+            result.append(
+                ModelRequest(
+                    parts=[
+                        ToolReturnPart(
+                            tool_name=tool_name,
+                            content=msg.content,
+                            tool_call_id=msg.tool_call_id,
+                        )
+                    ]
+                )
+            )
+        elif isinstance(msg, DeveloperMessage):  # pragma: no branch
+            result.append(ModelRequest(parts=[SystemPromptPart(content=msg.content)]))
+
+    return result
 
 
 @runtime_checkable

{pydantic_ai_slim-0.4.5 → pydantic_ai_slim-0.4.7}/pydantic_ai/agent.py

@@ -36,7 +36,7 @@ from ._tool_manager import ToolManager
 from .models.instrumented import InstrumentationSettings, InstrumentedModel, instrument_model
 from .output import OutputDataT, OutputSpec
 from .profiles import ModelProfile
-from .result import FinalResult, StreamedRunResult
+from .result import AgentStream, FinalResult, StreamedRunResult
 from .settings import ModelSettings, merge_model_settings
 from .tools import (
     AgentDepsT,
@@ -1127,29 +1127,15 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
             while True:
                 if self.is_model_request_node(node):
                     graph_ctx = agent_run.ctx
-                    async with node._stream(graph_ctx) as streamed_response:  # pyright: ignore[reportPrivateUsage]
-
-                        async def stream_to_final(
-                            s: models.StreamedResponse,
-                        ) -> FinalResult[models.StreamedResponse] | None:
-                            output_schema = graph_ctx.deps.output_schema
-                            async for maybe_part_event in streamed_response:
-                                if isinstance(maybe_part_event, _messages.PartStartEvent):
-                                    new_part = maybe_part_event.part
-                                    if isinstance(new_part, _messages.TextPart) and isinstance(
-                                        output_schema, _output.TextOutputSchema
-                                    ):
-                                        return FinalResult(s, None, None)
-                                    elif isinstance(new_part, _messages.ToolCallPart) and (
-                                        tool_def := graph_ctx.deps.tool_manager.get_tool_def(new_part.tool_name)
-                                    ):
-                                        if tool_def.kind == 'output':
-                                            return FinalResult(s, new_part.tool_name, new_part.tool_call_id)
-                                        elif tool_def.kind == 'deferred':
-                                            return FinalResult(s, None, None)
+                    async with node.stream(graph_ctx) as stream:
+
+                        async def stream_to_final(s: AgentStream) -> FinalResult[AgentStream] | None:
+                            async for event in stream:
+                                if isinstance(event, _messages.FinalResultEvent):
+                                    return FinalResult(s, event.tool_name, event.tool_call_id)
                             return None
 
-                        final_result = await stream_to_final(streamed_response)
+                        final_result = await stream_to_final(stream)
                         if final_result is not None:
                             if yielded:
                                 raise exceptions.AgentRunError('Agent run produced final results')  # pragma: no cover
@@ -1184,14 +1170,8 @@ class Agent(Generic[AgentDepsT, OutputDataT]):
                             yield StreamedRunResult(
                                 messages,
                                 graph_ctx.deps.new_message_index,
-                                graph_ctx.deps.usage_limits,
-                                streamed_response,
-                                graph_ctx.deps.output_schema,
-                                _agent_graph.build_run_context(graph_ctx),
-                                graph_ctx.deps.output_validators,
-                                final_result.tool_name,
+                                stream,
                                 on_complete,
-                                graph_ctx.deps.tool_manager,
                             )
                             break
                 next_node = await agent_run.next(node)