@dexto/core 1.1.4 → 1.1.6

package/dist/mcp/manager.js

@@ -0,0 +1,449 @@
+import { MCPClient } from "./mcp-client.js";
+import { logger } from "../logger/index.js";
+import { MCPError } from "./errors.js";
+class MCPManager {
+  clients = /* @__PURE__ */ new Map();
+  connectionErrors = {};
+  toolToClientMap = /* @__PURE__ */ new Map();
+  serverToolsMap = /* @__PURE__ */ new Map();
+  toolConflicts = /* @__PURE__ */ new Set();
+  promptToClientMap = /* @__PURE__ */ new Map();
+  resourceToClientMap = /* @__PURE__ */ new Map();
+  sanitizedNameToServerMap = /* @__PURE__ */ new Map();
+  // 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() {
+  }
+  /**
+   * Register a client that provides tools (and potentially more)
+   * @param name Unique name for the client
+   * @param client The client instance, expected to be IMCPClient
+   */
+  registerClient(name, client) {
+    if (this.clients.has(name)) {
+      logger.warn(`Client '${name}' already registered. Overwriting.`);
+    }
+    this.clearClientCache(name);
+    const sanitizedName = this.sanitizeServerName(name);
+    const existingServerWithSameSanitizedName = this.sanitizedNameToServerMap.get(sanitizedName);
+    if (existingServerWithSameSanitizedName && existingServerWithSameSanitizedName !== name) {
+      throw MCPError.duplicateName(name, existingServerWithSameSanitizedName);
+    }
+    this.clients.set(name, client);
+    this.sanitizedNameToServerMap.set(sanitizedName, name);
+    logger.info(`Registered client: ${name}`);
+    delete this.connectionErrors[name];
+  }
+  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);
+          }
+        }
+      }
+    );
+    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 [toolName, count] of toolCounts.entries()) {
+      if (count > 1) {
+        this.toolConflicts.add(toolName);
+        this.toolToClientMap.delete(toolName);
+      }
+    }
+    for (const [_, serverTools] of this.serverToolsMap.entries()) {
+      for (const [toolName, client] of serverTools.entries()) {
+        if (!this.toolConflicts.has(toolName)) {
+          this.toolToClientMap.set(toolName, client);
+        }
+      }
+    }
+  }
+  /**
+   * Sanitize server name for use in tool prefixing.
+   * Ensures the name is safe for LLM provider tool naming constraints.
+   */
+  sanitizeServerName(serverName) {
+    return serverName.replace(/[^a-zA-Z0-9_-]/g, "_");
+  }
+  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) {
+          this.toolConflicts.add(toolName);
+          this.toolToClientMap.delete(toolName);
+          logger.warn(
+            `\u26A0\uFE0F  Tool conflict detected for '${toolName}' - will use server prefix`
+          );
+        } else if (!this.toolConflicts.has(toolName)) {
+          this.toolToClientMap.set(toolName, client);
+          logger.debug(`\u2705 Tool '${toolName}' mapped to ${clientName}`);
+        }
+      }
+      logger.debug(
+        `\u2705 Successfully cached ${Object.keys(tools).length} tools for client: ${clientName}`
+      );
+    } catch (error) {
+      logger.error(
+        `\u274C Error retrieving tools for client ${clientName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
+    }
+    try {
+      const prompts = await client.listPrompts();
+      prompts.forEach((promptName) => {
+        this.promptToClientMap.set(promptName, client);
+      });
+      logger.debug(`Cached prompts for client: ${clientName}`);
+    } catch (error) {
+      logger.debug(`Skipping prompts for client ${clientName}: ${error}`);
+    }
+    try {
+      const resources = await client.listResources();
+      resources.forEach((resourceUri) => {
+        this.resourceToClientMap.set(resourceUri, client);
+      });
+      logger.debug(`Cached resources for client: ${clientName}`);
+    } catch (error) {
+      logger.debug(`Skipping resources for client ${clientName}: ${error}`);
+    }
+  }
+  /**
+   * Get all available MCP tools from all connected clients, updating the cache.
+   * Conflicted tools are prefixed with server name using distinctive delimiter.
+   * @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}`
+            };
+          }
+        }
+      }
+    }
+    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(", ")}`
+    );
+    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)}`);
+    return allTools;
+  }
+  /**
+   * Parse a qualified tool name to extract server name and actual tool name.
+   * Uses distinctive delimiter to avoid ambiguity and splits on last occurrence.
+   */
+  parseQualifiedToolName(toolName) {
+    const delimiterIndex = toolName.lastIndexOf(MCPManager.SERVER_DELIMITER);
+    if (delimiterIndex === -1) {
+      return null;
+    }
+    const serverPrefix = toolName.substring(0, delimiterIndex);
+    const actualToolName = toolName.substring(
+      delimiterIndex + MCPManager.SERVER_DELIMITER.length
+    );
+    const originalServerName = this.sanitizedNameToServerMap.get(serverPrefix);
+    if (originalServerName && this.serverToolsMap.get(originalServerName)?.has(actualToolName)) {
+      return { serverName: originalServerName, toolName: actualToolName };
+    }
+    return null;
+  }
+  /**
+   * Get client that provides a specific tool from the cache.
+   * Handles both simple tool names and server-prefixed tool names.
+   * @param toolName Name of the tool (may include server prefix)
+   * @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);
+  }
+  /**
+   * Execute a specific MCP tool with the given arguments.
+   * @param toolName Name of the MCP tool to execute (may include server prefix)
+   * @param args Arguments to pass to the tool
+   * @param sessionId Optional session ID
+   * @returns Promise resolving to the tool execution result
+   */
+  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.toolToClientMap.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);
+    const actualToolName = parsed ? parsed.toolName : toolName;
+    const serverName = parsed ? parsed.serverName : "direct";
+    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(
+        `\u274C MCP tool execution failed: '${actualToolName}' - ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * Get all available prompt names from all connected clients, updating the cache.
+   * @returns Promise resolving to an array of unique prompt names.
+   */
+  async listAllPrompts() {
+    return Array.from(this.promptToClientMap.keys());
+  }
+  /**
+   * Get the client that provides a specific prompt from the cache.
+   * @param promptName Name of the prompt.
+   * @returns The client instance or undefined.
+   */
+  getPromptClient(promptName) {
+    return this.promptToClientMap.get(promptName);
+  }
+  /**
+   * Get a specific prompt definition by name.
+   * @param name Name of the prompt.
+   * @param args Arguments for the prompt (optional).
+   * @returns Promise resolving to the prompt definition.
+   */
+  async getPrompt(name, args) {
+    const client = this.getPromptClient(name);
+    if (!client) {
+      throw MCPError.promptNotFound(name);
+    }
+    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.
+   */
+  async listAllResources() {
+    return Array.from(this.resourceToClientMap.keys());
+  }
+  /**
+   * Get the client that provides a specific resource from the cache.
+   * @param resourceUri URI of the resource.
+   * @returns The client instance or undefined.
+   */
+  getResourceClient(resourceUri) {
+    return this.resourceToClientMap.get(resourceUri);
+  }
+  /**
+   * Read a specific resource by URI.
+   * @param uri URI of the resource.
+   * @returns Promise resolving to the resource content.
+   */
+  async readResource(uri) {
+    const client = this.getResourceClient(uri);
+    if (!client) {
+      throw MCPError.resourceNotFound(uri);
+    }
+    return await client.readResource(uri);
+  }
+  /**
+   * Initialize clients from server configurations
+   * @param serverConfigs Server configurations with individual connection modes
+   * @returns Promise resolving when initialization is complete
+   */
+  async initializeFromConfig(serverConfigs) {
+    if (Object.keys(serverConfigs).length === 0) {
+      logger.info("No MCP servers configured - running without external tools");
+      return;
+    }
+    const successfulConnections = [];
+    const connectionPromises = [];
+    const strictServers = [];
+    const lenientServers = [];
+    for (const [name, config] of Object.entries(serverConfigs)) {
+      const effectiveMode = config.connectionMode || "lenient";
+      if (effectiveMode === "strict") {
+        strictServers.push(name);
+      } else {
+        lenientServers.push(name);
+      }
+      const connectPromise = this.connectServer(name, config).then(() => {
+        successfulConnections.push(name);
+      }).catch((error) => {
+        logger.debug(
+          `Handled connection error for '${name}' during initialization: ${error.message}`
+        );
+      });
+      connectionPromises.push(connectPromise);
+    }
+    await Promise.all(connectionPromises);
+    const failedStrictServers = strictServers.filter(
+      (name) => !successfulConnections.includes(name)
+    );
+    if (failedStrictServers.length > 0) {
+      const strictErrors = failedStrictServers.map((name) => `${name}: ${this.connectionErrors[name] || "Unknown error"}`).join("; ");
+      throw MCPError.connectionFailed("strict servers", strictErrors);
+    }
+  }
+  /**
+   * Dynamically connect to a new MCP server.
+   * @param name The unique name for the new server connection.
+   * @param config The configuration for the server.
+   * @returns Promise resolving when the connection attempt is complete.
+   * @throws Error if the connection fails.
+   */
+  async connectServer(name, config) {
+    if (this.clients.has(name)) {
+      logger.warn(`Client '${name}' is already connected or registered.`);
+      return;
+    }
+    const client = new MCPClient();
+    try {
+      logger.info(`Attempting to connect to new server '${name}'...`);
+      await client.connect(config, name);
+      this.registerClient(name, client);
+      await this.updateClientCache(name, client);
+      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.clients.delete(name);
+      throw MCPError.connectionFailed(name, errorMsg);
+    }
+  }
+  /**
+   * Get all registered clients
+   * @returns Map of client names to client instances
+   */
+  getClients() {
+    return this.clients;
+  }
+  /**
+   * Get the errors from failed connections
+   * @returns Map of server names to error messages
+   */
+  getFailedConnections() {
+    return this.connectionErrors;
+  }
+  /**
+   * Disconnect and remove a specific client by name.
+   * @param name The name of the client to remove.
+   */
+  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)}`
+          );
+        }
+      }
+      this.clearClientCache(name);
+      this.clients.delete(name);
+      logger.info(`Removed client from manager: ${name}`);
+    }
+    if (this.connectionErrors[name]) {
+      delete this.connectionErrors[name];
+      logger.info(`Cleared connection error for removed client: ${name}`);
+    }
+  }
+  /**
+   * 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}`)
+          )
+        );
+      }
+    }
+    await Promise.all(disconnectPromises);
+    this.clients.clear();
+    this.connectionErrors = {};
+    this.toolToClientMap.clear();
+    this.serverToolsMap.clear();
+    this.toolConflicts.clear();
+    this.promptToClientMap.clear();
+    this.resourceToClientMap.clear();
+    this.sanitizedNameToServerMap.clear();
+    logger.info("Disconnected all clients and cleared caches.");
+  }
+}
+export {
+  MCPManager
+};