@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-DF5EAHDN.js

@@ -0,0 +1,4461 @@
+"use client";
+import {
+  useSessionStartupState
+} from "./chunk-EMIVOS73.js";
+import {
+  deniesRetainedView,
+  useRetainedSessionView
+} from "./chunk-YUNVW3I2.js";
+import {
+  admissionRecheckControl
+} from "./chunk-JWKGPA6Q.js";
+import {
+  projectPendingApprovals
+} from "./chunk-VXORMNU4.js";
+import {
+  buildTimeline,
+  groupTimeline,
+  isToolOutputPreviewEvent,
+  sessionStatusFromEvents,
+  useToolOutputReads
+} from "./chunk-4YCA2Y73.js";
+import {
+  useFileAttachments
+} from "./chunk-I6FIXEL4.js";
+import {
+  forgetSessionHumanInputDrafts,
+  pruneHumanInputDrafts
+} from "./chunk-X62OJCQW.js";
+import {
+  useSharedQuery
+} from "./chunk-IWUGGOXA.js";
+import {
+  isActionableHumanInputRequest
+} from "./chunk-57MB2QGY.js";
+import {
+  readAcknowledgementFrontier,
+  sessionAttentionReadThroughSequence
+} from "./chunk-C5ZCSVZ7.js";
+import {
+  promptSendDestination,
+  sessionTurnKeepsRunControl
+} from "./chunk-TSENLSW6.js";
+import {
+  useClientConfigFlags
+} from "./chunk-XESA3B7W.js";
+import {
+  joinClientConfigRead
+} from "./chunk-IGVL3ELX.js";
+import {
+  FILE_ONLY_MESSAGE_TEXT,
+  notifyObserver,
+  useComposer
+} from "./chunk-MIHN76LX.js";
+import {
+  DEFAULT_TRANSIENT_READ_RETRY,
+  projectionReadThrough,
+  transientReadRetryStep,
+  useDebouncedCallback,
+  useMutationRunner,
+  usePageLiveActivity,
+  usePolledValue,
+  useSessionEventTrigger
+} from "./chunk-RV3O5OCQ.js";
+import {
+  normalizeError
+} from "./chunk-CM7LVUKC.js";
+import {
+  useEmbeddedGoal,
+  useEmbeddedHumanInputSession,
+  useEmbeddedSession,
+  useEmbeddedSessionRead,
+  useOpenGeni,
+  useOpenGeniClient
+} from "./chunk-TVQCDDSZ.js";
+import {
+  coerceReasoningEffortForModel,
+  defaultEffortForModel,
+  projectPickerRows,
+  runnableLatencyModesForModel,
+  sortPickerRows
+} from "./chunk-ZHC47M2B.js";
+import {
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/hooks/use-session.ts
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+// src/lib/session-detail-read.ts
+var lastOrdinal = 0;
+var reads = /* @__PURE__ */ new WeakMap();
+function readKey(workspaceId, sessionId) {
+  return `${workspaceId}\0${sessionId}`;
+}
+function sessionDetailReadMark() {
+  return lastOrdinal;
+}
+function readFreshSessionDetail(client, workspaceId, sessionId, options = {}) {
+  const promise = client.getSession(workspaceId, sessionId, { ...options, fresh: true });
+  const read = { promise, ordinal: ++lastOrdinal };
+  let scoped = reads.get(client);
+  if (!scoped) {
+    scoped = /* @__PURE__ */ new Map();
+    reads.set(client, scoped);
+  }
+  const key = readKey(workspaceId, sessionId);
+  scoped.set(key, read);
+  promise.catch(() => {
+    if (scoped.get(key) === read) scoped.delete(key);
+  });
+  return promise;
+}
+function joinSessionDetailRead(client, workspaceId, sessionId, mark) {
+  const read = reads.get(client)?.get(readKey(workspaceId, sessionId));
+  return read && read.ordinal > mark ? read.promise : null;
+}
+
+// src/hooks/use-session.ts
+function isTitleEvent(event) {
+  return event.type === "session.title_set";
+}
+function isSessionDetailEvent(event) {
+  return isTitleEvent(event) || // Description or avatar edits (by a person or the agent) refresh the header.
+  event.type === "session.profile_set" || // The chat's model, effort or speed changed (for example by the agent).
+  event.type === "session.model_settings.updated" || event.type.startsWith("session.command.") || event.type.startsWith("session.wait.") || event.type === "session.status.changed" || event.type === "system.update.pending";
+}
+function useSession(sessionId, options = {}) {
+  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSessionRead(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const [override, setOverride] = useState(null);
+  const nextReadRevision = useRef(0);
+  const nextReadGeneration = useRef(0);
+  const beginRead = options.beginRead;
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
+  const load = useCallback(
+    async (signal) => {
+      if (!sessionId) {
+        return null;
+      }
+      let readGeneration2 = 0;
+      const fetched = await readFreshSessionDetail(client, workspaceId, sessionId, {
+        signal,
+        onRequestStart: () => {
+          readGeneration2 = beginRead?.() ?? ++nextReadGeneration.current;
+        }
+      });
+      setOverride(null);
+      return {
+        session: fetched,
+        revision: ++nextReadRevision.current,
+        readGeneration: readGeneration2
+      };
+    },
+    [beginRead, client, workspaceId, sessionId]
+  );
+  const { data, loading, error, refresh } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled
+  });
+  useEffect(() => {
+    if (enabled && workspaceControlEvent) void refresh();
+  }, [enabled, refresh, workspaceControlEvent]);
+  useEffect(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "session", refresh);
+  }, [enabled, refresh, registerSessionReconciler, sessionId]);
+  const retained = useRetainedSessionView(
+    client,
+    workspaceId,
+    sessionId,
+    "detail",
+    data?.session ?? null,
+    { enabled, discard: deniesRetainedView(error) }
+  );
+  const base = data?.session ?? null;
+  const readRevision = data?.revision ?? 0;
+  const readGeneration = data?.readGeneration ?? 0;
+  const session = useMemo(
+    () => base && override && override.id === base.id ? { ...base, title: override.title, titleSource: override.titleSource } : base ?? retained,
+    [base, override, retained]
+  );
+  const sharedEvents = options.events;
+  const refreshDetail = useCallback(() => void refresh(), [refresh]);
+  const onTitleEvent = useCallback(
+    (event) => {
+      if (sharedEvents?.some(
+        (item) => item.sessionId === sessionId && !isTitleEvent(item) && isSessionDetailEvent(item) && item.sequence > (base?.lastSequence ?? -1)
+      )) {
+        void refresh();
+      } else if (!isTitleEvent(event)) {
+        if (!base || event.sequence > base.lastSequence) void refresh();
+        return;
+      }
+      if (!base || event.sequence <= base.lastSequence) {
+        return;
+      }
+      const payload = event.payload ?? {};
+      const title = payload.title;
+      if (typeof title !== "string") {
+        return;
+      }
+      const source = payload.source === "user" || payload.source === "agent" ? payload.source : null;
+      setOverride((current) => {
+        const next = current ?? base;
+        return { ...next, title, titleSource: source };
+      });
+    },
+    [base, refresh, sharedEvents, sessionId]
+  );
+  useSessionEventTrigger(client, workspaceId, sessionId, isSessionDetailEvent, onTitleEvent, {
+    enabled,
+    ...options.events !== void 0 ? { events: options.events } : {},
+    // The detail row is authoritative through its lastSequence: only a later
+    // event can make it stale, and one that arrives first waits for the read.
+    readThrough: base ? base.lastSequence : loading ? "reading" : null,
+    refresh: refreshDetail
+  });
+  const updateTitle = useCallback(
+    async (title) => {
+      if (!sessionId) {
+        return null;
+      }
+      const result = await run(() => client.updateSession(workspaceId, sessionId, { title }));
+      if (result) {
+        setOverride(result);
+      }
+      return result;
+    },
+    [client, workspaceId, sessionId, run]
+  );
+  return {
+    session,
+    loading: loading && retained === null,
+    error,
+    readRevision,
+    readGeneration,
+    refresh,
+    updateTitle,
+    updating: mutating,
+    mutationError,
+    clearMutationError
+  };
+}
+
+// src/older-history.ts
+var activeReceiptCapture;
+var preserveTailForAutomaticLoad = false;
+function invokeOlderHistoryLoaderWithReceiptCapture(load, capture, preserveTail = false) {
+  const previousCapture = activeReceiptCapture;
+  const previousPreserveTail = preserveTailForAutomaticLoad;
+  activeReceiptCapture = capture;
+  preserveTailForAutomaticLoad = preserveTail;
+  try {
+    return load();
+  } finally {
+    activeReceiptCapture = previousCapture;
+    preserveTailForAutomaticLoad = previousPreserveTail;
+  }
+}
+function createOlderHistoryLoadReceipt(load) {
+  let resolveResult;
+  let rejectResult;
+  const result = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  result.committed = false;
+  result.tailPreserved = false;
+  activeReceiptCapture?.(result);
+  try {
+    const loaded = load(
+      () => {
+        result.committed = true;
+      },
+      preserveTailForAutomaticLoad,
+      () => {
+        result.tailPreserved = true;
+      }
+    );
+    Promise.resolve(loaded).then(resolveResult, rejectResult);
+  } catch (error) {
+    rejectResult(error);
+  }
+  return result;
+}
+
+// src/hooks/use-session-events.ts
+import {
+  isPresentedSessionToolCall,
+  isRetryableStreamError,
+  isSessionModelResponsePhase,
+  isTransientRequestError,
+  SESSION_EVENT_COMPAT_EXCLUDED_STEP_TYPES,
+  SESSION_EVENT_CONTENT_STEP_TYPES,
+  SESSION_EVENT_CONVERSATION_FILTER_VERSION,
+  SESSION_EVENT_STEP_TYPES,
+  sessionEventStreamCoveredThrough
+} from "@opengeni/sdk";
+import { startTransition, useCallback as useCallback3, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/hooks/page-wake.ts
+var PAGE_WAKE_CHECK_INTERVAL_MS = 2e3;
+var PAGE_WAKE_GAP_MS = 15e3;
+var listeners = /* @__PURE__ */ new Set();
+var stopDetector = null;
+function subscribePageWake(listener) {
+  listeners.add(listener);
+  stopDetector ??= startDetector();
+  return () => {
+    listeners.delete(listener);
+    if (listeners.size === 0 && stopDetector) {
+      stopDetector();
+      stopDetector = null;
+    }
+  };
+}
+function emitPageWake() {
+  for (const listener of [...listeners]) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+}
+function startDetector() {
+  if (typeof window === "undefined" || typeof document === "undefined") return () => {
+  };
+  let lastTick = Date.now();
+  const check = () => {
+    const now = Date.now();
+    const elapsed = now - lastTick;
+    lastTick = now;
+    if (elapsed > PAGE_WAKE_GAP_MS) emitPageWake();
+  };
+  const onVisibility = () => {
+    if (document.visibilityState !== "hidden") check();
+  };
+  const onPageShow = (event) => {
+    lastTick = Date.now();
+    if (event.persisted) emitPageWake();
+  };
+  const onResume = () => {
+    lastTick = Date.now();
+    emitPageWake();
+  };
+  const timer = setInterval(check, PAGE_WAKE_CHECK_INTERVAL_MS);
+  document.addEventListener("visibilitychange", onVisibility);
+  document.addEventListener("resume", onResume);
+  window.addEventListener("pageshow", onPageShow);
+  window.addEventListener("online", onResume);
+  return () => {
+    clearInterval(timer);
+    document.removeEventListener("visibilitychange", onVisibility);
+    document.removeEventListener("resume", onResume);
+    window.removeEventListener("pageshow", onPageShow);
+    window.removeEventListener("online", onResume);
+  };
+}
+
+// src/hooks/turnless-output-gaps.ts
+import { useCallback as useCallback2, useSyncExternalStore } from "react";
+var MAX_IDLE_ENTRIES = 256;
+var entries = /* @__PURE__ */ new Map();
+function gapKey(workspaceId, sessionId) {
+  return `${workspaceId}\0${sessionId}`;
+}
+function gapEntry(key) {
+  let entry = entries.get(key);
+  if (!entry) {
+    entry = { generation: 0, listeners: /* @__PURE__ */ new Set() };
+    entries.set(key, entry);
+    if (entries.size > MAX_IDLE_ENTRIES) {
+      for (const [candidate, held] of entries) {
+        if (entries.size <= MAX_IDLE_ENTRIES) break;
+        if (candidate !== key && held.listeners.size === 0) entries.delete(candidate);
+      }
+    }
+  }
+  return entry;
+}
+function markTurnlessOutputGap(workspaceId, sessionId) {
+  const entry = gapEntry(gapKey(workspaceId, sessionId));
+  entry.generation += 1;
+  for (const listener of [...entry.listeners]) listener();
+}
+function useTurnlessOutputGap(workspaceId, sessionId) {
+  const key = sessionId ? gapKey(workspaceId, sessionId) : null;
+  const subscribe = useCallback2(
+    (listener) => {
+      if (!key) return () => {
+      };
+      const entry = gapEntry(key);
+      entry.listeners.add(listener);
+      return () => {
+        entry.listeners.delete(listener);
+      };
+    },
+    [key]
+  );
+  const read = useCallback2(() => key ? entries.get(key)?.generation ?? 0 : 0, [key]);
+  return useSyncExternalStore(subscribe, read, read);
+}
+
+// src/hooks/use-session-events.ts
+import { errorMessage } from "@opengeni/contracts/values";
+var SESSION_FIRST_WINDOW_PAGE_SIZE = 255;
+var SESSION_HISTORY_PAGE_SIZE = 1e3;
+var INITIAL_FETCH_CAP = 1;
+var OLDER_GROUP_TARGET = 32;
+var OLDER_FETCH_CAP = 2;
+var NEWER_GROUP_TARGET = 32;
+var NEWER_FETCH_CAP = 2;
+var OLDEST_GROUP_TARGET = 32;
+var OLDEST_FETCH_CAP = 2;
+var BOUNDARY_PAGE_CAP = 1;
+var FILTERED_PAGE_CAP = 32;
+var DIRECT_REPLAY_MAX_SEQUENCES = 16;
+var CATCHUP_MAX_PAGES = 2;
+var STRICT_REJOIN_ATTEMPTS = 5;
+var REJOIN_STALL_TIMEOUT_MS = 3e4;
+var FOREGROUND_REJOIN_RETRY_MS = 500;
+var FOREGROUND_REJOIN_RETRY_MAX_MS = 8e3;
+var EMPTY_EVENTS = [];
+var encoder = new TextEncoder();
+var SESSION_EVENT_BROWSER_MAX_BYTES = 16 * 1024 * 1024;
+var SESSION_EVENT_BROWSER_MAX_COUNT = 2e4;
+var SESSION_EVENT_BROWSER_PENDING_MAX_BYTES = 1024 * 1024;
+var SESSION_EVENT_BROWSER_PENDING_MAX_COUNT = 256;
+var EMPTY_EVENT_WINDOW = {
+  events: EMPTY_EVENTS,
+  bytes: 2,
+  truncated: false
+};
+function useSessionEvents(sessionId, options = {}) {
+  const t = useOpenGeniText();
+  const { client, workspaceId, reconcileSession } = useEmbeddedSession(options);
+  const enabled = options.enabled ?? true;
+  const pageLive = usePageLiveActivity();
+  const streamEnabled = enabled && pageLive;
+  const after = options.after ?? 0;
+  const replay = options.replay ?? "windowed";
+  const fullReplay = replay === "full" || after !== 0;
+  const streamKey = `${workspaceId}\0${sessionId ?? ""}\0${after}\0${fullReplay ? "full" : "windowed"}`;
+  const navigationIdentityRef = useRef2({ client, streamKey, enabled });
+  if (navigationIdentityRef.current.client !== client || navigationIdentityRef.current.streamKey !== streamKey || navigationIdentityRef.current.enabled !== enabled) {
+    navigationIdentityRef.current = { client, streamKey, enabled };
+  }
+  const navigationIdentity = navigationIdentityRef.current;
+  const ownsNavigation = useCallback3(
+    () => navigationIdentityRef.current === navigationIdentity,
+    [navigationIdentity]
+  );
+  const [eventWindow, setEventWindow] = useState2(EMPTY_EVENT_WINDOW);
+  const [questionEvidence, setQuestionEvidence] = useState2(null);
+  const [connectionState, setConnectionState] = useState2("idle");
+  const [error, setError] = useState2(null);
+  const [newerError, setNewerError] = useState2(null);
+  const [hasOlder, setHasOlder] = useState2(false);
+  const [hasNewer, setHasNewer] = useState2(false);
+  const [sessionStatusProjection, setSessionStatusProjection] = useState2(
+    null
+  );
+  const [initialLoading, setInitialLoading] = useState2(true);
+  const [initialHistoryReady, setInitialHistoryReady] = useState2(false);
+  const [loadingOlder, setLoadingOlder] = useState2(false);
+  const [loadingNewer, setLoadingNewer] = useState2(false);
+  const [loadingOldest, setLoadingOldest] = useState2(false);
+  const [loadingLatest, setLoadingLatest] = useState2(false);
+  const [loadingTarget, setLoadingTarget] = useState2(false);
+  const loadingTargetRef = useRef2(false);
+  const [streamEpoch, setStreamEpoch] = useState2(0);
+  const [viewMode, setViewMode] = useState2("live");
+  const lastSequenceRef = useRef2(after);
+  const streamResumeSequenceRef = useRef2(after);
+  const skippedStepsThroughRef = useRef2(null);
+  const oldestSequenceRef = useRef2(null);
+  const newestSequenceRef = useRef2(null);
+  const hasOlderRef = useRef2(false);
+  const hasNewerRef = useRef2(false);
+  const loadingOlderRef = useRef2(false);
+  const loadingNewerRef = useRef2(false);
+  const loadingOldestRef = useRef2(false);
+  const loadingLatestRef = useRef2(false);
+  const viewModeRef = useRef2("live");
+  const initialWindowLoadedRef = useRef2(false);
+  const openedStreamKeyRef = useRef2(null);
+  const reconcileAfterPageResumeRef = useRef2(false);
+  const streamAbortRef = useRef2(null);
+  const streamKeyRef = useRef2(null);
+  const generationRef = useRef2(0);
+  const navigationGenerationRef = useRef2(0);
+  const eventWindowRef = useRef2(EMPTY_EVENT_WINDOW);
+  const sessionStatusRef = useRef2({
+    sequence: after,
+    status: null
+  });
+  const [stateStreamKey, setStateStreamKey] = useState2(streamKey);
+  const historyFilter = fullReplay ? void 0 : CONVERSATION_FILTER;
+  const [stepStores, setStepStores] = useState2(EMPTY_STEP_STORES);
+  const stepStoresRef = useRef2(EMPTY_STEP_STORES);
+  const [turnlessSteps, setTurnlessSteps] = useState2(EMPTY_TURNLESS_STEPS);
+  const turnlessStepsRef = useRef2(EMPTY_TURNLESS_STEPS);
+  const renderedTurnlessRef = useRef2({ appended: 0, marked: false });
+  useEffect2(() => {
+    renderedTurnlessRef.current = { appended: turnlessSteps.appended, marked: false };
+  }, [turnlessSteps]);
+  const liveThroughRef = useRef2(0);
+  const stepGenerationRef = useRef2(0);
+  const stepRequestRef = useRef2(0);
+  const retainedTurnsRef = useRef2(/* @__PURE__ */ new Map());
+  const turnStepHandlesRef = useRef2(/* @__PURE__ */ new Map());
+  const presentedCallIdsRef = useRef2(/* @__PURE__ */ new Set());
+  const presentedScanRef = useRef2(null);
+  const startupRef = useRef2(emptyStartupTurns());
+  const [presentedOutputs, setPresentedOutputs] = useState2(EMPTY_PRESENTED_OUTPUTS);
+  const presentedRequestedRef = useRef2(/* @__PURE__ */ new Map());
+  const presentedFailuresRef = useRef2(/* @__PURE__ */ new Map());
+  const [presentedPass, setPresentedPass] = useState2(0);
+  const rejoinPendingRef = useRef2(false);
+  const streamTransientStreakRef = useRef2(null);
+  const commitStepStores = useCallback3((next) => {
+    stepStoresRef.current = next;
+    setStepStores(next);
+  }, []);
+  const pruneStepStores = useCallback3(
+    (window2, sealedBy, rereading = null) => {
+      const present = windowTurns(window2);
+      const settled = sealedBy ? settledTurns(sealedBy) : null;
+      const next = /* @__PURE__ */ new Map();
+      for (const [turnId, store] of stepStoresRef.current) {
+        if (present.has(turnId) && (!settled || settled.has(turnId) || turnId === rereading)) {
+          next.set(turnId, store);
+        }
+      }
+      if (next.size !== stepStoresRef.current.size) commitStepStores(next);
+      if (sealedBy) {
+        presentedRequestedRef.current = /* @__PURE__ */ new Map();
+      } else {
+        for (const [callId, request] of presentedRequestedRef.current) {
+          if (request.turnId && !present.has(request.turnId)) {
+            presentedRequestedRef.current.delete(callId);
+          }
+        }
+      }
+      setPresentedOutputs((current) => {
+        let kept = null;
+        for (const [callId, output] of current) {
+          if (output.turnId && present.has(output.turnId)) continue;
+          kept ??= new Map(current);
+          kept.delete(callId);
+        }
+        return kept ?? current;
+      });
+    },
+    [commitStepStores]
+  );
+  const presentedCallIds = useCallback3((event) => {
+    const ids = presentedCallIdsRef.current;
+    if (event.type === "agent.toolCall.created") {
+      notePresentedCalls([event], ids);
+    } else if (event.type === "agent.toolCall.output") {
+      const payload = event.payload;
+      const windowEvents = eventWindowRef.current.events;
+      if (typeof payload?.id === "string" && !ids.has(payload.id) && presentedScanRef.current !== windowEvents) {
+        presentedScanRef.current = windowEvents;
+        notePresentedCalls(windowEvents, ids);
+      }
+    }
+    return ids;
+  }, []);
+  const startupTurns = useCallback3(() => {
+    const windowEvents = eventWindowRef.current.events;
+    if (startupRef.current.window !== windowEvents) {
+      const state = emptyStartupTurns();
+      noteStartupTurns(windowEvents, state);
+      state.window = windowEvents;
+      startupRef.current = state;
+    }
+    return startupRef.current;
+  }, []);
+  const appendLiveSteps = useCallback3(
+    (steps) => {
+      if (steps.some((event) => !event.turnId)) {
+        const incoming = steps.filter((event) => !event.turnId);
+        const turnless = appendTurnlessSteps(turnlessStepsRef.current, incoming);
+        const rendered = renderedTurnlessRef.current;
+        if (!rendered.marked && turnless.appended - rendered.appended > turnless.events.length) {
+          rendered.marked = true;
+          if (sessionId) markTurnlessOutputGap(workspaceId, sessionId);
+        }
+        turnlessStepsRef.current = turnless;
+        setTurnlessSteps(turnless);
+      }
+      const windowEvents = withTurnlessSteps(
+        eventWindowRef.current.events,
+        turnlessStepsRef.current
+      );
+      const next = new Map(stepStoresRef.current);
+      const now = Date.now();
+      for (const [turnId, events] of groupByTurn(steps)) {
+        const existing = next.get(turnId);
+        const store = existing ?? {
+          events: [],
+          bytes: 2,
+          // Earlier steps exist when the window skips sequences between the
+          // turn's start and this first live step.
+          hasOlder: turnHasHiddenSequences(windowEvents, turnId, events[0].sequence),
+          cursor: null,
+          floor: null,
+          pinned: null,
+          loading: false,
+          error: false,
+          touched: now,
+          requestId: 0
+        };
+        let updated = { ...store, ...appendStepEvents(store, events), touched: now };
+        if (!retainedTurnsRef.current.get(turnId)) updated = trimLiveStepTail(updated);
+        next.set(turnId, updated);
+      }
+      commitStepStores(boundStepStores(next, retainedTurnsRef.current));
+    },
+    [commitStepStores, workspaceId, sessionId]
+  );
+  const loadTurnSteps = useCallback3(
+    (turnId, before) => {
+      if (!ownsNavigation() || !sessionId || fullReplay) return;
+      const current = stepStoresRef.current.get(turnId);
+      const pinnedUpper = before ?? (current?.error && current.pinned !== null ? current.pinned : void 0);
+      const pinned = pinnedUpper !== void 0;
+      if (!pinned && current?.loading) return;
+      const bounds = conversationTurnBounds(eventWindowRef.current.events).get(turnId);
+      if (!bounds) return;
+      if (!pinned && current && !stepStoreHasOlder(current, bounds) && !current.error) return;
+      const upper = pinnedUpper ?? current?.cursor ?? current?.events[0]?.sequence ?? (bounds.terminal !== null ? bounds.terminal + 1 : Number.MAX_SAFE_INTEGER);
+      const exactStart = bounds.started !== null;
+      const lower = turnStepLowerBound(bounds);
+      const generation = stepGenerationRef.current;
+      const requestId = ++stepRequestRef.current;
+      const isCurrent = () => ownsNavigation() && generation === stepGenerationRef.current && stepStoresRef.current.get(turnId)?.requestId === requestId;
+      const base = current ?? {
+        events: [],
+        bytes: 2,
+        hasOlder: true,
+        cursor: null,
+        floor: null,
+        pinned: null,
+        loading: false,
+        error: false,
+        touched: 0,
+        requestId
+      };
+      commitStepStores(
+        new Map(stepStoresRef.current).set(turnId, {
+          ...base,
+          pinned: pinned ? upper : null,
+          loading: true,
+          error: false,
+          touched: Date.now(),
+          requestId
+        })
+      );
+      void readEventPage(client, workspaceId, sessionId, {
+        // Bookkeeping too, whichever read built this window: rows it already
+        // holds (a fallback read keeps them) merge once by id.
+        includeTypes: [...TURN_STEP_READ_TYPES],
+        after: Math.max(0, lower),
+        before: upper,
+        direction: "before",
+        limit: SESSION_TURN_STEP_PAGE_SIZE,
+        compact: true,
+        payloadMode: "full",
+        // Large tool outputs arrive as bounded previews; a row reads its
+        // exact output when the reader needs it (see useToolOutputReads).
+        toolOutputs: "preview"
+      }).then(
+        (page) => {
+          if (!isCurrent()) return;
+          const own = page.events.filter((event) => event.turnId === turnId);
+          const latest = stepStoresRef.current.get(turnId);
+          const merged = pinned ? appendStepEvents(
+            { events: [], bytes: 2 },
+            [...own, ...latest.events.filter((event) => event.sequence >= upper)].sort(
+              (left, right) => left.sequence - right.sequence
+            )
+          ) : appendStepEvents(latest, own);
+          const oldestOwn = merged.events[0]?.sequence ?? upper;
+          const passedStart = !exactStart && page.events.some(
+            (event) => !!event.turnId && event.turnId !== turnId && event.sequence < oldestOwn
+          );
+          const moreBelow = !passedStart && (page.hasMore ?? page.events.length > 0);
+          const reachedFloor = !moreBelow && !passedStart && !exactStart;
+          const next = new Map(stepStoresRef.current).set(turnId, {
+            ...merged,
+            // A page read without a continuation fact (a client without
+            // listEventPage) offers one more page until a read comes back empty.
+            hasOlder: moreBelow,
+            // The next page continues below this page's oldest row, even when
+            // the page held only other turns' rows, or below the floor.
+            cursor: reachedFloor ? lower + 1 : page.events.reduce((oldest, event) => Math.min(oldest, event.sequence), upper),
+            floor: reachedFloor ? lower : null,
+            pinned: null,
+            loading: false,
+            error: false,
+            touched: Date.now(),
+            requestId
+          });
+          commitStepStores(boundStepStores(next, retainedTurnsRef.current));
+        },
+        () => {
+          if (!isCurrent()) return;
+          const latest = stepStoresRef.current.get(turnId);
+          commitStepStores(
+            new Map(stepStoresRef.current).set(turnId, { ...latest, loading: false, error: true })
+          );
+        }
+      );
+    },
+    [client, workspaceId, sessionId, fullReplay, ownsNavigation, commitStepStores]
+  );
+  const loadTurnStepsRef = useRef2(loadTurnSteps);
+  useEffect2(() => {
+    loadTurnStepsRef.current = loadTurnSteps;
+  }, [loadTurnSteps]);
+  const turnStepHandle = useCallback3((turnId) => {
+    let handle = turnStepHandlesRef.current.get(turnId);
+    if (!handle) {
+      const retained = retainedTurnsRef.current;
+      handle = {
+        load: () => loadTurnStepsRef.current(turnId),
+        retain: () => {
+          retained.set(turnId, (retained.get(turnId) ?? 0) + 1);
+          let released = false;
+          return () => {
+            if (released) return;
+            released = true;
+            const count = (retained.get(turnId) ?? 1) - 1;
+            if (count > 0) retained.set(turnId, count);
+            else retained.delete(turnId);
+          };
+        }
+      };
+      turnStepHandlesRef.current.set(turnId, handle);
+    }
+    return handle;
+  }, []);
+  useEffect2(() => {
+    navigationGenerationRef.current += 1;
+    setNewerError(null);
+    loadingOlderRef.current = false;
+    loadingNewerRef.current = false;
+    loadingOldestRef.current = false;
+    loadingTargetRef.current = false;
+    setQuestionEvidence(null);
+    setLoadingTarget(false);
+    setLoadingOlder(false);
+    setLoadingNewer(false);
+    setLoadingOldest(false);
+    return () => {
+      navigationGenerationRef.current += 1;
+    };
+  }, [client, workspaceId, sessionId, after, enabled, fullReplay]);
+  useEffect2(() => {
+    if (streamKeyRef.current !== streamKey) {
+      streamKeyRef.current = streamKey;
+      setStateStreamKey(streamKey);
+      eventWindowRef.current = EMPTY_EVENT_WINDOW;
+      setEventWindow(EMPTY_EVENT_WINDOW);
+      setError(null);
+      setHasOlder(false);
+      setHasNewer(false);
+      sessionStatusRef.current = { sequence: after, status: null };
+      setSessionStatusProjection(null);
+      setLoadingOlder(false);
+      setLoadingNewer(false);
+      setLoadingOldest(false);
+      setLoadingLatest(false);
+      setInitialLoading(true);
+      setInitialHistoryReady(false);
+      lastSequenceRef.current = after;
+      streamResumeSequenceRef.current = after;
+      liveThroughRef.current = after;
+      skippedStepsThroughRef.current = null;
+      oldestSequenceRef.current = null;
+      newestSequenceRef.current = null;
+      hasOlderRef.current = false;
+      hasNewerRef.current = false;
+      loadingOlderRef.current = false;
+      loadingNewerRef.current = false;
+      loadingOldestRef.current = false;
+      loadingLatestRef.current = false;
+      viewModeRef.current = "live";
+      setViewMode("live");
+      initialWindowLoadedRef.current = false;
+      reconcileAfterPageResumeRef.current = false;
+      rejoinPendingRef.current = false;
+      streamTransientStreakRef.current = null;
+      stepGenerationRef.current += 1;
+      stepStoresRef.current = EMPTY_STEP_STORES;
+      setStepStores(EMPTY_STEP_STORES);
+      turnlessStepsRef.current = EMPTY_TURNLESS_STEPS;
+      setTurnlessSteps(EMPTY_TURNLESS_STEPS);
+      turnStepHandlesRef.current = /* @__PURE__ */ new Map();
+      presentedCallIdsRef.current = /* @__PURE__ */ new Set();
+      presentedScanRef.current = null;
+      startupRef.current = emptyStartupTurns();
+      presentedRequestedRef.current = /* @__PURE__ */ new Map();
+      presentedFailuresRef.current = /* @__PURE__ */ new Map();
+      setPresentedOutputs(EMPTY_PRESENTED_OUTPUTS);
+    }
+    const generation = generationRef.current + 1;
+    generationRef.current = generation;
+    if (!sessionId || !streamEnabled) {
+      streamTransientStreakRef.current = null;
+      if (sessionId && enabled && !pageLive && !fullReplay && viewModeRef.current === "live" && initialWindowLoadedRef.current) {
+        reconcileAfterPageResumeRef.current = true;
+      }
+      setConnectionState("idle");
+      return;
+    }
+    if (viewMode === "history") {
+      reconcileAfterPageResumeRef.current = false;
+      setConnectionState("idle");
+      setInitialLoading(false);
+      return;
+    }
+    const reconcileForegroundResume = reconcileAfterPageResumeRef.current && !fullReplay;
+    reconcileAfterPageResumeRef.current = false;
+    const controller = new AbortController();
+    const detailReadMark = sessionDetailReadMark();
+    const isCurrent = () => generationRef.current === generation && !controller.signal.aborted && navigationIdentityRef.current.client === client && navigationIdentityRef.current.streamKey === streamKey && navigationIdentityRef.current.enabled === enabled;
+    streamAbortRef.current = controller;
+    let transientRetryTimer = null;
+    const scheduleTransientRetry = (delayMs, retry) => {
+      if (transientRetryTimer !== null) clearTimeout(transientRetryTimer);
+      transientRetryTimer = setTimeout(() => {
+        transientRetryTimer = null;
+        if (isCurrent()) retry();
+      }, delayMs);
+    };
+    let pending = [];
+    let pendingBytes = 2;
+    let flushTimer = null;
+    const flush = () => {
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      if (!isCurrent()) {
+        pending = [];
+        pendingBytes = 2;
+        return;
+      }
+      if (pending.length === 0) {
+        return;
+      }
+      const batch = pending;
+      pending = [];
+      pendingBytes = 2;
+      const lastInBatch = batch[batch.length - 1];
+      if (lastInBatch) {
+        const batchResumeSequence = Math.max(...batch.map(eventResumeSequence));
+        lastSequenceRef.current = Math.max(lastSequenceRef.current, batchResumeSequence);
+        streamResumeSequenceRef.current = Math.max(
+          streamResumeSequenceRef.current,
+          batchResumeSequence
+        );
+        liveThroughRef.current = Math.max(liveThroughRef.current, batchResumeSequence);
+      }
+      const status = observeSessionStatus(batch, sessionStatusRef);
+      if (status !== void 0) {
+        setSessionStatusProjection(status);
+      }
+      let conversation = batch;
+      const steps = [];
+      if (!fullReplay) {
+        const windowNewest = newestSequenceRef.current ?? 0;
+        const startup = startupTurns();
+        conversation = [];
+        for (const event of batch) {
+          if (!isConversationHistoryEvent(event, presentedCallIds(event), startup.open)) {
+            steps.push(event);
+          } else if (event.sequence > windowNewest) conversation.push(event);
+          noteStartupTurns([event], startup);
+        }
+      }
+      if (conversation.length > 0) {
+        const current = eventWindowRef.current;
+        const next = appendBrowserSessionEventWindow(current, conversation);
+        const retained = {
+          ...next,
+          truncated: current.truncated || next.truncated
+        };
+        eventWindowRef.current = retained;
+        setEventWindow(retained);
+        if (!fullReplay) startupRef.current.window = retained.events;
+        oldestSequenceRef.current = retained.events[0]?.sequence ?? null;
+        newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
+        if (retained.truncated) {
+          hasOlderRef.current = true;
+          setHasOlder(true);
+        }
+      }
+      if (steps.length > 0) appendLiveSteps(steps);
+    };
+    const scheduleFlush = () => {
+      if (!isCurrent()) return;
+      flushTimer ??= setTimeout(flush, 16);
+    };
+    const installCatchup = (events, head) => {
+      const current = eventWindowRef.current;
+      const windowNewest = newestSequenceRef.current ?? 0;
+      const fresh = events.filter((event) => event.sequence > windowNewest);
+      const status = observeSessionStatus(fresh, sessionStatusRef);
+      const next = appendBrowserSessionEventWindow(current, fresh);
+      const retained = { ...next, truncated: current.truncated || next.truncated };
+      eventWindowRef.current = retained;
+      oldestSequenceRef.current = retained.events[0]?.sequence ?? oldestSequenceRef.current;
+      newestSequenceRef.current = maxResumeSequenceOrNull(retained.events) ?? newestSequenceRef.current;
+      lastSequenceRef.current = Math.max(lastSequenceRef.current, head);
+      streamResumeSequenceRef.current = Math.max(streamResumeSequenceRef.current, head);
+      if (skippedStepsThroughRef.current !== null) {
+        skippedStepsThroughRef.current = Math.max(skippedStepsThroughRef.current, head);
+      }
+      if (status !== void 0) setSessionStatusProjection(status);
+      if (fresh.length > 0) setEventWindow(retained);
+      if (retained.truncated) {
+        hasOlderRef.current = true;
+        setHasOlder(true);
+      }
+    };
+    const effectScope = { signal: controller.signal, isCurrent };
+    const readSessionHead = async (mark, scope) => {
+      const joined = joinSessionDetailRead(client, workspaceId, sessionId, mark);
+      if (joined) {
+        try {
+          return await joined;
+        } catch (cause) {
+          if (scope.signal.aborted) throw cause;
+        }
+      }
+      return await client.getSession(workspaceId, sessionId, {
+        fresh: true,
+        signal: scope.signal
+      });
+    };
+    const rejoinLive = async (force, {
+      strict = false,
+      mark = detailReadMark,
+      scope = effectScope
+    } = {}) => {
+      const activeTurn = activeConversationTurn(eventWindowRef.current.events);
+      if (!force && !activeTurn) return "joined";
+      const cursor = streamResumeSequenceRef.current;
+      let head;
+      let sessionActiveTurn = null;
+      try {
+        const session = await readSessionHead(mark, scope);
+        scope.progress?.();
+        head = session.lastSequence;
+        sessionActiveTurn = session.activeTurnId;
+      } catch (cause) {
+        if (!scope.isCurrent() || strict && isRetryableStreamError(cause)) throw cause;
+        return "joined";
+      }
+      if (!scope.isCurrent()) throw abortError();
+      if (!Number.isSafeInteger(head) || head - cursor <= DIRECT_REPLAY_MAX_SEQUENCES) {
+        return "joined";
+      }
+      let catchup;
+      try {
+        catchup = await loadConversationCatchup(
+          client,
+          workspaceId,
+          sessionId,
+          cursor,
+          head,
+          scope
+        );
+      } catch (cause) {
+        if (!scope.isCurrent() || strict && isRetryableStreamError(cause)) throw cause;
+        return "joined";
+      }
+      if (!scope.isCurrent()) throw abortError();
+      if (catchup === null) return "reload";
+      const previous = eventWindowRef.current.events;
+      installCatchup(catchup, head);
+      const working = sessionActiveTurn ?? activeConversationTurn(eventWindowRef.current.events);
+      pruneStepStores(eventWindowRef.current.events, previous, working);
+      if (working) loadTurnStepsRef.current(working, head + 1);
+      if (working && conversationTurnBounds(eventWindowRef.current.events).has(working)) {
+        skippedStepsThroughRef.current = null;
+      }
+      return "joined";
+    };
+    const loadLatestWindow = async (scope = effectScope) => {
+      const window2 = await loadEventWindow(t, client, workspaceId, sessionId, {
+        before: Number.MAX_SAFE_INTEGER,
+        pageSize: SESSION_FIRST_WINDOW_PAGE_SIZE,
+        targetGroups: Number.POSITIVE_INFINITY,
+        maxFetches: INITIAL_FETCH_CAP,
+        boundaryPageCap: BOUNDARY_PAGE_CAP,
+        signal: scope.signal,
+        ...scope.progress ? { progress: scope.progress } : {},
+        filter: CONVERSATION_FILTER
+      });
+      if (!scope.isCurrent()) {
+        return false;
+      }
+      const status = observeSessionStatus(window2.events, sessionStatusRef);
+      const retained = boundBrowserSessionEventWindow(window2.events);
+      navigationGenerationRef.current += 1;
+      loadingOlderRef.current = false;
+      loadingNewerRef.current = false;
+      loadingOldestRef.current = false;
+      setLoadingOlder(false);
+      setLoadingNewer(false);
+      setLoadingOldest(false);
+      const previous = eventWindowRef.current.events;
+      eventWindowRef.current = retained;
+      pruneStepStores(retained.events, previous);
+      oldestSequenceRef.current = retained.events[0]?.sequence ?? window2.oldestSequence ?? window2.scanCursor;
+      newestSequenceRef.current = maxResumeSequenceOrNull(retained.events) ?? window2.newestSequence;
+      hasOlderRef.current = window2.hasOlder || retained.truncated;
+      hasNewerRef.current = false;
+      lastSequenceRef.current = Math.max(lastSequenceRef.current, window2.newestSequence);
+      streamResumeSequenceRef.current = window2.newestSequence;
+      skippedStepsThroughRef.current = retained.events.length === 0 && window2.newestSequence > 0 ? window2.newestSequence : null;
+      initialWindowLoadedRef.current = true;
+      streamTransientStreakRef.current = null;
+      setInitialHistoryReady(true);
+      setError(null);
+      if (status !== void 0) {
+        setSessionStatusProjection(status);
+      }
+      setEventWindow(retained);
+      setHasOlder(window2.hasOlder || retained.truncated);
+      setHasNewer(false);
+      setInitialLoading(false);
+      return true;
+    };
+    const noteStreamResume = () => {
+      if (!fullReplay && streamResumeSequenceRef.current > liveThroughRef.current) {
+        markTurnlessOutputGap(workspaceId, sessionId);
+      }
+      liveThroughRef.current = Math.max(liveThroughRef.current, streamResumeSequenceRef.current);
+    };
+    const reconcileAfterOpen = (initialOpen, streak = null) => {
+      void Promise.resolve().then(() => reconcileSession(sessionId, { initialOpen })).catch((cause) => {
+        if (!isCurrent()) return;
+        if (isTransientRequestError(cause)) {
+          const now = Date.now();
+          const current = streak ?? { since: now, attempts: 0, surfaced: false };
+          const step = transientReadRetryStep(current, now, DEFAULT_TRANSIENT_READ_RETRY, cause);
+          if (step.quiet) {
+            scheduleTransientRetry(step.delayMs, () => reconcileAfterOpen(initialOpen, current));
+            return;
+          }
+        }
+        setError(normalizeError(cause));
+      });
+    };
+    const boundedRejoin = async (strict, join) => {
+      if (!isCurrent()) throw abortError();
+      const attempt = new AbortController();
+      let timedOut = false;
+      const abortAttempt = () => attempt.abort();
+      controller.signal.addEventListener("abort", abortAttempt, { once: true });
+      const stalled = () => {
+        timedOut = true;
+        attempt.abort();
+      };
+      let timer = setTimeout(stalled, REJOIN_STALL_TIMEOUT_MS);
+      let stopWaiting;
+      const stopped = new Promise((_resolve, reject) => {
+        stopWaiting = () => reject(abortError());
+        attempt.signal.addEventListener("abort", stopWaiting, { once: true });
+      });
+      const scope = {
+        signal: attempt.signal,
+        isCurrent: () => isCurrent() && !attempt.signal.aborted,
+        progress: () => {
+          if (attempt.signal.aborted) return;
+          clearTimeout(timer);
+          timer = setTimeout(stalled, REJOIN_STALL_TIMEOUT_MS);
+        }
+      };
+      try {
+        return await Promise.race([join(scope), stopped]);
+      } catch (cause) {
+        if (!isCurrent()) throw cause;
+        if (timedOut) {
+          return strict ? {
+            retry: new TypeError(
+              `rejoining the live session stalled for ${REJOIN_STALL_TIMEOUT_MS}ms`
+            )
+          } : "joined";
+        }
+        if (strict && isRetryableStreamError(cause)) return { retry: cause };
+        throw cause;
+      } finally {
+        clearTimeout(timer);
+        controller.signal.removeEventListener("abort", abortAttempt);
+        if (stopWaiting) attempt.signal.removeEventListener("abort", stopWaiting);
+      }
+    };
+    const leniently = async (join) => {
+      const result = await boundedRejoin(false, join);
+      return typeof result === "string" ? result : "joined";
+    };
+    let strictFailures = 0;
+    const beforeReconnect = async (cursor) => {
+      flush();
+      if (!isCurrent()) throw abortError();
+      const strict = strictFailures < STRICT_REJOIN_ATTEMPTS;
+      const mark = sessionDetailReadMark();
+      let result;
+      try {
+        result = await boundedRejoin(strict, async (scope) => {
+          if (await rejoinLive(true, { strict, mark, scope }) === "joined") return "joined";
+          let loaded;
+          try {
+            loaded = await loadLatestWindow(scope);
+          } catch (cause) {
+            if (!scope.isCurrent() || strict && isRetryableStreamError(cause)) throw cause;
+            return "joined";
+          }
+          if (!loaded) throw abortError();
+          if (await rejoinLive(true, { strict, mark, scope }) === "reload" && strict) {
+            throw new TypeError("the session outran a fresh window while rejoining it");
+          }
+          return "joined";
+        });
+      } catch (cause) {
+        if (!isCurrent()) throw abortError();
+        if (!isRetryableStreamError(cause)) throw cause;
+        throw new Error(`rejoining the live session failed: ${errorMessage(cause)}`, { cause });
+      }
+      if (!isCurrent()) throw abortError();
+      if (typeof result === "object") {
+        strictFailures += 1;
+        throw result.retry;
+      }
+      noteStreamResume();
+      return Math.max(cursor, streamResumeSequenceRef.current);
+    };
+    void (async () => {
+      try {
+        if (reconcileForegroundResume) {
+          setConnectionState("connecting");
+          let outcome;
+          for (let attempt = 0; ; attempt += 1) {
+            const strict = attempt < STRICT_REJOIN_ATTEMPTS;
+            const result = await boundedRejoin(
+              strict,
+              (scope) => rejoinLive(true, { strict, scope })
+            );
+            if (typeof result === "string") {
+              outcome = result;
+              break;
+            }
+            await abortableDelay(
+              Math.min(FOREGROUND_REJOIN_RETRY_MS * 2 ** attempt, FOREGROUND_REJOIN_RETRY_MAX_MS),
+              controller.signal
+            );
+          }
+          if (outcome === "reload") {
+            initialWindowLoadedRef.current = false;
+            setError(null);
+          }
+        } else if (!fullReplay && initialWindowLoadedRef.current && rejoinPendingRef.current) {
+          rejoinPendingRef.current = false;
+          if (await leniently((scope) => rejoinLive(false, { scope })) === "reload") {
+            initialWindowLoadedRef.current = false;
+          }
+        }
+        rejoinPendingRef.current = false;
+        const windowPasses = fullReplay ? 0 : 2;
+        for (let attempt = 0; attempt < windowPasses && !initialWindowLoadedRef.current; attempt += 1) {
+          setConnectionState("connecting");
+          if (!await loadLatestWindow()) {
+            return;
+          }
+          if (await leniently((scope) => rejoinLive(true, { scope })) === "reload" && attempt === 0) {
+            initialWindowLoadedRef.current = false;
+          }
+        }
+        if (fullReplay) {
+          setInitialLoading(false);
+        }
+        noteStreamResume();
+        const stream = client.streamEvents(workspaceId, sessionId, {
+          after: streamResumeSequenceRef.current,
+          signal: controller.signal,
+          // Full replay keeps the SDK's exactly-once reconnects.
+          ...fullReplay ? {} : { beforeReconnect },
+          onOpen: () => {
+            const initialOpen = openedStreamKeyRef.current !== streamKey;
+            openedStreamKeyRef.current = streamKey;
+            strictFailures = 0;
+            if (streamTransientStreakRef.current?.surfaced) setError(null);
+            streamTransientStreakRef.current = null;
+            reconcileAfterOpen(initialOpen);
+          },
+          onStateChange: (state) => {
+            if (isCurrent()) {
+              setConnectionState(state);
+            }
+          }
+        });
+        for await (const event of stream) {
+          if (!isCurrent()) break;
+          const boundedEvent = event;
+          const boundedEventBytes = browserJsonBytes(boundedEvent);
+          const separatorBytes = pending.length === 0 ? 0 : 1;
+          if (pending.length > 0 && (pending.length >= SESSION_EVENT_BROWSER_PENDING_MAX_COUNT || pendingBytes + separatorBytes + boundedEventBytes > SESSION_EVENT_BROWSER_PENDING_MAX_BYTES)) {
+            flush();
+          }
+          pending.push(boundedEvent);
+          pendingBytes += (pending.length === 1 ? 0 : 1) + boundedEventBytes;
+          if (pending.length >= SESSION_EVENT_BROWSER_PENDING_MAX_COUNT || pendingBytes >= SESSION_EVENT_BROWSER_PENDING_MAX_BYTES) {
+            flush();
+          } else {
+            scheduleFlush();
+          }
+        }
+        if (isCurrent()) {
+          flush();
+          setConnectionState("ended");
+        }
+      } catch (cause) {
+        if (isCurrent()) {
+          flush();
+          let announce = true;
+          if (isTransientRequestError(cause)) {
+            const now = Date.now();
+            const streak = streamTransientStreakRef.current ??= {
+              since: now,
+              attempts: 0,
+              surfaced: false
+            };
+            const step = transientReadRetryStep(streak, now, DEFAULT_TRANSIENT_READ_RETRY, cause);
+            scheduleTransientRetry(step.delayMs, () => setStreamEpoch((epoch) => epoch + 1));
+            if (step.quiet) {
+              setConnectionState("connecting");
+              return;
+            }
+            announce = !streak.surfaced;
+            streak.surfaced = true;
+          } else {
+            streamTransientStreakRef.current = null;
+          }
+          if (announce) setError(normalizeError(cause));
+          setConnectionState("error");
+          setInitialLoading(false);
+        }
+      }
+    })();
+    return () => {
+      controller.abort();
+      if (transientRetryTimer !== null) clearTimeout(transientRetryTimer);
+      if (generationRef.current === generation) {
+        generationRef.current = generation + 1;
+      }
+      if (streamAbortRef.current === controller) {
+        streamAbortRef.current = null;
+      }
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+      }
+    };
+  }, [
+    client,
+    workspaceId,
+    sessionId,
+    after,
+    enabled,
+    pageLive,
+    streamEnabled,
+    fullReplay,
+    streamKey,
+    streamEpoch,
+    viewMode,
+    reconcileSession,
+    t,
+    pruneStepStores,
+    appendLiveSteps,
+    presentedCallIds,
+    startupTurns
+  ]);
+  useEffect2(() => {
+    if (!sessionId || !streamEnabled) return;
+    return subscribePageWake(() => {
+      const stream = streamAbortRef.current;
+      if (!stream || stream.signal.aborted || viewModeRef.current !== "live") return;
+      if (!fullReplay && initialWindowLoadedRef.current) {
+        reconcileAfterPageResumeRef.current = true;
+      }
+      setStreamEpoch((epoch) => epoch + 1);
+    });
+  }, [sessionId, streamEnabled, fullReplay]);
+  const navigationBusy = () => loadingTargetRef.current || loadingOlderRef.current || loadingNewerRef.current || loadingOldestRef.current || loadingLatestRef.current;
+  const loadOlder = useCallback3(
+    () => createOlderHistoryLoadReceipt(async (markCommitted, preserveTail, markTailPreserved) => {
+      if (!ownsNavigation() || !sessionId || navigationBusy() || !hasOlderRef.current) {
+        return false;
+      }
+      const before = oldestSequenceRef.current;
+      if (before === null) {
+        oldestSequenceRef.current = null;
+        hasOlderRef.current = false;
+        setHasOlder(false);
+        return false;
+      }
+      const generation = navigationGenerationRef.current;
+      const isCurrent = () => ownsNavigation() && navigationGenerationRef.current === generation;
+      loadingOlderRef.current = true;
+      setLoadingOlder(true);
+      let published = false;
+      try {
+        const window2 = await loadEventWindow(t, client, workspaceId, sessionId, {
+          before,
+          pageSize: SESSION_HISTORY_PAGE_SIZE,
+          targetGroups: OLDER_GROUP_TARGET,
+          maxFetches: OLDER_FETCH_CAP,
+          filteredPageCap: FILTERED_PAGE_CAP,
+          isCurrent,
+          filter: historyFilter
+        });
+        if (!isCurrent()) {
+          return false;
+        }
+        if (window2.events.length === 0) {
+          if (window2.hasOlder && window2.scanCursor < before) {
+            oldestSequenceRef.current = window2.scanCursor;
+            return true;
+          }
+          oldestSequenceRef.current = null;
+          hasOlderRef.current = false;
+          setHasOlder(false);
+          return false;
+        }
+        const current = eventWindowRef.current;
+        assertPrependOrder(current.events, window2.events);
+        const next = boundBrowserSessionEventWindow([...window2.events, ...current.events], {
+          direction: "oldest"
+        });
+        if (preserveTail && maxResumeSequence(next.events) < maxResumeSequence(current.events)) {
+          markTailPreserved();
+          return false;
+        }
+        const status = observeSessionStatus(window2.events, sessionStatusRef);
+        const retained = {
+          ...next,
+          truncated: current.truncated || next.truncated
+        };
+        const retainedOldest = retained.events[0]?.sequence ?? null;
+        if (retainedOldest === null || retainedOldest >= before) {
+          throw new Error("@opengeni/react: loadOlder made no durable sequence progress");
+        }
+        const retainedNewest = maxResumeSequenceOrNull(retained.events);
+        const previousNewest = maxResumeSequenceOrNull(current.events);
+        const evictedLiveTail = previousNewest !== null && retainedNewest !== null && retainedNewest < previousNewest;
+        if (evictedLiveTail && viewModeRef.current === "live") {
+          streamAbortRef.current?.abort();
+        }
+        eventWindowRef.current = retained;
+        if (evictedLiveTail) {
+          skippedStepsThroughRef.current = null;
+          pruneStepStores(retained.events, current.events);
+        } else {
+          const skippedThrough = skippedStepsThroughRef.current;
+          if (skippedThrough !== null && windowTurns(window2.events).size > 0) {
+            skippedStepsThroughRef.current = null;
+            const working = activeConversationTurn(retained.events);
+            const bounds = working ? conversationTurnBounds(retained.events).get(working) : void 0;
+            if (working && bounds && bounds.first <= skippedThrough) {
+              loadTurnStepsRef.current(working, skippedThrough + 1);
+            }
+          }
+        }
+        markCommitted();
+        oldestSequenceRef.current = retainedOldest;
+        newestSequenceRef.current = retainedNewest;
+        if (evictedLiveTail) {
+          streamResumeSequenceRef.current = maxResumeSequence(retained.events);
+        }
+        const olderStillAvailable = window2.hasOlder;
+        hasOlderRef.current = olderStillAvailable;
+        let newer = null;
+        let enterHistory = false;
+        if (viewModeRef.current === "history" || evictedLiveTail) {
+          const highWater = lastSequenceRef.current;
+          newer = retainedNewest !== null && (retainedNewest < highWater || retained.truncated);
+          hasNewerRef.current = newer;
+          if (evictedLiveTail) {
+            viewModeRef.current = "history";
+            enterHistory = true;
+          }
+        }
+        loadingOlderRef.current = false;
+        startTransition(() => {
+          if (status !== void 0) {
+            setSessionStatusProjection(status);
+          }
+          setEventWindow(retained);
+          setHasOlder(olderStillAvailable);
+          if (newer !== null) {
+            setHasNewer(newer);
+          }
+          if (enterHistory) {
+            setViewMode("history");
+          }
+          setLoadingOlder(false);
+        });
+        published = true;
+        return olderStillAvailable;
+      } catch (reason) {
+        if (!isCurrent()) return false;
+        throw reason;
+      } finally {
+        if (!published && isCurrent()) {
+          loadingOlderRef.current = false;
+          setLoadingOlder(false);
+        }
+      }
+    }),
+    [client, workspaceId, sessionId, ownsNavigation, t, historyFilter, pruneStepStores]
+  );
+  const loadOldest = useCallback3(async () => {
+    if (!ownsNavigation() || !sessionId || navigationBusy() || !hasOlderRef.current) {
+      return false;
+    }
+    const generation = ++navigationGenerationRef.current;
+    const isCurrent = () => ownsNavigation() && navigationGenerationRef.current === generation;
+    setQuestionEvidence(null);
+    loadingOldestRef.current = true;
+    setLoadingOldest(true);
+    let published = false;
+    try {
+      const window2 = await loadForwardEventWindow(t, client, workspaceId, sessionId, {
+        after: 0,
+        pageSize: SESSION_HISTORY_PAGE_SIZE,
+        targetGroups: OLDEST_GROUP_TARGET,
+        maxFetches: OLDEST_FETCH_CAP,
+        isCurrent,
+        filter: historyFilter
+      });
+      if (!isCurrent()) {
+        return false;
+      }
+      if (window2.events.length === 0) {
+        hasOlderRef.current = false;
+        setHasOlder(false);
+        return false;
+      }
+      streamAbortRef.current?.abort();
+      const status = observeSessionStatus(window2.events, sessionStatusRef);
+      const retained = boundBrowserSessionEventWindow(window2.events, { direction: "oldest" });
+      const retainedOldest = retained.events[0]?.sequence ?? null;
+      const retainedNewest = maxResumeSequenceOrNull(retained.events);
+      const previous = eventWindowRef.current.events;
+      eventWindowRef.current = retained;
+      skippedStepsThroughRef.current = null;
+      pruneStepStores(retained.events, previous);
+      oldestSequenceRef.current = retainedOldest;
+      newestSequenceRef.current = retainedNewest;
+      hasOlderRef.current = false;
+      const highWater = Math.max(lastSequenceRef.current, retainedNewest ?? 0);
+      lastSequenceRef.current = highWater;
+      const newer = window2.hasNewer || retained.truncated || retainedNewest !== null && retainedNewest < highWater;
+      hasNewerRef.current = newer;
+      initialWindowLoadedRef.current = true;
+      setInitialHistoryReady(true);
+      setError(null);
+      viewModeRef.current = "history";
+      loadingOldestRef.current = false;
+      setNewerError(null);
+      startTransition(() => {
+        if (status !== void 0) {
+          setSessionStatusProjection(status);
+        }
+        setEventWindow(retained);
+        setHasOlder(false);
+        setHasNewer(newer);
+        setViewMode("history");
+        setLoadingOldest(false);
+      });
+      published = true;
+      return newer;
+    } catch (reason) {
+      if (!isCurrent()) return false;
+      throw reason;
+    } finally {
+      if (!published && isCurrent()) {
+        loadingOldestRef.current = false;
+        setLoadingOldest(false);
+      }
+    }
+  }, [client, workspaceId, sessionId, ownsNavigation, t, historyFilter, pruneStepStores]);
+  const loadNewer = useCallback3(async () => {
+    if (!ownsNavigation() || !sessionId || navigationBusy() || !hasNewerRef.current) {
+      return false;
+    }
+    const afterSequence = newestSequenceRef.current;
+    if (afterSequence === null) {
+      hasNewerRef.current = false;
+      setHasNewer(false);
+      return false;
+    }
+    const generation = navigationGenerationRef.current;
+    const isCurrent = () => ownsNavigation() && navigationGenerationRef.current === generation;
+    loadingNewerRef.current = true;
+    setLoadingNewer(true);
+    let published = false;
+    try {
+      const window2 = await loadForwardEventWindow(t, client, workspaceId, sessionId, {
+        after: afterSequence,
+        pageSize: SESSION_HISTORY_PAGE_SIZE,
+        targetGroups: NEWER_GROUP_TARGET,
+        maxFetches: NEWER_FETCH_CAP,
+        filteredPageCap: FILTERED_PAGE_CAP,
+        isCurrent,
+        filter: historyFilter
+      });
+      if (!isCurrent()) {
+        return false;
+      }
+      if (window2.events.length === 0) {
+        if (window2.hasNewer && window2.scanCursor > afterSequence) {
+          newestSequenceRef.current = window2.scanCursor;
+          return true;
+        }
+        setNewerError(null);
+        hasNewerRef.current = false;
+        setHasNewer(false);
+        streamResumeSequenceRef.current = afterSequence;
+        rejoinPendingRef.current = true;
+        viewModeRef.current = "live";
+        setViewMode("live");
+        setStreamEpoch((epoch) => epoch + 1);
+        return false;
+      }
+      const current = eventWindowRef.current;
+      assertAppendOrder(current.events, window2.events);
+      const status = observeSessionStatus(window2.events, sessionStatusRef);
+      const previousOldest = current.events[0]?.sequence ?? null;
+      const next = appendBrowserSessionEventWindow(current, window2.events);
+      const retained = {
+        ...next,
+        truncated: current.truncated || next.truncated || window2.hasNewer
+      };
+      const retainedOldest = retained.events[0]?.sequence ?? null;
+      const retainedNewest = maxResumeSequenceOrNull(retained.events);
+      if (retainedNewest === null || retainedNewest <= afterSequence) {
+        throw new Error("@opengeni/react: loadNewer made no durable sequence progress");
+      }
+      eventWindowRef.current = retained;
+      pruneStepStores(retained.events, null);
+      oldestSequenceRef.current = retainedOldest;
+      newestSequenceRef.current = retainedNewest;
+      if (retainedOldest !== null && (previousOldest === null || retainedOldest > previousOldest || retained.truncated && retained.events[0]?.type !== "session.created" && retainedOldest > 1)) {
+        hasOlderRef.current = true;
+      }
+      const rearmedOlder = hasOlderRef.current;
+      const highWater = Math.max(lastSequenceRef.current, retainedNewest);
+      lastSequenceRef.current = highWater;
+      const newer = window2.hasNewer || retainedNewest < highWater;
+      hasNewerRef.current = newer;
+      let resumeLive = false;
+      if (!newer) {
+        streamResumeSequenceRef.current = retainedNewest;
+        rejoinPendingRef.current = true;
+        viewModeRef.current = "live";
+        resumeLive = true;
+      }
+      loadingNewerRef.current = false;
+      setNewerError(null);
+      startTransition(() => {
+        if (status !== void 0) {
+          setSessionStatusProjection(status);
+        }
+        setEventWindow(retained);
+        setHasOlder(rearmedOlder);
+        setHasNewer(newer);
+        if (resumeLive) {
+          setViewMode("live");
+          setStreamEpoch((epoch) => epoch + 1);
+        }
+        setLoadingNewer(false);
+      });
+      published = true;
+      return newer;
+    } catch (reason) {
+      if (!isCurrent()) {
+        return false;
+      }
+      setNewerError(normalizeError(reason));
+      throw reason;
+    } finally {
+      if (!published && isCurrent()) {
+        loadingNewerRef.current = false;
+        setLoadingNewer(false);
+      }
+    }
+  }, [client, workspaceId, sessionId, ownsNavigation, t, historyFilter, pruneStepStores]);
+  const jumpToSequence = useCallback3(
+    async (sequence, navigationOptions) => {
+      const signal = navigationOptions?.signal;
+      if (!ownsNavigation() || !sessionId || !Number.isSafeInteger(sequence) || sequence < 1)
+        return false;
+      if (signal?.aborted) return false;
+      const generation = ++navigationGenerationRef.current;
+      setQuestionEvidence(null);
+      const current = () => generation === navigationGenerationRef.current && ownsNavigation();
+      const previousMode = viewModeRef.current;
+      streamAbortRef.current?.abort();
+      generationRef.current += 1;
+      viewModeRef.current = "history";
+      setViewMode("history");
+      loadingOlderRef.current = loadingNewerRef.current = loadingOldestRef.current = false;
+      setLoadingOlder(false);
+      setLoadingNewer(false);
+      setLoadingOldest(false);
+      loadingTargetRef.current = true;
+      setLoadingTarget(true);
+      let published = false;
+      try {
+        const around = (filter) => Promise.all([
+          loadPreviousPage(client, workspaceId, sessionId, sequence + 1, {
+            pageSize: 128,
+            filter
+          }),
+          loadNextPage(client, workspaceId, sessionId, sequence, { pageSize: 128, filter })
+        ]);
+        let [before, following] = await around(historyFilter);
+        if (historyFilter && current() && !before.some((event) => event.sequence === sequence)) {
+          [before, following] = await around(void 0);
+        }
+        if (signal?.aborted) return false;
+        if (!current()) return false;
+        if (!before.some((event) => event.sequence === sequence)) return false;
+        const prefix = boundBrowserSessionEventWindow(before, {
+          direction: "newest",
+          maxBytes: SESSION_EVENT_BROWSER_MAX_BYTES / 2
+        });
+        const retained = boundBrowserSessionEventWindow([...prefix.events, ...following], {
+          direction: "oldest"
+        });
+        if (!retained.events.some((event) => event.sequence === sequence)) return false;
+        streamAbortRef.current?.abort();
+        generationRef.current += 1;
+        const status = observeSessionStatus(retained.events, sessionStatusRef);
+        const previous = eventWindowRef.current.events;
+        eventWindowRef.current = retained;
+        pruneStepStores(retained.events, previous);
+        oldestSequenceRef.current = retained.events[0].sequence;
+        newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
+        lastSequenceRef.current = Math.max(lastSequenceRef.current, newestSequenceRef.current ?? 0);
+        hasOlderRef.current = !isLogStart(retained.events[0]);
+        hasNewerRef.current = following.length > 0 || retained.truncated || (newestSequenceRef.current ?? 0) < lastSequenceRef.current;
+        initialWindowLoadedRef.current = true;
+        setInitialHistoryReady(true);
+        setError(null);
+        viewModeRef.current = "history";
+        setEventWindow(retained);
+        setHasOlder(hasOlderRef.current);
+        setHasNewer(hasNewerRef.current);
+        setInitialLoading(false);
+        setViewMode("history");
+        setNewerError(null);
+        if (status !== void 0) setSessionStatusProjection(status);
+        published = true;
+        return true;
+      } catch (reason) {
+        if (!current() || signal?.aborted) return false;
+        throw reason;
+      } finally {
+        if (current()) {
+          loadingTargetRef.current = false;
+          setLoadingTarget(false);
+          if (!published && previousMode === "live") {
+            viewModeRef.current = "live";
+            setViewMode("live");
+            setStreamEpoch((epoch) => epoch + 1);
+          }
+        }
+      }
+    },
+    [client, workspaceId, sessionId, ownsNavigation, historyFilter, pruneStepStores]
+  );
+  const jumpToLatestQuestion = useCallback3(
+    async (questionOptions) => {
+      if (!sessionId || !ownsNavigation()) return null;
+      let generation = navigationGenerationRef.current;
+      const current = () => ownsNavigation() && generation === navigationGenerationRef.current;
+      try {
+        const { resolveLatestQuestion } = await import("./latest-question-OX56OVQ5.js");
+        if (!current()) return null;
+        const destination = await resolveLatestQuestion(t, {
+          client,
+          workspaceId,
+          sessionId,
+          isCurrent: current,
+          resumeSequence: maxResumeSequence,
+          options: questionOptions
+        });
+        if (!destination || !current()) return null;
+        if (!eventWindowRef.current.events.some((event) => event.sequence === destination.anchor)) {
+          const navigation = jumpToSequence(destination.anchor);
+          generation = navigationGenerationRef.current;
+          if (!await navigation || !current()) return null;
+        }
+        setQuestionEvidence({
+          client,
+          streamKey,
+          anchor: destination.anchor,
+          events: destination.events
+        });
+        return destination.questionSequence;
+      } catch (reason) {
+        if (!current()) return null;
+        throw reason;
+      }
+    },
+    [client, workspaceId, sessionId, streamKey, ownsNavigation, jumpToSequence, t]
+  );
+  const jumpToLatest = useCallback3(async () => {
+    if (!ownsNavigation()) return;
+    if (loadingTargetRef.current) {
+      navigationGenerationRef.current += 1;
+      loadingTargetRef.current = false;
+      setLoadingTarget(false);
+    }
+    if (!sessionId || navigationBusy()) {
+      return;
+    }
+    navigationGenerationRef.current += 1;
+    setQuestionEvidence(null);
+    loadingLatestRef.current = true;
+    setLoadingLatest(true);
+    setNewerError(null);
+    setError(null);
+    let published = false;
+    try {
+      streamAbortRef.current?.abort();
+      hasNewerRef.current = false;
+      hasOlderRef.current = false;
+      newestSequenceRef.current = null;
+      oldestSequenceRef.current = null;
+      eventWindowRef.current = EMPTY_EVENT_WINDOW;
+      initialWindowLoadedRef.current = false;
+      streamResumeSequenceRef.current = after;
+      viewModeRef.current = "live";
+      loadingLatestRef.current = false;
+      startTransition(() => {
+        setHasNewer(false);
+        setHasOlder(false);
+        setEventWindow(EMPTY_EVENT_WINDOW);
+        setInitialLoading(true);
+        setViewMode("live");
+        setStreamEpoch((epoch) => epoch + 1);
+        setLoadingLatest(false);
+      });
+      published = true;
+      await Promise.resolve();
+    } finally {
+      if (!published) {
+        loadingLatestRef.current = false;
+        setLoadingLatest(false);
+      }
+    }
+  }, [after, sessionId, ownsNavigation]);
+  const identityMatches = stateStreamKey === streamKey;
+  const freshTail = identityMatches && initialHistoryReady && viewMode === "live" && !fullReplay ? {
+    events: eventWindow.events,
+    hasOlder,
+    truncated: eventWindow.truncated,
+    bytes: eventWindow.bytes,
+    sessionStatus: sessionStatusProjection
+  } : null;
+  const retainedTail = useRetainedSessionView(client, workspaceId, sessionId, "events", freshTail, {
+    enabled: !fullReplay,
+    bytes: (tail) => tail.bytes,
+    budgetBytes: SESSION_EVENT_BROWSER_MAX_BYTES,
+    discard: identityMatches && deniesRetainedView(error)
+  });
+  const showRetained = retainedTail !== null && !(identityMatches && initialHistoryReady);
+  const visibleEvents = showRetained ? retainedTail.events : identityMatches ? eventWindow.events : EMPTY_EVENTS;
+  const visibleHasOlder = showRetained ? retainedTail.hasOlder : identityMatches && hasOlder;
+  const visibleTruncated = showRetained ? retainedTail.truncated : eventWindow.truncated;
+  const liveSteps = identityMatches && !showRetained;
+  const visibleStepStores = liveSteps ? stepStores : EMPTY_STEP_STORES;
+  const visiblePresentedOutputs = liveSteps ? presentedOutputs : EMPTY_PRESENTED_OUTPUTS;
+  const visibleTurnless = liveSteps ? turnlessSteps : EMPTY_TURNLESS_STEPS;
+  const readToolOutput = useCallback3(
+    async (sequence) => sessionId ? (await readEventPage(client, workspaceId, sessionId, {
+      includeTypes: ["agent.toolCall.output"],
+      after: Math.max(0, sequence - 1),
+      before: sequence + 1,
+      direction: "after",
+      limit: 1,
+      payloadMode: "full"
+    })).events : [],
+    [client, workspaceId, sessionId]
+  );
+  const toolOutputs = useToolOutputReads(readToolOutput, stepStores);
+  const visibleToolOutputs = liveSteps ? toolOutputs.exact : EMPTY_PRESENTED_OUTPUTS;
+  const loadedEvents = useMemo2(
+    () => mergeLoadedEvents(
+      visibleEvents,
+      visibleStepStores,
+      visiblePresentedOutputs,
+      visibleTurnless.events,
+      visibleToolOutputs
+    ),
+    [
+      visibleEvents,
+      visibleStepStores,
+      visiblePresentedOutputs,
+      visibleTurnless,
+      visibleToolOutputs
+    ]
+  );
+  const turnSteps = useMemo2(() => {
+    if (fullReplay) return void 0;
+    const markers = /* @__PURE__ */ new Map();
+    const bounded = withTurnlessSteps(visibleEvents, visibleTurnless);
+    for (const [turnId, bounds] of conversationTurnBounds(bounded)) {
+      const store = visibleStepStores.get(turnId);
+      if (store && !store.loading && !store.error && !stepStoreHasOlder(store, bounds)) {
+        if (!store.events.some((event) => CONTENT_STEP_TYPES.has(event.type))) continue;
+      }
+      const state = store ? store.loading ? "loading" : store.error ? "error" : stepStoreHasOlder(store, bounds) ? "partial" : "complete" : bounds.hidden ? "idle" : null;
+      if (state === null) continue;
+      markers.set(turnId, { state, ...liveSteps ? turnStepHandle(turnId) : RETAINED_VIEW_STEPS });
+    }
+    return markers;
+  }, [fullReplay, visibleEvents, visibleTurnless, visibleStepStores, liveSteps, turnStepHandle]);
+  const timeline = useMemo2(() => {
+    const witness = questionEvidence?.client === client && questionEvidence.streamKey === streamKey && visibleEvents.some((event) => event.sequence === questionEvidence.anchor) ? questionEvidence.events : EMPTY_EVENTS;
+    const timelineOptions = {
+      partialStart: visibleHasOlder || visibleTruncated || after > 0,
+      ...turnSteps ? { turnSteps } : {},
+      ...liveSteps ? { toolOutputs: toolOutputs.reader } : {}
+    };
+    if (witness.length === 0) return buildTimeline(t, loadedEvents, timelineOptions);
+    const ids = new Set(loadedEvents.map((event) => event.id));
+    return buildTimeline(
+      t,
+      [...loadedEvents, ...witness.filter((event) => !ids.has(event.id))],
+      timelineOptions
+    );
+  }, [
+    loadedEvents,
+    visibleEvents,
+    visibleHasOlder,
+    visibleTruncated,
+    after,
+    questionEvidence,
+    client,
+    streamKey,
+    turnSteps,
+    liveSteps,
+    toolOutputs.reader,
+    t
+  ]);
+  useEffect2(() => {
+    if (fullReplay || !sessionId || !identityMatches || !initialHistoryReady) return;
+    const resolved = new Set(presentedOutputs.keys());
+    const collect = (events) => {
+      for (const event of events) {
+        if (event.type !== "agent.toolCall.output" || isToolOutputPreviewEvent(event)) continue;
+        const id = event.payload?.id;
+        if (typeof id === "string") resolved.add(id);
+      }
+    };
+    collect(eventWindow.events);
+    for (const store of stepStores.values()) collect(store.events);
+    const requested = presentedRequestedRef.current;
+    let inFlight = 0;
+    for (const request of requested.values()) if (request.pending) inFlight += 1;
+    const room = PRESENTED_OUTPUT_READS_PER_PASS - inFlight;
+    if (room <= 0) return;
+    const missing = [];
+    for (const event of eventWindow.events) {
+      if (event.type !== "agent.toolCall.created") continue;
+      const payload = event.payload;
+      const callId = payload?.id;
+      if (typeof callId !== "string" || resolved.has(callId) || requested.has(callId) || !isPresentedSessionToolCall(payload)) {
+        continue;
+      }
+      missing.push({ callId, sequence: event.sequence, turnId: event.turnId ?? null });
+    }
+    if (missing.length === 0) return;
+    const bounds = conversationTurnBounds(eventWindow.events);
+    for (const { callId, sequence, turnId } of missing.slice(-room)) {
+      const request = { turnId, pending: true };
+      requested.set(callId, request);
+      const isCurrent = () => presentedRequestedRef.current === requested && requested.get(callId) === request;
+      const terminal = turnId ? bounds.get(turnId)?.terminal ?? null : null;
+      void findPresentedOutput(client, workspaceId, sessionId, callId, sequence, terminal).then(
+        (output) => {
+          if (!ownsNavigation() || !isCurrent()) return;
+          request.pending = false;
+          if (output) setPresentedOutputs((current) => new Map(current).set(callId, output));
+          setPresentedPass((pass) => pass + 1);
+        },
+        () => {
+          if (!isCurrent()) return;
+          requested.delete(callId);
+          const failures = (presentedFailuresRef.current.get(callId) ?? 0) + 1;
+          presentedFailuresRef.current.set(callId, failures);
+          if (failures > PRESENTED_OUTPUT_RETRIES) return;
+          setTimeout(() => {
+            if (ownsNavigation()) setPresentedPass((pass) => pass + 1);
+          }, PRESENTED_OUTPUT_RETRY_MS * failures);
+        }
+      );
+    }
+  }, [
+    fullReplay,
+    sessionId,
+    identityMatches,
+    initialHistoryReady,
+    eventWindow,
+    stepStores,
+    presentedOutputs,
+    presentedPass,
+    client,
+    workspaceId,
+    ownsNavigation
+  ]);
+  return {
+    events: loadedEvents,
+    timeline,
+    sessionStatus: showRetained ? retainedTail.sessionStatus : identityMatches ? sessionStatusProjection : null,
+    sessionStatusSequence: identityMatches ? sessionStatusRef.current.sequence : 0,
+    connectionState: identityMatches ? connectionState : "idle",
+    lastSequence: identityMatches ? lastSequenceRef.current : after,
+    windowBytes: identityMatches ? eventWindow.bytes : 2,
+    windowTruncated: identityMatches ? eventWindow.truncated : false,
+    initialLoading: fullReplay || showRetained ? false : identityMatches ? initialLoading : true,
+    initialHistoryReady: identityMatches && initialHistoryReady,
+    hasOlder: visibleHasOlder,
+    loadingOlder: !identityMatches ? false : loadingOlder,
+    loadOlder,
+    hasNewer: !identityMatches ? false : hasNewer,
+    loadingNewer: !identityMatches ? false : loadingNewer,
+    loadNewer,
+    loadingOldest: !identityMatches ? false : loadingOldest,
+    loadOldest,
+    loadingLatest: !identityMatches ? false : loadingLatest,
+    jumpToLatest,
+    jumpToLatestQuestion,
+    jumpToSequence,
+    loadingTarget: identityMatches && loadingTarget,
+    error: identityMatches ? newerError ?? error : null
+  };
+}
+function boundBrowserSessionEventWindow(events, options = {}) {
+  const maxBytes = Math.max(1024, options.maxBytes ?? SESSION_EVENT_BROWSER_MAX_BYTES);
+  const maxCount = Math.max(1, Math.floor(options.maxCount ?? SESSION_EVENT_BROWSER_MAX_COUNT));
+  const safe = events;
+  const selected = [];
+  let bytes = 2;
+  const direction = options.direction ?? "newest";
+  const start = direction === "newest" ? safe.length - 1 : 0;
+  const end = direction === "newest" ? Math.max(-1, safe.length - maxCount - 1) : safe.length;
+  const step = direction === "newest" ? -1 : 1;
+  for (let index = start; index !== end && selected.length < maxCount; index += step) {
+    const event = safe[index];
+    const eventBytes = browserJsonBytes(event);
+    const separator = selected.length === 0 ? 0 : 1;
+    if (selected.length > 0 && bytes + separator + eventBytes > maxBytes) break;
+    selected.push(event);
+    bytes += separator + eventBytes;
+  }
+  if (direction === "newest") selected.reverse();
+  return {
+    events: selected,
+    bytes,
+    truncated: selected.length < safe.length
+  };
+}
+function appendBrowserSessionEventWindow(current, batch, options = {}) {
+  const maxBytes = Math.max(1024, options.maxBytes ?? SESSION_EVENT_BROWSER_MAX_BYTES);
+  const maxCount = Math.max(1, Math.floor(options.maxCount ?? SESSION_EVENT_BROWSER_MAX_COUNT));
+  const events = [...current.events, ...batch];
+  let bytes = current.bytes;
+  for (let index = 0; index < batch.length; index += 1) {
+    bytes += browserJsonBytes(batch[index]) + (current.events.length + index > 0 ? 1 : 0);
+  }
+  let start = 0;
+  while (events.length - start > 1 && (bytes > maxBytes || events.length - start > maxCount)) {
+    bytes -= browserJsonBytes(events[start]) + 1;
+    start += 1;
+  }
+  return {
+    events: start === 0 ? events : events.slice(start),
+    bytes,
+    truncated: current.truncated || start > 0
+  };
+}
+function browserJsonBytes(value) {
+  return encoder.encode(JSON.stringify(value)).byteLength;
+}
+function observeSessionStatus(events, ref) {
+  let latest = null;
+  for (const event of events) {
+    const status = sessionStatusFromEvents([event]);
+    if (status && (!latest || event.sequence >= latest.sequence)) {
+      latest = { sequence: event.sequence, status };
+    }
+  }
+  if (!latest || latest.sequence < ref.current.sequence) return void 0;
+  ref.current = latest;
+  return latest.status;
+}
+async function loadConversationCatchup(client, workspaceId, sessionId, cursor, head, options) {
+  const events = [];
+  let after = cursor;
+  for (let fetch = 0; fetch < CATCHUP_MAX_PAGES; fetch += 1) {
+    if (options.signal?.aborted) throw abortError();
+    const page = await readConversationPage(client, workspaceId, sessionId, {
+      after,
+      before: head + 1,
+      direction: "after",
+      limit: SESSION_HISTORY_PAGE_SIZE,
+      compact: true,
+      payloadMode: "full"
+    });
+    if (!options.isCurrent()) throw abortError();
+    options.progress?.();
+    const fresh = page.filter((event) => eventResumeSequence(event) > after);
+    assertAscending(fresh);
+    events.push(...fresh);
+    if (page.raw.newest === null || page.raw.newest <= after) return events;
+    after = page.raw.newest;
+    if (after >= head || page.hasMore === false) return events;
+  }
+  return null;
+}
+async function loadEventWindow(t, client, workspaceId, sessionId, options) {
+  let cursor = options.before;
+  let buffer = [];
+  let reachedStart = false;
+  let fetches = 0;
+  let filteredPages = 0;
+  let rawNewest = 0;
+  const counts = (page) => {
+    rawNewest = Math.max(rawNewest, page.raw.newest ?? 0);
+    return page.length > 0 || (filteredPages += 1) > (options.filteredPageCap ?? 0);
+  };
+  while (fetches < options.maxFetches) {
+    if (buffer.length > 0 && groupCount(t, buffer) >= options.targetGroups) {
+      break;
+    }
+    const page = await loadPreviousPage(client, workspaceId, sessionId, cursor, {
+      pageSize: options.pageSize,
+      filter: options.filter,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    if (options.isCurrent?.() === false) throw abortError();
+    options.progress?.();
+    if (page.raw.oldest === null) {
+      reachedStart = true;
+      break;
+    }
+    if (counts(page)) fetches += 1;
+    assertAscending(page);
+    buffer = [...page, ...buffer];
+    cursor = page.raw.oldest;
+    if (page.raw.oldest <= 1 || page[0] !== void 0 && isLogStart(page[0])) {
+      reachedStart = true;
+      break;
+    }
+  }
+  let snapPages = 0;
+  while (!reachedStart && findBoundaryIndex(buffer) === -1 && snapPages < (options.boundaryPageCap ?? 0)) {
+    const page = await loadPreviousPage(client, workspaceId, sessionId, cursor, {
+      pageSize: options.pageSize,
+      filter: options.filter,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    if (options.isCurrent?.() === false) throw abortError();
+    options.progress?.();
+    if (page.raw.oldest === null) {
+      reachedStart = true;
+      break;
+    }
+    if (counts(page)) {
+      fetches += 1;
+      snapPages += 1;
+    }
+    assertAscending(page);
+    buffer = [...page, ...buffer];
+    cursor = page.raw.oldest;
+    if (page.raw.oldest <= 1 || page[0] !== void 0 && isLogStart(page[0])) {
+      reachedStart = true;
+      break;
+    }
+  }
+  if (!reachedStart) {
+    const boundary = findBoundaryIndex(buffer);
+    if (boundary > 0) {
+      buffer = buffer.slice(boundary);
+    }
+  }
+  const densityWindow = trimBackwardToGroupTarget(t, buffer, options.targetGroups);
+  buffer = densityWindow.events;
+  const oldest = buffer[0] ?? null;
+  const newest = buffer[buffer.length - 1] ?? null;
+  return {
+    events: buffer,
+    oldestSequence: oldest?.sequence ?? null,
+    // A window that kept nothing resumes a live stream above the rows it read,
+    // not at the start of history. Otherwise rows dropped above its newest
+    // kept row are replayed (or caught up) into their turn's steps, so a
+    // working turn's latest tool calls still show.
+    newestSequence: newest ? maxResumeSequence(buffer) : rawNewest,
+    // An empty window that stopped before the start is still pageable.
+    hasOlder: buffer.length > 0 ? densityWindow.trimmed || !reachedStart && oldest?.type !== "session.created" : !reachedStart,
+    scanCursor: cursor
+  };
+}
+function findBoundaryIndex(events) {
+  for (let index = 0; index < events.length; index += 1) {
+    if (isTurnBoundary(events[index])) {
+      return index;
+    }
+  }
+  return -1;
+}
+function isTurnBoundary(event) {
+  return event.type === "session.created" || event.type === "user.message";
+}
+async function loadForwardEventWindow(t, client, workspaceId, sessionId, options) {
+  let cursor = options.after;
+  let buffer = [];
+  let fetches = 0;
+  let reachedEnd = false;
+  let filteredPages = 0;
+  while (fetches < options.maxFetches) {
+    if (buffer.length > 0 && groupCount(t, buffer) >= options.targetGroups) {
+      break;
+    }
+    const page = await loadNextPage(client, workspaceId, sessionId, cursor, {
+      pageSize: options.pageSize,
+      filter: options.filter,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    if (options.isCurrent?.() === false) throw abortError();
+    if (page.raw.newest === null) {
+      reachedEnd = true;
+      break;
+    }
+    if (page.length > 0 || (filteredPages += 1) > (options.filteredPageCap ?? 0)) fetches += 1;
+    assertAscending(page);
+    buffer = [...buffer, ...page];
+    cursor = page.raw.newest;
+  }
+  const densityWindow = trimForwardToGroupTarget(t, buffer, options.targetGroups);
+  buffer = densityWindow.events;
+  const oldest = buffer[0] ?? null;
+  const newest = buffer[buffer.length - 1] ?? null;
+  return {
+    events: buffer,
+    oldestSequence: oldest?.sequence ?? null,
+    newestSequence: newest ? maxResumeSequence(buffer) : 0,
+    // An empty window that stopped before the end is still pageable.
+    hasNewer: buffer.length > 0 ? densityWindow.trimmed || !reachedEnd : !reachedEnd,
+    scanCursor: cursor
+  };
+}
+function trimBackwardToGroupTarget(t, events, targetGroups) {
+  if (!Number.isFinite(targetGroups) || targetGroups <= 0 || events.length === 0) {
+    return { events, trimmed: false };
+  }
+  for (let index = events.length - 1; index > 0; index -= 1) {
+    if (!isTurnBoundary(events[index])) continue;
+    const candidate = events.slice(index);
+    if (groupCount(t, candidate) >= targetGroups) {
+      return { events: candidate, trimmed: true };
+    }
+  }
+  return { events, trimmed: false };
+}
+function trimForwardToGroupTarget(t, events, targetGroups) {
+  if (!Number.isFinite(targetGroups) || targetGroups <= 0 || events.length === 0) {
+    return { events, trimmed: false };
+  }
+  for (let index = 1; index < events.length; index += 1) {
+    if (!isTurnBoundary(events[index])) continue;
+    const candidate = events.slice(0, index);
+    if (groupCount(t, candidate) >= targetGroups) {
+      return { events: candidate, trimmed: true };
+    }
+  }
+  return { events, trimmed: false };
+}
+function rawPageExtent(events) {
+  return events.length === 0 ? { oldest: null, newest: null } : { oldest: events[0].sequence, newest: maxResumeSequence(events) };
+}
+function historyPage(events, requested, raw = rawPageExtent(events)) {
+  return Object.assign(events, { requested, raw });
+}
+async function loadPreviousPage(client, workspaceId, sessionId, before, options) {
+  if (options.signal?.aborted) {
+    throw abortError();
+  }
+  const requested = options.pageSize;
+  if (requested === 0) {
+    return historyPage([], requested);
+  }
+  const read = {
+    before,
+    limit: requested,
+    compact: true,
+    // Monitoring summaries omit correlation fields once a bounded durable
+    // payload exceeds their preview threshold. The browser timeline needs the
+    // exact stored payload so persisted tool outputs still match their
+    // calls and expose truthful truncation telemetry after a reload.
+    payloadMode: "full"
+  };
+  const page = options.filter ? await readConversationPage(client, workspaceId, sessionId, read) : historyPage(await client.listEvents(workspaceId, sessionId, read), requested);
+  if (options.signal?.aborted) {
+    throw abortError();
+  }
+  return Object.assign(page, { requested });
+}
+async function loadNextPage(client, workspaceId, sessionId, after, options) {
+  if (options.signal?.aborted) {
+    throw abortError();
+  }
+  const requested = options.pageSize;
+  if (requested === 0) {
+    return historyPage([], requested);
+  }
+  const read = {
+    ...options.before !== void 0 ? { before: options.before } : {},
+    after,
+    limit: requested,
+    compact: true,
+    direction: "after",
+    payloadMode: "full"
+  };
+  const page = options.filter ? await readConversationPage(client, workspaceId, sessionId, read) : historyPage(await client.listEvents(workspaceId, sessionId, read), requested);
+  if (options.signal?.aborted) {
+    throw abortError();
+  }
+  return Object.assign(page, { requested });
+}
+function groupCount(t, events) {
+  if (events.length === 0) {
+    return 0;
+  }
+  return groupTimeline(t, buildTimeline(t, events)).length;
+}
+function isLogStart(event) {
+  return event.type === "session.created" || event.sequence <= 1;
+}
+function maxResumeSequence(events) {
+  return events.reduce((max, event) => Math.max(max, eventResumeSequence(event)), 0);
+}
+function maxResumeSequenceOrNull(events) {
+  return events.length > 0 ? maxResumeSequence(events) : null;
+}
+function eventResumeSequence(event) {
+  const streamedCoverage = sessionEventStreamCoveredThrough(event);
+  if (streamedCoverage !== null) return streamedCoverage;
+  return typeof event.coveredThrough === "number" && Number.isSafeInteger(event.coveredThrough) && event.coveredThrough >= event.sequence ? event.coveredThrough : event.sequence;
+}
+function assertAscending(events) {
+  for (let index = 1; index < events.length; index += 1) {
+    if (events[index - 1].sequence >= events[index].sequence) {
+      throw new Error("@opengeni/react: session events must be ordered by ascending sequence");
+    }
+  }
+}
+function assertPrependOrder(existing, older) {
+  if (!shouldAssertDevelopment() || existing.length === 0 || older.length === 0) {
+    return;
+  }
+  if (older[older.length - 1].sequence >= existing[0].sequence) {
+    throw new Error("@opengeni/react: loadOlder returned overlapping session events");
+  }
+}
+function assertAppendOrder(existing, newer) {
+  if (!shouldAssertDevelopment() || existing.length === 0 || newer.length === 0) {
+    return;
+  }
+  if (newer[0].sequence <= existing[existing.length - 1].sequence) {
+    throw new Error("@opengeni/react: loadNewer returned overlapping session events");
+  }
+}
+function shouldAssertDevelopment() {
+  const processEnv = globalThis.process?.env;
+  return processEnv !== void 0 && processEnv.NODE_ENV !== "production";
+}
+function abortError() {
+  const error = new Error("The operation was aborted.");
+  error.name = "AbortError";
+  return error;
+}
+function abortableDelay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(abortError());
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError());
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var CONTENT_STEP_TYPES = new Set(SESSION_EVENT_CONTENT_STEP_TYPES);
+var COMPAT_EXCLUDED_TYPES = new Set(
+  SESSION_EVENT_COMPAT_EXCLUDED_STEP_TYPES
+);
+var CONVERSATION_FILTER = "conversation";
+var SESSION_TURN_STEP_PAGE_SIZE = 200;
+var SESSION_TURN_LIVE_STEP_TAIL = 200;
+var SESSION_TURN_LIVE_STEP_TAIL_BYTES = 2 * 1024 * 1024;
+var TURNLESS_STEP_TAIL = 1e3;
+var TURNLESS_STEP_TAIL_BYTES = 4 * 1024 * 1024;
+var TURN_STEP_READ_TYPES = SESSION_EVENT_STEP_TYPES.filter(
+  (type) => type !== "terminal.pty.output.delta"
+);
+var SESSION_STEP_BROWSER_MAX_BYTES = 16 * 1024 * 1024;
+var TERMINAL_TURN_TYPES = /* @__PURE__ */ new Set([
+  "turn.completed",
+  "turn.failed",
+  "turn.cancelled",
+  "turn.superseded"
+]);
+var EMPTY_STEP_STORES = /* @__PURE__ */ new Map();
+var EMPTY_TURNLESS_STEPS = { events: [], bytes: 2, ranges: [], appended: 0 };
+var TURNLESS_STEP_MAX_RANGES = 4096;
+function appendTurnlessSteps(current, incoming) {
+  const ranges = current.ranges.map((range) => [range[0], range[1]]);
+  for (const event of incoming) {
+    const sequence = event.sequence;
+    const last = ranges.at(-1);
+    if (last && sequence >= last[0] && sequence <= last[1]) continue;
+    if (last && sequence === last[1] + 1) last[1] = sequence;
+    else if (!last || sequence > last[1]) ranges.push([sequence, sequence]);
+    else if (!ranges.some(([first, end]) => sequence >= first && sequence <= end)) {
+      ranges.push([sequence, sequence]);
+      ranges.sort((left, right) => left[0] - right[0]);
+    }
+  }
+  if (ranges.length > TURNLESS_STEP_MAX_RANGES) {
+    ranges.splice(0, ranges.length - TURNLESS_STEP_MAX_RANGES);
+  }
+  const next = appendStepEvents(current, incoming);
+  const appended = current.appended + incoming.length;
+  if (next.events.length <= TURNLESS_STEP_TAIL && next.bytes <= TURNLESS_STEP_TAIL_BYTES) {
+    return { ...next, ranges, appended };
+  }
+  const kept = boundBrowserSessionEventWindow(next.events, {
+    maxCount: TURNLESS_STEP_TAIL,
+    maxBytes: TURNLESS_STEP_TAIL_BYTES
+  });
+  return { events: kept.events, bytes: kept.bytes, ranges, appended };
+}
+function withTurnlessSteps(window2, turnless) {
+  const first = window2[0]?.sequence;
+  if (first === void 0 || turnless.ranges.length === 0) return window2;
+  const placeholders = [];
+  for (const [start, end] of turnless.ranges) {
+    if (end < first) continue;
+    placeholders.push({
+      id: `turnless-steps-${start}`,
+      workspaceId: window2[0].workspaceId,
+      sessionId: window2[0].sessionId,
+      sequence: start,
+      coveredThrough: end,
+      type: "terminal.pty.output.delta",
+      payload: null,
+      occurredAt: window2[0].occurredAt,
+      turnId: null
+    });
+  }
+  if (placeholders.length === 0) return window2;
+  return [...window2, ...placeholders].sort((left, right) => left.sequence - right.sequence);
+}
+function turnStepLowerBound(bounds) {
+  return bounds.started !== null ? bounds.started - 1 : bounds.previous;
+}
+function stepStoreHasOlder(store, bounds) {
+  return store.hasOlder || store.floor !== null && turnStepLowerBound(bounds) < store.floor;
+}
+function isConversationHistoryEvent(event, presentedCallIds, startupTurns) {
+  if (event.turnId) {
+    if (event.type === "agent.model.usage") return startupTurns === void 0;
+    if (event.type === "agent.model.request") {
+      return startupTurns === void 0 || startupTurns.has(event.turnId);
+    }
+  }
+  if (!CONTENT_STEP_TYPES.has(event.type)) return true;
+  const payload = event.payload;
+  if (event.type === "agent.toolCall.created") return isPresentedSessionToolCall(payload);
+  if (event.type === "agent.toolCall.output") {
+    return typeof payload?.id === "string" && presentedCallIds.has(payload.id);
+  }
+  return false;
+}
+function emptyStartupTurns() {
+  return { window: null, open: /* @__PURE__ */ new Set(), responded: /* @__PURE__ */ new Set() };
+}
+function noteStartupTurns(events, state) {
+  for (const event of events) {
+    const turnId = event.turnId;
+    if (!turnId) continue;
+    if (event.type === "turn.started") {
+      if (!state.responded.has(turnId)) state.open.add(turnId);
+    } else if (event.type === "agent.model.request" && isSessionModelResponsePhase(event.payload?.phase)) {
+      state.open.delete(turnId);
+      state.responded.add(turnId);
+    }
+  }
+}
+var conversationFilterModes = /* @__PURE__ */ new WeakMap();
+var CONVERSATION_READS = {
+  v2: { excludeTypes: [...SESSION_EVENT_STEP_TYPES], presentedToolCalls: "include" },
+  compat: {
+    excludeTypes: [...SESSION_EVENT_COMPAT_EXCLUDED_STEP_TYPES],
+    presentedToolCalls: "include"
+  }
+};
+function conversationFilterMode(client) {
+  if (typeof client.listEventPage !== "function") {
+    return "compat";
+  }
+  return conversationFilterModes.get(client) ?? "v2";
+}
+async function readConversationPage(client, workspaceId, sessionId, options) {
+  let mode = conversationFilterMode(client);
+  for (; ; ) {
+    const read = await readEventPage(client, workspaceId, sessionId, {
+      ...CONVERSATION_READS[mode],
+      ...options
+    });
+    const announced = (read.conversationFilter ?? 0) >= SESSION_EVENT_CONVERSATION_FILTER_VERSION;
+    if (read.conversationFilter !== void 0) {
+      conversationFilterModes.set(client, announced ? "v2" : "compat");
+    }
+    if (mode === "v2" && !announced) {
+      mode = "compat";
+      continue;
+    }
+    const events = mode === "compat" ? read.events.filter(isCompatConversationEvent) : read.events;
+    return Object.assign(events === read.events ? [...events] : events, {
+      requested: options.limit,
+      raw: rawPageExtent(read.events),
+      hasMore: read.hasMore
+    });
+  }
+}
+function isCompatConversationEvent(event) {
+  if (COMPAT_EXCLUDED_TYPES.has(event.type)) return false;
+  if (event.type !== "agent.toolCall.created") return true;
+  return isPresentedSessionToolCall(event.payload);
+}
+function notePresentedCalls(events, ids) {
+  for (const event of events) {
+    if (event.type !== "agent.toolCall.created") continue;
+    const payload = event.payload;
+    if (typeof payload?.id === "string" && isPresentedSessionToolCall(payload)) {
+      ids.add(payload.id);
+    }
+  }
+}
+function conversationTurnBounds(events) {
+  const bounds = /* @__PURE__ */ new Map();
+  const gaps = [];
+  let expected = null;
+  let previous = 0;
+  for (const event of events) {
+    if (expected !== null && event.sequence > expected) gaps.push(expected);
+    const resume = eventResumeSequence(event);
+    expected = Math.max(expected ?? 0, resume + 1);
+    const turnId = event.turnId;
+    if (!turnId) continue;
+    const current = bounds.get(turnId);
+    if (!current) {
+      bounds.set(turnId, {
+        first: event.sequence,
+        started: event.type === "turn.started" ? event.sequence : null,
+        previous,
+        last: resume,
+        terminal: TERMINAL_TURN_TYPES.has(event.type) ? event.sequence : null,
+        hidden: false
+      });
+    } else {
+      current.last = Math.max(current.last, resume);
+      if (event.type === "turn.started" && current.started === null) {
+        current.started = event.sequence;
+      }
+      if (TERMINAL_TURN_TYPES.has(event.type)) current.terminal = event.sequence;
+    }
+    if (!PRE_START_TURN_TYPES.has(event.type)) previous = resume;
+  }
+  for (const turn of bounds.values()) {
+    let low = 0;
+    let high = gaps.length;
+    while (low < high) {
+      const middle = low + high >> 1;
+      if (gaps[middle] <= turn.first) low = middle + 1;
+      else high = middle;
+    }
+    turn.hidden = low < gaps.length && gaps[low] < turn.last;
+  }
+  return bounds;
+}
+function activeConversationTurn(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (!event.turnId) continue;
+    if (TERMINAL_TURN_TYPES.has(event.type)) return null;
+    if (event.type === "turn.started") return event.turnId;
+  }
+  return null;
+}
+function settledTurns(events) {
+  const settled = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.turnId && TERMINAL_TURN_TYPES.has(event.type)) settled.add(event.turnId);
+  }
+  return settled;
+}
+function windowTurns(events) {
+  const turns = /* @__PURE__ */ new Set();
+  for (const event of events) if (event.turnId) turns.add(event.turnId);
+  return turns;
+}
+var EMPTY_PRESENTED_OUTPUTS = /* @__PURE__ */ new Map();
+var PRE_START_TURN_TYPES = /* @__PURE__ */ new Set(["turn.queued", "turn.capacity_waiting"]);
+var PRESENTED_OUTPUT_READS_PER_PASS = 8;
+var PRESENTED_OUTPUT_PAGE_SIZE = 16;
+var PRESENTED_OUTPUT_MAX_PAGES = 16;
+var PRESENTED_OUTPUT_RETRIES = 3;
+var PRESENTED_OUTPUT_RETRY_MS = 2e3;
+var RETAINED_VIEW_STEPS = {
+  load: () => {
+  },
+  retain: () => () => {
+  }
+};
+function mergeLoadedEvents(conversation, stores, presented, turnless, exactOutputs = EMPTY_PRESENTED_OUTPUTS) {
+  if (stores.size === 0 && presented.size === 0 && turnless.length === 0 && exactOutputs.size === 0) {
+    return conversation;
+  }
+  const turns = windowTurns(conversation);
+  const ids = new Set(conversation.map((event) => event.id));
+  const extra = [];
+  const add = (event) => {
+    if (ids.has(event.id) || !event.turnId || !turns.has(event.turnId)) return;
+    ids.add(event.id);
+    extra.push(event);
+  };
+  presented.forEach(add);
+  exactOutputs.forEach(add);
+  for (const [turnId, store] of stores) if (turns.has(turnId)) store.events.forEach(add);
+  for (const event of turnless) {
+    if (ids.has(event.id)) continue;
+    ids.add(event.id);
+    extra.push(event);
+  }
+  if (extra.length === 0) return conversation;
+  return [...conversation, ...extra].sort((left, right) => left.sequence - right.sequence);
+}
+function groupByTurn(events) {
+  const turns = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (!event.turnId) continue;
+    const list = turns.get(event.turnId);
+    if (list) list.push(event);
+    else turns.set(event.turnId, [event]);
+  }
+  return turns;
+}
+function appendStepEvents(store, incoming) {
+  if (incoming.length === 0) return { events: store.events, bytes: store.bytes };
+  const ids = new Set(store.events.map((event) => event.id));
+  let bytes = store.bytes;
+  const fresh = [];
+  for (const event of incoming) {
+    if (ids.has(event.id)) continue;
+    ids.add(event.id);
+    fresh.push(event);
+    bytes += browserJsonBytes(event) + (store.events.length + fresh.length > 1 ? 1 : 0);
+  }
+  if (fresh.length === 0) return { events: store.events, bytes: store.bytes };
+  const last = store.events[store.events.length - 1];
+  const events = [...store.events, ...fresh];
+  if (last && fresh.some((event) => event.sequence < last.sequence)) {
+    events.sort((left, right) => left.sequence - right.sequence);
+  } else if (!last) {
+    events.sort((left, right) => left.sequence - right.sequence);
+  }
+  return { events, bytes };
+}
+function turnHasHiddenSequences(events, turnId, before) {
+  const start = events.findIndex((event) => event.turnId === turnId);
+  if (start < 0) return true;
+  let expected = eventResumeSequence(events[start]) + 1;
+  for (let index = start + 1; index < events.length; index += 1) {
+    const event = events[index];
+    if (event.sequence >= before) break;
+    if (event.sequence > expected) return true;
+    expected = Math.max(expected, eventResumeSequence(event) + 1);
+  }
+  return expected < before;
+}
+function trimLiveStepTail(store) {
+  if (store.events.length <= SESSION_TURN_LIVE_STEP_TAIL && store.bytes <= SESSION_TURN_LIVE_STEP_TAIL_BYTES) {
+    return store;
+  }
+  const kept = boundBrowserSessionEventWindow(store.events, {
+    maxCount: SESSION_TURN_LIVE_STEP_TAIL,
+    maxBytes: SESSION_TURN_LIVE_STEP_TAIL_BYTES
+  });
+  return { ...store, events: kept.events, bytes: kept.bytes, hasOlder: true, cursor: null };
+}
+function boundStepStores(stores, retained) {
+  let total = 0;
+  for (const [turnId, store] of stores) {
+    if (!retained.get(turnId)) total += store.bytes;
+  }
+  if (total <= SESSION_STEP_BROWSER_MAX_BYTES) return stores;
+  const candidates = [...stores].filter(([turnId, store]) => !retained.get(turnId) && !store.loading).sort((left, right) => left[1].touched - right[1].touched);
+  for (const [turnId, store] of candidates) {
+    if (total <= SESSION_STEP_BROWSER_MAX_BYTES) break;
+    stores.delete(turnId);
+    total -= store.bytes;
+  }
+  return stores;
+}
+async function findPresentedOutput(client, workspaceId, sessionId, callId, after, terminal) {
+  let cursor = after;
+  for (let page = 0; page < PRESENTED_OUTPUT_MAX_PAGES; page += 1) {
+    const read = await readEventPage(client, workspaceId, sessionId, {
+      includeTypes: ["agent.toolCall.output"],
+      after: cursor,
+      ...terminal !== null ? { before: terminal + 1 } : {},
+      direction: "after",
+      limit: PRESENTED_OUTPUT_PAGE_SIZE,
+      payloadMode: "full"
+    });
+    const output = read.events.find(
+      (event) => event.payload?.id === callId
+    );
+    if (output) return output;
+    const last = read.events.at(-1);
+    if (!last || !(read.hasMore ?? read.events.length >= PRESENTED_OUTPUT_PAGE_SIZE)) return null;
+    cursor = last.sequence;
+  }
+  return null;
+}
+async function readEventPage(client, workspaceId, sessionId, options) {
+  const pageClient = client;
+  if (typeof pageClient.listEventPage === "function") {
+    const page = await pageClient.listEventPage(workspaceId, sessionId, options);
+    return {
+      events: page.events,
+      hasMore: page.hasMore,
+      // An SDK that predates the announcement reports nothing: treat it as none.
+      conversationFilter: page.conversationFilter ?? null
+    };
+  }
+  return { events: await client.listEvents(workspaceId, sessionId, options), hasMore: null };
+}
+
+// src/hooks/use-turn-queue.ts
+import { isTransientRequestError as isTransientRequestError2 } from "@opengeni/sdk";
+import { useCallback as useCallback4, useEffect as useEffect3, useLayoutEffect, useMemo as useMemo3, useRef as useRef3, useState as useState3 } from "react";
+function isTurnQueueEvent(event) {
+  return event.type.startsWith("turn.") || event.type.startsWith("session.queue.") || event.type.startsWith("session.control.") || event.type.startsWith("system.update.") || event.type.startsWith("workspace.inference.");
+}
+function queueSnapshotCovers(candidate, observed) {
+  return Boolean(
+    candidate && candidate.version >= observed.version && candidate.effectiveControl.controlVersion >= observed.effectiveControl.controlVersion
+  );
+}
+var EMPTY_PENDING_BY_TURN = {};
+function useTurnQueue(sessionId, options = {}) {
+  const t = useOpenGeniText();
+  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSession(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const targetKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const pageLive = usePageLiveActivity();
+  const pageLiveRef = useRef3(pageLive);
+  pageLiveRef.current = pageLive;
+  const [snapshot, setSnapshot] = useState3(null);
+  const [stateTargetKey, setStateTargetKey] = useState3(targetKey);
+  const [loading, setLoading] = useState3(enabled);
+  const [error, setError] = useState3(null);
+  const [mutationError, setMutationError] = useState3(null);
+  const [pendingByTurn, setPendingByTurn] = useState3({});
+  const [acceptedSteers, setAcceptedSteers] = useState3([]);
+  const pendingRef = useRef3({});
+  const readGeneration = useRef3(0);
+  const targetKeyRef = useRef3(targetKey);
+  const snapshotRef = useRef3(null);
+  const transientStreakRef = useRef3(
+    null
+  );
+  const transientRetryTimerRef = useRef3(null);
+  const cancelTransientRetry = useCallback4(() => {
+    if (transientRetryTimerRef.current !== null) {
+      clearTimeout(transientRetryTimerRef.current);
+      transientRetryTimerRef.current = null;
+    }
+  }, []);
+  useLayoutEffect(() => {
+    if (targetKeyRef.current === targetKey) return;
+    targetKeyRef.current = targetKey;
+    readGeneration.current += 1;
+    snapshotRef.current = null;
+    pendingRef.current = {};
+    setStateTargetKey(targetKey);
+    setSnapshot(null);
+    setLoading(enabled);
+    setError(null);
+    transientStreakRef.current = null;
+    cancelTransientRetry();
+    setMutationError(null);
+    setPendingByTurn({});
+    setAcceptedSteers([]);
+  }, [cancelTransientRetry, enabled, targetKey]);
+  useEffect3(() => {
+    if (acceptedSteers.length === 0 || options.events === void 0) return;
+    const durablyConsumedTurnIds = new Set(
+      options.events.flatMap(
+        (event) => [
+          "turn.started",
+          "turn.superseded",
+          "turn.cancelled",
+          "turn.failed",
+          "turn.completed"
+        ].includes(event.type) && event.turnId ? [event.turnId] : []
+      )
+    );
+    if (durablyConsumedTurnIds.size === 0) return;
+    setAcceptedSteers(
+      (current) => current.filter((steer) => !durablyConsumedTurnIds.has(steer.turnId))
+    );
+  }, [acceptedSteers.length, options.events]);
+  const acceptSnapshot = useCallback4(
+    (ownedTargetKey, next) => {
+      if (targetKeyRef.current !== ownedTargetKey) return false;
+      const current = snapshotRef.current;
+      if (next && current && (next.version < current.version || next.effectiveControl.controlVersion < current.effectiveControl.controlVersion)) {
+        return false;
+      }
+      snapshotRef.current = next;
+      setStateTargetKey(ownedTargetKey);
+      setSnapshot(next);
+      return true;
+    },
+    []
+  );
+  const load = useCallback4(
+    async (rejectOnFailure = false, fresh = false) => {
+      if (!sessionId) return;
+      const ownedTargetKey = `${workspaceId}\0${sessionId}`;
+      const ticket = ++readGeneration.current;
+      try {
+        const fetched = fresh ? await client.getQueue(workspaceId, sessionId, { fresh: true }) : await client.getQueue(workspaceId, sessionId);
+        if (targetKeyRef.current !== ownedTargetKey) return;
+        transientStreakRef.current = null;
+        cancelTransientRetry();
+        const ownsLatestRead = ticket === readGeneration.current;
+        if (rejectOnFailure) {
+          const committed = acceptSnapshot(ownedTargetKey, fetched);
+          if (!committed && !queueSnapshotCovers(snapshotRef.current, fetched)) {
+            throw new TypeError("Queue reconciliation did not commit authoritative state");
+          }
+          setError(null);
+          if (ownsLatestRead) setLoading(false);
+        } else if (ownsLatestRead) {
+          acceptSnapshot(ownedTargetKey, fetched);
+          setError(null);
+          setLoading(false);
+        }
+      } catch (cause) {
+        if (targetKeyRef.current === ownedTargetKey && (ticket === readGeneration.current || rejectOnFailure)) {
+          if (isTransientRequestError2(cause)) {
+            const now = Date.now();
+            const streak = transientStreakRef.current ??= {
+              since: now,
+              attempts: 0,
+              surfaced: false
+            };
+            const step = transientReadRetryStep(streak, now, DEFAULT_TRANSIENT_READ_RETRY, cause);
+            if (!step.quiet) {
+              if (!streak.surfaced) setError(asError(cause));
+              streak.surfaced = true;
+              if (ticket === readGeneration.current) setLoading(false);
+            }
+            if (!rejectOnFailure && pageLiveRef.current) {
+              cancelTransientRetry();
+              transientRetryTimerRef.current = setTimeout(() => {
+                transientRetryTimerRef.current = null;
+                if (targetKeyRef.current === ownedTargetKey) void loadRef.current(false, fresh);
+              }, step.delayMs);
+            }
+          } else {
+            transientStreakRef.current = null;
+            setError(asError(cause));
+            if (ticket === readGeneration.current) setLoading(false);
+          }
+        }
+        if (rejectOnFailure) throw cause;
+      }
+    },
+    [client, workspaceId, sessionId, acceptSnapshot, cancelTransientRetry]
+  );
+  const loadRef = useRef3(load);
+  loadRef.current = load;
+  useEffect3(() => cancelTransientRetry, [cancelTransientRetry]);
+  useEffect3(() => {
+    if (!enabled || !pageLive) {
+      cancelTransientRetry();
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    const pollIntervalMs = options.pollIntervalMs;
+    if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
+      void load();
+      return () => {
+        readGeneration.current += 1;
+      };
+    }
+    let cancelled = false;
+    let timer = null;
+    const schedule = () => {
+      if (cancelled) return;
+      timer = setTimeout(() => {
+        timer = null;
+        void load().finally(schedule);
+      }, pollIntervalMs);
+    };
+    void load().finally(schedule);
+    return () => {
+      cancelled = true;
+      if (timer !== null) clearTimeout(timer);
+      readGeneration.current += 1;
+    };
+  }, [cancelTransientRetry, load, enabled, pageLive, options.pollIntervalMs]);
+  const loadFresh = useCallback4(() => load(false, true), [load]);
+  useEffect3(() => {
+    if (enabled && workspaceControlEvent) void loadFresh();
+  }, [enabled, loadFresh, workspaceControlEvent]);
+  useEffect3(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "queue", loadFresh);
+  }, [enabled, loadFresh, registerSessionReconciler, sessionId]);
+  const scheduleRefresh = useDebouncedCallback(() => void loadFresh());
+  const freshSnapshot = stateTargetKey === targetKey ? snapshot : null;
+  const freshLoading = stateTargetKey === targetKey ? loading : enabled;
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    isTurnQueueEvent,
+    scheduleRefresh,
+    {
+      enabled,
+      ...options.events !== void 0 ? { events: options.events } : {},
+      readThrough: projectionReadThrough(freshSnapshot, freshLoading),
+      refresh: scheduleRefresh
+    },
+    async () => await load(true, true)
+  );
+  const retainedSnapshot = useRetainedSessionView(
+    client,
+    workspaceId,
+    sessionId,
+    "queue",
+    freshSnapshot,
+    { enabled, discard: stateTargetKey === targetKey && deniesRetainedView(error) }
+  );
+  const mutate = useCallback4(
+    async (turnId, kind, command, failure = {}) => {
+      const ownedTargetKey = targetKey;
+      if (!sessionId || targetKeyRef.current !== ownedTargetKey || pendingRef.current[turnId]) {
+        return null;
+      }
+      const current = snapshotRef.current;
+      const turn = current?.items.find((candidate) => candidate.id === turnId);
+      if (!current || !turn) return null;
+      pendingRef.current = { ...pendingRef.current, [turnId]: kind };
+      setStateTargetKey(ownedTargetKey);
+      setPendingByTurn(pendingRef.current);
+      setMutationError(null);
+      const clientEventId = operationKey();
+      try {
+        let result;
+        try {
+          result = await command(current, turn, clientEventId);
+        } catch (cause) {
+          if (!isOutcomeUnknownError(cause)) throw cause;
+          result = await command(current, turn, clientEventId);
+        }
+        if (targetKeyRef.current !== ownedTargetKey) return null;
+        acceptSnapshot(ownedTargetKey, result.snapshot);
+        return result;
+      } catch (cause) {
+        if (targetKeyRef.current === ownedTargetKey) {
+          if (failure.quietWhenGone) {
+            await loadFresh();
+            const stillWaiting = snapshotRef.current?.items.some(
+              (candidate) => candidate.id === turnId
+            );
+            if (stillWaiting !== false && targetKeyRef.current === ownedTargetKey) {
+              setMutationError(asError(cause));
+            }
+          } else {
+            setMutationError(asError(cause));
+            await loadFresh();
+          }
+        }
+        return null;
+      } finally {
+        if (targetKeyRef.current === ownedTargetKey && turnId in pendingRef.current) {
+          const next = { ...pendingRef.current };
+          delete next[turnId];
+          pendingRef.current = next;
+          setPendingByTurn(next);
+        }
+      }
+    },
+    [acceptSnapshot, loadFresh, sessionId, targetKey]
+  );
+  const moveTurn = useCallback4(
+    async (turnId, beforeTurnId) => {
+      const result = await mutate(
+        turnId,
+        "move",
+        (current, _turn, clientEventId) => client.moveQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId,
+          expectedQueueVersion: current.version,
+          beforeTurnId
+        })
+      );
+      return result !== null;
+    },
+    [client, mutate, sessionId, workspaceId]
+  );
+  const editTurn = useCallback4(
+    async (turnId, edit) => {
+      const result = await mutate(
+        turnId,
+        "edit",
+        (_current, turn, clientEventId) => client.editQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId,
+          expectedTurnVersion: turn.version,
+          expectedDraftRevision: edit.expectedDraftRevision,
+          replaceDraft: edit.replaceDraft
+        })
+      );
+      return result?.draft ?? null;
+    },
+    [client, mutate, sessionId, workspaceId]
+  );
+  const recallTurn = useCallback4(
+    async (turnId, recall) => {
+      const ownedTargetKey = targetKey;
+      const known = snapshotRef.current?.items.some((candidate) => candidate.id === turnId);
+      if (known === false) return { status: "already_sent" };
+      const result = await mutate(
+        turnId,
+        "edit",
+        (_current, turn, clientEventId) => client.editQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId,
+          expectedTurnVersion: turn.version,
+          expectedDraftRevision: recall.expectedDraftRevision,
+          replaceDraft: false
+        }),
+        { quietWhenGone: true }
+      );
+      if (targetKeyRef.current !== ownedTargetKey) return { status: "failed" };
+      if (result?.draft) return { status: "recalled", draft: result.draft };
+      const stillWaiting = snapshotRef.current?.items.some((candidate) => candidate.id === turnId);
+      return result === null && stillWaiting === false ? { status: "already_sent" } : { status: "failed" };
+    },
+    [client, mutate, sessionId, targetKey, workspaceId]
+  );
+  const steerTurn = useCallback4(
+    async (turnId) => {
+      const ownedTargetKey = targetKey;
+      const turn = snapshotRef.current?.items.find((candidate) => candidate.id === turnId);
+      if (targetKeyRef.current !== ownedTargetKey) return false;
+      if (!turn) {
+        setMutationError(new Error(t("hooks.useTurnQueue.thatQueuedPromptChangedBefore")));
+        await loadFresh();
+        return false;
+      }
+      const optimistic = {
+        turnId: turn.id,
+        triggerEventId: turn.triggerEventId,
+        text: turn.prompt,
+        annotations: turn.annotations ?? [],
+        resources: turn.resources,
+        tools: turn.tools,
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        state: "sending"
+      };
+      setAcceptedSteers((current) => [
+        ...current.filter((steer) => steer.turnId !== turnId),
+        optimistic
+      ]);
+      const result = await mutate(
+        turnId,
+        "steer",
+        (current, queuedTurn, clientEventId) => client.steerQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId,
+          expectedTurnVersion: queuedTurn.version,
+          controlEtag: current.effectiveControl.controlEtag
+        })
+      );
+      if (targetKeyRef.current !== ownedTargetKey) return false;
+      const advancedWithoutSteer = result === null && snapshotRef.current !== null && !snapshotRef.current.items.some((candidate) => candidate.id === turnId);
+      if (advancedWithoutSteer) {
+        setMutationError(null);
+        setAcceptedSteers((current) => current.filter((steer) => steer.turnId !== turnId));
+        return true;
+      }
+      const accepted = result !== null || snapshotRef.current?.items.some(
+        (candidate) => candidate.id === turnId && candidate.metadata.delivery === "steer"
+      ) === true;
+      setAcceptedSteers(
+        (current) => accepted ? current.map(
+          (steer) => steer.turnId === turnId ? { ...steer, state: "queued" } : steer
+        ) : current.filter((steer) => steer.turnId !== turnId)
+      );
+      return accepted;
+    },
+    [client, loadFresh, mutate, sessionId, targetKey, workspaceId, t]
+  );
+  const removeTurn = useCallback4(
+    async (turnId) => {
+      const result = await mutate(
+        turnId,
+        "delete",
+        (_current, turn, clientEventId) => client.deleteQueueItem(workspaceId, sessionId, turnId, {
+          clientEventId,
+          expectedTurnVersion: turn.version,
+          reason: "Deleted from the prompt queue"
+        })
+      );
+      return result !== null;
+    },
+    [client, mutate, sessionId, workspaceId]
+  );
+  const identityMatches = stateTargetKey === targetKey;
+  const visibleSnapshot = freshSnapshot ?? retainedSnapshot;
+  const visiblePendingByTurn = identityMatches ? pendingByTurn : EMPTY_PENDING_BY_TURN;
+  const mutating = useMemo3(
+    () => Object.keys(visiblePendingByTurn).length > 0,
+    [visiblePendingByTurn]
+  );
+  const mutationFor = useCallback4(
+    (turnId) => visiblePendingByTurn[turnId] ?? null,
+    [visiblePendingByTurn]
+  );
+  return {
+    snapshot: visibleSnapshot,
+    queue: visibleSnapshot?.items ?? [],
+    pendingInputs: visibleSnapshot?.pendingInputs ?? [],
+    pendingInputAttachment: visibleSnapshot?.pendingInputAttachment ?? null,
+    activePersonalConnections: visibleSnapshot?.activePersonalConnections ?? [],
+    effectiveControl: visibleSnapshot?.effectiveControl ?? null,
+    stoppingPreviousAttempt: visibleSnapshot?.stoppingPreviousAttempt ?? false,
+    loading: freshLoading && retainedSnapshot === null,
+    error: identityMatches ? error : null,
+    refresh: load,
+    moveTurn,
+    editTurn,
+    recallTurn,
+    steerTurn,
+    removeTurn,
+    pendingByTurn: visiblePendingByTurn,
+    mutationFor,
+    mutating,
+    mutationError: identityMatches ? mutationError : null,
+    clearMutationError: useCallback4(() => {
+      if (targetKeyRef.current === targetKey) setMutationError(null);
+    }, [targetKey]),
+    acceptedSteers: identityMatches ? acceptedSteers : []
+  };
+}
+function operationKey() {
+  return globalThis.crypto.randomUUID();
+}
+function asError(cause) {
+  return normalizeError(cause);
+}
+function isOutcomeUnknownError(cause) {
+  return typeof cause === "object" && cause !== null && cause.outcomeUnknown === true;
+}
+
+// src/hooks/use-goal.ts
+import {
+  OpenGeniApiError,
+  observedSessionSequence
+} from "@opengeni/sdk";
+import { useCallback as useCallback5, useEffect as useEffect4, useLayoutEffect as useLayoutEffect2, useRef as useRef4, useState as useState4 } from "react";
+function isGoalEvent(event) {
+  return event.type.startsWith("goal.");
+}
+function isGoalRefreshEvent(event) {
+  const type = event.type;
+  return isGoalEvent(event) || type.startsWith("turn.") || type.startsWith("session.") || type.startsWith("system.update.") || type.startsWith("workspace.inference.") || type.startsWith("user.");
+}
+function useGoal(sessionId, options = {}) {
+  const { client, workspaceId } = useEmbeddedGoal(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const sharedEvents = options.events;
+  const sharedFeed = sharedEvents !== void 0;
+  const pageLive = usePageLiveActivity();
+  const [goal, setGoal] = useState4(null);
+  const [loading, setLoading] = useState4(enabled);
+  const [error, setError] = useState4(null);
+  const [readAbsent, setReadAbsent] = useState4(false);
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
+  const generation = useRef4(0);
+  const targetKeyRef = useRef4(null);
+  const goalAbsentRef = useRef4(false);
+  const pendingRefreshRef = useRef4("none");
+  const sharedEventsRef = useRef4(sharedEvents);
+  useLayoutEffect2(() => {
+    sharedEventsRef.current = sharedEvents;
+  }, [sharedEvents]);
+  const loadAbort = useRef4(null);
+  const scheduleRefreshRef = useRef4(() => void 0);
+  const retireLoads = useCallback5(() => {
+    generation.current += 1;
+    loadAbort.current?.abort();
+    loadAbort.current = null;
+  }, []);
+  const load = useCallback5(async () => {
+    if (!sessionId) {
+      return;
+    }
+    const ticket = ++generation.current;
+    pendingRefreshRef.current = "none";
+    loadAbort.current?.abort();
+    const controller = new AbortController();
+    loadAbort.current = controller;
+    let fetchedGoal = null;
+    try {
+      const fetched = typeof client.findGoal === "function" ? await client.findGoal(workspaceId, sessionId, { signal: controller.signal }) : await client.getGoal(workspaceId, sessionId, { signal: controller.signal });
+      fetchedGoal = fetched;
+      if (ticket === generation.current) {
+        goalAbsentRef.current = fetched === null;
+        setReadAbsent(fetched === null);
+        setGoal(fetched);
+        setError(null);
+        setLoading(false);
+      }
+    } catch (cause) {
+      if (ticket !== generation.current) {
+        return;
+      }
+      if (cause instanceof OpenGeniApiError && cause.status === 404) {
+        goalAbsentRef.current = true;
+        setReadAbsent(true);
+        setGoal(null);
+        setError(null);
+      } else {
+        setError(normalizeError(cause));
+      }
+      setLoading(false);
+    } finally {
+      if (loadAbort.current === controller) loadAbort.current = null;
+    }
+    if (ticket !== generation.current || pendingRefreshRef.current === "none") {
+      return;
+    }
+    const readThrough = fetchedGoal ? observedSessionSequence(fetchedGoal) : void 0;
+    if (readThrough !== void 0 && sharedEventsRef.current !== void 0) {
+      const events = sharedEventsRef.current;
+      const newest = events[events.length - 1];
+      if (!newest || newest.sequence <= readThrough) {
+        pendingRefreshRef.current = "none";
+        return;
+      }
+    }
+    if (goalAbsentRef.current && pendingRefreshRef.current === "refresh") {
+      const events = sharedEventsRef.current ?? [];
+      let latestGoalEvent;
+      for (let index = events.length - 1; index >= 0 && !latestGoalEvent; index -= 1) {
+        const event = events[index];
+        if (event && isGoalEvent(event)) latestGoalEvent = event;
+      }
+      if (!latestGoalEvent || latestGoalEvent.type === "goal.cleared") {
+        pendingRefreshRef.current = "none";
+        return;
+      }
+      pendingRefreshRef.current = "goal";
+    }
+    scheduleRefreshRef.current();
+  }, [client, workspaceId, sessionId]);
+  useEffect4(() => {
+    const targetKey = `${workspaceId} ${sessionId ?? ""}`;
+    if (targetKeyRef.current !== targetKey) {
+      targetKeyRef.current = targetKey;
+      goalAbsentRef.current = false;
+      pendingRefreshRef.current = "none";
+      setReadAbsent(false);
+      setGoal(null);
+      setError(null);
+    }
+    if (!enabled || !pageLive) {
+      retireLoads();
+      setLoading(false);
+      return;
+    }
+    if (sharedFeed) {
+      setLoading(true);
+      void load();
+      return () => {
+        retireLoads();
+      };
+    }
+    setLoading(true);
+    const pollIntervalMs = options.pollIntervalMs;
+    if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
+      void load();
+      return () => {
+        retireLoads();
+      };
+    }
+    let cancelled = false;
+    let timer = null;
+    const schedule = () => {
+      if (cancelled) return;
+      timer = setTimeout(() => {
+        timer = null;
+        void load().finally(schedule);
+      }, pollIntervalMs);
+    };
+    void load().finally(schedule);
+    return () => {
+      cancelled = true;
+      if (timer !== null) clearTimeout(timer);
+      retireLoads();
+    };
+  }, [
+    load,
+    enabled,
+    pageLive,
+    workspaceId,
+    sessionId,
+    options.pollIntervalMs,
+    retireLoads,
+    sharedFeed
+  ]);
+  const scheduleRefresh = useDebouncedCallback(() => {
+    const pending = pendingRefreshRef.current;
+    if (pending === "none" || loadAbort.current !== null) return;
+    if (pending === "refresh" && goalAbsentRef.current) {
+      pendingRefreshRef.current = "none";
+      return;
+    }
+    void load();
+  });
+  useLayoutEffect2(() => {
+    scheduleRefreshRef.current = scheduleRefresh;
+  }, [scheduleRefresh]);
+  const isRefreshEvent = useCallback5(
+    (event) => goalAbsentRef.current ? isGoalEvent(event) : isGoalRefreshEvent(event),
+    []
+  );
+  const refreshGoal = useCallback5(() => {
+    pendingRefreshRef.current = "goal";
+    scheduleRefresh();
+  }, [scheduleRefresh]);
+  const onRefreshEvent = useCallback5(
+    (event) => {
+      if (isGoalEvent(event)) pendingRefreshRef.current = "goal";
+      else if (pendingRefreshRef.current === "none") pendingRefreshRef.current = "refresh";
+      scheduleRefresh();
+    },
+    [scheduleRefresh]
+  );
+  useSessionEventTrigger(client, workspaceId, sessionId, isRefreshEvent, onRefreshEvent, {
+    enabled,
+    ...sharedEvents !== void 0 ? { events: sharedEvents } : {},
+    // The load settles events that arrive during its read itself (above).
+    readThrough: projectionReadThrough(goal, false),
+    refresh: refreshGoal
+  });
+  const retainedGoal = useRetainedSessionView(
+    client,
+    workspaceId,
+    sessionId,
+    "goal",
+    loading ? null : goal,
+    { enabled, discard: readAbsent || deniesRetainedView(error) }
+  );
+  const visibleGoal = loading ? goal ?? retainedGoal : goal;
+  const goalRef = useRef4(goal);
+  const shownRetainedRef = useRef4(null);
+  const readWaitersRef = useRef4([]);
+  useLayoutEffect2(() => {
+    goalRef.current = goal;
+    shownRetainedRef.current = loading && goal === null ? retainedGoal : null;
+  });
+  useEffect4(() => {
+    if (loading) return;
+    const waiters = readWaitersRef.current;
+    readWaitersRef.current = [];
+    for (const resolve of waiters) resolve();
+  }, [loading]);
+  useEffect4(
+    () => () => {
+      goalRef.current = null;
+      const waiters = readWaitersRef.current;
+      readWaitersRef.current = [];
+      for (const resolve of waiters) resolve();
+    },
+    [workspaceId, sessionId]
+  );
+  const aimedAtCurrentGoal = useCallback5(async () => {
+    const shown = shownRetainedRef.current;
+    if (!shown) return true;
+    await new Promise((resolve) => readWaitersRef.current.push(resolve));
+    const fresh = goalRef.current;
+    return fresh !== null && fresh.id === shown.id && fresh.objectiveRevision === shown.objectiveRevision;
+  }, []);
+  const pause = useCallback5(
+    async (rationale) => {
+      if (!sessionId || !await aimedAtCurrentGoal()) {
+        return null;
+      }
+      const result = await run(
+        () => client.updateGoal(workspaceId, sessionId, {
+          status: "paused",
+          ...rationale !== void 0 ? { rationale } : {}
+        })
+      );
+      if (result) {
+        setGoal(result);
+      }
+      return result;
+    },
+    [client, workspaceId, sessionId, run, aimedAtCurrentGoal]
+  );
+  const resume = useCallback5(async () => {
+    if (!sessionId || !await aimedAtCurrentGoal()) {
+      return null;
+    }
+    const result = await run(() => client.updateGoal(workspaceId, sessionId, { status: "active" }));
+    if (result) {
+      setGoal(result);
+    }
+    return result;
+  }, [client, workspaceId, sessionId, run, aimedAtCurrentGoal]);
+  const clearGoal = useCallback5(async () => {
+    if (!sessionId || !await aimedAtCurrentGoal()) {
+      return;
+    }
+    const ok = await run(async () => {
+      await client.deleteGoal(workspaceId, sessionId);
+      return true;
+    });
+    if (ok) {
+      retireLoads();
+      setReadAbsent(true);
+      setGoal(null);
+      setError(null);
+    }
+  }, [client, workspaceId, sessionId, run, retireLoads, aimedAtCurrentGoal]);
+  return {
+    goal: visibleGoal,
+    isActive: visibleGoal?.status === "active",
+    isPaused: visibleGoal?.status === "paused",
+    isCompleted: visibleGoal?.status === "completed",
+    loading: loading && retainedGoal === null,
+    error,
+    refresh: load,
+    pause,
+    resume,
+    clearGoal,
+    deleteGoal: clearGoal,
+    updating: mutating,
+    mutationError,
+    clearMutationError
+  };
+}
+
+// src/hooks/use-session-control.ts
+import { useCallback as useCallback6, useLayoutEffect as useLayoutEffect3, useRef as useRef5 } from "react";
+function useSessionControl(sessionId, options = {}) {
+  const { client, workspaceId } = useEmbeddedSession(options);
+  const approvalTargetKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const pendingApproval = useRef5(null);
+  useLayoutEffect3(() => {
+    if (pendingApproval.current?.targetKey !== approvalTargetKey) {
+      pendingApproval.current = null;
+    }
+  }, [approvalTargetKey]);
+  const {
+    run: runControl,
+    mutating: controlling,
+    mutationError: controlError,
+    clearMutationError: clearControlError
+  } = useMutationRunner(approvalTargetKey);
+  const {
+    run: runApproval,
+    mutating: responding,
+    mutationError: approvalError,
+    clearMutationError: clearApprovalError
+  } = useMutationRunner(approvalTargetKey);
+  const pause = useCallback6(
+    async (reason) => {
+      if (!sessionId) {
+        return null;
+      }
+      return await runControl(
+        () => client.pauseSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
+      );
+    },
+    [client, workspaceId, sessionId, runControl]
+  );
+  const resume = useCallback6(
+    async (reason) => {
+      if (!sessionId) return null;
+      return await runControl(
+        () => client.resumeSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
+      );
+    },
+    [client, workspaceId, sessionId, runControl]
+  );
+  const decide = useCallback6(
+    async (approvalId, decision, message, answer) => {
+      if (!sessionId) {
+        return null;
+      }
+      const decisionKey = JSON.stringify([approvalId, decision, message ?? null, answer ?? null]);
+      if (pendingApproval.current?.decisionKey !== decisionKey) {
+        pendingApproval.current = {
+          targetKey: approvalTargetKey,
+          decisionKey,
+          clientEventId: crypto.randomUUID()
+        };
+      }
+      const clientEventId = pendingApproval.current.clientEventId;
+      const accepted = await runApproval(
+        () => client.sendApprovalDecision(workspaceId, sessionId, {
+          approvalId,
+          decision,
+          ...message !== void 0 ? { message } : {},
+          ...answer !== void 0 ? answer : {},
+          clientEventId
+        })
+      );
+      if (accepted !== null && pendingApproval.current?.targetKey === approvalTargetKey && pendingApproval.current.clientEventId === clientEventId) {
+        pendingApproval.current = null;
+      }
+      return accepted;
+    },
+    [approvalTargetKey, client, workspaceId, sessionId, runApproval]
+  );
+  const approve = useCallback6(
+    async (approvalId, message, answer) => await decide(approvalId, "approve", message, answer),
+    [decide]
+  );
+  const reject = useCallback6(
+    async (approvalId, message) => await decide(approvalId, "reject", message),
+    [decide]
+  );
+  const error = approvalError ?? controlError;
+  const clearError = useCallback6(() => {
+    clearControlError();
+    clearApprovalError();
+  }, [clearControlError, clearApprovalError]);
+  return {
+    pause,
+    resume,
+    controlling,
+    approve,
+    reject,
+    responding,
+    error,
+    clearError
+  };
+}
+
+// src/hooks/use-available-models.ts
+import { useCallback as useCallback7 } from "react";
+function useAvailableModels(options = {}) {
+  const client = useOpenGeniClient(options);
+  const load = useCallback7(
+    async (signal) => await client.getClientConfig({ signal }),
+    [client]
+  );
+  const state = useSharedQuery(client, ["available-models"], load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled
+  });
+  return {
+    models: state.data?.models ?? [],
+    defaultModel: state.data?.defaultModel ?? null,
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh
+  };
+}
+function useWorkspaceModelCatalog(options) {
+  const t = useOpenGeniText();
+  const client = useOpenGeniClient(options);
+  const load = useCallback7(
+    async (signal) => {
+      if (!options.workspaceId) {
+        return { models: [], defaultModel: null };
+      }
+      const [catalog, config] = await Promise.all([
+        client.getWorkspaceModelCatalog(options.workspaceId, { signal }),
+        // Joins the same workspace's config read already in flight (for
+        // example the composer's voice availability).
+        joinClientConfigRead(client, options.workspaceId)
+      ]);
+      return {
+        models: catalog.models,
+        defaultModel: config.defaultModel
+      };
+    },
+    [client, options.workspaceId]
+  );
+  const state = useSharedQuery(client, ["workspace-model-catalog", options.workspaceId], load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled !== false && Boolean(options.workspaceId)
+  });
+  const rows = sortPickerRows(projectPickerRows(t, state.data?.models ?? []));
+  return {
+    models: state.data?.models ?? [],
+    rows,
+    defaultModel: state.data?.defaultModel ?? null,
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh
+  };
+}
+
+// src/hooks/use-human-input.ts
+import { useCallback as useCallback8, useEffect as useEffect5, useRef as useRef6, useState as useState5 } from "react";
+function isHumanInputEvent(event) {
+  return event.type === "session.humanInput.requested" || event.type === "user.humanInputResponse" || event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled";
+}
+function useHumanInputRequests(sessionId, options = {}) {
+  const { client, workspaceId, registerSessionReconciler } = useEmbeddedHumanInputSession(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const load = useCallback8(async () => {
+    if (!sessionId) return [];
+    const readStartedAt = Date.now();
+    const requests = await client.listHumanInputRequests(workspaceId, sessionId, {
+      status: "pending"
+    });
+    const now2 = Date.now();
+    pruneHumanInputDrafts(
+      workspaceId,
+      sessionId,
+      requests.filter((request) => isActionableHumanInputRequest(request, now2)).map((request) => request.id),
+      readStartedAt
+    );
+    return requests;
+  }, [client, sessionId, workspaceId]);
+  const state = usePolledValue(load, {
+    enabled,
+    pollIntervalMs: options.pollIntervalMs
+  });
+  const loadedRequests = state.data;
+  const refreshRequests = state.refresh;
+  const readDenied = enabled && Boolean(sessionId) && deniesRetainedView(state.error);
+  useEffect5(() => {
+    if (readDenied && sessionId) forgetSessionHumanInputDrafts(workspaceId, sessionId);
+  }, [readDenied, sessionId, workspaceId]);
+  const mutation = useMutationRunner(`${workspaceId}\0${sessionId ?? ""}`);
+  const [respondingRequestId, setRespondingRequestId] = useState5(null);
+  const [deadlineVersion, setDeadlineVersion] = useState5(0);
+  const respondingRequestRef = useRef6(null);
+  useEffect5(() => {
+    respondingRequestRef.current = null;
+    setRespondingRequestId(null);
+  }, [sessionId, workspaceId]);
+  useEffect5(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "human-input", state.refresh);
+  }, [enabled, registerSessionReconciler, sessionId, state.refresh]);
+  const scheduleRefresh = useDebouncedCallback(() => void state.refresh());
+  useSessionEventTrigger(client, workspaceId, sessionId, isHumanInputEvent, scheduleRefresh, {
+    enabled,
+    ...options.events !== void 0 ? { events: options.events } : {},
+    readThrough: projectionReadThrough(state.data, state.loading),
+    refresh: scheduleRefresh
+  });
+  const retainedRequests = useRetainedSessionView(
+    client,
+    workspaceId,
+    sessionId,
+    "human-input",
+    state.data,
+    { enabled, discard: deniesRetainedView(state.error) }
+  );
+  useEffect5(() => {
+    const now2 = Date.now();
+    const nextDeadline = (loadedRequests ?? []).reduce((next, request) => {
+      if (request.status !== "pending" || !request.expiresAt) return next;
+      const deadline = Date.parse(request.expiresAt);
+      if (!Number.isFinite(deadline) || deadline <= now2) return next;
+      return next === null ? deadline : Math.min(next, deadline);
+    }, null);
+    if (nextDeadline === null) return;
+    const timer = globalThis.setTimeout(
+      () => {
+        setDeadlineVersion((current) => current + 1);
+        void refreshRequests();
+      },
+      Math.min(2147483647, Math.max(0, nextDeadline - now2 + 1))
+    );
+    return () => globalThis.clearTimeout(timer);
+  }, [loadedRequests, refreshRequests]);
+  const respond = useCallback8(
+    async (requestId, response) => {
+      if (!sessionId || respondingRequestRef.current !== null) return null;
+      respondingRequestRef.current = requestId;
+      setRespondingRequestId(requestId);
+      try {
+        const event = await mutation.run(
+          () => client.submitHumanInputResponse(workspaceId, sessionId, requestId, response, {
+            clientEventId: globalThis.crypto.randomUUID()
+          })
+        );
+        if (event) await state.refresh();
+        return event;
+      } finally {
+        if (respondingRequestRef.current === requestId) {
+          respondingRequestRef.current = null;
+          setRespondingRequestId(null);
+        }
+      }
+    },
+    [client, mutation, sessionId, state, workspaceId]
+  );
+  const now = Date.now();
+  void deadlineVersion;
+  return {
+    requests: [...state.data ?? retainedRequests ?? []].filter((request) => isActionableHumanInputRequest(request, now)).sort(
+      (left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
+    ),
+    loading: state.loading && retainedRequests === null,
+    error: state.error,
+    refresh: state.refresh,
+    respond,
+    respondingRequestId,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError
+  };
+}
+
+// src/conversation-timeline.ts
+function conversationTimeline(items, queue, composer) {
+  const queued = new Set(
+    queue.queue.filter((turn) => turn.metadata.delivery !== "steer").map((turn) => turn.triggerEventId)
+  );
+  const pending = composer.optimisticMessages ?? [];
+  const pendingQueue = new Set(
+    pending.filter(
+      (message) => message.destination === "queue" && !(message.turnId && message.appliedQueueVersion != null && queue.snapshot && queue.snapshot.version >= message.appliedQueueVersion && !queue.queue.some((turn) => turn.id === message.turnId))
+    ).map((message) => `user-message:${message.clientEventId}`)
+  );
+  const visible = items.filter(
+    (item) => item.kind !== "user-message" || !queued.has(item.id) && !pendingQueue.has(item.reconciliationKey ?? "")
+  );
+  const keys = new Set(
+    visible.flatMap((item) => item.kind === "user-message" ? [item.reconciliationKey] : [])
+  );
+  const optimistic = pending.filter(
+    (message) => (message.destination === "chat" || message.state === "failed") && !keys.has(`user-message:${message.clientEventId}`) && !queue.queue.some((turn) => turn.id === message.turnId)
+  ).map((message) => ({
+    kind: "user-message",
+    id: `optimistic:${message.clientEventId}`,
+    reconciliationKey: `user-message:${message.clientEventId}`,
+    text: message.text,
+    annotations: message.annotations.map((annotation, ordinal) => ({ ...annotation, ordinal })),
+    resources: message.resources,
+    tools: [],
+    occurredAt: message.occurredAt,
+    delivery: {
+      state: message.state,
+      ...message.error ? { error: message.error } : {},
+      ...message.state === "failed" ? {
+        ...message.retryable !== false && composer.retryOptimisticMessage ? { onRetry: () => composer.retryOptimisticMessage?.(message.clientEventId) } : {},
+        ...message.retryable === false && composer.restoreOptimisticMessage ? { onEdit: () => composer.restoreOptimisticMessage?.(message.clientEventId) } : {},
+        onRemove: () => composer.removeOptimisticMessage?.(message.clientEventId)
+      } : {}
+    }
+  }));
+  const failed = optimistic.filter((message) => message.delivery?.state === "failed");
+  const unsent = optimistic.filter((message) => message.delivery?.state !== "failed");
+  const ids = new Set(visible.map((item) => item.id));
+  const steers = (queue.acceptedSteers ?? []).filter((steer) => !ids.has(steer.triggerEventId)).map((steer) => ({
+    kind: "user-message",
+    id: steer.triggerEventId,
+    text: steer.text,
+    annotations: steer.annotations,
+    resources: steer.resources,
+    tools: steer.tools,
+    occurredAt: steer.occurredAt,
+    delivery: { state: steer.state }
+  }));
+  return [...placeFailedSends(visible, failed), ...unsent, ...steers];
+}
+function placeFailedSends(items, failed) {
+  if (failed.length === 0) return items;
+  const before = /* @__PURE__ */ new Map();
+  const last = [];
+  for (const message of failed) {
+    const sentAt = Date.parse(message.occurredAt);
+    const newer = items.findIndex(
+      (item) => item.kind === "user-message" && Date.parse(item.occurredAt) > sentAt
+    );
+    if (newer === -1) {
+      last.push(message);
+    } else {
+      before.set(newer, [...before.get(newer) ?? [], message]);
+    }
+  }
+  return [...items.flatMap((item, index) => [...before.get(index) ?? [], item]), ...last];
+}
+
+// src/lib/session-startup-timeline.tsx
+import { useRef as useRef7 } from "react";
+function currentEvents(events) {
+  return events.filter(
+    (event) => !event.duplicateOfEventId && (!event.turnAssociation || event.turnAssociation === "current")
+  ).sort((a, b) => a.sequence - b.sequence);
+}
+function payloadOf(event) {
+  return event.payload && typeof event.payload === "object" ? event.payload : {};
+}
+function sessionStartupTimeline(items, input) {
+  const { session, optimisticMessages, hasNewer } = input;
+  if (hasNewer || session.effectiveControl.state !== "active" || !["idle", "queued", "running"].includes(session.status) || session.status === "idle" && session.inputWait)
+    return items;
+  const claimed = /* @__PURE__ */ new Set();
+  const pending = /* @__PURE__ */ new Map();
+  let queueVersion = session.queueVersion;
+  let newerProgress = false;
+  let observedActiveTurn = null;
+  let previousTurnEndedAt = null;
+  for (const event of currentEvents(input.events)) {
+    const payload = payloadOf(event);
+    if (event.turnId && ["turn.completed", "turn.failed", "turn.cancelled", "turn.superseded"].includes(event.type))
+      previousTurnEndedAt = event.occurredAt;
+    if (event.sequence > session.lastSequence && ([
+      "turn.started",
+      "turn.completed",
+      "turn.failed",
+      "turn.cancelled",
+      "turn.superseded"
+    ].includes(event.type) || event.type === "session.status.changed" && payload.status !== "queued" || event.type === "session.queue.changed" && ["edit", "delete"].includes(String(payload.operation))))
+      newerProgress = true;
+    if (event.type === "session.queue.changed" && typeof payload.queueVersion === "number")
+      queueVersion = Math.max(queueVersion, payload.queueVersion);
+    const turnId2 = event.turnId ?? (typeof payload.turnId === "string" ? payload.turnId : null);
+    if (!turnId2) continue;
+    if (event.sequence > session.lastSequence) {
+      if (event.type === "turn.started") observedActiveTurn = turnId2;
+      else if (observedActiveTurn === turnId2 && ["turn.completed", "turn.failed", "turn.cancelled", "turn.superseded"].includes(event.type))
+        observedActiveTurn = null;
+    }
+    if ([
+      "turn.started",
+      "turn.completed",
+      "turn.failed",
+      "turn.cancelled",
+      "turn.superseded"
+    ].includes(event.type) || event.type === "session.queue.changed" && ["edit", "delete"].includes(String(payload.operation)))
+      claimed.add(turnId2);
+    if ((event.type === "turn.queued" || event.type === "user.message") && payload.routing === "accepted_for_execution" && (session.status !== "idle" || event.sequence > session.lastSequence))
+      pending.set(turnId2, event.occurredAt);
+  }
+  for (const message of optimisticMessages ?? []) {
+    if (message.state === "queued" && message.destination === "chat" && message.delivery === "send" && message.turnId && !pending.has(message.turnId) && (session.status !== "idle" || message.appliedQueueVersion != null && message.appliedQueueVersion > session.queueVersion))
+      pending.set(message.turnId, message.occurredAt);
+  }
+  const head = input.queue && input.queue.version >= queueVersion ? input.queue.items[0] : null;
+  if (session.status === "queued" && !session.activeTurnId && head && !pending.has(head.id))
+    pending.set(
+      head.id,
+      previousTurnEndedAt && previousTurnEndedAt > head.createdAt ? previousTurnEndedAt : head.createdAt
+    );
+  const candidate = [...pending].find(
+    ([turnId2]) => !claimed.has(turnId2) && (!session.activeTurnId || session.activeTurnId === turnId2) && (!observedActiveTurn || observedActiveTurn === turnId2) && !items.some((item) => "turnId" in item && item.turnId === turnId2)
+  );
+  const fallback = !candidate && !newerProgress && session.status === "queued" && !session.activeTurnId && input.fallbackStartedAt;
+  if (!candidate && !fallback) return items;
+  const [turnId, startedAt] = candidate ?? [
+    `pending-startup:${session.id}`,
+    input.fallbackStartedAt
+  ];
+  return [
+    ...items,
+    {
+      kind: "startup-phase",
+      id: `${turnId}-queue`,
+      turnId,
+      phase: "queue",
+      status: "running",
+      startedAt,
+      occurredAt: startedAt,
+      completedAt: null,
+      durationMs: null,
+      outcome: null,
+      ...session.activeTurnId ? {} : { dispatchWait: session.status === "queued" ? session.dispatchWait ?? null : null }
+    }
+  ];
+}
+var PENDING_SCOPE = "pending-prompt";
+var PENDING_PROMPT_STARTUP_ID = "pending-prompt-startup";
+function pendingPromptItems(prompt) {
+  return [
+    {
+      kind: "user-message",
+      id: "pending-prompt-message",
+      text: prompt.text,
+      resources: prompt.resources ?? [],
+      tools: [],
+      occurredAt: prompt.sentAt
+    },
+    {
+      kind: "startup-phase",
+      id: PENDING_PROMPT_STARTUP_ID,
+      turnId: PENDING_SCOPE,
+      phase: "queue",
+      status: "running",
+      startedAt: prompt.sentAt,
+      occurredAt: prompt.sentAt,
+      completedAt: null,
+      durationMs: null,
+      outcome: null
+    }
+  ];
+}
+function useSessionStartupTimeline(items, input) {
+  const startup = useSessionStartupState(input.session);
+  const bridgeRef = useRef7(null);
+  const { pendingPrompt } = input;
+  if (pendingPrompt && (!input.session || input.historyReady === false)) {
+    bridgeRef.current = {
+      scope: PENDING_SCOPE,
+      id: PENDING_PROMPT_STARTUP_ID,
+      turnId: null,
+      since: pendingPrompt.sentAt,
+      sequence: 0
+    };
+    return [...items, ...pendingPromptItems(pendingPrompt)];
+  }
+  if (!input.session) {
+    bridgeRef.current = null;
+    return items;
+  }
+  const scope = `${input.session.workspaceId}:${input.session.id}`;
+  if (bridgeRef.current?.scope === PENDING_SCOPE)
+    bridgeRef.current = { ...bridgeRef.current, scope };
+  if (bridgeRef.current?.scope !== scope || input.hasNewer || input.session.effectiveControl.state !== "active" || !["queued", "running", "idle"].includes(input.session.status))
+    bridgeRef.current = null;
+  const boundTurn = bridgeRef.current?.turnId;
+  const settled = boundTurn && currentEvents(input.events).find(
+    (event) => event.turnId === boundTurn && ["turn.completed", "turn.failed", "turn.cancelled", "turn.superseded"].includes(event.type)
+  );
+  let fallbackStartedAt = bridgeRef.current?.turnId === null ? bridgeRef.current.since : startup?.startedAt;
+  if (settled) {
+    bridgeRef.current = null;
+    fallbackStartedAt = input.session.status === "queued" && input.session.lastSequence >= settled.sequence ? input.session.updatedAt : void 0;
+  }
+  const projected = sessionStartupTimeline(items, {
+    ...input,
+    session: input.session,
+    fallbackStartedAt
+  });
+  if (projected !== items) {
+    const phase2 = projected.at(-1);
+    if (phase2.kind !== "startup-phase") return projected;
+    const turnId2 = phase2.turnId === `pending-startup:${input.session.id}` ? null : phase2.turnId;
+    let bridge2 = bridgeRef.current;
+    if (!bridge2 || bridge2.turnId && turnId2 && bridge2.turnId !== turnId2) {
+      bridge2 = {
+        scope,
+        id: phase2.id,
+        turnId: turnId2,
+        since: phase2.startedAt,
+        sequence: input.session.lastSequence
+      };
+    } else
+      bridge2 = {
+        ...bridge2,
+        turnId: turnId2 ?? bridge2.turnId,
+        since: bridge2.since < phase2.startedAt ? bridge2.since : phase2.startedAt
+      };
+    bridgeRef.current = bridge2;
+    return [
+      ...projected.slice(0, -1),
+      { ...phase2, id: bridge2.id, startedAt: bridge2.since, occurredAt: bridge2.since }
+    ];
+  }
+  const bridge = bridgeRef.current;
+  if (!bridge) return items;
+  if (input.session.status === "idle") {
+    bridgeRef.current = null;
+    return items;
+  }
+  const started = currentEvents(input.events).find(
+    (event) => event.type === "turn.started" && (bridge.turnId ? event.turnId === bridge.turnId : event.sequence > bridge.sequence)
+  );
+  const turnId = bridge.turnId ?? started?.turnId ?? input.session.activeTurnId;
+  const phase = items.find((item) => item.kind === "startup-phase" && item.turnId === turnId);
+  if (phase?.kind === "startup-phase") {
+    bridgeRef.current = { ...bridge, turnId };
+    return items.map(
+      (item) => item === phase ? {
+        ...phase,
+        id: bridge.id,
+        loadingStartedAt: bridge.since < phase.startedAt ? bridge.since : phase.startedAt
+      } : item
+    );
+  }
+  if (turnId && (started || input.session.activeTurnId === turnId)) {
+    bridgeRef.current = { ...bridge, turnId };
+    return [
+      ...items,
+      {
+        kind: "startup-phase",
+        id: bridge.id,
+        turnId,
+        phase: "queue",
+        status: "complete",
+        startedAt: bridge.since,
+        occurredAt: bridge.since,
+        completedAt: started?.occurredAt ?? input.session.updatedAt,
+        durationMs: null,
+        outcome: null
+      }
+    ];
+  }
+  if (turnId) bridgeRef.current = null;
+  return items;
+}
+
+// src/hooks/use-session-conversation.ts
+import { useLayoutEffect as useLayoutEffect4, useMemo as useMemo4, useRef as useRef8, useState as useState6 } from "react";
+function useSessionConversation(sessionId, options = {}) {
+  const [initialPrompt] = useState6(() => options.pendingPrompt ?? null);
+  const context = useOpenGeni(options);
+  const scope = { client: context.client, workspaceId: context.workspaceId };
+  const config = useClientConfigFlags(context.client);
+  const showModelPicker = options.modelPicker ?? config.modelSelection;
+  const catalog = useWorkspaceModelCatalog({ ...scope, enabled: showModelPicker });
+  const feed = useSessionEvents(sessionId, scope);
+  const pendingPrompt = usePendingPrompt(initialPrompt, sessionId, feed.initialHistoryReady);
+  const eventOptions = { ...scope, events: feed.events };
+  const detail = useSession(sessionId, eventOptions);
+  const queue = useTurnQueue(sessionId, eventOptions);
+  const human = useHumanInputRequests(sessionId, eventOptions);
+  const control = useSessionControl(sessionId, scope);
+  const approvals = useMemo4(() => projectPendingApprovals(feed.events), [feed.events]);
+  const files = useFileAttachments(scope);
+  const clearFiles = files.clear;
+  const attachmentSession = useRef8(sessionId);
+  useLayoutEffect4(() => {
+    if (attachmentSession.current === sessionId) return;
+    const created = attachmentSession.current === null;
+    attachmentSession.current = sessionId;
+    if (created) return;
+    clearFiles();
+  }, [clearFiles, sessionId]);
+  const uploadsEnabled = (options.attachments ?? true) && config.uploads;
+  const status = feed.sessionStatus ?? detail.session?.status;
+  const terminal = status === "cancelled";
+  const importedArchive = detail.session?.importedArchive?.readOnly === true;
+  const host = options.composerOptions;
+  const resolveExtras = () => typeof host?.sendExtras === "function" ? host.sendExtras() : host?.sendExtras;
+  const releaseSentFiles = (input) => files.removeReadyFiles(
+    (input.resources ?? []).flatMap(
+      (resource) => resource.kind === "file" ? [resource.fileId] : []
+    )
+  );
+  const composer = useComposer(sessionId, {
+    ...eventOptions,
+    initialDraft: host?.initialDraft,
+    busySend: host?.busySend,
+    offerQueue: host?.offerQueue,
+    effectiveControl: queue.effectiveControl ?? detail.session?.effectiveControl,
+    // As in the console and the native screen: a turn that is still current
+    // (running or recovering) means a Send waits. A turn parked on provider
+    // capacity does not: the Send replaces it and starts right away.
+    sendDestination: () => promptSendDestination({
+      status,
+      activeTurnId: detail.session?.activeTurnId,
+      queuedPrompts: queue.queue.length,
+      admissionBlock: detail.session?.admissionBlock
+    }),
+    sendExtras: () => {
+      const extras = resolveExtras();
+      return {
+        ...extras,
+        resources: [...extras?.resources ?? [], ...uploadsEnabled ? files.readyResources : []]
+      };
+    },
+    sendBlocked: () => sessionId === null || terminal || importedArchive || uploadsEnabled && files.hasUnresolved || host?.sendBlocked?.() === true,
+    onSubmitted: (text, input) => {
+      releaseSentFiles(input);
+      return host?.onSubmitted?.(text, input);
+    },
+    onSent: (text, input) => {
+      releaseSentFiles(input);
+      return host?.onSent?.(text, input);
+    },
+    onDeliveryError: host?.onDeliveryError
+  });
+  const conversation = useMemo4(
+    () => conversationTimeline(feed.timeline, queue, composer),
+    [feed.timeline, queue, composer]
+  );
+  const session = detail.session;
+  const sessionControl = session?.effectiveControl;
+  const timeline = useSessionStartupTimeline(conversation, {
+    session: session && sessionControl ? {
+      ...session,
+      effectiveControl: admissionRecheckControl(
+        sessionControl,
+        queue.effectiveControl,
+        composer.effectiveControl
+      )
+    } : null,
+    events: feed.events,
+    optimisticMessages: composer.optimisticMessages,
+    hasNewer: feed.hasNewer,
+    queue: queue.snapshot,
+    pendingPrompt,
+    historyReady: sessionId !== null && feed.initialHistoryReady
+  });
+  const error = detail.error ?? feed.error ?? human.error;
+  const loadFailed = Boolean(feed.error) && !feed.initialHistoryReady;
+  const retry = async () => {
+    await Promise.all([
+      ...detail.error ? [detail.refresh()] : [],
+      ...human.error ? [human.refresh()] : [],
+      ...feed.error ? [feed.jumpToLatest()] : []
+    ]);
+  };
+  return {
+    ...scope,
+    sessionId,
+    config,
+    catalog,
+    showModelPicker,
+    feed,
+    detail,
+    queue,
+    human,
+    control,
+    approvals,
+    files,
+    uploadsEnabled,
+    composer,
+    /** The same live application context for text and durable voice messages. */
+    getModelContext: () => resolveExtras()?.modelContext,
+    timeline,
+    status,
+    terminal,
+    importedArchive,
+    running: sessionTurnKeepsRunControl(status),
+    error,
+    loadFailed,
+    retry
+  };
+}
+function usePendingPrompt(prompt, sessionId, historyReady) {
+  const owner = useRef8({
+    sessionId,
+    retired: prompt === null
+  });
+  const current = owner.current;
+  if (!current.retired && current.sessionId !== sessionId) {
+    if (current.sessionId === null) current.sessionId = sessionId;
+    else current.retired = true;
+  }
+  if (!current.retired && sessionId !== null && historyReady) current.retired = true;
+  return current.retired ? null : prompt;
+}
+
+// src/hooks/use-session-read-acknowledgement.ts
+import { useEffect as useEffect6, useMemo as useMemo5, useRef as useRef9 } from "react";
+var SESSION_READ_ACKNOWLEDGEMENT_RETRY_MS = 1e3;
+function isPermanentRejection(error) {
+  const status = error && typeof error === "object" ? error.status : void 0;
+  return typeof status === "number" && status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
+function useSessionReadAcknowledgement(input) {
+  const { client, workspaceId, sessionId, events, active } = input;
+  const session = input.session && (input.session.id ?? sessionId) === sessionId ? input.session : null;
+  const attentionThrough = useMemo5(() => sessionAttentionReadThroughSequence(events), [events]);
+  const { readThrough, unread } = readAcknowledgementFrontier(session, attentionThrough);
+  const hasSession = session !== null;
+  const receipt = useRef9(null);
+  const refused = useRef9(/* @__PURE__ */ new Set());
+  const retryTimer = useRef9(null);
+  useEffect6(
+    () => () => {
+      if (retryTimer.current !== null) clearTimeout(retryTimer.current);
+      retryTimer.current = null;
+      receipt.current = null;
+    },
+    []
+  );
+  useEffect6(() => {
+    if (!active || !hasSession || !unread || readThrough <= 0) return;
+    if (!workspaceId || !sessionId || typeof client.updateSessionAttention !== "function") return;
+    const scope = `${workspaceId}:${sessionId}`;
+    if (refused.current.has(scope)) return;
+    const key = `${scope}:${readThrough}`;
+    if (receipt.current === key) return;
+    receipt.current = key;
+    if (retryTimer.current !== null) clearTimeout(retryTimer.current);
+    retryTimer.current = null;
+    const attempt = (retried) => {
+      void Promise.resolve().then(
+        () => client.updateSessionAttention(workspaceId, sessionId, {
+          unread: false,
+          acknowledgedThroughSequence: readThrough
+        })
+      ).catch((error) => {
+        if (receipt.current !== key) return;
+        if (isPermanentRejection(error)) {
+          refused.current.add(scope);
+          return;
+        }
+        if (!retried) {
+          retryTimer.current = setTimeout(() => {
+            retryTimer.current = null;
+            if (receipt.current === key) attempt(true);
+          }, SESSION_READ_ACKNOWLEDGEMENT_RETRY_MS);
+          return;
+        }
+        receipt.current = null;
+      });
+    };
+    attempt(false);
+  }, [active, client, hasSession, readThrough, sessionId, unread, workspaceId]);
+}
+
+// src/hooks/use-new-conversation.ts
+import {
+  OpenGeniApiError as OpenGeniApiError2
+} from "@opengeni/sdk";
+import { useLayoutEffect as useLayoutEffect5, useMemo as useMemo6, useRef as useRef10, useState as useState7 } from "react";
+var NOOP_ASYNC = async () => {
+};
+function useNewConversation(options = {}) {
+  const t = useOpenGeniText();
+  const context = useOpenGeni(options);
+  const scope = { client: context.client, workspaceId: context.workspaceId };
+  const config = useClientConfigFlags(context.client);
+  const showModelPicker = options.modelPicker ?? config.modelSelection;
+  const catalog = useWorkspaceModelCatalog({ ...scope, enabled: showModelPicker });
+  const files = useFileAttachments(scope);
+  const uploadsEnabled = (options.attachments ?? true) && config.uploads;
+  const available = options.enabled !== false && (options.createSession !== void 0 || config.sessionCreation);
+  const [text, setText] = useState7("");
+  const [choice, setChoice] = useState7({});
+  const [sending, setSending] = useState7(false);
+  const [error, setError] = useState7(null);
+  const [pending, setPending] = useState7(null);
+  const [completion, setCompletion] = useState7(null);
+  const textRef = useRef10(text);
+  const textRevision = useRef10(0);
+  const choiceRef = useRef10(choice);
+  const filesRef = useRef10(files);
+  filesRef.current = files;
+  const pendingRef = useRef10(null);
+  const completionRef = useRef10(null);
+  const inFlight = useRef10(false);
+  const lifetime = useRef10({ mounted: true, generation: 0 }).current;
+  const identity = useMemo6(
+    () => ({
+      client: context.client,
+      workspaceId: context.workspaceId,
+      scopeKey: options.scopeKey
+    }),
+    [context.client, context.workspaceId, options.scopeKey]
+  );
+  const committedIdentity = useRef10(identity);
+  useLayoutEffect5(() => {
+    lifetime.mounted = true;
+    return () => {
+      lifetime.mounted = false;
+      lifetime.generation++;
+    };
+  }, [lifetime]);
+  useLayoutEffect5(() => {
+    if (committedIdentity.current === identity) return;
+    committedIdentity.current = identity;
+    lifetime.generation++;
+    inFlight.current = false;
+    pendingRef.current = null;
+    completionRef.current = null;
+    textRef.current = "";
+    textRevision.current = 0;
+    choiceRef.current = {};
+    setText("");
+    setChoice({});
+    setSending(false);
+    setError(null);
+    setPending(null);
+    setCompletion(null);
+    filesRef.current.clear();
+  }, [identity, lifetime]);
+  const ownsScope = () => lifetime.mounted && committedIdentity.current === identity;
+  const updateText = (value) => {
+    if (!ownsScope()) return;
+    if (value !== textRef.current) textRevision.current++;
+    textRef.current = value;
+    setText(value);
+  };
+  const updateChoice = (patch) => {
+    if (!ownsScope()) return;
+    const next = { ...choiceRef.current, ...patch };
+    const model = catalog.models.find((row) => row.id === (next.model ?? catalog.defaultModel));
+    if (model) {
+      if (next.reasoningEffort)
+        next.reasoningEffort = coerceReasoningEffortForModel(model, next.reasoningEffort);
+      if (next.latencyMode && !runnableLatencyModesForModel(model).includes(next.latencyMode))
+        next.latencyMode = "standard";
+    }
+    choiceRef.current = next;
+    setChoice(choiceRef.current);
+  };
+  const effectivePolicy = () => {
+    const model = choiceRef.current.model ?? catalog.defaultModel;
+    const definition = catalog.models.find((row) => row.id === model);
+    const effort = choiceRef.current.reasoningEffort ?? (definition ? defaultEffortForModel(definition) : config.defaultReasoningEffort ?? "medium");
+    return showModelPicker && model ? {
+      model,
+      reasoningEffort: definition ? coerceReasoningEffortForModel(definition, effort) : effort,
+      latencyMode: choiceRef.current.latencyMode ?? "standard"
+    } : void 0;
+  };
+  const create = options.createSession ?? (async (initialMessage, idempotencyKey, input) => {
+    const creator = context.client.createSession;
+    if (typeof creator !== "function")
+      throw new Error(t("hooks.useNewConversation.newChatsAreNotEnabled"));
+    const created = await creator.call(context.client, context.workspaceId, {
+      ...input.startMode === "realtime" ? {} : { initialMessage },
+      idempotencyKey,
+      ...input
+    });
+    return created.id;
+  });
+  const finishCreation = (accepted) => {
+    if (!lifetime.mounted || lifetime.generation !== accepted.generation) return;
+    const { attempt, sessionId } = accepted;
+    const sentFiles = new Set(attempt.options.resources?.map((resource) => resource.fileId) ?? []);
+    const policyChanged = ["model", "reasoningEffort", "latencyMode"].some(
+      (field) => choiceRef.current[field] !== attempt.options[field]
+    );
+    const draft = {
+      text: attempt.clearDraft && textRevision.current === attempt.textRevision ? "" : textRef.current,
+      resources: filesRef.current.readyResources.filter(
+        (resource) => !sentFiles.has(resource.fileId)
+      ),
+      // Unchanged choices are already part of the created session. Do not
+      // replace server-owned defaults with a browser's catalog estimate.
+      ...policyChanged ? { policy: effectivePolicy() } : {}
+    };
+    pendingRef.current = null;
+    completionRef.current = null;
+    setPending(null);
+    setCompletion(null);
+    updateText(draft.text);
+    filesRef.current.removeReadyFiles(sentFiles);
+    notifyObserver(options.onCreated, {
+      sessionId,
+      initialMessage: attempt.initialMessage,
+      sentAt: attempt.sentAt,
+      draft,
+      ...attempt.realtimeModel ? { realtimeModel: attempt.realtimeModel } : {}
+    });
+  };
+  const finishRef = useRef10(finishCreation);
+  finishRef.current = finishCreation;
+  useLayoutEffect5(() => {
+    if (completion && !files.hasUnresolved) finishRef.current(completion);
+  }, [completion, files.hasUnresolved]);
+  const deliver = async (attempt) => {
+    if (!ownsScope() || inFlight.current || completionRef.current || !available) return false;
+    const ownedGeneration = lifetime.generation;
+    inFlight.current = true;
+    pendingRef.current = attempt;
+    setSending(true);
+    setError(null);
+    setPending(null);
+    try {
+      const sessionId = await attempt.create(
+        attempt.initialMessage,
+        attempt.key,
+        structuredClone(attempt.options)
+      );
+      if (!lifetime.mounted || lifetime.generation !== ownedGeneration) return true;
+      const accepted = { sessionId, attempt, generation: ownedGeneration };
+      completionRef.current = accepted;
+      if (filesRef.current.hasUnresolved) setCompletion(accepted);
+      else finishCreation(accepted);
+      return true;
+    } catch (cause) {
+      if (!lifetime.mounted || lifetime.generation !== ownedGeneration) return false;
+      setError({ cause });
+      if (cause instanceof OpenGeniApiError2 && cause.outcomeUnknown === false) {
+        pendingRef.current = null;
+      } else {
+        setPending(attempt);
+      }
+      return false;
+    } finally {
+      if (lifetime.mounted && lifetime.generation === ownedGeneration) {
+        inFlight.current = false;
+        setSending(false);
+      }
+    }
+  };
+  const submit = async (explicit) => {
+    if (!ownsScope() || !available || inFlight.current || pendingRef.current || uploadsEnabled && filesRef.current.hasUnresolved)
+      return false;
+    const resources = uploadsEnabled ? filesRef.current.readyResources : [];
+    const draftText = explicit ?? textRef.current;
+    const initialMessage = draftText.trim() || (resources.length > 0 ? FILE_ONLY_MESSAGE_TEXT(t) : "");
+    if (!initialMessage) return false;
+    return deliver({
+      key: crypto.randomUUID(),
+      initialMessage,
+      sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+      textRevision: textRevision.current,
+      clearDraft: explicit === void 0,
+      create,
+      options: {
+        ...resources.length ? { resources: structuredClone(resources) } : {},
+        ...showModelPicker ? { ...choiceRef.current } : {}
+      }
+    });
+  };
+  const startRealtime = async (model) => {
+    if (!ownsScope() || !available || inFlight.current || pendingRef.current || !config.realtimeVoice || !(options.realtimeVoice ?? config.realtimeVoiceOffered))
+      return false;
+    if (filesRef.current.hasUnresolved) return false;
+    return deliver({
+      key: crypto.randomUUID(),
+      initialMessage: "",
+      sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+      textRevision: textRevision.current,
+      clearDraft: false,
+      create,
+      options: { ...showModelPicker ? { ...choiceRef.current } : {}, startMode: "realtime" },
+      realtimeModel: model
+    });
+  };
+  const composer = {
+    value: text,
+    setValue: updateText,
+    hasDraftContent: () => textRef.current.length > 0 || filesRef.current.attachments.length > 0,
+    send: submit,
+    steer: submit,
+    // Nothing runs before the conversation exists: Send just sends.
+    working: false,
+    sending,
+    canSend: available && !sending && !pending && !completion && (text.trim().length > 0 || uploadsEnabled && files.readyResources.length > 0) && !(uploadsEnabled && files.hasUnresolved),
+    pause: NOOP_ASYNC,
+    pausing: false,
+    resume: NOOP_ASYNC,
+    resumeScope: NOOP_ASYNC,
+    resuming: false,
+    draft: null,
+    draftRevision: 0,
+    draftLoading: false,
+    draftSaving: false,
+    draftConflict: null,
+    policy: effectivePolicy() ?? null,
+    setModel: (model) => updateChoice({ model }),
+    setReasoningEffort: (reasoningEffort) => updateChoice({ reasoningEffort }),
+    setLatencyMode: (latencyMode) => updateChoice({ latencyMode }),
+    draftPersistence: "disabled",
+    applyDraft: () => {
+    },
+    reloadDraft: NOOP_ASYNC,
+    resolveDraftConflict: NOOP_ASYNC,
+    restoredResources: [],
+    removeRestoredResource: () => {
+    },
+    error: null,
+    clearError: () => {
+      if (ownsScope()) setError(null);
+    }
+  };
+  return {
+    ...scope,
+    config,
+    files,
+    uploadsEnabled,
+    available,
+    showModelPicker,
+    catalog,
+    composer,
+    realtimeVoiceEnabled: config.realtimeVoice && (options.realtimeVoice ?? config.realtimeVoiceOffered),
+    error,
+    finishingUploads: completion !== null,
+    pending: pending ? { idempotencyKey: pending.key, realtimeModel: pending.realtimeModel } : null,
+    retry: () => pendingRef.current ? deliver(pendingRef.current) : Promise.resolve(false),
+    startRealtime
+  };
+}
+
+export {
+  isTitleEvent,
+  useSession,
+  invokeOlderHistoryLoaderWithReceiptCapture,
+  createOlderHistoryLoadReceipt,
+  useTurnlessOutputGap,
+  SESSION_EVENT_BROWSER_MAX_BYTES,
+  SESSION_EVENT_BROWSER_MAX_COUNT,
+  SESSION_EVENT_BROWSER_PENDING_MAX_BYTES,
+  SESSION_EVENT_BROWSER_PENDING_MAX_COUNT,
+  useSessionEvents,
+  boundBrowserSessionEventWindow,
+  isTurnQueueEvent,
+  useTurnQueue,
+  isGoalEvent,
+  useGoal,
+  useSessionControl,
+  useAvailableModels,
+  useWorkspaceModelCatalog,
+  isHumanInputEvent,
+  useHumanInputRequests,
+  conversationTimeline,
+  useSessionStartupTimeline,
+  useSessionConversation,
+  useSessionReadAcknowledgement,
+  useNewConversation
+};
+//# sourceMappingURL=chunk-DF5EAHDN.js.map