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

mcp_agent/workflows/llm/providers/sampling_converter_anthropic.py

@@ -1,27 +1,16 @@
-import json
-from typing import Iterable, List
-from mcp import CreateMessageResult, SamplingMessage, StopReason
-from pydantic import BaseModel
+from mcp import StopReason
+from mcp_agent.workflows.llm.providers.multipart_converter_anthropic import (
+    AnthropicConverter,
+)
 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_agent.logging.logger import get_logger
@@ -34,171 +23,10 @@ class AnthropicSamplingConverter(SamplingFormatConverter[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):
@@ -229,30 +57,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,26 +1,15 @@
-from typing import Iterable
-from mcp import CreateMessageResult, SamplingMessage
+from typing import Dict, Any
+
 from openai.types.chat import (
     ChatCompletionMessage,
-    ChatCompletionUserMessageParam,
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionMessageParam,
-    ChatCompletionContentPartTextParam,
-    ChatCompletionContentPartParam,
-    ChatCompletionContentPartRefusalParam,
 )
 
 from mcp.types import (
     PromptMessage,
-    TextContent,
-    ImageContent,
-    EmbeddedResource,
-    TextResourceContents,
 )
 
 from mcp_agent.workflows.llm.sampling_format_converter import (
     SamplingFormatConverter,
-    typed_dict_extras,
 )
 
 from mcp_agent.logging.logger import get_logger
@@ -29,201 +18,14 @@ _logger = get_logger(__name__)
 
 
 class OpenAISamplingConverter(
-    SamplingFormatConverter[ChatCompletionMessageParam, ChatCompletionMessage]
+    SamplingFormatConverter[Dict[str, Any], 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'"
-            )
-
-    @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)

mcp_agent/workflows/llm/sampling_converter.py

@@ -0,0 +1,124 @@
+"""
+Simplified converter between MCP sampling types and PromptMessageMultipart.
+This replaces the more complex provider-specific converters with direct conversions.
+"""
+
+from typing import List, Optional
+
+from mcp.types import (
+    CreateMessageRequestParams,
+    CreateMessageResult,
+    SamplingMessage,
+    StopReason,
+    TextContent,
+)
+
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.interfaces import RequestParams
+
+
+class SamplingConverter:
+    """
+    Simplified converter between MCP sampling types and internal LLM types.
+
+    This handles converting between:
+    - SamplingMessage and PromptMessageMultipart
+    - CreateMessageRequestParams and RequestParams
+    - LLM responses and CreateMessageResult
+    """
+
+    @staticmethod
+    def sampling_message_to_prompt_message(
+        message: SamplingMessage,
+    ) -> PromptMessageMultipart:
+        """
+        Convert a SamplingMessage to a PromptMessageMultipart.
+
+        Args:
+            message: MCP SamplingMessage to convert
+
+        Returns:
+            PromptMessageMultipart suitable for use with LLMs
+        """
+        return PromptMessageMultipart(role=message.role, content=[message.content])
+
+    @staticmethod
+    def extract_request_params(params: CreateMessageRequestParams) -> RequestParams:
+        """
+        Extract parameters from CreateMessageRequestParams into RequestParams.
+
+        Args:
+            params: MCP request parameters
+
+        Returns:
+            RequestParams suitable for use with LLM.generate_prompt
+        """
+        return RequestParams(
+            maxTokens=params.maxTokens,
+            systemPrompt=params.systemPrompt,
+            temperature=params.temperature,
+            stopSequences=params.stopSequences,
+            modelPreferences=params.modelPreferences,
+            # Add any other parameters needed
+        )
+
+    @staticmethod
+    def create_message_result(
+        response: str, model: str, stop_reason: StopReason = "endTurn"
+    ) -> CreateMessageResult:
+        """
+        Create a CreateMessageResult from an LLM response.
+
+        Args:
+            response: Text response from the LLM
+            model: Model identifier
+            stop_reason: Reason generation stopped
+
+        Returns:
+            CreateMessageResult suitable for returning to MCP
+        """
+        return CreateMessageResult(
+            role="assistant",
+            content=TextContent(type="text", text=response),
+            model=model,
+            stopReason=stop_reason,
+        )
+
+    @staticmethod
+    def error_result(
+        error_message: str, model: Optional[str] = None
+    ) -> CreateMessageResult:
+        """
+        Create an error result.
+
+        Args:
+            error_message: Error message text
+            model: Optional model identifier
+
+        Returns:
+            CreateMessageResult with error information
+        """
+        return CreateMessageResult(
+            role="assistant",
+            content=TextContent(type="text", text=error_message),
+            model=model or "unknown",
+            stopReason="error",
+        )
+
+    @staticmethod
+    def convert_messages(
+        messages: List[SamplingMessage],
+    ) -> List[PromptMessageMultipart]:
+        """
+        Convert multiple SamplingMessages to PromptMessageMultipart objects.
+
+        Args:
+            messages: List of SamplingMessages to convert
+
+        Returns:
+            List of PromptMessageMultipart objects, each with a single content item
+        """
+        return [
+            SamplingConverter.sampling_message_to_prompt_message(msg)
+            for msg in messages
+        ]

mcp_agent/workflows/llm/sampling_format_converter.py

@@ -1,6 +1,5 @@
 from typing import Generic, List, Protocol, TypeVar
 
-from mcp import CreateMessageResult, SamplingMessage
 
 # Define type variables here instead of importing from augmented_llm
 MessageParamT = TypeVar("MessageParamT")
@@ -13,22 +12,6 @@ MessageT = TypeVar("MessageT")
 class SamplingFormatConverter(Protocol, Generic[MessageParamT, MessageT]):
     """Conversions between LLM provider and MCP types"""
 
-    @classmethod
-    def to_sampling_result(cls, result: MessageT) -> CreateMessageResult:
-        """Convert an LLM response to an MCP message result type."""
-
-    @classmethod
-    def from_sampling_result(cls, result: CreateMessageResult) -> MessageT:
-        """Convert an MCP message result to an LLM response type."""
-
-    @classmethod
-    def to_sampling_message(cls, param: MessageParamT) -> SamplingMessage:
-        """Convert an LLM input to an MCP message (SamplingMessage) type."""
-
-    @classmethod
-    def from_sampling_message(cls, param: SamplingMessage) -> MessageParamT:
-        """Convert an MCP message (SamplingMessage) to an LLM input type."""
-
     @classmethod
     def from_prompt_message(cls, message) -> MessageParamT:
         """Convert an MCP PromptMessage to a provider-specific message parameter."""