autobyteus 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

autobyteus/tools/mcp/__init__.py

@@ -2,14 +2,15 @@
 """
 This package implements the Model Context Protocol (MCP) integration for AutoByteUs.
 It allows AutoByteUs to connect to external MCP servers, discover tools,
-and register them as standard AutoByteUs tools using a handler-based architecture.
+and register them as standard AutoByteUs tools using a stateful, server-centric
+architecture with per-agent isolation.
 """
 import logging
 
 logger = logging.getLogger(__name__)
 
 # The actual 'mcp' library and its components are expected to be installed 
-# in the environment and are used by the internal handlers.
+# in the environment and are used by the internal components.
 
 logger.info("AutoByteUs MCP integration package initialized. Expects 'mcp' library to be available.")
 
@@ -17,9 +18,9 @@ logger.info("AutoByteUs MCP integration package initialized. Expects 'mcp' libra
 from .types import (
     BaseMcpConfig,
     StdioMcpServerConfig,
-    SseMcpServerConfig,
     StreamableHttpMcpServerConfig,
-    McpTransportType
+    McpTransportType,
+    McpServerInstanceKey,
 )
 # Import McpConfigService from config_service.py
 from .config_service import McpConfigService
@@ -28,17 +29,19 @@ from .config_service import McpConfigService
 from .schema_mapper import McpSchemaMapper 
 from .tool import GenericMcpTool
 from .factory import McpToolFactory
-from .registrar import McpToolRegistrar
+from .tool_registrar import McpToolRegistrar
+from .server_instance_manager import McpServerInstanceManager
 
 __all__ = [
     # Types from types.py
     "BaseMcpConfig",
     "StdioMcpServerConfig",
-    "SseMcpServerConfig",
     "StreamableHttpMcpServerConfig",
     "McpTransportType",
-    # Service from config_service.py
+    "McpServerInstanceKey",
+    # Services and Managers
     "McpConfigService",
+    "McpServerInstanceManager",
     # Other public components
     "McpSchemaMapper",
     "GenericMcpTool",

autobyteus/tools/mcp/call_handlers/__init__.py

@@ -8,11 +8,9 @@ for a specific transport protocol (e.g., STDIO, Streamable HTTP).
 from .base_handler import McpCallHandler
 from .stdio_handler import StdioMcpCallHandler
 from .streamable_http_handler import StreamableHttpMcpCallHandler
-from .sse_handler import SseMcpCallHandler
 
 __all__ = [
     "McpCallHandler",
     "StdioMcpCallHandler",
     "StreamableHttpMcpCallHandler",
-    "SseMcpCallHandler",
 ]

autobyteus/tools/mcp/config_service.py

@@ -8,7 +8,6 @@ from typing import List, Dict, Any, Optional, Union, Type
 from .types import (
     BaseMcpConfig,
     StdioMcpServerConfig,
-    SseMcpServerConfig,
     StreamableHttpMcpServerConfig,
     McpTransportType
 )
@@ -38,7 +37,7 @@ class McpConfigService(metaclass=SingletonMeta):
     @staticmethod
     def _create_specific_config(server_id: str, transport_type: McpTransportType, config_data: Dict[str, Any]) -> BaseMcpConfig:
         """
-        Creates a specific McpServerConfig (Stdio, Sse, StreamableHttp) based on transport_type.
+        Creates a specific McpServerConfig (Stdio, StreamableHttp) based on transport_type.
         The 'server_id' is injected.
         Parameters from nested structures like 'stdio_params' are un-nested.
         """
@@ -50,7 +49,6 @@ class McpConfigService(metaclass=SingletonMeta):
 
         transport_specific_params_key_map = {
             McpTransportType.STDIO: "stdio_params",
-            McpTransportType.SSE: "sse_params",
             McpTransportType.STREAMABLE_HTTP: "streamable_http_params"
         }
 
@@ -62,7 +60,6 @@ class McpConfigService(metaclass=SingletonMeta):
             constructor_params.update(specific_params_dict)
         
         constructor_params.pop(transport_specific_params_key_map.get(McpTransportType.STDIO), None)
-        constructor_params.pop(transport_specific_params_key_map.get(McpTransportType.SSE), None)
         constructor_params.pop(transport_specific_params_key_map.get(McpTransportType.STREAMABLE_HTTP), None)
         constructor_params.pop('transport_type', None)
         
@@ -75,8 +72,6 @@ class McpConfigService(metaclass=SingletonMeta):
         try:
             if transport_type == McpTransportType.STDIO:
                 return StdioMcpServerConfig(**constructor_params)
-            elif transport_type == McpTransportType.SSE:
-                return SseMcpServerConfig(**constructor_params)
             elif transport_type == McpTransportType.STREAMABLE_HTTP:
                 return StreamableHttpMcpServerConfig(**constructor_params)
             else:

autobyteus/tools/mcp/factory.py

@@ -2,12 +2,10 @@
 import logging
 from typing import Optional, TYPE_CHECKING
 
-from autobyteus.tools.mcp.tool import GenericMcpTool
+from .tool import GenericMcpTool
 from autobyteus.tools.factory.tool_factory import ToolFactory
 
 if TYPE_CHECKING:
-    from autobyteus.tools.mcp.call_handlers.base_handler import McpCallHandler
-    from autobyteus.tools.mcp.types import BaseMcpConfig
     from autobyteus.tools.parameter_schema import ParameterSchema
     from autobyteus.tools.tool_config import ToolConfig
     from autobyteus.tools.base_tool import BaseTool
@@ -18,52 +16,40 @@ class McpToolFactory(ToolFactory):
     """
     A dedicated factory for creating configured instances of GenericMcpTool.
     
-    This factory captures the necessary context at the time of tool discovery
-    (e.g., server config, remote tool name, call handler) and uses it to 
-    instantiate a GenericMcpTool when requested by the ToolRegistry.
+    This factory captures the key identifiers of a remote tool (server_id,
+    remote_tool_name) and its schema information at the time of discovery.
     """
     def __init__(self,
-                 mcp_server_config: 'BaseMcpConfig',
-                 mcp_remote_tool_name: str,
-                 mcp_call_handler: 'McpCallHandler',
+                 server_id: str,
+                 remote_tool_name: str,
                  registered_tool_name: str,
                  tool_description: str,
                  tool_argument_schema: 'ParameterSchema'):
         """
-        Initializes the factory with the context of a specific remote tool.
+        Initializes the factory with the identifiers and schema of a specific remote tool.
         """
-        self._mcp_server_config = mcp_server_config
-        self._mcp_remote_tool_name = mcp_remote_tool_name
-        self._mcp_call_handler = mcp_call_handler
+        self._server_id = server_id
+        self._remote_tool_name = remote_tool_name
         self._registered_tool_name = registered_tool_name
         self._tool_description = tool_description
         self._tool_argument_schema = tool_argument_schema
         
         logger.debug(
-            f"McpToolFactory created for remote tool '{self._mcp_remote_tool_name}' "
-            f"on server '{self._mcp_server_config.server_id}' (to be registered as '{self._registered_tool_name}')."
+            f"McpToolFactory created for remote tool '{self._remote_tool_name}' "
+            f"on server '{self._server_id}' (to be registered as '{self._registered_tool_name}')."
         )
 
     def create_tool(self, config: Optional['ToolConfig'] = None) -> 'BaseTool':
         """
         Creates and returns a new instance of GenericMcpTool using the
         configuration captured by this factory.
-
-        Args:
-            config: An optional ToolConfig. This is part of the standard factory
-                    interface but is not used by this specific factory, as all
-                    configuration is provided during initialization.
-        
-        Returns:
-            A configured instance of GenericMcpTool.
         """
         if config:
             logger.debug(f"McpToolFactory for '{self._registered_tool_name}' received a ToolConfig, which will be ignored.")
             
         return GenericMcpTool(
-            mcp_server_config=self._mcp_server_config,
-            mcp_remote_tool_name=self._mcp_remote_tool_name,
-            mcp_call_handler=self._mcp_call_handler,
+            server_id=self._server_id,
+            remote_tool_name=self._remote_tool_name,
             name=self._registered_tool_name,
             description=self._tool_description,
             argument_schema=self._tool_argument_schema

autobyteus/tools/mcp/server/__init__.py

@@ -0,0 +1,16 @@
+# file: autobyteus/autobyteus/tools/mcp/server/__init__.py
+"""
+This package contains the core abstractions for managing connections to remote MCP servers.
+"""
+from .base_managed_mcp_server import BaseManagedMcpServer, ServerState
+from .stdio_managed_mcp_server import StdioManagedMcpServer
+from .http_managed_mcp_server import HttpManagedMcpServer
+from .proxy import McpServerProxy
+
+__all__ = [
+    "BaseManagedMcpServer",
+    "ServerState",
+    "StdioManagedMcpServer",
+    "HttpManagedMcpServer",
+    "McpServerProxy",
+]

autobyteus/tools/mcp/server/base_managed_mcp_server.py

@@ -0,0 +1,139 @@
+# file: autobyteus/autobyteus/tools/mcp/server/base_managed_mcp_server.py
+import logging
+import asyncio
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Dict, Any, List, Optional
+from contextlib import AsyncExitStack
+
+from mcp import ClientSession, types as mcp_types
+
+from ..types import BaseMcpConfig
+
+logger = logging.getLogger(__name__)
+
+class ServerState(str, Enum):
+    """Enumerates the possible connection states of a BaseManagedMcpServer."""
+    DISCONNECTED = "disconnected"
+    CONNECTING = "connecting"
+    CONNECTED = "connected"
+    FAILED = "failed"
+    CLOSED = "closed"
+
+class BaseManagedMcpServer(ABC):
+    """
+    Abstract base class representing a connection to a remote MCP server.
+    It manages the entire lifecycle and state of a single server connection.
+    """
+    
+    # --- Attributes ---
+    _config: BaseMcpConfig
+    _state: ServerState
+    _connection_lock: asyncio.Lock
+    _client_session: Optional[ClientSession]
+    _exit_stack: AsyncExitStack
+
+    # --- Initialization ---
+    def __init__(self, config: BaseMcpConfig):
+        self._config = config
+        self._state = ServerState.DISCONNECTED
+        self._connection_lock = asyncio.Lock()
+        self._client_session = None
+        self._exit_stack = AsyncExitStack()
+
+    # --- Public Properties ---
+    @property
+    def server_id(self) -> str:
+        return self._config.server_id
+
+    @property
+    def config(self) -> BaseMcpConfig:
+        return self._config
+        
+    @property
+    def state(self) -> ServerState:
+        return self._state
+
+    # --- Abstract Methods ---
+    @abstractmethod
+    async def _create_client_session(self) -> ClientSession:
+        """
+        Transport-specific logic to establish a connection and return a ClientSession.
+        This method should leverage self._exit_stack to manage resources.
+        """
+        pass
+
+    # --- Public API Methods ---
+    async def connect(self) -> None:
+        """Public method to establish a connection to the server. Idempotent."""
+        if self._state == ServerState.CONNECTED:
+            return
+
+        async with self._connection_lock:
+            # Re-check state after acquiring lock
+            if self._state == ServerState.CONNECTED:
+                return
+            if self._state == ServerState.CONNECTING:
+                logger.debug(f"Connection already in progress for '{self.server_id}'. Awaiting completion.")
+                # A more advanced implementation might use an asyncio.Event to wait here.
+                # For now, serializing via the lock is sufficient.
+                return
+
+            logger.info(f"Connecting to MCP server '{self.server_id}'...")
+            self._state = ServerState.CONNECTING
+            try:
+                # The exit stack must be fresh for each connection attempt.
+                self._exit_stack = AsyncExitStack()
+                self._client_session = await self._create_client_session()
+                self._state = ServerState.CONNECTED
+                logger.info(f"Successfully connected to MCP server '{self.server_id}'.")
+            except Exception as e:
+                self._state = ServerState.FAILED
+                logger.error(f"Failed to connect to MCP server '{self.server_id}': {e}", exc_info=True)
+                # Clean up any partially established resources on failure
+                if self._exit_stack:
+                    await self._exit_stack.aclose()
+                self._client_session = None
+                raise
+
+    async def close(self) -> None:
+        """Public method to gracefully close the connection to the server."""
+        async with self._connection_lock:
+            if self._state in [ServerState.DISCONNECTED, ServerState.CLOSED]:
+                logger.debug(f"Server '{self.server_id}' is already closed or disconnected. No action taken.")
+                return
+
+            logger.info(f"Closing connection to MCP server '{self.server_id}'...")
+            self._state = ServerState.CLOSED
+            
+            try:
+                if self._exit_stack:
+                    await self._exit_stack.aclose()
+            except Exception as e:
+                logger.error(f"Error during resource cleanup for server '{self.server_id}': {e}", exc_info=True)
+            
+            self._client_session = None
+            logger.info(f"Connection to MCP server '{self.server_id}' closed.")
+
+    async def list_remote_tools(self) -> List[mcp_types.Tool]:
+        """Connects if needed and fetches the list of raw tool objects."""
+        if self._state != ServerState.CONNECTED:
+            await self.connect()
+
+        if not self._client_session:
+            raise RuntimeError(f"Cannot list tools: client session not available for server '{self.server_id}'.")
+
+        logger.debug(f"Listing remote tools on server '{self.server_id}'.")
+        result = await self._client_session.list_tools()
+        return result.tools
+
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+        """Connects if needed and executes a tool call on the remote server."""
+        if self._state != ServerState.CONNECTED:
+            await self.connect()
+
+        if not self._client_session:
+            raise RuntimeError(f"Cannot call tool: client session not available for server '{self.server_id}'.")
+
+        logger.debug(f"Calling remote tool '{tool_name}' on server '{self.server_id}'.")
+        return await self._client_session.call_tool(tool_name, arguments)

autobyteus/tools/mcp/server/http_managed_mcp_server.py

@@ -0,0 +1,29 @@
+# file: autobyteus/autobyteus/tools/mcp/server/http_managed_mcp_server.py
+import logging
+from typing import cast
+
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+
+from .base_managed_mcp_server import BaseManagedMcpServer
+from ..types import StreamableHttpMcpServerConfig
+
+logger = logging.getLogger(__name__)
+
+class HttpManagedMcpServer(BaseManagedMcpServer):
+    """Manages the lifecycle of a streamable_http-based MCP server."""
+
+    def __init__(self, config: StreamableHttpMcpServerConfig):
+        super().__init__(config)
+
+    async def _create_client_session(self) -> ClientSession:
+        """Connects to a remote HTTP endpoint and establishes a client session."""
+        config = cast(StreamableHttpMcpServerConfig, self._config)
+        
+        logger.debug(f"Establishing HTTP connection for server '{self.server_id}' to URL: {config.url}")
+        read_stream, write_stream = await self._exit_stack.enter_async_context(
+            streamablehttp_client(config.url, headers=config.headers)
+        )
+        session = await self._exit_stack.enter_async_context(ClientSession(read_stream, write_stream))
+        logger.debug(f"ClientSession established for HTTP server '{self.server_id}'.")
+        return session

autobyteus/tools/mcp/server/proxy.py

@@ -0,0 +1,36 @@
+# file: autobyteus/autobyteus/tools/mcp/server/proxy.py
+import logging
+from typing import Any, Dict
+
+from ..server_instance_manager import McpServerInstanceManager
+
+logger = logging.getLogger(__name__)
+
+class McpServerProxy:
+    """
+    A proxy object that provides the interface of a BaseManagedMcpServer
+    but delegates the actual work to a real server instance retrieved from the
+    McpServerInstanceManager. This decouples the tool from the manager.
+    """
+    def __init__(self, agent_id: str, server_id: str):
+        if not agent_id or not server_id:
+            raise ValueError("McpServerProxy requires both agent_id and server_id.")
+        self._agent_id = agent_id
+        self._server_id = server_id
+        self._instance_manager = McpServerInstanceManager()
+        logger.debug(f"McpServerProxy created for agent '{agent_id}' and server '{server_id}'.")
+
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> Any:
+        """
+        Gets the real server instance from the manager and delegates the tool call.
+        """
+        logger.debug(f"Proxy: Getting server instance for agent '{self._agent_id}', server '{self._server_id}'.")
+        # The manager handles the logic of creating or returning a cached instance.
+        real_server_instance = self._instance_manager.get_server_instance(
+            agent_id=self._agent_id,
+            server_id=self._server_id
+        )
+        
+        logger.debug(f"Proxy: Delegating 'call_tool({tool_name})' to real server instance.")
+        # The real instance handles its own connection state.
+        return await real_server_instance.call_tool(tool_name, arguments)

autobyteus/tools/mcp/server/stdio_managed_mcp_server.py

@@ -0,0 +1,33 @@
+# file: autobyteus/autobyteus/tools/mcp/server/stdio_managed_mcp_server.py
+import logging
+from typing import cast
+
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+from .base_managed_mcp_server import BaseManagedMcpServer
+from ..types import StdioMcpServerConfig
+
+logger = logging.getLogger(__name__)
+
+class StdioManagedMcpServer(BaseManagedMcpServer):
+    """Manages the lifecycle of a stdio-based MCP server."""
+
+    def __init__(self, config: StdioMcpServerConfig):
+        super().__init__(config)
+
+    async def _create_client_session(self) -> ClientSession:
+        """Starts a subprocess and establishes a client session over its stdio."""
+        config = cast(StdioMcpServerConfig, self._config)
+        stdio_params = StdioServerParameters(
+            command=config.command,
+            args=config.args,
+            env=config.env,
+            cwd=config.cwd
+        )
+        
+        logger.debug(f"Establishing stdio connection for server '{self.server_id}' with command: {config.command}")
+        read_stream, write_stream = await self._exit_stack.enter_async_context(stdio_client(stdio_params))
+        session = await self._exit_stack.enter_async_context(ClientSession(read_stream, write_stream))
+        logger.debug(f"ClientSession established for stdio server '{self.server_id}'.")
+        return session

autobyteus/tools/mcp/server_instance_manager.py

@@ -0,0 +1,93 @@
+# file: autobyteus/autobyteus/tools/mcp/server_instance_manager.py
+import logging
+from typing import Dict, List, AsyncIterator
+from contextlib import asynccontextmanager
+
+from autobyteus.utils.singleton import SingletonMeta
+from .config_service import McpConfigService
+from .server import BaseManagedMcpServer, StdioManagedMcpServer, HttpManagedMcpServer
+from .types import McpTransportType, McpServerInstanceKey, BaseMcpConfig
+
+logger = logging.getLogger(__name__)
+
+class McpServerInstanceManager(metaclass=SingletonMeta):
+    """
+    Manages the lifecycle of BaseManagedMcpServer instances, providing
+    isolated server connections on a per-agent, per-server_id basis.
+    """
+    def __init__(self):
+        self._config_service = McpConfigService()
+        self._active_servers: Dict[McpServerInstanceKey, BaseManagedMcpServer] = {}
+        logger.info("McpServerInstanceManager initialized.")
+    
+    def _create_server_instance(self, server_config: BaseMcpConfig) -> BaseManagedMcpServer:
+        """Factory method to create a server instance from a config."""
+        if server_config.transport_type == McpTransportType.STDIO:
+            return StdioManagedMcpServer(server_config)
+        elif server_config.transport_type == McpTransportType.STREAMABLE_HTTP:
+            return HttpManagedMcpServer(server_config)
+        else:
+            raise NotImplementedError(f"No ManagedMcpServer implementation for transport type '{server_config.transport_type}'.")
+
+    def get_server_instance(self, agent_id: str, server_id: str) -> BaseManagedMcpServer:
+        """
+        Retrieves or creates a dedicated, long-lived managed server instance
+        for a given agent and server ID.
+        """
+        instance_key = McpServerInstanceKey(agent_id=agent_id, server_id=server_id)
+        
+        if instance_key in self._active_servers:
+            return self._active_servers[instance_key]
+
+        logger.info(f"Creating new persistent server instance for {instance_key}.")
+        config = self._config_service.get_config(server_id)
+        if not config:
+            raise ValueError(f"No configuration found for server_id '{server_id}'.")
+
+        server_instance = self._create_server_instance(config)
+        self._active_servers[instance_key] = server_instance
+        return server_instance
+
+    @asynccontextmanager
+    async def managed_discovery_session(self, server_config: BaseMcpConfig) -> AsyncIterator[BaseManagedMcpServer]:
+        """
+        Provides a temporary server instance for a one-shot operation like discovery.
+        Guarantees the instance is closed upon exiting the context.
+        This method uses the provided config object directly and does not look it up
+        in the config service, making it suitable for stateless previews.
+        """
+        if not server_config:
+            raise ValueError("A valid BaseMcpConfig object must be provided to managed_discovery_session.")
+        
+        logger.debug(f"Creating temporary discovery instance for server '{server_config.server_id}'.")
+        temp_server_instance = self._create_server_instance(server_config)
+        try:
+            yield temp_server_instance
+        finally:
+            logger.debug(f"Closing temporary discovery instance for server '{server_config.server_id}'.")
+            await temp_server_instance.close()
+
+    async def cleanup_mcp_server_instances_for_agent(self, agent_id: str):
+        """
+        Closes all active MCP server instances and removes them from the cache for a specific agent.
+        """
+        logger.info(f"Cleaning up all MCP server instances for agent '{agent_id}'.")
+        keys_to_remove: List[McpServerInstanceKey] = []
+        for instance_key, server_instance in self._active_servers.items():
+            if instance_key.agent_id == agent_id:
+                try:
+                    await server_instance.close()
+                except Exception as e:
+                    logger.error(f"Error closing MCP server '{instance_key.server_id}' for agent '{instance_key.agent_id}': {e}", exc_info=True)
+                keys_to_remove.append(instance_key)
+        
+        for key in keys_to_remove:
+            del self._active_servers[key]
+        logger.info(f"Finished cleaning up MCP server instances for agent '{agent_id}'.")
+
+    async def cleanup_all_mcp_server_instances(self):
+        """Closes all active MCP server instances for all agents and clears the cache."""
+        logger.info("Cleaning up all active MCP server instances.")
+        agent_ids = {key.agent_id for key in self._active_servers.keys()}
+        for agent_id in agent_ids:
+            await self.cleanup_mcp_server_instances_for_agent(agent_id)

autobyteus/tools/mcp/tool.py

@@ -4,98 +4,80 @@ from typing import Any, Optional, TYPE_CHECKING
 
 from autobyteus.tools.base_tool import BaseTool
 from autobyteus.tools.parameter_schema import ParameterSchema
+from .server.proxy import McpServerProxy
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from .call_handlers.base_handler import McpCallHandler
-    from .types import BaseMcpConfig
 
 logger = logging.getLogger(__name__)
 
 class GenericMcpTool(BaseTool):
     """
     A generic tool wrapper for executing tools on a remote MCP server.
-    This tool delegates the entire remote call, including connection and
-    protocol specifics, to an MCP call handler.
+    This tool is a lightweight blueprint. At execution time, it uses a proxy
+    to interact with the server, completely hiding the connection management logic.
     """
 
     def __init__(self,
-                 mcp_server_config: 'BaseMcpConfig',
-                 mcp_remote_tool_name: str,
-                 mcp_call_handler: 'McpCallHandler',
+                 server_id: str,
+                 remote_tool_name: str,
                  name: str, 
                  description: str,
                  argument_schema: ParameterSchema):
         """
-        Initializes the GenericMcpTool instance.
+        Initializes the GenericMcpTool instance with identifiers.
         """
         super().__init__() 
         
-        self._mcp_server_config = mcp_server_config
-        self._mcp_remote_tool_name = mcp_remote_tool_name
-        self._mcp_call_handler = mcp_call_handler
+        self._server_id = server_id
+        self._remote_tool_name = remote_tool_name
         
+        # Instance-specific properties for schema generation
         self._instance_name = name
         self._instance_description = description
         self._instance_argument_schema = argument_schema
         
-        # Override the base class's schema-related methods with instance-specific
-        # versions for correct validation and usage generation.
         self.get_name = self.get_instance_name
         self.get_description = self.get_instance_description
         self.get_argument_schema = self.get_instance_argument_schema
         
-        logger.info(f"GenericMcpTool instance created for remote tool '{mcp_remote_tool_name}' on server '{self._mcp_server_config.server_id}'. "
+        logger.info(f"GenericMcpTool instance created for remote tool '{remote_tool_name}' on server '{self._server_id}'. "
                     f"Registered in AutoByteUs as '{self._instance_name}'.")
 
     # --- Getters for instance-specific data ---
+    def get_instance_name(self) -> str: return self._instance_name
+    def get_instance_description(self) -> str: return self._instance_description
+    def get_instance_argument_schema(self) -> ParameterSchema: return self._instance_argument_schema
 
-    def get_instance_name(self) -> str:
-        return self._instance_name
-
-    def get_instance_description(self) -> str:
-        return self._instance_description
-
-    def get_instance_argument_schema(self) -> ParameterSchema:
-        return self._instance_argument_schema
-
-    # --- Base class methods that are NOT overridden at instance level ---
-
+    # --- Base class methods (class-level, not instance-level) ---
     @classmethod
-    def get_name(cls) -> str:
-        return "GenericMcpTool" 
-
+    def get_name(cls) -> str: return "GenericMcpTool"
     @classmethod
-    def get_description(cls) -> str:
-        return "A generic wrapper for executing tools on a remote MCP server. Specifics are instance-based."
-
+    def get_description(cls) -> str: return "A generic wrapper for executing remote MCP tools."
     @classmethod
-    def get_argument_schema(cls) -> Optional[ParameterSchema]:
-        return None 
+    def get_argument_schema(cls) -> Optional[ParameterSchema]: return None 
 
     async def _execute(self, context: 'AgentContext', **kwargs: Any) -> Any:
         """
-        Executes the remote MCP tool by delegating to the injected call handler.
+        Creates a proxy for the remote server and executes the tool call.
+        The proxy handles all interaction with the McpServerInstanceManager.
         """
+        agent_id = context.agent_id
         tool_name_for_log = self.get_instance_name()
-        logger.info(f"GenericMcpTool '{tool_name_for_log}': Delegating call for remote tool '{self._mcp_remote_tool_name}' "
-                    f"on server '{self._mcp_server_config.server_id}' to handler.")
         
-        if not self._mcp_call_handler:
-             logger.error(f"GenericMcpTool '{tool_name_for_log}': McpCallHandler is not set. Cannot execute.")
-             raise RuntimeError("McpCallHandler not available in GenericMcpTool instance.")
-
+        logger.info(f"GenericMcpTool '{tool_name_for_log}': Creating proxy for agent '{agent_id}' and server '{self._server_id}'.")
+        
         try:
-            # The handler is responsible for the entire end-to-end call.
-            return await self._mcp_call_handler.handle_call(
-                config=self._mcp_server_config,
-                remote_tool_name=self._mcp_remote_tool_name,
+            # The proxy is created on-demand for each execution.
+            proxy = McpServerProxy(agent_id=agent_id, server_id=self._server_id)
+            
+            return await proxy.call_tool(
+                tool_name=self._remote_tool_name,
                 arguments=kwargs
             )
         except Exception as e:
             logger.error(
-                f"The MCP call handler for tool '{tool_name_for_log}' raised an exception: {e}",
+                f"Execution failed for tool '{tool_name_for_log}' on server '{self._server_id}' for agent '{agent_id}': {e}",
                 exc_info=True
             )
-            # Re-raise to ensure the agent knows the tool call failed.
             raise