fast-agent-mcp 0.2.40__py3-none-any.whl → 0.2.42__py3-none-any.whl

mcp_agent/cli/commands/server_helpers.py

@@ -0,0 +1,106 @@
+"""Helper functions for server configuration and naming."""
+
+from typing import Any, Dict
+
+
+def generate_server_name(identifier: str) -> str:
+    """Generate a clean server name from various identifiers.
+
+    Args:
+        identifier: Package name, file path, or other identifier
+
+    Returns:
+        Clean server name with only alphanumeric and underscore characters
+
+    Examples:
+        >>> generate_server_name("@modelcontextprotocol/server-filesystem")
+        'server_filesystem'
+        >>> generate_server_name("./src/my-server.py")
+        'src_my_server'
+        >>> generate_server_name("my-mcp-server")
+        'my_mcp_server'
+    """
+
+    # Remove leading ./ if present
+    if identifier.startswith("./"):
+        identifier = identifier[2:]
+
+    # Handle npm package names with org prefix (only if no file extension)
+    has_file_ext = any(identifier.endswith(ext) for ext in [".py", ".js", ".ts"])
+    if "/" in identifier and not has_file_ext:
+        # This is likely an npm package, take the part after the last slash
+        identifier = identifier.split("/")[-1]
+
+    # Remove file extension for common script files
+    for ext in [".py", ".js", ".ts"]:
+        if identifier.endswith(ext):
+            identifier = identifier[: -len(ext)]
+            break
+
+    # Replace special characters with underscores
+    # Remove @ prefix if present
+    identifier = identifier.lstrip("@")
+
+    # Replace non-alphanumeric characters with underscores
+    server_name = ""
+    for char in identifier:
+        if char.isalnum():
+            server_name += char
+        else:
+            server_name += "_"
+
+    # Clean up multiple underscores
+    while "__" in server_name:
+        server_name = server_name.replace("__", "_")
+
+    # Remove leading/trailing underscores
+    server_name = server_name.strip("_")
+
+    return server_name
+
+
+async def add_servers_to_config(fast_app: Any, servers: Dict[str, Dict[str, Any]]) -> None:
+    """Add server configurations to the FastAgent app config.
+
+    This function handles the repetitive initialization and configuration
+    of MCP servers, ensuring the app is initialized and the config
+    structure exists before adding servers.
+
+    Args:
+        fast_app: The FastAgent instance
+        servers: Dictionary of server configurations
+    """
+    if not servers:
+        return
+
+    from mcp_agent.config import MCPServerSettings, MCPSettings
+
+    # Initialize the app to ensure context is ready
+    await fast_app.app.initialize()
+
+    # Initialize mcp settings if needed
+    if not hasattr(fast_app.app.context.config, "mcp"):
+        fast_app.app.context.config.mcp = MCPSettings()
+
+    # Initialize servers dictionary if needed
+    if (
+        not hasattr(fast_app.app.context.config.mcp, "servers")
+        or fast_app.app.context.config.mcp.servers is None
+    ):
+        fast_app.app.context.config.mcp.servers = {}
+
+    # Add each server to the config
+    for server_name, server_config in servers.items():
+        # Build server settings based on transport type
+        server_settings = {"transport": server_config["transport"]}
+
+        # Add transport-specific settings
+        if server_config["transport"] == "stdio":
+            server_settings["command"] = server_config["command"]
+            server_settings["args"] = server_config["args"]
+        elif server_config["transport"] in ["http", "sse"]:
+            server_settings["url"] = server_config["url"]
+            if "headers" in server_config:
+                server_settings["headers"] = server_config["headers"]
+
+        fast_app.app.context.config.mcp.servers[server_name] = MCPServerSettings(**server_settings)

mcp_agent/cli/constants.py

@@ -0,0 +1,25 @@
+"""Shared constants for CLI routing and commands."""
+
+# Options that should automatically route to the 'go' command
+GO_SPECIFIC_OPTIONS = {
+    "--npx",
+    "--uvx",
+    "--stdio",
+    "--url",
+    "--model",
+    "--models",
+    "--instruction",
+    "-i",
+    "--message",
+    "-m",
+    "--prompt-file",
+    "-p",
+    "--servers",
+    "--auth",
+    "--name",
+    "--config-path",
+    "-c",
+}
+
+# Known subcommands that should not trigger auto-routing
+KNOWN_SUBCOMMANDS = {"go", "setup", "check", "bootstrap", "quickstart", "--help", "-h", "--version"}

mcp_agent/cli/main.py

@@ -48,7 +48,7 @@ def show_welcome() -> None:
     console.print(table)
 
     console.print(
-        "\n[italic]get started with:[/italic] [bold][cyan]fast-agent[/cyan][/bold] [green]setup[/green]"
+        "\n[italic]get started with:[/italic] [bold][cyan]fast-agent[/cyan][/bold] [green]setup[/green]. visit [cyan][link=https://fast-agent.ai]fast-agent.ai[/link][/cyan] for more information."
     )
 
 

mcp_agent/config.py

@@ -6,7 +6,7 @@ for the application configuration.
 import os
 import re
 from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional, Tuple
 
 from pydantic import BaseModel, ConfigDict, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
@@ -175,6 +175,17 @@ class GoogleSettings(BaseModel):
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
+class XAISettings(BaseModel):
+    """
+    Settings for using xAI Grok models in the fast-agent application.
+    """
+
+    api_key: str | None = None
+    base_url: str | None = "https://api.x.ai/v1"
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
 class GenericSettings(BaseModel):
     """
     Settings for using OpenAI models in the fast-agent application.
@@ -242,6 +253,20 @@ class TensorZeroSettings(BaseModel):
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
+class BedrockSettings(BaseModel):
+    """
+    Settings for using AWS Bedrock models in the fast-agent application.
+    """
+
+    region: str | None = None
+    """AWS region for Bedrock service"""
+
+    profile: str | None = None
+    """AWS profile to use for authentication"""
+
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+
 class HuggingFaceSettings(BaseModel):
     """
     Settings for HuggingFace authentication (used for MCP connections).
@@ -296,6 +321,57 @@ class LoggerSettings(BaseModel):
     """Enable markup in console output. Disable for outputs that may conflict with rich console formatting"""
 
 
+def find_fastagent_config_files(start_path: Path) -> Tuple[Optional[Path], Optional[Path]]:
+    """
+    Find FastAgent configuration files with standardized behavior.
+
+    Returns:
+        Tuple of (config_path, secrets_path) where either can be None if not found.
+
+    Strategy:
+    1. Find config file recursively from start_path upward
+    2. Prefer secrets file in same directory as config file
+    3. If no secrets file next to config, search recursively from start_path
+    """
+    config_path = None
+    secrets_path = None
+
+    # First, find the config file with recursive search
+    current = start_path.resolve()
+    while current != current.parent:
+        potential_config = current / "fastagent.config.yaml"
+        if potential_config.exists():
+            config_path = potential_config
+            break
+        current = current.parent
+
+    # If config file found, prefer secrets file in the same directory
+    if config_path:
+        potential_secrets = config_path.parent / "fastagent.secrets.yaml"
+        if potential_secrets.exists():
+            secrets_path = potential_secrets
+        else:
+            # If no secrets file next to config, do recursive search from start
+            current = start_path.resolve()
+            while current != current.parent:
+                potential_secrets = current / "fastagent.secrets.yaml"
+                if potential_secrets.exists():
+                    secrets_path = potential_secrets
+                    break
+                current = current.parent
+    else:
+        # No config file found, just search for secrets file
+        current = start_path.resolve()
+        while current != current.parent:
+            potential_secrets = current / "fastagent.secrets.yaml"
+            if potential_secrets.exists():
+                secrets_path = potential_secrets
+                break
+            current = current.parent
+
+    return config_path, secrets_path
+
+
 class Settings(BaseSettings):
     """
     Settings class for the fast-agent application.
@@ -339,6 +415,9 @@ class Settings(BaseSettings):
     google: GoogleSettings | None = None
     """Settings for using DeepSeek models in the fast-agent application"""
 
+    xai: XAISettings | None = None
+    """Settings for using xAI Grok models in the fast-agent application"""
+
     openrouter: OpenRouterSettings | None = None
     """Settings for using OpenRouter models in the fast-agent application"""
 
@@ -354,6 +433,9 @@ class Settings(BaseSettings):
     aliyun: OpenAISettings | None = None
     """Settings for using Aliyun OpenAI Service in the fast-agent application"""
 
+    bedrock: BedrockSettings | None = None
+    """Settings for using AWS Bedrock models in the fast-agent application"""
+
     huggingface: HuggingFaceSettings | None = None
     """Settings for HuggingFace authentication (used for MCP connections)"""
 
@@ -445,51 +527,36 @@ def get_settings(config_path: str | None = None) -> Settings:
             resolved_path = Path.cwd() / config_file.name
             if resolved_path.exists():
                 config_file = resolved_path
+
+        # When config path is explicitly provided, find secrets using standardized logic
+        secrets_file = None
+        if config_file.exists():
+            _, secrets_file = find_fastagent_config_files(config_file.parent)
     else:
-        config_file = Settings.find_config()
+        # Use standardized discovery for both config and secrets
+        config_file, secrets_file = find_fastagent_config_files(Path.cwd())
 
     merged_settings = {}
 
-    if config_file:
-        if not config_file.exists():
-            print(f"Warning: Specified config file does not exist: {config_file}")
-        else:
-            import yaml  # pylint: disable=C0415
-
-            # Load main config
-            with open(config_file, "r", encoding="utf-8") as f:
-                yaml_settings = yaml.safe_load(f) or {}
-                # Resolve environment variables in the loaded YAML settings
-                resolved_yaml_settings = resolve_env_vars(yaml_settings)
-                merged_settings = resolved_yaml_settings
-            # Look for secrets files recursively up the directory tree
-            # but stop after finding the first one
-            current_dir = config_file.parent
-            found_secrets = False
-            # Start with the absolute path of the config file\'s directory
-            current_dir = config_file.parent.resolve()
-
-            while current_dir != current_dir.parent and not found_secrets:
-                for secrets_filename in [
-                    "fastagent.secrets.yaml",
-                ]:
-                    secrets_file = current_dir / secrets_filename
-                    if secrets_file.exists():
-                        with open(secrets_file, "r", encoding="utf-8") as f:
-                            yaml_secrets = yaml.safe_load(f) or {}
-                            # Resolve environment variables in the loaded secrets YAML
-                            resolved_secrets_yaml = resolve_env_vars(yaml_secrets)
-                            merged_settings = deep_merge(merged_settings, resolved_secrets_yaml)
-                            found_secrets = True
-                            break
-                if not found_secrets:
-                    # Get the absolute path of the parent directory
-                    current_dir = current_dir.parent.resolve()
-
-            _settings = Settings(**merged_settings)
-            return _settings
-    else:
-        pass
-
-    _settings = Settings()
+    import yaml  # pylint: disable=C0415
+
+    # Load main config if it exists
+    if config_file and config_file.exists():
+        with open(config_file, "r", encoding="utf-8") as f:
+            yaml_settings = yaml.safe_load(f) or {}
+            # Resolve environment variables in the loaded YAML settings
+            resolved_yaml_settings = resolve_env_vars(yaml_settings)
+            merged_settings = resolved_yaml_settings
+    elif config_file and not config_file.exists():
+        print(f"Warning: Specified config file does not exist: {config_file}")
+
+    # Load secrets file if found (regardless of whether config file exists)
+    if secrets_file and secrets_file.exists():
+        with open(secrets_file, "r", encoding="utf-8") as f:
+            yaml_secrets = yaml.safe_load(f) or {}
+            # Resolve environment variables in the loaded secrets YAML
+            resolved_secrets_yaml = resolve_env_vars(yaml_secrets)
+            merged_settings = deep_merge(merged_settings, resolved_secrets_yaml)
+
+    _settings = Settings(**merged_settings)
     return _settings

mcp_agent/core/agent_app.py

@@ -9,6 +9,7 @@ from mcp.types import PromptMessage
 from rich import print as rich_print
 
 from mcp_agent.agents.agent import Agent
+from mcp_agent.core.agent_types import AgentType
 from mcp_agent.core.interactive_prompt import InteractivePrompt
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.progress_display import progress_display
@@ -234,13 +235,14 @@ class AgentApp:
         """
         return await self.interactive(agent_name=agent_name, default_prompt=default_prompt)
 
-    async def interactive(self, agent_name: str | None = None, default_prompt: str = "") -> str:
+    async def interactive(self, agent_name: str | None = None, default_prompt: str = "", pretty_print_parallel: bool = False) -> str:
         """
         Interactive prompt for sending messages with advanced features.
 
         Args:
             agent_name: Optional target agent name (uses default if not specified)
             default: Default message to use when user presses enter
+            pretty_print_parallel: Enable clean parallel results display for parallel agents
 
         Returns:
             The result of the interactive session
@@ -275,10 +277,18 @@ class AgentApp:
         # Define the wrapper for send function
         async def send_wrapper(message, agent_name):
             result = await self.send(message, agent_name)
-            
+
+            # Show parallel results if enabled and this is a parallel agent
+            if pretty_print_parallel:
+                agent = self._agents.get(agent_name)
+                if agent and agent.agent_type == AgentType.PARALLEL:
+                    from mcp_agent.ui.console_display import ConsoleDisplay
+                    display = ConsoleDisplay(config=None)
+                    display.show_parallel_results(agent)
+
             # Show usage info after each turn if progress display is enabled
             self._show_turn_usage(agent_name)
-            
+
             return result
 
         # Start the prompt loop with the agent name (not the agent object)
@@ -293,32 +303,111 @@ class AgentApp:
     def _show_turn_usage(self, agent_name: str) -> None:
         """Show subtle usage information after each turn."""
         agent = self._agents.get(agent_name)
-        if not agent or not agent.usage_accumulator:
+        if not agent:
             return
-            
+
+        # Check if this is a parallel agent
+        if agent.agent_type == AgentType.PARALLEL:
+            self._show_parallel_agent_usage(agent)
+        else:
+            self._show_regular_agent_usage(agent)
+
+    def _show_regular_agent_usage(self, agent) -> None:
+        """Show usage for a regular (non-parallel) agent."""
+        usage_info = self._format_agent_usage(agent)
+        if usage_info:
+            with progress_display.paused():
+                rich_print(
+                    f"[dim]Last turn: {usage_info['display_text']}[/dim]{usage_info['cache_suffix']}"
+                )
+
+    def _show_parallel_agent_usage(self, parallel_agent) -> None:
+        """Show usage for a parallel agent and its children."""
+        # Collect usage from all child agents
+        child_usage_data = []
+        total_input = 0
+        total_output = 0
+        total_tool_calls = 0
+
+        # Get usage from fan-out agents
+        if hasattr(parallel_agent, "fan_out_agents") and parallel_agent.fan_out_agents:
+            for child_agent in parallel_agent.fan_out_agents:
+                usage_info = self._format_agent_usage(child_agent)
+                if usage_info:
+                    child_usage_data.append({**usage_info, "name": child_agent.name})
+                    total_input += usage_info["input_tokens"]
+                    total_output += usage_info["output_tokens"]
+                    total_tool_calls += usage_info["tool_calls"]
+
+        # Get usage from fan-in agent
+        if hasattr(parallel_agent, "fan_in_agent") and parallel_agent.fan_in_agent:
+            usage_info = self._format_agent_usage(parallel_agent.fan_in_agent)
+            if usage_info:
+                child_usage_data.append({**usage_info, "name": parallel_agent.fan_in_agent.name})
+                total_input += usage_info["input_tokens"]
+                total_output += usage_info["output_tokens"]
+                total_tool_calls += usage_info["tool_calls"]
+
+        if not child_usage_data:
+            return
+
+        # Show aggregated usage for parallel agent (no context percentage)
+        with progress_display.paused():
+            tool_info = f", {total_tool_calls} tool calls" if total_tool_calls > 0 else ""
+            rich_print(
+                f"[dim]Last turn (parallel): {total_input:,} Input, {total_output:,} Output{tool_info}[/dim]"
+            )
+
+            # Show individual child agent usage
+            for i, usage_data in enumerate(child_usage_data):
+                is_last = i == len(child_usage_data) - 1
+                prefix = "└─" if is_last else "├─"
+                rich_print(
+                    f"[dim]  {prefix} {usage_data['name']}: {usage_data['display_text']}[/dim]{usage_data['cache_suffix']}"
+                )
+
+    def _format_agent_usage(self, agent) -> Optional[Dict]:
+        """Format usage information for a single agent."""
+        if not agent or not agent.usage_accumulator:
+            return None
+
         # Get the last turn's usage (if any)
         turns = agent.usage_accumulator.turns
         if not turns:
-            return
-            
+            return None
+
         last_turn = turns[-1]
         input_tokens = last_turn.display_input_tokens
         output_tokens = last_turn.output_tokens
-        
+
         # Build cache indicators with bright colors
         cache_indicators = ""
         if last_turn.cache_usage.cache_write_tokens > 0:
             cache_indicators += "[bright_yellow]^[/bright_yellow]"
-        if last_turn.cache_usage.cache_read_tokens > 0 or last_turn.cache_usage.cache_hit_tokens > 0:
+        if (
+            last_turn.cache_usage.cache_read_tokens > 0
+            or last_turn.cache_usage.cache_hit_tokens > 0
+        ):
             cache_indicators += "[bright_green]*[/bright_green]"
-            
+
         # Build context percentage - get from accumulator, not individual turn
         context_info = ""
         context_percentage = agent.usage_accumulator.context_usage_percentage
         if context_percentage is not None:
             context_info = f" ({context_percentage:.1f}%)"
-            
-        # Show subtle usage line - pause progress display to ensure visibility
-        with progress_display.paused():
-            cache_suffix = f" {cache_indicators}" if cache_indicators else ""
-            rich_print(f"[dim]Last turn: {input_tokens:,} Input, {output_tokens:,} Output{context_info}[/dim]{cache_suffix}")
+
+        # Build tool call info
+        tool_info = f", {last_turn.tool_calls} tool calls" if last_turn.tool_calls > 0 else ""
+
+        # Build display text
+        display_text = f"{input_tokens:,} Input, {output_tokens:,} Output{tool_info}{context_info}"
+        cache_suffix = f" {cache_indicators}" if cache_indicators else ""
+
+        return {
+            "input_tokens": input_tokens,
+            "output_tokens": output_tokens,
+            "tool_calls": last_turn.tool_calls,
+            "context_percentage": context_percentage,
+            "display_text": display_text,
+            "cache_suffix": cache_suffix,
+        }

mcp_agent/core/agent_types.py

@@ -4,7 +4,7 @@ Type definitions for agents and agent configurations.
 
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import List
+from typing import Dict, List, Optional
 
 from mcp.client.session import ElicitationFnT
 
@@ -31,6 +31,9 @@ class AgentConfig:
     name: str
     instruction: str = "You are a helpful agent."
     servers: List[str] = field(default_factory=list)
+    tools: Optional[Dict[str, List[str]]] = None
+    resources: Optional[Dict[str, List[str]]] = None
+    prompts: Optional[Dict[str, List[str]]] = None
     model: str | None = None
     use_history: bool = True
     default_request_params: RequestParams | None = None
@@ -38,6 +41,7 @@ class AgentConfig:
     agent_type: AgentType = AgentType.BASIC
     default: bool = False
     elicitation_handler: ElicitationFnT | None = None
+    api_key: str | None = None
 
     def __post_init__(self):
         """Ensure default_request_params exists with proper history setting"""