@esso0428/pi-subagents 0.15.17 → 0.16.0

package/test/agent-history-list.test.ts

@@ -1,121 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  buildAgentStatusMenuEntries,
-  canOpenActiveAgent,
-  canOpenAgentHistory,
-  formatAgentHistoryOption,
-  isTerminalAgentStatus,
-  splitAgentRecords,
-} from "../src/agent-history-list.js";
-
-type TestRecord = {
-  status: string;
-  session?: object;
-  transcriptPath?: string;
-  type?: string;
-  description?: string;
-  startedAt?: number;
-  completedAt?: number;
-};
-
-const tempDirectories: string[] = [];
-
-afterEach(() => {
-  for (const directory of tempDirectories.splice(0)) {
-    rmSync(directory, { recursive: true, force: true });
-  }
-});
-
-function record(overrides: TestRecord): any {
-  return {
-    id: "agent-1",
-    type: "Explore",
-    description: "Inspect the repository",
-    status: "completed",
-    toolUses: 0,
-    startedAt: 1_000,
-    lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-    compactionCount: 0,
-    ...overrides,
-  };
-}
-
-describe("agent history list helpers", () => {
-  it("recognizes exactly the five terminal statuses", () => {
-    for (const status of ["completed", "steered", "stopped", "aborted", "error"]) {
-      expect(isTerminalAgentStatus(status)).toBe(true);
-    }
-    for (const status of ["running", "queued", "unknown", ""]) {
-      expect(isTerminalAgentStatus(status)).toBe(false);
-    }
-  });
-
-  it("separates active and terminal records without mutating input", () => {
-    const done = record({ status: "completed", session: {} });
-    const running = record({ status: "running", session: {} });
-    const stopped = record({ status: "stopped", session: {} });
-    const queued = record({ status: "queued", session: {} });
-    const input = [done, running, stopped, queued];
-    const before = [...input];
-
-    const result = splitAgentRecords(input, undefined);
-
-    expect(result.active).toEqual([running, queued]);
-    expect(result.history).toEqual([done, stopped]);
-    expect(input).toEqual(before);
-    expect(input).toEqual([done, running, stopped, queued]);
-  });
-
-  it("requires a session or existing transcript for history", () => {
-    expect(canOpenAgentHistory(record({ session: undefined }), undefined)).toBe(false);
-    expect(canOpenAgentHistory(record({ session: {} }), undefined)).toBe(true);
-    expect(canOpenAgentHistory(record({ status: "running", session: {} }), undefined)).toBe(false);
-    expect(canOpenActiveAgent(record({ status: "running", session: {} }))).toBe(true);
-    expect(canOpenActiveAgent(record({ status: "queued", session: undefined }))).toBe(false);
-    expect(canOpenActiveAgent(record({ status: "completed", session: {} }))).toBe(false);
-  });
-
-  it("opens history only for an existing project-local transcript", () => {
-    const cwd = mkdtempSync(join(tmpdir(), "pi-subagents-history-list-"));
-    tempDirectories.push(cwd);
-    const transcriptPath = ".pi-subagents/agent-transcripts/agent.jsonl";
-    mkdirSync(join(cwd, ".pi-subagents", "agent-transcripts"), { recursive: true });
-    const historical = record({ session: undefined, transcriptPath });
-
-    expect(canOpenAgentHistory(historical, cwd)).toBe(false);
-    writeFileSync(join(cwd, transcriptPath), "{}\n");
-    expect(canOpenAgentHistory(historical, cwd)).toBe(true);
-    expect(canOpenAgentHistory(historical, undefined)).toBe(false);
-  });
-
-  it("builds separate menu entries with openable records only", () => {
-    const entries = buildAgentStatusMenuEntries([
-      record({ status: "running", session: {} }),
-      record({ status: "queued", session: undefined }),
-      record({ status: "completed", session: {} }),
-      record({ status: "error", session: {} }),
-      record({ status: "stopped", session: undefined }),
-    ], undefined);
-
-    expect(entries).toEqual(["Running agents (1)", "Agent history (2)"]);
-    expect(buildAgentStatusMenuEntries([record({ status: "queued", session: undefined })], undefined)).toEqual([]);
-  });
-
-  it("formats a bounded history option using the display name and duration", () => {
-    const option = formatAgentHistoryOption(record({
-      status: "completed",
-      type: "Explore",
-      description: "A very long description ".repeat(20),
-      startedAt: 1_000,
-      completedAt: 3_000,
-    }), 9_000);
-
-    expect(option).toContain("[completed]");
-    expect(option).toContain("Explore");
-    expect(option).toContain("2.0s");
-    expect(option.length).toBeLessThanOrEqual(140);
-  });
-});

package/test/agent-manager-history.test.ts

@@ -1,88 +0,0 @@
-import { afterEach, describe, expect, it } from "vitest";
-import { AgentManager } from "../src/agent-manager.js";
-
-const managers: AgentManager[] = [];
-
-afterEach(() => {
-  for (const manager of managers.splice(0)) manager.dispose();
-});
-
-function makeManager(): AgentManager {
-  const manager = new AgentManager();
-  managers.push(manager);
-  return manager;
-}
-
-function record(overrides: Record<string, unknown> = {}) {
-  return {
-    id: "agent-1",
-    type: "Explore",
-    description: "Inspect the repository",
-    status: "completed",
-    result: "done",
-    toolUses: 2,
-    startedAt: 1_000,
-    completedAt: 2_000,
-    ...overrides,
-  };
-}
-
-describe("AgentManager.restoreCompleted", () => {
-  it("restores all five terminal statuses without sessions", () => {
-    const manager = makeManager();
-    manager.restoreCompleted(["completed", "steered", "stopped", "aborted", "error"].map((status, i) =>
-      record({ id: `agent-${i}`, status }),
-    ));
-
-    expect(manager.listAgents()).toHaveLength(5);
-    for (const restored of manager.listAgents()) {
-      expect(["completed", "steered", "stopped", "aborted", "error"]).toContain(restored.status);
-      expect(restored.session).toBeUndefined();
-      expect(restored.abortController).toBeUndefined();
-      expect(restored.promise).toBeUndefined();
-      expect(restored.lifetimeUsage).toEqual({ input: 0, output: 0, cacheWrite: 0 });
-      expect(restored.compactionCount).toBe(0);
-    }
-  });
-
-  it("ignores running, queued, and invalid records", () => {
-    const manager = makeManager();
-    manager.restoreCompleted([
-      record({ id: "running", status: "running" }),
-      record({ id: "queued", status: "queued" }),
-      { id: "invalid" },
-    ]);
-
-    expect(manager.listAgents()).toEqual([]);
-  });
-
-  it("keeps the last valid duplicate input", () => {
-    const manager = makeManager();
-    manager.restoreCompleted([
-      record({ result: "first", startedAt: 1_000, completedAt: 1_100 }),
-      record({ result: "last", startedAt: 2_000, completedAt: 2_100 }),
-    ]);
-
-    expect(manager.getRecord("agent-1")?.result).toBe("last");
-    expect(manager.getRecord("agent-1")?.startedAt).toBe(2_000);
-  });
-
-  it("does not replace a live record and rejects unsafe persisted data", () => {
-    const manager = makeManager();
-    // Exercise the public map through a restored terminal, then make it live
-    // without starting an LLM session.
-    manager.restoreCompleted([record({ id: "live", result: "original" })]);
-    const liveRecord = manager.getRecord("live")!;
-    liveRecord.status = "running";
-
-    manager.restoreCompleted([
-      record({ id: "live", result: "replacement" }),
-      record({ id: "bad-time", startedAt: Number.NaN }),
-      record({ id: "bad-path", transcriptPath: "../../outside.jsonl" }),
-    ]);
-
-    expect(manager.getRecord("live")?.result).toBe("original");
-    expect(manager.getRecord("bad-time")).toBeUndefined();
-    expect(manager.getRecord("bad-path")).toBeUndefined();
-  });
-});

package/test/agent-menu-history-navigation.test.ts

@@ -1,86 +0,0 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import extension from "../src/index.js";
-import { agentHistoryLocator } from "../src/agent-history.js";
-
-const tempDirectories: string[] = [];
-
-afterEach(() => {
-  for (const directory of tempDirectories.splice(0)) rmSync(directory, { recursive: true, force: true });
-});
-
-describe("/agents history navigation", () => {
-  it("returns to the Agents menu after closing a history viewer", async () => {
-    const cwd = mkdtempSync(join(tmpdir(), "pi-subagents-menu-test-"));
-    tempDirectories.push(cwd);
-    const transcript = ".pi-subagents/agent-transcripts/agent-1.jsonl";
-    mkdirSync(join(cwd, ".pi-subagents/agent-transcripts"), { recursive: true });
-    writeFileSync(join(cwd, transcript), JSON.stringify({ message: { role: "user", content: "hello" } }) + "\n");
-
-    const eventHandlers = new Map<string, Set<(...args: any[]) => any>>();
-    const events = {
-      on: (name: string, handler: (...args: any[]) => any) => {
-        const handlersForEvent = eventHandlers.get(name) ?? new Set<(...args: any[]) => any>();
-        handlersForEvent.add(handler);
-        eventHandlers.set(name, handlersForEvent);
-        return () => handlersForEvent.delete(handler);
-      },
-      emit: (name: string, ...args: any[]) => {
-        for (const handler of eventHandlers.get(name) ?? []) handler(...args);
-      },
-    };
-    const handlers = new Map<string, (...args: any[]) => any>();
-    let command: { handler: (_args: unknown, ctx: any) => Promise<void> } | undefined;
-    const pi: any = {
-      events,
-      registerMessageRenderer: () => {},
-      registerTool: () => {},
-      registerCommand: (_name: string, definition: typeof command) => { command = definition; },
-      on: (name: string, handler: (...args: any[]) => any) => { handlers.set(name, handler); },
-      appendEntry: () => {},
-      sendMessage: () => {},
-    };
-    extension(pi);
-
-    const titles: string[] = [];
-    let historySelections = 0;
-    const ui = {
-      notify: () => {},
-      setWidget: () => {},
-      setStatus: () => {},
-      onTerminalInput: () => () => {},
-      select: async (title: string, options: string[]) => {
-        titles.push(title);
-        if (title === "Agents" && titles.filter(item => item === "Agents").length === 1) {
-          return options.find(option => option.startsWith("Agent history ("));
-        }
-        if (title === "Agent history" && historySelections++ === 0) return options[0];
-        return undefined;
-      },
-      custom: async () => undefined,
-    };
-    const ctx = {
-      cwd,
-      ui,
-      sessionManager: {
-        getSessionId: () => undefined,
-        getBranch: () => [{
-          type: "custom",
-          customType: "subagents:record",
-          data: {
-            id: "agent-1", type: "Explore", description: "Inspect", status: "completed",
-            startedAt: 1, completedAt: 2, transcriptPath: agentHistoryLocator(cwd, join(cwd, transcript)),
-          },
-        }],
-      },
-    };
-
-    await handlers.get("session_start")?.({}, ctx);
-    await command?.handler({}, ctx);
-    await handlers.get("session_shutdown")?.();
-
-    expect(titles).toEqual(["Agents", "Agent history", "Agents"]);
-  });
-});

package/test/output-file-history.test.ts

@@ -1,50 +0,0 @@
-import { mkdtemp, readFile, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { streamToOutputFile, writeInitialEntry } from "../src/output-file.js";
-
-const tempDirs: string[] = [];
-
-afterEach(async () => {
-  await Promise.all(tempDirs.splice(0).map((dir) => rm(dir, { recursive: true, force: true })));
-});
-
-describe("streamToOutputFile durable message snapshots", () => {
-  it("writes tool result details to both output and project history files", async () => {
-    const dir = await mkdtemp(join(tmpdir(), "pi-subagents-output-test-"));
-    tempDirs.push(dir);
-    const outputPath = join(dir, "agent.output");
-    const historyPath = join(dir, "history.jsonl");
-    writeInitialEntry(outputPath, "agent-1", "run", dir);
-    writeInitialEntry(historyPath, "agent-1", "run", dir);
-
-    let listener: ((event: any) => void) | undefined;
-    const session = {
-      messages: [
-        { role: "user", content: "run" },
-        {
-          role: "toolResult",
-          toolCallId: "call-1",
-          toolName: "write",
-          content: [{ type: "text", text: "Successfully wrote to file.txt" }],
-          details: { diff: "+1 new", patch: "+new" },
-        },
-      ],
-      subscribe(next: (event: any) => void) {
-        listener = next;
-        return () => { listener = undefined; };
-      },
-    } as any;
-
-    const cleanup = streamToOutputFile(session, outputPath, "agent-1", dir, historyPath);
-    listener?.({ type: "turn_end" });
-    cleanup();
-
-    for (const path of [outputPath, historyPath]) {
-      const entries = (await readFile(path, "utf8")).trim().split("\n").map((line) => JSON.parse(line));
-      expect(entries).toHaveLength(2);
-      expect(entries[1].message.details).toEqual({ diff: "+1 new", patch: "+new" });
-    }
-  });
-});

package/test/ui/agent-widget.test.ts

@@ -1,172 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { AgentManager } from "../../src/agent-manager.js";
-import {
-  AgentWidget,
-  getWidgetLineBudget,
-  MAX_WIDGET_LINES,
-  type AgentActivity,
-  type Theme,
-} from "../../src/ui/agent-widget.js";
-import type { AgentRecord } from "../../src/types.js";
-
-const theme: Theme = {
-  fg: (_color, text) => text,
-  bold: (text) => text,
-};
-
-const managers: AgentManager[] = [];
-
-afterEach(() => {
-  for (const manager of managers.splice(0)) manager.dispose();
-});
-
-function makeRecord(overrides: Partial<AgentRecord> = {}): AgentRecord {
-  return {
-    id: "agent-1",
-    type: "Explore",
-    description: "Inspect the repository",
-    status: "completed",
-    toolUses: 0,
-    startedAt: 1_000,
-    completedAt: 2_000,
-    lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-    compactionCount: 0,
-    ...overrides,
-  };
-}
-
-function renderWidget(
-  records: AgentRecord[],
-  rows = 24,
-  activity = new Map<string, AgentActivity>(),
-  mode: "all" | "background" | "off" = "all",
-) {
-  const manager = { listAgents: () => records } as unknown as AgentManager;
-  const widget = new AgentWidget(manager, activity, () => mode);
-  const tui = { terminal: { columns: 200, rows } };
-  const render = () => (widget as any).renderWidget(tui, theme) as string[];
-  return { render, widget };
-}
-
-function createWidgetHarness(records: AgentRecord[]) {
-  const manager = { listAgents: () => records } as unknown as AgentManager;
-  let factory: ((tui: any, theme: Theme) => { render(): string[]; invalidate(): void }) | undefined;
-  const tui = {
-    terminal: { columns: 120, rows: 24 },
-    requestRender: vi.fn(),
-  };
-  const ui = {
-    setStatus: vi.fn(),
-    setWidget: vi.fn((_key: string, content: any) => { factory = content; }),
-  };
-  const widget = new AgentWidget(manager, new Map(), () => "all");
-  widget.setUICtx(ui);
-  widget.update();
-  factory?.(tui, theme).render();
-  tui.requestRender.mockClear();
-  return { records, tui, ui, widget, render: () => factory?.(tui, theme).render() ?? [] };
-}
-
-describe("AgentWidget live records", () => {
-  it("keeps restored history in the live widget and manager history", () => {
-    const manager = new AgentManager();
-    managers.push(manager);
-    manager.restoreCompleted([makeRecord({ id: "history", description: "restored history" })]);
-
-    const widget = new AgentWidget(manager, new Map(), () => "all");
-    const tui = { terminal: { columns: 120, rows: 24 } };
-
-    expect((widget as any).renderWidget(tui, theme).join("\n")).toContain("restored history");
-    expect(manager.listAgents().map(record => record.id)).toEqual(["history"]);
-    expect(manager.getRecord("history")).toBeDefined();
-  });
-
-  it("keeps a live completed record visible after markFinished", () => {
-    const record = makeRecord({ id: "live", description: "live completion" });
-    const { render, widget } = renderWidget([record]);
-
-    widget.markFinished(record.id);
-
-    expect(render().join("\n")).toContain("live completion");
-  });
-
-  it("normalizes multiline rows and bounds output by the responsive ceiling", () => {
-    const running = makeRecord({
-      id: "running",
-      status: "running",
-      completedAt: undefined,
-      description: "running\nsecond line",
-    });
-    const finished = makeRecord({
-      id: "finished",
-      description: "finished\nsecond line",
-    });
-    const extraFinished = Array.from({ length: 10 }, (_, i) => makeRecord({
-      id: `finished-${i}`,
-      description: `extra ${i}`,
-    }));
-    const activity = new Map<string, AgentActivity>([
-      [running.id, {
-        activeTools: new Map(),
-        toolUses: 0,
-        responseText: "activity\nsecond line",
-        turnCount: 1,
-        lifetimeUsage: { input: 0, output: 0, cacheWrite: 0 },
-      }],
-    ]);
-    const rows = 9;
-    const { render } = renderWidget([running, finished, ...extraFinished], rows, activity);
-    const lines = render();
-
-    expect(lines.every(line => !/[\r\n]/.test(line))).toBe(true);
-    expect(lines.length).toBeLessThanOrEqual(getWidgetLineBudget(rows));
-    expect(lines.length).toBeLessThanOrEqual(MAX_WIDGET_LINES);
-    expect(lines.join("\n")).toContain("running second line");
-    expect(lines.some(line => line.includes("more"))).toBe(true);
-  });
-
-  it("counts queued records in the overflow indicator on short terminals", () => {
-    const running = makeRecord({ id: "running", status: "running", completedAt: undefined });
-    const queued = makeRecord({ id: "queued", status: "queued", completedAt: undefined });
-    const { render } = renderWidget([running, queued], 6);
-
-    const output = render().join("\\n");
-    expect(output).toContain("+2 more");
-    expect(output).toContain("1 queued");
-  });
-
-  it("reserves editor space on short terminals while retaining the widget ceiling", () => {
-    expect(getWidgetLineBudget(9)).toBe(5);
-    expect(getWidgetLineBudget(100)).toBe(MAX_WIDGET_LINES);
-  });
-
-  it("does not request a render when a live snapshot is unchanged", () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(10_000);
-    try {
-      const running = makeRecord({ id: "running", status: "running", completedAt: undefined });
-      const { widget, tui } = createWidgetHarness([running]);
-
-      widget.update();
-      expect(tui.requestRender).not.toHaveBeenCalled();
-
-      running.description = "changed description";
-      widget.update();
-      expect(tui.requestRender).toHaveBeenCalledTimes(1);
-      widget.dispose();
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it("exposes a safe render-only refresh target", () => {
-    const running = makeRecord({ id: "running", status: "running", completedAt: undefined });
-    const { widget, tui } = createWidgetHarness([running]);
-    tui.requestRender.mockClear();
-
-    expect((widget as any).requestUiRefresh(true)).toBe(true);
-    expect(tui.requestRender).toHaveBeenCalledWith(true);
-    widget.dispose();
-    expect((widget as any).requestUiRefresh(true)).toBe(false);
-  });
-});

package/test/ui/conversation-blocks.test.ts

@@ -1,103 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatConversationMessages } from "../../src/ui/conversation-blocks.js";
-
-describe("formatConversationMessages", () => {
-  it("keeps markdown source for user and assistant blocks", () => {
-    const blocks = formatConversationMessages([
-      { role: "user", content: "# Ask\n\nUse `x`." },
-      { role: "assistant", content: [
-        { type: "text", text: "## Answer\n\n```ts\nconst x: number = 1;\n```" },
-      ] },
-    ] as any);
-
-    expect(blocks.filter((b) => b.kind === "text").map((b) => b.markdown)).toEqual([
-      "# Ask\n\nUse `x`.",
-      "## Answer\n\n```ts\nconst x: number = 1;\n```",
-    ]);
-  });
-
-  it("separates assistant tool calls and bounds tool results", () => {
-    const blocks = formatConversationMessages([
-      { role: "assistant", content: [
-        { type: "toolCall", name: "read", arguments: { path: "src/index.ts" } },
-      ] },
-      { role: "toolResult", toolName: "read", isError: false, content: [
-        { type: "text", text: "a".repeat(100) },
-      ] },
-    ] as any, { maxToolResultChars: 40 });
-
-    expect(blocks.some((b) => b.toolLine?.includes("read"))).toBe(true);
-    const result = blocks.find((b) => b.role === "tool" && b.fullText.includes("read"));
-    expect(result?.fullText.length).toBeLessThanOrEqual(40);
-  });
-
-  it("pairs tool results by id, then same-name source order, and preserves orphans", () => {
-    const blocks = formatConversationMessages([
-      { role: "assistant", content: [
-        { type: "toolCall", id: "call-read", name: "read", arguments: { path: "a.ts" } },
-        { type: "toolCall", id: "call-write", name: "write", arguments: { path: "b.ts", content: "new" } },
-      ] },
-      { role: "toolResult", toolCallId: "call-read", toolName: "read", isError: false, details: { source: "id" }, content: [{ type: "text", text: "read output" }] },
-      { role: "toolResult", toolName: "write", isError: true, details: { source: "name" }, content: [{ type: "text", text: "write failed" }] },
-      { role: "toolResult", toolCallId: "missing", toolName: "bash", isError: true, content: [{ type: "text", text: "orphan" }] },
-    ] as any);
-
-    const tools = blocks.filter((block) => block.kind === "tool");
-    expect(tools).toHaveLength(3);
-    expect(tools[0]?.toolCallId).toBe("call-read");
-    expect(tools[0]?.toolResult?.details).toEqual({ source: "id" });
-    expect(tools[1]?.toolCallId).toBe("call-write");
-    expect(tools[1]?.toolResult?.isError).toBe(true);
-    expect(tools[2]?.toolResult?.content).toEqual([{ type: "text", text: "orphan" }]);
-    expect(tools[2]?.fullText).toContain("orphan");
-  });
-
-  it("uses a stable synthetic id when a tool call omits its id", () => {
-    const blocks = formatConversationMessages([
-      { role: "assistant", content: [{ type: "toolCall", name: "read", arguments: { path: "a.ts" } }] },
-      { role: "toolResult", toolName: "read", content: [{ type: "text", text: "ok" }] },
-    ] as any);
-
-    expect(blocks[0]?.toolCallId).toBe("message-0-tool-0");
-    expect(blocks[0]?.toolResult?.content).toEqual([{ type: "text", text: "ok" }]);
-  });
-
-  it("normalizes CRLF and bounds text with a deterministic truncation marker", () => {
-    const blocks = formatConversationMessages([
-      { role: "user", content: "one\r\ntwo\rthree\nfour" },
-    ] as any, { maxEntryChars: 12 });
-
-    expect(blocks[0]?.markdown).toBe("\n… [truncate");
-    expect(blocks[0]?.id).toBe("message-0");
-    expect(blocks[0]?.fullText.length).toBeLessThanOrEqual(12);
-  });
-
-  it("formats bash, images, summaries, and deterministic tool ids", () => {
-    const blocks = formatConversationMessages([
-      { role: "assistant", content: [
-        { type: "text", text: "answer" },
-        { type: "toolCall", name: "read", arguments: { path: "a.ts" } },
-        { type: "toolCall", name: "write", arguments: { path: "b.ts" } },
-      ] },
-      { role: "bashExecution", command: "echo hi", output: "hi" },
-      { role: "custom", customType: "note", content: [{ type: "image" }] },
-      { role: "compactionSummary", summary: "Earlier context" },
-    ] as any);
-
-    expect(blocks.map((block) => block.id)).toEqual([
-      "message-0", "message-0-tool-0", "message-0-tool-1", "message-1", "message-2", "message-3",
-    ]);
-    expect(blocks[1]?.toolLine).toContain("· read → a.ts");
-    expect(blocks[3]?.fullText).toContain("$ echo hi\nhi");
-    expect(blocks[4]?.markdown).toBe("[image]");
-    expect(blocks[5]?.role).toBe("meta");
-  });
-
-  it("skips unsupported or empty messages without throwing", () => {
-    expect(formatConversationMessages([
-      { role: "unknown", content: { not: "text" } },
-      { role: "user", content: [{ type: "thinking", thinking: "hidden" }] },
-      { role: "custom", display: false, content: "hidden" },
-    ] as any)).toEqual([]);
-  });
-});