aegiscode 3.1.10 → 3.2.0

package/src/mcp/McpRegistry.ts

@@ -1,321 +0,0 @@
-/**
- * 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

@@ -1,251 +0,0 @@
-/**
- * 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

@@ -1,15 +0,0 @@
-/**
- * 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';