Addressing comments

Author: Artui

docs/builtin-tools.md

@@ -448,9 +448,9 @@ agent = Agent(
     'anthropic:claude-sonnet-4-0',
     builtin_tools=[
         MCPServerTool(
-            server_label='your-mcp-server',
-            server_url='https://example.com/mcp-server',
-            server_description='Your MCP Server',
+            label='your-mcp-server',
+            url='https://example.com/mcp-server',
+            description='Your MCP Server',
             authorization='$YOUR_AUTHORIZATION_TOKEN',
         )
     ]
@@ -472,9 +472,9 @@ agent = Agent(
     'openai-responses:gpt-4o',
     builtin_tools=[
         MCPServerTool(
-            server_label='your-mcp-server',
-            server_url='https://example.com/mcp-server',
-            server_description='Your MCP Server',
+            label='your-mcp-server',
+            url='https://example.com/mcp-server',
+            description='Your MCP Server',
             authorization='$YOUR_AUTHORIZATION_TOKEN',
         )
     ]
@@ -498,9 +498,9 @@ agent = Agent(
     'openai-responses:gpt-4o',
     builtin_tools=[
         MCPServerTool(
-            server_label='your-mcp-server',
-            server_url='https://example.com/mcp-server',
-            server_description='Your MCP Server',
+            label='your-mcp-server',
+            url='https://example.com/mcp-server',
+            description='Your MCP Server',
             authorization='$YOUR_AUTHORIZATION_TOKEN',
             allowed_tools=['tool-1', 'tool-2'],
             headers={'X-CUSTOM-HEADER': 'custom-value'},

pydantic_ai_slim/pydantic_ai/builtin_tools.py

@@ -251,28 +251,53 @@ class MCPServerTool(AbstractBuiltinTool):
 
     kind: str = 'mcp_server'
 
-    server_label: str
+    label: str
     """The label of the MCP server to use."""
 
-    server_url: str
-    """The URL of the MCP server to use."""
-
-    server_description: str
+    description: str
     """A description of the MCP server."""
 
-    allowed_tools: list[str] | None = None
-    """A list of tools that the MCP server can use."""
-
     authorization: str
     """Authorization header to use when making requests to the MCP server."""
 
+    url: str | None = None
+    """The URL of the MCP server to use.
+
+    For OpenAI Responses, one of `url` or `connector_id` must be provided.
+    """
+
+    allowed_tools: list[str] | None = None
+    """A list of tools that the MCP server can use.
+
+    Supported by:
+
+    * OpenAI Responses
+    * Anthropic
+    """
+
     headers: dict[str, str] | None = None
     """Optional HTTP headers to send to the MCP server.
 
     Use for authentication or other purposes.
+
+    Supported by:
+
+    * OpenAI Responses
     """
 
-    connector_id: str | None = None
+    connector_id: (
+        Literal[
+            'connector_dropbox',
+            'connector_gmail',
+            'connector_googlecalendar',
+            'connector_googledrive',
+            'connector_microsoftteams',
+            'connector_outlookcalendar',
+            'connector_outlookemail',
+            'connector_sharepoint',
+        ]
+        | None
+    ) = None
     """The ID of the connector to use.
 
     Supported by:

pydantic_ai_slim/pydantic_ai/models/anthropic.py

@@ -70,6 +70,7 @@
         BetaInputJSONDelta,
         BetaMCPToolResultBlock,
         BetaMCPToolUseBlock,
+        BetaMCPToolUseBlockParam,
         BetaMemoryTool20250818Param,
         BetaMessage,
         BetaMessageParam,
@@ -268,8 +269,7 @@ async def _messages_create(
     ) -> BetaMessage | AsyncStream[BetaRawMessageStreamEvent]:
         # standalone function to make it easier to override
         tools = self._get_tools(model_request_parameters)
-        tools, beta_features = self._add_builtin_tools(tools, model_request_parameters)
-        mcp_servers, beta_features = self._get_mcp_servers(model_request_parameters, beta_features)
+        tools, mcp_servers, beta_features = self._add_builtin_tools(tools, model_request_parameters)
 
         tool_choice: BetaToolChoiceParam | None
 
@@ -325,8 +325,6 @@ def _process_response(self, response: BetaMessage) -> ModelResponse:
         """Process a non-streamed response, and prepare a message to return."""
         items: list[ModelResponsePart] = []
         for item in response.content:
-            from anthropic.types.beta import BetaMCPToolUseBlock
-
             if isinstance(item, BetaTextBlock):
                 items.append(TextPart(content=item.text))
             elif isinstance(item, BetaServerToolUseBlock):
@@ -395,8 +393,9 @@ def _get_tools(self, model_request_parameters: ModelRequestParameters) -> list[B
 
     def _add_builtin_tools(
         self, tools: list[BetaToolUnionParam], model_request_parameters: ModelRequestParameters
-    ) -> tuple[list[BetaToolUnionParam], list[str]]:
+    ) -> tuple[list[BetaToolUnionParam], list[BetaRequestMCPServerURLDefinitionParam], list[str]]:
         beta_features: list[str] = []
+        mcp_servers: list[BetaRequestMCPServerURLDefinitionParam] = []
         for tool in model_request_parameters.builtin_tools:
             if isinstance(tool, WebSearchTool):
                 user_location = UserLocation(type='approximate', **tool.user_location) if tool.user_location else None
@@ -420,36 +419,26 @@ def _add_builtin_tools(
                 tools = [tool for tool in tools if tool['name'] != 'memory']
                 tools.append(BetaMemoryTool20250818Param(name='memory', type='memory_20250818'))
                 beta_features.append('context-management-2025-06-27')
-            elif isinstance(tool, MCPServerTool):
-                # Anthropic MCP servers are a separate parameter in the API call
-                pass
+                if isinstance(tool, MCPServerTool) and tool.url:
+                    tool_configuration = BetaRequestMCPServerToolConfigurationParam(
+                        enabled=True,
+                        allowed_tools=tool.allowed_tools,
+                    )
+                    mcp_servers.append(
+                        BetaRequestMCPServerURLDefinitionParam(
+                            type='url',
+                            name=tool.label,
+                            url=tool.url,
+                            authorization_token=tool.authorization,
+                            tool_configuration=tool_configuration,
+                        )
+                    )
+                    beta_features.append('mcp-client-2025-04-04')
             else:  # pragma: no cover
                 raise UserError(
                     f'`{tool.__class__.__name__}` is not supported by `AnthropicModel`. If it should be, please file an issue.'
                 )
-        return tools, beta_features
-
-    def _get_mcp_servers(
-        self, model_request_parameters: ModelRequestParameters, beta_features: list[str]
-    ) -> tuple[list[BetaRequestMCPServerURLDefinitionParam], list[str]]:
-        mcp_servers: list[BetaRequestMCPServerURLDefinitionParam] = []
-        for tool in model_request_parameters.builtin_tools:
-            if isinstance(tool, MCPServerTool):
-                tool_configuration = BetaRequestMCPServerToolConfigurationParam(
-                    enabled=True,
-                    allowed_tools=tool.allowed_tools,
-                )
-                mcp_servers.append(
-                    BetaRequestMCPServerURLDefinitionParam(
-                        type='url',
-                        name=tool.server_label,
-                        url=tool.server_url,
-                        authorization_token=tool.authorization,
-                        tool_configuration=tool_configuration,
-                    )
-                )
-                beta_features.append('mcp-client-2025-04-04')
-        return mcp_servers, beta_features
+        return tools, mcp_servers, beta_features
 
     async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[BetaMessageParam]]:  # noqa: C901
         """Just maps a `pydantic_ai.Message` to a `anthropic.types.MessageParam`."""
@@ -495,6 +484,8 @@ async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[Be
                     | BetaCodeExecutionToolResultBlockParam
                     | BetaThinkingBlockParam
                     | BetaRedactedThinkingBlockParam
+                    | BetaMCPToolUseBlockParam
+                    | BetaMCPToolResultBlock
                 ] = []
                 for response_part in m.parts:
                     if isinstance(response_part, TextPart):
@@ -553,6 +544,16 @@ async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[Be
                                     input=response_part.args_as_dict(),
                                 )
                                 assistant_content_params.append(server_tool_use_block_param)
+                            elif response_part.tool_name == MCPServerTool.kind:  # pragma: no branch
+                                args = response_part.args_as_dict()
+                                mcp_tool_use_block_param = BetaMCPToolUseBlockParam(
+                                    id=tool_use_id,
+                                    type='mcp_tool_use',
+                                    name=response_part.tool_name,
+                                    server_name=cast(str, args.get('server_name')),
+                                    input=args.get('input'),
+                                )
+                                assistant_content_params.append(mcp_tool_use_block_param)
                     elif isinstance(response_part, BuiltinToolReturnPart):
                         if response_part.provider_name == self.system:
                             tool_use_id = _guard_tool_call_id(t=response_part)
@@ -584,6 +585,21 @@ async def _map_message(self, messages: list[ModelMessage]) -> tuple[str, list[Be
                                         ),
                                     )
                                 )
+                            elif response_part.tool_name in (  # pragma: no branch
+                                MCPServerTool.kind,
+                                'mcp_tool_result',  # Backward compatibility
+                            ) and isinstance(response_part.content, str | list):
+                                assistant_content_params.append(
+                                    BetaMCPToolResultBlock(
+                                        tool_use_id=tool_use_id,
+                                        type='mcp_tool_result',
+                                        content=cast(
+                                            str | list[BetaTextBlock],
+                                            response_part.content,  # pyright: ignore[reportUnknownMemberType]
+                                        ),
+                                        is_error=False,
+                                    )
+                                )
                     elif isinstance(response_part, FilePart):  # pragma: no cover
                         # Files generated by models are not sent back to models that don't themselves generate files.
                         pass
@@ -870,7 +886,7 @@ def _map_mcp_server_use_block(item: BetaMCPToolUseBlock, provider_name: str) ->
     return BuiltinToolCallPart(
         provider_name=provider_name,
         tool_name=MCPServerTool.kind,
-        args=cast(dict[str, Any], item.input) or None,
+        args=cast(dict[str, Any], {'input': item.input, 'server_name': item.server_name}) or None,
         tool_call_id=item.id,
     )
 
@@ -883,7 +899,7 @@ def _map_mcp_server_use_block(item: BetaMCPToolUseBlock, provider_name: str) ->
 def _map_mcp_server_result_block(item: BetaMCPToolResultBlock, provider_name: str) -> BuiltinToolReturnPart:
     return BuiltinToolReturnPart(
         provider_name=provider_name,
-        tool_name=CodeExecutionTool.kind,
+        tool_name=MCPServerTool.kind,
         content=mcp_server_result_content_ta.dump_python(item.content, mode='json'),
         tool_call_id=item.tool_use_id,
     )