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

mcp_agent/workflows/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,44 +63,22 @@ 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 "\n" in text
-                ):
+                if text and (text.startswith("[Resource:") or text.startswith("[Binary Resource:")) and "\n" in text:
                     header, content_text = text.split("\n", 1)
                     if "MIME:" in header:
                         mime_match = header.split("MIME:", 1)[1].split("]")[0].strip()
 
                         # 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",
@@ -119,31 +96,17 @@ def _openai_message_to_multipart(
 
             # Handle image content
             elif part_type == "image_url":
-                image_url = (
-                    part.get("image_url", {})
-                    if isinstance(part, dict)
-                    else getattr(part, "image_url", None)
-                )
+                image_url = part.get("image_url", {}) if isinstance(part, dict) else getattr(part, "image_url", None)
                 if image_url:
-                    url = (
-                        image_url.get("url")
-                        if isinstance(image_url, dict)
-                        else getattr(image_url, "url", "")
-                    )
+                    url = image_url.get("url") if isinstance(image_url, dict) else getattr(image_url, "url", "")
                     if url and url.startswith("data:image/"):
                         # Handle base64 data URLs
                         mime_type = url.split(";")[0].replace("data:", "")
                         data = url.split(",")[1]
-                        mcp_contents.append(
-                            ImageContent(type="image", data=data, mimeType=mime_type)
-                        )
+                        mcp_contents.append(ImageContent(type="image", data=data, mimeType=mime_type))
 
             # 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 +115,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 +132,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/providers/sampling_converter_anthropic.py

@@ -1,204 +1,30 @@
-import json
-from typing import Iterable, List
-from mcp import CreateMessageResult, SamplingMessage, StopReason
-from pydantic import BaseModel
-from mcp_agent.workflows.llm.sampling_format_converter import SamplingFormatConverter
-
-from mcp.types import (
-    PromptMessage,
-    EmbeddedResource,
-    ImageContent,
-    TextContent,
-    TextResourceContents,
-)
-
 from anthropic.types import (
-    ContentBlock,
-    DocumentBlockParam,
     Message,
     MessageParam,
-    ImageBlockParam,
-    TextBlock,
-    TextBlockParam,
-    ToolResultBlockParam,
-    ToolUseBlockParam,
+)
+from mcp import StopReason
+from mcp.types import (
+    PromptMessage,
 )
 
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.workflows.llm.providers.multipart_converter_anthropic import (
+    AnthropicConverter,
+)
+from mcp_agent.workflows.llm.sampling_format_converter import ProviderFormatConverter
 
 _logger = get_logger(__name__)
 
 
-class AnthropicSamplingConverter(SamplingFormatConverter[MessageParam, Message]):
+class AnthropicSamplingConverter(ProviderFormatConverter[MessageParam, Message]):
     """
     Convert between Anthropic and MCP types.
     """
 
-    @classmethod
-    def from_sampling_result(cls, result: CreateMessageResult) -> Message:
-        #  -> Message
-        if result.role != "assistant":
-            raise ValueError(
-                f"Expected role to be 'assistant' but got '{result.role}' instead."
-            )
-
-        return Message(
-            role="assistant",
-            type="message",
-            content=[mcp_content_to_anthropic_content(result.content)],
-            stop_reason=mcp_stop_reason_to_anthropic_stop_reason(result.stopReason),
-            model=result.model,
-            usage={"input_tokens": 0, "output_tokens": 0},
-            id="sampling_id",
-            # TODO -- incorporate usage info and message identity
-        )
-
-    @classmethod
-    def to_sampling_result(cls, result: Message) -> CreateMessageResult:
-        contents = anthropic_content_to_mcp_content(result.content)
-        if len(contents) > 1:
-            raise NotImplementedError(
-                "Multiple content elements in a single message are not supported in MCP yet"
-            )
-        mcp_content = contents[0]
-
-        # Create a dictionary with required fields
-        result_dict = {
-            "role": result.role,
-            "content": mcp_content,
-            "model": result.model,
-            "stopReason": anthropic_stop_reason_to_mcp_stop_reason(result.stop_reason),
-        }
-
-        # Add any other fields from the original message that might be needed
-        extras = result.model_dump(exclude={"role", "content", "model", "stop_reason"})
-        if extras:
-            # Only include compatible fields to avoid validation errors
-            # Skip fields that would cause validation issues with CreateMessageResult
-            safe_extras = {
-                k: v for k, v in extras.items() if k in CreateMessageResult.model_fields
-            }
-            result_dict.update(safe_extras)
-
-        return CreateMessageResult(**result_dict)
-
-    @classmethod
-    def from_sampling_message(cls, param: SamplingMessage) -> MessageParam:
-        extras = param.model_dump(exclude={"role", "content"})
-        return MessageParam(
-            role=param.role,
-            content=[mcp_content_to_anthropic_content(param.content)],
-            **extras,
-        )
-
-    @classmethod
-    def to_sampling_message(cls, param: MessageParam) -> SamplingMessage:
-        # Implement the conversion from ChatCompletionMessage to MCP message param
-
-        contents = anthropic_content_to_mcp_content(param["content"])
-
-        # TODO: saqadri - the mcp_content can have multiple elements
-        # while sampling message content has a single content element
-        # Right now we error out if there are > 1 elements in mcp_content
-        # We need to handle this case properly going forward
-        if len(contents) > 1:
-            raise NotImplementedError(
-                "Multiple content elements in a single message are not supported"
-            )
-        mcp_content = contents[0]
-
-        # Only include fields that are valid for SamplingMessage
-        extras = {
-            k: v
-            for k, v in param.items()
-            if k not in ["role", "content"] and k in SamplingMessage.model_fields
-        }
-
-        return SamplingMessage(
-            role=param["role"],
-            content=mcp_content,
-            **extras,
-        )
-
     @classmethod
     def from_prompt_message(cls, message: PromptMessage) -> MessageParam:
         """Convert an MCP PromptMessage to an Anthropic MessageParam."""
-
-        # Extract content text
-        content_text = (
-            message.content.text
-            if hasattr(message.content, "text")
-            else str(message.content)
-        )
-
-        # Extract extras for flexibility
-        extras = message.model_dump(exclude={"role", "content"})
-
-        # Handle based on role
-        if message.role == "user":
-            return {"role": "user", "content": content_text, **extras}
-        elif message.role == "assistant":
-            return {
-                "role": "assistant",
-                "content": [{"type": "text", "text": content_text}],
-                **extras,
-            }
-        else:
-            # Fall back to user for any unrecognized role, including "system"
-            _logger.warning(
-                f"Unsupported role '{message.role}' in PromptMessage. Falling back to 'user' role."
-            )
-            return {
-                "role": "user",
-                "content": f"[{message.role.upper()}] {content_text}",
-                **extras,
-            }
-
-
-def anthropic_content_to_mcp_content(
-    content: str
-    | Iterable[
-        TextBlockParam
-        | ImageBlockParam
-        | ToolUseBlockParam
-        | ToolResultBlockParam
-        | DocumentBlockParam
-        | ContentBlock
-    ],
-) -> List[TextContent | ImageContent | EmbeddedResource]:
-    mcp_content = []
-
-    if isinstance(content, str):
-        mcp_content.append(TextContent(type="text", text=content))
-    else:
-        for block in content:
-            if block.type == "text":
-                mcp_content.append(TextContent(type="text", text=block.text))
-            elif block.type == "image":
-                raise NotImplementedError("Image content conversion not implemented")
-            elif block.type == "tool_use":
-                # Best effort to convert a tool use to text (since there's no ToolUseContent)
-                mcp_content.append(
-                    TextContent(
-                        type="text",
-                        text=to_string(block),
-                    )
-                )
-            elif block.type == "tool_result":
-                # Best effort to convert a tool result to text (since there's no ToolResultContent)
-                mcp_content.append(
-                    TextContent(
-                        type="text",
-                        text=to_string(block),
-                    )
-                )
-            elif block.type == "document":
-                raise NotImplementedError("Document content conversion not implemented")
-            else:
-                # Last effort to convert the content to a string
-                mcp_content.append(TextContent(type="text", text=str(block)))
-
-    return mcp_content
+        return AnthropicConverter.convert_prompt_message_to_anthropic(message)
 
 
 def mcp_stop_reason_to_anthropic_stop_reason(stop_reason: StopReason):
@@ -218,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":
@@ -229,30 +55,3 @@ def anthropic_stop_reason_to_mcp_stop_reason(stop_reason: str) -> StopReason:
         return "toolUse"
     else:
         return stop_reason
-
-
-def mcp_content_to_anthropic_content(
-    content: TextContent | ImageContent | EmbeddedResource,
-) -> ContentBlock:
-    if isinstance(content, TextContent):
-        return TextBlock(type=content.type, text=content.text)
-    elif isinstance(content, ImageContent):
-        # Best effort to convert an image to text (since there's no ImageBlock)
-        return TextBlock(type="text", text=f"{content.mimeType}:{content.data}")
-    elif isinstance(content, EmbeddedResource):
-        if isinstance(content.resource, TextResourceContents):
-            return TextBlock(type="text", text=content.resource.text)
-        else:  # BlobResourceContents
-            return TextBlock(
-                type="text", text=f"{content.resource.mimeType}:{content.resource.blob}"
-            )
-    else:
-        # Last effort to convert the content to a string
-        return TextBlock(type="text", text=str(content))
-
-
-def to_string(obj: BaseModel | dict) -> str:
-    if isinstance(obj, BaseModel):
-        return obj.model_dump_json()
-    else:
-        return json.dumps(obj)

mcp_agent/workflows/llm/providers/sampling_converter_openai.py

@@ -1,229 +1,27 @@
-from typing import Iterable
-from mcp import CreateMessageResult, SamplingMessage
-from openai.types.chat import (
-    ChatCompletionMessage,
-    ChatCompletionUserMessageParam,
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionMessageParam,
-    ChatCompletionContentPartTextParam,
-    ChatCompletionContentPartParam,
-    ChatCompletionContentPartRefusalParam,
-)
+from typing import Any, Dict
 
 from mcp.types import (
     PromptMessage,
-    TextContent,
-    ImageContent,
-    EmbeddedResource,
-    TextResourceContents,
 )
-
-from mcp_agent.workflows.llm.sampling_format_converter import (
-    SamplingFormatConverter,
-    typed_dict_extras,
+from openai.types.chat import (
+    ChatCompletionMessage,
 )
 
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.workflows.llm.sampling_format_converter import (
+    ProviderFormatConverter,
+)
 
 _logger = get_logger(__name__)
 
 
-class OpenAISamplingConverter(
-    SamplingFormatConverter[ChatCompletionMessageParam, ChatCompletionMessage]
-):
-    """
-    Convert between OpenAI and MCP types.
-    """
-
-    @classmethod
-    def from_sampling_result(cls, result: CreateMessageResult) -> ChatCompletionMessage:
-        """Convert an MCP message result to an OpenAI ChatCompletionMessage."""
-        # Basic implementation - would need to be expanded
-
-        if result.role != "assistant":
-            raise ValueError(
-                f"Expected role to be 'assistant' but got '{result.role}' instead."
-            )
-        # TODO -- add image support for sampling
-        return ChatCompletionMessage(
-            role=result.role,
-            content=result.content.text or "image",
-        )
-
-    @classmethod
-    def to_sampling_result(cls, result: ChatCompletionMessage) -> CreateMessageResult:
-        """Convert an OpenAI ChatCompletionMessage to an MCP message result."""
-        content = result.content
-        if content is None:
-            content = ""
-
-        return CreateMessageResult(
-            role=result.role,
-            content=TextContent(type="text", text=content),
-            model="unknown",  # Model is required by CreateMessageResult
-        )
-
-    @classmethod
-    def from_sampling_message(
-        cls, param: SamplingMessage
-    ) -> ChatCompletionMessageParam:
-        if param.role == "assistant":
-            return ChatCompletionAssistantMessageParam(
-                role="assistant",
-                content=mcp_to_openai_blocks(param.content),
-            )
-        elif param.role == "user":
-            return ChatCompletionUserMessageParam(
-                role="user",
-                content=mcp_to_openai_blocks(param.content),
-            )
-        else:
-            raise ValueError(
-                f"Unexpected role: {param.role}, MCP only supports 'assistant' and 'user'"
-            )
-
+class OpenAISamplingConverter(ProviderFormatConverter[Dict[str, Any], ChatCompletionMessage]):
     @classmethod
-    def to_sampling_message(cls, param: ChatCompletionMessageParam) -> SamplingMessage:
-        contents = openai_to_mcp_blocks(param)
-
-        # TODO: saqadri - the mcp_content can have multiple elements
-        # while sampling message content has a single content element
-        # Right now we error out if there are > 1 elements in mcp_content
-        # We need to handle this case properly going forward
-        if len(contents) > 1:
-            raise NotImplementedError(
-                "Multiple content elements in a single message are not supported"
-            )
-        mcp_content: TextContent | ImageContent | EmbeddedResource = contents[0]
-
-        if param["role"] == "assistant":
-            return SamplingMessage(
-                role="assistant",
-                content=mcp_content,
-                **typed_dict_extras(param, ["role", "content"]),
-            )
-        elif param["role"] == "user":
-            return SamplingMessage(
-                role="user",
-                content=mcp_content,
-                **typed_dict_extras(param, ["role", "content"]),
-            )
-        elif param.role == "tool":
-            raise NotImplementedError(
-                "Tool messages are not supported in SamplingMessage yet"
-            )
-        elif param.role == "system":
-            raise NotImplementedError(
-                "System messages are not supported in SamplingMessage yet"
-            )
-        elif param.role == "developer":
-            raise NotImplementedError(
-                "Developer messages are not supported in SamplingMessage yet"
-            )
-        elif param.role == "function":
-            raise NotImplementedError(
-                "Function messages are not supported in SamplingMessage yet"
-            )
-        else:
-            raise ValueError(
-                f"Unexpected role: {param.role}, MCP only supports 'assistant', 'user', 'tool', 'system', 'developer', and 'function'"
-            )
-
-    @classmethod
-    def from_prompt_message(cls, message: PromptMessage) -> ChatCompletionMessageParam:
-        """Convert an MCP PromptMessage to an OpenAI ChatCompletionMessageParam."""
-        content_text = (
-            message.content.text
-            if hasattr(message.content, "text")
-            else str(message.content)
-        )
-
-        return {
-            "role": message.role,
-            "content": content_text,
-        }
-
-
-def mcp_to_openai_blocks(
-    content: TextContent | ImageContent | EmbeddedResource,
-) -> ChatCompletionContentPartTextParam:
-    if isinstance(content, list):
-        # Handle list of content items
-        return ChatCompletionContentPartTextParam(
-            type="text",
-            text="\n".join(mcp_to_openai_blocks(c) for c in content),
-        )
-
-    if isinstance(content, TextContent):
-        return ChatCompletionContentPartTextParam(type="text", text=content.text)
-    elif isinstance(content, ImageContent):
-        # Best effort to convert an image to text
-        return ChatCompletionContentPartTextParam(
-            type="text", text=f"{content.mimeType}:{content.data}"
+    def from_prompt_message(cls, message: PromptMessage) -> Dict[str, Any]:
+        """Convert an MCP PromptMessage to an OpenAI message dict."""
+        from mcp_agent.workflows.llm.providers.multipart_converter_openai import (
+            OpenAIConverter,
         )
-    elif isinstance(content, EmbeddedResource):
-        if isinstance(content.resource, TextResourceContents):
-            return ChatCompletionContentPartTextParam(
-                type="text", text=content.resource.text
-            )
-        else:  # BlobResourceContents
-            return ChatCompletionContentPartTextParam(
-                type="text", text=f"{content.resource.mimeType}:{content.resource.blob}"
-            )
-    else:
-        # Last effort to convert the content to a string
-        return ChatCompletionContentPartTextParam(type="text", text=str(content))
-
-
-def openai_to_mcp_blocks(
-    content: str
-    | Iterable[ChatCompletionContentPartParam | ChatCompletionContentPartRefusalParam],
-) -> Iterable[TextContent | ImageContent | EmbeddedResource]:
-    mcp_content = []
-
-    if isinstance(content, str):
-        mcp_content = [TextContent(type="text", text=content)]
-
-    else:
-        mcp_content = [TextContent(type="text", text=content["content"])]
-
-    return mcp_content
-
-    # # TODO: saqadri - this is a best effort conversion, we should handle all possible content types
-    # for c in content["content"]:
-    #     # TODO: evalstate, need to go through all scenarios here
-    #     if isinstance(c, str):
-    #         mcp_content.append(TextContent(type="text", text=c))
-    #         break
 
-    #     if c.type == "text":  # isinstance(c, ChatCompletionContentPartTextParam):
-    #         mcp_content.append(
-    #             TextContent(
-    #                 type="text", text=c.text, **typed_dict_extras(c, ["text"])
-    #             )
-    #         )
-    #     elif (
-    #         c.type == "image_url"
-    #     ):  # isinstance(c, ChatCompletionContentPartImageParam):
-    #         raise NotImplementedError("Image content conversion not implemented")
-    #         # TODO: saqadri - need to download the image into a base64-encoded string
-    #         # Download image from c.image_url
-    #         # return ImageContent(
-    #         #     type="image",
-    #         #     data=downloaded_image,
-    #         #     **c
-    #         # )
-    #     elif (
-    #         c.type == "input_audio"
-    #     ):  # isinstance(c, ChatCompletionContentPartInputAudioParam):
-    #         raise NotImplementedError("Audio content conversion not implemented")
-    #     elif (
-    #         c.type == "refusal"
-    #     ):  # isinstance(c, ChatCompletionContentPartRefusalParam):
-    #         mcp_content.append(
-    #             TextContent(
-    #                 type="text", text=c.refusal, **typed_dict_extras(c, ["refusal"])
-    #             )
-    #         )
-    #     else:
-    #         raise ValueError(f"Unexpected content type: {c.type}")
+        # Use the full-featured OpenAI converter for consistent handling
+        return OpenAIConverter.convert_prompt_message_to_openai(message)