fast-agent-mcp 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

mcp_agent/core/fastagent.py

@@ -6,16 +6,17 @@ 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.direct_agent_app import DirectAgentApp
+from mcp_agent.core.agent_app import AgentApp
 from mcp_agent.core.direct_decorators import (
     agent as agent_decorator,
 )
@@ -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,29 +136,59 @@ 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
-        self._load_config()
 
-        # Create the MCPApp with the config
-        self.app = MCPApp(
-            name=name,
-            settings=Settings(**self.config) if hasattr(self, "config") else None,
-        )
+        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,
+                "YAML Parsing Error",
+                "There was an error parsing the config or secrets YAML configuration file.",
+            )
+            raise SystemExit(1)
 
         # 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:
@@ -159,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
@@ -196,7 +255,42 @@ class FastAgent:
                 )
 
                 # Create a wrapper with all agents for simplified access
-                wrapper = DirectAgentApp(active_agents)
+                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:
@@ -215,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}")
 
@@ -297,9 +392,67 @@ class FastAgent:
                 e,
                 "User requested exit",
             )
+        elif isinstance(e, asyncio.CancelledError):
+            handle_error(
+                e,
+                "Cancelled",
+                "The operation was cancelled.",
+            )
         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",
@@ -310,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")
@@ -318,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/mcp_content.py

@@ -14,6 +14,8 @@ from mcp.types import (
     BlobResourceContents,
     EmbeddedResource,
     ImageContent,
+    ReadResourceResult,
+    ResourceContents,
     TextContent,
     TextResourceContents,
 )
@@ -25,6 +27,9 @@ from mcp_agent.mcp.mime_utils import (
     is_image_mime_type,
 )
 
+# Type for all MCP content types
+MCPContentType = Union[TextContent, ImageContent, EmbeddedResource, ResourceContents]
+
 
 def MCPText(
     text: str,
@@ -147,7 +152,8 @@ def MCPFile(
 
 
 def MCPPrompt(
-    *content_items: Union[dict, str, Path, bytes], role: Literal["user", "assistant"] = "user"
+    *content_items: Union[dict, str, Path, bytes, MCPContentType, 'EmbeddedResource', 'ReadResourceResult'], 
+    role: Literal["user", "assistant"] = "user"
 ) -> List[dict]:
     """
     Create one or more prompt messages with various content types.
@@ -158,6 +164,11 @@ def MCPPrompt(
     - File paths with text mime types or other mime types become EmbeddedResource
     - Dicts with role and content are passed through unchanged
     - Raw bytes become ImageContent
+    - TextContent objects are used directly
+    - ImageContent objects are used directly
+    - EmbeddedResource objects are used directly
+    - ResourceContent objects are wrapped in EmbeddedResource
+    - ReadResourceResult objects are expanded into multiple messages
 
     Args:
         *content_items: Content items of various types
@@ -173,9 +184,9 @@ def MCPPrompt(
             # Already a fully formed message
             result.append(item)
         elif isinstance(item, str):
-            # Simple text content (that's not a file path)
+            # Simple text content
             result.append(MCPText(item, role=role))
-        elif isinstance(item, Path) or isinstance(item, str):
+        elif isinstance(item, Path):
             # File path - determine the content type based on mime type
             path_str = str(item)
             mime_type = guess_mime_type(path_str)
@@ -189,6 +200,28 @@ def MCPPrompt(
         elif isinstance(item, bytes):
             # Raw binary data, assume image
             result.append(MCPImage(data=item, role=role))
+        elif isinstance(item, TextContent):
+            # Already a TextContent, wrap in a message
+            result.append({"role": role, "content": item})
+        elif isinstance(item, ImageContent):
+            # Already an ImageContent, wrap in a message
+            result.append({"role": role, "content": item})
+        elif isinstance(item, EmbeddedResource):
+            # Already an EmbeddedResource, wrap in a message
+            result.append({"role": role, "content": item})
+        elif hasattr(item, 'type') and item.type == 'resource' and hasattr(item, 'resource'):
+            # Looks like an EmbeddedResource but may not be the exact class
+            result.append({"role": role, "content": EmbeddedResource(type="resource", resource=item.resource)})
+        elif isinstance(item, ResourceContents):
+            # It's a ResourceContents, wrap it in an EmbeddedResource
+            result.append({"role": role, "content": EmbeddedResource(type="resource", resource=item)})
+        elif isinstance(item, ReadResourceResult):
+            # It's a ReadResourceResult, convert each resource content
+            for resource_content in item.contents:
+                result.append({
+                    "role": role, 
+                    "content": EmbeddedResource(type="resource", resource=resource_content)
+                })
         else:
             # Try to convert to string
             result.append(MCPText(str(item), role=role))
@@ -196,12 +229,12 @@ def MCPPrompt(
     return result
 
 
-def User(*content_items) -> List[dict]:
+def User(*content_items: Union[dict, str, Path, bytes, MCPContentType, 'EmbeddedResource', 'ReadResourceResult']) -> List[dict]:
     """Create user message(s) with various content types."""
     return MCPPrompt(*content_items, role="user")
 
 
-def Assistant(*content_items) -> List[dict]:
+def Assistant(*content_items: Union[dict, str, Path, bytes, MCPContentType, 'EmbeddedResource', 'ReadResourceResult']) -> List[dict]:
     """Create assistant message(s) with various content types."""
     return MCPPrompt(*content_items, role="assistant")
 

mcp_agent/core/prompt.py

@@ -2,14 +2,15 @@
 Prompt class for easily creating and working with MCP prompt content.
 """
 
-from typing import List, Literal
+from pathlib import Path
+from typing import List, Literal, Union
 
 from mcp.types import PromptMessage
 
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 # Import our content helper functions
-from .mcp_content import Assistant, MCPPrompt, User
+from .mcp_content import Assistant, MCPContentType, MCPPrompt, User
 
 
 class Prompt:
@@ -25,34 +26,75 @@ class Prompt:
     - Strings become TextContent
     - Image file paths become ImageContent
     - Other file paths become EmbeddedResource
+    - TextContent objects are used directly
+    - ImageContent objects are used directly
+    - EmbeddedResource objects are used directly 
     - Pre-formatted messages pass through unchanged
     """
 
     @classmethod
-    def user(cls, *content_items) -> PromptMessageMultipart:
+    def user(cls, *content_items: Union[str, Path, bytes, dict, MCPContentType, PromptMessage, PromptMessageMultipart]) -> PromptMessageMultipart:
         """
         Create a user PromptMessageMultipart with various content items.
 
         Args:
-            *content_items: Content items (strings, file paths, etc.)
+            *content_items: Content items in various formats:
+                - Strings: Converted to TextContent
+                - Path objects: Converted based on file type (image/text/binary)
+                - Bytes: Treated as image data
+                - Dicts with role/content: Content extracted
+                - TextContent: Used directly
+                - ImageContent: Used directly
+                - EmbeddedResource: Used directly
+                - PromptMessage: Content extracted
+                - PromptMessageMultipart: Content extracted with role changed to user
 
         Returns:
             A PromptMessageMultipart with user role and the specified content
         """
+        # Handle PromptMessage and PromptMessageMultipart directly
+        if len(content_items) == 1:
+            item = content_items[0]
+            if isinstance(item, PromptMessage):
+                return PromptMessageMultipart(role="user", content=[item.content])
+            elif isinstance(item, PromptMessageMultipart):
+                # Keep the content but change role to user
+                return PromptMessageMultipart(role="user", content=item.content)
+                
+        # Use the original implementation for other types
         messages = User(*content_items)
         return PromptMessageMultipart(role="user", content=[msg["content"] for msg in messages])
 
     @classmethod
-    def assistant(cls, *content_items) -> PromptMessageMultipart:
+    def assistant(cls, *content_items: Union[str, Path, bytes, dict, MCPContentType, PromptMessage, PromptMessageMultipart]) -> PromptMessageMultipart:
         """
         Create an assistant PromptMessageMultipart with various content items.
 
         Args:
-            *content_items: Content items (strings, file paths, etc.)
+            *content_items: Content items in various formats:
+                - Strings: Converted to TextContent
+                - Path objects: Converted based on file type (image/text/binary)
+                - Bytes: Treated as image data
+                - Dicts with role/content: Content extracted
+                - TextContent: Used directly
+                - ImageContent: Used directly
+                - EmbeddedResource: Used directly
+                - PromptMessage: Content extracted
+                - PromptMessageMultipart: Content extracted with role changed to assistant
 
         Returns:
             A PromptMessageMultipart with assistant role and the specified content
         """
+        # Handle PromptMessage and PromptMessageMultipart directly
+        if len(content_items) == 1:
+            item = content_items[0]
+            if isinstance(item, PromptMessage):
+                return PromptMessageMultipart(role="assistant", content=[item.content])
+            elif isinstance(item, PromptMessageMultipart):
+                # Keep the content but change role to assistant
+                return PromptMessageMultipart(role="assistant", content=item.content)
+                
+        # Use the original implementation for other types
         messages = Assistant(*content_items)
         return PromptMessageMultipart(
             role="assistant", content=[msg["content"] for msg in messages]
@@ -60,18 +102,38 @@ class Prompt:
 
     @classmethod
     def message(
-        cls, *content_items, role: Literal["user", "assistant"] = "user"
+        cls, *content_items: Union[str, Path, bytes, dict, MCPContentType, PromptMessage, PromptMessageMultipart], 
+        role: Literal["user", "assistant"] = "user"
     ) -> PromptMessageMultipart:
         """
         Create a PromptMessageMultipart with the specified role and content items.
 
         Args:
-            *content_items: Content items (strings, file paths, etc.)
+            *content_items: Content items in various formats:
+                - Strings: Converted to TextContent
+                - Path objects: Converted based on file type (image/text/binary)
+                - Bytes: Treated as image data
+                - Dicts with role/content: Content extracted
+                - TextContent: Used directly
+                - ImageContent: Used directly
+                - EmbeddedResource: Used directly
+                - PromptMessage: Content extracted
+                - PromptMessageMultipart: Content extracted with role changed as specified
             role: Role for the message (user or assistant)
 
         Returns:
             A PromptMessageMultipart with the specified role and content
         """
+        # Handle PromptMessage and PromptMessageMultipart directly
+        if len(content_items) == 1:
+            item = content_items[0]
+            if isinstance(item, PromptMessage):
+                return PromptMessageMultipart(role=role, content=[item.content])
+            elif isinstance(item, PromptMessageMultipart):
+                # Keep the content but change role as specified
+                return PromptMessageMultipart(role=role, content=item.content)
+                
+        # Use the original implementation for other types
         messages = MCPPrompt(*content_items, role=role)
         return PromptMessageMultipart(
             role=messages[0]["role"] if messages else role,

mcp_agent/core/validation.py

@@ -231,7 +231,7 @@ def get_dependencies_groups(
             dependencies[name].update(agent_data.get("parallel_agents", []))
         elif agent_type == AgentType.CHAIN.value:
             # Chain agents depend on the agents in their sequence
-            dependencies[name].update(agent_data.get("chain_agents", []))
+            dependencies[name].update(agent_data.get("sequence", []))
         elif agent_type == AgentType.ROUTER.value:
             # Router agents depend on the agents they route to
             dependencies[name].update(agent_data.get("router_agents", []))