@truefoundry/assistant-ui-runtime 0.1.1 → 0.1.2

package/dist/index.js

@@ -1304,6 +1304,280 @@ function replaceSessionSnapshot(snapshot, patch) {
 // src/convertTurnMessages.ts
 var TURN_EVENTS_PAGE_SIZE = 25;
 var SESSION_EVENTS_PAGE_SIZE = 100;
+var MAX_HISTORY_BOUNDARY_PAGES = 10;
+function trimIncompleteLeadingEvents(itemsAsc) {
+  const start = itemsAsc.findIndex((item) => item.event.type === "turn.created");
+  if (start === -1) {
+    return [];
+  }
+  return itemsAsc.slice(start);
+}
+function oldestCompleteTurnGroupState(itemsAsc) {
+  const trimmed = trimIncompleteLeadingEvents(itemsAsc);
+  if (trimmed.length === 0) {
+    return "incomplete";
+  }
+  const created = trimmed[0];
+  if (created?.event.type !== "turn.created") {
+    return "incomplete";
+  }
+  const hasDone = trimmed.some(
+    (item) => item.turnId === created.turnId && item.event.type === "turn.done"
+  );
+  if (!hasDone) {
+    return "incomplete";
+  }
+  return extractTurnUserText(created.event.input) != null ? "user-group" : "continuation";
+}
+async function fetchSessionEventsPage(session, options) {
+  const page = await session.listEvents({
+    limit: SESSION_EVENTS_PAGE_SIZE,
+    ...options?.lastTurnId != null ? { lastTurnId: options.lastTurnId } : {},
+    ...options?.pageToken != null ? { pageToken: options.pageToken } : {}
+  });
+  const response = page.response;
+  const olderPageToken = response.pagination?.nextPageToken;
+  const hasOlder = typeof page.hasNextPage === "function" ? page.hasNextPage() : olderPageToken != null && olderPageToken !== "";
+  return {
+    itemsNewestFirst: page.data,
+    ...olderPageToken != null && olderPageToken !== "" ? { olderPageToken } : {},
+    hasOlder
+  };
+}
+async function fetchSessionEventsWindow(session, options) {
+  let itemsNewestFirst = [];
+  let pageToken = options?.pageToken;
+  let olderPageToken;
+  let hasOlder = false;
+  for (let pageCount = 0; pageCount < MAX_HISTORY_BOUNDARY_PAGES; pageCount++) {
+    const page = await fetchSessionEventsPage(session, {
+      ...options,
+      ...pageToken != null ? { pageToken } : {}
+    });
+    itemsNewestFirst = [...itemsNewestFirst, ...page.itemsNewestFirst];
+    olderPageToken = page.olderPageToken;
+    hasOlder = page.hasOlder;
+    const itemsAsc2 = trimIncompleteLeadingEvents([...itemsNewestFirst].reverse());
+    const groupState = oldestCompleteTurnGroupState(itemsAsc2);
+    if (groupState === "user-group" || !hasOlder) {
+      return {
+        itemsAsc: itemsAsc2,
+        ...olderPageToken != null ? { olderPageToken } : {},
+        hasOlder
+      };
+    }
+    if (olderPageToken == null) {
+      return { itemsAsc: itemsAsc2, hasOlder: false };
+    }
+    pageToken = olderPageToken;
+  }
+  const itemsAsc = trimIncompleteLeadingEvents([...itemsNewestFirst].reverse());
+  return {
+    itemsAsc,
+    ...olderPageToken != null ? { olderPageToken } : {},
+    hasOlder
+  };
+}
+async function fetchAllSessionEvents(session, options) {
+  const items = [];
+  for await (const item of await session.listEvents({
+    limit: SESSION_EVENTS_PAGE_SIZE,
+    ...options?.lastTurnId != null ? { lastTurnId: options.lastTurnId } : {}
+  })) {
+    items.push(item);
+  }
+  items.reverse();
+  return items;
+}
+function cloneThreadBucket(bucket) {
+  return {
+    events: new Map(bucket.events),
+    modelMessageIds: [...bucket.modelMessageIds],
+    toolResults: new Map(bucket.toolResults),
+    pendingApprovals: new Map(bucket.pendingApprovals),
+    approvalDecisions: new Map(bucket.approvalDecisions),
+    pendingResponses: new Map(bucket.pendingResponses),
+    done: bucket.done,
+    ...bucket.title != null ? { title: bucket.title } : {},
+    ...bucket.agentInfo != null ? { agentInfo: bucket.agentInfo } : {}
+  };
+}
+function prependFoldState(older, newer) {
+  const result = new PeerThreadFoldState();
+  const threadIds = /* @__PURE__ */ new Set([...older.threads.keys(), ...newer.threads.keys()]);
+  for (const threadId of threadIds) {
+    const olderBucket = older.threads.get(threadId);
+    const newerBucket = newer.threads.get(threadId);
+    if (olderBucket == null && newerBucket != null) {
+      result.threads.set(threadId, cloneThreadBucket(newerBucket));
+      continue;
+    }
+    if (newerBucket == null && olderBucket != null) {
+      result.threads.set(threadId, cloneThreadBucket(olderBucket));
+      continue;
+    }
+    if (olderBucket == null || newerBucket == null) {
+      continue;
+    }
+    result.threads.set(threadId, {
+      events: new Map([...olderBucket.events, ...newerBucket.events]),
+      modelMessageIds: [
+        ...olderBucket.modelMessageIds,
+        ...newerBucket.modelMessageIds
+      ],
+      toolResults: new Map([
+        ...olderBucket.toolResults,
+        ...newerBucket.toolResults
+      ]),
+      pendingApprovals: new Map([
+        ...olderBucket.pendingApprovals,
+        ...newerBucket.pendingApprovals
+      ]),
+      approvalDecisions: new Map([
+        ...olderBucket.approvalDecisions,
+        ...newerBucket.approvalDecisions
+      ]),
+      pendingResponses: new Map([
+        ...olderBucket.pendingResponses,
+        ...newerBucket.pendingResponses
+      ]),
+      done: newerBucket.done || olderBucket.done,
+      ...newerBucket.title != null || olderBucket.title != null ? { title: newerBucket.title ?? olderBucket.title } : {},
+      ...newerBucket.agentInfo != null || olderBucket.agentInfo != null ? { agentInfo: newerBucket.agentInfo ?? olderBucket.agentInfo } : {}
+    });
+  }
+  for (const [threadId, link] of older.threadParents) {
+    result.threadParents.set(threadId, link);
+  }
+  for (const [threadId, link] of newer.threadParents) {
+    result.threadParents.set(threadId, link);
+  }
+  return result;
+}
+function ingestSessionEventsIntoSnapshot(snapshot, items, onTurnComplete) {
+  let currentTurnId = null;
+  let currentCreatedEvent = null;
+  let currentContentEvents = [];
+  let beforeCount = 0;
+  for (const item of items) {
+    const { turnId, event } = item;
+    if (event.type === "turn.created") {
+      currentTurnId = turnId;
+      currentCreatedEvent = event;
+      currentContentEvents = [];
+      beforeCount = snapshot.fold.threads.get(ROOT_THREAD_ID)?.modelMessageIds.length ?? 0;
+    } else if (event.type === "turn.done") {
+      if (currentTurnId == null || currentCreatedEvent == null) {
+        continue;
+      }
+      const afterBucket = snapshot.fold.threads.get(ROOT_THREAD_ID);
+      const rootModelMessageIds = (afterBucket?.modelMessageIds ?? []).slice(
+        beforeCount
+      );
+      const sandboxEvent = currentContentEvents.find(
+        (ev) => ev.type === "sandbox.created"
+      );
+      applyUserToolResponsesToFold(
+        snapshot.fold,
+        currentCreatedEvent.input ?? []
+      );
+      snapshot.turns.push(
+        sessionEventsToSessionRecord(
+          currentTurnId,
+          currentCreatedEvent,
+          event,
+          rootModelMessageIds,
+          sandboxEvent?.sandboxId
+        )
+      );
+      onTurnComplete?.(replaceSessionSnapshot(snapshot, {}));
+      currentTurnId = null;
+      currentCreatedEvent = null;
+      currentContentEvents = [];
+    } else {
+      if (currentTurnId != null) {
+        ingestTurnEvent(snapshot.fold, event);
+        currentContentEvents.push(event);
+      }
+    }
+  }
+}
+function attachRunningTurn(snapshot, runningTurn) {
+  if (runningTurn == null) {
+    return snapshot;
+  }
+  const pendingUserText = extractTurnUserText(runningTurn.input);
+  return replaceSessionSnapshot(snapshot, {
+    runningTurn,
+    unstable_resume: true,
+    groupRootBaseline: computeGroupRootBaseline(snapshot.turns),
+    ...pendingUserText ? {
+      pendingUser: {
+        turnId: runningTurn.id,
+        content: extractTurnUserMessageContent(runningTurn.input),
+        createdAt: new Date(runningTurn.createdAt)
+      }
+    } : {}
+  });
+}
+async function buildSnapshotFromSessionEvents(session, onProgress) {
+  const turnsPage = await session.listTurns({ limit: 1 });
+  const newestTurn = turnsPage.data[0];
+  const runningTurn = newestTurn?.state?.status === "running" ? newestTurn : void 0;
+  const window = await fetchSessionEventsWindow(session);
+  const historyPagination = {
+    hasOlder: window.hasOlder,
+    ...window.olderPageToken != null ? { olderPageToken: window.olderPageToken } : {}
+  };
+  const snapshot = createEmptySessionSnapshot();
+  ingestSessionEventsIntoSnapshot(snapshot, window.itemsAsc, onProgress);
+  const withHistory = replaceSessionSnapshot(snapshot, {
+    historyEvents: window.itemsAsc,
+    historyPagination
+  });
+  return attachRunningTurn(withHistory, runningTurn);
+}
+async function prependOlderSessionHistory(session, snapshot) {
+  const pagination = snapshot.historyPagination;
+  if (pagination?.hasOlder !== true || pagination.olderPageToken == null) {
+    return snapshot;
+  }
+  const window = await fetchSessionEventsWindow(session, {
+    pageToken: pagination.olderPageToken
+  });
+  if (window.itemsAsc.length === 0) {
+    return replaceSessionSnapshot(snapshot, {
+      historyPagination: { hasOlder: false }
+    });
+  }
+  const olderSnap = createEmptySessionSnapshot();
+  ingestSessionEventsIntoSnapshot(olderSnap, window.itemsAsc);
+  const existingIds = new Set(snapshot.turns.map((turn) => turn.id));
+  const olderTurns = olderSnap.turns.filter((turn) => !existingIds.has(turn.id));
+  const mergedFold = prependFoldState(olderSnap.fold, snapshot.fold);
+  const historyEvents = [
+    ...window.itemsAsc,
+    ...snapshot.historyEvents ?? []
+  ];
+  const olderRootIds = olderTurns.flatMap(
+    (turn) => turn.rootModelMessageIds ?? []
+  );
+  return replaceSessionSnapshot(snapshot, {
+    fold: mergedFold,
+    turns: [...olderTurns, ...snapshot.turns],
+    historyEvents,
+    historyPagination: {
+      hasOlder: window.hasOlder,
+      ...window.olderPageToken != null ? { olderPageToken: window.olderPageToken } : {}
+    },
+    ...snapshot.groupRootBaseline != null ? {
+      groupRootBaseline: [
+        ...olderRootIds,
+        ...snapshot.groupRootBaseline
+      ]
+    } : {}
+  });
+}
 function assistantStatusFromTurnState(state) {
   switch (state.status) {
     case "done":
@@ -1710,92 +1984,6 @@ function projectSessionMessages(snapshot, options) {
   );
 }
 var DEFAULT_LIST_EVENTS_CONCURRENCY = 5;
-async function fetchAllSessionEvents(session, options) {
-  const items = [];
-  for await (const item of await session.listEvents({
-    limit: SESSION_EVENTS_PAGE_SIZE,
-    ...options?.lastTurnId != null ? { lastTurnId: options.lastTurnId } : {}
-  })) {
-    items.push(item);
-  }
-  items.reverse();
-  return items;
-}
-function ingestSessionEventsIntoSnapshot(snapshot, items, onTurnComplete) {
-  let currentTurnId = null;
-  let currentCreatedEvent = null;
-  let currentContentEvents = [];
-  let beforeCount = 0;
-  for (const item of items) {
-    const { turnId, event } = item;
-    if (event.type === "turn.created") {
-      currentTurnId = turnId;
-      currentCreatedEvent = event;
-      currentContentEvents = [];
-      beforeCount = snapshot.fold.threads.get(ROOT_THREAD_ID)?.modelMessageIds.length ?? 0;
-    } else if (event.type === "turn.done") {
-      if (currentTurnId == null || currentCreatedEvent == null) {
-        continue;
-      }
-      const afterBucket = snapshot.fold.threads.get(ROOT_THREAD_ID);
-      const rootModelMessageIds = (afterBucket?.modelMessageIds ?? []).slice(
-        beforeCount
-      );
-      const sandboxEvent = currentContentEvents.find(
-        (ev) => ev.type === "sandbox.created"
-      );
-      applyUserToolResponsesToFold(
-        snapshot.fold,
-        currentCreatedEvent.input ?? []
-      );
-      snapshot.turns.push(
-        sessionEventsToSessionRecord(
-          currentTurnId,
-          currentCreatedEvent,
-          event,
-          rootModelMessageIds,
-          sandboxEvent?.sandboxId
-        )
-      );
-      onTurnComplete?.(replaceSessionSnapshot(snapshot, {}));
-      currentTurnId = null;
-      currentCreatedEvent = null;
-      currentContentEvents = [];
-    } else {
-      if (currentTurnId != null) {
-        ingestTurnEvent(snapshot.fold, event);
-        currentContentEvents.push(event);
-      }
-    }
-  }
-}
-async function buildSnapshotFromSessionEvents(session, onProgress) {
-  let runningTurn;
-  for await (const turn of await session.listTurns({ limit: 1 })) {
-    if (turn.state?.status === "running") {
-      runningTurn = turn;
-    }
-  }
-  const items = await fetchAllSessionEvents(session);
-  const snapshot = createEmptySessionSnapshot();
-  ingestSessionEventsIntoSnapshot(snapshot, items, onProgress);
-  if (runningTurn == null) {
-    return snapshot;
-  }
-  const pendingUserText = extractTurnUserText(runningTurn.input);
-  return replaceSessionSnapshot(snapshot, {
-    runningTurn,
-    unstable_resume: true,
-    groupRootBaseline: computeGroupRootBaseline(snapshot.turns),
-    ...pendingUserText ? {
-      pendingUser: {
-        turnId: runningTurn.id,
-        content: extractTurnUserMessageContent(runningTurn.input),
-        createdAt: new Date(runningTurn.createdAt)
-      }
-    } : {}
-  });
-}
 function ingestTurnsIntoSnapshot(snapshot, turns, eventArrays) {
   let runningTurn;
   for (let i = 0; i < turns.length; i++) {
@@ -1834,9 +2022,18 @@ async function buildSnapshotFromSession(session, concurrency = DEFAULT_LIST_EVEN
   return replaceSessionSnapshot(snapshot, {
     runningTurn: turn,
     unstable_resume: true,
-    groupRootBaseline: computeGroupRootBaseline(snapshot.turns)
+    groupRootBaseline: computeGroupRootBaseline(snapshot.turns),
+    pendingUser: void 0
   });
 }
+async function buildSnapshotBeforeTurn(session, beforeTurnId, concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY) {
+  const turns = await listSessionTurnsOrdered(session);
+  const beforeIndex = turns.findIndex((turn) => turn.id === beforeTurnId);
+  if (beforeIndex === -1) {
+    throw new Error(`Turn ${beforeTurnId} not found in session`);
+  }
+  return buildSnapshotBeforeTurnIndex(session, beforeIndex, concurrency, turns);
+}
 async function buildSnapshotBeforeTurnIndex(session, turnIndex, _concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY, orderedTurns) {
   if (turnIndex <= 0) {
     return createEmptySessionSnapshot();
@@ -1859,6 +2056,11 @@ async function resolveGatewayBranchPreviousTurnId(session, turnIndex, orderedTur
   const turns = orderedTurns ?? await listSessionTurnsOrdered(session);
   return turns[turnIndex - 1]?.id ?? null;
 }
+async function resolveGatewayBranchPreviousTurnIdForTurn(session, turnId) {
+  const turns = await listSessionTurnsOrdered(session);
+  const turnIndex = turns.findIndex((turn) => turn.id === turnId);
+  return resolveGatewayBranchPreviousTurnId(session, turnIndex, turns);
+}
 async function listSessionTurnsOrdered(session) {
   const turns = [];
   for await (const turn of await session.listTurns()) {
@@ -2125,6 +2327,7 @@ function repositoryItemsFromMessages(messages) {
 }
 
 // src/private/draftSessionBridge.ts
+var DRAFT_SESSION_LAST_UPDATED_AT_HEADER = "x-tfy-session-last-updated-at";
 function createDraftSessionBridge(gateway) {
   async function getDraft(draftSessionId) {
     const response = await gateway.agents.private.draftSessions.get(draftSessionId);
@@ -2136,7 +2339,11 @@ function createDraftSessionBridge(gateway) {
       return draft.agentSpec;
     },
     async syncAgentSpec(draftSessionId, agentSpec) {
-      await gateway.agents.private.draftSessions.update(draftSessionId, { agentSpec });
+      const response = await gateway.agents.private.draftSessions.update(
+        draftSessionId,
+        { agentSpec }
+      );
+      return response.data.updatedAt;
     }
   };
 }
@@ -3392,6 +3599,29 @@ function useDraftAgentSpec({
   const syncGenerationRef = useRef(0);
   const loadedDraftIdRef = useRef(void 0);
   const localDirtyRef = useRef(false);
+  const lastUpdatedAtRef = useRef(void 0);
+  const pendingFlushRef = useRef(void 0);
+  const inFlightFlushRef = useRef(void 0);
+  const activeDraftIdRef = useRef(draftSessionId);
+  useEffect(() => {
+    const previousDraftId = activeDraftIdRef.current;
+    if (previousDraftId === draftSessionId) {
+      return;
+    }
+    activeDraftIdRef.current = draftSessionId;
+    syncGenerationRef.current++;
+    if (syncTimeoutRef.current != null) {
+      clearTimeout(syncTimeoutRef.current);
+      syncTimeoutRef.current = void 0;
+    }
+    pendingFlushRef.current = void 0;
+    inFlightFlushRef.current = void 0;
+    lastUpdatedAtRef.current = void 0;
+    setIsSpecSyncing(false);
+    if (previousDraftId != null) {
+      localDirtyRef.current = false;
+    }
+  }, [draftSessionId]);
   useEffect(() => {
     if (!enabled || draftBridge == null) {
       return;
@@ -3440,10 +3670,11 @@ function useDraftAgentSpec({
       }
       setIsSpecSyncing(true);
       try {
-        await draftBridge.syncAgentSpec(draftId, spec);
+        const updatedAt = await draftBridge.syncAgentSpec(draftId, spec);
         if (generation !== syncGenerationRef.current) {
           return;
         }
+        lastUpdatedAtRef.current = updatedAt || (/* @__PURE__ */ new Date()).toISOString();
         setSpecError(null);
         onAgentSpecChange?.(spec);
       } catch (error) {
@@ -3465,14 +3696,47 @@ function useDraftAgentSpec({
         clearTimeout(syncTimeoutRef.current);
       }
       const generation = ++syncGenerationRef.current;
+      const flush = () => {
+        pendingFlushRef.current = void 0;
+        syncTimeoutRef.current = void 0;
+        const promise = flushSpecSync(draftId, spec, generation).finally(() => {
+          if (inFlightFlushRef.current === promise) {
+            inFlightFlushRef.current = void 0;
+          }
+        });
+        inFlightFlushRef.current = promise;
+        return promise;
+      };
+      pendingFlushRef.current = flush;
       syncTimeoutRef.current = setTimeout(() => {
-        void flushSpecSync(draftId, spec, generation);
+        void flush();
       }, SPEC_SYNC_DEBOUNCE_MS);
     },
     [flushSpecSync]
   );
   const scheduleSpecSyncRef = useRef(scheduleSpecSync);
   scheduleSpecSyncRef.current = scheduleSpecSync;
+  const flushPendingSpecSyncNow = useCallback(async () => {
+    if (syncTimeoutRef.current != null) {
+      clearTimeout(syncTimeoutRef.current);
+      syncTimeoutRef.current = void 0;
+    }
+    const pending = pendingFlushRef.current;
+    if (pending != null) {
+      pendingFlushRef.current = void 0;
+      await pending();
+      return;
+    }
+    if (inFlightFlushRef.current != null) {
+      await inFlightFlushRef.current;
+    }
+  }, []);
+  const takeTurnHeaderTimestamp = useCallback(async () => {
+    await flushPendingSpecSyncNow();
+    const updatedAt = lastUpdatedAtRef.current;
+    lastUpdatedAtRef.current = void 0;
+    return updatedAt;
+  }, [flushPendingSpecSyncNow]);
   useEffect(
     () => () => {
       if (syncTimeoutRef.current != null) {
@@ -3501,7 +3765,8 @@ function useDraftAgentSpec({
       draftSessionId: enabled ? draftSessionId : void 0,
       isSpecSyncing: enabled ? isSpecSyncing : false,
       specError: enabled ? specError : null,
-      updateAgentSpec
+      updateAgentSpec,
+      takeTurnHeaderTimestamp
     }),
     [
       agentSpec,
@@ -3509,6 +3774,7 @@ function useDraftAgentSpec({
       enabled,
       isSpecSyncing,
       specError,
+      takeTurnHeaderTimestamp,
       updateAgentSpec
     ]
   );
@@ -3593,7 +3859,13 @@ async function* streamTurnContent(session, foldState, options, abortSignal, grou
   }
   try {
     yield* streamTurnEvents(
-      turn.execute({ stream: true }, { abortSignal }),
+      turn.execute(
+        { stream: true },
+        {
+          abortSignal,
+          ...options.headers != null ? { headers: options.headers } : {}
+        }
+      ),
       foldState,
       groupRootBaseline
     );
@@ -3745,16 +4017,6 @@ async function resolveActiveSessionId(remoteId, resolveConversationSessionId) {
   }
   return remoteId;
 }
-function findTurnIndex(snapshot, turnId) {
-  const committedIndex = snapshot.turns.findIndex((turn) => turn.id === turnId);
-  if (committedIndex !== -1) {
-    return committedIndex;
-  }
-  if (snapshot.pendingUser?.turnId === turnId) {
-    return snapshot.turns.length;
-  }
-  throw new Error(`Turn ${turnId} not found in session snapshot`);
-}
 function resolveTurnInput(snapshot, turnId) {
   const turnRecord = snapshot.turns.find((turn) => turn.id === turnId);
   if (turnRecord?.input != null) {
@@ -3773,7 +4035,8 @@ function useTrueFoundryAgentMessages({
   onError,
   initializeSession,
   resolveConversationSessionId,
-  draftGateway
+  draftGateway,
+  getTurnHeaders
 }) {
   const sessionOptions = useMemo2(
     () => draftGateway != null ? { draftGateway } : void 0,
@@ -3782,15 +4045,19 @@ function useTrueFoundryAgentMessages({
   const [snapshot, setSnapshot] = useState2(createEmptySessionSnapshot);
   const [isRunning, setIsRunning] = useState2(false);
   const [isLoading, setIsLoading] = useState2(false);
+  const [isLoadingOlderHistory, setIsLoadingOlderHistory] = useState2(false);
   const [loadRetryTrigger, setLoadRetryTrigger] = useState2(0);
   const snapshotRef = useRef2(snapshot);
   snapshotRef.current = snapshot;
+  const loadOlderInflightRef = useRef2(null);
   const onErrorRef = useRef2(onError);
   onErrorRef.current = onError;
   const resolveConversationSessionIdRef = useRef2(resolveConversationSessionId);
   resolveConversationSessionIdRef.current = resolveConversationSessionId;
   const initializeSessionRef = useRef2(initializeSession);
   initializeSessionRef.current = initializeSession;
+  const getTurnHeadersRef = useRef2(getTurnHeaders);
+  getTurnHeadersRef.current = getTurnHeaders;
   const createdAtByMessageIdRef = useRef2(/* @__PURE__ */ new Map());
   const abortControllerRef = useRef2(null);
   const activeRunRef = useRef2(null);
@@ -3920,9 +4187,11 @@ function useTrueFoundryAgentMessages({
     const generation = ++loadGenerationRef.current;
     ++streamGenerationRef.current;
     abortControllerRef.current?.abort();
+    loadOlderInflightRef.current = null;
     createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
     setSnapshot(createEmptySessionSnapshot());
     setIsLoading(true);
+    setIsLoadingOlderHistory(false);
     try {
       const conversationSessionId = await resolveActiveSessionId(
         sessionId,
@@ -3990,6 +4259,8 @@ function useTrueFoundryAgentMessages({
         resolveConversationSessionIdRef.current
       );
       const session = await getSession(client, conversationSessionId, sessionOptions);
+      const turnHeaders = await getTurnHeadersRef.current?.();
+      const streamHeaders = turnHeaders != null ? { headers: turnHeaders } : {};
       const isContinuation = "inputs" in options || "resumeMcpAuth" in options && options.resumeMcpAuth === true;
       const continuationTurnId = snapshotRef.current.activeStream?.turnId;
       const turnId = isContinuation && continuationTurnId != null ? continuationTurnId : generateId();
@@ -4048,7 +4319,7 @@ function useTrueFoundryAgentMessages({
             return streamTurnContent(
               session,
               snapshotRef.current.fold,
-              { inputs: options.inputs },
+              { inputs: options.inputs, ...streamHeaders },
               signal,
               groupRootBaseline
             );
@@ -4057,7 +4328,7 @@ function useTrueFoundryAgentMessages({
             return streamTurnContent(
               session,
               snapshotRef.current.fold,
-              { resumeMcpAuth: true },
+              { resumeMcpAuth: true, ...streamHeaders },
               signal,
               groupRootBaseline
             );
@@ -4067,7 +4338,8 @@ function useTrueFoundryAgentMessages({
             snapshotRef.current.fold,
             {
               userMessage: options.userMessage,
-              ...options.previousTurnId !== void 0 ? { previousTurnId: options.previousTurnId } : {}
+              ...options.previousTurnId !== void 0 ? { previousTurnId: options.previousTurnId } : {},
+              ...streamHeaders
             },
             signal,
             groupRootBaseline
@@ -4171,20 +4443,19 @@ function useTrueFoundryAgentMessages({
       }
       const committed = commitActiveStream(snapshotRef.current);
       setSnapshot(committed);
-      const turnIndex = findTurnIndex(committed, turnId);
       await cancel();
       const conversationSessionId = await resolveActiveSessionId(
         activeSessionId,
         resolveConversationSessionIdRef.current
       );
       const session = await getSession(client, conversationSessionId, sessionOptions);
-      const previousTurnId = await resolveGatewayBranchPreviousTurnId(
+      const previousTurnId = await resolveGatewayBranchPreviousTurnIdForTurn(
         session,
-        turnIndex
+        turnId
       );
-      const rewound = await buildSnapshotBeforeTurnIndex(
+      const rewound = await buildSnapshotBeforeTurn(
         session,
-        turnIndex,
+        turnId,
         listEventsConcurrency
       );
       createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
@@ -4235,10 +4506,64 @@ function useTrueFoundryAgentMessages({
   const retryLoad = useCallback2(() => {
     setLoadRetryTrigger((n) => n + 1);
   }, []);
+  const hasOlderHistory = snapshot.historyPagination?.hasOlder === true;
+  const loadOlderHistory = useCallback2(async () => {
+    if (sessionId == null || isMain === false) {
+      return;
+    }
+    if (loadOlderInflightRef.current != null) {
+      return loadOlderInflightRef.current;
+    }
+    const current = snapshotRef.current;
+    if (current.historyPagination?.hasOlder !== true) {
+      return;
+    }
+    if (current.historyPagination.olderPageToken == null) {
+      return;
+    }
+    const generation = loadGenerationRef.current;
+    setIsLoadingOlderHistory(true);
+    const run = (async () => {
+      try {
+        const conversationSessionId = await resolveActiveSessionId(
+          sessionId,
+          resolveConversationSessionIdRef.current
+        );
+        const session = await getSession(
+          client,
+          conversationSessionId,
+          sessionOptions
+        );
+        const next = await prependOlderSessionHistory(
+          session,
+          snapshotRef.current
+        );
+        if (generation !== loadGenerationRef.current) {
+          return;
+        }
+        setSnapshot(next);
+      } catch (error) {
+        if (generation === loadGenerationRef.current) {
+          onErrorRef.current?.(error);
+        }
+        throw error;
+      } finally {
+        if (generation === loadGenerationRef.current) {
+          setIsLoadingOlderHistory(false);
+        }
+        loadOlderInflightRef.current = null;
+      }
+    })();
+    loadOlderInflightRef.current = run;
+    return run;
+  }, [client, isMain, sessionId, sessionOptions]);
   return {
     messages,
     isRunning,
     isLoading,
+    isLoadingOlderHistory,
+    hasOlderHistory,
+    loadOlderHistory,
     retryLoad,
     sendTurn,
     cancel,
@@ -4279,6 +4604,18 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
     onAgentSpecChange: agent.mode === "draft" ? agent.onAgentSpecChange : void 0,
     onError
   });
+  const takeTurnHeaderTimestampRef = useRef3(draftSpec.takeTurnHeaderTimestamp);
+  takeTurnHeaderTimestampRef.current = draftSpec.takeTurnHeaderTimestamp;
+  const getTurnHeaders = useCallback3(async () => {
+    if (agent.mode !== "draft") {
+      return void 0;
+    }
+    const updatedAt = await takeTurnHeaderTimestampRef.current();
+    if (updatedAt == null) {
+      return void 0;
+    }
+    return { [DRAFT_SESSION_LAST_UPDATED_AT_HEADER]: updatedAt };
+  }, [agent.mode]);
   const aui = useAui();
   const initializeSession = useCallback3(
     () => aui.threadListItem().initialize(),
@@ -4290,6 +4627,9 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
     messages,
     isRunning,
     isLoading,
+    isLoadingOlderHistory,
+    hasOlderHistory,
+    loadOlderHistory,
     sendTurn,
     cancel,
     respondToToolApproval,
@@ -4305,7 +4645,8 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
     listEventsConcurrency,
     onError,
     initializeSession,
-    draftGateway: agent.mode === "draft" ? gateway : void 0
+    draftGateway: agent.mode === "draft" ? gateway : void 0,
+    getTurnHeaders: agent.mode === "draft" ? getTurnHeaders : void 0
   });
   if (agent.mode === "draft" && draftSpec.agentSpec != null) {
     pendingAgentSpecRef.current = draftSpec.agentSpec;
@@ -4374,6 +4715,9 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
         onError?.(error);
       }),
       reload: retryLoad,
+      hasOlderHistory,
+      isLoadingOlderHistory,
+      loadOlderHistory,
       draft: draftExtras
     }),
     unstable_enableToolInvocations: true,
@@ -4522,6 +4866,19 @@ var useTrueFoundryReload = () => {
   const aui = useAui2();
   return () => trueFoundryExtras.get(aui).reload();
 };
+var useTrueFoundryHistoryPagination = () => {
+  const extras = trueFoundryExtras.use((e) => e, void 0);
+  return useMemo4(
+    () => ({
+      hasOlderHistory: extras?.hasOlderHistory ?? false,
+      isLoadingOlderHistory: extras?.isLoadingOlderHistory ?? false,
+      loadOlderHistory: extras?.loadOlderHistory ?? (async () => {
+        throw new Error("TrueFoundry runtime is not ready yet");
+      })
+    }),
+    [extras]
+  );
+};
 var useTrueFoundryResetFromTurn = () => {
   const aui = useAui2();
   return (turnId) => trueFoundryExtras.get(aui).resetFromTurn(turnId);
@@ -4619,6 +4976,7 @@ export {
   useTrueFoundryApprovals,
   useTrueFoundryCancel,
   useTrueFoundryDownloadSandboxFile,
+  useTrueFoundryHistoryPagination,
   useTrueFoundryMcpAuth,
   useTrueFoundryReload,
   useTrueFoundryResetFromTurn,