fast-agent-mcp 0.2.58__py3-none-any.whl → 0.3.1__py3-none-any.whl

{mcp_agent → fast_agent}/cli/commands/setup.py

@@ -7,136 +7,38 @@ from rich.prompt import Confirm
 app = typer.Typer()
 console = Console()
 
-FASTAGENT_CONFIG_TEMPLATE = """
-# FastAgent Configuration File
-
-# Default Model Configuration:
-# 
-# Takes format:
-#   <provider>.<model_string>.<reasoning_effort?> (e.g. anthropic.claude-3-5-sonnet-20241022 or openai.o3-mini.low)
-# Accepts aliases for Anthropic Models: haiku, haiku3, sonnet, sonnet35, opus, opus3
-# and OpenAI Models: gpt-4.1, gpt-4.1-mini, o1, o1-mini, o3-mini
-#
-# If not specified, defaults to "haiku". 
-# Can be overriden with a command line switch --model=<model>, or within the Agent constructor.
-
-default_model: haiku
-
-# Logging and Console Configuration:
-logger:
-    # level: "debug" | "info" | "warning" | "error"
-    # type: "none" | "console" | "file" | "http"
-    # path: "/path/to/logfile.jsonl"
-
-    
-    # Switch the progress display on or off
-    progress_display: true
-
-    # Show chat User/Assistant messages on the console
-    show_chat: true
-    # Show tool calls on the console
-    show_tools: true
-    # Truncate long tool responses on the console 
-    truncate_tools: true
-
-# MCP Servers
-mcp:
-    servers:
-        fetch:
-            command: "uvx"
-            args: ["mcp-server-fetch"]
-        filesystem:
-            command: "npx"
-            args: ["-y", "@modelcontextprotocol/server-filesystem", "."]
-
-"""
-
-FASTAGENT_SECRETS_TEMPLATE = """
-# FastAgent Secrets Configuration
-# WARNING: Keep this file secure and never commit to version control
-
-# Alternatively set OPENAI_API_KEY, ANTHROPIC_API_KEY or other environment variables. 
-# Keys in the configuration file override environment variables.
-
-openai:
-    api_key: <your-api-key-here>
-anthropic:
-    api_key: <your-api-key-here>
-deepseek:
-    api_key: <your-api-key-here>
-openrouter:
-    api_key: <your-api-key-here>
-
-
-# Example of setting an MCP Server environment variable
-mcp:
-    servers:
-        brave:
-            env:
-                BRAVE_API_KEY: <your_api_key_here>
-
-"""
-
-GITIGNORE_TEMPLATE = """
-# FastAgent secrets file
-fastagent.secrets.yaml
-
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-
-# Virtual Environment
-.env
-.venv
-env/
-venv/
-ENV/
-
-# IDE
-.idea/
-.vscode/
-*.swp
-*.swo
-"""
-
-AGENT_EXAMPLE_TEMPLATE = """
-import asyncio
-from mcp_agent.core.fastagent import FastAgent
-
-# Create the application
-fast = FastAgent("fast-agent example")
-
-
-# Define the agent
-@fast.agent(instruction="You are a helpful AI Agent")
-async def main():
-    # use the --model command line switch or agent arguments to change model
-    async with fast.run() as agent:
-        await agent.interactive()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())
-
-"""
+
+def load_template_text(filename: str) -> str:
+    """Load template text from packaged resources only.
+
+    Special-case: when requesting 'fastagent.secrets.yaml', read the
+    'fastagent.secrets.yaml.example' template from resources, but still
+    return its contents so we can write out the real secrets file name
+    in the destination project.
+    """
+    from importlib.resources import files
+
+    # Map requested filenames to resource templates
+    if filename == "fastagent.secrets.yaml":
+        res_name = "fastagent.secrets.yaml.example"
+    elif filename == "pyproject.toml":
+        res_name = "pyproject.toml.tmpl"
+    else:
+        res_name = filename
+    resource_path = (
+        files("fast_agent").joinpath("resources").joinpath("setup").joinpath(res_name)
+    )
+    if resource_path.is_file():
+        return resource_path.read_text()
+
+    raise RuntimeError(
+        f"Setup template missing: '{filename}'.\n"
+        f"Expected packaged resource at: {resource_path}.\n"
+        "This indicates a packaging issue. Please rebuild/reinstall fast-agent."
+    )
+
+
+# (No embedded template defaults; templates are the single source of truth.)
 
 
 def find_gitignore(path: Path) -> bool:
@@ -195,6 +97,7 @@ def init(
     console.print(f"  - {config_path}/fastagent.config.yaml")
     console.print(f"  - {config_path}/fastagent.secrets.yaml")
     console.print(f"  - {config_path}/agent.py")
+    console.print(f"  - {config_path}/pyproject.toml")
     if needs_gitignore:
         console.print(f"  - {config_path}/.gitignore")
 
@@ -203,21 +106,59 @@ def init(
 
     # Create configuration files
     created = []
-    if create_file(config_path / "fastagent.config.yaml", FASTAGENT_CONFIG_TEMPLATE, force):
+    if create_file(
+        config_path / "fastagent.config.yaml", load_template_text("fastagent.config.yaml"), force
+    ):
         created.append("fastagent.yaml")
 
-    if create_file(config_path / "fastagent.secrets.yaml", FASTAGENT_SECRETS_TEMPLATE, force):
+    if create_file(
+        config_path / "fastagent.secrets.yaml", load_template_text("fastagent.secrets.yaml"), force
+    ):
         created.append("fastagent.secrets.yaml")
 
-    if create_file(config_path / "agent.py", AGENT_EXAMPLE_TEMPLATE, force):
+    if create_file(config_path / "agent.py", load_template_text("agent.py"), force):
         created.append("agent.py")
 
+    # Create a minimal pyproject.toml so `uv run` installs dependencies
+    def _render_pyproject(template_text: str) -> str:
+        # Determine Python requirement from installed fast-agent-mcp metadata, fall back if missing
+        py_req = ">=3.13.7"
+        try:
+            from importlib.metadata import metadata
+
+            md = metadata("fast-agent-mcp")
+            req = md.get("Requires-Python")
+            if req:
+                py_req = req
+        except Exception:
+            pass
+
+        # 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)
+        )
+
+    pyproject_template = load_template_text("pyproject.toml")
+    pyproject_text = _render_pyproject(pyproject_template)
+    if create_file(config_path / "pyproject.toml", pyproject_text, force):
+        created.append("pyproject.toml")
+
     # Only create .gitignore if none exists in parent directories
-    if needs_gitignore and create_file(config_path / ".gitignore", GITIGNORE_TEMPLATE, force):
+    if needs_gitignore and create_file(
+        config_path / ".gitignore", load_template_text(".gitignore"), force
+    ):
         created.append(".gitignore")
 
     if created:
         console.print("\n[green]Setup completed successfully![/green]")
+        if not needs_gitignore:
+            console.print(
+                "[yellow]Note:[/yellow] Found an existing .gitignore in this or a parent directory. "
+                "Ensure it ignores 'fastagent.secrets.yaml' to avoid committing secrets."
+            )
         if "fastagent.secrets.yaml" in created:
             console.print("\n[yellow]Important:[/yellow] Remember to:")
             console.print(

{mcp_agent → fast_agent}/cli/commands/url_parser.py

@@ -8,7 +8,7 @@ import re
 from typing import Dict, List, Literal, Tuple
 from urllib.parse import urlparse
 
-from mcp_agent.mcp.hf_auth import add_hf_auth_header
+from fast_agent.mcp.hf_auth import add_hf_auth_header
 
 
 def parse_server_url(
@@ -46,12 +46,13 @@ def parse_server_url(
 
     # Determine transport type based on URL path
     transport_type: Literal["http", "sse"] = "http"
-    if parsed_url.path.endswith("/sse"):
+    path = parsed_url.path or ""
+    normalized_path = path.rstrip("/")
+    if normalized_path.endswith("/sse"):
         transport_type = "sse"
-    elif not parsed_url.path.endswith("/mcp"):
-        # If path doesn't end with /mcp or /sse, append /mcp
-        url = url if url.endswith("/") else f"{url}/"
-        url = f"{url}mcp"
+    elif not normalized_path.endswith("/mcp"):
+        # If path doesn't end with /mcp or /sse (handling trailing slash), append /mcp once
+        url = f"{url.rstrip('/')}" + "/mcp"
 
     # Generate a server name based on hostname and port
     server_name = generate_server_name(url)
@@ -133,10 +134,10 @@ def parse_server_urls(
     result = []
     for url in url_list:
         server_name, transport_type, parsed_url = parse_server_url(url)
-        
+
         # Apply HuggingFace authentication if appropriate
         final_headers = add_hf_auth_header(parsed_url, headers)
-        
+
         result.append((server_name, transport_type, parsed_url, final_headers))
 
     return result

{mcp_agent → fast_agent}/cli/main.py

@@ -1,11 +1,11 @@
 """Main CLI entry point for MCP Agent."""
 
 import typer
-from rich.console import Console
 from rich.table import Table
 
-from mcp_agent.cli.commands import check_config, go, quickstart, setup
-from mcp_agent.cli.terminal import Application
+from fast_agent.cli.commands import check_config, go, quickstart, setup
+from fast_agent.cli.terminal import Application
+from fast_agent.ui.console import console as shared_console
 
 app = typer.Typer(
     help="fast-agent - Build effective agents using Model Context Protocol",
@@ -21,34 +21,54 @@ app.add_typer(quickstart.app, name="quickstart", help="Create example applicatio
 
 # Shared application context
 application = Application()
-console = Console()
+# Use shared console to match app-wide styling
+console = shared_console
 
 
 def show_welcome() -> None:
-    """Show a welcome message with available commands."""
+    """Show a welcome message with available commands, using new styling."""
     from importlib.metadata import version
 
+    from rich.text import Text
+
     try:
         app_version = version("fast-agent-mcp")
     except:  # noqa: E722
         app_version = "unknown"
 
-    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("[bold]go[/bold]", "Start an interactive session with an agent")
-    table.add_row("setup", "Create a new agent template and configuration files")
-    table.add_row("check", "Show or diagnose fast-agent configuration")
+    # Header in the same style used by check/console_display
+    def _print_section_header(title: str, color: str = "blue") -> None:
+        width = console.size.width
+        left = f"[{color}]▎[/{color}][dim {color}]▶[/dim {color}] [{color}]{title}[/{color}]"
+        left_text = Text.from_markup(left)
+        separator_count = max(1, width - left_text.cell_len - 1)
+
+        combined = Text()
+        combined.append_text(left_text)
+        combined.append(" ")
+        combined.append("─" * separator_count, style="dim")
+
+        console.print()
+        console.print(combined)
+        console.print()
+
+    header_title = f"fast-agent v{app_version}"
+    _print_section_header(header_title, color="blue")
+
+    # Commands list (no boxes), matching updated check styling
+    table = Table(show_header=True, box=None)
+    table.add_column("Command", style="green", header_style="bold bright_white")
+    table.add_column("Description", header_style="bold bright_white")
+
+    table.add_row("[bold]go[/bold]", "Start an interactive session")
+    table.add_row("check", "Show current configuration")
+    table.add_row("setup", "Create agent template and configuration")
     table.add_row("quickstart", "Create example applications (workflow, researcher, etc.)")
 
     console.print(table)
 
     console.print(
-        "\n[italic]get started with:[/italic] [bold][cyan]fast-agent[/cyan][/bold] [green]setup[/green]. visit [cyan][link=https://fast-agent.ai]fast-agent.ai[/link][/cyan] for more information."
+        "\nVisit [cyan][link=https://fast-agent.ai]fast-agent.ai[/link][/cyan] for more information."
     )
 
 

{mcp_agent → fast_agent}/cli/terminal.py

@@ -1,4 +1,4 @@
-from mcp_agent.console import console, error_console
+from fast_agent.ui.console import console, error_console
 
 
 class Application:
@@ -14,7 +14,7 @@ class Application:
             self.error_console = error_console
 
     def log(self, message: str, level: str = "info") -> None:
-        if (level == "info" or (level == "debug" and self.verbosity > 0) or level ==  "error"):
+        if level == "info" or (level == "debug" and self.verbosity > 0) or level == "error":
             if level == "error":
                 self.error_console.print(f"[{level.upper()}] {message}")
             else:

{mcp_agent → fast_agent}/config.py

@@ -84,10 +84,10 @@ class MCPServerSettings(BaseModel):
     """The timeout in seconds for the server connection."""
 
     url: str | None = None
-    """The URL for the server (e.g. for SSE transport)."""
+    """The URL for the server (e.g. for SSE/SHTTP transport)."""
 
     headers: Dict[str, str] | None = None
-    """Headers dictionary for SSE connections"""
+    """Headers dictionary for HTTP connections"""
 
     auth: MCPServerAuthSettings | None = None
     """The authentication configuration for the server."""
@@ -462,6 +462,14 @@ class Settings(BaseSettings):
     logger: LoggerSettings | None = LoggerSettings()
     """Logger settings for the fast-agent application"""
 
+    # MCP UI integration mode for handling ui:// embedded resources from MCP tool results
+    mcp_ui_mode: Literal["disabled", "enabled", "auto"] = "enabled"
+    """Controls handling of MCP UI embedded resources:
+    - "disabled": Do not process ui:// resources
+    - "enabled": Always extract ui:// resources into message channels (default)
+    - "auto": Extract and automatically open ui:// resources.
+    """
+
     @classmethod
     def find_config(cls) -> Path | None:
         """Find the config file in the current directory or parent directories."""

fast_agent/constants.py

@@ -0,0 +1,8 @@
+"""
+Global constants for fast_agent with minimal dependencies to avoid circular imports.
+"""
+
+# Canonical tool name for the human input/elicitation tool
+HUMAN_INPUT_TOOL_NAME = "__human_input"
+MCP_UI = "mcp-ui"
+REASONING = "reasoning"

{mcp_agent → fast_agent}/context.py

@@ -7,15 +7,11 @@ import concurrent.futures
 import uuid
 from typing import TYPE_CHECKING, Any, Optional, Union
 
-from mcp import ServerSession
 from opentelemetry import trace
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 
 # from opentelemetry.instrumentation.anthropic import AnthropicInstrumentor
-from opentelemetry.instrumentation.google_genai import GoogleGenAiSdkInstrumentor
-
 # from opentelemetry.instrumentation.mcp import McpInstrumentor
-from opentelemetry.instrumentation.openai import OpenAIInstrumentor
 from opentelemetry.propagate import set_global_textmap
 from opentelemetry.sdk.resources import Resource
 from opentelemetry.sdk.trace import TracerProvider
@@ -23,20 +19,18 @@ from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExport
 from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
 from pydantic import BaseModel, ConfigDict
 
-from mcp_agent.config import Settings, get_settings
-from mcp_agent.executor.executor import AsyncioExecutor, Executor
-from mcp_agent.executor.task_registry import ActivityRegistry
-from mcp_agent.logging.events import EventFilter, StreamingExclusionFilter
-from mcp_agent.logging.logger import LoggingConfig, get_logger
-from mcp_agent.logging.transport import create_transport
-from mcp_agent.mcp_server_registry import ServerRegistry
+from fast_agent.config import Settings, get_settings
+from fast_agent.core.executor.executor import AsyncioExecutor, Executor
+from fast_agent.core.executor.task_registry import ActivityRegistry
+from fast_agent.core.logging.events import EventFilter, StreamingExclusionFilter
+from fast_agent.core.logging.logger import LoggingConfig, get_logger
+from fast_agent.core.logging.transport import create_transport
+from fast_agent.mcp_server_registry import ServerRegistry
 
 if TYPE_CHECKING:
-    from mcp_agent.executor.workflow_signal import SignalWaitCallback
-    from mcp_agent.human_input.types import HumanInputCallback
+    from fast_agent.core.executor.workflow_signal import SignalWaitCallback
 else:
     # Runtime placeholders for the types
-    HumanInputCallback = Any
     SignalWaitCallback = Any
 
 logger = get_logger(__name__)
@@ -50,9 +44,8 @@ class Context(BaseModel):
 
     config: Optional[Settings] = None
     executor: Optional[Executor] = None
-    human_input_handler: Optional[HumanInputCallback] = None
+    human_input_handler: Optional[Any] = None
     signal_notification: Optional[SignalWaitCallback] = None
-    upstream_session: Optional[ServerSession] = None  # TODO: saqadri - figure this out
 
     # Registries
     server_registry: Optional[ServerRegistry] = None
@@ -113,9 +106,21 @@ async def configure_otel(config: "Settings") -> None:
 
     # Set as global tracer provider
     trace.set_tracer_provider(tracer_provider)
-    #    AnthropicInstrumentor().instrument()
-    OpenAIInstrumentor().instrument()
-    GoogleGenAiSdkInstrumentor().instrument()
+
+    # Attempt to instrument optional SDKs if available; continue silently if missing
+    try:
+        from opentelemetry.instrumentation.openai import OpenAIInstrumentor
+
+        OpenAIInstrumentor().instrument()
+    except Exception:  # pragma: no cover - optional instrumentation
+        pass
+
+    try:
+        from opentelemetry.instrumentation.google_genai import GoogleGenAiSdkInstrumentor
+
+        GoogleGenAiSdkInstrumentor().instrument()
+    except Exception:  # pragma: no cover - optional instrumentation
+        pass
 
 
 #    McpInstrumentor().instrument()

{mcp_agent → fast_agent}/context_dependent.py

@@ -1,8 +1,8 @@
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from mcp_agent.context import Context
+    from fast_agent.context import Context
 
 
 class ContextDependent:
@@ -11,7 +11,11 @@ class ContextDependent:
     Provides both global fallback and instance-specific context support.
     """
 
-    def __init__(self, context: Optional["Context"] = None, **kwargs: dict[str, Any]) -> None:
+    # Ensure the attribute always exists even if a subclass
+    # does not call this mixin's __init__.
+    _context: "Context | None" = None
+
+    def __init__(self, context: "Context | None" = None, **kwargs: dict[str, Any]) -> None:
         self._context = context
         super().__init__(**kwargs)
 
@@ -27,12 +31,12 @@ class ContextDependent:
 
         try:
             # Fall back to global context if available
-            from mcp_agent.context import get_current_context
+            from fast_agent.context import get_current_context
 
             return get_current_context()
         except Exception as e:
             raise RuntimeError(
-                f"No context available for {self.__class__.__name__}. Either initialize MCPApp first or pass context explicitly."
+                f"No context available for {self.__class__.__name__}. Either initialize Core first or pass context explicitly."
             ) from e
 
     @contextmanager

fast_agent/core/__init__.py

@@ -0,0 +1,52 @@
+"""
+Core interfaces and decorators for fast-agent.
+
+Public API:
+- `Core`: The core application container (lazy-loaded)
+- `FastAgent`: High-level, decorator-driven application class (lazy-loaded)
+- Decorators: `agent`, `custom`, `orchestrator`, `iterative_planner`,
+  `router`, `chain`, `parallel`, `evaluator_optimizer` (lazy-loaded)
+"""
+
+__all__ = [
+    "Core",
+    "FastAgent",
+    # Decorators
+    "agent",
+    "custom",
+    "orchestrator",
+    "iterative_planner",
+    "router",
+    "chain",
+    "parallel",
+    "evaluator_optimizer",
+]
+
+
+def __getattr__(name: str):
+    # Lazy imports to avoid heavy dependencies and circular imports at init time
+    if name == "Core":
+        from .core_app import Core
+
+        return Core
+    if name == "FastAgent":
+        from .fastagent import FastAgent
+
+        return FastAgent
+
+    # Decorators from direct_decorators
+    if name in {
+        "agent",
+        "custom",
+        "orchestrator",
+        "iterative_planner",
+        "router",
+        "chain",
+        "parallel",
+        "evaluator_optimizer",
+    }:
+        from . import direct_decorators as _dd
+
+        return getattr(_dd, name)
+
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")