fast-agent-mcp 0.1.10__py3-none-any.whl → 0.1.12__py3-none-any.whl

mcp_agent/workflows/llm/providers/multipart_converter_anthropic.py

@@ -1,4 +1,4 @@
-from typing import List, Union, Sequence
+from typing import List, Union, Sequence, Optional
 
 from mcp.types import (
     TextContent,
@@ -7,6 +7,7 @@ from mcp.types import (
     CallToolResult,
     TextResourceContents,
     BlobResourceContents,
+    PromptMessage,
 )
 from pydantic import AnyUrl
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
@@ -33,6 +34,7 @@ from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.resource_utils import extract_title_from_uri
 
 _logger = get_logger("multipart_converter_anthropic")
+
 # List of image MIME types supported by Anthropic API
 SUPPORTED_IMAGE_MIME_TYPES = {"image/jpeg", "image/png", "image/gif", "image/webp"}
 
@@ -41,59 +43,16 @@ class AnthropicConverter:
     """Converts MCP message types to Anthropic API format."""
 
     @staticmethod
-    def _convert_content_items(
-        content_items: Sequence[Union[TextContent, ImageContent, EmbeddedResource]],
-        documentMode: bool = True,
-    ) -> List[ContentBlockParam]:
-        """
-        Helper method to convert a list of content items to Anthropic format.
+    def _is_supported_image_type(mime_type: str) -> bool:
+        """Check if the given MIME type is supported by Anthropic's image API.
 
         Args:
-            content_items: Sequence of MCP content items
-            documentMode: Whether to convert text resources to document blocks (True) or text blocks (False)
+            mime_type: The MIME type to check
 
         Returns:
-            List of Anthropic content blocks
+            True if the MIME type is supported, False otherwise
         """
-
-        anthropic_blocks: List[ContentBlockParam] = []
-
-        for content_item in content_items:
-            if isinstance(content_item, TextContent):
-                anthropic_block = AnthropicConverter._convert_text_content(content_item)
-                anthropic_blocks.append(anthropic_block)
-            elif isinstance(content_item, ImageContent):
-                # Check if image MIME type is supported
-                if content_item.mimeType not in SUPPORTED_IMAGE_MIME_TYPES:
-                    anthropic_block = AnthropicConverter._format_fail_message(
-                        content_item, content_item.mimeType
-                    )
-                else:
-                    anthropic_block = AnthropicConverter._convert_image_content(
-                        content_item
-                    )
-                anthropic_blocks.append(anthropic_block)
-            elif isinstance(content_item, EmbeddedResource):
-                anthropic_block = AnthropicConverter._convert_embedded_resource(
-                    content_item, documentMode
-                )
-                anthropic_blocks.append(anthropic_block)
-
-        return anthropic_blocks
-
-    @staticmethod
-    def _format_fail_message(
-        resource: Union[TextContent, ImageContent, EmbeddedResource], mimetype: str
-    ) -> TextBlockParam:
-        """Create a fallback text block for unsupported resource types"""
-        fallback_text: str = f"Unknown resource with format {mimetype}"
-        if resource.type == "image":
-            fallback_text = f"Image with unsupported format '{mimetype}' ({len(resource.data)} characters)"
-        if isinstance(resource, EmbeddedResource):
-            if isinstance(resource.resource, BlobResourceContents):
-                fallback_text = f"Embedded Resource {resource.resource.uri._url} with unsupported format {resource.resource.mimeType} ({len(resource.resource.blob)} characters)"
-
-        return TextBlockParam(type="text", text=fallback_text)
+        return mime_type in SUPPORTED_IMAGE_MIME_TYPES
 
     @staticmethod
     def convert_to_anthropic(multipart_msg: PromptMessageMultipart) -> MessageParam:
@@ -106,12 +65,15 @@ class AnthropicConverter:
         Returns:
             An Anthropic API MessageParam object
         """
-        # Extract role
-        role: str = multipart_msg.role
+        role = multipart_msg.role
+
+        # Handle empty content case - create an empty list instead of a text block
+        if not multipart_msg.content:
+            return MessageParam(role=role, content=[])
 
         # Convert content blocks
-        anthropic_blocks: List[MessageParam] = (
-            AnthropicConverter._convert_content_items(multipart_msg.content)
+        anthropic_blocks = AnthropicConverter._convert_content_items(
+            multipart_msg.content, document_mode=True
         )
 
         # Filter blocks based on role (assistant can only have text blocks)
@@ -130,73 +92,111 @@ class AnthropicConverter:
         return MessageParam(role=role, content=anthropic_blocks)
 
     @staticmethod
-    def _convert_text_content(content: TextContent) -> TextBlockParam:
-        """Convert TextContent to Anthropic TextBlockParam."""
-        return TextBlockParam(type="text", text=content.text)
+    def convert_prompt_message_to_anthropic(message: PromptMessage) -> MessageParam:
+        """
+        Convert a standard PromptMessage to Anthropic API format.
 
-    @staticmethod
-    def _convert_image_content(content: ImageContent) -> ImageBlockParam:
-        """Convert ImageContent to Anthropic ImageBlockParam."""
-        # MIME type validation already done in the main convert method
-        return ImageBlockParam(
-            type="image",
-            source=Base64ImageSourceParam(
-                type="base64", media_type=content.mimeType, data=content.data
-            ),
-        )
+        Args:
+            message: The PromptMessage to convert
+
+        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])
+
+        # Use the existing conversion method
+        return AnthropicConverter.convert_to_anthropic(multipart)
 
     @staticmethod
-    def _determine_mime_type(
-        resource: TextResourceContents | BlobResourceContents,
-    ) -> str:
-        if resource.mimeType:
-            return resource.mimeType
+    def _convert_content_items(
+        content_items: Sequence[Union[TextContent, ImageContent, EmbeddedResource]],
+        document_mode: bool = True,
+    ) -> List[ContentBlockParam]:
+        """
+        Convert a list of content items to Anthropic content blocks.
 
-        if resource.uri:
-            return guess_mime_type(resource.uri.serialize_url)
+        Args:
+            content_items: Sequence of MCP content items
+            document_mode: Whether to convert text resources to document blocks (True) or text blocks (False)
 
-        if resource.blob:
-            return "application/octet-stream"
-        else:
-            return "text/plain"
+        Returns:
+            List of Anthropic content blocks
+        """
+        anthropic_blocks: List[ContentBlockParam] = []
+
+        for content_item in content_items:
+            if isinstance(content_item, TextContent):
+                anthropic_blocks.append(
+                    TextBlockParam(type="text", text=content_item.text)
+                )
+
+            elif isinstance(content_item, ImageContent):
+                # Check if image MIME type is supported
+                if not AnthropicConverter._is_supported_image_type(
+                    content_item.mimeType
+                ):
+                    anthropic_blocks.append(
+                        TextBlockParam(
+                            type="text",
+                            text=f"Image with unsupported format '{content_item.mimeType}' ({len(content_item.data)} bytes)",
+                        )
+                    )
+                else:
+                    anthropic_blocks.append(
+                        ImageBlockParam(
+                            type="image",
+                            source=Base64ImageSourceParam(
+                                type="base64",
+                                media_type=content_item.mimeType,
+                                data=content_item.data,
+                            ),
+                        )
+                    )
+
+            elif isinstance(content_item, EmbeddedResource):
+                block = AnthropicConverter._convert_embedded_resource(
+                    content_item, document_mode
+                )
+                anthropic_blocks.append(block)
+
+        return anthropic_blocks
 
     @staticmethod
     def _convert_embedded_resource(
         resource: EmbeddedResource,
-        documentMode: bool = True,
+        document_mode: bool = True,
     ) -> ContentBlockParam:
-        """Convert EmbeddedResource to appropriate Anthropic block type.
+        """
+        Convert EmbeddedResource to appropriate Anthropic block type.
 
         Args:
             resource: The embedded resource to convert
-            documentMode: Whether to convert text resources to Document blocks (True) or Text blocks (False)
+            document_mode: Whether to convert text resources to Document blocks (True) or Text blocks (False)
 
         Returns:
             An appropriate ContentBlockParam for the resource
         """
-        resource_content: TextResourceContents | BlobResourceContents = (
-            resource.resource
-        )
-        uri: AnyUrl = resource_content.uri
-        is_url: bool = uri.scheme in ("http", "https")
+        resource_content = resource.resource
+        uri: Optional[AnyUrl] = getattr(resource_content, "uri", None)
+        is_url: bool = uri and uri.scheme in ("http", "https")
+
+        # Determine MIME type
         mime_type = AnthropicConverter._determine_mime_type(resource_content)
+
         # Extract title from URI
-        title = extract_title_from_uri(uri) if uri else None
+        title = extract_title_from_uri(uri) if uri else "resource"
 
-        # Special case for SVG - it's actually text/XML, so extract as text
+        # Convert based on MIME type
         if mime_type == "image/svg+xml":
-            if hasattr(resource_content, "text"):
-                # For SVG from text resource
-                svg_content = resource_content.text
-                return TextBlockParam(type="text", text=f"```xml\n{svg_content}\n```")
-
-        # Handle image resources
-        if is_image_mime_type(mime_type):
-            # Check if image MIME type is supported
-            if mime_type not in SUPPORTED_IMAGE_MIME_TYPES:
-                return AnthropicConverter._format_fail_message(resource, mime_type)
-
-            # Handle supported image types
+            return AnthropicConverter._convert_svg_resource(resource_content)
+
+        elif is_image_mime_type(mime_type):
+            if not AnthropicConverter._is_supported_image_type(mime_type):
+                return AnthropicConverter._create_fallback_text(
+                    f"Image with unsupported format '{mime_type}'", resource
+                )
+
             if is_url:
                 return ImageBlockParam(
                     type="image", source=URLImageSourceParam(type="url", url=str(uri))
@@ -208,8 +208,10 @@ class AnthropicConverter:
                         type="base64", media_type=mime_type, data=resource_content.blob
                     ),
                 )
+            return AnthropicConverter._create_fallback_text(
+                "Image missing data", resource
+            )
 
-        # Handle PDF resources
         elif mime_type == "application/pdf":
             if is_url:
                 return DocumentBlockParam(
@@ -227,29 +229,109 @@ class AnthropicConverter:
                         data=resource_content.blob,
                     ),
                 )
+            return TextBlockParam(
+                type="text", text=f"[PDF resource missing data: {title}]"
+            )
 
-        # Handle text resources (default for all other text mime types)
         elif is_text_mime_type(mime_type):
-            if documentMode:
-                if hasattr(resource_content, "text"):
-                    return DocumentBlockParam(
-                        type="document",
-                        title=title,
-                        source=PlainTextSourceParam(
-                            type="text",
-                            media_type="text/plain",
-                            data=resource_content.text,
-                        ),
-                    )
-            # Return as text block when documentMode is False
-            if hasattr(resource_content, "text"):
-                return TextBlockParam(type="text", text=resource_content.text)
+            if not hasattr(resource_content, "text"):
+                return TextBlockParam(
+                    type="text",
+                    text=f"[Text content could not be extracted from {title}]",
+                )
+
+            # Create document block when in document mode
+            if document_mode:
+                return DocumentBlockParam(
+                    type="document",
+                    title=title,
+                    source=PlainTextSourceParam(
+                        type="text",
+                        media_type="text/plain",
+                        data=resource_content.text,
+                    ),
+                )
+
+            # Return as simple text block when not in document mode
+            return TextBlockParam(type="text", text=resource_content.text)
 
         # Default fallback - convert to text if possible
         if hasattr(resource_content, "text"):
             return TextBlockParam(type="text", text=resource_content.text)
 
-        return AnthropicConverter._format_fail_message(resource, mime_type)
+        # This is for binary resources - match the format expected by the test
+        if isinstance(resource.resource, BlobResourceContents) and hasattr(
+            resource.resource, "blob"
+        ):
+            blob_length = len(resource.resource.blob)
+            return TextBlockParam(
+                type="text",
+                text=f"Embedded Resource {uri._url} with unsupported format {mime_type} ({blob_length} characters)",
+            )
+
+        return AnthropicConverter._create_fallback_text(
+            f"Unsupported resource ({mime_type})", resource
+        )
+
+    @staticmethod
+    def _determine_mime_type(
+        resource: Union[TextResourceContents, BlobResourceContents],
+    ) -> str:
+        """
+        Determine the MIME type of a resource.
+
+        Args:
+            resource: The resource to check
+
+        Returns:
+            The MIME type as a string
+        """
+        if getattr(resource, "mimeType", None):
+            return resource.mimeType
+
+        if getattr(resource, "uri", None):
+            return guess_mime_type(resource.uri.serialize_url)
+
+        if hasattr(resource, "blob"):
+            return "application/octet-stream"
+
+        return "text/plain"
+
+    @staticmethod
+    def _convert_svg_resource(resource_content) -> TextBlockParam:
+        """
+        Convert SVG resource to text block with XML code formatting.
+
+        Args:
+            resource_content: The resource content containing SVG data
+
+        Returns:
+            A TextBlockParam with formatted SVG content
+        """
+        if hasattr(resource_content, "text"):
+            svg_content = resource_content.text
+            return TextBlockParam(type="text", text=f"```xml\n{svg_content}\n```")
+        return TextBlockParam(type="text", text="[SVG content could not be extracted]")
+
+    @staticmethod
+    def _create_fallback_text(
+        message: str, resource: Union[TextContent, ImageContent, EmbeddedResource]
+    ) -> TextBlockParam:
+        """
+        Create a fallback text block for unsupported resource types.
+
+        Args:
+            message: The fallback message
+            resource: The resource that couldn't be converted
+
+        Returns:
+            A TextBlockParam with the fallback message
+        """
+        if isinstance(resource, EmbeddedResource) and hasattr(resource.resource, "uri"):
+            uri = resource.resource.uri
+            return TextBlockParam(type="text", text=f"[{message}: {uri._url}]")
+
+        return TextBlockParam(type="text", text=f"[{message}]")
 
     @staticmethod
     def convert_tool_result_to_anthropic(
@@ -265,20 +347,20 @@ class AnthropicConverter:
         Returns:
             An Anthropic ToolResultBlockParam ready to be included in a user message
         """
-        # For tool results, we always use documentMode=False to get text blocks instead of document blocks
+        # 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, documentMode=False
+                    item, document_mode=False
                 )
                 anthropic_content.append(resource_block)
-            else:
-                # For other types (Text, Image), use standard conversion
+            elif isinstance(item, (TextContent, ImageContent)):
+                # For text and image, use standard conversion
                 blocks = AnthropicConverter._convert_content_items(
-                    [item], documentMode=False
+                    [item], document_mode=False
                 )
                 anthropic_content.extend(blocks)
 
@@ -312,35 +394,57 @@ class AnthropicConverter:
         content_blocks = []
 
         for tool_use_id, result in tool_results:
-            # Split into text/image content vs other content
-            tool_content = []
+            # Process each tool result
+            tool_result_blocks = []
             separate_blocks = []
 
+            # Process each content item in the result
             for item in result.content:
-                # Text and images go in tool results, other resources (PDFs) go as separate blocks
                 if isinstance(item, (TextContent, ImageContent)):
-                    tool_content.append(item)
+                    blocks = AnthropicConverter._convert_content_items(
+                        [item], document_mode=False
+                    )
+                    tool_result_blocks.extend(blocks)
                 elif isinstance(item, EmbeddedResource):
-                    # If it's a text resource, keep it in tool_content
-                    if isinstance(item.resource, TextResourceContents):
-                        tool_content.append(item)
+                    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, convert and add as separate block
+                        # For binary resources like PDFs, add as separate block
                         block = AnthropicConverter._convert_embedded_resource(
-                            item, documentMode=True
+                            item, document_mode=True
                         )
                         separate_blocks.append(block)
-                else:
-                    tool_content.append(item)
-
-            # Always create a tool result block, even if empty
-            # If tool_content is empty, we'll get a placeholder text block added in convert_tool_result_to_anthropic
-            tool_result = CallToolResult(content=tool_content, isError=result.isError)
-            content_blocks.append(
-                AnthropicConverter.convert_tool_result_to_anthropic(
-                    tool_result, tool_use_id
+
+            # Create the tool result block if we have content
+            if tool_result_blocks:
+                content_blocks.append(
+                    ToolResultBlockParam(
+                        type="tool_result",
+                        tool_use_id=tool_use_id,
+                        content=tool_result_blocks,
+                        is_error=result.isError,
+                    )
+                )
+            else:
+                # If there's no content, still create a placeholder
+                content_blocks.append(
+                    ToolResultBlockParam(
+                        type="tool_result",
+                        tool_use_id=tool_use_id,
+                        content=[
+                            TextBlockParam(
+                                type="text", text="[No content in tool result]"
+                            )
+                        ],
+                        is_error=result.isError,
+                    )
                 )
-            )
 
             # Add separate blocks directly to the message
             content_blocks.extend(separate_blocks)