aegiscode 3.1.8 → 3.1.10

package/src/mcp/McpRegistry.ts

@@ -0,0 +1,321 @@
+/**
+ * MCP 服务器注册中心
+ * 
+ */
+
+import { EventEmitter } from 'events';
+import {
+  McpConnectionStatus,
+  McpServerConfig,
+  McpServerInfo,
+  McpToolDefinition,
+  McpRegistryStatistics,
+} from './types.js';
+import { McpClient } from './McpClient.js';
+import { createMcpTool } from './createMcpTool.js';
+import type { Tool } from '../tools/types.js';
+import { mcpRegistryDebug } from '../utils/debug.js';
+
+/**
+ * MCP 注册中心（单例）
+ */
+export class McpRegistry extends EventEmitter {
+  private static instance: McpRegistry | null = null;
+  private servers: Map<string, McpServerInfo> = new Map();
+
+  private constructor() {
+    super();
+    // 增加监听器上限，因为可能有多个 Agent 实例监听同一事
+    this.setMaxListeners(20);
+  }
+
+  /**
+   * 
+   */
+  static getInstance(): McpRegistry {
+    if (!McpRegistry.instance) {
+      McpRegistry.instance = new McpRegistry();
+    }
+    return McpRegistry.instance;
+  }
+
+  /**
+   * 
+   */
+  static resetInstance(): void {
+    if (McpRegistry.instance) {
+      McpRegistry.instance.disconnectAll().catch(() => {});
+      McpRegistry.instance = null;
+    }
+  }
+
+  /**
+   * 
+   */
+  async registerServer(name: string, config: McpServerConfig): Promise<void> {
+    // 检查是否已禁
+    if (config.enabled === false) {
+      mcpRegistryDebug.log(`服务器 "${name}" 已禁用，跳过注册`);
+      return;
+    }
+
+    if (this.servers.has(name)) {
+      throw new Error(`MCP服务器 "${name}" 已经注册`);
+    }
+
+    const client = new McpClient(config, name, config.healthCheck);
+    const serverInfo: McpServerInfo = {
+      config,
+      client,
+      status: McpConnectionStatus.DISCONNECTED,
+      tools: [],
+    };
+
+    // 设置事件处理
+    this.setupClientEventHandlers(client, serverInfo, name);
+
+    this.servers.set(name, serverInfo);
+    this.emit('serverRegistered', name, serverInfo);
+
+    mcpRegistryDebug.log(`已注册服务器: ${name} (${config.type})`);
+
+    // 尝试连
+    try {
+      await this.connectServer(name);
+    } catch (error) {
+      mcpRegistryDebug.warn(`服务器 "${name}" 连接失败:`, (error as Error).message);
+    }
+  }
+
+  /**
+   * 
+   */
+  async registerServers(servers: Record<string, McpServerConfig>): Promise<void> {
+    const promises = Object.entries(servers).map(([name, config]) =>
+      this.registerServer(name, config).catch(error => {
+        mcpRegistryDebug.warn(`注册服务器 "${name}" 失败:`, (error as Error).message);
+        return error;
+      })
+    );
+
+    await Promise.allSettled(promises);
+  }
+
+  /**
+   * 
+   */
+  async connectServer(name: string): Promise<void> {
+    const serverInfo = this.servers.get(name);
+    if (!serverInfo) {
+      throw new Error(`服务器 "${name}" 未注册`);
+    }
+
+    if (serverInfo.status === McpConnectionStatus.CONNECTED) {
+      mcpRegistryDebug.log(`服务器 "${name}" 已连接`);
+      return;
+    }
+
+    await serverInfo.client.connectWithRetry();
+  }
+
+  /**
+   * 
+   */
+  async disconnectServer(name: string): Promise<void> {
+    const serverInfo = this.servers.get(name);
+    if (!serverInfo) {
+      throw new Error(`服务器 "${name}" 未注册`);
+    }
+
+    await serverInfo.client.disconnect();
+  }
+
+  /**
+   * 
+   */
+  async disconnectAll(): Promise<void> {
+    const promises = Array.from(this.servers.keys()).map(name =>
+      this.disconnectServer(name).catch(() => {})
+    );
+    await Promise.allSettled(promises);
+  }
+
+  /**
+   * 
+   */
+  async removeServer(name: string): Promise<void> {
+    const serverInfo = this.servers.get(name);
+    if (!serverInfo) {
+      return;
+    }
+
+    await serverInfo.client.disconnect().catch(() => {});
+    this.servers.delete(name);
+
+    mcpRegistryDebug.log(`已移除服务器: ${name}`);
+  }
+
+  /**
+   * 
+   */
+  private setupClientEventHandlers(
+    client: McpClient,
+    serverInfo: McpServerInfo,
+    name: string
+  ): void {
+    client.on('connected', (server: { name: string; version: string }) => {
+      serverInfo.status = McpConnectionStatus.CONNECTED;
+      serverInfo.connectedAt = new Date();
+      serverInfo.serverName = server.name;
+      serverInfo.serverVersion = server.version;
+      serverInfo.tools = client.availableTools;
+      serverInfo.lastError = undefined;
+      this.emit('serverConnected', name, server);
+    });
+
+    client.on('disconnected', () => {
+      serverInfo.status = McpConnectionStatus.DISCONNECTED;
+      serverInfo.connectedAt = undefined;
+      serverInfo.tools = [];
+      this.emit('serverDisconnected', name);
+    });
+
+    client.on('error', (error: Error) => {
+      serverInfo.status = McpConnectionStatus.ERROR;
+      serverInfo.lastError = error;
+      this.emit('serverError', name, error);
+    });
+
+    client.on('toolsUpdated', (tools: McpToolDefinition[]) => {
+      const oldCount = serverInfo.tools.length;
+      serverInfo.tools = tools;
+      this.emit('toolsUpdated', name, tools, oldCount);
+    });
+
+    client.on('reconnecting', (attempt: number) => {
+      serverInfo.status = McpConnectionStatus.CONNECTING;
+      mcpRegistryDebug.log(`服务器 "${name}" 正在重连 (第 ${attempt} 次)`);
+    });
+
+    client.on('reconnected', () => {
+      mcpRegistryDebug.log(`服务器 "${name}" 重连成功`);
+    });
+
+    client.on('reconnectFailed', () => {
+      serverInfo.status = McpConnectionStatus.ERROR;
+      mcpRegistryDebug.error(`服务器 "${name}" 重连失败`);
+    });
+  }
+
+  /**
+   * 
+   *
+   * 
+   * - 无冲突: toolName
+   * - 有冲突: serverName__toolName
+   */
+  async getAvailableTools(): Promise<Tool[]> {
+    const tools: Tool[] = [];
+    const nameConflicts = new Map<string, number>();
+
+    // 第一遍：检测冲
+    for (const [, serverInfo] of this.servers) {
+      if (serverInfo.status === McpConnectionStatus.CONNECTED) {
+        for (const mcpTool of serverInfo.tools) {
+          const count = nameConflicts.get(mcpTool.name) || 0;
+          nameConflicts.set(mcpTool.name, count + 1);
+        }
+      }
+    }
+
+    // 第二遍：创建工具（冲突时添加前
+    for (const [serverName, serverInfo] of this.servers) {
+      if (serverInfo.status === McpConnectionStatus.CONNECTED) {
+        for (const mcpTool of serverInfo.tools) {
+          const hasConflict = (nameConflicts.get(mcpTool.name) || 0) > 1;
+          const toolName = hasConflict
+            ? `${serverName}__${mcpTool.name}`  // 冲突
+            : mcpTool.name;                     // 无冲
+
+          try {
+            const tool = createMcpTool(
+              serverInfo.client,
+              serverName,
+              mcpTool,
+              toolName
+            );
+            tools.push(tool);
+          } catch (error) {
+            mcpRegistryDebug.warn(
+              `创建工具 "${mcpTool.name}" 失败:`,
+              (error as Error).message
+            );
+          }
+        }
+      }
+    }
+
+    return tools;
+  }
+
+  /**
+   * 
+   */
+  getServer(name: string): McpServerInfo | undefined {
+    return this.servers.get(name);
+  }
+
+  /**
+   * 
+   */
+  getAllServers(): Map<string, McpServerInfo> {
+    return new Map(this.servers);
+  }
+
+  /**
+   * 
+   */
+  getStatistics(): McpRegistryStatistics {
+    let connectedServers = 0;
+    let disconnectedServers = 0;
+    let errorServers = 0;
+    let totalTools = 0;
+
+    for (const serverInfo of this.servers.values()) {
+      switch (serverInfo.status) {
+        case McpConnectionStatus.CONNECTED:
+          connectedServers++;
+          totalTools += serverInfo.tools.length;
+          break;
+        case McpConnectionStatus.DISCONNECTED:
+          disconnectedServers++;
+          break;
+        case McpConnectionStatus.ERROR:
+          errorServers++;
+          break;
+      }
+    }
+
+    return {
+      totalServers: this.servers.size,
+      connectedServers,
+      disconnectedServers,
+      errorServers,
+      totalTools,
+    };
+  }
+
+  /**
+   * 
+   */
+  hasServer(name: string): boolean {
+    return this.servers.has(name);
+  }
+
+  /**
+   * 
+   */
+  getServerStatus(name: string): McpConnectionStatus | undefined {
+    return this.servers.get(name)?.status;
+  }
+}

package/src/mcp/createMcpTool.ts

@@ -0,0 +1,251 @@
+/**
+ * MCP Tool 转换器
+ * 
+ */
+
+import { z } from 'zod';
+import type {
+  McpToolDefinition,
+  McpClientInterface,
+  JSONSchemaProperty,
+} from './types.js';
+import { createTool } from '../tools/createTool.js';
+import { ToolKind, ToolErrorType } from '../tools/types.js';
+import { mcpDebug } from '../utils/debug.js';
+
+/**
+ * 
+ */
+function convertJsonSchemaToZod(jsonSchema: JSONSchemaProperty): z.ZodSchema {
+  // null 
+  if (!jsonSchema || typeof jsonSchema !== 'object') {
+    return z.any();
+  }
+
+  const type = Array.isArray(jsonSchema.type) ? jsonSchema.type[0] : jsonSchema.type;
+
+  // object 类
+  if (type === 'object' || jsonSchema.properties) {
+    const shape: Record<string, z.ZodSchema> = {};
+    const required = jsonSchema.required || [];
+
+    if (jsonSchema.properties) {
+      for (const [key, value] of Object.entries(jsonSchema.properties)) {
+        if (typeof value === 'object' && value !== null) {
+          let fieldSchema = convertJsonSchemaToZod(value);
+
+          // 非必填字段标记为可
+          if (!required.includes(key)) {
+            fieldSchema = fieldSchema.optional();
+          }
+
+          shape[key] = fieldSchema;
+        }
+      }
+    }
+
+    return z.object(shape);
+  }
+
+  // array 类
+  if (type === 'array') {
+    if (jsonSchema.items && typeof jsonSchema.items === 'object') {
+      return z.array(convertJsonSchemaToZod(jsonSchema.items));
+    }
+    return z.array(z.any());
+  }
+
+  // string 类
+  if (type === 'string') {
+    // 枚
+    if (jsonSchema.enum && jsonSchema.enum.length > 0) {
+      return z.enum(jsonSchema.enum as [string, ...string[]]);
+    }
+
+    let schema = z.string();
+
+    // 长度限
+    if (jsonSchema.minLength !== undefined) {
+      schema = schema.min(jsonSchema.minLength);
+    }
+    if (jsonSchema.maxLength !== undefined) {
+      schema = schema.max(jsonSchema.maxLength);
+    }
+
+    // 正则模
+    if (jsonSchema.pattern) {
+      try {
+        schema = schema.regex(new RegExp(jsonSchema.pattern));
+      } catch {
+        // 忽略无效的正
+      }
+    }
+
+    return schema;
+  }
+
+  // number / integer 类型
+  if (type === 'number' || type === 'integer') {
+    let schema = z.number();
+
+    if (jsonSchema.minimum !== undefined) {
+      schema = schema.min(jsonSchema.minimum);
+    }
+    if (jsonSchema.maximum !== undefined) {
+      schema = schema.max(jsonSchema.maximum);
+    }
+
+    return schema;
+  }
+
+  // boolean 类
+  if (type === 'boolean') {
+    return z.boolean();
+  }
+
+  // oneOf / anyOf
+  if (jsonSchema.oneOf && jsonSchema.oneOf.length >= 2) {
+    const schemas = jsonSchema.oneOf
+      .filter((s): s is JSONSchemaProperty => typeof s === 'object' && s !== null)
+      .map(s => convertJsonSchemaToZod(s));
+
+    if (schemas.length >= 2) {
+      return z.union(schemas as [z.ZodSchema, z.ZodSchema, ...z.ZodSchema[]]);
+    }
+  }
+
+  if (jsonSchema.anyOf && jsonSchema.anyOf.length >= 2) {
+    const schemas = jsonSchema.anyOf
+      .filter((s): s is JSONSchemaProperty => typeof s === 'object' && s !== null)
+      .map(s => convertJsonSchemaToZod(s));
+
+    if (schemas.length >= 2) {
+      return z.union(schemas as [z.ZodSchema, z.ZodSchema, ...z.ZodSchema[]]);
+    }
+  }
+
+  // 默
+  return z.any();
+}
+
+/**
+ * 
+ */
+export function createMcpTool(
+  mcpClient: McpClientInterface,
+  serverName: string,
+  toolDef: McpToolDefinition,
+  customName?: string
+) {
+  // 1. JSON Schema → Zod Schema
+  let zodSchema: z.ZodSchema;
+  try {
+    zodSchema = convertJsonSchemaToZod(toolDef.inputSchema);
+  } catch (error) {
+    mcpDebug.warn(
+      `Schema 转换失败，使用降级 schema: ${toolDef.name}`,
+      (error as Error).message
+    );
+    zodSchema = z.any();  // 降级方
+  }
+
+  // 2. 决定工具名
+  const toolName = customName || toolDef.name;
+
+  // 3. 创
+  return createTool({
+    name: toolName,
+    displayName: `${serverName}: ${toolDef.name}`,
+    kind: ToolKind.Execute,  // MCP 工具视为 Execute 类型（需要确
+    schema: zodSchema,
+    description: {
+      short: toolDef.description || `MCP Tool: ${toolDef.name}`,
+      long: [
+        `MCP 工具，来自服务器: ${serverName}`,
+        toolDef.description || '',
+        '',
+        '执行外部工具，需要用户确认。',
+      ].filter(Boolean).join('\n'),
+      important: [
+        `From MCP server: ${serverName}`,
+        'Executes external tools; user confirmation required',
+      ],
+    },
+    category: 'mcp',
+    tags: ['mcp', 'external', serverName],
+
+    async execute(params) {
+      try {
+        const result = await mcpClient.callTool(toolDef.name, params);
+
+        // 处理响应内
+        let llmContent = '';
+        let displayContent = '';
+
+        if (result.content && Array.isArray(result.content)) {
+          for (const item of result.content) {
+            if (item.type === 'text' && item.text) {
+              llmContent += item.text;
+              displayContent += item.text;
+            } else if (item.type === 'image') {
+              displayContent += `[图片: ${item.mimeType || 'unknown'}]\n`;
+              llmContent += `[image: ${item.mimeType || 'unknown'}]\n`;
+            } else if (item.type === 'resource') {
+              displayContent += `[资源: ${item.uri || item.mimeType || 'unknown'}]\n`;
+              llmContent += `[resource: ${item.uri || item.mimeType || 'unknown'}]\n`;
+            }
+          }
+        }
+
+        if (result.isError) {
+          return {
+            success: false,
+            llmContent: llmContent || 'MCP tool execution failed',
+            displayContent: `❌ ${displayContent || 'MCP工具执行失败'}`,
+            error: {
+              type: ToolErrorType.EXECUTION_ERROR,
+              message: llmContent || 'MCP tool execution failed',
+            },
+          };
+        }
+
+        return {
+          success: true,
+          llmContent: llmContent || 'Execution succeeded',
+          displayContent: `✅ MCP工具 ${toolDef.name} 执行成功\n${displayContent}`,
+          metadata: {
+            serverName,
+            toolName: toolDef.name,
+            mcpResult: result,
+          },
+        };
+      } catch (error) {
+        const errorMessage = (error as Error).message;
+        return {
+          success: false,
+          llmContent: `MCP tool execution failed: ${errorMessage}`,
+          displayContent: `❌ MCP工具执行失败: ${errorMessage}`,
+          error: {
+            type: ToolErrorType.EXECUTION_ERROR,
+            message: errorMessage,
+          },
+        };
+      }
+    },
+  });
+}
+
+/**
+ * 
+ */
+export function createMcpTools(
+  mcpClient: McpClientInterface,
+  serverName: string,
+  toolDefs: McpToolDefinition[],
+  namePrefix?: string
+) {
+  return toolDefs.map(toolDef => {
+    const customName = namePrefix ? `${namePrefix}__${toolDef.name}` : undefined;
+    return createMcpTool(mcpClient, serverName, toolDef, customName);
+  });
+}

package/src/mcp/index.ts

@@ -0,0 +1,15 @@
+/**
+ * MCP 协议模块
+ * Model Context Protocol - Anthropic 推出的 AI 工具扩展协议
+ */
+
+// 类型导
+export * from './types.js';
+
+// 核心组
+export { McpClient } from './McpClient.js';
+export { McpRegistry } from './McpRegistry.js';
+export { HealthMonitor } from './HealthMonitor.js';
+
+// 工具转
+export { createMcpTool, createMcpTools } from './createMcpTool.js';