foliko 2.0.22 → 2.0.23

package/tests/core/reasoning-content.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+
+// 测试 _injectReasoningContent：DeepSeek thinking mode 的关键修复
+// 关键：reasoning 必须作为 {type: 'reasoning', text} part 放入 content 数组
+// 不能直接 msg.reasoning_content = '...'（AI SDK 不认识这个字段，丢弃后报错）
+
+const path = require('path');
+const src = require('fs').readFileSync(
+  path.join(__dirname, '../../src/agent/chat.js'),
+  'utf-8'
+);
+
+// 静态检查：方法已定义
+describe('★ _injectReasoningContent 静态检查（关键修复）', () => {
+  it('★ chat.js 包含 _injectReasoningContent 方法', () => {
+    expect(src).toMatch(/_injectReasoningContent\s*\(/);
+  });
+
+  it('★ 不应再使用 msg.reasoning_content = 这种直接赋值（排除注释行）', () => {
+    // 关键：原始 bug 代码是 msg.reasoning_content = reasoningContent
+    // 修复后应该是 _injectReasoningContent(msg, ...)
+    // 允许的例外：delete msg.reasoning_content（清理旧字段）；typeof 检查；=== 比较
+    // 逐行检查，跳过 // 注释行
+    const lines = src.split('\n');
+    const directAssignments = lines.filter(line => {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('//')) return false;  // 跳过注释
+      if (trimmed.startsWith('*')) return false;   // 跳过 JSDoc
+      if (trimmed.startsWith('delete ')) return false;  // 允许 delete
+      if (trimmed.startsWith('typeof ')) return false;  // 允许 typeof 检查
+      // 只匹配 "msg.reasoning_content =" 后面不是 =（即 === 排除）
+      return /msg\.reasoning_content\s*=[^=]/.test(line);
+    });
+    expect(directAssignments).toEqual([]);
+  });
+
+  it('★ 修复版使用 ToolLoop 处理 reasoning（不再需要 injectReasoningContent）', () => {
+    // ToolLoop 内部自动处理 reasoning_content，不需要在 chat.js 里 inject
+    // _injectReasoningContent 仍保留用于旧 session 兼容
+    expect(src).toMatch(/_injectReasoningContent\s*\(/);
+  });
+});
+
+// 动态测试：实际验证 _injectReasoningContent 的行为
+// 通过创建最小化的 AgentChatHandler 实例调用方法
+describe('_injectReasoningContent 行为测试', () => {
+  // 动态 require chat.js 并取 AgentChatHandler 类
+  const { AgentChatHandler } = require('../../src/agent/chat.js');
+
+  function makeHandler() {
+    // 创建不调用构造函数的实例（只取方法）
+    return Object.create(AgentChatHandler.prototype);
+  }
+
+  it('★ 关键：content 是 string 时，转为 array 并加 reasoning part 在前', () => {
+    const handler = makeHandler();
+    const msg = { role: 'assistant', content: 'hello' };
+    handler._injectReasoningContent(msg, 'thinking text');
+    expect(Array.isArray(msg.content)).toBe(true);
+    expect(msg.content[0]).toEqual({ type: 'reasoning', text: 'thinking text' });
+    expect(msg.content[1]).toEqual({ type: 'text', text: 'hello' });
+  });
+
+  it('★ 关键：content 是 array 时，unshift reasoning part', () => {
+    const handler = makeHandler();
+    const msg = {
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'first' },
+        { type: 'tool-call', toolCallId: 'tc1', toolName: 'foo', input: {} },
+      ],
+    };
+    handler._injectReasoningContent(msg, 'reasoning text');
+    expect(msg.content[0]).toEqual({ type: 'reasoning', text: 'reasoning text' });
+    expect(msg.content[1]).toEqual({ type: 'text', text: 'first' });
+    expect(msg.content[2].type).toBe('tool-call');
+  });
+
+  it('★ 关键：已有 reasoning part 时合并（不重复）', () => {
+    const handler = makeHandler();
+    const msg = {
+      role: 'assistant',
+      content: [
+        { type: 'reasoning', text: 'OLD' },
+        { type: 'text', text: 'hello' },
+      ],
+    };
+    handler._injectReasoningContent(msg, 'NEW');
+    expect(msg.content).toHaveLength(2);
+    expect(msg.content[0]).toEqual({ type: 'reasoning', text: 'NEW' });
+    expect(msg.content[1]).toEqual({ type: 'text', text: 'hello' });
+  });
+
+  it('★ 关键：空 reasoningText 不修改消息', () => {
+    const handler = makeHandler();
+    const msg = { role: 'assistant', content: 'hello' };
+    handler._injectReasoningContent(msg, '');
+    expect(msg.content).toBe('hello');  // 未修改
+
+    handler._injectReasoningContent(msg, null);
+    expect(msg.content).toBe('hello');  // 未修改
+  });
+
+  it('★ content 是 undefined 时新建 array', () => {
+    const handler = makeHandler();
+    const msg = { role: 'assistant' };
+    handler._injectReasoningContent(msg, 'reasoning');
+    expect(msg.content).toEqual([{ type: 'reasoning', text: 'reasoning' }]);
+  });
+
+  it('★ 验证：ToolLoop 在 _buildApiMessages 中保留 reasoning（不丢失 tool-call 的配对）', () => {
+    // ToolLoop 的 _buildApiMessages 应该把 assistant(tool-call+reasoning) 转为 OpenAI 格式
+    // 不再依赖 AI SDK 的 convertToOpenAICompatibleMessages
+    const { ToolLoop } = require('../../src/agent/tool-loop.js');
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1 });
+
+    const messages = [
+      { role: 'user', content: 'hi' },
+      { role: 'assistant', content: [{ type: 'text', text: 'I think' }, { type: 'tool-call', toolCallId: 'call_1', toolName: 'read', input: {} }] },
+    ];
+    const api = loop._buildApiMessages(messages, 'you are a bot');
+    // 第二个消息应转为 OpenAI 格式：text content + tool_calls
+    expect(api[1].role).toBe('user');
+    expect(api[2].role).toBe('assistant');
+    expect(api[2].tool_calls).toBeDefined();
+    expect(api[2].tool_calls[0].id).toBe('call_1');
+    expect(api[2].content).toBe('I think');
+  });
+});

package/tests/core/strip-stale-tool-calls.test.js

@@ -0,0 +1,154 @@
+import { describe, it, expect } from 'vitest';
+
+// 测试 _stripStaleToolCalls：处理"过时"的 tool_call 消息
+// 场景：旧 session 文件（修复前保存）的 assistant(tool_call) 消息没有 reasoning part
+//       截断/压缩后这些消息会被发给 DeepSeek，触发 "reasoning_content must be passed back"
+
+const { AgentChatHandler } = require('../../src/agent/chat.js');
+
+function makeHandler({ thinkingMode = true } = {}) {
+  const h = Object.create(AgentChatHandler.prototype);
+  h._thinkingMode = thinkingMode;
+  return h;
+}
+
+describe('_stripStaleToolCalls 处理"过时"消息', () => {
+  it('★ 关键：thinking 模式下，缺 reasoning 的 assistant 消息移除 tool_calls', () => {
+    const h = makeHandler({ thinkingMode: true });
+    const messages = [{
+      role: 'assistant',
+      content: [
+        { type: 'text', text: '我先看看文件' },
+        { type: 'tool-call', toolCallId: 'call_abc', toolName: 'read', input: {} },
+      ],
+    }];
+    h._stripStaleToolCalls(messages);
+    expect(messages[0].content).toHaveLength(1);
+    expect(messages[0].content[0].type).toBe('text');
+  });
+
+  it('★ 关键：有 reasoning 的消息保留 tool_calls', () => {
+    const h = makeHandler({ thinkingMode: true });
+    const messages = [{
+      role: 'assistant',
+      content: [
+        { type: 'reasoning', text: 'thinking...' },
+        { type: 'tool-call', toolCallId: 'call_abc', toolName: 'read', input: {} },
+      ],
+    }];
+    h._stripStaleToolCalls(messages);
+    expect(messages[0].content).toHaveLength(2);  // 保留
+    expect(messages[0].content[1].type).toBe('tool-call');
+  });
+
+  it('★ 非 thinking 模式：不处理', () => {
+    const h = makeHandler({ thinkingMode: false });
+    const messages = [{
+      role: 'assistant',
+      content: [
+        { type: 'tool-call', toolCallId: 'call_abc', toolName: 'read', input: {} },
+      ],
+    }];
+    h._stripStaleToolCalls(messages);
+    // 保留 tool_call
+    expect(messages[0].content).toHaveLength(1);
+  });
+
+  it('★ 多个 tool_call 部分都被清理', () => {
+    const h = makeHandler({ thinkingMode: true });
+    const messages = [{
+      role: 'assistant',
+      content: [
+        { type: 'tool-call', toolCallId: 'c1', toolName: 'a', input: {} },
+        { type: 'text', text: '中间文字' },
+        { type: 'tool-call', toolCallId: 'c2', toolName: 'b', input: {} },
+        { type: 'tool-call', toolCallId: 'c3', toolName: 'c', input: {} },
+      ],
+    }];
+    const n = h._stripStaleToolCalls(messages);
+    expect(n).toBe(3);
+    expect(messages[0].content).toEqual([{ type: 'text', text: '中间文字' }]);
+  });
+
+  it('★ 处理 OpenAI 兼容格式的 msg.tool_calls（顶层字段）', () => {
+    const h = makeHandler({ thinkingMode: true });
+    const messages = [{
+      role: 'assistant',
+      content: [{ type: 'text', text: '我需要先读文件' }],
+      tool_calls: [
+        { id: 'call_1', type: 'function', function: { name: 'read', arguments: '{}' } },
+        { id: 'call_2', type: 'function', function: { name: 'write', arguments: '{}' } },
+      ],
+    }];
+    const n = h._stripStaleToolCalls(messages);
+    expect(n).toBe(2);
+    expect(messages[0].tool_calls).toBeUndefined();
+  });
+
+  it('★ 不影响非 assistant 消息', () => {
+    const h = makeHandler({ thinkingMode: true });
+    const messages = [
+      { role: 'user', content: 'hi' },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'abc', toolName: 'x', output: { type: 'text', value: 'ok' } },
+        ],
+      },
+    ];
+    const n = h._stripStaleToolCalls(messages);
+    expect(n).toBe(0);
+    expect(messages[1].content).toHaveLength(1);
+  });
+
+  it('★ 模拟 _createPrepareStep 截断后调用', () => {
+    // 模拟实际场景：12 条消息截断到 5 条，其中包含"旧"assistant(tool_call) 消息
+    const messages = [
+      { role: 'user', content: '问题1' },
+      // 截断时这部分会被丢掉
+      { role: 'assistant', content: '旧回复1' },
+      { role: 'user', content: '问题2' },
+      { role: 'assistant', content: '旧回复2' },
+      { role: 'tool', content: [{ type: 'tool-result', toolCallId: 'old1', toolName: 'x', output: { type: 'text', value: 'ok' } }] },
+      { role: 'user', content: '问题3' },
+      { role: 'assistant', content: '旧回复3' },
+      { role: 'tool', content: [{ type: 'tool-result', toolCallId: 'old2', toolName: 'x', output: { type: 'text', value: 'ok' } }] },
+      // 截断后保留的
+      { role: 'user', content: '问题4' },
+      { role: 'assistant', content: [
+        { type: 'text', text: '我先看看' },
+        { type: 'tool-call', toolCallId: 'recent1', toolName: 'read', input: {} },
+      ] },
+      { role: 'tool', content: [{ type: 'tool-result', toolCallId: 'recent1', toolName: 'read', output: { type: 'text', value: 'data' } }] },
+      { role: 'user', content: '问题5' },
+    ];
+    // 截断：保留最后 5 条 = [7, 8, 9, 10, 11]
+    const trimmed = messages.slice(-5);
+    messages.length = 0;
+    messages.push(...trimmed);
+
+    // 跑 _stripStaleToolCalls
+    const h = makeHandler({ thinkingMode: true });
+    const n = h._stripStaleToolCalls(messages);
+    expect(n).toBe(1);
+    // messages[2] 是 assistant（缺 reasoning 的 tool_call 被移除）
+    expect(messages[2].content).toEqual([{ type: 'text', text: '我先看看' }]);
+    // 其他消息不动
+    expect(messages).toHaveLength(5);
+  });
+
+  it('★ 返回值：清理的工具调用数量', () => {
+    const h = makeHandler({ thinkingMode: true });
+    const messages = [
+      {
+        role: 'assistant',
+        content: [
+          { type: 'tool-call', toolCallId: 'c1', toolName: 'a', input: {} },
+          { type: 'tool-call', toolCallId: 'c2', toolName: 'b', input: {} },
+        ],
+      },
+    ];
+    const n = h._stripStaleToolCalls(messages);
+    expect(n).toBe(2);
+  });
+});

package/tests/core/tool-loop.test.js

@@ -0,0 +1,208 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+
+const { ToolLoop } = require('../../src/agent/tool-loop.js');
+
+describe('ToolLoop._buildApiMessages 格式转换', () => {
+  let loop;
+  beforeEach(() => {
+    loop = new ToolLoop({ tools: {}, maxSteps: 1 });
+  });
+
+  it('user string 消息正确转换', () => {
+    const api = loop._buildApiMessages([
+      { role: 'user', content: 'hello' },
+    ], 'system prompt');
+    expect(api).toEqual([
+      { role: 'system', content: 'system prompt' },
+      { role: 'user', content: 'hello' },
+    ]);
+  });
+
+  it('assistant 消息带 tool_calls 的正确转换', () => {
+    const api = loop._buildApiMessages([
+      { role: 'user', content: 'hi' },
+      {
+        role: 'assistant',
+        content: [
+          { type: 'text', text: 'I\'ll read the file' },
+          { type: 'tool-call', toolCallId: 'call_xyz', toolName: 'read', input: { path: '/a' } },
+        ],
+      },
+    ], 'you are a bot');
+    expect(api[0].role).toBe('system');
+    expect(api[1].role).toBe('user');
+    expect(api[2].role).toBe('assistant');
+    expect(api[2].content).toBe("I'll read the file");
+    expect(api[2].tool_calls).toHaveLength(1);
+    expect(api[2].tool_calls[0].id).toBe('call_xyz');
+    expect(api[2].tool_calls[0].function.name).toBe('read');
+  });
+
+  it('tool 消息正确转换', () => {
+    const api = loop._buildApiMessages([
+      { role: 'user', content: 'hi' },
+      {
+        role: 'assistant',
+        content: 'looks ok',
+        tool_calls: [{ id: 'c1', type: 'function', function: { name: 'read', arguments: '{}' } }],
+      },
+      {
+        role: 'tool',
+        content: [
+          { type: 'tool-result', toolCallId: 'c1', toolName: 'read', output: { type: 'json', value: { data: 'ok' } } },
+        ],
+      },
+    ], 'sys prompt');
+    expect(api).toHaveLength(4);
+    expect(api[3].role).toBe('tool');
+    expect(api[3].tool_call_id).toBe('c1');
+    expect(api[3].content).toBe('{"data":"ok"}');
+  });
+
+  it('tool 消息已经用 OpenAI 格式时保持', () => {
+    const api = loop._buildApiMessages([
+      { role: 'tool', tool_call_id: 'c1', content: 'done' },
+    ], 'system prompt');
+    // 已经符合 OpenAI 格式的直接保留
+    expect(api[0].role).toBe('system');
+    expect(api[1].role).toBe('tool');
+    expect(api[1].tool_call_id).toBe('c1');
+  });
+
+  it('systemPrompt 为空时不加 system 消息', () => {
+    const api = loop._buildApiMessages([
+      { role: 'user', content: 'hello' },
+    ], '');
+    expect(api).toHaveLength(1);
+    expect(api[0].role).toBe('user');
+  });
+
+  it('assistant content 为 string 时原样保留', () => {
+    const api = loop._buildApiMessages([
+      { role: 'assistant', content: 'just text, no tool calls' },
+    ], '');
+    expect(api[0].role).toBe('assistant');
+    expect(api[0].content).toBe('just text, no tool calls');
+    expect(api[0].tool_calls).toBeUndefined();
+  });
+
+  it('★ thinking mode + 旧消息无 reasoning → 自动补充 placeholder reasoning_content', () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1, thinkingMode: true });
+    // 模拟旧 session 消息：assistant 带 tool_calls 但没有 reasoning_content
+    const api = loop._buildApiMessages([
+      { role: 'user', content: 'hi' },
+      {
+        role: 'assistant',
+        content: '',
+        tool_calls: [{ id: 'c1', type: 'function', function: { name: 'read', arguments: '{}' } }],
+      },
+      { role: 'tool', tool_call_id: 'c1', content: 'done' },
+    ], 'sys');
+    const assistant = api[2];
+    expect(assistant.reasoning_content).toBe('...');
+    expect(assistant.tool_calls).toHaveLength(1);
+    // tool 消息紧随其后 → 不会 orphan
+    expect(api[3].role).toBe('tool');
+  });
+
+  it('★ thinking mode + 新消息有 reasoning → 保留原始 reasoning_content', () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1, thinkingMode: true });
+    const api = loop._buildApiMessages([
+      { role: 'user', content: 'hi' },
+      {
+        role: 'assistant',
+        content: '',
+        reasoning_content: 'I need to read the file first',
+        tool_calls: [{ id: 'c1', type: 'function', function: { name: 'read', arguments: '{}' } }],
+      },
+    ], 'sys');
+    expect(api[2].reasoning_content).toBe('I need to read the file first');
+  });
+
+  it('★ 非 thinking mode → 正常发送 (不添加 reasoning_content)', () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1, thinkingMode: false });
+    const api = loop._buildApiMessages([
+      { role: 'assistant', content: '', tool_calls: [{ id: 'c1', type: 'function', function: { name: 'read', arguments: '{}' } }] },
+    ], 'sys');
+    expect(api[0].reasoning_content).toBeUndefined();
+  });
+
+  it('★ 关键：assistant content 为 string 且含 tool_calls（OpenAI 格式）时保留 tool_calls', () => {
+    const api = loop._buildApiMessages([
+      { role: 'user', content: 'hi' },
+      {
+        role: 'assistant',
+        content: '',
+        tool_calls: [{ id: 'c1', type: 'function', function: { name: 'read', arguments: '{}' } }],
+      },
+      { role: 'tool', tool_call_id: 'c1', content: 'done' },
+    ], 'sys');
+    // assistant 消息应该同时有 content + tool_calls
+    const assistant = api[2];
+    expect(assistant.role).toBe('assistant');
+    expect(assistant.tool_calls).toBeDefined();
+    expect(assistant.tool_calls).toHaveLength(1);
+    expect(assistant.tool_calls[0].id).toBe('c1');
+    // tool 消息跟在后面，API 不会报 "must be a response to tool_calls"
+    const tool = api[3];
+    expect(tool.role).toBe('tool');
+    expect(tool.tool_call_id).toBe('c1');
+  });
+});
+
+describe('ToolLoop._buildApiTools', () => {
+  it('空 tools map 返回 undefined', () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1 });
+    expect(loop._buildApiTools({})).toBeUndefined();
+  });
+
+  it('有工具时返回 OpenAI function calling 格式', () => {
+    const loop = new ToolLoop({ maxSteps: 1 });
+    const tools = {
+      read: { name: 'read', description: '读取文件', parameters: { type: 'object', properties: { path: { type: 'string' } } } },
+    };
+    const apiTools = loop._buildApiTools(tools);
+    expect(apiTools).toHaveLength(1);
+    expect(apiTools[0].type).toBe('function');
+    expect(apiTools[0].function.name).toBe('read');
+  });
+});
+
+describe('ToolLoop._repairArgs', () => {
+  let loop;
+  beforeEach(() => {
+    loop = new ToolLoop({ tools: {}, maxSteps: 1, repairToolCall: null });
+  });
+
+  it('空字符串修复为 {}', () => {
+    const r = loop._repairArgs('test', '', new Error('parse fail'));
+    expect(r).toEqual({});
+  });
+
+  it('缺开头的 { 尝试补全', () => {
+    expect(() => loop._repairArgs('test', '"path":"/a"}', new Error('parse fail'))).toThrow();
+  });
+
+  it('不完整的 JSON（缺末尾}）尝试补全', () => {
+    const r = loop._repairArgs('test', '{"path":"/a"', new Error('parse fail'));
+    expect(r).toEqual({ path: '/a' });
+  });
+});
+
+describe('ToolLoop 完整流程模拟（不调真实 API）', () => {
+  it('构造函数不抛错', () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1 });
+    expect(loop.maxSteps).toBe(1);
+    expect(typeof loop.generate).toBe('function');
+    expect(typeof loop.stream).toBe('function');
+  });
+
+  it('buildApiMessages 注入 system prompt', () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1 });
+    const api = loop._buildApiMessages(
+      [{ role: 'user', content: 'hi' }],
+      '你是一个助手'
+    );
+    expect(api[0]).toEqual({ role: 'system', content: '你是一个助手' });
+  });
+});