sailfork / t3code-github / packages/ shared/ src/ orchestrationV2Timeline.test.ts

import { NodeId, RunId } from "@t3tools/contracts";
import { describe, expect, it } from "vite-plus/test";

import {
  createOrchestrationV2TurnItemVisibility,
  isOrchestrationV2TurnItemVisible,
} from "./orchestrationV2Timeline.ts";

const runId = RunId.make("run:timeline-visibility");
const nodeId = NodeId.make("node:timeline-visibility");
const otherRunId = RunId.make("run:timeline-visibility:other");
const otherNodeId = NodeId.make("node:timeline-visibility:other");
type VisibilityInput = Parameters<typeof createOrchestrationV2TurnItemVisibility>[0];

const ordinaryStatuses = [
  "preparing",
  "queued",
  "starting",
  "running",
  "waiting",
  "completed",
  "interrupted",
  "failed",
] as const;

describe.each([
  ["point", isOrchestrationV2TurnItemVisible],
  [
    "indexed",
    (input: Parameters<typeof isOrchestrationV2TurnItemVisible>[0]) =>
      createOrchestrationV2TurnItemVisibility(input)(input.item),
  ],
] as const)("%s timeline visibility", (_, isVisible) => {
  it("hides unpaired interruption results from superseded attempts", () => {
    expect(
      isVisible({
        item: { type: "run_interrupt_result", runId, nodeId },
        runs: [{ id: runId, status: "running" }],
        attempts: [{ runId, rootNodeId: nodeId, status: "superseded" }],
        items: [{ type: "run_interrupt_result", runId, nodeId }],
      }),
    ).toBe(false);
  });

  it.each([
    { status: "running", visible: true },
    { status: "cancelled", visible: true },
    { status: "rolled_back", visible: false },
  ] as const)(
    "keeps paired superseded results unless the run is rolled back ($status)",
    ({ status, visible }) => {
      expect(
        isVisible({
          item: { type: "run_interrupt_result", runId, nodeId },
          runs: [{ id: runId, status }],
          attempts: [{ runId, rootNodeId: nodeId, status: "superseded" }],
          items: [
            { type: "run_interrupt_request", runId, nodeId },
            { type: "run_interrupt_result", runId, nodeId },
          ],
        }),
      ).toBe(visible);
    },
  );

  it("keeps interruption results from terminal attempts without a request", () => {
    expect(
      isVisible({
        item: { type: "run_interrupt_result", runId, nodeId },
        runs: [{ id: runId, status: "interrupted" }],
        attempts: [{ runId, rootNodeId: nodeId, status: "interrupted" }],
        items: [{ type: "run_interrupt_result", runId, nodeId }],
      }),
    ).toBe(true);
  });

  it("hides queued user messages once their run is cancelled", () => {
    expect(
      isVisible({
        item: { type: "user_message", inputIntent: "queued_turn", runId, nodeId },
        runs: [{ id: runId, status: "cancelled" }],
        attempts: [],
        items: [{ type: "user_message", inputIntent: "queued_turn", runId, nodeId }],
      }),
    ).toBe(false);
  });

  it("keeps non-queued user messages on cancelled runs", () => {
    expect(
      isVisible({
        item: { type: "user_message", inputIntent: "turn_start", runId, nodeId },
        runs: [{ id: runId, status: "cancelled" }],
        attempts: [],
        items: [{ type: "user_message", inputIntent: "turn_start", runId, nodeId }],
      }),
    ).toBe(true);
  });

  it("does not hide an interruption because another attempt was superseded", () => {
    expect(
      isVisible({
        item: { type: "run_interrupt_result", runId, nodeId },
        runs: [{ id: runId, status: "interrupted" }],
        attempts: [
          {
            runId,
            rootNodeId: NodeId.make("node:timeline-visibility:older"),
            status: "superseded",
          },
          { runId, rootNodeId: nodeId, status: "interrupted" },
        ],
        items: [{ type: "run_interrupt_result", runId, nodeId }],
      }),
    ).toBe(true);
  });

  it.each([
    ...ordinaryStatuses.map((status) => ({ status, hidden: [] })),
    { status: "cancelled", hidden: ["queued"] },
    {
      status: "rolled_back",
      hidden: ["queued", "start", "steer", "promoted", "legacy", "assistant", "request", "result"],
    },
  ] satisfies ReadonlyArray<{
    status: VisibilityInput["runs"][number]["status"];
    hidden: string[];
  }>)("keeps the correct transcript rows for $status runs", ({ status, hidden }) => {
    const rows = [
      { id: "queued", type: "user_message", inputIntent: "queued_turn", runId, nodeId },
      { id: "start", type: "user_message", inputIntent: "turn_start", runId, nodeId },
      { id: "steer", type: "user_message", inputIntent: "steer", runId, nodeId },
      {
        id: "promoted",
        type: "user_message",
        inputIntent: "promoted_queued_to_steer",
        runId,
        nodeId,
      },
      { id: "legacy", type: "user_message", runId, nodeId },
      { id: "assistant", type: "assistant_message", inputIntent: "queued_turn", runId, nodeId },
      { id: "request", type: "run_interrupt_request", runId, nodeId },
      { id: "result", type: "run_interrupt_result", runId, nodeId },
      { id: "null", type: "user_message", inputIntent: "queued_turn", runId: null, nodeId },
      {
        id: "missing",
        type: "user_message",
        inputIntent: "queued_turn",
        runId: otherRunId,
        nodeId,
      },
    ] satisfies ReadonlyArray<VisibilityInput["items"][number] & { id: string }>;
    const input = {
      runs: [{ id: runId, status }],
      attempts: [],
      items: rows,
    } satisfies VisibilityInput;
    expect(rows.filter((item) => isVisible({ ...input, item })).map((item) => item.id)).toEqual(
      [
        "queued",
        "start",
        "steer",
        "promoted",
        "legacy",
        "assistant",
        "request",
        "result",
        "null",
        "missing",
      ].filter((id) => !hidden.some((hiddenId) => hiddenId === id)),
    );
  });

  it.each([
    { name: "empty history", runs: [], attempts: [] },
    {
      name: "ordinary attempts",
      runs: [{ id: runId, status: "completed" }],
      attempts: [{ runId, rootNodeId: nodeId, status: "completed" }],
    },
  ] satisfies ReadonlyArray<Pick<VisibilityInput, "runs" | "attempts"> & { name: string }>)(
    "keeps all rows with $name",
    ({ runs, attempts }) => {
      const items = [
        { type: "user_message", inputIntent: "queued_turn", runId, nodeId },
        { type: "run_interrupt_result", runId, nodeId },
        { type: "assistant_message", runId: null, nodeId: null },
      ] satisfies VisibilityInput["items"];
      expect(items.filter((item) => isVisible({ item, runs, attempts, items }))).toEqual(items);
    },
  );

  it.each([
    { name: "unpaired", runId, nodeId, requests: [], visible: false },
    { name: "second root", runId, nodeId: otherNodeId, requests: [], visible: false },
    { name: "other run", runId: otherRunId, nodeId, requests: [], visible: true },
    {
      name: "unknown root",
      runId,
      nodeId: NodeId.make("node:unknown"),
      requests: [],
      visible: true,
    },
    { name: "null run", runId: null, nodeId, requests: [], visible: true },
    { name: "null node", runId, nodeId: null, requests: [], visible: true },
    { name: "other request", runId, nodeId, requests: [otherRunId], visible: false },
    { name: "null request", runId, nodeId, requests: [null], visible: false },
    { name: "paired request", runId, nodeId, requests: [runId], visible: true },
  ] satisfies ReadonlyArray<{
    name: string;
    runId: VisibilityInput["items"][number]["runId"];
    nodeId: VisibilityInput["items"][number]["nodeId"];
    requests: VisibilityInput["items"][number]["runId"][];
    visible: boolean;
  }>)("matches superseded roots and requests for $name results", (row) => {
    const item = { type: "run_interrupt_result", runId: row.runId, nodeId: row.nodeId } as const;
    const requests = row.requests.map((requestRunId) => ({
      type: "run_interrupt_request" as const,
      runId: requestRunId,
      nodeId: otherNodeId,
    }));
    for (const items of [
      [...requests, item],
      [item, ...requests],
    ]) {
      expect(
        isVisible({
          item,
          runs: [],
          attempts: [
            { runId, rootNodeId: nodeId, status: "superseded" },
            { runId, rootNodeId: otherNodeId, status: "superseded" },
          ],
          items,
        }),
      ).toBe(row.visible);
    }
  });
});

describe("indexed timeline visibility", () => {
  it.each([
    ...ordinaryStatuses.flatMap(
      (status) =>
        [
          { statuses: ["rolled_back", status], visible: true, ordinaryVisible: true },
          { statuses: ["cancelled", status], visible: true, ordinaryVisible: true },
          { statuses: [status, "rolled_back"], visible: false, ordinaryVisible: false },
          { statuses: [status, "cancelled"], visible: false, ordinaryVisible: true },
        ] as const,
    ),
    { statuses: ["rolled_back", "cancelled"], visible: false, ordinaryVisible: true },
    { statuses: ["cancelled", "rolled_back"], visible: false, ordinaryVisible: false },
    {
      statuses: ["rolled_back", "running", "cancelled", "completed"],
      visible: true,
      ordinaryVisible: true,
    },
  ] satisfies ReadonlyArray<{
    statuses: ReadonlyArray<VisibilityInput["runs"][number]["status"]>;
    visible: boolean;
    ordinaryVisible: boolean;
  }>)(
    "uses the last duplicate run status in $statuses",
    ({ statuses, visible, ordinaryVisible }) => {
      const queued = { type: "user_message", inputIntent: "queued_turn", runId, nodeId } as const;
      const ordinary = { type: "assistant_message", runId, nodeId } as const;
      const isVisible = createOrchestrationV2TurnItemVisibility({
        runs: statuses.map((status) => ({ id: runId, status })),
        attempts: [],
        items: [queued, ordinary],
      });
      expect(isVisible(queued)).toBe(visible);
      expect(isVisible(ordinary)).toBe(ordinaryVisible);
    },
  );

  it("preserves frozen rows and reads fresh status and attempt snapshots", () => {
    const item = Object.freeze({ type: "run_interrupt_result", runId, nodeId } as const);
    const queued = Object.freeze({
      type: "user_message",
      inputIntent: "queued_turn",
      runId,
      nodeId,
    } as const);
    const items = Object.freeze([item, queued]);
    const attempts = Object.freeze([
      Object.freeze({ runId, rootNodeId: nodeId, status: "superseded" } as const),
    ]);
    const runs = Object.freeze([Object.freeze({ id: runId, status: "running" } as const)]);
    const input = Object.freeze({ runs, attempts, items });
    const before = structuredClone(input);
    const visible = items.filter(createOrchestrationV2TurnItemVisibility(input));
    expect(visible).toEqual([queued]);
    expect(visible[0]).toBe(queued);
    expect(input).toEqual(before);
    expect(
      items.filter(createOrchestrationV2TurnItemVisibility({ ...input, attempts: [] })),
    ).toEqual(items);
    expect(
      items.filter(
        createOrchestrationV2TurnItemVisibility({
          ...input,
          runs: [{ id: runId, status: "cancelled" }],
        }),
      ),
    ).toEqual([]);
    expect(
      items.filter(
        createOrchestrationV2TurnItemVisibility({
          ...input,
          items: [...items, { type: "run_interrupt_request", runId, nodeId: null }],
        }),
      ),
    ).toEqual(items);
  });
});