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

mcp_agent/{workflows/llm → llm}/providers/multipart_converter_anthropic.py

@@ -1,36 +1,43 @@
-from typing import List, Union, Sequence, Optional
+from typing import List, Sequence, Union
 
+from anthropic.types import (
+    Base64ImageSourceParam,
+    Base64PDFSourceParam,
+    ContentBlockParam,
+    DocumentBlockParam,
+    ImageBlockParam,
+    MessageParam,
+    PlainTextSourceParam,
+    TextBlockParam,
+    ToolResultBlockParam,
+    URLImageSourceParam,
+    URLPDFSourceParam,
+)
 from mcp.types import (
-    TextContent,
-    ImageContent,
-    EmbeddedResource,
-    CallToolResult,
-    TextResourceContents,
     BlobResourceContents,
+    CallToolResult,
+    EmbeddedResource,
+    ImageContent,
     PromptMessage,
+    TextContent,
+    TextResourceContents,
 )
-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.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.prompts.prompt_helpers import (
+    get_image_data,
+    get_resource_uri,
+    get_text,
+    is_image_content,
+    is_resource_content,
+    is_text_content,
 )
-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")
@@ -126,38 +133,39 @@ class AnthropicConverter:
         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):
+            if is_text_content(content_item):
+                # Handle text content
+                text = get_text(content_item)
+                anthropic_blocks.append(TextBlockParam(type="text", text=text))
+
+            elif is_image_content(content_item):
+                # Handle image content
+                image_content = content_item  # type: ImageContent
                 # Check if image MIME type is supported
-                if not AnthropicConverter._is_supported_image_type(
-                    content_item.mimeType
-                ):
+                if not AnthropicConverter._is_supported_image_type(image_content.mimeType):
+                    data_size = len(image_content.data) if image_content.data else 0
                     anthropic_blocks.append(
                         TextBlockParam(
                             type="text",
-                            text=f"Image with unsupported format '{content_item.mimeType}' ({len(content_item.data)} bytes)",
+                            text=f"Image with unsupported format '{image_content.mimeType}' ({data_size} bytes)",
                         )
                     )
                 else:
+                    image_data = get_image_data(image_content)
                     anthropic_blocks.append(
                         ImageBlockParam(
                             type="image",
                             source=Base64ImageSourceParam(
                                 type="base64",
-                                media_type=content_item.mimeType,
-                                data=content_item.data,
+                                media_type=image_content.mimeType,
+                                data=image_data,
                             ),
                         )
                     )
 
-            elif isinstance(content_item, EmbeddedResource):
-                block = AnthropicConverter._convert_embedded_resource(
-                    content_item, document_mode
-                )
+            elif is_resource_content(content_item):
+                # Handle embedded resource
+                block = AnthropicConverter._convert_embedded_resource(content_item, document_mode)
                 anthropic_blocks.append(block)
 
         return anthropic_blocks
@@ -178,7 +186,8 @@ class AnthropicConverter:
             An appropriate ContentBlockParam for the resource
         """
         resource_content = resource.resource
-        uri: Optional[AnyUrl] = getattr(resource_content, "uri", None)
+        uri_str = get_resource_uri(resource)
+        uri = getattr(resource_content, "uri", None)
         is_url: bool = uri and uri.scheme in ("http", "https")
 
         # Determine MIME type
@@ -197,27 +206,29 @@ class AnthropicConverter:
                     f"Image with unsupported format '{mime_type}'", resource
                 )
 
-            if is_url:
+            if is_url and uri_str:
                 return ImageBlockParam(
-                    type="image", source=URLImageSourceParam(type="url", url=str(uri))
+                    type="image", source=URLImageSourceParam(type="url", url=uri_str)
                 )
-            elif hasattr(resource_content, "blob"):
+            
+            # Try to get image data
+            image_data = get_image_data(resource)
+            if image_data:
                 return ImageBlockParam(
                     type="image",
                     source=Base64ImageSourceParam(
-                        type="base64", media_type=mime_type, data=resource_content.blob
+                        type="base64", media_type=mime_type, data=image_data
                     ),
                 )
-            return AnthropicConverter._create_fallback_text(
-                "Image missing data", resource
-            )
+            
+            return AnthropicConverter._create_fallback_text("Image missing data", resource)
 
         elif mime_type == "application/pdf":
-            if is_url:
+            if is_url and uri_str:
                 return DocumentBlockParam(
                     type="document",
                     title=title,
-                    source=URLPDFSourceParam(type="url", url=str(uri)),
+                    source=URLPDFSourceParam(type="url", url=uri_str),
                 )
             elif hasattr(resource_content, "blob"):
                 return DocumentBlockParam(
@@ -229,12 +240,11 @@ class AnthropicConverter:
                         data=resource_content.blob,
                     ),
                 )
-            return TextBlockParam(
-                type="text", text=f"[PDF resource missing data: {title}]"
-            )
+            return TextBlockParam(type="text", text=f"[PDF resource missing data: {title}]")
 
         elif is_text_mime_type(mime_type):
-            if not hasattr(resource_content, "text"):
+            text = get_text(resource)
+            if not text:
                 return TextBlockParam(
                     type="text",
                     text=f"[Text content could not be extracted from {title}]",
@@ -248,16 +258,17 @@ class AnthropicConverter:
                     source=PlainTextSourceParam(
                         type="text",
                         media_type="text/plain",
-                        data=resource_content.text,
+                        data=text,
                     ),
                 )
 
             # Return as simple text block when not in document mode
-            return TextBlockParam(type="text", text=resource_content.text)
+            return TextBlockParam(type="text", text=text)
 
         # Default fallback - convert to text if possible
-        if hasattr(resource_content, "text"):
-            return TextBlockParam(type="text", text=resource_content.text)
+        text = get_text(resource)
+        if text:
+            return TextBlockParam(type="text", text=text)
 
         # This is for binary resources - match the format expected by the test
         if isinstance(resource.resource, BlobResourceContents) and hasattr(
@@ -359,16 +370,12 @@ class AnthropicConverter:
                 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
-                )
+                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(
@@ -401,9 +408,7 @@ class AnthropicConverter:
             # Process each content item in the result
             for item in result.content:
                 if isinstance(item, (TextContent, ImageContent)):
-                    blocks = AnthropicConverter._convert_content_items(
-                        [item], document_mode=False
-                    )
+                    blocks = AnthropicConverter._convert_content_items([item], document_mode=False)
                     tool_result_blocks.extend(blocks)
                 elif isinstance(item, EmbeddedResource):
                     resource_content = item.resource
@@ -437,11 +442,7 @@ class AnthropicConverter:
                     ToolResultBlockParam(
                         type="tool_result",
                         tool_use_id=tool_use_id,
-                        content=[
-                            TextBlockParam(
-                                type="text", text="[No content in tool result]"
-                            )
-                        ],
+                        content=[TextBlockParam(type="text", text="[No content in tool result]")],
                         is_error=result.isError,
                     )
                 )

mcp_agent/{workflows/llm → llm}/providers/multipart_converter_openai.py

@@ -1,23 +1,31 @@
-from typing import List, Union, Optional, Tuple, Dict, Any
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from mcp.types import (
-    TextContent,
-    ImageContent,
-    EmbeddedResource,
     CallToolResult,
+    EmbeddedResource,
+    ImageContent,
     PromptMessage,
+    TextContent,
 )
-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 mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.prompts.prompt_helpers import (
+    MessageContent,
+    get_image_data,
+    get_resource_uri,
+    get_text,
+    is_image_content,
+    is_resource_content,
+    is_text_content,
 )
 from mcp_agent.mcp.resource_utils import extract_title_from_uri
 
-
-from mcp_agent.logging.logger import get_logger
-
 _logger = get_logger("multipart_converter_openai")
 
 # Define type aliases for content blocks
@@ -40,9 +48,7 @@ class OpenAIConverter:
             True if the MIME type is generally supported, False otherwise
         """
         return (
-            mime_type is not None
-            and is_image_mime_type(mime_type)
-            and mime_type != "image/svg+xml"
+            mime_type is not None and is_image_mime_type(mime_type) and mime_type != "image/svg+xml"
         )
 
     @staticmethod
@@ -65,25 +71,10 @@ class OpenAIConverter:
         if not multipart_msg.content:
             return {"role": role, "content": ""}
 
-        # Assistant messages in OpenAI only support string content, not array of content blocks
-        if role == "assistant":
-            # Extract text from all text content blocks
-            content_text = ""
-            for item in multipart_msg.content:
-                if isinstance(item, TextContent):
-                    content_text += item.text
-                # Other types are ignored for assistant messages in OpenAI
-
-            return {"role": role, "content": content_text}
-
-        # System messages also only support string content
-        if role == "system":
-            # Extract text from all text content blocks
-            content_text = ""
-            for item in multipart_msg.content:
-                if isinstance(item, TextContent):
-                    content_text += item.text
-
+        # Assistant and system messages in OpenAI only support string content, not array of content blocks
+        if role == "assistant" or role == "system":
+            # Use MessageContent helper to get all text
+            content_text = MessageContent.join_text(multipart_msg, separator="")
             return {"role": role, "content": content_text}
 
         # For user messages, convert each content block
@@ -91,22 +82,21 @@ class OpenAIConverter:
 
         for item in multipart_msg.content:
             try:
-                if isinstance(item, TextContent):
-                    content_blocks.append({"type": "text", "text": item.text})
+                if is_text_content(item):
+                    text = get_text(item)
+                    content_blocks.append({"type": "text", "text": text})
 
-                elif isinstance(item, ImageContent):
+                elif is_image_content(item):
                     content_blocks.append(OpenAIConverter._convert_image_content(item))
 
-                elif isinstance(item, EmbeddedResource):
+                elif is_resource_content(item):
                     block = OpenAIConverter._convert_embedded_resource(item)
                     if block:
                         content_blocks.append(block)
 
                 # Handle input_audio if implemented
                 elif hasattr(item, "type") and getattr(item, "type") == "input_audio":
-                    _logger.warning(
-                        "Input audio content not supported in standard OpenAI types"
-                    )
+                    _logger.warning("Input audio content not supported in standard OpenAI types")
                     fallback_text = "[Audio content not directly supported]"
                     content_blocks.append({"type": "text", "text": fallback_text})
 
@@ -202,8 +192,11 @@ class OpenAIConverter:
     @staticmethod
     def _convert_image_content(content: ImageContent) -> ContentBlock:
         """Convert ImageContent to OpenAI image_url content block."""
+        # Get image data using helper
+        image_data = get_image_data(content)
+        
         # OpenAI requires image URLs or data URIs for images
-        image_url = {"url": f"data:{content.mimeType};base64,{content.data}"}
+        image_url = {"url": f"data:{content.mimeType};base64,{image_data}"}
 
         # Check if the image has annotations for detail level
         if hasattr(content, "annotations") and content.annotations:
@@ -251,6 +244,7 @@ class OpenAIConverter:
             An appropriate OpenAI content block or None if conversion failed
         """
         resource_content = resource.resource
+        uri_str = get_resource_uri(resource)
         uri = getattr(resource_content, "uri", None)
         is_url = uri and str(uri).startswith(("http://", "https://"))
         title = extract_title_from_uri(uri) if uri else "resource"
@@ -260,25 +254,26 @@ class OpenAIConverter:
 
         # Handle images
         if OpenAIConverter._is_supported_image_type(mime_type):
-            if is_url:
-                return {"type": "image_url", "image_url": {"url": str(uri)}}
-            elif hasattr(resource_content, "blob"):
+            if is_url and uri_str:
+                return {"type": "image_url", "image_url": {"url": uri_str}}
+            
+            # Try to get image data 
+            image_data = get_image_data(resource)
+            if image_data:
                 return {
                     "type": "image_url",
-                    "image_url": {
-                        "url": f"data:{mime_type};base64,{resource_content.blob}"
-                    },
+                    "image_url": {"url": f"data:{mime_type};base64,{image_data}"},
                 }
             else:
                 return {"type": "text", "text": f"[Image missing data: {title}]"}
 
         # Handle PDFs
         elif mime_type == "application/pdf":
-            if is_url:
+            if is_url and uri_str:
                 # OpenAI doesn't directly support PDF URLs, explain this limitation
                 return {
                     "type": "text",
-                    "text": f"[PDF URL: {uri}]\nOpenAI requires PDF files to be uploaded or provided as base64 data.",
+                    "text": f"[PDF URL: {uri_str}]\nOpenAI requires PDF files to be uploaded or provided as base64 data.",
                 }
             elif hasattr(resource_content, "blob"):
                 return {
@@ -290,26 +285,31 @@ class OpenAIConverter:
                 }
 
         # Handle SVG (convert to text)
-        elif mime_type == "image/svg+xml" and hasattr(resource_content, "text"):
-            file_text = (
-                f'<fastagent:file title="{title}" mimetype="{mime_type}">\n'
-                f"{resource_content.text}\n"
-                f"</fastagent:file>"
-            )
-            return {"type": "text", "text": file_text}
+        elif mime_type == "image/svg+xml":
+            text = get_text(resource)
+            if text:
+                file_text = (
+                    f'<fastagent:file title="{title}" mimetype="{mime_type}">\n'
+                    f"{text}\n"
+                    f"</fastagent:file>"
+                )
+                return {"type": "text", "text": file_text}
 
         # Handle text files
-        elif is_text_mime_type(mime_type) and hasattr(resource_content, "text"):
-            file_text = (
-                f'<fastagent:file title="{title}" mimetype="{mime_type}">\n'
-                f"{resource_content.text}\n"
-                f"</fastagent:file>"
-            )
-            return {"type": "text", "text": file_text}
+        elif is_text_mime_type(mime_type):
+            text = get_text(resource)
+            if text:
+                file_text = (
+                    f'<fastagent:file title="{title}" mimetype="{mime_type}">\n'
+                    f"{text}\n"
+                    f"</fastagent:file>"
+                )
+                return {"type": "text", "text": file_text}
 
         # Default fallback for text resources
-        elif hasattr(resource_content, "text"):
-            return {"type": "text", "text": resource_content.text}
+        text = get_text(resource)
+        if text:
+            return {"type": "text", "text": text}
 
         # Default fallback for binary resources
         elif hasattr(resource_content, "blob"):
@@ -349,11 +349,7 @@ class OpenAIConverter:
             if block.get("type") == "text":
                 text_parts.append(block.get("text", ""))
 
-        return (
-            " ".join(text_parts)
-            if text_parts
-            else "[Complex content converted to text]"
-        )
+        return " ".join(text_parts) if text_parts else "[Complex content converted to text]"
 
     @staticmethod
     def convert_tool_result_to_openai(
@@ -423,9 +419,7 @@ class OpenAIConverter:
             return tool_message
 
         # Process non-text content as a separate user message
-        non_text_multipart = PromptMessageMultipart(
-            role="user", content=non_text_content
-        )
+        non_text_multipart = PromptMessageMultipart(role="user", content=non_text_content)
 
         # Convert to OpenAI format
         user_message = OpenAIConverter.convert_to_openai(non_text_multipart)

mcp_agent/{workflows/llm → llm}/providers/openai_multipart.py

@@ -4,19 +4,18 @@ Clean utilities for converting between PromptMessageMultipart and OpenAI message
 Each function handles all content types consistently and is designed for simple testing.
 """
 
-from typing import Dict, Any, Union, List
-
-from openai.types.chat import (
-    ChatCompletionMessage,
-    ChatCompletionMessageParam,
-)
+from typing import Any, Dict, List, Union
 
 from mcp.types import (
-    TextContent,
-    ImageContent,
+    BlobResourceContents,
     EmbeddedResource,
+    ImageContent,
+    TextContent,
     TextResourceContents,
-    BlobResourceContents,
+)
+from openai.types.chat import (
+    ChatCompletionMessage,
+    ChatCompletionMessageParam,
 )
 
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
@@ -64,27 +63,16 @@ def _openai_message_to_multipart(
     # Handle list of content parts
     elif isinstance(content, list):
         for part in content:
-            part_type = (
-                part.get("type")
-                if isinstance(part, dict)
-                else getattr(part, "type", None)
-            )
+            part_type = part.get("type") if isinstance(part, dict) else getattr(part, "type", None)
 
             # Handle text content
             if part_type == "text":
-                text = (
-                    part.get("text")
-                    if isinstance(part, dict)
-                    else getattr(part, "text", "")
-                )
+                text = part.get("text") if isinstance(part, dict) else getattr(part, "text", "")
 
                 # Check if this is a resource marker
                 if (
                     text
-                    and (
-                        text.startswith("[Resource:")
-                        or text.startswith("[Binary Resource:")
-                    )
+                    and (text.startswith("[Resource:") or text.startswith("[Binary Resource:"))
                     and "\n" in text
                 ):
                     header, content_text = text.split("\n", 1)
@@ -93,15 +81,8 @@ def _openai_message_to_multipart(
 
                         # If not text/plain, create an embedded resource
                         if mime_match != "text/plain":
-                            if (
-                                "Resource:" in header
-                                and "Binary Resource:" not in header
-                            ):
-                                uri = (
-                                    header.split("Resource:", 1)[1]
-                                    .split(",")[0]
-                                    .strip()
-                                )
+                            if "Resource:" in header and "Binary Resource:" not in header:
+                                uri = header.split("Resource:", 1)[1].split(",")[0].strip()
                                 mcp_contents.append(
                                     EmbeddedResource(
                                         type="resource",
@@ -139,11 +120,7 @@ def _openai_message_to_multipart(
                         )
 
             # Handle explicit resource types
-            elif (
-                part_type == "resource"
-                and isinstance(part, dict)
-                and "resource" in part
-            ):
+            elif part_type == "resource" and isinstance(part, dict) and "resource" in part:
                 resource = part["resource"]
                 if isinstance(resource, dict):
                     # Text resource
@@ -152,9 +129,7 @@ def _openai_message_to_multipart(
                         uri = resource.get("uri", "resource://unknown")
 
                         if mime_type == "text/plain":
-                            mcp_contents.append(
-                                TextContent(type="text", text=resource["text"])
-                            )
+                            mcp_contents.append(TextContent(type="text", text=resource["text"]))
                         else:
                             mcp_contents.append(
                                 EmbeddedResource(
@@ -171,10 +146,7 @@ def _openai_message_to_multipart(
                         mime_type = resource["mimeType"]
                         uri = resource.get("uri", "resource://unknown")
 
-                        if (
-                            mime_type.startswith("image/")
-                            and mime_type != "image/svg+xml"
-                        ):
+                        if mime_type.startswith("image/") and mime_type != "image/svg+xml":
                             mcp_contents.append(
                                 ImageContent(
                                     type="image",

mcp_agent/{workflows/llm → llm/providers}/openai_utils.py

@@ -5,18 +5,18 @@ This file provides backward compatibility with the existing API while
 delegating to the proper implementations in the providers/ directory.
 """
 
-from typing import Dict, Any, Union
+from typing import Any, Dict, Union
 
 from openai.types.chat import (
     ChatCompletionMessage,
     ChatCompletionMessageParam,
 )
 
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
-from mcp_agent.workflows.llm.providers.multipart_converter_openai import OpenAIConverter
-from mcp_agent.workflows.llm.providers.openai_multipart import (
+from mcp_agent.llm.providers.multipart_converter_openai import OpenAIConverter
+from mcp_agent.llm.providers.openai_multipart import (
     openai_to_multipart,
 )
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 
 def openai_message_to_prompt_message_multipart(

mcp_agent/{workflows/llm → llm}/providers/sampling_converter_anthropic.py

@@ -1,24 +1,22 @@
-from mcp import StopReason
-from mcp_agent.workflows.llm.providers.multipart_converter_anthropic import (
-    AnthropicConverter,
+from anthropic.types import (
+    Message,
+    MessageParam,
 )
-from mcp_agent.workflows.llm.sampling_format_converter import SamplingFormatConverter
-
+from mcp import StopReason
 from mcp.types import (
     PromptMessage,
 )
 
-from anthropic.types import (
-    Message,
-    MessageParam,
+from mcp_agent.llm.providers.multipart_converter_anthropic import (
+    AnthropicConverter,
 )
-
+from mcp_agent.llm.sampling_format_converter import ProviderFormatConverter
 from mcp_agent.logging.logger import get_logger
 
 _logger = get_logger(__name__)
 
 
-class AnthropicSamplingConverter(SamplingFormatConverter[MessageParam, Message]):
+class AnthropicSamplingConverter(ProviderFormatConverter[MessageParam, Message]):
     """
     Convert between Anthropic and MCP types.
     """
@@ -46,7 +44,7 @@ def mcp_stop_reason_to_anthropic_stop_reason(stop_reason: StopReason):
 
 def anthropic_stop_reason_to_mcp_stop_reason(stop_reason: str) -> StopReason:
     if not stop_reason:
-        return None
+        return "end_turn"
     elif stop_reason == "end_turn":
         return "endTurn"
     elif stop_reason == "max_tokens":