@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-SWIHWCTW.js

@@ -1,4461 +0,0 @@
-"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-AXBSYWKX.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-TNUSPXPW.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-SWIHWCTW.js.map