fast-agent-mcp 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

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:

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,14 +9,29 @@ 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)
 
@@ -109,6 +124,42 @@ class MCPServerSettings(BaseModel):
 
     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 +311,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 +338,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 +459,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 +510,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
@@ -470,6 +521,10 @@ class Settings(BaseSettings):
     - "auto": Extract and automatically open ui:// resources.
     """
 
+    # Output directory for MCP-UI generated HTML files (relative to CWD if not absolute)
+    mcp_ui_output_dir: str = ".fast-agent/ui"
+    """Directory where MCP-UI HTML files are written. Relative paths are resolved from CWD."""
+
     @classmethod
     def find_config(cls) -> Path | None:
         """Find the config file in the current directory or parent directories."""

fast_agent/core/__init__.py

@@ -2,45 +2,32 @@
 Core interfaces and decorators for fast-agent.
 
 Public API:
-- `Core`: The core application container (eagerly exported)
-- `FastAgent`: High-level, decorator-driven application class (lazy-loaded)
+- `Core`: The core application container
+- `AgentApp`: Container for interacting with agents
+- `FastAgent`: High-level, decorator-driven application class
 - Decorators: `agent`, `custom`, `orchestrator`, `iterative_planner`,
-  `router`, `chain`, `parallel`, `evaluator_optimizer` (lazy-loaded)
-"""
-
-from typing import TYPE_CHECKING as _TYPE_CHECKING
+  `router`, `chain`, `parallel`, `evaluator_optimizer`
 
-from .core_app import Core  # Eager export for external applications
+Exports are resolved lazily to avoid circular imports during package init.
+"""
 
-__all__ = [
-    "Core",
-    "AgentApp",
-    "FastAgent",
-    # Decorators
-    "agent",
-    "custom",
-    "orchestrator",
-    "iterative_planner",
-    "router",
-    "chain",
-    "parallel",
-    "evaluator_optimizer",
-]
+from typing import TYPE_CHECKING
 
 
 def __getattr__(name: str):
-    # Lazy imports to avoid heavy dependencies and circular imports at init time
-    if name == "FastAgent":
-        from .fastagent import FastAgent
-
-        return FastAgent
     if name == "AgentApp":
         from .agent_app import AgentApp
 
         return AgentApp
+    elif name == "Core":
+        from .core_app import Core
 
-    # Decorators from direct_decorators
-    if name in {
+        return Core
+    elif name == "FastAgent":
+        from .fastagent import FastAgent
+
+        return FastAgent
+    elif name in (
         "agent",
         "custom",
         "orchestrator",
@@ -49,20 +36,22 @@ def __getattr__(name: str):
         "chain",
         "parallel",
         "evaluator_optimizer",
-    }:
+    ):
         from . import direct_decorators as _dd
 
-        return getattr(_dd, name)
-
+        return getattr(
+            _dd,
+            name,
+        )
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
 
-# Help static analyzers/IDEs resolve symbols and signatures without importing at runtime.
-if _TYPE_CHECKING:  # pragma: no cover - typing aid only
+if TYPE_CHECKING:  # pragma: no cover - typing aid only
     from .agent_app import AgentApp as AgentApp  # noqa: F401
-    from .direct_decorators import (
+    from .core_app import Core as Core  # noqa: F401
+    from .direct_decorators import (  # noqa: F401
         agent as agent,
-    )  # noqa: F401
+    )
     from .direct_decorators import (
         chain as chain,
     )
@@ -87,5 +76,17 @@ if _TYPE_CHECKING:  # pragma: no cover - typing aid only
     from .fastagent import FastAgent as FastAgent  # noqa: F401
 
 
-def __dir__():  # pragma: no cover - developer experience aid
-    return sorted(__all__)
+__all__ = [
+    "Core",
+    "AgentApp",
+    "FastAgent",
+    # Decorators
+    "agent",
+    "custom",
+    "orchestrator",
+    "iterative_planner",
+    "router",
+    "chain",
+    "parallel",
+    "evaluator_optimizer",
+]

fast_agent/core/direct_factory.py

@@ -5,9 +5,9 @@ Implements type-safe factories with improved error handling.
 
 from typing import Any, Dict, Optional, Protocol, TypeVar
 
+from fast_agent.agents import McpAgent
 from fast_agent.agents.agent_types import AgentConfig, AgentType
 from fast_agent.agents.llm_agent import LlmAgent
-from fast_agent.agents.mcp_agent import McpAgent
 from fast_agent.agents.workflow.evaluator_optimizer import (
     EvaluatorOptimizerAgent,
     QualityRating,

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
@@ -341,6 +342,8 @@ 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 +356,33 @@ 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}")