foliko 2.0.31 → 2.0.32

package/tests/core/latest-message-not-filtered.test.js

@@ -0,0 +1,143 @@
+import { describe, it, expect } from 'vitest';
+
+const { ToolLoop } = require('../../src/agent/tool-loop.js');
+
+/**
+ * 验证："每次发送消息都是最新的，不会被过滤掉"
+ * 即：无论历史消息如何被 sanitize / 补 reasoning / 去重，
+ *     用户最新的一条消息永远作为最后一条被发送给 API，绝不丢失。
+ */
+
+// 一个最小可捕获的 OpenAI 兼容客户端 mock
+function mockClient(responses) {
+  const calls = [];
+  return {
+    calls,
+    chat: {
+      completions: {
+        create: async (params) => {
+          // 深拷贝快照，避免后续 loop 复用引用导致断言失真
+          calls.push(JSON.parse(JSON.stringify(params)));
+          const r = responses.shift();
+          if (r instanceof Error) throw r;
+          return r;
+        },
+      },
+    },
+  };
+}
+
+// 非流式最终答复（无 tool_calls）
+function finalAnswer(text) {
+  return {
+    choices: [{ message: { content: text }, finish_reason: 'stop' }],
+    usage: { prompt_tokens: 1, completion_tokens: 1 },
+  };
+}
+
+const lastOf = (arr) => arr[arr.length - 1];
+
+describe('最新消息一定被发送（_buildApiMessages 层）', () => {
+  it('纯文本历史 + 最新 user → 最新 user 永远在最后', () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1 });
+    const api = loop._buildApiMessages([
+      { role: 'user', content: '第一条' },
+      { role: 'assistant', content: '回复第一条' },
+      { role: 'user', content: '最新消息-abc' },
+    ], 'sys');
+    expect(lastOf(api)).toEqual({ role: 'user', content: '最新消息-abc' });
+  });
+
+  it('历史含 tool_calls / tool 结果 / reasoning 时，最新 user 仍在最后且内容不变', () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1, thinkingMode: true });
+    const api = loop._buildApiMessages([
+      { role: 'user', content: '早前的问题' },
+      {
+        role: 'assistant',
+        content: '',
+        reasoning_content: '先读文件',
+        tool_calls: [{ id: 'c1', type: 'function', function: { name: 'read', arguments: '{}' } }],
+      },
+      { role: 'tool', tool_call_id: 'c1', content: 'file data' },
+      { role: 'assistant', content: '读完了' },
+      { role: 'user', content: '这是我最新发的-xyz' },
+    ], 'sys');
+    const last = lastOf(api);
+    expect(last.role).toBe('user');
+    expect(last.content).toBe('这是我最新发的-xyz');
+  });
+
+  it('最新 user 内容为空字符串也不会被丢弃', () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1 });
+    const api = loop._buildApiMessages([
+      { role: 'assistant', content: '上一轮' },
+      { role: 'user', content: '' },
+    ], 'sys');
+    expect(lastOf(api)).toEqual({ role: 'user', content: '' });
+  });
+
+  it('最新 user 是数组内容（含 text part）时，文本被保留为最后一条', () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 1 });
+    const api = loop._buildApiMessages([
+      { role: 'user', content: '历史' },
+      { role: 'assistant', content: 'ok' },
+      { role: 'user', content: [{ type: 'text', text: '多模态最新-777' }] },
+    ], 'sys');
+    const last = lastOf(api);
+    expect(last.role).toBe('user');
+    expect(last.content).toBe('多模态最新-777');
+  });
+});
+
+describe('最新消息一定被发送（generate 端到端，mock client）', () => {
+  it('实际发给 API 的 messages 末尾就是最新 user 输入', async () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 3 });
+    const client = mockClient([finalAnswer('这是回复')]);
+
+    const messages = [
+      { role: 'user', content: '旧消息1' },
+      { role: 'assistant', content: '旧回复1' },
+      { role: 'user', content: '★最新用户输入★' },
+    ];
+
+    const result = await loop.generate({ messages, systemPrompt: 'sys', model: 'm', client });
+
+    expect(result.text).toBe('这是回复');
+    expect(client.calls).toHaveLength(1);
+    const sent = lastOf(client.calls[0].messages);
+    expect(sent.role).toBe('user');
+    expect(sent.content).toBe('★最新用户输入★');
+  });
+
+  it('触发 reasoning_content 自愈重试后，最新 user 依旧在最后（两次请求都保住）', async () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 3 });
+    const err = new Error('400 The reasoning_content in the thinking mode must be passed back to the API.');
+    const client = mockClient([err, finalAnswer('重试成功的回复')]);
+
+    const messages = [
+      { role: 'user', content: '历史问' },
+      {
+        role: 'assistant',
+        content: '',
+        tool_calls: [{ id: 'c1', type: 'function', function: { name: 'read', arguments: '{}' } }],
+      },
+      { role: 'tool', tool_call_id: 'c1', content: 'done' },
+      { role: 'user', content: '重试也要带上的最新消息-999' },
+    ];
+
+    const result = await loop.generate({ messages, systemPrompt: 'sys', model: 'm', client });
+
+    expect(result.text).toBe('重试成功的回复');
+    // 一次失败 + 一次自愈重试 = 2 次调用
+    expect(client.calls).toHaveLength(2);
+    for (const call of client.calls) {
+      const last = lastOf(call.messages);
+      expect(last.role).toBe('user');
+      expect(last.content).toBe('重试也要带上的最新消息-999');
+    }
+    // 自愈生效：重试请求里 assistant 已补上 reasoning_content
+    const retried = client.calls[1].messages;
+    const assistantMsg = retried.find((m) => m.role === 'assistant' && m.tool_calls);
+    expect(assistantMsg.reasoning_content).toBeTruthy();
+  });
+});

package/tests/core/p0-fixes.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect } from 'vitest';
+
+const { ToolLoop } = require('../../src/agent/tool-loop.js');
+const { ContextCompressor } = require('../../src/context/compressor.js');
+
+// 最小可捕获的 OpenAI 兼容客户端 mock
+function mockClient(responses) {
+  const calls = [];
+  return {
+    calls,
+    chat: { completions: { create: async (p) => { calls.push(p); const r = responses.shift(); if (r instanceof Error) throw r; return r; } } },
+  };
+}
+const finalAnswer = (text, reasoning) => ({
+  choices: [{ message: { content: text, ...(reasoning ? { reasoning_content: reasoning } : {}) }, finish_reason: 'stop' }],
+  usage: { prompt_tokens: 1, completion_tokens: 1 },
+});
+const toolThenAnswer = (toolName) => ({
+  choices: [{ message: { content: '', tool_calls: [{ id: 'c1', type: 'function', function: { name: toolName, arguments: '{}' } }] }, finish_reason: 'tool_calls' }],
+  usage: { prompt_tokens: 1, completion_tokens: 1 },
+});
+
+describe('P0#2 — 最终 assistant 回复被写进 messages（generate）', () => {
+  it('无工具时，最终回复作为 assistant 消息追加到 messages', async () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 3 });
+    const client = mockClient([finalAnswer('这是最终答复', '我的思考')]);
+    const messages = [{ role: 'user', content: '问题' }];
+
+    const result = await loop.generate({ messages, systemPrompt: 'sys', model: 'm', client });
+
+    expect(result.text).toBe('这是最终答复');
+    const last = messages[messages.length - 1];
+    expect(last.role).toBe('assistant');
+    expect(last.content).toBe('这是最终答复');
+    expect(last.reasoning_content).toBe('我的思考');
+  });
+
+  it('工具轮 + 最终回复：messages 末尾是 assistant 答复（历史不丢答复）', async () => {
+    const loop = new ToolLoop({ tools: { read: { name: 'read', execute: async () => 'file data' } }, maxSteps: 3 });
+    const client = mockClient([toolThenAnswer('read'), finalAnswer('读完了，结果是X')]);
+    const messages = [{ role: 'user', content: '读文件' }];
+
+    await loop.generate({ messages, systemPrompt: 'sys', model: 'm', client });
+
+    const roles = messages.map(m => m.role);
+    // user -> assistant(tool_calls) -> tool -> assistant(final)
+    expect(roles[0]).toBe('user');
+    expect(roles[roles.length - 1]).toBe('assistant');
+    expect(messages[messages.length - 1].content).toBe('读完了，结果是X');
+  });
+});
+
+describe('P0#2/#3 — stream 追加最终回复 + thinking 只发增量', () => {
+  async function drain(gen) {
+    const events = [];
+    let ret;
+    while (true) {
+      const { value, done } = await gen.next();
+      if (done) { ret = value; break; }
+      events.push(value);
+    }
+    return { events, ret };
+  }
+
+  // 流式 chunk 构造
+  const chunk = (delta, finish = null) => ({ choices: [{ delta, finish_reason: finish }] });
+
+  it('thinking 事件是增量而非累积（不重复）', async () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 2, thinkingMode: true });
+    async function* streamGen() {
+      yield chunk({ reasoning_content: '我先' });
+      yield chunk({ reasoning_content: '想一下' });
+      yield chunk({ content: '答复' });
+      yield chunk({}, 'stop');
+      yield { choices: [], usage: { prompt_tokens: 1, completion_tokens: 1 } };
+    }
+    const client = { chat: { completions: { create: async () => streamGen() } } };
+    const messages = [{ role: 'user', content: 'hi' }];
+
+    const { events } = await drain(loop.stream({ messages, systemPrompt: 'sys', model: 'm', client }));
+    const thinking = events.filter(e => e.type === 'thinking').map(e => e.text);
+    // 增量应为 ['我先','想一下']，而不是 ['我先','我先想一下']
+    expect(thinking).toEqual(['我先', '想一下']);
+    // 且最终 assistant 回复被追加，reasoning 完整保存
+    const last = messages[messages.length - 1];
+    expect(last.role).toBe('assistant');
+    expect(last.content).toBe('答复');
+    expect(last.reasoning_content).toBe('我先想一下');
+  });
+});
+
+describe('P0#4 — 压缩器按 sessionId 隔离在途 promise', () => {
+  it('不同 session 并发压缩各自独立执行（不共享 in-flight）', async () => {
+    const comp = new ContextCompressor({ agent: null, framework: null, model: 'deepseek-chat', keepRecentMessages: 1, enableSmartCompress: false });
+    let calls = 0;
+    const orig = comp._doCompress.bind(comp);
+    comp._doCompress = async (...a) => { calls++; return orig(...a); };
+    const mkMsgs = (tag) => [
+      { role: 'user', content: `${tag}-1` },
+      { role: 'assistant', content: `${tag}-2` },
+      { role: 'user', content: `${tag}-3` },
+    ];
+    const storeA = { messages: mkMsgs('A'), save: async () => {} };
+    const storeB = { messages: mkMsgs('B'), save: async () => {} };
+
+    await Promise.all([
+      comp.compress('sessA', storeA.messages, storeA),
+      comp.compress('sessB', storeB.messages, storeB),
+    ]);
+    // 两个 session 各自跑一次压缩（旧实现里 B 会拿到 A 的 promise、根本不压缩自己）
+    expect(calls).toBe(2);
+  });
+
+  it('同一 session 并发调用只执行一次压缩（复用 in-flight）', async () => {
+    const comp = new ContextCompressor({ agent: null, framework: null, model: 'deepseek-chat', keepRecentMessages: 1, enableSmartCompress: false });
+    let calls = 0;
+    const orig = comp._doCompress.bind(comp);
+    comp._doCompress = async (...a) => { calls++; return orig(...a); };
+    const msgs = [
+      { role: 'user', content: 'x1' }, { role: 'assistant', content: 'x2' }, { role: 'user', content: 'x3' },
+    ];
+    const store = { messages: msgs, save: async () => {} };
+    await Promise.all([
+      comp.compress('same', msgs, store),
+      comp.compress('same', msgs, store),
+    ]);
+    expect(calls).toBe(1);
+  });
+});

package/tests/core/p1-fixes.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { ToolLoop } = require('../../src/agent/tool-loop.js');
+const { atomicWriteFileSync } = require('../../src/common/atomic-write.js');
+const { SessionManager } = require('../../src/session/session.js');
+
+function mockClient(responses) {
+  return { chat: { completions: { create: async () => { const r = responses.shift(); if (r instanceof Error) throw r; return r; } } } };
+}
+const toolCall = (name) => ({ choices: [{ message: { content: '', tool_calls: [{ id: 'c1', type: 'function', function: { name, arguments: '{}' } }] }, finish_reason: 'tool_calls' }], usage: {} });
+const answer = (t) => ({ choices: [{ message: { content: t }, finish_reason: 'stop' }], usage: {} });
+
+describe('P1#1 — maxSteps 用尽返回 stopReason', () => {
+  it('工具轮次耗尽 → stopReason=max_steps（不是成功）', async () => {
+    // 工具一直被调用，maxSteps=2 会在两轮后耗尽
+    const loop = new ToolLoop({ tools: { loopTool: { name: 'loopTool', execute: async () => 'again' } }, maxSteps: 2 });
+    const client = mockClient([toolCall('loopTool'), toolCall('loopTool'), toolCall('loopTool')]);
+    const messages = [{ role: 'user', content: 'go' }];
+    const result = await loop.generate({ messages, systemPrompt: 's', model: 'm', client });
+    expect(result.stopReason).toBe('max_steps');
+  });
+
+  it('正常给出答复 → stopReason=stop', async () => {
+    const loop = new ToolLoop({ tools: {}, maxSteps: 3 });
+    const client = mockClient([answer('done')]);
+    const messages = [{ role: 'user', content: 'go' }];
+    const result = await loop.generate({ messages, systemPrompt: 's', model: 'm', client });
+    expect(result.stopReason).toBe('stop');
+    expect(result.text).toBe('done');
+  });
+});
+
+describe('P1#6 — atomicWriteFileSync 原子写', () => {
+  it('写入内容可完整读回', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'foliko-atomic-'));
+    const fp = path.join(dir, 'x.jsonl');
+    atomicWriteFileSync(fp, 'line1\nline2\n');
+    expect(fs.readFileSync(fp, 'utf8')).toBe('line1\nline2\n');
+    // 覆盖写
+    atomicWriteFileSync(fp, 'new\n');
+    expect(fs.readFileSync(fp, 'utf8')).toBe('new\n');
+    // 不残留 tmp 文件
+    expect(fs.readdirSync(dir).filter(n => n.includes('.tmp-'))).toHaveLength(0);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
+
+describe('P1#3 — buildSessionContext 走活跃分支', () => {
+  it('切换分支后，非活跃分支的消息不进入上下文', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'foliko-branch-'));
+    const sm = new SessionManager(dir, dir, path.join(dir, 's.jsonl'), true);
+    // 主线：user A -> assistant A
+    sm.appendMessage({ role: 'user', content: '问题A' });
+    const branchPointId = sm.appendMessage({ role: 'assistant', content: '回答A' }); // 从这里分叉
+
+    // 继续主线：user B -> assistant B
+    sm.appendMessage({ role: 'user', content: '问题B-主线' });
+    sm.appendMessage({ role: 'assistant', content: '回答B-主线' });
+
+    // 从 branchPoint 开新分支（leafId 回到分叉点，再追加）
+    sm.branch(branchPointId);
+    sm.appendMessage({ role: 'user', content: '问题B-新分支' });
+    sm.appendMessage({ role: 'assistant', content: '回答B-新分支' });
+
+    const texts = sm.getMessages().map(m => (typeof m.content === 'string' ? m.content : '')).join('|');
+    // 活跃分支应包含新分支内容，不含主线的 B
+    expect(texts).toContain('问题B-新分支');
+    expect(texts).not.toContain('问题B-主线');
+    // 共同前缀仍在
+    expect(texts).toContain('问题A');
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});