pydantic-ai-slim 1.0.14__py3-none-any.whl → 1.0.16__py3-none-any.whl

pydantic_ai/result.py

@@ -4,7 +4,7 @@ from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
 from copy import deepcopy
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Generic, cast, overload
+from typing import TYPE_CHECKING, Generic, cast, overload
 
 from pydantic import ValidationError
 from typing_extensions import TypeVar, deprecated
@@ -15,9 +15,7 @@ from ._output import (
     OutputSchema,
     OutputValidator,
     OutputValidatorFunc,
-    PlainTextOutputSchema,
     TextOutputSchema,
-    ToolOutputSchema,
 )
 from ._run_context import AgentDepsT, RunContext
 from ._tool_manager import ToolManager
@@ -27,9 +25,11 @@ from .output import (
     OutputDataT,
     ToolOutput,
 )
-from .run import AgentRunResult
 from .usage import RunUsage, UsageLimits
 
+if TYPE_CHECKING:
+    from .run import AgentRunResult
+
 __all__ = (
     'OutputDataT',
     'OutputDataT_inv',
@@ -67,12 +67,12 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
                 except ValidationError:
                     pass
         if self._raw_stream_response.final_result_event is not None:  # pragma: no branch
-            yield await self.validate_response_output(self._raw_stream_response.get())
+            yield await self.validate_response_output(self.response)
 
     async def stream_responses(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[_messages.ModelResponse]:
         """Asynchronously stream the (unvalidated) model responses for the agent."""
         # if the message currently has any parts with content, yield before streaming
-        msg = self._raw_stream_response.get()
+        msg = self.response
         for part in msg.parts:
             if part.has_content():
                 yield msg
@@ -80,7 +80,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
 
         async with _utils.group_by_temporal(self, debounce_by) as group_iter:
             async for _items in group_iter:
-                yield self._raw_stream_response.get()  # current state of the response
+                yield self.response  # current state of the response
 
     async def stream_text(self, *, delta: bool = False, debounce_by: float | None = 0.1) -> AsyncIterator[str]:
         """Stream the text result as an async iterable.
@@ -95,7 +95,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
                 Debouncing is particularly important for long structured responses to reduce the overhead of
                 performing validation as each token is received.
         """
-        if not isinstance(self._output_schema, PlainTextOutputSchema):
+        if not isinstance(self._output_schema, TextOutputSchema):
             raise exceptions.UserError('stream_text() can only be used with text responses')
 
         if delta:
@@ -107,10 +107,17 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
                     text = await validator.validate(text, self._run_ctx)  # pragma: no cover
                 yield text
 
+    # TODO (v2): Drop in favor of `response` property
     def get(self) -> _messages.ModelResponse:
         """Get the current state of the response."""
         return self._raw_stream_response.get()
 
+    @property
+    def response(self) -> _messages.ModelResponse:
+        """Get the current state of the response."""
+        return self.get()
+
+    # TODO (v2): Make this a property
     def usage(self) -> RunUsage:
         """Return the usage of the whole run.
 
@@ -119,6 +126,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
         """
         return self._initial_run_ctx_usage + self._raw_stream_response.usage()
 
+    # TODO (v2): Make this a property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""
         return self._raw_stream_response.timestamp
@@ -128,7 +136,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
         async for _ in self:
             pass
 
-        return await self.validate_response_output(self._raw_stream_response.get())
+        return await self.validate_response_output(self.response)
 
     async def validate_response_output(
         self, message: _messages.ModelResponse, *, allow_partial: bool = False
@@ -140,13 +148,9 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
 
         output_tool_name = final_result_event.tool_name
 
-        if isinstance(self._output_schema, ToolOutputSchema) and output_tool_name is not None:
+        if self._output_schema.toolset and output_tool_name is not None:
             tool_call = next(
-                (
-                    part
-                    for part in message.parts
-                    if isinstance(part, _messages.ToolCallPart) and part.tool_name == output_tool_name
-                ),
+                (part for part in message.tool_calls if part.tool_name == output_tool_name),
                 None,
             )
             if tool_call is None:
@@ -156,13 +160,15 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
             return await self._tool_manager.handle_call(
                 tool_call, allow_partial=allow_partial, wrap_validation_errors=False
             )
-        elif deferred_tool_requests := _get_deferred_tool_requests(message.parts, self._tool_manager):
+        elif deferred_tool_requests := _get_deferred_tool_requests(message.tool_calls, self._tool_manager):
             if not self._output_schema.allows_deferred_tools:
                 raise exceptions.UserError(
                     'A deferred tool call was present, but `DeferredToolRequests` is not among output types. To resolve this, add `DeferredToolRequests` to the list of output types for this agent.'
                 )
             return cast(OutputDataT, deferred_tool_requests)
-        elif isinstance(self._output_schema, TextOutputSchema):
+        elif self._output_schema.allows_image and message.images:
+            return cast(OutputDataT, message.images[0])
+        elif text_processor := self._output_schema.text_processor:
             text = ''
             for part in message.parts:
                 if isinstance(part, _messages.TextPart):
@@ -172,7 +178,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
                     # not part of the final result output, so we reset the accumulated text
                     text = ''
 
-            result_data = await self._output_schema.process(
+            result_data = await text_processor.process(
                 text, self._run_ctx, allow_partial=allow_partial, wrap_validation_errors=False
             )
             for validator in self._output_validators:
@@ -195,7 +201,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
             # yields tuples of (text_content, part_index)
             # we don't currently make use of the part_index, but in principle this may be useful
             # so we retain it here for now to make possible future refactors simpler
-            msg = self._raw_stream_response.get()
+            msg = self.response
             for i, part in enumerate(msg.parts):
                 if isinstance(part, _messages.TextPart) and part.content:
                     yield part.content, i
@@ -398,7 +404,7 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
         elif self._stream_response is not None:
             async for output in self._stream_response.stream_output(debounce_by=debounce_by):
                 yield output
-            await self._marked_completed(self._stream_response.get())
+            await self._marked_completed(self.response)
         else:
             raise ValueError('No stream response or run result provided')  # pragma: no cover
 
@@ -426,7 +432,7 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
         elif self._stream_response is not None:
             async for text in self._stream_response.stream_text(delta=delta, debounce_by=debounce_by):
                 yield text
-            await self._marked_completed(self._stream_response.get())
+            await self._marked_completed(self.response)
         else:
             raise ValueError('No stream response or run result provided')  # pragma: no cover
 
@@ -451,15 +457,14 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
             An async iterable of the structured response message and whether that is the last message.
         """
         if self._run_result is not None:
-            model_response = cast(_messages.ModelResponse, self.all_messages()[-1])
-            yield model_response, True
+            yield self.response, True
             await self._marked_completed()
         elif self._stream_response is not None:
             # if the message currently has any parts with content, yield before streaming
             async for msg in self._stream_response.stream_responses(debounce_by=debounce_by):
                 yield msg, False
 
-            msg = self._stream_response.get()
+            msg = self.response
             yield msg, True
 
             await self._marked_completed(msg)
@@ -474,11 +479,22 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
             return output
         elif self._stream_response is not None:
             output = await self._stream_response.get_output()
-            await self._marked_completed(self._stream_response.get())
+            await self._marked_completed(self.response)
             return output
         else:
             raise ValueError('No stream response or run result provided')  # pragma: no cover
 
+    @property
+    def response(self) -> _messages.ModelResponse:
+        """Return the current state of the response."""
+        if self._run_result is not None:
+            return self._run_result.response
+        elif self._stream_response is not None:
+            return self._stream_response.get()
+        else:
+            raise ValueError('No stream response or run result provided')  # pragma: no cover
+
+    # TODO (v2): Make this a property
     def usage(self) -> RunUsage:
         """Return the usage of the whole run.
 
@@ -492,6 +508,7 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
         else:
             raise ValueError('No stream response or run result provided')  # pragma: no cover
 
+    # TODO (v2): Make this a property
     def timestamp(self) -> datetime:
         """Get the timestamp of the response."""
         if self._run_result is not None:
@@ -560,20 +577,19 @@ def _get_usage_checking_stream_response(
 
 
 def _get_deferred_tool_requests(
-    parts: Iterable[_messages.ModelResponsePart], tool_manager: ToolManager[AgentDepsT]
+    tool_calls: Iterable[_messages.ToolCallPart], tool_manager: ToolManager[AgentDepsT]
 ) -> DeferredToolRequests | None:
-    """Get the deferred tool requests from the model response parts."""
+    """Get the deferred tool requests from the model response tool calls."""
     approvals: list[_messages.ToolCallPart] = []
     calls: list[_messages.ToolCallPart] = []
 
-    for part in parts:
-        if isinstance(part, _messages.ToolCallPart):
-            tool_def = tool_manager.get_tool_def(part.tool_name)
-            if tool_def is not None:  # pragma: no branch
-                if tool_def.kind == 'unapproved':
-                    approvals.append(part)
-                elif tool_def.kind == 'external':
-                    calls.append(part)
+    for tool_call in tool_calls:
+        tool_def = tool_manager.get_tool_def(tool_call.tool_name)
+        if tool_def is not None:  # pragma: no branch
+            if tool_def.kind == 'unapproved':
+                approvals.append(tool_call)
+            elif tool_def.kind == 'external':
+                calls.append(tool_call)
 
     if not calls and not approvals:
         return None

pydantic_ai/run.py

@@ -10,6 +10,7 @@ from pydantic_graph import End, GraphRun, GraphRunContext
 
 from . import (
     _agent_graph,
+    _utils,
     exceptions,
     messages as _messages,
     usage as _usage,
@@ -227,6 +228,7 @@ class AgentRun(Generic[AgentDepsT, OutputDataT]):
         assert isinstance(next_node, End), f'Unexpected node type: {type(next_node)}'
         return next_node
 
+    # TODO (v2): Make this a property
     def usage(self) -> _usage.RunUsage:
         """Get usage statistics for the run so far, including token usage, model requests, and so on."""
         return self._graph_run.state.usage
@@ -244,10 +246,12 @@ class AgentRunResult(Generic[OutputDataT]):
     output: OutputDataT
     """The output data from the agent run."""
 
-    _output_tool_name: str | None = dataclasses.field(repr=False)
-    _state: _agent_graph.GraphAgentState = dataclasses.field(repr=False)
-    _new_message_index: int = dataclasses.field(repr=False)
-    _traceparent_value: str | None = dataclasses.field(repr=False)
+    _output_tool_name: str | None = dataclasses.field(repr=False, compare=False, default=None)
+    _state: _agent_graph.GraphAgentState = dataclasses.field(
+        repr=False, compare=False, default_factory=_agent_graph.GraphAgentState
+    )
+    _new_message_index: int = dataclasses.field(repr=False, compare=False, default=0)
+    _traceparent_value: str | None = dataclasses.field(repr=False, compare=False, default=None)
 
     @overload
     def _traceparent(self, *, required: Literal[False]) -> str | None: ...
@@ -344,12 +348,36 @@ class AgentRunResult(Generic[OutputDataT]):
             self.new_messages(output_tool_return_content=output_tool_return_content)
         )
 
+    @property
+    def response(self) -> _messages.ModelResponse:
+        """Return the last response from the message history."""
+        # The response may not be the very last item if it contained an output tool call. See `CallToolsNode._handle_final_result`.
+        for message in reversed(self.all_messages()):
+            if isinstance(message, _messages.ModelResponse):
+                return message
+        raise ValueError('No response found in the message history')  # pragma: no cover
+
+    # TODO (v2): Make this a property
     def usage(self) -> _usage.RunUsage:
         """Return the usage of the whole run."""
         return self._state.usage
 
+    # TODO (v2): Make this a property
     def timestamp(self) -> datetime:
         """Return the timestamp of last response."""
-        model_response = self.all_messages()[-1]
-        assert isinstance(model_response, _messages.ModelResponse)
-        return model_response.timestamp
+        return self.response.timestamp
+
+
+@dataclasses.dataclass(repr=False)
+class AgentRunResultEvent(Generic[OutputDataT]):
+    """An event indicating the agent run ended and containing the final result of the agent run."""
+
+    result: AgentRunResult[OutputDataT]
+    """The result of the run."""
+
+    _: dataclasses.KW_ONLY
+
+    event_kind: Literal['agent_run_result'] = 'agent_run_result'
+    """Event type identifier, used as a discriminator."""
+
+    __repr__ = _utils.dataclasses_no_defaults_repr

pydantic_ai/usage.py

@@ -3,8 +3,9 @@ from __future__ import annotations as _annotations
 import dataclasses
 from copy import copy
 from dataclasses import dataclass, fields
-from typing import Annotated
+from typing import Annotated, Any
 
+from genai_prices.data_snapshot import get_snapshot
 from pydantic import AliasChoices, BeforeValidator, Field
 from typing_extensions import deprecated, overload
 
@@ -120,6 +121,39 @@ class RequestUsage(UsageBase):
         new_usage.incr(other)
         return new_usage
 
+    @classmethod
+    def extract(
+        cls,
+        data: Any,
+        *,
+        provider: str,
+        provider_url: str,
+        provider_fallback: str,
+        api_flavor: str | None = None,
+        details: dict[str, Any] | None = None,
+    ) -> RequestUsage:
+        """Extract usage information from the response data using genai-prices.
+
+        Args:
+            data: The response data from the model API.
+            provider: The actual provider ID
+            provider_url: The provider base_url
+            provider_fallback: The fallback provider ID to use if the actual provider is not found in genai-prices.
+                For example, an OpenAI model should set this to "openai" in case it has an obscure provider ID.
+            api_flavor: The API flavor to use when extracting usage information,
+                e.g. 'chat' or 'responses' for OpenAI.
+            details: Becomes the `details` field on the returned `RequestUsage` for convenience.
+        """
+        details = details or {}
+        for provider_id, provider_api_url in [(None, provider_url), (provider, None), (provider_fallback, None)]:
+            try:
+                provider_obj = get_snapshot().find_provider(None, provider_id, provider_api_url)
+                _model_ref, extracted_usage = provider_obj.extract_usage(data, api_flavor=api_flavor)
+                return cls(**{k: v for k, v in extracted_usage.__dict__.items() if v is not None}, details=details)
+            except Exception:
+                pass
+        return cls(details=details)
+
 
 @dataclass(repr=False, kw_only=True)
 class RunUsage(UsageBase):
@@ -340,12 +374,13 @@ class UsageLimits:
         if self.total_tokens_limit is not None and total_tokens > self.total_tokens_limit:
             raise UsageLimitExceeded(f'Exceeded the total_tokens_limit of {self.total_tokens_limit} ({total_tokens=})')
 
-    def check_before_tool_call(self, usage: RunUsage) -> None:
-        """Raises a `UsageLimitExceeded` exception if the next tool call would exceed the tool call limit."""
+    def check_before_tool_call(self, projected_usage: RunUsage) -> None:
+        """Raises a `UsageLimitExceeded` exception if the next tool call(s) would exceed the tool call limit."""
         tool_calls_limit = self.tool_calls_limit
-        if tool_calls_limit is not None and usage.tool_calls >= tool_calls_limit:
+        tool_calls = projected_usage.tool_calls
+        if tool_calls_limit is not None and tool_calls > tool_calls_limit:
             raise UsageLimitExceeded(
-                f'The next tool call would exceed the tool_calls_limit of {tool_calls_limit} (tool_calls={usage.tool_calls})'
+                f'The next tool call(s) would exceed the tool_calls_limit of {tool_calls_limit} ({tool_calls=}).'
             )
 
     __repr__ = _utils.dataclasses_no_defaults_repr

{pydantic_ai_slim-1.0.14.dist-info → pydantic_ai_slim-1.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.14
+Version: 1.0.16
 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
@@ -29,11 +29,11 @@ Classifier: Topic :: Internet
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: exceptiongroup; python_version < '3.11'
-Requires-Dist: genai-prices>=0.0.28
+Requires-Dist: genai-prices>=0.0.30
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==1.0.14
+Requires-Dist: pydantic-graph==1.0.16
 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.0.14; extra == 'evals'
+Requires-Dist: pydantic-evals==1.0.16; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-1.0.14.dist-info → pydantic_ai_slim-1.0.16.dist-info}/RECORD

@@ -1,88 +1,88 @@
-pydantic_ai/__init__.py,sha256=ncKgkl6nkEbiI8yLeAQx4yFPEcIJ1xgyddxVX-f-wiE,4838
+pydantic_ai/__init__.py,sha256=IgLTfgpGwbYsT_d_2wSucOfFyIMl1GH6v-yfkNs_zrM,5149
 pydantic_ai/__main__.py,sha256=Q_zJU15DUA01YtlJ2mnaLCoId2YmgmreVEERGuQT-Y0,132
 pydantic_ai/_a2a.py,sha256=3_pl7JW2yHdu31qLgCrdcTZTqXaJNjAwUV6zavah_w8,12159
-pydantic_ai/_agent_graph.py,sha256=ejbRDXwDhKWiksa58R6jAjRha_QzM6GuefaZvJD3TA4,53258
-pydantic_ai/_cli.py,sha256=n1MX7p-UKH6ZWPNwiGPZTVcXYhXG8OiJIuNMeYX5k2M,14053
+pydantic_ai/_agent_graph.py,sha256=D_Oo_LbPqGwkVAaEAcFFERwrg9pVkxeZ45vtTMhES8M,54230
+pydantic_ai/_cli.py,sha256=iZTCFrpJy3aUZ49nJQ5nw2INFw6gPVQd8EhB0rahVcI,14005
 pydantic_ai/_function_schema.py,sha256=UnDGh7Wh5z70pEaRujXF_hKsSibQdN2ywI6lZGz3LUo,11663
 pydantic_ai/_griffe.py,sha256=BphvTL00FHxsSY56GM-bNyCOdwrpL0T3LbDQITWUK_Q,5280
 pydantic_ai/_instrumentation.py,sha256=3XJxRUT0m2K6NfpAb-JKro4Rpw-8weqQ_ydtufeKVrU,2964
 pydantic_ai/_json_schema.py,sha256=Br48srbwCTVIie98a9UEMGcCcTIa3E4zVvCbkxqQRso,7268
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
 pydantic_ai/_otel_messages.py,sha256=SsMpbyI1fIISOck_wQcZJPIOei8lOmvwARkdPSCx8y8,1650
-pydantic_ai/_output.py,sha256=OWoNkxZ1ml25MC36C_EZRPFe0V8VqIBf23bwTaMA4p0,38731
-pydantic_ai/_parts_manager.py,sha256=QRfZTk21tCO6jEu8hF0qZLEsyUzvu0C6-qkiFhnbqxI,21443
+pydantic_ai/_output.py,sha256=gHS1qwM701cH5FGGRUrMxgWlJhY1vNgdM6ylnHRa-Ew,40784
+pydantic_ai/_parts_manager.py,sha256=kXMhigRJAwUcputw7i54pQkc85NuNVS4Zy36lFvnRvk,19800
 pydantic_ai/_run_context.py,sha256=-ah9Ipf3mLTbvuYqmJSqBmBexaCcED7HGA1Llzs0dKU,2324
 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=iLFza1JiIPqLNo2B_DcNIhOY1r35vSzI6DWgkPGfLtY,10833
+pydantic_ai/_tool_manager.py,sha256=se5Fikg4HaiTOnxJ4LFrezktZ2Zfv9a2OH0V9PtFE54,10464
 pydantic_ai/_utils.py,sha256=TBzJ03szJPrmDdqRqKTyhRboTsyP6wppnCCprpZFBMw,16620
 pydantic_ai/ag_ui.py,sha256=X3b4P_IraypCE3r-L2ETIo8G951A1MDdP4P5TQ8Fces,32067
-pydantic_ai/builtin_tools.py,sha256=DFwiFEtCXhw8MWgnraps9x56X6olyDHt1UiCwIapcKk,3863
-pydantic_ai/direct.py,sha256=p4CvEmWjIsXlUdrnzhkLZGTpgwWv1QfMJXjAHwdKJA0,14825
+pydantic_ai/builtin_tools.py,sha256=xtRIlEGUJ9UQzxqsKIXs-KD0awHCxBOvXlZ7CLq5oDM,5666
+pydantic_ai/direct.py,sha256=i5yZ9Tx8IiwXg6Nz9CW4-fyXzxnjP59fsklExCh5sjA,15111
 pydantic_ai/exceptions.py,sha256=zsXZMKf2BJuVsfuHl1fWTkogLU37bd4yq7D6BKHAzVs,4968
-pydantic_ai/format_prompt.py,sha256=qQ9zv6PJR9D4FTII6gD3_bSOHYymhRYVIxhPMscxeLI,9528
-pydantic_ai/mcp.py,sha256=bDH_2F36I3dVaBj76DKk53_HMvh87GSslv4k_0k4-Ig,36327
-pydantic_ai/messages.py,sha256=CPainRnRN80ew8IMehfHjvioGBQut1Cr4MthzQ4tihA,57773
-pydantic_ai/output.py,sha256=Hh3P8IJHhd0DcVy8UBaUB-aEzL3Hd8V1-KwLICUxmGs,12940
+pydantic_ai/format_prompt.py,sha256=cLyWO8g77Y4JzqVSikqodXaAfTn6i-k206rNhYTiIsE,9710
+pydantic_ai/mcp.py,sha256=7Ouwepk-p2rOq_Rkv-MSZYyEGJ6FfrJvR7ySghuSLwc,36693
+pydantic_ai/messages.py,sha256=CuquO_BpWsMQP73GlhcGniMzBa3np926hjUxewommp4,64465
+pydantic_ai/output.py,sha256=q91oqvJ-FqV9GbUUil7WVWbii66SVsVZ54AEm_NWSEo,13002
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=eoQ6VJPvXVNReRhErOytK3-2tiy9FV6LIwywyh7DSzo,26247
+pydantic_ai/result.py,sha256=sVabgrAJXmj96I7NM-w0RBz1rH5x_zZql1V6epei4JU,26700
 pydantic_ai/retries.py,sha256=QM4oDA9DG-Y2qP06fbCp8Dqq8ups40Rr4HYjAOlbNyM,14650
-pydantic_ai/run.py,sha256=wHlWl4CXIHLcgo2R8PlsU3Pjn0vuMLFfP8D6Fbany-Y,15097
+pydantic_ai/run.py,sha256=dV3zIztC-lfOCKecXg_Mcx2CyOfUbxQC0JbZuPvQhTI,16227
 pydantic_ai/settings.py,sha256=0mr6KudxKKjTG8e3nsv_8vDLxNhu_1-WvefCOzCGSYM,3565
 pydantic_ai/tools.py,sha256=dCecmJtRkF1ioqFYbfT00XGGqzGB4PPO9n6IrHCQtnc,20343
-pydantic_ai/usage.py,sha256=KuDwSvWCzV5O9fPeEy5lUg2OhPq2eZFEFk2vYCA_DwA,14060
-pydantic_ai/agent/__init__.py,sha256=gmLwyTsyvL89sYvZR83Ba62A8lKLqTfRBk_KYbYYNQo,64116
-pydantic_ai/agent/abstract.py,sha256=dOpnqbQTtvc9IozGhFC_juj9vpw5071U_vIklwms_lI,44995
-pydantic_ai/agent/wrapper.py,sha256=xZw0spYA5oZkBc6GMcxV4hoQZSr02LbH9GCKqI3MokI,9734
+pydantic_ai/usage.py,sha256=_xXoPIfpENghWcjBvMj0URXQV6YwHWxxZYma4WZ4vUg,15710
+pydantic_ai/agent/__init__.py,sha256=amguU7oy8PT3NTy0MK4Ir-02hgu87hWxc9Ehc2WWyGw,64704
+pydantic_ai/agent/abstract.py,sha256=p94SOxrhvdBJNcBdIw1YHnBbpkgTV3LFjnDOQeWfucI,52859
+pydantic_ai/agent/wrapper.py,sha256=0F7CboJSOjsmhcUy5rNJCtB29DFa0GkCyA_yt_Nq960,9925
 pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/common_tools/duckduckgo.py,sha256=1ae_o3zqMGrC6KFqAmuqPwJqQgNBTisuvU2jX9KU8PI,2273
 pydantic_ai/common_tools/tavily.py,sha256=a7p2X03l9GS9B_0mvZZV3jePlCwf2TLNeej62-sPycs,2505
 pydantic_ai/durable_exec/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/durable_exec/dbos/__init__.py,sha256=H_dT0ERuNCBP0Im8eVGl8F9h7E9Aj87-pvmnLpDelF0,199
-pydantic_ai/durable_exec/dbos/_agent.py,sha256=QqUKttoZdnlb2QLuQVqLmwTNxQRy2toJ2GcwAlJLTw4,32903
+pydantic_ai/durable_exec/dbos/_agent.py,sha256=5GcnOatcuLs1jjLhIEp_9qLhGvg2DYkzP15Zxtf4FrU,38151
 pydantic_ai/durable_exec/dbos/_mcp_server.py,sha256=cLMCKmXQHqhqnn_E3Nf4IsNFIbqk-V7gnIvpmYeDCSA,2989
 pydantic_ai/durable_exec/dbos/_model.py,sha256=_Cxh0zYFF3cungXiSXpGHmjyBQF7KnksfurV7hMKp-E,5106
 pydantic_ai/durable_exec/dbos/_utils.py,sha256=_aNceFvTcNeqb78sTDYM2TdYph85tbdeLueyXY1lbTA,242
 pydantic_ai/durable_exec/temporal/__init__.py,sha256=XKwy68wfgmjr057nolRwGHTKiadxufpQEGEUprAV09k,5563
-pydantic_ai/durable_exec/temporal/_agent.py,sha256=ZdGPaKyxYxCw1eL73SIH-TtMqzQH38o2kS7Taw19L_0,37149
+pydantic_ai/durable_exec/temporal/_agent.py,sha256=mwQoasXnxKxk-nMfqBXZFDCmutWSNfD2nv7Tn1xcUBw,42796
 pydantic_ai/durable_exec/temporal/_function_toolset.py,sha256=3n_A5uHzygsT88LM105kKuYqwxC1sjI4bOzETeUbT4E,5553
 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/_model.py,sha256=6jtcwNebL5B8nuKTLUmF5J_FhPa4-62DZoKetm0HhjA,7117
+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/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
-pydantic_ai/models/__init__.py,sha256=8PXVHffd8qJm6yjb6GvYlBZrMacrDzPWf-FSWgCNcOk,35059
-pydantic_ai/models/anthropic.py,sha256=raBHsTYvdwEUg2Xv7mxjWqrgxNuZmtCQfUROGt8kBMg,38035
+pydantic_ai/models/__init__.py,sha256=bZXZRrvQa5xEbv6GLvwmcI39vCZG-y6AxUGres1UtBk,35700
+pydantic_ai/models/anthropic.py,sha256=-vW7aoPrELKnJzbooCEhMu8__jY6iqvWdFJbIKeQPa8,38087
 pydantic_ai/models/bedrock.py,sha256=fha8zVZgDFYgDqO5nvBkZ2CEv4GV92yq_YnK4qmD73E,33639
-pydantic_ai/models/cohere.py,sha256=5p103VxbKXZxLTmTh7GH2QiG1LVgiJRH7KdSUiRVJmA,13817
+pydantic_ai/models/cohere.py,sha256=_ccK7XBts1OwD-RP8puU3z425SZ4PeJGts1WFhPjikg,14051
 pydantic_ai/models/fallback.py,sha256=fjQz7qRuxEwC6aFYkglBv-2Z39-6kZ931vs6o7PIti8,5016
-pydantic_ai/models/function.py,sha256=MCke1w8HHhqlWWONWpF7yW-Xh0T8zJDxqkd-09GLZbA,15816
-pydantic_ai/models/gemini.py,sha256=D4tFMRmS5meUBSJU7Ti5lR7Ei0Nj_ThBmRup2occkaw,39674
-pydantic_ai/models/google.py,sha256=ID9FekcpX2LxFb8tqFj5xDd1oB8H4Pp1jnBg8abjIWg,39783
-pydantic_ai/models/groq.py,sha256=iDXDXEZFehFekRvvrdGi8hUJUrpijMPNPzUNtwn6RAs,29416
-pydantic_ai/models/huggingface.py,sha256=NY870MVS-9_HpEL3SwA9sj-e_1aofUypI0qXDKK21Nk,21385
+pydantic_ai/models/function.py,sha256=7-ej1m4f7c1TbvgB8sF02qlFD7Kf-EX-k_xN4RkbIEw,15880
+pydantic_ai/models/gemini.py,sha256=Ik7e1SnDCvFyjmYHcM-6vilXyl6pHY_GKaM3pHJGNG4,40016
+pydantic_ai/models/google.py,sha256=vWBkQtieMH6fJ93uNMescz7Deo13ddibv-pfcfMSEes,41534
+pydantic_ai/models/groq.py,sha256=pVLl-4Z5CtiYU7bLgRlFTQhfh4LkMi6-aSkvgDuddrk,29633
+pydantic_ai/models/huggingface.py,sha256=711C0ysjLYKriGfSxPiaF6lqjGcNmIaJaCvAXoucTes,21488
 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=Jtcng1ga56U77-1a6R8VwjMOwCZpZAZTje5qgw7ZVBY,33952
-pydantic_ai/models/openai.py,sha256=ZyR5EHCKzi9LwUGAUnXOMjcXL_BgB6G16aCt7uyoSF4,92562
-pydantic_ai/models/test.py,sha256=wATXt4OvSYqyStJDsiCbujLbZWXEeztdTormsJOZbTs,20267
+pydantic_ai/models/mistral.py,sha256=fi57hADjYxZw8wEpAcNI6mqY32VG9hHK9GGRQ-9vlZg,33905
+pydantic_ai/models/openai.py,sha256=_qU8o9PBwmPmELQz3V8OAjxkKy8gXiKtdG6MKQ7Iq_Y,99708
+pydantic_ai/models/test.py,sha256=5ER66nwZG7Iwm-KkzPo4vwNd3rulzgkpgysu4YcT1W4,20568
 pydantic_ai/models/wrapper.py,sha256=nwh8Gea59blbr1JDKlUnkYICuI9TUubC4qP7iZRRW28,2440
-pydantic_ai/profiles/__init__.py,sha256=FMMCAkEnaK5pNdOEjnxy_sZR5Aj_XF2HHg3Uv8rNj1M,3294
+pydantic_ai/profiles/__init__.py,sha256=UHknN-CYsQexUaxfsgz_J_uSZ9QwistLSuAErQkvbcM,3385
 pydantic_ai/profiles/amazon.py,sha256=IPa2wydpcbFLLvhDK35-pwwoKo0Pg4vP84823fHx0zc,314
 pydantic_ai/profiles/anthropic.py,sha256=J9N46G8eOjHdQ5CwZSLiwGdPb0eeIMdsMjwosDpvNhI,275
 pydantic_ai/profiles/cohere.py,sha256=lcL34Ht1jZopwuqoU6OV9l8vN4zwF-jiPjlsEABbSRo,215
 pydantic_ai/profiles/deepseek.py,sha256=JDwfkr-0YovlB3jEKk7dNFvepxNf_YuLgLkGCtyXHSk,282
-pydantic_ai/profiles/google.py,sha256=QJDl29lwQlE2MBdafCVtwqS9yz-P7zGex28PBSa8NWE,4857
+pydantic_ai/profiles/google.py,sha256=9-fXikwK0gnVQZ7mPWSfF63NgELUjVfkDsaPJDfXiwM,5017
 pydantic_ai/profiles/grok.py,sha256=nBOxOCYCK9aiLmz2Q-esqYhotNbbBC1boAoOYIk1tVw,211
 pydantic_ai/profiles/groq.py,sha256=jD_vG6M5q_uwLmJgkPavWWhGCqo3HvT_4UYfwzC1BMU,682
 pydantic_ai/profiles/harmony.py,sha256=HKOQ1QUBd9jLLabO9jMCq97d3pgAzd3Y7c_jiwPFS2s,555
 pydantic_ai/profiles/meta.py,sha256=JdZcpdRWx8PY1pU9Z2i_TYtA0Cpbg23xyFrV7eXnooY,309
 pydantic_ai/profiles/mistral.py,sha256=ll01PmcK3szwlTfbaJLQmfd0TADN8lqjov9HpPJzCMQ,217
 pydantic_ai/profiles/moonshotai.py,sha256=e1RJnbEvazE6aJAqfmYLYGNtwNwg52XQDRDkcLrv3fU,272
-pydantic_ai/profiles/openai.py,sha256=KUklAtUMymCV2yM6qpV9h3zHr7Bl3iiqHELZuOJBIYk,9593
+pydantic_ai/profiles/openai.py,sha256=MXOsktUqfcF2pBgYJMyFWMZafPJ7tejwyoFM2mjKzaY,9689
 pydantic_ai/profiles/qwen.py,sha256=9SnTpMKndxNQMFyumyaOczJa5JGWbYQdpVKKW4OzKjk,749
 pydantic_ai/providers/__init__.py,sha256=nqKuq778BrKuZCV8S5evmTKCHkFrakMDAnsHVifdvYI,4613
 pydantic_ai/providers/anthropic.py,sha256=vwNjO2JJ0Ux_3PXI9_XvzNZ24PKessm8z2ja1uzbBwM,3327
@@ -121,8 +121,8 @@ pydantic_ai/toolsets/prefixed.py,sha256=0KwcDkW8OM36ZUsOLVP5h-Nj2tPq78L3_E2c-1Fb
 pydantic_ai/toolsets/prepared.py,sha256=Zjfz6S8In6PBVxoKFN9sKPN984zO6t0awB7Lnq5KODw,1431
 pydantic_ai/toolsets/renamed.py,sha256=JuLHpi-hYPiSPlaTpN8WiXLiGsywYK0axi2lW2Qs75k,1637
 pydantic_ai/toolsets/wrapper.py,sha256=KRzF1p8dncHbva8CE6Ud-IC5E_aygIHlwH5atXK55k4,1673
-pydantic_ai_slim-1.0.14.dist-info/METADATA,sha256=ShPYXYRzjuw6MLy43l4A2XEeY3H5XGJz1FxCYGur5HM,4631
-pydantic_ai_slim-1.0.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-1.0.14.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-1.0.14.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-1.0.14.dist-info/RECORD,,
+pydantic_ai_slim-1.0.16.dist-info/METADATA,sha256=wnSrB4dase8ngwq7y219eZR9aA6FE5HYY6B4FNQ6e-Y,4631
+pydantic_ai_slim-1.0.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-1.0.16.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-1.0.16.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-1.0.16.dist-info/RECORD,,