pydantic-ai-slim 1.0.9__py3-none-any.whl → 1.0.11__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/_function_schema.py

@@ -231,31 +231,39 @@ R = TypeVar('R')
 
 WithCtx = Callable[Concatenate[RunContext[Any], P], R]
 WithoutCtx = Callable[P, R]
-TargetFunc = WithCtx[P, R] | WithoutCtx[P, R]
+TargetCallable = WithCtx[P, R] | WithoutCtx[P, R]
 
 
-def _takes_ctx(function: TargetFunc[P, R]) -> TypeIs[WithCtx[P, R]]:
-    """Check if a function takes a `RunContext` first argument.
+def _takes_ctx(callable_obj: TargetCallable[P, R]) -> TypeIs[WithCtx[P, R]]:
+    """Check if a callable takes a `RunContext` first argument.
 
     Args:
-        function: The function to check.
+        callable_obj: The callable to check.
 
     Returns:
-        `True` if the function takes a `RunContext` as first argument, `False` otherwise.
+        `True` if the callable takes a `RunContext` as first argument, `False` otherwise.
     """
     try:
-        sig = signature(function)
-    except ValueError:  # pragma: no cover
-        return False  # pragma: no cover
+        sig = signature(callable_obj)
+    except ValueError:
+        return False
     try:
         first_param_name = next(iter(sig.parameters.keys()))
     except StopIteration:
         return False
     else:
-        type_hints = _typing_extra.get_function_type_hints(function)
+        # See https://github.com/pydantic/pydantic/pull/11451 for a similar implementation in Pydantic
+        if not isinstance(callable_obj, _decorators._function_like):  # pyright: ignore[reportPrivateUsage]
+            call_func = getattr(type(callable_obj), '__call__', None)
+            if call_func is not None:
+                callable_obj = call_func
+            else:
+                return False  # pragma: no cover
+
+        type_hints = _typing_extra.get_function_type_hints(_decorators.unwrap_wrapped_function(callable_obj))
         annotation = type_hints.get(first_param_name)
         if annotation is None:
-            return False  # pragma: no cover
+            return False
         return True is not sig.empty and _is_call_ctx(annotation)
 
 

pydantic_ai/_output.py

@@ -19,6 +19,7 @@ from .output import (
     NativeOutput,
     OutputDataT,
     OutputMode,
+    OutputObjectDefinition,
     OutputSpec,
     OutputTypeOrFunction,
     PromptedOutput,
@@ -581,14 +582,6 @@ class ToolOrTextOutputSchema(ToolOutputSchema[OutputDataT], PlainTextOutputSchem
         return 'tool_or_text'
 
 
-@dataclass
-class OutputObjectDefinition:
-    json_schema: ObjectJsonSchema
-    name: str | None = None
-    description: str | None = None
-    strict: bool | None = None
-
-
 @dataclass(init=False)
 class BaseOutputProcessor(ABC, Generic[OutputDataT]):
     @abstractmethod

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/mcp.py

@@ -540,7 +540,7 @@ class MCPServerStdio(MCPServer):
             f'args={self.args!r}',
         ]
         if self.id:
-            repr_args.append(f'id={self.id!r}')
+            repr_args.append(f'id={self.id!r}')  # pragma: lax no cover
         return f'{self.__class__.__name__}({", ".join(repr_args)})'
 
     def __eq__(self, value: object, /) -> bool:

pydantic_ai/messages.py

@@ -126,6 +126,7 @@ class FileUrl(ABC):
 
     Supported by:
     - `GoogleModel`: `VideoUrl.vendor_metadata` is used as `video_metadata`: https://ai.google.dev/gemini-api/docs/video-understanding#customize-video-processing
+    - `OpenAIChatModel`, `OpenAIResponsesModel`: `ImageUrl.vendor_metadata['detail']` is used as `detail` setting for images
     """
 
     _media_type: Annotated[str | None, pydantic.Field(alias='media_type', default=None, exclude=True)] = field(
@@ -471,6 +472,7 @@ class BinaryContent:
 
     Supported by:
     - `GoogleModel`: `BinaryContent.vendor_metadata` is used as `video_metadata`: https://ai.google.dev/gemini-api/docs/video-understanding#customize-video-processing
+    - `OpenAIChatModel`, `OpenAIResponsesModel`: `BinaryContent.vendor_metadata['detail']` is used as `detail` setting for images
     """
 
     kind: Literal['binary'] = 'binary'
@@ -1161,11 +1163,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/__init__.py

@@ -65,6 +65,8 @@ KnownModelName = TypeAliasType(
         'anthropic:claude-opus-4-20250514',
         'anthropic:claude-sonnet-4-0',
         'anthropic:claude-sonnet-4-20250514',
+        'anthropic:claude-sonnet-4-5',
+        'anthropic:claude-sonnet-4-5-20250929',
         'bedrock:amazon.titan-tg1-large',
         'bedrock:amazon.titan-text-lite-v1',
         'bedrock:amazon.titan-text-express-v1',
@@ -121,23 +123,6 @@ KnownModelName = TypeAliasType(
         'cerebras:qwen-3-32b',
         'cerebras:qwen-3-coder-480b',
         'cerebras:qwen-3-235b-a22b-thinking-2507',
-        'claude-3-5-haiku-20241022',
-        'claude-3-5-haiku-latest',
-        'claude-3-5-sonnet-20240620',
-        'claude-3-5-sonnet-20241022',
-        'claude-3-5-sonnet-latest',
-        'claude-3-7-sonnet-20250219',
-        'claude-3-7-sonnet-latest',
-        'claude-3-haiku-20240307',
-        'claude-3-opus-20240229',
-        'claude-3-opus-latest',
-        'claude-4-opus-20250514',
-        'claude-4-sonnet-20250514',
-        'claude-opus-4-0',
-        'claude-opus-4-1-20250805',
-        'claude-opus-4-20250514',
-        'claude-sonnet-4-0',
-        'claude-sonnet-4-20250514',
         'cohere:c4ai-aya-expanse-32b',
         'cohere:c4ai-aya-expanse-8b',
         'cohere:command',
@@ -163,54 +148,6 @@ KnownModelName = TypeAliasType(
         'google-vertex:gemini-2.5-flash',
         'google-vertex:gemini-2.5-flash-lite',
         'google-vertex:gemini-2.5-pro',
-        'gpt-3.5-turbo',
-        'gpt-3.5-turbo-0125',
-        'gpt-3.5-turbo-0301',
-        'gpt-3.5-turbo-0613',
-        'gpt-3.5-turbo-1106',
-        'gpt-3.5-turbo-16k',
-        'gpt-3.5-turbo-16k-0613',
-        'gpt-4',
-        'gpt-4-0125-preview',
-        'gpt-4-0314',
-        'gpt-4-0613',
-        'gpt-4-1106-preview',
-        'gpt-4-32k',
-        'gpt-4-32k-0314',
-        'gpt-4-32k-0613',
-        'gpt-4-turbo',
-        'gpt-4-turbo-2024-04-09',
-        'gpt-4-turbo-preview',
-        'gpt-4-vision-preview',
-        'gpt-4.1',
-        'gpt-4.1-2025-04-14',
-        'gpt-4.1-mini',
-        'gpt-4.1-mini-2025-04-14',
-        'gpt-4.1-nano',
-        'gpt-4.1-nano-2025-04-14',
-        'gpt-4o',
-        'gpt-4o-2024-05-13',
-        'gpt-4o-2024-08-06',
-        'gpt-4o-2024-11-20',
-        'gpt-4o-audio-preview',
-        'gpt-4o-audio-preview-2024-10-01',
-        'gpt-4o-audio-preview-2024-12-17',
-        'gpt-4o-audio-preview-2025-06-03',
-        'gpt-4o-mini',
-        'gpt-4o-mini-2024-07-18',
-        'gpt-4o-mini-audio-preview',
-        'gpt-4o-mini-audio-preview-2024-12-17',
-        'gpt-4o-mini-search-preview',
-        'gpt-4o-mini-search-preview-2025-03-11',
-        'gpt-4o-search-preview',
-        'gpt-4o-search-preview-2025-03-11',
-        'gpt-5',
-        'gpt-5-2025-08-07',
-        'gpt-5-chat-latest',
-        'gpt-5-mini',
-        'gpt-5-mini-2025-08-07',
-        'gpt-5-nano',
-        'gpt-5-nano-2025-08-07',
         'grok:grok-4',
         'grok:grok-4-0709',
         'grok:grok-3',
@@ -271,22 +208,6 @@ KnownModelName = TypeAliasType(
         'moonshotai:kimi-latest',
         'moonshotai:kimi-thinking-preview',
         'moonshotai:kimi-k2-0711-preview',
-        'o1',
-        'o1-2024-12-17',
-        'o1-mini',
-        'o1-mini-2024-09-12',
-        'o1-preview',
-        'o1-preview-2024-09-12',
-        'o1-pro',
-        'o1-pro-2025-03-19',
-        'o3',
-        'o3-2025-04-16',
-        'o3-deep-research',
-        'o3-deep-research-2025-06-26',
-        'o3-mini',
-        'o3-mini-2025-01-31',
-        'o3-pro',
-        'o3-pro-2025-06-10',
         'openai:chatgpt-4o-latest',
         'openai:codex-mini-latest',
         'openai:gpt-3.5-turbo',

pydantic_ai/models/anthropic.py

@@ -54,7 +54,7 @@ _FINISH_REASON_MAP: dict[BetaStopReason, FinishReason] = {
 
 
 try:
-    from anthropic import NOT_GIVEN, APIStatusError, AsyncStream
+    from anthropic import NOT_GIVEN, APIStatusError, AsyncStream, omit as OMIT
     from anthropic.types.beta import (
         BetaBase64PDFBlockParam,
         BetaBase64PDFSourceParam,
@@ -265,6 +265,10 @@ class AnthropicModel(Model):
         else:
             if not model_request_parameters.allow_text_output:
                 tool_choice = {'type': 'any'}
+                if (thinking := model_settings.get('anthropic_thinking')) and thinking.get('type') == 'enabled':
+                    raise UserError(
+                        'Anthropic does not support thinking and output tools at the same time. Use `output_type=PromptedOutput(...)` instead.'
+                    )
             else:
                 tool_choice = {'type': 'auto'}
 
@@ -281,18 +285,18 @@ class AnthropicModel(Model):
 
             return await self.client.beta.messages.create(
                 max_tokens=model_settings.get('max_tokens', 4096),
-                system=system_prompt or NOT_GIVEN,
+                system=system_prompt or OMIT,
                 messages=anthropic_messages,
                 model=self._model_name,
-                tools=tools or NOT_GIVEN,
-                tool_choice=tool_choice or NOT_GIVEN,
+                tools=tools or OMIT,
+                tool_choice=tool_choice or OMIT,
                 stream=stream,
-                thinking=model_settings.get('anthropic_thinking', NOT_GIVEN),
-                stop_sequences=model_settings.get('stop_sequences', NOT_GIVEN),
-                temperature=model_settings.get('temperature', NOT_GIVEN),
-                top_p=model_settings.get('top_p', NOT_GIVEN),
+                thinking=model_settings.get('anthropic_thinking', OMIT),
+                stop_sequences=model_settings.get('stop_sequences', OMIT),
+                temperature=model_settings.get('temperature', OMIT),
+                top_p=model_settings.get('top_p', OMIT),
                 timeout=model_settings.get('timeout', NOT_GIVEN),
-                metadata=model_settings.get('anthropic_metadata', NOT_GIVEN),
+                metadata=model_settings.get('anthropic_metadata', OMIT),
                 extra_headers=extra_headers,
                 extra_body=model_settings.get('extra_body'),
             )
@@ -759,6 +763,8 @@ def _map_server_tool_use_block(item: BetaServerToolUseBlock, provider_name: str)
             args=cast(dict[str, Any], item.input) or None,
             tool_call_id=item.id,
         )
+    elif item.name in ('web_fetch', 'bash_code_execution', 'text_editor_code_execution'):  # pragma: no cover
+        raise NotImplementedError(f'Anthropic built-in tool {item.name!r} is not currently supported.')
     else:
         assert_never(item.name)
 

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/models/instrumented.py

@@ -9,6 +9,7 @@ from dataclasses import dataclass, field
 from typing import Any, Literal, cast
 from urllib.parse import urlparse
 
+from genai_prices.types import PriceCalculation
 from opentelemetry._events import (
     Event,  # pyright: ignore[reportPrivateImportUsage]
     EventLogger,  # pyright: ignore[reportPrivateImportUsage]
@@ -169,6 +170,11 @@ class InstrumentationSettings:
             self.tokens_histogram = self.meter.create_histogram(
                 **tokens_histogram_kwargs,  # pyright: ignore
             )
+        self.cost_histogram = self.meter.create_histogram(
+            'operation.cost',
+            unit='{USD}',
+            description='Monetary cost',
+        )
 
     def messages_to_otel_events(self, messages: list[ModelMessage]) -> list[Event]:
         """Convert a list of model messages to OpenTelemetry events.
@@ -302,6 +308,21 @@ class InstrumentationSettings:
                 }
             )
 
+    def record_metrics(
+        self,
+        response: ModelResponse,
+        price_calculation: PriceCalculation | None,
+        attributes: dict[str, AttributeValue],
+    ):
+        for typ in ['input', 'output']:
+            if not (tokens := getattr(response.usage, f'{typ}_tokens', 0)):  # pragma: no cover
+                continue
+            token_attributes = {**attributes, 'gen_ai.token.type': typ}
+            self.tokens_histogram.record(tokens, token_attributes)
+            if price_calculation:
+                cost = float(getattr(price_calculation, f'{typ}_price'))
+                self.cost_histogram.record(cost, token_attributes)
+
 
 GEN_AI_SYSTEM_ATTRIBUTE = 'gen_ai.system'
 GEN_AI_REQUEST_MODEL_ATTRIBUTE = 'gen_ai.request.model'
@@ -395,6 +416,7 @@ class InstrumentedModel(WrapperModel):
                     system = cast(str, attributes[GEN_AI_SYSTEM_ATTRIBUTE])
 
                     response_model = response.model_name or request_model
+                    price_calculation = None
 
                     def _record_metrics():
                         metric_attributes = {
@@ -403,16 +425,7 @@ class InstrumentedModel(WrapperModel):
                             'gen_ai.request.model': request_model,
                             'gen_ai.response.model': response_model,
                         }
-                        if response.usage.input_tokens:  # pragma: no branch
-                            self.instrumentation_settings.tokens_histogram.record(
-                                response.usage.input_tokens,
-                                {**metric_attributes, 'gen_ai.token.type': 'input'},
-                            )
-                        if response.usage.output_tokens:  # pragma: no branch
-                            self.instrumentation_settings.tokens_histogram.record(
-                                response.usage.output_tokens,
-                                {**metric_attributes, 'gen_ai.token.type': 'output'},
-                            )
+                        self.instrumentation_settings.record_metrics(response, price_calculation, metric_attributes)
 
                     nonlocal record_metrics
                     record_metrics = _record_metrics
@@ -427,7 +440,7 @@ class InstrumentedModel(WrapperModel):
                         'gen_ai.response.model': response_model,
                     }
                     try:
-                        attributes_to_set['operation.cost'] = float(response.cost().total_price)
+                        price_calculation = response.cost()
                     except LookupError:
                         # The cost of this provider/model is unknown, which is common.
                         pass
@@ -435,6 +448,9 @@ class InstrumentedModel(WrapperModel):
                         warnings.warn(
                             f'Failed to get cost from response: {type(e).__name__}: {e}', CostCalculationFailedWarning
                         )
+                    else:
+                        attributes_to_set['operation.cost'] = float(price_calculation.total_price)
+
                     if response.provider_response_id is not None:
                         attributes_to_set['gen_ai.response.id'] = response.provider_response_id
                     if response.finish_reason is not None:

pydantic_ai/models/openai.py

@@ -526,16 +526,20 @@ class OpenAIChatModel(Model):
 
         choice = response.choices[0]
         items: list[ModelResponsePart] = []
+
         # The `reasoning_content` field is only present in DeepSeek models.
         # https://api-docs.deepseek.com/guides/reasoning_model
         if reasoning_content := getattr(choice.message, 'reasoning_content', None):
             items.append(ThinkingPart(id='reasoning_content', content=reasoning_content, provider_name=self.system))
 
-        # NOTE: We don't currently handle OpenRouter `reasoning_details`:
-        # - https://openrouter.ai/docs/use-cases/reasoning-tokens#preserving-reasoning-blocks
-        # NOTE: We don't currently handle OpenRouter/gpt-oss `reasoning`:
+        # The `reasoning` field is only present in gpt-oss via Ollama and OpenRouter.
         # - https://cookbook.openai.com/articles/gpt-oss/handle-raw-cot#chat-completions-api
         # - https://openrouter.ai/docs/use-cases/reasoning-tokens#basic-usage-with-reasoning-tokens
+        if reasoning := getattr(choice.message, 'reasoning', None):
+            items.append(ThinkingPart(id='reasoning', content=reasoning, provider_name=self.system))
+
+        # NOTE: We don't currently handle OpenRouter `reasoning_details`:
+        # - https://openrouter.ai/docs/use-cases/reasoning-tokens#preserving-reasoning-blocks
         # If you need this, please file an issue.
 
         vendor_details: dict[str, Any] = {}
@@ -753,12 +757,16 @@ class OpenAIChatModel(Model):
                 if isinstance(item, str):
                     content.append(ChatCompletionContentPartTextParam(text=item, type='text'))
                 elif isinstance(item, ImageUrl):
-                    image_url = ImageURL(url=item.url)
+                    image_url: ImageURL = {'url': item.url}
+                    if metadata := item.vendor_metadata:
+                        image_url['detail'] = metadata.get('detail', 'auto')
                     content.append(ChatCompletionContentPartImageParam(image_url=image_url, type='image_url'))
                 elif isinstance(item, BinaryContent):
                     base64_encoded = base64.b64encode(item.data).decode('utf-8')
                     if item.is_image:
-                        image_url = ImageURL(url=f'data:{item.media_type};base64,{base64_encoded}')
+                        image_url: ImageURL = {'url': f'data:{item.media_type};base64,{base64_encoded}'}
+                        if metadata := item.vendor_metadata:
+                            image_url['detail'] = metadata.get('detail', 'auto')
                         content.append(ChatCompletionContentPartImageParam(image_url=image_url, type='image_url'))
                     elif item.is_audio:
                         assert item.format in ('wav', 'mp3')
@@ -1383,11 +1391,17 @@ class OpenAIResponsesModel(Model):
                 elif isinstance(item, BinaryContent):
                     base64_encoded = base64.b64encode(item.data).decode('utf-8')
                     if item.is_image:
+                        detail: Literal['auto', 'low', 'high'] = 'auto'
+                        if metadata := item.vendor_metadata:
+                            detail = cast(
+                                Literal['auto', 'low', 'high'],
+                                metadata.get('detail', 'auto'),
+                            )
                         content.append(
                             responses.ResponseInputImageParam(
                                 image_url=f'data:{item.media_type};base64,{base64_encoded}',
                                 type='input_image',
-                                detail='auto',
+                                detail=detail,
                             )
                         )
                     elif item.is_document:
@@ -1406,8 +1420,15 @@ class OpenAIResponsesModel(Model):
                     else:  # pragma: no cover
                         raise RuntimeError(f'Unsupported binary content type: {item.media_type}')
                 elif isinstance(item, ImageUrl):
+                    detail: Literal['auto', 'low', 'high'] = 'auto'
+                    if metadata := item.vendor_metadata:
+                        detail = cast(Literal['auto', 'low', 'high'], metadata.get('detail', 'auto'))
                     content.append(
-                        responses.ResponseInputImageParam(image_url=item.url, type='input_image', detail='auto')
+                        responses.ResponseInputImageParam(
+                            image_url=item.url,
+                            type='input_image',
+                            detail=detail,
+                        )
                     )
                 elif isinstance(item, AudioUrl):  # pragma: no cover
                     downloaded_item = await download_item(item, data_format='base64_uri', type_format='extension')
@@ -1492,6 +1513,17 @@ class OpenAIStreamedResponse(StreamedResponse):
                     provider_name=self.provider_name,
                 )
 
+            # The `reasoning` field is only present in gpt-oss via Ollama and OpenRouter.
+            # - https://cookbook.openai.com/articles/gpt-oss/handle-raw-cot#chat-completions-api
+            # - https://openrouter.ai/docs/use-cases/reasoning-tokens#basic-usage-with-reasoning-tokens
+            if reasoning := getattr(choice.delta, 'reasoning', None):  # pragma: no cover
+                yield self._parts_manager.handle_thinking_delta(
+                    vendor_part_id='reasoning',
+                    id='reasoning',
+                    content=reasoning,
+                    provider_name=self.provider_name,
+                )
+
             for dtc in choice.delta.tool_calls or []:
                 maybe_event = self._parts_manager.handle_tool_call_delta(
                     vendor_part_id=dtc.index,

pydantic_ai/output.py

@@ -11,7 +11,7 @@ from typing_extensions import TypeAliasType, TypeVar, deprecated
 
 from . import _utils
 from .messages import ToolCallPart
-from .tools import DeferredToolRequests, RunContext, ToolDefinition
+from .tools import DeferredToolRequests, ObjectJsonSchema, RunContext, ToolDefinition
 
 __all__ = (
     # classes
@@ -20,6 +20,7 @@ __all__ = (
     'PromptedOutput',
     'TextOutput',
     'StructuredDict',
+    'OutputObjectDefinition',
     # types
     'OutputDataT',
     'OutputMode',
@@ -242,6 +243,16 @@ class PromptedOutput(Generic[OutputDataT]):
         self.template = template
 
 
+@dataclass
+class OutputObjectDefinition:
+    """Definition of an output object used for structured output generation."""
+
+    json_schema: ObjectJsonSchema
+    name: str | None = None
+    description: str | None = None
+    strict: bool | None = None
+
+
 @dataclass
 class TextOutput(Generic[OutputDataT]):
     """Marker class to use text output for an output function taking a string argument.

pydantic_ai/profiles/harmony.py

@@ -10,4 +10,6 @@ def harmony_model_profile(model_name: str) -> ModelProfile | None:
     See <https://cookbook.openai.com/articles/openai-harmony> for more details.
     """
     profile = openai_model_profile(model_name)
-    return OpenAIModelProfile(openai_supports_tool_choice_required=False).update(profile)
+    return OpenAIModelProfile(
+        openai_supports_tool_choice_required=False, ignore_streamed_leading_whitespace=True
+    ).update(profile)

pydantic_ai/providers/ollama.py

@@ -11,6 +11,7 @@ from pydantic_ai.profiles import ModelProfile
 from pydantic_ai.profiles.cohere import cohere_model_profile
 from pydantic_ai.profiles.deepseek import deepseek_model_profile
 from pydantic_ai.profiles.google import google_model_profile
+from pydantic_ai.profiles.harmony import harmony_model_profile
 from pydantic_ai.profiles.meta import meta_model_profile
 from pydantic_ai.profiles.mistral import mistral_model_profile
 from pydantic_ai.profiles.openai import OpenAIJsonSchemaTransformer, OpenAIModelProfile
@@ -50,6 +51,7 @@ class OllamaProvider(Provider[AsyncOpenAI]):
             'deepseek': deepseek_model_profile,
             'mistral': mistral_model_profile,
             'command': cohere_model_profile,
+            'gpt-oss': harmony_model_profile,
         }
 
         profile = None

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.9
+Version: 1.0.11
 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.23
+Requires-Dist: genai-prices>=0.0.28
 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.11
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -42,7 +42,7 @@ Provides-Extra: ag-ui
 Requires-Dist: ag-ui-protocol>=0.1.8; extra == 'ag-ui'
 Requires-Dist: starlette>=0.45.3; extra == 'ag-ui'
 Provides-Extra: anthropic
-Requires-Dist: anthropic>=0.61.0; extra == 'anthropic'
+Requires-Dist: anthropic>=0.69.0; extra == 'anthropic'
 Provides-Extra: bedrock
 Requires-Dist: boto3>=1.39.0; extra == 'bedrock'
 Provides-Extra: cli
@@ -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.11; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq
@@ -77,7 +77,7 @@ Requires-Dist: tenacity>=8.2.3; extra == 'retries'
 Provides-Extra: tavily
 Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: temporal
-Requires-Dist: temporalio==1.17.0; extra == 'temporal'
+Requires-Dist: temporalio==1.18.0; extra == 'temporal'
 Provides-Extra: vertexai
 Requires-Dist: google-auth>=2.36.0; extra == 'vertexai'
 Requires-Dist: requests>=2.32.2; extra == 'vertexai'

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

@@ -1,13 +1,13 @@
 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/_function_schema.py,sha256=UnDGh7Wh5z70pEaRujXF_hKsSibQdN2ywI6lZGz3LUo,11663
 pydantic_ai/_griffe.py,sha256=BphvTL00FHxsSY56GM-bNyCOdwrpL0T3LbDQITWUK_Q,5280
 pydantic_ai/_mcp.py,sha256=PuvwnlLjv7YYOa9AZJCrklevBug99zGMhwJCBGG7BHQ,5626
 pydantic_ai/_otel_messages.py,sha256=SsMpbyI1fIISOck_wQcZJPIOei8lOmvwARkdPSCx8y8,1650
-pydantic_ai/_output.py,sha256=phJ9AQYUlhQhAVikL0FpPn_Vm05V_yK3VYmCUUtH778,38296
+pydantic_ai/_output.py,sha256=e6KBPnzOcYj13XmMaWOH6Xm1vxVG97U1ljuwuVRQaY8,38153
 pydantic_ai/_parts_manager.py,sha256=QRfZTk21tCO6jEu8hF0qZLEsyUzvu0C6-qkiFhnbqxI,21443
 pydantic_ai/_run_context.py,sha256=142KI0Sy5uMox4VMBkkIgkBl4uCwZvI9HcXJKdnsWBU,2108
 pydantic_ai/_system_prompt.py,sha256=WdDW_DTGHujcFFaK-J7J6mA4ZDJZ0IOKpyizJA-1Y5Q,1142
@@ -18,10 +18,10 @@ 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/mcp.py,sha256=N1X5zldNeNJmH9EHnccLxXU4Pw7tBCdxFJzzbTOVAnE,34778
-pydantic_ai/messages.py,sha256=f26gyrPeMKIjLpDHgUWOzEZFXJgglGYJVIyeYUE-MXA,57554
-pydantic_ai/output.py,sha256=wzNgVKJgxyXtSH-uNbRxIaUNLidxlQcwWYT2o1gY2hE,12037
+pydantic_ai/format_prompt.py,sha256=qQ9zv6PJR9D4FTII6gD3_bSOHYymhRYVIxhPMscxeLI,9528
+pydantic_ai/mcp.py,sha256=VBqPgW-Mr3QQ1gt-sY3IWeP6_XApl5NfCrJs4OL8WEI,34802
+pydantic_ai/messages.py,sha256=-t5sbnQVEGeo0e-mTxNdV8wLNtFQvSlHgcpKyza05Uk,57635
+pydantic_ai/output.py,sha256=esyNK-56j_r7dUiPyzsvWtPppX2N9fbboNq-1x5CQaQ,12337
 pydantic_ai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/result.py,sha256=eoQ6VJPvXVNReRhErOytK3-2tiy9FV6LIwywyh7DSzo,26247
 pydantic_ai/retries.py,sha256=QM4oDA9DG-Y2qP06fbCp8Dqq8ups40Rr4HYjAOlbNyM,14650
@@ -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
@@ -52,20 +52,20 @@ pydantic_ai/durable_exec/temporal/_toolset.py,sha256=bnMbmR8JmBjBeWGaAMtgWP9Kb93
 pydantic_ai/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pydantic_ai/ext/aci.py,sha256=sUllKDNO-LOMurbFgxwRHuzNlBkSa3aVBqXfEm-A_vo,2545
 pydantic_ai/ext/langchain.py,sha256=iLVEZv1kcLkdIHo3us2yfdi0kVqyJ6qTaCt9BoLWm4k,2335
-pydantic_ai/models/__init__.py,sha256=TwCSdRVEfNK2M241tMoczcZzkHjnPs0xNIy6AwxijYs,36379
-pydantic_ai/models/anthropic.py,sha256=yhIg2LfFYqsvwfIgGQ9T4Fy_gCqElyB2SI1Ja4P9FVE,36546
+pydantic_ai/models/__init__.py,sha256=ooszfzxleH1MMY47N7P8CVVO7Saf4TtgNm7HVuni4mQ,34038
+pydantic_ai/models/anthropic.py,sha256=GWrx7xa6FcgmjhDyTFH27kQPwOi2Nf8eykv0lC7sdVA,37050
 pydantic_ai/models/bedrock.py,sha256=wHo65QNEsfsb1UaUv_TpvJ0WrgFoKoegB6I3eDVnORI,33393
 pydantic_ai/models/cohere.py,sha256=uQLynz-zWciZBHuvkm8HxJyTOee1bs3pSka-x-56a98,13668
 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
+pydantic_ai/models/instrumented.py,sha256=4GXBNLjzs7s9kjcN_d4S3Wn3IgotNhIpCntAqF1Rrts,21863
 pydantic_ai/models/mcp_sampling.py,sha256=qnLCO3CB5bNQ86SpWRA-CSSOVcCCLPwjHtcNFvW9wHs,3461
 pydantic_ai/models/mistral.py,sha256=ru8EHwFS0xZBN6s1tlssUdjxjQyjB9L_8kFH7qq5U_g,33654
-pydantic_ai/models/openai.py,sha256=JTYxqvG7YQmEJzPrxSwBVOMqDxUbEKUN4oqiUBqK4Gc,87796
+pydantic_ai/models/openai.py,sha256=cKPe53DhB2ci_JkJleI-n-WemAuBJr_UNUMIKlzO6w4,89579
 pydantic_ai/models/test.py,sha256=1kBwi7pSUt9_K1U-hokOilplxJWPQ3KRKH_s8bYmt_s,19969
 pydantic_ai/models/wrapper.py,sha256=9MeHW7mXPsEK03IKL0rtjeX6QgXyZROOOzLh72GiX2k,2148
 pydantic_ai/profiles/__init__.py,sha256=V6uGAVJuIaYRuZOQjkdIyFfDKD5py18RC98njnHOFug,3293
@@ -77,7 +77,7 @@ pydantic_ai/profiles/deepseek.py,sha256=JDwfkr-0YovlB3jEKk7dNFvepxNf_YuLgLkGCtyX
 pydantic_ai/profiles/google.py,sha256=cd5zwtx0MU1Xwm8c-oqi2_OJ2-PMJ8Vy23mxvSJF7ik,4856
 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=_81tOGOYGTH3Za67jjtdINvASTTM5_CTyc1Ej2KHJQw,500
+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
@@ -103,7 +103,7 @@ pydantic_ai/providers/huggingface.py,sha256=_Bvi2qdbOB8E9mhiJX3fVoUDZWPCTduCFASZ
 pydantic_ai/providers/litellm.py,sha256=3hTCjHWRG_1c4S9JSNm0BDBDi4q6BVVZ3OLSXhTndNM,5079
 pydantic_ai/providers/mistral.py,sha256=pHcWHb2Wf9ZcqQl_Lp84ZvepO0Hmyb1CiqCTbur9S-s,3083
 pydantic_ai/providers/moonshotai.py,sha256=LwasmxCZCPkq1pb1uDtZTEb_nE55bAtX3QXgLmuNlHE,3260
-pydantic_ai/providers/ollama.py,sha256=_bxons0p8g0RSPNV8iq3AScVS1ym27QTW4zhDqSakgY,4633
+pydantic_ai/providers/ollama.py,sha256=wSwB2eh2F5oUwHhdvvN3tZkzc1I8siojKl5NI27M6AI,4742
 pydantic_ai/providers/openai.py,sha256=SKRsYRUW_zu24iKAM7KJ-6j8GQDIjjxll4AWY1uB3Vs,3410
 pydantic_ai/providers/openrouter.py,sha256=PXGgHPtlQQHKFaSnmiswWZ3dTvmT9PAg-NvfRYGjrPw,4154
 pydantic_ai/providers/together.py,sha256=Dln_NgCul1XVOQtNaYvqWrNjOWj9XzA8n4NwNMKkbLk,3450
@@ -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.11.dist-info/METADATA,sha256=DTxapfIdQXo-SYga_J5A8841fU5NK-7eDfwF4BQhLsU,4631
+pydantic_ai_slim-1.0.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydantic_ai_slim-1.0.11.dist-info/entry_points.txt,sha256=kbKxe2VtDCYS06hsI7P3uZGxcVC08-FPt1rxeiMpIps,50
+pydantic_ai_slim-1.0.11.dist-info/licenses/LICENSE,sha256=vA6Jc482lEyBBuGUfD1pYx-cM7jxvLYOxPidZ30t_PQ,1100
+pydantic_ai_slim-1.0.11.dist-info/RECORD,,