fix(webapp,core,sdk): page chat history and keep model context private

# Chat history reads a page at a time, and the model's context stays
private

Reading a `chat.agent` conversation's history used to download and parse
the whole conversation, so
it got slower as a chat grew. A conversation's stored transcript now
carries an index, so reading
the most recent messages fetches only those messages.

The same change closes a narrower problem: the model-side context an
agent keeps, its compacted
history and any injected context, was reachable from a browser. It is
not part of a transcript and
is no longer served with one.

## Before

```mermaid
sequenceDiagram
    participant Browser
    participant Webapp
    participant Store as Object store
    Browser->>Webapp: open a chat
    Webapp-->>Browser: presigned URL for the whole snapshot
    Browser->>Store: GET the entire object
    Store-->>Browser: messages AND model context
    Note over Browser,Store: the whole conversation, including context a transcript never shows
    Webapp->>Store: GET the entire object (page read)
    Webapp->>Webapp: parse all of it, return 50 messages
```

Every read paid for the whole conversation: request-thread CPU for the
API, bytes over the wire for
the browser. Paging alone could not fix it, because the messages a page
needs sit at the end of one
JSON document, so finding them meant parsing all of it.

## After

```mermaid
sequenceDiagram
    participant Browser
    participant Webapp
    participant Store as Object store
    Browser->>Webapp: open a chat
    Webapp->>Store: ranged GET, end of the object
    Store-->>Webapp: index + newest entries
    Webapp-->>Browser: messages and a cursor
    Note over Webapp,Store: one ranged read, and the browser never touches the store
```

The stored transcript is a header line holding the cursors and the
agent's own state, one line per
message, an index, and a fixed-width trailer giving the index's length.
A reader takes the end of
the object and decodes only the bytes holding the page it was asked for.

## Safety contract

- The private state lives in the header, so a page read cannot return it
by layout, not by
  remembering to strip a field.
- A cursor the transcript no longer holds yields an empty page, never
the newest entries, which
  would present recent messages as older ones.
- Page timestamps come from a message's position in the whole
transcript, not in its page, so pages
  fetched newest-first still merge into conversation order.
- Trimming is expressed relative to the compaction watermark, because
everything after it is live
  context the next boot converts and must never be dropped.

## Scope and impact

A conversation saved by an earlier version still reads correctly: the
reader recognises the old
format and reads the whole object. Each conversation moves to the new
layout the next time it
saves, so there is no migration step. An older reader cannot read the
new format, so roll forward
rather than back.

The built-in storage is deliberately basic about long conversations:
once an agent has compacted it
keeps roughly the last hundred messages and drops the rest, so what it
rewrites each turn stops
growing. A conversation that never compacts is kept whole. An app that
renders history further back
than that keeps its own transcript storage.

## Rollout controls

No flag. The read change is the same data through a cheaper path, and
gating the exposure fix would
mean leaving it open by default. Revert is a deploy revert: stored
objects are untouched and the
state is still written and read on the private path. Presigned URLs
already issued stay valid for
their lifetime, so the exposure fix is not retroactive for the few
minutes before a deploy.

What a regression looks like: `chat.agent: snapshot version/shape
mismatch` at run boot, or
`transcript endpoint: ranged read failed` in the webapp logs. The first
would mean a conversation a
later run cannot read, which is the one worth paging on.

## Verification

Tests prove: paging over byte offsets, including multibyte content where
a character-indexed table
would slice mid-message; reading the previous format; a conversation
whose stored media type
disagrees with its contents; a cursor the transcript no longer holds;
each page's position in the
whole transcript; that no byte a page read fetches contains the private
state; that a trimmed
transcript still restores the model's context; and that a watermark
outside the retained window
does not discard the summary. One test asserts the failure that guard
prevents, so it cannot be
dropped quietly. Real runs additionally cover a cold continuation
booting from a trimmed snapshot
and snapshot size plateauing over 130 turns.

Mono-RevId: 7e57e5e9b859592827719a35e6a624c1cd7123f6

Author: ericallam

.changeset/chat-transcript-paged-reads.md

@@ -0,0 +1,12 @@
+---
+"@trigger.dev/core": patch
+"@trigger.dev/sdk": patch
+---
+
+Reading a page of a chat agent's conversation no longer downloads the whole conversation. The saved transcript now carries an index, so asking for the most recent messages fetches only those messages, and history loads in roughly constant time however long the chat gets.
+
+A paged read also returns only the conversation itself. The model-side context an agent keeps, its compacted history and any injected context, is no longer included, so it cannot reach a browser through a load-transcript server action.
+
+The built-in storage is deliberately basic about long conversations: once an agent has compacted, it keeps roughly the last hundred messages and drops the rest, so what it rewrites each turn stops growing. A conversation that never compacts is kept whole. If your app renders history further back than that, give the agent your own transcript storage.
+
+The saved format has changed and an older SDK cannot read it, so a deployment rolled back to an earlier version will not find a readable transcript for conversations the newer version already saved, and those conversations continue from the live stream tail instead. Roll forward rather than back, or keep your own transcript storage.

apps/webapp/app/components/runs/v3/agent/AgentView.tsx

@@ -1,11 +1,12 @@
 import type { UIMessage } from "@ai-sdk/react";
 import { SSEStreamSubscription } from "@trigger.dev/core/v3";
-import { useEffect, useMemo, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Button } from "~/components/primitives/Buttons";
 import { Paragraph } from "~/components/primitives/Paragraph";
 import { Spinner } from "~/components/primitives/Spinner";
 import { AgentMessageView } from "~/components/runs/v3/agent/AgentMessageView";
-import { seedFromTranscriptSnapshot } from "~/components/runs/v3/agent/transcriptSnapshotSeed";
 import { useAutoScrollToBottom } from "~/hooks/useAutoScrollToBottom";
+import type { TranscriptSeed } from "~/services/realtime/transcriptSeed.server";
 import { useEnvironment } from "~/hooks/useEnvironment";
 import { useOrganization } from "~/hooks/useOrganizations";
 import { useProject } from "~/hooks/useProject";
@@ -29,14 +30,13 @@ export type AgentViewAuth = {
    */
   initialMessages: UIMessage[];
   /**
-   * Presigned GET URL for the session's chat-snapshot S3 blob (written
-   * by the agent after each turn-complete; see `ChatSnapshotV1`).
-   * Optional — sessions that registered a `hydrateMessages` hook skip
-   * snapshot writes and the URL fetch will 404. In that case the
-   * dashboard falls back to seq=0 SSE (which, post-trim, shows only the
-   * most recent turn). Generated server-side by `SessionPresenter`.
+   * The most recent messages of the session's saved transcript, read
+   * server-side by `SessionPresenter`, with the stream cursor to resume just
+   * past them. Absent for sessions that registered a `hydrateMessages` hook and
+   * so save no transcript; the dashboard then falls back to seq=0 SSE (which,
+   * post-trim, shows only the most recent turn).
    */
-  snapshotPresignedUrl?: string;
+  transcriptSeed?: TranscriptSeed;
 };
 
 /**
@@ -84,14 +84,14 @@ export function AgentView({ agentView }: { agentView: AgentViewAuth }) {
   const project = useProject();
   const environment = useEnvironment();
 
-  const messages = useAgentSessionMessages({
+  const { messages, hasEarlier, isLoadingEarlier, loadEarlier } = useAgentSessionMessages({
     sessionId: agentView.sessionId,
     apiOrigin: agentView.apiOrigin,
     orgSlug: organization.slug,
     projectSlug: project.slug,
     envSlug: environment.slug,
     initialMessages: agentView.initialMessages,
-    snapshotPresignedUrl: agentView.snapshotPresignedUrl,
+    transcriptSeed: agentView.transcriptSeed,
   });
 
   // Sticky-bottom auto-scroll: walks up to find the inspector's scroll
@@ -112,7 +112,16 @@ export function AgentView({ agentView }: { agentView: AgentViewAuth }) {
           </div>
         </div>
       ) : (
-        <AgentMessageView messages={messages} />
+        <>
+          {hasEarlier ? (
+            <div className="flex justify-center pb-2">
+              <Button variant="minimal/small" onClick={loadEarlier} disabled={isLoadingEarlier}>
+                {isLoadingEarlier ? "Loading…" : "Load earlier messages"}
+              </Button>
+            </div>
+          ) : null}
+          <AgentMessageView messages={messages} />
+        </>
       )}
     </div>
   );
@@ -234,35 +243,46 @@ function useAgentSessionMessages({
   projectSlug,
   envSlug,
   initialMessages,
-  snapshotPresignedUrl,
+  transcriptSeed,
 }: {
   sessionId: string;
   apiOrigin: string;
   orgSlug: string;
   projectSlug: string;
   envSlug: string;
   initialMessages: UIMessage[];
-  snapshotPresignedUrl?: string;
-}): UIMessage[] {
+  transcriptSeed?: TranscriptSeed;
+}): {
+  messages: UIMessage[];
+  hasEarlier: boolean;
+  isLoadingEarlier: boolean;
+  loadEarlier: () => void;
+} {
   // Seed with the user messages from the run's task payload.
   const seedMessages = useMemo(
     () => initialMessages.filter((m) => m.role === "user"),
     [initialMessages]
   );
 
-  // The snapshot URL is re-signed by the loader on every navigation
-  // (tab switches in the inspector pane re-run the session loader),
-  // which would otherwise re-trigger the subscription effect below
-  // and replay post-snapshot `.out` chunks on top of the messages we
-  // already accumulated — duplicating any assistant content that
-  // lives past `snapshot.lastOutEventId` (e.g., a canceled run whose
-  // turn never completed). Hold the URL behind a ref and keep it
-  // out of the effect's deps so the effect runs exactly once per
-  // mount.
-  const snapshotUrlRef = useRef(snapshotPresignedUrl);
+  // The seed is re-read by the loader on every navigation (tab switches in the
+  // inspector pane re-run the session loader), which would otherwise re-trigger
+  // the subscription effect below and replay post-snapshot `.out` chunks on top
+  // of the messages we already accumulated — duplicating any assistant content
+  // that lives past `lastOutEventId` (e.g., a canceled run whose turn never
+  // completed). Hold it behind a ref and keep it out of the effect's deps so
+  // the effect runs exactly once per mount.
+  const transcriptSeedRef = useRef(transcriptSeed);
   useEffect(() => {
-    snapshotUrlRef.current = snapshotPresignedUrl;
-  }, [snapshotPresignedUrl]);
+    transcriptSeedRef.current = transcriptSeed;
+  }, [transcriptSeed]);
+
+  // Cursor for history older than the seeded page. The dashboard seeds the
+  // most recent page server-side; earlier pages are fetched on demand so a long
+  // conversation is not rendered truncated.
+  const [earlierCursor, setEarlierCursor] = useState<string | undefined>(
+    transcriptSeed?.nextCursor
+  );
+  const [isLoadingEarlier, setIsLoadingEarlier] = useState(false);
 
   // `pendingRef` is the authoritative, eagerly-updated message state:
   // chunks mutate this synchronously as they arrive. A throttled flush
@@ -386,28 +406,17 @@ function useAgentSessionMessages({
      * have a snapshot (e.g. `hydrateMessages` customers, or sessions that
      * have never completed a turn).
      */
-    const loadSnapshot = async (): Promise<string | undefined> => {
-      const url = snapshotUrlRef.current;
-      if (!url) return undefined;
-      try {
-        const resp = await fetch(url, { signal: abort.signal });
-        if (!resp.ok) return undefined;
-        const json = (await resp.json()) as unknown;
-        const seed = seedFromTranscriptSnapshot(json);
-        if (!seed) return undefined;
-        for (const { id, message, timestamp } of seed.messages) {
-          // The snapshot's seed wins over the task-payload seed for any
-          // overlapping ids (the snapshot represents the agent's
-          // canonical accumulator, post-turn).
-          pendingRef.current.set(id, message);
-          timestampsRef.current.set(id, timestamp);
-        }
-        scheduleFlush.current();
-        return seed.lastOutEventId;
-      } catch {
-        // 404 / network / parse / abort — fall back to seq=0 SSE
-        return undefined;
+    const loadSnapshot = (): string | undefined => {
+      const seed = transcriptSeedRef.current;
+      if (!seed) return undefined;
+      for (const { id, message, timestamp } of seed.messages) {
+        // The transcript wins over the task-payload seed for any overlapping
+        // ids: it is the agent's canonical accumulator, post-turn.
+        pendingRef.current.set(id, message);
+        timestampsRef.current.set(id, timestamp);
       }
+      if (seed.messages.length > 0) scheduleFlush.current();
+      return seed.lastOutEventId;
     };
 
     const outputSubOptions = (lastEventId: string | undefined) =>
@@ -449,7 +458,7 @@ function useAgentSessionMessages({
         // at seq=0 — which, post-trim, contains roughly one turn of
         // records (acceptable fallback for `hydrateMessages` sessions
         // and fresh sessions).
-        const snapshotLastEventId = await loadSnapshot();
+        const snapshotLastEventId = loadSnapshot();
         if (abort.signal.aborted) return;
 
         const sub = new SSEStreamSubscription(outputUrl, outputSubOptions(snapshotLastEventId));
@@ -656,7 +665,39 @@ function useAgentSessionMessages({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [sessionId, apiOrigin, orgSlug, projectSlug, envSlug]);
 
-  return useMemo(() => {
+  const loadEarlier = useCallback(() => {
+    if (earlierCursor === undefined || isLoadingEarlier) return;
+    setIsLoadingEarlier(true);
+
+    const origin = typeof window !== "undefined" ? window.location.origin : apiOrigin;
+    const url =
+      `${origin}/resources/orgs/${orgSlug}/projects/${projectSlug}/env/${envSlug}` +
+      `/sessions/${encodeURIComponent(sessionId)}/transcript?before=${encodeURIComponent(
+        earlierCursor
+      )}`;
+
+    fetch(url)
+      .then((resp) => (resp.ok ? resp.json() : Promise.reject(new Error(String(resp.status)))))
+      .then((raw) => {
+        const body = raw as { messages?: TranscriptSeed["messages"]; nextCursor?: string };
+        for (const { id, message, timestamp } of body.messages ?? []) {
+          // Earlier history never overwrites a message already on screen: what
+          // is here came from the stream or a newer page and is at least as
+          // current.
+          if (pendingRef.current.has(id)) continue;
+          pendingRef.current.set(id, message);
+          timestampsRef.current.set(id, timestamp);
+        }
+        setEarlierCursor(body.nextCursor);
+        scheduleFlush.current();
+      })
+      .catch(() => {
+        // Leave the cursor in place so the control stays available to retry.
+      })
+      .finally(() => setIsLoadingEarlier(false));
+  }, [earlierCursor, isLoadingEarlier, apiOrigin, orgSlug, projectSlug, envSlug, sessionId]);
+
+  const sorted = useMemo(() => {
     const timestamps = timestampsRef.current;
     const arr = Array.from(messagesById.values());
 
@@ -670,6 +711,13 @@ function useAgentSessionMessages({
     });
     return arr;
   }, [messagesById]);
+
+  return {
+    messages: sorted,
+    hasEarlier: earlierCursor !== undefined,
+    isLoadingEarlier,
+    loadEarlier,
+  };
 }
 
 // ---------------------------------------------------------------------------