fast-agent-mcp 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

mcp_agent/workflows/llm/augmented_llm_passthrough.py

@@ -0,0 +1,104 @@
+from typing import Any, List, Optional, Type, Union
+
+from mcp import GetPromptResult
+from mcp.types import PromptMessage
+from pydantic_core import from_json
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.workflows.llm.augmented_llm import (
+    AugmentedLLM,
+    MessageParamT,
+    MessageT,
+    ModelT,
+    RequestParams,
+)
+from mcp_agent.logging.logger import get_logger
+
+
+class PassthroughLLM(AugmentedLLM):
+    """
+    A specialized LLM implementation that simply passes through input messages without modification.
+
+    This is useful for cases where you need an object with the AugmentedLLM interface
+    but want to preserve the original message without any processing, such as in a
+    parallel workflow where no fan-in aggregation is needed.
+    """
+
+    def __init__(self, name: str = "Passthrough", context=None, **kwargs):
+        super().__init__(name=name, context=context, **kwargs)
+        self.provider = "fast-agent"
+        # Initialize logger - keep it simple without name reference
+        self.logger = get_logger(__name__)
+        self._messages = [PromptMessage]
+
+    async def generate(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        request_params: Optional[RequestParams] = None,
+    ) -> Union[List[MessageT], Any]:
+        """Simply return the input message as is."""
+        # Return in the format expected by the caller
+        return [message] if isinstance(message, list) else message
+
+    async def generate_str(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        request_params: Optional[RequestParams] = None,
+    ) -> str:
+        """Return the input message as a string."""
+        self.show_user_message(message, model="fastagent-passthrough", chat_turn=0)
+        await self.show_assistant_message(message, title="ASSISTANT/PASSTHROUGH")
+
+        return str(message)
+
+    async def generate_structured(
+        self,
+        message: Union[str, MessageParamT, List[MessageParamT]],
+        response_model: Type[ModelT],
+        request_params: Optional[RequestParams] = None,
+    ) -> ModelT:
+        """
+        Return the input message as the requested model type.
+        This is a best-effort implementation - it may fail if the
+        message cannot be converted to the requested model.
+        """
+        if isinstance(message, response_model):
+            return message
+        elif isinstance(message, dict):
+            return response_model(**message)
+        elif isinstance(message, str):
+            return response_model.model_validate(from_json(message, allow_partial=True))
+
+    async def generate_prompt(
+        self, prompt: "PromptMessageMultipart", request_params: RequestParams | None
+    ) -> str:
+        return await self.generate_str(prompt.content[0].text, request_params)
+
+    async def apply_prompt_template(
+        self, prompt_result: GetPromptResult, prompt_name: str
+    ) -> str:
+        """
+        Apply a prompt template by adding it to the conversation history.
+        If the last message in the prompt is from a user, automatically
+        generate an assistant response.
+
+        Args:
+            prompt_result: The GetPromptResult containing prompt messages
+            prompt_name: The name of the prompt being applied
+
+        Returns:
+            String representation of the assistant's response if generated,
+            or the last assistant message in the prompt
+        """
+        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,
+        )
+        self._messages = prompt_messages

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

@@ -7,10 +7,17 @@ from mcp_agent.core.exceptions import ModelConfigError
 from mcp_agent.workflows.llm.augmented_llm_anthropic import AnthropicAugmentedLLM
 from mcp_agent.workflows.llm.augmented_llm_openai import OpenAIAugmentedLLM
 from mcp_agent.workflows.llm.augmented_llm import RequestParams
-from mcp_agent.workflows.llm.enhanced_passthrough import EnhancedPassthroughLLM
+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):
@@ -18,7 +25,7 @@ class Provider(Enum):
 
     ANTHROPIC = auto()
     OPENAI = auto()
-    SIMULATOR = auto()
+    FAST_AGENT = auto()
 
 
 class ReasoningEffort(Enum):
@@ -45,6 +52,7 @@ class ModelFactory:
     PROVIDER_MAP = {
         "anthropic": Provider.ANTHROPIC,
         "openai": Provider.OPENAI,
+        "fast-agent": Provider.FAST_AGENT,
     }
 
     # Mapping of effort strings to enum values
@@ -54,11 +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,
@@ -93,7 +103,13 @@ class ModelFactory:
     PROVIDER_CLASSES: Dict[Provider, LLMClass] = {
         Provider.ANTHROPIC: AnthropicAugmentedLLM,
         Provider.OPENAI: OpenAIAugmentedLLM,
-        Provider.SIMULATOR: EnhancedPassthroughLLM,
+        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
@@ -149,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"]