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

{fast_agent_mcp-0.2.19.dist-info → fast_agent_mcp-0.2.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fast-agent-mcp
-Version: 0.2.19
+Version: 0.2.20
 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

{fast_agent_mcp-0.2.19.dist-info → fast_agent_mcp-0.2.20.dist-info}/RECORD

@@ -1,11 +1,11 @@
-mcp_agent/__init__.py,sha256=-AIoeL4c9UAp_P4U0z-uIWTTmQWdihOis5nbQ5L_eao,1664
+mcp_agent/__init__.py,sha256=18T0AG0W9sJhTY38O9GFFOzliDhxx9p87CvRyti9zbw,1620
 mcp_agent/app.py,sha256=WRsiUdwy_9IAnaGRDwuLm7pzgQpt2wgsg10vBOpfcwM,5539
-mcp_agent/config.py,sha256=4MB8QBwGb6MPPRc85p-xdCzRloGwpWsPfEgxsoS_4N0,12159
+mcp_agent/config.py,sha256=_b5JeS2nWHScSUUTu6wYxXzdfKefoqII305ecKcw7Gs,12248
 mcp_agent/console.py,sha256=Gjf2QLFumwG1Lav__c07X_kZxxEUSkzV-1_-YbAwcwo,813
-mcp_agent/context.py,sha256=fHyDjeZpHYRBOCVY58hVcFQxybOXSJmuui2o51kLbuA,7307
+mcp_agent/context.py,sha256=Kb3s_0MolHx7AeTs1NVcY3ly-xFBd35o8LT7Srpx9is,7334
 mcp_agent/context_dependent.py,sha256=QXfhw3RaQCKfscEEBRGuZ3sdMWqkgShz2jJ1ivGGX1I,1455
 mcp_agent/event_progress.py,sha256=3dqk5Pn1tAG_m_wn4IPNwLWLyzm7CyKIidqHN-4l-JY,2736
-mcp_agent/mcp_server_registry.py,sha256=pSD3euU-Oc2LAVenqkLU7UmutAzk6A9liYVLjCj4J70,10068
+mcp_agent/mcp_server_registry.py,sha256=jUmCdfcpTitXm1-3TxpWsdRWY_8phdKNYgXwB16ZSVU,10100
 mcp_agent/progress_display.py,sha256=GeJU9VUt6qKsFVymG688hCMVCsAygG9ifiiEb5IcbN4,361
 mcp_agent/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mcp_agent/agents/agent.py,sha256=GgaUHoilgqzh9PQYr5k2WiPj4pagwicf9-ZLFsHkNNo,3848
@@ -34,7 +34,7 @@ mcp_agent/core/direct_factory.py,sha256=d96OM1yS3eIocIiaA9FQt6C2zr6VDUyCJBTZCp_D
 mcp_agent/core/enhanced_prompt.py,sha256=bzvcengS7XzHWB7NWhyxHM3hhO2HI4zP5DbGXAOw0Jw,19155
 mcp_agent/core/error_handling.py,sha256=xoyS2kLe0eG0bj2eSJCJ2odIhGUve2SbDR7jP-A-uRw,624
 mcp_agent/core/exceptions.py,sha256=ENAD_qGG67foxy6vDkIvc-lgopIUQy6O7zvNPpPXaQg,2289
-mcp_agent/core/fastagent.py,sha256=OkS1mazgMUJyA02RbW-9z2nI6XQ4kKCLfyjgAkgv0O8,22708
+mcp_agent/core/fastagent.py,sha256=WEEGz2WBAddDGNeWJwqwFIPLiQnLjaNxZLoMR0peyyU,22884
 mcp_agent/core/interactive_prompt.py,sha256=w3VyRzW4hzn0xhWZRwo_qRRAD5WVSrJYe8QDe1XZ55Y,24252
 mcp_agent/core/mcp_content.py,sha256=2D7KHY9mG_vxoDwFLKvsPQV9VRIzHItM7V-jcEnACh8,8878
 mcp_agent/core/prompt.py,sha256=qnintOUGEoDPYLI9bu9G2OlgVMCe5ZPUZilgMzydXhc,7919
@@ -48,7 +48,7 @@ mcp_agent/human_input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 mcp_agent/human_input/handler.py,sha256=s712Z5ssTCwjL9-VKoIdP5CtgMh43YvepynYisiWTTA,3144
 mcp_agent/human_input/types.py,sha256=RtWBOVzy8vnYoQrc36jRLn8z8N3C4pDPMBN5vF6qM5Y,1476
 mcp_agent/llm/__init__.py,sha256=d8zgwG-bRFuwiMNMYkywg_qytk4P8lawyld_meuUmHI,68
-mcp_agent/llm/augmented_llm.py,sha256=fP2uWIFY9qaEuY0mehti4A3NjhvGuj-TebLI0FVTbcM,23380
+mcp_agent/llm/augmented_llm.py,sha256=ASe604OhrMZ9dVoGEUEpUQaY6fFamz4gL8ttzWP_9m0,24212
 mcp_agent/llm/augmented_llm_passthrough.py,sha256=zHcctNpwg4EFJvD1x9Eg443SVX-uyzFphLikwF_yVE0,6288
 mcp_agent/llm/augmented_llm_playback.py,sha256=6L_RWIK__R67oZK7u3Xt3hWy1T2LnHXIO-efqgP3tPw,4177
 mcp_agent/llm/memory.py,sha256=HQ_c1QemOUjrkY6Z2omE6BG5fXga7y4jN7KCMOuGjPs,3345
@@ -60,11 +60,11 @@ mcp_agent/llm/sampling_converter.py,sha256=C7wPBlmT0eD90XWabC22zkxsrVHKCrjwIwg6c
 mcp_agent/llm/sampling_format_converter.py,sha256=xGz4odHpOcP7--eFaJaFtUR8eR9jxZS7MnLH6J7n0EU,1263
 mcp_agent/llm/providers/__init__.py,sha256=heVxtmuqFJOnjjxHz4bWSqTAxXoN1E8twC_gQ_yJpHk,265
 mcp_agent/llm/providers/anthropic_utils.py,sha256=vYDN5G5jKMhD2CQg8veJYab7tvvzYkDMq8M1g_hUAQg,3275
-mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=poouQMsDoZSH-5a_TL2Z2EFPSqFlsAgXuKuYcqge-Gg,15468
+mcp_agent/llm/providers/augmented_llm_anthropic.py,sha256=RQ4r5Q84VJ_dyuNo23b-EMzvq6RrpspzIQWtfVUfw6M,15468
 mcp_agent/llm/providers/augmented_llm_deepseek.py,sha256=NiZK5nv91ZS2VgVFXpbsFNFYLsLcppcbo_RstlRMd7I,1145
 mcp_agent/llm/providers/augmented_llm_generic.py,sha256=5Uq8ZBhcFuQTt7koP_5ykolREh2iWu8zKhNbh3pM9lQ,1210
 mcp_agent/llm/providers/augmented_llm_google.py,sha256=N0a2fphVtkvNYxKQpEX6J4tlO1C_mRw4sw3LBXnrOeI,1130
-mcp_agent/llm/providers/augmented_llm_openai.py,sha256=XFFoIMmXCoigC98zrR0_1c7DsyS4ep7hLvklmdn4jqU,14085
+mcp_agent/llm/providers/augmented_llm_openai.py,sha256=TumZs1y678IvyvYIehf8xSDqYWqC44dWrIbqFGtz03g,14085
 mcp_agent/llm/providers/augmented_llm_openrouter.py,sha256=V_TlVKm92GHBxYIo6gpvH_6cAaIdppS25Tz6x5T7LW0,2341
 mcp_agent/llm/providers/multipart_converter_anthropic.py,sha256=t5lHYGfFUacJldnrVtMNW-8gEMoto8Y7hJkDrnyZR-Y,16650
 mcp_agent/llm/providers/multipart_converter_openai.py,sha256=XPIulWntNpZWNGWrc240StPzok2RqrDAV7OigDwQ1uU,15850
@@ -84,8 +84,8 @@ mcp_agent/mcp/gen_client.py,sha256=fAVwFVCgSamw4PwoWOV4wrK9TABx1S_zZv8BctRyF2k,3
 mcp_agent/mcp/interfaces.py,sha256=PAou8znAl2HgtvfCpLQOZFbKra9F72OcVRfBJbboNX8,6965
 mcp_agent/mcp/logger_textio.py,sha256=vljC1BtNTCxBAda9ExqNB-FwVNUZIuJT3h1nWmCjMws,3172
 mcp_agent/mcp/mcp_agent_client_session.py,sha256=RMYNltc2pDIzxwEJSS5589RbvPO0KWV4Y3jSyAmhKf0,4181
-mcp_agent/mcp/mcp_aggregator.py,sha256=RjRcYHMKt5Wn85JWVar6X0hZLYtBeHrctiBBAK5AYcc,40584
-mcp_agent/mcp/mcp_connection_manager.py,sha256=R_oGvFkolZJ_i3SizIIlKS_NPjXscsWLSOf1x9Zu0dM,14008
+mcp_agent/mcp/mcp_aggregator.py,sha256=c3UDWsTgHMcpHPx1p-vVru4y3eVO1jBQyLzwEMH2RHU,40237
+mcp_agent/mcp/mcp_connection_manager.py,sha256=L5Dk4cyarN_v2rfktkrfZJR4xUuD3yN_hUyQnKHBWgM,14044
 mcp_agent/mcp/mime_utils.py,sha256=difepNR_gpb4MpMLkBRAoyhDk-AjXUHTiqKvT_VwS1o,1805
 mcp_agent/mcp/prompt_message_multipart.py,sha256=BDwRdNwyWHb2q2bccDb2iR2VlORqVvkvoG3xYzcMpCE,4403
 mcp_agent/mcp/prompt_render.py,sha256=k3v4BZDThGE2gGiOYVQtA6x8WTEdOuXIEnRafANhN1U,2996
@@ -102,7 +102,7 @@ mcp_agent/mcp/prompts/prompt_load.py,sha256=Zo0FogqWFEG5FtF1d9ZH-RWsCSSMsi5FIEQH
 mcp_agent/mcp/prompts/prompt_server.py,sha256=SiUR2xYfd3vEpghnYRdzz2rFEMtAbCKx2xzUXgvz1g8,18501
 mcp_agent/mcp/prompts/prompt_template.py,sha256=EejiqGkau8OizORNyKTUwUjrPof5V-hH1H_MBQoQfXw,15732
 mcp_agent/mcp_server/__init__.py,sha256=zBU51ITHIEPScd9nRafnhEddsWqXRPAAvHhkrbRI2_4,155
-mcp_agent/mcp_server/agent_server.py,sha256=yne6wdc2sHwzOGuLFikLxUnHEuPEr3l8cfPlT_jbzBI,19811
+mcp_agent/mcp_server/agent_server.py,sha256=s-nI0uTNWx4nYDDM_5GmuY5x6ZeFkymfNoCSuwuBRd8,19891
 mcp_agent/resources/examples/data-analysis/analysis-campaign.py,sha256=16gxrQ5kM8fb8tPwSCMXaitonk3PSEhz28njWwPxXrw,7269
 mcp_agent/resources/examples/data-analysis/analysis.py,sha256=M9z8Q4YC5OGuqSa5uefYmmfmctqMn-WqCSfg5LI407o,2609
 mcp_agent/resources/examples/data-analysis/fastagent.config.yaml,sha256=ini94PHyJCfgpjcjHKMMbGuHs6LIj46F1NwY0ll5HVk,1609
@@ -143,8 +143,8 @@ mcp_agent/resources/examples/workflows/parallel.py,sha256=DQ5vY5-h8Qa5QHcYjsWXhZ
 mcp_agent/resources/examples/workflows/router.py,sha256=E4x_-c3l4YW9w1i4ARcDtkdeqIdbWEGfsMzwLYpdbVc,1677
 mcp_agent/resources/examples/workflows/short_story.txt,sha256=X3y_1AyhLFN2AKzCKvucJtDgAFIJfnlbsbGZO5bBWu0,1187
 mcp_agent/ui/console_display.py,sha256=TVGDtJ37hc6UG0ei9g7ZPZZfFNeS1MYozt-Mx8HsPCk,9752
-fast_agent_mcp-0.2.19.dist-info/METADATA,sha256=slU0l8N_MAEEmGn3bla4jeHibkCq3DGTtngvii6xrro,30142
-fast_agent_mcp-0.2.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-fast_agent_mcp-0.2.19.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
-fast_agent_mcp-0.2.19.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
-fast_agent_mcp-0.2.19.dist-info/RECORD,,
+fast_agent_mcp-0.2.20.dist-info/METADATA,sha256=RlU6MHHAJoP4xuuA8QsIspMEZfGdSKDo76so374wzA4,30142
+fast_agent_mcp-0.2.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+fast_agent_mcp-0.2.20.dist-info/entry_points.txt,sha256=bRniFM5zk3Kix5z7scX0gf9VnmGQ2Cz_Q1Gh7Ir4W00,186
+fast_agent_mcp-0.2.20.dist-info/licenses/LICENSE,sha256=cN3FxDURL9XuzE5mhK9L2paZo82LTfjwCYVT7e3j0e4,10939
+fast_agent_mcp-0.2.20.dist-info/RECORD,,

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

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

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

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)

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

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

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

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,
@@ -43,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):
     """
@@ -231,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 []
 
@@ -278,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,
@@ -320,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."""
@@ -420,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,
@@ -506,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",
@@ -564,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:
@@ -616,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:
@@ -664,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:
@@ -942,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

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

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