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

mcp_agent/workflows/llm/augmented_llm.py

@@ -10,7 +10,6 @@ from typing import (
     TYPE_CHECKING,
 )
 
-from mcp import CreateMessageResult, SamplingMessage
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.workflows.llm.sampling_format_converter import (
     SamplingFormatConverter,
@@ -25,23 +24,28 @@ if TYPE_CHECKING:
     from mcp_agent.context import Context
 
 
-from pydantic import Field
 
 from mcp.types import (
     CallToolRequest,
     CallToolResult,
-    CreateMessageRequestParams,
-    ModelPreferences,
     PromptMessage,
     TextContent,
     GetPromptResult,
 )
 
 from mcp_agent.context_dependent import ContextDependent
-from mcp_agent.core.exceptions import PromptExitError
+from mcp_agent.core.exceptions import ModelConfigError, PromptExitError
+from mcp_agent.core.request_params import RequestParams
 from mcp_agent.event_progress import ProgressAction
-from mcp_agent.mcp.mcp_aggregator import MCPAggregator
-from mcp_agent.workflows.llm.llm_selector import ModelSelector
+
+try:
+    from mcp_agent.mcp.mcp_aggregator import MCPAggregator
+except ImportError:
+    # For testing purposes
+    class MCPAggregator:
+        pass
+
+
 from mcp_agent.ui.console_display import ConsoleDisplay
 from rich.text import Text
 
@@ -155,43 +159,6 @@ class SimpleMemory(Memory, Generic[MessageParamT]):
             self.prompt_messages = []
 
 
-class RequestParams(CreateMessageRequestParams):
-    """
-    Parameters to configure the AugmentedLLM 'generate' requests.
-    """
-
-    messages: None = Field(exclude=True, default=None)
-    """
-    Ignored. 'messages' are removed from CreateMessageRequestParams 
-    to avoid confusion with the 'message' parameter on 'generate' method.
-    """
-
-    maxTokens: int = 2048
-    """The maximum number of tokens to sample, as requested by the server."""
-
-    model: str | None = None
-    """
-    The model to use for the LLM generation.
-    If specified, this overrides the 'modelPreferences' selection criteria.
-    """
-
-    use_history: bool = True
-    """
-    Include the message history in the generate request.
-    """
-
-    max_iterations: int = 10
-    """
-    The maximum number of iterations to run the LLM for.
-    """
-
-    parallel_tool_calls: bool = True
-    """
-    Whether to allow multiple tool calls per iteration.
-    Also known as multi-step tool use.
-    """
-
-
 class AugmentedLLMProtocol(Protocol, Generic[MessageParamT, MessageT]):
     """Protocol defining the interface for augmented LLMs"""
 
@@ -269,30 +236,15 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
         # Initialize the display component
         self.display = ConsoleDisplay(config=self.context.config)
 
-        # Set initial model preferences
-        self.model_preferences = ModelPreferences(
-            costPriority=0.3,
-            speedPriority=0.4,
-            intelligencePriority=0.3,
-        )
-
         # Initialize default parameters
         self.default_request_params = self._initialize_default_params(kwargs)
 
-        # Update model preferences from default params
-        if self.default_request_params and self.default_request_params.modelPreferences:
-            self.model_preferences = self.default_request_params.modelPreferences
-
         # Merge with provided params if any
         if self._init_request_params:
             self.default_request_params = self._merge_request_params(
                 self.default_request_params, self._init_request_params
             )
-            # Update model preferences again if they changed in the merge
-            if self.default_request_params.modelPreferences:
-                self.model_preferences = self.default_request_params.modelPreferences
 
-        self.model_selector = self.context.model_selector
         self.type_converter = type_converter
         self.verb = kwargs.get("verb")
 
@@ -321,39 +273,21 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
     ) -> ModelT:
         """Request a structured LLM generation and return the result as a Pydantic model."""
 
-    # aysnc def generate2_str(self, prompt: PromptMessageMultipart, request_params: RequestParams | None = None) -> List[MessageT]:
-    #     """Request an LLM generation, which may run multiple iterations, and return the result"""
-    #     return None
-
     async def select_model(
         self, request_params: RequestParams | None = None
     ) -> str | None:
         """
-        Select an LLM based on the request parameters.
-        If a model is specified in the request, it will override the model selection criteria.
+        Return the configured model (legacy support)
         """
-        model_preferences = self.model_preferences
-        if request_params is not None:
-            model_preferences = request_params.modelPreferences or model_preferences
-            model = request_params.model
-            if model:
-                return model
+        if request_params.model:
+            return request_params.model
 
-        ## TODO -- can't have been tested, returns invalid model strings (e.g. claude-35-sonnet)
-        if not self.model_selector:
-            self.model_selector = ModelSelector()
-
-        model_info = self.model_selector.select_best_model(
-            model_preferences=model_preferences, provider=self.provider
-        )
-
-        return model_info.name
+        raise ModelConfigError("Internal Error: Model is not configured correctly")
 
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize default parameters for the LLM.
         Should be overridden by provider implementations to set provider-specific defaults."""
         return RequestParams(
-            modelPreferences=self.model_preferences,
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
             max_iterations=10,
@@ -395,25 +329,6 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
 
         return default_request_params
 
-    def to_mcp_message_result(self, result: MessageT) -> CreateMessageResult:
-        """Convert an LLM response to an MCP message result type."""
-        return self.type_converter.to_sampling_result(result)
-
-    def from_mcp_message_result(self, result: CreateMessageResult) -> MessageT:
-        """Convert an MCP message result to an LLM response type."""
-        return self.type_converter.from_sampling_result(result)
-
-    def to_mcp_message_param(self, param: MessageParamT) -> SamplingMessage:
-        """Convert an LLM input to an MCP message (SamplingMessage) type."""
-        return self.type_converter.to_sampling_message(param)
-
-    def from_mcp_message_param(self, param: SamplingMessage) -> MessageParamT:
-        """Convert an MCP message (SamplingMessage) to an LLM input type."""
-        return self.type_converter.from_sampling_message(param)
-
-    def from_mcp_prompt_message(self, message: PromptMessage) -> MessageParamT:
-        return self.type_converter.from_prompt_message(message)
-
     @classmethod
     def convert_message_to_message_param(
         cls, message: MessageT, **kwargs
@@ -689,10 +604,35 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol[MessageParamT, Message
         )
 
         # Delegate to the provider-specific implementation
-        return await self._apply_prompt_template_provider_specific(multipart_messages)
+        return await self._apply_prompt_template_provider_specific(
+            multipart_messages, None
+        )
+
+    async def apply_prompt(
+        self,
+        multipart_messages: List["PromptMessageMultipart"],
+        request_params: RequestParams | None = None,
+    ) -> str:
+        """
+        Apply a list of PromptMessageMultipart messages directly to the LLM.
+        This is a cleaner interface to _apply_prompt_template_provider_specific.
+
+        Args:
+            multipart_messages: List of PromptMessageMultipart objects
+            request_params: Optional parameters to configure the LLM request
+
+        Returns:
+            String representation of the assistant's response
+        """
+        # Delegate to the provider-specific implementation
+        return await self._apply_prompt_template_provider_specific(
+            multipart_messages, request_params
+        )
 
     async def _apply_prompt_template_provider_specific(
-        self, multipart_messages: List["PromptMessageMultipart"]
+        self,
+        multipart_messages: List["PromptMessageMultipart"],
+        request_params: RequestParams | None = None,
     ) -> str:
         """
         Provider-specific implementation of apply_prompt_template.

mcp_agent/workflows/llm/augmented_llm_anthropic.py

@@ -60,7 +60,6 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         """Initialize Anthropic-specific default parameters"""
         return RequestParams(
             model=kwargs.get("model", DEFAULT_ANTHROPIC_MODEL),
-            modelPreferences=self.model_preferences,
             maxTokens=4096,  # default haiku3
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
@@ -360,7 +359,9 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
         )
 
     async def _apply_prompt_template_provider_specific(
-        self, multipart_messages: List["PromptMessageMultipart"]
+        self,
+        multipart_messages: List["PromptMessageMultipart"],
+        request_params: RequestParams | None = None,
     ) -> str:
         """
         Anthropic-specific implementation of apply_prompt_template that handles
@@ -393,7 +394,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
                 "Last message in prompt is from user, generating assistant response"
             )
             message_param = AnthropicConverter.convert_to_anthropic(last_message)
-            return await self.generate_str(message_param)
+            return await self.generate_str(message_param, request_params)
         else:
             # For assistant messages: Return the last message content as text
             self.logger.debug(

mcp_agent/workflows/llm/augmented_llm_openai.py

@@ -92,7 +92,6 @@ class OpenAIAugmentedLLM(
 
         return RequestParams(
             model=chosen_model,
-            modelPreferences=self.model_preferences,
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
             max_iterations=10,
@@ -395,7 +394,9 @@ class OpenAIAugmentedLLM(
         return "\n".join(final_text)
 
     async def _apply_prompt_template_provider_specific(
-        self, multipart_messages: List["PromptMessageMultipart"]
+        self,
+        multipart_messages: List["PromptMessageMultipart"],
+        request_params: RequestParams | None = None,
     ) -> str:
         """
         OpenAI-specific implementation of apply_prompt_template that handles
@@ -431,7 +432,7 @@ class OpenAIAugmentedLLM(
                 "Last message in prompt is from user, generating assistant response"
             )
             message_param = OpenAIConverter.convert_to_openai(last_message)
-            return await self.generate_str(message_param)
+            return await self.generate_str(message_param, request_params)
         else:
             # For assistant messages: Return the last message content as text
             self.logger.debug(

mcp_agent/workflows/llm/augmented_llm_passthrough.py

@@ -1,5 +1,5 @@
 from typing import Any, List, Optional, Type, Union
-import json
+import json  # Import at the module level
 from mcp import GetPromptResult
 from mcp.types import PromptMessage
 from pydantic_core import from_json
@@ -52,6 +52,13 @@ class PassthroughLLM(AugmentedLLM):
         self.show_user_message(message, model="fastagent-passthrough", chat_turn=0)
         await self.show_assistant_message(message, title="ASSISTANT/PASSTHROUGH")
 
+        # Handle PromptMessage by concatenating all parts
+        if isinstance(message, PromptMessage):
+            parts_text = []
+            for part in message.content:
+                parts_text.append(str(part))
+            return "\n".join(parts_text)
+
         return str(message)
 
     async def _call_tool_and_return_result(self, command: str) -> str:
@@ -65,42 +72,73 @@ class PassthroughLLM(AugmentedLLM):
             Tool result as a string
         """
         try:
-            # Parse the tool name and optional arguments
-            parts = command.split(" ", 2)
-            if len(parts) < 2:
-                return "Error: Invalid format. Expected '***CALL_TOOL <tool_name> [arguments_json]'"
-
-            tool_name = parts[1].strip()
-            arguments = None
-
-            # Parse optional JSON arguments if provided
-            if len(parts) > 2:
-                try:
-                    arguments = json.loads(parts[2])
-                except json.JSONDecodeError:
-                    return f"Error: Invalid JSON arguments: {parts[2]}"
-
-            # Call the tool and get the result
-            self.logger.info(f"Calling tool {tool_name} with arguments {arguments}")
+            tool_name, arguments = self._parse_tool_command(command)
             result = await self.aggregator.call_tool(tool_name, arguments)
+            return self._format_tool_result(tool_name, result)
+        except Exception as e:
+            self.logger.error(f"Error calling tool: {str(e)}")
+            return f"Error calling tool: {str(e)}"
+
+    def _parse_tool_command(self, command: str) -> tuple[str, Optional[dict]]:
+        """
+        Parse a tool command string into tool name and arguments.
 
-            # Format the result as a string
-            if result.isError:
-                return f"Error calling tool '{tool_name}': {result.message}"
+        Args:
+            command: The command string in format "***CALL_TOOL <tool_name> [arguments_json]"
 
-            # Extract text content from result
-            result_text = []
+        Returns:
+            Tuple of (tool_name, arguments_dict)
+
+        Raises:
+            ValueError: If command format is invalid
+        """
+        parts = command.split(" ", 2)
+        if len(parts) < 2:
+            raise ValueError(
+                "Invalid format. Expected '***CALL_TOOL <tool_name> [arguments_json]'"
+            )
+
+        tool_name = parts[1].strip()
+        arguments = None
+
+        if len(parts) > 2:
+            try:
+                arguments = json.loads(parts[2])
+            except json.JSONDecodeError:
+                raise ValueError(f"Invalid JSON arguments: {parts[2]}")
+
+        self.logger.info(f"Calling tool {tool_name} with arguments {arguments}")
+        return tool_name, arguments
+
+    def _format_tool_result(self, tool_name: str, result) -> str:
+        """
+        Format tool execution result as a string.
+
+        Args:
+            tool_name: The name of the tool that was called
+            result: The result returned from the tool
+
+        Returns:
+            Formatted result as a string
+        """
+        if result.isError:
+            error_text = []
             for content_item in result.content:
                 if hasattr(content_item, "text"):
-                    result_text.append(content_item.text)
+                    error_text.append(content_item.text)
                 else:
-                    result_text.append(str(content_item))
+                    error_text.append(str(content_item))
+            error_message = "\n".join(error_text) if error_text else "Unknown error"
+            return f"Error calling tool '{tool_name}': {error_message}"
 
-            return "\n".join(result_text)
+        result_text = []
+        for content_item in result.content:
+            if hasattr(content_item, "text"):
+                result_text.append(content_item.text)
+            else:
+                result_text.append(str(content_item))
 
-        except Exception as e:
-            self.logger.error(f"Error calling tool: {str(e)}")
-            return f"Error calling tool: {str(e)}"
+        return "\n".join(result_text)
 
     async def generate_structured(
         self,
@@ -123,26 +161,62 @@ class PassthroughLLM(AugmentedLLM):
     async def generate_prompt(
         self, prompt: "PromptMessageMultipart", request_params: RequestParams | None
     ) -> str:
-        message = prompt.content[0].text if prompt.content else ""
-        if isinstance(message, str) and message.startswith("***CALL_TOOL "):
-            return await self._call_tool_and_return_result(message)
-        return await self.generate_str(message, request_params)
+        # 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 ")
+        ):
+            return await self._call_tool_and_return_result(prompt.content[0].text)
+
+        # Process all parts of the PromptMessageMultipart
+        parts_text = []
+        for part in prompt.content:
+            parts_text.append(str(part))
+
+        # If no parts found, return empty string
+        if not parts_text:
+            return ""
+
+        # Join all parts and process with generate_str
+        return await self.generate_str("\n".join(parts_text), request_params)
+
+    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
 
@@ -157,3 +231,11 @@ class PassthroughLLM(AugmentedLLM):
             arguments=arguments,
         )
         self._messages = prompt_messages
+
+        # Convert prompt messages to multipart format
+        multipart_messages = PromptMessageMultipart.from_prompt_messages(
+            prompt_messages
+        )
+
+        # Use apply_prompt to handle the multipart messages
+        return await self.apply_prompt(multipart_messages)

mcp_agent/workflows/llm/model_factory.py

@@ -4,9 +4,9 @@ from typing import Optional, Type, Dict, Union, Callable
 
 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 import RequestParams
 from mcp_agent.workflows.llm.augmented_llm_passthrough import PassthroughLLM
 from mcp_agent.workflows.llm.augmented_llm_playback import PlaybackLLM
 

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,46 @@ 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})
+    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 +139,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})