fast-agent-mcp 0.2.13__py3-none-any.whl → 0.2.14__py3-none-any.whl

mcp_agent/cli/commands/check_config.py

@@ -0,0 +1,450 @@
+"""Command to check FastAgent configuration."""
+
+import platform
+import sys
+from importlib.metadata import version
+from pathlib import Path
+from typing import Optional
+
+import typer
+import yaml
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from mcp_agent.llm.provider_key_manager import API_KEY_HINT_TEXT, ProviderKeyManager
+from mcp_agent.llm.provider_types import Provider
+
+app = typer.Typer(
+    help="Check and diagnose FastAgent configuration",
+    no_args_is_help=False,  # Allow showing our custom help instead
+)
+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
+
+        # 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
+
+
+def get_system_info() -> dict:
+    """Get system information including Python version, OS, etc."""
+    return {
+        "platform": platform.system(),
+        "platform_version": platform.version(),
+        "python_version": sys.version,
+        "python_path": sys.executable,
+    }
+
+
+def get_secrets_summary(secrets_path: Optional[Path]) -> dict:
+    """Extract information from the secrets file."""
+    result = {
+        "status": "not_found",  # Default status: not found
+        "error": None,
+        "secrets": {},
+    }
+
+    if not secrets_path:
+        return result
+
+    if not secrets_path.exists():
+        result["status"] = "not_found"
+        return result
+
+    # File exists, attempt to parse
+    try:
+        with open(secrets_path, "r") as f:
+            secrets = yaml.safe_load(f)
+
+        # Mark as successfully parsed
+        result["status"] = "parsed"
+        result["secrets"] = secrets or {}
+
+    except Exception as e:
+        # File exists but has parse errors
+        result["status"] = "error"
+        result["error"] = str(e)
+        console.print(f"[yellow]Warning:[/yellow] Error parsing secrets file: {e}")
+
+    return result
+
+
+def check_api_keys(secrets_summary: dict) -> dict:
+    """Check if API keys are configured in secrets file or environment."""
+    import os
+
+    # Initialize results dict using Provider enum values
+    results = {
+        provider.value: {"env": None, "config": None}
+        for provider in Provider
+        if provider != Provider.FAST_AGENT
+    }  # Include GENERIC but exclude FAST_AGENT
+
+    # Get secrets if available
+    secrets = secrets_summary.get("secrets", {})
+    secrets_status = secrets_summary.get("status", "not_found")
+
+    # Check both environment variables and config file for each provider
+    for provider_value in results:
+        # 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:
+            # Store the last 5 characters if key is long enough
+            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:
+                # Store the last 5 characters if key is long enough
+                if len(config_key) > 5:
+                    results[provider_value]["config"] = f"...{config_key[-5:]}"
+                else:
+                    results[provider_value]["config"] = "...***"
+
+    return results
+
+
+def get_fastagent_version() -> str:
+    """Get the installed version of FastAgent."""
+    try:
+        return version("fast-agent-mcp")
+    except:  # noqa: E722
+        return "unknown"
+
+
+def get_config_summary(config_path: Optional[Path]) -> dict:
+    """Extract key information from the configuration file."""
+    result = {
+        "status": "not_found",  # Default status: not found
+        "error": None,
+        "default_model": "haiku (system default)",
+        "logger": {},
+        "mcp_servers": [],
+    }
+
+    if not config_path:
+        return result
+
+    if not config_path.exists():
+        result["status"] = "not_found"
+        return result
+
+    # File exists, attempt to parse
+    try:
+        with open(config_path, "r") as f:
+            config = yaml.safe_load(f)
+
+        # Mark as successfully parsed
+        result["status"] = "parsed"
+
+        if not config:
+            return result
+
+        # Get default model
+        if "default_model" in config:
+            result["default_model"] = config["default_model"]
+
+        # Get logger settings
+        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)),
+            }
+
+        # Get MCP server info
+        if "mcp" in config and "servers" in config["mcp"]:
+            for server_name, server_config in config["mcp"]["servers"].items():
+                server_info = {
+                    "name": server_name,
+                    "transport": "STDIO",  # Default transport type
+                    "command": "",
+                    "url": "",
+                }
+
+                # Determine transport type
+                if "url" in server_config:
+                    server_info["transport"] = "SSE"
+                    server_info["url"] = server_config.get("url", "")
+
+                # Get command and args
+                command = server_config.get("command", "")
+                args = server_config.get("args", [])
+
+                if command:
+                    if args:
+                        args_str = " ".join([str(arg) for arg in args])
+                        full_cmd = f"{command} {args_str}"
+                        # Truncate if too long
+                        if len(full_cmd) > 60:
+                            full_cmd = full_cmd[:57] + "..."
+                        server_info["command"] = full_cmd
+                    else:
+                        server_info["command"] = command
+
+                # Truncate URL if too long
+                if server_info["url"] and len(server_info["url"]) > 60:
+                    server_info["url"] = server_info["url"][:57] + "..."
+
+                result["mcp_servers"].append(server_info)
+
+    except Exception as e:
+        # File exists but has parse errors
+        result["status"] = "error"
+        result["error"] = str(e)
+        console.print(f"[red]Error parsing configuration file:[/red] {e}")
+
+    return result
+
+
+def show_check_summary() -> None:
+    """Show a summary of checks with colorful styling."""
+    cwd = Path.cwd()
+    config_files = find_config_files(cwd)
+    system_info = get_system_info()
+    config_summary = get_config_summary(config_files["config"])
+    secrets_summary = get_secrets_summary(config_files["secrets"])
+    api_keys = check_api_keys(secrets_summary)
+    fastagent_version = get_fastagent_version()
+
+    # System info panel
+    system_table = Table(show_header=False, box=None)
+    system_table.add_column("Key", style="cyan")
+    system_table.add_column("Value")
+
+    system_table.add_row("FastAgent Version", fastagent_version)
+    system_table.add_row("Platform", system_info["platform"])
+    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"))
+
+    # Configuration files panel
+    config_path = config_files["config"]
+    secrets_path = config_files["secrets"]
+
+    files_table = Table(show_header=False, box=None)
+    files_table.add_column("Setting", style="cyan")
+    files_table.add_column("Value")
+
+    # Show secrets file status
+    secrets_status = secrets_summary.get("status", "not_found")
+    if secrets_status == "not_found":
+        files_table.add_row("Secrets File", "[yellow]Not found[/yellow]")
+    elif secrets_status == "error":
+        files_table.add_row("Secrets File", f"[orange_red1]Errors[/orange_red1] ({secrets_path})")
+        files_table.add_row(
+            "Secrets Error",
+            f"[orange_red1]{secrets_summary.get('error', 'Unknown error')}[/orange_red1]",
+        )
+    else:  # parsed successfully
+        files_table.add_row("Secrets File", f"[green]Found[/green] ({secrets_path})")
+
+    # Show config file status
+    config_status = config_summary.get("status", "not_found")
+    if config_status == "not_found":
+        files_table.add_row("Config File", "[red]Not found[/red]")
+    elif config_status == "error":
+        files_table.add_row("Config File", f"[orange_red1]Errors[/orange_red1] ({config_path})")
+        files_table.add_row(
+            "Config Error",
+            f"[orange_red1]{config_summary.get('error', 'Unknown error')}[/orange_red1]",
+        )
+    else:  # parsed successfully
+        files_table.add_row("Config File", f"[green]Found[/green] ({config_path})")
+        files_table.add_row(
+            "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", border_style="blue"))
+
+    # API keys panel
+    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")
+
+    for provider, status in api_keys.items():
+        # Environment key indicator
+        if status["env"] and status["config"]:
+            # Both exist but config takes precedence (env is present but not active)
+            env_status = "[yellow]✓[/yellow]"
+        elif status["env"]:
+            # Only env exists and is active
+            env_status = "[bold green]✓[/bold green]"
+        else:
+            # No env key
+            env_status = "[dim]✗[/dim]"
+
+        # Config file key indicator
+        if status["config"]:
+            # Config exists and takes precedence (is active)
+            config_status = "[bold green]✓[/bold green]"
+        else:
+            # No config key
+            config_status = "[dim]✗[/dim]"
+
+        # Display active key
+        if status["config"]:
+            # Config key is active
+            active = f"[bold green]{status['config']}[/bold green]"
+        elif status["env"]:
+            # Env key is active
+            active = f"[bold green]{status['env']}[/bold green]"
+        elif provider == "generic":
+            # Generic provider uses "ollama" as a default when no key is set
+            active = "[green]ollama (default)[/green]"
+        else:
+            # No key available for other providers
+            active = "[dim]Not configured[/dim]"
+
+        keys_table.add_row(provider.capitalize(), env_status, config_status, active)
+
+    console.print(Panel(keys_table, title="API Keys", border_style="blue"))
+    
+    # MCP Servers panel (shown after API Keys)
+    if config_summary.get("status") == "parsed":
+        mcp_servers = config_summary.get("mcp_servers", [])
+        if mcp_servers:
+            servers_table = Table(show_header=True, box=None)
+            servers_table.add_column("Name", style="cyan")
+            servers_table.add_column("Transport", style="magenta")
+            servers_table.add_column("Command/URL")
+
+            for server in mcp_servers:
+                name = server["name"]
+                transport = server["transport"]
+
+                # Show either command or URL based on transport type
+                if transport == "STDIO":
+                    command_url = server["command"] or "[dim]Not configured[/dim]"
+                    servers_table.add_row(name, transport, command_url)
+                else:  # SSE
+                    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"))
+
+    # 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")
+    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")
+
+    if all(
+        not api_keys[provider]["env"] and not api_keys[provider]["config"] for provider in api_keys
+    ):
+        console.print(
+            "\n[yellow]No API keys configured. Set up API keys to use LLM services:[/yellow]"
+        )
+        console.print("1. Add keys to fastagent.secrets.yaml")
+        env_vars = ", ".join(
+            [
+                ProviderKeyManager.get_env_key_name(p.value)
+                for p in Provider
+                if p != Provider.FAST_AGENT
+            ]
+        )
+        console.print(f"2. Or set environment variables ({env_vars})")
+
+
+@app.command()
+def show(
+    path: Optional[str] = typer.Argument(None, help="Path to configuration file to display"),
+    secrets: bool = typer.Option(
+        False, "--secrets", "-s", help="Show secrets file instead of config"
+    ),
+) -> None:
+    """Display the configuration file content or search for it."""
+    file_type = "secrets" if secrets else "config"
+
+    if path:
+        config_path = Path(path).resolve()
+        if not config_path.exists():
+            console.print(
+                f"[red]Error:[/red] {file_type.capitalize()} file not found at {config_path}"
+            )
+            raise typer.Exit(1)
+    else:
+        config_files = find_config_files(Path.cwd())
+        config_path = config_files[file_type]
+        if not config_path:
+            console.print(
+                f"[yellow]No {file_type} file found in current directory or parents[/yellow]"
+            )
+            console.print("Run [cyan]fast-agent setup[/cyan] to create configuration files")
+            raise typer.Exit(1)
+
+    console.print(f"\n[bold]{file_type.capitalize()} file:[/bold] {config_path}\n")
+
+    try:
+        with open(config_path, "r") as f:
+            content = f.read()
+
+        # Try to parse as YAML to check validity
+        parsed = yaml.safe_load(content)
+
+        # Show parsing success status
+        console.print("[green]YAML syntax is valid[/green]")
+        if parsed is None:
+            console.print("[yellow]Warning: File is empty or contains only comments[/yellow]\n")
+        else:
+            console.print(
+                f"[green]Successfully parsed {len(parsed) if isinstance(parsed, dict) else 0} root keys[/green]\n"
+            )
+
+        # Print the content
+        console.print(content)
+
+    except Exception as e:
+        console.print(f"[red]Error parsing {file_type} file:[/red] {e}")
+
+
+@app.callback(invoke_without_command=True)
+def main(ctx: typer.Context) -> None:
+    """Check and diagnose FastAgent configuration."""
+    if ctx.invoked_subcommand is None:
+        show_check_summary()

mcp_agent/cli/commands/setup.py

@@ -190,7 +190,7 @@ def init(
     # Check for existing .gitignore
     needs_gitignore = not find_gitignore(config_path)
 
-    console.print("\n[bold]fast-agent Setup[/bold]\n")
+    console.print("\n[bold]fast-agent setup[/bold]\n")
     console.print("This will create the following files:")
     console.print(f"  - {config_path}/fastagent.config.yaml")
     console.print(f"  - {config_path}/fastagent.secrets.yaml")

mcp_agent/cli/main.py

@@ -4,7 +4,7 @@ import typer
 from rich.console import Console
 from rich.table import Table
 
-from mcp_agent.cli.commands import quickstart, setup
+from mcp_agent.cli.commands import check_config, quickstart, setup
 from mcp_agent.cli.terminal import Application
 
 app = typer.Typer(
@@ -14,6 +14,7 @@ app = typer.Typer(
 
 # Subcommands
 app.add_typer(setup.app, name="setup", help="Set up a new agent project")
+app.add_typer(check_config.app, name="check", help="Show or diagnose fast-agent configuration")
 app.add_typer(quickstart.app, name="bootstrap", help="Create example applications")
 app.add_typer(quickstart.app, name="quickstart", help="Create example applications")
 
@@ -31,30 +32,22 @@ def show_welcome() -> None:
     except:  # noqa: E722
         app_version = "unknown"
 
-    console.print(f"\n[bold]fast-agent (fast-agent-mcp) {app_version}[/bold]")
-    console.print("Build effective agents using Model Context Protocol (MCP)")
+    console.print(f"\nfast-agent {app_version} [dim](fast-agent-mcp)[/dim] ")
 
     # Create a table for commands
     table = Table(title="\nAvailable Commands")
     table.add_column("Command", style="green")
     table.add_column("Description")
 
-    table.add_row("setup", "Set up a new agent project with configuration files")
+    table.add_row("setup", "Create a new agent and configuration files")
+    table.add_row("check", "Show or diagnose fast-agent configuration")
     table.add_row("quickstart", "Create example applications (workflow, researcher, etc.)")
-    # table.add_row("config", "Manage agent configuration settings")
 
     console.print(table)
 
-    console.print("\n[bold]Getting Started:[/bold]")
-    console.print("1. Set up a new project:")
-    console.print("   fastagent setup")
-    console.print("\n2. Create Building Effective Agents  workflow examples:")
-    console.print("   fastagent quickstart workflow")
-    console.print("\n3. Explore other examples:")
-    console.print("   fastagent quickstart")
-
-    console.print("\nUse --help with any command for more information")
-    console.print("Example: fastagent quickstart --help")
+    console.print(
+        "\n[italic]get started with:[/italic] [cyan]fast-agent[/cyan] [green]setup[/green]"
+    )
 
 
 @app.callback(invoke_without_command=True)

mcp_agent/core/agent_types.py

@@ -2,11 +2,11 @@
 Type definitions for agents and agent configurations.
 """
 
-import dataclasses
-from dataclasses import dataclass
 from enum import Enum
 from typing import List
 
+from pydantic import BaseModel, Field, model_validator
+
 # Forward imports to avoid circular dependencies
 from mcp_agent.core.request_params import RequestParams
 
@@ -22,22 +22,21 @@ class AgentType(Enum):
     CHAIN = "chain"
 
 
-@dataclass
-class AgentConfig:
+class AgentConfig(BaseModel):
     """Configuration for an Agent instance"""
 
     name: str
     instruction: str = "You are a helpful agent."
-    servers: List[str] = dataclasses.field(default_factory=list)
+    servers: List[str] = Field(default_factory=list)
     model: str | None = None
     use_history: bool = True
     default_request_params: RequestParams | None = None
     human_input: bool = False
-    agent_type: str = AgentType.BASIC.value
+    agent_type: AgentType = AgentType.BASIC
 
-    def __post_init__(self) -> None:
+    @model_validator(mode='after')
+    def ensure_default_request_params(self) -> 'AgentConfig':
         """Ensure default_request_params exists with proper history setting"""
-
         if self.default_request_params is None:
             self.default_request_params = RequestParams(
                 use_history=self.use_history, systemPrompt=self.instruction
@@ -45,3 +44,4 @@ class AgentConfig:
         else:
             # Override the request params history setting if explicitly configured
             self.default_request_params.use_history = self.use_history
+        return self

mcp_agent/core/direct_decorators.py

@@ -206,15 +206,22 @@ def agent(
     )
 
 
+DEFAULT_INSTRUCTION_ORCHESTRATOR = """
+You are an expert planner. Given an objective task and a list of Agents 
+(which are collections of capabilities), your job is to break down the objective 
+into a series of steps, which can be performed by these agents.
+"""
+
+
 def orchestrator(
     self,
     name: str,
     *,
     agents: List[str],
-    instruction: Optional[str] = None,
+    instruction: str = DEFAULT_INSTRUCTION_ORCHESTRATOR,
     model: Optional[str] = None,
-    use_history: bool = False,
     request_params: RequestParams | None = None,
+    use_history: bool = False,
     human_input: bool = False,
     plan_type: Literal["full", "iterative"] = "full",
     max_iterations: int = 30,
@@ -236,11 +243,6 @@ def orchestrator(
     Returns:
         A decorator that registers the orchestrator with proper type annotations
     """
-    default_instruction = """
-    You are an expert planner. Given an objective task and a list of Agents 
-    (which are collections of capabilities), your job is to break down the objective 
-    into a series of steps, which can be performed by these agents.
-    """
 
     # Create final request params with max_iterations
 
@@ -250,7 +252,7 @@ def orchestrator(
             self,
             AgentType.ORCHESTRATOR,
             name=name,
-            instruction=instruction or default_instruction,
+            instruction=instruction,
             servers=[],  # Orchestrators don't connect to servers directly
             model=model,
             use_history=use_history,

mcp_agent/core/direct_factory.py

@@ -133,11 +133,13 @@ async def create_agents_by_type(
             },
         )
 
+        # Compare type string from config with Enum value
         if agent_data["type"] == agent_type.value:
             # Get common configuration
             config = agent_data["config"]
 
-            # Type-specific initialization
+                # Type-specific initialization based on the Enum type
+            # Note: Above we compared string values from config, here we compare Enum objects directly
             if agent_type == AgentType.BASIC:
                 # Create a basic agent
                 agent = Agent(
@@ -338,6 +340,7 @@ async def create_agents_in_dependency_order(
     # Create agent proxies for each group in dependency order
     for group in dependencies:
         # Create basic agents first
+        # Note: We compare string values from config with the Enum's string value
         if AgentType.BASIC.value in [agents_dict[name]["type"] for name in group]:
             basic_agents = await create_agents_by_type(
                 app_instance,

mcp_agent/core/validation.py

@@ -51,8 +51,9 @@ def validate_workflow_references(agents: Dict[str, Dict[str, Any]]) -> None:
     available_components = set(agents.keys())
 
     for name, agent_data in agents.items():
-        agent_type = agent_data["type"]
-
+        agent_type = agent_data["type"]  # This is a string from config
+        
+        # Note: Compare string values from config with the Enum's string value
         if agent_type == AgentType.PARALLEL.value:
             # Check fan_in exists
             fan_in = agent_data["fan_in"]
@@ -224,8 +225,9 @@ def get_dependencies_groups(
 
     # Build the dependency graph
     for name, agent_data in agents_dict.items():
-        agent_type = agent_data["type"]
-
+        agent_type = agent_data["type"]  # This is a string from config
+        
+        # Note: Compare string values from config with the Enum's string value
         if agent_type == AgentType.PARALLEL.value:
             # Parallel agents depend on their fan-out and fan-in agents
             dependencies[name].update(agent_data.get("parallel_agents", []))

mcp_agent/event_progress.py

@@ -1,9 +1,10 @@
 """Module for converting log events to progress events."""
 
-from dataclasses import dataclass
 from enum import Enum
 from typing import Optional
 
+from pydantic import BaseModel
+
 from mcp_agent.logging.events import Event
 
 
@@ -24,8 +25,7 @@ class ProgressAction(str, Enum):
     FATAL_ERROR = "Error"
 
 
-@dataclass
-class ProgressEvent:
+class ProgressEvent(BaseModel):
     """Represents a progress event converted from a log event."""
 
     action: ProgressAction
@@ -87,8 +87,8 @@ def convert_log_event(event: Event) -> Optional[ProgressEvent]:
             target = event_data.get("target", "unknown")
 
     return ProgressEvent(
-        ProgressAction(progress_action),
-        target,
-        details,
+        action=ProgressAction(progress_action),
+        target=target,
+        details=details,
         agent_name=event_data.get("agent_name"),
     )