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

pydantic_ai/models/groq.py

@@ -8,11 +8,11 @@ from datetime import datetime
 from typing import Any, Literal, cast, overload
 
 from pydantic import BaseModel, Json, ValidationError
+from pydantic_core import from_json
 from typing_extensions import assert_never
 
-from pydantic_ai._output import DEFAULT_OUTPUT_TOOL_NAME, OutputObjectDefinition
-
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
+from .._output import DEFAULT_OUTPUT_TOOL_NAME, OutputObjectDefinition
 from .._run_context import RunContext
 from .._thinking_part import split_content_into_text_and_thinking
 from .._utils import generate_tool_call_id, guard_tool_call_id as _guard_tool_call_id, number_to_datetime
@@ -55,6 +55,7 @@ try:
     from groq import NOT_GIVEN, APIError, APIStatusError, AsyncGroq, AsyncStream
     from groq.types import chat
     from groq.types.chat.chat_completion_content_part_image_param import ImageURL
+    from groq.types.chat.chat_completion_message import ExecutedTool
 except ImportError as _import_error:
     raise ImportError(
         'Please install `groq` to use the Groq model, '
@@ -308,22 +309,15 @@ class GroqModel(Model):
         timestamp = number_to_datetime(response.created)
         choice = response.choices[0]
         items: list[ModelResponsePart] = []
-        if choice.message.executed_tools:
-            for tool in choice.message.executed_tools:
-                tool_call_id = generate_tool_call_id()
-                items.append(
-                    BuiltinToolCallPart(
-                        tool_name=tool.type, args=tool.arguments, provider_name=self.system, tool_call_id=tool_call_id
-                    )
-                )
-                items.append(
-                    BuiltinToolReturnPart(
-                        provider_name=self.system, tool_name=tool.type, content=tool.output, tool_call_id=tool_call_id
-                    )
-                )
         if choice.message.reasoning is not None:
             # NOTE: The `reasoning` field is only present if `groq_reasoning_format` is set to `parsed`.
             items.append(ThinkingPart(content=choice.message.reasoning))
+        if choice.message.executed_tools:
+            for tool in choice.message.executed_tools:
+                call_part, return_part = _map_executed_tool(tool, self.system)
+                if call_part and return_part:  # pragma: no branch
+                    items.append(call_part)
+                    items.append(return_part)
         if choice.message.content is not None:
             # NOTE: The `<think>` tag is only present if `groq_reasoning_format` is set to `raw`.
             items.extend(split_content_into_text_and_thinking(choice.message.content, self.profile.thinking_tags))
@@ -400,7 +394,7 @@ class GroqModel(Model):
                         start_tag, end_tag = self.profile.thinking_tags
                         texts.append('\n'.join([start_tag, item.content, end_tag]))
                     elif isinstance(item, BuiltinToolCallPart | BuiltinToolReturnPart):  # pragma: no cover
-                        # This is currently never returned from groq
+                        # These are not currently sent back
                         pass
                     else:
                         assert_never(item)
@@ -513,8 +507,9 @@ class GroqStreamedResponse(StreamedResponse):
     _timestamp: datetime
     _provider_name: str
 
-    async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
+    async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:  # noqa: C901
         try:
+            executed_tool_call_id: str | None = None
             async for chunk in self._response:
                 self._usage += _map_usage(chunk)
 
@@ -530,6 +525,28 @@ class GroqStreamedResponse(StreamedResponse):
                     self.provider_details = {'finish_reason': raw_finish_reason}
                     self.finish_reason = _FINISH_REASON_MAP.get(raw_finish_reason)
 
+                if choice.delta.reasoning is not None:
+                    # NOTE: The `reasoning` field is only present if `groq_reasoning_format` is set to `parsed`.
+                    yield self._parts_manager.handle_thinking_delta(
+                        vendor_part_id='reasoning', content=choice.delta.reasoning
+                    )
+
+                if choice.delta.executed_tools:
+                    for tool in choice.delta.executed_tools:
+                        call_part, return_part = _map_executed_tool(
+                            tool, self.provider_name, streaming=True, tool_call_id=executed_tool_call_id
+                        )
+                        if call_part:
+                            executed_tool_call_id = call_part.tool_call_id
+                            yield self._parts_manager.handle_builtin_tool_call_part(
+                                vendor_part_id=f'executed_tools-{tool.index}-call', part=call_part
+                            )
+                        if return_part:
+                            executed_tool_call_id = None
+                            yield self._parts_manager.handle_builtin_tool_return_part(
+                                vendor_part_id=f'executed_tools-{tool.index}-return', part=return_part
+                            )
+
                 # Handle the text part of the response
                 content = choice.delta.content
                 if content is not None:
@@ -626,3 +643,37 @@ class _GroqToolUseFailedError(BaseModel):
     # }
 
     error: _GroqToolUseFailedInnerError
+
+
+def _map_executed_tool(
+    tool: ExecutedTool, provider_name: str, streaming: bool = False, tool_call_id: str | None = None
+) -> tuple[BuiltinToolCallPart | None, BuiltinToolReturnPart | None]:
+    if tool.type == 'search':
+        if tool.search_results and (tool.search_results.images or tool.search_results.results):
+            results = tool.search_results.model_dump(mode='json')
+        else:
+            results = tool.output
+
+        tool_call_id = tool_call_id or generate_tool_call_id()
+        call_part = BuiltinToolCallPart(
+            tool_name=WebSearchTool.kind,
+            args=from_json(tool.arguments),
+            provider_name=provider_name,
+            tool_call_id=tool_call_id,
+        )
+        return_part = BuiltinToolReturnPart(
+            tool_name=WebSearchTool.kind,
+            content=results,
+            provider_name=provider_name,
+            tool_call_id=tool_call_id,
+        )
+
+        if streaming:
+            if results:
+                return None, return_part
+            else:
+                return call_part, None
+        else:
+            return call_part, return_part
+    else:  # pragma: no cover
+        return None, None

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

@@ -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:

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,