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

mcp_agent/workflows/llm/augmented_llm_playback.py

@@ -0,0 +1,109 @@
+from typing import List, Optional, Union
+from mcp import GetPromptResult
+from mcp.types import PromptMessage
+from mcp_agent.workflows.llm.augmented_llm import MessageParamT, RequestParams
+from mcp_agent.workflows.llm.augmented_llm_passthrough import PassthroughLLM
+
+
+# TODO -- support tool calling
+class PlaybackLLM(PassthroughLLM):
+    """
+    A specialized LLM implementation that plays back assistant messages when loaded with prompts.
+
+    Unlike the PassthroughLLM which simply passes through messages without modification,
+    PlaybackLLM is designed to simulate a conversation by playing back prompt messages
+    in sequence when loaded with prompts through apply_prompt_template.
+
+    After apply_prompts has been called, each call to generate_str returns the next
+    "ASSISTANT" message in the loaded messages. If no messages are set or all messages have
+    been played back, it returns a message indicating that messages are exhausted.
+    """
+
+    def __init__(self, name: str = "Playback", **kwargs):
+        super().__init__(name=name, **kwargs)
+        self._messages: List[PromptMessage] = []
+        self._current_index = 0
+
+    async def generate_str(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        request_params: Optional[RequestParams] = None,
+    ) -> str:
+        """
+        Return the next ASSISTANT message in the loaded messages list.
+        If no messages are available or all have been played back,
+        returns a message indicating messages are exhausted.
+
+        Note: Only assistant messages are returned; user messages are skipped.
+        """
+        self.show_user_message(message, model="fastagent-playback", chat_turn=0)
+
+        if not self._messages or self._current_index >= len(self._messages):
+            size = len(self._messages) if self._messages else 0
+            response = f"MESSAGES EXHAUSTED (list size {size})"
+        else:
+            response = self._get_next_assistant_message()
+
+        await self.show_assistant_message(response, title="ASSISTANT/PLAYBACK")
+        return response
+
+    def _get_next_assistant_message(self) -> str:
+        """
+        Get the next assistant message from the loaded messages.
+        Increments the current message index and skips user messages.
+        """
+        # Find next assistant message
+        while self._current_index < len(self._messages):
+            message = self._messages[self._current_index]
+            self._current_index += 1
+
+            # Skip non-assistant messages
+            if getattr(message, "role", None) != "assistant":
+                continue
+
+            # Get content as string
+            content = message.content
+            if hasattr(content, "text"):
+                return content.text
+            return str(content)
+
+        # If we get here, we've run out of assistant messages
+        return f"MESSAGES EXHAUSTED (list size {len(self._messages)})"
+
+    async def apply_prompt_template(
+        self, prompt_result: GetPromptResult, prompt_name: str
+    ) -> str:
+        """
+        Apply a prompt template by adding its messages to the playback queue.
+
+        Args:
+            prompt_result: The GetPromptResult containing prompt messages
+            prompt_name: The name of the prompt being applied
+
+        Returns:
+            String representation of the first message or an indication that no messages were added
+        """
+        prompt_messages: List[PromptMessage] = prompt_result.messages
+
+        # Extract arguments if they were stored in the result
+        arguments = getattr(prompt_result, "arguments", None)
+
+        # Display information about the loaded prompt
+        await self.show_prompt_loaded(
+            prompt_name=prompt_name,
+            description=prompt_result.description,
+            message_count=len(prompt_messages),
+            arguments=arguments,
+        )
+
+        # Add new messages to the end of the existing messages list
+        self._messages.extend(prompt_messages)
+
+        if not prompt_messages:
+            return "Prompt contains no messages"
+
+        # Reset current index if this is the first time loading messages
+        if len(self._messages) == len(prompt_messages):
+            self._current_index = 0
+
+        return f"Added {len(prompt_messages)} messages to playback queue"

mcp_agent/workflows/llm/model_factory.py

@@ -8,9 +8,16 @@ from mcp_agent.workflows.llm.augmented_llm_anthropic import AnthropicAugmentedLL
 from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
 from mcp_agent.workflows.llm.augmented_llm import RequestParams
 from mcp_agent.workflows.llm.augmented_llm_passthrough import PassthroughLLM
+from mcp_agent.workflows.llm.augmented_llm_playback import PlaybackLLM
+
 
 # Type alias for LLM classes
-LLMClass = Union[Type[AnthropicAugmentedLLM], Type[OpenAIAugmentedLLM]]
+LLMClass = Union[
+    Type[AnthropicAugmentedLLM],
+    Type[OpenAIAugmentedLLM],
+    Type[PassthroughLLM],
+    Type[PlaybackLLM],
+]
 
 
 class Provider(Enum):
@@ -55,12 +62,13 @@ class ModelFactory:
         "high": ReasoningEffort.HIGH,
     }
 
-    # TODO -- add context window size information for display/mmanagement
+    # TODO -- add context window size information for display/management
     # TODO -- add audio supporting got-4o-audio-preview
     # TODO -- bring model parameter configuration here
     # Mapping of model names to their default providers
     DEFAULT_PROVIDERS = {
         "passthrough": Provider.FAST_AGENT,
+        "playback": Provider.FAST_AGENT,
         "gpt-4o": Provider.OPENAI,
         "gpt-4o-mini": Provider.OPENAI,
         "o1-mini": Provider.OPENAI,
@@ -98,6 +106,12 @@ class ModelFactory:
         Provider.FAST_AGENT: PassthroughLLM,
     }
 
+    # Mapping of special model names to their specific LLM classes
+    # This overrides the provider-based class selection
+    MODEL_SPECIFIC_CLASSES: Dict[str, LLMClass] = {
+        "playback": PlaybackLLM,
+    }
+
     @classmethod
     def parse_model_string(cls, model_string: str) -> ModelConfig:
         """Parse a model string into a ModelConfig object"""
@@ -151,7 +165,10 @@ class ModelFactory:
         """
         # Parse configuration up front
         config = cls.parse_model_string(model_string)
-        llm_class = cls.PROVIDER_CLASSES[config.provider]
+        if config.model_name in cls.MODEL_SPECIFIC_CLASSES:
+            llm_class = cls.MODEL_SPECIFIC_CLASSES[config.model_name]
+        else:
+            llm_class = cls.PROVIDER_CLASSES[config.provider]
 
         # Create a factory function matching the attach_llm protocol
         def factory(agent: Agent, **kwargs) -> LLMClass:

mcp_agent/workflows/llm/openai_utils.py

@@ -0,0 +1,65 @@
+"""
+Utility functions for OpenAI integration with MCP.
+
+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 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 (
+    openai_to_multipart,
+)
+
+
+def openai_message_to_prompt_message_multipart(
+    message: Union[ChatCompletionMessage, Dict[str, Any]],
+) -> PromptMessageMultipart:
+    """
+    Convert an OpenAI ChatCompletionMessage to a PromptMessageMultipart.
+
+    Args:
+        message: The OpenAI message to convert (can be an actual ChatCompletionMessage
+                or a dictionary with the same structure)
+
+    Returns:
+        A PromptMessageMultipart representation
+    """
+    return openai_to_multipart(message)
+
+
+def openai_message_param_to_prompt_message_multipart(
+    message_param: ChatCompletionMessageParam,
+) -> PromptMessageMultipart:
+    """
+    Convert an OpenAI ChatCompletionMessageParam to a PromptMessageMultipart.
+
+    Args:
+        message_param: The OpenAI message param to convert
+
+    Returns:
+        A PromptMessageMultipart representation
+    """
+    return openai_to_multipart(message_param)
+
+
+def prompt_message_multipart_to_openai_message_param(
+    multipart: PromptMessageMultipart,
+) -> ChatCompletionMessageParam:
+    """
+    Convert a PromptMessageMultipart to an OpenAI ChatCompletionMessageParam.
+
+    Args:
+        multipart: The PromptMessageMultipart to convert
+
+    Returns:
+        An OpenAI ChatCompletionMessageParam representation
+    """
+    return OpenAIConverter.convert_to_openai(multipart)

mcp_agent/workflows/llm/providers/__init__.py

@@ -0,0 +1,8 @@
+from mcp_agent.workflows.llm.providers.sampling_converter_anthropic import (
+    AnthropicSamplingConverter,
+)
+from mcp_agent.workflows.llm.providers.sampling_converter_openai import (
+    OpenAISamplingConverter,
+)
+
+__all__ = ["AnthropicSamplingConverter", "OpenAISamplingConverter"]

mcp_agent/workflows/llm/providers/multipart_converter_anthropic.py

@@ -0,0 +1,348 @@
+from typing import List, Union, Sequence
+
+from mcp.types import (
+    TextContent,
+    ImageContent,
+    EmbeddedResource,
+    CallToolResult,
+    TextResourceContents,
+    BlobResourceContents,
+)
+from pydantic import AnyUrl
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.mime_utils import (
+    guess_mime_type,
+    is_text_mime_type,
+    is_image_mime_type,
+)
+
+from anthropic.types import (
+    MessageParam,
+    TextBlockParam,
+    ImageBlockParam,
+    DocumentBlockParam,
+    Base64ImageSourceParam,
+    URLImageSourceParam,
+    Base64PDFSourceParam,
+    URLPDFSourceParam,
+    PlainTextSourceParam,
+    ToolResultBlockParam,
+    ContentBlockParam,
+)
+from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.resource_utils import extract_title_from_uri
+
+_logger = get_logger("multipart_converter_anthropic")
+# List of image MIME types supported by Anthropic API
+SUPPORTED_IMAGE_MIME_TYPES = {"image/jpeg", "image/png", "image/gif", "image/webp"}
+
+
+class AnthropicConverter:
+    """Converts MCP message types to Anthropic API format."""
+
+    @staticmethod
+    def _convert_content_items(
+        content_items: Sequence[Union[TextContent, ImageContent, EmbeddedResource]],
+        documentMode: bool = True,
+    ) -> List[ContentBlockParam]:
+        """
+        Helper method to convert a list of content items to Anthropic format.
+
+        Args:
+            content_items: Sequence of MCP content items
+            documentMode: Whether to convert text resources to document blocks (True) or text blocks (False)
+
+        Returns:
+            List of Anthropic content blocks
+        """
+
+        anthropic_blocks: List[ContentBlockParam] = []
+
+        for content_item in content_items:
+            if isinstance(content_item, TextContent):
+                anthropic_block = AnthropicConverter._convert_text_content(content_item)
+                anthropic_blocks.append(anthropic_block)
+            elif isinstance(content_item, ImageContent):
+                # Check if image MIME type is supported
+                if content_item.mimeType not in SUPPORTED_IMAGE_MIME_TYPES:
+                    anthropic_block = AnthropicConverter._format_fail_message(
+                        content_item, content_item.mimeType
+                    )
+                else:
+                    anthropic_block = AnthropicConverter._convert_image_content(
+                        content_item
+                    )
+                anthropic_blocks.append(anthropic_block)
+            elif isinstance(content_item, EmbeddedResource):
+                anthropic_block = AnthropicConverter._convert_embedded_resource(
+                    content_item, documentMode
+                )
+                anthropic_blocks.append(anthropic_block)
+
+        return anthropic_blocks
+
+    @staticmethod
+    def _format_fail_message(
+        resource: Union[TextContent, ImageContent, EmbeddedResource], mimetype: str
+    ) -> TextBlockParam:
+        """Create a fallback text block for unsupported resource types"""
+        fallback_text: str = f"Unknown resource with format {mimetype}"
+        if resource.type == "image":
+            fallback_text = f"Image with unsupported format '{mimetype}' ({len(resource.data)} characters)"
+        if isinstance(resource, EmbeddedResource):
+            if isinstance(resource.resource, BlobResourceContents):
+                fallback_text = f"Embedded Resource {resource.resource.uri._url} with unsupported format {resource.resource.mimeType} ({len(resource.resource.blob)} characters)"
+
+        return TextBlockParam(type="text", text=fallback_text)
+
+    @staticmethod
+    def convert_to_anthropic(multipart_msg: PromptMessageMultipart) -> MessageParam:
+        """
+        Convert a PromptMessageMultipart message to Anthropic API format.
+
+        Args:
+            multipart_msg: The PromptMessageMultipart message to convert
+
+        Returns:
+            An Anthropic API MessageParam object
+        """
+        # Extract role
+        role: str = multipart_msg.role
+
+        # Convert content blocks
+        anthropic_blocks: List[MessageParam] = (
+            AnthropicConverter._convert_content_items(multipart_msg.content)
+        )
+
+        # Filter blocks based on role (assistant can only have text blocks)
+        if role == "assistant":
+            text_blocks = []
+            for block in anthropic_blocks:
+                if block.get("type") == "text":
+                    text_blocks.append(block)
+                else:
+                    _logger.warning(
+                        f"Removing non-text block from assistant message: {block.get('type')}"
+                    )
+            anthropic_blocks = text_blocks
+
+        # Create the Anthropic message
+        return MessageParam(role=role, content=anthropic_blocks)
+
+    @staticmethod
+    def _convert_text_content(content: TextContent) -> TextBlockParam:
+        """Convert TextContent to Anthropic TextBlockParam."""
+        return TextBlockParam(type="text", text=content.text)
+
+    @staticmethod
+    def _convert_image_content(content: ImageContent) -> ImageBlockParam:
+        """Convert ImageContent to Anthropic ImageBlockParam."""
+        # MIME type validation already done in the main convert method
+        return ImageBlockParam(
+            type="image",
+            source=Base64ImageSourceParam(
+                type="base64", media_type=content.mimeType, data=content.data
+            ),
+        )
+
+    @staticmethod
+    def _determine_mime_type(
+        resource: TextResourceContents | BlobResourceContents,
+    ) -> str:
+        if resource.mimeType:
+            return resource.mimeType
+
+        if resource.uri:
+            return guess_mime_type(resource.uri.serialize_url)
+
+        if resource.blob:
+            return "application/octet-stream"
+        else:
+            return "text/plain"
+
+    @staticmethod
+    def _convert_embedded_resource(
+        resource: EmbeddedResource,
+        documentMode: bool = True,
+    ) -> ContentBlockParam:
+        """Convert EmbeddedResource to appropriate Anthropic block type.
+
+        Args:
+            resource: The embedded resource to convert
+            documentMode: Whether to convert text resources to Document blocks (True) or Text blocks (False)
+
+        Returns:
+            An appropriate ContentBlockParam for the resource
+        """
+        resource_content: TextResourceContents | BlobResourceContents = (
+            resource.resource
+        )
+        uri: AnyUrl = resource_content.uri
+        is_url: bool = uri.scheme in ("http", "https")
+        mime_type = AnthropicConverter._determine_mime_type(resource_content)
+        # Extract title from URI
+        title = extract_title_from_uri(uri) if uri else None
+
+        # Special case for SVG - it's actually text/XML, so extract as text
+        if mime_type == "image/svg+xml":
+            if hasattr(resource_content, "text"):
+                # For SVG from text resource
+                svg_content = resource_content.text
+                return TextBlockParam(type="text", text=f"```xml\n{svg_content}\n```")
+
+        # Handle image resources
+        if is_image_mime_type(mime_type):
+            # Check if image MIME type is supported
+            if mime_type not in SUPPORTED_IMAGE_MIME_TYPES:
+                return AnthropicConverter._format_fail_message(resource, mime_type)
+
+            # Handle supported image types
+            if is_url:
+                return ImageBlockParam(
+                    type="image", source=URLImageSourceParam(type="url", url=str(uri))
+                )
+            elif hasattr(resource_content, "blob"):
+                return ImageBlockParam(
+                    type="image",
+                    source=Base64ImageSourceParam(
+                        type="base64", media_type=mime_type, data=resource_content.blob
+                    ),
+                )
+
+        # Handle PDF resources
+        elif mime_type == "application/pdf":
+            if is_url:
+                return DocumentBlockParam(
+                    type="document",
+                    title=title,
+                    source=URLPDFSourceParam(type="url", url=str(uri)),
+                )
+            elif hasattr(resource_content, "blob"):
+                return DocumentBlockParam(
+                    type="document",
+                    title=title,
+                    source=Base64PDFSourceParam(
+                        type="base64",
+                        media_type="application/pdf",
+                        data=resource_content.blob,
+                    ),
+                )
+
+        # Handle text resources (default for all other text mime types)
+        elif is_text_mime_type(mime_type):
+            if documentMode:
+                if hasattr(resource_content, "text"):
+                    return DocumentBlockParam(
+                        type="document",
+                        title=title,
+                        source=PlainTextSourceParam(
+                            type="text",
+                            media_type="text/plain",
+                            data=resource_content.text,
+                        ),
+                    )
+            # Return as text block when documentMode is False
+            if hasattr(resource_content, "text"):
+                return TextBlockParam(type="text", text=resource_content.text)
+
+        # Default fallback - convert to text if possible
+        if hasattr(resource_content, "text"):
+            return TextBlockParam(type="text", text=resource_content.text)
+
+        return AnthropicConverter._format_fail_message(resource, mime_type)
+
+    @staticmethod
+    def convert_tool_result_to_anthropic(
+        tool_result: CallToolResult, tool_use_id: str
+    ) -> ToolResultBlockParam:
+        """
+        Convert an MCP CallToolResult to an Anthropic ToolResultBlockParam.
+
+        Args:
+            tool_result: The tool result from a tool call
+            tool_use_id: The ID of the associated tool use
+
+        Returns:
+            An Anthropic ToolResultBlockParam ready to be included in a user message
+        """
+        # For tool results, we always use documentMode=False to get text blocks instead of document blocks
+        anthropic_content = []
+
+        for item in tool_result.content:
+            if isinstance(item, EmbeddedResource):
+                # For embedded resources, always use text mode in tool results
+                resource_block = AnthropicConverter._convert_embedded_resource(
+                    item, documentMode=False
+                )
+                anthropic_content.append(resource_block)
+            else:
+                # For other types (Text, Image), use standard conversion
+                blocks = AnthropicConverter._convert_content_items(
+                    [item], documentMode=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]")
+            ]
+
+        # Create the tool result block
+        return ToolResultBlockParam(
+            type="tool_result",
+            tool_use_id=tool_use_id,
+            content=anthropic_content,
+            is_error=tool_result.isError,
+        )
+
+    @staticmethod
+    def create_tool_results_message(
+        tool_results: List[tuple[str, CallToolResult]],
+    ) -> MessageParam:
+        """
+        Create a user message containing tool results.
+
+        Args:
+            tool_results: List of (tool_use_id, tool_result) tuples
+
+        Returns:
+            A MessageParam with role='user' containing all tool results
+        """
+        content_blocks = []
+
+        for tool_use_id, result in tool_results:
+            # Split into text/image content vs other content
+            tool_content = []
+            separate_blocks = []
+
+            for item in result.content:
+                # Text and images go in tool results, other resources (PDFs) go as separate blocks
+                if isinstance(item, (TextContent, ImageContent)):
+                    tool_content.append(item)
+                elif isinstance(item, EmbeddedResource):
+                    # If it's a text resource, keep it in tool_content
+                    if isinstance(item.resource, TextResourceContents):
+                        tool_content.append(item)
+                    else:
+                        # For binary resources like PDFs, convert and add as separate block
+                        block = AnthropicConverter._convert_embedded_resource(
+                            item, documentMode=True
+                        )
+                        separate_blocks.append(block)
+                else:
+                    tool_content.append(item)
+
+            # Always create a tool result block, even if empty
+            # If tool_content is empty, we'll get a placeholder text block added in convert_tool_result_to_anthropic
+            tool_result = CallToolResult(content=tool_content, isError=result.isError)
+            content_blocks.append(
+                AnthropicConverter.convert_tool_result_to_anthropic(
+                    tool_result, tool_use_id
+                )
+            )
+
+            # Add separate blocks directly to the message
+            content_blocks.extend(separate_blocks)
+
+        return MessageParam(role="user", content=content_blocks)