@dexto/core 1.2.4 → 1.2.5

package/dist/mcp/manager.js

@@ -1,6 +1,6 @@
 import "../chunk-C6A6W6XS.js";
 import { MCPClient } from "./mcp-client.js";
-import { logger } from "../logger/index.js";
+import { DextoLogComponent } from "../logger/v2/types.js";
 import { MCPError } from "./errors.js";
 import { eventBus } from "../events/index.js";
 class MCPManager {
@@ -16,10 +16,12 @@ class MCPManager {
   sanitizedNameToServerMap = /* @__PURE__ */ new Map();
   approvalManager = null;
   // Will be set by service initializer
+  logger;
   // 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() {
+  constructor(logger) {
+    this.logger = logger.createChild(DextoLogComponent.MCP);
   }
   /**
    * Set the approval manager for handling elicitation requests from MCP servers
@@ -76,7 +78,7 @@ class MCPManager {
    */
   registerClient(name, client) {
     if (this.clients.has(name)) {
-      logger.warn(`Client '${name}' already registered. Overwriting.`);
+      this.logger.warn(`Client '${name}' already registered. Overwriting.`);
     }
     this.clearClientCache(name);
     const sanitizedName = this.sanitizeServerName(name);
@@ -87,7 +89,7 @@ class MCPManager {
     this.clients.set(name, client);
     this.sanitizedNameToServerMap.set(sanitizedName, name);
     this.setupClientNotifications(name, client);
-    logger.info(`Registered client: ${name}`);
+    this.logger.info(`Registered client: ${name}`);
     delete this.connectionErrors[name];
   }
   /**
@@ -131,7 +133,9 @@ class MCPManager {
           this.toolCache.delete(qualifiedKey);
           this.toolCache.set(baseName, entry);
           this.toolConflicts.delete(baseName);
-          logger.debug(`Restored tool '${baseName}' to simple name (conflict resolved)`);
+          this.logger.debug(
+            `Restored tool '${baseName}' to simple name (conflict resolved)`
+          );
         }
       }
     }
@@ -145,7 +149,7 @@ class MCPManager {
         this.resourceCache.delete(key);
       }
     }
-    logger.debug(`Cleared cache for client: ${clientName}`);
+    this.logger.debug(`Cleared cache for client: ${clientName}`);
   }
   /**
    * Sanitize server name for use in tool prefixing.
@@ -190,7 +194,7 @@ class MCPManager {
   async updateClientCache(clientName, client) {
     try {
       const tools = await client.getTools();
-      logger.debug(
+      this.logger.debug(
         `\u{1F527} Discovered ${Object.keys(tools).length} tools from server '${clientName}': [${Object.keys(tools).join(", ")}]`
       );
       for (const toolName in tools) {
@@ -210,7 +214,7 @@ class MCPManager {
             client,
             definition: toolDef
           });
-          logger.warn(
+          this.logger.warn(
             `\u26A0\uFE0F  Tool conflict detected for '${toolName}' - using server prefixes: ${existingQualified}, ${newQualified}`
           );
         } else if (this.toolConflicts.has(toolName)) {
@@ -221,21 +225,21 @@ class MCPManager {
             client,
             definition: toolDef
           });
-          logger.debug(`\u2705 Tool '${qualifiedName}' cached (known conflict)`);
+          this.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}`);
+          this.logger.debug(`\u2705 Tool '${toolName}' mapped to ${clientName}`);
         }
       }
-      logger.debug(
+      this.logger.debug(
         `\u2705 Successfully cached ${Object.keys(tools).length} tools for client: ${clientName}`
       );
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `\u274C Error retrieving tools for client ${clientName}: ${error instanceof Error ? error.message : String(error)}`
       );
       return;
@@ -255,9 +259,9 @@ class MCPManager {
           definition
         });
       }
-      logger.debug(`Cached ${prompts.length} prompts for client: ${clientName}`);
+      this.logger.debug(`Cached ${prompts.length} prompts for client: ${clientName}`);
     } catch (error) {
-      logger.debug(`Skipping prompts for client ${clientName}: ${error}`);
+      this.logger.debug(`Skipping prompts for client ${clientName}: ${error}`);
     }
     try {
       this.removeServerResources(clientName);
@@ -270,9 +274,9 @@ class MCPManager {
           summary
         });
       });
-      logger.debug(`Cached resources for client: ${clientName}`);
+      this.logger.debug(`Cached resources for client: ${clientName}`);
     } catch (error) {
-      logger.debug(`Skipping resources for client ${clientName}: ${error}`);
+      this.logger.debug(`Skipping resources for client ${clientName}: ${error}`);
     }
   }
   /**
@@ -296,19 +300,17 @@ class MCPManager {
     const serverNames = Array.from(
       new Set(Array.from(this.toolCache.values()).map((e) => e.serverName))
     );
-    logger.debug(
+    this.logger.debug(
       `\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) => {
-        if (toolName.includes(MCPManager.SERVER_DELIMITER)) {
-          logger.debug(`  - ${toolName} (qualified)`);
-        } else {
-          logger.debug(`  - ${toolName}`);
-        }
-      });
-    }
-    logger.silly(`MCP tools: ${JSON.stringify(allTools, null, 2)}`);
+    Object.keys(allTools).forEach((toolName) => {
+      if (toolName.includes(MCPManager.SERVER_DELIMITER)) {
+        this.logger.debug(`  - ${toolName} (qualified)`);
+      } else {
+        this.logger.debug(`  - ${toolName}`);
+      }
+    });
+    this.logger.silly(`MCP tools: ${JSON.stringify(allTools, null, 2)}`);
     return allTools;
   }
   /**
@@ -349,20 +351,24 @@ class MCPManager {
   async executeTool(toolName, args, _sessionId) {
     const client = this.getToolClient(toolName);
     if (!client) {
-      logger.error(`\u274C No MCP tool found: ${toolName}`);
-      logger.debug(`Available MCP tools: ${Array.from(this.toolCache.keys()).join(", ")}`);
-      logger.debug(`Conflicted tools: ${Array.from(this.toolConflicts).join(", ")}`);
+      this.logger.error(`\u274C No MCP tool found: ${toolName}`);
+      this.logger.debug(
+        `Available MCP tools: ${Array.from(this.toolCache.keys()).join(", ")}`
+      );
+      this.logger.debug(`Conflicted tools: ${Array.from(this.toolConflicts).join(", ")}`);
       throw MCPError.toolNotFound(toolName);
     }
     const parsed = this.parseQualifiedToolName(toolName);
     const actualToolName = parsed ? parsed.toolName : toolName;
     const serverName = parsed ? parsed.serverName : "direct";
-    logger.debug(`\u25B6\uFE0F  Executing MCP tool '${actualToolName}' on server '${serverName}'...`);
+    this.logger.debug(
+      `\u25B6\uFE0F  Executing MCP tool '${actualToolName}' on server '${serverName}'...`
+    );
     try {
       const result = await client.callTool(actualToolName, args);
       return result;
     } catch (error) {
-      logger.error(
+      this.logger.error(
         `\u274C MCP tool execution failed: '${actualToolName}' - ${error instanceof Error ? error.message : String(error)}`
       );
       throw error;
@@ -463,7 +469,7 @@ class MCPManager {
    */
   async initializeFromConfig(serverConfigs) {
     if (Object.keys(serverConfigs).length === 0) {
-      logger.info("No MCP servers configured - running without external tools");
+      this.logger.info("No MCP servers configured - running without external tools");
       return;
     }
     const successfulConnections = [];
@@ -480,7 +486,7 @@ class MCPManager {
       const connectPromise = this.connectServer(name, config).then(() => {
         successfulConnections.push(name);
       }).catch((error) => {
-        logger.debug(
+        this.logger.debug(
           `Handled connection error for '${name}' during initialization: ${error.message}`
         );
       });
@@ -504,12 +510,12 @@ class MCPManager {
    */
   async connectServer(name, config) {
     if (this.clients.has(name)) {
-      logger.warn(`Client '${name}' is already connected or registered.`);
+      this.logger.warn(`Client '${name}' is already connected or registered.`);
       return;
     }
-    const client = new MCPClient();
+    const client = new MCPClient(this.logger);
     try {
-      logger.info(`Attempting to connect to new server '${name}'...`);
+      this.logger.info(`Attempting to connect to new server '${name}'...`);
       await client.connect(config, name);
       if (this.approvalManager) {
         client.setApprovalManager(this.approvalManager);
@@ -517,11 +523,11 @@ class MCPManager {
       this.registerClient(name, client);
       await this.updateClientCache(name, client);
       this.configCache.set(name, config);
-      logger.info(`Successfully connected and cached new server '${name}'`);
+      this.logger.info(`Successfully connected and cached new server '${name}'`);
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
       this.connectionErrors[name] = errorMsg;
-      logger.error(`Failed to connect to new server '${name}': ${errorMsg}`);
+      this.logger.error(`Failed to connect to new server '${name}': ${errorMsg}`);
       this.clients.delete(name);
       throw MCPError.connectionFailed(name, errorMsg);
     }
@@ -546,13 +552,15 @@ class MCPManager {
    * In normal operation, caches are automatically kept fresh via server notifications
    */
   async refresh() {
-    logger.debug("Refreshing all MCPManager caches...");
+    this.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)`);
+    this.logger.debug(
+      `\u2705 MCPManager cache refresh complete for ${this.clients.size} client(s)`
+    );
   }
   /**
    * Disconnect and remove a specific client by name.
@@ -563,20 +571,20 @@ class MCPManager {
     if (client) {
       try {
         await client.disconnect();
-        logger.info(`Successfully disconnected client: ${name}`);
+        this.logger.info(`Successfully disconnected client: ${name}`);
       } catch (error) {
-        logger.error(
+        this.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}`);
+      this.logger.info(`Removed client from manager: ${name}`);
     }
     if (this.connectionErrors[name]) {
       delete this.connectionErrors[name];
-      logger.info(`Cleared connection error for removed client: ${name}`);
+      this.logger.info(`Cleared connection error for removed client: ${name}`);
     }
   }
   /**
@@ -593,18 +601,18 @@ class MCPManager {
       );
     }
     const client = this.clients.get(name);
-    logger.info(`Restarting MCP server '${name}'...`);
+    this.logger.info(`Restarting MCP server '${name}'...`);
     if (client) {
       try {
         await client.disconnect();
-        logger.info(`Disconnected server '${name}' for restart`);
+        this.logger.info(`Disconnected server '${name}' for restart`);
       } catch (error) {
-        logger.warn(
+        this.logger.warn(
           `Error disconnecting server '${name}' during restart (continuing): ${error instanceof Error ? error.message : String(error)}`
         );
       }
     } else {
-      logger.info(
+      this.logger.info(
         `No active client found for '${name}' during restart; attempting fresh connection`
       );
     }
@@ -612,19 +620,19 @@ class MCPManager {
     this.clients.delete(name);
     delete this.connectionErrors[name];
     try {
-      const newClient = new MCPClient();
+      const newClient = new MCPClient(this.logger);
       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 });
+      this.logger.info(`Successfully restarted server '${name}'`);
+      eventBus.emit("mcp:server-restarted", { 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}`);
+      this.logger.error(`Failed to restart server '${name}': ${errorMsg}`);
       throw MCPError.connectionFailed(name, errorMsg);
     }
   }
@@ -635,8 +643,8 @@ class MCPManager {
     const disconnectPromises = [];
     for (const [name, client] of Array.from(this.clients.entries())) {
       disconnectPromises.push(
-        client.disconnect().then(() => logger.info(`Disconnected client: ${name}`)).catch(
-          (error) => logger.error(`Failed to disconnect client '${name}': ${error}`)
+        client.disconnect().then(() => this.logger.info(`Disconnected client: ${name}`)).catch(
+          (error) => this.logger.error(`Failed to disconnect client '${name}': ${error}`)
         )
       );
     }
@@ -649,7 +657,7 @@ class MCPManager {
     this.promptCache.clear();
     this.resourceCache.clear();
     this.sanitizedNameToServerMap.clear();
-    logger.info("Disconnected all clients and cleared caches.");
+    this.logger.info("Disconnected all clients and cleared caches.");
   }
   /**
    * Set up notification listeners for a specific client
@@ -657,22 +665,22 @@ class MCPManager {
   setupClientNotifications(clientName, client) {
     try {
       client.on("resourceUpdated", async (params) => {
-        logger.debug(
+        this.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}`);
+        this.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}`);
+        this.logger.debug(`Received tools list change notification from ${clientName}`);
         await this.handleToolsListChanged(clientName, client);
       });
-      logger.debug(`Set up notification listeners for client: ${clientName}`);
+      this.logger.debug(`Set up notification listeners for client: ${clientName}`);
     } catch (error) {
-      logger.warn(`Failed to set up notification listeners for ${clientName}: ${error}`);
+      this.logger.warn(`Failed to set up notification listeners for ${clientName}: ${error}`);
     }
   }
   /**
@@ -692,18 +700,18 @@ class MCPManager {
               client,
               summary: updatedResource
             });
-            logger.debug(`Updated resource cache for: ${params.uri}`);
+            this.logger.debug(`Updated resource cache for: ${params.uri}`);
           }
         } catch (error) {
-          logger.warn(`Failed to refresh resource ${params.uri}: ${error}`);
+          this.logger.warn(`Failed to refresh resource ${params.uri}: ${error}`);
         }
       }
-      eventBus.emit("dexto:mcpResourceUpdated", {
+      eventBus.emit("mcp:resource-updated", {
         serverName,
         resourceUri: params.uri
       });
     } catch (error) {
-      logger.error(`Error handling resource update: ${error}`);
+      this.logger.error(`Error handling resource update: ${error}`);
     }
   }
   /**
@@ -731,18 +739,18 @@ class MCPManager {
           });
         }
         const promptNames = newPrompts.map((p) => p.name);
-        logger.debug(
+        this.logger.debug(
           `Updated prompts cache for ${serverName}: [${promptNames.join(", ")}]`
         );
-        eventBus.emit("dexto:mcpPromptsListChanged", {
+        eventBus.emit("mcp:prompts-list-changed", {
           serverName,
           prompts: promptNames
         });
       } catch (error) {
-        logger.warn(`Failed to refresh prompts for ${serverName}: ${error}`);
+        this.logger.warn(`Failed to refresh prompts for ${serverName}: ${error}`);
       }
     } catch (error) {
-      logger.error(`Error handling prompts list change: ${error}`);
+      this.logger.error(`Error handling prompts list change: ${error}`);
     }
   }
   /**
@@ -764,7 +772,7 @@ class MCPManager {
       try {
         const tools = await client.getTools();
         const toolNames = Object.keys(tools);
-        logger.debug(
+        this.logger.debug(
           `\u{1F527} Refreshing tools from server '${serverName}': [${toolNames.join(", ")}]`
         );
         for (const toolName in tools) {
@@ -784,7 +792,7 @@ class MCPManager {
               client,
               definition: toolDef
             });
-            logger.warn(
+            this.logger.warn(
               `\u26A0\uFE0F  Tool conflict detected for '${toolName}' - using server prefixes: ${existingQualified}, ${newQualified}`
             );
           } else if (this.toolConflicts.has(toolName)) {
@@ -795,14 +803,14 @@ class MCPManager {
               client,
               definition: toolDef
             });
-            logger.debug(`\u2705 Tool '${qualifiedName}' cached (known conflict)`);
+            this.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}`);
+            this.logger.debug(`\u2705 Tool '${toolName}' mapped to ${serverName}`);
           }
         }
         for (const baseName of removedToolBaseNames) {
@@ -824,22 +832,24 @@ class MCPManager {
               this.toolCache.delete(qualifiedKey);
               this.toolCache.set(baseName, entry);
               this.toolConflicts.delete(baseName);
-              logger.debug(
+              this.logger.debug(
                 `Restored tool '${baseName}' to simple name (conflict resolved)`
               );
             }
           }
         }
-        logger.debug(`Updated tools cache for ${serverName}: [${toolNames.join(", ")}]`);
-        eventBus.emit("dexto:mcpToolsListChanged", {
+        this.logger.debug(
+          `Updated tools cache for ${serverName}: [${toolNames.join(", ")}]`
+        );
+        eventBus.emit("mcp:tools-list-changed", {
           serverName,
           tools: toolNames
         });
       } catch (error) {
-        logger.warn(`Failed to refresh tools for ${serverName}: ${error}`);
+        this.logger.warn(`Failed to refresh tools for ${serverName}: ${error}`);
       }
     } catch (error) {
-      logger.error(`Error handling tools list change: ${error}`);
+      this.logger.error(`Error handling tools list change: ${error}`);
     }
   }
 }