fast-agent-mcp 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

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
@@ -242,16 +236,13 @@ async def create_agents_by_type(
                     config=config,
                     context=app_instance.context,
                     agents=router_agents,
-                    routing_instruction=agent_data.get("routing_instruction"),
+                    routing_instruction=agent_data.get("instruction"),
                 )
                 await router.initialize()
 
                 # 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

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":

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

mcp_agent/core/interactive_prompt.py

@@ -77,7 +77,7 @@ class InteractivePrompt:
         if agent not in available_agents:
             raise ValueError(f"No agent named '{agent}'")
 
-        # Create agent_types dictionary if not provided
+        # Ensure we track available agents in a set for fast lookup
         available_agents_set = set(available_agents)
 
         result = ""

mcp_agent/llm/augmented_llm.py

@@ -39,7 +39,6 @@ from mcp_agent.mcp.interfaces import (
 from mcp_agent.mcp.mcp_aggregator import MCPAggregator
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 from mcp_agent.mcp.prompt_render import render_multipart_message
-from mcp_agent.mcp.prompt_serialization import multipart_messages_to_delimited_format
 from mcp_agent.ui.console_display import ConsoleDisplay
 
 # Define type variables locally
@@ -148,7 +147,7 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
         """Apply the prompt and return the result as a Pydantic model, or None if coercion fails"""
         try:
             result: PromptMessageMultipart = await self.generate(prompt, request_params)
-            json_data = from_json(result.first_text(), allow_partial=True)
+            json_data = from_json(result.first_text().strip(), allow_partial=True)
             validated_model = model.model_validate(json_data)
             return cast("ModelT", validated_model), Prompt.assistant(json_data)
         except Exception as e:
@@ -435,16 +434,15 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
 
     async def _save_history(self, filename: str) -> None:
         """
-        Save the Message History to a file in a simple delimeted format.
+        Save the Message History to a file in a format determined by the file extension.
+
+        Uses JSON format for .json files (MCP SDK compatible format) and
+        delimited text format for other extensions.
         """
-        # Convert to delimited format
-        delimited_content = multipart_messages_to_delimited_format(
-            self._message_history,
-        )
+        from mcp_agent.mcp.prompt_serialization import save_messages_to_file
 
-        # Write to file
-        with open(filename, "w", encoding="utf-8") as f:
-            f.write("\n\n".join(delimited_content))
+        # Save messages using the unified save function that auto-detects format
+        save_messages_to_file(self._message_history, filename)
 
     @abstractmethod
     async def _apply_prompt_provider_specific(

mcp_agent/llm/augmented_llm_passthrough.py

@@ -143,7 +143,9 @@ class PassthroughLLM(AugmentedLLM):
 
         # TODO -- improve when we support Audio/Multimodal gen
         if self.is_tool_call(last_message):
-            return Prompt.assistant(await self.generate_str(last_message.first_text()))
+            result = Prompt.assistant(await self.generate_str(last_message.first_text()))
+            await self.show_assistant_message(result.first_text())
+            return result
 
         if last_message.first_text().startswith(FIXED_RESPONSE_INDICATOR):
             self._fixed_response = (

mcp_agent/llm/model_factory.py

@@ -103,7 +103,7 @@ class ModelFactory:
         "sonnet": "claude-3-7-sonnet-latest",
         "sonnet35": "claude-3-5-sonnet-latest",
         "sonnet37": "claude-3-7-sonnet-latest",
-        "claude": "claude-3-5-sonnet-latest",
+        "claude": "claude-3-7-sonnet-latest",
         "haiku": "claude-3-5-haiku-latest",
         "haiku3": "claude-3-haiku-20240307",
         "haiku35": "claude-3-5-haiku-latest",
@@ -188,24 +188,22 @@ class ModelFactory:
 
         # Create a factory function matching the updated attach_llm protocol
         def factory(
-            agent: Agent, 
-            request_params: Optional[RequestParams] = None, 
-            **kwargs
+            agent: Agent, request_params: Optional[RequestParams] = None, **kwargs
         ) -> AugmentedLLMProtocol:
             # Create base params with parsed model name
             base_params = RequestParams()
             base_params.model = config.model_name  # Use the parsed model name, not the alias
-            
+
             # Add reasoning effort if available
             if config.reasoning_effort:
                 kwargs["reasoning_effort"] = config.reasoning_effort.value
-            
+
             # Forward all arguments to LLM constructor
             llm_args = {
                 "agent": agent,
                 "model": config.model_name,
                 "request_params": request_params,
-                **kwargs
+                **kwargs,
             }
 
             llm: AugmentedLLMProtocol = llm_class(**llm_args)

mcp_agent/mcp/interfaces.py

@@ -136,6 +136,11 @@ class AgentProtocol(AugmentedLLMProtocol, Protocol):
 
     name: str
 
+    @property
+    def agent_type(self) -> str:
+        """Return the type of this agent"""
+        ...
+
     async def __call__(self, message: Union[str, PromptMessage, PromptMessageMultipart]) -> str:
         """Make the agent callable for sending messages directly."""
         ...

mcp_agent/mcp/prompt_serialization.py

@@ -110,6 +110,48 @@ def load_messages_from_json_file(file_path: str) -> List[PromptMessageMultipart]
     return json_to_multipart_messages(json_str)
 
 
+def save_messages_to_file(messages: List[PromptMessageMultipart], file_path: str) -> None:
+    """
+    Save PromptMessageMultipart objects to a file, with format determined by file extension.
+    
+    Uses JSON format for .json files and delimited text format for other extensions.
+    
+    Args:
+        messages: List of PromptMessageMultipart objects
+        file_path: Path to save the file
+    """
+    path_str = str(file_path).lower()
+    
+    if path_str.endswith(".json"):
+        # Use JSON format for .json files (MCP SDK compatible format)
+        save_messages_to_json_file(messages, file_path)
+    else:
+        # Use delimited text format for other extensions
+        save_messages_to_delimited_file(messages, file_path)
+
+
+def load_messages_from_file(file_path: str) -> List[PromptMessageMultipart]:
+    """
+    Load PromptMessageMultipart objects from a file, with format determined by file extension.
+    
+    Uses JSON format for .json files and delimited text format for other extensions.
+    
+    Args:
+        file_path: Path to the file
+        
+    Returns:
+        List of PromptMessageMultipart objects
+    """
+    path_str = str(file_path).lower()
+    
+    if path_str.endswith(".json"):
+        # Use JSON format for .json files (MCP SDK compatible format)
+        return load_messages_from_json_file(file_path)
+    else:
+        # Use delimited text format for other extensions
+        return load_messages_from_delimited_file(file_path)
+
+
 # -------------------------------------------------------------------------
 # Delimited Text Format Functions
 # -------------------------------------------------------------------------

mcp_agent/mcp/prompts/prompt_load.py

@@ -101,9 +101,57 @@ def create_resource_message(
 
 
 def load_prompt(file: Path) -> List[PromptMessage]:
-    template: PromptTemplate = PromptTemplateLoader().load_from_file(file)
-    return create_messages_with_resources(template.content_sections, [file])
+    """
+    Load a prompt from a file and return as PromptMessage objects.
+    
+    The loader uses file extension to determine the format:
+    - .json files are loaded as MCP SDK compatible JSON format
+    - All other files are loaded using the template-based delimited format
+    
+    Args:
+        file: Path to the prompt file
+        
+    Returns:
+        List of PromptMessage objects
+    """
+    file_str = str(file).lower()
+    
+    if file_str.endswith(".json"):
+        # JSON format (MCP SDK compatible)
+        from mcp_agent.mcp.prompt_serialization import load_messages_from_json_file
+        
+        # Load multipart messages and convert to flat messages
+        multipart_messages = load_messages_from_json_file(str(file))
+        messages = []
+        for mp in multipart_messages:
+            messages.extend(mp.from_multipart())
+        return messages
+    else:
+        # Template-based format (delimited text)
+        template: PromptTemplate = PromptTemplateLoader().load_from_file(file)
+        return create_messages_with_resources(template.content_sections, [file])
 
 
 def load_prompt_multipart(file: Path) -> List[PromptMessageMultipart]:
-    return PromptMessageMultipart.to_multipart(load_prompt(file))
+    """
+    Load a prompt from a file and return as PromptMessageMultipart objects.
+    
+    The loader uses file extension to determine the format:
+    - .json files are loaded as MCP SDK compatible JSON format
+    - All other files are loaded using the template-based delimited format
+    
+    Args:
+        file: Path to the prompt file
+        
+    Returns:
+        List of PromptMessageMultipart objects
+    """
+    file_str = str(file).lower()
+    
+    if file_str.endswith(".json"):
+        # JSON format (MCP SDK compatible)
+        from mcp_agent.mcp.prompt_serialization import load_messages_from_json_file
+        return load_messages_from_json_file(str(file))
+    else:
+        # Template-based format (delimited text)
+        return PromptMessageMultipart.to_multipart(load_prompt(file))