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

mcp_agent/cli/commands/check_config.py

@@ -23,30 +23,14 @@ console = Console()
 
 
 def find_config_files(start_path: Path) -> dict[str, Optional[Path]]:
-    """Find FastAgent configuration files in current directory or parents."""
-    results = {
-        "config": None,
-        "secrets": None,
-    }
-
-    current = start_path
-    while current != current.parent:  # Stop at root directory
-        config_path = current / "fastagent.config.yaml"
-        secrets_path = current / "fastagent.secrets.yaml"
-
-        if config_path.exists() and results["config"] is None:
-            results["config"] = config_path
-
-        if secrets_path.exists() and results["secrets"] is None:
-            results["secrets"] = secrets_path
+    """Find FastAgent configuration files, preferring secrets file next to config file."""
+    from mcp_agent.config import find_fastagent_config_files
 
-        # Stop searching if we found both files
-        if results["config"] is not None and results["secrets"] is not None:
-            break
-
-        current = current.parent
-
-    return results
+    config_path, secrets_path = find_fastagent_config_files(start_path)
+    return {
+        "config": config_path,
+        "secrets": secrets_path,
+    }
 
 
 def get_system_info() -> dict:
@@ -109,13 +93,23 @@ def check_api_keys(secrets_summary: dict, config_summary: dict) -> dict:
     secrets_status = secrets_summary.get("status", "not_found")
     # Get config if available
     config = config_summary if config_summary.get("status") == "parsed" else {}
+
     config_azure = {}
     if config and "azure" in config.get("config", {}):
         config_azure = config["config"]["azure"]
 
-    for provider_value in results:
+    for provider in results:
+        # Always check environment variables first
+        env_key_name = ProviderKeyManager.get_env_key_name(provider)
+        env_key_value = os.environ.get(env_key_name)
+        if env_key_value:
+            if len(env_key_value) > 5:
+                results[provider]["env"] = f"...{env_key_value[-5:]}"
+            else:
+                results[provider]["env"] = "...***"
+
         # Special handling for Azure: support api_key and DefaultAzureCredential
-        if provider_value == "azure":
+        if provider == "azure":
             # Prefer secrets if present, else fallback to config
             azure_cfg = {}
             if secrets_status == "parsed" and "azure" in secrets:
@@ -125,40 +119,18 @@ def check_api_keys(secrets_summary: dict, config_summary: dict) -> dict:
 
             use_default_cred = azure_cfg.get("use_default_azure_credential", False)
             base_url = azure_cfg.get("base_url")
-            api_key = azure_cfg.get("api_key")
-            # DefaultAzureCredential mode
             if use_default_cred and base_url:
-                results[provider_value]["config"] = "DefaultAzureCredential"
-            # API key mode (retrocompatible)
-            if api_key and api_key != API_KEY_HINT_TEXT:
-                if len(api_key) > 5:
-                    if results[provider_value]["config"]:
-                        results[provider_value]["config"] += " + api_key"
-                    else:
-                        results[provider_value]["config"] = f"...{api_key[-5:]}"
+                results[provider]["config"] = "DefaultAzureCredential"
+                continue
+
+        # Check secrets file if it was parsed successfully
+        if secrets_status == "parsed":
+            config_key = ProviderKeyManager.get_config_file_key(provider, secrets)
+            if config_key and config_key != API_KEY_HINT_TEXT:
+                if len(config_key) > 5:
+                    results[provider]["config"] = f"...{config_key[-5:]}"
                 else:
-                    if results[provider_value]["config"]:
-                        results[provider_value]["config"] += " + api_key"
-                    else:
-                        results[provider_value]["config"] = "...***"
-        else:
-            # Check environment variables using ProviderKeyManager
-            env_key_name = ProviderKeyManager.get_env_key_name(provider_value)
-            env_key_value = os.environ.get(env_key_name)
-            if env_key_value:
-                if len(env_key_value) > 5:
-                    results[provider_value]["env"] = f"...{env_key_value[-5:]}"
-                else:
-                    results[provider_value]["env"] = "...***"
-
-            # Check secrets file if it was parsed successfully
-            if secrets_status == "parsed":
-                config_key = ProviderKeyManager.get_config_file_key(provider_value, secrets)
-                if config_key and config_key != API_KEY_HINT_TEXT:
-                    if len(config_key) > 5:
-                        results[provider_value]["config"] = f"...{config_key[-5:]}"
-                    else:
-                        results[provider_value]["config"] = "...***"
+                    results[provider]["config"] = "...***"
 
     return results
 
@@ -173,11 +145,24 @@ def get_fastagent_version() -> str:
 
 def get_config_summary(config_path: Optional[Path]) -> dict:
     """Extract key information from the configuration file."""
+    from mcp_agent.config import Settings
+
+    # Get actual defaults from Settings class
+    default_settings = Settings()
+
     result = {
         "status": "not_found",  # Default status: not found
         "error": None,
-        "default_model": "haiku (system default)",
-        "logger": {},
+        "default_model": default_settings.default_model,
+        "logger": {
+            "level": default_settings.logger.level,
+            "type": default_settings.logger.type,
+            "progress_display": default_settings.logger.progress_display,
+            "show_chat": default_settings.logger.show_chat,
+            "show_tools": default_settings.logger.show_tools,
+            "truncate_tools": default_settings.logger.truncate_tools,
+            "enable_markup": default_settings.logger.enable_markup,
+        },
         "mcp_servers": [],
     }
 
@@ -207,11 +192,19 @@ def get_config_summary(config_path: Optional[Path]) -> dict:
         if "logger" in config:
             logger_config = config["logger"]
             result["logger"] = {
-                "level": logger_config.get("level", "info (default)"),
-                "type": logger_config.get("type", "console (default)"),
-                "progress_display": str(logger_config.get("progress_display", True)),
-                "show_chat": str(logger_config.get("show_chat", True)),
-                "show_tools": str(logger_config.get("show_tools", True)),
+                "level": logger_config.get("level", default_settings.logger.level),
+                "type": logger_config.get("type", default_settings.logger.type),
+                "progress_display": logger_config.get(
+                    "progress_display", default_settings.logger.progress_display
+                ),
+                "show_chat": logger_config.get("show_chat", default_settings.logger.show_chat),
+                "show_tools": logger_config.get("show_tools", default_settings.logger.show_tools),
+                "truncate_tools": logger_config.get(
+                    "truncate_tools", default_settings.logger.truncate_tools
+                ),
+                "enable_markup": logger_config.get(
+                    "enable_markup", default_settings.logger.enable_markup
+                ),
             }
 
         # Get MCP server info
@@ -228,10 +221,11 @@ def get_config_summary(config_path: Optional[Path]) -> dict:
                 if "url" in server_config:
                     url = server_config.get("url", "")
                     server_info["url"] = url
-                    
+
                     # Use URL path to determine transport type
                     try:
                         from .url_parser import parse_server_url
+
                         _, transport_type, _ = parse_server_url(url)
                         server_info["transport"] = transport_type.upper()
                     except Exception:
@@ -288,7 +282,9 @@ def show_check_summary() -> None:
     system_table.add_row("Python Version", ".".join(system_info["python_version"].split(".")[:3]))
     system_table.add_row("Python Path", system_info["python_path"])
 
-    console.print(Panel(system_table, title="System Information", border_style="blue"))
+    console.print(
+        Panel(system_table, title="System Information", title_align="left", border_style="blue")
+    )
 
     # Configuration files panel
     config_path = config_files["config"]
@@ -327,25 +323,59 @@ def show_check_summary() -> None:
             "Default Model", config_summary.get("default_model", "haiku (system default)")
         )
 
-        # Add logger settings if available
-        logger = config_summary.get("logger", {})
-        if logger:
-            files_table.add_row("Logger Level", logger.get("level", "info (default)"))
-            files_table.add_row("Logger Type", logger.get("type", "console (default)"))
-            files_table.add_row("Progress Display", logger.get("progress_display", "True"))
-            files_table.add_row("Show Chat", logger.get("show_chat", "True"))
-            files_table.add_row("Show Tools", logger.get("show_tools", "True"))
+    console.print(
+        Panel(files_table, title="Configuration Files", title_align="left", border_style="blue")
+    )
+
+    # Logger Settings panel with two-column layout
+    logger = config_summary.get("logger", {})
+    logger_table = Table(show_header=True, box=None)
+    logger_table.add_column("Setting", style="cyan")
+    logger_table.add_column("Value")
+    logger_table.add_column("Setting", style="cyan")
+    logger_table.add_column("Value")
+
+    def bool_to_symbol(value):
+        return "[bold green]✓[/bold green]" if value else "[bold red]✗[/bold red]"
+
+    # Prepare all settings as pairs
+    settings_data = [
+        ("Logger Level", logger.get("level", "warning (default)")),
+        ("Logger Type", logger.get("type", "file (default)")),
+        ("Progress Display", bool_to_symbol(logger.get("progress_display", True))),
+        ("Show Chat", bool_to_symbol(logger.get("show_chat", True))),
+        ("Show Tools", bool_to_symbol(logger.get("show_tools", True))),
+        ("Truncate Tools", bool_to_symbol(logger.get("truncate_tools", True))),
+        ("Enable Markup", bool_to_symbol(logger.get("enable_markup", True))),
+    ]
+
+    # Add rows in two-column layout
+    for i in range(0, len(settings_data), 2):
+        left_setting, left_value = settings_data[i]
+        if i + 1 < len(settings_data):
+            right_setting, right_value = settings_data[i + 1]
+            logger_table.add_row(left_setting, left_value, right_setting, right_value)
+        else:
+            # Odd number of settings - fill right column with empty strings
+            logger_table.add_row(left_setting, left_value, "", "")
 
-    console.print(Panel(files_table, title="Configuration Files", border_style="blue"))
+    console.print(
+        Panel(logger_table, title="Logger Settings", title_align="left", border_style="blue")
+    )
 
-    # API keys panel
+    # API keys panel with two-column layout
     keys_table = Table(show_header=True, box=None)
     keys_table.add_column("Provider", style="cyan")
     keys_table.add_column("Env", justify="center")
     keys_table.add_column("Config", justify="center")
     keys_table.add_column("Active Key", style="green")
+    keys_table.add_column("Provider", style="cyan")
+    keys_table.add_column("Env", justify="center")
+    keys_table.add_column("Config", justify="center")
+    keys_table.add_column("Active Key", style="green")
 
-    for provider, status in api_keys.items():
+    def format_provider_row(provider, status):
+        """Format a single provider's status for display."""
         # Environment key indicator
         if status["env"] and status["config"]:
             # Both exist but config takes precedence (env is present but not active)
@@ -379,10 +409,35 @@ def show_check_summary() -> None:
             # No key available for other providers
             active = "[dim]Not configured[/dim]"
 
-        keys_table.add_row(provider.capitalize(), env_status, config_status, active)
+        # Get the proper display name for the provider
+        from mcp_agent.llm.provider_types import Provider
+
+        provider_enum = Provider(provider)
+        display_name = provider_enum.display_name
+
+        return display_name, env_status, config_status, active
+
+    # Split providers into two columns
+    providers_list = list(api_keys.items())
+    mid_point = (len(providers_list) + 1) // 2  # Round up for odd numbers
+
+    for i in range(mid_point):
+        # Left column
+        left_provider, left_status = providers_list[i]
+        left_data = format_provider_row(left_provider, left_status)
+
+        # Right column (if exists)
+        if i + mid_point < len(providers_list):
+            right_provider, right_status = providers_list[i + mid_point]
+            right_data = format_provider_row(right_provider, right_status)
+            # Add row with both columns
+            keys_table.add_row(*left_data, *right_data)
+        else:
+            # Add row with only left column (right column empty)
+            keys_table.add_row(*left_data, "", "", "", "")
 
     # Print the API Keys panel (fix: this was missing)
-    keys_panel = Panel(keys_table, title="API Keys", border_style="blue", subtitle_align="left")
+    keys_panel = Panel(keys_table, title="API Keys", title_align="left", border_style="blue")
     console.print(keys_panel)
 
     # MCP Servers panel (shown after API Keys)
@@ -406,12 +461,16 @@ def show_check_summary() -> None:
                     command_url = server["url"] or "[dim]Not configured[/dim]"
                     servers_table.add_row(name, transport, command_url)
 
-            console.print(Panel(servers_table, title="MCP Servers", border_style="blue"))
+            console.print(
+                Panel(servers_table, title="MCP Servers", title_align="left", border_style="blue")
+            )
 
     # Show help tips
     if config_status == "not_found" or secrets_status == "not_found":
         console.print("\n[bold]Setup Tips:[/bold]")
-        console.print("Run [cyan]fast-agent setup[/cyan] to create configuration files")
+        console.print(
+            "Run [cyan]fast-agent setup[/cyan] to create configuration files. Visit [cyan][link=https://fast-agent.ai]fast-agent.ai[/link][/cyan] for configuration guides. "
+        )
     elif config_status == "error" or secrets_status == "error":
         console.print("\n[bold]Config File Issues:[/bold]")
         console.print("Fix the YAML syntax errors in your configuration files")

mcp_agent/cli/commands/go.py

@@ -1,16 +1,20 @@
 """Run an interactive agent directly from the command line."""
 
 import asyncio
+import shlex
 import sys
 from typing import Dict, List, Optional
 
 import typer
 
+from mcp_agent.cli.commands.server_helpers import add_servers_to_config, generate_server_name
 from mcp_agent.cli.commands.url_parser import generate_server_configs, parse_server_urls
 from mcp_agent.core.fastagent import FastAgent
+from mcp_agent.ui.console_display import ConsoleDisplay
 
 app = typer.Typer(
-    help="Run an interactive agent directly from the command line without creating an agent.py file"
+    help="Run an interactive agent directly from the command line without creating an agent.py file",
+    context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
 )
 
 
@@ -23,11 +27,11 @@ async def _run_agent(
     message: Optional[str] = None,
     prompt_file: Optional[str] = None,
     url_servers: Optional[Dict[str, Dict[str, str]]] = None,
+    stdio_servers: Optional[Dict[str, Dict[str, str]]] = None,
 ) -> None:
     """Async implementation to run an interactive agent."""
     from pathlib import Path
 
-    from mcp_agent.config import MCPServerSettings, MCPSettings
     from mcp_agent.mcp.prompts.prompt_load import load_prompt_multipart
 
     # Create the FastAgent instance
@@ -40,41 +44,69 @@ async def _run_agent(
 
     fast = FastAgent(**fast_kwargs)
 
-    # Add URL-based servers to the context configuration
-    if url_servers:
-        # Initialize the app to ensure context is ready
-        await fast.app.initialize()
+    # Add all dynamic servers to the configuration
+    await add_servers_to_config(fast, url_servers)
+    await add_servers_to_config(fast, stdio_servers)
 
-        # Initialize mcp settings if needed
-        if not hasattr(fast.app.context.config, "mcp"):
-            fast.app.context.config.mcp = MCPSettings()
+    # Check if we have multiple models (comma-delimited)
+    if model and "," in model:
+        # Parse multiple models
+        models = [m.strip() for m in model.split(",") if m.strip()]
 
-        # Initialize servers dictionary if needed
-        if (
-            not hasattr(fast.app.context.config.mcp, "servers")
-            or fast.app.context.config.mcp.servers is None
-        ):
-            fast.app.context.config.mcp.servers = {}
+        # Create an agent for each model
+        fan_out_agents = []
+        for i, model_name in enumerate(models):
+            agent_name = f"{model_name}"
 
-        # Add each URL server to the config
-        for server_name, server_config in url_servers.items():
-            server_settings = {"transport": server_config["transport"], "url": server_config["url"]}
+            # Define the agent with specified parameters
+            agent_kwargs = {"instruction": instruction, "name": agent_name}
+            if server_list:
+                agent_kwargs["servers"] = server_list
+            agent_kwargs["model"] = model_name
 
-            # Add headers if present in the server config
-            if "headers" in server_config:
-                server_settings["headers"] = server_config["headers"]
+            @fast.agent(**agent_kwargs)
+            async def model_agent():
+                pass
 
-            fast.app.context.config.mcp.servers[server_name] = MCPServerSettings(**server_settings)
+            fan_out_agents.append(agent_name)
 
-    # Define the agent with specified parameters
-    agent_kwargs = {"instruction": instruction}
-    if server_list:
-        agent_kwargs["servers"] = server_list
-    if model:
-        agent_kwargs["model"] = model
+        # Create a silent fan-in agent for cleaner output
+        @fast.agent(
+            name="aggregate",
+            model="silent",
+            instruction="You are a silent agent that combines outputs from parallel agents.",
+        )
+        async def fan_in_agent():
+            pass
 
-    # Handle prompt file and message options
-    if message or prompt_file:
+        # Create a parallel agent with silent fan_in
+        @fast.parallel(
+            name="parallel",
+            fan_out=fan_out_agents,
+            fan_in="aggregate",
+            include_request=True,
+        )
+        async def cli_agent():
+            async with fast.run() as agent:
+                if message:
+                    await agent.parallel.send(message)
+                    display = ConsoleDisplay(config=None)
+                    display.show_parallel_results(agent.parallel)
+                elif prompt_file:
+                    prompt = load_prompt_multipart(Path(prompt_file))
+                    await agent.parallel.generate(prompt)
+                    display = ConsoleDisplay(config=None)
+                    display.show_parallel_results(agent.parallel)
+                else:
+                    await agent.interactive(agent_name="parallel", pretty_print_parallel=True)
+    else:
+        # Single model - use original behavior
+        # Define the agent with specified parameters
+        agent_kwargs = {"instruction": instruction}
+        if server_list:
+            agent_kwargs["servers"] = server_list
+        if model:
+            agent_kwargs["model"] = model
 
         @fast.agent(**agent_kwargs)
         async def cli_agent():
@@ -88,12 +120,8 @@ async def _run_agent(
                     response = await agent.default.generate(prompt)
                     # Print the response text and exit
                     print(response.last_text())
-    else:
-        # Standard interactive mode
-        @fast.agent(**agent_kwargs)
-        async def cli_agent():
-            async with fast.run() as agent:
-                await agent.interactive()
+                else:
+                    await agent.interactive()
 
     # Run the agent
     await cli_agent()
@@ -109,6 +137,7 @@ def run_async_agent(
     model: Optional[str] = None,
     message: Optional[str] = None,
     prompt_file: Optional[str] = None,
+    stdio_commands: Optional[List[str]] = None,
 ):
     """Run the async agent function with proper loop handling."""
     server_list = servers.split(",") if servers else None
@@ -129,6 +158,60 @@ def run_async_agent(
             print(f"Error parsing URLs: {e}")
             return
 
+    # Generate STDIO server configurations if provided
+    stdio_servers = None
+
+    if stdio_commands:
+        stdio_servers = {}
+        for i, stdio_cmd in enumerate(stdio_commands):
+            # Parse the stdio command string
+            try:
+                parsed_command = shlex.split(stdio_cmd)
+                if not parsed_command:
+                    print(f"Error: Empty stdio command: {stdio_cmd}")
+                    continue
+
+                command = parsed_command[0]
+                initial_args = parsed_command[1:] if len(parsed_command) > 1 else []
+
+                # Generate a server name from the command
+                if initial_args:
+                    # Try to extract a meaningful name from the args
+                    for arg in initial_args:
+                        if arg.endswith(".py") or arg.endswith(".js") or arg.endswith(".ts"):
+                            base_name = generate_server_name(arg)
+                            break
+                    else:
+                        # Fallback to command name
+                        base_name = generate_server_name(command)
+                else:
+                    base_name = generate_server_name(command)
+
+                # Ensure unique server names when multiple servers
+                server_name = base_name
+                if len(stdio_commands) > 1:
+                    server_name = f"{base_name}_{i + 1}"
+
+                # Build the complete args list
+                stdio_command_args = initial_args.copy()
+
+                # Add this server to the configuration
+                stdio_servers[server_name] = {
+                    "transport": "stdio",
+                    "command": command,
+                    "args": stdio_command_args,
+                }
+
+                # Add STDIO server to the server list
+                if not server_list:
+                    server_list = [server_name]
+                else:
+                    server_list.append(server_name)
+
+            except ValueError as e:
+                print(f"Error parsing stdio command '{stdio_cmd}': {e}")
+                continue
+
     # Check if we're already in an event loop
     try:
         loop = asyncio.get_event_loop()
@@ -153,6 +236,7 @@ def run_async_agent(
                 message=message,
                 prompt_file=prompt_file,
                 url_servers=url_servers,
+                stdio_servers=stdio_servers,
             )
         )
     finally:
@@ -171,7 +255,7 @@ def run_async_agent(
             pass
 
 
-@app.callback(invoke_without_command=True)
+@app.callback(invoke_without_command=True, no_args_is_help=False)
 def go(
     ctx: typer.Context,
     name: str = typer.Option("FastAgent CLI", "--name", help="Name for the agent"),
@@ -191,7 +275,7 @@ def go(
         None, "--auth", help="Bearer token for authorization with URL-based servers"
     ),
     model: Optional[str] = typer.Option(
-        None, "--model", help="Override the default model (e.g., haiku, sonnet, gpt-4)"
+        None, "--model", "--models", help="Override the default model (e.g., haiku, sonnet, gpt-4)"
     ),
     message: Optional[str] = typer.Option(
         None, "--message", "-m", help="Message to send to the agent (skips interactive mode)"
@@ -199,6 +283,15 @@ def go(
     prompt_file: Optional[str] = typer.Option(
         None, "--prompt-file", "-p", help="Path to a prompt file to use (either text or JSON)"
     ),
+    npx: Optional[str] = typer.Option(
+        None, "--npx", help="NPX package and args to run as MCP server (quoted)"
+    ),
+    uvx: Optional[str] = typer.Option(
+        None, "--uvx", help="UVX package and args to run as MCP server (quoted)"
+    ),
+    stdio: Optional[str] = typer.Option(
+        None, "--stdio", help="Command to run as STDIO MCP server (quoted)"
+    ),
 ) -> None:
     """
     Run an interactive agent directly from the command line.
@@ -209,6 +302,10 @@ def go(
         fast-agent go --prompt-file=my-prompt.txt --model=haiku
         fast-agent go --url=http://localhost:8001/mcp,http://api.example.com/sse
         fast-agent go --url=https://api.example.com/mcp --auth=YOUR_API_TOKEN
+        fast-agent go --npx "@modelcontextprotocol/server-filesystem /path/to/data"
+        fast-agent go --uvx "mcp-server-fetch --verbose"
+        fast-agent go --stdio "python my_server.py --debug"
+        fast-agent go --stdio "uv run server.py --config=settings.json"
 
     This will start an interactive session with the agent, using the specified model
     and instruction. It will use the default configuration from fastagent.config.yaml
@@ -222,7 +319,22 @@ def go(
         --auth                Bearer token for authorization with URL-based servers
         --message, -m         Send a single message and exit
         --prompt-file, -p     Use a prompt file instead of interactive mode
+        --npx                 NPX package and args to run as MCP server (quoted)
+        --uvx                 UVX package and args to run as MCP server (quoted)
+        --stdio               Command to run as STDIO MCP server (quoted)
     """
+    # Collect all stdio commands from convenience options
+    stdio_commands = []
+
+    if npx:
+        stdio_commands.append(f"npx {npx}")
+
+    if uvx:
+        stdio_commands.append(f"uvx {uvx}")
+
+    if stdio:
+        stdio_commands.append(stdio)
+
     run_async_agent(
         name=name,
         instruction=instruction,
@@ -233,4 +345,5 @@ def go(
         model=model,
         message=message,
         prompt_file=prompt_file,
+        stdio_commands=stdio_commands,
     )

mcp_agent/cli/commands/quickstart.py

@@ -383,12 +383,16 @@ def _show_completion_message(example_type: str, created: list[str]) -> None:
                 "On Windows platforms, please edit the fastagent.config.yaml and adjust the volume mount point."
             )
         elif example_type == "state-transfer":
-            console.print("Check https://fast-agent.ai for quick start walkthroughs")
+            console.print(
+                "Check [cyan][link=https://fast-agent.ai]fast-agent.ai[/link][/cyan] for quick start walkthroughs"
+            )
         elif example_type == "elicitations":
             console.print("1. Go to the `elicitations` subdirectory (cd elicitations)")
             console.print("2. Try the forms demo: uv run forms_demo.py")
             console.print("3. Run the game character creator: uv run game_character.py")
-            console.print("Check https://fast-agent.ai/mcp/elicitations/ for more details")
+            console.print(
+                "Check [cyan][link=https://fast-agent.ai/mcp/elicitations/]https://fast-agent.ai/mcp/elicitations/[/link][/cyan] for more details"
+            )
     else:
         console.print("\n[yellow]No files were created.[/yellow]")