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

mcp_agent/workflows/llm/providers/sampling_converter_anthropic.py

@@ -0,0 +1,258 @@
+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_agent.logging.logger import get_logger
+
+_logger = get_logger(__name__)
+
+
+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
+
+
+def mcp_stop_reason_to_anthropic_stop_reason(stop_reason: StopReason):
+    if not stop_reason:
+        return None
+    elif stop_reason == "endTurn":
+        return "end_turn"
+    elif stop_reason == "maxTokens":
+        return "max_tokens"
+    elif stop_reason == "stopSequence":
+        return "stop_sequence"
+    elif stop_reason == "toolUse":
+        return "tool_use"
+    else:
+        return stop_reason
+
+
+def anthropic_stop_reason_to_mcp_stop_reason(stop_reason: str) -> StopReason:
+    if not stop_reason:
+        return None
+    elif stop_reason == "end_turn":
+        return "endTurn"
+    elif stop_reason == "max_tokens":
+        return "maxTokens"
+    elif stop_reason == "stop_sequence":
+        return "stopSequence"
+    elif stop_reason == "tool_use":
+        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

@@ -0,0 +1,229 @@
+from typing import Iterable
+from mcp import CreateMessageResult, SamplingMessage
+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
+
+_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'"
+            )
+
+    @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}"
+        )
+    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}")

mcp_agent/workflows/llm/sampling_format_converter.py

@@ -0,0 +1,39 @@
+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")
+"""A type representing an input message to an LLM."""
+
+MessageT = TypeVar("MessageT")
+"""A type representing an output message from an LLM."""
+
+
+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."""
+
+
+def typed_dict_extras(d: dict, exclude: List[str]):
+    extras = {k: v for k, v in d.items() if k not in exclude}
+    return extras

mcp_agent/core/server_validation.py

@@ -1,44 +0,0 @@
-"""FastAgent validation methods."""
-
-from mcp_agent.core.exceptions import ServerConfigError
-
-
-def _validate_server_references(self) -> None:
-    """
-    Validate that all server references in agent configurations exist in config.
-    Raises ServerConfigError if any referenced servers are not defined.
-    """
-    # First check if any agents need servers
-    agents_needing_servers = {
-        name: agent_data["config"].servers
-        for name, agent_data in self.agents.items()
-        if agent_data["config"].servers
-    }
-
-    if not agents_needing_servers:
-        return  # No validation needed
-
-    # If we need servers, verify MCP config exists
-    if not hasattr(self.context.config, "mcp"):
-        raise ServerConfigError(
-            "MCP configuration missing",
-            "Agents require server access but no MCP configuration found.\n"
-            "Add an 'mcp' section to your configuration file.",
-        )
-
-    if not self.context.config.mcp.servers:
-        raise ServerConfigError(
-            "No MCP servers configured",
-            "Agents require server access but no servers are defined.\n"
-            "Add server definitions under mcp.servers in your configuration file.",
-        )
-
-    # Now check each agent's servers exist
-    available_servers = set(self.context.config.mcp.servers.keys())
-    for name, servers in agents_needing_servers.items():
-        missing = [s for s in servers if s not in available_servers]
-        if missing:
-            raise ServerConfigError(
-                f"Missing server configuration for agent '{name}'",
-                f"The following servers are referenced but not defined in config: {', '.join(missing)}",
-            )

mcp_agent/core/simulator_registry.py

@@ -1,22 +0,0 @@
-from typing import Optional, Any
-
-
-class SimulatorRegistry:
-    """Registry to access simulator instances for testing assertions"""
-
-    _instances = {}
-
-    @classmethod
-    def register(cls, name: str, simulator: "Any"):
-        """Register a simulator instance"""
-        cls._instances[name] = simulator
-
-    @classmethod
-    def get(cls, name: str) -> Optional["Any"]:
-        """Get a simulator by name"""
-        return cls._instances.get(name)
-
-    @classmethod
-    def clear(cls):
-        """Clear registry (useful between tests)"""
-        cls._instances.clear()

mcp_agent/workflows/llm/enhanced_passthrough.py

@@ -1,70 +0,0 @@
-# src/mcp_agent/workflows/llm/enhanced_passthrough.py
-
-
-import datetime
-from typing import List, Optional, Union
-from mcp_agent.core.simulator_registry import SimulatorRegistry
-from mcp_agent.workflows.llm.augmented_llm import (
-    AugmentedLLM,
-    MessageParamT,
-    RequestParams,
-)
-
-
-class EnhancedPassthroughLLM(AugmentedLLM):
-    """Enhanced passthrough LLM for testing parameter handling and workflows"""
-
-    def __init__(self, name: str = "Simulator", context=None, **kwargs):
-        super().__init__(name=name, context=context, **kwargs)
-        self.simulation_mode = kwargs.get("simulation_mode", "passthrough")
-        self.request_log = []
-        self.last_request_params = None
-
-        # Register this instance with the registry
-        SimulatorRegistry.register(self.name, self)
-
-    async def generate_str(
-        self,
-        message: Union[str, MessageParamT, List[MessageParamT]],
-        request_params: Optional[RequestParams] = None,
-    ) -> str:
-        """Capture parameters and log the request"""
-        # Store for assertion testing
-        self.last_request_params = request_params
-
-        # Log the request
-        self.request_log.append(
-            {
-                "timestamp": datetime.now().isoformat(),
-                "message": str(message),
-                "request_params": request_params.model_dump()
-                if request_params
-                else None,
-            }
-        )
-
-        # Display for debugging
-        self.show_user_message(str(message), model="simulator", chat_turn=0)
-
-        # Simulate response
-        result = f"[SIMULATOR] Response to: {message}"
-        await self.show_assistant_message(result, title="SIMULATOR")
-
-        return result
-
-    # Other generate methods with similar parameter capture
-
-    def get_parameter_usage_report(self):
-        """Generate report of parameter usage"""
-        param_usage = {}
-
-        for req in self.request_log:
-            params = req.get("request_params", {})
-            if params:
-                for key, value in params.items():
-                    if key not in param_usage:
-                        param_usage[key] = {"count": 0, "values": set()}
-                    param_usage[key]["count"] += 1
-                    param_usage[key]["values"].add(str(value))
-
-        return {"total_requests": len(self.request_log), "parameter_usage": param_usage}