fast-agent-mcp 0.2.40__tar.gz → 0.2.41__tar.gz

{fast_agent_mcp-0.2.40 → fast_agent_mcp-0.2.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.40
+Version: 0.2.41
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>
 License:                                  Apache License

{fast_agent_mcp-0.2.40 → fast_agent_mcp-0.2.41}/examples/mcp/elicitations/forms_demo.py

@@ -51,8 +51,6 @@ async def main():
         else:
             console.print("[red]No registration data received[/red]")
 
-        console.print("\n" + "─" * 50 + "\n")
-
         # Example 2: Product Review
         console.print("[bold yellow]Example 2: Product Review Form[/bold yellow]")
         console.print(
@@ -66,8 +64,6 @@ async def main():
             )
             console.print(review_panel)
 
-        console.print("\n" + "─" * 50 + "\n")
-
         # Example 3: Account Settings
         console.print("[bold yellow]Example 3: Account Settings Form[/bold yellow]")
         console.print(
@@ -81,8 +77,6 @@ async def main():
             )
             console.print(settings_panel)
 
-        console.print("\n" + "─" * 50 + "\n")
-
         # Example 4: Service Appointment
         console.print("[bold yellow]Example 4: Service Appointment Booking[/bold yellow]")
         console.print(

{fast_agent_mcp-0.2.40/src/mcp_agent/resources → fast_agent_mcp-0.2.41}/examples/workflows/router.py

@@ -7,6 +7,8 @@ Demonstrates router's ability to either:
 
 import asyncio
 
+from rich.console import Console
+
 from mcp_agent.core.fastagent import FastAgent
 
 # Create the application
@@ -45,7 +47,14 @@ SAMPLE_REQUESTS = [
     agents=["code_expert", "general_assistant", "fetcher"],
 )
 async def main() -> None:
+    console = Console()
+    console.print(
+        "\n[bright_red]Router Workflow Demo[/bright_red]\n\n"
+        "Enter a request to route it to the appropriate agent.\nEnter [bright_red]STOP[/bright_red] to run the demo, [bright_red]EXIT[/bright_red] to leave"
+    )
+
     async with fast.run() as agent:
+        await agent.interactive(agent_name="route")
         for request in SAMPLE_REQUESTS:
             await agent.route(request)
 

{fast_agent_mcp-0.2.40 → fast_agent_mcp-0.2.41}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.40"
+version = "0.2.41"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -108,8 +108,8 @@ dev = [
 ]
 
 [project.scripts]
-fast-agent = "mcp_agent.cli.__main__:app"
-fast-agent-mcp = "mcp_agent.cli.__main__:app"
+fast-agent = "mcp_agent.cli.__main__:main"
+fast-agent-mcp = "mcp_agent.cli.__main__:main"
 fastagent = "mcp_agent.cli.__main__:app"
 silsila = "mcp_agent.cli.__main__:app"
 prompt-server = "mcp_agent.mcp.prompts.__main__:main"

fast_agent_mcp-0.2.41/src/mcp_agent/cli/__main__.py

@@ -0,0 +1,33 @@
+import sys
+
+from mcp_agent.cli.constants import GO_SPECIFIC_OPTIONS, KNOWN_SUBCOMMANDS
+from mcp_agent.cli.main import app
+
+# if the arguments would work with "go" we'll just route to it
+
+
+def main():
+    """Main entry point that handles auto-routing to 'go' command."""
+    # Check if we should auto-route to 'go'
+    if len(sys.argv) > 1:
+        # Check if first arg is not already a subcommand
+        first_arg = sys.argv[1]
+
+        if first_arg not in KNOWN_SUBCOMMANDS and any(
+            arg in sys.argv or any(arg.startswith(opt + "=") for opt in GO_SPECIFIC_OPTIONS)
+            for arg in sys.argv
+        ):
+            # Find where to insert 'go' - before the first go-specific option
+            insert_pos = 1
+            for i, arg in enumerate(sys.argv[1:], 1):
+                if arg in GO_SPECIFIC_OPTIONS or any(arg.startswith(opt + "=") for opt in GO_SPECIFIC_OPTIONS):
+                    insert_pos = i
+                    break
+            # Auto-route to go command
+            sys.argv.insert(insert_pos, "go")
+
+    app()
+
+
+if __name__ == "__main__":
+    main()

{fast_agent_mcp-0.2.40 → fast_agent_mcp-0.2.41}/src/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")