fast-agent-mcp 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

fast_agent/cli/commands/check_config.py

@@ -8,18 +8,17 @@ from typing import Optional
 
 import typer
 import yaml
-from rich.console import Console
 from rich.table import Table
 from rich.text import Text
 
 from fast_agent.llm.provider_key_manager import API_KEY_HINT_TEXT, ProviderKeyManager
 from fast_agent.llm.provider_types import Provider
+from fast_agent.ui.console import console
 
 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]]:
@@ -305,6 +304,27 @@ def show_check_summary() -> None:
     env_table.add_column("Setting", style="white")
     env_table.add_column("Value")
 
+    # Determine keyring backend early so it can appear in the top section
+    # Also detect whether the backend is actually usable (not the fail backend)
+    keyring_usable = False
+    try:
+        import keyring  # type: ignore
+
+        keyring_backend = keyring.get_keyring()
+        keyring_name = getattr(keyring_backend, "name", keyring_backend.__class__.__name__)
+        try:
+            # Detect the "fail" backend explicitly; it's present but unusable
+            from keyring.backends.fail import Keyring as FailKeyring  # type: ignore
+
+            keyring_usable = not isinstance(keyring_backend, FailKeyring)
+        except Exception:
+            # If we can't import the fail backend marker, assume usable
+            keyring_usable = True
+    except Exception:
+        keyring = None  # type: ignore
+        keyring_name = "unavailable"
+        keyring_usable = False
+
     # Python info (highlight version and path in green)
     env_table.add_row(
         "Python Version", f"[green]{'.'.join(system_info['python_version'].split('.')[:3])}[/green]"
@@ -336,9 +356,15 @@ def show_check_summary() -> None:
         )
     else:  # parsed successfully
         env_table.add_row("Config File", f"[green]Found[/green] ({config_path})")
-        default_model_value = config_summary.get("default_model", "haiku (system default)")
+        default_model_value = config_summary.get("default_model", "gpt-5-mini.low (system default)")
         env_table.add_row("Default Model", f"[green]{default_model_value}[/green]")
 
+    # Keyring backend (always shown in application-level settings)
+    if keyring_usable and keyring_name != "unavailable":
+        env_table.add_row("Keyring Backend", f"[green]{keyring_name}[/green]")
+    else:
+        env_table.add_row("Keyring Backend", "[red]not available[/red]")
+
     console.print(env_table)
 
     # Logger Settings panel with two-column layout
@@ -470,10 +496,15 @@ def show_check_summary() -> None:
     if config_summary.get("status") == "parsed":
         mcp_servers = config_summary.get("mcp_servers", [])
         if mcp_servers:
+            from fast_agent.config import MCPServerSettings
+            from fast_agent.mcp.oauth_client import compute_server_identity
+
             servers_table = Table(show_header=True, box=None)
             servers_table.add_column("Name", style="white", header_style="bold bright_white")
             servers_table.add_column("Transport", style="white", header_style="bold bright_white")
             servers_table.add_column("Command/URL", header_style="bold bright_white")
+            servers_table.add_column("OAuth", header_style="bold bright_white")
+            servers_table.add_column("Token", header_style="bold bright_white")
 
             for server in mcp_servers:
                 name = server["name"]
@@ -489,7 +520,48 @@ def show_check_summary() -> None:
                 if "Not configured" not in command_url:
                     command_url = f"[green]{command_url}[/green]"
 
-                servers_table.add_row(name, transport, command_url)
+                # OAuth status and token presence
+                # Default for unsupported transports (e.g., STDIO): show "-" rather than "off"
+                oauth_status = "[dim]-[/dim]"
+                token_status = "[dim]n/a[/dim]"
+                # Attempt to reconstruct minimal server settings for identity check
+                try:
+                    cfg = MCPServerSettings(
+                        name=name,
+                        transport="sse"
+                        if transport == "SSE"
+                        else ("stdio" if transport == "STDIO" else "http"),
+                        url=(server.get("url") or None),
+                        auth=server.get("auth") if isinstance(server.get("auth"), dict) else None,
+                    )
+                except Exception:
+                    cfg = None
+
+                if cfg and cfg.transport in ("http", "sse"):
+                    # Determine if OAuth is enabled for this server
+                    oauth_enabled = True
+                    if cfg.auth is not None and hasattr(cfg.auth, "oauth"):
+                        oauth_enabled = bool(getattr(cfg.auth, "oauth"))
+                    oauth_status = "[green]on[/green]" if oauth_enabled else "[dim]off[/dim]"
+
+                    # Only check token presence when using keyring persist
+                    persist = "keyring"
+                    if cfg.auth is not None and hasattr(cfg.auth, "persist"):
+                        persist = getattr(cfg.auth, "persist") or "keyring"
+                    if keyring and keyring_usable and persist == "keyring" and oauth_enabled:
+                        identity = compute_server_identity(cfg)
+                        tkey = f"oauth:tokens:{identity}"
+                        try:
+                            has = keyring.get_password("fast-agent-mcp", tkey) is not None
+                        except Exception:
+                            has = False
+                        token_status = "[bold green]✓[/bold green]" if has else "[dim]✗[/dim]"
+                    elif persist == "keyring" and not keyring_usable and oauth_enabled:
+                        token_status = "[red]not available[/red]"
+                    elif persist == "memory" and oauth_enabled:
+                        token_status = "[yellow]memory[/yellow]"
+
+                servers_table.add_row(name, transport, command_url, oauth_status, token_status)
 
             _print_section_header("MCP Servers", color="blue")
             console.print(servers_table)

fast_agent/cli/commands/go.py

@@ -18,10 +18,16 @@ app = typer.Typer(
     context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
 )
 
+default_instruction = """You are a helpful AI Agent.
+
+{{serverInstructions}}
+
+The current date is {{currentDate}}."""
+
 
 async def _run_agent(
     name: str = "fast-agent cli",
-    instruction: str = "You are a helpful AI Agent.",
+    instruction: str = default_instruction,
     config_path: Optional[str] = None,
     server_list: Optional[List[str]] = None,
     model: Optional[str] = None,
@@ -352,7 +358,7 @@ def go(
         stdio_commands.append(stdio)
 
     # Resolve instruction from file/URL or use default
-    resolved_instruction = "You are a helpful AI Agent."  # Default
+    resolved_instruction = default_instruction  # Default
     agent_name = "agent"
 
     if instruction:

fast_agent/cli/commands/quickstart.py

@@ -8,11 +8,13 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
 
+from fast_agent.ui.console import console as shared_console
+
 app = typer.Typer(
     help="Create fast-agent quickstarts",
     no_args_is_help=False,  # Allow showing our custom help instead
 )
-console = Console()
+console = shared_console
 
 EXAMPLE_TYPES = {
     "workflow": {

fast_agent/cli/commands/server_helpers.py

@@ -89,7 +89,7 @@ async def add_servers_to_config(fast_app: Any, servers: Dict[str, Dict[str, Any]
     ):
         fast_app.app.context.config.mcp.servers = {}
 
-    # Add each server to the config
+    # Add each server to the config (and keep the runtime registry in sync)
     for server_name, server_config in servers.items():
         # Build server settings based on transport type
         server_settings = {"transport": server_config["transport"]}
@@ -103,4 +103,12 @@ async def add_servers_to_config(fast_app: Any, servers: Dict[str, Dict[str, Any]
             if "headers" in server_config:
                 server_settings["headers"] = server_config["headers"]
 
-        fast_app.app.context.config.mcp.servers[server_name] = MCPServerSettings(**server_settings)
+        mcp_server = MCPServerSettings(**server_settings)
+        # Update config model
+        fast_app.app.context.config.mcp.servers[server_name] = mcp_server
+        # Ensure ServerRegistry sees dynamic additions even when no config file exists
+        if (
+            hasattr(fast_app.app.context, "server_registry")
+            and fast_app.app.context.server_registry is not None
+        ):
+            fast_app.app.context.server_registry.registry[server_name] = mcp_server

fast_agent/cli/commands/setup.py

@@ -1,11 +1,12 @@
 from pathlib import Path
 
 import typer
-from rich.console import Console
 from rich.prompt import Confirm
 
+from fast_agent.ui.console import console as shared_console
+
 app = typer.Typer()
-console = Console()
+console = shared_console
 
 
 def load_template_text(filename: str) -> str:
@@ -25,9 +26,7 @@ def load_template_text(filename: str) -> str:
         res_name = "pyproject.toml.tmpl"
     else:
         res_name = filename
-    resource_path = (
-        files("fast_agent").joinpath("resources").joinpath("setup").joinpath(res_name)
-    )
+    resource_path = files("fast_agent").joinpath("resources").joinpath("setup").joinpath(res_name)
     if resource_path.is_file():
         return resource_path.read_text()
 
@@ -136,9 +135,8 @@ def init(
         # Always use latest fast-agent-mcp (no version pin)
         fast_agent_dep = '"fast-agent-mcp"'
 
-        return (
-            template_text.replace("{{python_requires}}", py_req)
-            .replace("{{fast_agent_dep}}", fast_agent_dep)
+        return template_text.replace("{{python_requires}}", py_req).replace(
+            "{{fast_agent_dep}}", fast_agent_dep
         )
 
     pyproject_template = load_template_text("pyproject.toml")
@@ -168,7 +166,7 @@ def init(
                 "2. Keep fastagent.secrets.yaml secure and never commit it to version control"
             )
             console.print(
-                "3. Update fastagent.config.yaml to set a default model (currently system default is 'haiku')"
+                "3. Update fastagent.config.yaml to set a default model (currently system default is 'gpt-5-mini.low')"
             )
         console.print("\nTo get started, run:")
         console.print("  uv run agent.py")

fast_agent/cli/constants.py

@@ -22,4 +22,4 @@ GO_SPECIFIC_OPTIONS = {
 }
 
 # Known subcommands that should not trigger auto-routing
-KNOWN_SUBCOMMANDS = {"go", "setup", "check", "bootstrap", "quickstart", "--help", "-h", "--version"}
+KNOWN_SUBCOMMANDS = {"go", "setup", "check", "auth", "bootstrap", "quickstart", "--help", "-h", "--version"}

fast_agent/cli/main.py

@@ -3,7 +3,7 @@
 import typer
 from rich.table import Table
 
-from fast_agent.cli.commands import check_config, go, quickstart, setup
+from fast_agent.cli.commands import auth, check_config, go, quickstart, setup
 from fast_agent.cli.terminal import Application
 from fast_agent.ui.console import console as shared_console
 
@@ -16,6 +16,7 @@ app = typer.Typer(
 app.add_typer(go.app, name="go", help="Run an interactive agent directly from the command line")
 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(auth.app, name="auth", help="Manage OAuth authentication for MCP servers")
 app.add_typer(quickstart.app, name="bootstrap", help="Create example applications")
 app.add_typer(quickstart.app, name="quickstart", help="Create example applications")
 
@@ -62,6 +63,7 @@ def show_welcome() -> None:
 
     table.add_row("[bold]go[/bold]", "Start an interactive session")
     table.add_row("check", "Show current configuration")
+    table.add_row("auth", "Manage OAuth tokens and keyring")
     table.add_row("setup", "Create agent template and configuration")
     table.add_row("quickstart", "Create example applications (workflow, researcher, etc.)")
 

fast_agent/config.py

@@ -9,20 +9,35 @@ from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional, Tuple
 
 from mcp import Implementation
-from pydantic import BaseModel, ConfigDict, field_validator
+from pydantic import BaseModel, ConfigDict, field_validator, model_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 class MCPServerAuthSettings(BaseModel):
-    """Represents authentication configuration for a server."""
+    """Represents authentication configuration for a server.
 
-    api_key: str | None = None
+    Minimal OAuth v2.1 support with sensible defaults.
+    """
+
+    # Enable OAuth for SSE/HTTP transports. If None is provided for the auth block,
+    # the system will assume OAuth is enabled by default.
+    oauth: bool = True
+
+    # Local callback server configuration
+    redirect_port: int = 3030
+    redirect_path: str = "/callback"
+
+    # Optional scope override. If set to a list, values are space-joined.
+    scope: str | list[str] | None = None
+
+    # Token persistence: use OS keychain via 'keyring' by default; fallback to 'memory'.
+    persist: Literal["keyring", "memory"] = "keyring"
 
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
 class MCPSamplingSettings(BaseModel):
-    model: str = "haiku"
+    model: str = "gpt-5-mini.low"
 
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
@@ -107,8 +122,47 @@ class MCPServerSettings(BaseModel):
     cwd: str | None = None
     """Working directory for the executed server command."""
 
+    include_instructions: bool = True
+    """Whether to include this server's instructions in the system prompt (default: True)."""
+
     implementation: Implementation | None = None
 
+    @model_validator(mode="before")
+    @classmethod
+    def validate_transport_inference(cls, values):
+        """Automatically infer transport type based on url/command presence."""
+        import warnings
+
+        if isinstance(values, dict):
+            # Check if transport was explicitly provided in the input
+            transport_explicit = "transport" in values
+            url = values.get("url")
+            command = values.get("command")
+
+            # Only infer if transport was not explicitly set
+            if not transport_explicit:
+                # Check if we have both url and command specified
+                has_url = url is not None and str(url).strip()
+                has_command = command is not None and str(command).strip()
+
+                if has_url and has_command:
+                    warnings.warn(
+                        f"MCP Server config has both 'url' ({url}) and 'command' ({command}) specified. "
+                        "Preferring HTTP transport and ignoring command.",
+                        UserWarning,
+                        stacklevel=4,
+                    )
+                    values["transport"] = "http"
+                    values["command"] = None  # Clear command to avoid confusion
+                elif has_url and not has_command:
+                    values["transport"] = "http"
+                elif has_command and not has_url:
+                    # Keep default "stdio" for command-based servers
+                    values["transport"] = "stdio"
+                # If neither url nor command is specified, keep default "stdio"
+
+        return values
+
 
 class MCPSettings(BaseModel):
     """Configuration for all MCP servers."""
@@ -260,8 +314,8 @@ class TensorZeroSettings(BaseModel):
     Settings for using TensorZero via its OpenAI-compatible API.
     """
 
-    base_url: Optional[str] = None
-    api_key: Optional[str] = None
+    base_url: str | None = None
+    api_key: str | None = None
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
@@ -287,7 +341,7 @@ class HuggingFaceSettings(BaseModel):
     Settings for HuggingFace authentication (used for MCP connections).
     """
 
-    api_key: Optional[str] = None
+    api_key: str | None = None
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
 
@@ -408,7 +462,7 @@ class Settings(BaseSettings):
     execution_engine: Literal["asyncio"] = "asyncio"
     """Execution engine for the fast-agent application"""
 
-    default_model: str | None = "haiku"
+    default_model: str | None = "gpt-5-mini.low"
     """
     Default model for agents. Format is provider.model_name.<reasoning_effort>, for example openai.o3-mini.low
     Aliases are provided for common models e.g. sonnet, haiku, gpt-4.1, o3-mini etc.
@@ -459,7 +513,7 @@ class Settings(BaseSettings):
     groq: GroqSettings | None = None
     """Settings for using the Groq provider in the fast-agent application"""
 
-    logger: LoggerSettings | None = LoggerSettings()
+    logger: LoggerSettings = LoggerSettings()
     """Logger settings for the fast-agent application"""
 
     # MCP UI integration mode for handling ui:// embedded resources from MCP tool results

fast_agent/mcp/mcp_aggregator.py

@@ -461,6 +461,36 @@ class MCPAggregator(ContextDependent):
         for server_name in self.server_names:
             await self._refresh_server_tools(server_name)
 
+    async def get_server_instructions(self) -> Dict[str, tuple[str, List[str]]]:
+        """
+        Get instructions from all connected servers along with their tool names.
+
+        Returns:
+            Dict mapping server name to tuple of (instructions, list of tool names)
+        """
+        instructions = {}
+
+        if self.connection_persistence and hasattr(self, '_persistent_connection_manager'):
+            # Get instructions from persistent connections
+            for server_name in self.server_names:
+                try:
+                    server_conn = await self._persistent_connection_manager.get_server(
+                        server_name, client_session_factory=self._create_session_factory(server_name)
+                    )
+                    # Always include server, even if no instructions
+                    # Get tool names for this server
+                    tool_names = [
+                        namespaced_tool.tool.name
+                        for namespaced_tool_name, namespaced_tool in self._namespaced_tool_map.items()
+                        if namespaced_tool.server_name == server_name
+                    ]
+                    # Include server even if instructions is None
+                    instructions[server_name] = (server_conn.server_instructions, tool_names)
+                except Exception as e:
+                    logger.debug(f"Failed to get instructions from server {server_name}: {e}")
+
+        return instructions
+
     async def _execute_on_server(
         self,
         server_name: str,

fast_agent/mcp/mcp_connection_manager.py

@@ -33,6 +33,7 @@ from fast_agent.core.logging.logger import get_logger
 from fast_agent.event_progress import ProgressAction
 from fast_agent.mcp.logger_textio import get_stderr_handler
 from fast_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
+from fast_agent.mcp.oauth_client import build_oauth_provider
 
 if TYPE_CHECKING:
     from fast_agent.context import Context
@@ -104,6 +105,9 @@ class ServerConnection:
         self._error_occurred = False
         self._error_message = None
 
+        # Server instructions from initialization
+        self.server_instructions: str | None = None
+
     def is_healthy(self) -> bool:
         """Check if the server connection is healthy and ready to use."""
         return self.session is not None and not self._error_occurred
@@ -130,10 +134,20 @@ class ServerConnection:
         Initializes the server connection and session.
         Must be called within an async context.
         """
-
+        assert self.session, "Session must be created before initialization"
         result = await self.session.initialize()
 
         self.server_capabilities = result.capabilities
+
+        # Store instructions if provided by the server and enabled in config
+        if self.server_config.include_instructions:
+            self.server_instructions = getattr(result, 'instructions', None)
+            if self.server_instructions:
+                logger.debug(f"{self.server_name}: Received server instructions", data={"instructions": self.server_instructions})
+        else:
+            self.server_instructions = None
+            logger.debug(f"{self.server_name}: Server instructions disabled by configuration")
+
         # If there's an init hook, run it
 
         # Now the session is ready for use
@@ -341,6 +355,10 @@ class MCPConnectionManager(ContextDependent):
 
         def transport_context_factory():
             if config.transport == "stdio":
+                if not config.command:
+                    raise ValueError(
+                        f"Server '{server_name}' uses stdio transport but no command is specified"
+                    )
                 server_params = StdioServerParameters(
                     command=config.command,
                     args=config.args if config.args is not None else [],
@@ -353,18 +371,37 @@ class MCPConnectionManager(ContextDependent):
                 logger.debug(f"{server_name}: Creating stdio client with custom error handler")
                 return _add_none_to_context(stdio_client(server_params, errlog=error_handler))
             elif config.transport == "sse":
+                if not config.url:
+                    raise ValueError(
+                        f"Server '{server_name}' uses sse transport but no url is specified"
+                    )
                 # Suppress MCP library error spam
                 self._suppress_mcp_sse_errors()
-
+                oauth_auth = build_oauth_provider(config)
+                # If using OAuth, strip any pre-existing Authorization headers to avoid conflicts
+                headers = dict(config.headers or {})
+                if oauth_auth is not None:
+                    headers.pop("Authorization", None)
+                    headers.pop("X-HF-Authorization", None)
                 return _add_none_to_context(
                     sse_client(
                         config.url,
-                        config.headers,
+                        headers,
                         sse_read_timeout=config.read_transport_sse_timeout_seconds,
+                        auth=oauth_auth,
                     )
                 )
             elif config.transport == "http":
-                return streamablehttp_client(config.url, config.headers)
+                if not config.url:
+                    raise ValueError(
+                        f"Server '{server_name}' uses http transport but no url is specified"
+                    )
+                oauth_auth = build_oauth_provider(config)
+                headers = dict(config.headers or {})
+                if oauth_auth is not None:
+                    headers.pop("Authorization", None)
+                    headers.pop("X-HF-Authorization", None)
+                return streamablehttp_client(config.url, headers, auth=oauth_auth)
             else:
                 raise ValueError(f"Unsupported transport: {config.transport}")