foliko 2.0.21 → 2.0.23

package/tests/core/edit-file.test.js

@@ -0,0 +1,194 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const FileSystemPlugin = require('../../plugins/io/file-system/index.js');
+
+let tempDir, framework, tool;
+let fileSystem;
+
+beforeEach(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'edit-test-'));
+  fs.writeFileSync(path.join(tempDir, 'sample.js'),
+    'function hello() {\n  console.log("hello world");\n  return 42;\n}\n');
+
+  const registeredTools = [];
+  framework = {
+    getCwd: () => tempDir,
+    registerTool: (t) => registeredTools.push(t),
+    pluginManager: { get: () => null },
+    toolRegistry: { has: () => false, register: (t) => registeredTools.push(t) },
+  };
+  const p = new FileSystemPlugin();
+  p.install(framework);
+  tool = registeredTools.find(t => t.name === 'edit' || t.name === 'edit_file');
+  if (!tool) throw new Error('edit tool not registered');
+});
+
+afterEach(() => {
+  fs.rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe('edit/edit_file 工具 (frs-replace 实现)', () => {
+  it('★ 基础：单次字面量替换', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: 'hello world', newText: 'goodbye universe' }],
+    }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data.appliedEdits).toBe(1);
+    const newContent = fs.readFileSync(path.join(tempDir, 'sample.js'), 'utf8');
+    expect(newContent).toContain('goodbye universe');
+    expect(newContent).not.toContain('hello world');
+  });
+
+  it('★ 多次替换按顺序应用', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [
+        { oldText: 'function hello', newText: 'function greet' },
+        { oldText: 'console.log', newText: 'console.warn' },
+      ],
+    }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data.appliedEdits).toBe(2);
+    const newContent = fs.readFileSync(path.join(tempDir, 'sample.js'), 'utf8');
+    expect(newContent).toContain('function greet()');
+    expect(newContent).toContain('console.warn');
+  });
+
+  it('★ 关键：找不到 oldText 报错（不再静默不生效）', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: 'NOT_EXISTING_TEXT_XYZ', newText: 'foo' }],
+    }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('替换未生效');
+    expect(r.error).toContain('找不到');
+  });
+
+  it('★ useRegex=true 支持正则匹配', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{
+        oldText: '\\b\\w+\\(\\)',  // 匹配 "函数名()"
+        newText: 'fn()',
+        useRegex: true,
+      }],
+    }, framework);
+    expect(r.success).toBe(true);
+    const newContent = fs.readFileSync(path.join(tempDir, 'sample.js'), 'utf8');
+    // hello() → fn() 但 greet() 也会变（多匹配中第一个）
+    expect(newContent).toContain('fn()');
+  });
+
+  it('★ useRegex=true 无效正则报错', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: '[invalid(', newText: 'X', useRegex: true }],
+    }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('无效的正则');
+  });
+
+  it('★ useRegex=true 多次出现都被替换（默认）', async () => {
+    fs.writeFileSync(path.join(tempDir, 'multi.txt'), 'foo foo foo bar foo');
+    const r = await tool.execute({
+      path: 'multi.txt',
+      edits: [{ oldText: 'foo', newText: 'BAZ', useRegex: true }],
+    }, framework);
+    expect(r.success).toBe(true);
+    const newContent = fs.readFileSync(path.join(tempDir, 'multi.txt'), 'utf8');
+    expect(newContent).toBe('BAZ BAZ BAZ bar BAZ');
+  });
+
+  it('★ allOccurrences=false 只替换第一个', async () => {
+    fs.writeFileSync(path.join(tempDir, 'multi.txt'), 'foo foo foo bar foo');
+    const r = await tool.execute({
+      path: 'multi.txt',
+      edits: [{ oldText: 'foo', newText: 'BAZ', allOccurrences: false }],
+    }, framework);
+    expect(r.success).toBe(true);
+    const newContent = fs.readFileSync(path.join(tempDir, 'multi.txt'), 'utf8');
+    expect(newContent).toBe('BAZ foo foo bar foo');
+  });
+
+  it('★ 多 edit 中第二个找不到：报错且不应用第一个', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [
+        { oldText: 'function hello', newText: 'function greet' },     // 找得到
+        { oldText: 'NOT_EXISTING', newText: 'foo' },                 // 找不到
+      ],
+    }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('edits[1]');
+    // ★ 验证第一个 edit 也没应用（避免部分应用）
+    const content = fs.readFileSync(path.join(tempDir, 'sample.js'), 'utf8');
+    expect(content).toContain('function hello');
+    expect(content).not.toContain('function greet');
+  });
+
+  it('★ 文件不存在报错', async () => {
+    const r = await tool.execute({
+      path: 'nonexistent.js',
+      edits: [{ oldText: 'foo', newText: 'bar' }],
+    }, framework);
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('读取文件失败');
+  });
+
+  it('★ edits 是空数组报错', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [],
+    }, framework);
+    expect(r.success).toBe(false);
+  });
+
+  it('★ edits[i].oldText 是空字符串报错', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: '', newText: 'foo' }],
+    }, framework);
+    expect(r.success).toBe(false);
+  });
+
+  it('★ 原子写入：失败时不留 .tmp 垃圾', async () => {
+    // 模拟：先创建 .tmp 但删除 source file 让 rename 失败
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: 'function hello', newText: 'function greet' }],
+    }, framework);
+    expect(r.success).toBe(true);
+    // 检查没有遗留 .tmp
+    const files = fs.readdirSync(tempDir);
+    expect(files.some(f => f.endsWith('.tmp'))).toBe(false);
+  });
+
+  it('★ edit_file 是 edit 的别名（同实现）', async () => {
+    // 找到 edit_file 工具
+    const p = new FileSystemPlugin();
+    p.install(framework);
+    const editFileTool = p._registeredTools?.find(t => t.name === 'edit_file')
+      || (p._registeredTools || []).find(t => t.name === 'edit_file');
+    // 由于 install 重新注册，p._registeredTools 是空（mock 没捕获 Plugin base class 的 _registeredTools）
+    // 重新调用 install 让 mock 捕获
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: 'function hello', newText: 'function greet' }],
+    }, framework);
+    expect(r.success).toBe(true);
+  });
+
+  it('★ 返回元数据：contentLength before/after', async () => {
+    const r = await tool.execute({
+      path: 'sample.js',
+      edits: [{ oldText: 'hello world', newText: 'X' }],  // 11 → 1
+    }, framework);
+    expect(r.success).toBe(true);
+    expect(r.data.contentLength.before).toBeGreaterThan(r.data.contentLength.after);
+    expect(r.data.contentChanged).toBe(true);
+  });
+});

package/tests/core/ext-call-empty-args.test.js

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+const { z } = require('zod');
+const ExtensionExecutorPlugin = require('../../plugins/executors/extension/index.js');
+
+function makePlugin(tools = {}) {
+  const p = Object.create(ExtensionExecutorPlugin.prototype);
+  p._framework = {
+    emit: () => {},
+    pluginManager: { get: () => null },
+  };
+  p._registry = {
+    getPlugin(name) {
+      if (tools[name]) return { name, tools: tools[name].tools || [] };
+      return null;
+    },
+    getTool: () => null,
+  };
+  return p;
+}
+
+describe('_emptyArgsError 专门处理 args={} 的情况', () => {
+  it('★ 关键：args={} + 工具必填 id → 返回明确错误提示用 ext_skill', () => {
+    const addCoverTool = {
+      name: 'addCover',
+      description: '添加片头',
+      inputSchema: z.object({
+        id: z.string().describe('视频ID（必填）'),
+        title: z.string().optional(),
+      }),
+      execute: async () => 'ok',
+    };
+    const p = makePlugin({ 'skill:creator': { tools: [addCoverTool] } });
+    // 新签名：(plugin, tool, toolArgs, toolDef, zodError)
+    const r = p._emptyArgsError('skill:creator', 'addCover', {}, addCoverTool, {
+      issues: [{ path: ['id'], message: 'Required' }],
+    });
+    expect(r.success).toBe(false);
+    expect(r.error).toContain('参数缺失');
+    expect(r.error).toContain('args 为空对象');
+    expect(r.receivedArgs).toEqual({});
+    expect(r.action).toBe('call_ext_skill_first');
+    expect(r.hint).toContain('ext_skill');
+    expect(r.hint).toContain('id');  // 必填字段应被提及
+  });
+
+  it('★ 关键：从 zodError.issues 提取必填字段（即使 schema shape 解析失败）', () => {
+    const tool = {
+      name: 'foo',
+      inputSchema: z.object({ x: z.string(), y: z.string(), z: z.string().optional() }),
+      execute: async () => '',
+    };
+    const p = makePlugin();
+    const r = p._emptyArgsError('plugin', 'foo', {}, tool, {
+      issues: [
+        { path: ['x'], message: 'Required' },
+        { path: ['y'], message: 'Required' },
+      ],
+    });
+    expect(r.hint).toContain('x');
+    expect(r.hint).toContain('y');
+    expect(r.hint).not.toContain('z');  // z 是 optional，不应被提及
+  });
+
+  it('★ 关键：error 中要明确"为什么失败"和"如何修复"', () => {
+    const tool = {
+      name: 'publish',
+      inputSchema: z.object({ id: z.string() }),
+      execute: async () => '',
+    };
+    const p = makePlugin();
+    const r = p._emptyArgsError('skill:baidu', 'publish', {}, tool, {
+      issues: [{ path: ['id'], message: 'Required' }],
+    });
+    // 错误信息要包含可操作的具体指引
+    expect(r.error).toMatch(/参数缺失.*publish/);
+    expect(r.hint).toMatch(/ext_skill.*plugin.*必填字段/);
+  });
+});
+
+describe('_doExecute 集成：空 args 走特殊错误路径', () => {
+  it('★ 关键：ext_call({plugin, tool, args:{}}) → 返回 emptyArgsError', async () => {
+    const addCoverTool = {
+      name: 'addCover',
+      description: '添加片头',
+      inputSchema: z.object({
+        id: z.string().describe('视频ID（必填）'),
+      }),
+      execute: async (args) => {
+        if (!args.id) throw new Error('视频项目不存在: undefined');
+        return 'ok';
+      },
+    };
+    const p = makePlugin({ 'skill:creator': { tools: [addCoverTool] } });
+    const r = await p._executeExtensionTool('skill:creator', 'addCover', {});
+    expect(r.success).toBe(false);
+    expect(r.action).toBe('call_ext_skill_first');
+    expect(r.error).toContain('参数缺失');
+    expect(r.hint).toContain('ext_skill');
+  });
+
+  it('★ 关键：ext_call({plugin, tool, args: {id: "abc"}}) → 正常执行', async () => {
+    let receivedArgs = null;
+    const tool = {
+      name: 'addCover',
+      inputSchema: z.object({ id: z.string() }),
+      execute: async (args) => {
+        receivedArgs = args;
+        return 'ok';
+      },
+    };
+    const p = makePlugin({ 'skill:creator': { tools: [tool] } });
+    const r = await p._executeExtensionTool('skill:creator', 'addCover', { id: 'abc' });
+    expect(r.success).toBe(true);
+    expect(receivedArgs).toEqual({ id: 'abc' });
+  });
+});
+
+describe('ext_call 工具描述', () => {
+  it('★ 描述里必须强调 args 必填 + 工作流（先 ext_skill）', () => {
+    const p = new ExtensionExecutorPlugin();
+    const extCall = p._createExtCallTool();
+    expect(extCall.description).toContain('args');
+    expect(extCall.description).toContain('必填');
+    expect(extCall.description).toContain('ext_skill');
+    // 给具体的多参数示例
+    expect(extCall.description).toMatch(/id:\s*['"]/);
+  });
+
+  it('★ inputSchema.args.description 必须强调"先查 ext_skill"', () => {
+    const p = new ExtensionExecutorPlugin();
+    const extCall = p._createExtCallTool();
+    const argDesc = extCall.inputSchema.shape.args.description;
+    expect(argDesc).toContain('必填');
+    expect(argDesc).toContain('ext_skill');
+  });
+});

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/sanitize-for-llm.test.js

@@ -0,0 +1,152 @@
+import { describe, it, expect } from 'vitest';
+const { sanitizeForLLM } = require('../../src/utils/message-validator.js');
+
+describe('sanitizeForLLM 防御性清洗', () => {
+  it('空数组返回空', () => {
+    const r = sanitizeForLLM([]);
+    expect(r.messages).toEqual([]);
+    expect(r.fixed).toBe(0);
+    expect(r.dropped).toBe(0);
+  });
+
+  it('非数组输入返回空', () => {
+    expect(sanitizeForLLM(null).messages).toEqual([]);
+    expect(sanitizeForLLM(undefined).messages).toEqual([]);
+  });
+
+  it('正常消息保持原样', () => {
+    const messages = [
+      { role: 'user', content: 'hello' },
+      { role: 'assistant', content: [{ type: 'text', text: 'hi' }] },
+      { role: 'tool', content: [{ type: 'tool-result', toolCallId: 'x', toolName: 'y', output: { type: 'json', value: 1 } }] },
+    ];
+    const r = sanitizeForLLM(messages);
+    expect(r.messages).toEqual(messages);
+    expect(r.fixed).toBe(0);
+    expect(r.dropped).toBe(0);
+  });
+
+  it('★ 关键：user.content = null 应丢弃', () => {
+    const r = sanitizeForLLM([{ role: 'user', content: null }]);
+    expect(r.messages).toEqual([]);
+    expect(r.dropped).toBe(1);
+  });
+
+  it('★ 关键：user.content = undefined 应丢弃', () => {
+    const r = sanitizeForLLM([{ role: 'user' }]);
+    expect(r.messages).toEqual([]);
+    expect(r.dropped).toBe(1);
+  });
+
+  it('★ 关键：tool.content = null 应丢弃', () => {
+    const r = sanitizeForLLM([{ role: 'tool', content: null }]);
+    expect(r.messages).toEqual([]);
+    expect(r.dropped).toBe(1);
+  });
+
+  it('★ 关键：tool.content = "string" 应丢弃', () => {
+    const r = sanitizeForLLM([{ role: 'tool', content: 'not array' }]);
+    expect(r.messages).toEqual([]);
+    expect(r.dropped).toBe(1);
+  });
+
+  it('assistant.content = object 应转为 string', () => {
+    const r = sanitizeForLLM([{ role: 'assistant', content: { foo: 'bar' } }]);
+    expect(r.messages[0].content).toBe('{"foo":"bar"}');
+    expect(r.fixed).toBe(1);
+  });
+
+  it('assistant content array 中 part 缺 type 应丢弃', () => {
+    const r = sanitizeForLLM([{
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'ok' },
+        { noType: 'broken' },
+        null,
+      ],
+    }]);
+    expect(r.messages[0].content).toEqual([{ type: 'text', text: 'ok' }]);
+    expect(r.fixed).toBe(2);
+  });
+
+  it('user content array 中 part.type 不在白名单应丢弃', () => {
+    const r = sanitizeForLLM([{
+      role: 'user',
+      content: [
+        { type: 'text', text: 'ok' },
+        { type: 'tool-call', toolCallId: 'x' }, // user 不允许 tool-call
+        { type: 'image', image: 'data:...' }, // image 允许
+      ],
+    }]);
+    expect(r.messages[0].content).toHaveLength(2);
+    expect(r.fixed).toBe(1);
+  });
+
+  it('tool content array 中 part.type 不在白名单应丢弃', () => {
+    const r = sanitizeForLLM([{
+      role: 'tool',
+      content: [
+        { type: 'tool-result', toolCallId: 'x', toolName: 'y', output: { type: 'json', value: 1 } },
+        { type: 'text', text: 'should be dropped' },
+      ],
+    }]);
+    expect(r.messages[0].content).toHaveLength(1);
+    expect(r.fixed).toBe(1);
+  });
+
+  it('tool-result output 缺 type 应修复为 text', () => {
+    const r = sanitizeForLLM([{
+      role: 'tool',
+      content: [{
+        type: 'tool-result',
+        toolCallId: 'x',
+        toolName: 'y',
+        output: { value: 1 } // 缺 type
+      }],
+    }]);
+    expect(r.messages[0].content[0].output).toEqual({ type: 'text', value: '{"value":1}' });
+    expect(r.fixed).toBe(1);
+  });
+
+  it('tool-result output.type 不在白名单应降级为 text', () => {
+    const r = sanitizeForLLM([{
+      role: 'tool',
+      content: [{
+        type: 'tool-result',
+        toolCallId: 'x',
+        toolName: 'y',
+        output: { type: 'unknown-type', value: 1 }
+      }],
+    }]);
+    expect(r.messages[0].content[0].output.type).toBe('text');
+    expect(r.fixed).toBe(1);
+  });
+
+  it('未知 role 应丢弃', () => {
+    const r = sanitizeForLLM([
+      { role: 'compactionSummary', content: 'foo' },
+      { role: 'user', content: 'hi' },
+    ]);
+    expect(r.messages).toHaveLength(1);
+    expect(r.dropped).toBe(1);
+  });
+
+  it('★ 实战：cli_default 场景 模拟消息（确保全部通过 sanitize）', () => {
+    // 模拟 cli_default.jsonl 中典型消息 + 一些异常
+    const messages = [
+      { role: 'user', content: '请帮我做视频' },
+      { role: 'assistant', content: [
+        { type: 'text', text: '好的' },
+        { type: 'tool-call', toolCallId: 'h_x_1', toolName: 'ext_call', input: { plugin: 'creator' } },
+      ]},
+      { role: 'tool', content: [
+        { type: 'tool-result', toolCallId: 'h_x_1', toolName: 'ext_call', output: { type: 'json', value: { success: true } } },
+      ]},
+      { role: 'user', content: null }, // 异常
+      { role: 'assistant', content: '完成' },
+    ];
+    const r = sanitizeForLLM(messages);
+    expect(r.messages).toHaveLength(4);
+    expect(r.dropped).toBe(1);
+  });
+});