foliko 2.0.19 → 2.0.21

package/plugins/messaging/weixin/index.js

@@ -689,6 +689,29 @@ class WeixinPlugin extends Plugin {
             true)
         }
         break
+      // === Planner 集成：/plan 系列命令 ===
+      // 完整 planner 工具在 plugins/core/planner/，这里只是命令入口
+      case 'plan':
+        // /plan <task>：把 task 发给 main agent，让 LLM 按 PROMPT.md 工作流走
+        if (!args || !args.trim()) {
+          await this._sendMessageBatch(originalMsg, userId, '用法: /plan <任务描述>', true)
+        } else {
+          await this._processChat(userId, `请进入计划模式完成：${args}`, originalMsg)
+        }
+        break
+      case 'plan_continue':
+        // /plan_continue <planId>：恢复计划
+        await this._handlePlanContinue(userId, args, originalMsg)
+        break
+      case 'plan_list':
+        await this._handlePlanList(userId, originalMsg)
+        break
+      case 'plan_show':
+        await this._handlePlanShow(userId, args, originalMsg)
+        break
+      case 'plan_delete':
+        await this._handlePlanDelete(userId, args, originalMsg)
+        break
       default:
         // 未识别命令，当作普通消息处理
         await this._processChat(userId, text, originalMsg)
@@ -877,6 +900,128 @@ class WeixinPlugin extends Plugin {
     }
   }
 
+  // ============================================================
+  // Planner 命令处理器（/plan_continue / /plan_list / /plan_show / /plan_delete）
+  // ============================================================
+
+  async _handlePlanContinue(userId, args, originalMsg) {
+    if (!this._framework) {
+      await this._sendMessageBatch(originalMsg, userId, '❌ 框架未就绪', true)
+      return
+    }
+    const planId = (args || '').trim()
+    if (!planId) {
+      await this._sendMessageBatch(originalMsg, userId, '用法: /plan_continue <planId>', true)
+      return
+    }
+    try {
+      const result = await this._framework.executeTool('plan_continue', { planId })
+      if (!result.success) {
+        await this._sendMessageBatch(originalMsg, userId, `❌ ${result.error}`, true)
+        return
+      }
+      const plan = result.plan
+      const next = plan.steps[result.resumableFrom]
+      const lines = [
+        `🔄 恢复计划：${plan.title}`,
+        '',
+        `进度: ${plan.completedSteps}/${plan.totalSteps}（已完成 ${plan.completedSteps}，失败 ${plan.failedSteps}）`,
+        `下一步: Step ${result.resumableFrom + 1} — ${result.nextStepName}`,
+        '',
+        '完整步骤：',
+        ...plan.steps.map(s => {
+          const box = { completed: '✅', failed: '❌', in_progress: '🔄', skipped: '⏭️', pending: '⬜' }[s.status] || '⬜'
+          return `${box} ${s.index + 1}. ${s.name}`
+        }),
+      ]
+      await this._sendMessageBatch(originalMsg, userId, lines.join('\n'), true)
+      // 把恢复指令作为普通消息发给 agent，让 LLM 继续执行
+      const resumeMsg = `请继续执行计划 ${planId} 的 Step ${result.resumableFrom + 1}：${result.nextStepName}`
+      await this._processChat(userId, resumeMsg, originalMsg)
+    } catch (err) {
+      log.error('plan_continue 失败:', err.message)
+      await this._sendMessageBatch(originalMsg, userId, `❌ 恢复失败: ${err.message}`, true)
+    }
+  }
+
+  async _handlePlanList(userId, originalMsg) {
+    if (!this._framework) {
+      await this._sendMessageBatch(originalMsg, userId, '❌ 框架未就绪', true)
+      return
+    }
+    try {
+      const result = await this._framework.executeTool('plan_list', {})
+      if (!result.success || result.count === 0) {
+        await this._sendMessageBatch(originalMsg, userId, '📋 当前没有计划', true)
+        return
+      }
+      const statusBox = {
+        in_progress: '🔄', completed: '✅', failed: '❌', paused: '⏸️',
+      }
+      const lines = [
+        `📋 计划列表（${result.count}）`,
+        '',
+        ...result.plans.map(p => [
+          `${statusBox[p.status] || '❔'} ${p.title}`,
+          `   进度: ${p.completedSteps}/${p.totalSteps} | ${p.status}`,
+          `   ID: ${p.planId}`,
+          `   更新: ${p.updatedAt}`,
+        ].join('\n')),
+      ]
+      await this._sendMessageBatch(originalMsg, userId, lines.join('\n\n'), true)
+    } catch (err) {
+      log.error('plan_list 失败:', err.message)
+      await this._sendMessageBatch(originalMsg, userId, `❌ 查询失败: ${err.message}`, true)
+    }
+  }
+
+  async _handlePlanShow(userId, args, originalMsg) {
+    if (!this._framework) {
+      await this._sendMessageBatch(originalMsg, userId, '❌ 框架未就绪', true)
+      return
+    }
+    const planId = (args || '').trim()
+    if (!planId) {
+      await this._sendMessageBatch(originalMsg, userId, '用法: /plan_show <planId>', true)
+      return
+    }
+    try {
+      const result = await this._framework.executeTool('plan_show', { planId })
+      if (!result.success) {
+        await this._sendMessageBatch(originalMsg, userId, `❌ ${result.error}`, true)
+        return
+      }
+      // markdown 直接发给用户（_sendMessageBatch 会 removeMarkdown）
+      await this._sendMessageBatch(originalMsg, userId, result.markdown, true)
+    } catch (err) {
+      log.error('plan_show 失败:', err.message)
+      await this._sendMessageBatch(originalMsg, userId, `❌ ${err.message}`, true)
+    }
+  }
+
+  async _handlePlanDelete(userId, args, originalMsg) {
+    if (!this._framework) {
+      await this._sendMessageBatch(originalMsg, userId, '❌ 框架未就绪', true)
+      return
+    }
+    const planId = (args || '').trim()
+    if (!planId) {
+      await this._sendMessageBatch(originalMsg, userId, '用法: /plan_delete <planId>', true)
+      return
+    }
+    try {
+      const result = await this._framework.executeTool('plan_delete', { planId })
+      if (!result.success) {
+        await this._sendMessageBatch(originalMsg, userId, `❌ ${result.error || '删除失败'}`, true)
+        return
+      }
+      await this._sendMessageBatch(originalMsg, userId, `✅ 计划已删除: ${planId}`, true)
+    } catch (err) {
+      log.error('plan_delete 失败:', err.message)
+      await this._sendMessageBatch(originalMsg, userId, `❌ ${err.message}`, true)
+    }
+  }
+
   /**
    * 处理定时提醒
    */

package/src/agent/chat.js

@@ -1073,6 +1073,16 @@ class AgentChatHandler extends EventEmitter {
     this._repairInvalidToolCallsInMessages(messages);
     this._repairAndPrefixHistoricalIds(messages);
 
+    // ★ 关键：去重重复的 tool-call ID
+    // 场景：DeepSeek API 在某些情况下会为不同的 LLM 调用生成相同的 toolCallId
+    //   （或者重放历史消息时保留了原始 ID）。同一请求中 tool-call ID 必须唯一，
+    //   否则 DeepSeek 会抛 "invalid params, tool result's tool id(X) not found" 错误。
+    // 策略：保留第一次出现的 ID，后续出现重命名为 <id>_v2/_v3... 并同步更新 tool-result。
+    const deduped = this._dedupeToolCallIds(messages);
+    if (deduped > 0) {
+      logger.warn(`[_prepareSession] 去重 ${deduped} 个重复 tool-call ID`);
+    }
+
     // 单次遍历完成所有验证 + 规范化（validateAll 内部处理 error-text/error-json）
     const validated = validateAll(messages);
     if (validated.length !== messages.length) {
@@ -1106,6 +1116,85 @@ class AgentChatHandler extends EventEmitter {
     return { messageStore, messages, userMessage };
   }
 
+  /**
+   * ★ 去重 messages 中重复的 tool-call / tool-result ID
+   * DeepSeek API 严格要求同一请求中 toolCallId 唯一。
+   * 当历史会话中多个 assistant 消息复用了同一 toolCallId（DeepSeek 偶尔会这样生成），
+   * 第二个 tool-result 会找不到匹配 → 报 "tool result's tool id not found"。
+   *
+   * 策略：保留第一次出现的 ID；后续出现重命名为 `<id>_v2`、`<id>_v3`...，
+   *       并同步更新紧随其后的 tool-result ID（保留 call/result 配对）。
+   *
+   * @param {Array} messages 消息数组（原地修改）
+   * @returns {number} 修复的 ID 数量
+   */
+  _dedupeToolCallIds(messages) {
+    if (!Array.isArray(messages)) return 0;
+
+    let fixedCount = 0;
+    // 跟踪第一次出现某 ID 的位置（用于同步 result 改名）
+    const firstSeen = new Map(); // id → {msgIdx, itemIdx, kind: 'call'|'result'}
+
+    for (let msgIdx = 0; msgIdx < messages.length; msgIdx++) {
+      const msg = messages[msgIdx];
+      if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+        for (let itemIdx = 0; itemIdx < msg.content.length; itemIdx++) {
+          const item = msg.content[itemIdx];
+          if (!item) continue;
+          if ((item.type === 'tool-call' || item.type === 'tool-use') && item.toolCallId) {
+            const id = item.toolCallId;
+            if (firstSeen.has(id)) {
+              // 冲突：生成唯一新 ID（不依赖全局计数器，避免跨调用泄露）
+              const newId = `${id}_dup${msgIdx}_${itemIdx}`;
+              item.toolCallId = newId;
+              // 同步修改紧随其后的 tool-result
+              const renamed = this._renameFollowingToolResult(messages, msgIdx, id, newId);
+              fixedCount += 1 + (renamed ? 1 : 0);
+              // 不更新 firstSeen（原始 ID 已被第一次声明占用）
+            } else {
+              firstSeen.set(id, { msgIdx, itemIdx, kind: 'call' });
+            }
+          }
+        }
+      } else if (msg.role === 'tool' && Array.isArray(msg.content)) {
+        for (let itemIdx = 0; itemIdx < msg.content.length; itemIdx++) {
+          const item = msg.content[itemIdx];
+          if (!item) continue;
+          if ((item.type === 'tool-result' || item.type === 'tool_result') && item.toolCallId) {
+            const id = item.toolCallId;
+            // 记录 tool-result 第一次出现（不与 call 比较，因为可能已被上面的分支处理过）
+            if (!firstSeen.has(id)) {
+              firstSeen.set(id, { msgIdx, itemIdx, kind: 'result' });
+            }
+          }
+        }
+      }
+    }
+    return fixedCount;
+  }
+
+  /**
+   * 在 msgIdx 之后的 tool 消息中，找到第一个 toolCallId === oldId 的项，改名为 newId
+   * 遇到下一个 assistant 消息时停止（确保只改当前 assistant 的 result）
+   * @private
+   */
+  _renameFollowingToolResult(messages, afterMsgIdx, oldId, newId) {
+    for (let i = afterMsgIdx + 1; i < messages.length; i++) {
+      const m = messages[i];
+      if (m.role === 'assistant') return false;
+      if (m.role === 'tool' && Array.isArray(m.content)) {
+        for (const item of m.content) {
+          if (!item) continue;
+          if ((item.type === 'tool-result' || item.type === 'tool_result') && item.toolCallId === oldId) {
+            item.toolCallId = newId;
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+
   /**
    * 判断两个 user content 是否等价（用于末尾 user 去重）
    * @private

package/tests/core/dedupe-tool-call-ids.test.js

@@ -0,0 +1,260 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+
+// 测试 chat.js 的 _dedupeToolCallIds 私有方法
+// 通过 require + 拿到 AgentChatHandler 类的 prototype
+
+const { z } = require('zod');
+const { AgentChatHandler } = require('../../src/agent/chat.js');
+
+function makeHandler() {
+  // 最小化构造，跳过框架依赖
+  const handler = Object.create(AgentChatHandler.prototype);
+  return handler;
+}
+
+describe('_dedupeToolCallIds 私有方法', () => {
+  let handler;
+  beforeEach(() => {
+    handler = makeHandler();
+  });
+
+  it('空数组返回 0', () => {
+    expect(handler._dedupeToolCallIds([])).toBe(0);
+  });
+
+  it('非数组输入返回 0', () => {
+    expect(handler._dedupeToolCallIds(null)).toBe(0);
+    expect(handler._dedupeToolCallIds(undefined)).toBe(0);
+  });
+
+  it('没有重复时返回 0（保持原样）', () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'call_A_1', toolName: 'read', input: {} },
+          { type: 'tool-call', toolCallId: 'call_B_1', toolName: 'write', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'call_A_1', toolName: 'read', output: { type: 'text', value: 'ok' } },
+          { type: 'tool-result', toolCallId: 'call_B_1', toolName: 'write', output: { type: 'text', value: 'ok' } },
+        ],
+      },
+    ];
+    expect(handler._dedupeToolCallIds(messages)).toBe(0);
+    expect(messages[0].content[0].toolCallId).toBe('call_A_1');
+    expect(messages[0].content[1].toolCallId).toBe('call_B_1');
+  });
+
+  it('★ 关键：去重重复的 tool-call ID + 同步 result', () => {
+    // 模拟真实场景：DeepSeek 在不同 LLM 调用中为相同 tool 生成相同 ID
+    const messages = [
+      // 第 1 轮：assistant 调 schedule_list，ID = X
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', output: { type: 'text', value: 'first' } },
+        ],
+      },
+      // 第 2 轮：assistant 又调 schedule_list，ID 还是 X（DeepSeek 复用）
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', output: { type: 'text', value: 'second' } },
+        ],
+      },
+    ];
+
+    const fixed = handler._dedupeToolCallIds(messages);
+    expect(fixed).toBe(2);  // 1 个 call + 1 个 result 改名
+
+    // 第 1 轮的 call/result 保持原 ID
+    expect(messages[0].content[0].toolCallId).toBe('h_call_function_t08sdzj01nre_1');
+    expect(messages[1].content[0].toolCallId).toBe('h_call_function_t08sdzj01nre_1');
+
+    // 第 2 轮的 call/result 被改名
+    expect(messages[2].content[0].toolCallId).toMatch(/^h_call_function_t08sdzj01nre_1_dup\d+_\d+$/);
+    expect(messages[3].content[0].toolCallId).toBe(messages[2].content[0].toolCallId);
+  });
+
+  it('同一 assistant 消息里有多个 call，且都重复', () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_X_1', toolName: 'a', input: {} },
+          { type: 'tool-call', toolCallId: 'h_X_2', toolName: 'b', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_X_1', toolName: 'a', output: {} },
+          { type: 'tool-result', toolCallId: 'h_X_2', toolName: 'b', output: {} },
+        ],
+      },
+      // 第二轮同样的两个 call
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_X_1', toolName: 'a', input: {} },
+          { type: 'tool-call', toolCallId: 'h_X_2', toolName: 'b', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_X_1', toolName: 'a', output: {} },
+          { type: 'tool-result', toolCallId: 'h_X_2', toolName: 'b', output: {} },
+        ],
+      },
+    ];
+
+    const fixed = handler._dedupeToolCallIds(messages);
+    expect(fixed).toBe(4);
+
+    // 第一轮保留
+    expect(messages[0].content[0].toolCallId).toBe('h_X_1');
+    expect(messages[0].content[1].toolCallId).toBe('h_X_2');
+
+    // 第二轮都改名
+    expect(messages[2].content[0].toolCallId).not.toBe('h_X_1');
+    expect(messages[2].content[1].toolCallId).not.toBe('h_X_2');
+    expect(messages[2].content[0].toolCallId).toMatch(/dup/);
+    expect(messages[2].content[1].toolCallId).toMatch(/dup/);
+    // 第二轮的两个 call 改名后仍不同
+    expect(messages[2].content[0].toolCallId).not.toBe(messages[2].content[1].toolCallId);
+
+    // 第二轮的 result 跟随同名 call
+    expect(messages[3].content[0].toolCallId).toBe(messages[2].content[0].toolCallId);
+    expect(messages[3].content[1].toolCallId).toBe(messages[2].content[1].toolCallId);
+  });
+
+  it('★ 真实场景模拟：weixin jsonl 文件中的重复 ID', () => {
+    // 模拟用户报告的真实场景：
+    // 3 个"对话"（conv 2、3、4）都有相同的 tool-call ID
+    // getBranch(leafId) 会把它们都装进 messages 数组
+    const messages = [
+      { role: 'user', content: 'conv 2 user' },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', input: {} },
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_2', toolName: 'read_directory', input: { path: '/app/.foliko/skills/takumi-card' } },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', output: { type: 'text', value: 'A' } },
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_2', toolName: 'read_directory', output: { type: 'text', value: 'A' } },
+        ],
+      },
+      { role: 'user', content: 'conv 3 user' },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', input: {} },
+          { type: 'tool-call', toolCallId: 'h_call_function_t08sdzj01nre_2', toolName: 'read_directory', input: { path: '/app/.foliko/skills/takumi-card' } },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_1', toolName: 'schedule_list', output: { type: 'text', value: 'B' } },
+          { type: 'tool-result', toolCallId: 'h_call_function_t08sdzj01nre_2', toolName: 'read_directory', output: { type: 'text', value: 'B' } },
+        ],
+      },
+    ];
+
+    const fixed = handler._dedupeToolCallIds(messages);
+    // 2 个 call (conv 3) + 2 个 result (conv 3) = 4
+    expect(fixed).toBe(4);
+
+    // 收集所有 call IDs
+    const callIds = new Set();
+    for (const m of messages) {
+      if (m.role === 'assistant') {
+        for (const c of m.content) {
+          if (c.type === 'tool-call') callIds.add(c.toolCallId);
+        }
+      }
+    }
+    // 期望：4 个 call 都是不同的 ID（2 原始 + 2 改名）
+    expect(callIds.size).toBe(4);
+
+    // 收集所有 result IDs
+    const resultIds = new Set();
+    for (const m of messages) {
+      if (m.role === 'tool') {
+        for (const c of m.content) {
+          if (c.type === 'tool-result') resultIds.add(c.toolCallId);
+        }
+      }
+    }
+    expect(resultIds.size).toBe(4);
+
+    // ★ 关键：每个 result 都能在 call 中找到匹配
+    for (const resultId of resultIds) {
+      expect(callIds.has(resultId)).toBe(true);
+    }
+  });
+
+  it('部分 result 缺失也能正确处理（不影响已有配对）', () => {
+    const messages = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_X_1', toolName: 'a', input: {} },
+        ],
+      },
+      // 没有 result（模拟加载时被截断）
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'h_X_1', toolName: 'a', input: {} },
+        ],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'h_X_1', toolName: 'a', output: {} },
+        ],
+      },
+    ];
+
+    const fixed = handler._dedupeToolCallIds(messages);
+    expect(fixed).toBeGreaterThan(0);
+
+    // 第一个 call 保留，第二个改名
+    expect(messages[0].content[0].toolCallId).toBe('h_X_1');
+    expect(messages[1].content[0].toolCallId).toMatch(/dup/);
+    // 最后一个 result 还是匹配第一个 call（因为它出现在第一个 call 之后）
+    // 实际上看 _renameFollowingToolResult 的实现：它从 afterMsgIdx 之后找，
+    // 所以 [0] call 后的 result 是 [2] tool message 的 [0]，会被改成第一个 call 的 ID
+    // 但第一个 call 已经是原始 ID，所以 result 也是原始 ID
+    // 这里我们只检查 IDs 都不重复
+    const ids = new Set();
+    for (const m of messages) {
+      for (const c of m.content || []) {
+        if (c.toolCallId) ids.add(c.toolCallId);
+      }
+    }
+    expect(ids.size).toBe(2);
+  });
+});