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

mcp_agent/llm/augmented_llm_playback.py

@@ -0,0 +1,83 @@
+from typing import Any, List
+
+from mcp_agent.core.prompt import Prompt
+from mcp_agent.llm.augmented_llm import RequestParams
+from mcp_agent.llm.augmented_llm_passthrough import PassthroughLLM
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from mcp_agent.mcp.prompts.prompt_helpers import MessageContent
+
+
+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: dict[str, Any]) -> None:
+        super().__init__(name=name, **kwargs)
+        self._messages: List[PromptMessageMultipart] = []
+        self._current_index = -1
+        self._overage = -1
+
+    def _get_next_assistant_message(self) -> PromptMessageMultipart:
+        """
+        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
+            if "assistant" != message.role:
+                continue
+
+            return message
+
+        self._overage += 1
+        return Prompt.assistant(
+            f"MESSAGES EXHAUSTED (list size {len(self._messages)}) ({self._overage} overage)"
+        )
+
+    async def generate(
+        self,
+        multipart_messages: List[PromptMessageMultipart],
+        request_params: RequestParams | None = None,
+    ) -> PromptMessageMultipart:
+        """
+        Handle playback of messages in two modes:
+        1. First call: store messages for playback and return "HISTORY LOADED"
+        2. Subsequent calls: return the next assistant message
+        """
+        # If this is the first call (initialization) or we're loading a prompt template
+        # with multiple messages (comes from apply_prompt)
+        if -1 == self._current_index:
+            if len(multipart_messages) > 1:
+                self._messages = multipart_messages
+            else:
+                self._messages.extend(multipart_messages)
+
+            # Reset the index to the beginning for proper playback
+            self._current_index = 0
+
+            await self.show_assistant_message(
+                message_text=f"HISTORY LOADED ({len(self._messages)} messages)",
+                title="ASSISTANT/PLAYBACK",
+            )
+
+            # In PlaybackLLM, we always return "HISTORY LOADED" on initialization,
+            # regardless of the prompt content. The next call will return messages.
+            return Prompt.assistant("HISTORY LOADED")
+
+        response = self._get_next_assistant_message()
+        await self.show_assistant_message(
+            message_text=MessageContent.get_first_text(response), title="ASSISTANT/PLAYBACK"
+        )
+
+        return response

mcp_agent/llm/memory.py

@@ -0,0 +1,103 @@
+from typing import Generic, List, Protocol, TypeVar
+
+# Define our own type variable for implementation use
+MessageParamT = TypeVar("MessageParamT")
+
+
+class Memory(Protocol, Generic[MessageParamT]):
+    """
+    Simple memory management for storing past interactions in-memory.
+    """
+
+    # TODO: saqadri - add checkpointing and other advanced memory capabilities
+
+    def __init__(self) -> None: ...
+
+    def extend(self, messages: List[MessageParamT], is_prompt: bool = False) -> None: ...
+
+    def set(self, messages: List[MessageParamT], is_prompt: bool = False) -> None: ...
+
+    def append(self, message: MessageParamT, is_prompt: bool = False) -> None: ...
+
+    def get(self, include_history: bool = True) -> List[MessageParamT]: ...
+
+    def clear(self, clear_prompts: bool = False) -> None: ...
+
+
+class SimpleMemory(Memory, Generic[MessageParamT]):
+    """
+    Simple memory management for storing past interactions in-memory.
+
+    Maintains both prompt messages (which are always included) and
+    generated conversation history (which is included based on use_history setting).
+    """
+
+    def __init__(self) -> None:
+        self.history: List[MessageParamT] = []
+        self.prompt_messages: List[MessageParamT] = []  # Always included
+
+    def extend(self, messages: List[MessageParamT], is_prompt: bool = False) -> None:
+        """
+        Add multiple messages to history.
+
+        Args:
+            messages: Messages to add
+            is_prompt: If True, add to prompt_messages instead of regular history
+        """
+        if is_prompt:
+            self.prompt_messages.extend(messages)
+        else:
+            self.history.extend(messages)
+
+    def set(self, messages: List[MessageParamT], is_prompt: bool = False) -> None:
+        """
+        Replace messages in history.
+
+        Args:
+            messages: Messages to set
+            is_prompt: If True, replace prompt_messages instead of regular history
+        """
+        if is_prompt:
+            self.prompt_messages = messages.copy()
+        else:
+            self.history = messages.copy()
+
+    def append(self, message: MessageParamT, is_prompt: bool = False) -> None:
+        """
+        Add a single message to history.
+
+        Args:
+            message: Message to add
+            is_prompt: If True, add to prompt_messages instead of regular history
+        """
+        if is_prompt:
+            self.prompt_messages.append(message)
+        else:
+            self.history.append(message)
+
+    def get(self, include_history: bool = True) -> List[MessageParamT]:
+        """
+        Get all messages in memory.
+
+        Args:
+            include_history: If True, include regular history messages
+                             If False, only return prompt messages
+
+        Returns:
+            Combined list of prompt messages and optionally history messages
+        """
+        if include_history:
+            return self.prompt_messages + self.history
+        else:
+            return self.prompt_messages.copy()
+
+    def clear(self, clear_prompts: bool = False) -> None:
+        """
+        Clear history and optionally prompt messages.
+
+        Args:
+            clear_prompts: If True, also clear prompt messages
+        """
+        self.history = []
+        if clear_prompts:
+            self.prompt_messages = []

mcp_agent/{workflows/llm → llm}/model_factory.py

@@ -1,14 +1,18 @@
 from dataclasses import dataclass
 from enum import Enum, auto
-from typing import Optional, Type, Dict, Union, Callable
+from typing import Callable, Dict, Optional, Type, Union
 
 from mcp_agent.agents.agent import Agent
 from mcp_agent.core.exceptions import ModelConfigError
 from mcp_agent.core.request_params import RequestParams
-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_passthrough import PassthroughLLM
-from mcp_agent.workflows.llm.augmented_llm_playback import PlaybackLLM
+from mcp_agent.llm.augmented_llm_passthrough import PassthroughLLM
+from mcp_agent.llm.augmented_llm_playback import PlaybackLLM
+from mcp_agent.llm.providers.augmented_llm_anthropic import AnthropicAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_deepseek import DeepSeekAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
+
+# from mcp_agent.workflows.llm.augmented_llm_deepseek import DeekSeekAugmentedLLM
 
 
 # Type alias for LLM classes
@@ -17,6 +21,7 @@ LLMClass = Union[
     Type[OpenAIAugmentedLLM],
     Type[PassthroughLLM],
     Type[PlaybackLLM],
+    Type[DeepSeekAugmentedLLM],
 ]
 
 
@@ -26,6 +31,7 @@ class Provider(Enum):
     ANTHROPIC = auto()
     OPENAI = auto()
     FAST_AGENT = auto()
+    DEEPSEEK = auto()
 
 
 class ReasoningEffort(Enum):
@@ -53,6 +59,7 @@ class ModelFactory:
         "anthropic": Provider.ANTHROPIC,
         "openai": Provider.OPENAI,
         "fast-agent": Provider.FAST_AGENT,
+        "deepseek": Provider.DEEPSEEK,
     }
 
     # Mapping of effort strings to enum values
@@ -85,6 +92,8 @@ class ModelFactory:
         "claude-3-7-sonnet-latest": Provider.ANTHROPIC,
         "claude-3-opus-20240229": Provider.ANTHROPIC,
         "claude-3-opus-latest": Provider.ANTHROPIC,
+        "deepseek-chat": Provider.DEEPSEEK,
+        #        "deepseek-reasoner": Provider.DEEPSEEK, reinstate on release
     }
 
     MODEL_ALIASES = {
@@ -97,6 +106,8 @@ class ModelFactory:
         "haiku35": "claude-3-5-haiku-latest",
         "opus": "claude-3-opus-latest",
         "opus3": "claude-3-opus-latest",
+        "deepseekv3": "deepseek-chat",
+        "deepseek": "deepseek-chat",
     }
 
     # Mapping of providers to their LLM classes
@@ -104,6 +115,7 @@ class ModelFactory:
         Provider.ANTHROPIC: AnthropicAugmentedLLM,
         Provider.OPENAI: OpenAIAugmentedLLM,
         Provider.FAST_AGENT: PassthroughLLM,
+        Provider.DEEPSEEK: DeepSeekAugmentedLLM,
     }
 
     # Mapping of special model names to their specific LLM classes
@@ -152,7 +164,7 @@ class ModelFactory:
     @classmethod
     def create_factory(
         cls, model_string: str, request_params: Optional[RequestParams] = None
-    ) -> Callable[..., LLMClass]:
+    ) -> Callable[..., AugmentedLLMProtocol]:
         """
         Creates a factory function that follows the attach_llm protocol.
 
@@ -173,19 +185,13 @@ class ModelFactory:
         # Create a factory function matching the attach_llm protocol
         def factory(agent: Agent, **kwargs) -> LLMClass:
             # Create merged params with parsed model name
-            factory_params = (
-                request_params.model_copy() if request_params else RequestParams()
-            )
-            factory_params.model = (
-                config.model_name
-            )  # Use the parsed model name, not the alias
+            factory_params = request_params.model_copy() if request_params else RequestParams()
+            factory_params.model = config.model_name  # Use the parsed model name, not the alias
 
             # Merge with any provided default_request_params
             if "default_request_params" in kwargs and kwargs["default_request_params"]:
                 params_dict = factory_params.model_dump()
-                params_dict.update(
-                    kwargs["default_request_params"].model_dump(exclude_unset=True)
-                )
+                params_dict.update(kwargs["default_request_params"].model_dump(exclude_unset=True))
                 factory_params = RequestParams(**params_dict)
                 factory_params.model = (
                     config.model_name
@@ -208,7 +214,7 @@ class ModelFactory:
                 if key not in ["agent", "default_request_params", "name"]:
                     llm_args[key] = value
 
-            llm = llm_class(**llm_args)
+            llm: AugmentedLLMProtocol = llm_class(**llm_args)
             return llm
 
         return factory

mcp_agent/{workflows/llm → llm}/prompt_utils.py

@@ -97,9 +97,7 @@ def format_server_info(
 
     # Combine all components
     server_content = "\n".join(components)
-    return format_fastagent_tag(
-        "server", f"\n{server_content}\n", {"name": server_name}
-    )
+    return format_fastagent_tag("server", f"\n{server_content}\n", {"name": server_name})
 
 
 def format_agent_info(

mcp_agent/llm/providers/__init__.py

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

mcp_agent/{workflows/llm → llm/providers}/anthropic_utils.py

@@ -8,11 +8,10 @@ leveraging existing code for resource handling and delimited formats.
 from anthropic.types import (
     MessageParam,
 )
-
 from mcp.types import (
-    TextContent,
-    ImageContent,
     EmbeddedResource,
+    ImageContent,
+    TextContent,
     TextResourceContents,
 )
 
@@ -37,9 +36,7 @@ def anthropic_message_param_to_prompt_message_multipart(
 
     # Handle string content (user messages can be simple strings)
     if isinstance(content, str):
-        return PromptMessageMultipart(
-            role=role, content=[TextContent(type="text", text=content)]
-        )
+        return PromptMessageMultipart(role=role, content=[TextContent(type="text", text=content)])
 
     # Convert content blocks to MCP content types
     mcp_contents = []
@@ -52,27 +49,15 @@ def anthropic_message_param_to_prompt_message_multipart(
                 # Check if this is a resource marker
                 if (
                     text
-                    and (
-                        text.startswith("[Resource:")
-                        or text.startswith("[Binary Resource:")
-                    )
+                    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 (
-                            mime_match != "text/plain"
-                        ):  # Only process non-plain text resources
-                            if (
-                                "Resource:" in header
-                                and "Binary Resource:" not in header
-                            ):
-                                uri = (
-                                    header.split("Resource:", 1)[1]
-                                    .split(",")[0]
-                                    .strip()
-                                )
+                        if mime_match != "text/plain":  # Only process non-plain text resources
+                            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",
@@ -94,8 +79,6 @@ def anthropic_message_param_to_prompt_message_multipart(
                 if isinstance(source, dict) and source.get("type") == "base64":
                     media_type = source.get("media_type", "image/png")
                     data = source.get("data", "")
-                    mcp_contents.append(
-                        ImageContent(type="image", data=data, mimeType=media_type)
-                    )
+                    mcp_contents.append(ImageContent(type="image", data=data, mimeType=media_type))
 
     return PromptMessageMultipart(role=role, content=mcp_contents)