fix(timeline): fall back to pages when a whole turn exceeds the frame limit

This commit is contained in:
AnalyticETH
2026-11-18 18:14:05 -05:00
parent bcf52f93b1
commit b60f3d26aa
4 changed files with 193 additions and 69 deletions
+5 -3
View File
@@ -65,9 +65,11 @@ Initialization timeouts guard lack of catch-up progress, not the full multi-page
Opening or resuming an agent fetches the latest available turns with a soft target of 40
projected items. Backward pages and prompt-jump windows also include whole turns, including
all currently available rows of an active run. There is no per-turn cap: a large run can
exceed the target. Local history mounting uses the same boundaries so revealing older rows
does not change the collapse state of a turn already displayed.
all currently available rows of an active run. A large run can exceed the target. For a paged
request whose complete-turn reply cannot fit the wire message limit, the daemon falls back to
item pages with continuation cursors so the rest remains reachable. Local history mounting uses
turn boundaries so revealing older rows does not change the collapse state of a turn already
displayed.
`wholeTurns` is a preference negotiated once at the client fetch boundary. Hosts advertising
`features.wholeTurnTimeline` receive it; other hosts receive the existing item-based request.
@@ -5,6 +5,94 @@ import { describe, expect, it } from "vitest";
import { selectReferenceProjectedTimelinePage } from "./test-utils/timeline-page-reference.js";
import type { AgentTimelineItem } from "./agent-sdk-types.js";
import { InMemoryAgentTimelineStore } from "./agent-timeline-store.js";
import { selectTimelineResponseWithinFrameBudget } from "../session/timeline-frame-budget.js";
describe("whole-turn byte budget", () => {
function fixture() {
const store = new InMemoryAgentTimelineStore();
store.initialize("agent", { epoch: "current" });
for (let index = 1; index <= 8; index++) {
store.append(
"agent",
{ type: "assistant_message", messageId: `item-${index}`, text: "\u20ac".repeat(180) },
{ turnId: "one-turn" },
);
}
return store;
}
function request(
store: ReturnType<typeof fixture>,
options: {
maxBytes: number;
limit: number;
direction?: "before" | "after";
cursor?: { epoch: string; seq: number };
},
) {
return selectTimelineResponseWithinFrameBudget({
wholeTurns: true,
limit: options.limit,
maxBytes: options.maxBytes,
select: ({ wholeTurns, limit }) => {
const { rows, ...page } = store.fetch("agent", {
direction: options.direction ?? "tail",
cursor: options.cursor,
wholeTurns,
limit,
});
return { type: "fetch_agent_timeline_response", payload: { ...page, entries: rows } };
},
}).payload;
}
it("keeps complete turns whenever they fit, and leaves explicit full reads unchanged", () => {
const store = fixture();
expect(request(store, { maxBytes: 10000, limit: 2 }).entries.map((row) => row.seq)).toEqual([
1, 2, 3, 4, 5, 6, 7, 8,
]);
expect(request(store, { maxBytes: 500, limit: 0 }).entries).toHaveLength(8);
});
it("splits an oversized turn into adjacent older pages without losing any entries", () => {
const store = fixture();
let page = request(store, { maxBytes: 1300, limit: 2 });
expect(page).toMatchObject({ startSeq: 8, endSeq: 8, hasOlder: true });
const seen = page.entries.map((row) => row.seq);
for (let index = 7; index >= 1; index--) {
page = request(store, {
maxBytes: 1300,
limit: 2,
direction: "before",
cursor: { epoch: page.epoch, seq: page.startSeq! },
});
expect(page).toMatchObject({ startSeq: index, endSeq: index, hasOlder: index > 1 });
seen.unshift(...page.entries.map((row) => row.seq));
}
expect(seen).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
});
it("keeps the forward cursor on the oldest unsent part of an oversized turn", () => {
const store = fixture();
let seq = 1;
for (let expected = 2; expected <= 8; expected++) {
const page = request(store, {
maxBytes: 1300,
limit: 2,
direction: "after",
cursor: { epoch: "current", seq },
});
expect(page).toMatchObject({ startSeq: expected, endSeq: expected, hasNewer: expected < 8 });
seq = page.endSeq!;
}
});
it("reports when even a single row cannot fit", () => {
expect(() => request(fixture(), { maxBytes: 100, limit: 2 })).toThrow(
/timeline item exceeds the response size limit/i,
);
});
});
describe("InMemoryAgentTimelineStore", () => {
it("resets stale forward cursors to complete available turns", () => {
+49 -66
View File
@@ -213,6 +213,7 @@ import {
type SpeechModelsSessionOptions,
} from "./session/speech/speech-models-session.js";
import { WorkspaceFilesSession } from "./session/files/workspace-files-session.js";
import { selectTimelineResponseWithinFrameBudget } from "./session/timeline-frame-budget.js";
import { AgentConfigSession } from "./session/agent-config/agent-config-session.js";
import { ProjectConfigSession } from "./session/project-config/project-config-session.js";
import { DaemonSession, type DaemonRuntimeConfig } from "./session/daemon/daemon-session.js";
@@ -8458,76 +8459,58 @@ export class Session {
});
const agentPayload = await this.buildAgentPayload(snapshot);
const fetchedControlTimeline = this.agentManager.fetchTimeline(msg.agentId, {
direction,
cursor,
const supportsReasoningMerge = source
? this.supportsForSource(CLIENT_CAPS.reasoningMergeEnum, source)
: this.supports(CLIENT_CAPS.reasoningMergeEnum);
const response = selectTimelineResponseWithinFrameBudget({
limit: msg.limit,
wholeTurns: msg.wholeTurns,
});
const selectedTimeline = {
timeline: fetchedControlTimeline,
entries: fetchedControlTimeline.rows,
startSeq: fetchedControlTimeline.startSeq,
endSeq: fetchedControlTimeline.endSeq,
hasOlder: fetchedControlTimeline.hasOlder,
hasNewer: fetchedControlTimeline.hasNewer,
};
const startCursor =
selectedTimeline.startSeq !== null
? { epoch: selectedTimeline.timeline.epoch, seq: selectedTimeline.startSeq }
: null;
const endCursor =
selectedTimeline.endSeq !== null
? { epoch: selectedTimeline.timeline.epoch, seq: selectedTimeline.endSeq }
: null;
const entries = selectedTimeline.entries.filter((entry) =>
this.supportsTimelineItem(entry.item, source),
);
this.emitForSource(
{
type: "fetch_agent_timeline_response",
payload: {
requestId: msg.requestId,
agentId: msg.agentId,
agent: agentPayload,
select: ({ limit, wholeTurns }) => {
const timeline = this.agentManager.fetchTimeline(msg.agentId, {
direction,
projection,
epoch: selectedTimeline.timeline.epoch,
reset: fetchedControlTimeline.reset,
staleCursor: fetchedControlTimeline.staleCursor,
gap: fetchedControlTimeline.gap,
window: selectedTimeline.timeline.window,
startCursor,
endCursor,
hasOlder: selectedTimeline.hasOlder,
hasNewer: selectedTimeline.hasNewer,
...(msg.mergeWindow === true ? { mergeWindow: true } : {}),
entries: entries.map((entry) => {
const payloadEntry = {
provider: snapshot.provider,
item: entry.item,
timestamp: entry.timestamp,
seqStart: entry.seqStart,
seqEnd: entry.seqEnd,
sourceSeqRanges: entry.sourceSeqRanges,
turnId: undefined as string | undefined,
collapsed: (
source
? this.supportsForSource(CLIENT_CAPS.reasoningMergeEnum, source)
: this.supports(CLIENT_CAPS.reasoningMergeEnum)
)
? entry.collapsed
: entry.collapsed.filter((value) => value !== "reasoning_merge"),
};
payloadEntry.turnId = entry.turnId;
return payloadEntry;
}),
error: null,
},
cursor,
limit,
wholeTurns,
});
const { epoch, startSeq, endSeq } = timeline;
return {
type: "fetch_agent_timeline_response" as const,
payload: {
requestId: msg.requestId,
agentId: msg.agentId,
agent: agentPayload,
direction,
projection,
epoch,
reset: timeline.reset,
staleCursor: timeline.staleCursor,
gap: timeline.gap,
window: timeline.window,
startCursor: startSeq === null ? null : { epoch, seq: startSeq },
endCursor: endSeq === null ? null : { epoch, seq: endSeq },
hasOlder: timeline.hasOlder,
hasNewer: timeline.hasNewer,
...(msg.mergeWindow === true ? { mergeWindow: true } : {}),
entries: timeline.rows
.filter((entry) => this.supportsTimelineItem(entry.item, source))
.map((entry) => ({
provider: snapshot.provider,
item: entry.item,
timestamp: entry.timestamp,
seqStart: entry.seqStart,
seqEnd: entry.seqEnd,
sourceSeqRanges: entry.sourceSeqRanges,
turnId: entry.turnId,
collapsed: supportsReasoningMerge
? entry.collapsed
: entry.collapsed.filter((value) => value !== "reasoning_merge"),
})),
error: null,
},
};
},
source,
);
});
this.emitForSource(response, source);
} catch (error) {
this.sessionLogger.error(
{ err: error, agentId: msg.agentId },
@@ -0,0 +1,51 @@
import { MAX_WEBSOCKET_MESSAGE_BYTES } from "@getpaseo/protocol/websocket-message-limit";
// Routed replies add their own envelope around the session frame.
const TIMELINE_FRAME_BUDGET_BYTES = MAX_WEBSOCKET_MESSAGE_BYTES - 64 * 1024;
interface TimelineRequest {
wholeTurns?: boolean;
limit?: number;
}
interface TimelineResponse {
payload: { entries: readonly unknown[] };
}
function fitsFrameBudget(response: TimelineResponse, maxBytes: number): boolean {
const { entries, ...payload } = response.payload;
// Count bytes without constructing an oversized JSON string for the whole turn.
let bytes = Buffer.byteLength(
JSON.stringify({
type: "session",
message: { ...response, payload: { ...payload, entries: [] } },
}),
);
for (const entry of entries) {
bytes += Buffer.byteLength(JSON.stringify(entry)) + 1;
if (bytes > maxBytes) return false;
}
return bytes <= maxBytes;
}
export function selectTimelineResponseWithinFrameBudget<T extends TimelineResponse>(
options: TimelineRequest & { select: (request: TimelineRequest) => T; maxBytes?: number },
): T {
const { select, wholeTurns, maxBytes = TIMELINE_FRAME_BUDGET_BYTES } = options;
let { limit } = options;
const requested = select({ wholeTurns, limit });
// Preserve whole-turn pages that fit and the existing explicit full-read contract.
if (wholeTurns !== true || limit === 0 || fitsFrameBudget(requested, maxBytes)) return requested;
for (;;) {
// Reselect using the original direction and cursor; slicing the old response
// would keep the wrong fences and hide the skipped entries from scrollback.
const page = select({ wholeTurns: false, limit });
if (fitsFrameBudget(page, maxBytes)) return page;
const currentLimit = limit ?? page.payload.entries.length;
if (currentLimit <= 1) {
throw new Error("A timeline item exceeds the response size limit.");
}
limit = Math.floor(currentLimit / 2);
}
}