pydantic-ai-slim 1.9.0__py3-none-any.whl → 1.12.0__py3-none-any.whl

pydantic_ai/models/openai.py

@@ -477,7 +477,7 @@ class OpenAIChatModel(Model):
         else:
             tool_choice = 'auto'
 
-        openai_messages = await self._map_messages(messages)
+        openai_messages = await self._map_messages(messages, model_request_parameters)
 
         response_format: chat.completion_create_params.ResponseFormat | None = None
         if model_request_parameters.output_mode == 'native':
@@ -672,7 +672,9 @@ class OpenAIChatModel(Model):
                     f'`{tool.__class__.__name__}` is not supported by `OpenAIChatModel`. If it should be, please file an issue.'
                 )
 
-    async def _map_messages(self, messages: list[ModelMessage]) -> list[chat.ChatCompletionMessageParam]:
+    async def _map_messages(
+        self, messages: list[ModelMessage], model_request_parameters: ModelRequestParameters
+    ) -> list[chat.ChatCompletionMessageParam]:
         """Just maps a `pydantic_ai.Message` to a `openai.types.ChatCompletionMessageParam`."""
         openai_messages: list[chat.ChatCompletionMessageParam] = []
         for message in messages:
@@ -713,7 +715,7 @@ class OpenAIChatModel(Model):
                 openai_messages.append(message_param)
             else:
                 assert_never(message)
-        if instructions := self._get_instructions(messages):
+        if instructions := self._get_instructions(messages, model_request_parameters):
             openai_messages.insert(0, chat.ChatCompletionSystemMessageParam(content=instructions, role='system'))
         return openai_messages
 
@@ -948,6 +950,10 @@ class OpenAIResponsesModel(Model):
 
         super().__init__(settings=settings, profile=profile or provider.model_profile)
 
+    @property
+    def base_url(self) -> str:
+        return str(self.client.base_url)
+
     @property
     def model_name(self) -> OpenAIModelName:
         """The model name."""
@@ -1160,7 +1166,7 @@ class OpenAIResponsesModel(Model):
         if previous_response_id == 'auto':
             previous_response_id, messages = self._get_previous_response_id_and_new_messages(messages)
 
-        instructions, openai_messages = await self._map_messages(messages, model_settings)
+        instructions, openai_messages = await self._map_messages(messages, model_settings, model_request_parameters)
         reasoning = self._get_reasoning(model_settings)
 
         text: responses.ResponseTextConfigParam | None = None
@@ -1348,7 +1354,10 @@ class OpenAIResponsesModel(Model):
             return None, messages
 
     async def _map_messages(  # noqa: C901
-        self, messages: list[ModelMessage], model_settings: OpenAIResponsesModelSettings
+        self,
+        messages: list[ModelMessage],
+        model_settings: OpenAIResponsesModelSettings,
+        model_request_parameters: ModelRequestParameters,
     ) -> tuple[str | NotGiven, list[responses.ResponseInputItemParam]]:
         """Just maps a `pydantic_ai.Message` to a `openai.types.responses.ResponseInputParam`."""
         profile = OpenAIModelProfile.from_profile(self.profile)
@@ -1573,7 +1582,7 @@ class OpenAIResponsesModel(Model):
                         assert_never(item)
             else:
                 assert_never(message)
-        instructions = self._get_instructions(messages) or NOT_GIVEN
+        instructions = self._get_instructions(messages, model_request_parameters) or NOT_GIVEN
         return instructions, openai_messages
 
     def _map_json_schema(self, o: OutputObjectDefinition) -> responses.ResponseFormatTextJSONSchemaConfigParam:

pydantic_ai/models/outlines.py

@@ -8,14 +8,13 @@ from __future__ import annotations
 import io
 from collections.abc import AsyncIterable, AsyncIterator, Sequence
 from contextlib import asynccontextmanager
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any, Literal, cast
 
 from typing_extensions import assert_never
 
 from .. import UnexpectedModelBehavior, _utils
-from .._output import PromptedOutputSchema
 from .._run_context import RunContext
 from .._thinking_part import split_content_into_text_and_thinking
 from ..exceptions import UserError
@@ -247,6 +246,10 @@ class OutlinesModel(Model):
         model_settings: ModelSettings | None,
         model_request_parameters: ModelRequestParameters,
     ) -> ModelResponse:
+        model_settings, model_request_parameters = self.prepare_request(
+            model_settings,
+            model_request_parameters,
+        )
         """Make a request to the model."""
         prompt, output_type, inference_kwargs = await self._build_generation_arguments(
             messages, model_settings, model_request_parameters
@@ -267,6 +270,11 @@ class OutlinesModel(Model):
         model_request_parameters: ModelRequestParameters,
         run_context: RunContext[Any] | None = None,
     ) -> AsyncIterator[StreamedResponse]:
+        model_settings, model_request_parameters = self.prepare_request(
+            model_settings,
+            model_request_parameters,
+        )
+
         prompt, output_type, inference_kwargs = await self._build_generation_arguments(
             messages, model_settings, model_request_parameters
         )
@@ -298,15 +306,11 @@ class OutlinesModel(Model):
             raise UserError('Outlines does not support function tools and builtin tools yet.')
 
         if model_request_parameters.output_object:
-            instructions = PromptedOutputSchema.build_instructions(
-                self.profile.prompted_output_template, model_request_parameters.output_object
-            )
             output_type = JsonSchema(model_request_parameters.output_object.json_schema)
         else:
-            instructions = None
             output_type = None
 
-        prompt = await self._format_prompt(messages, instructions)
+        prompt = await self._format_prompt(messages, model_request_parameters)
         inference_kwargs = self.format_inference_kwargs(model_settings)
 
         return prompt, output_type, inference_kwargs
@@ -416,17 +420,14 @@ class OutlinesModel(Model):
         return filtered_settings
 
     async def _format_prompt(  # noqa: C901
-        self, messages: list[ModelMessage], output_format_instructions: str | None
+        self, messages: list[ModelMessage], model_request_parameters: ModelRequestParameters
     ) -> Chat:
         """Turn the model messages into an Outlines Chat instance."""
         chat = Chat()
 
-        if instructions := self._get_instructions(messages):
+        if instructions := self._get_instructions(messages, model_request_parameters):
             chat.add_system_message(instructions)
 
-        if output_format_instructions:
-            chat.add_system_message(output_format_instructions)
-
         for message in messages:
             if isinstance(message, ModelRequest):
                 for part in message.parts:
@@ -525,6 +526,14 @@ class OutlinesModel(Model):
             _provider_name='outlines',
         )
 
+    def customize_request_parameters(self, model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
+        """Customize the model request parameters for the model."""
+        if model_request_parameters.output_mode in ('auto', 'native'):
+            # This way the JSON schema will be included in the instructions.
+            return replace(model_request_parameters, output_mode='prompted')
+        else:
+            return model_request_parameters
+
 
 @dataclass
 class OutlinesStreamedResponse(StreamedResponse):

pydantic_ai/models/wrapper.py

@@ -44,7 +44,7 @@ class WrapperModel(Model):
             yield response_stream
 
     def customize_request_parameters(self, model_request_parameters: ModelRequestParameters) -> ModelRequestParameters:
-        return self.wrapped.customize_request_parameters(model_request_parameters)
+        return self.wrapped.customize_request_parameters(model_request_parameters)  # pragma: no cover
 
     def prepare_request(
         self,

pydantic_ai/output.py

@@ -37,10 +37,11 @@ T_co = TypeVar('T_co', covariant=True)
 OutputDataT = TypeVar('OutputDataT', default=str, covariant=True)
 """Covariant type variable for the output data type of a run."""
 
-OutputMode = Literal['text', 'tool', 'native', 'prompted', 'tool_or_text', 'image']
+OutputMode = Literal['text', 'tool', 'native', 'prompted', 'tool_or_text', 'image', 'auto']
 """All output modes.
 
-`tool_or_text` is deprecated and no longer in use.
+- `tool_or_text` is deprecated and no longer in use.
+- `auto` means the model will automatically choose a structured output mode based on the model's `ModelProfile.default_structured_output_mode`.
 """
 StructuredOutputMode = Literal['tool', 'native', 'prompted']
 """Output modes that can be used for structured output. Used by ModelProfile.default_structured_output_mode"""

pydantic_ai/profiles/openai.py

@@ -62,7 +62,10 @@ class OpenAIModelProfile(ModelProfile):
 
 def openai_model_profile(model_name: str) -> ModelProfile:
     """Get the model profile for an OpenAI model."""
-    is_reasoning_model = model_name.startswith('o') or model_name.startswith('gpt-5')
+    is_gpt_5 = model_name.startswith('gpt-5')
+    is_o_series = model_name.startswith('o')
+    is_reasoning_model = is_o_series or (is_gpt_5 and 'gpt-5-chat' not in model_name)
+
     # Check if the model supports web search (only specific search-preview models)
     supports_web_search = '-search-preview' in model_name
 
@@ -91,7 +94,7 @@ def openai_model_profile(model_name: str) -> ModelProfile:
         json_schema_transformer=OpenAIJsonSchemaTransformer,
         supports_json_schema_output=True,
         supports_json_object_output=True,
-        supports_image_output=is_reasoning_model or '4.1' in model_name or '4o' in model_name,
+        supports_image_output=is_gpt_5 or 'o3' in model_name or '4.1' in model_name or '4o' in model_name,
         openai_unsupported_model_settings=openai_unsupported_model_settings,
         openai_system_prompt_role=openai_system_prompt_role,
         openai_chat_supports_web_search=supports_web_search,

pydantic_ai/providers/anthropic.py

@@ -12,7 +12,7 @@ from pydantic_ai.profiles.anthropic import anthropic_model_profile
 from pydantic_ai.providers import Provider
 
 try:
-    from anthropic import AsyncAnthropic, AsyncAnthropicBedrock
+    from anthropic import AsyncAnthropic, AsyncAnthropicBedrock, AsyncAnthropicVertex
 except ImportError as _import_error:
     raise ImportError(
         'Please install the `anthropic` package to use the Anthropic provider, '
@@ -20,7 +20,7 @@ except ImportError as _import_error:
     ) from _import_error
 
 
-AsyncAnthropicClient: TypeAlias = AsyncAnthropic | AsyncAnthropicBedrock
+AsyncAnthropicClient: TypeAlias = AsyncAnthropic | AsyncAnthropicBedrock | AsyncAnthropicVertex
 
 
 class AnthropicProvider(Provider[AsyncAnthropicClient]):

pydantic_ai/providers/openrouter.py

@@ -81,6 +81,9 @@ class OpenRouterProvider(Provider[AsyncOpenAI]):
     @overload
     def __init__(self, *, api_key: str, http_client: httpx.AsyncClient) -> None: ...
 
+    @overload
+    def __init__(self, *, http_client: httpx.AsyncClient) -> None: ...
+
     @overload
     def __init__(self, *, openai_client: AsyncOpenAI | None = None) -> None: ...
 

pydantic_ai/result.py

@@ -1,8 +1,8 @@
 from __future__ import annotations as _annotations
 
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
+from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Iterator
 from copy import deepcopy
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from datetime import datetime
 from typing import TYPE_CHECKING, Generic, cast, overload
 
@@ -35,6 +35,7 @@ __all__ = (
     'OutputDataT_inv',
     'ToolOutput',
     'OutputValidatorFunc',
+    'StreamedRunResultSync',
 )
 
 
@@ -116,7 +117,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
         else:
             async for text in self._stream_response_text(delta=False, debounce_by=debounce_by):
                 for validator in self._output_validators:
-                    text = await validator.validate(text, self._run_ctx)  # pragma: no cover
+                    text = await validator.validate(text, replace(self._run_ctx, partial_output=True))
                 yield text
 
     # TODO (v2): Drop in favor of `response` property
@@ -194,7 +195,9 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
                 text, self._run_ctx, allow_partial=allow_partial, wrap_validation_errors=False
             )
             for validator in self._output_validators:
-                result_data = await validator.validate(result_data, self._run_ctx)
+                result_data = await validator.validate(
+                    result_data, replace(self._run_ctx, partial_output=allow_partial)
+                )
             return result_data
         else:
             raise exceptions.UnexpectedModelBehavior(  # pragma: no cover
@@ -555,6 +558,158 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
             await self._on_complete()
 
 
+@dataclass(init=False)
+class StreamedRunResultSync(Generic[AgentDepsT, OutputDataT]):
+    """Synchronous wrapper for [`StreamedRunResult`][pydantic_ai.result.StreamedRunResult] that only exposes sync methods."""
+
+    _streamed_run_result: StreamedRunResult[AgentDepsT, OutputDataT]
+
+    def __init__(self, streamed_run_result: StreamedRunResult[AgentDepsT, OutputDataT]) -> None:
+        self._streamed_run_result = streamed_run_result
+
+    def all_messages(self, *, output_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
+        """Return the history of messages.
+
+        Args:
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
+                not be modified.
+
+        Returns:
+            List of messages.
+        """
+        return self._streamed_run_result.all_messages(output_tool_return_content=output_tool_return_content)
+
+    def all_messages_json(self, *, output_tool_return_content: str | None = None) -> bytes:  # pragma: no cover
+        """Return all messages from [`all_messages`][pydantic_ai.result.StreamedRunResultSync.all_messages] as JSON bytes.
+
+        Args:
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
+                not be modified.
+
+        Returns:
+            JSON bytes representing the messages.
+        """
+        return self._streamed_run_result.all_messages_json(output_tool_return_content=output_tool_return_content)
+
+    def new_messages(self, *, output_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
+        """Return new messages associated with this run.
+
+        Messages from older runs are excluded.
+
+        Args:
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
+                not be modified.
+
+        Returns:
+            List of new messages.
+        """
+        return self._streamed_run_result.new_messages(output_tool_return_content=output_tool_return_content)
+
+    def new_messages_json(self, *, output_tool_return_content: str | None = None) -> bytes:  # pragma: no cover
+        """Return new messages from [`new_messages`][pydantic_ai.result.StreamedRunResultSync.new_messages] as JSON bytes.
+
+        Args:
+            output_tool_return_content: The return content of the tool call to set in the last message.
+                This provides a convenient way to modify the content of the output tool call if you want to continue
+                the conversation and want to set the response to the output tool call. If `None`, the last message will
+                not be modified.
+
+        Returns:
+            JSON bytes representing the new messages.
+        """
+        return self._streamed_run_result.new_messages_json(output_tool_return_content=output_tool_return_content)
+
+    def stream_output(self, *, debounce_by: float | None = 0.1) -> Iterator[OutputDataT]:
+        """Stream the output as an iterable.
+
+        The pydantic validator for structured data will be called in
+        [partial mode](https://docs.pydantic.dev/dev/concepts/experimental/#partial-validation)
+        on each iteration.
+
+        Args:
+            debounce_by: by how much (if at all) to debounce/group the output chunks by. `None` means no debouncing.
+                Debouncing is particularly important for long structured outputs to reduce the overhead of
+                performing validation as each token is received.
+
+        Returns:
+            An iterable of the response data.
+        """
+        return _utils.sync_async_iterator(self._streamed_run_result.stream_output(debounce_by=debounce_by))
+
+    def stream_text(self, *, delta: bool = False, debounce_by: float | None = 0.1) -> Iterator[str]:
+        """Stream the text result as an iterable.
+
+        !!! note
+            Result validators will NOT be called on the text result if `delta=True`.
+
+        Args:
+            delta: if `True`, yield each chunk of text as it is received, if `False` (default), yield the full text
+                up to the current point.
+            debounce_by: by how much (if at all) to debounce/group the response chunks by. `None` means no debouncing.
+                Debouncing is particularly important for long structured responses to reduce the overhead of
+                performing validation as each token is received.
+        """
+        return _utils.sync_async_iterator(self._streamed_run_result.stream_text(delta=delta, debounce_by=debounce_by))
+
+    def stream_responses(self, *, debounce_by: float | None = 0.1) -> Iterator[tuple[_messages.ModelResponse, bool]]:
+        """Stream the response as an iterable of Structured LLM Messages.
+
+        Args:
+            debounce_by: by how much (if at all) to debounce/group the response chunks by. `None` means no debouncing.
+                Debouncing is particularly important for long structured responses to reduce the overhead of
+                performing validation as each token is received.
+
+        Returns:
+            An iterable of the structured response message and whether that is the last message.
+        """
+        return _utils.sync_async_iterator(self._streamed_run_result.stream_responses(debounce_by=debounce_by))
+
+    def get_output(self) -> OutputDataT:
+        """Stream the whole response, validate and return it."""
+        return _utils.get_event_loop().run_until_complete(self._streamed_run_result.get_output())
+
+    @property
+    def response(self) -> _messages.ModelResponse:
+        """Return the current state of the response."""
+        return self._streamed_run_result.response
+
+    def usage(self) -> RunUsage:
+        """Return the usage of the whole run.
+
+        !!! note
+            This won't return the full usage until the stream is finished.
+        """
+        return self._streamed_run_result.usage()
+
+    def timestamp(self) -> datetime:
+        """Get the timestamp of the response."""
+        return self._streamed_run_result.timestamp()
+
+    def validate_response_output(self, message: _messages.ModelResponse, *, allow_partial: bool = False) -> OutputDataT:
+        """Validate a structured result message."""
+        return _utils.get_event_loop().run_until_complete(
+            self._streamed_run_result.validate_response_output(message, allow_partial=allow_partial)
+        )
+
+    @property
+    def is_complete(self) -> bool:
+        """Whether the stream has all been received.
+
+        This is set to `True` when one of
+        [`stream_output`][pydantic_ai.result.StreamedRunResultSync.stream_output],
+        [`stream_text`][pydantic_ai.result.StreamedRunResultSync.stream_text],
+        [`stream_responses`][pydantic_ai.result.StreamedRunResultSync.stream_responses] or
+        [`get_output`][pydantic_ai.result.StreamedRunResultSync.get_output] completes.
+        """
+        return self._streamed_run_result.is_complete
+
+
 @dataclass(repr=False)
 class FinalResult(Generic[OutputDataT]):
     """Marker class storing the final output of an agent run and associated metadata."""

pydantic_ai/tools.py

@@ -1,7 +1,7 @@
 from __future__ import annotations as _annotations
 
 from collections.abc import Awaitable, Callable, Sequence
-from dataclasses import KW_ONLY, dataclass, field, replace
+from dataclasses import KW_ONLY, dataclass, field
 from typing import Annotated, Any, Concatenate, Generic, Literal, TypeAlias, cast
 
 from pydantic import Discriminator, Tag
@@ -240,16 +240,20 @@ class GenerateToolJsonSchema(GenerateJsonSchema):
         return s
 
 
+ToolAgentDepsT = TypeVar('ToolAgentDepsT', default=object, contravariant=True)
+"""Type variable for agent dependencies for a tool."""
+
+
 @dataclass(init=False)
-class Tool(Generic[AgentDepsT]):
+class Tool(Generic[ToolAgentDepsT]):
     """A tool function for an agent."""
 
-    function: ToolFuncEither[AgentDepsT]
+    function: ToolFuncEither[ToolAgentDepsT]
     takes_ctx: bool
     max_retries: int | None
     name: str
     description: str | None
-    prepare: ToolPrepareFunc[AgentDepsT] | None
+    prepare: ToolPrepareFunc[ToolAgentDepsT] | None
     docstring_format: DocstringFormat
     require_parameter_descriptions: bool
     strict: bool | None
@@ -265,13 +269,13 @@ class Tool(Generic[AgentDepsT]):
 
     def __init__(
         self,
-        function: ToolFuncEither[AgentDepsT],
+        function: ToolFuncEither[ToolAgentDepsT],
         *,
         takes_ctx: bool | None = None,
         max_retries: int | None = None,
         name: str | None = None,
         description: str | None = None,
-        prepare: ToolPrepareFunc[AgentDepsT] | None = None,
+        prepare: ToolPrepareFunc[ToolAgentDepsT] | None = None,
         docstring_format: DocstringFormat = 'auto',
         require_parameter_descriptions: bool = False,
         schema_generator: type[GenerateJsonSchema] = GenerateToolJsonSchema,
@@ -411,9 +415,10 @@ class Tool(Generic[AgentDepsT]):
             strict=self.strict,
             sequential=self.sequential,
             metadata=self.metadata,
+            kind='unapproved' if self.requires_approval else 'function',
         )
 
-    async def prepare_tool_def(self, ctx: RunContext[AgentDepsT]) -> ToolDefinition | None:
+    async def prepare_tool_def(self, ctx: RunContext[ToolAgentDepsT]) -> ToolDefinition | None:
         """Get the tool definition.
 
         By default, this method creates a tool definition, then either returns it, or calls `self.prepare`
@@ -424,9 +429,6 @@ class Tool(Generic[AgentDepsT]):
         """
         base_tool_def = self.tool_def
 
-        if self.requires_approval and not ctx.tool_call_approved:
-            base_tool_def = replace(base_tool_def, kind='unapproved')
-
         if self.prepare is not None:
             return await self.prepare(ctx, base_tool_def)
         else:

pydantic_ai/ui/_adapter.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator, Sequence
-from dataclasses import KW_ONLY, Field, dataclass, replace
+from dataclasses import KW_ONLY, Field, dataclass
 from functools import cached_property
 from http import HTTPStatus
 from typing import (
@@ -238,7 +238,7 @@ class UIAdapter(ABC, Generic[RunInputT, MessageT, EventT, AgentDepsT, OutputData
             else:
                 state = raw_state
 
-            deps = replace(deps, state=state)
+            deps.state = state
         elif self.state:
             raise UserError(
                 f'State is provided but `deps` of type `{type(deps).__name__}` does not implement the `StateHandler` protocol: it needs to be a dataclass with a non-optional `state` field.'

pydantic_ai/ui/_event_stream.py

@@ -404,7 +404,7 @@ class UIEventStream(ABC, Generic[RunInputT, EventT, AgentDepsT, OutputDataT]):
 
         Override this to inject custom events at the start of the request.
         """
-        return
+        return  # pragma: lax no cover
         yield  # Make this an async generator
 
     async def after_request(self) -> AsyncIterator[EventT]:
@@ -412,7 +412,7 @@ class UIEventStream(ABC, Generic[RunInputT, EventT, AgentDepsT, OutputDataT]):
 
         Override this to inject custom events at the end of the request.
         """
-        return
+        return  # pragma: lax no cover
         yield  # Make this an async generator
 
     async def before_response(self) -> AsyncIterator[EventT]:
@@ -420,7 +420,7 @@ class UIEventStream(ABC, Generic[RunInputT, EventT, AgentDepsT, OutputDataT]):
 
         Override this to inject custom events at the start of the response.
         """
-        return
+        return  # pragma: no cover
         yield  # Make this an async generator
 
     async def after_response(self) -> AsyncIterator[EventT]:
@@ -428,7 +428,7 @@ class UIEventStream(ABC, Generic[RunInputT, EventT, AgentDepsT, OutputDataT]):
 
         Override this to inject custom events at the end of the response.
         """
-        return
+        return  # pragma: lax no cover
         yield  # Make this an async generator
 
     async def handle_text_start(self, part: TextPart, follows_text: bool = False) -> AsyncIterator[EventT]:

pydantic_ai/ui/ag_ui/_event_stream.py

@@ -92,6 +92,13 @@ class AGUIEventStream(UIEventStream[RunAgentInput, BaseEvent, AgentDepsT, Output
             run_id=self.run_input.run_id,
         )
 
+    async def before_response(self) -> AsyncIterator[BaseEvent]:
+        # Prevent parts from a subsequent response being tied to parts from an earlier response.
+        # See https://github.com/pydantic/pydantic-ai/issues/3316
+        self.new_message_id()
+        return
+        yield  # Make this an async generator
+
     async def after_stream(self) -> AsyncIterator[BaseEvent]:
         if not self._error:
             yield RunFinishedEvent(
@@ -167,9 +174,11 @@ class AGUIEventStream(UIEventStream[RunAgentInput, BaseEvent, AgentDepsT, Output
         self, part: ToolCallPart | BuiltinToolCallPart, tool_call_id: str | None = None
     ) -> AsyncIterator[BaseEvent]:
         tool_call_id = tool_call_id or part.tool_call_id
-        message_id = self.message_id or self.new_message_id()
+        parent_message_id = self.message_id
 
-        yield ToolCallStartEvent(tool_call_id=tool_call_id, tool_call_name=part.tool_name, parent_message_id=message_id)
+        yield ToolCallStartEvent(
+            tool_call_id=tool_call_id, tool_call_name=part.tool_name, parent_message_id=parent_message_id
+        )
         if part.args:
             yield ToolCallArgsEvent(tool_call_id=tool_call_id, delta=part.args_as_json_str())
 

pydantic_ai/ui/ag_ui/app.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable, Mapping, Sequence
+from dataclasses import replace
 from typing import Any, Generic
 
 from typing_extensions import Self
@@ -18,7 +19,7 @@ from pydantic_ai.tools import AgentDepsT
 from pydantic_ai.toolsets import AbstractToolset
 from pydantic_ai.usage import RunUsage, UsageLimits
 
-from .. import OnCompleteFunc
+from .. import OnCompleteFunc, StateHandler
 from ._adapter import AGUIAdapter
 
 try:
@@ -121,6 +122,12 @@ class AGUIApp(Generic[AgentDepsT, OutputDataT], Starlette):
 
         async def run_agent(request: Request) -> Response:
             """Endpoint to run the agent with the provided input data."""
+            # `dispatch_request` will store the frontend state from the request on `deps.state` (if it implements the `StateHandler` protocol),
+            # so we need to copy the deps to avoid different requests mutating the same deps object.
+            nonlocal deps
+            if isinstance(deps, StateHandler):  # pragma: no branch
+                deps = replace(deps)
+
             return await AGUIAdapter[AgentDepsT, OutputDataT].dispatch_request(
                 request,
                 agent=agent,