foliko 2.0.5 → 2.0.7

package/src/executors/mcp-executor.js

@@ -14,7 +14,7 @@ const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio
 const { zodSchemaToMarkdown } = require('@chnak/zod-to-markdown');
 const { logger } = require('../common/logger');
 const { MCPClientWrapper } = require('./mcp-client');
-const { extractSchema, buildMCPServersDescription, bindMcpParamsDesc } = require('./mcp-desc');
+const { extractSchema } = require('./mcp-desc');
 const { jsonSchemaToZod } = require('../tool/schema');
 
 const log = logger.child('MCPExecutor');
@@ -53,120 +53,6 @@ class MCPExecutorPlugin extends Plugin {
       }
     }
 
-    framework.registerTool({
-      name: 'mcp_tool_schema',
-      description: '查询工具的调用示例，直接复制 example 或 fullExample 字段使用',
-      inputSchema: z.object({
-        server: z.string().describe('MCP 服务器名称'),
-        tool: z.string().describe('工具名称'),
-      }),
-      execute: async (args) => {
-        const { server, tool } = args;
-        const clientInfo = this._clients.get(server);
-        if (!clientInfo) return { success: false, error: `MCP server '${server}' not found` };
-
-        const toolInfo = clientInfo.tools.find((t) => t.name === tool);
-        if (!toolInfo) return { success: false, error: `Tool '${tool}' not found` };
-
-        const schema = extractSchema(toolInfo.inputSchema);
-        const props = schema.properties || {};
-        const required = schema.required || [];
-
-        const generateExample = (prop, depth = 0) => {
-          if (!prop) return null;
-          const type = prop.type || (prop.properties ? 'object' : 'string');
-          if (type === 'string') return prop.description?.split('.')[0] || `${prop.title || '值'}`;
-          if (type === 'number' || type === 'integer') return prop.default || 0;
-          if (type === 'boolean') return false;
-          if (type === 'array') {
-            if (prop.items) {
-              const itemExample = generateExample(prop.items, depth + 1);
-              return depth === 0 ? [itemExample] : itemExample;
-            }
-            return ['示例'];
-          }
-          if (type === 'object' || prop.properties) {
-            const obj = {};
-            for (const [key, val] of Object.entries(prop.properties || {})) {
-              obj[key] = generateExample(val, depth + 1);
-            }
-            return obj;
-          }
-          return null;
-        };
-
-        const exampleArgs = {};
-        for (const key of required) {
-          const prop = props[key];
-          if (prop) exampleArgs[key] = generateExample(prop);
-        }
-
-        return {
-          success: true,
-          data: {
-            name: toolInfo.name, description: toolInfo.description, required,
-            parameters: Object.fromEntries(
-              required.map((key) => [key, {
-                type: props[key]?.type || 'string',
-                description: props[key]?.description || '',
-                example: generateExample(props[key]),
-              }])
-            ),
-            example: JSON.stringify(exampleArgs, null, 2),
-            fullExample: `mcp_call({ server: "${server}", tool: "${tool}", args_json: ${JSON.stringify(JSON.stringify(exampleArgs))} })`,
-          },
-        };
-      },
-    });
-
-    framework.registerTool({
-      name: 'mcp_call',
-      description: '调用 MCP 服务器工具。args_json 是包含实际参数的 JSON 字符串',
-      inputSchema: z.object({
-        server: z.string().describe('MCP 服务器名称'),
-        tool: z.string().describe('工具名称'),
-        args_json: z.string().describe('参数 JSON 字符串'),
-      }),
-      execute: async (args) => {
-        const { server, tool, args_json } = args;
-        const clientInfo = this._clients.get(server);
-        if (!clientInfo) return { success: false, error: `MCP server '${server}' not found` };
-
-        let finalArgs = {};
-        if (args_json) {
-          try { finalArgs = JSON.parse(args_json); }
-          catch (e) { return { success: false, error: `args_json 格式错误: ${args_json}` }; }
-        }
-
-        if (!finalArgs || Object.keys(finalArgs).length === 0) {
-          const toolInfo = clientInfo.tools.find((t) => t.name === tool);
-          if (toolInfo) {
-            const schema = extractSchema(toolInfo.inputSchema);
-            const required = schema.required || [];
-            return { success: false, error: `参数为空！必须提供: ${required.join(', ')}`, hint: `正确格式: {"${required[0]}": "具体值"}` };
-          }
-        }
-
-        try {
-          const mcpTool = clientInfo.toolObjects?.[tool];
-          if (!mcpTool) return { success: false, error: `Tool '${tool}' not found on server '${server}'` };
-
-          const mcpToolName = `${server}:${tool}`;
-          framework.emit('tool:call', { name: mcpToolName, args: finalArgs, source: 'mcp' });
-          framework.emit('tool-call', { name: mcpToolName, args: finalArgs, source: 'mcp' });
-
-          const execResult = await mcpTool.execute(finalArgs);
-
-          framework.emit('tool:result', { name: mcpToolName, args: finalArgs, result: execResult, source: 'mcp' });
-          return { success: true, data: execResult };
-        } catch (err) {
-          log.error(` Tool '${tool}' failed:`, err.message);
-          framework.emit('tool:error', { name: `${server}:${tool}`, args: finalArgs, error: err.message, source: 'mcp' });
-          return { success: false, error: err.message };
-        }
-      },
-    });
-
     framework.registerTool({
       name: 'mcp_list_servers',
       description: '列出已连接的 MCP 服务器及其工具',
@@ -235,9 +121,12 @@ class MCPExecutorPlugin extends Plugin {
           if (!clientInfo) return { success: false, error: `MCP server '${server}' not found` };
           try { clientInfo.client.close?.(); } catch (e) { /* ignore */ }
           this._clients.delete(server);
-          for (const key of Object.keys(this.tools)) {
-            if (key.startsWith(`${server}_`)) delete this.tools[key];
+          // 注销该服务器的所有工具（this.tools 中的 key 就是 MCP 原始工具名）
+          for (const t of clientInfo.tools) {
+            if (this.tools[t.name]) delete this.tools[t.name];
           }
+          // 同时注销对应的扩展（mcp:<server>）
+          this._unregisterExtension(server);
           await this._saveMCPServerEnabled(server, false);
           this._refreshAllAgentsMCPPrompt(this._framework);
           return { success: true, data: `MCP 服务器 '${server}' 已关闭` };
@@ -343,15 +232,23 @@ class MCPExecutorPlugin extends Plugin {
         toolObjects[toolName] = tool;
         toolsInfo.push({ name: toolName, description: tool.description || '', inputSchema: tool.inputSchema || {} });
 
-        const registeredName = `${name}_${toolName}`;
-        this.tools[registeredName] = {
-          name: registeredName,
-          description: `[${name}] ${tool.description || ''}`,
+        // 直接调用底层 MCP 工具（不再走 mcp_call 中转）
+        this.tools[toolName] = {
+          name: toolName,
+          description: tool.description || '',
           inputSchema: tool.inputSchema || {},
           execute: async (args) => {
-            return await this._framework.executeTool('mcp_call', {
-              server: name, tool: toolName, args_json: JSON.stringify(args || {}),
-            });
+            try {
+              const mcpToolName = `${name}:${toolName}`;
+              framework?.emit?.('tool:call', { name: mcpToolName, args: args || {}, source: 'mcp' });
+              const execResult = await tool.execute(args || {});
+              framework?.emit?.('tool:result', { name: mcpToolName, args: args || {}, result: execResult, source: 'mcp' });
+              return { success: true, data: execResult };
+            } catch (err) {
+              log.error(` Tool '${toolName}' failed:`, err.message);
+              framework?.emit?.('tool:error', { name: `${name}:${toolName}`, args: args || {}, error: err.message, source: 'mcp' });
+              return { success: false, error: err.message };
+            }
           },
         };
       }
@@ -359,10 +256,89 @@ class MCPExecutorPlugin extends Plugin {
 
     this._clients.set(name, { client, tools: toolsInfo, toolObjects, enabled: config.enabled !== false });
 
+    // 把整个 MCP 服务器注册为扩展（mcp:<servername>），让 ext_call / ext_skill 统一调度
+    this._registerAsExtension(name, toolsInfo, toolObjects);
+
+    // 触发 mcp 工具变化事件，通知 extension-executor 刷新
+    this._framework?.emit?.('mcp:tools-changed', { name, toolsCount: toolsInfo.length });
+
     log.debug(` Added server '${name}' with ${toolsInfo.length} tools`);
     return { success: true, name, toolsCount: toolsInfo.length };
   }
 
+  /**
+   * 把 MCP 服务器注册为扩展插件（mcp:<servername>）
+   * 使其能通过 ext_call({plugin:'mcp:<server>', tool:'xxx', args:{...}}) 调用
+   * 通过 ext_skill({plugin:'mcp:<server>'}) 获取参数说明
+   */
+  _registerAsExtension(serverName, toolsInfo, toolObjects) {
+    const extExecutor = this._framework?.pluginManager?.get('extension-executor');
+    if (!extExecutor || typeof extExecutor.registerTool !== 'function') return;
+
+    const extName = `mcp:${serverName}`;
+    // 优先从 server config 取 description，否则用 server name
+    const serverConfig = this._serverConfigs.get(serverName) || {};
+    const extDescription = serverConfig.description
+      ? serverConfig.description
+      : `MCP 服务器 ${serverName}`;
+    const pluginInfo = {
+      name: extName,
+      description: extDescription,
+      version: '1.0.0',
+    };
+
+    for (const toolInfo of toolsInfo) {
+      const mcpTool = toolObjects[toolInfo.name];
+      if (!mcpTool) continue;
+
+      // 把 JSON schema 转换为 Zod schema（用于 AI SDK 的工具参数定义）
+      // 同时保留原始 JSON schema 作为 _rawSchema，让 ext_skill 能渲染出清晰的参数说明
+      const rawSchema = extractSchema(toolInfo.inputSchema);
+      let inputSchema = rawSchema;
+      try {
+        if (rawSchema && rawSchema.properties) {
+          const zodSchema = this._jsonSchemaToZod(rawSchema);
+          if (zodSchema) inputSchema = zodSchema;
+        }
+      } catch (e) { /* fallback: 保留原始 schema */ }
+
+      extExecutor.registerTool(extName, pluginInfo, {
+        name: toolInfo.name,
+        description: toolInfo.description || '',
+        inputSchema,
+        _rawSchema: rawSchema,  // 原始 JSON schema，用于 ext_skill 渲染
+        execute: async (args, framework) => {
+          try {
+            const finalArgs = args || {};
+            const mcpToolName = `${serverName}:${toolInfo.name}`;
+            framework?.emit?.('tool:call', { name: mcpToolName, args: finalArgs, source: 'mcp' });
+            const result = await mcpTool.execute(finalArgs);
+            framework?.emit?.('tool:result', { name: mcpToolName, args: finalArgs, result, source: 'mcp' });
+            return { success: true, data: result };
+          } catch (err) {
+            log.error(` Tool '${toolInfo.name}' failed:`, err.message);
+            return { success: false, error: err.message };
+          }
+        },
+      });
+    }
+  }
+
+  /**
+   * 注销 MCP 服务器对应的扩展
+   */
+  _unregisterExtension(serverName) {
+    const extExecutor = this._framework?.pluginManager?.get('extension-executor');
+    if (!extExecutor || typeof extExecutor._unregisterTool !== 'function') return;
+
+    const extName = `mcp:${serverName}`;
+    const clientInfo = this._clients.get(serverName);
+    const toolNames = clientInfo?.tools?.map((t) => t.name) || [];
+    for (const toolName of toolNames) {
+      extExecutor._unregisterTool(extName, toolName);
+    }
+  }
+
   async removeServer(name) {
     const clientInfo = this._clients.get(name);
     if (clientInfo) {
@@ -373,9 +349,13 @@ class MCPExecutorPlugin extends Plugin {
         }
       } catch (e) { /* ignore */ }
       for (const toolName of Object.keys(this.tools)) {
-        if (toolName.startsWith(name + '_')) delete this.tools[toolName];
+        if (this.tools[toolName]?.description?.includes?.(`[${name}]`)) {
+          delete this.tools[toolName];
+        }
       }
       this._clients.delete(name);
+      this._unregisterExtension(name);
+      this._framework?.emit?.('mcp:tools-changed', { name, removed: true });
     }
   }
 

package/src/framework/framework.js

@@ -91,7 +91,7 @@ class Framework extends EventEmitter {
     // Subsystems
     this.toolRegistry = new ToolRegistry();
     this.pluginManager = new PluginManager(this);
-    this.promptRegistry = new PromptRegistry();
+    this.promptRegistry = new PromptRegistry(this);
 
     // Agent management
     this._agents = [];
@@ -206,16 +206,70 @@ class Framework extends EventEmitter {
   async disablePlugin(name) { await this.pluginManager.disable(name); return this; }
   updatePluginConfig(name, config) { return this.pluginManager.updatePluginConfig(name, config); }
 
-  registerTool(tool) { this.toolRegistry.register(tool); return this; }
+  registerTool(tool) {
+    this.toolRegistry.register(tool);
+    // 通知所有 Agent 使 ChatHandler._aiToolsCache 失效。
+    // 🔴 修复：热重载插件时，插件调 framework.registerTool 注册新工具，
+    // 但 ChatHandler 的 _aiToolsCache 只在 agent.registerTool 被调用时清，
+    // 所以 reload 后 LLM 仍使用旧的 execute 闭包。
+    if (Array.isArray(this._agents)) {
+      for (const agent of this._agents) {
+        const ch = agent && agent._chatHandler;
+        if (ch) {
+          ch._aiToolsCache = null;
+          ch._aiToolsCacheKey = '';
+          ch._toolsTokensCacheVersion = 0;
+          if (ch._toolExecutor && ch._toolExecutor._tools) {
+            ch._toolExecutor._tools.set(tool.name, tool);
+          }
+        }
+      }
+    }
+    this.emit('tool:registered-changed', tool);
+    return this;
+  }
   tool(toolDef) {
     const tool = { ...toolDef };
     if (tool.input && !tool.inputSchema) tool.inputSchema = tool.input;
     delete tool.input;
     this.toolRegistry.register(tool);
+    // 同步使所有 Agent 的 ChatHandler 缓存失效并同步工具。
+    if (Array.isArray(this._agents)) {
+      for (const agent of this._agents) {
+        const ch = agent && agent._chatHandler;
+        if (ch) {
+          ch._aiToolsCache = null;
+          ch._aiToolsCacheKey = '';
+          ch._toolsTokensCacheVersion = 0;
+          if (ch._toolExecutor && ch._toolExecutor._tools) {
+            ch._toolExecutor._tools.set(tool.name, tool);
+          }
+        }
+      }
+    }
     return this;
   }
   getTools() { return this.toolRegistry.getAll(); }
 
+  unregisterTool(name) {
+    if (this.toolRegistry.unregister) this.toolRegistry.unregister(name);
+    if (Array.isArray(this._agents)) {
+      for (const agent of this._agents) {
+        const ch = agent && agent._chatHandler;
+        if (ch) {
+          ch._aiToolsCache = null;
+          ch._aiToolsCacheKey = '';
+          ch._toolsTokensCacheVersion = 0;
+          if (ch._toolExecutor && ch._toolExecutor._tools) {
+            ch._toolExecutor._tools.delete(name);
+          }
+        }
+      }
+    }
+    this.emit('tool:unregistered-changed', { name });
+    return this;
+  }
+
   // tools 对象别名
   get tools() {
     const self = this;
@@ -912,23 +966,23 @@ class Framework extends EventEmitter {
         return true;
       },
       /**
-       * 调用 MCP 工具
+       * 调用 MCP 工具（通过 ext_call 统一调度）
        * @param {string} server 服务器名
        * @param {string} tool 工具名
        * @param {Object} args 参数
        */
       call: async (server, tool, args) => {
-        return await self.executeTool('mcp_call', {
-          server,
+        return await self.executeTool('ext_call', {
+          plugin: `mcp:${server}`,
           tool,
-          args_json: JSON.stringify(args || {}),
+          args: args || {},
         });
       },
       /**
-       * 获取工具调用示例
+       * 获取工具调用参数说明（通过 ext_skill）
        */
-      getToolSchema: async (server, tool) => {
-        return await self.executeTool('mcp_tool_schema', { server, tool });
+      getToolSchema: async (server, _tool) => {
+        return await self.executeTool('ext_skill', { plugin: `mcp:${server}` });
       },
       /**
        * 动态开启/关闭 MCP 服务器
@@ -946,7 +1000,14 @@ class Framework extends EventEmitter {
   }
 
   getMainAgent() { return this._mainAgent; }
-  getSystemPrompt() { return this._mainAgent?._buildSystemPrompt?.() || ''; }
+  /**
+   * 获取 main agent 的完整系统提示词
+   * 统一走 framework.prompts.build()（含 _originalPrompt + 注册表所有 parts）
+   * 这是 LLM 实际看到的完整 system prompt
+   */
+  getSystemPrompt() {
+    return this.prompts?.build?.() || '';
+  }
   getPluginInstance(name) { return this.pluginManager.get(name) || null; }
   getAgents() { return [...this._agents]; }
   listSessionContexts() { return Array.from(this._sessionContexts.keys()); }
@@ -1007,7 +1068,10 @@ class Framework extends EventEmitter {
         const { SessionManager } = require('../session/session');
         manager = SessionManager.open(sessionFile, sessionDir, cwd);
       }
-    } catch { /* ignore */ }
+    } catch (err) {
+      // Log error but continue - will create new session if load failed
+      this.logger.warn(`[Framework] Failed to load session '${sessionId}': ${err.message}`);
+    }
     if (!manager) {
       const { SessionManager } = require('../session/session');
       manager = new SessionManager(cwd, sessionDir, sessionFile, true);
@@ -1032,7 +1096,9 @@ class Framework extends EventEmitter {
         this._sessionContexts.set(sessionId, manager);
         this.emit('session:context-created', { sessionId, manager });
       }
-    } catch { /* ignore */ }
+    } catch (err) {
+      this.logger.warn(`[Framework] Failed to load session context '${sessionId}': ${err.message}`);
+    }
     return manager || null;
   }
 

package/src/index.js

@@ -11,6 +11,10 @@
 // 加载工作目录 .env 配置（优先于系统环境变量）
 require('dotenv').config({ override: true });
 
+// 安装全局错误捕获:把 unhandledRejection / uncaughtException 的完整堆栈
+// 落盘到 .foliko/error.log。需要堆栈时直接 cat 这个文件即可。
+require('./common/error-capture').install();
+
 // ============================================================
 // Framework
 // ============================================================