@dexto/core 1.1.4 → 1.1.6

package/dist/mcp/errors.js

@@ -0,0 +1,107 @@
+import { DextoRuntimeError } from "../errors/DextoRuntimeError.js";
+import { ErrorScope, ErrorType } from "../errors/types.js";
+import { MCPErrorCode } from "./error-codes.js";
+class MCPError {
+  /**
+   * MCP server connection failed
+   */
+  static connectionFailed(serverName, reason) {
+    return new DextoRuntimeError(
+      MCPErrorCode.CONNECTION_FAILED,
+      ErrorScope.MCP,
+      ErrorType.THIRD_PARTY,
+      `Failed to connect to MCP server '${serverName}': ${reason}`,
+      { serverName, reason },
+      "Check that the MCP server is running and accessible"
+    );
+  }
+  /**
+   * MCP protocol error
+   */
+  static protocolError(message, details) {
+    return new DextoRuntimeError(
+      MCPErrorCode.PROTOCOL_ERROR,
+      ErrorScope.MCP,
+      ErrorType.THIRD_PARTY,
+      `MCP protocol error: ${message}`,
+      details,
+      "Check MCP server compatibility and protocol version"
+    );
+  }
+  /**
+   * MCP duplicate server name
+   */
+  static duplicateName(name, existingName) {
+    return new DextoRuntimeError(
+      MCPErrorCode.DUPLICATE_NAME,
+      ErrorScope.MCP,
+      ErrorType.USER,
+      `Server name '${name}' conflicts with existing '${existingName}'`,
+      { name, existingName },
+      "Use a unique name for each MCP server"
+    );
+  }
+  /**
+   * MCP tool not found
+   */
+  static toolNotFound(toolName) {
+    return new DextoRuntimeError(
+      MCPErrorCode.TOOL_NOT_FOUND,
+      ErrorScope.MCP,
+      ErrorType.NOT_FOUND,
+      `No MCP tool found: ${toolName}`,
+      { toolName }
+    );
+  }
+  /**
+   * MCP prompt not found
+   */
+  static promptNotFound(promptName) {
+    return new DextoRuntimeError(
+      MCPErrorCode.PROMPT_NOT_FOUND,
+      ErrorScope.MCP,
+      ErrorType.NOT_FOUND,
+      `No client found for prompt: ${promptName}`,
+      { promptName }
+    );
+  }
+  /**
+   * MCP resource not found
+   */
+  static resourceNotFound(resourceUri) {
+    return new DextoRuntimeError(
+      MCPErrorCode.RESOURCE_NOT_FOUND,
+      ErrorScope.MCP,
+      ErrorType.NOT_FOUND,
+      `No client found for resource: ${resourceUri}`,
+      { resourceUri }
+    );
+  }
+  /**
+   * MCP client not connected
+   */
+  static clientNotConnected(context) {
+    return new DextoRuntimeError(
+      MCPErrorCode.CONNECTION_FAILED,
+      ErrorScope.MCP,
+      ErrorType.SYSTEM,
+      `MCP client is not connected${context ? `: ${context}` : ""}`,
+      { context }
+    );
+  }
+  /**
+   * Invalid tool schema
+   */
+  static invalidToolSchema(toolName, reason) {
+    return new DextoRuntimeError(
+      MCPErrorCode.PROTOCOL_ERROR,
+      ErrorScope.MCP,
+      ErrorType.THIRD_PARTY,
+      `Tool '${toolName}' has invalid schema: ${reason}`,
+      { toolName, reason }
+    );
+  }
+}
+export {
+  MCPError
+};

package/dist/mcp/index.cjs

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mcp_exports = {};
+module.exports = __toCommonJS(mcp_exports);
+__reExport(mcp_exports, require("./manager.js"), module.exports);
+__reExport(mcp_exports, require("./mcp-client.js"), module.exports);
+__reExport(mcp_exports, require("./types.js"), module.exports);
+__reExport(mcp_exports, require("./schemas.js"), module.exports);
+__reExport(mcp_exports, require("./errors.js"), module.exports);
+__reExport(mcp_exports, require("./error-codes.js"), module.exports);
+__reExport(mcp_exports, require("./resolver.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./manager.js"),
+  ...require("./mcp-client.js"),
+  ...require("./types.js"),
+  ...require("./schemas.js"),
+  ...require("./errors.js"),
+  ...require("./error-codes.js"),
+  ...require("./resolver.js")
+});

package/dist/mcp/index.d.cts

@@ -0,0 +1,26 @@
+export { MCPManager } from './manager.cjs';
+export { MCPClient } from './mcp-client.cjs';
+export { IMCPClient } from './types.cjs';
+export { HttpServerConfig, HttpServerConfigSchema, McpServerConfig, McpServerConfigSchema, ServerConfigs, ServerConfigsSchema, SseServerConfig, SseServerConfigSchema, StdioServerConfig, StdioServerConfigSchema, ValidatedHttpServerConfig, ValidatedMcpServerConfig, ValidatedServerConfigs, ValidatedSseServerConfig, ValidatedStdioServerConfig } from './schemas.cjs';
+export { MCPError } from './errors.cjs';
+export { MCPErrorCode } from './error-codes.cjs';
+export { McpServerContext, resolveAndValidateMcpServerConfig } from './resolver.cjs';
+import '../tools/types.cjs';
+import 'json-schema';
+import 'zod';
+import '@modelcontextprotocol/sdk/types.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '../errors/DextoRuntimeError.cjs';
+import '../errors/DextoBaseError.cjs';
+import '../errors/types.cjs';
+import '../agent/error-codes.cjs';
+import '../config/error-codes.cjs';
+import '../context/error-codes.cjs';
+import '../llm/error-codes.cjs';
+import '../session/error-codes.cjs';
+import '../storage/error-codes.cjs';
+import '../systemPrompt/error-codes.cjs';
+import '../tools/error-codes.cjs';
+import '../preferences/error-codes.cjs';
+import '../agent/registry/error-codes.cjs';
+import '../utils/result.cjs';

package/dist/mcp/index.d.ts

@@ -0,0 +1,26 @@
+export { MCPManager } from './manager.js';
+export { MCPClient } from './mcp-client.js';
+export { IMCPClient } from './types.js';
+export { HttpServerConfig, HttpServerConfigSchema, McpServerConfig, McpServerConfigSchema, ServerConfigs, ServerConfigsSchema, SseServerConfig, SseServerConfigSchema, StdioServerConfig, StdioServerConfigSchema, ValidatedHttpServerConfig, ValidatedMcpServerConfig, ValidatedServerConfigs, ValidatedSseServerConfig, ValidatedStdioServerConfig } from './schemas.js';
+export { MCPError } from './errors.js';
+export { MCPErrorCode } from './error-codes.js';
+export { McpServerContext, resolveAndValidateMcpServerConfig } from './resolver.js';
+import '../tools/types.js';
+import 'json-schema';
+import 'zod';
+import '@modelcontextprotocol/sdk/types.js';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '../errors/DextoRuntimeError.js';
+import '../errors/DextoBaseError.js';
+import '../errors/types.js';
+import '../agent/error-codes.js';
+import '../config/error-codes.js';
+import '../context/error-codes.js';
+import '../llm/error-codes.js';
+import '../session/error-codes.js';
+import '../storage/error-codes.js';
+import '../systemPrompt/error-codes.js';
+import '../tools/error-codes.js';
+import '../preferences/error-codes.js';
+import '../agent/registry/error-codes.js';
+import '../utils/result.js';

package/dist/mcp/index.js

@@ -0,0 +1,7 @@
+export * from "./manager.js";
+export * from "./mcp-client.js";
+export * from "./types.js";
+export * from "./schemas.js";
+export * from "./errors.js";
+export * from "./error-codes.js";
+export * from "./resolver.js";

package/dist/mcp/manager.cjs

@@ -0,0 +1,473 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var manager_exports = {};
+__export(manager_exports, {
+  MCPManager: () => MCPManager
+});
+module.exports = __toCommonJS(manager_exports);
+var import_mcp_client = require("./mcp-client.js");
+var import_logger = require("../logger/index.js");
+var import_errors = require("./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)) {
+      import_logger.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 import_errors.MCPError.duplicateName(name, existingServerWithSameSanitizedName);
+    }
+    this.clients.set(name, client);
+    this.sanitizedNameToServerMap.set(sanitizedName, name);
+    import_logger.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();
+    }
+    import_logger.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();
+      import_logger.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);
+          import_logger.logger.warn(
+            `\u26A0\uFE0F  Tool conflict detected for '${toolName}' - will use server prefix`
+          );
+        } else if (!this.toolConflicts.has(toolName)) {
+          this.toolToClientMap.set(toolName, client);
+          import_logger.logger.debug(`\u2705 Tool '${toolName}' mapped to ${clientName}`);
+        }
+      }
+      import_logger.logger.debug(
+        `\u2705 Successfully cached ${Object.keys(tools).length} tools for client: ${clientName}`
+      );
+    } catch (error) {
+      import_logger.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);
+      });
+      import_logger.logger.debug(`Cached prompts for client: ${clientName}`);
+    } catch (error) {
+      import_logger.logger.debug(`Skipping prompts for client ${clientName}: ${error}`);
+    }
+    try {
+      const resources = await client.listResources();
+      resources.forEach((resourceUri) => {
+        this.resourceToClientMap.set(resourceUri, client);
+      });
+      import_logger.logger.debug(`Cached resources for client: ${clientName}`);
+    } catch (error) {
+      import_logger.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}`
+            };
+          }
+        }
+      }
+    }
+    import_logger.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 (import_logger.logger.getLevel() === "debug") {
+      Object.keys(allTools).forEach((toolName) => {
+        if (toolName.includes(MCPManager.SERVER_DELIMITER)) {
+          import_logger.logger.debug(`  - ${toolName} (qualified)`);
+        } else {
+          import_logger.logger.debug(`  - ${toolName}`);
+        }
+      });
+    }
+    import_logger.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) {
+      import_logger.logger.error(`\u274C No MCP tool found: ${toolName}`);
+      import_logger.logger.debug(
+        `Available MCP tools: ${Array.from(this.toolToClientMap.keys()).join(", ")}`
+      );
+      import_logger.logger.debug(`Conflicted tools: ${Array.from(this.toolConflicts).join(", ")}`);
+      import_logger.logger.debug(
+        `Server tools map keys: ${Array.from(this.serverToolsMap.keys()).join(", ")}`
+      );
+      throw import_errors.MCPError.toolNotFound(toolName);
+    }
+    const parsed = this.parseQualifiedToolName(toolName);
+    const actualToolName = parsed ? parsed.toolName : toolName;
+    const serverName = parsed ? parsed.serverName : "direct";
+    import_logger.logger.debug(`\u25B6\uFE0F  Executing MCP tool '${actualToolName}' on server '${serverName}'...`);
+    try {
+      const result = await client.callTool(actualToolName, args);
+      return result;
+    } catch (error) {
+      import_logger.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 import_errors.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 import_errors.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) {
+      import_logger.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) => {
+        import_logger.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 import_errors.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)) {
+      import_logger.logger.warn(`Client '${name}' is already connected or registered.`);
+      return;
+    }
+    const client = new import_mcp_client.MCPClient();
+    try {
+      import_logger.logger.info(`Attempting to connect to new server '${name}'...`);
+      await client.connect(config, name);
+      this.registerClient(name, client);
+      await this.updateClientCache(name, client);
+      import_logger.logger.info(`Successfully connected and cached new server '${name}'`);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      this.connectionErrors[name] = errorMsg;
+      import_logger.logger.error(`Failed to connect to new server '${name}': ${errorMsg}`);
+      this.clients.delete(name);
+      throw import_errors.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();
+          import_logger.logger.info(`Successfully disconnected client: ${name}`);
+        } catch (error) {
+          import_logger.logger.error(
+            `Error disconnecting client '${name}': ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      this.clearClientCache(name);
+      this.clients.delete(name);
+      import_logger.logger.info(`Removed client from manager: ${name}`);
+    }
+    if (this.connectionErrors[name]) {
+      delete this.connectionErrors[name];
+      import_logger.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(() => import_logger.logger.info(`Disconnected client: ${name}`)).catch(
+            (error) => import_logger.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();
+    import_logger.logger.info("Disconnected all clients and cleared caches.");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPManager
+});