fast-agent-mcp 0.2.6__tar.gz → 0.2.8__tar.gz

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.6
+Version: 0.2.8
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -260,8 +260,7 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 `fast-agent` is multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints via Prompts, Resources and MCP Tool Call results. The inclusion of passthrough and playback LLMs enable rapid development and test of Python glue-code for your applications.
 
-> [!TIP]
-> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
+> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
 
 ### Agent Application Development
 
@@ -525,7 +524,7 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
   servers=["filesystem"],                # list of MCP Servers for the agent
   model="o3-mini.high",                  # specify a model for the agent
   use_history=True,                      # agent maintains chat history
-  request_params={"temperature": 0.7},   # additional parameters for the LLM (or RequestParams())
+  request_params=RequestParams(temperature= 0.7)), # additional parameters for the LLM (or RequestParams())
   human_input=True,                      # agent can request human input
 )
 ```

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/README.md

@@ -18,8 +18,7 @@ The simple declarative syntax lets you concentrate on composing your Prompts and
 
 `fast-agent` is multi-modal, supporting Images and PDFs for both Anthropic and OpenAI endpoints via Prompts, Resources and MCP Tool Call results. The inclusion of passthrough and playback LLMs enable rapid development and test of Python glue-code for your applications.
 
-> [!TIP]
-> `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
+> [!TIP] > `fast-agent` is now MCP Native! Coming Soon - Full Documentation Site and Further MCP Examples.
 
 ### Agent Application Development
 
@@ -283,7 +282,7 @@ agent["greeter"].send("Good Evening!")          # Dictionary access is supported
   servers=["filesystem"],                # list of MCP Servers for the agent
   model="o3-mini.high",                  # specify a model for the agent
   use_history=True,                      # agent maintains chat history
-  request_params={"temperature": 0.7},   # additional parameters for the LLM (or RequestParams())
+  request_params=RequestParams(temperature= 0.7)), # additional parameters for the LLM (or RequestParams())
   human_input=True,                      # agent can request human input
 )
 ```

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.6"
+version = "0.2.8"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/src/mcp_agent/agents/base_agent.py

@@ -215,7 +215,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
 
         # Use the LLM to generate a response
         response = await self.generate([prompt], None)
-        return response.first_text()
+        return response.all_text()
 
     def _normalize_message_input(
         self, message: Union[str, PromptMessage, PromptMessageMultipart]
@@ -625,15 +625,15 @@ class BaseAgent(MCPAggregator, AgentProtocol):
     @property
     def agent_type(self) -> str:
         """
-        Return the type of this agent. 
-        
+        Return the type of this agent.
+
         This is used for display purposes in the interactive prompt and other UI elements.
-        
+
         Returns:
             String representing the agent type
         """
         return self.config.agent_type
-        
+
     @property
     def message_history(self) -> List[PromptMessageMultipart]:
         """

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/src/mcp_agent/agents/workflow/chain_agent.py

@@ -23,7 +23,8 @@ class ChainAgent(BaseAgent):
     A chain agent that processes requests through a series of specialized agents in sequence.
     Passes the output of each agent to the next agent in the chain.
     """
-    
+
+    # TODO -- consider adding "repeat" mode
     @property
     def agent_type(self) -> str:
         """Return the type of this agent."""
@@ -70,20 +71,11 @@ class ChainAgent(BaseAgent):
         # # Get the original user message (last message in the list)
         user_message = multipart_messages[-1] if multipart_messages else None
 
-        # # If no user message, return an error
-        # if not user_message:
-        #     return PromptMessageMultipart(
-        #         role="assistant",
-        #         content=[TextContent(type="text", text="No input message provided.")],
-        #     )
-
-        # Initialize messages with the input
-
         if not self.cumulative:
             response: PromptMessageMultipart = await self.agents[0].generate(multipart_messages)
             # Process the rest of the agents in the chain
             for agent in self.agents[1:]:
-                next_message = Prompt.user(response.content[0].text)
+                next_message = Prompt.user(*response.content)
                 response = await agent.generate([next_message])
 
             return response

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/src/mcp_agent/agents/workflow/router_agent.py

@@ -53,12 +53,29 @@ You are a highly accurate request router that directs incoming requests to the m
 Your task is to analyze the request and determine the most appropriate agent from the options above.
 
 <fastagent:instruction>
-Respond in JSON format. ONLY include JSON (no explanation). NEVER include Code Fences:
+Respond with JSON following the schema below:
 {{
-    "agent": "<agent name>",
-    "confidence": "<high, medium or low>",
-    "reasoning": "<brief explanation>"
+    "type": "object",
+    "required": ["agent", "confidence", "reasoning"],
+    "properties": {{
+        "agent": {{
+            "type": "string",
+            "description": "The exact name of the selected agent"
+        }},
+        "confidence": {{
+            "type": "string",
+            "enum": ["high", "medium", "low"],
+            "description": "Your confidence level in this selection"
+        }},
+        "reasoning": {{
+            "type": "string",
+            "description": "Brief explanation for your selection"
+        }}
+    }}
 }}
+
+Supply only the JSON with no preamble. Use "reasoning" field to describe actions. NEVER EMIT CODE FENCES. 
+
 </fastagent:instruction>
 """
 
@@ -87,7 +104,7 @@ class RouterAgent(BaseAgent):
     A simplified router that uses an LLM to determine the best agent for a request,
     then dispatches the request to that agent and returns the response.
     """
-    
+
     @property
     def agent_type(self) -> str:
         """Return the type of this agent."""

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/src/mcp_agent/config.py

@@ -75,6 +75,9 @@ class MCPServerSettings(BaseModel):
     url: str | None = None
     """The URL for the server (e.g. for SSE transport)."""
 
+    headers: Dict[str, str] | None = None
+    """Headers dictionary for SSE connections"""
+
     auth: MCPServerAuthSettings | None = None
     """The authentication configuration for the server."""
 
@@ -84,9 +87,6 @@ class MCPServerSettings(BaseModel):
     env: Dict[str, str] | None = None
     """Environment variables to pass to the server process."""
 
-    env: Dict[str, str] | None = None
-    """Environment variables to pass to the server process."""
-
     sampling: MCPSamplingSettings | None = None
     """Sampling settings for this Client/Server pair"""
 
@@ -146,6 +146,17 @@ class GenericSettings(BaseModel):
     base_url: str | None = None
 
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+    
+
+class OpenRouterSettings(BaseModel):
+    """
+    Settings for using OpenRouter models via its OpenAI-compatible API.
+    """
+    api_key: str | None = None
+    
+    base_url: str | None = None # Optional override, defaults handled in provider
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
 class TemporalSettings(BaseModel):
@@ -262,6 +273,9 @@ class Settings(BaseSettings):
     deepseek: DeepSeekSettings | None = None
     """Settings for using DeepSeek models in the fast-agent application"""
 
+    openrouter: OpenRouterSettings | None = None
+    """Settings for using OpenRouter models in the fast-agent application"""
+
     generic: GenericSettings | None = None
     """Settings for using Generic models in the fast-agent application"""
 

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/src/mcp_agent/core/enhanced_prompt.py

@@ -285,10 +285,17 @@ async def get_enhanced_input(
             elif cmd == "agents":
                 return "LIST_AGENTS"
             elif cmd == "prompts":
-                return "SELECT_PROMPT"  # Directly launch prompt selection UI
+                # Return a dictionary with select_prompt action instead of a string
+                # This way it will match what the command handler expects
+                return {"select_prompt": True, "prompt_name": None}
             elif cmd == "prompt" and len(cmd_parts) > 1:
-                # Direct prompt selection with name
-                return f"SELECT_PROMPT:{cmd_parts[1].strip()}"
+                # Direct prompt selection with name or number
+                prompt_arg = cmd_parts[1].strip()
+                # Check if it's a number (use as index) or a name (use directly)
+                if prompt_arg.isdigit():
+                    return {"select_prompt": True, "prompt_index": int(prompt_arg)}
+                else:
+                    return f"SELECT_PROMPT:{prompt_arg}"
             elif cmd == "exit":
                 return "EXIT"
             elif cmd.lower() == "stop":
@@ -420,13 +427,27 @@ async def get_argument_input(
             prompt_session.app.exit()
 
 
-async def handle_special_commands(command: str, agent_app=None):
-    """Handle special input commands."""
+async def handle_special_commands(command, agent_app=None):
+    """
+    Handle special input commands.
+    
+    Args:
+        command: The command to handle, can be string or dictionary
+        agent_app: Optional agent app reference
+        
+    Returns:
+        True if command was handled, False if not, or a dict with action info
+    """
     # Quick guard for empty or None commands
     if not command:
         return False
+        
+    # If command is already a dictionary, it has been pre-processed
+    # Just return it directly (like when /prompts converts to select_prompt dict)
+    if isinstance(command, dict):
+        return command
 
-    # Check for special commands
+    # Check for special string commands
     if command == "HELP":
         rich_print("\n[bold]Available Commands:[/bold]")
         rich_print("  /help          - Show this help")
@@ -450,7 +471,7 @@ async def handle_special_commands(command: str, agent_app=None):
         print("\033c", end="")
         return True
 
-    elif command.upper() == "EXIT":
+    elif isinstance(command, str) and command.upper() == "EXIT":
         raise PromptExitError("User requested to exit fast-agent session")
 
     elif command == "LIST_AGENTS":
@@ -462,8 +483,6 @@ async def handle_special_commands(command: str, agent_app=None):
             rich_print("[yellow]No agents available[/yellow]")
         return True
 
-    # Removed LIST_PROMPTS handling as it's now covered by SELECT_PROMPT
-
     elif command == "SELECT_PROMPT" or (
         isinstance(command, str) and command.startswith("SELECT_PROMPT:")
     ):

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/src/mcp_agent/core/fastagent.py

@@ -235,6 +235,8 @@ class FastAgent:
                     progress_display.stop()
 
                 # Pre-flight validation
+                if 0 == len(self.agents):
+                    raise AgentConfigError("No agents defined. Please define at least one agent.")
                 validate_server_references(self.context, self.agents)
                 validate_workflow_references(self.agents)
 

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/src/mcp_agent/core/interactive_prompt.py

@@ -26,6 +26,7 @@ from mcp_agent.core.enhanced_prompt import (
     get_selection_input,
     handle_special_commands,
 )
+from mcp_agent.mcp.mcp_aggregator import SEP  # Import SEP once at the top
 from mcp_agent.progress_display import progress_display
 
 
@@ -96,7 +97,7 @@ class InteractivePrompt:
 
                 # Handle special commands - pass "True" to enable agent switching
                 command_result = await handle_special_commands(user_input, True)
-
+                
                 # Check if we should switch agents
                 if isinstance(command_result, dict):
                     if "switch_agent" in command_result:
@@ -107,6 +108,7 @@ class InteractivePrompt:
                         else:
                             rich_print(f"[red]Agent '{new_agent}' not found[/red]")
                             continue
+                    # Keep the existing list_prompts handler for backward compatibility
                     elif "list_prompts" in command_result and list_prompts_func:
                         # Use the list_prompts_func directly
                         await self._list_prompts(list_prompts_func, agent)
@@ -114,7 +116,29 @@ class InteractivePrompt:
                     elif "select_prompt" in command_result and (list_prompts_func and apply_prompt_func):
                         # Handle prompt selection, using both list_prompts and apply_prompt
                         prompt_name = command_result.get("prompt_name")
-                        await self._select_prompt(list_prompts_func, apply_prompt_func, agent, prompt_name)
+                        prompt_index = command_result.get("prompt_index")
+                        
+                        # If a specific index was provided (from /prompt <number>)
+                        if prompt_index is not None:
+                            # First get a list of all prompts to look up the index
+                            all_prompts = await self._get_all_prompts(list_prompts_func, agent)
+                            if not all_prompts:
+                                rich_print("[yellow]No prompts available[/yellow]")
+                                continue
+                                
+                            # Check if the index is valid
+                            if 1 <= prompt_index <= len(all_prompts):
+                                # Get the prompt at the specified index (1-based to 0-based)
+                                selected_prompt = all_prompts[prompt_index - 1]
+                                # Use the already created namespaced_name to ensure consistency
+                                await self._select_prompt(list_prompts_func, apply_prompt_func, agent, selected_prompt["namespaced_name"])
+                            else:
+                                rich_print(f"[red]Invalid prompt number: {prompt_index}. Valid range is 1-{len(all_prompts)}[/red]")
+                                # Show the prompt list for convenience
+                                await self._list_prompts(list_prompts_func, agent)
+                        else:
+                            # Use the name-based selection
+                            await self._select_prompt(list_prompts_func, apply_prompt_func, agent, prompt_name)
                         continue
 
                 # Skip further processing if command was handled
@@ -131,42 +155,119 @@ class InteractivePrompt:
 
         return result
 
-    async def _list_prompts(self, list_prompts_func, agent_name) -> None:
+    async def _get_all_prompts(self, list_prompts_func, agent_name):
         """
-        List available prompts for an agent.
-
+        Get a list of all available prompts.
+        
         Args:
             list_prompts_func: Function to get available prompts
             agent_name: Name of the agent
+            
+        Returns:
+            List of prompt info dictionaries, sorted by server and name
         """
-        from rich import print as rich_print
-
         try:
-            # Directly call the list_prompts function for this agent
-            rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
-            
-            prompt_servers = await list_prompts_func(agent_name)
+            # Pass None instead of agent_name to get prompts from all servers
+            # the agent_name parameter should never be used as a server name
+            prompt_servers = await list_prompts_func(None)
+            all_prompts = []
             
             # Process the returned prompt servers
             if prompt_servers:
-                found_prompts = False
+                # First collect all prompts
                 for server_name, prompts_info in prompt_servers.items():
                     if prompts_info and hasattr(prompts_info, "prompts") and prompts_info.prompts:
-                        rich_print(f"\n[bold cyan]{server_name}:[/bold cyan]")
                         for prompt in prompts_info.prompts:
-                            rich_print(f"  {prompt.name}")
-                        found_prompts = True
+                            # Use the SEP constant for proper namespacing
+                            all_prompts.append({
+                                "server": server_name,
+                                "name": prompt.name,
+                                "namespaced_name": f"{server_name}{SEP}{prompt.name}",
+                                "description": getattr(prompt, "description", "No description"),
+                                "arg_count": len(getattr(prompt, "arguments", [])),
+                                "arguments": getattr(prompt, "arguments", [])
+                            })
                     elif isinstance(prompts_info, list) and prompts_info:
-                        rich_print(f"\n[bold cyan]{server_name}:[/bold cyan]")
                         for prompt in prompts_info:
                             if isinstance(prompt, dict) and "name" in prompt:
-                                rich_print(f"  {prompt['name']}")
+                                all_prompts.append({
+                                    "server": server_name,
+                                    "name": prompt["name"],
+                                    "namespaced_name": f"{server_name}{SEP}{prompt['name']}",
+                                    "description": prompt.get("description", "No description"),
+                                    "arg_count": len(prompt.get("arguments", [])),
+                                    "arguments": prompt.get("arguments", [])
+                                })
                             else:
-                                rich_print(f"  {prompt}")
-                        found_prompts = True
+                                all_prompts.append({
+                                    "server": server_name,
+                                    "name": str(prompt),
+                                    "namespaced_name": f"{server_name}{SEP}{str(prompt)}",
+                                    "description": "No description",
+                                    "arg_count": 0,
+                                    "arguments": []
+                                })
+                
+                # Sort prompts by server and name for consistent ordering
+                all_prompts.sort(key=lambda p: (p["server"], p["name"]))
+            
+            return all_prompts
+        
+        except Exception as e:
+            import traceback
+
+            from rich import print as rich_print
+            rich_print(f"[red]Error getting prompts: {e}[/red]")
+            rich_print(f"[dim]{traceback.format_exc()}[/dim]")
+            return []
+
+    async def _list_prompts(self, list_prompts_func, agent_name) -> None:
+        """
+        List available prompts for an agent.
+
+        Args:
+            list_prompts_func: Function to get available prompts
+            agent_name: Name of the agent
+        """
+        from rich import print as rich_print
+        from rich.console import Console
+        from rich.table import Table
 
-                if not found_prompts:
-                    rich_print("[yellow]No prompts available[/yellow]")
+        console = Console()
+
+        try:
+            # Directly call the list_prompts function for this agent
+            rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
+            
+            # Get all prompts using the helper function - pass None as server name
+            # to get prompts from all available servers
+            all_prompts = await self._get_all_prompts(list_prompts_func, None)
+            
+            if all_prompts:
+                # Create a table for better display
+                table = Table(title="Available MCP Prompts")
+                table.add_column("#", justify="right", style="cyan")
+                table.add_column("Server", style="green")
+                table.add_column("Prompt Name", style="bright_blue")
+                table.add_column("Description")
+                table.add_column("Args", justify="center")
+                
+                # Add prompts to table
+                for i, prompt in enumerate(all_prompts):
+                    table.add_row(
+                        str(i + 1),
+                        prompt["server"],
+                        prompt["name"],
+                        prompt["description"],
+                        str(prompt["arg_count"])
+                    )
+                
+                console.print(table)
+                
+                # Add usage instructions
+                rich_print("\n[bold]Usage:[/bold]")
+                rich_print("  • Use [cyan]/prompt <number>[/cyan] to select a prompt by number")
+                rich_print("  • Or use [cyan]/prompts[/cyan] to open the prompt selection UI")
             else:
                 rich_print("[yellow]No prompts available[/yellow]")
         except Exception as e:
@@ -192,7 +293,9 @@ class InteractivePrompt:
         try:
             # Get all available prompts directly from the list_prompts function
             rich_print(f"\n[bold]Fetching prompts for agent [cyan]{agent_name}[/cyan]...[/bold]")
-            prompt_servers = await list_prompts_func(agent_name)
+            # IMPORTANT: list_prompts_func gets MCP server prompts, not agent prompts 
+            # So we pass None to get prompts from all servers, not using agent_name as server name
+            prompt_servers = await list_prompts_func(None)
 
             if not prompt_servers:
                 rich_print("[yellow]No prompts available for this agent[/yellow]")
@@ -242,8 +345,8 @@ class InteractivePrompt:
                                 else:
                                     optional_args.append(name)
 
-                    # Create namespaced version
-                    namespaced_name = f"{server_name}-{prompt_name}"
+                    # Create namespaced version using the consistent separator
+                    namespaced_name = f"{server_name}{SEP}{prompt_name}"
 
                     # Add to collection
                     all_prompts.append(
@@ -410,12 +513,13 @@ class InteractivePrompt:
                             arg_values[arg_name] = arg_value
 
             # Apply the prompt
+            namespaced_name = selected_prompt["namespaced_name"]
             rich_print(
-                f"\n[bold]Applying prompt [cyan]{selected_prompt['namespaced_name']}[/cyan]...[/bold]"
+                f"\n[bold]Applying prompt [cyan]{namespaced_name}[/cyan]...[/bold]"
             )
 
             # Call apply_prompt function with the prompt name and arguments
-            await apply_prompt_func(selected_prompt["namespaced_name"], arg_values, agent_name)
+            await apply_prompt_func(namespaced_name, arg_values, agent_name)
 
         except Exception as e:
             import traceback

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/src/mcp_agent/llm/augmented_llm.py

@@ -32,6 +32,7 @@ from mcp_agent.llm.sampling_format_converter import (
     ProviderFormatConverter,
 )
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.helpers.content_helpers import get_text
 from mcp_agent.mcp.interfaces import (
     AugmentedLLMProtocol,
     ModelT,
@@ -147,8 +148,11 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         """Apply the prompt and return the result as a Pydantic model, or None if coercion fails"""
         try:
             result: PromptMessageMultipart = await self.generate(prompt, request_params)
-            json_data = from_json(result.first_text().strip(), allow_partial=True)
+            final_generation = get_text(result.content[-1]) or ""
+            await self.show_assistant_message(final_generation)
+            json_data = from_json(final_generation, allow_partial=True)
             validated_model = model.model_validate(json_data)
+
             return cast("ModelT", validated_model), Prompt.assistant(json_data)
         except Exception as e:
             logger = get_logger(__name__)

{fast_agent_mcp-0.2.6 → fast_agent_mcp-0.2.8}/src/mcp_agent/llm/model_factory.py

@@ -11,6 +11,7 @@ from mcp_agent.llm.providers.augmented_llm_anthropic import AnthropicAugmentedLL
 from mcp_agent.llm.providers.augmented_llm_deepseek import DeepSeekAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_generic import GenericAugmentedLLM
 from mcp_agent.llm.providers.augmented_llm_openai import OpenAIAugmentedLLM
+from mcp_agent.llm.providers.augmented_llm_openrouter import OpenRouterAugmentedLLM
 from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
 
 # from mcp_agent.workflows.llm.augmented_llm_deepseek import DeekSeekAugmentedLLM
@@ -23,6 +24,7 @@ LLMClass = Union[
     Type[PassthroughLLM],
     Type[PlaybackLLM],
     Type[DeepSeekAugmentedLLM],
+    Type[OpenRouterAugmentedLLM],
 ]
 
 
@@ -34,6 +36,7 @@ class Provider(Enum):
     FAST_AGENT = auto()
     DEEPSEEK = auto()
     GENERIC = auto()
+    OPENROUTER = auto()
 
 
 class ReasoningEffort(Enum):
@@ -63,6 +66,7 @@ class ModelFactory:
         "fast-agent": Provider.FAST_AGENT,
         "deepseek": Provider.DEEPSEEK,
         "generic": Provider.GENERIC,
+        "openrouter": Provider.OPENROUTER,
     }
 
     # Mapping of effort strings to enum values
@@ -120,6 +124,7 @@ class ModelFactory:
         Provider.FAST_AGENT: PassthroughLLM,
         Provider.DEEPSEEK: DeepSeekAugmentedLLM,
         Provider.GENERIC: GenericAugmentedLLM,
+        Provider.OPENROUTER: OpenRouterAugmentedLLM,
     }
 
     # Mapping of special model names to their specific LLM classes