minimal-agent 0.10.0 → 0.12.0

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

@@ -0,0 +1,33 @@
+/**
+ * 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

@@ -0,0 +1,342 @@
+/**
+ * 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

@@ -0,0 +1,213 @@
+/**
+ * ============================================================
+ *  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

@@ -0,0 +1,87 @@
+/**
+ * ============================================================
+ *  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('未知 -- 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' });
+  });
+});