@xiaozhi-client/mcp-core 1.9.7-beta.5 → 1.9.7-beta.6

package/dist/index.js

@@ -53,144 +53,806 @@ var ToolCallError = class extends Error {
   }
 };
 
-// src/manager.ts
-import { EventEmitter } from "events";
-var MCPServiceManager = class extends EventEmitter {
+// src/connection.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+
+// src/transport-factory.ts
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { EventSource } from "eventsource";
+var globalThisAny = typeof globalThis !== "undefined" ? globalThis : global;
+if (typeof globalThisAny !== "undefined" && !globalThisAny.EventSource) {
+  globalThisAny.EventSource = EventSource;
+}
+function createTransport(config) {
+  console.debug(
+    `[TransportFactory] \u521B\u5EFA ${config.type} transport for ${config.name}`
+  );
+  switch (config.type) {
+    case "stdio" /* STDIO */:
+      return createStdioTransport(config);
+    case "sse" /* SSE */:
+      return createSSETransport(config);
+    case "streamable-http" /* STREAMABLE_HTTP */:
+      return createStreamableHTTPTransport(config);
+    default:
+      throw new Error(`\u4E0D\u652F\u6301\u7684\u4F20\u8F93\u7C7B\u578B: ${config.type}`);
+  }
+}
+__name(createTransport, "createTransport");
+function createStdioTransport(config) {
+  if (!config.command) {
+    throw new Error("stdio transport \u9700\u8981 command \u914D\u7F6E");
+  }
+  return new StdioClientTransport({
+    command: config.command,
+    args: config.args || [],
+    env: config.env
+    // 传递环境变量
+  });
+}
+__name(createStdioTransport, "createStdioTransport");
+function createSSETransport(config) {
+  if (!config.url) {
+    throw new Error("SSE transport \u9700\u8981 URL \u914D\u7F6E");
+  }
+  const url = new URL(config.url);
+  const options = createSSEOptions(config);
+  return new SSEClientTransport(url, options);
+}
+__name(createSSETransport, "createSSETransport");
+function createStreamableHTTPTransport(config) {
+  if (!config.url) {
+    throw new Error("StreamableHTTP transport \u9700\u8981 URL \u914D\u7F6E");
+  }
+  const url = new URL(config.url);
+  const options = createStreamableHTTPOptions(config);
+  return new StreamableHTTPClientTransport(url, options);
+}
+__name(createStreamableHTTPTransport, "createStreamableHTTPTransport");
+function createSSEOptions(config) {
+  const options = {};
+  if (config.apiKey) {
+    options.requestInit = {
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        ...config.headers
+      }
+    };
+  } else if (config.headers) {
+    options.requestInit = {
+      headers: config.headers
+    };
+  }
+  return options;
+}
+__name(createSSEOptions, "createSSEOptions");
+function createStreamableHTTPOptions(config) {
+  const options = {};
+  if (config.apiKey) {
+    options.requestInit = {
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        ...config.headers
+      }
+    };
+  } else if (config.headers) {
+    options.requestInit = {
+      headers: config.headers
+    };
+  }
+  return options;
+}
+__name(createStreamableHTTPOptions, "createStreamableHTTPOptions");
+function validateConfig(config) {
+  if (!config.name || typeof config.name !== "string") {
+    throw new Error("\u914D\u7F6E\u5FC5\u987B\u5305\u542B\u6709\u6548\u7684 name \u5B57\u6BB5");
+  }
+  if (config.type && !Object.values(MCPTransportType).includes(config.type)) {
+    throw new Error(`\u4E0D\u652F\u6301\u7684\u4F20\u8F93\u7C7B\u578B: ${config.type}`);
+  }
+  if (!config.type) {
+    throw new Error("\u4F20\u8F93\u7C7B\u578B\u672A\u8BBE\u7F6E\uFF0C\u8FD9\u5E94\u8BE5\u5728 inferTransportType \u4E2D\u5904\u7406");
+  }
+  switch (config.type) {
+    case "stdio" /* STDIO */:
+      if (!config.command) {
+        throw new Error("stdio \u7C7B\u578B\u9700\u8981 command \u5B57\u6BB5");
+      }
+      break;
+    case "sse" /* SSE */:
+      if (config.url === void 0 || config.url === null) {
+        throw new Error(`${config.type} \u7C7B\u578B\u9700\u8981 url \u5B57\u6BB5`);
+      }
+      break;
+    case "streamable-http" /* STREAMABLE_HTTP */:
+      if (config.url === void 0 || config.url === null) {
+        throw new Error(`${config.type} \u7C7B\u578B\u9700\u8981 url \u5B57\u6BB5`);
+      }
+      break;
+    default:
+      throw new Error(`\u4E0D\u652F\u6301\u7684\u4F20\u8F93\u7C7B\u578B: ${config.type}`);
+  }
+}
+__name(validateConfig, "validateConfig");
+function getSupportedTypes() {
+  return [
+    "stdio" /* STDIO */,
+    "sse" /* SSE */,
+    "streamable-http" /* STREAMABLE_HTTP */
+  ];
+}
+__name(getSupportedTypes, "getSupportedTypes");
+var TransportFactory = {
+  create: createTransport,
+  validateConfig,
+  getSupportedTypes
+};
+
+// src/utils/type-normalizer.ts
+var TypeFieldNormalizer;
+((TypeFieldNormalizer2) => {
+  function normalizeTypeField2(config) {
+    if (!config || typeof config !== "object") {
+      return config;
+    }
+    const normalizedConfig = JSON.parse(JSON.stringify(config));
+    if (!("type" in normalizedConfig)) {
+      return normalizedConfig;
+    }
+    const originalType = normalizedConfig.type;
+    if (originalType === "sse" || originalType === "streamable-http") {
+      return normalizedConfig;
+    }
+    let normalizedType;
+    if (originalType === "streamableHttp" || originalType === "streamable_http") {
+      normalizedType = "streamable-http";
+    } else if (originalType === "s_se" || originalType === "s-se") {
+      normalizedType = "sse";
+    } else {
+      normalizedType = convertToKebabCase(originalType);
+    }
+    if (normalizedType === "sse" || normalizedType === "streamable-http") {
+      normalizedConfig.type = normalizedType;
+      if (originalType !== normalizedType) {
+      }
+    }
+    return normalizedConfig;
+  }
+  TypeFieldNormalizer2.normalizeTypeField = normalizeTypeField2;
+  __name(normalizeTypeField2, "normalizeTypeField");
+  function convertToKebabCase(str) {
+    return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+  }
+  __name(convertToKebabCase, "convertToKebabCase");
+})(TypeFieldNormalizer || (TypeFieldNormalizer = {}));
+function normalizeTypeField(config) {
+  return TypeFieldNormalizer.normalizeTypeField(config);
+}
+__name(normalizeTypeField, "normalizeTypeField");
+
+// src/utils/validators.ts
+function inferTransportTypeFromUrl(url, options) {
+  try {
+    const parsedUrl = new URL(url);
+    const pathname = parsedUrl.pathname;
+    if (pathname.endsWith("/sse")) {
+      return "sse" /* SSE */;
+    }
+    if (pathname.endsWith("/mcp")) {
+      return "streamable-http" /* STREAMABLE_HTTP */;
+    }
+    if (options?.serviceName) {
+      console.info(
+        `[MCP-${options.serviceName}] URL \u8DEF\u5F84 ${pathname} \u4E0D\u5339\u914D\u7279\u5B9A\u89C4\u5219\uFF0C\u9ED8\u8BA4\u63A8\u65AD\u4E3A streamable-http \u7C7B\u578B`
+      );
+    }
+    return "streamable-http" /* STREAMABLE_HTTP */;
+  } catch (error) {
+    if (options?.serviceName) {
+      console.warn(
+        `[MCP-${options.serviceName}] URL \u89E3\u6790\u5931\u8D25\uFF0C\u9ED8\u8BA4\u63A8\u65AD\u4E3A streamable-http \u7C7B\u578B`,
+        error
+      );
+    }
+    return "streamable-http" /* STREAMABLE_HTTP */;
+  }
+}
+__name(inferTransportTypeFromUrl, "inferTransportTypeFromUrl");
+function inferTransportTypeFromConfig(config) {
+  if (config.type) {
+    const normalizedConfig = TypeFieldNormalizer.normalizeTypeField(config);
+    return normalizedConfig;
+  }
+  if (config.command) {
+    return {
+      ...config,
+      type: "stdio" /* STDIO */
+    };
+  }
+  if (config.url !== void 0 && config.url !== null) {
+    const inferredType = inferTransportTypeFromUrl(config.url, {
+      serviceName: config.name
+    });
+    return {
+      ...config,
+      type: inferredType
+    };
+  }
+  throw new Error(
+    `\u65E0\u6CD5\u4E3A\u670D\u52A1 ${config.name} \u63A8\u65AD\u4F20\u8F93\u7C7B\u578B\u3002\u8BF7\u663E\u5F0F\u6307\u5B9A type \u5B57\u6BB5\uFF0C\u6216\u63D0\u4F9B command/url \u914D\u7F6E`
+  );
+}
+__name(inferTransportTypeFromConfig, "inferTransportTypeFromConfig");
+function validateToolCallParams(params, options) {
+  const opts = {
+    validateName: true,
+    validateArguments: true,
+    allowEmptyArguments: true,
+    ...options
+  };
+  if (!params || typeof params !== "object") {
+    throw new ToolCallError(
+      -32602 /* INVALID_PARAMS */,
+      "\u8BF7\u6C42\u53C2\u6570\u5FC5\u987B\u662F\u5BF9\u8C61"
+    );
+  }
+  const paramsObj = params;
+  if (opts.validateName) {
+    if (!paramsObj.name || typeof paramsObj.name !== "string") {
+      throw new ToolCallError(
+        -32602 /* INVALID_PARAMS */,
+        "\u5DE5\u5177\u540D\u79F0\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32"
+      );
+    }
+  }
+  if (opts.validateArguments && paramsObj.arguments !== void 0 && paramsObj.arguments !== null) {
+    if (typeof paramsObj.arguments !== "object" || Array.isArray(paramsObj.arguments)) {
+      throw new ToolCallError(
+        -32602 /* INVALID_PARAMS */,
+        "\u5DE5\u5177\u53C2\u6570\u5FC5\u987B\u662F\u5BF9\u8C61"
+      );
+    }
+  }
+  if (!opts.allowEmptyArguments && paramsObj.arguments !== void 0 && paramsObj.arguments !== null) {
+    const argsObj = paramsObj.arguments;
+    if (Object.keys(argsObj).length === 0) {
+      throw new ToolCallError(
+        -32602 /* INVALID_PARAMS */,
+        "\u5DE5\u5177\u53C2\u6570\u4E0D\u80FD\u4E3A\u7A7A"
+      );
+    }
+  }
+  if (opts.customValidator) {
+    const error = opts.customValidator(paramsObj);
+    if (error) {
+      throw new ToolCallError(-32602 /* INVALID_PARAMS */, error);
+    }
+  }
+  return {
+    name: paramsObj.name,
+    arguments: paramsObj.arguments
+  };
+}
+__name(validateToolCallParams, "validateToolCallParams");
+
+// src/connection.ts
+var MCPConnection = class {
   static {
-    __name(this, "MCPServiceManager");
+    __name(this, "MCPConnection");
   }
-  configs = {};
+  config;
+  client = null;
+  transport = null;
   tools = /* @__PURE__ */ new Map();
-  isInitialized = false;
-  constructor(configs) {
-    super();
-    if (configs) {
-      this.configs = configs;
-    }
+  connectionState = "disconnected" /* DISCONNECTED */;
+  connectionTimeout = null;
+  initialized = false;
+  callbacks;
+  constructor(config, callbacks) {
+    this.config = inferTransportTypeFromConfig(config);
+    this.callbacks = callbacks;
+    this.validateConfig();
   }
   /**
-   * 添加服务配置
+   * 验证配置
    */
-  addServiceConfig(name, config) {
-    this.configs[name] = { ...config, name };
+  validateConfig() {
+    TransportFactory.validateConfig(this.config);
   }
   /**
-   * 更新服务配置
+   * 连接到 MCP 服务
    */
-  updateServiceConfig(name, config) {
-    if (!this.configs[name]) {
-      throw new Error(`\u670D\u52A1\u4E0D\u5B58\u5728: ${name}`);
+  async connect() {
+    if (this.connectionState === "connecting" /* CONNECTING */) {
+      throw new Error("\u8FDE\u63A5\u6B63\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5F85\u8FDE\u63A5\u5B8C\u6210");
     }
-    this.configs[name] = { ...config, name };
+    this.cleanupConnection();
+    return this.attemptConnection();
   }
   /**
-   * 移除服务配置
+   * 尝试建立连接
    */
-  removeServiceConfig(name) {
-    delete this.configs[name];
+  async attemptConnection() {
+    this.connectionState = "connecting" /* CONNECTING */;
+    console.debug(
+      `[MCP-${this.config.name}] \u6B63\u5728\u8FDE\u63A5 MCP \u670D\u52A1: ${this.config.name}`
+    );
+    return new Promise((resolve, reject) => {
+      this.connectionTimeout = setTimeout(() => {
+        const error = new Error(`\u8FDE\u63A5\u8D85\u65F6 (${this.config.timeout || 1e4}ms)`);
+        this.handleConnectionError(error);
+        reject(error);
+      }, this.config.timeout || 1e4);
+      try {
+        this.client = new Client(
+          {
+            name: `xiaozhi-${this.config.name}-client`,
+            version: "1.0.0"
+          },
+          {
+            capabilities: {}
+          }
+        );
+        this.transport = TransportFactory.create(this.config);
+        this.client.connect(this.transport).then(async () => {
+          this.handleConnectionSuccess();
+          await this.refreshTools();
+          this.callbacks?.onConnected?.({
+            serviceName: this.config.name,
+            tools: this.getTools(),
+            connectionTime: /* @__PURE__ */ new Date()
+          });
+          resolve();
+        }).catch((error) => {
+          this.handleConnectionError(error);
+          reject(error);
+        });
+      } catch (error) {
+        this.handleConnectionError(error);
+        reject(error);
+      }
+    });
   }
   /**
-   * 获取所有服务配置
+   * 处理连接成功
    */
-  getServiceConfigs() {
-    return { ...this.configs };
+  handleConnectionSuccess() {
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+      this.connectionTimeout = null;
+    }
+    this.connectionState = "connected" /* CONNECTED */;
+    this.initialized = true;
+    console.info(
+      `[MCP-${this.config.name}] MCP \u670D\u52A1 ${this.config.name} \u8FDE\u63A5\u5DF2\u5EFA\u7ACB`
+    );
   }
   /**
-   * 启动所有服务
+   * 处理连接错误
    */
-  async startAllServices() {
-    if (this.isInitialized) {
-      return;
+  handleConnectionError(error) {
+    this.connectionState = "disconnected" /* DISCONNECTED */;
+    this.initialized = false;
+    console.debug(`MCP \u670D\u52A1 ${this.config.name} \u8FDE\u63A5\u9519\u8BEF:`, error.message);
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+      this.connectionTimeout = null;
     }
-    this.isInitialized = true;
-    this.emit("initialized");
+    this.cleanupConnection();
+    this.callbacks?.onConnectionFailed?.({
+      serviceName: this.config.name,
+      error,
+      attempt: 0
+    });
   }
   /**
-   * 启动单个服务
+   * 清理连接资源
    */
-  async startService(serviceName) {
-    if (!this.configs[serviceName]) {
-      throw new Error(`\u670D\u52A1\u914D\u7F6E\u4E0D\u5B58\u5728: ${serviceName}`);
+  cleanupConnection() {
+    if (this.client) {
+      try {
+        this.client.close().catch(() => {
+        });
+      } catch (error) {
+      }
+      this.client = null;
+    }
+    this.transport = null;
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+      this.connectionTimeout = null;
     }
-    this.emit("serviceStarted", serviceName);
+    this.initialized = false;
   }
   /**
-   * 获取所有工具列表
+   * 刷新工具列表
    */
-  getAllTools(status = "all") {
-    const allTools = Array.from(this.tools.values());
-    if (status === "all") {
-      return allTools;
+  async refreshTools() {
+    if (!this.client) {
+      throw new Error("\u5BA2\u6237\u7AEF\u672A\u521D\u59CB\u5316");
+    }
+    try {
+      const toolsResult = await this.client.listTools();
+      const tools = toolsResult.tools || [];
+      this.tools.clear();
+      for (const tool of tools) {
+        this.tools.set(tool.name, tool);
+      }
+      console.debug(
+        `${this.config.name} \u670D\u52A1\u52A0\u8F7D\u4E86 ${tools.length} \u4E2A\u5DE5\u5177: ${tools.map((t) => t.name).join(", ")}`
+      );
+    } catch (error) {
+      console.error(
+        `${this.config.name} \u83B7\u53D6\u5DE5\u5177\u5217\u8868\u5931\u8D25:`,
+        error instanceof Error ? error.message : String(error)
+      );
+      throw error;
     }
-    return allTools.filter(
-      (tool) => status === "enabled" ? tool.enabled : !tool.enabled
-    );
+  }
+  /**
+   * 断开连接
+   */
+  async disconnect() {
+    console.info(`\u4E3B\u52A8\u65AD\u5F00 MCP \u670D\u52A1 ${this.config.name} \u8FDE\u63A5`);
+    this.cleanupConnection();
+    this.connectionState = "disconnected" /* DISCONNECTED */;
+    this.callbacks?.onDisconnected?.({
+      serviceName: this.config.name,
+      reason: "\u624B\u52A8\u65AD\u5F00",
+      disconnectionTime: /* @__PURE__ */ new Date()
+    });
+  }
+  /**
+   * 获取工具列表
+   */
+  getTools() {
+    return Array.from(this.tools.values());
   }
   /**
    * 调用工具
    */
-  async callTool(toolName, _arguments_, _options) {
-    const tool = this.tools.get(toolName);
-    if (!tool) {
-      throw new ToolCallError(
-        -32601 /* TOOL_NOT_FOUND */,
-        `\u5DE5\u5177\u4E0D\u5B58\u5728: ${toolName}`
-      );
+  async callTool(name, arguments_) {
+    if (!this.client) {
+      throw new Error(`\u670D\u52A1 ${this.config.name} \u672A\u8FDE\u63A5`);
     }
-    if (!tool.enabled) {
-      throw new ToolCallError(
-        -32001 /* SERVICE_UNAVAILABLE */,
-        `\u5DE5\u5177\u5DF2\u7981\u7528: ${toolName}`
+    if (!this.tools.has(name)) {
+      throw new Error(`\u5DE5\u5177 ${name} \u5728\u670D\u52A1 ${this.config.name} \u4E2D\u4E0D\u5B58\u5728`);
+    }
+    console.debug(
+      `\u8C03\u7528 ${this.config.name} \u670D\u52A1\u7684\u5DE5\u5177 ${name}\uFF0C\u53C2\u6570:`,
+      JSON.stringify(arguments_)
+    );
+    try {
+      const result = await this.client.callTool({
+        name,
+        arguments: arguments_ || {}
+      });
+      console.debug(
+        `\u5DE5\u5177 ${name} \u8C03\u7528\u6210\u529F\uFF0C\u7ED3\u679C:`,
+        `${JSON.stringify(result).substring(0, 500)}...`
+      );
+      return result;
+    } catch (error) {
+      console.error(
+        `\u5DE5\u5177 ${name} \u8C03\u7528\u5931\u8D25:`,
+        error instanceof Error ? error.message : String(error)
       );
+      throw error;
     }
+  }
+  /**
+   * 获取服务配置
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * 获取服务状态
+   */
+  getStatus() {
     return {
-      content: [
-        {
-          type: "text",
-          text: `\u5DE5\u5177 ${toolName} \u9700\u8981\u901A\u8FC7\u5B9E\u9645\u7684 MCP \u8FDE\u63A5\u8C03\u7528`
-        }
-      ],
-      isError: false
+      name: this.config.name,
+      connected: this.connectionState === "connected" /* CONNECTED */,
+      initialized: this.initialized,
+      transportType: this.config.type || "streamable-http" /* STREAMABLE_HTTP */,
+      toolCount: this.tools.size,
+      connectionState: this.connectionState
     };
   }
   /**
-   * 添加工具（用于测试或自定义工具）
+   * 检查是否已连接
    */
-  addTool(tool) {
-    this.tools.set(tool.name, tool);
+  isConnected() {
+    return this.connectionState === "connected" /* CONNECTED */ && this.initialized;
+  }
+};
+
+// src/manager.ts
+import { EventEmitter } from "events";
+var MCPManager = class extends EventEmitter {
+  static {
+    __name(this, "MCPManager");
+  }
+  connections = /* @__PURE__ */ new Map();
+  configs = /* @__PURE__ */ new Map();
+  constructor() {
+    super();
   }
   /**
-   * 移除工具
+   * 添加 MCP 服务器配置
+   * @param name 服务器名称
+   * @param config 服务器配置
+   *
+   * @example
+   * ```typescript
+   * // 添加 stdio 服务
+   * manager.addServer('calculator', {
+   *   type: 'stdio',
+   *   command: 'node',
+   *   args: ['calculator.js']
+   * });
+   *
+   * // 添加 HTTP 服务
+   * manager.addServer('web-search', {
+   *   type: 'http',
+   *   url: 'https://api.example.com/mcp',
+   *   headers: {
+   *     Authorization: 'Bearer your-api-key'
+   *   }
+   * });
+   * ```
    */
-  removeTool(toolName) {
-    this.tools.delete(toolName);
+  addServer(name, config) {
+    if (this.configs.has(name)) {
+      throw new Error(`\u670D\u52A1 ${name} \u5DF2\u5B58\u5728`);
+    }
+    const fullConfig = {
+      ...config,
+      name
+    };
+    if (config.type) {
+      const typeStr = String(config.type);
+      if (typeStr === "http") {
+        fullConfig.type = "streamable-http" /* STREAMABLE_HTTP */;
+      } else if (typeStr === "sse") {
+        fullConfig.type = "sse" /* SSE */;
+      } else {
+        fullConfig.type = config.type;
+      }
+    }
+    this.configs.set(name, fullConfig);
   }
   /**
-   * 获取管理器状态
+   * 移除服务器配置
+   * @param name 服务器名称
    */
-  getStatus() {
-    const availableTools = this.getAllTools("enabled").map((t) => t.name);
+  removeServer(name) {
+    return this.configs.delete(name);
+  }
+  /**
+   * 连接所有已添加的 MCP 服务
+   * 所有服务并行连接，单个服务失败不会影响其他服务
+   *
+   * @example
+   * ```typescript
+   * await manager.connect();
+   * ```
+   */
+  async connect() {
+    this.emit("connect");
+    const promises = Array.from(this.configs.entries()).map(
+      async ([name, config]) => {
+        try {
+          const connection = new MCPConnection(config, {
+            onConnected: /* @__PURE__ */ __name((data) => {
+              this.emit("connected", {
+                serverName: data.serviceName,
+                tools: data.tools
+              });
+            }, "onConnected"),
+            onDisconnected: /* @__PURE__ */ __name((data) => {
+              this.emit("disconnected", {
+                serverName: data.serviceName,
+                reason: data.reason
+              });
+            }, "onDisconnected"),
+            onConnectionFailed: /* @__PURE__ */ __name((data) => {
+              this.emit("error", {
+                serverName: data.serviceName,
+                error: data.error
+              });
+            }, "onConnectionFailed")
+          });
+          await connection.connect();
+          this.connections.set(name, connection);
+        } catch (error) {
+          this.emit("error", { serverName: name, error });
+          throw error;
+        }
+      }
+    );
+    await Promise.allSettled(promises);
+  }
+  /**
+   * 断开所有 MCP 服务连接
+   *
+   * @example
+   * ```typescript
+   * await manager.disconnect();
+   * ```
+   */
+  async disconnect() {
+    const promises = Array.from(this.connections.values()).map(
+      (conn) => conn.disconnect()
+    );
+    await Promise.allSettled(promises);
+    this.connections.clear();
+    this.emit("disconnect");
+  }
+  /**
+   * 调用指定服务的工具
+   * @param serverName 服务名称
+   * @param toolName 工具名称
+   * @param args 工具参数
+   *
+   * @example
+   * ```typescript
+   * const result = await manager.callTool('datetime', 'get_current_time', {
+   *   format: 'YYYY-MM-DD HH:mm:ss'
+   * });
+   * ```
+   */
+  async callTool(serverName, toolName, args) {
+    const connection = this.connections.get(serverName);
+    if (!connection) {
+      throw new Error(`\u670D\u52A1 ${serverName} \u4E0D\u5B58\u5728`);
+    }
+    if (!connection.isConnected()) {
+      throw new Error(`\u670D\u52A1 ${serverName} \u672A\u8FDE\u63A5`);
+    }
+    return connection.callTool(toolName, args);
+  }
+  /**
+   * 列出所有可用的工具
+   * @returns 工具列表，格式为 [{ name, serverName, description, inputSchema }]
+   *
+   * @example
+   * ```typescript
+   * const tools = manager.listTools();
+   * console.log('可用工具:', tools.map(t => `${t.serverName}/${t.name}`));
+   * ```
+   */
+  listTools() {
+    const allTools = [];
+    for (const [serverName, connection] of this.connections) {
+      if (connection.isConnected()) {
+        const tools = connection.getTools();
+        for (const tool of tools) {
+          allTools.push({
+            name: tool.name,
+            serverName,
+            description: tool.description || "",
+            inputSchema: tool.inputSchema
+          });
+        }
+      }
+    }
+    return allTools;
+  }
+  /**
+   * 获取服务状态
+   * @param serverName 服务名称
+   * @returns 服务状态，如果服务不存在则返回 null
+   *
+   * @example
+   * ```typescript
+   * const status = manager.getServerStatus('datetime');
+   * if (status) {
+   *   console.log(`已连接: ${status.connected}, 工具数: ${status.toolCount}`);
+   * }
+   * ```
+   */
+  getServerStatus(serverName) {
+    const connection = this.connections.get(serverName);
+    if (!connection) {
+      return null;
+    }
+    const status = connection.getStatus();
     return {
-      services: {},
-      totalTools: this.tools.size,
-      availableTools
+      connected: status.connected,
+      toolCount: status.toolCount
     };
   }
   /**
-   * 清理资源
+   * 获取所有服务的状态
+   * @returns 所有服务的状态映射
+   *
+   * @example
+   * ```typescript
+   * const statuses = manager.getAllServerStatus();
+   * console.log(statuses);
+   * // {
+   * //   datetime: { connected: true, toolCount: 3 },
+   * //   calculator: { connected: true, toolCount: 1 }
+   * // }
+   * ```
+   */
+  getAllServerStatus() {
+    const statuses = {};
+    for (const [serverName, connection] of this.connections) {
+      const status = connection.getStatus();
+      statuses[serverName] = {
+        connected: status.connected,
+        toolCount: status.toolCount
+      };
+    }
+    return statuses;
+  }
+  /**
+   * 检查服务是否已连接
+   * @param serverName 服务名称
+   *
+   * @example
+   * ```typescript
+   * if (manager.isConnected('datetime')) {
+   *   console.log('datetime 服务已连接');
+   * }
+   * ```
+   */
+  isConnected(serverName) {
+    const connection = this.connections.get(serverName);
+    return connection ? connection.isConnected() : false;
+  }
+  /**
+   * 获取已配置的服务列表
+   * @returns 服务名称数组
+   *
+   * @example
+   * ```typescript
+   * const servers = manager.getServerNames();
+   * console.log('已配置的服务:', servers);
+   * ```
    */
-  async cleanup() {
-    this.tools.clear();
-    this.isInitialized = false;
+  getServerNames() {
+    return Array.from(this.configs.keys());
+  }
+  /**
+   * 获取已连接的服务列表
+   * @returns 已连接的服务名称数组
+   *
+   * @example
+   * ```typescript
+   * const connectedServers = manager.getConnectedServerNames();
+   * console.log('已连接的服务:', connectedServers);
+   * ```
+   */
+  getConnectedServerNames() {
+    const connected = [];
+    for (const [serverName, connection] of this.connections) {
+      if (connection.isConnected()) {
+        connected.push(serverName);
+      }
+    }
+    return connected;
   }
 };
 export {
   ConnectionState,
-  MCPServiceManager,
+  MCPConnection,
+  MCPManager,
+  MCPManager as MCPServiceManager,
   MCPTransportType,
   ToolCallError,
   ToolCallErrorCode,
+  TransportFactory,
+  TypeFieldNormalizer,
   ensureToolJSONSchema,
-  isValidToolJSONSchema
+  inferTransportTypeFromConfig,
+  inferTransportTypeFromUrl,
+  isValidToolJSONSchema,
+  normalizeTypeField,
+  validateToolCallParams
 };
 //# sourceMappingURL=index.js.map