fast-agent-mcp 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

mcp_agent/mcp/mcp_connection_manager.py

@@ -21,12 +21,13 @@ from mcp.client.stdio import (
     get_default_environment,
 )
 from mcp.client.sse import sse_client
-from mcp.types import JSONRPCMessage
+from mcp.types import JSONRPCMessage, ServerCapabilities
 
 from mcp_agent.config import MCPServerSettings
 from mcp_agent.core.exceptions import ServerInitializationError
 from mcp_agent.event_progress import ProgressAction
 from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.mcp_agent_client_session import MCPAgentClientSession
 from mcp_agent.mcp.stdio import stdio_client_with_rich_stderr
 from mcp_agent.context_dependent import ContextDependent
 
@@ -107,8 +108,9 @@ class ServerConnection:
         Must be called within an async context.
         """
 
-        await self.session.initialize()
+        result = await self.session.initialize()
 
+        self.server_capabilities = result.capabilities
         # If there's an init hook, run it
         if self._init_hook:
             logger.info(f"{self.server_name}: Executing init hook.")
@@ -333,6 +335,15 @@ class MCPConnectionManager(ContextDependent):
 
         return server_conn
 
+    async def get_server_capabilities(
+        self, server_name: str
+    ) -> ServerCapabilities | None:
+        """Get the capabilities of a specific server."""
+        server_conn = await self.get_server(
+            server_name, client_session_factory=MCPAgentClientSession
+        )
+        return server_conn.server_capabilities if server_conn else None
+
     async def disconnect_server(self, server_name: str) -> None:
         """
         Disconnect a specific server if it's running under this connection manager.

mcp_agent/mcp_server/__init__.py

@@ -0,0 +1,4 @@
+# Import and re-export AgentMCPServer to avoid circular imports
+from mcp_agent.mcp_server.agent_server import AgentMCPServer
+
+__all__ = ["AgentMCPServer"]

mcp_agent/mcp_server/agent_server.py

@@ -0,0 +1,121 @@
+# src/mcp_agent/mcp_server/agent_server.py
+
+from mcp.server.fastmcp import FastMCP
+
+# Remove circular import
+from mcp_agent.core.agent_app import AgentApp
+from mcp.server.fastmcp import Context as MCPContext
+
+
+class AgentMCPServer:
+    """Exposes FastAgent agents as MCP tools through an MCP server."""
+
+    def __init__(
+        self,
+        agent_app: AgentApp,
+        server_name: str = "FastAgent-MCP-Server",
+        server_description: str = None,
+    ):
+        self.agent_app = agent_app
+        self.mcp_server = FastMCP(
+            name=server_name,
+            instructions=server_description
+            or f"This server provides access to {len(agent_app.agents)} agents",
+        )
+        self.setup_tools()
+
+    def setup_tools(self):
+        """Register all agents as MCP tools."""
+        for agent_name, agent_proxy in self.agent_app._agents.items():
+            self.register_agent_tools(agent_name, agent_proxy)
+
+    def register_agent_tools(self, agent_name: str, agent_proxy):
+        """Register tools for a specific agent."""
+
+        # Basic send message tool
+        @self.mcp_server.tool(
+            name=f"{agent_name}.send",
+            description=f"Send a message to the {agent_name} agent",
+        )
+        async def send_message(message: str, ctx: MCPContext) -> str:
+            """Send a message to the agent and return its response."""
+
+            # Get the agent's context
+            agent_context = None
+            if hasattr(agent_proxy, "_agent") and hasattr(
+                agent_proxy._agent, "context"
+            ):
+                agent_context = agent_proxy._agent.context
+
+            # Define the function to execute
+            async def execute_send():
+                return await agent_proxy.send(message)
+
+            # Execute with bridged context
+            if agent_context and ctx:
+                return await self.with_bridged_context(agent_context, ctx, execute_send)
+            else:
+                return await execute_send()
+
+    def run(self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000):
+        """Run the MCP server."""
+        if transport == "sse":
+            # For running as a web server
+            self.mcp_server.settings.host = host
+            self.mcp_server.settings.port = port
+
+        self.mcp_server.run(transport=transport)
+
+    async def run_async(
+        self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000
+    ):
+        """Run the MCP server asynchronously."""
+        if transport == "sse":
+            self.mcp_server.settings.host = host
+            self.mcp_server.settings.port = port
+            await self.mcp_server.run_sse_async()
+        else:  # stdio
+            await self.mcp_server.run_stdio_async()
+
+    async def with_bridged_context(
+        self, agent_context, mcp_context, func, *args, **kwargs
+    ):
+        """
+        Execute a function with bridged context between MCP and agent
+
+        Args:
+            agent_context: The agent's context object
+            mcp_context: The MCP context from the tool call
+            func: The function to execute
+            args, kwargs: Arguments to pass to the function
+        """
+        # Store original progress reporter if it exists
+        original_progress_reporter = None
+        if hasattr(agent_context, "progress_reporter"):
+            original_progress_reporter = agent_context.progress_reporter
+
+        # Store MCP context in agent context for nested calls
+        agent_context.mcp_context = mcp_context
+
+        # Create bridged progress reporter
+        async def bridged_progress(progress, total=None):
+            if mcp_context:
+                await mcp_context.report_progress(progress, total)
+            if original_progress_reporter:
+                await original_progress_reporter(progress, total)
+
+        # Install bridged progress reporter
+        if hasattr(agent_context, "progress_reporter"):
+            agent_context.progress_reporter = bridged_progress
+
+        try:
+            # Call the function
+            return await func(*args, **kwargs)
+        finally:
+            # Restore original progress reporter
+            if hasattr(agent_context, "progress_reporter"):
+                agent_context.progress_reporter = original_progress_reporter
+
+            # Remove MCP context reference
+            if hasattr(agent_context, "mcp_context"):
+                delattr(agent_context, "mcp_context")

mcp_agent/resources/examples/internal/fastagent.config.yaml

@@ -0,0 +1,52 @@
+default_model: sonnet
+
+# on windows, adjust the mount point to be the full path e.g. x:/temp/data-analysis/mount-point:/mnt/data/
+
+mcp:
+  servers:
+    interpreter:
+      command: "docker"
+      args:
+        [
+          "run",
+          "-i",
+          "--rm",
+          "--pull=always",
+          "-v",
+          "./mount-point:/mnt/data/",
+          "ghcr.io/evalstate/mcp-py-repl:latest",
+        ]
+      roots:
+        - uri: "file://./mount-point/"
+          name: "test_data"
+          server_uri_alias: "file:///mnt/data/"
+    filesystem:
+      # On windows update the command and arguments to use `node` and the absolute path to the server.
+      # Use `npm i -g @modelcontextprotocol/server-filesystem` to install the server globally.
+      # Use `npm -g root` to find the global node_modules path.`
+      # command: "node"
+      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-filesystem/dist/index.js","."]
+      command: "npx"
+      args:
+        [
+          "-y",
+          "@modelcontextprotocol/server-filesystem",
+          "src/mcp_agent/resources/examples/data-analysis/mount-point/",
+        ]
+    fetch:
+      command: "uvx"
+      args: ["mcp-server-fetch"]
+    brave:
+      # On windows replace the command and args line to use `node` and the absolute path to the server.
+      # Use `npm i -g @modelcontextprotocol/server-brave-search` to install the server globally.
+      # Use `npm -g root` to find the global node_modules path.`
+      # command: "node"
+      # args: ["c:/Program Files/nodejs/node_modules/@modelcontextprotocol/server-brave-search/dist/index.js"]
+      command: "npx"
+      args: ["-y", "@modelcontextprotocol/server-brave-search"]
+    sizer:
+      command: "uv"
+      args: ["run", "prompt_sizing.py"]
+    category:
+      command: "uv"
+      args: ["run", "prompt_category.py"]

mcp_agent/resources/examples/internal/prompt_category.py

@@ -0,0 +1,21 @@
+from mcp.server.fastmcp import FastMCP
+from mcp.server.fastmcp.prompts.base import UserMessage, AssistantMessage
+
+mcp = FastMCP("MCP Root Tester")
+
+
+@mcp.prompt(name="category_prompt", description="set up the category protocol")
+def category_prompt():
+    return [
+        UserMessage("Cat"),
+        AssistantMessage("animal"),
+        UserMessage("dog"),
+        AssistantMessage("animal"),
+        UserMessage("quartz"),
+        AssistantMessage("mineral"),
+        #        UserMessage("the sun"),
+    ]
+
+
+if __name__ == "__main__":
+    mcp.run()

mcp_agent/resources/examples/internal/prompt_sizing.py

@@ -0,0 +1,53 @@
+from pydantic import Field
+from mcp.server.fastmcp import FastMCP
+from mcp.server.fastmcp.prompts.base import UserMessage, AssistantMessage
+
+mcp = FastMCP("MCP Prompt Tester")
+
+
+@mcp.prompt(name="sizing_prompt", description="set up the sizing protocol")
+def sizing_prompt():
+    return [
+        UserMessage("What is the size of the moon?"),
+        AssistantMessage("OBJECT: MOON\nSIZE: 3,474.8\nUNITS: KM\nTYPE: MINERAL"),
+        UserMessage("What is the size of the Earth?"),
+        AssistantMessage("OBJECT: EARTH\nSIZE: 12,742\nUNITS: KM\nTYPE: MINERAL"),
+        UserMessage("A tiger"),
+        AssistantMessage("OBJECT: TIGER\nSIZE: 1.2\nUNITS: M\nTYPE: ANIMAL"),
+        UserMessage("Domestic Cat"),
+    ]
+
+
+@mcp.prompt(
+    name="sizing_prompt_units",
+    description="set up the sizing protocol with metric or imperial units",
+)
+def sizing_prompt_units(
+    metric: bool = Field(
+        description="Set to True for Metric, False for Imperial", default=True
+    ),
+):
+    if metric:
+        return [
+            UserMessage("What is the size of the moon?"),
+            AssistantMessage("OBJECT: MOON\nSIZE: 3,474.8\nUNITS: KM\nTYPE: MINERAL"),
+            UserMessage("What is the size of the Earth?"),
+            AssistantMessage("OBJECT: EARTH\nSIZE: 12,742\nUNITS: KM\nTYPE: MINERAL"),
+            UserMessage("A tiger"),
+            AssistantMessage("OBJECT: TIGER\nSIZE: 1.2\nUNITS: M\nTYPE: ANIMAL"),
+            UserMessage("Domestic Cat"),
+        ]
+    else:
+        return [
+            UserMessage("What is the size of the moon?"),
+            AssistantMessage("OBJECT: MOON\nSIZE: 2,159.1\nUNITS: MI\nTYPE: MINERAL"),
+            UserMessage("What is the size of the Earth?"),
+            AssistantMessage("OBJECT: EARTH\nSIZE: 7,918\nUNITS: MI\nTYPE: MINERAL"),
+            UserMessage("A tiger"),
+            AssistantMessage("OBJECT: TIGER\nSIZE: 3.9\nUNITS: FT\nTYPE: ANIMAL"),
+            UserMessage("Domestic Cat"),
+        ]
+
+
+if __name__ == "__main__":
+    mcp.run()

mcp_agent/resources/examples/internal/sizer.py

@@ -0,0 +1,24 @@
+import asyncio
+from mcp_agent.core.fastagent import FastAgent
+
+fast = FastAgent("Sizer Prompt Test")
+
+
+@fast.agent(
+    "sizer",
+    "given an object return its size",
+    servers=["sizer", "category"],
+    use_history=True,
+)
+async def main():
+    async with fast.run() as agent:
+        # await agent["sizer"].load_prompt("sizing_prompt_units", {"metric": "False"})
+        # print(await agent["sizer"].load_prompt("category-category_prompt"))
+        #        await agent("What is the size of the moon?")
+        #        await agent("What is the size of the Earth?")
+        #        await agent("What is the size of the Sun?")
+        await agent()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/resources/examples/researcher/fastagent.config.yaml

@@ -6,7 +6,7 @@
 
 execution_engine: asyncio
 logger:
-  type: file
+  type: console
   level: error
   truncate_tools: true
 
@@ -51,3 +51,16 @@ mcp:
     fetch:
       command: "uvx"
       args: ["mcp-server-fetch"]
+    sequential:
+      command: "npx"
+      args: ["-y","@modelcontextprotocol/server-sequential-thinking"]
+
+#    webmcp:
+#      command: "node"
+#      args: ["/home/ssmith/.webmcp/server.cjs"]
+#      env:
+#         WEBMCP_SERVER_TOKEN: 96e22896d8143fc1d61fec09208fc5ed
+
+
+
+

mcp_agent/resources/examples/workflows/sse.py

@@ -0,0 +1,23 @@
+# example_mcp_server.py
+import asyncio
+
+from mcp_agent.core.fastagent import FastAgent
+
+# Define your agents as normal
+fa = FastAgent("My Application")
+
+
+@fa.agent("analyst", "hello, world", servers=["fetch"])
+
+# Run the application with MCP server
+async def main():
+    await fa.run_with_mcp_server(
+        transport="sse",  # Use "sse" for web server, "stdio" for command line
+        port=8000,
+        server_name="MyAgents",
+        server_description="MCP Server exposing analyst and researcher agents",
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

mcp_agent/ui/console_display.py

@@ -0,0 +1,278 @@
+from typing import Optional, Union
+
+from mcp.types import CallToolResult
+from rich.panel import Panel
+from rich.text import Text
+
+from mcp_agent import console
+from mcp_agent.mcp.mcp_aggregator import SEP
+
+# Constants
+HUMAN_INPUT_TOOL_NAME = "__human_input__"
+
+
+class ConsoleDisplay:
+    """
+    Handles displaying formatted messages, tool calls, and results to the console.
+    This centralizes the UI display logic used by LLM implementations.
+    """
+
+    def __init__(self, config=None):
+        """
+        Initialize the console display handler.
+
+        Args:
+            config: Configuration object containing display preferences
+        """
+        self.config = config
+
+    def show_tool_result(self, result: CallToolResult):
+        """Display a tool result in a formatted panel."""
+        if not self.config or not self.config.logger.show_tools:
+            return
+
+        style = "red" if result.isError else "magenta"
+
+        panel = Panel(
+            Text(str(result.content), overflow="..."),
+            title="[TOOL RESULT]",
+            title_align="right",
+            style=style,
+            border_style="bold white",
+            padding=(1, 2),
+        )
+
+        if self.config and self.config.logger.truncate_tools:
+            if len(str(result.content)) > 360:
+                panel.height = 8
+
+        console.console.print(panel)
+        console.console.print("\n")
+
+    def show_oai_tool_result(self, result):
+        """Display an OpenAI tool result in a formatted panel."""
+        if not self.config or not self.config.logger.show_tools:
+            return
+
+        panel = Panel(
+            Text(str(result), overflow="..."),
+            title="[TOOL RESULT]",
+            title_align="right",
+            style="magenta",
+            border_style="bold white",
+            padding=(1, 2),
+        )
+
+        if self.config and self.config.logger.truncate_tools:
+            if len(str(result)) > 360:
+                panel.height = 8
+
+        console.console.print(panel)
+        console.console.print("\n")
+
+    def show_tool_call(self, available_tools, tool_name, tool_args):
+        """Display a tool call in a formatted panel."""
+        if not self.config or not self.config.logger.show_tools:
+            return
+
+        display_tool_list = self._format_tool_list(available_tools, tool_name)
+
+        panel = Panel(
+            Text(str(tool_args), overflow="ellipsis"),
+            title="[TOOL CALL]",
+            title_align="left",
+            style="magenta",
+            border_style="bold white",
+            subtitle=display_tool_list,
+            subtitle_align="left",
+            padding=(1, 2),
+        )
+
+        if self.config and self.config.logger.truncate_tools:
+            if len(str(tool_args)) > 360:
+                panel.height = 8
+
+        console.console.print(panel)
+        console.console.print("\n")
+
+    def _format_tool_list(self, available_tools, selected_tool_name):
+        """Format the list of available tools, highlighting the selected one."""
+        display_tool_list = Text()
+        for display_tool in available_tools:
+            # Handle both OpenAI and Anthropic tool formats
+            if isinstance(display_tool, dict):
+                if "function" in display_tool:
+                    # OpenAI format
+                    tool_call_name = display_tool["function"]["name"]
+                else:
+                    # Anthropic format
+                    tool_call_name = display_tool["name"]
+            else:
+                # Handle potential object format (e.g., Pydantic models)
+                tool_call_name = (
+                    display_tool.function.name
+                    if hasattr(display_tool, "function")
+                    else display_tool.name
+                )
+
+            parts = (
+                tool_call_name.split(SEP)
+                if SEP in tool_call_name
+                else [tool_call_name, tool_call_name]
+            )
+
+            if selected_tool_name.split(SEP)[0] == parts[0]:
+                style = (
+                    "magenta" if tool_call_name == selected_tool_name else "dim white"
+                )
+                shortened_name = (
+                    parts[1] if len(parts[1]) <= 12 else parts[1][:11] + "…"
+                )
+                display_tool_list.append(f"[{shortened_name}] ", style)
+
+        return display_tool_list
+
+    async def show_assistant_message(
+        self,
+        message_text: Union[str, Text],
+        aggregator=None,
+        highlight_namespaced_tool: str = "",
+        title: str = "ASSISTANT",
+        name: Optional[str] = None,
+    ):
+        """Display an assistant message in a formatted panel."""
+        if not self.config or not self.config.logger.show_chat:
+            return
+
+        display_server_list = Text()
+
+        if aggregator:
+            # Add human input tool if available
+            tools = await aggregator.list_tools()
+            if any(tool.name == HUMAN_INPUT_TOOL_NAME for tool in tools.tools):
+                style = (
+                    "green"
+                    if highlight_namespaced_tool == HUMAN_INPUT_TOOL_NAME
+                    else "dim white"
+                )
+                display_server_list.append("[human] ", style)
+
+            # Add all available servers
+            mcp_server_name = (
+                highlight_namespaced_tool.split(SEP)[0]
+                if SEP in highlight_namespaced_tool
+                else highlight_namespaced_tool
+            )
+
+            for server_name in await aggregator.list_servers():
+                style = "green" if server_name == mcp_server_name else "dim white"
+                display_server_list.append(f"[{server_name}] ", style)
+
+        panel = Panel(
+            message_text,
+            title=f"[{title}]{f' ({name})' if name else ''}",
+            title_align="left",
+            style="green",
+            border_style="bold white",
+            padding=(1, 2),
+            subtitle=display_server_list,
+            subtitle_align="left",
+        )
+        console.console.print(panel)
+        console.console.print("\n")
+
+    def show_user_message(
+        self, message, model: Optional[str], chat_turn: int, name: Optional[str] = None
+    ):
+        """Display a user message in a formatted panel."""
+        if not self.config or not self.config.logger.show_chat:
+            return
+
+        panel = Panel(
+            message,
+            title=f"{f'({name}) [USER]' if name else '[USER]'}",
+            title_align="right",
+            style="blue",
+            border_style="bold white",
+            padding=(1, 2),
+            subtitle=Text(f"{model or 'unknown'} turn {chat_turn}", style="dim white"),
+            subtitle_align="left",
+        )
+        console.console.print(panel)
+        console.console.print("\n")
+
+    async def show_prompt_loaded(
+        self,
+        prompt_name: str,
+        description: Optional[str] = None,
+        message_count: int = 0,
+        agent_name: Optional[str] = None,
+        aggregator=None,
+        arguments: Optional[dict[str, str]] = None,
+    ):
+        """
+        Display information about a loaded prompt template.
+
+        Args:
+            prompt_name: The name of the prompt that was loaded (should be namespaced)
+            description: Optional description of the prompt
+            message_count: Number of messages added to the conversation history
+            agent_name: Name of the agent using the prompt
+            aggregator: Optional aggregator instance to use for server highlighting
+            arguments: Optional dictionary of arguments passed to the prompt template
+        """
+        if not self.config or not self.config.logger.show_tools:
+            return
+
+        # Get server name from the namespaced prompt_name
+        mcp_server_name = None
+        if SEP in prompt_name:
+            # Extract the server from the namespaced prompt name
+            mcp_server_name = prompt_name.split(SEP)[0]
+        elif aggregator and aggregator.server_names:
+            # Fallback to first server if not namespaced
+            mcp_server_name = aggregator.server_names[0]
+
+        # Build the server list with highlighting
+        display_server_list = Text()
+        if aggregator:
+            for server_name in await aggregator.list_servers():
+                style = "green" if server_name == mcp_server_name else "dim white"
+                display_server_list.append(f"[{server_name}] ", style)
+
+        # Create content text
+        content = Text()
+        messages_phrase = (
+            f"Loaded {message_count} message{'s' if message_count != 1 else ''}"
+        )
+        content.append(f"{messages_phrase} from template ", style="cyan italic")
+        content.append(f"'{prompt_name}'", style="cyan bold italic")
+
+        if agent_name:
+            content.append(f" for {agent_name}", style="cyan italic")
+            
+        # Add template arguments if provided
+        if arguments:
+            content.append("\n\nArguments:", style="cyan")
+            for key, value in arguments.items():
+                content.append(f"\n  {key}: ", style="cyan bold")
+                content.append(value, style="white")
+                
+        if description:
+            content.append("\n\n", style="default")
+            content.append(description, style="dim white")
+
+        # Create panel
+        panel = Panel(
+            content,
+            title="[PROMPT LOADED]",
+            title_align="right",
+            style="cyan",
+            border_style="bold white",
+            padding=(1, 2),
+            subtitle=display_server_list,
+            subtitle_align="left",
+        )
+
+        console.console.print(panel)
+        console.console.print("\n")