TypeScript
perf(shared): avoid redundant visibility work on status updates (#28965)
Hieu Le0a86e157a0ea
diff --git a/packages/shared/src/orchestrationV2Timeline.test.ts b/packages/shared/src/orchestrationV2Timeline.test.tsindex 8d38d1db59b..9ed07c4f09b 100644--- a/packages/shared/src/orchestrationV2Timeline.test.ts+++ b/packages/shared/src/orchestrationV2Timeline.test.ts@@ -8,6 +8,20 @@ import {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],@@ -28,19 +42,26 @@ describe.each([).toBe(false);});- it("keeps paired 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_request", runId, nodeId },- { type: "run_interrupt_result", runId, nodeId },- ],- }),- ).toBe(true);- });+ 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(@@ -92,4 +113,204 @@ describe.each([}),).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);+ });});diff --git a/packages/shared/src/orchestrationV2Timeline.ts b/packages/shared/src/orchestrationV2Timeline.tsindex 6ca8a95f7fb..05f13557138 100644--- a/packages/shared/src/orchestrationV2Timeline.ts+++ b/packages/shared/src/orchestrationV2Timeline.ts@@ -74,7 +74,12 @@ export function createOrchestrationV2TurnItemVisibility(input: {readonly attempts: ReadonlyArray<TimelineRunAttempt>;readonly items: ReadonlyArray<TimelineTurnItem>;}): (item: TimelineTurnItem) => boolean {- const statuses = new Map(input.runs.map((run) => [run.id, run.status]));+ const statuses = new Map<TimelineRun["id"], TimelineRun["status"]>();+ for (const run of input.runs) {+ if (run.status === "rolled_back" || run.status === "cancelled")+ statuses.set(run.id, run.status);+ else statuses.delete(run.id);+ }const supersededRoots = new Map<TimelineRunAttempt["runId"],Set<TimelineRunAttempt["rootNodeId"]>@@ -85,9 +90,13 @@ export function createOrchestrationV2TurnItemVisibility(input: {if (roots === undefined) supersededRoots.set(attempt.runId, (roots = new Set()));roots.add(attempt.rootNodeId);}- const interruptRuns = new Set(- input.items.filter((item) => item.type === "run_interrupt_request").map((item) => item.runId),- );+ if (statuses.size === 0 && supersededRoots.size === 0) return () => true;+ const interruptRuns = new Set<TimelineTurnItem["runId"]>();+ if (supersededRoots.size > 0) {+ for (const item of input.items) {+ if (item.type === "run_interrupt_request") interruptRuns.add(item.runId);+ }+ }return (item) => {const status = item.runId === null ? undefined : statuses.get(item.runId);if (status === "rolled_back") return false;