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

mcp_agent/mcp_server/agent_server.py

@@ -1,9 +1,13 @@
 # src/mcp_agent/mcp_server/agent_server.py
 
+import asyncio
+
 from mcp.server.fastmcp import Context as MCPContext
 from mcp.server.fastmcp import FastMCP
 
-# Import the DirectAgentApp instead of AgentApp
+import mcp_agent
+import mcp_agent.core
+import mcp_agent.core.prompt
 from mcp_agent.core.agent_app import AgentApp
 
 
@@ -14,7 +18,7 @@ class AgentMCPServer:
         self,
         agent_app: AgentApp,
         server_name: str = "FastAgent-MCP-Server",
-        server_description: str = None,
+        server_description: str | None = None,
     ) -> None:
         self.agent_app = agent_app
         self.mcp_server = FastMCP(
@@ -26,28 +30,26 @@ class AgentMCPServer:
 
     def setup_tools(self) -> None:
         """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)
+        for agent_name, agent in self.agent_app._agents.items():
+            self.register_agent_tools(agent_name, agent)
 
-    def register_agent_tools(self, agent_name: str, agent_proxy) -> None:
+    def register_agent_tools(self, agent_name: str, agent) -> None:
         """Register tools for a specific agent."""
 
         # Basic send message tool
         @self.mcp_server.tool(
-            name=f"{agent_name}.send",
+            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
+            agent_context = getattr(agent, "context", None)
 
             # Define the function to execute
             async def execute_send():
-                return await agent_proxy.send(message)
+                return await agent.send(message)
 
             # Execute with bridged context
             if agent_context and ctx:
@@ -55,6 +57,25 @@ class AgentMCPServer:
             else:
                 return await execute_send()
 
+        # Register a history prompt for this agent
+        @self.mcp_server.prompt(
+            name=f"{agent_name}_history",
+            description=f"Conversation history for the {agent_name} agent",
+        )
+        async def get_history_prompt() -> list:
+            """Return the conversation history as MCP messages."""
+            # Get the conversation history from the agent's LLM
+            if not hasattr(agent, "_llm") or agent._llm is None:
+                return []
+
+            # Convert the multipart message history to standard PromptMessages
+            multipart_history = agent._llm.message_history
+            prompt_messages = mcp_agent.core.prompt.Prompt.from_multipart(multipart_history)
+
+            # In FastMCP, we need to return the raw list of messages
+            # that matches the structure that FastMCP expects (list of dicts with role/content)
+            return [{"role": msg.role, "content": msg.content} for msg in prompt_messages]
+
     def run(self, transport: str = "sse", host: str = "0.0.0.0", port: int = 8000) -> None:
         """Run the MCP server."""
         if transport == "sse":
@@ -71,9 +92,19 @@ class AgentMCPServer:
         if transport == "sse":
             self.mcp_server.settings.host = host
             self.mcp_server.settings.port = port
-            await self.mcp_server.run_sse_async()
+            try:
+                await self.mcp_server.run_sse_async()
+            except (asyncio.CancelledError, KeyboardInterrupt):
+                # Gracefully handle cancellation during shutdown
+                await self.shutdown()
+                pass
         else:  # stdio
-            await self.mcp_server.run_stdio_async()
+            try:
+                await self.mcp_server.run_stdio_async()
+            except (asyncio.CancelledError, KeyboardInterrupt):
+                # Gracefully handle cancellation during shutdown
+                await self.shutdown()
+                pass
 
     async def with_bridged_context(self, agent_context, mcp_context, func, *args, **kwargs):
         """
@@ -115,3 +146,21 @@ class AgentMCPServer:
             # Remove MCP context reference
             if hasattr(agent_context, "mcp_context"):
                 delattr(agent_context, "mcp_context")
+
+    async def shutdown(self):
+        """Gracefully shutdown the MCP server and its resources."""
+        # Your MCP server may have additional cleanup code here
+        try:
+            # If your MCP server has a shutdown method, call it
+            if hasattr(self.mcp_server, "shutdown"):
+                await self.mcp_server.shutdown()
+
+            # Clean up any other resources
+            import asyncio
+
+            # Allow any pending tasks to clean up
+            await asyncio.sleep(0.5)
+        except Exception as e:
+            # Just log exceptions during shutdown, don't raise
+            print(f"Error during MCP server shutdown: {e}")
+            pass

mcp_agent/resources/examples/internal/agent.py

@@ -7,13 +7,13 @@ fast = FastAgent("FastAgent Example")
 
 
 # Define the agent
-@fast.agent(servers=["category", "mcp_hfspace"])
+@fast.agent(servers=["category", "mcp_hfspace","mcp_webcam"])
 #@fast.agent(name="test")
 async def main() -> None:
     # use the --model command line switch or agent arguments to change model
     async with fast.run() as agent:
 #        await agent.prompt(agent_name="test")
-        await agent.send("hello,world")
+        await agent()
 
 
 if __name__ == "__main__":

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

@@ -59,3 +59,8 @@ mcp:
     mcp_hfspace:
       command: "npx"
       args: ["@llmindset/mcp-hfspace"]
+
+    mcp_webcam:
+      command: "npx"
+      args: ["@llmindset/mcp-webcam"]
+

mcp_agent/mcp/mcp_agent_server.py

@@ -1,56 +0,0 @@
-import asyncio
-
-from mcp.server import NotificationOptions
-from mcp.server.fastmcp import FastMCP
-from mcp.server.stdio import stdio_server
-
-from mcp_agent.executor.temporal import get_temporal_client
-from mcp_agent.telemetry.tracing import setup_tracing
-
-app = FastMCP("mcp-agent-server")
-
-setup_tracing("mcp-agent-server")
-
-
-async def run() -> None:
-    async with stdio_server() as (read_stream, write_stream):
-        await app._mcp_server.run(
-            read_stream,
-            write_stream,
-            app._mcp_server.create_initialization_options(
-                notification_options=NotificationOptions(tools_changed=True, resources_changed=True)
-            ),
-        )
-
-
-@app.tool
-async def run_workflow(query: str) -> None:
-    """Run the workflow given its name or id"""
-    pass
-
-
-@app.tool
-async def pause_workflow(workflow_id: str) -> None:
-    """Pause a running workflow."""
-    temporal_client = await get_temporal_client()
-    handle = temporal_client.get_workflow_handle(workflow_id)
-    await handle.signal("pause")
-
-
-@app.tool
-async def resume_workflow(workflow_id: str) -> None:
-    """Resume a paused workflow."""
-    temporal_client = await get_temporal_client()
-    handle = temporal_client.get_workflow_handle(workflow_id)
-    await handle.signal("resume")
-
-
-async def provide_user_input(workflow_id: str, input_data: str) -> None:
-    """Provide user/human input to a waiting workflow step."""
-    temporal_client = await get_temporal_client()
-    handle = temporal_client.get_workflow_handle(workflow_id)
-    await handle.signal("human_input", input_data)
-
-
-if __name__ == "__main__":
-    asyncio.run(run())