@xiaozhi-client/endpoint 1.9.7-beta.3

package/dist/index.js

@@ -0,0 +1,846 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/endpoint.ts
+import WebSocket from "ws";
+
+// src/types.ts
+var ToolCallErrorCode = /* @__PURE__ */ ((ToolCallErrorCode2) => {
+  ToolCallErrorCode2[ToolCallErrorCode2["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+  ToolCallErrorCode2[ToolCallErrorCode2["TOOL_NOT_FOUND"] = -32601] = "TOOL_NOT_FOUND";
+  ToolCallErrorCode2[ToolCallErrorCode2["SERVICE_UNAVAILABLE"] = -32001] = "SERVICE_UNAVAILABLE";
+  ToolCallErrorCode2[ToolCallErrorCode2["TIMEOUT"] = -32002] = "TIMEOUT";
+  ToolCallErrorCode2[ToolCallErrorCode2["TOOL_EXECUTION_ERROR"] = -32e3] = "TOOL_EXECUTION_ERROR";
+  return ToolCallErrorCode2;
+})(ToolCallErrorCode || {});
+var ToolCallError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "ToolCallError";
+  }
+  static {
+    __name(this, "ToolCallError");
+  }
+};
+function ensureToolJSONSchema(schema) {
+  if (typeof schema === "object" && schema !== null && "type" in schema && schema.type === "object") {
+    return schema;
+  }
+  return {
+    type: "object",
+    properties: {},
+    required: [],
+    additionalProperties: true
+  };
+}
+__name(ensureToolJSONSchema, "ensureToolJSONSchema");
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["DISCONNECTED"] = "disconnected";
+  ConnectionState2["CONNECTING"] = "connecting";
+  ConnectionState2["CONNECTED"] = "connected";
+  ConnectionState2["FAILED"] = "failed";
+  return ConnectionState2;
+})(ConnectionState || {});
+
+// src/utils.ts
+function sliceEndpoint(endpoint) {
+  return `${endpoint.slice(0, 30)}...${endpoint.slice(-10)}`;
+}
+__name(sliceEndpoint, "sliceEndpoint");
+function validateToolCallParams(params) {
+  if (!params || typeof params !== "object") {
+    throw new Error("\u5DE5\u5177\u8C03\u7528\u53C2\u6570\u5FC5\u987B\u662F\u5BF9\u8C61");
+  }
+  const p = params;
+  if (!p.name || typeof p.name !== "string") {
+    throw new Error("\u5DE5\u5177\u540D\u79F0\u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+  }
+  const validated = {
+    name: p.name
+  };
+  if (p.arguments !== void 0) {
+    if (typeof p.arguments !== "object" || p.arguments === null) {
+      throw new Error("\u5DE5\u5177\u53C2\u6570\u5FC5\u987B\u662F\u5BF9\u8C61");
+    }
+    validated.arguments = p.arguments;
+  }
+  return validated;
+}
+__name(validateToolCallParams, "validateToolCallParams");
+function isValidEndpointUrl(endpoint) {
+  if (!endpoint || typeof endpoint !== "string") {
+    return false;
+  }
+  if (!endpoint.startsWith("ws://") && !endpoint.startsWith("wss://")) {
+    return false;
+  }
+  try {
+    new URL(endpoint);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isValidEndpointUrl, "isValidEndpointUrl");
+function deepMerge(target, ...sources) {
+  if (sources.length === 0) {
+    return target;
+  }
+  const source = sources.shift();
+  if (source === void 0) {
+    return target;
+  }
+  for (const key in source) {
+    if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key]) && typeof target[key] === "object" && target[key] !== null && !Array.isArray(target[key])) {
+      target[key] = deepMerge(
+        target[key],
+        source[key]
+      );
+    } else {
+      target[key] = source[key];
+    }
+  }
+  return deepMerge(target, ...sources);
+}
+__name(deepMerge, "deepMerge");
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(sleep, "sleep");
+function formatErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return String(error);
+}
+__name(formatErrorMessage, "formatErrorMessage");
+
+// src/internal-mcp-manager.ts
+var InternalMCPManagerAdapter = class {
+  constructor(config) {
+    this.config = config;
+  }
+  static {
+    __name(this, "InternalMCPManagerAdapter");
+  }
+  tools = /* @__PURE__ */ new Map();
+  isInitialized = false;
+  /**
+   * 初始化并启动所有 MCP 服务
+   */
+  async initialize() {
+    if (this.isInitialized) {
+      return;
+    }
+    for (const [serviceName, serverConfig] of Object.entries(
+      this.config.mcpServers
+    )) {
+      await this._loadServiceTools(serviceName, serverConfig);
+    }
+    this.isInitialized = true;
+  }
+  /**
+   * 获取所有工具列表
+   */
+  getAllTools() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * 调用工具
+   */
+  async callTool(toolName, arguments_) {
+    const tool = this.tools.get(toolName);
+    if (!tool) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `\u5DE5\u5177\u4E0D\u5B58\u5728: ${toolName}`
+          }
+        ],
+        isError: true
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: `\u5DE5\u5177 ${toolName} \u8C03\u7528\u6210\u529F\uFF08\u5360\u4F4D\u5B9E\u73B0\uFF09`
+        }
+      ],
+      isError: false
+    };
+  }
+  /**
+   * 清理资源
+   */
+  async cleanup() {
+    this.tools.clear();
+    this.isInitialized = false;
+  }
+  /**
+   * 加载服务的工具列表
+   * 这是一个简化实现，实际应该连接到 MCP 服务获取工具列表
+   */
+  async _loadServiceTools(serviceName, serverConfig) {
+    const toolName = `${serviceName}__tool`;
+    this.tools.set(toolName, {
+      name: toolName,
+      description: `\u6765\u81EA ${serviceName} \u7684\u5DE5\u5177`,
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      serviceName,
+      originalName: "tool",
+      enabled: true,
+      usageCount: 0,
+      lastUsedTime: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
+
+// src/endpoint.ts
+var Endpoint = class {
+  static {
+    __name(this, "Endpoint");
+  }
+  endpointUrl;
+  ws = null;
+  connectionStatus = false;
+  serverInitialized = false;
+  mcpAdapter;
+  // 连接状态管理
+  connectionState = "disconnected" /* DISCONNECTED */;
+  // 最后一次错误信息
+  lastError = null;
+  // 连接超时定时器
+  connectionTimeout = null;
+  // 工具调用超时配置
+  toolCallTimeout = 3e4;
+  reconnectDelay;
+  // 重连延迟（毫秒）
+  /**
+   * 构造函数
+   *
+   * @param endpointUrl - 小智接入点 URL
+   * @param config - Endpoint 配置（包含 mcpServers）
+   */
+  constructor(endpointUrl, config) {
+    this.endpointUrl = endpointUrl;
+    this.reconnectDelay = config.reconnectDelay ?? 2e3;
+    this.mcpAdapter = new InternalMCPManagerAdapter(config);
+  }
+  /**
+   * 获取 Endpoint URL
+   */
+  getUrl() {
+    return this.endpointUrl;
+  }
+  /**
+   * 获取当前所有工具列表
+   */
+  getTools() {
+    try {
+      const allTools = this.mcpAdapter.getAllTools();
+      return allTools.map((toolInfo) => ({
+        name: toolInfo.name,
+        description: toolInfo.description,
+        inputSchema: ensureToolJSONSchema(toolInfo.inputSchema)
+      }));
+    } catch (error) {
+      console.error(
+        `\u83B7\u53D6\u5DE5\u5177\u5217\u8868\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return [];
+    }
+  }
+  /**
+   * 连接小智接入点
+   */
+  async connect() {
+    await this.mcpAdapter.initialize();
+    if (this.connectionState === "connecting" /* CONNECTING */) {
+      throw new Error("\u8FDE\u63A5\u6B63\u5728\u8FDB\u884C\u4E2D\uFF0C\u8BF7\u7B49\u5F85\u8FDE\u63A5\u5B8C\u6210");
+    }
+    this.cleanupConnection();
+    return this.attemptConnection();
+  }
+  /**
+   * 尝试建立连接
+   */
+  async attemptConnection() {
+    this.connectionState = "connecting" /* CONNECTING */;
+    console.debug(`\u6B63\u5728\u8FDE\u63A5\u5C0F\u667A\u63A5\u5165\u70B9: ${sliceEndpoint(this.endpointUrl)}`);
+    return new Promise((resolve, reject) => {
+      this.connectionTimeout = setTimeout(() => {
+        const error = new Error("\u8FDE\u63A5\u8D85\u65F6 (10000ms)");
+        this.handleConnectionError(error);
+        reject(error);
+      }, 1e4);
+      this.ws = new WebSocket(this.endpointUrl);
+      this.ws.on("open", () => {
+        this.handleConnectionSuccess();
+        resolve();
+      });
+      this.ws.on("message", (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          this.handleMessage(message);
+        } catch (error) {
+          console.error("MCP \u6D88\u606F\u89E3\u6790\u9519\u8BEF:", error);
+        }
+      });
+      this.ws.on("close", (code, reason) => {
+        this.handleConnectionClose(code, reason.toString());
+      });
+      this.ws.on("error", (error) => {
+        this.handleConnectionError(error);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * 处理连接成功
+   */
+  handleConnectionSuccess() {
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+      this.connectionTimeout = null;
+    }
+    this.connectionStatus = true;
+    this.connectionState = "connected" /* CONNECTED */;
+    console.debug("MCP WebSocket \u8FDE\u63A5\u5DF2\u5EFA\u7ACB");
+  }
+  /**
+   * 处理连接错误
+   */
+  handleConnectionError(error) {
+    this.lastError = error.message;
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+      this.connectionTimeout = null;
+    }
+    console.error("MCP WebSocket \u9519\u8BEF:", error.message);
+    this.cleanupConnection();
+  }
+  /**
+   * 处理连接关闭
+   */
+  handleConnectionClose(code, reason) {
+    this.connectionStatus = false;
+    this.serverInitialized = false;
+    this.connectionState = "disconnected" /* DISCONNECTED */;
+    console.info(`\u5C0F\u667A\u8FDE\u63A5\u5DF2\u5173\u95ED (\u4EE3\u7801: ${code}, \u539F\u56E0: ${reason})`);
+  }
+  /**
+   * 清理连接资源
+   */
+  cleanupConnection() {
+    if (this.ws) {
+      this.ws.removeAllListeners();
+      try {
+        if (this.ws.readyState === WebSocket.OPEN) {
+          this.ws.close(1e3, "Cleaning up connection");
+        } else if (this.ws.readyState === WebSocket.CONNECTING) {
+          this.ws.terminate();
+        }
+      } catch (error) {
+        console.debug("WebSocket \u5173\u95ED\u65F6\u51FA\u73B0\u9519\u8BEF\uFF08\u5DF2\u5FFD\u7565\uFF09:", error);
+      }
+      this.ws = null;
+    }
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+      this.connectionTimeout = null;
+    }
+    this.connectionStatus = false;
+    this.serverInitialized = false;
+    this.connectionState = "disconnected" /* DISCONNECTED */;
+  }
+  /**
+   * 处理 MCP 消息
+   */
+  handleMessage(message) {
+    console.debug("\u6536\u5230 MCP \u6D88\u606F:", JSON.stringify(message, null, 2));
+    if (!message.method) {
+      console.debug("\u6536\u5230\u6CA1\u6709 method \u5B57\u6BB5\u7684\u6D88\u606F\uFF0C\u5FFD\u7565");
+      return;
+    }
+    switch (message.method) {
+      case "initialize":
+      case "notifications/initialized":
+        this.sendResponse(message.id, {
+          protocolVersion: "2024-11-05",
+          capabilities: {
+            tools: { listChanged: true },
+            logging: {}
+          },
+          serverInfo: {
+            name: "xiaozhi-mcp-server",
+            version: "1.0.0"
+          }
+        });
+        this.serverInitialized = true;
+        console.debug("MCP \u670D\u52A1\u5668\u521D\u59CB\u5316\u5B8C\u6210");
+        break;
+      case "tools/list": {
+        const toolsList = this.getTools();
+        this.sendResponse(message.id, { tools: toolsList });
+        console.debug(`MCP \u5DE5\u5177\u5217\u8868\u5DF2\u53D1\u9001 (${toolsList.length}\u4E2A\u5DE5\u5177)`);
+        break;
+      }
+      case "tools/call": {
+        this.handleToolCall(message).catch((error) => {
+          console.error("\u5904\u7406\u5DE5\u5177\u8C03\u7528\u65F6\u53D1\u751F\u672A\u6355\u83B7\u9519\u8BEF:", error);
+        });
+        break;
+      }
+      case "ping":
+        this.sendResponse(message.id, {});
+        console.debug("\u56DE\u5E94 MCP ping \u6D88\u606F");
+        break;
+      default:
+        console.warn(`\u672A\u77E5\u7684 MCP \u8BF7\u6C42: ${message.method}`);
+    }
+  }
+  /**
+   * 发送响应消息
+   */
+  sendResponse(id, result) {
+    console.debug(
+      `\u5C1D\u8BD5\u53D1\u9001\u54CD\u5E94: id=${id}, isConnected=${this.connectionStatus}, wsReadyState=${this.ws?.readyState}`
+    );
+    if (this.connectionStatus && this.ws?.readyState === WebSocket.OPEN) {
+      const response = {
+        jsonrpc: "2.0",
+        id,
+        result
+      };
+      try {
+        this.ws.send(JSON.stringify(response));
+        console.debug("\u54CD\u5E94\u5DF2\u53D1\u9001", {
+          id,
+          responseSize: JSON.stringify(response).length
+        });
+      } catch (error) {
+        console.error("\u53D1\u9001\u54CD\u5E94\u5931\u8D25", {
+          id,
+          error
+        });
+      }
+    } else {
+      console.error("\u65E0\u6CD5\u53D1\u9001\u54CD\u5E94", {
+        id,
+        isConnected: this.connectionStatus,
+        wsReadyState: this.ws?.readyState
+      });
+    }
+  }
+  /**
+   * 获取服务器状态
+   */
+  getStatus() {
+    const availableTools = this.mcpAdapter.getAllTools().length;
+    return {
+      connected: this.connectionStatus,
+      initialized: this.serverInitialized,
+      url: this.endpointUrl,
+      availableTools,
+      connectionState: this.connectionState,
+      lastError: this.lastError
+    };
+  }
+  /**
+   * 检查连接状态
+   */
+  isConnected() {
+    return this.connectionStatus;
+  }
+  /**
+   * 主动断开小智连接
+   */
+  disconnect() {
+    console.info("\u4E3B\u52A8\u65AD\u5F00\u5C0F\u667A\u8FDE\u63A5");
+    this.cleanupConnection();
+  }
+  /**
+   * 重连小智接入点
+   */
+  async reconnect() {
+    console.info(`\u91CD\u8FDE\u5C0F\u667A\u63A5\u5165\u70B9: ${sliceEndpoint(this.endpointUrl)}`);
+    this.disconnect();
+    await new Promise((resolve) => setTimeout(resolve, this.reconnectDelay));
+    await this.connect();
+  }
+  /**
+   * 处理工具调用请求
+   */
+  async handleToolCall(request) {
+    if (request.id === void 0 || request.id === null) {
+      throw new ToolCallError(
+        -32602 /* INVALID_PARAMS */,
+        "\u8BF7\u6C42 ID \u4E0D\u80FD\u4E3A\u7A7A"
+      );
+    }
+    const requestId = request.id;
+    const startTime = Date.now();
+    try {
+      const params = validateToolCallParams(request.params);
+      console.info("\u5F00\u59CB\u5904\u7406\u5DE5\u5177\u8C03\u7528", {
+        requestId,
+        toolName: params.name,
+        hasArguments: !!params.arguments
+      });
+      const result = await this.executeToolWithTimeout(
+        params.name,
+        params.arguments || {},
+        this.toolCallTimeout
+      );
+      this.sendResponse(requestId, {
+        content: result.content || [
+          { type: "text", text: JSON.stringify(result) }
+        ],
+        isError: result.isError || false
+      });
+      console.info("\u5DE5\u5177\u8C03\u7528\u6210\u529F", {
+        requestId,
+        toolName: params.name,
+        duration: `${Date.now() - startTime}ms`
+      });
+    } catch (error) {
+      this.handleToolCallError(error, requestId, Date.now() - startTime);
+    }
+  }
+  /**
+   * 带超时控制的工具执行
+   */
+  async executeToolWithTimeout(toolName, arguments_, timeoutMs = 3e4) {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(
+          new ToolCallError(
+            -32002 /* TIMEOUT */,
+            `\u5DE5\u5177\u8C03\u7528\u8D85\u65F6 (${timeoutMs}ms): ${toolName}`
+          )
+        );
+      }, timeoutMs);
+      this.mcpAdapter.callTool(toolName, arguments_).then((result) => {
+        clearTimeout(timeoutId);
+        resolve(result);
+      }).catch((error) => {
+        clearTimeout(timeoutId);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (errorMessage.includes("\u672A\u627E\u5230\u5DE5\u5177")) {
+          reject(
+            new ToolCallError(
+              -32601 /* TOOL_NOT_FOUND */,
+              `\u5DE5\u5177\u4E0D\u5B58\u5728: ${toolName}`
+            )
+          );
+        } else {
+          reject(
+            new ToolCallError(
+              -32e3 /* TOOL_EXECUTION_ERROR */,
+              `\u5DE5\u5177\u6267\u884C\u5931\u8D25: ${errorMessage}`
+            )
+          );
+        }
+      });
+    });
+  }
+  /**
+   * 处理工具调用错误
+   */
+  handleToolCallError(error, requestId, duration) {
+    let errorResponse;
+    if (error instanceof ToolCallError) {
+      errorResponse = {
+        code: error.code,
+        message: error.message,
+        data: error.data
+      };
+    } else {
+      const errorMessage = error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF";
+      errorResponse = {
+        code: -32e3 /* TOOL_EXECUTION_ERROR */,
+        message: errorMessage,
+        data: { originalError: String(error) || "null" }
+      };
+    }
+    this.sendErrorResponse(requestId, errorResponse);
+    console.error("\u5DE5\u5177\u8C03\u7528\u5931\u8D25", {
+      requestId,
+      duration: `${duration}ms`,
+      error: errorResponse
+    });
+  }
+  /**
+   * 发送错误响应
+   */
+  sendErrorResponse(id, error) {
+    if (this.connectionStatus && this.ws?.readyState === WebSocket.OPEN) {
+      const response = {
+        jsonrpc: "2.0",
+        id,
+        error
+      };
+      this.ws.send(JSON.stringify(response));
+      console.debug("\u5DF2\u53D1\u9001\u9519\u8BEF\u54CD\u5E94:", response);
+    }
+  }
+};
+
+// src/manager.ts
+import { EventEmitter } from "events";
+var EndpointManager = class extends EventEmitter {
+  /**
+   * 构造函数
+   *
+   * @param config - 可选的配置
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+    console.debug("[EndpointManager] \u5B9E\u4F8B\u5DF2\u521B\u5EFA\uFF08\u65B0 API\uFF09");
+  }
+  static {
+    __name(this, "EndpointManager");
+  }
+  endpoints = /* @__PURE__ */ new Map();
+  connectionStates = /* @__PURE__ */ new Map();
+  /**
+   * 添加 Endpoint 实例
+   *
+   * @param endpoint - Endpoint 实例
+   */
+  addEndpoint(endpoint) {
+    const url = endpoint.getUrl();
+    if (this.endpoints.has(url)) {
+      console.debug(
+        `[EndpointManager] \u63A5\u5165\u70B9 ${sliceEndpoint(url)} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u6DFB\u52A0`
+      );
+      return;
+    }
+    console.debug(`[EndpointManager] \u6DFB\u52A0\u63A5\u5165\u70B9: ${sliceEndpoint(url)}`);
+    this.endpoints.set(url, endpoint);
+    this.connectionStates.set(url, {
+      endpoint: url,
+      connected: false,
+      initialized: false
+    });
+    this.emit("endpointAdded", { endpoint: url });
+  }
+  /**
+   * 移除 Endpoint 实例
+   *
+   * @param endpoint - Endpoint 实例
+   */
+  removeEndpoint(endpoint) {
+    const url = endpoint.getUrl();
+    if (!this.endpoints.has(url)) {
+      console.debug(
+        `[EndpointManager] \u63A5\u5165\u70B9 ${sliceEndpoint(url)} \u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u79FB\u9664`
+      );
+      return;
+    }
+    console.debug(`[EndpointManager] \u79FB\u9664\u63A5\u5165\u70B9: ${sliceEndpoint(url)}`);
+    endpoint.disconnect();
+    this.endpoints.delete(url);
+    this.connectionStates.delete(url);
+    this.emit("endpointRemoved", { endpoint: url });
+  }
+  /**
+   * 连接所有 Endpoint
+   */
+  async connect() {
+    console.debug(`[EndpointManager] \u5F00\u59CB\u8FDE\u63A5\u6240\u6709\u63A5\u5165\u70B9\uFF0C\u603B\u6570: ${this.endpoints.size}`);
+    const promises = [];
+    for (const [url, endpoint] of this.endpoints) {
+      promises.push(
+        this.connectSingleEndpoint(url, endpoint).catch((error) => {
+          console.error(`[EndpointManager] \u8FDE\u63A5\u5931\u8D25: ${sliceEndpoint(url)}`, error);
+          const status = this.connectionStates.get(url);
+          if (status) {
+            status.connected = false;
+            status.initialized = false;
+            status.lastError = error instanceof Error ? error.message : String(error);
+          }
+        })
+      );
+    }
+    await Promise.allSettled(promises);
+    const connectedCount = Array.from(this.connectionStates.values()).filter(
+      (s) => s.connected
+    ).length;
+    console.info(`[EndpointManager] \u8FDE\u63A5\u5B8C\u6210: \u6210\u529F ${connectedCount}/${this.endpoints.size}`);
+  }
+  /**
+   * 断开所有连接
+   */
+  async disconnect() {
+    console.debug("[EndpointManager] \u5F00\u59CB\u65AD\u5F00\u6240\u6709\u8FDE\u63A5");
+    const promises = [];
+    for (const endpoint of this.endpoints.values()) {
+      promises.push(
+        Promise.resolve().then(() => {
+          endpoint.disconnect();
+        })
+      );
+    }
+    await Promise.allSettled(promises);
+    for (const status of this.connectionStates.values()) {
+      status.connected = false;
+      status.initialized = false;
+    }
+    console.debug("[EndpointManager] \u6240\u6709\u63A5\u5165\u70B9\u5DF2\u65AD\u5F00\u8FDE\u63A5");
+  }
+  /**
+   * 获取所有 Endpoint URL
+   */
+  getEndpoints() {
+    return Array.from(this.endpoints.keys());
+  }
+  /**
+   * 获取指定 Endpoint 实例
+   *
+   * @param url - Endpoint URL
+   */
+  getEndpoint(url) {
+    return this.endpoints.get(url);
+  }
+  /**
+   * 获取所有连接状态
+   */
+  getConnectionStatus() {
+    return Array.from(this.connectionStates.values());
+  }
+  /**
+   * 检查是否有任何连接处于连接状态
+   */
+  isAnyConnected() {
+    for (const status of this.connectionStates.values()) {
+      if (status.connected) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * 检查指定端点是否已连接
+   *
+   * @param url - 端点 URL
+   */
+  isEndpointConnected(url) {
+    const status = this.connectionStates.get(url);
+    return status?.connected ?? false;
+  }
+  /**
+   * 获取指定端点的状态
+   *
+   * @param url - 端点 URL
+   */
+  getEndpointStatus(url) {
+    return this.connectionStates.get(url);
+  }
+  /**
+   * 重连所有端点
+   */
+  async reconnectAll() {
+    console.info("[EndpointManager] \u5F00\u59CB\u91CD\u8FDE\u6240\u6709\u63A5\u5165\u70B9");
+    const promises = [];
+    for (const [url, endpoint] of this.endpoints) {
+      promises.push(
+        this.reconnectSingleEndpoint(url, endpoint).catch((error) => {
+          console.error(`[EndpointManager] \u91CD\u8FDE\u5931\u8D25: ${sliceEndpoint(url)}`, error);
+        })
+      );
+    }
+    await Promise.allSettled(promises);
+  }
+  /**
+   * 重连指定的端点
+   *
+   * @param url - 要重连的端点 URL
+   */
+  async reconnectEndpoint(url) {
+    const endpoint = this.endpoints.get(url);
+    if (!endpoint) {
+      throw new Error(`\u63A5\u5165\u70B9\u4E0D\u5B58\u5728: ${sliceEndpoint(url)}`);
+    }
+    await this.reconnectSingleEndpoint(url, endpoint);
+  }
+  /**
+   * 清除所有端点
+   */
+  async clearEndpoints() {
+    console.debug("[EndpointManager] \u6E05\u9664\u6240\u6709\u63A5\u5165\u70B9");
+    await this.disconnect();
+    this.endpoints.clear();
+    this.connectionStates.clear();
+    console.info("[EndpointManager] \u6240\u6709\u63A5\u5165\u70B9\u5DF2\u6E05\u9664");
+  }
+  /**
+   * 清理资源
+   */
+  async cleanup() {
+    console.debug("[EndpointManager] \u5F00\u59CB\u6E05\u7406\u8D44\u6E90");
+    await this.clearEndpoints();
+    console.debug("[EndpointManager] \u8D44\u6E90\u6E05\u7406\u5B8C\u6210");
+  }
+  // ==================== 私有方法 ====================
+  /**
+   * 连接单个端点
+   */
+  async connectSingleEndpoint(url, endpoint) {
+    const status = this.connectionStates.get(url);
+    if (!status) {
+      throw new Error(`\u7AEF\u70B9\u72B6\u6001\u4E0D\u5B58\u5728: ${sliceEndpoint(url)}`);
+    }
+    console.debug(`[EndpointManager] \u8FDE\u63A5\u7AEF\u70B9: ${sliceEndpoint(url)}`);
+    status.connected = false;
+    status.initialized = false;
+    await endpoint.connect();
+    status.connected = true;
+    status.initialized = true;
+    status.lastConnected = /* @__PURE__ */ new Date();
+    status.lastError = void 0;
+    console.info(`[EndpointManager] \u7AEF\u70B9\u8FDE\u63A5\u6210\u529F: ${sliceEndpoint(url)}`);
+  }
+  /**
+   * 重连单个端点
+   */
+  async reconnectSingleEndpoint(url, endpoint) {
+    const status = this.connectionStates.get(url);
+    if (!status) {
+      throw new Error(`\u7AEF\u70B9\u72B6\u6001\u4E0D\u5B58\u5728: ${sliceEndpoint(url)}`);
+    }
+    console.debug(`[EndpointManager] \u91CD\u8FDE\u7AEF\u70B9: ${sliceEndpoint(url)}`);
+    await endpoint.reconnect();
+    status.connected = true;
+    status.initialized = true;
+    status.lastConnected = /* @__PURE__ */ new Date();
+    status.lastError = void 0;
+    console.info(`[EndpointManager] \u7AEF\u70B9\u91CD\u8FDE\u6210\u529F: ${sliceEndpoint(url)}`);
+  }
+};
+export {
+  ConnectionState,
+  Endpoint,
+  EndpointManager,
+  ToolCallError,
+  ToolCallErrorCode,
+  deepMerge,
+  ensureToolJSONSchema,
+  formatErrorMessage,
+  isValidEndpointUrl,
+  sleep,
+  sliceEndpoint,
+  validateToolCallParams
+};
+//# sourceMappingURL=index.js.map