Skip to content

Commit 9a348c8

Browse files
committed
perf(shared): avoid redundant visibility work on status updates
1 parent fa31b66 commit 9a348c8

2 files changed

Lines changed: 247 additions & 17 deletions

File tree

‎packages/shared/src/orchestrationV2Timeline.test.ts‎

Lines changed: 234 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,20 @@ import {
88

99
const runId = RunId.make("run:timeline-visibility");
1010
const nodeId = NodeId.make("node:timeline-visibility");
11+
const otherRunId = RunId.make("run:timeline-visibility:other");
12+
const otherNodeId = NodeId.make("node:timeline-visibility:other");
13+
type VisibilityInput = Parameters<typeof createOrchestrationV2TurnItemVisibility>[0];
14+
15+
const ordinaryStatuses = [
16+
"preparing",
17+
"queued",
18+
"starting",
19+
"running",
20+
"waiting",
21+
"completed",
22+
"interrupted",
23+
"failed",
24+
] as const;
1125

1226
describe.each([
1327
["point", isOrchestrationV2TurnItemVisible],
@@ -28,19 +42,26 @@ describe.each([
2842
).toBe(false);
2943
});
3044

31-
it("keeps paired interruption results from superseded attempts", () => {
32-
expect(
33-
isVisible({
34-
item: { type: "run_interrupt_result", runId, nodeId },
35-
runs: [{ id: runId, status: "running" }],
36-
attempts: [{ runId, rootNodeId: nodeId, status: "superseded" }],
37-
items: [
38-
{ type: "run_interrupt_request", runId, nodeId },
39-
{ type: "run_interrupt_result", runId, nodeId },
40-
],
41-
}),
42-
).toBe(true);
43-
});
45+
it.each([
46+
{ status: "running", visible: true },
47+
{ status: "cancelled", visible: true },
48+
{ status: "rolled_back", visible: false },
49+
] as const)(
50+
"keeps paired superseded results unless the run is rolled back ($status)",
51+
({ status, visible }) => {
52+
expect(
53+
isVisible({
54+
item: { type: "run_interrupt_result", runId, nodeId },
55+
runs: [{ id: runId, status }],
56+
attempts: [{ runId, rootNodeId: nodeId, status: "superseded" }],
57+
items: [
58+
{ type: "run_interrupt_request", runId, nodeId },
59+
{ type: "run_interrupt_result", runId, nodeId },
60+
],
61+
}),
62+
).toBe(visible);
63+
},
64+
);
4465

4566
it("keeps interruption results from terminal attempts without a request", () => {
4667
expect(
@@ -92,4 +113,204 @@ describe.each([
92113
}),
93114
).toBe(true);
94115
});
116+
117+
it.each([
118+
...ordinaryStatuses.map((status) => ({ status, hidden: [] })),
119+
{ status: "cancelled", hidden: ["queued"] },
120+
{
121+
status: "rolled_back",
122+
hidden: ["queued", "start", "steer", "promoted", "legacy", "assistant", "request", "result"],
123+
},
124+
] satisfies ReadonlyArray<{
125+
status: VisibilityInput["runs"][number]["status"];
126+
hidden: string[];
127+
}>)("keeps the correct transcript rows for $status runs", ({ status, hidden }) => {
128+
const rows = [
129+
{ id: "queued", type: "user_message", inputIntent: "queued_turn", runId, nodeId },
130+
{ id: "start", type: "user_message", inputIntent: "turn_start", runId, nodeId },
131+
{ id: "steer", type: "user_message", inputIntent: "steer", runId, nodeId },
132+
{
133+
id: "promoted",
134+
type: "user_message",
135+
inputIntent: "promoted_queued_to_steer",
136+
runId,
137+
nodeId,
138+
},
139+
{ id: "legacy", type: "user_message", runId, nodeId },
140+
{ id: "assistant", type: "assistant_message", inputIntent: "queued_turn", runId, nodeId },
141+
{ id: "request", type: "run_interrupt_request", runId, nodeId },
142+
{ id: "result", type: "run_interrupt_result", runId, nodeId },
143+
{ id: "null", type: "user_message", inputIntent: "queued_turn", runId: null, nodeId },
144+
{
145+
id: "missing",
146+
type: "user_message",
147+
inputIntent: "queued_turn",
148+
runId: otherRunId,
149+
nodeId,
150+
},
151+
] satisfies ReadonlyArray<VisibilityInput["items"][number] & { id: string }>;
152+
const input = {
153+
runs: [{ id: runId, status }],
154+
attempts: [],
155+
items: rows,
156+
} satisfies VisibilityInput;
157+
expect(rows.filter((item) => isVisible({ ...input, item })).map((item) => item.id)).toEqual(
158+
[
159+
"queued",
160+
"start",
161+
"steer",
162+
"promoted",
163+
"legacy",
164+
"assistant",
165+
"request",
166+
"result",
167+
"null",
168+
"missing",
169+
].filter((id) => !hidden.some((hiddenId) => hiddenId === id)),
170+
);
171+
});
172+
173+
it.each([
174+
{ name: "empty history", runs: [], attempts: [] },
175+
{
176+
name: "ordinary attempts",
177+
runs: [{ id: runId, status: "completed" }],
178+
attempts: [{ runId, rootNodeId: nodeId, status: "completed" }],
179+
},
180+
] satisfies ReadonlyArray<Pick<VisibilityInput, "runs" | "attempts"> & { name: string }>)(
181+
"keeps all rows with $name",
182+
({ runs, attempts }) => {
183+
const items = [
184+
{ type: "user_message", inputIntent: "queued_turn", runId, nodeId },
185+
{ type: "run_interrupt_result", runId, nodeId },
186+
{ type: "assistant_message", runId: null, nodeId: null },
187+
] satisfies VisibilityInput["items"];
188+
expect(items.filter((item) => isVisible({ item, runs, attempts, items }))).toEqual(items);
189+
},
190+
);
191+
192+
it.each([
193+
{ name: "unpaired", runId, nodeId, requests: [], visible: false },
194+
{ name: "second root", runId, nodeId: otherNodeId, requests: [], visible: false },
195+
{ name: "other run", runId: otherRunId, nodeId, requests: [], visible: true },
196+
{
197+
name: "unknown root",
198+
runId,
199+
nodeId: NodeId.make("node:unknown"),
200+
requests: [],
201+
visible: true,
202+
},
203+
{ name: "null run", runId: null, nodeId, requests: [], visible: true },
204+
{ name: "null node", runId, nodeId: null, requests: [], visible: true },
205+
{ name: "other request", runId, nodeId, requests: [otherRunId], visible: false },
206+
{ name: "null request", runId, nodeId, requests: [null], visible: false },
207+
{ name: "paired request", runId, nodeId, requests: [runId], visible: true },
208+
] satisfies ReadonlyArray<{
209+
name: string;
210+
runId: VisibilityInput["items"][number]["runId"];
211+
nodeId: VisibilityInput["items"][number]["nodeId"];
212+
requests: VisibilityInput["items"][number]["runId"][];
213+
visible: boolean;
214+
}>)("matches superseded roots and requests for $name results", (row) => {
215+
const item = { type: "run_interrupt_result", runId: row.runId, nodeId: row.nodeId } as const;
216+
const requests = row.requests.map((requestRunId) => ({
217+
type: "run_interrupt_request" as const,
218+
runId: requestRunId,
219+
nodeId: otherNodeId,
220+
}));
221+
for (const items of [
222+
[...requests, item],
223+
[item, ...requests],
224+
]) {
225+
expect(
226+
isVisible({
227+
item,
228+
runs: [],
229+
attempts: [
230+
{ runId, rootNodeId: nodeId, status: "superseded" },
231+
{ runId, rootNodeId: otherNodeId, status: "superseded" },
232+
],
233+
items,
234+
}),
235+
).toBe(row.visible);
236+
}
237+
});
238+
});
239+
240+
describe("indexed timeline visibility", () => {
241+
it.each([
242+
...ordinaryStatuses.flatMap(
243+
(status) =>
244+
[
245+
{ statuses: ["rolled_back", status], visible: true, ordinaryVisible: true },
246+
{ statuses: ["cancelled", status], visible: true, ordinaryVisible: true },
247+
{ statuses: [status, "rolled_back"], visible: false, ordinaryVisible: false },
248+
{ statuses: [status, "cancelled"], visible: false, ordinaryVisible: true },
249+
] as const,
250+
),
251+
{ statuses: ["rolled_back", "cancelled"], visible: false, ordinaryVisible: true },
252+
{ statuses: ["cancelled", "rolled_back"], visible: false, ordinaryVisible: false },
253+
{
254+
statuses: ["rolled_back", "running", "cancelled", "completed"],
255+
visible: true,
256+
ordinaryVisible: true,
257+
},
258+
] satisfies ReadonlyArray<{
259+
statuses: ReadonlyArray<VisibilityInput["runs"][number]["status"]>;
260+
visible: boolean;
261+
ordinaryVisible: boolean;
262+
}>)(
263+
"uses the last duplicate run status in $statuses",
264+
({ statuses, visible, ordinaryVisible }) => {
265+
const queued = { type: "user_message", inputIntent: "queued_turn", runId, nodeId } as const;
266+
const ordinary = { type: "assistant_message", runId, nodeId } as const;
267+
const isVisible = createOrchestrationV2TurnItemVisibility({
268+
runs: statuses.map((status) => ({ id: runId, status })),
269+
attempts: [],
270+
items: [queued, ordinary],
271+
});
272+
expect(isVisible(queued)).toBe(visible);
273+
expect(isVisible(ordinary)).toBe(ordinaryVisible);
274+
},
275+
);
276+
277+
it("preserves frozen rows and reads fresh status and attempt snapshots", () => {
278+
const item = Object.freeze({ type: "run_interrupt_result", runId, nodeId } as const);
279+
const queued = Object.freeze({
280+
type: "user_message",
281+
inputIntent: "queued_turn",
282+
runId,
283+
nodeId,
284+
} as const);
285+
const items = Object.freeze([item, queued]);
286+
const attempts = Object.freeze([
287+
Object.freeze({ runId, rootNodeId: nodeId, status: "superseded" } as const),
288+
]);
289+
const runs = Object.freeze([Object.freeze({ id: runId, status: "running" } as const)]);
290+
const input = Object.freeze({ runs, attempts, items });
291+
const before = structuredClone(input);
292+
const visible = items.filter(createOrchestrationV2TurnItemVisibility(input));
293+
expect(visible).toEqual([queued]);
294+
expect(visible[0]).toBe(queued);
295+
expect(input).toEqual(before);
296+
expect(
297+
items.filter(createOrchestrationV2TurnItemVisibility({ ...input, attempts: [] })),
298+
).toEqual(items);
299+
expect(
300+
items.filter(
301+
createOrchestrationV2TurnItemVisibility({
302+
...input,
303+
runs: [{ id: runId, status: "cancelled" }],
304+
}),
305+
),
306+
).toEqual([]);
307+
expect(
308+
items.filter(
309+
createOrchestrationV2TurnItemVisibility({
310+
...input,
311+
items: [...items, { type: "run_interrupt_request", runId, nodeId: null }],
312+
}),
313+
),
314+
).toEqual(items);
315+
});
95316
});

‎packages/shared/src/orchestrationV2Timeline.ts‎

Lines changed: 13 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -74,7 +74,12 @@ export function createOrchestrationV2TurnItemVisibility(input: {
7474
readonly attempts: ReadonlyArray<TimelineRunAttempt>;
7575
readonly items: ReadonlyArray<TimelineTurnItem>;
7676
}): (item: TimelineTurnItem) => boolean {
77-
const statuses = new Map(input.runs.map((run) => [run.id, run.status]));
77+
const statuses = new Map<TimelineRun["id"], TimelineRun["status"]>();
78+
for (const run of input.runs) {
79+
if (run.status === "rolled_back" || run.status === "cancelled")
80+
statuses.set(run.id, run.status);
81+
else statuses.delete(run.id);
82+
}
7883
const supersededRoots = new Map<
7984
TimelineRunAttempt["runId"],
8085
Set<TimelineRunAttempt["rootNodeId"]>
@@ -85,9 +90,13 @@ export function createOrchestrationV2TurnItemVisibility(input: {
8590
if (roots === undefined) supersededRoots.set(attempt.runId, (roots = new Set()));
8691
roots.add(attempt.rootNodeId);
8792
}
88-
const interruptRuns = new Set(
89-
input.items.filter((item) => item.type === "run_interrupt_request").map((item) => item.runId),
90-
);
93+
if (statuses.size === 0 && supersededRoots.size === 0) return () => true;
94+
const interruptRuns = new Set<TimelineTurnItem["runId"]>();
95+
if (supersededRoots.size > 0) {
96+
for (const item of input.items) {
97+
if (item.type === "run_interrupt_request") interruptRuns.add(item.runId);
98+
}
99+
}
91100
return (item) => {
92101
const status = item.runId === null ? undefined : statuses.get(item.runId);
93102
if (status === "rolled_back") return false;

0 commit comments

Comments
 (0)