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

pydantic_ai/models/openai.py

@@ -9,6 +9,7 @@ from datetime import datetime
 from typing import Any, Literal, cast, overload
 
 from pydantic import ValidationError
+from pydantic_core import to_json
 from typing_extensions import assert_never, deprecated
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
@@ -195,7 +196,7 @@ class OpenAIResponsesModelSettings(OpenAIChatModelSettings, total=False):
     """
 
     openai_send_reasoning_ids: bool
-    """Whether to send reasoning IDs from the message history to the model. Enabled by default.
+    """Whether to send the unique IDs of reasoning, text, and function call parts from the message history to the model. Enabled by default for reasoning models.
 
     This can result in errors like `"Item 'rs_123' of type 'reasoning' was provided without its required following item."`
     if the message history you're sending does not match exactly what was received from the Responses API in a previous response,
@@ -233,6 +234,18 @@ class OpenAIResponsesModelSettings(OpenAIChatModelSettings, total=False):
     for more information.
     """
 
+    openai_include_code_execution_outputs: bool
+    """Whether to include the code execution results in the response.
+
+    Corresponds to the `code_interpreter_call.outputs` value of the `include` parameter in the Responses API.
+    """
+
+    openai_include_web_search_sources: bool
+    """Whether to include the web search results in the response.
+
+    Corresponds to the `web_search_call.action.sources` value of the `include` parameter in the Responses API.
+    """
+
 
 @dataclass(init=False)
 class OpenAIChatModel(Model):
@@ -586,9 +599,13 @@ class OpenAIChatModel(Model):
                 'Streamed response ended without content or tool calls'
             )
 
+        # When using Azure OpenAI and a content filter is enabled, the first chunk will contain a `''` model name,
+        # so we set it from a later chunk in `OpenAIChatStreamedResponse`.
+        model_name = first_chunk.model or self._model_name
+
         return OpenAIStreamedResponse(
             model_request_parameters=model_request_parameters,
-            _model_name=first_chunk.model,
+            _model_name=model_name,
             _model_profile=self.profile,
             _response=peekable_response,
             _timestamp=number_to_datetime(first_chunk.created),
@@ -872,7 +889,7 @@ class OpenAIResponsesModel(Model):
         async with response:
             yield await self._process_streamed_response(response, model_request_parameters)
 
-    def _process_response(self, response: responses.Response) -> ModelResponse:
+    def _process_response(self, response: responses.Response) -> ModelResponse:  # noqa: C901
         """Process a non-streamed response, and prepare a message to return."""
         timestamp = number_to_datetime(response.created_at)
         items: list[ModelResponsePart] = []
@@ -911,6 +928,37 @@ class OpenAIResponsesModel(Model):
                 items.append(
                     ToolCallPart(item.name, item.arguments, tool_call_id=_combine_tool_call_ids(item.call_id, item.id))
                 )
+            elif isinstance(item, responses.ResponseCodeInterpreterToolCall):
+                call_part, return_part = _map_code_interpreter_tool_call(item, self.system)
+                items.append(call_part)
+                items.append(return_part)
+            elif isinstance(item, responses.ResponseFunctionWebSearch):
+                call_part, return_part = _map_web_search_tool_call(item, self.system)
+                items.append(call_part)
+                items.append(return_part)
+            elif isinstance(item, responses.ResponseComputerToolCall):  # pragma: no cover
+                # Pydantic AI doesn't yet support the ComputerUse built-in tool
+                pass
+            elif isinstance(item, responses.response_output_item.ImageGenerationCall):  # pragma: no cover
+                # Pydantic AI doesn't yet support the ImageGeneration built-in tool
+                pass
+            elif isinstance(item, responses.ResponseCustomToolCall):  # pragma: no cover
+                # Support is being implemented in https://github.com/pydantic/pydantic-ai/pull/2572
+                pass
+            elif isinstance(item, responses.response_output_item.LocalShellCall):  # pragma: no cover
+                # Pydantic AI doesn't yet support the `codex-mini-latest` LocalShell built-in tool
+                pass
+            elif isinstance(item, responses.ResponseFileSearchToolCall):  # pragma: no cover
+                # Pydantic AI doesn't yet support the FileSearch built-in tool
+                pass
+            elif isinstance(  # pragma: no cover
+                item,
+                responses.response_output_item.McpCall
+                | responses.response_output_item.McpListTools
+                | responses.response_output_item.McpApprovalRequest,
+            ):
+                # Pydantic AI supports MCP natively
+                pass
 
         finish_reason: FinishReason | None = None
         provider_details: dict[str, Any] | None = None
@@ -1021,9 +1069,13 @@ class OpenAIResponsesModel(Model):
         for setting in unsupported_model_settings:
             model_settings.pop(setting, None)
 
-        include: list[responses.ResponseIncludable] | None = None
+        include: list[responses.ResponseIncludable] = []
         if profile.openai_supports_encrypted_reasoning_content:
-            include = ['reasoning.encrypted_content']
+            include.append('reasoning.encrypted_content')
+        if model_settings.get('openai_include_code_execution_outputs'):
+            include.append('code_interpreter_call.outputs')
+        if model_settings.get('openai_include_web_search_sources'):
+            include.append('web_search_call.action.sources')  # pyright: ignore[reportArgumentType]
 
         try:
             extra_headers = model_settings.get('extra_headers', {})
@@ -1082,7 +1134,7 @@ class OpenAIResponsesModel(Model):
         for tool in model_request_parameters.builtin_tools:
             if isinstance(tool, WebSearchTool):
                 web_search_tool = responses.WebSearchToolParam(
-                    type='web_search_preview', search_context_size=tool.search_context_size
+                    type='web_search', search_context_size=tool.search_context_size
                 )
                 if tool.user_location:
                     web_search_tool['user_location'] = responses.web_search_tool_param.UserLocation(
@@ -1134,6 +1186,11 @@ class OpenAIResponsesModel(Model):
         self, messages: list[ModelMessage], model_settings: OpenAIResponsesModelSettings
     ) -> tuple[str | NotGiven, list[responses.ResponseInputItemParam]]:
         """Just maps a `pydantic_ai.Message` to a `openai.types.responses.ResponseInputParam`."""
+        profile = OpenAIModelProfile.from_profile(self.profile)
+        send_item_ids = model_settings.get(
+            'openai_send_reasoning_ids', profile.openai_supports_encrypted_reasoning_content
+        )
+
         openai_messages: list[responses.ResponseInputItemParam] = []
         for message in messages:
             if isinstance(message, ModelRequest):
@@ -1169,15 +1226,19 @@ class OpenAIResponsesModel(Model):
                     else:
                         assert_never(part)
             elif isinstance(message, ModelResponse):
+                send_item_ids = send_item_ids and message.provider_name == self.system
+
                 message_item: responses.ResponseOutputMessageParam | None = None
                 reasoning_item: responses.ResponseReasoningItemParam | None = None
+                web_search_item: responses.ResponseFunctionWebSearchParam | None = None
+                code_interpreter_item: responses.ResponseCodeInterpreterToolCallParam | None = None
                 for item in message.parts:
                     if isinstance(item, TextPart):
-                        if item.id and message.provider_name == self.system:
+                        if item.id and send_item_ids:
                             if message_item is None or message_item['id'] != item.id:  # pragma: no branch
                                 message_item = responses.ResponseOutputMessageParam(
                                     role='assistant',
-                                    id=item.id or _utils.generate_tool_call_id(),
+                                    id=item.id,
                                     content=[],
                                     type='message',
                                     status='completed',
@@ -1195,23 +1256,73 @@ class OpenAIResponsesModel(Model):
                                 responses.EasyInputMessageParam(role='assistant', content=item.content)
                             )
                     elif isinstance(item, ToolCallPart):
-                        openai_messages.append(self._map_tool_call(item))
-                    elif isinstance(item, BuiltinToolCallPart | BuiltinToolReturnPart):
-                        # We don't currently track built-in tool calls from OpenAI
-                        pass
+                        call_id = _guard_tool_call_id(t=item)
+                        call_id, id = _split_combined_tool_call_id(call_id)
+
+                        param = responses.ResponseFunctionToolCallParam(
+                            name=item.tool_name,
+                            arguments=item.args_as_json_str(),
+                            call_id=call_id,
+                            type='function_call',
+                        )
+                        if id and send_item_ids:  # pragma: no branch
+                            param['id'] = id
+                        openai_messages.append(param)
+                    elif isinstance(item, BuiltinToolCallPart):
+                        if item.provider_name == self.system:
+                            if (
+                                item.tool_name == CodeExecutionTool.kind
+                                and item.tool_call_id
+                                and (args := item.args_as_dict())
+                                and (container_id := args.get('container_id'))
+                            ):
+                                code_interpreter_item = responses.ResponseCodeInterpreterToolCallParam(
+                                    id=item.tool_call_id,
+                                    code=args.get('code'),
+                                    container_id=container_id,
+                                    outputs=None,
+                                    status='completed',
+                                    type='code_interpreter_call',
+                                )
+                                openai_messages.append(code_interpreter_item)
+                            elif (
+                                item.tool_name == WebSearchTool.kind
+                                and item.tool_call_id
+                                and (args := item.args_as_dict())
+                            ):  # pragma: no branch
+                                web_search_item = responses.ResponseFunctionWebSearchParam(
+                                    id=item.tool_call_id,
+                                    action=cast(responses.response_function_web_search_param.Action, args),
+                                    status='completed',
+                                    type='web_search_call',
+                                )
+                                openai_messages.append(web_search_item)
+                    elif isinstance(item, BuiltinToolReturnPart):
+                        if item.provider_name == self.system:
+                            if (
+                                item.tool_name == CodeExecutionTool.kind
+                                and code_interpreter_item is not None
+                                and isinstance(item.content, dict)
+                                and (content := cast(dict[str, Any], item.content))  # pyright: ignore[reportUnknownMemberType]
+                                and (status := content.get('status'))
+                            ):
+                                code_interpreter_item['outputs'] = content.get('outputs')
+                                code_interpreter_item['status'] = status
+                            elif (
+                                item.tool_name == WebSearchTool.kind
+                                and web_search_item is not None
+                                and isinstance(item.content, dict)  # pyright: ignore[reportUnknownMemberType]
+                                and (content := cast(dict[str, Any], item.content))  # pyright: ignore[reportUnknownMemberType]
+                                and (status := content.get('status'))
+                            ):  # pragma: no branch
+                                web_search_item['status'] = status
                     elif isinstance(item, ThinkingPart):
-                        if (
-                            item.id
-                            and message.provider_name == self.system
-                            and model_settings.get('openai_send_reasoning_ids', True)
-                        ):
+                        if item.id and send_item_ids:
                             signature: str | None = None
                             if (
                                 item.signature
                                 and item.provider_name == self.system
-                                and OpenAIModelProfile.from_profile(
-                                    self.profile
-                                ).openai_supports_encrypted_reasoning_content
+                                and profile.openai_supports_encrypted_reasoning_content
                             ):
                                 signature = item.signature
 
@@ -1234,7 +1345,7 @@ class OpenAIResponsesModel(Model):
                                     Summary(text=item.content, type='summary_text'),
                                 ]
                         else:
-                            start_tag, end_tag = self.profile.thinking_tags
+                            start_tag, end_tag = profile.thinking_tags
                             openai_messages.append(
                                 responses.EasyInputMessageParam(
                                     role='assistant', content='\n'.join([start_tag, item.content, end_tag])
@@ -1247,21 +1358,6 @@ class OpenAIResponsesModel(Model):
         instructions = self._get_instructions(messages) or NOT_GIVEN
         return instructions, openai_messages
 
-    @staticmethod
-    def _map_tool_call(t: ToolCallPart) -> responses.ResponseFunctionToolCallParam:
-        call_id = _guard_tool_call_id(t=t)
-        call_id, id = _split_combined_tool_call_id(call_id)
-
-        param = responses.ResponseFunctionToolCallParam(
-            name=t.tool_name,
-            arguments=t.args_as_json_str(),
-            call_id=call_id,
-            type='function_call',
-        )
-        if id:  # pragma: no branch
-            param['id'] = id
-        return param
-
     def _map_json_schema(self, o: OutputObjectDefinition) -> responses.ResponseFormatTextJSONSchemaConfigParam:
         response_format_param: responses.ResponseFormatTextJSONSchemaConfigParam = {
             'type': 'json_schema',
@@ -1352,9 +1448,12 @@ class OpenAIStreamedResponse(StreamedResponse):
         async for chunk in self._response:
             self._usage += _map_usage(chunk)
 
-            if chunk.id and self.provider_response_id is None:
+            if chunk.id:  # pragma: no branch
                 self.provider_response_id = chunk.id
 
+            if chunk.model:
+                self._model_name = chunk.model
+
             try:
                 choice = chunk.choices[0]
             except IndexError:
@@ -1457,9 +1556,7 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
             elif isinstance(chunk, responses.ResponseFunctionCallArgumentsDeltaEvent):
                 maybe_event = self._parts_manager.handle_tool_call_delta(
                     vendor_part_id=chunk.item_id,
-                    tool_name=None,
                     args=chunk.delta,
-                    tool_call_id=None,
                 )
                 if maybe_event is not None:  # pragma: no branch
                     yield maybe_event
@@ -1486,7 +1583,27 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
                 elif isinstance(chunk.item, responses.ResponseOutputMessage):
                     pass
                 elif isinstance(chunk.item, responses.ResponseFunctionWebSearch):
-                    pass
+                    call_part, _ = _map_web_search_tool_call(chunk.item, self.provider_name)
+                    yield self._parts_manager.handle_builtin_tool_call_part(
+                        vendor_part_id=f'{chunk.item.id}-call', part=replace(call_part, args=None)
+                    )
+                elif isinstance(chunk.item, responses.ResponseCodeInterpreterToolCall):
+                    call_part, _ = _map_code_interpreter_tool_call(chunk.item, self.provider_name)
+
+                    args_json = call_part.args_as_json_str()
+                    # Drop the final `"}` so that we can add code deltas
+                    args_json_delta = args_json[:-2]
+                    assert args_json_delta.endswith('code":"')
+
+                    yield self._parts_manager.handle_builtin_tool_call_part(
+                        vendor_part_id=f'{chunk.item.id}-call', part=replace(call_part, args=None)
+                    )
+                    maybe_event = self._parts_manager.handle_tool_call_delta(
+                        vendor_part_id=f'{chunk.item.id}-call',
+                        args=args_json_delta,
+                    )
+                    if maybe_event is not None:  # pragma: no branch
+                        yield maybe_event
                 else:
                     warnings.warn(  # pragma: no cover
                         f'Handling of this item type is not yet implemented. Please report on our GitHub: {chunk}',
@@ -1503,6 +1620,24 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
                             signature=signature,
                             provider_name=self.provider_name,
                         )
+                elif isinstance(chunk.item, responses.ResponseCodeInterpreterToolCall):
+                    _, return_part = _map_code_interpreter_tool_call(chunk.item, self.provider_name)
+                    yield self._parts_manager.handle_builtin_tool_return_part(
+                        vendor_part_id=f'{chunk.item.id}-return', part=return_part
+                    )
+                elif isinstance(chunk.item, responses.ResponseFunctionWebSearch):
+                    call_part, return_part = _map_web_search_tool_call(chunk.item, self.provider_name)
+
+                    maybe_event = self._parts_manager.handle_tool_call_delta(
+                        vendor_part_id=f'{chunk.item.id}-call',
+                        args=call_part.args,
+                    )
+                    if maybe_event is not None:  # pragma: no branch
+                        yield maybe_event
+
+                    yield self._parts_manager.handle_builtin_tool_return_part(
+                        vendor_part_id=f'{chunk.item.id}-return', part=return_part
+                    )
 
             elif isinstance(chunk, responses.ResponseReasoningSummaryPartAddedEvent):
                 yield self._parts_manager.handle_thinking_delta(
@@ -1525,7 +1660,7 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
                 )
 
             # TODO(Marcelo): We should support annotations in the future.
-            elif isinstance(chunk, responses.ResponseOutputTextAnnotationAddedEvent):
+            elif isinstance(chunk, responses.ResponseOutputTextAnnotationAddedEvent):  # pragma: no cover
                 pass  # there's nothing we need to do here
 
             elif isinstance(chunk, responses.ResponseTextDeltaEvent):
@@ -1550,6 +1685,32 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
             elif isinstance(chunk, responses.ResponseAudioDeltaEvent):  # pragma: lax no cover
                 pass  # there's nothing we need to do here
 
+            elif isinstance(chunk, responses.ResponseCodeInterpreterCallCodeDeltaEvent):
+                json_args_delta = to_json(chunk.delta).decode()[1:-1]  # Drop the surrounding `"`
+                maybe_event = self._parts_manager.handle_tool_call_delta(
+                    vendor_part_id=f'{chunk.item_id}-call',
+                    args=json_args_delta,
+                )
+                if maybe_event is not None:  # pragma: no branch
+                    yield maybe_event
+
+            elif isinstance(chunk, responses.ResponseCodeInterpreterCallCodeDoneEvent):
+                maybe_event = self._parts_manager.handle_tool_call_delta(
+                    vendor_part_id=f'{chunk.item_id}-call',
+                    args='"}',
+                )
+                if maybe_event is not None:  # pragma: no branch
+                    yield maybe_event
+
+            elif isinstance(chunk, responses.ResponseCodeInterpreterCallCompletedEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseCodeInterpreterCallInProgressEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseCodeInterpreterCallInterpretingEvent):
+                pass  # there's nothing we need to do here
+
             else:  # pragma: no cover
                 warnings.warn(
                     f'Handling of this event type is not yet implemented. Please report on our GitHub: {chunk}',
@@ -1635,3 +1796,63 @@ def _split_combined_tool_call_id(combined_id: str) -> tuple[str, str | None]:
         return call_id, id
     else:
         return combined_id, None  # pragma: no cover
+
+
+def _map_code_interpreter_tool_call(
+    item: responses.ResponseCodeInterpreterToolCall, provider_name: str
+) -> tuple[BuiltinToolCallPart, BuiltinToolReturnPart]:
+    result: dict[str, Any] = {
+        'status': item.status,
+    }
+    if item.outputs:
+        result['outputs'] = [output.model_dump(mode='json') for output in item.outputs]
+
+    return (
+        BuiltinToolCallPart(
+            tool_name=CodeExecutionTool.kind,
+            tool_call_id=item.id,
+            args={
+                'container_id': item.container_id,
+                'code': item.code,
+            },
+            provider_name=provider_name,
+        ),
+        BuiltinToolReturnPart(
+            tool_name=CodeExecutionTool.kind,
+            tool_call_id=item.id,
+            content=result,
+            provider_name=provider_name,
+        ),
+    )
+
+
+def _map_web_search_tool_call(
+    item: responses.ResponseFunctionWebSearch, provider_name: str
+) -> tuple[BuiltinToolCallPart, BuiltinToolReturnPart]:
+    args: dict[str, Any] | None = None
+
+    result = {
+        'status': item.status,
+    }
+
+    if action := item.action:
+        args = action.model_dump(mode='json')
+
+        # To prevent `Unknown parameter: 'input[2].action.sources'` for `ActionSearch`
+        if sources := args.pop('sources', None):
+            result['sources'] = sources
+
+    return (
+        BuiltinToolCallPart(
+            tool_name=WebSearchTool.kind,
+            tool_call_id=item.id,
+            args=args,
+            provider_name=provider_name,
+        ),
+        BuiltinToolReturnPart(
+            tool_name=WebSearchTool.kind,
+            tool_call_id=item.id,
+            content=result,
+            provider_name=provider_name,
+        ),
+    )

pydantic_ai/providers/__init__.py

@@ -48,7 +48,7 @@ class Provider(ABC, Generic[InterfaceClient]):
         return None  # pragma: no cover
 
     def __repr__(self) -> str:
-        return f'{self.__class__.__name__}(name={self.name}, base_url={self.base_url})'
+        return f'{self.__class__.__name__}(name={self.name}, base_url={self.base_url})'  # pragma: lax no cover
 
 
 def infer_provider_class(provider: str) -> type[Provider[Any]]:  # noqa: C901

pydantic_ai/result.py

@@ -1,7 +1,7 @@
 from __future__ import annotations as _annotations
 
 from collections.abc import AsyncIterator, Awaitable, Callable, Iterable
-from copy import copy
+from copy import deepcopy
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Generic, cast, overload
@@ -56,7 +56,7 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
     _initial_run_ctx_usage: RunUsage = field(init=False)
 
     def __post_init__(self):
-        self._initial_run_ctx_usage = copy(self._run_ctx.usage)
+        self._initial_run_ctx_usage = deepcopy(self._run_ctx.usage)
 
     async def stream_output(self, *, debounce_by: float | None = 0.1) -> AsyncIterator[OutputDataT]:
         """Asynchronously stream the (validated) agent outputs."""
@@ -163,7 +163,14 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
                 )
             return cast(OutputDataT, deferred_tool_requests)
         elif isinstance(self._output_schema, TextOutputSchema):
-            text = '\n\n'.join(x.content for x in message.parts if isinstance(x, _messages.TextPart))
+            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 = ''
 
             result_data = await self._output_schema.process(
                 text, self._run_ctx, allow_partial=allow_partial, wrap_validation_errors=False
@@ -193,19 +200,30 @@ class AgentStream(Generic[AgentDepsT, OutputDataT]):
                 if isinstance(part, _messages.TextPart) and part.content:
                     yield part.content, i
 
+            last_text_index: int | None = None
             async for event in self._raw_stream_response:
                 if (
                     isinstance(event, _messages.PartStartEvent)
                     and isinstance(event.part, _messages.TextPart)
                     and event.part.content
                 ):
-                    yield event.part.content, event.index  # pragma: no cover
-                elif (  # pragma: no branch
+                    last_text_index = event.index
+                    yield event.part.content, event.index
+                elif (
                     isinstance(event, _messages.PartDeltaEvent)
                     and isinstance(event.delta, _messages.TextPartDelta)
                     and event.delta.content_delta
                 ):
+                    last_text_index = event.index
                     yield event.delta.content_delta, event.index
+                elif (
+                    isinstance(event, _messages.PartStartEvent)
+                    and isinstance(event.part, _messages.BuiltinToolCallPart)
+                    and last_text_index is not None
+                ):
+                    # Text parts that are interrupted by a built-in tool call should not be joined together directly
+                    yield '\n\n', event.index
+                    last_text_index = None
 
         async def _stream_text_deltas() -> AsyncIterator[str]:
             async with _utils.group_by_temporal(_stream_text_deltas_ungrouped(), debounce_by) as group_iter:
@@ -322,9 +340,7 @@ class StreamedRunResult(Generic[AgentDepsT, OutputDataT]):
             self.all_messages(output_tool_return_content=output_tool_return_content)
         )
 
-    def new_messages(
-        self, *, output_tool_return_content: str | None = None
-    ) -> list[_messages.ModelMessage]:  # pragma: no cover
+    def new_messages(self, *, output_tool_return_content: str | None = None) -> list[_messages.ModelMessage]:
         """Return new messages associated with this run.
 
         Messages from older runs are excluded.

pydantic_ai/toolsets/function.py

@@ -309,7 +309,13 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
     async def get_tools(self, ctx: RunContext[AgentDepsT]) -> dict[str, ToolsetTool[AgentDepsT]]:
         tools: dict[str, ToolsetTool[AgentDepsT]] = {}
         for original_name, tool in self.tools.items():
-            run_context = replace(ctx, tool_name=original_name, retry=ctx.retries.get(original_name, 0))
+            max_retries = tool.max_retries if tool.max_retries is not None else self.max_retries
+            run_context = replace(
+                ctx,
+                tool_name=original_name,
+                retry=ctx.retries.get(original_name, 0),
+                max_retries=max_retries,
+            )
             tool_def = await tool.prepare_tool_def(run_context)
             if not tool_def:
                 continue
@@ -324,7 +330,7 @@ class FunctionToolset(AbstractToolset[AgentDepsT]):
             tools[new_name] = FunctionToolsetTool(
                 toolset=self,
                 tool_def=tool_def,
-                max_retries=tool.max_retries if tool.max_retries is not None else self.max_retries,
+                max_retries=max_retries,
                 args_validator=tool.function_schema.validator,
                 call_func=tool.function_schema.call,
                 is_async=tool.function_schema.is_async,

pydantic_ai/usage.py

@@ -135,7 +135,7 @@ class RunUsage(UsageBase):
     """Number of successful tool calls executed during the run."""
 
     input_tokens: int = 0
-    """Total number of text input/prompt tokens."""
+    """Total number of input/prompt tokens."""
 
     cache_write_tokens: int = 0
     """Total number of tokens written to the cache."""
@@ -150,7 +150,7 @@ class RunUsage(UsageBase):
     """Total number of audio tokens read from the cache."""
 
     output_tokens: int = 0
-    """Total number of text output/completion tokens."""
+    """Total number of output/completion tokens."""
 
     details: dict[str, int] = dataclasses.field(default_factory=dict)
     """Any extra details returned by the model."""

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydantic-ai-slim
-Version: 1.0.7
+Version: 1.0.9
 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.7
+Requires-Dist: pydantic-graph==1.0.9
 Requires-Dist: pydantic>=2.10
 Requires-Dist: typing-inspection>=0.4.0
 Provides-Extra: a2a
@@ -53,11 +53,11 @@ Requires-Dist: rich>=13; extra == 'cli'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.18.0; (platform_system != 'Emscripten') and extra == 'cohere'
 Provides-Extra: dbos
-Requires-Dist: dbos>=1.13.0; extra == 'dbos'
+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.7; extra == 'evals'
+Requires-Dist: pydantic-evals==1.0.9; extra == 'evals'
 Provides-Extra: google
 Requires-Dist: google-genai>=1.31.0; extra == 'google'
 Provides-Extra: groq
@@ -71,7 +71,7 @@ Requires-Dist: mcp>=1.12.3; extra == 'mcp'
 Provides-Extra: mistral
 Requires-Dist: mistralai>=1.9.10; extra == 'mistral'
 Provides-Extra: openai
-Requires-Dist: openai>=1.99.9; extra == 'openai'
+Requires-Dist: openai>=1.107.2; extra == 'openai'
 Provides-Extra: retries
 Requires-Dist: tenacity>=8.2.3; extra == 'retries'
 Provides-Extra: tavily