fast-agent-mcp 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

mcp_agent/workflows/llm/providers/multipart_converter_anthropic.py

@@ -1,38 +1,42 @@
-from typing import List, Union, Sequence
+from typing import TYPE_CHECKING, List, Optional, Sequence, Union
 
+from anthropic.types import (
+    Base64ImageSourceParam,
+    Base64PDFSourceParam,
+    ContentBlockParam,
+    DocumentBlockParam,
+    ImageBlockParam,
+    MessageParam,
+    PlainTextSourceParam,
+    TextBlockParam,
+    ToolResultBlockParam,
+    URLImageSourceParam,
+    URLPDFSourceParam,
+)
 from mcp.types import (
-    TextContent,
-    ImageContent,
-    EmbeddedResource,
+    BlobResourceContents,
     CallToolResult,
+    EmbeddedResource,
+    ImageContent,
+    PromptMessage,
+    TextContent,
     TextResourceContents,
-    BlobResourceContents,
 )
-from pydantic import AnyUrl
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.mime_utils import (
     guess_mime_type,
-    is_text_mime_type,
     is_image_mime_type,
+    is_text_mime_type,
 )
-
-from anthropic.types import (
-    MessageParam,
-    TextBlockParam,
-    ImageBlockParam,
-    DocumentBlockParam,
-    Base64ImageSourceParam,
-    URLImageSourceParam,
-    Base64PDFSourceParam,
-    URLPDFSourceParam,
-    PlainTextSourceParam,
-    ToolResultBlockParam,
-    ContentBlockParam,
-)
-from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.mcp.resource_utils import extract_title_from_uri
 
+if TYPE_CHECKING:
+    from pydantic import AnyUrl
+
 _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 +45,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,13 +67,14 @@ 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)
         if role == "assistant":
@@ -121,95 +83,119 @@ class AnthropicConverter:
                 if block.get("type") == "text":
                     text_blocks.append(block)
                 else:
-                    _logger.warning(
-                        f"Removing non-text block from assistant message: {block.get('type')}"
-                    )
+                    _logger.warning(f"Removing non-text block from assistant message: {block.get('type')}")
             anthropic_blocks = text_blocks
 
         # Create the Anthropic message
         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))
-                )
+                return ImageBlockParam(type="image", source=URLImageSourceParam(type="url", url=str(uri)))
             elif hasattr(resource_content, "blob"):
                 return ImageBlockParam(
                     type="image",
-                    source=Base64ImageSourceParam(
-                        type="base64", media_type=mime_type, data=resource_content.blob
-                    ),
+                    source=Base64ImageSourceParam(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,34 +213,104 @@ 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(
-        tool_result: CallToolResult, tool_use_id: str
-    ) -> ToolResultBlockParam:
+    def convert_tool_result_to_anthropic(tool_result: CallToolResult, tool_use_id: str) -> ToolResultBlockParam:
         """
         Convert an MCP CallToolResult to an Anthropic ToolResultBlockParam.
 
@@ -265,28 +321,22 @@ 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
-                )
+                resource_block = AnthropicConverter._convert_embedded_resource(item, document_mode=False)
                 anthropic_content.append(resource_block)
-            else:
-                # For other types (Text, Image), use standard conversion
-                blocks = AnthropicConverter._convert_content_items(
-                    [item], documentMode=False
-                )
+            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]")
-            ]
+            anthropic_content = [TextBlockParam(type="text", text="[No content in tool result]")]
 
         # Create the tool result block
         return ToolResultBlockParam(
@@ -312,35 +362,47 @@ 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
-                        block = AnthropicConverter._convert_embedded_resource(
-                            item, documentMode=True
-                        )
+                        # For binary resources like PDFs, add as separate block
+                        block = AnthropicConverter._convert_embedded_resource(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)