pydantic-ai-slim 1.0.9__py3-none-any.whl → 1.0.10__py3-none-any.whl

pydantic_ai/_agent_graph.py

@@ -547,7 +547,7 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
             async def _run_stream() -> AsyncIterator[_messages.HandleResponseEvent]:  # noqa: C901
                 text = ''
                 tool_calls: list[_messages.ToolCallPart] = []
-                thinking_parts: list[_messages.ThinkingPart] = []
+                invisible_parts: bool = False
 
                 for part in self.model_response.parts:
                     if isinstance(part, _messages.TextPart):
@@ -558,11 +558,13 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                         # Text parts before a built-in tool call are essentially thoughts,
                         # not part of the final result output, so we reset the accumulated text
                         text = ''
+                        invisible_parts = True
                         yield _messages.BuiltinToolCallEvent(part)  # pyright: ignore[reportDeprecated]
                     elif isinstance(part, _messages.BuiltinToolReturnPart):
+                        invisible_parts = True
                         yield _messages.BuiltinToolResultEvent(part)  # pyright: ignore[reportDeprecated]
                     elif isinstance(part, _messages.ThinkingPart):
-                        thinking_parts.append(part)
+                        invisible_parts = True
                     else:
                         assert_never(part)
 
@@ -570,43 +572,51 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
                 # In the future, we'd consider making this configurable at the agent or run level.
                 # This accounts for cases like anthropic returns that might contain a text response
                 # and a tool call response, where the text response just indicates the tool call will happen.
-                if tool_calls:
-                    async for event in self._handle_tool_calls(ctx, tool_calls):
-                        yield event
-                elif text:
-                    # No events are emitted during the handling of text responses, so we don't need to yield anything
-                    self._next_node = await self._handle_text_response(ctx, text)
-                elif thinking_parts:
-                    # handle thinking-only responses (responses that contain only ThinkingPart instances)
-                    # this can happen with models that support thinking mode when they don't provide
-                    # actionable output alongside their thinking content.
-                    self._next_node = ModelRequestNode[DepsT, NodeRunEndT](
-                        _messages.ModelRequest(
-                            parts=[_messages.RetryPromptPart('Responses without text or tool calls are not permitted.')]
+                try:
+                    if tool_calls:
+                        async for event in self._handle_tool_calls(ctx, tool_calls):
+                            yield event
+                    elif text:
+                        # No events are emitted during the handling of text responses, so we don't need to yield anything
+                        self._next_node = await self._handle_text_response(ctx, text)
+                    elif invisible_parts:
+                        # handle responses with only thinking or built-in tool parts.
+                        # this can happen with models that support thinking mode when they don't provide
+                        # actionable output alongside their thinking content. so we tell the model to try again.
+                        m = _messages.RetryPromptPart(
+                            content='Responses without text or tool calls are not permitted.',
                         )
-                    )
-                else:
-                    # we got an empty response with no tool calls, text, or thinking
-                    # this sometimes happens with anthropic (and perhaps other models)
-                    # when the model has already returned text along side tool calls
-                    # in this scenario, if text responses are allowed, we return text from the most recent model
-                    # response, if any
-                    if isinstance(ctx.deps.output_schema, _output.TextOutputSchema):
-                        for message in reversed(ctx.state.message_history):
-                            if isinstance(message, _messages.ModelResponse):
-                                text = ''
-                                for part in message.parts:
-                                    if isinstance(part, _messages.TextPart):
-                                        text += part.content
-                                    elif isinstance(part, _messages.BuiltinToolCallPart):
-                                        # Text parts before a built-in tool call are essentially thoughts,
-                                        # not part of the final result output, so we reset the accumulated text
-                                        text = ''  # pragma: no cover
-                                if text:
-                                    self._next_node = await self._handle_text_response(ctx, text)
-                                    return
-
-                    raise exceptions.UnexpectedModelBehavior('Received empty model response')
+                        raise ToolRetryError(m)
+                    else:
+                        # we got an empty response with no tool calls, text, thinking, or built-in tool calls.
+                        # this sometimes happens with anthropic (and perhaps other models)
+                        # when the model has already returned text along side tool calls
+                        # in this scenario, if text responses are allowed, we return text from the most recent model
+                        # response, if any
+                        if isinstance(ctx.deps.output_schema, _output.TextOutputSchema):
+                            for message in reversed(ctx.state.message_history):
+                                if isinstance(message, _messages.ModelResponse):
+                                    text = ''
+                                    for part in message.parts:
+                                        if isinstance(part, _messages.TextPart):
+                                            text += part.content
+                                        elif isinstance(part, _messages.BuiltinToolCallPart):
+                                            # Text parts before a built-in tool call are essentially thoughts,
+                                            # not part of the final result output, so we reset the accumulated text
+                                            text = ''  # pragma: no cover
+                                    if text:
+                                        self._next_node = await self._handle_text_response(ctx, text)
+                                        return
+
+                        # Go back to the model request node with an empty request, which means we'll essentially
+                        # resubmit the most recent request that resulted in an empty response,
+                        # as the empty response and request will not create any items in the API payload,
+                        # in the hope the model will return a non-empty response this time.
+                        ctx.state.increment_retries(ctx.deps.max_result_retries)
+                        self._next_node = ModelRequestNode[DepsT, NodeRunEndT](_messages.ModelRequest(parts=[]))
+                except ToolRetryError as e:
+                    ctx.state.increment_retries(ctx.deps.max_result_retries, e)
+                    self._next_node = ModelRequestNode[DepsT, NodeRunEndT](_messages.ModelRequest(parts=[e.tool_retry]))
 
             self._events_iterator = _run_stream()
 
@@ -666,23 +676,19 @@ class CallToolsNode(AgentNode[DepsT, NodeRunEndT]):
         text: str,
     ) -> ModelRequestNode[DepsT, NodeRunEndT] | End[result.FinalResult[NodeRunEndT]]:
         output_schema = ctx.deps.output_schema
-        try:
-            run_context = build_run_context(ctx)
-            if isinstance(output_schema, _output.TextOutputSchema):
-                result_data = await output_schema.process(text, run_context)
-            else:
-                m = _messages.RetryPromptPart(
-                    content='Plain text responses are not permitted, please include your response in a tool call',
-                )
-                raise ToolRetryError(m)
+        run_context = build_run_context(ctx)
 
-            for validator in ctx.deps.output_validators:
-                result_data = await validator.validate(result_data, run_context)
-        except ToolRetryError as e:
-            ctx.state.increment_retries(ctx.deps.max_result_retries, e)
-            return ModelRequestNode[DepsT, NodeRunEndT](_messages.ModelRequest(parts=[e.tool_retry]))
+        if isinstance(output_schema, _output.TextOutputSchema):
+            result_data = await output_schema.process(text, run_context)
         else:
-            return self._handle_final_result(ctx, result.FinalResult(result_data), [])
+            m = _messages.RetryPromptPart(
+                content='Plain text responses are not permitted, please include your response in a tool call',
+            )
+            raise ToolRetryError(m)
+
+        for validator in ctx.deps.output_validators:
+            result_data = await validator.validate(result_data, run_context)
+        return self._handle_final_result(ctx, result.FinalResult(result_data), [])
 
     __repr__ = dataclasses_no_defaults_repr
 

pydantic_ai/agent/__init__.py

@@ -259,7 +259,8 @@ class Agent(AbstractAgent[AgentDepsT, OutputDataT]):
             name: The name of the agent, used for logging. If `None`, we try to infer the agent name from the call frame
                 when the agent is first run.
             model_settings: Optional model request settings to use for this agent's runs, by default.
-            retries: The default number of retries to allow before raising an error.
+            retries: The default number of retries to allow for tool calls and output validation, before raising an error.
+                For model request retries, see the [HTTP Request Retries](../retries.md) documentation.
             output_retries: The maximum number of retries to allow for output validation, defaults to `retries`.
             tools: Tools to register with the agent, you can also register tools via the decorators
                 [`@agent.tool`][pydantic_ai.Agent.tool] and [`@agent.tool_plain`][pydantic_ai.Agent.tool_plain].

pydantic_ai/format_prompt.py

@@ -1,15 +1,17 @@
 from __future__ import annotations as _annotations
 
 from collections.abc import Iterable, Iterator, Mapping
-from dataclasses import asdict, dataclass, is_dataclass
+from dataclasses import asdict, dataclass, field, fields, is_dataclass
 from datetime import date
-from typing import Any
+from typing import Any, Literal
 from xml.etree import ElementTree
 
 from pydantic import BaseModel
 
 __all__ = ('format_as_xml',)
 
+from pydantic.fields import ComputedFieldInfo, FieldInfo
+
 
 def format_as_xml(
     obj: Any,
@@ -17,6 +19,7 @@ def format_as_xml(
     item_tag: str = 'item',
     none_str: str = 'null',
     indent: str | None = '  ',
+    include_field_info: Literal['once'] | bool = False,
 ) -> str:
     """Format a Python object as XML.
 
@@ -33,6 +36,10 @@ def format_as_xml(
             for dataclasses and Pydantic models.
         none_str: String to use for `None` values.
         indent: Indentation string to use for pretty printing.
+        include_field_info: Whether to include attributes like Pydantic `Field` attributes and dataclasses `field()`
+            `metadata` as XML attributes. In both cases the allowed `Field` attributes and `field()` metadata keys are
+            `title` and `description`. If a field is repeated in the data (e.g. in a list) by setting `once`
+            the attributes are included only in the first occurrence of an XML element relative to the same field.
 
     Returns:
         XML representation of the object.
@@ -51,7 +58,12 @@ def format_as_xml(
     '''
     ```
     """
-    el = _ToXml(item_tag=item_tag, none_str=none_str).to_xml(obj, root_tag)
+    el = _ToXml(
+        data=obj,
+        item_tag=item_tag,
+        none_str=none_str,
+        include_field_info=include_field_info,
+    ).to_xml(root_tag)
     if root_tag is None and el.text is None:
         join = '' if indent is None else '\n'
         return join.join(_rootless_xml_elements(el, indent))
@@ -63,11 +75,26 @@ def format_as_xml(
 
 @dataclass
 class _ToXml:
+    data: Any
     item_tag: str
     none_str: str
-
-    def to_xml(self, value: Any, tag: str | None) -> ElementTree.Element:
-        element = ElementTree.Element(self.item_tag if tag is None else tag)
+    include_field_info: Literal['once'] | bool
+    # a map of Pydantic and dataclasses Field paths to their metadata:
+    # a field unique string representation and its class
+    _fields_info: dict[str, tuple[str, FieldInfo | ComputedFieldInfo]] = field(default_factory=dict)
+    # keep track of fields we have extracted attributes from
+    _included_fields: set[str] = field(default_factory=set)
+    # keep track of class names for dataclasses and Pydantic models, that occur in lists
+    _element_names: dict[str, str] = field(default_factory=dict)
+    # flag for parsing dataclasses and Pydantic models once
+    _is_info_extracted: bool = False
+    _FIELD_ATTRIBUTES = ('title', 'description')
+
+    def to_xml(self, tag: str | None = None) -> ElementTree.Element:
+        return self._to_xml(value=self.data, path='', tag=tag)
+
+    def _to_xml(self, value: Any, path: str, tag: str | None = None) -> ElementTree.Element:
+        element = self._create_element(self.item_tag if tag is None else tag, path)
         if value is None:
             element.text = self.none_str
         elif isinstance(value, str):
@@ -79,31 +106,96 @@ class _ToXml:
         elif isinstance(value, date):
             element.text = value.isoformat()
         elif isinstance(value, Mapping):
-            self._mapping_to_xml(element, value)  # pyright: ignore[reportUnknownArgumentType]
+            if tag is None and path in self._element_names:
+                element.tag = self._element_names[path]
+            self._mapping_to_xml(element, value, path)  # pyright: ignore[reportUnknownArgumentType]
         elif is_dataclass(value) and not isinstance(value, type):
+            self._init_structure_info()
             if tag is None:
-                element = ElementTree.Element(value.__class__.__name__)
-            dc_dict = asdict(value)
-            self._mapping_to_xml(element, dc_dict)
+                element.tag = value.__class__.__name__
+            self._mapping_to_xml(element, asdict(value), path)
         elif isinstance(value, BaseModel):
+            self._init_structure_info()
             if tag is None:
-                element = ElementTree.Element(value.__class__.__name__)
-            self._mapping_to_xml(element, value.model_dump(mode='python'))
+                element.tag = value.__class__.__name__
+            # by dumping the model we loose all metadata in nested data structures,
+            # but we have collected it when called _init_structure_info
+            self._mapping_to_xml(element, value.model_dump(), path)
         elif isinstance(value, Iterable):
-            for item in value:  # pyright: ignore[reportUnknownVariableType]
-                item_el = self.to_xml(item, None)
-                element.append(item_el)
+            for n, item in enumerate(value):  # pyright: ignore[reportUnknownVariableType,reportUnknownArgumentType]
+                element.append(self._to_xml(value=item, path=f'{path}.[{n}]' if path else f'[{n}]'))
         else:
             raise TypeError(f'Unsupported type for XML formatting: {type(value)}')
         return element
 
-    def _mapping_to_xml(self, element: ElementTree.Element, mapping: Mapping[Any, Any]) -> None:
+    def _create_element(self, tag: str, path: str) -> ElementTree.Element:
+        element = ElementTree.Element(tag)
+        if path in self._fields_info:
+            field_repr, field_info = self._fields_info[path]
+            if self.include_field_info and self.include_field_info != 'once' or field_repr not in self._included_fields:
+                field_attributes = self._extract_attributes(field_info)
+                for k, v in field_attributes.items():
+                    element.set(k, v)
+                self._included_fields.add(field_repr)
+        return element
+
+    def _init_structure_info(self):
+        """Create maps with all data information (fields info and class names), if not already created."""
+        if not self._is_info_extracted:
+            self._parse_data_structures(self.data)
+            self._is_info_extracted = True
+
+    def _mapping_to_xml(
+        self,
+        element: ElementTree.Element,
+        mapping: Mapping[Any, Any],
+        path: str = '',
+    ) -> None:
         for key, value in mapping.items():
             if isinstance(key, int):
                 key = str(key)
             elif not isinstance(key, str):
                 raise TypeError(f'Unsupported key type for XML formatting: {type(key)}, only str and int are allowed')
-            element.append(self.to_xml(value, key))
+            element.append(self._to_xml(value=value, path=f'{path}.{key}' if path else key, tag=key))
+
+    def _parse_data_structures(
+        self,
+        value: Any,
+        path: str = '',
+    ):
+        """Parse data structures as dataclasses or Pydantic models to extract element names and attributes."""
+        if value is None or isinstance(value, (str | int | float | date | bytearray | bytes | bool)):
+            return
+        elif isinstance(value, Mapping):
+            for k, v in value.items():  # pyright: ignore[reportUnknownVariableType]
+                self._parse_data_structures(v, f'{path}.{k}' if path else f'{k}')
+        elif is_dataclass(value) and not isinstance(value, type):
+            self._element_names[path] = value.__class__.__name__
+            for field in fields(value):
+                new_path = f'{path}.{field.name}' if path else field.name
+                if self.include_field_info and field.metadata:
+                    attributes = {k: v for k, v in field.metadata.items() if k in self._FIELD_ATTRIBUTES}
+                    if attributes:
+                        field_repr = f'{value.__class__.__name__}.{field.name}'
+                        self._fields_info[new_path] = (field_repr, FieldInfo(**attributes))
+                self._parse_data_structures(getattr(value, field.name), new_path)
+        elif isinstance(value, BaseModel):
+            self._element_names[path] = value.__class__.__name__
+            for model_fields in (value.__class__.model_fields, value.__class__.model_computed_fields):
+                for field, info in model_fields.items():
+                    new_path = f'{path}.{field}' if path else field
+                    if self.include_field_info and (isinstance(info, ComputedFieldInfo) or not info.exclude):
+                        field_repr = f'{value.__class__.__name__}.{field}'
+                        self._fields_info[new_path] = (field_repr, info)
+                    self._parse_data_structures(getattr(value, field), new_path)
+        elif isinstance(value, Iterable):
+            for n, item in enumerate(value):  # pyright: ignore[reportUnknownVariableType,reportUnknownArgumentType]
+                new_path = f'{path}.[{n}]' if path else f'[{n}]'
+                self._parse_data_structures(item, new_path)
+
+    @classmethod
+    def _extract_attributes(cls, info: FieldInfo | ComputedFieldInfo) -> dict[str, str]:
+        return {attr: str(value) for attr in cls._FIELD_ATTRIBUTES if (value := getattr(info, attr, None)) is not None}
 
 
 def _rootless_xml_elements(root: ElementTree.Element, indent: str | None) -> Iterator[str]:

pydantic_ai/messages.py

@@ -1161,11 +1161,7 @@ class ModelResponse:
                 if settings.include_content and part.content is not None:  # pragma: no branch
                     from .models.instrumented import InstrumentedModel
 
-                    return_part['result'] = (
-                        part.content
-                        if isinstance(part.content, str)
-                        else {k: InstrumentedModel.serialize_any(v) for k, v in part.content.items()}
-                    )
+                    return_part['result'] = InstrumentedModel.serialize_any(part.content)
 
                 parts.append(return_part)
         return parts

pydantic_ai/models/google.py

@@ -51,6 +51,7 @@ from . import (
 try:
     from google.genai import Client
     from google.genai.types import (
+        BlobDict,
         CodeExecutionResult,
         CodeExecutionResultDict,
         ContentDict,
@@ -58,6 +59,7 @@ try:
         CountTokensConfigDict,
         ExecutableCode,
         ExecutableCodeDict,
+        FileDataDict,
         FinishReason as GoogleFinishReason,
         FunctionCallDict,
         FunctionCallingConfigDict,
@@ -79,6 +81,7 @@ try:
         ToolDict,
         ToolListUnionDict,
         UrlContextDict,
+        VideoMetadataDict,
     )
 
     from ..providers.google import GoogleProvider
@@ -525,17 +528,17 @@ class GoogleModel(Model):
                 if isinstance(item, str):
                     content.append({'text': item})
                 elif isinstance(item, BinaryContent):
-                    # NOTE: The type from Google GenAI is incorrect, it should be `str`, not `bytes`.
-                    base64_encoded = base64.b64encode(item.data).decode('utf-8')
-                    inline_data_dict = {'inline_data': {'data': base64_encoded, 'mime_type': item.media_type}}
+                    inline_data_dict: BlobDict = {'data': item.data, 'mime_type': item.media_type}
+                    part_dict: PartDict = {'inline_data': inline_data_dict}
                     if item.vendor_metadata:
-                        inline_data_dict['video_metadata'] = item.vendor_metadata
-                    content.append(inline_data_dict)  # type: ignore
+                        part_dict['video_metadata'] = cast(VideoMetadataDict, item.vendor_metadata)
+                    content.append(part_dict)
                 elif isinstance(item, VideoUrl) and item.is_youtube:
-                    file_data_dict = {'file_data': {'file_uri': item.url, 'mime_type': item.media_type}}
+                    file_data_dict: FileDataDict = {'file_uri': item.url, 'mime_type': item.media_type}
+                    part_dict: PartDict = {'file_data': file_data_dict}
                     if item.vendor_metadata:  # pragma: no branch
-                        file_data_dict['video_metadata'] = item.vendor_metadata
-                    content.append(file_data_dict)  # type: ignore
+                        part_dict['video_metadata'] = cast(VideoMetadataDict, item.vendor_metadata)
+                    content.append(part_dict)
                 elif isinstance(item, FileUrl):
                     if item.force_download or (
                         # google-gla does not support passing file urls directly, except for youtube videos
@@ -543,13 +546,15 @@ class GoogleModel(Model):
                         self.system == 'google-gla'
                         and not item.url.startswith(r'https://generativelanguage.googleapis.com/v1beta/files')
                     ):
-                        downloaded_item = await download_item(item, data_format='base64')
-                        inline_data = {'data': downloaded_item['data'], 'mime_type': downloaded_item['data_type']}
-                        content.append({'inline_data': inline_data})  # type: ignore
+                        downloaded_item = await download_item(item, data_format='bytes')
+                        inline_data: BlobDict = {
+                            'data': downloaded_item['data'],
+                            'mime_type': downloaded_item['data_type'],
+                        }
+                        content.append({'inline_data': inline_data})
                     else:
-                        content.append(
-                            {'file_data': {'file_uri': item.url, 'mime_type': item.media_type}}
-                        )  # pragma: lax no cover
+                        file_data_dict: FileDataDict = {'file_uri': item.url, 'mime_type': item.media_type}
+                        content.append({'file_data': file_data_dict})  # pragma: lax no cover
                 else:
                     assert_never(item)
         return content
@@ -578,7 +583,9 @@ class GeminiStreamedResponse(StreamedResponse):
         async for chunk in self._response:
             self._usage = _metadata_as_usage(chunk)
 
-            assert chunk.candidates is not None
+            if not chunk.candidates:
+                continue  # pragma: no cover
+
             candidate = chunk.candidates[0]
 
             if chunk.response_id:  # pragma: no branch
@@ -610,7 +617,10 @@ class GeminiStreamedResponse(StreamedResponse):
                 else:  # pragma: no cover
                     raise UnexpectedModelBehavior('Content field missing from streaming Gemini response', str(chunk))
 
-            parts = candidate.content.parts or []
+            parts = candidate.content.parts
+            if not parts:
+                continue  # pragma: no cover
+
             for part in parts:
                 if part.thought_signature:
                     signature = base64.b64encode(part.thought_signature).decode('utf-8')
@@ -822,7 +832,7 @@ def _metadata_as_usage(response: GenerateContentResponse) -> usage.RequestUsage:
         if not metadata_details:
             continue
         for detail in metadata_details:
-            if not detail.modality or not detail.token_count:  # pragma: no cover
+            if not detail.modality or not detail.token_count:
                 continue
             details[f'{detail.modality.lower()}_{prefix}_tokens'] = detail.token_count
             if detail.modality != 'AUDIO':

{pydantic_ai_slim-1.0.9.dist-info → pydantic_ai_slim-1.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.9
+Version: 1.0.10
 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.23
 Requires-Dist: griffe>=1.3.2
 Requires-Dist: httpx>=0.27
 Requires-Dist: opentelemetry-api>=1.28.0
-Requires-Dist: pydantic-graph==1.0.9
+Requires-Dist: pydantic-graph==1.0.10
 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.9; extra == 'evals'
+Requires-Dist: pydantic-evals==1.0.10; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq

{pydantic_ai_slim-1.0.9.dist-info → pydantic_ai_slim-1.0.10.dist-info}/RECORD

@@ -1,7 +1,7 @@
 pydantic_ai/__init__.py,sha256=CfqGPSjKlDl5iw1L48HbELsDuzxIzBFnFnovI_GcFWA,2083
 pydantic_ai/__main__.py,sha256=Q_zJU15DUA01YtlJ2mnaLCoId2YmgmreVEERGuQT-Y0,132
 pydantic_ai/_a2a.py,sha256=2Hopcyl6o6U91eVkd7iAbEPYA5f0hJb8A5_fwMC0UfM,12168
-pydantic_ai/_agent_graph.py,sha256=NAl4C6VPptiSFMSRwWYPEkSu_-NtRdNme-nVzwghrm0,52571
+pydantic_ai/_agent_graph.py,sha256=c5rdUxBcCau2UgumvR_4TBXvpAMeg5wjvOi0sk3YSmo,53217
 pydantic_ai/_cli.py,sha256=n1MX7p-UKH6ZWPNwiGPZTVcXYhXG8OiJIuNMeYX5k2M,14053
 pydantic_ai/_function_schema.py,sha256=olbmUMQoQV5qKV4j0-cOnhcTINz4uYyeDqMyusrFRtY,11234
 pydantic_ai/_griffe.py,sha256=BphvTL00FHxsSY56GM-bNyCOdwrpL0T3LbDQITWUK_Q,5280
@@ -18,9 +18,9 @@ pydantic_ai/ag_ui.py,sha256=X3b4P_IraypCE3r-L2ETIo8G951A1MDdP4P5TQ8Fces,32067
 pydantic_ai/builtin_tools.py,sha256=DUzhHNUtWJPhaPQ7iV4E1jNImBO0DqpSLtA_HuHLaKw,3623
 pydantic_ai/direct.py,sha256=zMsz6poVgEq7t7L_8FWM6hmKdqTzjyQYL5xzQt_59Us,14951
 pydantic_ai/exceptions.py,sha256=zsXZMKf2BJuVsfuHl1fWTkogLU37bd4yq7D6BKHAzVs,4968
-pydantic_ai/format_prompt.py,sha256=37imBG2Fgpn-_RfAFalOX8Xc_XpGH2gY9tnhJDvxfk8,4243
+pydantic_ai/format_prompt.py,sha256=qQ9zv6PJR9D4FTII6gD3_bSOHYymhRYVIxhPMscxeLI,9528
 pydantic_ai/mcp.py,sha256=N1X5zldNeNJmH9EHnccLxXU4Pw7tBCdxFJzzbTOVAnE,34778
-pydantic_ai/messages.py,sha256=f26gyrPeMKIjLpDHgUWOzEZFXJgglGYJVIyeYUE-MXA,57554
+pydantic_ai/messages.py,sha256=I-FlL8Gh3-852ANENoxZs9f3P0OoA9mCt-_0XGOhJbQ,57380
 pydantic_ai/output.py,sha256=wzNgVKJgxyXtSH-uNbRxIaUNLidxlQcwWYT2o1gY2hE,12037
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/result.py,sha256=eoQ6VJPvXVNReRhErOytK3-2tiy9FV6LIwywyh7DSzo,26247
@@ -29,7 +29,7 @@ pydantic_ai/run.py,sha256=wHlWl4CXIHLcgo2R8PlsU3Pjn0vuMLFfP8D6Fbany-Y,15097
 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=HH0bJXzNkpfzv99MMYkHIBy8_ArpETqNF6yugkTjqu8,62542
+pydantic_ai/agent/__init__.py,sha256=Ceckz-CDtBsFo7pMm4LRKKTVOQkPZF-DIwGBbZCxSdQ,62684
 pydantic_ai/agent/abstract.py,sha256=fL2nD5XgLHfmva6t-foBENpLHV_WYTUWLGBKU-l8stM,44622
 pydantic_ai/agent/wrapper.py,sha256=lx0NcM8MX_MoNm0oiPFDH2Cod78N5ONcerKcpJQeJes,9425
 pydantic_ai/common_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -59,7 +59,7 @@ pydantic_ai/models/cohere.py,sha256=uQLynz-zWciZBHuvkm8HxJyTOee1bs3pSka-x-56a98,
 pydantic_ai/models/fallback.py,sha256=XJ74wRxVT4dF0uewHH3is9I-zcLBK8KFIhpK3BB6mRw,5526
 pydantic_ai/models/function.py,sha256=aTaRMul7-pm__uxqoJLa2e3_73eXeq6sRVLdj1BXX88,15518
 pydantic_ai/models/gemini.py,sha256=DYEaOnwGmo9FUGVkRRrydGuQwYhnO-Cq5grTurLWgb4,39376
-pydantic_ai/models/google.py,sha256=jMJEPHnrsdHSFSuhobttQk92jxXu6ykIEfPC4VXA_Gg,39182
+pydantic_ai/models/google.py,sha256=uVGqhjDntgoE1ALQ6DbafarjKiXKdtreR24Xi6pVeyI,39368
 pydantic_ai/models/groq.py,sha256=lQIQHuFhvzoHFubXIcA3B4DohW7DnpGrPcrN6j9yuck,29118
 pydantic_ai/models/huggingface.py,sha256=f1tZObCJkcbiUCwNoPyuiaRaGYuj0GBFmbA8yFd-tHY,21176
 pydantic_ai/models/instrumented.py,sha256=DCnyG7HXgV-W2EWac8oZb2A8PL8yarXeU7Rt97l4w_s,21421
@@ -120,8 +120,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.9.dist-info/METADATA,sha256=vsOF2zsC5Bve4LZynrAVozutKpJFxMpr2E2px588Pgc,4628
-pydantic_ai_slim-1.0.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydantic_ai_slim-1.0.9.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
-pydantic_ai_slim-1.0.9.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
-pydantic_ai_slim-1.0.9.dist-info/RECORD,,
+pydantic_ai_slim-1.0.10.dist-info/METADATA,sha256=tEWF3SrlMgCnCqZ8AQWM4f_ar1e6Atn-PAIg4g2iAT0,4631
+pydantic_ai_slim-1.0.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-1.0.10.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-1.0.10.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-1.0.10.dist-info/RECORD,,