move builtin tool support to profile and move check to base model class

Author: dsfaccini

pydantic_ai_slim/pydantic_ai/models/__init__.py

@@ -486,6 +486,16 @@ def prepare_request(
         if params.allow_image_output and not self.profile.supports_image_output:
             raise UserError('Image output is not supported by this model.')
 
+        # Check if builtin tools are supported
+        if params.builtin_tools:
+            supported_types = self.profile.supported_builtin_tools
+            for tool in params.builtin_tools:
+                if not isinstance(tool, tuple(supported_types)):
+                    raise UserError(
+                        f'Builtin tool {type(tool).__name__} is not supported by this model. '
+                        f'Supported tools: {[t.__name__ for t in supported_types]}'
+                    )
+
         return model_settings, params
 
     @property
@@ -499,24 +509,39 @@ def label(self) -> str:
         """Human-friendly display label for the model."""
         return _format_model_label(self.model_name)
 
-    @classmethod
-    def supported_builtin_tools(cls) -> frozenset[type[AbstractBuiltinTool]]:
-        """Return the set of builtin tool types this model class can handle.
+    def supported_builtin_tools(self, profile: ModelProfile) -> frozenset[type[AbstractBuiltinTool]]:
+        """Return the set of builtin tool types this model can handle.
+
+        Args:
+            profile: The resolved model profile (passed to avoid circular dependency with self.profile)
 
         Subclasses should override this to reflect their actual capabilities.
         Default is empty set - subclasses must explicitly declare support.
         """
-        return frozenset()  # pragma: no cover
+        return frozenset()
 
     @cached_property
     def profile(self) -> ModelProfile:
-        """The model profile."""
+        """The model profile.
+
+        We use this to compute the intersection of the profile's supported_builtin_tools
+        and the model's implemented tools, ensuring model.profile.supported_builtin_tools
+        is the single source of truth for what builtin tools are actually usable.
+        """
         _profile = self._profile
         if callable(_profile):
             _profile = _profile(self.model_name)
 
         if _profile is None:
-            return DEFAULT_PROFILE
+            _profile = DEFAULT_PROFILE
+
+        # Compute intersection: profile's allowed tools & model's implemented tools
+        model_supported = self.supported_builtin_tools(_profile)
+        profile_supported = _profile.supported_builtin_tools
+        effective_tools = profile_supported & model_supported
+
+        if effective_tools != profile_supported:
+            _profile = replace(_profile, supported_builtin_tools=effective_tools)
 
         return _profile
 

pydantic_ai_slim/pydantic_ai/models/anthropic.py

@@ -44,7 +44,7 @@
     ToolReturnPart,
     UserPromptPart,
 )
-from ..profiles import ModelProfileSpec
+from ..profiles import ModelProfile, ModelProfileSpec
 from ..providers import Provider, infer_provider
 from ..providers.anthropic import AsyncAnthropicClient
 from ..settings import ModelSettings, merge_model_settings
@@ -261,9 +261,8 @@ def system(self) -> str:
         """The model provider."""
         return self._provider.name
 
-    @classmethod
-    def supported_builtin_tools(cls) -> frozenset[type[AbstractBuiltinTool]]:
-        """Return the set of builtin tool types this model class can handle."""
+    def supported_builtin_tools(self, profile: ModelProfile) -> frozenset[type[AbstractBuiltinTool]]:
+        """Return the set of builtin tool types this model can handle."""
         return frozenset({WebSearchTool, CodeExecutionTool, WebFetchTool, MemoryTool, MCPServerTool})
 
     async def request(

pydantic_ai_slim/pydantic_ai/models/bedrock.py

@@ -433,7 +433,8 @@ async def _messages_create(
         if tool_config:
             params['toolConfig'] = tool_config
 
-        if model_request_parameters.builtin_tools:
+        if model_request_parameters.builtin_tools:  # pragma: no cover
+            # this check is done in the base Model class - leave this as a placeholder for when Bedrock supports built-in tools
             raise UserError('Bedrock does not support built-in tools')
 
         # Bedrock supports a set of specific extra parameters

pydantic_ai_slim/pydantic_ai/models/cohere.py

@@ -6,7 +6,7 @@
 
 from typing_extensions import assert_never
 
-from pydantic_ai.exceptions import ModelAPIError, UserError
+from pydantic_ai.exceptions import ModelAPIError
 
 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
@@ -175,9 +175,6 @@ async def _chat(
     ) -> 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, model_request_parameters)
         try:
             return await self.client.chat(

pydantic_ai_slim/pydantic_ai/models/function.py

@@ -201,8 +201,7 @@ def system(self) -> str:
         """The system / model provider."""
         return self._system
 
-    @classmethod
-    def supported_builtin_tools(cls) -> frozenset[type[AbstractBuiltinTool]]:
+    def supported_builtin_tools(self, profile: ModelProfile) -> frozenset[type[AbstractBuiltinTool]]:
         """FunctionModel supports all builtin tools for testing flexibility."""
         from ..builtin_tools import get_builtin_tool_types
 

pydantic_ai_slim/pydantic_ai/models/google.py

@@ -37,7 +37,7 @@
     UserPromptPart,
     VideoUrl,
 )
-from ..profiles import ModelProfileSpec
+from ..profiles import ModelProfile, ModelProfileSpec
 from ..profiles.google import GoogleModelProfile
 from ..providers import Provider, infer_provider
 from ..settings import ModelSettings
@@ -229,9 +229,8 @@ def system(self) -> str:
         """The model provider."""
         return self._provider.name
 
-    @classmethod
-    def supported_builtin_tools(cls) -> frozenset[type[AbstractBuiltinTool]]:
-        """Return the set of builtin tool types this model class can handle."""
+    def supported_builtin_tools(self, profile: ModelProfile) -> frozenset[type[AbstractBuiltinTool]]:
+        """Return the set of builtin tool types this model can handle."""
         return frozenset({WebSearchTool, CodeExecutionTool, WebFetchTool, ImageGenerationTool})
 
     def prepare_request(

pydantic_ai_slim/pydantic_ai/models/groq.py

@@ -179,9 +179,8 @@ def system(self) -> str:
         """The model provider."""
         return self._provider.name
 
-    @classmethod
-    def supported_builtin_tools(cls) -> frozenset[type[AbstractBuiltinTool]]:
-        """Return the set of builtin tool types this model class can handle."""
+    def supported_builtin_tools(self, profile: ModelProfile) -> frozenset[type[AbstractBuiltinTool]]:
+        """Return the set of builtin tool types this model can handle."""
         return frozenset({WebSearchTool})
 
     async def request(
@@ -389,7 +388,7 @@ def _get_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
-            else:
+            else:  # pragma: no cover
                 raise UserError(
                     f'`{tool.__class__.__name__}` is not supported by `GroqModel`. If it should be, please file an issue.'
                 )

pydantic_ai_slim/pydantic_ai/models/huggingface.py

@@ -229,7 +229,8 @@ async def _completions_create(
         else:
             tool_choice = 'auto'
 
-        if model_request_parameters.builtin_tools:
+        if model_request_parameters.builtin_tools:  # pragma: no cover
+            # this check is done in the base Model class - leave this as a placeholder for when Bedrock supports built-in tools
             raise UserError('HuggingFace does not support built-in tools')
 
         hf_messages = await self._map_messages(messages, model_request_parameters)

pydantic_ai_slim/pydantic_ai/models/mistral.py

@@ -224,7 +224,8 @@ async def _completions_create(
         """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:
+        if model_request_parameters.builtin_tools:  # pragma: no cover
+            # this check is done in the base Model class - leave this as a placeholder for when Bedrock supports built-in tools
             raise UserError('Mistral does not support built-in tools')
 
         try:

pydantic_ai_slim/pydantic_ai/models/openai.py

@@ -424,10 +424,15 @@ def system(self) -> str:
         """The model provider."""
         return self._provider.name
 
-    @classmethod
-    def supported_builtin_tools(cls) -> frozenset[type[AbstractBuiltinTool]]:
-        """Return the set of builtin tool types this model class can handle."""
-        return frozenset({WebSearchTool})
+    def supported_builtin_tools(self, profile: ModelProfile) -> frozenset[type[AbstractBuiltinTool]]:
+        """Return the set of builtin tool types this model can handle.
+
+        WebSearchTool is only supported if openai_chat_supports_web_search is True.
+        """
+        openai_profile = OpenAIModelProfile.from_profile(profile)
+        if openai_profile.openai_chat_supports_web_search:
+            return frozenset({WebSearchTool})
+        return frozenset()
 
     @property
     @deprecated('Set the `system_prompt_role` in the `OpenAIModelProfile` instead.')
@@ -699,12 +704,6 @@ def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[c
     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 not OpenAIModelProfile.from_profile(self.profile).openai_chat_supports_web_search:
-                    raise UserError(
-                        f'WebSearchTool is not supported with `OpenAIChatModel` and model {self.model_name!r}. '
-                        f'Please use `OpenAIResponsesModel` instead.'
-                    )
-
                 if tool.user_location:
                     return WebSearchOptions(
                         search_context_size=tool.search_context_size,
@@ -714,10 +713,7 @@ def _get_web_search_options(self, model_request_parameters: ModelRequestParamete
                         ),
                     )
                 return WebSearchOptions(search_context_size=tool.search_context_size)
-            else:
-                raise UserError(
-                    f'`{tool.__class__.__name__}` is not supported by `OpenAIChatModel`. If it should be, please file an issue.'
-                )
+        return None
 
     @dataclass
     class _MapModelResponseContext:
@@ -1096,9 +1092,8 @@ def system(self) -> str:
         """The model provider."""
         return self._provider.name
 
-    @classmethod
-    def supported_builtin_tools(cls) -> frozenset[type[AbstractBuiltinTool]]:
-        """Return the set of builtin tool types this model class can handle."""
+    def supported_builtin_tools(self, profile: ModelProfile) -> frozenset[type[AbstractBuiltinTool]]:
+        """Return the set of builtin tool types this model can handle."""
         return frozenset({WebSearchTool, CodeExecutionTool, MCPServerTool, ImageGenerationTool})
 
     async def request(