fast-agent-mcp 0.2.4__tar.gz → 0.2.5__tar.gz

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/.gitignore

@@ -184,3 +184,9 @@ example-outputs/
 
 tests/integration/prompt-state/simple.txt
 tests/integration/workflow/router/fastagent.jsonl
+tests/e2e/smoke/weather_location.txt
+tests/integration/resources/fastagent.jsonl
+tests/integration/workflow/orchestrator/fastagent.jsonl
+fastagent.jsonl
+tests/integration/resources/fastagent.jsonl
+fastagent.jsonl

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.4
+Version: 0.2.5
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -244,7 +244,7 @@ Description-Content-Type: text/markdown
 <a href="https://pypi.org/project/fast-agent-mcp/"><img src="https://img.shields.io/pypi/v/fast-agent-mcp?color=%2334D058&label=pypi" /></a>
 <a href="#"><img src="https://github.com/evalstate/fast-agent/actions/workflows/main-checks.yml/badge.svg" /></a>
 <a href="https://github.com/evalstate/fast-agent/issues"><img src="https://img.shields.io/github/issues-raw/evalstate/fast-agent" /></a>
-<a href="https://lmai.link/discord/mcp-agent"><img src="https://shields.io/discord/1089284610329952357" alt="discord" /></a>
+<a href="https://discord.gg/xg5cJ7ndN6"><img src="https://img.shields.io/discord/1358470293990936787" alt="discord" /></a>
 <img alt="Pepy Total Downloads" src="https://img.shields.io/pepy/dt/fast-agent-mcp?label=pypi%20%7C%20downloads"/>
 <a href="https://github.com/evalstate/fast-agent-mcp/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/fast-agent-mcp" /></a>
 </p>

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/README.md

@@ -2,7 +2,7 @@
 <a href="https://pypi.org/project/fast-agent-mcp/"><img src="https://img.shields.io/pypi/v/fast-agent-mcp?color=%2334D058&label=pypi" /></a>
 <a href="#"><img src="https://github.com/evalstate/fast-agent/actions/workflows/main-checks.yml/badge.svg" /></a>
 <a href="https://github.com/evalstate/fast-agent/issues"><img src="https://img.shields.io/github/issues-raw/evalstate/fast-agent" /></a>
-<a href="https://lmai.link/discord/mcp-agent"><img src="https://shields.io/discord/1089284610329952357" alt="discord" /></a>
+<a href="https://discord.gg/xg5cJ7ndN6"><img src="https://img.shields.io/discord/1358470293990936787" alt="discord" /></a>
 <img alt="Pepy Total Downloads" src="https://img.shields.io/pepy/dt/fast-agent-mcp?label=pypi%20%7C%20downloads"/>
 <a href="https://github.com/evalstate/fast-agent-mcp/blob/main/LICENSE"><img src="https://img.shields.io/pypi/l/fast-agent-mcp" /></a>
 </p>

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.4"
+version = "0.2.5"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/src/mcp_agent/agents/base_agent.py

@@ -120,28 +120,30 @@ class BaseAgent(MCPAggregator, AgentProtocol):
         llm_factory: Union[Type[AugmentedLLMProtocol], Callable[..., AugmentedLLMProtocol]],
         model: Optional[str] = None,
         request_params: Optional[RequestParams] = None,
-        **additional_kwargs
+        **additional_kwargs,
     ) -> AugmentedLLMProtocol:
         """
         Create and attach an LLM instance to this agent.
-        
+
         Parameters have the following precedence (highest to lowest):
         1. Explicitly passed parameters to this method
         2. Agent's default_request_params
         3. LLM's default values
-        
+
         Args:
             llm_factory: A class or callable that constructs an AugmentedLLM
             model: Optional model name override
             request_params: Optional request parameters override
             **additional_kwargs: Additional parameters passed to the LLM constructor
-            
+
         Returns:
             The created LLM instance
         """
         # Start with agent's default params
-        effective_params = self._default_request_params.model_copy() if self._default_request_params else None
-        
+        effective_params = (
+            self._default_request_params.model_copy() if self._default_request_params else None
+        )
+
         # Override with explicitly passed request_params
         if request_params:
             if effective_params:
@@ -151,18 +153,16 @@ class BaseAgent(MCPAggregator, AgentProtocol):
                         setattr(effective_params, k, v)
             else:
                 effective_params = request_params
-        
+
         # Override model if explicitly specified
         if model and effective_params:
             effective_params.model = model
-        
+
         # Create the LLM instance
         self._llm = llm_factory(
-            agent=self,
-            request_params=effective_params,
-            **additional_kwargs
+            agent=self, request_params=effective_params, context=self._context, **additional_kwargs
         )
-        
+
         return self._llm
 
     async def shutdown(self) -> None:
@@ -468,7 +468,7 @@ class BaseAgent(MCPAggregator, AgentProtocol):
 
         # Get the prompt - this will search all servers if needed
         self.logger.debug(f"Loading prompt '{prompt_name}'")
-        prompt_result = await self.get_prompt(prompt_name, arguments, server_name)
+        prompt_result: GetPromptResult = await self.get_prompt(prompt_name, arguments, server_name)
 
         if not prompt_result or not prompt_result.messages:
             error_msg = f"Prompt '{prompt_name}' could not be found or contains no messages"

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/src/mcp_agent/cli/main.py

@@ -62,6 +62,7 @@ def main(
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose mode"),
     quiet: bool = typer.Option(False, "--quiet", "-q", help="Disable output"),
     color: bool = typer.Option(True, "--color/--no-color", help="Enable/disable color output"),
+    version: bool = typer.Option(False, "--version", help="Show version and exit"),
 ) -> None:
     """FastAgent CLI - Build effective agents using Model Context Protocol (MCP).
 
@@ -70,6 +71,16 @@ def main(
     application.verbosity = 1 if verbose else 0 if not quiet else -1
     application.console = application.console if color else None
 
+    # Handle version flag
+    if version:
+        from importlib.metadata import version as get_version
+        try:
+            app_version = get_version("fast-agent-mcp")
+        except:  # noqa: E722
+            app_version = "unknown"
+        console.print(f"fast-agent-mcp v{app_version}")
+        raise typer.Exit()
+
     # Show welcome message if no command was invoked
     if ctx.invoked_subcommand is None:
         show_welcome()

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/src/mcp_agent/config.py

@@ -40,7 +40,7 @@ class MCPRootSettings(BaseModel):
     @classmethod
     def validate_uri(cls, v: str) -> str:
         """Validate that the URI starts with file:// (required by specification 2024-11-05)"""
-        if not v.startswith("file://"):
+        if v and not v.startswith("file://"):
             raise ValueError("Root URI must start with file://")
         return v
 
@@ -276,9 +276,9 @@ class Settings(BaseSettings):
         # Check current directory and parent directories
         while current_dir != current_dir.parent:
             for filename in [
+                "fastagent.config.yaml",
                 "mcp-agent.config.yaml",
                 "mcp_agent.config.yaml",
-                "fastagent.config.yaml",
             ]:
                 config_path = current_dir / filename
                 if config_path.exists():
@@ -306,15 +306,33 @@ def get_settings(config_path: str | None = None) -> Settings:
         return merged
 
     global _settings
-    if _settings:
+
+    # If we have a specific config path, always reload settings
+    # This ensures each test gets its own config
+    if config_path:
+        # Reset for the new path
+        _settings = None
+    elif _settings:
+        # Use cached settings only for no specific path
         return _settings
 
-    config_file = Path(config_path) if config_path else Settings.find_config()
+    # Handle config path - convert string to Path if needed
+    if config_path:
+        config_file = Path(config_path)
+        # If it's a relative path and doesn't exist, try finding it
+        if not config_file.is_absolute() and not config_file.exists():
+            # Try resolving against current directory first
+            resolved_path = Path.cwd() / config_file.name
+            if resolved_path.exists():
+                config_file = resolved_path
+    else:
+        config_file = Settings.find_config()
+
     merged_settings = {}
 
     if config_file:
         if not config_file.exists():
-            pass
+            print(f"Warning: Specified config file does not exist: {config_file}")
         else:
             import yaml  # pylint: disable=C0415
 
@@ -326,11 +344,14 @@ def get_settings(config_path: str | None = None) -> Settings:
             # but stop after finding the first one
             current_dir = config_file.parent
             found_secrets = False
+            # Start with the absolute path of the config file's directory
+            current_dir = config_file.parent.resolve()
+
             while current_dir != current_dir.parent and not found_secrets:
                 for secrets_filename in [
+                    "fastagent.secrets.yaml",
                     "mcp-agent.secrets.yaml",
                     "mcp_agent.secrets.yaml",
-                    "fastagent.secrets.yaml",
                 ]:
                     secrets_file = current_dir / secrets_filename
                     if secrets_file.exists():
@@ -340,7 +361,8 @@ def get_settings(config_path: str | None = None) -> Settings:
                             found_secrets = True
                             break
                 if not found_secrets:
-                    current_dir = current_dir.parent
+                    # Get the absolute path of the parent directory
+                    current_dir = current_dir.parent.resolve()
 
             _settings = Settings(**merged_settings)
             return _settings

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/src/mcp_agent/context.py

@@ -234,5 +234,7 @@ def get_current_context() -> Context:
 def get_current_config():
     """
     Get the current application config.
+    
+    Returns the context config if available, otherwise falls back to global settings.
     """
     return get_current_context().config or get_settings()

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/src/mcp_agent/core/direct_factory.py

@@ -148,10 +148,7 @@ async def create_agents_by_type(
 
                 # Attach LLM to the agent
                 llm_factory = model_factory_func(model=config.model)
-                await agent.attach_llm(
-                    llm_factory,
-                    request_params=config.default_request_params
-                )
+                await agent.attach_llm(llm_factory, request_params=config.default_request_params)
                 result_agents[name] = agent
 
             elif agent_type == AgentType.ORCHESTRATOR:
@@ -185,8 +182,7 @@ async def create_agents_by_type(
                 # Attach LLM to the orchestrator
                 llm_factory = model_factory_func(model=config.model)
                 await orchestrator.attach_llm(
-                    llm_factory,
-                    request_params=config.default_request_params
+                    llm_factory, request_params=config.default_request_params
                 )
 
                 result_agents[name] = orchestrator
@@ -201,9 +197,7 @@ async def create_agents_by_type(
                     # Create default fan-in agent with auto-generated name
                     fan_in_name = f"{name}_fan_in"
                     fan_in_agent = await _create_default_fan_in_agent(
-                        fan_in_name,
-                        app_instance.context, 
-                        model_factory_func
+                        fan_in_name, app_instance.context, model_factory_func
                     )
                     # Add to result_agents so it's registered properly
                     result_agents[fan_in_name] = fan_in_agent
@@ -248,10 +242,7 @@ async def create_agents_by_type(
 
                 # Attach LLM to the router
                 llm_factory = model_factory_func(model=config.model)
-                await router.attach_llm(
-                    llm_factory,
-                    request_params=config.default_request_params
-                )
+                await router.attach_llm(llm_factory, request_params=config.default_request_params)
                 result_agents[name] = router
 
             elif agent_type == AgentType.CHAIN:
@@ -459,7 +450,7 @@ async def _create_default_fan_in_agent(
     default_config = AgentConfig(
         name=fan_in_name,
         model="passthrough",
-        instruction="You are a passthrough agent that combines outputs from parallel agents."
+        instruction="You are a passthrough agent that combines outputs from parallel agents.",
     )
 
     # Create and initialize the default agent

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/src/mcp_agent/core/enhanced_prompt.py

@@ -291,7 +291,7 @@ async def get_enhanced_input(
                 return f"SELECT_PROMPT:{cmd_parts[1].strip()}"
             elif cmd == "exit":
                 return "EXIT"
-            elif cmd == "stop":
+            elif cmd.lower() == "stop":
                 return "STOP"
 
         # Agent switching
@@ -420,7 +420,7 @@ async def get_argument_input(
             prompt_session.app.exit()
 
 
-async def handle_special_commands(command, agent_app=None):
+async def handle_special_commands(command: str, agent_app=None):
     """Handle special input commands."""
     # Quick guard for empty or None commands
     if not command:
@@ -450,7 +450,7 @@ async def handle_special_commands(command, agent_app=None):
         print("\033c", end="")
         return True
 
-    elif command == "EXIT":
+    elif command.upper() == "EXIT":
         raise PromptExitError("User requested to exit fast-agent session")
 
     elif command == "LIST_AGENTS":

{fast_agent_mcp-0.2.4 → fast_agent_mcp-0.2.5}/src/mcp_agent/core/fastagent.py

@@ -6,14 +6,15 @@ directly creates Agent instances without proxies.
 
 import argparse
 import asyncio
-import os
+import sys
 from contextlib import asynccontextmanager
+from importlib.metadata import version as get_version
 from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, TypeVar
 
 import yaml
 
+from mcp_agent import config
 from mcp_agent.app import MCPApp
-from mcp_agent.config import Settings
 from mcp_agent.context import Context
 from mcp_agent.core.agent_app import AgentApp
 from mcp_agent.core.direct_decorators import (
@@ -70,7 +71,7 @@ class FastAgent:
     def __init__(
         self,
         name: str,
-        config_path: Optional[str] = None,
+        config_path: str | None = None,
         ignore_unknown_args: bool = False,
     ) -> None:
         """
@@ -101,6 +102,33 @@ class FastAgent:
             action="store_true",
             help="Disable progress display, tool and message logging for cleaner output",
         )
+        parser.add_argument(
+            "--version",
+            action="store_true",
+            help="Show version and exit",
+        )
+        parser.add_argument(
+            "--server",
+            action="store_true",
+            help="Run as an MCP server",
+        )
+        parser.add_argument(
+            "--transport",
+            choices=["sse", "stdio"],
+            default="sse",
+            help="Transport protocol to use when running as a server (sse or stdio)",
+        )
+        parser.add_argument(
+            "--port",
+            type=int,
+            default=8000,
+            help="Port to use when running as a server with SSE transport",
+        )
+        parser.add_argument(
+            "--host",
+            default="0.0.0.0",
+            help="Host address to bind to when running as a server with SSE transport",
+        )
 
         if ignore_unknown_args:
             known_args, _ = parser.parse_known_args()
@@ -108,10 +136,28 @@ class FastAgent:
         else:
             self.args = parser.parse_args()
 
+        # Handle version flag
+        if self.args.version:
+            try:
+                app_version = get_version("fast-agent-mcp")
+            except:  # noqa: E722
+                app_version = "unknown"
+            print(f"fast-agent-mcp v{app_version}")
+            sys.exit(0)
+
         self.name = name
         self.config_path = config_path
+
         try:
+            # Load configuration directly for this instance
             self._load_config()
+
+            # Create the app with our local settings
+            self.app = MCPApp(
+                name=name,
+                settings=config.Settings(**self.config) if hasattr(self, "config") else None,
+            )
+
         except yaml.parser.ParserError as e:
             handle_error(
                 e,
@@ -119,25 +165,30 @@ class FastAgent:
                 "There was an error parsing the config or secrets YAML configuration file.",
             )
             raise SystemExit(1)
-        # Create the MCPApp with the config
-        self.app = MCPApp(
-            name=name,
-            settings=Settings(**self.config) if hasattr(self, "config") else None,
-        )
 
         # Dictionary to store agent configurations from decorators
         self.agents: Dict[str, Dict[str, Any]] = {}
 
     def _load_config(self) -> None:
-        """Load configuration from YAML file"""
-        if self.config_path:
-            with open(self.config_path) as f:
-                self.config = yaml.safe_load(f) or {}
-        elif os.path.exists("fastagent.config.yaml"):
-            with open("fastagent.config.yaml") as f:
-                self.config = yaml.safe_load(f) or {}
-        else:
-            self.config = {}
+        """Load configuration from YAML file including secrets using get_settings
+        but without relying on the global cache."""
+
+        # Import but make a local copy to avoid affecting the global state
+        from mcp_agent.config import _settings, get_settings
+
+        # Temporarily clear the global settings to ensure a fresh load
+        old_settings = _settings
+        _settings = None
+
+        try:
+            # Use get_settings to load config - this handles all paths and secrets merging
+            settings = get_settings(self.config_path)
+
+            # Convert to dict for backward compatibility
+            self.config = settings.model_dump() if settings else {}
+        finally:
+            # Restore the original global settings
+            _settings = old_settings
 
     @property
     def context(self) -> Context:
@@ -166,16 +217,17 @@ class FastAgent:
         quiet_mode = hasattr(self, "args") and self.args.quiet
 
         try:
-            async with self.app.run() as agent_app:
+            async with self.app.run():
                 # Apply quiet mode if requested
                 if (
                     quiet_mode
-                    and hasattr(agent_app.context, "config")
-                    and hasattr(agent_app.context.config, "logger")
+                    and hasattr(self.app.context, "config")
+                    and hasattr(self.app.context.config, "logger")
                 ):
-                    agent_app.context.config.logger.progress_display = False
-                    agent_app.context.config.logger.show_chat = False
-                    agent_app.context.config.logger.show_tools = False
+                    # Update our app's config directly
+                    self.app.context.config.logger.progress_display = False
+                    self.app.context.config.logger.show_chat = False
+                    self.app.context.config.logger.show_tools = False
 
                     # Directly disable the progress display singleton
                     from mcp_agent.progress_display import progress_display
@@ -205,6 +257,41 @@ class FastAgent:
                 # Create a wrapper with all agents for simplified access
                 wrapper = AgentApp(active_agents)
 
+                # Handle command line options that should be processed after agent initialization
+
+                # Handle --server option
+                if hasattr(self, "args") and self.args.server:
+                    try:
+                        # Print info message if not in quiet mode
+                        if not quiet_mode:
+                            print(f"Starting FastAgent '{self.name}' in server mode")
+                            print(f"Transport: {self.args.transport}")
+                            if self.args.transport == "sse":
+                                print(f"Listening on {self.args.host}:{self.args.port}")
+                            print("Press Ctrl+C to stop")
+
+                        # Create the MCP server
+                        from mcp_agent.mcp_server import AgentMCPServer
+
+                        mcp_server = AgentMCPServer(
+                            agent_app=wrapper,
+                            server_name=f"{self.name}-MCP-Server",
+                        )
+
+                        # Run the server directly (this is a blocking call)
+                        await mcp_server.run_async(
+                            transport=self.args.transport, host=self.args.host, port=self.args.port
+                        )
+                    except KeyboardInterrupt:
+                        if not quiet_mode:
+                            print("\nServer stopped by user (Ctrl+C)")
+                    except Exception as e:
+                        if not quiet_mode:
+                            print(f"\nServer stopped with error: {e}")
+
+                    # Exit after server shutdown
+                    raise SystemExit(0)
+
                 # Handle direct message sending if --agent and --message are provided
                 if hasattr(self, "args") and self.args.agent and self.args.message:
                     agent_name = self.args.agent
@@ -222,7 +309,8 @@ class FastAgent:
                         agent = active_agents[agent_name]
                         response = await agent.send(message)
 
-                        # Print the response in quiet mode
+                        # In quiet mode, just print the raw response
+                        # The chat display should already be turned off by the configuration
                         if self.args.quiet:
                             print(f"{response}")
 
@@ -313,6 +401,58 @@ class FastAgent:
         else:
             handle_error(e, error_type or "Error", "An unexpected error occurred.")
 
+    async def start_server(
+        self,
+        transport: str = "sse",
+        host: str = "0.0.0.0",
+        port: int = 8000,
+        server_name: Optional[str] = None,
+        server_description: Optional[str] = None,
+    ) -> None:
+        """
+        Start the application as an MCP server.
+        This method initializes agents and exposes them through an MCP server.
+        It is a blocking method that runs until the server is stopped.
+
+        Args:
+            transport: Transport protocol to use ("stdio" or "sse")
+            host: Host address for the server when using SSE
+            port: Port for the server when using SSE
+            server_name: Optional custom name for the MCP server
+            server_description: Optional description for the MCP server
+        """
+        # This method simply updates the command line arguments and uses run()
+        # to ensure we follow the same initialization path for all operations
+
+        # Store original args
+        original_args = None
+        if hasattr(self, "args"):
+            original_args = self.args
+
+        # Create our own args object with server settings
+        from argparse import Namespace
+
+        self.args = Namespace()
+        self.args.server = True
+        self.args.transport = transport
+        self.args.host = host
+        self.args.port = port
+        self.args.quiet = (
+            original_args.quiet if original_args and hasattr(original_args, "quiet") else False
+        )
+        self.args.model = None
+        if hasattr(original_args, "model"):
+            self.args.model = original_args.model
+
+        # Run the application, which will detect the server flag and start server mode
+        async with self.run():
+            pass  # This won't be reached due to SystemExit in run()
+
+        # Restore original args (if we get here)
+        if original_args:
+            self.args = original_args
+
+    # Keep run_with_mcp_server for backward compatibility
     async def run_with_mcp_server(
         self,
         transport: str = "sse",
@@ -323,6 +463,8 @@ class FastAgent:
     ) -> None:
         """
         Run the application and expose agents through an MCP server.
+        This method is kept for backward compatibility.
+        For new code, use start_server() instead.
 
         Args:
             transport: Transport protocol to use ("stdio" or "sse")
@@ -331,26 +473,40 @@ class FastAgent:
             server_name: Optional custom name for the MCP server
             server_description: Optional description for the MCP server
         """
-        from mcp_agent.mcp_server import AgentMCPServer
-
-        async with self.run() as agent_app:
-            # Create the MCP server
-            mcp_server = AgentMCPServer(
-                agent_app=agent_app,
-                server_name=server_name or f"{self.name}-MCP-Server",
-                server_description=server_description,
-            )
-
-            # Run the MCP server in a separate task
-            server_task = asyncio.create_task(
-                mcp_server.run_async(transport=transport, host=host, port=port)
-            )
+        await self.start_server(
+            transport=transport,
+            host=host,
+            port=port,
+            server_name=server_name,
+            server_description=server_description,
+        )
 
-            try:
-                # Wait for the server task to complete (or be cancelled)
-                await server_task
-            except asyncio.CancelledError:
-                # Propagate cancellation
-                server_task.cancel()
-                await asyncio.gather(server_task, return_exceptions=True)
-                raise
+    async def main(self):
+        """
+        Helper method for checking if server mode was requested.
+
+        Usage:
+        ```python
+        fast = FastAgent("My App")
+
+        @fast.agent(...)
+        async def app_main():
+            # Check if server mode was requested
+            # This doesn't actually do anything - the check happens in run()
+            # But it provides a way for application code to know if server mode
+            # was requested for conditionals
+            is_server_mode = hasattr(self, "args") and self.args.server
+
+            # Normal run - this will handle server mode automatically if requested
+            async with fast.run() as agent:
+                # This code only executes for normal mode
+                # Server mode will exit before reaching here
+                await agent.send("Hello")
+        ```
+
+        Returns:
+            bool: True if --server flag is set, False otherwise
+        """
+        # Just check if the flag is set, no action here
+        # The actual server code will be handled by run()
+        return hasattr(self, "args") and self.args.server