fast-agent-mcp 0.2.43__py3-none-any.whl → 0.2.45__py3-none-any.whl

mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -1,6 +1,7 @@
-from typing import TYPE_CHECKING, List, Tuple, Type
+import json
+from typing import TYPE_CHECKING, Any, List, Tuple, Type
 
-from mcp.types import EmbeddedResource, ImageContent, TextContent
+from mcp.types import TextContent
 
 from mcp_agent.core.prompt import Prompt
 from mcp_agent.event_progress import ProgressAction
@@ -33,6 +34,8 @@ from anthropic.types import (
 from mcp.types import (
     CallToolRequest,
     CallToolRequestParams,
+    CallToolResult,
+    ContentBlock,
 )
 from rich.text import Text
 
@@ -98,6 +101,184 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             cache_mode = self.context.config.anthropic.cache_mode
         return cache_mode
 
+    async def _prepare_tools(self, structured_model: Type[ModelT] | None = None) -> List[ToolParam]:
+        """Prepare tools based on whether we're in structured output mode."""
+        if structured_model:
+            # JSON mode - create a single tool for structured output
+            return [
+                ToolParam(
+                    name="return_structured_output",
+                    description="Return the response in the required JSON format",
+                    input_schema=structured_model.model_json_schema(),
+                )
+            ]
+        else:
+            # Regular mode - use tools from aggregator
+            tool_list: ListToolsResult = await self.aggregator.list_tools()
+            return [
+                ToolParam(
+                    name=tool.name,
+                    description=tool.description or "",
+                    input_schema=tool.inputSchema,
+                )
+                for tool in tool_list.tools
+            ]
+
+    def _apply_system_cache(self, base_args: dict, cache_mode: str) -> None:
+        """Apply cache control to system prompt if cache mode allows it."""
+        if cache_mode != "off" and base_args["system"]:
+            if isinstance(base_args["system"], str):
+                base_args["system"] = [
+                    {
+                        "type": "text",
+                        "text": base_args["system"],
+                        "cache_control": {"type": "ephemeral"},
+                    }
+                ]
+                self.logger.debug(
+                    "Applied cache_control to system prompt (caches tools+system in one block)"
+                )
+            else:
+                self.logger.debug(f"System prompt is not a string: {type(base_args['system'])}")
+
+    async def _apply_conversation_cache(self, messages: List[MessageParam], cache_mode: str) -> int:
+        """Apply conversation caching if in auto mode. Returns number of cache blocks applied."""
+        applied_count = 0
+        if cache_mode == "auto" and self.history.should_apply_conversation_cache():
+            cache_updates = self.history.get_conversation_cache_updates()
+
+            # Remove cache control from old positions
+            if cache_updates["remove"]:
+                self.history.remove_cache_control_from_messages(messages, cache_updates["remove"])
+                self.logger.debug(
+                    f"Removed conversation cache_control from positions {cache_updates['remove']}"
+                )
+
+            # Add cache control to new positions
+            if cache_updates["add"]:
+                applied_count = self.history.add_cache_control_to_messages(
+                    messages, cache_updates["add"]
+                )
+                if applied_count > 0:
+                    self.history.apply_conversation_cache_updates(cache_updates)
+                    self.logger.debug(
+                        f"Applied conversation cache_control to positions {cache_updates['add']} ({applied_count} blocks)"
+                    )
+                else:
+                    self.logger.debug(
+                        f"Failed to apply conversation cache_control to positions {cache_updates['add']}"
+                    )
+
+        return applied_count
+
+    async def _process_structured_output(
+        self,
+        content_block: Any,
+    ) -> Tuple[str, CallToolResult, TextContent]:
+        """
+        Process a structured output tool call from Anthropic.
+
+        This handles the special case where Anthropic's model was forced to use
+        a 'return_structured_output' tool via tool_choice. The tool input contains
+        the JSON data we want, so we extract it and format it for display.
+
+        Even though we don't call an external tool, we must create a CallToolResult
+        to satisfy Anthropic's API requirement that every tool_use has a corresponding
+        tool_result in the next message.
+
+        Returns:
+            Tuple of (tool_use_id, tool_result, content_block) for the structured data
+        """
+        tool_args = content_block.input
+        tool_use_id = content_block.id
+
+        # Show the formatted JSON response to the user
+        json_response = json.dumps(tool_args, indent=2)
+        await self.show_assistant_message(json_response)
+
+        # Create the content for responses
+        structured_content = TextContent(type="text", text=json.dumps(tool_args))
+
+        # Create a CallToolResult to satisfy Anthropic's API requirements
+        # This represents the "result" of our structured output "tool"
+        tool_result = CallToolResult(isError=False, content=[structured_content])
+
+        return tool_use_id, tool_result, structured_content
+
+    async def _process_regular_tool_call(
+        self,
+        content_block: Any,
+        available_tools: List[ToolParam],
+        is_first_tool: bool,
+        message_text: str | Text,
+    ) -> Tuple[str, CallToolResult]:
+        """
+        Process a regular MCP tool call.
+
+        This handles actual tool execution via the MCP aggregator.
+        """
+        tool_name = content_block.name
+        tool_args = content_block.input
+        tool_use_id = content_block.id
+
+        if is_first_tool:
+            await self.show_assistant_message(message_text, tool_name)
+
+        self.show_tool_call(available_tools, tool_name, tool_args)
+        tool_call_request = CallToolRequest(
+            method="tools/call",
+            params=CallToolRequestParams(name=tool_name, arguments=tool_args),
+        )
+        result = await self.call_tool(request=tool_call_request, tool_call_id=tool_use_id)
+        self.show_tool_result(result)
+        return tool_use_id, result
+
+    async def _process_tool_calls(
+        self,
+        tool_uses: List[Any],
+        available_tools: List[ToolParam],
+        message_text: str | Text,
+        structured_model: Type[ModelT] | None = None,
+    ) -> Tuple[List[Tuple[str, CallToolResult]], List[ContentBlock]]:
+        """
+        Process tool calls, handling both structured output and regular MCP tools.
+
+        For structured output mode:
+        - Extracts JSON data from the forced 'return_structured_output' tool
+        - Does NOT create fake CallToolResults
+        - Returns the JSON content directly
+
+        For regular tools:
+        - Calls actual MCP tools via the aggregator
+        - Returns real CallToolResults
+        """
+        tool_results = []
+        responses = []
+
+        for tool_idx, content_block in enumerate(tool_uses):
+            tool_name = content_block.name
+            is_first_tool = tool_idx == 0
+
+            if tool_name == "return_structured_output" and structured_model:
+                # Structured output: extract JSON, don't call external tools
+                (
+                    tool_use_id,
+                    tool_result,
+                    structured_content,
+                ) = await self._process_structured_output(content_block)
+                responses.append(structured_content)
+                # Add to tool_results to satisfy Anthropic's API requirement for tool_result messages
+                tool_results.append((tool_use_id, tool_result))
+            else:
+                # Regular tool: call external MCP tool
+                tool_use_id, tool_result = await self._process_regular_tool_call(
+                    content_block, available_tools, is_first_tool, message_text
+                )
+                tool_results.append((tool_use_id, tool_result))
+                responses.extend(tool_result.content)
+
+        return tool_results, responses
+
     async def _process_stream(self, stream: AsyncMessageStream, model: str) -> Message:
         """Process the streaming response and display real-time token usage."""
         # Track estimated output tokens by counting text chunks
@@ -149,7 +330,8 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         self,
         message_param,
         request_params: RequestParams | None = None,
-    ) -> list[TextContent | ImageContent | EmbeddedResource]:
+        structured_model: Type[ModelT] | None = None,
+    ) -> list[ContentBlock]:
         """
         Process a query using an LLM and available tools.
         Override this method to use a different LLM.
@@ -180,17 +362,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         cache_mode = self._get_cache_mode()
         self.logger.debug(f"Anthropic cache_mode: {cache_mode}")
 
-        tool_list: ListToolsResult = await self.aggregator.list_tools()
-        available_tools: List[ToolParam] = [
-            ToolParam(
-                name=tool.name,
-                description=tool.description or "",
-                input_schema=tool.inputSchema,
-            )
-            for tool in tool_list.tools
-        ]
+        available_tools = await self._prepare_tools(structured_model)
 
-        responses: List[TextContent | ImageContent | EmbeddedResource] = []
+        responses: List[ContentBlock] = []
 
         model = self.default_request_params.model
 
@@ -208,59 +382,25 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 "tools": available_tools,
             }
 
-            # Apply cache_control to system prompt if cache_mode is not "off"
-            # This caches both tools and system prompt together in one cache block
-            if cache_mode != "off" and base_args["system"]:
-                if isinstance(base_args["system"], str):
-                    base_args["system"] = [
-                        {
-                            "type": "text",
-                            "text": base_args["system"],
-                            "cache_control": {"type": "ephemeral"},
-                        }
-                    ]
-                    self.logger.debug(
-                        "Applied cache_control to system prompt (caches tools+system in one block)"
-                    )
-                else:
-                    self.logger.debug(f"System prompt is not a string: {type(base_args['system'])}")
+            # Add tool_choice for structured output mode
+            if structured_model:
+                base_args["tool_choice"] = {"type": "tool", "name": "return_structured_output"}
 
-            # Apply conversation caching using walking algorithm if in auto mode
-            if cache_mode == "auto" and self.history.should_apply_conversation_cache():
-                cache_updates = self.history.get_conversation_cache_updates()
+            # Apply cache control to system prompt
+            self._apply_system_cache(base_args, cache_mode)
 
-                # Remove cache control from old positions
-                if cache_updates["remove"]:
-                    self.history.remove_cache_control_from_messages(
-                        messages, cache_updates["remove"]
-                    )
-                    self.logger.debug(
-                        f"Removed conversation cache_control from positions {cache_updates['remove']}"
-                    )
+            # Apply conversation caching
+            applied_count = await self._apply_conversation_cache(messages, cache_mode)
 
-                # Add cache control to new positions
-                if cache_updates["add"]:
-                    applied_count = self.history.add_cache_control_to_messages(
-                        messages, cache_updates["add"]
+            # Verify we don't exceed Anthropic's 4 cache block limit
+            if applied_count > 0:
+                total_cache_blocks = applied_count
+                if cache_mode != "off" and base_args["system"]:
+                    total_cache_blocks += 1  # tools+system cache block
+                if total_cache_blocks > 4:
+                    self.logger.warning(
+                        f"Total cache blocks ({total_cache_blocks}) exceeds Anthropic limit of 4"
                     )
-                    if applied_count > 0:
-                        self.history.apply_conversation_cache_updates(cache_updates)
-                        self.logger.debug(
-                            f"Applied conversation cache_control to positions {cache_updates['add']} ({applied_count} blocks)"
-                        )
-
-                        # Verify we don't exceed Anthropic's 4 cache block limit
-                        total_cache_blocks = applied_count
-                        if cache_mode != "off" and base_args["system"]:
-                            total_cache_blocks += 1  # tools+system cache block
-                        if total_cache_blocks > 4:
-                            self.logger.warning(
-                                f"Total cache blocks ({total_cache_blocks}) exceeds Anthropic limit of 4"
-                            )
-                    else:
-                        self.logger.debug(
-                            f"Failed to apply conversation cache_control to positions {cache_updates['add']}"
-                        )
 
             if params.maxTokens is not None:
                 base_args["max_tokens"] = params.maxTokens
@@ -386,34 +526,22 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                             style="dim green italic",
                         )
 
-                    # Process all tool calls and collect results
-                    tool_results = []
-                    # Use a different loop variable for tool enumeration if 'i' is outer loop counter
-                    for tool_idx, content_block in enumerate(tool_uses):
-                        tool_name = content_block.name
-                        tool_args = content_block.input
-                        tool_use_id = content_block.id
-
-                        if tool_idx == 0:  # Only show message for first tool use
-                            await self.show_assistant_message(message_text, tool_name)
-
-                        self.show_tool_call(available_tools, tool_name, tool_args)
-                        tool_call_request = CallToolRequest(
-                            method="tools/call",
-                            params=CallToolRequestParams(name=tool_name, arguments=tool_args),
-                        )
-                        # TODO -- support MCP isError etc.
-                        result = await self.call_tool(
-                            request=tool_call_request, tool_call_id=tool_use_id
-                        )
-                        self.show_tool_result(result)
-
-                        # Add each result to our collection
-                        tool_results.append((tool_use_id, result))
-                        responses.extend(result.content)
+                    # Process all tool calls using the helper method
+                    tool_results, tool_responses = await self._process_tool_calls(
+                        tool_uses, available_tools, message_text, structured_model
+                    )
+                    responses.extend(tool_responses)
 
+                    # Always add tool_results_message first (required by Anthropic API)
                     messages.append(AnthropicConverter.create_tool_results_message(tool_results))
 
+                    # For structured output, we have our result and should exit after sending tool_result
+                    if structured_model and any(
+                        tool.name == "return_structured_output" for tool in tool_uses
+                    ):
+                        self.logger.debug("Structured output received, breaking iteration loop")
+                        break
+
         # Only save the new conversation messages to history if use_history is true
         # Keep the prompt messages separate
         if params.use_history:
@@ -500,19 +628,51 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
     ) -> Tuple[ModelT | None, PromptMessageMultipart]:  # noqa: F821
         request_params = self.get_request_params(request_params)
 
-        # TODO - convert this to use Tool Calling convention for Anthropic Structured outputs
-        multipart_messages[-1].add_text(
-            """YOU MUST RESPOND IN THE FOLLOWING FORMAT:
-            {schema}
-            RESPOND ONLY WITH THE JSON, NO PREAMBLE, CODE FENCES OR 'properties' ARE PERMISSABLE """.format(
-                schema=model.model_json_schema()
-            )
-        )
+        # Check the last message role
+        last_message = multipart_messages[-1]
 
-        result: PromptMessageMultipart = await self._apply_prompt_provider_specific(
-            multipart_messages, request_params
+        # Add all previous messages to history (or all messages if last is from assistant)
+        messages_to_add = (
+            multipart_messages[:-1] if last_message.role == "user" else multipart_messages
         )
-        return self._structured_from_multipart(result, model)
+        converted = []
+
+        for msg in messages_to_add:
+            anthropic_msg = AnthropicConverter.convert_to_anthropic(msg)
+            converted.append(anthropic_msg)
+
+        self.history.extend(converted, is_prompt=False)
+
+        if last_message.role == "user":
+            self.logger.debug("Last message in prompt is from user, generating structured response")
+            message_param = AnthropicConverter.convert_to_anthropic(last_message)
+
+            # Call _anthropic_completion with the structured model
+            response_content = await self._anthropic_completion(
+                message_param, request_params, structured_model=model
+            )
+
+            # Extract the structured data from the response
+            for content in response_content:
+                if content.type == "text":
+                    try:
+                        # Parse the JSON response from the tool
+                        data = json.loads(content.text)
+                        parsed_model = model(**data)
+                        # Create assistant response
+                        assistant_response = Prompt.assistant(content)
+                        return parsed_model, assistant_response
+                    except (json.JSONDecodeError, ValueError) as e:
+                        self.logger.error(f"Failed to parse structured output: {e}")
+                        assistant_response = Prompt.assistant(content)
+                        return None, assistant_response
+
+            # If no valid response found
+            return None, Prompt.assistant()
+        else:
+            # For assistant messages: Return the last message content
+            self.logger.debug("Last message in prompt is from assistant, returning it directly")
+            return None, last_message
 
     def _show_usage(self, raw_usage: Usage, turn_usage: TurnUsage) -> None:
         # Print raw usage for debugging

mcp_agent/llm/providers/augmented_llm_bedrock.py

@@ -4,7 +4,7 @@ import re
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Dict, List, Tuple, Type, Union
 
-from mcp.types import EmbeddedResource, ImageContent, TextContent
+from mcp.types import ContentBlock, TextContent
 from rich.text import Text
 
 from mcp_agent.core.exceptions import ProviderKeyError
@@ -1066,7 +1066,7 @@ class BedrockAugmentedLLM(AugmentedLLM[BedrockMessageParam, BedrockMessage]):
         self,
         message_param: BedrockMessageParam,
         request_params: RequestParams | None = None,
-    ) -> List[TextContent | ImageContent | EmbeddedResource]:
+    ) -> List[ContentBlock | CallToolRequestParams]:
         """
         Process a query using Bedrock and available tools.
         """
@@ -1120,7 +1120,7 @@ class BedrockAugmentedLLM(AugmentedLLM[BedrockMessageParam, BedrockMessage]):
                 f"Model {model_to_check} does not support tool use - skipping tool preparation"
             )
 
-        responses: List[TextContent | ImageContent | EmbeddedResource] = []
+        responses: List[ContentBlock] = []
         model = self.default_request_params.model
 
         for i in range(params.max_iterations):

mcp_agent/llm/providers/augmented_llm_google_native.py

@@ -10,8 +10,7 @@ from mcp.types import (
     CallToolRequest,
     CallToolRequestParams,
     CallToolResult,
-    EmbeddedResource,
-    ImageContent,
+    ContentBlock,
     TextContent,
 )
 from rich.text import Text
@@ -228,12 +227,12 @@ class GoogleNativeAugmentedLLM(AugmentedLLM[types.Content, types.Content]):
     async def _google_completion(
         self,
         request_params: RequestParams | None = None,
-    ) -> List[TextContent | ImageContent | EmbeddedResource]:
+    ) -> List[ContentBlock]:
         """
         Process a query using Google's generate_content API and available tools.
         """
         request_params = self.get_request_params(request_params=request_params)
-        responses: List[TextContent | ImageContent | EmbeddedResource] = []
+        responses: List[ContentBlock] = []
 
         # Load full conversation history if use_history is true
         if request_params.use_history:
@@ -376,9 +375,7 @@ class GoogleNativeAugmentedLLM(AugmentedLLM[types.Content, types.Content]):
 
                     # Execute the tool call. google.genai does not provide a tool_call_id, pass None.
                     result = await self.call_tool(tool_call_request, None)
-                    self.show_oai_tool_result(
-                        str(result.content)
-                    )  # Use show_oai_tool_result for consistency
+                    self.show_tool_result(result)
 
                     tool_results.append((tool_call_params.name, result))  # Store name and result
 

mcp_agent/llm/providers/augmented_llm_openai.py

@@ -4,8 +4,7 @@ from mcp.types import (
     CallToolRequest,
     CallToolRequestParams,
     CallToolResult,
-    EmbeddedResource,
-    ImageContent,
+    ContentBlock,
     TextContent,
 )
 from openai import AsyncOpenAI, AuthenticationError
@@ -298,7 +297,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
         self,
         message: OpenAIMessage,
         request_params: RequestParams | None = None,
-    ) -> List[TextContent | ImageContent | EmbeddedResource]:
+    ) -> List[ContentBlock]:
         """
         Process a query using an LLM and available tools.
         The default implementation uses OpenAI's ChatCompletion as the LLM.
@@ -307,7 +306,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
         request_params = self.get_request_params(request_params=request_params)
 
-        responses: List[TextContent | ImageContent | EmbeddedResource] = []
+        responses: List[ContentBlock] = []
 
         # TODO -- move this in to agent context management / agent group handling
         messages: List[ChatCompletionMessageParam] = []
@@ -427,7 +426,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
                         ),
                     )
                     result = await self.call_tool(tool_call_request, tool_call.id)
-                    self.show_oai_tool_result(str(result))
+                    self.show_tool_result(result)
 
                     tool_results.append((tool_call.id, result))
                     responses.extend(result.content)
@@ -511,9 +510,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
 
         # For assistant messages: Return the last message (no completion needed)
         message_param: OpenAIMessage = OpenAIConverter.convert_to_openai(last_message)
-        responses: List[
-            TextContent | ImageContent | EmbeddedResource
-        ] = await self._openai_completion(
+        responses: List[ContentBlock] = await self._openai_completion(
             message_param,
             request_params,
         )

mcp_agent/llm/providers/augmented_llm_tensorzero.py

@@ -5,8 +5,7 @@ from mcp.types import (
     CallToolRequest,
     CallToolRequestParams,
     CallToolResult,
-    EmbeddedResource,
-    ImageContent,
+    ContentBlock,
     TextContent,
 )
 from tensorzero import AsyncTensorZeroGateway
@@ -169,7 +168,7 @@ class TensorZeroAugmentedLLM(AugmentedLLM[Dict[str, Any], Any]):
         available_tools: Optional[List[Dict[str, Any]]] = await self._prepare_t0_tools()
 
         # [3] Initialize storage arrays for the text content of the assistant message reply and, optionally, tool calls and results, and begin inference loop
-        final_assistant_message: List[Union[TextContent, ImageContent, EmbeddedResource]] = []
+        final_assistant_message: List[ContentBlock] = []
         last_executed_results: Optional[List[CallToolResult]] = None
 
         for i in range(merged_params.max_iterations):
@@ -353,11 +352,11 @@ class TensorZeroAugmentedLLM(AugmentedLLM[Dict[str, Any], Any]):
         completion: Union[ChatInferenceResponse, JsonInferenceResponse],
         available_tools_for_display: Optional[List[Dict[str, Any]]] = None,
     ) -> Tuple[
-        List[Union[TextContent, ImageContent, EmbeddedResource]],  # Text/Image content ONLY
+        List[Union[ContentBlock]],  # Text/Image content ONLY
         List[CallToolResult],  # Executed results
         List[Any],  # Raw tool_call blocks
     ]:
-        content_parts_this_turn: List[Union[TextContent, ImageContent, EmbeddedResource]] = []
+        content_parts_this_turn: List[ContentBlock] = []
         executed_tool_results: List[CallToolResult] = []
         raw_tool_call_blocks_from_t0: List[Any] = []
 
@@ -402,7 +401,7 @@ class TensorZeroAugmentedLLM(AugmentedLLM[Dict[str, Any], Any]):
                             setattr(result, "_t0_tool_name_temp", tool_name)
                             setattr(result, "_t0_is_error_temp", False)
                             executed_tool_results.append(result)
-                            self.show_oai_tool_result(str(result))
+                            self.show_tool_result(result)
                         except Exception as e:
                             self.logger.error(
                                 f"Error executing tool {tool_name} (id: {tool_use_id}): {e}"
@@ -415,7 +414,7 @@ class TensorZeroAugmentedLLM(AugmentedLLM[Dict[str, Any], Any]):
                             setattr(error_result, "_t0_tool_name_temp", tool_name)
                             setattr(error_result, "_t0_is_error_temp", True)
                             executed_tool_results.append(error_result)
-                            self.show_oai_tool_result(f"ERROR: {error_text}")
+                            self.show_tool_result(error_result)
 
                 elif block_type == "thought":
                     thought_text = getattr(block, "text", None)

mcp_agent/llm/providers/google_converter.py

@@ -8,6 +8,7 @@ from mcp.types import (
     CallToolRequest,
     CallToolRequestParams,
     CallToolResult,
+    ContentBlock,
     EmbeddedResource,
     ImageContent,
     TextContent,
@@ -158,17 +159,15 @@ class GoogleConverter:
 
     def convert_from_google_content(
         self, content: types.Content
-    ) -> List[TextContent | ImageContent | EmbeddedResource | CallToolRequestParams]:
+    ) -> List[ContentBlock | CallToolRequestParams]:
         """
         Converts google.genai types.Content from a model response to a list of
         fast-agent content types or tool call requests.
         """
-        fast_agent_parts: List[
-            TextContent | ImageContent | EmbeddedResource | CallToolRequestParams
-        ] = []
+        fast_agent_parts: List[ContentBlock | CallToolRequestParams] = []
 
-        if content is None or not hasattr(content, 'parts') or content.parts is None:
-                    return [] # Google API response 'content' object is None. Cannot extract parts.
+        if content is None or not hasattr(content, "parts") or content.parts is None:
+            return []  # Google API response 'content' object is None. Cannot extract parts.
 
         for part in content.parts:
             if part.text:
@@ -340,9 +339,7 @@ class GoogleConverter:
         if content.role == "model" and any(part.function_call for part in content.parts):
             return PromptMessageMultipart(role="assistant", content=[])
 
-        fast_agent_parts: List[
-            TextContent | ImageContent | EmbeddedResource | CallToolRequestParams
-        ] = []
+        fast_agent_parts: List[ContentBlock | CallToolRequestParams] = []
         for part in content.parts:
             if part.text:
                 fast_agent_parts.append(TextContent(type="text", text=part.text))

mcp_agent/llm/providers/multipart_converter_anthropic.py

@@ -16,6 +16,7 @@ from anthropic.types import (
 from mcp.types import (
     BlobResourceContents,
     CallToolResult,
+    ContentBlock,
     EmbeddedResource,
     ImageContent,
     PromptMessage,
@@ -117,7 +118,7 @@ class AnthropicConverter:
 
     @staticmethod
     def _convert_content_items(
-        content_items: Sequence[Union[TextContent, ImageContent, EmbeddedResource]],
+        content_items: Sequence[ContentBlock],
         document_mode: bool = True,
     ) -> List[ContentBlockParam]:
         """
@@ -210,7 +211,7 @@ class AnthropicConverter:
                 return ImageBlockParam(
                     type="image", source=URLImageSourceParam(type="url", url=uri_str)
                 )
-            
+
             # Try to get image data
             image_data = get_image_data(resource)
             if image_data:
@@ -220,7 +221,7 @@ class AnthropicConverter:
                         type="base64", media_type=mime_type, data=image_data
                     ),
                 )
-            
+
             return AnthropicConverter._create_fallback_text("Image missing data", resource)
 
         elif mime_type == "application/pdf":
@@ -450,4 +451,4 @@ class AnthropicConverter:
             # Add separate blocks directly to the message
             content_blocks.extend(separate_blocks)
 
-        return MessageParam(role="user", content=content_blocks)
+        return MessageParam(role="user", content=content_blocks)