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

mcp_agent/workflows/llm/augmented_llm_passthrough.py

@@ -1,8 +1,11 @@
-from typing import Any, List, Optional, Type, Union
 import json  # Import at the module level
+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.logging.logger import get_logger
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.workflows.llm.augmented_llm import (
     AugmentedLLM,
@@ -11,7 +14,6 @@ from mcp_agent.workflows.llm.augmented_llm import (
     ModelT,
     RequestParams,
 )
-from mcp_agent.logging.logger import get_logger
 
 
 class PassthroughLLM(AugmentedLLM):
@@ -23,7 +25,7 @@ class PassthroughLLM(AugmentedLLM):
     parallel workflow where no fan-in aggregation is needed.
     """
 
-    def __init__(self, name: str = "Passthrough", context=None, **kwargs):
+    def __init__(self, name: str = "Passthrough", context=None, **kwargs) -> None:
         super().__init__(name=name, context=context, **kwargs)
         self.provider = "fast-agent"
         # Initialize logger - keep it simple without name reference
@@ -61,6 +63,9 @@ class PassthroughLLM(AugmentedLLM):
 
         return str(message)
 
+    async def initialize(self) -> None:
+        pass
+
     async def _call_tool_and_return_result(self, command: str) -> str:
         """
         Call a tool based on the command and return its result as a string.
@@ -94,9 +99,7 @@ class PassthroughLLM(AugmentedLLM):
         """
         parts = command.split(" ", 2)
         if len(parts) < 2:
-            raise ValueError(
-                "Invalid format. Expected '***CALL_TOOL <tool_name> [arguments_json]'"
-            )
+            raise ValueError("Invalid format. Expected '***CALL_TOOL <tool_name> [arguments_json]'")
 
         tool_name = parts[1].strip()
         arguments = None
@@ -158,15 +161,9 @@ class PassthroughLLM(AugmentedLLM):
         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:
+    async def generate_prompt(self, prompt: "PromptMessageMultipart", request_params: RequestParams | None) -> str:
         # Check if this prompt contains a tool call command
-        if (
-            prompt.content
-            and prompt.content[0].text
-            and prompt.content[0].text.startswith("***CALL_TOOL ")
-        ):
+        if prompt.content and prompt.content[0].text and prompt.content[0].text.startswith("***CALL_TOOL "):
             return await self._call_tool_and_return_result(prompt.content[0].text)
 
         # Process all parts of the PromptMessageMultipart
@@ -181,21 +178,40 @@ class PassthroughLLM(AugmentedLLM):
         # Join all parts and process with generate_str
         return await self.generate_str("\n".join(parts_text), request_params)
 
-    async def apply_prompt_template(
-        self, prompt_result: GetPromptResult, prompt_name: str
+    async def apply_prompt(
+        self,
+        multipart_messages: List["PromptMessageMultipart"],
+        request_params: Optional[RequestParams] = None,
     ) -> str:
+        """
+        Apply a list of PromptMessageMultipart messages directly to the LLM.
+        In PassthroughLLM, this returns a concatenated string of all message content.
+
+        Args:
+            multipart_messages: List of PromptMessageMultipart objects
+            request_params: Optional parameters to configure the LLM request
+
+        Returns:
+            String representation of all message content concatenated together
+        """
+        # Generate and concatenate result from all messages
+        result = ""
+        for prompt in multipart_messages:
+            result += await self.generate_prompt(prompt, request_params) + "\n"
+
+        return result
+
+    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.
+        For PassthroughLLM, this returns all content concatenated together.
 
         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
+            String representation of all message content concatenated together
         """
         prompt_messages: List[PromptMessage] = prompt_result.messages
 
@@ -210,3 +226,9 @@ class PassthroughLLM(AugmentedLLM):
             arguments=arguments,
         )
         self._messages = prompt_messages
+
+        # Convert prompt messages to multipart format
+        multipart_messages = PromptMessageMultipart.to_multipart(prompt_messages)
+
+        # Use apply_prompt to handle the multipart messages
+        return await self.apply_prompt(multipart_messages)

mcp_agent/workflows/llm/augmented_llm_playback.py

@@ -1,9 +1,13 @@
-from typing import List, Optional, Union
+from typing import TYPE_CHECKING, 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
 
+if TYPE_CHECKING:
+    from mcp.types import PromptMessage
+
 
 # TODO -- support tool calling
 class PlaybackLLM(PassthroughLLM):
@@ -19,7 +23,7 @@ class PlaybackLLM(PassthroughLLM):
     been played back, it returns a message indicating that messages are exhausted.
     """
 
-    def __init__(self, name: str = "Playback", **kwargs):
+    def __init__(self, name: str = "Playback", **kwargs) -> None:
         super().__init__(name=name, **kwargs)
         self._messages: List[PromptMessage] = []
         self._current_index = 0
@@ -70,9 +74,7 @@ class PlaybackLLM(PassthroughLLM):
         # 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:
+    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.
 

mcp_agent/workflows/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/model_factory.py

@@ -1,16 +1,16 @@
 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.mcp.interfaces import AugmentedLLMProtocol
 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.augmented_llm_passthrough import PassthroughLLM
 from mcp_agent.workflows.llm.augmented_llm_playback import PlaybackLLM
 
-
 # Type alias for LLM classes
 LLMClass = Union[
     Type[AnthropicAugmentedLLM],
@@ -145,14 +145,10 @@ class ModelFactory:
             if provider is None:
                 raise ModelConfigError(f"Unknown model: {model_name}")
 
-        return ModelConfig(
-            provider=provider, model_name=model_name, reasoning_effort=reasoning_effort
-        )
+        return ModelConfig(provider=provider, model_name=model_name, reasoning_effort=reasoning_effort)
 
     @classmethod
-    def create_factory(
-        cls, model_string: str, request_params: Optional[RequestParams] = None
-    ) -> Callable[..., LLMClass]:
+    def create_factory(cls, model_string: str, request_params: Optional[RequestParams] = None) -> Callable[..., AugmentedLLMProtocol]:
         """
         Creates a factory function that follows the attach_llm protocol.
 
@@ -173,23 +169,15 @@ 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
-                )  # Ensure parsed model name isn't overwritten
+                factory_params.model = config.model_name  # Ensure parsed model name isn't overwritten
 
             # Forward all keyword arguments to LLM constructor
             llm_args = {

mcp_agent/workflows/llm/openai_utils.py

@@ -5,7 +5,7 @@ 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 typing import Any, Dict, Union
 
 from openai.types.chat import (
     ChatCompletionMessage,

mcp_agent/workflows/llm/prompt_utils.py

@@ -5,8 +5,11 @@ XML formatting utilities for consistent prompt engineering across components.
 from typing import Dict, List, Optional, Union
 
 
-def format_xml_tag(tag_name: str, content: Optional[str] = None, 
-                 attributes: Optional[Dict[str, str]] = None) -> str:
+def format_xml_tag(
+    tag_name: str,
+    content: Optional[str] = None,
+    attributes: Optional[Dict[str, str]] = None,
+) -> str:
     """
     Format an XML tag with optional content and attributes.
     Uses self-closing tag when content is None or empty.
@@ -23,56 +26,62 @@ def format_xml_tag(tag_name: str, content: Optional[str] = None,
     attrs_str = ""
     if attributes:
         attrs_str = " " + " ".join(f'{k}="{v}"' for k, v in attributes.items())
-    
+
     # Use self-closing tag if no content
     if content is None or content == "":
         return f"<{tag_name}{attrs_str} />"
-    
+
     # Full tag with content
     return f"<{tag_name}{attrs_str}>{content}</{tag_name}>"
 
 
-def format_fastagent_tag(tag_type: str, content: Optional[str] = None, 
-                        attributes: Optional[Dict[str, str]] = None) -> str:
+def format_fastagent_tag(
+    tag_type: str,
+    content: Optional[str] = None,
+    attributes: Optional[Dict[str, str]] = None,
+) -> str:
     """
     Format a fastagent-namespaced XML tag with consistent formatting.
-    
+
     Args:
         tag_type: Type of fastagent tag (without namespace prefix)
         content: Content to include inside the tag
         attributes: Dictionary of attribute name-value pairs
-        
+
     Returns:
         Formatted fastagent XML tag as string
     """
     return format_xml_tag(f"fastagent:{tag_type}", content, attributes)
 
 
-def format_server_info(server_name: str, description: Optional[str] = None, 
-                      tools: Optional[List[Dict[str, str]]] = None) -> str:
+def format_server_info(
+    server_name: str,
+    description: Optional[str] = None,
+    tools: Optional[List[Dict[str, str]]] = None,
+) -> str:
     """
     Format server information consistently across router and orchestrator modules.
-    
+
     Args:
         server_name: Name of the server
         description: Optional server description
         tools: Optional list of tool dictionaries with 'name' and 'description' keys
-        
+
     Returns:
         Formatted server XML as string
     """
     # Use self-closing tag if no description or tools
     if not description and not tools:
         return format_fastagent_tag("server", None, {"name": server_name})
-    
+
     # Start building components
     components = []
-    
+
     # Add description if present
     if description:
         desc_tag = format_fastagent_tag("description", description)
         components.append(desc_tag)
-    
+
     # Add tools section if tools exist
     if tools and len(tools) > 0:
         tool_tags = []
@@ -81,41 +90,44 @@ def format_server_info(server_name: str, description: Optional[str] = None,
             tool_desc = tool.get("description", "")
             tool_tag = format_fastagent_tag("tool", tool_desc, {"name": tool_name})
             tool_tags.append(tool_tag)
-        
+
         tools_content = "\n".join(tool_tags)
         tools_tag = format_fastagent_tag("tools", f"\n{tools_content}\n")
         components.append(tools_tag)
-    
+
     # Combine all components
     server_content = "\n".join(components)
     return format_fastagent_tag("server", f"\n{server_content}\n", {"name": server_name})
 
 
-def format_agent_info(agent_name: str, description: Optional[str] = None, 
-                     servers: Optional[List[Dict[str, Union[str, List[Dict[str, str]]]]]] = None) -> str:
+def format_agent_info(
+    agent_name: str,
+    description: Optional[str] = None,
+    servers: Optional[List[Dict[str, Union[str, List[Dict[str, str]]]]]] = None,
+) -> str:
     """
     Format agent information consistently across router and orchestrator modules.
-    
+
     Args:
         agent_name: Name of the agent
         description: Optional agent description/instruction
         servers: Optional list of server dictionaries with 'name', 'description', and 'tools' keys
-        
+
     Returns:
         Formatted agent XML as string
     """
     # Start building components
     components = []
-    
+
     # Add description if present
     if description:
         desc_tag = format_fastagent_tag("description", description)
         components.append(desc_tag)
-    
+
     # If no description or servers, use self-closing tag
     if not description and not servers:
         return format_fastagent_tag("agent", None, {"name": agent_name})
-        
+
     # If has servers, format them
     if servers and len(servers) > 0:
         server_tags = []
@@ -125,13 +137,13 @@ def format_agent_info(agent_name: str, description: Optional[str] = None,
             server_tools = server.get("tools", [])
             server_tag = format_server_info(server_name, server_desc, server_tools)
             server_tags.append(server_tag)
-        
+
         # Only add servers section if we have servers
         if server_tags:
             servers_content = "\n".join(server_tags)
             servers_tag = format_fastagent_tag("servers", f"\n{servers_content}\n")
             components.append(servers_tag)
-    
+
     # Combine all components
     agent_content = "\n".join(components)
-    return format_fastagent_tag("agent", f"\n{agent_content}\n", {"name": agent_name})
+    return format_fastagent_tag("agent", f"\n{agent_content}\n", {"name": agent_name})