@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/__tests__/harnesses/pi/PiSessionParser.test.ts

@@ -0,0 +1,280 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import { AgentStatus } from "../../../adapters/AgentAdapter.js";
+import { PiSessionParser } from "../../../harnesses/pi/PiSessionParser.js";
+
+describe("PiSessionParser", () => {
+  let tmpDir: string;
+  let parser: PiSessionParser;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-parser-test-"));
+    parser = new PiSessionParser();
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("reads session metadata, summary, timestamps, and status signal", () => {
+    const filePath = writeJsonl("session.jsonl", [
+      {
+        type: "session_meta",
+        timestamp: "2026-06-10T08:58:20.754Z",
+        sessionId: "sess-101",
+        cwd: "/repo/project-a",
+      },
+      { role: "user", timestamp: "2026-06-10T08:58:21.000Z", content: "implement Pi adapter" },
+      { role: "assistant", timestamp: new Date().toISOString(), content: "working on it" },
+    ]);
+
+    const session = parser.readSession(filePath);
+
+    expect(session).toMatchObject({
+      sessionId: "sess-101",
+      projectPath: "/repo/project-a",
+      summary: "implement Pi adapter",
+      lastRole: "assistant",
+    });
+    expect(session?.sessionStart.toISOString()).toBe("2026-06-10T08:58:20.754Z");
+    expect(parser.determineStatus(session!)).toBe(AgentStatus.WAITING);
+  });
+
+  it("uses the filename session id fallback and reports running when the latest message is from the user", () => {
+    const filePath = writeJsonl("plain-session.jsonl", [
+      { role: "user", timestamp: new Date().toISOString(), content: "still working" },
+    ]);
+
+    const session = parser.readSession(filePath);
+
+    expect(session).toMatchObject({
+      sessionId: "plain-session",
+      summary: "still working",
+      lastRole: "user",
+    });
+    expect(parser.determineStatus(session!)).toBe(AgentStatus.RUNNING);
+  });
+
+  it("truncates long user prompts in detected session summaries", () => {
+    const longPrompt = "x".repeat(140);
+    const filePath = writeJsonl("session.jsonl", [
+      {
+        type: "session",
+        timestamp: "2026-06-10T08:58:20.754Z",
+        id: "sess-long",
+        cwd: "/repo/project-long-summary",
+      },
+      { role: "user", timestamp: "2026-06-10T08:58:21.000Z", content: longPrompt },
+    ]);
+
+    const session = parser.readSession(filePath);
+
+    expect(session?.summary).toHaveLength(120);
+    expect(session?.summary.endsWith("...")).toBe(true);
+  });
+
+  it("reads user and assistant conversation messages from JSONL", () => {
+    const filePath = writeJsonl("conversation.jsonl", [
+      { role: "system", timestamp: "2026-06-10T08:58:20.000Z", content: "hidden" },
+      { role: "user", timestamp: "2026-06-10T08:58:21.000Z", content: "hello pi" },
+      {
+        type: "assistant",
+        timestamp: "2026-06-10T08:58:22.000Z",
+        message: { content: "hello human" },
+      },
+      "{not json",
+    ]);
+
+    expect(parser.getConversation(filePath)).toEqual([
+      { role: "user", content: "hello pi", timestamp: "2026-06-10T08:58:21.000Z" },
+      { role: "assistant", content: "hello human", timestamp: "2026-06-10T08:58:22.000Z" },
+    ]);
+  });
+
+  it("includes system entries only in verbose conversation mode", () => {
+    const filePath = writeJsonl("verbose.jsonl", [
+      { role: "system", timestamp: "2026-06-10T08:58:20.000Z", content: "model changed" },
+      { role: "user", timestamp: "2026-06-10T08:58:21.000Z", content: "visible" },
+    ]);
+
+    expect(parser.getConversation(filePath)).toEqual([
+      { role: "user", content: "visible", timestamp: "2026-06-10T08:58:21.000Z" },
+    ]);
+    expect(parser.getConversation(filePath, { verbose: true })).toEqual([
+      { role: "system", content: "model changed", timestamp: "2026-06-10T08:58:20.000Z" },
+      { role: "user", content: "visible", timestamp: "2026-06-10T08:58:21.000Z" },
+    ]);
+  });
+
+  it("reads real Pi message entries with nested role and text parts", () => {
+    const filePath = writeJsonl("real.jsonl", [
+      {
+        type: "session",
+        version: 3,
+        id: "sess-real",
+        timestamp: "2026-06-10T13:27:17.581Z",
+        cwd: "/repo/project-real",
+      },
+      {
+        type: "model_change",
+        id: "model-1",
+        timestamp: "2026-06-10T13:27:17.655Z",
+        modelId: "claude-sonnet-4-6",
+      },
+      {
+        type: "message",
+        id: "msg-user",
+        timestamp: "2026-06-10T13:27:37.975Z",
+        message: {
+          role: "user",
+          content: [{ type: "text", text: "hello" }],
+          timestamp: 1781098057974,
+        },
+      },
+      {
+        type: "message",
+        id: "msg-assistant",
+        timestamp: "2026-06-10T13:27:40.161Z",
+        message: {
+          role: "assistant",
+          content: [{ type: "text", text: "Hello! How can I help you today?" }],
+          provider: "anthropic",
+          model: "claude-sonnet-4-6",
+          timestamp: 1781098058012,
+        },
+      },
+    ]);
+
+    expect(parser.getConversation(filePath)).toEqual([
+      { role: "user", content: "hello", timestamp: "2026-06-10T13:27:37.975Z" },
+      {
+        role: "assistant",
+        content: "Hello! How can I help you today?",
+        timestamp: "2026-06-10T13:27:40.161Z",
+      },
+    ]);
+    expect(parser.readSession(filePath)).toMatchObject({
+      sessionId: "sess-real",
+      summary: "hello",
+      lastActive: new Date("2026-06-10T13:27:40.161Z"),
+    });
+  });
+
+  it("builds historical summaries from the first user message", () => {
+    const filePath = writeJsonl("summary.jsonl", [
+      { timestamp: "2026-06-10T08:58:20.754Z", sessionId: "sess-g", cwd: "/repo/project-g" },
+      { role: "user", timestamp: "2026-06-10T08:58:21.000Z", content: "first matching message" },
+    ]);
+
+    expect(parser.fileToSessionSummary(filePath)).toMatchObject({
+      type: "pi",
+      sessionId: "sess-g",
+      cwd: "/repo/project-g",
+      firstUserMessage: "first matching message",
+      sessionFilePath: filePath,
+    });
+  });
+
+  describe("readSessionIncremental", () => {
+    const fixtures: Array<Array<Record<string, unknown> | string>> = [
+      [
+        { type: "session", id: "sess-a", timestamp: "2026-06-10T08:58:20.754Z", cwd: "/repo/a" },
+        { role: "system", timestamp: "2026-06-10T08:58:21.000Z", content: "model changed" },
+        { role: "user", timestamp: "2026-06-10T08:58:22.000Z", content: "first" },
+        { role: "assistant", timestamp: "2026-06-10T08:58:23.000Z", content: "reply" },
+        { role: "user", timestamp: "bad-date", content: "x".repeat(200) },
+        { role: "system", content: "trailing system" },
+      ],
+      [{ role: "user", content: "no timestamps or id" }, "{not json", "[1,2]", "42"],
+      [
+        {
+          payload: { sessionId: "nested", cwd: "/repo/nested", timestamp: "2026-06-10T08:00:00Z" },
+        },
+        { data: { role: "assistant", content: [{ type: "text", text: "nested reply" }] } },
+      ],
+      ["{not json", "   "],
+    ];
+
+    it.each(fixtures.map((entries, index) => [index, entries] as const))(
+      "matches readSession for fixture %i",
+      (_index, entries) => {
+        const filePath = writeJsonl("equivalence.jsonl", entries);
+        expect(parser.readSessionIncremental(filePath, "/fallback")).toEqual(
+          parser.readSession(filePath, "/fallback"),
+        );
+      },
+    );
+
+    it("folds appended lines into the cached summary", () => {
+      const filePath = writeJsonl("append.jsonl", [
+        { type: "session", id: "sess-append", timestamp: "2026-06-10T08:58:20.754Z", cwd: "/r" },
+        { role: "user", timestamp: "2026-06-10T08:58:21.000Z", content: "before" },
+      ]);
+      expect(parser.readSessionIncremental(filePath)?.summary).toBe("before");
+
+      const next = { role: "user", timestamp: "2026-06-10T09:00:00.000Z", content: "after" };
+      fs.appendFileSync(filePath, `\n${JSON.stringify(next)}\n`);
+
+      const session = parser.readSessionIncremental(filePath);
+      expect(session).toEqual(parser.readSession(filePath));
+      expect(session).toMatchObject({ summary: "after", sessionId: "sess-append" });
+    });
+  });
+
+  describe("readSessionHead", () => {
+    it("stops reading once the header gives session id and cwd", () => {
+      const filePath = writeJsonl("head.jsonl", [
+        { type: "session", id: "sess-head", timestamp: "2026-06-10T08:58:20.754Z", cwd: "/repo/h" },
+        ...Array.from({ length: 5000 }, (_, i) => ({ role: "assistant", content: `line ${i}` })),
+      ]);
+
+      const head = parser.readSessionHead(filePath);
+
+      expect(head).toMatchObject({ sessionId: "sess-head", projectPath: "/repo/h" });
+      expect(head?.complete).toBe(false);
+      expect(head!.bytesRead).toBeLessThanOrEqual(4 * 1024);
+    });
+
+    it("never reads more than the byte cap", () => {
+      const filePath = writeJsonl(
+        "no-header.jsonl",
+        Array.from({ length: 5000 }, (_, i) => ({ role: "assistant", content: `line ${i}` })),
+      );
+      expect(fs.statSync(filePath).size).toBeGreaterThan(64 * 1024);
+
+      expect(parser.readSessionHead(filePath)).toEqual({ bytesRead: 64 * 1024, complete: false });
+      expect(parser.readSessionHead(filePath, 1000)?.bytesRead).toBe(1000);
+    });
+
+    it("uses an unterminated last line only when it ends the file", () => {
+      const whole = writeJsonl("whole.jsonl", [{ id: "sess-whole", cwd: "/repo/whole" }]);
+      expect(parser.readSessionHead(whole)).toMatchObject({
+        sessionId: "sess-whole",
+        projectPath: "/repo/whole",
+        complete: true,
+      });
+
+      const cut = writeJsonl("cut.jsonl", [
+        { id: "sess-cut", cwd: "/repo/cut", pad: "y".repeat(50) },
+      ]);
+      expect(parser.readSessionHead(cut, 20)).toEqual({ bytesRead: 20, complete: false });
+    });
+
+    it("returns null for a missing file", () => {
+      expect(parser.readSessionHead(path.join(tmpDir, "missing.jsonl"))).toBeNull();
+    });
+  });
+
+  function writeJsonl(name: string, entries: Array<Record<string, unknown> | string>): string {
+    const filePath = path.join(tmpDir, name);
+    fs.writeFileSync(
+      filePath,
+      entries
+        .map((entry) => (typeof entry === "string" ? entry : JSON.stringify(entry)))
+        .join("\n"),
+    );
+    return filePath;
+  }
+});

package/src/__tests__/harnesses/pi/PiSessionTracker.test.ts

@@ -0,0 +1,79 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import type { ProcessInfo } from "../../../adapters/AgentAdapter.js";
+import { PiSessionTracker } from "../../../harnesses/pi/PiSessionTracker.js";
+
+describe("PiSessionTracker", () => {
+  let tmpHome: string;
+  let sessionsDir: string;
+  let trackerPath: string;
+  let tracker: PiSessionTracker;
+
+  beforeEach(() => {
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), "pi-tracker-test-"));
+    sessionsDir = path.join(tmpHome, ".pi", "agent", "sessions");
+    trackerPath = path.join(tmpHome, ".pi", "agent", "sessions.json");
+    fs.mkdirSync(sessionsDir, { recursive: true });
+    tracker = new PiSessionTracker({ sessionsDir, trackerPath });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+  });
+
+  it("matches trusted tracker session files by PID", () => {
+    const proc = makeProcess({ pid: 101 });
+    const sessionFile = writeSessionFile("project-a/session.jsonl");
+    writeTracker({ 101: sessionFile });
+
+    expect(tracker.match([proc])).toEqual({
+      matches: [{ process: proc, filePath: sessionFile }],
+      fallback: [],
+    });
+  });
+
+  it("ignores malformed tracker metadata", () => {
+    const proc = makeProcess({ pid: 303 });
+    fs.writeFileSync(trackerPath, "{bad json");
+
+    expect(tracker.match([proc])).toEqual({
+      matches: [],
+      fallback: [proc],
+    });
+  });
+
+  it("does not trust tracker paths outside the Pi sessions directory", () => {
+    const proc = makeProcess({ pid: 404 });
+    const outside = path.join(tmpHome, "outside.jsonl");
+    fs.writeFileSync(outside, JSON.stringify({ role: "user", content: "nope" }));
+    writeTracker({ 404: outside });
+
+    expect(tracker.match([proc])).toEqual({
+      matches: [],
+      fallback: [proc],
+    });
+  });
+
+  function makeProcess(overrides: Partial<ProcessInfo>): ProcessInfo {
+    return {
+      pid: 1,
+      command: "pi",
+      cwd: "/repo",
+      tty: "ttys001",
+      ...overrides,
+    };
+  }
+
+  function writeTracker(entries: Record<number, string>): void {
+    fs.writeFileSync(trackerPath, JSON.stringify(entries));
+  }
+
+  function writeSessionFile(relativePath: string): string {
+    const filePath = path.join(sessionsDir, relativePath);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify({ role: "user", content: "hello" }));
+    return filePath;
+  }
+});

package/src/__tests__/harnesses/pi/durable/PiCliProbe.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it, vi } from "vitest";
+import { PiCliProbe } from "../../../../harnesses/pi/durable/PiCliProbe.js";
+
+describe("PiCliProbe", () => {
+  it("validates documented JSON mode and session capabilities", async () => {
+    const exec = vi
+      .fn()
+      .mockResolvedValueOnce({ stdout: "pi 0.52.8", stderr: "" })
+      .mockResolvedValueOnce({
+        stdout: "--mode json\n--session-id <uuid>\n--session <path|id>",
+        stderr: "",
+      });
+    await expect(new PiCliProbe({ executable: "fake-pi", exec }).validate()).resolves.toEqual({
+      executable: "fake-pi",
+      version: "pi 0.52.8",
+    });
+    expect(exec.mock.calls).toEqual([
+      ["fake-pi", ["--version"]],
+      ["fake-pi", ["--help"]],
+    ]);
+  });
+
+  it("rejects unsupported and unavailable CLIs with sanitized errors", async () => {
+    await expect(
+      new PiCliProbe({
+        exec: vi
+          .fn()
+          .mockResolvedValueOnce({ stdout: "", stderr: "" })
+          .mockResolvedValueOnce({ stdout: "--print only", stderr: "" }),
+      }).validate(),
+    ).rejects.toMatchObject({ code: "PI_CLI_UNSUPPORTED" });
+    const unavailable = new PiCliProbe({
+      exec: vi.fn().mockRejectedValue(new Error(`bad\0${"x".repeat(1000)}`)),
+    });
+    const error = await unavailable.validate().catch((value: Error & { code: string }) => value);
+    expect(error.code).toBe("PI_CLI_UNAVAILABLE");
+    expect(error.message).not.toContain("\0");
+    expect(error.message.length).toBeLessThan(600);
+  });
+
+  it("reports an empty version as unknown", async () => {
+    const exec = vi
+      .fn()
+      .mockResolvedValueOnce({ stdout: " \n", stderr: "" })
+      .mockResolvedValueOnce({ stdout: "--mode json --session-id --session", stderr: "" });
+    await expect(new PiCliProbe({ exec }).validate()).resolves.toMatchObject({
+      version: "unknown",
+    });
+  });
+});

package/src/__tests__/harnesses/pi/durable/PiPrintAgentService.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, it, vi } from "vitest";
+import { PiPrintError } from "../../../../durable/DurableAgent.js";
+import { PiPrintAgentService } from "../../../../harnesses/pi/durable/PiPrintAgentService.js";
+const SESSION = "22222222-2222-4222-8222-222222222222";
+const base = {
+  id: "id",
+  name: "reviewer",
+  provider: "pi",
+  providerSessionId: SESSION,
+  sessionHealth: "uninitialized",
+};
+
+describe("PiPrintAgentService", () => {
+  it("probes before provider-aware create", async () => {
+    const probe = { validate: vi.fn() };
+    const repository = { create: vi.fn().mockResolvedValue(base), list: vi.fn() };
+    const runner = { run: vi.fn() };
+    await new PiPrintAgentService({ repository, probe, runner }).create({
+      name: "reviewer",
+      cwd: "/project",
+    });
+    expect(probe.validate).toHaveBeenCalledOnce();
+    expect(repository.create).toHaveBeenCalledWith({
+      name: "reviewer",
+      cwd: "/project",
+      provider: "pi",
+    });
+  });
+
+  it("records successful first and resumed sends", async () => {
+    const repository = {
+      list: vi.fn(),
+      resolve: vi.fn().mockResolvedValue(base),
+      acquireRun: vi
+        .fn()
+        .mockResolvedValueOnce({ agent: base, token: "one" })
+        .mockResolvedValueOnce({ agent: { ...base, sessionHealth: "healthy" }, token: "two" }),
+      recordProviderProcess: vi.fn(),
+      completeRun: vi.fn(),
+    };
+    const runner = {
+      run: vi.fn(async (request) => {
+        await request.onSpawn({ pid: 42, startedAt: "start" });
+        return { sessionId: SESSION, result: "answer", messages: ["answer"], exitCode: 0 };
+      }),
+    };
+    const service = new PiPrintAgentService({ repository, probe: { validate: vi.fn() }, runner });
+    await service.send("reviewer", "first");
+    await service.send("reviewer", "later");
+    expect(repository.completeRun).toHaveBeenCalledWith(
+      "id",
+      "one",
+      expect.objectContaining({ status: "succeeded", sessionHealth: "healthy" }),
+    );
+  });
+
+  it("records mismatches and rejects missing and ambiguous records", async () => {
+    const completeRun = vi.fn();
+    const repository = {
+      list: vi.fn(),
+      resolve: vi.fn().mockResolvedValue(base),
+      acquireRun: vi.fn().mockResolvedValue({ agent: base, token: "one" }),
+      recordProviderProcess: vi.fn(),
+      completeRun,
+    };
+    await expect(
+      new PiPrintAgentService({
+        repository,
+        probe: { validate: vi.fn() },
+        runner: { run: vi.fn().mockRejectedValue(new PiPrintError("bad", "PI_SESSION_MISMATCH")) },
+      }).send("reviewer", "x"),
+    ).rejects.toMatchObject({ code: "PI_SESSION_MISMATCH" });
+    expect(completeRun).toHaveBeenCalledWith(
+      "id",
+      "one",
+      expect.objectContaining({ sessionHealth: "mismatch" }),
+    );
+    const earlyRepository = {
+      ...repository,
+      resolve: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce([base, base]),
+      acquireRun: vi.fn(),
+    };
+    const early = new PiPrintAgentService({
+      repository: earlyRepository,
+      probe: { validate: vi.fn() },
+      runner: { run: vi.fn() },
+    });
+    await expect(early.send("missing", "x")).rejects.toMatchObject({
+      code: "DURABLE_AGENT_NOT_FOUND",
+    });
+    await expect(early.send("many", "x")).rejects.toMatchObject({ code: "PI_UNSUPPORTED" });
+  });
+
+  it("rejects a non-Pi target without acquiring or mutating it", async () => {
+    const repository = {
+      resolve: vi.fn().mockResolvedValue({ ...base, provider: "claude" }),
+      acquireRun: vi.fn(),
+      recordProviderProcess: vi.fn(),
+      completeRun: vi.fn(),
+    };
+
+    await expect(
+      new PiPrintAgentService({
+        repository,
+        probe: { validate: vi.fn() },
+        runner: { run: vi.fn() },
+      }).send("reviewer", "x"),
+    ).rejects.toMatchObject({ code: "PI_UNSUPPORTED" });
+    expect(repository.acquireRun).not.toHaveBeenCalled();
+    expect(repository.completeRun).not.toHaveBeenCalled();
+  });
+
+  it("does not turn a successful completion write failure into a second completion", async () => {
+    const completionFailure = new Error("completion failed");
+    const repository = {
+      resolve: vi.fn().mockResolvedValue(base),
+      acquireRun: vi.fn().mockResolvedValue({ agent: base, token: "one" }),
+      recordProviderProcess: vi.fn(),
+      completeRun: vi.fn().mockRejectedValue(completionFailure),
+    };
+    const runner = {
+      run: vi.fn().mockResolvedValue({
+        sessionId: SESSION,
+        result: "answer",
+        messages: ["answer"],
+        exitCode: 0,
+      }),
+    };
+
+    await expect(
+      new PiPrintAgentService({ repository, probe: { validate: vi.fn() }, runner }).send(
+        "reviewer",
+        "x",
+      ),
+    ).rejects.toBe(completionFailure);
+    expect(repository.completeRun).toHaveBeenCalledOnce();
+  });
+});

package/src/__tests__/harnesses/pi/durable/PiPrintProtocol.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildPiPrintArgs,
+  readPiAssistantText,
+  readPiSessionId,
+} from "../../../../harnesses/pi/durable/PiPrintProtocol.js";
+
+const SESSION = "22222222-2222-4222-8222-222222222222";
+
+describe("Pi print pure protocol mapping", () => {
+  it("maps first and resumed runs to exact documented arguments", () => {
+    expect(buildPiPrintArgs(SESSION, true)).toEqual(["--mode", "json", "--session-id", SESSION]);
+    expect(buildPiPrintArgs(SESSION, false)).toEqual(["--mode", "json", "--session", SESSION]);
+  });
+
+  it("accepts one expected UUID and rejects invalid, duplicate, and mismatched identities", () => {
+    expect(readPiSessionId({ id: SESSION }, null, SESSION)).toBe(SESSION);
+    expect(() => readPiSessionId({}, null, SESSION)).toThrowError(
+      expect.objectContaining({ code: "PI_PROTOCOL" }),
+    );
+    expect(() => readPiSessionId({ id: [SESSION] }, null, SESSION)).toThrowError(
+      expect.objectContaining({ code: "PI_PROTOCOL" }),
+    );
+    expect(() => readPiSessionId({ id: SESSION }, SESSION, SESSION)).toThrowError(
+      expect.objectContaining({ code: "PI_PROTOCOL" }),
+    );
+    expect(() =>
+      readPiSessionId({ id: "33333333-3333-4333-8333-333333333333" }, null, SESSION),
+    ).toThrowError(expect.objectContaining({ code: "PI_SESSION_MISMATCH" }));
+  });
+
+  it("extracts only non-empty completed assistant text", () => {
+    expect(readPiAssistantText({ type: "future" })).toBeNull();
+    expect(readPiAssistantText({ type: "message_end" })).toBeNull();
+    expect(readPiAssistantText({ type: "message_end", message: [] })).toBeNull();
+    expect(
+      readPiAssistantText({ type: "message_end", message: { role: "user", content: "no" } }),
+    ).toBeNull();
+    expect(
+      readPiAssistantText({ type: "message_end", message: { role: "assistant", content: " " } }),
+    ).toBeNull();
+    expect(
+      readPiAssistantText({
+        type: "message_end",
+        message: { role: "assistant", content: "answer" },
+      }),
+    ).toBe("answer");
+    expect(
+      readPiAssistantText({ type: "message_end", message: { role: "assistant", content: null } }),
+    ).toBeNull();
+    expect(
+      readPiAssistantText({
+        type: "message_end",
+        message: { role: "assistant", content: [null, [], { type: "thinking" }] },
+      }),
+    ).toBeNull();
+    expect(
+      readPiAssistantText({
+        type: "message_end",
+        message: {
+          role: "assistant",
+          content: [
+            { type: "text", text: "a" },
+            { type: "text", text: 1 },
+            { type: "text", text: "b" },
+          ],
+        },
+      }),
+    ).toBe("ab");
+  });
+});