pydantic-ai-slim 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

pydantic_ai/models/bedrock.py

@@ -15,9 +15,12 @@ import anyio.to_thread
 from typing_extensions import ParamSpec, assert_never
 
 from pydantic_ai import _utils, usage
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.messages import (
     AudioUrl,
     BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     DocumentUrl,
     ImageUrl,
     ModelMessage,
@@ -59,6 +62,8 @@ if TYPE_CHECKING:
         MessageUnionTypeDef,
         PerformanceConfigurationTypeDef,
         PromptVariableValuesTypeDef,
+        ReasoningContentBlockOutputTypeDef,
+        ReasoningTextBlockTypeDef,
         SystemContentBlockTypeDef,
         ToolChoiceTypeDef,
         ToolConfigurationTypeDef,
@@ -276,9 +281,10 @@ class BedrockConverseModel(Model):
                 if reasoning_content := item.get('reasoningContent'):
                     reasoning_text = reasoning_content.get('reasoningText')
                     if reasoning_text:  # pragma: no branch
-                        thinking_part = ThinkingPart(content=reasoning_text['text'])
-                        if reasoning_signature := reasoning_text.get('signature'):
-                            thinking_part.signature = reasoning_signature
+                        thinking_part = ThinkingPart(
+                            content=reasoning_text['text'],
+                            signature=reasoning_text.get('signature'),
+                        )
                         items.append(thinking_part)
                 if text := item.get('text'):
                     items.append(TextPart(content=text))
@@ -339,6 +345,9 @@ class BedrockConverseModel(Model):
         if tool_config:
             params['toolConfig'] = tool_config
 
+        if model_request_parameters.builtin_tools:
+            raise UserError('Bedrock does not support built-in tools')
+
         # Bedrock supports a set of specific extra parameters
         if model_settings:
             if guardrail_config := model_settings.get('bedrock_guardrail_config', None):
@@ -462,7 +471,20 @@ class BedrockConverseModel(Model):
                     if isinstance(item, TextPart):
                         content.append({'text': item.content})
                     elif isinstance(item, ThinkingPart):
-                        # NOTE: We don't pass the thinking part to Bedrock since it raises an error.
+                        if BedrockModelProfile.from_profile(self.profile).bedrock_send_back_thinking_parts:
+                            reasoning_text: ReasoningTextBlockTypeDef = {
+                                'text': item.content,
+                            }
+                            if item.signature:
+                                reasoning_text['signature'] = item.signature
+                            reasoning_content: ReasoningContentBlockOutputTypeDef = {
+                                'reasoningText': reasoning_text,
+                            }
+                            content.append({'reasoningContent': reasoning_content})
+                        else:
+                            # NOTE: We don't pass the thinking part to Bedrock for models other than Claude since it raises an error.
+                            pass
+                    elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):
                         pass
                     else:
                         assert isinstance(item, ToolCallPart)
@@ -610,7 +632,11 @@ class BedrockStreamedResponse(StreamedResponse):
                 delta = chunk['contentBlockDelta']['delta']
                 if 'reasoningContent' in delta:
                     if text := delta['reasoningContent'].get('text'):
-                        yield self._parts_manager.handle_thinking_delta(vendor_part_id=index, content=text)
+                        yield self._parts_manager.handle_thinking_delta(
+                            vendor_part_id=index,
+                            content=text,
+                            signature=delta['reasoningContent'].get('signature'),
+                        )
                     else:  # pragma: no cover
                         warnings.warn(
                             f'Only text reasoning content is supported yet, but you got {delta["reasoningContent"]}. '

pydantic_ai/models/cohere.py

@@ -7,10 +7,13 @@ from typing import Literal, Union, cast
 from typing_extensions import assert_never
 
 from pydantic_ai._thinking_part import split_content_into_text_and_thinking
+from pydantic_ai.exceptions import UserError
 
 from .. import ModelHTTPError, usage
 from .._utils import generate_tool_call_id as _generate_tool_call_id, guard_tool_call_id as _guard_tool_call_id
 from ..messages import (
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     ModelMessage,
     ModelRequest,
     ModelResponse,
@@ -166,6 +169,10 @@ class CohereModel(Model):
         model_request_parameters: ModelRequestParameters,
     ) -> V2ChatResponse:
         tools = self._get_tools(model_request_parameters)
+
+        if model_request_parameters.builtin_tools:
+            raise UserError('Cohere does not support built-in tools')
+
         cohere_messages = self._map_messages(messages)
         try:
             return await self.client.chat(
@@ -223,6 +230,9 @@ class CohereModel(Model):
                         pass
                     elif isinstance(item, ToolCallPart):
                         tool_calls.append(self._map_tool_call(item))
+                    elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+                        # This is currently never returned from cohere
+                        pass
                     else:
                         assert_never(item)
                 message_param = AssistantChatMessageV2(role='assistant')

pydantic_ai/models/function.py

@@ -17,6 +17,8 @@ from .. import _utils, usage
 from .._utils import PeekableAsyncStream
 from ..messages import (
     BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     ModelMessage,
     ModelRequest,
     ModelResponse,
@@ -331,6 +333,13 @@ def _estimate_usage(messages: Iterable[ModelMessage]) -> usage.Usage:
                     response_tokens += _estimate_string_tokens(part.content)
                 elif isinstance(part, ToolCallPart):
                     response_tokens += 1 + _estimate_string_tokens(part.args_as_json_str())
+                # TODO(Marcelo): We need to add coverage here.
+                elif isinstance(part, BuiltinToolCallPart):  # pragma: no cover
+                    call = part
+                    response_tokens += 1 + _estimate_string_tokens(call.args_as_json_str())
+                # TODO(Marcelo): We need to add coverage here.
+                elif isinstance(part, BuiltinToolReturnPart):  # pragma: no cover
+                    response_tokens += _estimate_string_tokens(part.model_response_str())
                 else:
                     assert_never(part)
         else:

pydantic_ai/models/gemini.py

@@ -20,6 +20,8 @@ from .._output import OutputObjectDefinition
 from ..exceptions import UserError
 from ..messages import (
     BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     FileUrl,
     ModelMessage,
     ModelRequest,
@@ -610,6 +612,9 @@ def _content_model_response(m: ModelResponse) -> _GeminiContent:
         elif isinstance(item, TextPart):
             if item.content:
                 parts.append(_GeminiTextPart(text=item.content))
+        elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+            # This is currently never returned from gemini
+            pass
         else:
             assert_never(item)
     return _GeminiContent(role='model', parts=parts)

pydantic_ai/models/google.py

@@ -8,13 +8,17 @@ from datetime import datetime
 from typing import Any, Literal, Union, cast, overload
 from uuid import uuid4
 
+from google.genai.types import ExecutableCodeDict
 from typing_extensions import assert_never
 
 from .. import UnexpectedModelBehavior, _utils, usage
 from .._output import OutputObjectDefinition
+from ..builtin_tools import CodeExecutionTool, WebSearchTool
 from ..exceptions import UserError
 from ..messages import (
     BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     FileUrl,
     ModelMessage,
     ModelRequest,
@@ -54,12 +58,14 @@ try:
         FunctionDeclarationDict,
         GenerateContentConfigDict,
         GenerateContentResponse,
+        GoogleSearchDict,
         HttpOptionsDict,
         MediaResolution,
         Part,
         PartDict,
         SafetySettingDict,
         ThinkingConfigDict,
+        ToolCodeExecutionDict,
         ToolConfigDict,
         ToolDict,
         ToolListUnionDict,
@@ -213,6 +219,11 @@ class GoogleModel(Model):
                 ToolDict(function_declarations=[_function_declaration_from_tool(t)])
                 for t in model_request_parameters.output_tools
             ]
+        for tool in model_request_parameters.builtin_tools:
+            if isinstance(tool, WebSearchTool):
+                tools.append(ToolDict(google_search=GoogleSearchDict()))
+            elif isinstance(tool, CodeExecutionTool):  # pragma: no branch
+                tools.append(ToolDict(code_execution=ToolCodeExecutionDict()))
         return tools or None
 
     def _get_tool_config(
@@ -499,6 +510,14 @@ def _content_model_response(m: ModelResponse) -> ContentDict:
             # please open an issue. The below code is the code to send thinking to the provider.
             # parts.append({'text': item.content, 'thought': True})
             pass
+        elif isinstance(item, BuiltinToolCallPart):
+            if item.provider_name == 'google':
+                if item.tool_name == 'code_execution':  # pragma: no branch
+                    parts.append({'executable_code': cast(ExecutableCodeDict, item.args)})
+        elif isinstance(item, BuiltinToolReturnPart):
+            if item.provider_name == 'google':
+                if item.tool_name == 'code_execution':  # pragma: no branch
+                    parts.append({'code_execution_result': item.content})
         else:
             assert_never(item)
     return ContentDict(role='model', parts=parts)
@@ -513,7 +532,22 @@ def _process_response_from_parts(
 ) -> ModelResponse:
     items: list[ModelResponsePart] = []
     for part in parts:
-        if part.text is not None:
+        if part.executable_code is not None:
+            items.append(
+                BuiltinToolCallPart(
+                    provider_name='google', args=part.executable_code.model_dump(), tool_name='code_execution'
+                )
+            )
+        elif part.code_execution_result is not None:
+            items.append(
+                BuiltinToolReturnPart(
+                    provider_name='google',
+                    tool_name='code_execution',
+                    content=part.code_execution_result,
+                    tool_call_id='not_provided',
+                )
+            )
+        elif part.text is not None:
             if part.thought:
                 items.append(ThinkingPart(content=part.text))
             else:
@@ -563,7 +597,7 @@ def _metadata_as_usage(response: GenerateContentResponse) -> usage.Usage:
         details['thoughts_tokens'] = thoughts_token_count
 
     if tool_use_prompt_token_count := metadata.get('tool_use_prompt_token_count'):
-        details['tool_use_prompt_tokens'] = tool_use_prompt_token_count  # pragma: no cover
+        details['tool_use_prompt_tokens'] = tool_use_prompt_token_count
 
     for key, metadata_details in metadata.items():
         if key.endswith('_details') and metadata_details:

pydantic_ai/models/groq.py

@@ -10,11 +10,16 @@ from typing import Literal, Union, cast, overload
 from typing_extensions import assert_never
 
 from pydantic_ai._thinking_part import split_content_into_text_and_thinking
+from pydantic_ai.exceptions import UserError
+from pydantic_ai.profiles.groq import GroqModelProfile
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
-from .._utils import guard_tool_call_id as _guard_tool_call_id, number_to_datetime
+from .._utils import generate_tool_call_id, guard_tool_call_id as _guard_tool_call_id, number_to_datetime
+from ..builtin_tools import CodeExecutionTool, WebSearchTool
 from ..messages import (
     BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     DocumentUrl,
     ImageUrl,
     ModelMessage,
@@ -212,7 +217,7 @@ class GroqModel(Model):
         model_request_parameters: ModelRequestParameters,
     ) -> chat.ChatCompletion | AsyncStream[chat.ChatCompletionChunk]:
         tools = self._get_tools(model_request_parameters)
-        # standalone function to make it easier to override
+        tools += self._get_builtin_tools(model_request_parameters)
         if not tools:
             tool_choice: Literal['none', 'required', 'auto'] | None = None
         elif not model_request_parameters.allow_text_output:
@@ -226,7 +231,7 @@ class GroqModel(Model):
             extra_headers = model_settings.get('extra_headers', {})
             extra_headers.setdefault('User-Agent', get_user_agent())
             return await self.client.chat.completions.create(
-                model=str(self._model_name),
+                model=self._model_name,
                 messages=groq_messages,
                 n=1,
                 parallel_tool_calls=model_settings.get('parallel_tool_calls', NOT_GIVEN),
@@ -256,6 +261,19 @@ 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='groq', tool_call_id=tool_call_id
+                    )
+                )
+                items.append(
+                    BuiltinToolReturnPart(
+                        provider_name='groq', tool_name=tool.type, content=tool.output, tool_call_id=tool_call_id
+                    )
+                )
         # NOTE: The `reasoning` field is only present if `groq_reasoning_format` is set to `parsed`.
         if choice.message.reasoning is not None:
             items.append(ThinkingPart(content=choice.message.reasoning))
@@ -291,6 +309,18 @@ class GroqModel(Model):
             tools += [self._map_tool_definition(r) for r in model_request_parameters.output_tools]
         return tools
 
+    def _get_builtin_tools(
+        self, model_request_parameters: ModelRequestParameters
+    ) -> list[chat.ChatCompletionToolParam]:
+        tools: list[chat.ChatCompletionToolParam] = []
+        for tool in model_request_parameters.builtin_tools:
+            if isinstance(tool, WebSearchTool):
+                if not GroqModelProfile.from_profile(self.profile).groq_always_has_web_search_builtin_tool:
+                    raise UserError('`WebSearchTool` is not supported by Groq')  # pragma: no cover
+            elif isinstance(tool, CodeExecutionTool):  # pragma: no branch
+                raise UserError('`CodeExecutionTool` is not supported by Groq')
+        return tools
+
     def _map_messages(self, messages: list[ModelMessage]) -> list[chat.ChatCompletionMessageParam]:
         """Just maps a `pydantic_ai.Message` to a `groq.types.ChatCompletionMessageParam`."""
         groq_messages: list[chat.ChatCompletionMessageParam] = []
@@ -308,6 +338,9 @@ class GroqModel(Model):
                     elif isinstance(item, ThinkingPart):
                         # Skip thinking parts when mapping to Groq messages
                         continue
+                    elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+                        # This is currently never returned from groq
+                        pass
                     else:
                         assert_never(item)
                 message_param = chat.ChatCompletionAssistantMessageParam(role='assistant')

pydantic_ai/models/huggingface.py

@@ -10,6 +10,7 @@ from typing import Literal, Union, cast, overload
 from typing_extensions import assert_never
 
 from pydantic_ai._thinking_part import split_content_into_text_and_thinking
+from pydantic_ai.exceptions import UserError
 from pydantic_ai.providers import Provider, infer_provider
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
@@ -17,6 +18,8 @@ from .._utils import guard_tool_call_id as _guard_tool_call_id, now_utc as _now_
 from ..messages import (
     AudioUrl,
     BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     DocumentUrl,
     ImageUrl,
     ModelMessage,
@@ -198,6 +201,9 @@ class HuggingFaceModel(Model):
         else:
             tool_choice = 'auto'
 
+        if model_request_parameters.builtin_tools:
+            raise UserError('HuggingFace does not support built-in tools')
+
         hf_messages = await self._map_messages(messages)
 
         try:
@@ -301,6 +307,9 @@ class HuggingFaceModel(Model):
                         # please open an issue. The below code is the code to send thinking to the provider.
                         # texts.append(f'<think>\n{item.content}\n</think>')
                         pass
+                    elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+                        # This is currently never returned from huggingface
+                        pass
                     else:
                         assert_never(item)
                 message_param = ChatCompletionInputMessage(role='assistant')  # type: ignore

pydantic_ai/models/mistral.py

@@ -12,11 +12,14 @@ from httpx import Timeout
 from typing_extensions import assert_never
 
 from pydantic_ai._thinking_part import split_content_into_text_and_thinking
+from pydantic_ai.exceptions import UserError
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils
 from .._utils import generate_tool_call_id as _generate_tool_call_id, now_utc as _now_utc, number_to_datetime
 from ..messages import (
     BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     DocumentUrl,
     ImageUrl,
     ModelMessage,
@@ -199,6 +202,11 @@ class MistralModel(Model):
         model_request_parameters: ModelRequestParameters,
     ) -> MistralChatCompletionResponse:
         """Make a non-streaming request to the model."""
+        # TODO(Marcelo): We need to replace the current MistralAI client to use the beta client.
+        # See https://docs.mistral.ai/agents/connectors/websearch/ to support web search.
+        if model_request_parameters.builtin_tools:
+            raise UserError('Mistral does not support built-in tools')
+
         try:
             response = await self.client.chat.complete_async(
                 model=str(self._model_name),
@@ -233,6 +241,11 @@ class MistralModel(Model):
         response: MistralEventStreamAsync[MistralCompletionEvent] | None
         mistral_messages = self._map_messages(messages)
 
+        # TODO(Marcelo): We need to replace the current MistralAI client to use the beta client.
+        # See https://docs.mistral.ai/agents/connectors/websearch/ to support web search.
+        if model_request_parameters.builtin_tools:
+            raise UserError('Mistral does not support built-in tools')
+
         if (
             model_request_parameters.output_tools
             and model_request_parameters.function_tools
@@ -502,6 +515,9 @@ class MistralModel(Model):
                         pass
                     elif isinstance(part, ToolCallPart):
                         tool_calls.append(self._map_tool_call(part))
+                    elif isinstance(part, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+                        # This is currently never returned from mistral
+                        pass
                     else:
                         assert_never(part)
                 mistral_messages.append(MistralAssistantMessage(content=content_chunks, tool_calls=tool_calls))

pydantic_ai/models/openai.py

@@ -11,16 +11,18 @@ from typing import Any, Literal, Union, cast, overload
 from pydantic import ValidationError
 from typing_extensions import assert_never
 
-from pydantic_ai._thinking_part import split_content_into_text_and_thinking
-from pydantic_ai.profiles.openai import OpenAIModelProfile
-from pydantic_ai.providers import Provider, infer_provider
+from pydantic_ai.exceptions import UserError
 
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._output import DEFAULT_OUTPUT_TOOL_NAME, OutputObjectDefinition
+from .._thinking_part import split_content_into_text_and_thinking
 from .._utils import guard_tool_call_id as _guard_tool_call_id, now_utc as _now_utc, number_to_datetime
+from ..builtin_tools import CodeExecutionTool, WebSearchTool
 from ..messages import (
     AudioUrl,
     BinaryContent,
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     DocumentUrl,
     ImageUrl,
     ModelMessage,
@@ -38,16 +40,11 @@ from ..messages import (
     VideoUrl,
 )
 from ..profiles import ModelProfile, ModelProfileSpec
+from ..profiles.openai import OpenAIModelProfile
+from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
 from ..tools import ToolDefinition
-from . import (
-    Model,
-    ModelRequestParameters,
-    StreamedResponse,
-    check_allow_model_requests,
-    download_item,
-    get_user_agent,
-)
+from . import Model, ModelRequestParameters, StreamedResponse, check_allow_model_requests, download_item, get_user_agent
 
 try:
     from openai import NOT_GIVEN, APIStatusError, AsyncOpenAI, AsyncStream, NotGiven
@@ -63,6 +60,11 @@ try:
     from openai.types.chat.chat_completion_content_part_input_audio_param import InputAudio
     from openai.types.chat.chat_completion_content_part_param import File, FileFile
     from openai.types.chat.chat_completion_prediction_content_param import ChatCompletionPredictionContentParam
+    from openai.types.chat.completion_create_params import (
+        WebSearchOptions,
+        WebSearchOptionsUserLocation,
+        WebSearchOptionsUserLocationApproximate,
+    )
     from openai.types.responses import ComputerToolParam, FileSearchToolParam, WebSearchToolParam
     from openai.types.responses.response_input_param import FunctionCallOutput, Message
     from openai.types.shared import ReasoningEffort
@@ -298,6 +300,8 @@ class OpenAIModel(Model):
         model_request_parameters: ModelRequestParameters,
     ) -> chat.ChatCompletion | AsyncStream[ChatCompletionChunk]:
         tools = self._get_tools(model_request_parameters)
+        web_search_options = self._get_web_search_options(model_request_parameters)
+
         if not tools:
             tool_choice: Literal['none', 'required', 'auto'] | None = None
         elif (
@@ -344,6 +348,7 @@ class OpenAIModel(Model):
                 seed=model_settings.get('seed', NOT_GIVEN),
                 reasoning_effort=model_settings.get('openai_reasoning_effort', NOT_GIVEN),
                 user=model_settings.get('openai_user', NOT_GIVEN),
+                web_search_options=web_search_options or NOT_GIVEN,
                 service_tier=model_settings.get('openai_service_tier', NOT_GIVEN),
                 prediction=model_settings.get('openai_prediction', NOT_GIVEN),
                 temperature=sampling_settings.get('temperature', NOT_GIVEN),
@@ -444,6 +449,21 @@ class OpenAIModel(Model):
             tools += [self._map_tool_definition(r) for r in model_request_parameters.output_tools]
         return tools
 
+    def _get_web_search_options(self, model_request_parameters: ModelRequestParameters) -> WebSearchOptions | None:
+        for tool in model_request_parameters.builtin_tools:
+            if isinstance(tool, WebSearchTool):  # pragma: no branch
+                if tool.user_location:
+                    return WebSearchOptions(
+                        search_context_size=tool.search_context_size,
+                        user_location=WebSearchOptionsUserLocation(
+                            type='approximate',
+                            approximate=WebSearchOptionsUserLocationApproximate(**tool.user_location),
+                        ),
+                    )
+                return WebSearchOptions(search_context_size=tool.search_context_size)
+            elif isinstance(tool, CodeExecutionTool):  # pragma: no branch
+                raise UserError('`CodeExecutionTool` is not supported by OpenAI')
+
     async def _map_messages(self, messages: list[ModelMessage]) -> list[chat.ChatCompletionMessageParam]:
         """Just maps a `pydantic_ai.Message` to a `openai.types.ChatCompletionMessageParam`."""
         openai_messages: list[chat.ChatCompletionMessageParam] = []
@@ -464,6 +484,9 @@ class OpenAIModel(Model):
                         pass
                     elif isinstance(item, ToolCallPart):
                         tool_calls.append(self._map_tool_call(item))
+                    # OpenAI doesn't return built-in tool calls
+                    elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+                        pass
                     else:
                         assert_never(item)
                 message_param = chat.ChatCompletionAssistantMessageParam(role='assistant')
@@ -753,7 +776,7 @@ class OpenAIResponsesModel(Model):
         model_request_parameters: ModelRequestParameters,
     ) -> responses.Response | AsyncStream[responses.ResponseStreamEvent]:
         tools = self._get_tools(model_request_parameters)
-        tools = list(model_settings.get('openai_builtin_tools', [])) + tools
+        tools = self._get_builtin_tools(model_request_parameters) + tools
 
         if not tools:
             tool_choice: Literal['none', 'required', 'auto'] | None = None
@@ -841,6 +864,22 @@ class OpenAIResponsesModel(Model):
             tools += [self._map_tool_definition(r) for r in model_request_parameters.output_tools]
         return tools
 
+    def _get_builtin_tools(self, model_request_parameters: ModelRequestParameters) -> list[responses.ToolParam]:
+        tools: list[responses.ToolParam] = []
+        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
+                )
+                if tool.user_location:
+                    web_search_tool['user_location'] = responses.web_search_tool_param.UserLocation(
+                        type='approximate', **tool.user_location
+                    )
+                tools.append(web_search_tool)
+            elif isinstance(tool, CodeExecutionTool):  # pragma: no branch
+                tools.append({'type': 'code_interpreter', 'container': {'type': 'auto'}})
+        return tools
+
     def _map_tool_definition(self, f: ToolDefinition) -> responses.FunctionToolParam:
         return {
             'name': f.name,
@@ -895,6 +934,9 @@ class OpenAIResponsesModel(Model):
                         openai_messages.append(responses.EasyInputMessageParam(role='assistant', content=item.content))
                     elif isinstance(item, ToolCallPart):
                         openai_messages.append(self._map_tool_call(item))
+                    # OpenAI doesn't return built-in tool calls
+                    elif isinstance(item, (BuiltinToolCallPart, BuiltinToolReturnPart)):
+                        pass
                     elif isinstance(item, ThinkingPart):
                         # NOTE: We don't send ThinkingPart to the providers yet. If you are unsatisfied with this,
                         # please open an issue. The below code is the code to send thinking to the provider.
@@ -1071,6 +1113,7 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
 
     async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:  # noqa: C901
         async for chunk in self._response:
+            # NOTE: You can inspect the builtin tools used checking the `ResponseCompletedEvent`.
             if isinstance(chunk, responses.ResponseCompletedEvent):
                 self._usage += _map_usage(chunk.response)
 
@@ -1122,6 +1165,8 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
                     )
                 elif isinstance(chunk.item, responses.ResponseOutputMessage):
                     pass
+                elif isinstance(chunk.item, responses.ResponseFunctionWebSearch):
+                    pass
                 else:
                     warnings.warn(  # pragma: no cover
                         f'Handling of this item type is not yet implemented. Please report on our GitHub: {chunk}',
@@ -1148,6 +1193,10 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
                     signature=chunk.item_id,
                 )
 
+            # TODO(Marcelo): We should support annotations in the future.
+            elif isinstance(chunk, responses.ResponseOutputTextAnnotationAddedEvent):
+                pass  # there's nothing we need to do here
+
             elif isinstance(chunk, responses.ResponseTextDeltaEvent):
                 maybe_event = self._parts_manager.handle_text_delta(
                     vendor_part_id=chunk.content_index, content=chunk.delta
@@ -1158,6 +1207,18 @@ class OpenAIResponsesStreamedResponse(StreamedResponse):
             elif isinstance(chunk, responses.ResponseTextDoneEvent):
                 pass  # there's nothing we need to do here
 
+            elif isinstance(chunk, responses.ResponseWebSearchCallInProgressEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseWebSearchCallSearchingEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseWebSearchCallCompletedEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseAudioDeltaEvent):  # pragma: lax no cover
+                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}',

pydantic_ai/models/test.py

@@ -12,7 +12,10 @@ import pydantic_core
 from typing_extensions import assert_never
 
 from .. import _utils
+from ..exceptions import UserError
 from ..messages import (
+    BuiltinToolCallPart,
+    BuiltinToolReturnPart,
     ModelMessage,
     ModelRequest,
     ModelResponse,
@@ -179,6 +182,9 @@ class TestModel(Model):
         model_settings: ModelSettings | None,
         model_request_parameters: ModelRequestParameters,
     ) -> ModelResponse:
+        if model_request_parameters.builtin_tools:
+            raise UserError('TestModel does not support built-in tools')
+
         tool_calls = self._get_tool_calls(model_request_parameters)
         output_wrapper = self._get_output(model_request_parameters)
         output_tools = model_request_parameters.output_tools
@@ -283,6 +289,9 @@ class TestStreamedResponse(StreamedResponse):
                 yield self._parts_manager.handle_tool_call_part(
                     vendor_part_id=i, tool_name=part.tool_name, args=part.args, tool_call_id=part.tool_call_id
                 )
+            elif isinstance(part, (BuiltinToolCallPart, BuiltinToolReturnPart)):  # pragma: no cover
+                # NOTE: These parts are not generated by TestModel, but we need to handle them for type checking
+                assert False, f'Unexpected part type in TestModel: {type(part).__name__}'
             elif isinstance(part, ThinkingPart):  # pragma: no cover
                 # NOTE: There's no way to reach this part of the code, since we don't generate ThinkingPart on TestModel.
                 assert False, "This should be unreachable — we don't generate ThinkingPart on TestModel."

pydantic_ai/profiles/__init__.py

@@ -7,7 +7,15 @@ from typing import Callable, Union
 from typing_extensions import Self
 
 from ..output import StructuredOutputMode
-from ._json_schema import JsonSchemaTransformer
+from ._json_schema import InlineDefsJsonSchemaTransformer, JsonSchemaTransformer
+
+__all__ = [
+    'ModelProfile',
+    'ModelProfileSpec',
+    'DEFAULT_PROFILE',
+    'InlineDefsJsonSchemaTransformer',
+    'JsonSchemaTransformer',
+]
 
 
 @dataclass

pydantic_ai/profiles/amazon.py

@@ -1,7 +1,6 @@
 from __future__ import annotations as _annotations
 
-from . import ModelProfile
-from ._json_schema import InlineDefsJsonSchemaTransformer
+from . import InlineDefsJsonSchemaTransformer, ModelProfile
 
 
 def amazon_model_profile(model_name: str) -> ModelProfile | None: