pydantic-ai-slim 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

pydantic_ai/profiles/__init__.py

@@ -1,10 +1,12 @@
 from __future__ import annotations as _annotations
 
 from dataclasses import dataclass, fields, replace
+from textwrap import dedent
 from typing import Callable, Union
 
 from typing_extensions import Self
 
+from ..output import StructuredOutputMode
 from ._json_schema import JsonSchemaTransformer
 
 
@@ -12,7 +14,26 @@ from ._json_schema import JsonSchemaTransformer
 class ModelProfile:
     """Describes how requests to a specific model or family of models need to be constructed to get the best results, independent of the model and provider classes used."""
 
+    supports_tools: bool = True
+    """Whether the model supports tools."""
+    supports_json_schema_output: bool = False
+    """Whether the model supports JSON schema output."""
+    supports_json_object_output: bool = False
+    """Whether the model supports JSON object output."""
+    default_structured_output_mode: StructuredOutputMode = 'tool'
+    """The default structured output mode to use for the model."""
+    prompted_output_template: str = dedent(
+        """
+        Always respond with a JSON object that's compatible with this schema:
+
+        {schema}
+
+        Don't include any text or Markdown fencing before or after.
+        """
+    )
+    """The instructions template to use for prompted structured output. The '{schema}' placeholder will be replaced with the JSON schema for the output."""
     json_schema_transformer: type[JsonSchemaTransformer] | None = None
+    """The transformer to use to make JSON schemas for tools and structured output compatible with the model."""
 
     @classmethod
     def from_profile(cls, profile: ModelProfile | None) -> Self:

pydantic_ai/profiles/_json_schema.py

@@ -174,7 +174,7 @@ class JsonSchemaTransformer(ABC):
                 # they are both null, so just return one of them
                 return [cases[0]]
 
-        return cases  # pragma: no cover
+        return cases
 
 
 class InlineDefsJsonSchemaTransformer(JsonSchemaTransformer):

pydantic_ai/profiles/google.py

@@ -10,7 +10,11 @@ from ._json_schema import JsonSchema, JsonSchemaTransformer
 
 def google_model_profile(model_name: str) -> ModelProfile | None:
     """Get the model profile for a Google model."""
-    return ModelProfile(json_schema_transformer=GoogleJsonSchemaTransformer)
+    return ModelProfile(
+        json_schema_transformer=GoogleJsonSchemaTransformer,
+        supports_json_schema_output=True,
+        supports_json_object_output=True,
+    )
 
 
 class GoogleJsonSchemaTransformer(JsonSchemaTransformer):
@@ -47,7 +51,7 @@ class GoogleJsonSchemaTransformer(JsonSchemaTransformer):
         schema.pop('title', None)
         schema.pop('default', None)
         schema.pop('$schema', None)
-        if (const := schema.pop('const', None)) is not None:  # pragma: no cover
+        if (const := schema.pop('const', None)) is not None:
             # Gemini doesn't support const, but it does support enum with a single value
             schema['enum'] = [const]
         schema.pop('discriminator', None)

pydantic_ai/profiles/openai.py

@@ -25,8 +25,13 @@ 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')
+    # Structured Outputs (output mode 'native') is only supported with the gpt-4o-mini, gpt-4o-mini-2024-07-18, and gpt-4o-2024-08-06 model snapshots and later.
+    # We leave it in here for all models because the `default_structured_output_mode` is `'tool'`, so `native` is only used
+    # when the user specifically uses the `NativeOutput` marker, so an error from the API is acceptable.
     return OpenAIModelProfile(
         json_schema_transformer=OpenAIJsonSchemaTransformer,
+        supports_json_schema_output=True,
+        supports_json_object_output=True,
         openai_supports_sampling_settings=not is_reasoning_model,
     )
 

pydantic_ai/result.py

@@ -5,24 +5,35 @@ from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callable
 from copy import copy
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Generic, cast
+from typing import Generic
 
-from typing_extensions import TypeVar, assert_type, deprecated, overload
+from pydantic import ValidationError
+from typing_extensions import TypeVar, deprecated, overload
 
-from . import _output, _utils, exceptions, messages as _messages, models
+from . import _utils, exceptions, messages as _messages, models
 from ._output import (
-    OutputDataT,
     OutputDataT_inv,
     OutputSchema,
     OutputValidator,
     OutputValidatorFunc,
-    ToolOutput,
+    PlainTextOutputSchema,
+    TextOutputSchema,
+    ToolOutputSchema,
 )
+from ._run_context import AgentDepsT, RunContext
 from .messages import AgentStreamEvent, FinalResultEvent
-from .tools import AgentDepsT, RunContext
+from .output import (
+    OutputDataT,
+    ToolOutput,
+)
 from .usage import Usage, UsageLimits
 
-__all__ = 'OutputDataT', 'OutputDataT_inv', 'ToolOutput', 'OutputValidatorFunc'
+__all__ = (
+    'OutputDataT',
+    'OutputDataT_inv',
+    'ToolOutput',
+    'OutputValidatorFunc',
+)
 
 
 T = TypeVar('T')
@@ -32,7 +43,7 @@ T = TypeVar('T')
 @dataclass
 class AgentStream(Generic[AgentDepsT, OutputDataT]):
     _raw_stream_response: models.StreamedResponse
-    _output_schema: OutputSchema[OutputDataT] | None
+    _output_schema: OutputSchema[OutputDataT]
     _output_validators: list[OutputValidator[AgentDepsT, OutputDataT]]
     _run_ctx: RunContext[AgentDepsT]
     _usage_limits: UsageLimits | None
@@ -80,7 +91,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
     ) -> OutputDataT:
         """Validate a structured result message."""
         call = None
-        if self._output_schema is not None and output_tool_name is not None:
+        if isinstance(self._output_schema, ToolOutputSchema) and output_tool_name is not None:
             match = self._output_schema.find_named_tool(message.parts, output_tool_name)
             if match is None:
                 raise exceptions.UnexpectedModelBehavior(  # pragma: no cover
@@ -91,10 +102,16 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
             result_data = await output_tool.process(
                 call, self._run_ctx, allow_partial=allow_partial, wrap_validation_errors=False
             )
-        else:
+        elif isinstance(self._output_schema, TextOutputSchema):
             text = '\n\n'.join(x.content for x in message.parts if isinstance(x, _messages.TextPart))
-            # The following cast is safe because we know `str` is an allowed output type
-            result_data = cast(OutputDataT, text)
+
+            result_data = await self._output_schema.process(
+                text, self._run_ctx, allow_partial=allow_partial, wrap_validation_errors=False
+            )
+        else:
+            raise exceptions.UnexpectedModelBehavior(  # pragma: no cover
+                'Invalid response, unable to process text output'
+            )
 
         for validator in self._output_validators:
             result_data = await validator.validate(result_data, call, self._run_ctx)
@@ -117,14 +134,12 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
                 """Return an appropriate FinalResultEvent if `e` corresponds to a part that will produce a final result."""
                 if isinstance(e, _messages.PartStartEvent):
                     new_part = e.part
-                    if isinstance(new_part, _messages.ToolCallPart):
-                        if output_schema:
-                            for call, _ in output_schema.find_tool([new_part]):  # pragma: no branch
-                                return _messages.FinalResultEvent(
-                                    tool_name=call.tool_name, tool_call_id=call.tool_call_id
-                                )
-                    elif _output.allow_text_output(output_schema):  # pragma: no branch
-                        assert_type(e, _messages.PartStartEvent)
+                    if isinstance(new_part, _messages.ToolCallPart) and isinstance(output_schema, ToolOutputSchema):
+                        for call, _ in output_schema.find_tool([new_part]):  # pragma: no branch
+                            return _messages.FinalResultEvent(tool_name=call.tool_name, tool_call_id=call.tool_call_id)
+                    elif isinstance(new_part, _messages.TextPart) and isinstance(
+                        output_schema, TextOutputSchema
+                    ):  # pragma: no branch
                         return _messages.FinalResultEvent(tool_name=None, tool_call_id=None)
 
             usage_checking_stream = _get_usage_checking_stream_response(
@@ -155,7 +170,7 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
 
     _usage_limits: UsageLimits | None
     _stream_response: models.StreamedResponse
-    _output_schema: OutputSchema[OutputDataT] | None
+    _output_schema: OutputSchema[OutputDataT]
     _run_ctx: RunContext[AgentDepsT]
     _output_validators: list[OutputValidator[AgentDepsT, OutputDataT]]
     _output_tool_name: str | None
@@ -296,7 +311,11 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
             An async iterable of the response data.
         """
         async for structured_message, is_last in self.stream_structured(debounce_by=debounce_by):
-            yield await self.validate_structured_output(structured_message, allow_partial=not is_last)
+            try:
+                yield await self.validate_structured_output(structured_message, allow_partial=not is_last)
+            except ValidationError:
+                if is_last:
+                    raise  # pragma: lax no cover
 
     async def stream_text(self, *, delta: bool = False, debounce_by: float | None = 0.1) -> AsyncIterator[str]:
         """Stream the text result as an async iterable.
@@ -311,7 +330,7 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
                 Debouncing is particularly important for long structured responses to reduce the overhead of
                 performing validation as each token is received.
         """
-        if self._output_schema and not self._output_schema.allow_text_output:
+        if not isinstance(self._output_schema, PlainTextOutputSchema):
             raise exceptions.UserError('stream_text() can only be used with text responses')
 
         if delta:
@@ -390,7 +409,7 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
     ) -> OutputDataT:
         """Validate a structured result message."""
         call = None
-        if self._output_schema is not None and self._output_tool_name is not None:
+        if isinstance(self._output_schema, ToolOutputSchema) and self._output_tool_name is not None:
             match = self._output_schema.find_named_tool(message.parts, self._output_tool_name)
             if match is None:
                 raise exceptions.UnexpectedModelBehavior(  # pragma: no cover
@@ -401,9 +420,16 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
             result_data = await output_tool.process(
                 call, self._run_ctx, allow_partial=allow_partial, wrap_validation_errors=False
             )
-        else:
+        elif isinstance(self._output_schema, TextOutputSchema):
             text = '\n\n'.join(x.content for x in message.parts if isinstance(x, _messages.TextPart))
-            result_data = cast(OutputDataT, text)
+
+            result_data = await self._output_schema.process(
+                text, self._run_ctx, allow_partial=allow_partial, wrap_validation_errors=False
+            )
+        else:
+            raise exceptions.UnexpectedModelBehavior(  # pragma: no cover
+                'Invalid response, unable to process text output'
+            )
 
         for validator in self._output_validators:
             result_data = await validator.validate(result_data, call, self._run_ctx)  # pragma: no cover

pydantic_ai/tools.py

@@ -4,7 +4,7 @@ import dataclasses
 import json
 from collections.abc import Awaitable, Sequence
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, Union
+from typing import Any, Callable, Generic, Literal, Union
 
 from opentelemetry.trace import Tracer
 from pydantic import ValidationError
@@ -13,12 +13,9 @@ from pydantic_core import SchemaValidator, core_schema
 from typing_extensions import Concatenate, ParamSpec, Self, TypeAlias, TypeVar
 
 from . import _function_schema, _utils, messages as _messages
+from ._run_context import AgentDepsT, RunContext
 from .exceptions import ModelRetry, UnexpectedModelBehavior
 
-if TYPE_CHECKING:
-    from .models import Model
-    from .result import Usage
-
 __all__ = (
     'AgentDepsT',
     'DocstringFormat',
@@ -35,48 +32,6 @@ __all__ = (
     'ToolDefinition',
 )
 
-AgentDepsT = TypeVar('AgentDepsT', default=None, contravariant=True)
-"""Type variable for agent dependencies."""
-
-
-@dataclasses.dataclass(repr=False)
-class RunContext(Generic[AgentDepsT]):
-    """Information about the current call."""
-
-    deps: AgentDepsT
-    """Dependencies for the agent."""
-    model: Model
-    """The model used in this run."""
-    usage: Usage
-    """LLM usage associated with the run."""
-    prompt: str | Sequence[_messages.UserContent] | None
-    """The original user prompt passed to the run."""
-    messages: list[_messages.ModelMessage] = field(default_factory=list)
-    """Messages exchanged in the conversation so far."""
-    tool_call_id: str | None = None
-    """The ID of the tool call."""
-    tool_name: str | None = None
-    """Name of the tool being called."""
-    retry: int = 0
-    """Number of retries so far."""
-    run_step: int = 0
-    """The current step in the run."""
-
-    def replace_with(
-        self,
-        retry: int | None = None,
-        tool_name: str | None | _utils.Unset = _utils.UNSET,
-    ) -> RunContext[AgentDepsT]:
-        # Create a new `RunContext` a new `retry` value and `tool_name`.
-        kwargs = {}
-        if retry is not None:
-            kwargs['retry'] = retry
-        if tool_name is not _utils.UNSET:  # pragma: no branch
-            kwargs['tool_name'] = tool_name
-        return dataclasses.replace(self, **kwargs)
-
-    __repr__ = _utils.dataclasses_no_defaults_repr
-
 
 ToolParams = ParamSpec('ToolParams', default=...)
 """Retrieval function param spec."""
@@ -372,6 +327,7 @@ class Tool(Generic[AgentDepsT]):
         message: _messages.ToolCallPart,
         run_context: RunContext[AgentDepsT],
         tracer: Tracer,
+        include_content: bool = False,
     ) -> _messages.ToolReturnPart | _messages.RetryPromptPart:
         """Run the tool function asynchronously.
 
@@ -383,14 +339,14 @@ class Tool(Generic[AgentDepsT]):
             'gen_ai.tool.name': self.name,
             # NOTE: this means `gen_ai.tool.call.id` will be included even if it was generated by pydantic-ai
             'gen_ai.tool.call.id': message.tool_call_id,
-            'tool_arguments': message.args_as_json_str(),
+            **({'tool_arguments': message.args_as_json_str()} if include_content else {}),
             'logfire.msg': f'running tool: {self.name}',
             # add the JSON schema so these attributes are formatted nicely in Logfire
             'logfire.json_schema': json.dumps(
                 {
                     'type': 'object',
                     'properties': {
-                        'tool_arguments': {'type': 'object'},
+                        **({'tool_arguments': {'type': 'object'}} if include_content else {}),
                         'gen_ai.tool.name': {},
                         'gen_ai.tool.call.id': {},
                     },

{pydantic_ai_slim-0.3.2.dist-info → pydantic_ai_slim-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 0.3.2
+Version: 0.3.4
 Summary: Agent Framework / shim to use Pydantic with LLMs, slim package
 Author-email: Samuel Colvin <samuel@pydantic.dev>, Marcelo Trylesinski <marcelotryle@gmail.com>, David Montague <david@pydantic.dev>, Alex Hall <alex@pydantic.dev>
 License-Expression: MIT
@@ -30,11 +30,11 @@ Requires-Dist: exceptiongroup; python_version < '3.11'
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==0.3.2
+Requires-Dist: pydantic-graph==0.3.4
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
-Requires-Dist: fasta2a==0.3.2; extra == 'a2a'
+Requires-Dist: fasta2a==0.3.4; extra == 'a2a'
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.52.0; extra == 'anthropic'
 Provides-Extra: bedrock
@@ -48,7 +48,7 @@ Requires-Dist: cohere>=5.13.11; (platform_system != 'Emscripten') and extra == '
 Provides-Extra: duckduckgo
 Requires-Dist: duckduckgo-search>=7.0.0; extra == 'duckduckgo'
 Provides-Extra: evals
-Requires-Dist: pydantic-evals==0.3.2; extra == 'evals'
+Requires-Dist: pydantic-evals==0.3.4; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.15.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-0.3.2.dist-info → pydantic_ai_slim-0.3.4.dist-info}/RECORD

@@ -1,59 +1,61 @@
-pydantic_ai/__init__.py,sha256=5flxyMQJVrHRMQ3MYaZf1el2ctNs0JmPClKbw2Q-Lsk,1160
+pydantic_ai/__init__.py,sha256=Ns04g4Efqkzwccs8w2nGphfWbptMlIJYG8vIJbGGyG0,1262
 pydantic_ai/__main__.py,sha256=Q_zJU15DUA01YtlJ2mnaLCoId2YmgmreVEERGuQT-Y0,132
 pydantic_ai/_a2a.py,sha256=8nNtx6GENDt2Ej3f1ui9L-FuNQBYVELpJFfwz-y7fUw,7234
-pydantic_ai/_agent_graph.py,sha256=8Y1xEFwNCp0hVsRst_2I4WQymeTFRJ4Ec5-lURMd5HQ,39671
-pydantic_ai/_cli.py,sha256=kc9UxGjYsKK0IR4No-V5BGiAtq2fY6eZZ9rBkAdHWOM,12948
-pydantic_ai/_function_schema.py,sha256=VXHGnudrpyW40UJqCopgSUB_IuSip5pEEBSLGhVEuFI,10846
+pydantic_ai/_agent_graph.py,sha256=pAP2bbO1TenFZO3alaW-5QTMk2uN7lWfFfgWe7zAAAU,40571
+pydantic_ai/_cli.py,sha256=R-sE-9gYqPxV5-5utso4g-bzAKMiTCdo33XOVqE0ZEg,13206
+pydantic_ai/_function_schema.py,sha256=TP9Y1wlN7tRHTDhkJ1IopJHPWpSbxJCxS3zxCb0dpK4,10806
 pydantic_ai/_griffe.py,sha256=Sf_DisE9k2TA0VFeVIK2nf1oOct5MygW86PBCACJkFA,5244
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
-pydantic_ai/_output.py,sha256=HYhcaqcisU16PT_EFdl2VuV5MI-nRFbUPzijd_rTTgM,16787
+pydantic_ai/_output.py,sha256=PdYdIe9Xg0CiASGnaFeLVP3H4einbTK00syRfXO9BIg,33117
 pydantic_ai/_parts_manager.py,sha256=Lioi8b7Nfyax09yQu8jTkMzxd26dYDrdAqhYvjRSKqQ,16182
-pydantic_ai/_system_prompt.py,sha256=W5wYN6rH5JCshl1xI2s0ygevBCutCraqyG6t75yZubk,1117
+pydantic_ai/_run_context.py,sha256=zNkSyiQSH-YweO39ii3iB2taouUOodo3sTjz2Lrj4Pc,1792
+pydantic_ai/_system_prompt.py,sha256=lUSq-gDZjlYTGtd6BUm54yEvTIvgdwBmJ8mLsNZZtYU,1142
 pydantic_ai/_thinking_part.py,sha256=mzx2RZSfiQxAKpljEflrcXRXmFKxtp6bKVyorY3UYZk,1554
-pydantic_ai/_utils.py,sha256=qi2NjYpIVOgCHDMPgyV8oUL42Fv2_rLyj8KdOUO5fQU,11319
-pydantic_ai/agent.py,sha256=CISy6RrSR45esRSU-JjI7-l4-wxRo1MCs97PHQKcSjo,94836
+pydantic_ai/_utils.py,sha256=JKjM3YIgn2CslJcQKxDcq5nWV57TUTS23x8t3u6v_wA,15025
+pydantic_ai/agent.py,sha256=Xy92Pi4R0CKrEkPtAXbUBWQi_d4Un1mwXafPBfjjTy8,95584
 pydantic_ai/direct.py,sha256=tXRcQ3fMkykaawO51VxnSwQnqcEmu1LhCy7U9gOyM-g,7768
 pydantic_ai/exceptions.py,sha256=IdFw594Ou7Vn4YFa7xdZ040_j_6nmyA3MPANbC7sys4,3175
 pydantic_ai/format_as_xml.py,sha256=IINfh1evWDphGahqHNLBArB5dQ4NIqS3S-kru35ztGg,372
 pydantic_ai/format_prompt.py,sha256=qdKep95Sjlr7u1-qag4JwPbjoURbG0GbeU_l5ODTNw4,4466
 pydantic_ai/mcp.py,sha256=MSLNFiC38A1e5W7K8gQdnh0_DNLqD_AdzW064U83FJ8,21836
-pydantic_ai/messages.py,sha256=7GtSO0x3nypiIZZOiAf72woeTqhuf7W21-jbYS582RQ,36300
+pydantic_ai/messages.py,sha256=AkfJBDaldwpx05AkBvOI-jqTSmx1tn9yt9CUr07VWW0,36742
+pydantic_ai/output.py,sha256=L05UoIwLbQ2LWvk0TuQrAdbbNdWSP6xZt10l61ORVfI,9147
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pydantic_ai/result.py,sha256=YlcR0QAQIejz3fbZ50zYfHKIZco0dwmnZTxytV-n3oM,24609
+pydantic_ai/result.py,sha256=jCnM_KDX9383OoPy4L8YtPmhmlZkJkCufbq2CGxbgK4,25437
 pydantic_ai/settings.py,sha256=yuUZ7-GkdPB-Gbx71kSdh8dSr6gwM9gEwk84qNxPO_I,3552
-pydantic_ai/tools.py,sha256=9xx55FOrtUzyVSfiMHC8JMrZngc_602X96ut_IsGo8Y,18506
+pydantic_ai/tools.py,sha256=FFmNShGNh7tpOy9PBd7VDwParxKhbNsNZ-iYw0eHVzY,17117
 pydantic_ai/usage.py,sha256=35YPmItlzfNOwP35Rhh0qBUOlg5On5rUE7xqHQWrpaU,5596
 pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/common_tools/duckduckgo.py,sha256=Ty9tu1rCwMfGKgz1JAaC2q_4esmL6QvpkHQUN8F0Ecc,2152
 pydantic_ai/common_tools/tavily.py,sha256=Q1xxSF5HtXAaZ10Pp-OaDOHXwJf2mco9wScGEQXD7E4,2495
 pydantic_ai/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/ext/langchain.py,sha256=TI8B6eBjEGKFfvwyLgC_-0eeba4hDJq7wLZ0OZhbiWw,1967
-pydantic_ai/models/__init__.py,sha256=mE7tcHZM0uAwkUA67rGwetB_lQB-lXJpNdJh-_xe8aI,28224
-pydantic_ai/models/anthropic.py,sha256=s7yvNObBfS-gcXLT0vU8UXjLHITsbr5kkXgP1SYkPms,23832
+pydantic_ai/models/__init__.py,sha256=baO_rIg9sr_AQVj2Qbz7fgdA-R4eDXriwtkV1u-mS58,29012
+pydantic_ai/models/anthropic.py,sha256=YdN4TXPsVoPB8lILz2k9we-7K8thfPo7ikrta-sDd_Y,23676
 pydantic_ai/models/bedrock.py,sha256=67qf_mFnx0kfmKoI96zLOAUn3P47PxPqMrQsaYUrJJ0,29120
 pydantic_ai/models/cohere.py,sha256=UU04-_O-KLgC4DUpM-g4FBPoTOatbmVJJ7mkZNBGsbQ,12626
 pydantic_ai/models/fallback.py,sha256=idOYGMo3CZzpCBT8DDiuPAAgnV2jzluDUq3ESb3KteM,4981
-pydantic_ai/models/function.py,sha256=xvN_oNKw0X4c16oe1l3MX2_kJtFWMOMaseMNO6eNBYI,11709
-pydantic_ai/models/gemini.py,sha256=zDEZIPnlH9CtlJwZh6TizqzXqz0XidMjGLYpeCNXwHI,37472
-pydantic_ai/models/google.py,sha256=Xvw1nXji3WtDnsQrC9SFHYfmvwxQM303sxvy55QEK0U,22383
+pydantic_ai/models/function.py,sha256=nfCjRmbcF7sdK_nsak1fvzz9Xkptx5WhsxvWdB02zec,12113
+pydantic_ai/models/gemini.py,sha256=r_DWEmaMvP55duanTLI2SvKC3hAqnDAm2W0-UwLYShI,38485
+pydantic_ai/models/google.py,sha256=fbMG5VEjxHIeoP9JXBgymQtfB8gVnzDU2TTey5FMbbA,23396
 pydantic_ai/models/groq.py,sha256=lojKRdvg0p-EtZ20Z2CS4I0goq4CoGkLj3LuYHA6o-I,18497
-pydantic_ai/models/instrumented.py,sha256=vVq7mS071EXS2PZ3NJ4Zgt93iQgAscFr2dyg9fAeuCE,15703
+pydantic_ai/models/instrumented.py,sha256=olTa7Fl2BwHLvTLT6sSrS2HOS7UyWg182Xujx8hutBw,15947
 pydantic_ai/models/mcp_sampling.py,sha256=dWPJjez_aghF_JVGGCd4nZjlnmxYGLFtUS0vlzfRFyk,3398
-pydantic_ai/models/mistral.py,sha256=LHm3F2yVKoE1uDjEPtTPug6duHwr4A42qey2Pncqqx4,30093
-pydantic_ai/models/openai.py,sha256=onyJSKCo5zj_VY22RTQnPRE0Bpxu1ojgtftveQF_VQc,49633
-pydantic_ai/models/test.py,sha256=X5QVCsBAWXxw4MKet-UTGZ0FteUnCHoK3Py3ngJM2Zk,17437
-pydantic_ai/models/wrapper.py,sha256=43ntRkTF7rVBYLC-Ihdo1fkwpeveOpA_1fXe1fd3W9Y,1690
-pydantic_ai/profiles/__init__.py,sha256=uO_f1kSqrnXuO0x5U0EHTTMRYcmOiOoa-tS1OZppxBk,1426
-pydantic_ai/profiles/_json_schema.py,sha256=3ofRGnBca9WzqlUbw0C1ywhv_V7eGTmFAf2O7Bs5zgk,7199
+pydantic_ai/models/mistral.py,sha256=Ev2zK2UWh4NrRpc2LQE0LNZFBSznNvZ1mkh4_4VcRMg,30514
+pydantic_ai/models/openai.py,sha256=NUE2WroS0BSxLWlfi-RFGTp0k0iv5zb2LWXQ7-Uz9Hw,53016
+pydantic_ai/models/test.py,sha256=STNd79ZoCyyphm0eFRNDoTpvkOzhw1qFw1zgv44kqsg,17441
+pydantic_ai/models/wrapper.py,sha256=2g06TxE5kFqfaJCwsDJHp7Rltoj0XXH0OzdpRDOcqNo,1861
+pydantic_ai/profiles/__init__.py,sha256=BXMqUpgRfosmYgcxjKAI9ESCj47JTSa30DhKXEgVLzM,2419
+pydantic_ai/profiles/_json_schema.py,sha256=sTNHkaK0kbwmbldZp9JRGQNax0f5Qvwy0HkWuu_nGxU,7179
 pydantic_ai/profiles/amazon.py,sha256=O4ijm1Lpz01vaSiHrkSeGQhbCKV5lyQVtHYqh0pCW_k,339
 pydantic_ai/profiles/anthropic.py,sha256=DtTGh85tbkTrrrn2OrJ4FJKXWUIxUH_1Vw6y5fyMRyM,222
 pydantic_ai/profiles/cohere.py,sha256=lcL34Ht1jZopwuqoU6OV9l8vN4zwF-jiPjlsEABbSRo,215
 pydantic_ai/profiles/deepseek.py,sha256=DS_idprnXpMliKziKF0k1neLDJOwUvpatZ3YLaiYnCM,219
-pydantic_ai/profiles/google.py,sha256=TL8WxCuFKQ7FZnDQpBYvtd26_qOwPDpLfDeTdAOdrBE,4812
+pydantic_ai/profiles/google.py,sha256=DJ0otpkCgVIrjwV2lzAUAejw8ivwZT9pNAY_sGRcrVg,4891
 pydantic_ai/profiles/grok.py,sha256=nBOxOCYCK9aiLmz2Q-esqYhotNbbBC1boAoOYIk1tVw,211
 pydantic_ai/profiles/meta.py,sha256=IAGPoUrLWd-g9ajAgpWp9fIeOrP-7dBlZ2HEFjIhUbY,334
 pydantic_ai/profiles/mistral.py,sha256=ll01PmcK3szwlTfbaJLQmfd0TADN8lqjov9HpPJzCMQ,217
-pydantic_ai/profiles/openai.py,sha256=QK1-e4fHdTvWgi090UI7ouAlO9hbDu2CBrI0AX1MSUI,5807
+pydantic_ai/profiles/openai.py,sha256=DzrKYvegfCerqavHU3jHzrNQCm0IllWoIqS7_DiQB9M,6281
 pydantic_ai/profiles/qwen.py,sha256=u7pL8uomoQTVl45g5wDrHx0P_oFDLaN6ALswuwmkWc0,334
 pydantic_ai/providers/__init__.py,sha256=l3xrEhFzfCNyZZlJ5RJOi-BjVayZ-SwjNbs7pZ6UDhg,3549
 pydantic_ai/providers/anthropic.py,sha256=D35UXxCPXv8yIbD0fj9Zg2FvNyoMoJMeDUtVM8Sn78I,3046
@@ -72,8 +74,8 @@ pydantic_ai/providers/mistral.py,sha256=EIUSENjFuGzBhvbdrarUTM4VPkesIMnZrzfnEKHO
 pydantic_ai/providers/openai.py,sha256=7iGij0EaFylab7dTZAZDgXr78tr-HsZrn9EI9AkWBNQ,3091
 pydantic_ai/providers/openrouter.py,sha256=NXjNdnlXIBrBMMqbzcWQnowXOuZh4NHikXenBn5h3mc,4061
 pydantic_ai/providers/together.py,sha256=zFVSMSm5jXbpkNouvBOTjWrPmlPpCp6sQS5LMSyVjrQ,3482
-pydantic_ai_slim-0.3.2.dist-info/METADATA,sha256=DFCrOmEE1CgLPCdBpW6WGjVGT62gg5bOrOJqNX4a4iQ,3846
-pydantic_ai_slim-0.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-0.3.2.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-0.3.2.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-0.3.2.dist-info/RECORD,,
+pydantic_ai_slim-0.3.4.dist-info/METADATA,sha256=0A68abJj0VyoP1r1LiU35lWhK0WbZfcu6NX5_pe9LBs,3846
+pydantic_ai_slim-0.3.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-0.3.4.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-0.3.4.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-0.3.4.dist-info/RECORD,,