@xiaozhi-client/endpoint 1.9.7-beta.10

package/dist/index.js

@@ -0,0 +1,801 @@
+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 isSafeKey(key) {
+  const dangerousKeys = ["__proto__", "constructor", "prototype"];
+  if (dangerousKeys.includes(key)) {
+    return false;
+  }
+  return typeof key === "string" && key.length > 0;
+}
+__name(isSafeKey, "isSafeKey");
+function deepMerge(target, ...sources) {
+  if (sources.length === 0) {
+    return target;
+  }
+  const source = sources.shift();
+  if (source === void 0) {
+    return target;
+  }
+  const keys = Object.keys(source);
+  for (const key of keys) {
+    if (!isSafeKey(key)) {
+      continue;
+    }
+    const sourceValue = source[key];
+    const targetValue = target[key];
+    if (typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(sourceValue) && typeof targetValue === "object" && targetValue !== null && !Array.isArray(targetValue)) {
+      target[key] = deepMerge(
+        targetValue,
+        sourceValue
+      );
+    } else {
+      target[key] = sourceValue;
+    }
+  }
+  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
+import { MCPManager } from "@xiaozhi-client/mcp-core";
+import { convertLegacyToNew } from "@xiaozhi-client/config";
+var InternalMCPManagerAdapter = class {
+  constructor(config) {
+    this.config = config;
+    this.mcpManager = new MCPManager();
+    for (const [serviceName, serverConfig] of Object.entries(
+      config.mcpServers
+    )) {
+      const mcpConfig = this.convertToMCPServiceConfig(serviceName, serverConfig);
+      this.mcpManager.addServer(serviceName, mcpConfig);
+    }
+    this.mcpManager.on("connected", (data) => {
+    });
+    this.mcpManager.on("error", (data) => {
+    });
+  }
+  static {
+    __name(this, "InternalMCPManagerAdapter");
+  }
+  mcpManager;
+  tools = /* @__PURE__ */ new Map();
+  isInitialized = false;
+  /**
+   * 初始化并启动所有 MCP 服务
+   */
+  async initialize() {
+    if (this.isInitialized) {
+      return;
+    }
+    await this.mcpManager.connect();
+    await this.refreshTools();
+    this.isInitialized = true;
+  }
+  /**
+   * 获取所有工具列表
+   */
+  getAllTools() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * 调用工具（真实实现）
+   */
+  async callTool(toolName, arguments_) {
+    const [serviceName, actualToolName] = this.parseToolName(toolName);
+    return this.mcpManager.callTool(serviceName, actualToolName, arguments_);
+  }
+  /**
+   * 清理资源
+   */
+  async cleanup() {
+    await this.mcpManager.disconnect();
+    this.tools.clear();
+    this.isInitialized = false;
+  }
+  /**
+   * 刷新工具列表
+   */
+  async refreshTools() {
+    this.tools.clear();
+    const mcpTools = this.mcpManager.listTools();
+    for (const mcpTool of mcpTools) {
+      const enhancedTool = {
+        name: `${mcpTool.serverName}__${mcpTool.name}`,
+        description: mcpTool.description,
+        inputSchema: mcpTool.inputSchema,
+        serviceName: mcpTool.serverName,
+        originalName: mcpTool.name,
+        enabled: true,
+        usageCount: 0,
+        lastUsedTime: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.tools.set(enhancedTool.name, enhancedTool);
+    }
+  }
+  /**
+   * 解析工具名称
+   */
+  parseToolName(toolName) {
+    const parts = toolName.split("__");
+    if (parts.length < 2) {
+      throw new Error(`\u65E0\u6548\u7684\u5DE5\u5177\u540D\u79F0\u683C\u5F0F: ${toolName}`);
+    }
+    const serviceName = parts[0];
+    const actualToolName = parts.slice(1).join("__");
+    return [serviceName, actualToolName];
+  }
+  /**
+   * 将 MCPServerConfig 转换为 MCPServiceConfig
+   * 使用统一的配置适配器，确保路径解析逻辑一致
+   */
+  convertToMCPServiceConfig(serviceName, config) {
+    const converted = convertLegacyToNew(serviceName, config);
+    const { name, ...rest } = converted;
+    return rest;
+  }
+};
+
+// 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) {
+      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 */;
+    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) {
+        }
+      });
+      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 */;
+  }
+  /**
+   * 处理连接错误
+   */
+  handleConnectionError(error) {
+    this.lastError = error.message;
+    if (this.connectionTimeout) {
+      clearTimeout(this.connectionTimeout);
+      this.connectionTimeout = null;
+    }
+    this.cleanupConnection();
+  }
+  /**
+   * 处理连接关闭
+   */
+  handleConnectionClose(code, reason) {
+    this.connectionStatus = false;
+    this.serverInitialized = false;
+    this.connectionState = "disconnected" /* DISCONNECTED */;
+  }
+  /**
+   * 清理连接资源
+   */
+  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) {
+      }
+      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) {
+    if (!message.method) {
+      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;
+        break;
+      case "tools/list": {
+        const toolsList = this.getTools();
+        this.sendResponse(message.id, { tools: toolsList });
+        break;
+      }
+      case "tools/call": {
+        this.handleToolCall(message).catch((error) => {
+        });
+        break;
+      }
+      case "ping":
+        this.sendResponse(message.id, {});
+        break;
+      default:
+    }
+  }
+  /**
+   * 发送响应消息
+   */
+  sendResponse(id, result) {
+    if (this.connectionStatus && this.ws?.readyState === WebSocket.OPEN) {
+      const response = {
+        jsonrpc: "2.0",
+        id,
+        result
+      };
+      try {
+        this.ws.send(JSON.stringify(response));
+      } catch (error) {
+      }
+    } else {
+    }
+  }
+  /**
+   * 获取服务器状态
+   */
+  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;
+  }
+  /**
+   * 主动断开小智连接
+   */
+  async disconnect() {
+    await this.mcpAdapter.cleanup();
+    this.cleanupConnection();
+  }
+  /**
+   * 重连小智接入点
+   */
+  async reconnect() {
+    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);
+      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
+      });
+    } 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);
+  }
+  /**
+   * 发送错误响应
+   */
+  sendErrorResponse(id, error) {
+    if (this.connectionStatus && this.ws?.readyState === WebSocket.OPEN) {
+      const response = {
+        jsonrpc: "2.0",
+        id,
+        error
+      };
+      this.ws.send(JSON.stringify(response));
+    }
+  }
+};
+
+// src/manager.ts
+import { EventEmitter } from "events";
+var EndpointManager = class extends EventEmitter {
+  /**
+   * 构造函数
+   *
+   * @param config - 可选的配置
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  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)) {
+      return;
+    }
+    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)) {
+      return;
+    }
+    endpoint.disconnect();
+    this.endpoints.delete(url);
+    this.connectionStates.delete(url);
+    this.emit("endpointRemoved", { endpoint: url });
+  }
+  /**
+   * 连接所有 Endpoint
+   */
+  async connect() {
+    const promises = [];
+    for (const [url, endpoint] of this.endpoints) {
+      promises.push(
+        this.connectSingleEndpoint(url, endpoint).catch((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;
+  }
+  /**
+   * 断开所有连接
+   */
+  async disconnect() {
+    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;
+    }
+  }
+  /**
+   * 获取所有 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() {
+    const promises = [];
+    for (const [url, endpoint] of this.endpoints) {
+      promises.push(
+        this.reconnectSingleEndpoint(url, endpoint).catch((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() {
+    await this.disconnect();
+    this.endpoints.clear();
+    this.connectionStates.clear();
+  }
+  /**
+   * 清理资源
+   */
+  async cleanup() {
+    await this.clearEndpoints();
+  }
+  // ==================== 私有方法 ====================
+  /**
+   * 连接单个端点
+   */
+  async connectSingleEndpoint(url, endpoint) {
+    const status = this.connectionStates.get(url);
+    if (!status) {
+      throw new Error(`\u7AEF\u70B9\u72B6\u6001\u4E0D\u5B58\u5728: ${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;
+  }
+  /**
+   * 重连单个端点
+   */
+  async reconnectSingleEndpoint(url, endpoint) {
+    const status = this.connectionStates.get(url);
+    if (!status) {
+      throw new Error(`\u7AEF\u70B9\u72B6\u6001\u4E0D\u5B58\u5728: ${sliceEndpoint(url)}`);
+    }
+    await endpoint.reconnect();
+    status.connected = true;
+    status.initialized = true;
+    status.lastConnected = /* @__PURE__ */ new Date();
+    status.lastError = void 0;
+  }
+};
+export {
+  ConnectionState,
+  Endpoint,
+  EndpointManager,
+  ToolCallError,
+  ToolCallErrorCode,
+  deepMerge,
+  ensureToolJSONSchema,
+  formatErrorMessage,
+  isValidEndpointUrl,
+  sleep,
+  sliceEndpoint,
+  validateToolCallParams
+};
+//# sourceMappingURL=index.js.map