fast-agent-mcp 0.2.58__py3-none-any.whl → 0.3.0__py3-none-any.whl

{mcp_agent/llm/providers → fast_agent/llm/provider/anthropic}/multipart_converter_anthropic.py

@@ -10,6 +10,7 @@ from anthropic.types import (
     PlainTextSourceParam,
     TextBlockParam,
     ToolResultBlockParam,
+    ToolUseBlockParam,
     URLImageSourceParam,
     URLPDFSourceParam,
 )
@@ -24,8 +25,8 @@ from mcp.types import (
     TextResourceContents,
 )
 
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.helpers.content_helpers import (
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.mcp.helpers.content_helpers import (
     get_image_data,
     get_resource_uri,
     get_text,
@@ -33,13 +34,12 @@ from mcp_agent.mcp.helpers.content_helpers import (
     is_resource_content,
     is_text_content,
 )
-from mcp_agent.mcp.mime_utils import (
+from fast_agent.mcp.mime_utils import (
     guess_mime_type,
     is_image_mime_type,
     is_text_mime_type,
 )
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.mcp.resource_utils import extract_title_from_uri
+from fast_agent.types import PromptMessageExtended
 
 _logger = get_logger("multipart_converter_anthropic")
 
@@ -63,41 +63,81 @@ class AnthropicConverter:
         return mime_type in SUPPORTED_IMAGE_MIME_TYPES
 
     @staticmethod
-    def convert_to_anthropic(multipart_msg: PromptMessageMultipart) -> MessageParam:
+    def convert_to_anthropic(multipart_msg: PromptMessageExtended) -> MessageParam:
         """
-        Convert a PromptMessageMultipart message to Anthropic API format.
+        Convert a PromptMessageExtended message to Anthropic API format.
 
         Args:
-            multipart_msg: The PromptMessageMultipart message to convert
+            multipart_msg: The PromptMessageExtended message to convert
 
         Returns:
             An Anthropic API MessageParam object
         """
         role = multipart_msg.role
+        all_content_blocks = []
+
+        # If this is an assistant message that contains tool_calls, convert
+        # those into Anthropic tool_use blocks so the next user message can
+        # legally include corresponding tool_result blocks.
+        if role == "assistant" and multipart_msg.tool_calls:
+            for tool_use_id, req in multipart_msg.tool_calls.items():
+                name = None
+                args = None
+                try:
+                    params = getattr(req, "params", None)
+                    if params is not None:
+                        name = getattr(params, "name", None)
+                        args = getattr(params, "arguments", None)
+                except Exception:
+                    pass
+
+                all_content_blocks.append(
+                    ToolUseBlockParam(
+                        type="tool_use",
+                        id=tool_use_id,
+                        name=name or "unknown_tool",
+                        input=args or {},
+                    )
+                )
 
-        # Handle empty content case - create an empty list instead of a text block
-        if not multipart_msg.content:
-            return MessageParam(role=role, content=[])
+            return MessageParam(role=role, content=all_content_blocks)
+
+        # Handle tool_results if present (for user messages with tool results)
+        # Tool results must come FIRST in the content array per Anthropic API requirements
+        if multipart_msg.tool_results:
+            # Convert dict to list of tuples for create_tool_results_message
+            tool_results_list = list(multipart_msg.tool_results.items())
+            tool_msg = AnthropicConverter.create_tool_results_message(tool_results_list)
+            # Extract the content blocks from the tool results message
+            all_content_blocks.extend(tool_msg["content"])
+
+        # Then handle regular content blocks if present
+        if multipart_msg.content:
+            # Convert content blocks
+            anthropic_blocks = AnthropicConverter._convert_content_items(
+                multipart_msg.content, document_mode=True
+            )
 
-        # Convert content blocks
-        anthropic_blocks = AnthropicConverter._convert_content_items(
-            multipart_msg.content, document_mode=True
-        )
+            # Filter blocks based on role (assistant can only have text blocks)
+            if role == "assistant":
+                text_blocks = []
+                for block in anthropic_blocks:
+                    if block.get("type") == "text":
+                        text_blocks.append(block)
+                    else:
+                        _logger.warning(
+                            f"Removing non-text block from assistant message: {block.get('type')}"
+                        )
+                anthropic_blocks = text_blocks
 
-        # Filter blocks based on role (assistant can only have text blocks)
-        if role == "assistant":
-            text_blocks = []
-            for block in anthropic_blocks:
-                if block.get("type") == "text":
-                    text_blocks.append(block)
-                else:
-                    _logger.warning(
-                        f"Removing non-text block from assistant message: {block.get('type')}"
-                    )
-            anthropic_blocks = text_blocks
+            all_content_blocks.extend(anthropic_blocks)
+
+        # Handle empty content case
+        if not all_content_blocks:
+            return MessageParam(role=role, content=[])
 
         # Create the Anthropic message
-        return MessageParam(role=role, content=anthropic_blocks)
+        return MessageParam(role=role, content=all_content_blocks)
 
     @staticmethod
     def convert_prompt_message_to_anthropic(message: PromptMessage) -> MessageParam:
@@ -110,8 +150,8 @@ class AnthropicConverter:
         Returns:
             An Anthropic API MessageParam object
         """
-        # Convert the PromptMessage to a PromptMessageMultipart containing a single content item
-        multipart = PromptMessageMultipart(role=message.role, content=[message.content])
+        # Convert the PromptMessage to a PromptMessageExtended containing a single content item
+        multipart = PromptMessageExtended(role=message.role, content=[message.content])
 
         # Use the existing conversion method
         return AnthropicConverter.convert_to_anthropic(multipart)
@@ -195,6 +235,8 @@ class AnthropicConverter:
         mime_type = AnthropicConverter._determine_mime_type(resource_content)
 
         # Extract title from URI
+        from fast_agent.mcp.resource_utils import extract_title_from_uri
+
         title = extract_title_from_uri(uri) if uri else "resource"
 
         # Convert based on MIME type
@@ -345,47 +387,6 @@ class AnthropicConverter:
 
         return TextBlockParam(type="text", text=f"[{message}]")
 
-    @staticmethod
-    def convert_tool_result_to_anthropic(
-        tool_result: CallToolResult, tool_use_id: str
-    ) -> ToolResultBlockParam:
-        """
-        Convert an MCP CallToolResult to an Anthropic ToolResultBlockParam.
-
-        Args:
-            tool_result: The tool result from a tool call
-            tool_use_id: The ID of the associated tool use
-
-        Returns:
-            An Anthropic ToolResultBlockParam ready to be included in a user message
-        """
-        # For tool results, always use document_mode=False to get text blocks instead of document blocks
-        anthropic_content = []
-
-        for item in tool_result.content:
-            if isinstance(item, EmbeddedResource):
-                # For embedded resources, always use text mode in tool results
-                resource_block = AnthropicConverter._convert_embedded_resource(
-                    item, document_mode=False
-                )
-                anthropic_content.append(resource_block)
-            elif isinstance(item, (TextContent, ImageContent)):
-                # For text and image, use standard conversion
-                blocks = AnthropicConverter._convert_content_items([item], document_mode=False)
-                anthropic_content.extend(blocks)
-
-        # If we ended up with no valid content blocks, create a placeholder
-        if not anthropic_content:
-            anthropic_content = [TextBlockParam(type="text", text="[No content in tool result]")]
-
-        # Create the tool result block
-        return ToolResultBlockParam(
-            type="tool_result",
-            tool_use_id=tool_use_id,
-            content=anthropic_content,
-            is_error=tool_result.isError,
-        )
-
     @staticmethod
     def create_tool_results_message(
         tool_results: List[tuple[str, CallToolResult]],
@@ -404,7 +405,6 @@ class AnthropicConverter:
         for tool_use_id, result in tool_results:
             # Process each tool result
             tool_result_blocks = []
-            separate_blocks = []
 
             # Process each content item in the result
             for item in result.content:
@@ -413,19 +413,13 @@ class AnthropicConverter:
                     tool_result_blocks.extend(blocks)
                 elif isinstance(item, EmbeddedResource):
                     resource_content = item.resource
-
-                    # Text resources go in tool results, others go as separate blocks
-                    if isinstance(resource_content, TextResourceContents):
-                        block = AnthropicConverter._convert_embedded_resource(
-                            item, document_mode=False
-                        )
-                        tool_result_blocks.append(block)
-                    else:
-                        # For binary resources like PDFs, add as separate block
-                        block = AnthropicConverter._convert_embedded_resource(
-                            item, document_mode=True
-                        )
-                        separate_blocks.append(block)
+                    document_mode: bool = not isinstance(resource_content, TextResourceContents)
+                    # With  Anthropic SDK 0.66, documents can be inside tool results
+                    # Text resources remain inline within the tool_result
+                    block = AnthropicConverter._convert_embedded_resource(
+                        item, document_mode=document_mode
+                    )
+                    tool_result_blocks.append(block)
 
             # Create the tool result block if we have content
             if tool_result_blocks:
@@ -448,7 +442,6 @@ class AnthropicConverter:
                     )
                 )
 
-            # Add separate blocks directly to the message
-            content_blocks.extend(separate_blocks)
+            # All content is now included within the tool_result block.
 
         return MessageParam(role="user", content=content_blocks)

{mcp_agent/llm/providers → fast_agent/llm/provider/bedrock}/bedrock_utils.py

@@ -120,7 +120,9 @@ def all_model_summaries(
     )
     provider_filter: Optional[Set[str]] = set(providers) if providers is not None else None
     effective_inference: Set[InferenceType] = (
-        set(inference_types) if inference_types is not None else {cast("InferenceType", "ON_DEMAND")}
+        set(inference_types)
+        if inference_types is not None
+        else {cast("InferenceType", "ON_DEMAND")}
     )
 
     for summary in cache.values():