foliko 1.1.6 → 1.1.7

package/src/core/agent-chat.js

@@ -5,7 +5,7 @@
 
 const { EventEmitter } = require('../utils/event-emitter');
 const { logger } = require('../utils/logger');
-const { generateText, stepCountIs } = require('ai');
+const { generateText, stepCountIs, isLoopFinished } = require('ai');
 const { prepareMessagesForAPI } = require('../utils');
 const fs = require('fs/promises');
 
@@ -28,10 +28,11 @@ function extractToolCallId(msg) {
 // 模型上下文限制表（留 15-20% 余量给 system prompt 和输出）
 const MODEL_CONTEXT_LIMITS = {
   // DeepSeek
-  'deepseek-chat': 28000,
-  'deepseek-coder': 28000,
+  'deepseek-chat': 128000,
+  'deepseek-coder': 128000,
+  'deepseek-reasoner': 128000,
   // MiniMax
-  'MiniMax-M2.7': 120000,
+  'MiniMax-M2.7': 110000,
   // OpenAI
   'gpt-4': 100000,
   'gpt-4o': 100000,
@@ -1328,7 +1329,7 @@ ${truncatedContent}${truncatedNote}
 
       // 触发 agent:message 事件，让 memory 插件可以自动提取记忆
       const userMsg = messages[messages.length - result.response.messages.length - 1];
-      this.emit('message', { userMessage: userMsg, assistantResponse: result.text });
+      this.emit('message', { content: result.text, sessionId: sessionId, userMessage: userMsg });
 
       // 生成后检查：如果消息太长，下次需要压缩
       const afterTokens = this._countMessagesTokens(messages);
@@ -1341,6 +1342,39 @@ ${truncatedContent}${truncatedNote}
         message: result.text || '',
         stepCount: result.stepCount || 1,
       };
+    } catch (err) {
+      // 捕获 AI API 瞬时错误（如 Invalid JSON response、服务负载过高等）
+      const errorMsg = err.message || String(err);
+      const causeMsg = err.cause?.message || String(err.cause) || '';
+      const fullMsg = errorMsg + causeMsg;
+
+      const isTransientError =
+        fullMsg.includes('Invalid JSON response') ||
+        fullMsg.includes('负载较高') ||
+        fullMsg.includes('Failed after') ||
+        fullMsg.includes('timeout') ||
+        fullMsg.includes('retry') ||
+        err.name === 'AI_RetryError' ||
+        err.name === 'AI_APICallError';
+
+      logger.warn(
+        `[AgentChat] Error caught in _doChat: msg="${errorMsg}", name=${err.name}, isTransient=${isTransientError}`
+      );
+
+      if (isTransientError) {
+        return {
+          success: false,
+          message: 'AI 服务暂时不可用，请稍后重试。',
+          error: errorMsg,
+          stepCount: 0,
+        };
+      }
+
+      // 未知错误，打印调试信息后继续抛出
+      logger.error(
+        `[AgentChat] Unknown error in _doChat: ${err.message}, name: ${err.name}, cause: ${err.cause?.message || err.cause}`
+      );
+      throw err;
     } finally {
       // 校验并修复消息中的不完整工具调用
       this._validateToolCalls(messages);
@@ -1368,7 +1402,7 @@ ${truncatedContent}${truncatedNote}
       this._systemPrompt = this.agent._buildSystemPrompt();
       // 动态导入 AI SDK
       const { tool, ToolLoopAgent } = await this._importAI();
-      //await fs.writeFile('system.md',this._systemPrompt)
+      // await fs.writeFile('system.md', this._systemPrompt);
       const userMessage =
         typeof message === 'string' ? { role: 'user', content: message } : message;
       messages.push(userMessage);
@@ -1480,6 +1514,7 @@ ${truncatedContent}${truncatedNote}
         model: this._aiClient,
         instructions: this._systemPrompt,
         tools: tools,
+        stopWhen: isLoopFinished(),
         prepareStep: prepareStepChainStream,
       });
 
@@ -1530,10 +1565,30 @@ ${truncatedContent}${truncatedNote}
 
       // 触发 agent:message 事件，让 memory 插件可以自动提取记忆
       const userMsg = messages[messages.length - finishMessages.length - 1];
-      this.emit('message', { userMessage: userMsg, assistantResponse: fullText });
+      this.emit('message', { content: fullText, sessionId: sessionId, userMessage: userMsg });
     } catch (err) {
-      this.emit('error', { error: err.message });
-      yield { type: 'error', error: err.message };
+      // 捕获 AI API 瞬时错误
+      const errorMsg = err.message || String(err);
+      const causeMsg = err.cause?.message || String(err.cause) || '';
+      const fullMsg = errorMsg + causeMsg;
+
+      const isTransientError =
+        fullMsg.includes('Invalid JSON response') ||
+        fullMsg.includes('负载较高') ||
+        fullMsg.includes('Failed after') ||
+        fullMsg.includes('timeout') ||
+        fullMsg.includes('retry') ||
+        err.name === 'AI_RetryError' ||
+        err.name === 'AI_APICallError';
+
+      if (isTransientError) {
+        logger.warn(`[AgentChat] Transient AI error in stream: ${errorMsg}`);
+        yield { type: 'error', error: 'AI 服务暂时不可用，请稍后重试。' };
+      } else {
+        logger.error(`[AgentChat] Stream error: ${err.message}, name: ${err.name}`);
+        this.emit('error', { error: err.message });
+        yield { type: 'error', error: err.message };
+      }
     } finally {
       // 校验并修复消息中的不完整工具调用
       this._validateToolCalls(messages);

package/src/core/agent.js

@@ -6,7 +6,8 @@
 const { EventEmitter } = require('../utils/event-emitter');
 const { AgentChatHandler } = require('./agent-chat');
 const { SystemPromptBuilder } = require('./system-prompt-builder');
-const { zodSchemaToTable } = require('@chnak/zod-to-markdown');
+const { zodSchemaToMarkdown } = require('@chnak/zod-to-markdown');
+const { zodSchema } = require('ai');
 const os = require('os');
 
 /**
@@ -278,7 +279,7 @@ class Agent extends EventEmitter {
     }
 
     // 使用数组收集 + join 优化字符串拼接
-    const lines = ['【可用技能】'];
+    const lines = ['## 可用技能', ''];
     for (const skill of skills) {
       const name = skill.metadata?.name || skill.name || 'unknown';
       const descText = skill.metadata?.description || '';
@@ -286,7 +287,7 @@ class Agent extends EventEmitter {
     }
     lines.push(
       '',
-      '重要：当需要开发插件、执行专业任务时，必须先使用 loadSkill 工具加载对应技能，获取专业指导。'
+      '> **重要提示**：当需要开发插件、执行专业任务时，必须先使用 `loadSkill` 工具加载对应技能，获取专业指导。'
     );
 
     return lines.join('\n');
@@ -313,11 +314,11 @@ class Agent extends EventEmitter {
     }
 
     // 使用数组收集 + join 优化字符串拼接
-    const lines = ['【系统能力】'];
+    const lines = ['## 系统能力', ''];
     keyPlugins.forEach((plugin, index) => {
       const name = plugin.instance?.name || plugin.name || 'unknown';
       const description = plugin.instance?.description || '无描述';
-      lines.push(`${index + 1}. ${name}: ${description}`);
+      lines.push(`${index + 1}. **${name}**：${description}`);
     });
 
     return lines.join('\n');
@@ -339,14 +340,16 @@ class Agent extends EventEmitter {
     }
 
     const sections = [
-      '## 【Extensions 扩展工具】',
+      '## Extensions 扩展工具',
       '',
       '你可以通过 `ext_call` 工具调用以下扩展插件的功能。',
       '',
-      '**重要调用规则：**',
-      '1. 调用前必须指定 `plugin`（插件名）和 `tool`（工具名）',
-      '2. 参数通过 `args` 对象传入，参数名和类型见各工具说明',
-      '3. 必填参数（Required）必须提供，可选参数（Optional）可省略',
+      '### 调用规则',
+      '',
+      '> **重要**：',
+      '> 1. 调用前必须指定 `plugin`（插件名）和 `tool`（工具名）',
+      '> 2. 参数通过 `args` 对象传入，参数名和类型见各工具说明',
+      '> 3. 必填参数（Required）必须提供，可选参数（Optional）可省略',
       '',
       '---',
       '',
@@ -355,21 +358,30 @@ class Agent extends EventEmitter {
     for (const ext of extensions) {
       sections.push(`### ${ext.name}`, '');
       sections.push(ext.description || '无描述', '');
+      sections.push(`**版本：** ${ext.version || '1.0.0'}`, '');
 
       for (const tool of ext.tools) {
-        sections.push(`#### ${tool.name}`, '');
+        sections.push(`#### \`${tool.name}\``, '');
         sections.push(tool.description || '无描述', '');
 
         // 使用 zodSchemaToMarkdown 解析参数
         if (tool.inputSchema) {
           try {
-            const schemaMarkdown = zodSchemaToTable(tool.inputSchema);
-            sections.push('**参数:**', ' ');
-            sections.push(schemaMarkdown || '无', ' ');
+            const schemaMarkdown = zodSchemaToMarkdown(tool.inputSchema);
+            // 检查是否包含未解析的原始 Zod 类型名（如 ZodMap、ZodSet、ZodAny 等）
+            const hasUnparsedTypes = schemaMarkdown && /\|.*\bZod\w+\b.*\|/.test(schemaMarkdown);
+            if (hasUnparsedTypes) {
+              // 降级处理：zodSchemaToMarkdown 未正确解析，使用 fallback
+              sections.push('**参数：**', ' ');
+              sections.push(this._fallbackSchemaToText(tool.inputSchema), ' ');
+            } else {
+              sections.push('**参数：**', ' ');
+              sections.push(schemaMarkdown || '无', ' ');
+            }
           } catch (e) {
             logger.warn('Agent', `转换工具 ${tool.name} 的参数描述失败`, e.message);
             // 降级处理：手动解析常见 Zod 类型
-            sections.push('**参数:**', ' ');
+            sections.push('**参数：**', ' ');
             sections.push(this._fallbackSchemaToText(tool.inputSchema), ' ');
           }
         }
@@ -383,18 +395,18 @@ class Agent extends EventEmitter {
       '',
       '## 调用示例',
       '',
-      '**格式:**',
-      '```',
+      '### 格式',
+      '```javascript',
       'ext_call({ plugin: "插件名", tool: "工具名", args: {参数} })',
       '```',
       '',
-      '**示例 - 获取余额:**',
-      '```',
+      '### 示例 - 获取余额',
+      '```javascript',
       'ext_call({ plugin: "gate-trading", tool: "gate_get_account_balance", args: {} })',
       '```',
       '',
-      '**示例 - HTTP 请求:**',
-      '```',
+      '### 示例 - HTTP 请求',
+      '```javascript',
       'ext_call({ plugin: "web", tool: "web_request", args: { method: "GET", path: "/api/data" } })',
       '```'
     );
@@ -404,6 +416,7 @@ class Agent extends EventEmitter {
 
   /**
    * 降级处理：当 zodSchemaToMarkdown 解析失败时的备用方案
+   * 支持复杂 Zod 类型如 ZodOptional、ZodUnion、ZodArray 等
    * @param {Object} schema - Zod schema 对象
    * @returns {string} 参数描述文本
    */
@@ -414,41 +427,79 @@ class Agent extends EventEmitter {
 
     const lines = [];
     for (const [name, field] of Object.entries(schema.shape)) {
-      const type = this._inferZodType(field);
-      const desc = field.description || field._def?.description || '';
-      const isOptional = type.includes('optional') ? '（可选）' : '（必填）';
-      lines.push(`- ${name} (${type}) ${isOptional}${desc ? `: ${desc}` : ''}`);
+      const typeInfo = this._extractFieldType(field);
+      const desc = typeInfo.description || '';
+      const isOptional = typeInfo.isOptional ? '（可选）' : '（必填）';
+      lines.push(`- ${name} (${typeInfo.type}) ${isOptional}${desc ? `: ${desc}` : ''}`);
     }
 
     return lines.join('\n') || '- （参数描述不可用）';
   }
 
   /**
-   * 从 Zod schema 推断类型名称
+   * 递归提取字段类型信息
+   * 处理 ZodOptional、ZodUnion、ZodArray 等复杂类型
    * @param {Object} field - Zod schema 字段
-   * @returns {string} 类型名称
+   * @returns {{ type: string, isOptional: boolean, description: string }}
    */
-  _inferZodType(field) {
+  _extractFieldType(field) {
     const typeName = field._def?.typeName || field.constructor?.name || '';
-
-    const typeMap = {
-      ZodString: 'string',
-      ZodNumber: 'number',
-      ZodBoolean: 'boolean',
-      ZodArray: 'array',
-      ZodObject: 'object',
-      ZodOptional: 'optional',
-      ZodDefault: 'any',
-      ZodEnum: 'enum',
-      ZodUnion: 'union',
-      ZodRecord: 'record',
-    };
-
-    return typeMap[typeName] || typeName.replace('Zod', '').toLowerCase() || 'any';
+    let description = field.description || field._def?.description || '';
+
+    switch (typeName) {
+      case 'ZodOptional': {
+        const inner = field._def.innerType;
+        const innerInfo = this._extractFieldType(inner);
+        return {
+          type: innerInfo.type,
+          isOptional: true,
+          description: description || innerInfo.description,
+        };
+      }
+      case 'ZodUnion': {
+        const types = field._def.options.map((opt) => this._extractFieldType(opt).type);
+        return { type: `union(${types.join(' | ')})`, isOptional: false, description };
+      }
+      case 'ZodArray': {
+        const innerInfo = this._extractFieldType(field._def.type);
+        return { type: `${innerInfo.type}[]`, isOptional: false, description };
+      }
+      case 'ZodObject': {
+        const props = Object.keys(field._def.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':
+        return {
+          type: field._def.values.map((v) => `"${v}"`).join(' | '),
+          isOptional: false,
+          description,
+        };
+      case 'ZodRecord': {
+        const keyType = this._extractFieldType(field._def.keyType).type;
+        const valueType = this._extractFieldType(field._def.valueType).type;
+        return { type: `record<${keyType}, ${valueType}>`, isOptional: false, description };
+      }
+      case 'ZodIntersection':
+        return { type: 'intersection', isOptional: false, description };
+      case 'ZodLiteral':
+        return { type: JSON.stringify(field._def.value), isOptional: false, description };
+      default:
+        return {
+          type: typeName.replace('Zod', '').toLowerCase() || 'any',
+          isOptional: false,
+          description,
+        };
+    }
   }
 
   _buildMcpToolsDescription() {
-    const mcpExecutor = this.framework.pluginManager.get('mcp-executor');
+    const mcpExecutor = this.framework.pluginManager.get('mcp');
     if (!mcpExecutor) {
       return '';
     }
@@ -471,7 +522,10 @@ class Agent extends EventEmitter {
     }
 
     // 使用数组收集 + join 模式优化字符串拼接
-    const lines = ['【子 Agent 匹配表 - 优先使用】'];
+    const lines = ['## 子 Agent 匹配表', ''];
+    lines.push('');
+    lines.push('> **提示**：根据任务类型选择最匹配的子 Agent 处理');
+    lines.push('');
 
     // 动态从配置文件读取每个子Agent的核心能力
     for (const plugin of allSubAgents) {
@@ -488,21 +542,24 @@ class Agent extends EventEmitter {
         if (skills && skills.length > 0) {
           info += ` (技能: ${skills.join(', ')})`;
         }
-        lines.push(`  - ${name}: ${info}`);
+        lines.push(`- **${name}**：${info}`);
       } else {
         // 回退到旧逻辑
-        lines.push(`  - ${name}: ${role || goal || '子代理'}`);
+        lines.push(`- **${name}**：${role || goal || '子代理'}`);
       }
     }
 
     // 通用规则
     lines.push('');
-    lines.push('【子Agent匹配规则 - 必须遵守】');
-    lines.push('  - 根据上述【子 Agent 匹配表】，将任务委托给最匹配的子Agent处理');
-    lines.push('  - 使用 subagent_call 工具并指定 agentName 来委托任务');
-    lines.push('  - 只有当没有匹配的子Agent时，才直接调用工具');
+    lines.push('### 子 Agent 调用规则');
+    lines.push('');
+    lines.push('> **重要**：必须严格遵守以下规则');
+    lines.push('');
+    lines.push('1. 根据上述「子 Agent 匹配表」，将任务委托给最匹配的子 Agent 处理');
+    lines.push('2. 使用 `subagent_call` 工具并指定 `agentName` 来委托任务');
+    lines.push('3. 只有当没有匹配的子 Agent 时，才直接调用工具');
 
-    return lines.join('\n').trim();
+    return lines.join('\n');
   }
 
   /**
@@ -689,24 +746,26 @@ class Agent extends EventEmitter {
    * @private
    */
   _getToolCoreRules() {
-    return `【工具调用核心规则】
-1. **子Agent优先**：任务匹配子Agent专业领域时，**必须优先使用** 使用 subagent_call 工具并指定 agentName 委托给对应子Agent处理，而不是直接调用工具。只有当没有匹配的子Agent时，才直接调用工具。
+    return `## 工具调用核心规则
+
+1. **子 Agent 优先**：任务匹配子 Agent 专业领域时，**必须优先使用** \`subagent_call\` 工具并指定 \`agentName\` 委托给对应子 Agent 处理，而不是直接调用工具。只有当没有匹配的子 Agent 时，才直接调用工具。
 2. **必须先调用工具再回复**：当问题需要信息、操作或计算时，必须调用工具获取真实结果后才能回答。禁止在未调用工具的情况下直接给出答案。
 3. **禁止编造数据**：不许捏造用户、订单、任务、文件、内容等任何数据。所有数据必须通过工具获取。
-4. **工具优先**：可用工具列表会提供，格式为 toolName(toolArgs)。不确定用哪个工具时，优先调用可能相关的工具。
+4. **工具优先**：可用工具列表会提供，格式为 \`toolName(toolArgs)\`。不确定用哪个工具时，优先调用可能相关的工具。
 5. **结果导向**：调用工具后，基于返回结果回答，不要重复工具的内部实现细节。
 6. **多步骤任务**：复杂任务拆解为多个工具调用，逐步完成，每步基于结果决定下一步。
 7. **步骤未完成必须提示继续**：如果任务需要多步骤操作，在返回前必须明确告知用户当前进度和下一步操作。如果回复内容为空或不完整，必须说明"步骤进行中，请继续"。
 
+## 响应规范
+
+> 直接给出结论或结果，不说"我需要..."、"我建议..."等铺垫话术
 
-【响应规范】
-- 直接给出结论或结果，不说"我需要..."、"我建议..."等铺垫话术
 - 如果工具返回错误，说明错误原因并给出解决建议
 - 如果信息不足，先调用工具获取必要信息，不要假设或猜测
-- **重要：如果任务需要多步骤操作，在回复末尾必须提示用户"请继续"或"是否继续下一步"**
+- **重要**：如果任务需要多步骤操作，在回复末尾必须提示用户"请继续"或"是否继续下一步"
 
+## 禁止事项
 
-【禁止事项】
 - 不调用工具就直接回答
 - 编造不存在的数据、文件、订单、用户等信息
 - 回复含糊不清，让用户无法确定答案是否正确

package/src/core/tool-registry.js

@@ -163,7 +163,7 @@ class ToolRegistry extends EventEmitter {
     const tool = this._tools.get(name);
     if (!tool) {
       const error = new Error(`Tool '${name}' not found`);
-      this.emit('tool:error', { name, args, error });
+      this.emit('tool:error', { name, args, error, source: 'tool' });
       throw error;
     }
 
@@ -199,7 +199,7 @@ class ToolRegistry extends EventEmitter {
           error.toolName = name;
           error.toolArgs = args;
           error.errorType = 'VALIDATION_ERROR';
-          this.emit('tool:error', { name, args, error });
+          this.emit('tool:error', { name, args, error, source: 'tool' });
           throw error;
         }
         // 其他错误（可能是非 Zod 错误），包装后抛出
@@ -207,7 +207,7 @@ class ToolRegistry extends EventEmitter {
         error.toolName = name;
         error.toolArgs = args;
         error.errorType = 'PARSE_ERROR';
-        this.emit('tool:error', { name, args, error });
+        this.emit('tool:error', { name, args, error, source: 'tool' });
         throw error;
       }
     }
@@ -240,7 +240,7 @@ class ToolRegistry extends EventEmitter {
     });
 
     try {
-      this.emit('tool:call', { name, args: validatedArgs });
+      this.emit('tool:call', { name, args: validatedArgs, source: 'tool' });
 
       // 确定重试配置
       let retryConfig = tool.retryOptions;
@@ -288,7 +288,7 @@ class ToolRegistry extends EventEmitter {
         result = await executeTool();
       }
 
-      this.emit('tool:result', { name, args, result });
+      this.emit('tool:result', { name, args, result, source: 'tool' });
       return result;
     } catch (err) {
       // 包装错误信息，添加详细上下文