@dexto/core 1.1.10 → 1.2.0

package/dist/mcp/manager.js

@@ -1,20 +1,74 @@
+import "../chunk-C6A6W6XS.js";
 import { MCPClient } from "./mcp-client.js";
 import { logger } from "../logger/index.js";
 import { MCPError } from "./errors.js";
+import { eventBus } from "../events/index.js";
 class MCPManager {
   clients = /* @__PURE__ */ new Map();
   connectionErrors = {};
-  toolToClientMap = /* @__PURE__ */ new Map();
-  serverToolsMap = /* @__PURE__ */ new Map();
+  configCache = /* @__PURE__ */ new Map();
+  // Store original configs for restart
+  toolCache = /* @__PURE__ */ new Map();
   toolConflicts = /* @__PURE__ */ new Set();
-  promptToClientMap = /* @__PURE__ */ new Map();
-  resourceToClientMap = /* @__PURE__ */ new Map();
+  // Track which tool names have conflicts
+  promptCache = /* @__PURE__ */ new Map();
+  resourceCache = /* @__PURE__ */ new Map();
   sanitizedNameToServerMap = /* @__PURE__ */ new Map();
+  approvalManager = null;
+  // Will be set by service initializer
   // Use a distinctive delimiter that won't appear in normal server/tool names
   // Using double hyphen as it's allowed in LLM tool name patterns (^[a-zA-Z0-9_-]+$)
   static SERVER_DELIMITER = "--";
   constructor() {
   }
+  /**
+   * Set the approval manager for handling elicitation requests from MCP servers
+   *
+   * TODO: Consider making ApprovalManager a required constructor parameter instead of using a setter.
+   * This would make the dependency explicit and remove the need for defensive `if (!approvalManager)` checks.
+   * Current setter pattern is useful if we want to expose MCPManager as a standalone service to end-users
+   * without requiring them to know about ApprovalManager.
+   */
+  setApprovalManager(approvalManager) {
+    this.approvalManager = approvalManager;
+    for (const [_name, client] of this.clients.entries()) {
+      if (client instanceof MCPClient) {
+        client.setApprovalManager(approvalManager);
+      }
+    }
+  }
+  buildQualifiedResourceKey(serverName, resourceUri) {
+    return `mcp:${serverName}:${resourceUri}`;
+  }
+  parseQualifiedResourceKey(key) {
+    if (!key.startsWith("mcp:")) {
+      throw MCPError.resourceNotFound(key);
+    }
+    const [, serverName, ...rest] = key.split(":");
+    if (!serverName || rest.length === 0) {
+      throw MCPError.resourceNotFound(key);
+    }
+    return { serverName, resourceUri: rest.join(":") };
+  }
+  removeServerResources(serverName) {
+    for (const [key, entry] of Array.from(this.resourceCache.entries())) {
+      if (entry.serverName === serverName) {
+        this.resourceCache.delete(key);
+      }
+    }
+  }
+  getResourceCacheEntry(resourceKey) {
+    if (this.resourceCache.has(resourceKey)) {
+      return this.resourceCache.get(resourceKey);
+    }
+    try {
+      const { serverName, resourceUri } = this.parseQualifiedResourceKey(resourceKey);
+      const canonicalKey = this.buildQualifiedResourceKey(serverName, resourceUri);
+      return this.resourceCache.get(canonicalKey);
+    } catch {
+      return void 0;
+    }
+  }
   /**
    * Register a client that provides tools (and potentially more)
    * @param name Unique name for the client
@@ -32,53 +86,66 @@ class MCPManager {
     }
     this.clients.set(name, client);
     this.sanitizedNameToServerMap.set(sanitizedName, name);
+    this.setupClientNotifications(name, client);
     logger.info(`Registered client: ${name}`);
     delete this.connectionErrors[name];
   }
+  /**
+   * Clears all cached data for a disconnected MCP client
+   *
+   * Performs comprehensive cleanup of tool, prompt, and resource caches.
+   * Uses two-pass algorithm to detect and resolve tool name conflicts:
+   * if a conflicted tool now has only one provider, restores simple name.
+   *
+   * @param clientName - The name/identifier of the MCP server being removed
+   * @private
+   */
   clearClientCache(clientName) {
     const client = this.clients.get(clientName);
     if (!client) return;
-    const hadServerTools = this.serverToolsMap.has(clientName);
-    this.serverToolsMap.delete(clientName);
     const sanitizedName = this.sanitizeServerName(clientName);
     if (this.sanitizedNameToServerMap.get(sanitizedName) === clientName) {
       this.sanitizedNameToServerMap.delete(sanitizedName);
     }
-    [this.toolToClientMap, this.promptToClientMap, this.resourceToClientMap].forEach(
-      (cacheMap) => {
-        for (const [key, mappedClient] of Array.from(cacheMap.entries())) {
-          if (mappedClient === client) {
-            cacheMap.delete(key);
-          }
-        }
+    const removedToolBaseNames = /* @__PURE__ */ new Set();
+    for (const [toolKey, entry] of Array.from(this.toolCache.entries())) {
+      if (entry.serverName === clientName) {
+        const delimiterIndex = toolKey.lastIndexOf(MCPManager.SERVER_DELIMITER);
+        const baseName = delimiterIndex === -1 ? toolKey : toolKey.substring(delimiterIndex + MCPManager.SERVER_DELIMITER.length);
+        removedToolBaseNames.add(baseName);
+        this.toolCache.delete(toolKey);
       }
-    );
-    if (hadServerTools) {
-      this.rebuildToolConflicts();
     }
-    logger.debug(`Cleared cache for client: ${clientName}`);
-  }
-  rebuildToolConflicts() {
-    this.toolConflicts.clear();
-    const toolCounts = /* @__PURE__ */ new Map();
-    for (const serverTools of this.serverToolsMap.values()) {
-      for (const toolName of serverTools.keys()) {
-        toolCounts.set(toolName, (toolCounts.get(toolName) || 0) + 1);
+    for (const baseName of removedToolBaseNames) {
+      const remainingTools = Array.from(this.toolCache.entries()).filter(([key, _]) => {
+        const delimiterIndex = key.lastIndexOf(MCPManager.SERVER_DELIMITER);
+        const bn = delimiterIndex === -1 ? key : key.substring(delimiterIndex + MCPManager.SERVER_DELIMITER.length);
+        return bn === baseName;
+      });
+      if (remainingTools.length === 0) {
+        this.toolConflicts.delete(baseName);
+      } else if (remainingTools.length === 1 && this.toolConflicts.has(baseName)) {
+        const singleTool = remainingTools[0];
+        if (singleTool) {
+          const [qualifiedKey, entry] = singleTool;
+          this.toolCache.delete(qualifiedKey);
+          this.toolCache.set(baseName, entry);
+          this.toolConflicts.delete(baseName);
+          logger.debug(`Restored tool '${baseName}' to simple name (conflict resolved)`);
+        }
       }
     }
-    for (const [toolName, count] of toolCounts.entries()) {
-      if (count > 1) {
-        this.toolConflicts.add(toolName);
-        this.toolToClientMap.delete(toolName);
+    for (const [promptName, entry] of Array.from(this.promptCache.entries())) {
+      if (entry.serverName === clientName) {
+        this.promptCache.delete(promptName);
       }
     }
-    for (const [_, serverTools] of this.serverToolsMap.entries()) {
-      for (const [toolName, client] of serverTools.entries()) {
-        if (!this.toolConflicts.has(toolName)) {
-          this.toolToClientMap.set(toolName, client);
-        }
+    for (const [key, entry] of Array.from(this.resourceCache.entries())) {
+      if (entry.client === client || entry.serverName === clientName) {
+        this.resourceCache.delete(key);
       }
     }
+    logger.debug(`Cleared cache for client: ${clientName}`);
   }
   /**
    * Sanitize server name for use in tool prefixing.
@@ -87,25 +154,80 @@ class MCPManager {
   sanitizeServerName(serverName) {
     return serverName.replace(/[^a-zA-Z0-9_-]/g, "_");
   }
+  /**
+   * Updates internal caches for a connected MCP client
+   *
+   * This method performs initial cache population after a client connects.
+   * It fetches and caches tools, prompts, and resources from the MCP server,
+   * implementing conflict detection and resolution for tool names.
+   *
+   * @param clientName - The name/identifier of the MCP server
+   * @param client - The connected MCP client instance
+   *
+   * @remarks
+   * **Tool Caching:**
+   * - Fetches all tools and caches them with full definitions
+   * - Detects naming conflicts when multiple servers provide same tool name
+   * - On conflict: uses qualified names (`server--toolname`) for all conflicting tools
+   * - Updates toolConflicts set to track which base names have conflicts
+   *
+   * **Prompt Caching:**
+   * - Fetches all prompts and their metadata (description, arguments)
+   * - Stores full prompt definitions in promptCache for efficient access
+   * - Falls back to minimal metadata if full definition fetch fails
+   *
+   * **Resource Caching:**
+   * - Fetches all resource summaries (uri, name, mimeType)
+   * - Stores resource metadata in resourceCache for quick lookups
+   *
+   * **Error Handling:**
+   * - Tool fetch errors abort caching entirely (early return)
+   * - Prompt/resource errors log warnings but don't block other caching
+   * - Individual prompt metadata errors are caught and logged
+   *
+   * @private
+   */
   async updateClientCache(clientName, client) {
-    const serverTools = /* @__PURE__ */ new Map();
-    this.serverToolsMap.set(clientName, serverTools);
     try {
       const tools = await client.getTools();
       logger.debug(
         `\u{1F527} Discovered ${Object.keys(tools).length} tools from server '${clientName}': [${Object.keys(tools).join(", ")}]`
       );
       for (const toolName in tools) {
-        serverTools.set(toolName, client);
-        const existingClient = this.toolToClientMap.get(toolName);
-        if (existingClient && existingClient !== client) {
+        const toolDef = tools[toolName];
+        if (!toolDef) continue;
+        const existingEntry = this.toolCache.get(toolName);
+        if (existingEntry && existingEntry.serverName !== clientName) {
           this.toolConflicts.add(toolName);
-          this.toolToClientMap.delete(toolName);
+          this.toolCache.delete(toolName);
+          const existingSanitized = this.sanitizeServerName(existingEntry.serverName);
+          const existingQualified = `${existingSanitized}${MCPManager.SERVER_DELIMITER}${toolName}`;
+          this.toolCache.set(existingQualified, existingEntry);
+          const newSanitized = this.sanitizeServerName(clientName);
+          const newQualified = `${newSanitized}${MCPManager.SERVER_DELIMITER}${toolName}`;
+          this.toolCache.set(newQualified, {
+            serverName: clientName,
+            client,
+            definition: toolDef
+          });
           logger.warn(
-            `\u26A0\uFE0F  Tool conflict detected for '${toolName}' - will use server prefix`
+            `\u26A0\uFE0F  Tool conflict detected for '${toolName}' - using server prefixes: ${existingQualified}, ${newQualified}`
           );
-        } else if (!this.toolConflicts.has(toolName)) {
-          this.toolToClientMap.set(toolName, client);
+        } else if (this.toolConflicts.has(toolName)) {
+          const sanitizedName = this.sanitizeServerName(clientName);
+          const qualifiedName = `${sanitizedName}${MCPManager.SERVER_DELIMITER}${toolName}`;
+          this.toolCache.set(qualifiedName, {
+            serverName: clientName,
+            client,
+            definition: toolDef
+          });
+          logger.debug(`\u2705 Tool '${qualifiedName}' cached (known conflict)`);
+        } else {
+          this.toolCache.set(toolName, {
+            serverName: clientName,
+            client,
+            definition: toolDef
+          });
           logger.debug(`\u2705 Tool '${toolName}' mapped to ${clientName}`);
         }
       }
@@ -120,17 +242,33 @@ class MCPManager {
     }
     try {
       const prompts = await client.listPrompts();
-      prompts.forEach((promptName) => {
-        this.promptToClientMap.set(promptName, client);
-      });
-      logger.debug(`Cached prompts for client: ${clientName}`);
+      for (const prompt of prompts) {
+        const definition = {
+          name: prompt.name,
+          ...prompt.title && { title: prompt.title },
+          ...prompt.description && { description: prompt.description },
+          ...prompt.arguments && { arguments: prompt.arguments }
+        };
+        this.promptCache.set(prompt.name, {
+          serverName: clientName,
+          client,
+          definition
+        });
+      }
+      logger.debug(`Cached ${prompts.length} prompts for client: ${clientName}`);
     } catch (error) {
       logger.debug(`Skipping prompts for client ${clientName}: ${error}`);
     }
     try {
+      this.removeServerResources(clientName);
       const resources = await client.listResources();
-      resources.forEach((resourceUri) => {
-        this.resourceToClientMap.set(resourceUri, client);
+      resources.forEach((summary) => {
+        const key = this.buildQualifiedResourceKey(clientName, summary.uri);
+        this.resourceCache.set(key, {
+          serverName: clientName,
+          client,
+          summary
+        });
       });
       logger.debug(`Cached resources for client: ${clientName}`);
     } catch (error) {
@@ -138,45 +276,28 @@ class MCPManager {
     }
   }
   /**
-   * Get all available MCP tools from all connected clients, updating the cache.
-   * Conflicted tools are prefixed with server name using distinctive delimiter.
+   * Get all available MCP tools from cache (no network calls).
+   * Conflicted tools are already stored with qualified names.
    * @returns Promise resolving to a ToolSet mapping tool names to Tool definitions
    */
   async getAllTools() {
     const allTools = {};
-    const clientToolsCache = /* @__PURE__ */ new Map();
-    const getClientTools = async (client) => {
-      if (!clientToolsCache.has(client)) {
-        const tools = await client.getTools();
-        clientToolsCache.set(client, tools);
-      }
-      return clientToolsCache.get(client);
-    };
-    for (const [toolName, client] of Array.from(this.toolToClientMap.entries())) {
-      const clientTools = await getClientTools(client);
-      const toolDef = clientTools[toolName];
-      if (toolDef) {
-        allTools[toolName] = toolDef;
-      }
-    }
-    for (const [serverName, serverTools] of this.serverToolsMap.entries()) {
-      for (const [toolName, client] of serverTools.entries()) {
-        if (this.toolConflicts.has(toolName)) {
-          const sanitizedServerName = this.sanitizeServerName(serverName);
-          const qualifiedName = `${sanitizedServerName}${MCPManager.SERVER_DELIMITER}${toolName}`;
-          const clientTools = await getClientTools(client);
-          const toolDef = clientTools[toolName];
-          if (toolDef) {
-            allTools[qualifiedName] = {
-              ...toolDef,
-              description: toolDef.description ? `${toolDef.description} (via ${serverName})` : `Tool from ${serverName}`
-            };
-          }
-        }
+    for (const [toolKey, entry] of this.toolCache.entries()) {
+      const toolDef = entry.definition;
+      if (toolKey.includes(MCPManager.SERVER_DELIMITER)) {
+        allTools[toolKey] = {
+          ...toolDef,
+          description: toolDef.description ? `${toolDef.description} (via ${entry.serverName})` : `Tool from ${entry.serverName}`
+        };
+      } else {
+        allTools[toolKey] = toolDef;
       }
     }
+    const serverNames = Array.from(
+      new Set(Array.from(this.toolCache.values()).map((e) => e.serverName))
+    );
     logger.debug(
-      `\u{1F527} MCP tool discovery: ${Object.keys(allTools).length} total tools, ${this.toolConflicts.size} conflicts, connected servers: ${Array.from(this.serverToolsMap.keys()).join(", ")}`
+      `\u{1F527} MCP tools from cache: ${Object.keys(allTools).length} total tools, ${this.toolConflicts.size} conflicts, connected servers: ${serverNames.join(", ")}`
     );
     if (logger.getLevel() === "debug") {
       Object.keys(allTools).forEach((toolName) => {
@@ -204,7 +325,7 @@ class MCPManager {
       delimiterIndex + MCPManager.SERVER_DELIMITER.length
     );
     const originalServerName = this.sanitizedNameToServerMap.get(serverPrefix);
-    if (originalServerName && this.serverToolsMap.get(originalServerName)?.has(actualToolName)) {
+    if (originalServerName && this.toolCache.has(toolName)) {
       return { serverName: originalServerName, toolName: actualToolName };
     }
     return null;
@@ -216,12 +337,7 @@ class MCPManager {
    * @returns The client that provides the tool, or undefined if not found
    */
   getToolClient(toolName) {
-    const parsed = this.parseQualifiedToolName(toolName);
-    if (parsed) {
-      const serverTools = this.serverToolsMap.get(parsed.serverName);
-      return serverTools?.get(parsed.toolName);
-    }
-    return this.toolToClientMap.get(toolName);
+    return this.toolCache.get(toolName)?.client;
   }
   /**
    * Execute a specific MCP tool with the given arguments.
@@ -234,13 +350,8 @@ class MCPManager {
     const client = this.getToolClient(toolName);
     if (!client) {
       logger.error(`\u274C No MCP tool found: ${toolName}`);
-      logger.debug(
-        `Available MCP tools: ${Array.from(this.toolToClientMap.keys()).join(", ")}`
-      );
+      logger.debug(`Available MCP tools: ${Array.from(this.toolCache.keys()).join(", ")}`);
       logger.debug(`Conflicted tools: ${Array.from(this.toolConflicts).join(", ")}`);
-      logger.debug(
-        `Server tools map keys: ${Array.from(this.serverToolsMap.keys()).join(", ")}`
-      );
       throw MCPError.toolNotFound(toolName);
     }
     const parsed = this.parseQualifiedToolName(toolName);
@@ -262,7 +373,7 @@ class MCPManager {
    * @returns Promise resolving to an array of unique prompt names.
    */
   async listAllPrompts() {
-    return Array.from(this.promptToClientMap.keys());
+    return Array.from(this.promptCache.keys());
   }
   /**
    * Get the client that provides a specific prompt from the cache.
@@ -270,7 +381,7 @@ class MCPManager {
    * @returns The client instance or undefined.
    */
   getPromptClient(promptName) {
-    return this.promptToClientMap.get(promptName);
+    return this.promptCache.get(promptName)?.client;
   }
   /**
    * Get a specific prompt definition by name.
@@ -286,31 +397,64 @@ class MCPManager {
     return await client.getPrompt(name, args);
   }
   /**
-   * Get all available resource URIs from all connected clients, updating the cache.
-   * @returns Promise resolving to an array of unique resource URIs.
+   * Get cached prompt metadata (no network calls).
+   * @param promptName Name of the prompt.
+   * @returns Cached prompt definition or undefined if not cached.
+   */
+  getPromptMetadata(promptName) {
+    const entry = this.promptCache.get(promptName);
+    return entry?.definition;
+  }
+  /**
+   * Get all cached prompt metadata (no network calls).
+   * @returns Array of all cached prompt definitions with server info.
+   */
+  getAllPromptMetadata() {
+    return Array.from(this.promptCache.entries()).map(([promptName, entry]) => ({
+      promptName,
+      serverName: entry.serverName,
+      definition: entry.definition
+    }));
+  }
+  /**
+   * Get all cached MCP resources (no network calls).
    */
   async listAllResources() {
-    return Array.from(this.resourceToClientMap.keys());
+    return Array.from(this.resourceCache.entries()).map(([key, { serverName, summary }]) => ({
+      key,
+      serverName,
+      summary
+    }));
   }
   /**
-   * Get the client that provides a specific resource from the cache.
-   * @param resourceUri URI of the resource.
-   * @returns The client instance or undefined.
+   * Determine if a qualified MCP resource is cached.
    */
-  getResourceClient(resourceUri) {
-    return this.resourceToClientMap.get(resourceUri);
+  hasResource(resourceKey) {
+    return this.getResourceCacheEntry(resourceKey) !== void 0;
+  }
+  /**
+   * Get cached resource metadata by qualified key.
+   */
+  getResource(resourceKey) {
+    const entry = this.getResourceCacheEntry(resourceKey);
+    if (!entry) return void 0;
+    return {
+      key: resourceKey,
+      serverName: entry.serverName,
+      summary: entry.summary
+    };
   }
   /**
-   * Read a specific resource by URI.
-   * @param uri URI of the resource.
+   * Read a specific resource by qualified URI.
+   * @param resourceKey Qualified resource key in the form mcp:server:uri.
    * @returns Promise resolving to the resource content.
    */
-  async readResource(uri) {
-    const client = this.getResourceClient(uri);
-    if (!client) {
-      throw MCPError.resourceNotFound(uri);
+  async readResource(resourceKey) {
+    const entry = this.getResourceCacheEntry(resourceKey);
+    if (!entry) {
+      throw MCPError.resourceNotFound(resourceKey);
     }
-    return await client.readResource(uri);
+    return await entry.client.readResource(entry.summary.uri);
   }
   /**
    * Initialize clients from server configurations
@@ -367,8 +511,12 @@ class MCPManager {
     try {
       logger.info(`Attempting to connect to new server '${name}'...`);
       await client.connect(config, name);
+      if (this.approvalManager) {
+        client.setApprovalManager(this.approvalManager);
+      }
       this.registerClient(name, client);
       await this.updateClientCache(name, client);
+      this.configCache.set(name, config);
       logger.info(`Successfully connected and cached new server '${name}'`);
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
@@ -392,6 +540,20 @@ class MCPManager {
   getFailedConnections() {
     return this.connectionErrors;
   }
+  /**
+   * Refresh all client caches by re-fetching capabilities from servers
+   * Useful when you want to force a full refresh of tools, prompts, and resources
+   * In normal operation, caches are automatically kept fresh via server notifications
+   */
+  async refresh() {
+    logger.debug("Refreshing all MCPManager caches...");
+    const refreshPromises = [];
+    for (const [clientName, client] of this.clients.entries()) {
+      refreshPromises.push(this.updateClientCache(clientName, client));
+    }
+    await Promise.all(refreshPromises);
+    logger.debug(`\u2705 MCPManager cache refresh complete for ${this.clients.size} client(s)`);
+  }
   /**
    * Disconnect and remove a specific client by name.
    * @param name The name of the client to remove.
@@ -399,18 +561,17 @@ class MCPManager {
   async removeClient(name) {
     const client = this.clients.get(name);
     if (client) {
-      if (typeof client.disconnect === "function") {
-        try {
-          await client.disconnect();
-          logger.info(`Successfully disconnected client: ${name}`);
-        } catch (error) {
-          logger.error(
-            `Error disconnecting client '${name}': ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
+      try {
+        await client.disconnect();
+        logger.info(`Successfully disconnected client: ${name}`);
+      } catch (error) {
+        logger.error(
+          `Error disconnecting client '${name}': ${error instanceof Error ? error.message : String(error)}`
+        );
       }
       this.clearClientCache(name);
       this.clients.delete(name);
+      this.configCache.delete(name);
       logger.info(`Removed client from manager: ${name}`);
     }
     if (this.connectionErrors[name]) {
@@ -418,31 +579,269 @@ class MCPManager {
       logger.info(`Cleared connection error for removed client: ${name}`);
     }
   }
+  /**
+   * Restart a specific MCP server by disconnecting and reconnecting with original config.
+   * @param name The name of the server to restart.
+   * @throws Error if server doesn't exist or config is not cached.
+   */
+  async restartServer(name) {
+    const config = this.configCache.get(name);
+    if (!config) {
+      throw MCPError.serverNotFound(
+        name,
+        "Server config not found - cannot restart dynamically added servers without stored config"
+      );
+    }
+    const client = this.clients.get(name);
+    logger.info(`Restarting MCP server '${name}'...`);
+    if (client) {
+      try {
+        await client.disconnect();
+        logger.info(`Disconnected server '${name}' for restart`);
+      } catch (error) {
+        logger.warn(
+          `Error disconnecting server '${name}' during restart (continuing): ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    } else {
+      logger.info(
+        `No active client found for '${name}' during restart; attempting fresh connection`
+      );
+    }
+    this.clearClientCache(name);
+    this.clients.delete(name);
+    delete this.connectionErrors[name];
+    try {
+      const newClient = new MCPClient();
+      await newClient.connect(config, name);
+      if (this.approvalManager) {
+        newClient.setApprovalManager(this.approvalManager);
+      }
+      this.registerClient(name, newClient);
+      await this.updateClientCache(name, newClient);
+      logger.info(`Successfully restarted server '${name}'`);
+      eventBus.emit("dexto:mcpServerRestarted", { serverName: name });
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.connectionErrors[name] = errorMsg;
+      logger.error(`Failed to restart server '${name}': ${errorMsg}`);
+      throw MCPError.connectionFailed(name, errorMsg);
+    }
+  }
   /**
    * Disconnect all clients and clear caches
    */
   async disconnectAll() {
     const disconnectPromises = [];
     for (const [name, client] of Array.from(this.clients.entries())) {
-      if (client.disconnect) {
-        disconnectPromises.push(
-          client.disconnect().then(() => logger.info(`Disconnected client: ${name}`)).catch(
-            (error) => logger.error(`Failed to disconnect client '${name}': ${error}`)
-          )
-        );
-      }
+      disconnectPromises.push(
+        client.disconnect().then(() => logger.info(`Disconnected client: ${name}`)).catch(
+          (error) => logger.error(`Failed to disconnect client '${name}': ${error}`)
+        )
+      );
     }
     await Promise.all(disconnectPromises);
     this.clients.clear();
     this.connectionErrors = {};
-    this.toolToClientMap.clear();
-    this.serverToolsMap.clear();
+    this.configCache.clear();
+    this.toolCache.clear();
     this.toolConflicts.clear();
-    this.promptToClientMap.clear();
-    this.resourceToClientMap.clear();
+    this.promptCache.clear();
+    this.resourceCache.clear();
     this.sanitizedNameToServerMap.clear();
     logger.info("Disconnected all clients and cleared caches.");
   }
+  /**
+   * Set up notification listeners for a specific client
+   */
+  setupClientNotifications(clientName, client) {
+    try {
+      client.on("resourceUpdated", async (params) => {
+        logger.debug(
+          `Received resource update notification from ${clientName}: ${params.uri}`
+        );
+        await this.handleResourceUpdated(clientName, params);
+      });
+      client.on("promptsListChanged", async () => {
+        logger.debug(`Received prompts list change notification from ${clientName}`);
+        await this.handlePromptsListChanged(clientName, client);
+      });
+      client.on("toolsListChanged", async () => {
+        logger.debug(`Received tools list change notification from ${clientName}`);
+        await this.handleToolsListChanged(clientName, client);
+      });
+      logger.debug(`Set up notification listeners for client: ${clientName}`);
+    } catch (error) {
+      logger.warn(`Failed to set up notification listeners for ${clientName}: ${error}`);
+    }
+  }
+  /**
+   * Handle resource updated notification
+   */
+  async handleResourceUpdated(serverName, params) {
+    try {
+      const client = this.clients.get(serverName);
+      if (client) {
+        const key = this.buildQualifiedResourceKey(serverName, params.uri);
+        try {
+          const resources = await client.listResources();
+          const updatedResource = resources.find((r) => r.uri === params.uri);
+          if (updatedResource) {
+            this.resourceCache.set(key, {
+              serverName,
+              client,
+              summary: updatedResource
+            });
+            logger.debug(`Updated resource cache for: ${params.uri}`);
+          }
+        } catch (error) {
+          logger.warn(`Failed to refresh resource ${params.uri}: ${error}`);
+        }
+      }
+      eventBus.emit("dexto:mcpResourceUpdated", {
+        serverName,
+        resourceUri: params.uri
+      });
+    } catch (error) {
+      logger.error(`Error handling resource update: ${error}`);
+    }
+  }
+  /**
+   * Handle prompts list changed notification
+   */
+  async handlePromptsListChanged(serverName, client) {
+    try {
+      const existingPrompts = Array.from(this.promptCache.entries()).filter(([_, entry]) => entry.client === client).map(([promptName]) => promptName);
+      existingPrompts.forEach((promptName) => {
+        this.promptCache.delete(promptName);
+      });
+      try {
+        const newPrompts = await client.listPrompts();
+        for (const prompt of newPrompts) {
+          const definition = {
+            name: prompt.name,
+            ...prompt.title && { title: prompt.title },
+            ...prompt.description && { description: prompt.description },
+            ...prompt.arguments && { arguments: prompt.arguments }
+          };
+          this.promptCache.set(prompt.name, {
+            serverName,
+            client,
+            definition
+          });
+        }
+        const promptNames = newPrompts.map((p) => p.name);
+        logger.debug(
+          `Updated prompts cache for ${serverName}: [${promptNames.join(", ")}]`
+        );
+        eventBus.emit("dexto:mcpPromptsListChanged", {
+          serverName,
+          prompts: promptNames
+        });
+      } catch (error) {
+        logger.warn(`Failed to refresh prompts for ${serverName}: ${error}`);
+      }
+    } catch (error) {
+      logger.error(`Error handling prompts list change: ${error}`);
+    }
+  }
+  /**
+   * Handle tools list changed notification
+   */
+  async handleToolsListChanged(serverName, client) {
+    try {
+      const removedToolBaseNames = /* @__PURE__ */ new Set();
+      for (const [toolKey, entry] of Array.from(this.toolCache.entries())) {
+        if (entry.serverName === serverName) {
+          const delimiterIndex = toolKey.lastIndexOf(MCPManager.SERVER_DELIMITER);
+          const baseName = delimiterIndex === -1 ? toolKey : toolKey.substring(
+            delimiterIndex + MCPManager.SERVER_DELIMITER.length
+          );
+          removedToolBaseNames.add(baseName);
+          this.toolCache.delete(toolKey);
+        }
+      }
+      try {
+        const tools = await client.getTools();
+        const toolNames = Object.keys(tools);
+        logger.debug(
+          `\u{1F527} Refreshing tools from server '${serverName}': [${toolNames.join(", ")}]`
+        );
+        for (const toolName in tools) {
+          const toolDef = tools[toolName];
+          if (!toolDef) continue;
+          const existingEntry = this.toolCache.get(toolName);
+          if (existingEntry && existingEntry.serverName !== serverName) {
+            this.toolConflicts.add(toolName);
+            this.toolCache.delete(toolName);
+            const existingSanitized = this.sanitizeServerName(existingEntry.serverName);
+            const existingQualified = `${existingSanitized}${MCPManager.SERVER_DELIMITER}${toolName}`;
+            this.toolCache.set(existingQualified, existingEntry);
+            const newSanitized = this.sanitizeServerName(serverName);
+            const newQualified = `${newSanitized}${MCPManager.SERVER_DELIMITER}${toolName}`;
+            this.toolCache.set(newQualified, {
+              serverName,
+              client,
+              definition: toolDef
+            });
+            logger.warn(
+              `\u26A0\uFE0F  Tool conflict detected for '${toolName}' - using server prefixes: ${existingQualified}, ${newQualified}`
+            );
+          } else if (this.toolConflicts.has(toolName)) {
+            const sanitizedName = this.sanitizeServerName(serverName);
+            const qualifiedName = `${sanitizedName}${MCPManager.SERVER_DELIMITER}${toolName}`;
+            this.toolCache.set(qualifiedName, {
+              serverName,
+              client,
+              definition: toolDef
+            });
+            logger.debug(`\u2705 Tool '${qualifiedName}' cached (known conflict)`);
+          } else {
+            this.toolCache.set(toolName, {
+              serverName,
+              client,
+              definition: toolDef
+            });
+            logger.debug(`\u2705 Tool '${toolName}' mapped to ${serverName}`);
+          }
+        }
+        for (const baseName of removedToolBaseNames) {
+          const remainingTools = Array.from(this.toolCache.entries()).filter(
+            ([key, _]) => {
+              const delimiterIndex = key.lastIndexOf(MCPManager.SERVER_DELIMITER);
+              const bn = delimiterIndex === -1 ? key : key.substring(
+                delimiterIndex + MCPManager.SERVER_DELIMITER.length
+              );
+              return bn === baseName;
+            }
+          );
+          if (remainingTools.length === 0) {
+            this.toolConflicts.delete(baseName);
+          } else if (remainingTools.length === 1 && this.toolConflicts.has(baseName)) {
+            const singleTool = remainingTools[0];
+            if (singleTool) {
+              const [qualifiedKey, entry] = singleTool;
+              this.toolCache.delete(qualifiedKey);
+              this.toolCache.set(baseName, entry);
+              this.toolConflicts.delete(baseName);
+              logger.debug(
+                `Restored tool '${baseName}' to simple name (conflict resolved)`
+              );
+            }
+          }
+        }
+        logger.debug(`Updated tools cache for ${serverName}: [${toolNames.join(", ")}]`);
+        eventBus.emit("dexto:mcpToolsListChanged", {
+          serverName,
+          tools: toolNames
+        });
+      } catch (error) {
+        logger.warn(`Failed to refresh tools for ${serverName}: ${error}`);
+      }
+    } catch (error) {
+      logger.error(`Error handling tools list change: ${error}`);
+    }
+  }
 }
 export {
   MCPManager