fast-agent-mcp 0.2.19__tar.gz → 0.2.21__tar.gz

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.19
+Version: 0.2.21
 Summary: Define, Prompt and Test MCP enabled Agents and Workflows
 Author-email: Shaun Smith <fastagent@llmindset.co.uk>, Sarmad Qadri <sarmad@lastmileai.dev>
 License:                                  Apache License
@@ -213,7 +213,7 @@ Requires-Dist: a2a-types>=0.1.0
 Requires-Dist: aiohttp>=3.11.13
 Requires-Dist: anthropic>=0.49.0
 Requires-Dist: fastapi>=0.115.6
-Requires-Dist: mcp==1.6.0
+Requires-Dist: mcp~=1.7.0
 Requires-Dist: openai>=1.63.2
 Requires-Dist: opentelemetry-distro>=0.50b0
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=1.29.0

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fast-agent-mcp"
-version = "0.2.19"
+version = "0.2.21"
 description = "Define, Prompt and Test MCP enabled Agents and Workflows"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -16,7 +16,7 @@ classifiers = [
 requires-python = ">=3.10"
 dependencies = [
     "fastapi>=0.115.6",
-    "mcp==1.6.0",
+    "mcp~=1.7.0",
     "opentelemetry-distro>=0.50b0",
     "opentelemetry-exporter-otlp-proto-http>=1.29.0",
     "pydantic-settings>=2.7.0",

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/__init__.py

@@ -36,7 +36,7 @@ from mcp_agent.core.request_params import RequestParams
 
 # Core protocol interfaces
 from mcp_agent.mcp.interfaces import AgentProtocol, AugmentedLLMProtocol
-from mcp_agent.mcp.mcp_aggregator import MCPAggregator, MCPCompoundServer
+from mcp_agent.mcp.mcp_aggregator import MCPAggregator
 from mcp_agent.mcp.prompt_message_multipart import PromptMessageMultipart
 
 __all__ = [
@@ -58,7 +58,6 @@ __all__ = [
     "Agent",
     "AgentConfig",
     "MCPAggregator",
-    "MCPCompoundServer",
     "PromptMessageMultipart",
     # FastAgent components
     "FastAgent",

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/config.py

@@ -93,6 +93,9 @@ class MCPServerSettings(BaseModel):
     sampling: MCPSamplingSettings | None = None
     """Sampling settings for this Client/Server pair"""
 
+    cwd: str | None = None
+    """Working directory for the executed server command."""
+
 
 class MCPSettings(BaseModel):
     """Configuration for all MCP servers."""

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/context.py

@@ -4,6 +4,7 @@ A central context object to store global state that is shared across the applica
 
 import asyncio
 import concurrent.futures
+import uuid
 from typing import TYPE_CHECKING, Any, Optional, Union
 
 from mcp import ServerSession
@@ -79,12 +80,12 @@ async def configure_otel(config: "Settings") -> None:
     except:  # noqa: E722
         app_version = "unknown"
 
-    # Create resource identifying this service
     resource = Resource.create(
         attributes={
             key: value
             for key, value in {
                 "service.name": service_name,
+                "service.instance.id": str(uuid.uuid4())[:6],
                 "service.version": app_version,
             }.items()
             if value is not None

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/core/fastagent.py

@@ -324,13 +324,16 @@ class FastAgent:
                                 print("\nServer stopped by user (Ctrl+C)")
                         except Exception as e:
                             if not quiet_mode:
+                                import traceback
+
+                                traceback.print_exc()
                                 print(f"\nServer stopped with error: {e}")
 
                         # Exit after server shutdown
                         raise SystemExit(0)
 
                     # Handle direct message sending if  --message is provided
-                    if self.args.message:
+                    if hasattr(self.args, "message") and self.args.message:
                         agent_name = self.args.agent
                         message = self.args.message
 
@@ -356,7 +359,7 @@ class FastAgent:
                             print(f"\n\nError sending message to agent '{agent_name}': {str(e)}")
                             raise SystemExit(1)
 
-                    if self.args.prompt_file:
+                    if hasattr(self.args, "prompt_file") and self.args.prompt_file:
                         agent_name = self.args.agent
                         prompt: List[PromptMessageMultipart] = load_prompt_multipart(
                             Path(self.args.prompt_file)

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/llm/augmented_llm.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 from typing import (
     TYPE_CHECKING,
     Any,
+    Dict,
     Generic,
     List,
     Optional,
@@ -59,7 +60,36 @@ if TYPE_CHECKING:
 HUMAN_INPUT_TOOL_NAME = "__human_input__"
 
 
-class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT, MessageT]):
+def deep_merge(dict1: Dict[Any, Any], dict2: Dict[Any, Any]) -> Dict[Any, Any]:
+    """
+    Recursively merges `dict2` into `dict1` in place.
+
+    If a key exists in both dictionaries and their values are dictionaries,
+    the function merges them recursively. Otherwise, the value from `dict2`
+    overwrites or is added to `dict1`.
+
+    Args:
+        dict1 (Dict): The dictionary to be updated.
+        dict2 (Dict): The dictionary to merge into `dict1`.
+
+    Returns:
+        Dict: The updated `dict1`.
+    """
+    for key in dict2:
+        if (
+            key in dict1
+            and isinstance(dict1[key], dict)
+            and isinstance(dict2[key], dict)
+        ):
+            deep_merge(dict1[key], dict2[key])
+        else:
+            dict1[key] = dict2[key]
+    return dict1
+
+
+class AugmentedLLM(
+    ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT, MessageT]
+):
     # Common parameter names used across providers
     PARAM_MESSAGES = "messages"
     PARAM_MODEL = "model"
@@ -357,8 +387,10 @@ class AugmentedLLM(ContextDependent, AugmentedLLMProtocol, Generic[MessageParamT
     ) -> RequestParams:
         """Merge default and provided request parameters"""
 
-        merged = default_params.model_dump()
-        merged.update(provided_params.model_dump(exclude_unset=True))
+        merged = deep_merge(
+            default_params.model_dump(),
+            provided_params.model_dump(exclude_unset=True),
+        )
         final_params = RequestParams(**merged)
 
         return final_params

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/llm/providers/augmented_llm_anthropic.py

@@ -79,7 +79,7 @@ class AnthropicAugmentedLLM(AugmentedLLM[MessageParam, Message]):
             maxTokens=4096,  # default haiku3
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
-            max_iterations=10,
+            max_iterations=20,
             use_history=True,
         )
 

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/llm/providers/augmented_llm_openai.py

@@ -95,7 +95,7 @@ class OpenAIAugmentedLLM(AugmentedLLM[ChatCompletionMessageParam, ChatCompletion
             model=chosen_model,
             systemPrompt=self.instruction,
             parallel_tool_calls=True,
-            max_iterations=10,
+            max_iterations=20,
             use_history=True,
         )
 

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/mcp/mcp_agent_client_session.py

@@ -3,6 +3,7 @@ A derived client session for the MCP Agent framework.
 It adds logging and supports sampling requests.
 """
 
+from datetime import timedelta
 from typing import TYPE_CHECKING, Optional
 
 from mcp import ClientSession
@@ -73,10 +74,13 @@ class MCPAgentClientSession(ClientSession, ContextDependent):
         self,
         request: SendRequestT,
         result_type: type[ReceiveResultT],
+        request_read_timeout_seconds: timedelta | None = None,
     ) -> ReceiveResultT:
         logger.debug("send_request: request=", data=request.model_dump())
         try:
-            result = await super().send_request(request, result_type)
+            result = await super().send_request(
+                request, result_type, request_read_timeout_seconds=request_read_timeout_seconds
+            )
             logger.debug("send_request: response=", data=result.model_dump())
             return result
         except Exception as e:

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/mcp/mcp_aggregator.py

@@ -12,8 +12,6 @@ from typing import (
 
 from mcp import GetPromptResult, ReadResourceResult
 from mcp.client.session import ClientSession
-from mcp.server.lowlevel.server import Server
-from mcp.server.stdio import stdio_server
 from mcp.types import (
     CallToolResult,
     ListToolsResult,
@@ -44,6 +42,16 @@ T = TypeVar("T")
 R = TypeVar("R")
 
 
+def create_namespaced_name(server_name: str, resource_name: str) -> str:
+    """Create a namespaced resource name from server and resource names"""
+    return f"{server_name}{SEP}{resource_name}"
+
+
+def is_namespaced_name(name: str) -> bool:
+    """Check if a name is already namespaced"""
+    return SEP in name
+
+
 class NamespacedTool(BaseModel):
     """
     A tool that is namespaced by server name.
@@ -231,8 +239,7 @@ class MCPAggregator(ContextDependent):
 
         async def fetch_prompts(client: ClientSession, server_name: str) -> List[Prompt]:
             # Only fetch prompts if the server supports them
-            capabilities = await self.get_capabilities(server_name)
-            if not capabilities or not capabilities.prompts:
+            if not await self.server_supports_feature(server_name, "prompts"):
                 logger.debug(f"Server '{server_name}' does not support prompts")
                 return []
 
@@ -278,7 +285,7 @@ class MCPAggregator(ContextDependent):
             # Process tools
             self._server_to_tool_map[server_name] = []
             for tool in tools:
-                namespaced_tool_name = f"{server_name}{SEP}{tool.name}"
+                namespaced_tool_name = create_namespaced_name(server_name, tool.name)
                 namespaced_tool = NamespacedTool(
                     tool=tool,
                     server_name=server_name,
@@ -321,6 +328,41 @@ class MCPAggregator(ContextDependent):
             logger.debug(f"Error getting capabilities for server '{server_name}': {e}")
             return None
 
+    async def validate_server(self, server_name: str) -> bool:
+        """
+        Validate that a server exists in our server list.
+
+        Args:
+            server_name: Name of the server to validate
+
+        Returns:
+            True if the server exists, False otherwise
+        """
+        valid = server_name in self.server_names
+        if not valid:
+            logger.debug(f"Server '{server_name}' not found")
+        return valid
+
+    async def server_supports_feature(self, server_name: str, feature: str) -> bool:
+        """
+        Check if a server supports a specific feature.
+
+        Args:
+            server_name: Name of the server to check
+            feature: Feature to check for (e.g., "prompts", "resources")
+
+        Returns:
+            True if the server supports the feature, False otherwise
+        """
+        if not await self.validate_server(server_name):
+            return False
+
+        capabilities = await self.get_capabilities(server_name)
+        if not capabilities:
+            return False
+
+        return getattr(capabilities, feature, False)
+
     async def list_servers(self) -> List[str]:
         """Return the list of server names aggregated by this agent."""
         if not self.initialized:
@@ -420,40 +462,45 @@ class MCPAggregator(ContextDependent):
         Returns:
             Tuple of (server_name, local_resource_name)
         """
-        server_name = None
-        local_name = None
-
-        if SEP in name:  # Namespaced resource name
-            server_name, local_name = name.split(SEP, 1)
-        else:
-            # For tools, search all servers for the tool
-            if resource_type == "tool":
-                for _, tools in self._server_to_tool_map.items():
-                    for namespaced_tool in tools:
-                        if namespaced_tool.tool.name == name:
-                            server_name = namespaced_tool.server_name
-                            local_name = name
-                            break
-                    if server_name:
-                        break
-            # For all other resource types, use the first server
-            # (prompt resource type is specially handled in get_prompt)
-            else:
-                local_name = name
-                server_name = self.server_names[0] if self.server_names else None
-
-        return server_name, local_name
+        # First, check if this is a direct hit in our namespaced tool map
+        # This handles both namespaced and non-namespaced direct lookups
+        if resource_type == "tool" and name in self._namespaced_tool_map:
+            namespaced_tool = self._namespaced_tool_map[name]
+            return namespaced_tool.server_name, namespaced_tool.tool.name
+
+        # Next, attempt to interpret as a namespaced name
+        if is_namespaced_name(name):
+            parts = name.split(SEP, 1)
+            server_name, local_name = parts[0], parts[1]
+
+            # Validate that the parsed server actually exists
+            if server_name in self.server_names:
+                return server_name, local_name
+
+            # If the server name doesn't exist, it might be a tool with a hyphen in its name
+            # Fall through to the next checks
+
+        # For tools, search all servers for the tool by exact name match
+        if resource_type == "tool":
+            for server_name, tools in self._server_to_tool_map.items():
+                for namespaced_tool in tools:
+                    if namespaced_tool.tool.name == name:
+                        return server_name, name
+
+        # For all other resource types, use the first server
+        return (self.server_names[0] if self.server_names else None, name)
 
     async def call_tool(self, name: str, arguments: dict | None = None) -> CallToolResult:
         """
-        Call a namespaced tool, e.g., 'server_name.tool_name'.
+        Call a namespaced tool, e.g., 'server_name-tool_name'.
         """
         if not self.initialized:
             await self.load_servers()
 
+        # Use the common parser to get server and tool name
         server_name, local_tool_name = await self._parse_resource_name(name, "tool")
 
-        if server_name is None or local_tool_name is None:
+        if server_name is None:
             logger.error(f"Error: Tool '{name}' not found")
             return CallToolResult(
                 isError=True,
@@ -479,7 +526,10 @@ class MCPAggregator(ContextDependent):
                 operation_type="tool",
                 operation_name=local_tool_name,
                 method_name="call_tool",
-                method_args={"name": local_tool_name, "arguments": arguments},
+                method_args={
+                    "name": local_tool_name,
+                    "arguments": arguments,
+                },
                 error_factory=lambda msg: CallToolResult(
                     isError=True, content=[TextContent(type="text", text=msg)]
                 ),
@@ -506,18 +556,29 @@ class MCPAggregator(ContextDependent):
         if not self.initialized:
             await self.load_servers()
 
-        # Handle the case where prompt_name is None
-        if SEP in prompt_name and server_name is None:
-            server_name, local_prompt_name = prompt_name.split(SEP, 1)
-            namespaced_name = prompt_name  # Already namespaced
-        # Plain prompt name - use provided server or search
+        # If server_name is explicitly provided, use it
+        if server_name:
+            local_prompt_name = prompt_name
+        # Otherwise, check if prompt_name is namespaced and validate the server exists
+        elif is_namespaced_name(prompt_name):
+            parts = prompt_name.split(SEP, 1)
+            potential_server = parts[0]
+
+            # Only treat as namespaced if the server part is valid
+            if potential_server in self.server_names:
+                server_name = potential_server
+                local_prompt_name = parts[1]
+            else:
+                # The hyphen is part of the prompt name, not a namespace separator
+                local_prompt_name = prompt_name
+        # Otherwise, use prompt_name as-is for searching
         else:
             local_prompt_name = prompt_name
-            namespaced_name = None  # Will be set when server is found
+            # We'll search all servers below
 
         # If we have a specific server to check
         if server_name:
-            if server_name not in self.server_names:
+            if not await self.validate_server(server_name):
                 logger.error(f"Error: Server '{server_name}' not found")
                 return GetPromptResult(
                     description=f"Error: Server '{server_name}' not found",
@@ -525,8 +586,7 @@ class MCPAggregator(ContextDependent):
                 )
 
             # Check if server supports prompts
-            capabilities = await self.get_capabilities(server_name)
-            if not capabilities or not capabilities.prompts:
+            if not await self.server_supports_feature(server_name, "prompts"):
                 logger.debug(f"Server '{server_name}' does not support prompts")
                 return GetPromptResult(
                     description=f"Server '{server_name}' does not support prompts",
@@ -564,7 +624,7 @@ class MCPAggregator(ContextDependent):
 
             # Add namespaced name and source server to the result
             if result and result.messages:
-                result.namespaced_name = namespaced_name or f"{server_name}{SEP}{local_prompt_name}"
+                result.namespaced_name = create_namespaced_name(server_name, local_prompt_name)
 
                 # Store the arguments in the result for display purposes
                 if arguments:
@@ -616,7 +676,7 @@ class MCPAggregator(ContextDependent):
                             f"Successfully retrieved prompt '{local_prompt_name}' from server '{s_name}'"
                         )
                         # Add namespaced name using the actual server where found
-                        result.namespaced_name = f"{s_name}{SEP}{local_prompt_name}"
+                        result.namespaced_name = create_namespaced_name(s_name, local_prompt_name)
 
                         # Store the arguments in the result for display purposes
                         if arguments:
@@ -664,7 +724,7 @@ class MCPAggregator(ContextDependent):
                             f"Found prompt '{local_prompt_name}' on server '{s_name}' (not in cache)"
                         )
                         # Add namespaced name using the actual server where found
-                        result.namespaced_name = f"{s_name}{SEP}{local_prompt_name}"
+                        result.namespaced_name = create_namespaced_name(s_name, local_prompt_name)
 
                         # Store the arguments in the result for display purposes
                         if arguments:
@@ -942,68 +1002,3 @@ class MCPAggregator(ContextDependent):
                 logger.error(f"Error fetching resources from {s_name}: {e}")
 
         return results
-
-
-class MCPCompoundServer(Server):
-    """
-    A compound server (server-of-servers) that aggregates multiple MCP servers and is itself an MCP server
-    """
-
-    def __init__(self, server_names: List[str], name: str = "MCPCompoundServer") -> None:
-        super().__init__(name)
-        self.aggregator = MCPAggregator(server_names)
-
-        # Register handlers for tools, prompts, and resources
-        self.list_tools()(self._list_tools)
-        self.call_tool()(self._call_tool)
-        self.get_prompt()(self._get_prompt)
-        self.list_prompts()(self._list_prompts)
-
-    async def _list_tools(self) -> List[Tool]:
-        """List all tools aggregated from connected MCP servers."""
-        tools_result = await self.aggregator.list_tools()
-        return tools_result.tools
-
-    async def _call_tool(self, name: str, arguments: dict | None = None) -> CallToolResult:
-        """Call a specific tool from the aggregated servers."""
-        try:
-            result = await self.aggregator.call_tool(name=name, arguments=arguments)
-            return result.content
-        except Exception as e:
-            return CallToolResult(
-                isError=True,
-                content=[TextContent(type="text", text=f"Error calling tool: {e}")],
-            )
-
-    async def _get_prompt(
-        self, name: str = None, arguments: dict[str, str] = None
-    ) -> GetPromptResult:
-        """
-        Get a prompt from the aggregated servers.
-
-        Args:
-            name: Name of the prompt to get (optionally namespaced)
-            arguments: Optional dictionary of string arguments for prompt templating
-        """
-        try:
-            result = await self.aggregator.get_prompt(prompt_name=name, arguments=arguments)
-            return result
-        except Exception as e:
-            return GetPromptResult(description=f"Error getting prompt: {e}", messages=[])
-
-    async def _list_prompts(self, server_name: str = None) -> Dict[str, List[Prompt]]:
-        """List available prompts from the aggregated servers."""
-        try:
-            return await self.aggregator.list_prompts(server_name=server_name)
-        except Exception as e:
-            logger.error(f"Error listing prompts: {e}")
-            return {}
-
-    async def run_stdio_async(self) -> None:
-        """Run the server using stdio transport."""
-        async with stdio_server() as (read_stream, write_stream):
-            await self.run(
-                read_stream=read_stream,
-                write_stream=write_stream,
-                initialization_options=self.create_initialization_options(),
-            )

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/mcp/mcp_connection_manager.py

@@ -264,6 +264,7 @@ class MCPConnectionManager(ContextDependent):
                     command=config.command,
                     args=config.args if config.args is not None else [],
                     env={**get_default_environment(), **(config.env or {})},
+                    cwd=config.cwd,
                 )
                 # Create custom error handler to ensure all output is captured
                 error_handler = get_stderr_handler(server_name)

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/mcp/prompts/prompt_server.py

@@ -82,6 +82,7 @@ class PromptConfig(PromptMetadata):
     http_timeout: float = 10.0
     transport: str = "stdio"
     port: int = 8000
+    host: str = "0.0.0.0"
 
 
 # We'll maintain registries of all exposed resources and prompts
@@ -344,6 +345,12 @@ def parse_args():
         default=8000,
         help="Port to use for SSE transport (default: 8000)",
     )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="0.0.0.0",
+        help="Host to bind to for SSE transport (default: 0.0.0.0)",
+    )
     parser.add_argument(
         "--test", type=str, help="Test a specific prompt without starting the server"
     )
@@ -380,6 +387,7 @@ def initialize_config(args) -> PromptConfig:
         http_timeout=args.http_timeout,
         transport=args.transport,
         port=args.port,
+        host=args.host,
     )
 
 
@@ -497,7 +505,10 @@ async def async_main() -> int:
     if config.transport == "stdio":
         await mcp.run_stdio_async()
     else:  # sse
-        # TODO update to 2025-03-26 specification and test config.
+        # Set the host and port in settings before running the server
+        mcp.settings.host = config.host
+        mcp.settings.port = config.port
+        logger.info(f"Starting SSE server on {config.host}:{config.port}")
         await mcp.run_sse_async()
     return 0
 

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/mcp_server/agent_server.py

@@ -110,7 +110,10 @@ class AgentMCPServer:
 
         # Register handlers for SIGINT (Ctrl+C) and SIGTERM
         for sig, is_term in [(signal.SIGINT, False), (signal.SIGTERM, True)]:
-            loop.add_signal_handler(sig, lambda term=is_term: handle_signal(term))
+            import platform
+
+            if platform.system() != "Windows":
+                loop.add_signal_handler(sig, lambda term=is_term: handle_signal(term))
 
         logger.debug("Signal handlers installed")
 

{fast_agent_mcp-0.2.19 → fast_agent_mcp-0.2.21}/src/mcp_agent/mcp_server_registry.py

@@ -128,6 +128,7 @@ class ServerRegistry:
                 command=config.command,
                 args=config.args,
                 env={**get_default_environment(), **(config.env or {})},
+                cwd=config.cwd,
             )
 
             # Create a stderr handler that logs to our application logger