minimal-agent 0.13.0 → 0.15.0

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

@@ -1,33 +0,0 @@
-/**
- * test/maxTurnsRetryDelay.test.ts
- * ------------------------------------------------------------
- * 锁定 self_heal in-run retry 的延时分类契约：
- *   - maxTurns 截断默认仍立即续跑（兼容旧行为），但可由
- *     self_heal.max_turns_retry_delay_ms 单独配置等待。
- *   - 网络/LLM 错误 = 瞬态故障，仍走 retry_delay_ms 退避。
- *
- * 测 producer(describeMaxTurnsCutoff)/detector(isMaxTurnsCutoff) 同源契约，
- * 以及网络类报错不被误判为 maxTurns（否则退避失效、撞同一拥塞波）。
- */
-
-import { describe, expect, it } from 'bun:test';
-
-import {
-  MAX_TURNS_CUTOFF_MARKER,
-  describeMaxTurnsCutoff,
-  isMaxTurnsCutoff,
-} from '../src/agentCommon.js';
-
-describe('maxTurns 截断的重试延时分类', () => {
-  it('describeMaxTurnsCutoff 的文案能被 isMaxTurnsCutoff 识别（同源契约）', () => {
-    expect(isMaxTurnsCutoff(describeMaxTurnsCutoff('stage0_clarify', 8))).toBe(true);
-    expect(describeMaxTurnsCutoff('x', 8)).toContain(MAX_TURNS_CUTOFF_MARKER);
-  });
-
-  it('网络/LLM 类报错不被误判为 maxTurns（仍需退避）', () => {
-    expect(isMaxTurnsCutoff('Unable to connect to api.minimax.chat')).toBe(false);
-    expect(isMaxTurnsCutoff('LLM 调用失败：HTTP 429 Too Many Requests')).toBe(false);
-    expect(isMaxTurnsCutoff('step foo: 工具执行失败')).toBe(false);
-    expect(isMaxTurnsCutoff('')).toBe(false);
-  });
-});

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

@@ -1,342 +0,0 @@
-/**
- * workflow-runner 多模态输入测试：
- * llm / agent 步骤声明 images 后，应通过 runQuery 进入 OpenAI 兼容 content blocks。
- */
-
-import { describe, expect, it } from 'bun:test';
-
-import { ALL_TOOLS } from '../../../src/tools/index.js';
-import type {
-  ChatContentPart,
-  LlmStreamEvent,
-  Message,
-  Provider,
-  Tool,
-} from '../../../src/types.js';
-import { execAgentStep } from '../src/stepExecutors/agent.js';
-import { execLlmStep } from '../src/stepExecutors/llm.js';
-import { VarStack } from '../src/types.js';
-import type { RunContext, StepDef } from '../src/types.js';
-
-const provider: Provider = {
-  name: 'test',
-  baseURL: 'https://example.test/v1',
-  apiKey: 'test',
-  model: 'fake',
-  contextWindow: 128_000,
-};
-
-async function drain<R>(gen: AsyncGenerator<unknown, R, void>): Promise<R> {
-  let r = await gen.next();
-  while (!r.done) r = await gen.next();
-  return r.value;
-}
-
-function createContext(captured: Message[][], text = '完成'): RunContext {
-  const chat = async function* (args: {
-    provider: Provider;
-    messages: Message[];
-    tools: Tool[];
-    signal?: AbortSignal;
-  }): AsyncGenerator<LlmStreamEvent> {
-    captured.push(args.messages);
-    yield { type: 'text_delta', delta: text };
-    yield { type: 'done', stopReason: 'stop' };
-  };
-  return {
-    provider,
-    history: [],
-    cwd: process.cwd(),
-    tools: [],
-    chat,
-  };
-}
-
-function lastUserContent(messages: Message[]): Message['content'] {
-  const user = [...messages].reverse().find((m) => m.role === 'user');
-  if (!user) throw new Error('missing user message');
-  return user.content;
-}
-
-function messagesContainImage(messages: Message[]): boolean {
-  return messages.some((msg) => {
-    if (!Array.isArray(msg.content)) return false;
-    return msg.content.some((part) => part.type === 'image_url');
-  });
-}
-
-describe('workflow-runner multimodal images', () => {
-  it('agent allowed_tools cannot expand the host tool catalog', async () => {
-    let round = 0;
-    let executed = 0;
-    const chat = async function* (): AsyncGenerator<LlmStreamEvent> {
-      if (round++ === 0) {
-        yield { type: 'tool_call_delta', index: 0, id: 'hidden', name: 'Bash' };
-        yield {
-          type: 'tool_call_delta',
-          index: 0,
-          argumentsDelta: '{"command":"echo no"}',
-        };
-        yield { type: 'done', stopReason: 'tool_calls' };
-        return;
-      }
-      yield { type: 'text_delta', delta: '已改道。' };
-      yield { type: 'done', stopReason: 'stop' };
-    };
-    const ctx: RunContext = {
-      provider,
-      history: [{ role: 'system', content: 'stable' }],
-      cwd: process.cwd(),
-      tools: ALL_TOOLS.filter((tool) => tool.name === 'Read'),
-      chat,
-      executeTool: async () => {
-        executed += 1;
-        return { ok: true, content: 'unexpected' };
-      },
-    };
-    const result = await drain(
-      execAgentStep(
-        { id: 'bounded', agent: '完成任务', allowed_tools: ['Bash'] },
-        new VarStack(),
-        ctx,
-      ),
-    );
-    expect(executed).toBe(0);
-    expect(result.raw.text).toBe('已改道。');
-  });
-
-  it('an empty host tool catalog remains empty instead of restoring global tools', async () => {
-    let round = 0;
-    let executed = 0;
-    const chat = async function* (): AsyncGenerator<LlmStreamEvent> {
-      if (round++ === 0) {
-        yield { type: 'tool_call_delta', index: 0, id: 'hidden', name: 'Read' };
-        yield {
-          type: 'tool_call_delta',
-          index: 0,
-          argumentsDelta: '{"file_path":"README.md"}',
-        };
-        yield { type: 'done', stopReason: 'tool_calls' };
-        return;
-      }
-      yield { type: 'text_delta', delta: '没有可用工具。' };
-      yield { type: 'done', stopReason: 'stop' };
-    };
-    const ctx: RunContext = {
-      provider,
-      history: [{ role: 'system', content: 'stable' }],
-      cwd: process.cwd(),
-      tools: [],
-      chat,
-      executeTool: async () => {
-        executed += 1;
-        return { ok: true, content: 'unexpected' };
-      },
-    };
-
-    const result = await drain(
-      execAgentStep(
-        { id: 'empty-bound', agent: '完成任务', allowed_tools: ['Read'] },
-        new VarStack(),
-        ctx,
-      ),
-    );
-
-    expect(executed).toBe(0);
-    expect(result.raw.text).toBe('没有可用工具。');
-  });
-
-  it('execLlmStep 把 images 传成 image_url content block，并支持变量插值', async () => {
-    const captured: Message[][] = [];
-    const ctx = createContext(captured);
-    const vars = new VarStack();
-    vars.setGlobal('inputs', {
-      image: 'https://example.com/mockup.png',
-    });
-    const step: StepDef = {
-      id: 'inspect',
-      llm: '请描述图片',
-      images: [
-        {
-          source: '${inputs.image}',
-          detail: 'high',
-          max_long_side_pixel: 1600,
-        },
-      ],
-    };
-
-    await drain(execLlmStep(step, vars, ctx));
-
-    const content = lastUserContent(captured[0]);
-    expect(Array.isArray(content)).toBe(true);
-    const parts = content as ChatContentPart[];
-    expect(parts[0]).toEqual({ type: 'text', text: '请描述图片' });
-    expect(parts[1]).toEqual({
-      type: 'image_url',
-      image_url: {
-        url: 'https://example.com/mockup.png',
-        detail: 'high',
-        max_long_side_pixel: 1600,
-      },
-    });
-  });
-
-  it('parse_inline_images=true 时解析 prompt 内图片引用', async () => {
-    const captured: Message[][] = [];
-    const ctx = createContext(captured);
-    const step: StepDef = {
-      id: 'inline',
-      llm: '请看 @https://example.com/a.png 并指出问题',
-      parse_inline_images: true,
-      image_detail: 'low',
-    };
-
-    await drain(execLlmStep(step, new VarStack(), ctx));
-
-    const content = lastUserContent(captured[0]);
-    expect(Array.isArray(content)).toBe(true);
-    const parts = content as ChatContentPart[];
-    expect(parts[0]).toEqual({ type: 'text', text: '请看 并指出问题' });
-    expect(parts[1]).toEqual({
-      type: 'image_url',
-      image_url: { url: 'https://example.com/a.png', detail: 'low' },
-    });
-  });
-
-  it('execAgentStep 支持 images，且不影响 agent 验证闸门', async () => {
-    const captured: Message[][] = [];
-    const ctx = createContext(captured, '已经完成图片分析。');
-    const step: StepDef = {
-      id: 'agent-inspect',
-      agent: '看图后给出结论',
-      images: ['https://example.com/design.png'],
-      image_detail: 'default',
-      allowed_tools: [],
-    };
-
-    const result = await drain(execAgentStep(step, new VarStack(), ctx));
-
-    expect(result.raw.text).toBe('已经完成图片分析。');
-    const content = lastUserContent(captured[0]);
-    expect(Array.isArray(content)).toBe(true);
-    const parts = content as ChatContentPart[];
-    expect(parts.at(-1)).toEqual({
-      type: 'image_url',
-      image_url: { url: 'https://example.com/design.png', detail: 'default' },
-    });
-  });
-
-  it('history_mode=isolated 的多模态 llm 可 capture 输出，但不污染共享 history', async () => {
-    const captured: Message[][] = [];
-    const ctx = createContext(captured, '图片可用');
-    ctx.history.push({ role: 'system', content: 'workflow system prompt' });
-    const step: StepDef = {
-      id: 'review-image',
-      llm: '复核生成图',
-      images: ['https://example.com/generated.png'],
-      image_detail: 'high',
-      history_mode: 'isolated',
-    };
-
-    const result = await drain(execLlmStep(step, new VarStack(), ctx));
-
-    expect(result.raw.text).toBe('图片可用');
-    expect(messagesContainImage(captured[0])).toBe(true);
-    expect(ctx.history).toEqual([
-      { role: 'system', content: 'workflow system prompt' },
-    ]);
-  });
-
-  it('isolated 多模态步骤之后的普通 agent 不会收到前一步 image_url', async () => {
-    const captured: Message[][] = [];
-    const ctx = createContext(captured, '完成');
-    ctx.history.push({ role: 'system', content: 'workflow system prompt' });
-
-    await drain(
-      execLlmStep(
-        {
-          id: 'review-image',
-          llm: '复核生成图',
-          images: ['https://example.com/generated.png'],
-          history_mode: 'isolated',
-        },
-        new VarStack(),
-        ctx,
-      ),
-    );
-
-    await drain(
-      execAgentStep(
-        {
-          id: 'export',
-          agent: '导出 PPTX',
-          allowed_tools: [],
-        },
-        new VarStack(),
-        ctx,
-      ),
-    );
-
-    expect(messagesContainImage(captured[0])).toBe(true);
-    expect(messagesContainImage(captured[1])).toBe(false);
-  });
-
-  it('history_mode=isolated 的 agent 仍可调用工具，但不把工具对话写回共享 history', async () => {
-    const captured: Message[][] = [];
-    let calls = 0;
-    let toolCalled = false;
-    const chat = async function* (args: {
-      provider: Provider;
-      messages: Message[];
-      tools: Tool[];
-      signal?: AbortSignal;
-    }): AsyncGenerator<LlmStreamEvent> {
-      captured.push(args.messages);
-      calls++;
-      if (calls === 1) {
-        yield {
-          type: 'tool_call_delta',
-          index: 0,
-          id: 'call_1',
-          name: 'Write',
-          argumentsDelta: '{"file_path":"./out.txt","content":"ok"}',
-        };
-        yield { type: 'done', stopReason: 'tool_calls' };
-        return;
-      }
-      yield { type: 'text_delta', delta: '文件已写好。' };
-      yield { type: 'done', stopReason: 'stop' };
-    };
-    const ctx: RunContext = {
-      provider,
-      history: [{ role: 'system', content: 'workflow system prompt' }],
-      cwd: process.cwd(),
-      tools: ALL_TOOLS.filter((tool) => tool.name === 'Write'),
-      chat,
-      executeTool: async () => {
-        toolCalled = true;
-        return { ok: true, content: 'written' };
-      },
-    };
-
-    const result = await drain(
-      execAgentStep(
-        {
-          id: 'isolated-export',
-          agent: '写一个文件并报告',
-          allowed_tools: ['Write'],
-          history_mode: 'isolated',
-        },
-        new VarStack(),
-        ctx,
-      ),
-    );
-
-    expect(toolCalled).toBe(true);
-    expect(result.raw.text).toBe('文件已写好。');
-    expect(ctx.history).toEqual([
-      { role: 'system', content: 'workflow system prompt' },
-    ]);
-    expect(captured.length).toBe(2);
-  });
-});

package/plugins/workflow-runner/test/output-schema.test.ts

@@ -1,213 +0,0 @@
-/**
- * ============================================================
- *  test/output-schema.test.ts —— ADR-05 Wave 2 验证
- * ------------------------------------------------------------
- *  覆盖 execLlmStep 的 output_schema 行为：
- *    1. 带 output_schema → chat() 收到 responseFormat 参数，raw 是 parsed JSON
- *    2. capture { findings: items } 能从 structured raw 抽出字段
- *    3. JSON.parse 失败 → 抛错含原文前 200 字
- *    4. 缺省 output_schema → 走老路径（raw 是 { text, result }，无 [json] 前缀）
- *
- *  策略：
- *    - mock.module('../../../src/llm/client.js') 拦截 chat
- *    - 同时把收到的 args 暂存到 module 级数组，用于断言 responseFormat
- *    - case 2 用 runWorkflow，验证 runner 端 capture 联动 structured raw
- *    - 其余 case 直接调 execLlmStep
- * ============================================================
- */
-
-import { beforeEach, describe, expect, it, mock } from 'bun:test';
-
-import { execLlmStep } from '../src/stepExecutors/llm.js';
-import { runWorkflow } from '../src/runner.js';
-import { VarStack } from '../src/types.js';
-import type {
-  LoopEvent,
-  Provider,
-} from '../../../src/types.js';
-import type {
-  RunContext,
-  StepDef,
-  WorkflowDef,
-  WorkflowEvent,
-} from '../src/types.js';
-
-type WfOrLoop = WorkflowEvent | LoopEvent;
-
-const fakeProvider: Provider = {
-  name: 'test',
-  baseURL: '',
-  apiKey: '',
-  model: 'm',
-  contextWindow: 128000,
-};
-
-/** 收集 chat() 收到的参数（每次调用 push 一条）；测试 case 切换前 clear */
-const capturedChatArgs: unknown[] = [];
-/** 测试 case 控制：本轮 chat 应该 yield 的文本 */
-let mockChatText = '';
-
-mock.module('../../../src/llm/client.js', () => ({
-  chat: async function* (args: unknown) {
-    capturedChatArgs.push(args);
-    yield { type: 'text_delta', delta: mockChatText };
-    yield { type: 'done', stopReason: 'stop' };
-  },
-}));
-
-async function collect(
-  gen: AsyncGenerator<WfOrLoop, void, void>,
-): Promise<WfOrLoop[]> {
-  const out: WfOrLoop[] = [];
-  for await (const ev of gen) out.push(ev);
-  return out;
-}
-
-/** execLlmStep 现为 AsyncGenerator：drain 取最终 return 值（yield 的事件直接丢弃）。 */
-async function drainLlm<R>(gen: AsyncGenerator<unknown, R, void>): Promise<R> {
-  let r = await gen.next();
-  while (!r.done) r = await gen.next();
-  return r.value;
-}
-
-describe('workflow-runner output_schema (ADR-05)', () => {
-  let ctx: RunContext;
-
-  beforeEach(() => {
-    capturedChatArgs.length = 0;
-    mockChatText = '';
-    ctx = { provider: fakeProvider, history: [], cwd: process.cwd(), tools: [] };
-  });
-
-  it('case 1: 带 output_schema → schema 内嵌进 prompt，raw 是 parsed JSON', async () => {
-    // v0.9 重构：llm 步委托 runQuery(TAOR) 执行，不再走 provider-native responseFormat
-    // （弱模型多不支持 json_schema），改为把 schema 约束【内嵌进 prompt】+ 上层 extractJsonPayload
-    // 容错解析。本用例对齐该设计：断言 schema 进了发给模型的 prompt + raw 是解析后的 JSON。
-    mockChatText = '{"findings":["bug1","bug2"]}';
-    const schema = {
-      type: 'object',
-      properties: {
-        findings: { type: 'array', items: { type: 'string' } },
-      },
-      required: ['findings'],
-    };
-    const step: StepDef = {
-      id: 'analyze',
-      llm: 'find bugs',
-      output_schema: schema,
-    };
-
-    const result = await drainLlm(execLlmStep(step, new VarStack(), ctx));
-
-    // 断言 1: chat 被调一次，schema 约束内嵌进发给模型的 user prompt
-    expect(capturedChatArgs.length).toBe(1);
-    const args = capturedChatArgs[0] as {
-      messages: { role: string; content: string }[];
-    };
-    const userMsg = args.messages.find((m) => m.role === 'user');
-    expect(userMsg).toBeDefined();
-    expect(userMsg!.content).toContain('JSON Schema');
-    expect(userMsg!.content).toContain('findings');
-
-    // 断言 2: raw 是 parsed JSON 对象，preview 带 [json] 前缀
-    expect(result.raw).toEqual({ findings: ['bug1', 'bug2'] });
-    expect(result.preview.startsWith('[json] ')).toBe(true);
-  });
-
-  it('case 2: capture 从 structured raw 抽出字段（runner 端联动）', async () => {
-    mockChatText = '{"findings":["bug1","bug2"]}';
-    const def: WorkflowDef = {
-      name: 'cap-struct',
-      description: 'd',
-      steps: [
-        {
-          id: 'analyze',
-          llm: 'find bugs',
-          output_schema: {
-            type: 'object',
-            properties: {
-              findings: { type: 'array', items: { type: 'string' } },
-            },
-            required: ['findings'],
-          },
-          capture: { findings: 'items' },
-        },
-        {
-          id: 'check',
-          type: 'assert',
-          condition: 'length(items) == 2',
-        },
-      ],
-    };
-
-    const events = await collect(runWorkflow(def, {}, ctx));
-    // workflow 跑完
-    expect(events.some((e) => e.type === 'workflow_done')).toBe(true);
-    // 拿到 workflow_done 的 vars 快照
-    const done = events.find(
-      (e): e is Extract<WorkflowEvent, { type: 'workflow_done' }> =>
-        e.type === 'workflow_done',
-    );
-    expect(done).toBeDefined();
-    expect(done!.vars.items).toEqual(['bug1', 'bug2']);
-  });
-
-  it('case 3: JSON.parse 失败 → 抛错含原文前 200 字', async () => {
-    mockChatText = 'this is not json';
-    const step: StepDef = {
-      id: 'bad',
-      llm: 'go',
-      output_schema: { type: 'object' },
-    };
-
-    let caught: Error | null = null;
-    try {
-      await drainLlm(execLlmStep(step, new VarStack(), ctx));
-    } catch (e) {
-      caught = e as Error;
-    }
-    expect(caught).not.toBeNull();
-    expect(caught!.message).toContain('output_schema 要求 JSON 输出但解析失败');
-    expect(caught!.message).toContain('this is not json');
-  });
-
-  it('case 3b: content 掺 <think> 思维链 → 仍能解析（MiniMax-M2/M3 真实场景）', async () => {
-    // 思考型模型即便在 strict json_schema 下也会把 <think> 写进 content。
-    // 这条端到端 case 锁住"解析点确实接了 extractJsonPayload"——纯函数单测覆盖不到接线。
-    mockChatText =
-      '<think>用户要 findings。我应该返回 {"findings": [...]} 形状。</think>{"findings":["real"],"open_questions":[]}';
-    const step: StepDef = {
-      id: 'thinky',
-      llm: 'go',
-      output_schema: {
-        type: 'object',
-        properties: { findings: { type: 'array', items: { type: 'string' } } },
-        required: ['findings'],
-      },
-    };
-
-    const result = await drainLlm(execLlmStep(step, new VarStack(), ctx));
-    expect(result.raw).toEqual({ findings: ['real'], open_questions: [] });
-  });
-
-  it('case 4: 缺省 output_schema → 老路径（raw {text,result}, preview 无 [json]）', async () => {
-    mockChatText = 'Hello world';
-    const step: StepDef = {
-      id: 'plain',
-      llm: 'say hi',
-    };
-
-    const result = await drainLlm(execLlmStep(step, new VarStack(), ctx));
-
-    // chat 收到的 responseFormat 必须是 undefined（不破坏老调用方）
-    expect(capturedChatArgs.length).toBe(1);
-    const args = capturedChatArgs[0] as { responseFormat?: unknown };
-    expect(args.responseFormat).toBeUndefined();
-
-    // raw 是 { text, result } 双字段
-    expect(result.raw).toEqual({ text: 'Hello world', result: 'Hello world' });
-    // preview 无 [json] 前缀
-    expect(result.preview.startsWith('[json] ')).toBe(false);
-    expect(result.preview).toBe('Hello world');
-  });
-});

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

@@ -1,106 +0,0 @@
-/**
- * ============================================================
- *  test/parseWorkflowArgs.test.ts —— 边界行为冻结测试
- * ------------------------------------------------------------
- *  parseWorkflowArgs / tokenizeArgs 当前的行为（无转义、引号宽松、未知 flag 跳一个 token）
- *  被这些测试冻结。改 tokenizer 语义 → 改这些测试。
- * ============================================================
- */
-import { describe, test, expect } from 'bun:test';
-import { parseWorkflowArgs } from '../src/index.js';
-
-describe('parseWorkflowArgs / tokenizeArgs 边界行为冻结', () => {
-  test('未闭合引号：剩余部分作为单 token', () => {
-    const r = parseWorkflowArgs('hello "未闭合');
-    expect(r.name).toBe('hello');
-    expect(r.positional).toEqual(['未闭合']);
-  });
-
-  test('混合引号：双引号内含单引号字面量', () => {
-    const r = parseWorkflowArgs(`hello "it's fine"`);
-    expect(r.positional).toEqual([`it's fine`]);
-  });
-
-  test('反斜杠不转义：原样保留', () => {
-    const r = parseWorkflowArgs('hello a\\"b');
-    // 当前行为：\\" 不视为转义；按空白切分得到 'a\\' 然后 '"b'（'b' 未闭合）
-    // 行为冻结测试 —— 用 toBeDefined 而非具体值，保留未来微调空间
-    expect(r.positional.length).toBeGreaterThan(0);
-  });
-
-  test('空字符串引号产生空 token', () => {
-    const r = parseWorkflowArgs('hello ""');
-    expect(r.positional).toEqual(['']);
-  });
-
-  test('连续空白合并', () => {
-    const r = parseWorkflowArgs('hello   alice    bob');
-    expect(r.positional).toEqual(['alice', 'bob']);
-  });
-
-  test('--input 后无 = 的 token：被丢弃不报错', () => {
-    const r = parseWorkflowArgs('hello --input justkey');
-    expect(r.inputs).toEqual({});
-    expect(r.name).toBe('hello');
-  });
-
-  test('--input 末尾无值：循环 break 不崩', () => {
-    const r = parseWorkflowArgs('hello --input');
-    expect(r.inputs).toEqual({});
-    expect(r.name).toBe('hello');
-  });
-
-  test('.yaml 后缀大小写不敏感剥离', () => {
-    expect(parseWorkflowArgs('hello.YAML alice').name).toBe('hello');
-    expect(parseWorkflowArgs('hello.YML alice').name).toBe('hello');
-    expect(parseWorkflowArgs('hello.Yaml alice').name).toBe('hello');
-  });
-
-  test('引号包裹整个 KV：含空格的 value 正确捕获', () => {
-    const r = parseWorkflowArgs('hello --input "topic=AI 教程"');
-    expect(r.inputs).toEqual({ topic: 'AI 教程' });
-  });
-
-  test('引号在 = 后的 KV：value 含空格也完整捕获（回归：曾按空白硬切+引号残留）', () => {
-    // 用户 shell 习惯 `--input topic="带空格 的值"` —— 引号在 token 内部（= 之后），
-    // 曾被 tokenizeArgs 按空白切分 → 值截断 + 引号残留 + 散落 positional。
-    const r = parseWorkflowArgs(
-      'hello --input topic="比特币量化 长线 短线策略" --input depth=standard',
-    );
-    expect(r.inputs).toEqual({
-      topic: '比特币量化 长线 短线策略',
-      depth: 'standard',
-    });
-    expect(r.positional).toEqual([]);
-  });
-
-  test('单引号在 = 后同理支持', () => {
-    const r = parseWorkflowArgs("hello --input topic='AI 教程 入门'");
-    expect(r.inputs).toEqual({ topic: 'AI 教程 入门' });
-    expect(r.positional).toEqual([]);
-  });
-
-  test('未知 -- flag 跳过其后一个 token（保守解析）', () => {
-    const r = parseWorkflowArgs('hello --foo bar alice');
-    // --foo bar 被吃掉，alice 进 positional
-    expect(r.positional).toEqual(['alice']);
-  });
-
-  test('单引号也支持引号包裹', () => {
-    const r = parseWorkflowArgs(`hello 'AI tutorial'`);
-    expect(r.positional).toEqual(['AI tutorial']);
-  });
-
-  test('完全空字符串：name 为 null', () => {
-    const r = parseWorkflowArgs('');
-    expect(r.name).toBeNull();
-    expect(r.positional).toEqual([]);
-    expect(r.inputs).toEqual({});
-  });
-
-  test('仅有 flag 没有 name：name 仍为 null', () => {
-    const r = parseWorkflowArgs('--input name=alice');
-    expect(r.name).toBeNull();
-    expect(r.inputs).toEqual({ name: 'alice' });
-  });
-});