minimal-agent 0.1.8 → 0.2.0

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

@@ -0,0 +1,268 @@
+/**
+ * ============================================================
+ *  test/workflows/e2e.test.ts —— /workflow 端到端测试
+ * ------------------------------------------------------------
+ *  从用户敲 `/workflow hello-workflow --input ...` 这一最外层入口开始，
+ *  穿过：
+ *
+ *    runWithPlugins
+ *      → discoverPlugins (扫到真实 workflow-runner 插件)
+ *      → resolveCommand  (识别 /workflow)
+ *      → cmd.executionMode === 'workflow' 路径
+ *      → lazy import workflows/index.ts
+ *      → parseWorkflowArgs + coerceInputs
+ *      → findWorkflowByName (从 tmp/workflows/ 加载 fixture)
+ *      → runWorkflow → step executors (真实 executeTool('Write'))
+ *
+ *  断言：
+ *    - 整个事件序列形态合理（workflow_start → step_start/end ×N → workflow_done）
+ *    - 文件真的落盘到正确路径，内容正确
+ *    - 缺必填 input 时不写任何文件
+ *    - assert 失败时整个 workflow halt
+ *
+ *  不 mock chat / runQuery —— fixture 不依赖 LLM。
+ *  只 mock workingDir.ts，因为其它测试文件留下的全局 mock 会污染。
+ * ============================================================
+ */
+
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  mock,
+} from 'bun:test';
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.ts';
+import { _resetPluginCache } from '../../../src/plugins/commandRouter.ts';
+import type { LoopEvent, Provider } from '../../../src/types.ts';
+import type { PluginEvent } from '../../../src/plugins/pluginApi.ts';
+import type { WorkflowEvent } from '../src/types.ts';
+
+type WfOrLoop = LoopEvent | PluginEvent | WorkflowEvent;
+
+const FIXTURE_SRC = join(import.meta.dir, 'fixtures', 'hello-workflow.yaml');
+
+const provider: 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 as WfOrLoop);
+  return out;
+}
+
+describe('workflow E2E（/workflow → 路由 → runner → 文件落盘）', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-e2e-'));
+    mkdirSync(join(tmp, 'workflows'), { recursive: true });
+    copyFileSync(FIXTURE_SRC, join(tmp, 'workflows', 'hello-workflow.yaml'));
+
+    process.env.MINIMAL_AGENT_CWD = tmp;
+    _resetWorkingDir();
+    _resetPluginCache();
+
+    // 抵抗其它测试文件留下的 workingDir.ts 全局 mock 污染。
+    // 注：这一行让 getWorkingDir 跟着 tmp 走，相对路径锚点 + workflows/ 双源扫描都受益。
+    mock.module('../../../src/bootstrap/workingDir.ts', () => ({
+      getWorkingDir: () => tmp,
+      initWorkingDir: () => tmp,
+      _resetWorkingDir: () => {},
+    }));
+  });
+
+  afterEach(() => {
+    delete process.env.MINIMAL_AGENT_CWD;
+    _resetWorkingDir();
+    _resetPluginCache();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  async function runCmd(input: string): Promise<WfOrLoop[]> {
+    const { runWithPlugins } = await import('../../../src/plugins/pluginRunner.ts');
+    return collect(
+      runWithPlugins(input, { provider, history: [] }) as AsyncGenerator<WfOrLoop, void, void>,
+    );
+  }
+
+  it('golden path：/workflow hello-workflow --input name=alice --input lang=zh 跑完且文件落盘', async () => {
+    const events = await runCmd('/workflow hello-workflow --input name=alice --input lang=zh');
+
+    // 整体形态
+    expect(events[0]?.type).toBe('workflow_start');
+    expect(events[events.length - 1]?.type).toBe('workflow_done');
+    expect(events.some((e) => e.type === 'error')).toBe(false);
+
+    // 每个 step 都跑完且 ok=true
+    const ends = events.filter(
+      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_end' }> => e.type === 'workflow_step_end',
+    );
+    expect(ends.length).toBe(4);
+    expect(ends.every((e) => e.ok)).toBe(true);
+    expect(ends.map((e) => e.id)).toEqual([
+      'write_greeting',
+      'write_meta',
+      'verify_files',
+      'verify_capture',
+    ]);
+
+    // 文件实际写盘
+    const helloPath = join(tmp, 'greetings', 'alice', 'hello.txt');
+    const metaPath = join(tmp, 'greetings', 'alice', 'meta.json');
+    expect(existsSync(helloPath)).toBe(true);
+    expect(existsSync(metaPath)).toBe(true);
+
+    // hello.txt 内容验证（${var} 插值确实工作了）
+    expect(readFileSync(helloPath, 'utf8')).toBe('Hello, alice! (lang=zh)');
+
+    // meta.json 是合法 JSON，字段对得上
+    const meta = JSON.parse(readFileSync(metaPath, 'utf8'));
+    expect(meta.name).toBe('alice');
+    expect(meta.lang).toBe('zh');
+    // length() 内置函数 + capture 链路：greeting_text="Hello, alice! (lang=zh)" → 长度 23
+    expect(meta.greeting_length).toBe('Hello, alice! (lang=zh)'.length);
+  });
+
+  it('lang 使用默认值 en（input enum default 路径）', async () => {
+    const events = await runCmd('/workflow hello-workflow --input name=bob');
+    expect(events[events.length - 1]?.type).toBe('workflow_done');
+    expect(readFileSync(join(tmp, 'greetings', 'bob', 'hello.txt'), 'utf8'))
+      .toBe('Hello, bob! (lang=en)');
+  });
+
+  it('workflow_step_start 事件 index/total 单调且与 yaml 一致', async () => {
+    const events = await runCmd('/workflow hello-workflow --input name=carol');
+    const starts = events.filter(
+      (e): e is Extract<WorkflowEvent, { type: 'workflow_step_start' }> => e.type === 'workflow_step_start',
+    );
+    expect(starts.length).toBe(4);
+    expect(starts.map((s) => s.index)).toEqual([0, 1, 2, 3]);
+    expect(starts.every((s) => s.total === 4)).toBe(true);
+    expect(starts.map((s) => s.kind)).toEqual(['tool', 'tool', 'assert', 'assert']);
+  });
+
+  it('缺必填 input name → yield error，且没写任何文件', async () => {
+    const events = await runCmd('/workflow hello-workflow');
+    expect(events.some((e) => e.type === 'error')).toBe(true);
+    expect(events.some((e) => e.type === 'workflow_start')).toBe(false);
+    // tmp/greetings/ 不应被创建
+    expect(existsSync(join(tmp, 'greetings'))).toBe(false);
+  });
+
+  it('lang 传非法值 → yield enum 校验 error，且不进入 runWorkflow', async () => {
+    const events = await runCmd('/workflow hello-workflow --input name=dave --input lang=fr');
+    const err = events.find(
+      (e): e is Extract<LoopEvent, { type: 'error' }> => e.type === 'error',
+    );
+    expect(err).toBeDefined();
+    expect(err!.error).toContain('lang');
+    expect(events.some((e) => e.type === 'workflow_start')).toBe(false);
+  });
+
+  it('未知 workflow 名 → yield error，不污染文件系统', async () => {
+    const events = await runCmd('/workflow definitely-not-exists --input name=eve');
+    expect(events.some((e) => e.type === 'error')).toBe(true);
+    expect(events.some((e) => e.type === 'workflow_start')).toBe(false);
+    expect(existsSync(join(tmp, 'greetings'))).toBe(false);
+  });
+
+  it('/workflows 列表能看到 hello-workflow（cwd 优先双源加载）', async () => {
+    const events = await runCmd('/workflows');
+    const text = events
+      .filter((e): e is Extract<LoopEvent, { type: 'text' }> => e.type === 'text')
+      .map((e) => e.delta)
+      .join('');
+    expect(text).toContain('hello-workflow');
+  });
+});
+
+describe('workflow E2E：assert 失败 → halt（用变体 fixture）', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-e2e-fail-'));
+    mkdirSync(join(tmp, 'workflows'), { recursive: true });
+    // 写一个故意 assert 不通过的 yaml
+    const failYaml = `name: assert-fail-fixture
+description: assert 必失败的端到端 fixture
+steps:
+  - id: write_a
+    tool: Write
+    args:
+      file_path: "a.txt"
+      content: "hi"
+  - id: bad_assert
+    type: assert
+    condition: '1 == 2'
+    onFail: "故意失败"
+  - id: should_not_run
+    tool: Write
+    args:
+      file_path: "b.txt"
+      content: "should not exist"
+`;
+    require('node:fs').writeFileSync(
+      join(tmp, 'workflows', 'assert-fail-fixture.yaml'),
+      failYaml,
+      'utf8',
+    );
+
+    process.env.MINIMAL_AGENT_CWD = tmp;
+    _resetWorkingDir();
+    _resetPluginCache();
+    mock.module('../../../src/bootstrap/workingDir.ts', () => ({
+      getWorkingDir: () => tmp,
+      initWorkingDir: () => tmp,
+      _resetWorkingDir: () => {},
+    }));
+  });
+
+  afterEach(() => {
+    delete process.env.MINIMAL_AGENT_CWD;
+    _resetWorkingDir();
+    _resetPluginCache();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('assert 失败 → 后续 step 不执行 + yield error + 没 workflow_done', async () => {
+    const { runWithPlugins } = await import('../../../src/plugins/pluginRunner.ts');
+    const events = await collect(
+      runWithPlugins('/workflow assert-fail-fixture', { provider, history: [] }),
+    );
+
+    expect(events.some((e) => e.type === 'workflow_done')).toBe(false);
+    expect(events.some((e) => e.type === 'error')).toBe(true);
+
+    // a.txt 在 assert 前就写盘，应存在
+    expect(existsSync(join(tmp, 'a.txt'))).toBe(true);
+    // b.txt 在 assert 后，不应被写
+    expect(existsSync(join(tmp, 'b.txt'))).toBe(false);
+
+    // 错误信息含 onFail 自定义文案
+    const errs = events
+      .filter((e): e is Extract<LoopEvent, { type: 'error' }> => e.type === 'error')
+      .map((e) => e.error)
+      .join('\n');
+    expect(errs).toContain('故意失败');
+  });
+});

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

@@ -0,0 +1,140 @@
+/**
+ * ============================================================
+ *  test/workflows/expressions.test.ts
+ * ------------------------------------------------------------
+ *  workflow 表达式引擎单测：tokenizer / evalExpr / interpolate /
+ *  interpolateDeep。重点覆盖：
+ *    - 变量点路径（inputs.book）
+ *    - 比较 + 布尔运算
+ *    - 白名单内置函数（fileExists / length / lower / upper）
+ *    - ${} 插值（包括括号匹配 + 转义 + 对象 JSON 化）
+ *    - 安全：禁止 eval/Function 等被插入
+ * ============================================================
+ */
+
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.ts';
+import {
+  evalExpr,
+  interpolate,
+  interpolateDeep,
+} from '../src/expressions.ts';
+import { VarStack } from '../src/types.ts';
+
+describe('workflows/expressions', () => {
+  let vars: VarStack;
+
+  beforeEach(() => {
+    vars = new VarStack();
+    vars.setGlobal('inputs', { book: '原则', angle: 'insight', n: 3 });
+    vars.set('thumb_prompt', 'a book and a lamp');
+  });
+
+  it('字面量数字 / 字符串 / 布尔', () => {
+    expect(evalExpr('42', vars)).toBe(42);
+    expect(evalExpr('"hello"', vars)).toBe('hello');
+    expect(evalExpr("'x'", vars)).toBe('x');
+    expect(evalExpr('true', vars)).toBe(true);
+    expect(evalExpr('false', vars)).toBe(false);
+    expect(evalExpr('null', vars)).toBe(null);
+  });
+
+  it('变量 + 点路径', () => {
+    expect(evalExpr('thumb_prompt', vars)).toBe('a book and a lamp');
+    expect(evalExpr('inputs.book', vars)).toBe('原则');
+    expect(evalExpr('inputs.n', vars)).toBe(3);
+    expect(evalExpr('inputs.missing', vars)).toBeUndefined();
+  });
+
+  it('比较运算 ==/!=/>/<', () => {
+    expect(evalExpr('inputs.n == 3', vars)).toBe(true);
+    expect(evalExpr('inputs.n != 4', vars)).toBe(true);
+    expect(evalExpr('inputs.n > 2', vars)).toBe(true);
+    expect(evalExpr('inputs.n < 2', vars)).toBe(false);
+    expect(evalExpr('"a" == "a"', vars)).toBe(true);
+  });
+
+  it('布尔运算 && / || / !', () => {
+    expect(evalExpr('true && false', vars)).toBe(false);
+    expect(evalExpr('true || false', vars)).toBe(true);
+    expect(evalExpr('!false', vars)).toBe(true);
+    expect(evalExpr('inputs.n > 0 && inputs.book == "原则"', vars)).toBe(true);
+  });
+
+  it('白名单函数 length / lower / upper', () => {
+    expect(evalExpr('length("abcd")', vars)).toBe(4);
+    expect(evalExpr('length(inputs.book)', vars)).toBe(2);
+    expect(evalExpr('lower("HELLO")', vars)).toBe('hello');
+    expect(evalExpr('upper("hi")', vars)).toBe('HI');
+  });
+
+  it('未知函数被拒绝（白名单外）', () => {
+    expect(() => evalExpr('eval("1+1")', vars)).toThrow();
+    expect(() => evalExpr('require("fs")', vars)).toThrow();
+    expect(() => evalExpr('Function("x")', vars)).toThrow();
+  });
+
+  it('interpolate ${EXPR} 替换变量', () => {
+    expect(interpolate('book=${inputs.book}', vars)).toBe('book=原则');
+    expect(interpolate('${inputs.n} times', vars)).toBe('3 times');
+  });
+
+  it('interpolate 处理对象 → JSON.stringify', () => {
+    const out = interpolate('${inputs}', vars);
+    expect(out).toContain('原则');
+    expect(out).toContain('insight');
+  });
+
+  it('interpolate 支持 \\$ 转义', () => {
+    expect(interpolate('price=\\${inputs.n}', vars)).toBe('price=${inputs.n}');
+  });
+
+  it('interpolate 未闭合 ${ 原样保留', () => {
+    expect(interpolate('hello ${unclosed', vars)).toBe('hello ${unclosed');
+  });
+
+  it('interpolateDeep 递归处理对象/数组', () => {
+    const input = {
+      file_path: 'videos/${inputs.book}/script.txt',
+      content: '${thumb_prompt}',
+      nested: { list: ['${inputs.angle}', 'static'] },
+    };
+    const out = interpolateDeep(input, vars);
+    expect(out.file_path).toBe('videos/原则/script.txt');
+    expect(out.content).toBe('a book and a lamp');
+    expect(out.nested.list[0]).toBe('insight');
+    expect(out.nested.list[1]).toBe('static');
+  });
+});
+
+describe('workflows/expressions::fileExists', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-expr-'));
+    process.env.MINIMAL_AGENT_CWD = tmp;
+    _resetWorkingDir();
+    mock.module('../../../src/bootstrap/workingDir.ts', () => ({
+      getWorkingDir: () => tmp,
+      initWorkingDir: () => tmp,
+      _resetWorkingDir: () => {},
+    }));
+  });
+
+  afterEach(() => {
+    delete process.env.MINIMAL_AGENT_CWD;
+    _resetWorkingDir();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('fileExists 命中真实文件', () => {
+    writeFileSync(join(tmp, 'a.txt'), 'x');
+    const vars = new VarStack();
+    expect(evalExpr('fileExists("a.txt")', vars)).toBe(true);
+    expect(evalExpr('fileExists("missing.txt")', vars)).toBe(false);
+  });
+});

package/plugins/workflow-runner/test/fixtures/cli-e2e.yaml

@@ -0,0 +1,27 @@
+name: cli-e2e
+description: CLI 端到端测试 fixture：纯 Write + assert，不调 LLM 不调网络
+version: "0.1"
+
+inputs:
+  - name: topic
+    type: string
+    required: true
+
+steps:
+  - id: write_note
+    tool: Write
+    args:
+      file_path: "out/${inputs.topic}/note.txt"
+      content: "topic=${inputs.topic} ok"
+    capture:
+      args.content: note_body
+
+  - id: verify_file
+    type: assert
+    condition: 'fileExists("out/${inputs.topic}/note.txt")'
+    onFail: "note.txt 未落盘"
+
+  - id: verify_capture
+    type: assert
+    condition: 'length(note_body) > 0'
+    onFail: "capture 没绑到 note_body"

package/plugins/workflow-runner/test/fixtures/hello-workflow.yaml

@@ -0,0 +1,49 @@
+name: hello-workflow
+description: |
+  E2E 测试用极简 workflow：不依赖 LLM、不调网络，只用确定性工具。
+  覆盖：input 必填校验 / ${var} 插值 / 嵌套目录 / 多步 capture / assert+fileExists。
+version: "0.1"
+
+inputs:
+  - name: name
+    type: string
+    required: true
+    description: 收件人名字
+  - name: lang
+    type: enum
+    values: [zh, en]
+    default: en
+
+steps:
+  # 1. 写问候语文件 + capture 内容
+  - id: write_greeting
+    tool: Write
+    args:
+      file_path: "greetings/${inputs.name}/hello.txt"
+      content: "Hello, ${inputs.name}! (lang=${inputs.lang})"
+    capture:
+      args.content: greeting_text
+
+  # 2. 写 meta json
+  - id: write_meta
+    tool: Write
+    args:
+      file_path: "greetings/${inputs.name}/meta.json"
+      content: |
+        {
+          "name": "${inputs.name}",
+          "lang": "${inputs.lang}",
+          "greeting_length": ${length(greeting_text)}
+        }
+
+  # 3. 守门 assert：两个文件都得在
+  - id: verify_files
+    type: assert
+    condition: 'fileExists("greetings/${inputs.name}/hello.txt") && fileExists("greetings/${inputs.name}/meta.json")'
+    onFail: "hello-workflow 文件未全部落盘"
+
+  # 4. 守门 assert：capture 的变量非空
+  - id: verify_capture
+    type: assert
+    condition: 'length(greeting_text) > 0'
+    onFail: "capture 没绑到 greeting_text"

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

@@ -0,0 +1,139 @@
+/**
+ * ============================================================
+ *  test/workflows/graceful.test.ts
+ * ------------------------------------------------------------
+ *  降级契约（R1）：
+ *    - workflows/ 不存在 → listWorkflows() 返回包内自带 [包内 yaml]，绝不抛错
+ *    - 全是坏 yaml → 跳过坏的，列出好的
+ *    - findWorkflowByName 未命中 → 返回 null（让调用方 yield 友好 error）
+ *    - runWorkflowFromCommand 对未知 name → yield error，不污染 history
+ *    - runWorkflowsList 在空列表时 yield 友好提示
+ * ============================================================
+ */
+
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { _resetWorkingDir } from '../../../src/bootstrap/workingDir.ts';
+import { listWorkflows } from '../src/loader.ts';
+import {
+  runWorkflowFromCommand,
+  runWorkflowsList,
+} from '../src/index.ts';
+import type { LoopEvent, Provider } from '../../../src/types.ts';
+import type { WorkflowEvent } from '../src/types.ts';
+
+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/graceful', () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'wf-graceful-'));
+    process.env.MINIMAL_AGENT_CWD = tmp;
+    _resetWorkingDir();
+    mock.module('../../../src/bootstrap/workingDir.ts', () => ({
+      getWorkingDir: () => tmp,
+      initWorkingDir: () => tmp,
+      _resetWorkingDir: () => {},
+    }));
+  });
+
+  afterEach(() => {
+    delete process.env.MINIMAL_AGENT_CWD;
+    _resetWorkingDir();
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('cwd 下无 workflows/ 目录 → listWorkflows() 仍返回（packageRoot fallback 也只是空降级，不抛）', async () => {
+    const list = await listWorkflows();
+    // 至少应该包含包内自带的 book-review-short
+    expect(Array.isArray(list)).toBe(true);
+  });
+
+  it('cwd 下 workflows/ 全空 → 不抛，不增加任何条目', async () => {
+    mkdirSync(join(tmp, 'workflows'), { recursive: true });
+    const list = await listWorkflows();
+    expect(Array.isArray(list)).toBe(true);
+  });
+
+  it('cwd 下全是坏 yaml → 不抛，只跳过坏的', async () => {
+    mkdirSync(join(tmp, 'workflows'), { recursive: true });
+    writeYamlIn(tmp, 'bad1.yaml', 'name: x\n  : weird:::\n');
+    writeYamlIn(tmp, 'bad2.yaml', '@@@@@@\n');
+    const list = await listWorkflows();
+    // 不抛错，至少包内自带的仍然可见
+    expect(Array.isArray(list)).toBe(true);
+  });
+
+  it('/workflow unknown-name → yield error，无 workflow_start', async () => {
+    const events = await collect(
+      runWorkflowFromCommand('definitely-not-a-real-wf-xyz', {
+        provider: fakeProvider,
+        history: [],
+      }),
+    );
+    expect(events.some((e) => e.type === 'error')).toBe(true);
+    expect(events.some((e) => e.type === 'workflow_start')).toBe(false);
+  });
+
+  it('/workflow（不带 name）→ yield 用法提示 error', async () => {
+    const events = await collect(
+      runWorkflowFromCommand('', {
+        provider: fakeProvider,
+        history: [],
+      }),
+    );
+    const err = events.find(
+      (e): e is Extract<LoopEvent, { type: 'error' }> => e.type === 'error',
+    );
+    expect(err).toBeDefined();
+    expect(err!.error).toContain('/workflow');
+  });
+
+  it('/workflows 列表 yield text 事件 + turn_done', async () => {
+    const events = await collect(runWorkflowsList());
+    expect(events.some((e) => e.type === 'text')).toBe(true);
+    expect(events[events.length - 1].type).toBe('turn_done');
+  });
+
+  it('缺必填 input → yield error，不进入 runWorkflow', async () => {
+    // book-review-short 要求 book 必填
+    const events = await collect(
+      runWorkflowFromCommand('book-review-short', {
+        provider: fakeProvider,
+        history: [],
+      }),
+    );
+    const err = events.find(
+      (e): e is Extract<LoopEvent, { type: 'error' }> => e.type === 'error',
+    );
+    expect(err).toBeDefined();
+    expect(err!.error).toContain('book');
+    // 没有 workflow_start
+    expect(events.some((e) => e.type === 'workflow_start')).toBe(false);
+  });
+});
+
+function writeYamlIn(root: string, name: string, body: string) {
+  mkdirSync(join(root, 'workflows'), { recursive: true });
+  writeFileSync(join(root, 'workflows', name), body, 'utf8');
+}