fast-agent-mcp 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

mcp_agent/mcp/sampling.py

@@ -0,0 +1,133 @@
+"""
+Module for handling MCP Sampling functionality without causing circular imports.
+This module is carefully designed to avoid circular imports in the agent system.
+"""
+
+from mcp import ClientSession
+from mcp.types import (
+    CreateMessageRequestParams,
+    CreateMessageResult,
+    TextContent,
+)
+
+from mcp_agent.logging.logger import get_logger
+from mcp_agent.mcp.interfaces import AugmentedLLMProtocol
+from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
+
+# Protocol is sufficient to describe the interface - no need for TYPE_CHECKING imports
+
+logger = get_logger(__name__)
+
+
+def create_sampling_llm(
+    mcp_ctx: ClientSession, model_string: str
+) -> AugmentedLLMProtocol:
+    """
+    Create an LLM instance for sampling without tools support.
+    This utility function creates a minimal LLM instance based on the model string.
+
+    Args:
+        mcp_ctx: The MCP ClientSession
+        model_string: The model to use (e.g. "passthrough", "claude-3-5-sonnet-latest")
+
+    Returns:
+        An initialized LLM instance ready to use
+    """
+    from mcp_agent.workflows.llm.model_factory import ModelFactory
+    from mcp_agent.agents.agent import Agent, AgentConfig
+
+    # Get application context from global state if available
+    # We don't try to extract it from mcp_ctx as they're different contexts
+    app_context = None
+    try:
+        from mcp_agent.context import get_current_context
+
+        app_context = get_current_context()
+    except Exception:
+        logger.warning("App context not available for sampling call")
+
+    # Create a minimal agent configuration
+    agent_config = AgentConfig(
+        name="sampling_agent",
+        instruction="You are a sampling agent.",
+        servers=[],  # No servers needed
+    )
+
+    # Create agent with our application context (not the MCP context)
+    # Set connection_persistence=False to avoid server connections
+    agent = Agent(
+        config=agent_config,
+        context=app_context,
+        server_names=[],  # Make sure no server connections are attempted
+        connection_persistence=False,  # Avoid server connection management
+    )
+
+    # Create the LLM using the factory
+    factory = ModelFactory.create_factory(model_string)
+    llm = factory(agent=agent)
+
+    # Attach the LLM to the agent
+    agent._llm = llm
+
+    return llm
+
+
+async def sample(
+    mcp_ctx: ClientSession, params: CreateMessageRequestParams
+) -> CreateMessageResult:
+    """
+    Handle sampling requests from the MCP protocol.
+    This function extracts the model from the server config and
+    returns a simple response using the specified model.
+    """
+    model = None
+    try:
+        # Extract model from server config
+        if (
+            hasattr(mcp_ctx, "session")
+            and hasattr(mcp_ctx.session, "server_config")
+            and mcp_ctx.session.server_config
+            and hasattr(mcp_ctx.session.server_config, "sampling")
+            and mcp_ctx.session.server_config.sampling.model
+        ):
+            model = mcp_ctx.session.server_config.sampling.model
+
+        if model is None:
+            raise ValueError("No model configured")
+
+        # Create an LLM instance using our utility function
+        llm = create_sampling_llm(mcp_ctx, model)
+
+        # Get user message from the request params
+        user_message = params.messages[0].content.text
+
+        # Create a multipart prompt message with the user's input
+        prompt = PromptMessageMultipart(
+            role="user", content=[TextContent(type="text", text=user_message)]
+        )
+
+        try:
+            # Use the LLM to generate a response
+            logger.info(f"Processing input: {user_message[:50]}...")
+            llm_response = await llm.generate_prompt(prompt, None)
+            logger.info(f"Generated response: {llm_response[:50]}...")
+        except Exception as e:
+            # If there's an error in LLM processing, fall back to echo
+            logger.error(f"Error generating response: {str(e)}")
+            llm_response = f"Echo response: {user_message}"
+
+        # Return the LLM-generated response
+        return CreateMessageResult(
+            role="assistant",
+            content=TextContent(type="text", text=llm_response),
+            model=model,
+            stopReason="endTurn",
+        )
+    except Exception as e:
+        logger.error(f"Error in sampling: {str(e)}")
+        return CreateMessageResult(
+            role="assistant",
+            content=TextContent(type="text", text=f"Error in sampling: {str(e)}"),
+            model=model or "unknown",
+            stopReason="error",
+        )

mcp_agent/mcp/stdio.py

@@ -9,10 +9,12 @@ from anyio.streams.text import TextReceiveStream
 from mcp.client.stdio import StdioServerParameters, get_default_environment
 import mcp.types as types
 from mcp_agent.logging.logger import get_logger
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 
 logger = get_logger(__name__)
 
 
+# TODO this will be removed when client library with https://github.com/modelcontextprotocol/python-sdk/pull/343 is released
 @asynccontextmanager
 async def stdio_client_with_rich_stderr(server: StdioServerParameters):
     """
@@ -22,10 +24,16 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
     Args:
         server: The server parameters for the stdio connection
     """
+    read_stream: MemoryObjectReceiveStream[types.JSONRPCMessage | Exception]
+    read_stream_writer: MemoryObjectSendStream[types.JSONRPCMessage | Exception]
+
+    write_stream: MemoryObjectSendStream[types.JSONRPCMessage]
+    write_stream_reader: MemoryObjectReceiveStream[types.JSONRPCMessage]
+
     read_stream_writer, read_stream = anyio.create_memory_object_stream(0)
     write_stream, write_stream_reader = anyio.create_memory_object_stream(0)
-
     # Open process with stderr piped for capture
+
     process = await anyio.open_process(
         [server.command, *server.args],
         env=server.env if server.env is not None else get_default_environment(),
@@ -67,19 +75,19 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
         except anyio.ClosedResourceError:
             await anyio.lowlevel.checkpoint()
 
-    async def stderr_reader():
-        assert process.stderr, "Opened process is missing stderr"
-        try:
-            async for chunk in TextReceiveStream(
-                process.stderr,
-                encoding=server.encoding,
-                errors=server.encoding_error_handler,
-            ):
-                if chunk.strip():
-                    # Let the logging system handle the formatting consistently
-                    logger.event("info", "mcpserver.stderr", chunk.rstrip(), None, {})
-        except anyio.ClosedResourceError:
-            await anyio.lowlevel.checkpoint()
+    # async def stderr_reader():
+    #     assert process.stderr, "Opened process is missing stderr"
+    #     try:
+    #         async for chunk in TextReceiveStream(
+    #             process.stderr,
+    #             encoding=server.encoding,
+    #             errors=server.encoding_error_handler,
+    #         ):
+    #             if chunk.strip():
+    #                 # Let the logging system handle the formatting consistently
+    #                 logger.event("info", "mcpserver.stderr", chunk.rstrip(), None, {})
+    #     except anyio.ClosedResourceError:
+    #         await anyio.lowlevel.checkpoint()
 
     async def stdin_writer():
         assert process.stdin, "Opened process is missing stdin"
@@ -100,5 +108,4 @@ async def stdio_client_with_rich_stderr(server: StdioServerParameters):
     async with anyio.create_task_group() as tg, process:
         tg.start_soon(stdout_reader)
         tg.start_soon(stdin_writer)
-        tg.start_soon(stderr_reader)
         yield read_stream, write_stream

mcp_agent/mcp_server_registry.py

@@ -15,9 +15,9 @@ from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStre
 from mcp import ClientSession
 from mcp.client.stdio import (
     StdioServerParameters,
-    stdio_client,
     get_default_environment,
 )
+from mcp_agent.mcp.stdio import stdio_client_with_rich_stderr
 from mcp.client.sse import sse_client
 
 from mcp_agent.config import (
@@ -134,7 +134,10 @@ class ServerRegistry:
                 env={**get_default_environment(), **(config.env or {})},
             )
 
-            async with stdio_client(server_params) as (read_stream, write_stream):
+            async with stdio_client_with_rich_stderr(server_params) as (
+                read_stream,
+                write_stream,
+            ):
                 session = client_session_factory(
                     read_stream,
                     write_stream,

mcp_agent/resources/examples/internal/agent.py

@@ -6,7 +6,7 @@ fast = FastAgent("FastAgent Example")
 
 
 # Define the agent
-@fast.agent(servers=["fetch"])
+@fast.agent(servers=["fetch", "mcp_hfspace"])
 async def main():
     # use the --model command line switch or agent arguments to change model
     async with fast.run() as agent:

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

@@ -50,3 +50,6 @@ mcp:
     category:
       command: "uv"
       args: ["run", "prompt_category.py"]
+    mcp_hfspace:
+      command: "npx"
+      args: ["@llmindset/mcp-hfspace"]

mcp_agent/resources/examples/workflows/orchestrator.py

@@ -50,9 +50,9 @@ fast = FastAgent("Orchestrator-Workers")
 async def main():
     async with fast.run() as agent:
         await agent()
-#        await agent.author(
-#            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
-#        )
+        await agent.author(
+            "write a 250 word short story about kittens discovering a castle, and save it to short_story.md"
+        )
 
         # The orchestrator can be used just like any other agent
         task = (

mcp_agent/workflows/llm/augmented_llm_passthrough.py

@@ -1,5 +1,5 @@
 from typing import Any, List, Optional, Type, Union
-
+import json  # Import at the module level
 from mcp import GetPromptResult
 from mcp.types import PromptMessage
 from pydantic_core import from_json
@@ -45,11 +45,101 @@ class PassthroughLLM(AugmentedLLM):
         request_params: Optional[RequestParams] = None,
     ) -> str:
         """Return the input message as a string."""
+        # Check if this is a special command to call a tool
+        if isinstance(message, str) and message.startswith("***CALL_TOOL "):
+            return await self._call_tool_and_return_result(message)
+
         self.show_user_message(message, model="fastagent-passthrough", chat_turn=0)
         await self.show_assistant_message(message, title="ASSISTANT/PASSTHROUGH")
 
+        # Handle PromptMessage by concatenating all parts
+        if isinstance(message, PromptMessage):
+            parts_text = []
+            for part in message.content:
+                parts_text.append(str(part))
+            return "\n".join(parts_text)
+
         return str(message)
 
+    async def _call_tool_and_return_result(self, command: str) -> str:
+        """
+        Call a tool based on the command and return its result as a string.
+
+        Args:
+            command: The command string, expected format: "***CALL_TOOL <server>-<tool_name> [arguments_json]"
+
+        Returns:
+            Tool result as a string
+        """
+        try:
+            tool_name, arguments = self._parse_tool_command(command)
+            result = await self.aggregator.call_tool(tool_name, arguments)
+            return self._format_tool_result(tool_name, result)
+        except Exception as e:
+            self.logger.error(f"Error calling tool: {str(e)}")
+            return f"Error calling tool: {str(e)}"
+
+    def _parse_tool_command(self, command: str) -> tuple[str, Optional[dict]]:
+        """
+        Parse a tool command string into tool name and arguments.
+
+        Args:
+            command: The command string in format "***CALL_TOOL <tool_name> [arguments_json]"
+
+        Returns:
+            Tuple of (tool_name, arguments_dict)
+
+        Raises:
+            ValueError: If command format is invalid
+        """
+        parts = command.split(" ", 2)
+        if len(parts) < 2:
+            raise ValueError(
+                "Invalid format. Expected '***CALL_TOOL <tool_name> [arguments_json]'"
+            )
+
+        tool_name = parts[1].strip()
+        arguments = None
+
+        if len(parts) > 2:
+            try:
+                arguments = json.loads(parts[2])
+            except json.JSONDecodeError:
+                raise ValueError(f"Invalid JSON arguments: {parts[2]}")
+
+        self.logger.info(f"Calling tool {tool_name} with arguments {arguments}")
+        return tool_name, arguments
+
+    def _format_tool_result(self, tool_name: str, result) -> str:
+        """
+        Format tool execution result as a string.
+
+        Args:
+            tool_name: The name of the tool that was called
+            result: The result returned from the tool
+
+        Returns:
+            Formatted result as a string
+        """
+        if result.isError:
+            error_text = []
+            for content_item in result.content:
+                if hasattr(content_item, "text"):
+                    error_text.append(content_item.text)
+                else:
+                    error_text.append(str(content_item))
+            error_message = "\n".join(error_text) if error_text else "Unknown error"
+            return f"Error calling tool '{tool_name}': {error_message}"
+
+        result_text = []
+        for content_item in result.content:
+            if hasattr(content_item, "text"):
+                result_text.append(content_item.text)
+            else:
+                result_text.append(str(content_item))
+
+        return "\n".join(result_text)
+
     async def generate_structured(
         self,
         message: Union[str, MessageParamT, List[MessageParamT]],
@@ -71,7 +161,25 @@ class PassthroughLLM(AugmentedLLM):
     async def generate_prompt(
         self, prompt: "PromptMessageMultipart", request_params: RequestParams | None
     ) -> str:
-        return await self.generate_str(prompt.content[0].text, request_params)
+        # Check if this prompt contains a tool call command
+        if (
+            prompt.content
+            and prompt.content[0].text
+            and prompt.content[0].text.startswith("***CALL_TOOL ")
+        ):
+            return await self._call_tool_and_return_result(prompt.content[0].text)
+
+        # Process all parts of the PromptMessageMultipart
+        parts_text = []
+        for part in prompt.content:
+            parts_text.append(str(part))
+
+        # If no parts found, return empty string
+        if not parts_text:
+            return ""
+
+        # Join all parts and process with generate_str
+        return await self.generate_str("\n".join(parts_text), request_params)
 
     async def apply_prompt_template(
         self, prompt_result: GetPromptResult, prompt_name: str