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

{mcp_agent → fast_agent}/agents/workflow/router_agent.py

@@ -5,25 +5,24 @@ This provides a simplified implementation that routes messages to agents
 by determining the best agent for a request and dispatching to it.
 """
 
-from typing import TYPE_CHECKING, Callable, List, Optional, Tuple, Type
+from typing import TYPE_CHECKING, List, Optional, Tuple, Type
 
+from mcp import Tool
 from opentelemetry import trace
 from pydantic import BaseModel
 
-from mcp_agent.agents.agent import Agent
-from mcp_agent.agents.base_agent import BaseAgent
-from mcp_agent.core.agent_types import AgentConfig, AgentType
-from mcp_agent.core.exceptions import AgentConfigError
-from mcp_agent.core.prompt import Prompt
-from mcp_agent.core.request_params import RequestParams
-from mcp_agent.logging.logger import get_logger
-from mcp_agent.mcp.interfaces import AugmentedLLMProtocol, ModelT
-from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+from fast_agent.agents.agent_types import AgentConfig, AgentType
+from fast_agent.agents.llm_agent import LlmAgent
+from fast_agent.core.exceptions import AgentConfigError
+from fast_agent.core.logging.logger import get_logger
+from fast_agent.core.prompt import Prompt
+from fast_agent.interfaces import FastAgentLLMProtocol, LLMFactoryProtocol, ModelT
+from fast_agent.types import PromptMessageExtended, RequestParams
 
 if TYPE_CHECKING:
     from a2a.types import AgentCard
 
-    from mcp_agent.context import Context
+    from fast_agent.context import Context
 
 logger = get_logger(__name__)
 
@@ -60,7 +59,7 @@ class RoutingResponse(BaseModel):
     reasoning: str | None = None
 
 
-class RouterAgent(BaseAgent):
+class RouterAgent(LlmAgent):
     """
     A simplified router that uses an LLM to determine the best agent for a request,
     then dispatches the request to that agent and returns the response.
@@ -74,10 +73,10 @@ class RouterAgent(BaseAgent):
     def __init__(
         self,
         config: AgentConfig,
-        agents: List[Agent],
-        routing_instruction: Optional[str] = None,
-        context: Optional["Context"] = None,
-        default_request_params: Optional[RequestParams] = None,
+        agents: List[LlmAgent],
+        routing_instruction: str | None = None,
+        context: "Context | None" = None,
+        default_request_params: RequestParams | None = None,
         **kwargs,
     ) -> None:
         """
@@ -117,7 +116,7 @@ class RouterAgent(BaseAgent):
 
             # Initialize all agents if not already initialized
             for agent in self.agents:
-                if not getattr(agent, "initialized", False):
+                if not agent.initialized:
                     await agent.initialize()
 
             complete_routing_instruction = await self._generate_routing_instruction(
@@ -130,9 +129,6 @@ class RouterAgent(BaseAgent):
             )
             self._default_request_params.systemPrompt = combined_system_prompt
             self.instruction = combined_system_prompt
-            self._routing_instruction_generated = True
-
-            self.initialized = True
 
     async def shutdown(self) -> None:
         """Shutdown the router and all agents."""
@@ -147,7 +143,7 @@ class RouterAgent(BaseAgent):
 
     @staticmethod
     async def _generate_routing_instruction(
-        agents: List[Agent], routing_instruction: Optional[str] = None
+        agents: List[LlmAgent], routing_instruction: Optional[str] = None
     ) -> str:
         """
         Generate the complete routing instruction with agent cards.
@@ -177,54 +173,59 @@ class RouterAgent(BaseAgent):
 
     async def attach_llm(
         self,
-        llm_factory: type[AugmentedLLMProtocol] | Callable[..., AugmentedLLMProtocol],
+        llm_factory: LLMFactoryProtocol,
         model: str | None = None,
         request_params: RequestParams | None = None,
         **additional_kwargs,
-    ) -> AugmentedLLMProtocol:
+    ) -> FastAgentLLMProtocol:
         return await super().attach_llm(
             llm_factory, model, request_params, verb="Routing", **additional_kwargs
         )
 
-    async def generate(
+    async def generate_impl(
         self,
-        multipart_messages: List[PromptMessageMultipart],
+        messages: List[PromptMessageExtended],
         request_params: Optional[RequestParams] = None,
-    ) -> PromptMessageMultipart:
+        tools: List[Tool] | None = None,
+    ) -> PromptMessageExtended:
         """
         Route the request to the most appropriate agent and return its response.
 
         Args:
-            multipart_messages: Messages to route
+            normalized_messages: Already normalized list of PromptMessageExtended
             request_params: Optional request parameters
 
         Returns:
             The response from the selected agent
         """
+
+        # implementation note. the duplication between generated and structured
+        # is probably the most readable. alt could be a _get_route_agent or
+        # some form of dynamic dispatch.. but only if this gets more complex
         tracer = trace.get_tracer(__name__)
         with tracer.start_as_current_span(f"Routing: '{self.name}' generate"):
-            route, warn = await self._route_request(multipart_messages[-1])
+            route, warn = await self._route_request(messages[-1])
 
             if not route:
                 return Prompt.assistant(warn or "No routing result or warning received")
 
             # Get the selected agent
-            agent: Agent = self.agent_map[route.agent]
+            agent: LlmAgent = self.agent_map[route.agent]
 
             # Dispatch the request to the selected agent
-            return await agent.generate(multipart_messages, request_params)
+            return await agent.generate_impl(messages, request_params)
 
-    async def structured(
+    async def structured_impl(
         self,
-        multipart_messages: List[PromptMessageMultipart],
+        messages: List[PromptMessageExtended],
         model: Type[ModelT],
         request_params: Optional[RequestParams] = None,
-    ) -> Tuple[ModelT | None, PromptMessageMultipart]:
+    ) -> Tuple[ModelT | None, PromptMessageExtended]:
         """
         Route the request to the most appropriate agent and parse its response.
 
         Args:
-            prompt: Messages to route
+            messages: Messages to route
             model: Pydantic model to parse the response into
             request_params: Optional request parameters
 
@@ -234,7 +235,7 @@ class RouterAgent(BaseAgent):
 
         tracer = trace.get_tracer(__name__)
         with tracer.start_as_current_span(f"Routing: '{self.name}' structured"):
-            route, warn = await self._route_request(multipart_messages[-1])
+            route, warn = await self._route_request(messages[-1])
 
             if not route:
                 return None, Prompt.assistant(
@@ -242,13 +243,13 @@ class RouterAgent(BaseAgent):
                 )
 
             # Get the selected agent
-            agent: Agent = self.agent_map[route.agent]
+            agent: LlmAgent = self.agent_map[route.agent]
 
             # Dispatch the request to the selected agent
-            return await agent.structured(multipart_messages, model, request_params)
+            return await agent.structured_impl(messages, model, request_params)
 
     async def _route_request(
-        self, message: PromptMessageMultipart
+        self, message: PromptMessageExtended
     ) -> Tuple[RoutingResponse | None, str | None]:
         """
         Determine which agent to route the request to.
@@ -263,13 +264,16 @@ class RouterAgent(BaseAgent):
             logger.error("No agents available for routing")
             raise AgentConfigError("No agents available for routing - fatal error")
 
-        # If only one agent is available, use it directly
+        # go straight to agent if only one available
         if len(self.agents) == 1:
             return RoutingResponse(
                 agent=self.agents[0].name, confidence="high", reasoning="Only one agent available"
             ), None
 
         assert self._llm
+        # Display the user's routing request
+        self.display.show_user_message(message.first_text(), name=self.name)
+
         # No need to add routing instruction here - it's already in the system prompt
         response, _ = await self._llm.structured(
             [message],
@@ -292,4 +296,15 @@ class RouterAgent(BaseAgent):
                 f"Routing structured request to agent: {response.agent or 'error'} (confidence: {response.confidence or ''})"
             )
 
+            routing_message = f"Routing to: {response.agent}"
+            if response.reasoning:
+                routing_message += f" ({response.reasoning})"
+
+            await self.display.show_assistant_message(
+                routing_message,
+                bottom_items=list(self.agent_map.keys()),
+                highlight_items=[response.agent],
+                name=self.name,
+            )
+
             return response, None

{mcp_agent → fast_agent}/cli/__main__.py

@@ -1,7 +1,7 @@
 import sys
 
-from mcp_agent.cli.constants import GO_SPECIFIC_OPTIONS, KNOWN_SUBCOMMANDS
-from mcp_agent.cli.main import app
+from fast_agent.cli.constants import GO_SPECIFIC_OPTIONS, KNOWN_SUBCOMMANDS
+from fast_agent.cli.main import app
 
 # if the arguments would work with "go" we'll just route to it
 
@@ -20,7 +20,9 @@ def main():
             # 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):
+                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

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

@@ -9,11 +9,11 @@ from typing import Optional
 import typer
 import yaml
 from rich.console import Console
-from rich.panel import Panel
 from rich.table import Table
+from rich.text import Text
 
-from mcp_agent.llm.provider_key_manager import API_KEY_HINT_TEXT, ProviderKeyManager
-from mcp_agent.llm.provider_types import Provider
+from fast_agent.llm.provider_key_manager import API_KEY_HINT_TEXT, ProviderKeyManager
+from fast_agent.llm.provider_types import Provider
 
 app = typer.Typer(
     help="Check and diagnose FastAgent configuration",
@@ -24,7 +24,7 @@ console = Console()
 
 def find_config_files(start_path: Path) -> dict[str, Optional[Path]]:
     """Find FastAgent configuration files, preferring secrets file next to config file."""
-    from mcp_agent.config import find_fastagent_config_files
+    from fast_agent.config import find_fastagent_config_files
 
     config_path, secrets_path = find_fastagent_config_files(start_path)
     return {
@@ -145,7 +145,7 @@ 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
+    from fast_agent.config import Settings
 
     # Get actual defaults from Settings class
     default_settings = Settings()
@@ -163,6 +163,7 @@ def get_config_summary(config_path: Optional[Path]) -> dict:
             "truncate_tools": default_settings.logger.truncate_tools,
             "enable_markup": default_settings.logger.enable_markup,
         },
+        "mcp_ui_mode": default_settings.mcp_ui_mode,
         "mcp_servers": [],
     }
 
@@ -207,6 +208,10 @@ def get_config_summary(config_path: Optional[Path]) -> dict:
                 ),
             }
 
+        # Get MCP UI mode
+        if "mcp_ui_mode" in config:
+            result["mcp_ui_mode"] = config["mcp_ui_mode"]
+
         # Get MCP server info
         if "mcp" in config and "servers" in config["mcp"]:
             for server_name, server_config in config["mcp"]["servers"].items():
@@ -272,76 +277,93 @@ def show_check_summary() -> None:
     api_keys = check_api_keys(secrets_summary, config_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")
+    # Helper to print section headers using the new console_display style
+    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)
 
-    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"])
+        combined = Text()
+        combined.append_text(left_text)
+        combined.append(" ")
+        combined.append("─" * separator_count, style="dim")
 
-    console.print(
-        Panel(system_table, title="System Information", title_align="left", border_style="blue")
-    )
+        console.print()
+        console.print(combined)
+        console.print()
+
+    # Environment and configuration section (merged)
+    # Header shows version and platform for a concise overview
+    header_title = f"fast-agent v{fastagent_version} ({system_info['platform']})"
+    _print_section_header(header_title, color="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")
+    env_table = Table(show_header=False, box=None)
+    env_table.add_column("Setting", style="white")
+    env_table.add_column("Value")
 
-    # Show secrets file status
+    # Python info (highlight version and path in green)
+    env_table.add_row(
+        "Python Version", f"[green]{'.'.join(system_info['python_version'].split('.')[:3])}[/green]"
+    )
+    env_table.add_row("Python Path", f"[green]{system_info['python_path']}[/green]")
+
+    # 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]")
+        env_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(
+        env_table.add_row("Secrets File", f"[orange_red1]Errors[/orange_red1] ({secrets_path})")
+        env_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})")
+        env_table.add_row("Secrets File", f"[green]Found[/green] ({secrets_path})")
 
-    # Show config file status
+    # 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]")
+        env_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(
+        env_table.add_row("Config File", f"[orange_red1]Errors[/orange_red1] ({config_path})")
+        env_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)")
-        )
+        env_table.add_row("Config File", f"[green]Found[/green] ({config_path})")
+        default_model_value = config_summary.get("default_model", "haiku (system default)")
+        env_table.add_row("Default Model", f"[green]{default_model_value}[/green]")
 
-    console.print(
-        Panel(files_table, title="Configuration Files", title_align="left", border_style="blue")
-    )
+    console.print(env_table)
 
     # 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")
+    logger_table.add_column("Setting", style="white", header_style="bold bright_white")
+    logger_table.add_column("Value", header_style="bold bright_white")
+    logger_table.add_column("Setting", style="white", header_style="bold bright_white")
+    logger_table.add_column("Value", header_style="bold bright_white")
 
     def bool_to_symbol(value):
         return "[bold green]✓[/bold green]" if value else "[bold red]✗[/bold red]"
 
+    # Format MCP-UI mode value
+    mcp_ui_mode = config_summary.get("mcp_ui_mode", "auto")
+    if mcp_ui_mode == "disabled":
+        mcp_ui_display = "[dim]disabled[/dim]"
+    else:
+        mcp_ui_display = f"[green]{mcp_ui_mode}[/green]"
+
     # Prepare all settings as pairs
     settings_data = [
-        ("Logger Level", logger.get("level", "warning (default)")),
-        ("Logger Type", logger.get("type", "file (default)")),
+        ("Log Level", logger.get("level", "warning (default)")),
+        ("Log Type", logger.get("type", "file (default)")),
+        ("MCP-UI", mcp_ui_display),
         ("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))),
@@ -349,30 +371,34 @@ def show_check_summary() -> None:
         ("Enable Markup", bool_to_symbol(logger.get("enable_markup", True))),
     ]
 
-    # Add rows in two-column layout
+    # Add rows in two-column layout, styling some values in green
     for i in range(0, len(settings_data), 2):
         left_setting, left_value = settings_data[i]
+        # Style certain values in green (MCP-UI is already pre-styled)
+        if left_setting in ("Log Level", "Log Type"):
+            left_value = f"[green]{left_value}[/green]"
         if i + 1 < len(settings_data):
             right_setting, right_value = settings_data[i + 1]
+            if right_setting in ("Log Level", "Log Type"):
+                right_value = f"[green]{right_value}[/green]"
             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(logger_table, title="Logger Settings", title_align="left", border_style="blue")
-    )
+    _print_section_header("Application Settings", color="blue")
+    console.print(logger_table)
 
     # 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")
+    keys_table.add_column("Provider", style="white", header_style="bold bright_white")
+    keys_table.add_column("Env", justify="center", header_style="bold bright_white")
+    keys_table.add_column("Config", justify="center", header_style="bold bright_white")
+    keys_table.add_column("Active Key", style="green", header_style="bold bright_white")
+    keys_table.add_column("Provider", style="white", header_style="bold bright_white")
+    keys_table.add_column("Env", justify="center", header_style="bold bright_white")
+    keys_table.add_column("Config", justify="center", header_style="bold bright_white")
+    keys_table.add_column("Active Key", style="green", header_style="bold bright_white")
 
     def format_provider_row(provider, status):
         """Format a single provider's status for display."""
@@ -410,7 +436,7 @@ def show_check_summary() -> None:
             active = "[dim]Not configured[/dim]"
 
         # Get the proper display name for the provider
-        from mcp_agent.llm.provider_types import Provider
+        from fast_agent.llm.provider_types import Provider
 
         provider_enum = Provider(provider)
         display_name = provider_enum.display_name
@@ -436,18 +462,18 @@ def show_check_summary() -> None:
             # 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", title_align="left", border_style="blue")
-    console.print(keys_panel)
+    # API Keys section
+    _print_section_header("API Keys", color="blue")
+    console.print(keys_table)
 
     # 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")
+            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")
 
             for server in mcp_servers:
                 name = server["name"]
@@ -456,14 +482,17 @@ def show_check_summary() -> None:
                 # 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", title_align="left", border_style="blue")
-            )
+                # Style configured command/url in green (keep "Not configured" dim)
+                if "Not configured" not in command_url:
+                    command_url = f"[green]{command_url}[/green]"
+
+                servers_table.add_row(name, transport, command_url)
+
+            _print_section_header("MCP Servers", color="blue")
+            console.print(servers_table)
 
     # Show help tips
     if config_status == "not_found" or secrets_status == "not_found":

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

@@ -7,10 +7,11 @@ from typing import Dict, List, Optional
 
 import typer
 
-from mcp_agent.cli.commands.server_helpers import add_servers_to_config, generate_server_name
-from mcp_agent.cli.commands.url_parser import generate_server_configs, parse_server_urls
-from mcp_agent.core.fastagent import FastAgent
-from mcp_agent.ui.console_display import ConsoleDisplay
+from fast_agent.agents.llm_agent import LlmAgent
+from fast_agent.cli.commands.server_helpers import add_servers_to_config, generate_server_name
+from fast_agent.cli.commands.url_parser import generate_server_configs, parse_server_urls
+from fast_agent.core.fastagent import FastAgent
+from fast_agent.ui.console_display import ConsoleDisplay
 
 app = typer.Typer(
     help="Run an interactive agent directly from the command line without creating an agent.py file",
@@ -33,7 +34,7 @@ async def _run_agent(
     """Async implementation to run an interactive agent."""
     from pathlib import Path
 
-    from mcp_agent.mcp.prompts.prompt_load import load_prompt_multipart
+    from fast_agent.mcp.prompts.prompt_load import load_prompt_multipart
 
     # Create the FastAgent instance
 
@@ -72,13 +73,21 @@ async def _run_agent(
 
             fan_out_agents.append(agent_name)
 
-        # Create a silent fan-in agent for cleaner output
-        @fast.agent(
+        # Create a silent fan-in agent (suppresses display output)
+        class SilentFanInAgent(LlmAgent):
+            async def show_assistant_message(self, *args, **kwargs):  # type: ignore[override]
+                return None
+
+            def show_user_message(self, *args, **kwargs):  # type: ignore[override]
+                return None
+
+        @fast.custom(
+            SilentFanInAgent,
             name="aggregate",
-            model="silent",
-            instruction="You are a silent agent that combines outputs from parallel agents.",
+            model="passthrough",
+            instruction="You aggregate parallel outputs without displaying intermediate messages.",
         )
-        async def fan_in_agent():
+        async def aggregate():
             pass
 
         # Create a parallel agent with silent fan_in
@@ -352,7 +361,7 @@ def go(
 
             from pydantic import AnyUrl
 
-            from mcp_agent.core.direct_decorators import _resolve_instruction
+            from fast_agent.core.direct_decorators import _resolve_instruction
 
             # Check if it's a URL
             if instruction.startswith(("http://", "https://")):

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

@@ -126,7 +126,7 @@ def copy_example_files(example_type: str, target_dir: Path, force: bool = False)
         if example_type == "state-transfer":
             # The state-transfer example is in the mcp subdirectory
             source_dir = (
-                files("mcp_agent")
+                files("fast_agent")
                 .joinpath("resources")
                 .joinpath("examples")
                 .joinpath("mcp")
@@ -135,7 +135,7 @@ def copy_example_files(example_type: str, target_dir: Path, force: bool = False)
         elif example_type == "elicitations":
             # The elicitations example is in the mcp subdirectory
             source_dir = (
-                files("mcp_agent")
+                files("fast_agent")
                 .joinpath("resources")
                 .joinpath("examples")
                 .joinpath("mcp")
@@ -144,7 +144,7 @@ def copy_example_files(example_type: str, target_dir: Path, force: bool = False)
         else:
             # Other examples are at the top level of examples
             source_dir = (
-                files("mcp_agent")
+                files("fast_agent")
                 .joinpath("resources")
                 .joinpath("examples")
                 .joinpath("workflows" if example_type == "workflow" else f"{example_type}")
@@ -454,7 +454,7 @@ def tensorzero(
     from importlib.resources import files
     try:
         # This path MUST match the "to" path from hatch_build.py
-        source_dir = files("mcp_agent").joinpath("resources").joinpath("examples").joinpath("tensorzero")
+        source_dir = files("fast_agent").joinpath("resources").joinpath("examples").joinpath("tensorzero")
         if not source_dir.is_dir():
             raise FileNotFoundError  # Fallback to dev mode if resource isn't a dir
     except (ImportError, ModuleNotFoundError, FileNotFoundError):

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

@@ -73,7 +73,7 @@ async def add_servers_to_config(fast_app: Any, servers: Dict[str, Dict[str, Any]
     if not servers:
         return
 
-    from mcp_agent.config import MCPServerSettings, MCPSettings
+    from fast_agent.config import MCPServerSettings, MCPSettings
 
     # Initialize the app to ensure context is ready
     await fast_app.app.initialize()