fast-agent-mcp 0.2.18__py3-none-any.whl → 0.2.20__py3-none-any.whl

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,
@@ -21,6 +19,7 @@ from mcp.types import (
     TextContent,
     Tool,
 )
+from opentelemetry import trace
 from pydantic import AnyUrl, BaseModel, ConfigDict
 
 from mcp_agent.context_dependent import ContextDependent
@@ -42,6 +41,14 @@ SEP = "-"
 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):
     """
@@ -230,8 +237,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 []
 
@@ -277,7 +283,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,
@@ -319,6 +325,41 @@ class MCPAggregator(ContextDependent):
         except Exception as e:
             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."""
@@ -419,40 +460,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,
@@ -469,16 +515,20 @@ class MCPAggregator(ContextDependent):
             },
         )
 
-        return await self._execute_on_server(
-            server_name=server_name,
-            operation_type="tool",
-            operation_name=local_tool_name,
-            method_name="call_tool",
-            method_args={"name": local_tool_name, "arguments": arguments},
-            error_factory=lambda msg: CallToolResult(
-                isError=True, content=[TextContent(type="text", text=msg)]
-            ),
-        )
+        tracer = trace.get_tracer(__name__)
+        with tracer.start_as_current_span(f"MCP Tool: {server_name}/{local_tool_name}"):
+            trace.get_current_span().set_attribute("tool_name", local_tool_name)
+            trace.get_current_span().set_attribute("server_name", server_name)
+            return await self._execute_on_server(
+                server_name=server_name,
+                operation_type="tool",
+                operation_name=local_tool_name,
+                method_name="call_tool",
+                method_args={"name": local_tool_name, "arguments": arguments},
+                error_factory=lambda msg: CallToolResult(
+                    isError=True, content=[TextContent(type="text", text=msg)]
+                ),
+            )
 
     async def get_prompt(
         self,
@@ -501,27 +551,37 @@ 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",
                     messages=[],
                 )
-
+                
             # 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",
@@ -559,7 +619,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:
@@ -611,7 +671,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:
@@ -659,7 +719,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:
@@ -937,68 +997,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(),
-            )

mcp_agent/mcp/mcp_connection_manager.py

@@ -262,8 +262,9 @@ class MCPConnectionManager(ContextDependent):
             if config.transport == "stdio":
                 server_params = StdioServerParameters(
                     command=config.command,
-                    args=config.args,
+                    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)

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")
 

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

mcp_agent/logging/tracing.py

@@ -1,138 +0,0 @@
-"""
-Telemetry manager that defines distributed tracing decorators for OpenTelemetry traces/spans
-for the Logger module for MCP Agent
-"""
-
-import asyncio
-import functools
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple
-
-from opentelemetry import trace
-from opentelemetry.context import Context as OtelContext
-from opentelemetry.propagate import extract as otel_extract
-from opentelemetry.trace import SpanKind, Status, StatusCode, set_span_in_context
-from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
-
-from mcp_agent.context_dependent import ContextDependent
-
-if TYPE_CHECKING:
-    from mcp_agent.context import Context
-
-
-class TelemetryManager(ContextDependent):
-    """
-    Simple manager for creating OpenTelemetry spans automatically.
-    Decorator usage: @telemetry.traced("SomeSpanName")
-    """
-
-    def __init__(self, context: Optional["Context"] = None, **kwargs) -> None:
-        # If needed, configure resources, exporters, etc.
-        # E.g.: from opentelemetry.sdk.trace import TracerProvider
-        # trace.set_tracer_provider(TracerProvider(...))
-        super().__init__(context=context, **kwargs)
-
-    def traced(
-        self,
-        name: str | None = None,
-        kind: SpanKind = SpanKind.INTERNAL,
-        attributes: Dict[str, Any] = None,
-    ) -> Callable:
-        """
-        Decorator that automatically creates and manages a span for a function.
-        Works for both async and sync functions.
-        """
-
-        def decorator(func):
-            span_name = name or f"{func.__module__}.{func.__qualname__}"
-
-            tracer = self.context.tracer or trace.get_tracer("mcp_agent")
-
-            @functools.wraps(func)
-            async def async_wrapper(*args, **kwargs):
-                with tracer.start_as_current_span(span_name, kind=kind) as span:
-                    if attributes:
-                        for k, v in attributes.items():
-                            span.set_attribute(k, v)
-                    # Record simple args
-                    self._record_args(span, args, kwargs)
-                    try:
-                        res = await func(*args, **kwargs)
-                        return res
-                    except Exception as e:
-                        span.record_exception(e)
-                        span.set_status(Status(StatusCode.ERROR))
-                        raise
-
-            @functools.wraps(func)
-            def sync_wrapper(*args, **kwargs):
-                with tracer.start_as_current_span(span_name, kind=kind) as span:
-                    if attributes:
-                        for k, v in attributes.items():
-                            span.set_attribute(k, v)
-                    # Record simple args
-                    self._record_args(span, args, kwargs)
-                    try:
-                        res = func(*args, **kwargs)
-                        return res
-                    except Exception as e:
-                        span.record_exception(e)
-                        span.set_status(Status(StatusCode.ERROR))
-                        raise
-
-            if asyncio.iscoroutinefunction(func):
-                return async_wrapper
-            else:
-                return sync_wrapper
-
-        return decorator
-
-    def _record_args(self, span, args, kwargs) -> None:
-        """Optionally record primitive args as span attributes."""
-        for i, arg in enumerate(args):
-            if isinstance(arg, (str, int, float, bool)):
-                span.set_attribute(f"arg_{i}", str(arg))
-        for k, v in kwargs.items():
-            if isinstance(v, (str, int, float, bool)):
-                span.set_attribute(k, str(v))
-
-
-class MCPRequestTrace:
-    """Helper class for trace context propagation in MCP"""
-
-    @staticmethod
-    def start_span_from_mcp_request(
-        method: str, params: Dict[str, Any]
-    ) -> Tuple[trace.Span, OtelContext]:
-        """Extract trace context from incoming MCP request and start a new span"""
-        # Extract trace context from _meta if present
-        carrier = {}
-        _meta = params.get("_meta", {})
-        if "traceparent" in _meta:
-            carrier["traceparent"] = _meta["traceparent"]
-        if "tracestate" in _meta:
-            carrier["tracestate"] = _meta["tracestate"]
-
-        # Extract context and start span
-        ctx = otel_extract(carrier, context=OtelContext())
-        tracer = trace.get_tracer(__name__)
-        span = tracer.start_span(method, context=ctx, kind=SpanKind.SERVER)
-        return span, set_span_in_context(span)
-
-    @staticmethod
-    def inject_trace_context(arguments: Dict[str, Any]) -> Dict[str, Any]:
-        """Inject current trace context into outgoing MCP request arguments"""
-        carrier = {}
-        TraceContextTextMapPropagator().inject(carrier)
-
-        # Create or update _meta with trace context
-        _meta = arguments.get("_meta", {})
-        if "traceparent" in carrier:
-            _meta["traceparent"] = carrier["traceparent"]
-        if "tracestate" in carrier:
-            _meta["tracestate"] = carrier["tracestate"]
-        arguments["_meta"] = _meta
-
-        return arguments
-
-
-telemetry = TelemetryManager()