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

pydantic_ai/_run_context.py

@@ -16,15 +16,19 @@ if TYPE_CHECKING:
     from .models import Model
     from .result import RunUsage
 
+# TODO (v2): Change the default for all typevars like this from `None` to `object`
 AgentDepsT = TypeVar('AgentDepsT', default=None, contravariant=True)
 """Type variable for agent dependencies."""
 
+RunContextAgentDepsT = TypeVar('RunContextAgentDepsT', default=None, covariant=True)
+"""Type variable for the agent dependencies in `RunContext`."""
+
 
 @dataclasses.dataclass(repr=False, kw_only=True)
-class RunContext(Generic[AgentDepsT]):
+class RunContext(Generic[RunContextAgentDepsT]):
     """Information about the current call."""
 
-    deps: AgentDepsT
+    deps: RunContextAgentDepsT
     """Dependencies for the agent."""
     model: Model
     """The model used in this run."""

pydantic_ai/_utils.py

@@ -234,6 +234,15 @@ def sync_anext(iterator: Iterator[T]) -> T:
         raise StopAsyncIteration() from e
 
 
+def sync_async_iterator(async_iter: AsyncIterator[T]) -> Iterator[T]:
+    loop = get_event_loop()
+    while True:
+        try:
+            yield loop.run_until_complete(anext(async_iter))
+        except StopAsyncIteration:
+            break
+
+
 def now_utc() -> datetime:
     return datetime.now(tz=timezone.utc)
 
@@ -489,3 +498,12 @@ def get_union_args(tp: Any) -> tuple[Any, ...]:
         return tuple(_unwrap_annotated(arg) for arg in get_args(tp))
     else:
         return ()
+
+
+def get_event_loop():
+    try:
+        event_loop = asyncio.get_event_loop()
+    except RuntimeError:  # pragma: lax no cover
+        event_loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(event_loop)
+    return event_loop

pydantic_ai/agent/abstract.py

@@ -12,7 +12,6 @@ import anyio
 from typing_extensions import Self, TypeIs, TypeVar
 
 from pydantic_graph import End
-from pydantic_graph._utils import get_event_loop
 
 from .. import (
     _agent_graph,
@@ -335,7 +334,7 @@ class AbstractAgent(Generic[AgentDepsT, OutputDataT], ABC):
         if infer_name and self.name is None:
             self._infer_name(inspect.currentframe())
 
-        return get_event_loop().run_until_complete(
+        return _utils.get_event_loop().run_until_complete(
             self.run(
                 user_prompt,
                 output_type=output_type,
@@ -581,6 +580,133 @@ class AbstractAgent(Generic[AgentDepsT, OutputDataT], ABC):
         if not yielded:
             raise exceptions.AgentRunError('Agent run finished without producing a final result')  # pragma: no cover
 
+    @overload
+    def run_stream_sync(
+        self,
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
+        *,
+        output_type: None = None,
+        message_history: Sequence[_messages.ModelMessage] | None = None,
+        deferred_tool_results: DeferredToolResults | None = None,
+        model: models.Model | models.KnownModelName | str | None = None,
+        deps: AgentDepsT = None,
+        model_settings: ModelSettings | None = None,
+        usage_limits: _usage.UsageLimits | None = None,
+        usage: _usage.RunUsage | None = None,
+        infer_name: bool = True,
+        toolsets: Sequence[AbstractToolset[AgentDepsT]] | None = None,
+        builtin_tools: Sequence[AbstractBuiltinTool] | None = None,
+        event_stream_handler: EventStreamHandler[AgentDepsT] | None = None,
+    ) -> result.StreamedRunResultSync[AgentDepsT, OutputDataT]: ...
+
+    @overload
+    def run_stream_sync(
+        self,
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
+        *,
+        output_type: OutputSpec[RunOutputDataT],
+        message_history: Sequence[_messages.ModelMessage] | None = None,
+        deferred_tool_results: DeferredToolResults | None = None,
+        model: models.Model | models.KnownModelName | str | None = None,
+        deps: AgentDepsT = None,
+        model_settings: ModelSettings | None = None,
+        usage_limits: _usage.UsageLimits | None = None,
+        usage: _usage.RunUsage | None = None,
+        infer_name: bool = True,
+        toolsets: Sequence[AbstractToolset[AgentDepsT]] | None = None,
+        builtin_tools: Sequence[AbstractBuiltinTool] | None = None,
+        event_stream_handler: EventStreamHandler[AgentDepsT] | None = None,
+    ) -> result.StreamedRunResultSync[AgentDepsT, RunOutputDataT]: ...
+
+    def run_stream_sync(
+        self,
+        user_prompt: str | Sequence[_messages.UserContent] | None = None,
+        *,
+        output_type: OutputSpec[RunOutputDataT] | None = None,
+        message_history: Sequence[_messages.ModelMessage] | None = None,
+        deferred_tool_results: DeferredToolResults | None = None,
+        model: models.Model | models.KnownModelName | str | None = None,
+        deps: AgentDepsT = None,
+        model_settings: ModelSettings | None = None,
+        usage_limits: _usage.UsageLimits | None = None,
+        usage: _usage.RunUsage | None = None,
+        infer_name: bool = True,
+        toolsets: Sequence[AbstractToolset[AgentDepsT]] | None = None,
+        builtin_tools: Sequence[AbstractBuiltinTool] | None = None,
+        event_stream_handler: EventStreamHandler[AgentDepsT] | None = None,
+    ) -> result.StreamedRunResultSync[AgentDepsT, Any]:
+        """Run the agent with a user prompt in sync streaming mode.
+
+        This is a convenience method that wraps [`run_stream()`][pydantic_ai.agent.AbstractAgent.run_stream] with `loop.run_until_complete(...)`.
+        You therefore can't use this method inside async code or if there's an active event loop.
+
+        This method builds an internal agent graph (using system prompts, tools and output schemas) and then
+        runs the graph until the model produces output matching the `output_type`, for example text or structured data.
+        At this point, a streaming run result object is yielded from which you can stream the output as it comes in,
+        and -- once this output has completed streaming -- get the complete output, message history, and usage.
+
+        As this method will consider the first output matching the `output_type` to be the final output,
+        it will stop running the agent graph and will not execute any tool calls made by the model after this "final" output.
+        If you want to always run the agent graph to completion and stream events and output at the same time,
+        use [`agent.run()`][pydantic_ai.agent.AbstractAgent.run] with an `event_stream_handler` or [`agent.iter()`][pydantic_ai.agent.AbstractAgent.iter] instead.
+
+        Example:
+        ```python
+        from pydantic_ai import Agent
+
+        agent = Agent('openai:gpt-4o')
+
+        def main():
+            response = agent.run_stream_sync('What is the capital of the UK?')
+            print(response.get_output())
+            #> The capital of the UK is London.
+        ```
+
+        Args:
+            user_prompt: User input to start/continue the conversation.
+            output_type: Custom output type to use for this run, `output_type` may only be used if the agent has no
+                output validators since output validators would expect an argument that matches the agent's output type.
+            message_history: History of the conversation so far.
+            deferred_tool_results: Optional results for deferred tool calls in the message history.
+            model: Optional model to use for this run, required if `model` was not set when creating the agent.
+            deps: Optional dependencies to use for this run.
+            model_settings: Optional settings to use for this model's request.
+            usage_limits: Optional limits on model request count or token usage.
+            usage: Optional usage to start with, useful for resuming a conversation or agents used in tools.
+            infer_name: Whether to try to infer the agent name from the call frame if it's not set.
+            toolsets: Optional additional toolsets for this run.
+            builtin_tools: Optional additional builtin tools for this run.
+            event_stream_handler: Optional handler for events from the model's streaming response and the agent's execution of tools to use for this run.
+                It will receive all the events up until the final result is found, which you can then read or stream from inside the context manager.
+                Note that it does _not_ receive any events after the final result is found.
+
+        Returns:
+            The result of the run.
+        """
+        if infer_name and self.name is None:
+            self._infer_name(inspect.currentframe())
+
+        async def _consume_stream():
+            async with self.run_stream(
+                user_prompt,
+                output_type=output_type,
+                message_history=message_history,
+                deferred_tool_results=deferred_tool_results,
+                model=model,
+                deps=deps,
+                model_settings=model_settings,
+                usage_limits=usage_limits,
+                usage=usage,
+                infer_name=infer_name,
+                toolsets=toolsets,
+                builtin_tools=builtin_tools,
+                event_stream_handler=event_stream_handler,
+            ) as stream_result:
+                yield stream_result
+
+        async_result = _utils.get_event_loop().run_until_complete(anext(_consume_stream()))
+        return result.StreamedRunResultSync(async_result)
+
     @overload
     def run_stream_events(
         self,
@@ -1217,6 +1343,6 @@ class AbstractAgent(Generic[AgentDepsT, OutputDataT], ABC):
         agent.to_cli_sync(prog_name='assistant')
         ```
         """
-        return get_event_loop().run_until_complete(
+        return _utils.get_event_loop().run_until_complete(
             self.to_cli(deps=deps, prog_name=prog_name, message_history=message_history)
         )

pydantic_ai/durable_exec/temporal/_function_toolset.py

@@ -1,57 +1,22 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from dataclasses import dataclass
-from typing import Annotated, Any, Literal
+from typing import Any, Literal
 
-from pydantic import ConfigDict, Discriminator, with_config
 from temporalio import activity, workflow
 from temporalio.workflow import ActivityConfig
-from typing_extensions import assert_never
 
 from pydantic_ai import FunctionToolset, ToolsetTool
-from pydantic_ai.exceptions import ApprovalRequired, CallDeferred, ModelRetry, UserError
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.tools import AgentDepsT, RunContext
 from pydantic_ai.toolsets.function import FunctionToolsetTool
 
 from ._run_context import TemporalRunContext
-from ._toolset import TemporalWrapperToolset
-
-
-@dataclass
-@with_config(ConfigDict(arbitrary_types_allowed=True))
-class _CallToolParams:
-    name: str
-    tool_args: dict[str, Any]
-    serialized_run_context: Any
-
-
-@dataclass
-class _ApprovalRequired:
-    kind: Literal['approval_required'] = 'approval_required'
-
-
-@dataclass
-class _CallDeferred:
-    kind: Literal['call_deferred'] = 'call_deferred'
-
-
-@dataclass
-class _ModelRetry:
-    message: str
-    kind: Literal['model_retry'] = 'model_retry'
-
-
-@dataclass
-class _ToolReturn:
-    result: Any
-    kind: Literal['tool_return'] = 'tool_return'
-
-
-_CallToolResult = Annotated[
-    _ApprovalRequired | _CallDeferred | _ModelRetry | _ToolReturn,
-    Discriminator('kind'),
-]
+from ._toolset import (
+    CallToolParams,
+    CallToolResult,
+    TemporalWrapperToolset,
+)
 
 
 class TemporalFunctionToolset(TemporalWrapperToolset[AgentDepsT]):
@@ -70,7 +35,7 @@ class TemporalFunctionToolset(TemporalWrapperToolset[AgentDepsT]):
         self.tool_activity_config = tool_activity_config
         self.run_context_type = run_context_type
 
-        async def call_tool_activity(params: _CallToolParams, deps: AgentDepsT) -> _CallToolResult:
+        async def call_tool_activity(params: CallToolParams, deps: AgentDepsT) -> CallToolResult:
             name = params.name
             ctx = self.run_context_type.deserialize_run_context(params.serialized_run_context, deps=deps)
             try:
@@ -84,15 +49,7 @@ class TemporalFunctionToolset(TemporalWrapperToolset[AgentDepsT]):
             # The tool args will already have been validated into their proper types in the `ToolManager`,
             # but `execute_activity` would have turned them into simple Python types again, so we need to re-validate them.
             args_dict = tool.args_validator.validate_python(params.tool_args)
-            try:
-                result = await self.wrapped.call_tool(name, args_dict, ctx, tool)
-                return _ToolReturn(result=result)
-            except ApprovalRequired:
-                return _ApprovalRequired()
-            except CallDeferred:
-                return _CallDeferred()
-            except ModelRetry as e:
-                return _ModelRetry(message=e.message)
+            return await self._wrap_call_tool_result(self.wrapped.call_tool(name, args_dict, ctx, tool))
 
         # Set type hint explicitly so that Temporal can take care of serialization and deserialization
         call_tool_activity.__annotations__['deps'] = deps_type
@@ -123,25 +80,18 @@ class TemporalFunctionToolset(TemporalWrapperToolset[AgentDepsT]):
 
         tool_activity_config = self.activity_config | tool_activity_config
         serialized_run_context = self.run_context_type.serialize_run_context(ctx)
-        result = await workflow.execute_activity(  # pyright: ignore[reportUnknownMemberType]
-            activity=self.call_tool_activity,
-            args=[
-                _CallToolParams(
-                    name=name,
-                    tool_args=tool_args,
-                    serialized_run_context=serialized_run_context,
-                ),
-                ctx.deps,
-            ],
-            **tool_activity_config,
+        return self._unwrap_call_tool_result(
+            await workflow.execute_activity(  # pyright: ignore[reportUnknownMemberType]
+                activity=self.call_tool_activity,
+                args=[
+                    CallToolParams(
+                        name=name,
+                        tool_args=tool_args,
+                        serialized_run_context=serialized_run_context,
+                        tool_def=None,
+                    ),
+                    ctx.deps,
+                ],
+                **tool_activity_config,
+            )
         )
-        if isinstance(result, _ApprovalRequired):
-            raise ApprovalRequired()
-        elif isinstance(result, _CallDeferred):
-            raise CallDeferred()
-        elif isinstance(result, _ModelRetry):
-            raise ModelRetry(result.message)
-        elif isinstance(result, _ToolReturn):
-            return result.result
-        else:
-            assert_never(result)

pydantic_ai/durable_exec/temporal/_mcp_server.py

@@ -11,11 +11,15 @@ from typing_extensions import Self
 
 from pydantic_ai import ToolsetTool
 from pydantic_ai.exceptions import UserError
-from pydantic_ai.mcp import MCPServer, ToolResult
+from pydantic_ai.mcp import MCPServer
 from pydantic_ai.tools import AgentDepsT, RunContext, ToolDefinition
 
 from ._run_context import TemporalRunContext
-from ._toolset import TemporalWrapperToolset
+from ._toolset import (
+    CallToolParams,
+    CallToolResult,
+    TemporalWrapperToolset,
+)
 
 
 @dataclass
@@ -24,15 +28,6 @@ class _GetToolsParams:
     serialized_run_context: Any
 
 
-@dataclass
-@with_config(ConfigDict(arbitrary_types_allowed=True))
-class _CallToolParams:
-    name: str
-    tool_args: dict[str, Any]
-    serialized_run_context: Any
-    tool_def: ToolDefinition
-
-
 class TemporalMCPServer(TemporalWrapperToolset[AgentDepsT]):
     def __init__(
         self,
@@ -72,13 +67,16 @@ class TemporalMCPServer(TemporalWrapperToolset[AgentDepsT]):
             get_tools_activity
         )
 
-        async def call_tool_activity(params: _CallToolParams, deps: AgentDepsT) -> ToolResult:
+        async def call_tool_activity(params: CallToolParams, deps: AgentDepsT) -> CallToolResult:
             run_context = self.run_context_type.deserialize_run_context(params.serialized_run_context, deps=deps)
-            return await self.wrapped.call_tool(
-                params.name,
-                params.tool_args,
-                run_context,
-                self.tool_for_tool_def(params.tool_def),
+            assert isinstance(params.tool_def, ToolDefinition)
+            return await self._wrap_call_tool_result(
+                self.wrapped.call_tool(
+                    params.name,
+                    params.tool_args,
+                    run_context,
+                    self.tool_for_tool_def(params.tool_def),
+                )
             )
 
         # Set type hint explicitly so that Temporal can take care of serialization and deserialization
@@ -125,22 +123,24 @@ class TemporalMCPServer(TemporalWrapperToolset[AgentDepsT]):
         tool_args: dict[str, Any],
         ctx: RunContext[AgentDepsT],
         tool: ToolsetTool[AgentDepsT],
-    ) -> ToolResult:
+    ) -> CallToolResult:
         if not workflow.in_workflow():
             return await super().call_tool(name, tool_args, ctx, tool)
 
         tool_activity_config = self.activity_config | self.tool_activity_config.get(name, {})
         serialized_run_context = self.run_context_type.serialize_run_context(ctx)
-        return await workflow.execute_activity(  # pyright: ignore[reportUnknownMemberType]
-            activity=self.call_tool_activity,
-            args=[
-                _CallToolParams(
-                    name=name,
-                    tool_args=tool_args,
-                    serialized_run_context=serialized_run_context,
-                    tool_def=tool.tool_def,
-                ),
-                ctx.deps,
-            ],
-            **tool_activity_config,
+        return self._unwrap_call_tool_result(
+            await workflow.execute_activity(  # pyright: ignore[reportUnknownMemberType]
+                activity=self.call_tool_activity,
+                args=[
+                    CallToolParams(
+                        name=name,
+                        tool_args=tool_args,
+                        serialized_run_context=serialized_run_context,
+                        tool_def=tool.tool_def,
+                    ),
+                    ctx.deps,
+                ],
+                **tool_activity_config,
+            )
         )

pydantic_ai/durable_exec/temporal/_run_context.py

@@ -2,8 +2,13 @@ from __future__ import annotations
 
 from typing import Any
 
+from typing_extensions import TypeVar
+
 from pydantic_ai.exceptions import UserError
-from pydantic_ai.tools import AgentDepsT, RunContext
+from pydantic_ai.tools import RunContext
+
+AgentDepsT = TypeVar('AgentDepsT', default=None, covariant=True)
+"""Type variable for the agent dependencies in `RunContext`."""
 
 
 class TemporalRunContext(RunContext[AgentDepsT]):
@@ -47,6 +52,6 @@ class TemporalRunContext(RunContext[AgentDepsT]):
         }
 
     @classmethod
-    def deserialize_run_context(cls, ctx: dict[str, Any], deps: AgentDepsT) -> TemporalRunContext[AgentDepsT]:
+    def deserialize_run_context(cls, ctx: dict[str, Any], deps: Any) -> TemporalRunContext[Any]:
         """Deserialize the run context from a `dict[str, Any]`."""
         return cls(**ctx, deps=deps)

pydantic_ai/durable_exec/temporal/_toolset.py

@@ -1,17 +1,58 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import Callable
-from typing import Any, Literal
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Annotated, Any, Literal
 
+from pydantic import ConfigDict, Discriminator, with_config
 from temporalio.workflow import ActivityConfig
+from typing_extensions import assert_never
 
 from pydantic_ai import AbstractToolset, FunctionToolset, WrapperToolset
-from pydantic_ai.tools import AgentDepsT
+from pydantic_ai.exceptions import ApprovalRequired, CallDeferred, ModelRetry
+from pydantic_ai.tools import AgentDepsT, ToolDefinition
 
 from ._run_context import TemporalRunContext
 
 
+@dataclass
+@with_config(ConfigDict(arbitrary_types_allowed=True))
+class CallToolParams:
+    name: str
+    tool_args: dict[str, Any]
+    serialized_run_context: Any
+    tool_def: ToolDefinition | None
+
+
+@dataclass
+class _ApprovalRequired:
+    kind: Literal['approval_required'] = 'approval_required'
+
+
+@dataclass
+class _CallDeferred:
+    kind: Literal['call_deferred'] = 'call_deferred'
+
+
+@dataclass
+class _ModelRetry:
+    message: str
+    kind: Literal['model_retry'] = 'model_retry'
+
+
+@dataclass
+class _ToolReturn:
+    result: Any
+    kind: Literal['tool_return'] = 'tool_return'
+
+
+CallToolResult = Annotated[
+    _ApprovalRequired | _CallDeferred | _ModelRetry | _ToolReturn,
+    Discriminator('kind'),
+]
+
+
 class TemporalWrapperToolset(WrapperToolset[AgentDepsT], ABC):
     @property
     def id(self) -> str:
@@ -30,6 +71,29 @@ class TemporalWrapperToolset(WrapperToolset[AgentDepsT], ABC):
         # Temporalized toolsets cannot be swapped out after the fact.
         return self
 
+    async def _wrap_call_tool_result(self, coro: Awaitable[Any]) -> CallToolResult:
+        try:
+            result = await coro
+            return _ToolReturn(result=result)
+        except ApprovalRequired:
+            return _ApprovalRequired()
+        except CallDeferred:
+            return _CallDeferred()
+        except ModelRetry as e:
+            return _ModelRetry(message=e.message)
+
+    def _unwrap_call_tool_result(self, result: CallToolResult) -> Any:
+        if isinstance(result, _ToolReturn):
+            return result.result
+        elif isinstance(result, _ApprovalRequired):
+            raise ApprovalRequired()
+        elif isinstance(result, _CallDeferred):
+            raise CallDeferred()
+        elif isinstance(result, _ModelRetry):
+            raise ModelRetry(result.message)
+        else:
+            assert_never(result)
+
 
 def temporalize_toolset(
     toolset: AbstractToolset[AgentDepsT],

pydantic_ai/messages.py

@@ -34,6 +34,7 @@ DocumentMediaType: TypeAlias = Literal[
     'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
     'text/html',
     'text/markdown',
+    'application/msword',
     'application/vnd.ms-excel',
 ]
 VideoMediaType: TypeAlias = Literal[
@@ -434,8 +435,12 @@ class DocumentUrl(FileUrl):
             return 'application/pdf'
         elif self.url.endswith('.rtf'):
             return 'application/rtf'
+        elif self.url.endswith('.doc'):
+            return 'application/msword'
         elif self.url.endswith('.docx'):
             return 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+        elif self.url.endswith('.xls'):
+            return 'application/vnd.ms-excel'
         elif self.url.endswith('.xlsx'):
             return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
 
@@ -645,6 +650,7 @@ _document_format_lookup: dict[str, DocumentFormat] = {
     'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
     'text/html': 'html',
     'text/markdown': 'md',
+    'application/msword': 'doc',
     'application/vnd.ms-excel': 'xls',
 }
 _audio_format_lookup: dict[str, AudioFormat] = {

pydantic_ai/models/google.py

@@ -471,11 +471,9 @@ class GoogleModel(Model):
                 raise UnexpectedModelBehavior(
                     f'Content filter {raw_finish_reason.value!r} triggered', response.model_dump_json()
                 )
-            else:
-                raise UnexpectedModelBehavior(
-                    'Content field missing from Gemini response', response.model_dump_json()
-                )  # pragma: no cover
-        parts = candidate.content.parts or []
+            parts = []  # pragma: no cover
+        else:
+            parts = candidate.content.parts or []
 
         usage = _metadata_as_usage(response)
         return _process_response_from_parts(
@@ -649,17 +647,12 @@ class GeminiStreamedResponse(StreamedResponse):
             #     )
 
             if candidate.content is None or candidate.content.parts is None:
-                if self.finish_reason == 'stop':  # pragma: no cover
-                    # Normal completion - skip this chunk
-                    continue
-                elif self.finish_reason == 'content_filter' and raw_finish_reason:  # pragma: no cover
+                if self.finish_reason == 'content_filter' and raw_finish_reason:  # pragma: no cover
                     raise UnexpectedModelBehavior(
                         f'Content filter {raw_finish_reason.value!r} triggered', chunk.model_dump_json()
                     )
                 else:  # pragma: no cover
-                    raise UnexpectedModelBehavior(
-                        'Content field missing from streaming Gemini response', chunk.model_dump_json()
-                    )
+                    continue
 
             parts = candidate.content.parts
             if not parts:

pydantic_ai/models/openai.py

@@ -948,6 +948,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."""

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,6 +1,6 @@
 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 datetime import datetime
@@ -35,6 +35,7 @@ __all__ = (
     'OutputDataT_inv',
     'ToolOutput',
     'OutputValidatorFunc',
+    'StreamedRunResultSync',
 )
 
 
@@ -555,6 +556,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

@@ -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,
@@ -413,7 +417,7 @@ class Tool(Generic[AgentDepsT]):
             metadata=self.metadata,
         )
 
-    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`

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,

{pydantic_ai_slim-1.9.0.dist-info → pydantic_ai_slim-1.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.9.0
+Version: 1.10.0
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Project-URL: Homepage, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
 Project-URL: Source, https://github.com/pydantic/pydantic-ai/tree/main/pydantic_ai_slim
@@ -33,7 +33,7 @@ Requires-Dist: genai-prices>=0.0.35
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==1.9.0
+Requires-Dist: pydantic-graph==1.10.0
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -57,7 +57,7 @@ Requires-Dist: dbos>=1.14.0; extra == 'dbos'
 Provides-Extra: duckduckgo
 Requires-Dist: ddgs>=9.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==1.9.0; extra == 'evals'
+Requires-Dist: pydantic-evals==1.10.0; extra == 'evals'
 Provides-Extra: fastmcp
 Requires-Dist: fastmcp>=2.12.0; extra == 'fastmcp'
 Provides-Extra: google

{pydantic_ai_slim-1.9.0.dist-info → pydantic_ai_slim-1.10.0.dist-info}/RECORD

@@ -11,28 +11,28 @@ pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
 pydantic_ai/_otel_messages.py,sha256=SsMpbyI1fIISOck_wQcZJPIOei8lOmvwARkdPSCx8y8,1650
 pydantic_ai/_output.py,sha256=83Imvnwqwr-zveX_I95E24zt2Iqn-ofpd0HsbvOhS70,41274
 pydantic_ai/_parts_manager.py,sha256=05m8q2JZQk9Z8vNKOocxGDJQwYgbUGABGBRnXYJcsg8,19914
-pydantic_ai/_run_context.py,sha256=-ah9Ipf3mLTbvuYqmJSqBmBexaCcED7HGA1Llzs0dKU,2324
+pydantic_ai/_run_context.py,sha256=fGNn9-RSAa7sEG_iqDTC-v-wKDuPsD3TRDvdVLXaXY0,2577
 pydantic_ai/_system_prompt.py,sha256=WdDW_DTGHujcFFaK-J7J6mA4ZDJZ0IOKpyizJA-1Y5Q,1142
 pydantic_ai/_thinking_part.py,sha256=_0DajGyWPa50WUTPWN1UPfZw0xD8_hHcuSt0T3fgRr0,1295
 pydantic_ai/_tool_manager.py,sha256=se5Fikg4HaiTOnxJ4LFrezktZ2Zfv9a2OH0V9PtFE54,10464
-pydantic_ai/_utils.py,sha256=65H0E1GVGO2OmXpSoSbWDEPUxqLFVOzDXs3UkN2fyik,16580
+pydantic_ai/_utils.py,sha256=LCZCzZWAyS852bjqwYSL4fvkmvLJMTkCN09ruaICldY,17062
 pydantic_ai/ag_ui.py,sha256=kE7bk-yH7_GLkup0_EGqSiA5ZpxGqeeN0tb8tQ3QXe4,6974
 pydantic_ai/builtin_tools.py,sha256=EYSp9JVRethTLz-cL6HNrFRqnYaJMYBoDi-FTMcFf8c,8448
 pydantic_ai/direct.py,sha256=GnPFyHa2HkUEAKd2uVHMxZ90KM76lYGa9AQM84dEUXg,15513
 pydantic_ai/exceptions.py,sha256=gCmXLaic_PLD6_X6CNY0hcKRGr-bNUeKeV_ZR9Xyt7U,5141
 pydantic_ai/format_prompt.py,sha256=cLyWO8g77Y4JzqVSikqodXaAfTn6i-k206rNhYTiIsE,9710
 pydantic_ai/mcp.py,sha256=FHlD5pHH7Z6h76P6IjddQz0Pt6F0gAVlepmks4U1Cho,36190
-pydantic_ai/messages.py,sha256=th9AyBBrpyXZeHOVDJkWJZZkMGsL3vYJ7E5vDFYmItc,65957
+pydantic_ai/messages.py,sha256=cTuaiM0NjcvwMn_x2U7NVdnlWuye_v6qz-1qMLfmO58,66182
 pydantic_ai/output.py,sha256=q91oqvJ-FqV9GbUUil7WVWbii66SVsVZ54AEm_NWSEo,13002
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=nOTTGUJUHqSbOQzWikzPJa3sJmztDzEeV-5DVHd_q0o,26998
+pydantic_ai/result.py,sha256=57Bn1Jcxw_jEigGwPhVsVflokNJ2e-HEdjGddxp5cos,34660
 pydantic_ai/retries.py,sha256=QM4oDA9DG-Y2qP06fbCp8Dqq8ups40Rr4HYjAOlbNyM,14650
 pydantic_ai/run.py,sha256=5mOgh7UkLRtCjs1S85NM6OjcWvOy91VQhCkNMQQPhxs,17039
 pydantic_ai/settings.py,sha256=HlQxrw62YsXpIIhhddecYNTquDfhnpfaZU7y1p4CuVs,3935
-pydantic_ai/tools.py,sha256=dCecmJtRkF1ioqFYbfT00XGGqzGB4PPO9n6IrHCQtnc,20343
+pydantic_ai/tools.py,sha256=ITisUdqf_vuTUhwifriMxinE9b5etAzcODPh6CRbOmk,20503
 pydantic_ai/usage.py,sha256=lhReoVNwqt7mfmWk40A1ddnKk4-MVFJ0qCl_oFdGzxo,16251
 pydantic_ai/agent/__init__.py,sha256=rvVo5Fw78yu5IOVE6ub6tmJTIuDGsIY15D3_KTFXtx4,66525
-pydantic_ai/agent/abstract.py,sha256=zXj7fZHG7Nj6WwVajWuNI0xHqWEX2Zyte_lGmyDZd6o,56378
+pydantic_ai/agent/abstract.py,sha256=kv2ktxJcsB414VmnHeGnfH1UoGNcdo3mkC5QvG5KusY,63184
 pydantic_ai/agent/wrapper.py,sha256=ygwfMq24mGe3pGIK-TtPAy3cV7M8VZJW3ulEHvwNTck,10293
 pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/common_tools/duckduckgo.py,sha256=1ae_o3zqMGrC6KFqAmuqPwJqQgNBTisuvU2jX9KU8PI,2273
@@ -53,12 +53,12 @@ pydantic_ai/durable_exec/prefect/_toolset.py,sha256=dBgIMsQikjJgGr7_QAs3UG7nycBB
 pydantic_ai/durable_exec/prefect/_types.py,sha256=cTtXnKokPSCDMBQJrLlEho0mJLvDIGNCZF-q6infkkU,1270
 pydantic_ai/durable_exec/temporal/__init__.py,sha256=KTbzwj9C-Xu6i5kwgMraUsKfmjfz6yxBc4FCJNEbFjs,6187
 pydantic_ai/durable_exec/temporal/_agent.py,sha256=I03CafhyyZ4KVN9DtnypMvRcNXYsfapDv9LUwCGZPzM,44594
-pydantic_ai/durable_exec/temporal/_function_toolset.py,sha256=blGpeMWDfqgGcGrPEnQ2LE0FGv_jQ6legY4o2PWd3Fo,5582
+pydantic_ai/durable_exec/temporal/_function_toolset.py,sha256=lYE66Rv7ofh3_gzaMr1dkTU8sg-c7ntjVDFSUMEfq_w,4224
 pydantic_ai/durable_exec/temporal/_logfire.py,sha256=ASd7vb0cd61yESI0mgU2w9SCGxsOegz95HtQjKdlQkE,2472
-pydantic_ai/durable_exec/temporal/_mcp_server.py,sha256=vxfWeI7ZtYyXVgX621rPtG-WOZjlKWnqJhcvR9eBgIo,6014
+pydantic_ai/durable_exec/temporal/_mcp_server.py,sha256=wBN8R1wFQ9SUiZvskqE-LuSLqm2K2naElnVwHLkdkDY,6104
 pydantic_ai/durable_exec/temporal/_model.py,sha256=sOrDgMjQmCizSXe041dNpd5EDFAXgE6r0LGZghWkaeg,7546
-pydantic_ai/durable_exec/temporal/_run_context.py,sha256=Y0RTm-P6q8Oziu2gml6hpAjhbVBeJuktEme84qwXE8A,2449
-pydantic_ai/durable_exec/temporal/_toolset.py,sha256=IlPQrumm2MpZrb518ru15s0jIl8-cGwvE6ZNWIZrFuE,2879
+pydantic_ai/durable_exec/temporal/_run_context.py,sha256=fYWTAN4zswf7ugE7PDgD5qlauc5j9RKhIRxE7zupGkc,2592
+pydantic_ai/durable_exec/temporal/_toolset.py,sha256=wO7wnk9cp4RWo_kCZ4iZhe_rTe6YfG3poHH9gg134hI,4692
 pydantic_ai/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/ext/aci.py,sha256=YWYLXzTQJ6hS7qfgNycA8cRl69gogGgThqEU6II7eMA,2527
 pydantic_ai/ext/langchain.py,sha256=kmbbV3Cx2BiNYEJCZMHVYQquUQD-zG2L_bwDangy0Ww,2317
@@ -69,13 +69,13 @@ pydantic_ai/models/cohere.py,sha256=wQ3UYiFMs5Oyeyz5sd6NyG3b94iCeYBptnJC8bEYOUA,
 pydantic_ai/models/fallback.py,sha256=fjQz7qRuxEwC6aFYkglBv-2Z39-6kZ931vs6o7PIti8,5016
 pydantic_ai/models/function.py,sha256=7-ej1m4f7c1TbvgB8sF02qlFD7Kf-EX-k_xN4RkbIEw,15880
 pydantic_ai/models/gemini.py,sha256=ZMO1mUX6GXPo0N2OHoi_nS9Lb-Rqf0YFsILoRcssaG4,40410
-pydantic_ai/models/google.py,sha256=rcYzRMELj98dgnw8YrBHM1R3HLVjCTkWgDXMSNQrxOA,42141
+pydantic_ai/models/google.py,sha256=xaQkej5FYD4LRil4enwZHb5GmYmUqB_Wvj7-1oWdBnk,41700
 pydantic_ai/models/groq.py,sha256=HxJSquMfqOAS8gsQQQJyM8iReaPYp0VywK740thOYCU,29931
 pydantic_ai/models/huggingface.py,sha256=iADyoCKYrNyjixr55rEpXW02F-sah4rLmqrThEcNNDw,21464
 pydantic_ai/models/instrumented.py,sha256=J8eVTutr3UP1r_wd5sM5c0BIdzkRqT-EGgd2NiF0ssQ,22319
 pydantic_ai/models/mcp_sampling.py,sha256=qY4y4nXbRpNp2QbkfjzWLvF_8KLZGXypz4cc0lYRHXU,3553
 pydantic_ai/models/mistral.py,sha256=fi57hADjYxZw8wEpAcNI6mqY32VG9hHK9GGRQ-9vlZg,33905
-pydantic_ai/models/openai.py,sha256=JV47aeiHJ6GnFI6-gi9nuuWkGalqmqff2DtCaZ0Q6ZI,109208
+pydantic_ai/models/openai.py,sha256=OO4O7HlEdHXx_sAv0y7Lf8NeVJac248JsrlRiNjagRk,109295
 pydantic_ai/models/outlines.py,sha256=Un4KERT-jW97georXrE3iNuThFiYaYxZjGYHm2-PpD8,24270
 pydantic_ai/models/test.py,sha256=cRiLD1uXKERUkBTyrVj3L5NQHoDrDqL5UU9EG_odkTg,20707
 pydantic_ai/models/wrapper.py,sha256=nwh8Gea59blbr1JDKlUnkYICuI9TUubC4qP7iZRRW28,2440
@@ -94,7 +94,7 @@ pydantic_ai/profiles/moonshotai.py,sha256=e1RJnbEvazE6aJAqfmYLYGNtwNwg52XQDRDkcL
 pydantic_ai/profiles/openai.py,sha256=kve8KnvsGguioNi1gQtO7dqF8vvxR8W21fERehb3GPo,10053
 pydantic_ai/profiles/qwen.py,sha256=9SnTpMKndxNQMFyumyaOczJa5JGWbYQdpVKKW4OzKjk,749
 pydantic_ai/providers/__init__.py,sha256=Fwpu0w2-NpkKYQkDS2__kaWOR3dMW2KiE9v0K1EKwP4,4985
-pydantic_ai/providers/anthropic.py,sha256=vwNjO2JJ0Ux_3PXI9_XvzNZ24PKessm8z2ja1uzbBwM,3327
+pydantic_ai/providers/anthropic.py,sha256=gAxVAJYrhUhq3FEUaYy3rNxkB52EDISL4Zf5yzd5ups,3372
 pydantic_ai/providers/azure.py,sha256=PFRykTOfARMdANODnTLq__0ZynX7DlQ35GVf2Qs9VBY,5814
 pydantic_ai/providers/bedrock.py,sha256=bPbz-o3UhDzCRrg5xCrTfluLpDi2Yy9-JiCtC5mCIRk,8539
 pydantic_ai/providers/cerebras.py,sha256=3rIu092TYYuI5S4mlRjWxay5uomPbEDyHWIBMfrDBdA,3427
@@ -116,7 +116,7 @@ pydantic_ai/providers/moonshotai.py,sha256=iaQHZRYJb7hqeq-Di7Qb0LYJ8EEoE7a_wWtlt
 pydantic_ai/providers/nebius.py,sha256=nGpgbZnBZgNz4wHTi1vgvc-9tO2_zj5r3vRzEUbhPKM,3877
 pydantic_ai/providers/ollama.py,sha256=jg48g_3fYsvK8g-V3UOmR9HOsvnvb533BAB-rZZDxdA,4733
 pydantic_ai/providers/openai.py,sha256=cVVf99GgBnYBKYeWKBscvnkoRCu0ctWuKulG19lgWMo,3401
-pydantic_ai/providers/openrouter.py,sha256=o33Fk7kMyMhEM4NcSXU6IuG0cIUc45ySaenozrRypBI,4145
+pydantic_ai/providers/openrouter.py,sha256=H5EgV0DGDFw-pgfYquy9uy8C8dXwl9mmfor991jlXL8,4231
 pydantic_ai/providers/outlines.py,sha256=9Y3bnRKooqeUIVquexf75oGWpj8XOpJ71tBMWp0mTMQ,1251
 pydantic_ai/providers/ovhcloud.py,sha256=qvPB7-hgeClBMeNSKOiTrF-pSp6RczRaqWg5iAeUwss,3428
 pydantic_ai/providers/together.py,sha256=QtIR1BVJjoEYLvsUFpvPe81akx0iQvjYptl87XVpCpo,3441
@@ -135,21 +135,21 @@ pydantic_ai/toolsets/prepared.py,sha256=Zjfz6S8In6PBVxoKFN9sKPN984zO6t0awB7Lnq5K
 pydantic_ai/toolsets/renamed.py,sha256=JuLHpi-hYPiSPlaTpN8WiXLiGsywYK0axi2lW2Qs75k,1637
 pydantic_ai/toolsets/wrapper.py,sha256=KRzF1p8dncHbva8CE6Ud-IC5E_aygIHlwH5atXK55k4,1673
 pydantic_ai/ui/__init__.py,sha256=J19J5ZWFWcg_SbnHxqwR_tK4A53NlpaTFk898n7tQww,406
-pydantic_ai/ui/_adapter.py,sha256=OUqD-MqdWBg69lbV7WCMqFgHiy5wXeCGZCzUSxC1YYE,16597
-pydantic_ai/ui/_event_stream.py,sha256=MsS4PZ88RkYjhqq1zOotBLoDvI5D5DS8Ed2sIGQXBss,24984
+pydantic_ai/ui/_adapter.py,sha256=f73ChFKjAmg1Tios3-rvE70htpEGMKwx-bhWg7ZAMGI,16573
+pydantic_ai/ui/_event_stream.py,sha256=icW6OEkC4y2tBP8PljzUSPqmE2rSQurNQ3F1xotI_-I,25076
 pydantic_ai/ui/_messages_builder.py,sha256=jQaKD8B8GtkDXCRb1134ufnRpv84mLgGzdZeCsFwikY,1215
 pydantic_ai/ui/ag_ui/__init__.py,sha256=CWtc_Xu-upchzJYoEgJy_0o2NnfUItT-gFbOVWDO8UE,192
 pydantic_ai/ui/ag_ui/_adapter.py,sha256=UbXbT3Iq0h-_UAIR7dcDPnomfSE2uM05O58e3PLt51I,6988
-pydantic_ai/ui/ag_ui/_event_stream.py,sha256=_NEZvOaVNSTBTD2hSoVUeUZ13mzzqaQQC9SrM1Tg48o,9017
-pydantic_ai/ui/ag_ui/app.py,sha256=YY8nnSNox4ngV7GcOZCJU6uG5FeKoObEtpkahG0cOnQ,7504
+pydantic_ai/ui/ag_ui/_event_stream.py,sha256=eJEdi72207T1D4ftuG_EwHcvi2ZXXRk5bDbI0llzN4g,9348
+pydantic_ai/ui/ag_ui/app.py,sha256=0reVNuSOF3vNuONjbFys8pUl0wikgJ4lIMffwzc_8so,7927
 pydantic_ai/ui/vercel_ai/__init__.py,sha256=RG6J_W7Hr89XP-GST8uRPMbxveA2EB4BmoYSuUko79s,488
 pydantic_ai/ui/vercel_ai/_adapter.py,sha256=8QWDzGuIb2paM1nivS7w8x9-a7TPM8DJ6lggKkm-nrM,8723
 pydantic_ai/ui/vercel_ai/_event_stream.py,sha256=78DXqziNDtdtxrgiilYQqCNXh3Ct62jWcCwtVsy__3U,6806
 pydantic_ai/ui/vercel_ai/_utils.py,sha256=F-2qOC8Ckp-xSwuKp4Y0_8achi8RIGWHOSs1y7diD48,441
 pydantic_ai/ui/vercel_ai/request_types.py,sha256=VQpYZJdJ2aCm2NtZPhHzBws6Qkm5aYdNcGyq-Q8IQV8,7387
 pydantic_ai/ui/vercel_ai/response_types.py,sha256=nuU41wFXOCdnlyQRPZZmV9HEOvCZVjdczlg5A8qADTY,5258
-pydantic_ai_slim-1.9.0.dist-info/METADATA,sha256=5_K5Te_aJ_LXYtWBp9rU3x0flq9BCvNgETslhc1x10c,5659
-pydantic_ai_slim-1.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-1.9.0.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-1.9.0.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-1.9.0.dist-info/RECORD,,
+pydantic_ai_slim-1.10.0.dist-info/METADATA,sha256=CKxuvI-j6tveJ-GufhUjENDFqZFZGx4aaS1jkc1TC5M,5662
+pydantic_ai_slim-1.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-1.10.0.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-1.10.0.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-1.10.0.dist-info/RECORD,,