Adding streaming support and test coverage

Author: Artui

pydantic_ai_slim/pydantic_ai/builtin_tools.py

@@ -243,16 +243,14 @@ class MCPServerTool(AbstractBuiltinTool):
     Supported by:
 
     * OpenAI Responses
+    * Anthropic
     """
 
     kind: str = 'mcp_server'
 
     server_label: str
     """The label of the MCP server to use."""
 
-    require_approval: Literal['never', 'always'] | None = None
-    """Whether to require approval before using the MCP server."""
-
     server_url: str
     """The URL of the MCP server to use."""
 
@@ -272,4 +270,9 @@ class MCPServerTool(AbstractBuiltinTool):
     """
 
     connector_id: str | None = None
-    """The ID of the connector to use."""
+    """The ID of the connector to use.
+
+    Supported by:
+
+    * OpenAI Responses
+    """

pydantic_ai_slim/pydantic_ai/models/anthropic.py

@@ -13,7 +13,7 @@
 from .. import ModelHTTPError, UnexpectedModelBehavior, _utils, usage
 from .._run_context import RunContext
 from .._utils import guard_tool_call_id as _guard_tool_call_id
-from ..builtin_tools import CodeExecutionTool, MemoryTool, WebSearchTool
+from ..builtin_tools import CodeExecutionTool, MCPServerTool, MemoryTool, WebSearchTool
 from ..exceptions import UserError
 from ..messages import (
     BinaryContent,
@@ -82,6 +82,8 @@
         BetaRawMessageStreamEvent,
         BetaRedactedThinkingBlock,
         BetaRedactedThinkingBlockParam,
+        BetaRequestMCPServerToolConfigurationParam,
+        BetaRequestMCPServerURLDefinitionParam,
         BetaServerToolUseBlock,
         BetaServerToolUseBlockParam,
         BetaSignatureDelta,
@@ -265,6 +267,7 @@ async def _messages_create(
         # 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 = self._get_mcp_servers(model_request_parameters)
 
         tool_choice: BetaToolChoiceParam | None
 
@@ -300,6 +303,7 @@ async def _messages_create(
                 model=self._model_name,
                 tools=tools or OMIT,
                 tool_choice=tool_choice or OMIT,
+                mcp_servers=mcp_servers or OMIT,
                 stream=stream,
                 thinking=model_settings.get('anthropic_thinking', OMIT),
                 stop_sequences=model_settings.get('stop_sequences', OMIT),
@@ -407,12 +411,40 @@ 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
             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
+    ) -> list[BetaRequestMCPServerURLDefinitionParam]:
+        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,
+                    )
+                    if tool.allowed_tools
+                    else None
+                )
+                mcp_servers.append(
+                    BetaRequestMCPServerURLDefinitionParam(
+                        type='url',
+                        name=tool.server_label,
+                        url=tool.server_url,
+                        authorization_token=tool.authorization,
+                        tool_configuration=tool_configuration,
+                    )
+                )
+        return mcp_servers
+
     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`."""
         system_prompt_parts: list[str] = []

pydantic_ai_slim/pydantic_ai/models/openai.py

@@ -1032,13 +1032,16 @@ def _process_response(  # noqa: C901
             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
+            elif isinstance(item, responses.response_output_item.McpCall):
+                call_part, return_part = _map_mcp_call(item, self.system)
+                items.append(call_part)
+                items.append(return_part)
+            elif isinstance(item, responses.response_output_item.McpListTools):
+                call_part, return_part = _map_mcp_list_tools(item, self.system)
+                items.append(call_part)
+                items.append(return_part)
+            elif isinstance(item, responses.response_output_item.McpApprovalRequest):
+                # Pydantic AI doesn't yet support McpApprovalRequest (explicit tool usage approval)
                 pass
 
         finish_reason: FinishReason | None = None
@@ -1235,7 +1238,7 @@ def _get_builtin_tools(self, model_request_parameters: ModelRequestParameters) -
                         server_description=tool.server_description,
                         allowed_tools=tool.allowed_tools,
                         authorization=tool.authorization,
-                        require_approval=tool.require_approval,
+                        require_approval='never',
                         headers=tool.headers,
                     )
                 )
@@ -1760,7 +1763,12 @@ async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
                 elif isinstance(chunk.item, responses.response_output_item.ImageGenerationCall):
                     call_part, _, _ = _map_image_generation_tool_call(chunk.item, self.provider_name)
                     yield self._parts_manager.handle_part(vendor_part_id=f'{chunk.item.id}-call', part=call_part)
-
+                elif isinstance(chunk.item, responses.response_output_item.McpCall):
+                    call_part, _ = _map_mcp_call(chunk.item, self.provider_name)
+                    yield self._parts_manager.handle_part(vendor_part_id=f'{chunk.item.id}-call', part=call_part)
+                elif isinstance(chunk.item, responses.response_output_item.McpListTools):
+                    call_part, _ = _map_mcp_list_tools(chunk.item, self.provider_name)
+                    yield self._parts_manager.handle_part(vendor_part_id=f'{chunk.item.id}-call', part=call_part)
                 else:
                     warnings.warn(  # pragma: no cover
                         f'Handling of this item type is not yet implemented. Please report on our GitHub: {chunk}',
@@ -1801,6 +1809,25 @@ async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
                         yield self._parts_manager.handle_part(vendor_part_id=f'{chunk.item.id}-file', part=file_part)
                     yield self._parts_manager.handle_part(vendor_part_id=f'{chunk.item.id}-return', part=return_part)
 
+                elif isinstance(chunk.item, responses.response_output_item.McpCall):
+                    call_part, return_part = _map_mcp_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_part(vendor_part_id=f'{chunk.item.id}-return', part=return_part)
+                elif isinstance(chunk.item, responses.response_output_item.McpListTools):
+                    call_part, return_part = _map_mcp_list_tools(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_part(vendor_part_id=f'{chunk.item.id}-return', part=return_part)
+
             elif isinstance(chunk, responses.ResponseReasoningSummaryPartAddedEvent):
                 yield self._parts_manager.handle_thinking_delta(
                     vendor_part_id=f'{chunk.item_id}-{chunk.summary_index}',
@@ -1895,6 +1922,33 @@ async def _get_event_iterator(self) -> AsyncIterator[ModelResponseStreamEvent]:
                 )
                 yield self._parts_manager.handle_part(vendor_part_id=f'{chunk.item_id}-file', part=file_part)
 
+            elif isinstance(chunk, responses.ResponseMcpCallArgumentsDeltaEvent):
+                maybe_event = self._parts_manager.handle_text_delta(
+                    vendor_part_id=chunk.item_id, content=chunk.delta, id=chunk.item_id
+                )
+                if maybe_event is not None:  # pragma: no branch
+                    yield maybe_event
+            elif isinstance(chunk, responses.ResponseMcpCallArgumentsDoneEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseMcpListToolsInProgressEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseMcpListToolsCompletedEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseMcpListToolsFailedEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseMcpCallInProgressEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseMcpCallFailedEvent):
+                pass  # there's nothing we need to do here
+
+            elif isinstance(chunk, responses.ResponseMcpCallCompletedEvent):
+                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}',
@@ -2106,3 +2160,59 @@ def _map_image_generation_tool_call(
         ),
         file_part,
     )
+
+
+def _map_mcp_list_tools(
+    item: responses.response_output_item.McpListTools, provider_name: str
+) -> tuple[BuiltinToolCallPart, BuiltinToolReturnPart]:
+    result = {
+        'server_label': item.server_label,
+        'tools': [
+            {
+                'name': tool.name,
+                'description': tool.description,
+                'input_schema': tool.input_schema,
+            }
+            for tool in item.tools
+        ],
+    }
+
+    return (
+        BuiltinToolCallPart(
+            tool_name=MCPServerTool.kind,
+            tool_call_id=item.id,
+            provider_name=provider_name,
+        ),
+        BuiltinToolReturnPart(
+            tool_name=MCPServerTool.kind,
+            tool_call_id=item.id,
+            content=result,
+            provider_name=provider_name,
+        ),
+    )
+
+
+def _map_mcp_call(
+    item: responses.response_output_item.McpCall, provider_name: str
+) -> tuple[BuiltinToolCallPart, BuiltinToolReturnPart]:
+    result = {
+        'name': item.name,
+        'server_label': item.server_label,
+        'arguments': item.arguments,
+        'error': item.error,
+        'output': item.output,
+    }
+
+    return (
+        BuiltinToolCallPart(
+            tool_name=MCPServerTool.kind,
+            tool_call_id=item.id,
+            provider_name=provider_name,
+        ),
+        BuiltinToolReturnPart(
+            tool_name=MCPServerTool.kind,
+            tool_call_id=item.id,
+            content=result,
+            provider_name=provider_name,
+        ),
+    )