@truefoundry/assistant-ui-runtime 0.1.0-rc.1 → 0.1.2

package/dist/index.js

@@ -276,7 +276,10 @@ function parseAskUserQuestionArgs(argsText) {
 
 // src/createSubAgent.ts
 function isCreateSubAgentToolCall(toolCall) {
-  return toolCall.toolInfo.type === "truefoundry-system" && toolCall.toolInfo.name === "create_sub_agent";
+  if (toolCall.toolInfo?.type === "truefoundry-system" && toolCall.toolInfo?.name === "create_sub_agent") {
+    return true;
+  }
+  return toolCall.function?.name === "create_sub_agent";
 }
 
 // src/modelMessageImageContent.ts
@@ -735,10 +738,13 @@ function attachSubAgentMessages(state, parentThreadId, parts) {
         });
       }
     }
-    if (messages.length === 0) {
+    if (messages.length === 0 && subAgents.length === 0) {
       return part;
     }
     const artifact = { subAgents };
+    if (messages.length === 0) {
+      return { ...part, artifact };
+    }
     return { ...part, messages, artifact };
   });
 }
@@ -1144,6 +1150,27 @@ function deriveSandboxId(messages) {
   return void 0;
 }
 
+// src/extractTurnUserText.ts
+function extractTurnUserText(input) {
+  const parts = [];
+  for (const item of input ?? []) {
+    if (item.type !== "user.message") {
+      continue;
+    }
+    const { content } = item;
+    if (typeof content === "string") {
+      parts.push(content);
+      continue;
+    }
+    for (const part of content) {
+      if (part.type === "text") {
+        parts.push(part.text);
+      }
+    }
+  }
+  return parts.join("\n").trim();
+}
+
 // src/mcpAuth.ts
 var MCP_AUTH_RESUME_RUN_CUSTOM_KEY = "resumeMcpAuth";
 function buildMcpAuthTextParts(servers) {
@@ -1230,27 +1257,6 @@ function appendMcpAuthToTurnContent(content, turn) {
   );
 }
 
-// src/extractTurnUserText.ts
-function extractTurnUserText(input) {
-  const parts = [];
-  for (const item of input ?? []) {
-    if (item.type !== "user.message") {
-      continue;
-    }
-    const { content } = item;
-    if (typeof content === "string") {
-      parts.push(content);
-      continue;
-    }
-    for (const part of content) {
-      if (part.type === "text") {
-        parts.push(part.text);
-      }
-    }
-  }
-  return parts.join("\n").trim();
-}
-
 // src/sessionSnapshot.ts
 function emptyRequiredActionsOverlay() {
   return {
@@ -1275,6 +1281,18 @@ function turnToSessionRecord(turn) {
     input: turn.input
   };
 }
+function sessionEventsToSessionRecord(turnId, createdEvent, doneEvent, rootModelMessageIds, sandboxId) {
+  const userText = extractTurnUserText(createdEvent.input);
+  return {
+    id: turnId,
+    ...userText ? { userText } : {},
+    createdAt: createdEvent.createdAt,
+    state: doneEvent.state,
+    input: createdEvent.input,
+    rootModelMessageIds,
+    ...sandboxId != null ? { sandboxId } : {}
+  };
+}
 function replaceSessionSnapshot(snapshot, patch) {
   return {
     ...snapshot,
@@ -1285,6 +1303,281 @@ 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":
@@ -1719,37 +2012,41 @@ function ingestTurnsIntoSnapshot(snapshot, turns, eventArrays) {
   return runningTurn;
 }
 async function buildSnapshotFromSession(session, concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY) {
-  const turns = [];
-  for await (const turn of await session.listTurns()) {
-    turns.push(turn);
+  const snapshot = await buildSnapshotFromSessionEvents(session);
+  if (snapshot.runningTurn == null) {
+    return snapshot;
   }
-  turns.reverse();
-  const eventArrays = await fetchAllTurnEventsWithConcurrency(turns, concurrency);
-  const snapshot = createEmptySessionSnapshot();
-  const runningTurn = ingestTurnsIntoSnapshot(snapshot, turns, eventArrays);
+  const turn = snapshot.runningTurn;
+  const eventArrays = await fetchAllTurnEventsWithConcurrency([turn], concurrency);
+  ingestTurnsIntoSnapshot(snapshot, [turn], eventArrays);
   return replaceSessionSnapshot(snapshot, {
-    ...runningTurn != null ? {
-      runningTurn,
-      unstable_resume: true,
-      groupRootBaseline: computeGroupRootBaseline(snapshot.turns)
-    } : {}
+    runningTurn: turn,
+    unstable_resume: true,
+    groupRootBaseline: computeGroupRootBaseline(snapshot.turns),
+    pendingUser: void 0
   });
 }
-async function buildSnapshotBeforeTurnIndex(session, turnIndex, concurrency = DEFAULT_LIST_EVENTS_CONCURRENCY, orderedTurns) {
+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();
   }
   const turns = orderedTurns ?? await listSessionTurnsOrdered(session);
   const turnsToInclude = turns.slice(0, turnIndex);
-  if (turnsToInclude.length === 0) {
+  const lastTurnId = turnsToInclude.at(-1)?.id;
+  if (lastTurnId == null) {
     return createEmptySessionSnapshot();
   }
-  const eventArrays = await fetchAllTurnEventsWithConcurrency(
-    turnsToInclude,
-    concurrency
-  );
+  const items = await fetchAllSessionEvents(session, { lastTurnId });
   const snapshot = createEmptySessionSnapshot();
-  ingestTurnsIntoSnapshot(snapshot, turnsToInclude, eventArrays);
+  ingestSessionEventsIntoSnapshot(snapshot, items);
   return snapshot;
 }
 async function resolveGatewayBranchPreviousTurnId(session, turnIndex, orderedTurns) {
@@ -1759,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()) {
@@ -2024,7 +2326,8 @@ function repositoryItemsFromMessages(messages) {
   return items;
 }
 
-// src/draftSessionBridge.ts
+// 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);
@@ -2036,12 +2339,16 @@ 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;
     }
   };
 }
 
-// src/agentSpec.ts
+// src/private/agentSpec.ts
 function mergeAgentSpec(base, update) {
   const { model: modelUpdate, ...rest } = update;
   const next = {
@@ -2069,7 +2376,7 @@ function sessionListStartTimestamp() {
   return start.toISOString();
 }
 
-// src/truefoundryDraftThreadListAdapter.ts
+// src/private/truefoundryDraftThreadListAdapter.ts
 var THREAD_LIST_PAGE_SIZE = 20;
 function createTrueFoundryDraftThreadListAdapter(options) {
   const { gateway, defaultAgentSpec, getAgentSpec } = options;
@@ -2137,7 +2444,7 @@ var EMPTY_DRAFT_EXTRAS = {
   }
 };
 
-// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/core/fetcher/HttpResponsePromise.mjs
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.3.1/node_modules/truefoundry-gateway-sdk/dist/esm/core/fetcher/HttpResponsePromise.mjs
 var __awaiter = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
@@ -2252,7 +2559,7 @@ var HttpResponsePromise = class _HttpResponsePromise extends Promise {
   }
 };
 
-// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/core/pagination/Page.mjs
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.3.1/node_modules/truefoundry-gateway-sdk/dist/esm/core/pagination/Page.mjs
 var __awaiter2 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
@@ -2407,7 +2714,7 @@ var Page = class {
   }
 };
 
-// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/agents/TurnStreamData.mjs
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.3.1/node_modules/truefoundry-gateway-sdk/dist/esm/agents/TurnStreamData.mjs
 function parseSequenceNumber(id) {
   if (!id) {
     throw new Error("Missing SSE sequence number id.");
@@ -2419,7 +2726,7 @@ function parseSequenceNumber(id) {
   return parsed;
 }
 
-// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/agents/Turn.mjs
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.3.1/node_modules/truefoundry-gateway-sdk/dist/esm/agents/Turn.mjs
 var __awaiter3 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
@@ -2657,7 +2964,7 @@ _Turn_client = /* @__PURE__ */ new WeakMap(), _Turn_state = /* @__PURE__ */ new
     __classPrivateFieldSet(this, _Turn_state, event.state, "f");
 };
 
-// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/agents/PreparedTurn.mjs
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.3.1/node_modules/truefoundry-gateway-sdk/dist/esm/agents/PreparedTurn.mjs
 var __awaiter4 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
@@ -3012,7 +3319,7 @@ var PreparedTurn = class {
 };
 _PreparedTurn_client = /* @__PURE__ */ new WeakMap(), _PreparedTurn_input = /* @__PURE__ */ new WeakMap(), _PreparedTurn_previousTurnIdInput = /* @__PURE__ */ new WeakMap(), _PreparedTurn_start = /* @__PURE__ */ new WeakMap(), _PreparedTurn_turn = /* @__PURE__ */ new WeakMap();
 
-// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.2.0/node_modules/truefoundry-gateway-sdk/dist/esm/agents/AgentSession.mjs
+// ../../node_modules/.pnpm/truefoundry-gateway-sdk@0.3.1/node_modules/truefoundry-gateway-sdk/dist/esm/agents/AgentSession.mjs
 var __awaiter5 = function(thisArg, _arguments, P, generator) {
   function adopt(value) {
     return value instanceof P ? value : new P(function(resolve) {
@@ -3122,10 +3429,22 @@ var AgentSession = class {
       yield __classPrivateFieldGet3(this, _AgentSession_client, "f").agents.sessions.cancel(this.id, {}, requestOptions);
     });
   }
+  /**
+   * Paginated session events across turns (newest first); subscribe to a running turn for live events.
+   *
+   * @param opts.pageToken - Token from the previous response nextPageToken.
+   * @param opts.lastTurnId - Newest turn in the listing window (initial load only). Omit to use the session last turn.
+   * @param opts.limit - Page size. Default 100.
+   * @param requestOptions - Overrides client timeout, retries, abortSignal, headers, queryParams.
+   * @returns {Promise<core.Page<TrueFoundryGatewayApi.SessionEventItem, TrueFoundryGatewayApi.ListSessionEventsResponse>>} Paginated session events.
+   */
+  listEvents(opts, requestOptions) {
+    return __classPrivateFieldGet3(this, _AgentSession_client, "f").agents.sessions.listEvents(this.id, opts, requestOptions);
+  }
 };
 _AgentSession_client = /* @__PURE__ */ new WeakMap();
 
-// src/bindDraftAgentSession.ts
+// src/private/bindDraftAgentSession.ts
 var inflightByDraftId = /* @__PURE__ */ new Map();
 function getGatewayFromSessionClient(client) {
   const internal = client;
@@ -3260,7 +3579,7 @@ function resolveTrueFoundryAgentRuntimeOptions(options) {
   };
 }
 
-// src/useDraftAgentSpec.ts
+// src/private/useDraftAgentSpec.ts
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 var SPEC_SYNC_DEBOUNCE_MS = 400;
 function useDraftAgentSpec({
@@ -3280,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;
@@ -3328,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) {
@@ -3353,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) {
@@ -3389,7 +3765,8 @@ function useDraftAgentSpec({
       draftSessionId: enabled ? draftSessionId : void 0,
       isSpecSyncing: enabled ? isSpecSyncing : false,
       specError: enabled ? specError : null,
-      updateAgentSpec
+      updateAgentSpec,
+      takeTurnHeaderTimestamp
     }),
     [
       agentSpec,
@@ -3397,6 +3774,7 @@ function useDraftAgentSpec({
       enabled,
       isSpecSyncing,
       specError,
+      takeTurnHeaderTimestamp,
       updateAgentSpec
     ]
   );
@@ -3408,11 +3786,13 @@ import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMem
 
 // src/loadSessionSnapshot.ts
 var inflightBySessionId2 = /* @__PURE__ */ new Map();
-function loadSessionSnapshot(client, sessionId, concurrency, sessionOptions) {
+function loadSessionSnapshot(client, sessionId, sessionOptions, onProgress) {
   const cacheKey = sessionOptions?.draftGateway != null ? `draft:${sessionId}` : sessionId;
   let inflight = inflightBySessionId2.get(cacheKey);
   if (inflight == null) {
-    inflight = getSession(client, sessionId, sessionOptions).then((session) => buildSnapshotFromSession(session, concurrency)).finally(() => {
+    inflight = getSession(client, sessionId, sessionOptions).then(
+      (session) => buildSnapshotFromSessionEvents(session, onProgress)
+    ).finally(() => {
       if (inflightBySessionId2.get(cacheKey) === inflight) {
         inflightBySessionId2.delete(cacheKey);
       }
@@ -3479,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
     );
@@ -3631,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) {
@@ -3654,11 +4030,13 @@ function resolveTurnInput(snapshot, turnId) {
 function useTrueFoundryAgentMessages({
   client,
   sessionId,
+  isMain,
   listEventsConcurrency,
   onError,
   initializeSession,
   resolveConversationSessionId,
-  draftGateway
+  draftGateway,
+  getTurnHeaders
 }) {
   const sessionOptions = useMemo2(
     () => draftGateway != null ? { draftGateway } : void 0,
@@ -3667,13 +4045,25 @@ 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);
   const runningTurnRef = useRef2(void 0);
   const loadGenerationRef = useRef2(0);
+  const streamGenerationRef = useRef2(0);
   const lazilyCreatedSessionIdRef = useRef2(void 0);
   const projectOptions = useMemo2(
     () => ({
@@ -3693,41 +4083,62 @@ function useTrueFoundryAgentMessages({
     () => projectSessionMessages(snapshot, projectOptions),
     [snapshot, projectOptions]
   );
-  const applyStreamUpdate = useCallback2(
-    (update, turnId, isContinuation) => {
-      setSnapshot(
-        (prev) => replaceSessionSnapshot(prev, {
-          activeStream: {
-            turnId,
-            update,
-            isContinuation
-          }
-        })
-      );
-    },
-    []
-  );
   const runStream = useCallback2(
     (createStream, turnId, isContinuation) => {
+      const streamGeneration = ++streamGenerationRef.current;
       abortControllerRef.current?.abort();
       const abortController = new AbortController();
       abortControllerRef.current = abortController;
       setIsRunning(true);
       const run = (async () => {
+        let pendingStreamUpdate = null;
+        let streamUpdateRaf = null;
+        const flushPendingStreamUpdate = () => {
+          streamUpdateRaf = null;
+          const pending = pendingStreamUpdate;
+          pendingStreamUpdate = null;
+          if (pending == null || streamGeneration !== streamGenerationRef.current) {
+            return;
+          }
+          const { update, turnId: pendingTurnId, isContinuation: pendingIsContinuation } = pending;
+          setSnapshot(
+            (prev) => replaceSessionSnapshot(prev, {
+              activeStream: {
+                turnId: pendingTurnId,
+                update,
+                isContinuation: pendingIsContinuation
+              }
+            })
+          );
+        };
+        const applyStreamUpdate = (update) => {
+          pendingStreamUpdate = { update, turnId, isContinuation };
+          if (streamUpdateRaf == null) {
+            streamUpdateRaf = requestAnimationFrame(flushPendingStreamUpdate);
+          }
+        };
         try {
           for await (const update of createStream(abortController.signal)) {
             if (abortController.signal.aborted) {
               return;
             }
-            applyStreamUpdate(update, turnId, isContinuation);
+            applyStreamUpdate(update);
           }
         } catch (error) {
           if (error instanceof Error && error.name === "AbortError") {
             return;
           }
-          onError?.(error);
+          onErrorRef.current?.(error);
           throw error;
         } finally {
+          if (streamUpdateRaf != null) {
+            cancelAnimationFrame(streamUpdateRaf);
+            streamUpdateRaf = null;
+          }
+          if (streamGeneration !== streamGenerationRef.current) {
+            return;
+          }
+          flushPendingStreamUpdate();
           if (abortControllerRef.current === abortController) {
             abortControllerRef.current = null;
           }
@@ -3758,7 +4169,7 @@ function useTrueFoundryAgentMessages({
       });
       return run;
     },
-    [applyStreamUpdate, onError]
+    [onError]
   );
   const load = useCallback2(async () => {
     if (sessionId == null) {
@@ -3766,22 +4177,35 @@ function useTrueFoundryAgentMessages({
       setSnapshot(createEmptySessionSnapshot());
       return;
     }
+    if (isMain === false) return;
+    if (lazilyCreatedSessionIdRef.current != null && sessionId !== lazilyCreatedSessionIdRef.current) {
+      lazilyCreatedSessionIdRef.current = void 0;
+    }
     if (sessionId === lazilyCreatedSessionIdRef.current) {
       return;
     }
     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,
-        resolveConversationSessionId
+        resolveConversationSessionIdRef.current
       );
       const loadedSnapshot = await loadSessionSnapshot(
         client,
         conversationSessionId,
-        listEventsConcurrency,
-        sessionOptions
+        sessionOptions,
+        (snap) => {
+          if (generation === loadGenerationRef.current) {
+            setSnapshot(snap);
+          }
+        }
       );
       if (generation !== loadGenerationRef.current) {
         return;
@@ -3789,30 +4213,33 @@ function useTrueFoundryAgentMessages({
       createdAtByMessageIdRef.current = /* @__PURE__ */ new Map();
       setSnapshot(loadedSnapshot);
       runningTurnRef.current = loadedSnapshot.runningTurn;
+      setIsLoading(false);
       if (loadedSnapshot.runningTurn != null) {
         const turn = loadedSnapshot.runningTurn;
         const isContinuation = !extractTurnUserText(turn.input);
-        await runStream(
+        void runStream(
           (signal) => resumeTurnStream(
             turn,
-            snapshotRef.current.fold,
+            loadedSnapshot.fold,
             signal,
             void 0,
-            snapshotRef.current.groupRootBaseline
+            loadedSnapshot.groupRootBaseline
           ),
           turn.id,
           isContinuation
-        );
+        ).catch(() => void 0);
       }
     } catch (error) {
-      onError?.(error);
+      if (generation === loadGenerationRef.current) {
+        onErrorRef.current?.(error);
+      }
       throw error;
     } finally {
       if (generation === loadGenerationRef.current) {
         setIsLoading(false);
       }
     }
-  }, [client, listEventsConcurrency, onError, resolveConversationSessionId, runStream, sessionId, sessionOptions]);
+  }, [client, runStream, sessionId, sessionOptions, loadRetryTrigger, isMain]);
   useEffect2(() => {
     void load().catch(() => void 0);
   }, [load]);
@@ -3820,18 +4247,20 @@ function useTrueFoundryAgentMessages({
     async (options) => {
       let activeSessionId = sessionId;
       if (activeSessionId == null) {
-        if (initializeSession == null) {
+        if (initializeSessionRef.current == null) {
           throw new Error("Cannot send a turn without an active session.");
         }
-        const { remoteId } = await initializeSession();
+        const { remoteId } = await initializeSessionRef.current();
         activeSessionId = remoteId;
         lazilyCreatedSessionIdRef.current = remoteId;
       }
       const conversationSessionId = await resolveActiveSessionId(
         activeSessionId,
-        resolveConversationSessionId
+        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();
@@ -3841,29 +4270,48 @@ function useTrueFoundryAgentMessages({
           options.inputs
         );
       }
-      setSnapshot(
-        (prev) => commitActiveStream(
-          prev,
-          "inputs" in options ? options.inputs : void 0
-        )
-      );
+      const branchBase = "userMessage" in options ? options.branchFromSnapshot : void 0;
       let groupRootBaseline;
-      if ("userMessage" in options) {
-        const rootBucket = snapshotRef.current.fold.threads.get(ROOT_THREAD_ID);
+      if (branchBase != null && "userMessage" in options) {
+        const rootBucket = branchBase.fold.threads.get(ROOT_THREAD_ID);
         groupRootBaseline = [...rootBucket?.modelMessageIds ?? []];
+        const nextSnapshot = replaceSessionSnapshot(branchBase, {
+          pendingUser: {
+            turnId,
+            content: options.userMessage,
+            createdAt: /* @__PURE__ */ new Date()
+          },
+          activeStream: void 0,
+          groupRootBaseline
+        });
+        snapshotRef.current = nextSnapshot;
+        setSnapshot(nextSnapshot);
+      } else {
         setSnapshot(
-          (prev) => replaceSessionSnapshot(prev, {
-            pendingUser: {
-              turnId,
-              content: options.userMessage,
-              createdAt: /* @__PURE__ */ new Date()
-            },
-            activeStream: void 0,
-            groupRootBaseline
-          })
+          (prev) => commitActiveStream(
+            prev,
+            "inputs" in options ? options.inputs : void 0
+          )
         );
-      } else {
-        groupRootBaseline = snapshotRef.current.groupRootBaseline ?? computeGroupRootBaseline(snapshotRef.current.turns);
+        if ("userMessage" in options) {
+          const rootBucket = snapshotRef.current.fold.threads.get(ROOT_THREAD_ID);
+          groupRootBaseline = [...rootBucket?.modelMessageIds ?? []];
+          setSnapshot((prev) => {
+            const next = replaceSessionSnapshot(prev, {
+              pendingUser: {
+                turnId,
+                content: options.userMessage,
+                createdAt: /* @__PURE__ */ new Date()
+              },
+              activeStream: void 0,
+              groupRootBaseline
+            });
+            snapshotRef.current = next;
+            return next;
+          });
+        } else {
+          groupRootBaseline = snapshotRef.current.groupRootBaseline ?? computeGroupRootBaseline(snapshotRef.current.turns);
+        }
       }
       await runStream(
         (signal) => {
@@ -3871,7 +4319,7 @@ function useTrueFoundryAgentMessages({
             return streamTurnContent(
               session,
               snapshotRef.current.fold,
-              { inputs: options.inputs },
+              { inputs: options.inputs, ...streamHeaders },
               signal,
               groupRootBaseline
             );
@@ -3880,7 +4328,7 @@ function useTrueFoundryAgentMessages({
             return streamTurnContent(
               session,
               snapshotRef.current.fold,
-              { resumeMcpAuth: true },
+              { resumeMcpAuth: true, ...streamHeaders },
               signal,
               groupRootBaseline
             );
@@ -3890,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
@@ -3900,7 +4349,7 @@ function useTrueFoundryAgentMessages({
         isContinuation
       );
     },
-    [client, initializeSession, resolveConversationSessionId, runStream, sessionId, sessionOptions]
+    [client, runStream, sessionId, sessionOptions]
   );
   const cancel = useCallback2(async () => {
     if (sessionId == null) {
@@ -3909,12 +4358,12 @@ function useTrueFoundryAgentMessages({
     }
     const conversationSessionId = await resolveActiveSessionId(
       sessionId,
-      resolveConversationSessionId
+      resolveConversationSessionIdRef.current
     );
     const session = await getSession(client, conversationSessionId, sessionOptions);
     await session.cancel().catch(() => void 0);
     await activeRunRef.current?.catch(() => void 0);
-  }, [client, resolveConversationSessionId, sessionId, sessionOptions]);
+  }, [client, sessionId, sessionOptions]);
   const isRunningRef = useRef2(isRunning);
   isRunningRef.current = isRunning;
   const trySendCollectedRequiredActions = useCallback2(
@@ -3929,10 +4378,10 @@ function useTrueFoundryAgentMessages({
       }
       const inputs = collectRequiredActionInputs(paused);
       if (inputs.length > 0) {
-        void sendTurn({ inputs }).catch((error) => onError?.(error));
+        void sendTurn({ inputs }).catch((error) => onErrorRef.current?.(error));
       }
     },
-    [onError, projectOptions, sendTurn]
+    [projectOptions, sendTurn]
   );
   const respondToToolApproval = useCallback2(
     (response) => {
@@ -3994,34 +4443,34 @@ function useTrueFoundryAgentMessages({
       }
       const committed = commitActiveStream(snapshotRef.current);
       setSnapshot(committed);
-      const turnIndex = findTurnIndex(committed, turnId);
       await cancel();
       const conversationSessionId = await resolveActiveSessionId(
         activeSessionId,
-        resolveConversationSessionId
+        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();
+      snapshotRef.current = rewound;
       setSnapshot(rewound);
       await sendTurn({
         userMessage,
-        previousTurnId
+        previousTurnId,
+        branchFromSnapshot: rewound
       });
     },
     [
       cancel,
       client,
       listEventsConcurrency,
-      resolveConversationSessionId,
       sendTurn,
       sessionId,
       sessionOptions
@@ -4054,11 +4503,68 @@ function useTrueFoundryAgentMessages({
     },
     [branchFromTurn]
   );
+  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,
-    load,
+    isLoadingOlderHistory,
+    hasOlderHistory,
+    loadOlderHistory,
+    retryLoad,
     sendTurn,
     cancel,
     respondToToolApproval,
@@ -4088,6 +4594,9 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
     (state) => agent.mode === "draft" ? state.threadListItem.remoteId ?? void 0 : void 0
   );
   const sessionId = useAuiState((state) => state.threadListItem.remoteId ?? void 0);
+  const isMain = useAuiState(
+    (state) => state.threads.mainThreadId === state.threadListItem.id
+  );
   const draftSpec = useDraftAgentSpec({
     draftSessionId,
     draftBridge: draftBridgeRef.current,
@@ -4095,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(),
@@ -4106,20 +4627,26 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
     messages,
     isRunning,
     isLoading,
+    isLoadingOlderHistory,
+    hasOlderHistory,
+    loadOlderHistory,
     sendTurn,
     cancel,
     respondToToolApproval,
     respondToToolResponse,
     resumeRun,
     editFromTurn,
-    resetFromTurn
+    resetFromTurn,
+    retryLoad
   } = useTrueFoundryAgentMessages({
     client,
     sessionId,
+    isMain,
     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;
@@ -4187,6 +4714,10 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
       resetFromTurn: (turnId) => resetFromTurn(turnId).catch((error) => {
         onError?.(error);
       }),
+      reload: retryLoad,
+      hasOlderHistory,
+      isLoadingOlderHistory,
+      loadOlderHistory,
       draft: draftExtras
     }),
     unstable_enableToolInvocations: true,
@@ -4235,32 +4766,32 @@ function useTrueFoundryAgentRuntimeImpl(options, pendingAgentSpecRef) {
   });
 }
 function useTrueFoundryAgentRuntime(options) {
-  const resolved = useMemo3(
-    () => resolveTrueFoundryAgentRuntimeOptions(options),
-    [options]
-  );
+  const resolved = resolveTrueFoundryAgentRuntimeOptions(options);
   const { client, agent, gateway } = resolved;
   const pendingAgentSpecRef = useRef3(
     agent.mode === "draft" ? agent.defaultAgentSpec : void 0
   );
+  const agentMode = agent.mode;
+  const namedAgentName = agent.mode === "named" ? agent.agentName : void 0;
   const threadListAdapter = useMemo3(() => {
-    if (agent.mode === "draft") {
+    if (agentMode === "draft") {
       if (gateway == null) {
         throw new Error(
           "Draft agent mode requires a `gateway` TrueFoundryGateway client."
         );
       }
+      const draftAgent = agent;
       return createTrueFoundryDraftThreadListAdapter({
         gateway,
-        defaultAgentSpec: agent.defaultAgentSpec,
-        getAgentSpec: () => pendingAgentSpecRef.current ?? agent.defaultAgentSpec
+        defaultAgentSpec: draftAgent.defaultAgentSpec,
+        getAgentSpec: () => pendingAgentSpecRef.current ?? draftAgent.defaultAgentSpec
       });
     }
     return createTrueFoundryThreadListAdapter({
       client,
-      agentName: agent.agentName
+      agentName: namedAgentName
     });
-  }, [agent, client, gateway]);
+  }, [agentMode, namedAgentName, client, gateway]);
   return useRemoteThreadListRuntime({
     allowNesting: true,
     adapter: threadListAdapter,
@@ -4331,6 +4862,23 @@ var useTrueFoundryCancel = () => {
   const aui = useAui2();
   return () => trueFoundryExtras.get(aui).cancel();
 };
+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);
@@ -4428,7 +4976,9 @@ export {
   useTrueFoundryApprovals,
   useTrueFoundryCancel,
   useTrueFoundryDownloadSandboxFile,
+  useTrueFoundryHistoryPagination,
   useTrueFoundryMcpAuth,
+  useTrueFoundryReload,
   useTrueFoundryResetFromTurn,
   useTrueFoundryRespondToToolApproval,
   useTrueFoundryRespondToToolResponse,