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

mcp_agent/mcp/mcp_aggregator.py

@@ -461,8 +461,8 @@ class MCPAggregator(ContextDependent):
         if server_name is None or local_tool_name is None:
             logger.error(f"Error: Tool '{name}' not found")
             return CallToolResult(
-                isError=True, 
-                content=[TextContent(type="text", text=f"Tool '{name}' not found")]
+                isError=True,
+                content=[TextContent(type="text", text=f"Tool '{name}' not found")],
             )
 
         logger.info(
@@ -482,8 +482,7 @@ class MCPAggregator(ContextDependent):
             method_name="call_tool",
             method_args={"name": local_tool_name, "arguments": arguments},
             error_factory=lambda msg: CallToolResult(
-                isError=True, 
-                content=[TextContent(type="text", text=msg)]
+                isError=True, content=[TextContent(type="text", text=msg)]
             ),
         )
 
@@ -906,8 +905,8 @@ class MCPCompoundServer(Server):
             return result.content
         except Exception as e:
             return CallToolResult(
-                isError=True, 
-                content=[TextContent(type="text", text=f"Error calling tool: {e}")]
+                isError=True,
+                content=[TextContent(type="text", text=f"Error calling tool: {e}")],
             )
 
     async def _get_prompt(

mcp_agent/mcp/sampling.py

@@ -1,26 +1,24 @@
 """
-Module for handling MCP Sampling functionality without causing circular imports.
-This module is carefully designed to avoid circular imports in the agent system.
+This simplified implementation directly converts between MCP types and PromptMessageMultipart.
 """
 
 from mcp import ClientSession
 from mcp.types import (
     CreateMessageRequestParams,
     CreateMessageResult,
-    TextContent,
 )
 
+from mcp_agent.core.agent_types import AgentConfig
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
-# Protocol is sufficient to describe the interface - no need for TYPE_CHECKING imports
+from mcp_agent.workflows.llm.sampling_converter import SamplingConverter
 
 logger = get_logger(__name__)
 
 
 def create_sampling_llm(
-    mcp_ctx: ClientSession, model_string: str
+    params: CreateMessageRequestParams, model_string: str
 ) -> AugmentedLLMProtocol:
     """
     Create an LLM instance for sampling without tools support.
@@ -34,10 +32,8 @@ def create_sampling_llm(
         An initialized LLM instance ready to use
     """
     from mcp_agent.workflows.llm.model_factory import ModelFactory
-    from mcp_agent.agents.agent import Agent, AgentConfig
+    from mcp_agent.agents.agent import Agent
 
-    # Get application context from global state if available
-    # We don't try to extract it from mcp_ctx as they're different contexts
     app_context = None
     try:
         from mcp_agent.context import get_current_context
@@ -46,20 +42,10 @@ def create_sampling_llm(
     except Exception:
         logger.warning("App context not available for sampling call")
 
-    # Create a minimal agent configuration
-    agent_config = AgentConfig(
-        name="sampling_agent",
-        instruction="You are a sampling agent.",
-        servers=[],  # No servers needed
-    )
-
-    # Create agent with our application context (not the MCP context)
-    # Set connection_persistence=False to avoid server connections
     agent = Agent(
-        config=agent_config,
+        config=sampling_agent_config(params),
         context=app_context,
-        server_names=[],  # Make sure no server connections are attempted
-        connection_persistence=False,  # Avoid server connection management
+        connection_persistence=False,
     )
 
     # Create the LLM using the factory
@@ -76,9 +62,20 @@ async def sample(
     mcp_ctx: ClientSession, params: CreateMessageRequestParams
 ) -> CreateMessageResult:
     """
-    Handle sampling requests from the MCP protocol.
-    This function extracts the model from the server config and
-    returns a simple response using the specified model.
+    Handle sampling requests from the MCP protocol using SamplingConverter.
+
+    This function:
+    1. Extracts the model from the request
+    2. Uses SamplingConverter to convert types
+    3. Calls the LLM's generate_prompt method
+    4. Returns the result as a CreateMessageResult
+
+    Args:
+        mcp_ctx: The MCP ClientSession
+        params: The sampling request parameters
+
+    Returns:
+        A CreateMessageResult containing the LLM's response
     """
     model = None
     try:
@@ -95,39 +92,49 @@ async def sample(
         if model is None:
             raise ValueError("No model configured")
 
-        # Create an LLM instance using our utility function
-        llm = create_sampling_llm(mcp_ctx, model)
+        # Create an LLM instance
+        llm = create_sampling_llm(params, model)
 
-        # Get user message from the request params
-        user_message = params.messages[0].content.text
+        # Extract all messages from the request params
+        if not params.messages:
+            raise ValueError("No messages provided")
 
-        # Create a multipart prompt message with the user's input
-        prompt = PromptMessageMultipart(
-            role="user", content=[TextContent(type="text", text=user_message)]
-        )
+        # Convert all SamplingMessages to PromptMessageMultipart objects
+        conversation = SamplingConverter.convert_messages(params.messages)
+
+        # Extract request parameters using our converter
+        request_params = SamplingConverter.extract_request_params(params)
 
-        try:
-            # Use the LLM to generate a response
-            logger.info(f"Processing input: {user_message[:50]}...")
-            llm_response = await llm.generate_prompt(prompt, None)
-            logger.info(f"Generated response: {llm_response[:50]}...")
-        except Exception as e:
-            # If there's an error in LLM processing, fall back to echo
-            logger.error(f"Error generating response: {str(e)}")
-            llm_response = f"Echo response: {user_message}"
-
-        # Return the LLM-generated response
-        return CreateMessageResult(
-            role="assistant",
-            content=TextContent(type="text", text=llm_response),
-            model=model,
-            stopReason="endTurn",
+        # Use the new public apply_prompt method which is cleaner than calling the protected method
+        llm_response = await llm.apply_prompt(conversation, request_params)
+        logger.info(f"Complete sampling request : {llm_response[:50]}...")
+
+        # Create result using our converter
+        return SamplingConverter.create_message_result(
+            response=llm_response, model=model
         )
     except Exception as e:
         logger.error(f"Error in sampling: {str(e)}")
-        return CreateMessageResult(
-            role="assistant",
-            content=TextContent(type="text", text=f"Error in sampling: {str(e)}"),
-            model=model or "unknown",
-            stopReason="error",
+        return SamplingConverter.error_result(
+            error_message=f"Error in sampling: {str(e)}", model=model
         )
+
+
+def sampling_agent_config(
+    params: CreateMessageRequestParams = None,
+) -> AgentConfig:
+    """
+    Build a sampling AgentConfig based on request parameters.
+
+    Args:
+        params: Optional CreateMessageRequestParams that may contain a system prompt
+
+    Returns:
+        An initialized AgentConfig for use in sampling
+    """
+    # Use systemPrompt from params if available, otherwise use default
+    instruction = "You are a helpful AI Agent."
+    if params and hasattr(params, "systemPrompt") and params.systemPrompt is not None:
+        instruction = params.systemPrompt
+
+    return AgentConfig(name="sampling_agent", instruction=instruction, servers=[])

mcp_agent/mcp_server/__init__.py

@@ -1,4 +1,4 @@
 # Import and re-export AgentMCPServer to avoid circular imports
 from mcp_agent.mcp_server.agent_server import AgentMCPServer
 
-__all__ = ["AgentMCPServer"]
+__all__ = ["AgentMCPServer"]

mcp_agent/resources/examples/prompting/__init__.py

@@ -1,3 +1,3 @@
 """
 Prompting examples package for MCP Agent.
-"""
+"""

mcp_agent/ui/console_display.py

@@ -250,14 +250,14 @@ class ConsoleDisplay:
 
         if agent_name:
             content.append(f" for {agent_name}", style="cyan italic")
-            
+
         # Add template arguments if provided
         if arguments:
             content.append("\n\nArguments:", style="cyan")
             for key, value in arguments.items():
                 content.append(f"\n  {key}: ", style="cyan bold")
                 content.append(value, style="white")
-                
+
         if description:
             content.append("\n\n", style="default")
             content.append(description, style="dim white")

mcp_agent/workflows/evaluator_optimizer/evaluator_optimizer.py

@@ -10,7 +10,8 @@ from mcp_agent.workflows.llm.augmented_llm import (
     ModelT,
     RequestParams,
 )
-from mcp_agent.agents.agent import Agent, AgentConfig
+from mcp_agent.agents.agent import Agent
+from mcp_agent.core.agent_types import AgentConfig
 from mcp_agent.logging.logger import get_logger
 from mcp_agent.workflows.llm.augmented_llm_passthrough import PassthroughLLM
 
@@ -68,7 +69,6 @@ class EvaluatorOptimizerLLM(AugmentedLLM[MessageParamT, MessageT]):
     def _initialize_default_params(self, kwargs: dict) -> RequestParams:
         """Initialize default parameters using the workflow's settings."""
         return RequestParams(
-            modelPreferences=self.model_preferences,
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
             max_iterations=10,

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

@@ -181,21 +181,42 @@ 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(
+        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 +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