foliko 1.1.6 → 1.1.8

package/src/executors/mcp-executor.js

@@ -10,7 +10,7 @@ const path = require('path');
 const { z } = require('zod');
 const { createMCPClient } = require('@ai-sdk/mcp');
 const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js');
-const { zodSchemaToTable } = require('@chnak/zod-to-markdown');
+const { zodSchemaToMarkdown } = require('@chnak/zod-to-markdown');
 const { logger } = require('../utils/logger');
 
 const log = logger.child('MCPExecutor');
@@ -193,7 +193,7 @@ class MCPClientWrapper {
 class MCPExecutorPlugin extends Plugin {
   constructor(config = {}) {
     super();
-    this.name = 'mcp-executor';
+    this.name = 'mcp';
     this.version = '1.0.0';
     this.description = 'MCP (Model Context Protocol) 执行器';
     this.priority = 11;
@@ -202,7 +202,12 @@ class MCPExecutorPlugin extends Plugin {
     this._framework = null;
     // serverName -> { client, tools: [{ name, description, inputSchema }], toolObjects: { toolName: actualTool } }
     this._clients = new Map();
+    // 保存服务器配置，用于重新启用
+    this._serverConfigs = new Map();
     this._config = config;
+    // 注册的工具对象（extension-executor 会扫描这个）
+    // 格式: { 'server_toolname': { name, description, inputSchema, execute } }
+    this.tools = {};
   }
 
   install(framework) {
@@ -214,6 +219,12 @@ class MCPExecutorPlugin extends Plugin {
     // 先连接所有 MCP 服务器
     if (this._config.servers) {
       for (const serverConfig of this._config.servers) {
+        if (serverConfig.enabled === false) {
+          log.info(` Skipping disabled server: ${serverConfig.name}`);
+          // 保存完整配置，以便后续动态启用
+          this._serverConfigs.set(serverConfig.name, { ...serverConfig });
+          continue;
+        }
         await this.addServer(serverConfig);
       }
     }
@@ -406,12 +417,26 @@ class MCPExecutorPlugin extends Plugin {
       inputSchema: z.object({}),
       execute: async () => {
         const servers = [];
+        // 已连接的服务器
         for (const [name, info] of this._clients) {
           servers.push({
             name,
+            enabled: true,
+            connected: true,
             tools: info.tools.map((t) => ({ name: t.name, description: t.description })),
           });
         }
+        // 未连接的服务器（配置中存在但未启用）
+        for (const [name, config] of this._serverConfigs) {
+          if (!this._clients.has(name)) {
+            servers.push({
+              name,
+              enabled: false,
+              connected: false,
+              tools: [],
+            });
+          }
+        }
         return { success: true, servers };
       },
     });
@@ -453,6 +478,77 @@ class MCPExecutorPlugin extends Plugin {
       },
     });
 
+    // 注册 mcp_set_enabled 工具 - 动态开启/关闭 MCP 服务器
+    framework.registerTool({
+      name: 'mcp_set_enabled',
+      description: '动态开启或关闭某个 MCP 服务器',
+      inputSchema: z.object({
+        server: z.string().describe('MCP 服务器名称'),
+        enabled: z.boolean().describe('true=开启，false=关闭'),
+      }),
+      execute: async (args) => {
+        const { server, enabled } = args;
+        const clientInfo = this._clients.get(server);
+        const serverConfig = this._serverConfigs.get(server);
+
+        if (enabled) {
+          // 启用服务器
+          if (clientInfo && clientInfo.enabled) {
+            return { success: true, message: `MCP 服务器 '${server}' 已经是开启状态` };
+          }
+          // 如果服务器从未连接过，也检查配置中的 enabled 状态
+          if (!clientInfo && serverConfig && serverConfig.enabled === false) {
+            // 服务器是被禁用的，可以尝试启用
+          }
+          log.info(
+            `[MCP] Enabling server: ${server}, clientInfo=${!!clientInfo}, serverConfig.enabled=${serverConfig?.enabled}`
+          );
+          try {
+            if (serverConfig) {
+              const result = await this.addServer({ ...serverConfig, enabled: true });
+              log.info(`[MCP] addServer result:`, JSON.stringify(result));
+              if (!result || result.success === false) {
+                this._refreshAllAgentsMCPPrompt(this._framework);
+                return result;
+              }
+              // 保存 enabled 状态到配置文件
+              await this._saveMCPServerEnabled(server, true);
+              this._refreshAllAgentsMCPPrompt(this._framework);
+              return { success: true, message: `MCP 服务器 '${server}' 已开启` };
+            } else {
+              return { success: false, error: '服务器配置不存在，需要重载配置' };
+            }
+          } catch (err) {
+            log.error(`[MCP] Enabling failed:`, err.message);
+            return { success: false, error: `开启失败: ${err.message}` };
+          }
+        } else {
+          // 禁用服务器
+          if (!clientInfo) {
+            return { success: false, error: `MCP server '${server}' not found` };
+          }
+          log.info(` Disabling MCP server: ${server}`);
+          try {
+            clientInfo.client.close?.();
+          } catch (e) {}
+          // 从 clients 中移除
+          this._clients.delete(server);
+          // 移除该服务器注册的工具
+          for (const key of Object.keys(this.tools)) {
+            if (key.startsWith(`${server}_`)) {
+              delete this.tools[key];
+            }
+          }
+          // 保存 enabled 状态到配置文件
+          await this._saveMCPServerEnabled(server, false);
+          this._refreshAllAgentsMCPPrompt(this._framework);
+          return { success: true, message: `MCP 服务器 '${server}' 已关闭` };
+        }
+
+        return { success: true, message: `MCP 服务器 '${server}' 状态未变化` };
+      },
+    });
+
     // 监听 agent 创建事件，附加 MCP 信息到系统提示词
     framework.on('agent:created', (agent) => {
       if (!this._mainAgent) {
@@ -482,7 +578,7 @@ class MCPExecutorPlugin extends Plugin {
     const traverse = (agent) => {
       if (!agent || visited.has(agent)) return;
       visited.add(agent);
-      this._refreshAgentMCPPrompt(agent);
+      //this._refreshAgentMCPPrompt(agent);
 
       // 递归处理子 agent
       const subAgents = agent.getSubAgents?.() || agent._subAgents || new Map();
@@ -506,11 +602,11 @@ class MCPExecutorPlugin extends Plugin {
       return;
     }
 
-    const mcpDesc = this._buildMCPServersDescription();
-    if (!mcpDesc) return;
+    // const mcpDesc = this._buildMCPServersDescription();
+    // if (!mcpDesc) return;
 
     // 将 MCP 描述追加到系统提示词
-    agent.setSystemPrompt(existingPrompt + '\n\n' + mcpDesc);
+    //agent.setSystemPrompt(existingPrompt + '\n\n' + mcpDesc);
   }
 
   /**
@@ -520,6 +616,8 @@ class MCPExecutorPlugin extends Plugin {
     if (!inputSchema) return {};
     // 处理 {jsonSchema: {...}} 格式
     if (inputSchema.jsonSchema) return inputSchema.jsonSchema;
+    // 处理 {inputSchema: {...}} 格式 (某些 MCP 服务器返回这种格式)
+    if (inputSchema.inputSchema) return inputSchema.inputSchema;
     // 处理直接是 schema 的格式
     return inputSchema;
   }
@@ -532,53 +630,134 @@ class MCPExecutorPlugin extends Plugin {
       return '';
     }
 
-    let desc = '【MCP Servers】 工具合集\n\n';
-    desc += '你可以通过 `mcp_call` 工具调用以下 MCP 服务器的工具。\n\n';
+    let desc = '## 【MCP Servers】 工具合集\n\n';
+    desc += 'MCP 服务器工具已注册为 `服务器_工具名` 格式（如 github_search）。\n';
+    desc += '通过 `ext_call` 调用：\n\n';
 
     for (const [serverName, info] of this._clients) {
       desc += `### ${serverName}\n\n`;
       for (const tool of info.tools) {
-        desc += `#### ${tool.name}\n`;
-        desc += `${tool.description || '无描述'}\n\n`;
+        const fullName = `${serverName}_${tool.name}`;
+        desc += `- **${fullName}**: ${tool.description || '无描述'}\n`;
 
         // 使用 zodSchemaToMarkdown 生成参数文档
-        const schema = tool.inputSchema;
+        const rawSchema = tool.inputSchema;
+        const schema = this._extractSchema(rawSchema);
         if (schema) {
           try {
-            if (typeof schema.toJSON === 'function') {
+            let schemaResult = null;
+            let zodSchemaForFallback = null; // 保存 Zod schema 供 fallback 使用
+            // 检查是否是 Zod schema (有 shape 方法或 _def 属性)
+            const isZodSchema =
+              typeof schema.shape === 'function' || (schema._def && schema._def.typeName);
+            if (isZodSchema) {
               // Zod schema 直接转换
-              desc += `**参数:**\n\n`;
-              desc += zodSchemaToTable(schema) + '\n\n';
+              schemaResult = zodSchemaToMarkdown(schema);
+              zodSchemaForFallback = schema;
             } else if (schema.jsonSchema) {
               // JSON Schema 格式，尝试转换为 Zod schema
               const zodSchema = this._jsonSchemaToZod(schema.jsonSchema || schema);
               if (zodSchema) {
-                desc += `**参数:**\n\n`;
-                desc += zodSchemaToTable(zodSchema) + '\n\n';
+                schemaResult = zodSchemaToMarkdown(zodSchema);
+                zodSchemaForFallback = zodSchema;
               }
             } else if (schema.properties) {
               // 已经是对象格式
               const zodSchema = this._jsonSchemaToZod(schema);
               if (zodSchema) {
+                schemaResult = zodSchemaToMarkdown(zodSchema);
+                zodSchemaForFallback = zodSchema;
+              }
+            }
+
+            // 检查是否包含未解析的原始 Zod 类型名或只有类型信息没有参数
+            if (schemaResult) {
+              const hasUnparsedTypes = /\|.*\bZod\w+\b.*\|/.test(schemaResult);
+              // 检查是否只有类型信息而没有实际参数（如 "Type: Object" 或 "Type: ZodAny"）
+              const hasOnlyType =
+                /^-\s+\w+:\s+.+\n?$/.test(schemaResult.trim()) && !schemaResult.includes('`');
+              if (hasUnparsedTypes || hasOnlyType) {
+                // zodSchemaToMarkdown 未正确解析，使用 fallback
+                desc += this._fallbackParamsDesc(zodSchemaForFallback || schema);
+              } else {
                 desc += `**参数:**\n\n`;
-                desc += zodSchemaToTable(zodSchema) + '\n\n';
+                desc += schemaResult + '\n\n';
               }
             }
           } catch (e) {
-            // 如果转换失败，使用简化格式
-            desc += this._fallbackParamsDesc(schema);
+            // 如果转换失败，使用 fallback
+            try {
+              desc += this._fallbackParamsDesc(zodSchemaForFallback || schema);
+            } catch (e2) {
+              // fallback 也失败，忽略参数描述
+            }
           }
         }
       }
-      desc += '---\n\n';
+      desc += '\n';
     }
 
     desc += '**调用格式:**\n';
-    desc += '```\nmcp_call({ server: "服务器", tool: "工具", args_json: \'{"参数": "值"}\' })\n';
+    desc += '```\next_call({ plugin: "mcp", tool: "服务器_工具名", args: {参数} })\n';
     desc += '```\n';
     return desc.trim();
   }
 
+  _bindMcpParamsDesc(rawSchema) {
+    let desc = '';
+    const schema = this._extractSchema(rawSchema);
+    if (!schema) return desc;
+    try {
+      let schemaResult = null;
+      let zodSchemaForFallback = null; // 保存 Zod schema 供 fallback 使用
+      // 检查是否是 Zod schema (有 shape 方法或 _def 属性)
+      const isZodSchema =
+        typeof schema.shape === 'function' || (schema._def && schema._def.typeName);
+      if (isZodSchema) {
+        // Zod schema 直接转换
+        schemaResult = zodSchemaToMarkdown(schema);
+        zodSchemaForFallback = schema;
+      } else if (schema.jsonSchema) {
+        // JSON Schema 格式，尝试转换为 Zod schema
+        const zodSchema = this._jsonSchemaToZod(schema.jsonSchema || schema);
+        if (zodSchema) {
+          schemaResult = zodSchemaToMarkdown(zodSchema);
+          zodSchemaForFallback = zodSchema;
+        }
+      } else if (schema.properties) {
+        // 已经是对象格式
+        const zodSchema = this._jsonSchemaToZod(schema);
+        if (zodSchema) {
+          schemaResult = zodSchemaToMarkdown(zodSchema);
+          zodSchemaForFallback = zodSchema;
+        }
+      }
+
+      // 检查是否包含未解析的原始 Zod 类型名或只有类型信息没有参数
+      if (schemaResult) {
+        const hasUnparsedTypes = /\|.*\bZod\w+\b.*\|/.test(schemaResult);
+        // 检查是否只有类型信息而没有实际参数（如 "Type: Object" 或 "Type: ZodAny"）
+        const hasOnlyType =
+          /^-\s+\w+:\s+.+\n?$/.test(schemaResult.trim()) && !schemaResult.includes('`');
+        if (hasUnparsedTypes || hasOnlyType) {
+          // zodSchemaToMarkdown 未正确解析，使用 fallback
+          desc += this._fallbackParamsDesc(zodSchemaForFallback || schema);
+        } else {
+          desc += `**参数:**\n\n`;
+          desc += schemaResult + '\n\n';
+        }
+      }
+    } catch (e) {
+      // 如果转换失败，使用 fallback
+      try {
+        desc += this._fallbackParamsDesc(zodSchemaForFallback || schema);
+      } catch (e2) {
+        // fallback 也失败，忽略参数描述
+      }
+    }
+    return desc;
+  }
+
   /**
    * 将 JSON Schema 转换为 Zod schema
    */
@@ -648,21 +827,152 @@ class MCPExecutorPlugin extends Plugin {
    * 回退的参数描述（当 zodSchemaToMarkdown 失败时）
    */
   _fallbackParamsDesc(schema) {
+    // 优先尝试 JSON Schema 格式
     const props = schema.properties || {};
     const required = schema.required || [];
 
-    if (Object.keys(props).length === 0) {
-      return '';
+    if (Object.keys(props).length > 0) {
+      let desc = '**参数:**\n\n';
+      for (const [key, prop] of Object.entries(props)) {
+        const isRequired = required.includes(key);
+        const type = prop.type || 'any';
+        const desc_text = prop.description || '';
+        desc += `- \`${key}\`${isRequired ? ' (必填)' : ''}: ${type} ${desc_text}\n`;
+      }
+      return desc + '\n';
+    }
+
+    // 尝试 Zod schema 格式
+    if (typeof schema.shape === 'function' || (schema._def && schema._def.shape)) {
+      const shape = typeof schema.shape === 'function' ? schema.shape() : schema._def.shape();
+      if (shape && typeof shape === 'object') {
+        let desc = '**参数:**\n\n';
+        for (const [key, field] of Object.entries(shape)) {
+          const typeInfo = this._extractZodFieldType(field);
+          const isOptional = typeInfo.isOptional ? ' (可选)' : ' (必填)';
+          desc += `- \`${key}\`${isOptional}: ${typeInfo.type}\n`;
+        }
+        return desc + '\n';
+      }
+    }
+
+    return '';
+  }
+
+  /**
+   * 从 Zod schema 字段提取类型信息
+   */
+  _extractZodFieldType(field) {
+    if (!field) {
+      return { type: 'unknown', isOptional: false, description: '' };
     }
 
-    let desc = '**参数:**\n\n';
-    for (const [key, prop] of Object.entries(props)) {
-      const isRequired = required.includes(key);
-      const type = prop.type || 'any';
-      const desc_text = prop.description || '';
-      desc += `- \`${key}\`${isRequired ? ' (必填)' : ''}: ${type} ${desc_text}\n`;
+    const typeName = field._def?.typeName || field.constructor?.name || '';
+    const description = field.description || field._def?.description || '';
+
+    switch (typeName) {
+      case 'ZodOptional': {
+        const inner = field._def?.innerType;
+        if (!inner) return { type: 'optional', isOptional: true, description };
+        return this._extractZodFieldType(inner);
+      }
+      case 'ZodArray': {
+        const inner = field._def?.type;
+        if (!inner) return { type: 'array', isOptional: false, description };
+        const innerInfo = this._extractZodFieldType(inner);
+        return { type: `${innerInfo.type}[]`, isOptional: false, description };
+      }
+      case 'ZodObject': {
+        const shapeFn = field._def?.shape;
+        if (typeof shapeFn !== 'function')
+          return { type: 'object', isOptional: false, description };
+        const shape = shapeFn();
+        if (!shape) return { type: 'object', isOptional: false, description };
+        const props = Object.keys(shape).join(', ');
+        return { type: `object{${props}}`, isOptional: false, description };
+      }
+      case 'ZodString':
+        return { type: 'string', isOptional: false, description };
+      case 'ZodNumber':
+        return { type: 'number', isOptional: false, description };
+      case 'ZodBoolean':
+        return { type: 'boolean', isOptional: false, description };
+      case 'ZodEnum': {
+        const values = field._def?.values;
+        if (!values) return { type: 'enum', isOptional: false, description };
+        return {
+          type: values.map((v) => `"${v}"`).join(' | '),
+          isOptional: false,
+          description,
+        };
+      }
+      case 'ZodUnion': {
+        const options = field._def?.options;
+        if (!options) return { type: 'union', isOptional: false, description };
+        const types = options.map((opt) => this._extractZodFieldType(opt).type);
+        return { type: `union(${types.join(' | ')})`, isOptional: false, description };
+      }
+      case 'ZodLiteral':
+        return { type: JSON.stringify(field._def?.value), isOptional: false, description };
+      case 'ZodRecord': {
+        const keyType = this._extractZodFieldType(field._def?.keyType);
+        const valueType = this._extractZodFieldType(field._def?.valueType);
+        return {
+          type: `record<${keyType?.type || 'any'}, ${valueType?.type || 'any'}>`,
+          isOptional: false,
+          description,
+        };
+      }
+      case 'ZodMap': {
+        const keyType = this._extractZodFieldType(field._def?.keyType);
+        const valueType = this._extractZodFieldType(field._def?.valueType);
+        return {
+          type: `map<${keyType?.type || 'any'}, ${valueType?.type || 'any'}>`,
+          isOptional: false,
+          description,
+        };
+      }
+      case 'ZodSet': {
+        const valueType = this._extractZodFieldType(field._def?.valueType);
+        return { type: `set<${valueType?.type || 'any'}>`, isOptional: false, description };
+      }
+      case 'ZodAny':
+        return { type: 'any', isOptional: false, description };
+      case 'ZodUnknown':
+        return { type: 'unknown', isOptional: false, description };
+      case 'ZodNever':
+        return { type: 'never', isOptional: false, description };
+      case 'ZodNull':
+        return { type: 'null', isOptional: false, description };
+      case 'ZodUndefined':
+        return { type: 'undefined', isOptional: false, description };
+      case 'ZodDate':
+        return { type: 'date', isOptional: false, description };
+      case 'ZodBigInt':
+        return { type: 'bigint', isOptional: false, description };
+      case 'ZodFunction':
+        return { type: 'function', isOptional: false, description };
+      case 'ZodLazy':
+        return { type: 'lazy', isOptional: false, description };
+      case 'ZodNativeEnum':
+        return { type: 'nativeEnum', isOptional: false, description };
+      case 'ZodDefault': {
+        const inner = field._def?.innerType;
+        if (!inner) return { type: 'default', isOptional: false, description };
+        const innerInfo = this._extractZodFieldType(inner);
+        return { type: innerInfo.type, isOptional: false, description };
+      }
+      case 'ZodEffects':
+        return { type: 'effects', isOptional: false, description };
+      case 'ZodPipeline':
+        return { type: 'pipeline', isOptional: false, description };
+      default:
+        return {
+          type: typeName.replace('Zod', '').toLowerCase() || 'any',
+          isOptional: false,
+          description,
+        };
     }
-    return desc + '\n';
   }
 
   _getParentAgent() {
@@ -703,11 +1013,44 @@ class MCPExecutorPlugin extends Plugin {
    * 添加 MCP 服务器
    */
   async addServer(config) {
-    const { name, command, args = [], env, url, type, headers = {}, authProvider } = config;
+    const {
+      name,
+      command,
+      args = [],
+      env,
+      url,
+      type,
+      headers = {},
+      authProvider,
+      enabled,
+    } = config;
+    log.info(
+      `[MCP] addServer called: ${name}, enabled=${enabled}, hasClient=${this._clients.has(name)}`
+    );
+
     if (this._clients.has(name)) {
       log.warn(` Server '${name}' already exists, skipping`);
-      return;
+      return { success: false, error: `Server '${name}' already connected` };
     }
+
+    // 如果 enabled === false，跳过连接（用于 mcp_set_enabled 禁用后再开启的场景）
+    if (enabled === false) {
+      log.info(` Server '${name}' is disabled, skipping connection`);
+      return { success: false, error: `Server '${name}' is disabled` };
+    }
+
+    // 保存配置，用于重新启用
+    this._serverConfigs.set(name, {
+      name,
+      command,
+      args,
+      env,
+      url,
+      type,
+      headers,
+      authProvider,
+      enabled,
+    });
     log.info(` Connecting to ${name}...`);
     let client;
     try {
@@ -741,7 +1084,7 @@ class MCPExecutorPlugin extends Plugin {
       }
     } catch (err) {
       log.error(` Failed to create client '${name}':`, err.message);
-      return;
+      return { success: false, error: `创建客户端失败: ${err.message}` };
     }
 
     // 获取 MCP 服务器的工具列表
@@ -750,7 +1093,8 @@ class MCPExecutorPlugin extends Plugin {
       mcpTools = await this._withTimeout(client.tools(), 10000, `client.tools ${name}`);
     } catch (err) {
       log.error(` Failed to get tools from '${name}':`, err.message);
-      return;
+      client.close?.();
+      return { success: false, error: `获取工具列表失败: ${err.message}` };
     }
 
     // 提取工具信息和实际工具对象
@@ -765,6 +1109,22 @@ class MCPExecutorPlugin extends Plugin {
           description: tool.description || '',
           inputSchema: tool.inputSchema || {},
         });
+
+        // 注册为 server_toolname 格式，供 ext_call 使用
+        const registeredName = `${name}_${toolName}`;
+        this.tools[registeredName] = {
+          name: registeredName,
+          description: `[${name}] ${tool.description || ''}`,
+          inputSchema: tool.inputSchema || {},
+          execute: async (args) => {
+            // 路由到 mcp_call
+            return await this._framework.executeTool('mcp_call', {
+              server: name,
+              tool: toolName,
+              args_json: JSON.stringify(args || {}),
+            });
+          },
+        };
       }
     }
 
@@ -773,9 +1133,18 @@ class MCPExecutorPlugin extends Plugin {
       client,
       tools: toolsInfo,
       toolObjects, // 实际工具对象，供 mcp_call 直接调用
+      enabled: config.enabled !== false,
     });
 
-    log.info(` Added server '${name}' with ${toolsInfo.length} tools`);
+    log.info(
+      ` Added server '${name}' with ${toolsInfo.length} tools (ext_call names: ${Object.keys(
+        this.tools
+      )
+        .filter((k) => k.startsWith(name + '_'))
+        .join(', ')})`
+    );
+
+    return { success: true, name, toolsCount: toolsInfo.length };
   }
 
   /**
@@ -796,6 +1165,14 @@ class MCPExecutorPlugin extends Plugin {
       } catch (e) {
         // ignore
       }
+
+      // 清理已注册的工具
+      for (const toolName of Object.keys(this.tools)) {
+        if (toolName.startsWith(name + '_')) {
+          delete this.tools[toolName];
+        }
+      }
+
       this._clients.delete(name);
     }
   }
@@ -832,10 +1209,18 @@ class MCPExecutorPlugin extends Plugin {
       } catch (e) {}
     }
     this._clients.clear();
+    // 清理服务器配置
+    this._serverConfigs.clear();
 
     // 2. 并行添加新服务器
     log.info(' Adding new servers...');
     const addPromises = Object.entries(newServers).map(async ([name, serverConfig]) => {
+      if (serverConfig.enabled === false) {
+        log.info(` Skipping disabled server: ${name}`);
+        // 仍保存配置，以便后续动态启用
+        this._serverConfigs.set(name, { name, ...serverConfig });
+        return;
+      }
       const normalizedConfig = {
         name,
         type: serverConfig.type,
@@ -845,6 +1230,7 @@ class MCPExecutorPlugin extends Plugin {
         command: serverConfig.command,
         args: serverConfig.args,
         env: serverConfig.env,
+        enabled: true,
       };
       await this.addServer(normalizedConfig);
     });
@@ -858,6 +1244,38 @@ class MCPExecutorPlugin extends Plugin {
     }
   }
 
+  /**
+   * 保存 MCP 服务器的 enabled 状态到配置文件
+   */
+  async _saveMCPServerEnabled(serverName, enabled) {
+    const fs = require('fs');
+    const path = require('path');
+    const configPath = path.resolve('.agent/mcp_config.json');
+
+    try {
+      if (!fs.existsSync(configPath)) {
+        log.warn(` MCP config file not found: ${configPath}`);
+        return false;
+      }
+
+      const configContent = fs.readFileSync(configPath, 'utf8');
+      const config = JSON.parse(configContent);
+
+      if (!config.mcpServers || !config.mcpServers[serverName]) {
+        log.warn(` Server '${serverName}' not found in MCP config`);
+        return false;
+      }
+
+      config.mcpServers[serverName].enabled = enabled;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+      log.info(` Saved enabled=${enabled} for server '${serverName}' to config`);
+      return true;
+    } catch (err) {
+      log.error(` Failed to save MCP config:`, err.message);
+      return false;
+    }
+  }
+
   async uninstall(framework) {
     // 断开所有 MCP 连接
     for (const [name, clientInfo] of this._clients) {

package/src/utils/id.js

@@ -130,4 +130,9 @@ module.exports = {
   messageId,
   ruleId,
   resetSnowflake,
+  // 通用 ID 生成器（向后兼容）
+  generateId: () => {
+    const random = crypto.randomBytes(8).toString('base64url');
+    return `id_${Date.now()}_${random}`;
+  },
 };