@zhushanwen/subagent-core 0.2.0

package/src/__tests__/robustness-medium-batch4.test.ts

@@ -0,0 +1,358 @@
+// Medium batch 4: M4 IPC 字段校验（行为测试）
+//
+// M4: dispatchAgentCall / dispatchWorkflowCall 在函数最开头校验 IPC 消息字段
+// （callId 非数字、opts/args 非对象、prompt/name 非字符串），畸形消息仅记日志后 return，
+// 不抛 TypeError、不写 trace 节点、不 postMessage 回 worker。
+//
+// 通过 handleWorkerMessage 触发 dispatchAgentCall / dispatchWorkflowCall（内部函数不 export）。
+// Mock 构造模式参考 orchestration/__tests__/agent-call-catch-fallback.test.ts 和
+// orchestration/__tests__/error-recovery-workflow-call.test.ts。
+
+import { describe, expect, it, vi } from "vitest";
+
+// Mock 共享 logger，让 logger.error 可被 spy（源码已从 console.error 改为 logger.error）
+const { loggerMock } = vi.hoisted(() => ({
+  loggerMock: {
+    debug: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+vi.mock("../core/logger.ts", () => ({
+  getLogger: () => loggerMock,
+}));
+
+import { handleWorkerMessage } from "../orchestration/error-recovery.ts";
+import type { LifecycleDeps, WorkerHandlers } from "../orchestration/models/ports.ts";
+import { Trace } from "../orchestration/models/trace.ts";
+import type { AgentResult } from "../orchestration/models/types.ts";
+import type { WorkflowRun } from "../orchestration/models/workflow-run.ts";
+
+// ── helpers ──────────────────────────────────────────────────
+
+/** 构造 status="running" 的 mock WorkflowRun，含 trace/budget/calls/runtime。
+ *  与 agent-call-catch-fallback.test.ts 同构。 */
+function makeRunningRun(runId: string): WorkflowRun {
+  const trace = new Trace();
+  const controller = new AbortController();
+  return {
+    runId,
+    spec: { scriptName: "test-wf", scriptSource: "agent('hi')", args: {}, runId, slug: undefined },
+    state: {
+      status: "running" as const,
+      reason: undefined,
+      trace,
+      budget: {
+        usedTokens: 0,
+        usedCost: 0,
+        totalCallCount: 0,
+        consume: vi.fn(),
+        isExceeded: vi.fn(() => false),
+        incrementCallCount: vi.fn(),
+      },
+      calls: new Map(),
+      scriptResult: undefined,
+    },
+    meta: { startedAt: new Date().toISOString(), workerErrorCount: 0, scriptErrorCount: 0 },
+    runtime: {
+      controller,
+      worker: { postMessage: vi.fn() },
+    },
+    transition: vi.fn(),
+    replaceRuntime: vi.fn(),
+  } as unknown as WorkflowRun;
+}
+
+/** LifecycleDeps mock——runner.run 默认成功。 */
+function makeDeps(): LifecycleDeps {
+  const runnerRun = vi.fn(async () => {
+    return { content: "OK", durationMs: 10, error: undefined, toolCalls: [] } as AgentResult;
+  });
+  return {
+    store: { save: vi.fn(async () => {}) },
+    workerHost: { start: vi.fn() },
+    runner: { run: runnerRun },
+    runs: new Map(),
+    eventBus: { emit: vi.fn() },
+    onRunDone: vi.fn(),
+    log: vi.fn(),
+  } as unknown as LifecycleDeps;
+}
+
+function makeHandlers(): WorkerHandlers {
+  return {
+    onMessage: vi.fn(async () => {}),
+    onError: vi.fn(async () => {}),
+    onExit: vi.fn(async () => {}),
+  } as unknown as WorkerHandlers;
+}
+
+/** 清空 logger.error 调用记录（校验失败会打印 malformed 消息日志，避免污染跨用例断言）。 */
+function silenceConsoleError(): () => void {
+  loggerMock.error.mockClear();
+  return () => {
+    loggerMock.error.mockClear();
+  };
+}
+
+// ── M4: dispatchAgentCall 字段校验 ───────────────────────────
+
+describe("M4: dispatchAgentCall validates IPC fields before dereferencing", () => {
+  it("callId 非数字 → 不抛、不写 trace 节点、不 postMessage", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const run = makeRunningRun("wf-m4-001");
+      const deps = makeDeps();
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      // callId = "not-a-number"（字符串）
+      await handleWorkerMessage(
+        run,
+        { type: "agent-call", callId: "not-a-number", opts: { prompt: "test" } },
+        deps,
+        makeHandlers(),
+      );
+
+      expect(run.state.trace.toArray().length).toBe(0);
+      expect(run.state.calls.size).toBe(0);
+      expect(postMessage).not.toHaveBeenCalled();
+      expect(deps.store.save).not.toHaveBeenCalled();
+    } finally {
+      restore();
+    }
+  });
+
+  it("opts 为 null → 不抛、不写 trace 节点", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const run = makeRunningRun("wf-m4-002");
+      const deps = makeDeps();
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      await handleWorkerMessage(
+        run,
+        { type: "agent-call", callId: 1, opts: null },
+        deps,
+        makeHandlers(),
+      );
+
+      expect(run.state.trace.toArray().length).toBe(0);
+      expect(run.state.calls.size).toBe(0);
+      expect(postMessage).not.toHaveBeenCalled();
+    } finally {
+      restore();
+    }
+  });
+
+  it("opts.prompt 非字符串（数字）→ 不抛、不写 trace 节点", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const run = makeRunningRun("wf-m4-003");
+      const deps = makeDeps();
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      await handleWorkerMessage(
+        run,
+        { type: "agent-call", callId: 1, opts: { prompt: 123 } },
+        deps,
+        makeHandlers(),
+      );
+
+      expect(run.state.trace.toArray().length).toBe(0);
+      expect(run.state.calls.size).toBe(0);
+      expect(postMessage).not.toHaveBeenCalled();
+    } finally {
+      restore();
+    }
+  });
+
+  it("opts 缺失（undefined）→ 不抛、不写 trace 节点", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const run = makeRunningRun("wf-m4-004");
+      const deps = makeDeps();
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      await handleWorkerMessage(
+        run,
+        { type: "agent-call", callId: 1, opts: undefined },
+        deps,
+        makeHandlers(),
+      );
+
+      expect(run.state.trace.toArray().length).toBe(0);
+      expect(run.state.calls.size).toBe(0);
+      expect(postMessage).not.toHaveBeenCalled();
+    } finally {
+      restore();
+    }
+  });
+
+  it("callId 非有限数（NaN）→ 不抛、不写 trace 节点", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const run = makeRunningRun("wf-m4-005");
+      const deps = makeDeps();
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      await handleWorkerMessage(
+        run,
+        { type: "agent-call", callId: NaN, opts: { prompt: "test" } },
+        deps,
+        makeHandlers(),
+      );
+
+      expect(run.state.trace.toArray().length).toBe(0);
+      expect(run.state.calls.size).toBe(0);
+      expect(postMessage).not.toHaveBeenCalled();
+    } finally {
+      restore();
+    }
+  });
+
+  it("正常消息 → 正常派发（trace 节点创建）", async () => {
+    const run = makeRunningRun("wf-m4-006");
+    const deps = makeDeps();
+
+    await handleWorkerMessage(
+      run,
+      { type: "agent-call", callId: 1, opts: { prompt: "test", description: "test-agent" } },
+      deps,
+      makeHandlers(),
+    );
+
+    // 正常消息应创建 trace 节点（status=running，等待异步执行）
+    const nodes = run.state.trace.toArray();
+    expect(nodes.length).toBeGreaterThan(0);
+    expect(nodes[0]!.stepIndex).toBe(1);
+    expect(nodes[0]!.task).toBe("test");
+    expect(nodes[0]!.agent).toBe("test-agent");
+    // call 已入 run.state.calls
+    expect(run.state.calls.size).toBeGreaterThan(0);
+  });
+
+  it("校验失败打印 malformed 日志（含 callId）", async () => {
+    loggerMock.error.mockClear();
+    try {
+      const run = makeRunningRun("wf-m4-007");
+      const deps = makeDeps();
+
+      await handleWorkerMessage(
+        run,
+        { type: "agent-call", callId: "bad", opts: { prompt: "test" } },
+        deps,
+        makeHandlers(),
+      );
+
+      expect(loggerMock.error).toHaveBeenCalled();
+      const logged = String(loggerMock.error.mock.calls[0]![0]);
+      expect(logged).toContain("malformed agent-call");
+      expect(logged).toContain('"bad"');
+    } finally {
+      loggerMock.error.mockClear();
+    }
+  });
+});
+
+// ── M4: dispatchWorkflowCall 字段校验 ────────────────────────
+
+describe("M4: dispatchWorkflowCall validates IPC fields before dereferencing", () => {
+  it("callId 非数字 → 不抛、不 postMessage", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const run = makeRunningRun("wf-m4-w-001");
+      const deps = { onWorkflowCall: vi.fn(async () => ({ content: "ok" })) } as unknown as LifecycleDeps;
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      await handleWorkerMessage(
+        run,
+        { type: "workflow-call", callId: "bad", name: "sub", args: {} },
+        deps,
+        makeHandlers(),
+      );
+
+      expect(deps.onWorkflowCall).not.toHaveBeenCalled();
+      expect(postMessage).not.toHaveBeenCalled();
+    } finally {
+      restore();
+    }
+  });
+
+  it("name 非字符串 → 不抛、不 postMessage", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const run = makeRunningRun("wf-m4-w-002");
+      const deps = { onWorkflowCall: vi.fn(async () => ({ content: "ok" })) } as unknown as LifecycleDeps;
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      await handleWorkerMessage(
+        run,
+        { type: "workflow-call", callId: 1, name: 42, args: {} },
+        deps,
+        makeHandlers(),
+      );
+
+      expect(deps.onWorkflowCall).not.toHaveBeenCalled();
+      expect(postMessage).not.toHaveBeenCalled();
+    } finally {
+      restore();
+    }
+  });
+
+  it("args 为 null → 不抛、不 postMessage", async () => {
+    const restore = silenceConsoleError();
+    try {
+      const run = makeRunningRun("wf-m4-w-003");
+      const deps = { onWorkflowCall: vi.fn(async () => ({ content: "ok" })) } as unknown as LifecycleDeps;
+      const postMessage = run.runtime!.worker.postMessage as ReturnType<typeof vi.fn>;
+
+      await handleWorkerMessage(
+        run,
+        { type: "workflow-call", callId: 1, name: "sub", args: null },
+        deps,
+        makeHandlers(),
+      );
+
+      expect(deps.onWorkflowCall).not.toHaveBeenCalled();
+      expect(postMessage).not.toHaveBeenCalled();
+    } finally {
+      restore();
+    }
+  });
+
+  it("校验失败打印 malformed 日志", async () => {
+    loggerMock.error.mockClear();
+    try {
+      const run = makeRunningRun("wf-m4-w-004");
+      const deps = { onWorkflowCall: vi.fn(async () => ({ content: "ok" })) } as unknown as LifecycleDeps;
+
+      await handleWorkerMessage(
+        run,
+        { type: "workflow-call", callId: "bad", name: 42, args: {} },
+        deps,
+        makeHandlers(),
+      );
+
+      expect(loggerMock.error).toHaveBeenCalled();
+      const logged = String(loggerMock.error.mock.calls[0]![0]);
+      expect(logged).toContain("malformed workflow-call");
+    } finally {
+      loggerMock.error.mockClear();
+    }
+  });
+
+  it("正常消息 → 正常派发（onWorkflowCall 被调用）", async () => {
+    const run = makeRunningRun("wf-m4-w-005");
+    const onWorkflowCall = vi.fn(async () => ({ content: "ok" }));
+    const deps = { onWorkflowCall } as unknown as LifecycleDeps;
+
+    await handleWorkerMessage(
+      run,
+      { type: "workflow-call", callId: 1, name: "sub", args: { k: 1 } },
+      deps,
+      makeHandlers(),
+    );
+
+    expect(onWorkflowCall).toHaveBeenCalledWith("sub", { k: 1 }, run);
+  });
+});

package/src/__tests__/session-runner.test.ts

@@ -0,0 +1,69 @@
+/**
+ * session-runner message_update 分流测试。
+ *
+ * 核心回归点：toolcall_delta（工具入参 JSON 增量）不得被当成 text_delta
+ * forward 到 subagent overlay 的 streaming content——否则 assistant 正文会
+ * 原样流出 {"path":"..."}{"command":"..."} 工具参数 JSON 串，表现为对话末尾
+ * JSON 与 text 混杂、无 ICON+title 工具卡片前缀（用户实际报告的现象）。
+ *
+ * 根因：pi-ai AssistantMessageEvent 的 type 集合含 text_delta / thinking_delta /
+ * toolcall_delta / signature_delta 等（见 @earendil-works/pi-ai types.d.ts）。
+ * 旧实现 `ame?.delta !== undefined` 反向排除（只拦 thinking_delta），toolcall_delta
+ * 因带 delta 字段被误判为 text_delta。正向判定（只放行 text_delta）根治。
+ */
+import { describe, it, expect } from "vitest";
+import { mapAssistantMessageDelta } from "../execution/session-runner.js";
+
+describe("mapAssistantMessageDelta: assistantMessageEvent → streaming 事件分流", () => {
+  it("text_delta → forward 为 text_delta", () => {
+    expect(mapAssistantMessageDelta({ type: "text_delta", delta: "hello" })).toEqual({
+      type: "text_delta",
+      delta: "hello",
+    });
+  });
+
+  it("thinking_delta → forward 为 thinking_delta（走独立通道，不进 text stream）", () => {
+    expect(mapAssistantMessageDelta({ type: "thinking_delta", delta: "思考" })).toEqual({
+      type: "thinking_delta",
+      delta: "思考",
+    });
+  });
+
+  it("thinking_delta 缺 delta 兜底空串（不抛错，与旧实现行为一致）", () => {
+    expect(mapAssistantMessageDelta({ type: "thinking_delta" })).toEqual({
+      type: "thinking_delta",
+      delta: "",
+    });
+  });
+
+  it("toolcall_delta → null（工具入参 JSON 增量绝不混入 text）", () => {
+    // 核心回归：旧实现 ame?.delta !== undefined 会把 toolcall_delta 当 text_delta
+    expect(mapAssistantMessageDelta({ type: "toolcall_delta", delta: '{"path":"/x"}' })).toBeNull();
+  });
+
+  it("toolcall_delta 的部分 JSON 片段也不混入（流式累积的中间态）", () => {
+    expect(mapAssistantMessageDelta({ type: "toolcall_delta", delta: '{"path":"' })).toBeNull();
+    expect(mapAssistantMessageDelta({ type: "toolcall_delta", delta: "/Users/foo/bar" })).toBeNull();
+    expect(mapAssistantMessageDelta({ type: "toolcall_delta", delta: '"}}' })).toBeNull();
+  });
+
+  it("其他带 delta 的 type（signature_delta 等未来扩展）也不混入 text", () => {
+    expect(mapAssistantMessageDelta({ type: "signature_delta", delta: "sig-xyz" })).toBeNull();
+  });
+
+  it("非 delta 事件（start/end/done 等）返回 null", () => {
+    expect(mapAssistantMessageDelta({ type: "text_start" })).toBeNull();
+    expect(mapAssistantMessageDelta({ type: "text_end" })).toBeNull();
+    expect(mapAssistantMessageDelta({ type: "toolcall_start" })).toBeNull();
+    expect(mapAssistantMessageDelta({ type: "toolcall_end" })).toBeNull();
+    expect(mapAssistantMessageDelta({ type: "done" })).toBeNull();
+  });
+
+  it("缺 type 或缺 delta 的异常输入返回 null（不抛错）", () => {
+    expect(mapAssistantMessageDelta({})).toBeNull();
+    // text_delta 缺 delta → null（无法 forward 空 delta 增量）
+    expect(mapAssistantMessageDelta({ type: "text_delta" })).toBeNull();
+    // 有 delta 无 type → null（未知来源，不放行）
+    expect(mapAssistantMessageDelta({ delta: "x" })).toBeNull();
+  });
+});

package/src/__tests__/smoke.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+
+import { CORE_PACKAGE_VERSION } from "../index";
+
+describe("subagent-core scaffold smoke", () => {
+  it("exposes CORE_PACKAGE_VERSION", () => {
+    expect(CORE_PACKAGE_VERSION).toBe("0.1.0");
+  });
+});

package/src/__tests__/stream-sink.test.ts

@@ -0,0 +1,203 @@
+/**
+ * SubagentStream — text_delta streaming 生命周期测试。
+ *
+ * 覆盖：
+ * - leading edge：第一个 delta 立即 flush
+ * - trailing edge：100ms 内多个 delta 合并为一次 flush
+ * - 多行文本：delta 含换行符时 split("\n") 正确
+ * - dispose：清除 widget + 清 timer（幂等）
+ * - dispose 后 onDelta 静默丢弃
+ * - widgetKey 格式（subagent-stream-<recordId>）
+ *
+ * SubagentStream 内聚 buffer/timer 状态，通过 StreamSink 接口输出。
+ * 测试用 mock sink 收集 setWidget 调用，vi.useFakeTimers 控制合并窗口时序。
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { type StreamSink, SubagentStream } from "../execution/stream-sink.ts";
+
+/** mock sink：收集所有 setWidget 调用，便于断言。 */
+function createMockSink(): StreamSink & { calls: { key: string; lines: string[] | undefined }[] } {
+  const calls: { key: string; lines: string[] | undefined }[] = [];
+  return {
+    calls,
+    setWidget(key: string, lines: string[] | undefined): void {
+      calls.push({ key, lines });
+    },
+  };
+}
+
+describe("SubagentStream", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  // ============================================================
+  // U1: leading edge — 第一个 delta 立即触发 flush
+  // ============================================================
+  describe("leading edge", () => {
+    it("第一个 delta 立即 flush，不等 timer", () => {
+      const sink = createMockSink();
+      const stream = new SubagentStream("bg-test", sink);
+
+      stream.onDelta("Hello");
+
+      expect(sink.calls).toHaveLength(1);
+      expect(sink.calls[0]).toEqual({
+        key: "subagent-stream-bg-test",
+        lines: ["Hello"],
+      });
+    });
+  });
+
+  // ============================================================
+  // U2: trailing edge — 100ms 内多个 delta 合并为一次 flush
+  // ============================================================
+  describe("trailing edge", () => {
+    it("leading 之后的 delta 在 100ms 窗口内合并为一次 flush", () => {
+      const sink = createMockSink();
+      const stream = new SubagentStream("bg-merge", sink);
+
+      // leading flush
+      stream.onDelta("A");
+      expect(sink.calls).toHaveLength(1);
+
+      // trailing delta 进入 buffer，等 timer
+      stream.onDelta("B");
+      stream.onDelta("C");
+      expect(sink.calls).toHaveLength(1); // 还没 flush
+
+      // 推进 timer
+      vi.advanceTimersByTime(100);
+
+      expect(sink.calls).toHaveLength(2); // leading + trailing
+      expect(sink.calls[1]).toEqual({
+        key: "subagent-stream-bg-merge",
+        lines: ["ABC"], // 累积全文
+      });
+    });
+  });
+
+  // ============================================================
+  // U3: 多行文本 — delta 含换行符时 split 正确
+  // ============================================================
+  describe("多行文本", () => {
+    it("delta 含换行符 → widgetLines 按行拆分", () => {
+      const sink = createMockSink();
+      const stream = new SubagentStream("bg-multi", sink);
+
+      stream.onDelta("line1\nline2\nline3");
+
+      expect(sink.calls[0]).toEqual({
+        key: "subagent-stream-bg-multi",
+        lines: ["line1", "line2", "line3"],
+      });
+    });
+  });
+
+  // ============================================================
+  // U4: dispose — 清除 widget + 清 timer（幂等）
+  // ============================================================
+  describe("dispose", () => {
+    it("dispose 清除 widget（setWidget key, undefined）", () => {
+      const sink = createMockSink();
+      const stream = new SubagentStream("bg-disp", sink);
+
+      stream.onDelta("X"); // leading flush
+      stream.onDelta("Y"); // 开始 trailing timer
+      stream.dispose();
+
+      // dispose 调 setWidget(key, undefined) 清除 widget
+      const lastCall = sink.calls[sink.calls.length - 1];
+      expect(lastCall).toEqual({
+        key: "subagent-stream-bg-disp",
+        lines: undefined,
+      });
+    });
+
+    it("dispose 后 trailing timer 不再触发 flush", () => {
+      const sink = createMockSink();
+      const stream = new SubagentStream("bg-timer", sink);
+
+      stream.onDelta("X"); // leading flush
+      stream.onDelta("Y"); // 开始 trailing timer
+      stream.dispose(); // 清 timer
+
+      const callCountBefore = sink.calls.length;
+      vi.advanceTimersByTime(200); // timer 应已被清
+
+      expect(sink.calls.length).toBe(callCountBefore); // 无新 flush
+    });
+
+    it("dispose 幂等——二次调用静默无副作用", () => {
+      const sink = createMockSink();
+      const stream = new SubagentStream("bg-idem", sink);
+
+      stream.dispose();
+      const callCountAfterFirst = sink.calls.length;
+
+      stream.dispose(); // 二次 dispose
+      expect(sink.calls.length).toBe(callCountAfterFirst); // 无新调用
+    });
+  });
+
+  // ============================================================
+  // U5: dispose 后 onDelta 静默丢弃
+  // ============================================================
+  describe("dispose 后 onDelta", () => {
+    it("dispose 后调 onDelta 不触发任何 setWidget", () => {
+      const sink = createMockSink();
+      const stream = new SubagentStream("bg-late", sink);
+
+      stream.dispose();
+      const callCountAfterDispose = sink.calls.length;
+
+      stream.onDelta("late delta");
+      vi.advanceTimersByTime(200); // 确保没有延迟 flush
+
+      expect(sink.calls.length).toBe(callCountAfterDispose); // 无新调用
+    });
+  });
+
+  // ============================================================
+  // U6: widgetKey 格式
+  // ============================================================
+  describe("widgetKey 格式", () => {
+    it("widgetKey = subagent-stream-<recordId>", () => {
+      const sink = createMockSink();
+      const stream = new SubagentStream("bg-abc123", sink);
+
+      stream.onDelta("x");
+
+      expect(sink.calls[0]?.key).toBe("subagent-stream-bg-abc123");
+    });
+  });
+
+  // ============================================================
+  // U7: 空 delta 静默丢弃（不消耗 leading edge）
+  // ============================================================
+  describe("空 delta", () => {
+    it("空字符串 onDelta 不触发 setWidget", () => {
+      const sink = createMockSink();
+      const stream = new SubagentStream("bg-empty", sink);
+
+      stream.onDelta("");
+
+      expect(sink.calls).toHaveLength(0);
+    });
+
+    it("空 delta 不消耗 leading edge——后续真实 delta 仍立即 flush", () => {
+      const sink = createMockSink();
+      const stream = new SubagentStream("bg-empty", sink);
+
+      stream.onDelta("");   // 空串，不应消耗 leading
+      stream.onDelta("Hi"); // 首个真实 delta，应立即 flush
+
+      expect(sink.calls).toHaveLength(1);
+      expect(sink.calls[0]?.lines).toEqual(["Hi"]);
+    });
+  });
+});