minimal-agent 0.12.0 → 0.14.0

package/plugins/workflow-runner/test/agent.test.ts

@@ -1,587 +0,0 @@
-/**
- * ============================================================
- *  plugins/workflow-runner/test/agent.test.ts —— agent: 节点（受工作流指导的有界 TAOR）
- * ------------------------------------------------------------
- *  验证「节点级 agency 旋钮」：
- *    - agent 节点完成任务 → capture 绑定 → workflow 继续到 done；step kind 报 'agent'
- *    - agent 显式放弃（__AGENT_GIVEUP__）→ 抛错 → 默认 halt（带原因）
- *    - agent 放弃 + onError:recover → 恢复 agent 再救回 → 继续到 done（机制与其它动作 step 一致）
- *    - agent + output_schema → 结构化产出按字段 capture
- *    - agent + allowed_tools → 只把白名单工具下发给 LLM
- *
- *  策略（同 recovery.test.ts）：agent 节点底层经 execAgentStep → runMiniReAct → chat，
- *  mock client.js 控制其输出。
- * ============================================================
- */
-
-import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.js';
-import type { LoopEvent, Provider } from '../../../src/types.js';
-import { ALL_TOOLS } from '../../../src/tools/index.js';
-import { runWorkflow } from '../src/runner.js';
-import type { RunContext, WorkflowDef, WorkflowEvent } from '../src/types.js';
-import { interpretMiniReActResult, parseGiveup, GIVEUP_MARKER } from '../src/agentCommon.js';
-import type { StepResult } from '../src/types.js';
-
-type WfOrLoop = WorkflowEvent | LoopEvent;
-
-const fakeProvider: Provider = {
-  name: 'test',
-  baseURL: '',
-  apiKey: '',
-  model: 'm',
-  contextWindow: 128000,
-};
-
-async function collect(
-  gen: AsyncGenerator<WfOrLoop, void, void>,
-): Promise<WfOrLoop[]> {
-  const out: WfOrLoop[] = [];
-  for await (const ev of gen) out.push(ev);
-  return out;
-}
-
-describe('workflows/agent (agent: 节点)', () => {
-  let tmp: string;
-  let ctx: RunContext;
-
-  beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), 'wf-agent-'));
-    process.env.MINIMAL_AGENT_CWD = tmp;
-    _resetWorkingDir();
-    mock.module('../../../src/bootstrap/workingDir.js', () => ({
-      getWorkingDir: () => tmp,
-      initWorkingDir: () => tmp,
-      _resetWorkingDir: () => {},
-    }));
-    ctx = { provider: fakeProvider, history: [], cwd: tmp, tools: ALL_TOOLS };
-  });
-
-  afterEach(() => {
-    delete process.env.MINIMAL_AGENT_CWD;
-    _resetWorkingDir();
-    rmSync(tmp, { recursive: true, force: true });
-  });
-
-  it('agent 节点完成任务 → capture 绑定 → workflow 跑完；kind 报 agent', async () => {
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* () {
-        yield { type: 'text_delta', delta: 'csv-summary-ok' };
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-ok',
-      description: '把任务交给 agent 自主完成',
-      steps: [
-        { id: 'a1', agent: '把 data 转成 summary', capture: { content: 'out' } },
-        { id: 'check', type: 'assert', condition: 'out == "csv-summary-ok"' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    expect(events.some((e) => e.type === 'error')).toBe(false);
-    const a1Start = events.find(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_start' }> =>
-        e.type === 'workflow_step_start' && e.id === 'a1',
-    );
-    expect(a1Start?.kind).toBe('agent');
-    const a1End = events.find(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> =>
-        e.type === 'workflow_step_end' && e.id === 'a1',
-    );
-    expect(a1End?.ok).toBe(true);
-  });
-
-  it('agent 显式放弃（GIVEUP）→ 默认 halt 且错误带原因', async () => {
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* () {
-        yield { type: 'text_delta', delta: '__AGENT_GIVEUP__: 任务无法完成' };
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-giveup',
-      description: 'agent 放弃则 halt',
-      steps: [
-        { id: 'a1', agent: '做不到的事' },
-        { id: 'after', type: 'assert', condition: 'true' }, // 不应执行
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
-    const err = events.find(
-      (e): e is { type: 'error'; error: string } => e.type === 'error',
-    );
-    expect(err).toBeDefined();
-    expect(err!.error).toContain('任务无法完成'); // 放弃原因透传进 halt 文案
-    const startedIds = events
-      .filter(
-        (e): e is Extract<WorkflowEvent, { type: 'workflow_step_start' }> =>
-          e.type === 'workflow_step_start',
-      )
-      .map((e) => e.id);
-    expect(startedIds).not.toContain('after');
-  });
-
-  it('agent 放弃 + onError:recover → 恢复 agent 再救回 → 继续到 done', async () => {
-    // 第 1 次 chat（agent 节点）放弃；第 2 次 chat（recover）给真结果。
-    let call = 0;
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* () {
-        call++;
-        yield {
-          type: 'text_delta',
-          delta: call === 1 ? '__AGENT_GIVEUP__: 先放弃' : 'rescued-value',
-        };
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-recover',
-      description: 'agent 放弃后被 recover 救回',
-      steps: [
-        {
-          id: 'a1',
-          agent: '困难任务',
-          onError: 'recover',
-          capture: { content: 'out' },
-        },
-        { id: 'check', type: 'assert', condition: 'out == "rescued-value"' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    expect(events.some((e) => e.type === 'error')).toBe(false);
-    expect(
-      events.some((e) => e.type === 'warning' && e.message.includes('自适应恢复')),
-    ).toBe(true);
-    const a1End = events.find(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> =>
-        e.type === 'workflow_step_end' && e.id === 'a1',
-    );
-    expect(a1End?.ok).toBe(true);
-    expect(a1End?.output).toContain('recovered');
-  });
-
-  it('agent + output_schema → 结构化产出按字段 capture', async () => {
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* () {
-        yield { type: 'text_delta', delta: '{"title":"T","score":9}' };
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-schema',
-      description: 'agent 结构化产出',
-      steps: [
-        {
-          id: 'a1',
-          agent: '评估并给结构化结果',
-          output_schema: {
-            type: 'object',
-            properties: { title: { type: 'string' }, score: { type: 'number' } },
-            required: ['title', 'score'],
-          },
-          // v0.9 后 agent 步委托 runQuery(TAOR) 执行，schema 模式下 raw 结果暂为
-          // { text, result, content } 三键别名（与 llm 步的 JSON 解析行为不同）。
-          // 此处先用 result（完整 JSON 文本）做 capture，待 agent.ts 对齐 llm.ts 的
-          // extractJsonPayload + JSON.parse 后可恢复字段级 capture: { title: 'the_title' }。
-          capture: { result: 'the_title' },
-        },
-        // result 字段包含模型返回的完整 JSON 文本，验证 capture 绑定了非空值
-        { id: 'check', type: 'assert', condition: 'length(the_title) > 0' },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    expect(events.some((e) => e.type === 'error')).toBe(false);
-  });
-
-  it('agent + allowed_tools → 只把白名单工具下发给 LLM', async () => {
-    let seenTools: string[] = [];
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* (args: { tools?: { name: string }[] }) {
-        seenTools = (args.tools ?? []).map((t) => t.name);
-        yield { type: 'text_delta', delta: 'ok' };
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-allowed',
-      description: 'agent 工具收窄',
-      steps: [
-        { id: 'a1', agent: '只用 Read', allowed_tools: ['Read'], capture: { content: 'out' } },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    expect(seenTools).toEqual(['Read']);
-  });
-
-  it('流式：agent 节点把 text 与 tool_start/tool_end 事件透传到 runWorkflow', async () => {
-    // 第 1 轮发起一个工具调用（Glob），第 2 轮给最终文本收尾。
-    // 验证 miniReAct 的事件经 execAgentStep → dispatchActionStep → runWorkflow 一路 yield 出来。
-    let call = 0;
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* () {
-        call++;
-        if (call === 1) {
-          yield {
-            type: 'tool_call_delta',
-            index: 0,
-            id: 'tc1',
-            name: 'Glob',
-            argumentsDelta: '{"pattern":"*"}',
-          };
-          yield { type: 'done', stopReason: 'tool_calls' };
-        } else {
-          yield { type: 'text_delta', delta: 'done-streaming' };
-          yield { type: 'done', stopReason: 'stop' };
-        }
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-stream',
-      description: '验证 agent 节点事件流式透传',
-      steps: [{ id: 'a1', agent: '先用工具看看再答', capture: { content: 'out' } }],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 流式透传：text + tool_start(Glob) + tool_end(Glob) 都应出现在事件流里
-    expect(events.some((e) => e.type === 'text')).toBe(true);
-    expect(
-      events.some((e) => e.type === 'tool_start' && e.toolName === 'Glob'),
-    ).toBe(true);
-    expect(
-      events.some((e) => e.type === 'tool_end' && e.toolName === 'Glob'),
-    ).toBe(true);
-    // stage_change 透传：thinking（每轮）/ tool_executing（轮1有工具）/ streaming（轮2有文本）。
-    // 缺它们时 TUI LiveArea 在 idle 整块隐藏，上面 text/tool 事件发了也看不见（本轮修复点）。
-    const stages = events
-      .filter(
-        (e): e is Extract<LoopEvent, { type: 'stage_change' }> =>
-          e.type === 'stage_change',
-      )
-      .map((e) => e.stage);
-    expect(stages).toContain('thinking');
-    expect(stages).toContain('tool_executing');
-    expect(stages).toContain('streaming');
-  });
-
-  it('done_when 满足优先：Write 已落盘但最终无文本输出 → workflow 成功', async () => {
-    let call = 0;
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* () {
-        call++;
-        if (call === 1) {
-          yield {
-            type: 'tool_call_delta',
-            index: 0,
-            id: 'write-draft',
-            name: 'Write',
-            argumentsDelta: '{"file_path":"./build/draft.md","content":"# 深度稿件\\n\\n已经落盘"}',
-          };
-          yield { type: 'done', stopReason: 'tool_calls' };
-          return;
-        }
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-done-when-empty-final',
-      description: 'done_when 是强验收条件',
-      steps: [
-        {
-          id: 'stage_research',
-          agent: '写 draft.md',
-          done_when: "fileExists('./build/draft.md')",
-          capture: { content: 'report' },
-        },
-        { id: 'check', type: 'assert', condition: 'includes(report, "完成条件已满足")' },
-      ],
-    };
-
-    const events = await collect(runWorkflow(def, {}, ctx));
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    expect(existsSync(join(tmp, 'build/draft.md'))).toBe(true);
-    expect(readFileSync(join(tmp, 'build/draft.md'), 'utf8')).toContain('已经落盘');
-    expect(events.some((e) => e.type === 'error')).toBe(false);
-  });
-
-  it('done_when 未满足时不因空产出直接放弃：nudge 后 Write 落盘 → workflow 成功', async () => {
-    let call = 0;
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* () {
-        call++;
-        if (call === 1) {
-          yield { type: 'text_delta', delta: '我现在创建目录并开始写稿。' };
-          yield { type: 'done', stopReason: 'stop' };
-          return;
-        }
-        if (call === 2) {
-          yield {
-            type: 'tool_call_delta',
-            index: 0,
-            id: 'write-after-nudge',
-            name: 'Write',
-            argumentsDelta: '{"file_path":"./build/draft.md","content":"# 被 nudge 后真正写入"}',
-          };
-          yield { type: 'done', stopReason: 'tool_calls' };
-          return;
-        }
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-done-when-nudge',
-      description: '宣告不算完成',
-      steps: [
-        {
-          id: 'stage_research',
-          agent: '写 draft.md',
-          done_when: "fileExists('./build/draft.md')",
-        },
-      ],
-    };
-
-    const events = await collect(runWorkflow(def, {}, ctx));
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    expect(existsSync(join(tmp, 'build/draft.md'))).toBe(true);
-    expect(
-      events.some(
-        (e) => e.type === 'warning' && e.message.includes('完成条件未满足'),
-      ),
-    ).toBe(true);
-  });
-
-  it('done_when 多轮仍不满足 → halt 归因为完成条件未满足，而不是没有产出任何结果', async () => {
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* () {
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-done-when-exhaust',
-      description: '空答不落盘',
-      steps: [
-        {
-          id: 'stage_research',
-          agent: '写 draft.md',
-          done_when: "fileExists('./build/draft.md')",
-        },
-      ],
-    };
-
-    const events = await collect(runWorkflow(def, {}, ctx));
-    const halt = events.find(
-      (e) => e.type === 'error' && e.error.includes('Workflow halted'),
-    ) as { type: 'error'; error: string } | undefined;
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
-    expect(halt).toBeDefined();
-    expect(halt!.error).toContain('完成条件未满足');
-    expect(halt!.error).not.toContain('没有产出任何结果');
-    expect(halt!.error).toContain('没有观察到工具调用');
-  });
-
-  it('没有 done_when 的 agent 空输出仍按没有产出任何结果失败', async () => {
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* () {
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-empty-no-done-when',
-      description: '旧语义保持',
-      steps: [{ id: 'a1', agent: '做点事' }],
-    };
-
-    const events = await collect(runWorkflow(def, {}, ctx));
-    const halt = events.find(
-      (e) => e.type === 'error' && e.error.includes('Workflow halted'),
-    ) as { type: 'error'; error: string } | undefined;
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
-    expect(halt).toBeDefined();
-    expect(halt!.error).toContain('没有产出任何结果');
-  });
-
-  it('agent + output_schema → 不把 JSON 原文当 text 流式回显（对齐 llm.ts 克制）', async () => {
-    mock.module('../../../src/llm/client.js', () => ({
-      chat: async function* () {
-        yield { type: 'text_delta', delta: '{"k":"v"}' };
-        yield { type: 'done', stopReason: 'stop' };
-      },
-    }));
-
-    const def: WorkflowDef = {
-      name: 'agent-schema-silent',
-      description: 'schema 模式不刷 JSON',
-      steps: [
-        {
-          id: 'a1',
-          agent: '产出结构化结果',
-          output_schema: {
-            type: 'object',
-            properties: { k: { type: 'string' } },
-            required: ['k'],
-          },
-          capture: { k: 'out' },
-        },
-      ],
-    };
-    const events = await collect(runWorkflow(def, {}, ctx));
-
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // v0.9 后 agent 步委托 runQuery(TAOR) 执行，text_delta 自然透传为 text 事件（不再像旧
-    // miniReAct 那样在 schema 模式下抑制 text 回显）。schema 约束通过 prompt 嵌入传达给模型，
-    // 但事件流仍会包含原始文本。
-    expect(events.some((e) => e.type === 'text')).toBe(true);
-    const stages = events
-      .filter(
-        (e): e is Extract<LoopEvent, { type: 'stage_change' }> =>
-          e.type === 'stage_change',
-      )
-      .map((e) => e.stage);
-    expect(stages).toContain('streaming');
-  });
-});
-
-// ============================================================
-//  interpretMiniReActResult 单元测试（GIVEUP 标记 + 误报过滤）
-// ============================================================
-
-describe('workflows/agent::GIVEUP 标记检测与误报过滤', () => {
-  function makeStepResult(text: string): StepResult {
-    return { raw: { text, result: text }, preview: text.slice(0, 200) };
-  }
-
-  it('新标记 [wf-internal-abort-do-not-generate] 被正确识别为放弃', () => {
-    const r = interpretMiniReActResult(makeStepResult(`一些前文\n[wf-internal-abort-do-not-generate]: 任务太复杂`), false);
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.reason).toBe('任务太复杂');
-  });
-
-  it('旧标记 __AGENT_GIVEUP__ 向后兼容（仍被识别）', () => {
-    const r = interpretMiniReActResult(makeStepResult(`前文\n__AGENT_GIVEUP__: 无法完成`), false);
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.reason).toContain('无法完成');
-  });
-
-  it('无任何标记 → 正常交付', () => {
-    const r = interpretMiniReActResult(makeStepResult('这是正常的工作成果输出'), false);
-    expect(r.ok).toBe(true);
-    if (r.ok) expect(r.value.raw.text).toBe('这是正常的工作成果输出');
-  });
-
-  it('误报防护：reason > 80 字符 → 降级为成功交付（去掉标记后的内容）', () => {
-    // 模拟用户遇到的场景：LLM 输出中碰巧包含旧标记，后面跟着大量实质内容
-    const longContent = 'since I did the work and have findings. I\'ll output the research report directly.\n\n## 代码探索报告\n\n### 相关文件\n- src/main.ts\n- src/loop.ts\n\n### 现有架构概要\n三层结构设计...';
-    const r = interpretMiniReActResult(makeStepResult(`前序分析完成。\n__AGENT_GIVEUP__: ${longContent}`), false);
-    expect(r.ok).toBe(true); // 关键：不被判为放弃！
-    if (r.ok) {
-      expect(r.value.raw.text).toContain('代码探索报告');
-      expect(r.value.raw.text).not.toContain('__AGENT_GIVEUP__'); // 标记已被清除
-    }
-  });
-
-  it('误报防护降级时标记出现多次 → 全部清除不残留（replaceAll）', () => {
-    // LLM 在长输出中误触发标记两次（新旧各一）：降级为成功后，
-    // cleanText 不应残留任何标记（replace 只删首个的回归锚）
-    const r = interpretMiniReActResult(
-      makeStepResult(
-        `[wf-internal-abort-do-not-generate]: ## 研究报告\n\n### 发现1\n内容…\n__AGENT_GIVEUP__\n更多内容\n[wf-internal-abort-do-not-generate]`,
-      ),
-      false,
-    );
-    expect(r.ok).toBe(true); // 含 ## 标题 → 误报降级为成功
-    if (r.ok) {
-      expect(r.value.raw.text).not.toContain('[wf-internal-abort-do-not-generate]');
-      expect(r.value.raw.text).not.toContain('__AGENT_GIVEUP__');
-      expect(r.value.raw.text).toContain('研究报告');
-    }
-  });
-
-  it('误报防护：reason 包含 markdown 标题（##）→ 视为误报', () => {
-    const r = interpretMiniReActResult(
-      makeStepResult(`工作完成。\n[wf-internal-abort-do-not-generate]: ## 研究报告\n\n### 发现1\n内容...`),
-      false,
-    );
-    expect(r.ok).toBe(true); // 含 ## 标题 → 误报
-    if (r.ok) expect(r.value.raw.text).toContain('研究报告');
-  });
-
-  it('误报防护：reason 包含 markdown 列表项（- ）→ 视为误报', () => {
-    const r = interpretMiniReActResult(
-      makeStepResult(`[wf-internal-abort-do-not-generate]: - 发现 A\n- 发现 B\n- 发现 C`),
-      false,
-    );
-    expect(r.ok).toBe(true); // 含列表项 → 误报
-  });
-
-  it('真正放弃：reason 短且无结构化内容 → 仍判为放弃', () => {
-    const r = interpretMiniReActResult(
-      makeStepResult(`[wf-internal-abort-do-not-generate]: 无法访问数据库`),
-      false,
-    );
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.reason).toBe('无法访问数据库');
-  });
-
-  it('真正放弃：reason 为空字符串 → 显示默认原因', () => {
-    const r = interpretMiniReActResult(makeStepResult('结束[wf-internal-abort-do-not-generate]'), false);
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.reason).toBe('显式放弃（未给原因）');
-  });
-
-  it('schema 模式不受 GIVEUP 影响（schema 走独立解析路径）', () => {
-    const r = interpretMiniReActResult(
-      makeStepResult('{"result": "ok"}\n[wf-internal-abort-do-not-generate]: 假放弃'),
-      true, // hasSchema=true
-    );
-    expect(r.ok).toBe(true); // schema 模式不检查 GIVEUP
-  });
-
-  it('空产出 → 放弃（非 GIVEUP，而是没有结果）', () => {
-    const r = interpretMiniReActResult(makeStepResult(''), false);
-    expect(r.ok).toBe(false);
-    if (!r.ok) expect(r.reason).toBe('没有产出任何结果');
-  });
-
-  it('parseGiveup 新标记优先于旧标记（新标记先出现时）', () => {
-    // 新标记先出现 → 应取新标记后的内容（到字符串末尾，包含后续旧标记文本）
-    const text = `文本\n[wf-internal-abort-do-not-generate]: 新原因\n更多文本 __AGENT_GIVEUP__: 旧原因`;
-    const reason = parseGiveup(text);
-    // parseGiveup 返回标记后的全部内容（不截断到下一个标记）
-    expect(reason).toContain('新原因'); // 至少以新原因开头
-    expect(reason).not.toContain('[wf-internal-abort-do-not-generate]'); // 标记本身不在 reason 中
-  });
-
-  it('parseGiveup 旧标记兜底（只有旧标记时）', () => {
-    const reason = parseGiveup('一些文字 __AGENT_GIVEUP__: 只有旧标记');
-    expect(reason).toBe('只有旧标记');
-  });
-});