@opengeni/react 3.7.0-canary.0 → 3.7.0-canary.1

package/dist/{chunk-FJBOU2TH.js → chunk-MOWYEBCQ.js}

@@ -1,9 +1,21 @@
 import {
   CREDIT_EXHAUSTION_MESSAGE,
-  humanizeFailureReason,
   isCreditExhaustion,
+  presentFailure,
   tryParseJson
-} from "./chunk-VTOREEXF.js";
+} from "./chunk-PLYRL5ER.js";
+import {
+  useDebouncedCallback,
+  useMutationRunner,
+  usePageLiveActivity,
+  usePolledValue,
+  useSessionEventTrigger
+} from "./chunk-KZ73RL76.js";
+import {
+  useEmbeddedHumanInputSession,
+  useEmbeddedSession,
+  useEmbeddedSessionRead
+} from "./chunk-NEXLLTP4.js";
 
 // src/human-input.ts
 function isActionableHumanInputRequest(request, nowMs = Date.now()) {
@@ -1059,6 +1071,7 @@ ${message}` : message;
             id: `${pendingWaitOutcome.id}-visible-outcome`,
             tone: "waiting",
             text: waitingOutcomeText(pendingWaitOutcome.reason),
+            recordedOutcome: true,
             occurredAt: pendingWaitOutcome.occurredAt
           });
         }
@@ -1631,7 +1644,7 @@ function foldSettledTurn(groups, turnEnd) {
   );
 }
 function isTurnBoundary(group) {
-  return group?.kind === "turn" || group?.kind === "item" && (group.item.kind === "user-message" || group.item.kind === "human-input" || group.item.kind === "context-compaction" || group.item.kind === "machine-input-batch" && group.item.members.some((member) => member.kind === "media_generation_result") || group.item.kind === "notice" && group.item.tone === "input");
+  return group?.kind === "turn" || group?.kind === "item" && (group.item.kind === "user-message" || group.item.kind === "human-input" || group.item.kind === "context-compaction" || group.item.kind === "machine-input-batch" || group.item.kind === "notice" && group.item.tone === "input");
 }
 function belongsToDifferentTurn(group, turnId) {
   if (!group || !turnId) {
@@ -1741,6 +1754,8 @@ function machineInputMembers(value) {
   const kinds = /* @__PURE__ */ new Set([
     "scheduled_occurrence",
     "goal_continuation",
+    "background_command_result",
+    "session_wait_timeout",
     "agent_message",
     "agent_steer_instruction",
     "child_terminal_result",
@@ -1915,13 +1930,7 @@ function elapsedDurationMs(startedAt, completedAt) {
   return Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : null;
 }
 function failureMessage(payload) {
-  for (const key of ["error", "message"]) {
-    const value = payload[key];
-    if (typeof value === "string" && value.trim().length > 0) {
-      return humanizeFailureReason(value);
-    }
-  }
-  return null;
+  return presentFailure(payload).reason;
 }
 function goalText(payload) {
   if (typeof payload.text === "string" && payload.text) {
@@ -2127,6 +2136,1700 @@ function looksLikeId(value) {
   return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
 
+// src/hooks/use-session-events.ts
+import {
+  sessionEventStreamCoveredThrough
+} from "@opengeni/sdk";
+import { startTransition, useCallback, useEffect, useMemo, useRef, useState } from "react";
+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 FOREGROUND_DIRECT_REPLAY_MAX_SEQUENCES = 16;
+var FOREGROUND_COMPACT_PROBE_MAX_SEQUENCES = SESSION_HISTORY_PAGE_SIZE;
+var FOREGROUND_COMPACT_CATCHUP_MAX_EVENTS = 128;
+var FOREGROUND_COMPACT_CATCHUP_MAX_GROUPS = 16;
+var FOREGROUND_COMPACT_CATCHUP_MAX_BYTES = 512 * 1024;
+var EMPTY_EVENTS = [];
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var BROWSER_EVENT_TYPE_MAX_BYTES = 256;
+var BROWSER_EVENT_ID_MAX_BYTES = 256;
+var BROWSER_EVENT_CLIENT_ID_MAX_BYTES = 4 * 1024;
+var BROWSER_EVENT_DUPLICATE_REASON_MAX_BYTES = 4 * 1024;
+var BROWSER_EVENT_PAYLOAD_PREVIEW_MAX_BYTES = 48 * 1024;
+var BROWSER_EVENT_PAYLOAD_IDENTITY_FIELDS = [
+  "id",
+  "callId",
+  "call_id",
+  "name",
+  "toolName",
+  "status",
+  "code",
+  "isError",
+  "stream",
+  "commandId",
+  "sequence",
+  "coalescedUntil",
+  "coalescedCount",
+  "firstSequence",
+  "lastSequence"
+];
+var SESSION_EVENT_BROWSER_MAX_BYTES = 8 * 1024 * 1024;
+var SESSION_EVENT_BROWSER_MAX_COUNT = 1e4;
+var SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES = 96 * 1024;
+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 { 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 [eventWindow, setEventWindow] = useState(EMPTY_EVENT_WINDOW);
+  const [connectionState, setConnectionState] = useState("idle");
+  const [error, setError] = useState(null);
+  const [hasOlder, setHasOlder] = useState(false);
+  const [hasNewer, setHasNewer] = useState(false);
+  const [sessionStatusProjection, setSessionStatusProjection] = useState(
+    null
+  );
+  const [initialLoading, setInitialLoading] = useState(true);
+  const [loadingOlder, setLoadingOlder] = useState(false);
+  const [loadingNewer, setLoadingNewer] = useState(false);
+  const [loadingOldest, setLoadingOldest] = useState(false);
+  const [loadingLatest, setLoadingLatest] = useState(false);
+  const [streamEpoch, setStreamEpoch] = useState(0);
+  const [viewMode, setViewMode] = useState("live");
+  const lastSequenceRef = useRef(after);
+  const streamResumeSequenceRef = useRef(after);
+  const oldestSequenceRef = useRef(null);
+  const newestSequenceRef = useRef(null);
+  const hasOlderRef = useRef(false);
+  const hasNewerRef = useRef(false);
+  const loadingOlderRef = useRef(false);
+  const loadingNewerRef = useRef(false);
+  const loadingOldestRef = useRef(false);
+  const loadingLatestRef = useRef(false);
+  const viewModeRef = useRef("live");
+  const initialWindowLoadedRef = useRef(false);
+  const reconcileAfterPageResumeRef = useRef(false);
+  const streamAbortRef = useRef(null);
+  const streamKeyRef = useRef(null);
+  const generationRef = useRef(0);
+  const navigationGenerationRef = useRef(0);
+  const eventWindowRef = useRef(EMPTY_EVENT_WINDOW);
+  const sessionStatusRef = useRef({
+    sequence: after,
+    status: null
+  });
+  const [stateStreamKey, setStateStreamKey] = useState(streamKey);
+  useEffect(() => {
+    navigationGenerationRef.current += 1;
+    loadingOlderRef.current = false;
+    loadingNewerRef.current = false;
+    loadingOldestRef.current = false;
+    setLoadingOlder(false);
+    setLoadingNewer(false);
+    setLoadingOldest(false);
+    return () => {
+      navigationGenerationRef.current += 1;
+    };
+  }, [client, workspaceId, sessionId, after, enabled, fullReplay]);
+  useEffect(() => {
+    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);
+      lastSequenceRef.current = after;
+      streamResumeSequenceRef.current = after;
+      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;
+    }
+    const generation = generationRef.current + 1;
+    generationRef.current = generation;
+    if (!sessionId || !streamEnabled) {
+      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 isCurrent = () => generationRef.current === generation && !controller.signal.aborted;
+    streamAbortRef.current = controller;
+    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
+        );
+      }
+      const status = observeSessionStatus(batch, sessionStatusRef);
+      if (status !== void 0) {
+        setSessionStatusProjection(status);
+      }
+      const current = eventWindowRef.current;
+      const next = boundBrowserSessionEventWindow([...current.events, ...batch]);
+      const retained = {
+        ...next,
+        truncated: current.truncated || next.truncated
+      };
+      eventWindowRef.current = retained;
+      setEventWindow(retained);
+      oldestSequenceRef.current = retained.events[0]?.sequence ?? null;
+      newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
+      if (retained.truncated) {
+        hasOlderRef.current = true;
+        setHasOlder(true);
+      }
+    };
+    const scheduleFlush = () => {
+      if (!isCurrent()) return;
+      flushTimer ??= setTimeout(flush, 16);
+    };
+    void (async () => {
+      try {
+        if (reconcileForegroundResume) {
+          setConnectionState("connecting");
+          const cursor = streamResumeSequenceRef.current;
+          let plan = { kind: "resume" };
+          try {
+            plan = await planForegroundCatchup(client, workspaceId, sessionId, cursor, {
+              signal: controller.signal
+            });
+          } catch {
+            if (controller.signal.aborted) return;
+            plan = { kind: "resume" };
+          }
+          if (!isCurrent()) return;
+          if (plan.kind === "append") {
+            const current = eventWindowRef.current;
+            assertAppendOrder(current.events, plan.events);
+            const status = observeSessionStatus(plan.events, sessionStatusRef);
+            const next = boundBrowserSessionEventWindow([...current.events, ...plan.events]);
+            const retained = {
+              ...next,
+              truncated: current.truncated || next.truncated
+            };
+            eventWindowRef.current = retained;
+            oldestSequenceRef.current = retained.events[0]?.sequence ?? null;
+            newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
+            lastSequenceRef.current = Math.max(lastSequenceRef.current, plan.resumeSequence);
+            streamResumeSequenceRef.current = Math.max(
+              streamResumeSequenceRef.current,
+              plan.resumeSequence
+            );
+            if (status !== void 0) {
+              setSessionStatusProjection(status);
+            }
+            setEventWindow(retained);
+            if (retained.truncated) {
+              hasOlderRef.current = true;
+              setHasOlder(true);
+            }
+          } else if (plan.kind === "reload") {
+            initialWindowLoadedRef.current = false;
+            setError(null);
+          }
+        }
+        if (!fullReplay && !initialWindowLoadedRef.current) {
+          setConnectionState("connecting");
+          const window = await loadEventWindow(client, workspaceId, sessionId, {
+            before: Number.MAX_SAFE_INTEGER,
+            pageSize: SESSION_HISTORY_PAGE_SIZE,
+            targetGroups: Number.POSITIVE_INFINITY,
+            maxFetches: INITIAL_FETCH_CAP,
+            boundaryPageCap: BOUNDARY_PAGE_CAP,
+            signal: controller.signal
+          });
+          if (!isCurrent()) {
+            return;
+          }
+          const status = observeSessionStatus(window.events, sessionStatusRef);
+          const retained = boundBrowserSessionEventWindow(window.events);
+          navigationGenerationRef.current += 1;
+          loadingOlderRef.current = false;
+          loadingNewerRef.current = false;
+          loadingOldestRef.current = false;
+          setLoadingOlder(false);
+          setLoadingNewer(false);
+          setLoadingOldest(false);
+          eventWindowRef.current = retained;
+          oldestSequenceRef.current = retained.events[0]?.sequence ?? window.oldestSequence;
+          newestSequenceRef.current = maxResumeSequenceOrNull(retained.events) ?? window.newestSequence;
+          hasOlderRef.current = window.hasOlder || retained.truncated;
+          hasNewerRef.current = false;
+          lastSequenceRef.current = window.newestSequence;
+          streamResumeSequenceRef.current = window.newestSequence;
+          initialWindowLoadedRef.current = true;
+          if (status !== void 0) {
+            setSessionStatusProjection(status);
+          }
+          setEventWindow(retained);
+          setHasOlder(window.hasOlder || retained.truncated);
+          setHasNewer(false);
+          setInitialLoading(false);
+        }
+        if (fullReplay) {
+          setInitialLoading(false);
+        }
+        const stream = client.streamEvents(workspaceId, sessionId, {
+          after: streamResumeSequenceRef.current,
+          signal: controller.signal,
+          onOpen: () => {
+            void Promise.resolve().then(() => reconcileSession(sessionId)).catch((cause) => {
+              if (isCurrent()) {
+                setError(cause instanceof Error ? cause : new Error(String(cause)));
+              }
+            });
+          },
+          onStateChange: (state) => {
+            if (isCurrent()) {
+              setConnectionState(state);
+            }
+          }
+        });
+        for await (const event of stream) {
+          if (!isCurrent()) break;
+          const boundedEvent = boundBrowserLegacyEvent(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();
+          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setConnectionState("error");
+          setInitialLoading(false);
+        }
+      }
+    })();
+    return () => {
+      controller.abort();
+      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
+  ]);
+  const navigationBusy = () => loadingOlderRef.current || loadingNewerRef.current || loadingOldestRef.current || loadingLatestRef.current;
+  const loadOlder = useCallback(
+    () => createOlderHistoryLoadReceipt(async (markCommitted) => {
+      if (!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;
+      loadingOlderRef.current = true;
+      setLoadingOlder(true);
+      let published = false;
+      try {
+        const window = await loadEventWindow(client, workspaceId, sessionId, {
+          before,
+          pageSize: SESSION_HISTORY_PAGE_SIZE,
+          targetGroups: OLDER_GROUP_TARGET,
+          maxFetches: OLDER_FETCH_CAP
+        });
+        if (navigationGenerationRef.current !== generation) {
+          return false;
+        }
+        if (window.events.length === 0) {
+          oldestSequenceRef.current = null;
+          hasOlderRef.current = false;
+          setHasOlder(false);
+          return false;
+        }
+        const current = eventWindowRef.current;
+        assertPrependOrder(current.events, window.events);
+        streamAbortRef.current?.abort();
+        const status = observeSessionStatus(window.events, sessionStatusRef);
+        const next = boundBrowserSessionEventWindow([...window.events, ...current.events], {
+          direction: "oldest"
+        });
+        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);
+        eventWindowRef.current = retained;
+        markCommitted();
+        oldestSequenceRef.current = retainedOldest;
+        newestSequenceRef.current = retainedNewest;
+        streamResumeSequenceRef.current = maxResumeSequence(retained.events);
+        const olderStillAvailable = window.hasOlder;
+        hasOlderRef.current = olderStillAvailable;
+        const evictedLiveTail = previousNewest !== null && retainedNewest !== null && retainedNewest < previousNewest;
+        let newer = null;
+        let enterHistory = false;
+        let reconnectLive = 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;
+          }
+        } else {
+          reconnectLive = true;
+        }
+        loadingOlderRef.current = false;
+        startTransition(() => {
+          if (status !== void 0) {
+            setSessionStatusProjection(status);
+          }
+          setEventWindow(retained);
+          setHasOlder(olderStillAvailable);
+          if (newer !== null) {
+            setHasNewer(newer);
+          }
+          if (enterHistory) {
+            setViewMode("history");
+          } else if (reconnectLive) {
+            setStreamEpoch((epoch) => epoch + 1);
+          }
+          setLoadingOlder(false);
+        });
+        published = true;
+        return olderStillAvailable;
+      } finally {
+        if (!published && navigationGenerationRef.current === generation) {
+          loadingOlderRef.current = false;
+          setLoadingOlder(false);
+        }
+      }
+    }),
+    [client, workspaceId, sessionId]
+  );
+  const loadOldest = useCallback(async () => {
+    if (!sessionId || navigationBusy() || !hasOlderRef.current) {
+      return false;
+    }
+    const generation = navigationGenerationRef.current;
+    loadingOldestRef.current = true;
+    setLoadingOldest(true);
+    let published = false;
+    try {
+      const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
+        after: 0,
+        pageSize: SESSION_HISTORY_PAGE_SIZE,
+        targetGroups: OLDEST_GROUP_TARGET,
+        maxFetches: OLDEST_FETCH_CAP
+      });
+      if (navigationGenerationRef.current !== generation) {
+        return false;
+      }
+      if (window.events.length === 0) {
+        hasOlderRef.current = false;
+        setHasOlder(false);
+        return false;
+      }
+      streamAbortRef.current?.abort();
+      const status = observeSessionStatus(window.events, sessionStatusRef);
+      const retained = boundBrowserSessionEventWindow(window.events, { direction: "oldest" });
+      const retainedOldest = retained.events[0]?.sequence ?? null;
+      const retainedNewest = maxResumeSequenceOrNull(retained.events);
+      eventWindowRef.current = retained;
+      oldestSequenceRef.current = retainedOldest;
+      newestSequenceRef.current = retainedNewest;
+      hasOlderRef.current = false;
+      const highWater = Math.max(lastSequenceRef.current, retainedNewest ?? 0);
+      lastSequenceRef.current = highWater;
+      const newer = window.hasNewer || retained.truncated || retainedNewest !== null && retainedNewest < highWater;
+      hasNewerRef.current = newer;
+      initialWindowLoadedRef.current = true;
+      viewModeRef.current = "history";
+      loadingOldestRef.current = false;
+      startTransition(() => {
+        if (status !== void 0) {
+          setSessionStatusProjection(status);
+        }
+        setEventWindow(retained);
+        setHasOlder(false);
+        setHasNewer(newer);
+        setViewMode("history");
+        setLoadingOldest(false);
+      });
+      published = true;
+      return newer;
+    } finally {
+      if (!published && navigationGenerationRef.current === generation) {
+        loadingOldestRef.current = false;
+        setLoadingOldest(false);
+      }
+    }
+  }, [client, workspaceId, sessionId]);
+  const loadNewer = useCallback(async () => {
+    if (!sessionId || navigationBusy() || !hasNewerRef.current) {
+      return false;
+    }
+    const afterSequence = newestSequenceRef.current;
+    if (afterSequence === null) {
+      hasNewerRef.current = false;
+      setHasNewer(false);
+      return false;
+    }
+    const generation = navigationGenerationRef.current;
+    loadingNewerRef.current = true;
+    setLoadingNewer(true);
+    let published = false;
+    try {
+      const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
+        after: afterSequence,
+        pageSize: SESSION_HISTORY_PAGE_SIZE,
+        targetGroups: NEWER_GROUP_TARGET,
+        maxFetches: NEWER_FETCH_CAP
+      });
+      if (navigationGenerationRef.current !== generation) {
+        return false;
+      }
+      if (window.events.length === 0) {
+        hasNewerRef.current = false;
+        setHasNewer(false);
+        streamResumeSequenceRef.current = afterSequence;
+        viewModeRef.current = "live";
+        setViewMode("live");
+        setStreamEpoch((epoch) => epoch + 1);
+        return false;
+      }
+      const current = eventWindowRef.current;
+      assertAppendOrder(current.events, window.events);
+      const status = observeSessionStatus(window.events, sessionStatusRef);
+      const previousOldest = current.events[0]?.sequence ?? null;
+      const next = boundBrowserSessionEventWindow([...current.events, ...window.events], {
+        direction: "newest"
+      });
+      const retained = {
+        ...next,
+        truncated: current.truncated || next.truncated || window.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;
+      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 = window.hasNewer || retainedNewest < highWater;
+      hasNewerRef.current = newer;
+      let resumeLive = false;
+      if (!newer) {
+        streamResumeSequenceRef.current = retainedNewest;
+        viewModeRef.current = "live";
+        resumeLive = true;
+      }
+      loadingNewerRef.current = false;
+      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;
+    } finally {
+      if (!published && navigationGenerationRef.current === generation) {
+        loadingNewerRef.current = false;
+        setLoadingNewer(false);
+      }
+    }
+  }, [client, workspaceId, sessionId]);
+  const jumpToLatest = useCallback(async () => {
+    if (!sessionId || navigationBusy()) {
+      return;
+    }
+    loadingLatestRef.current = true;
+    setLoadingLatest(true);
+    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]);
+  const identityMatches = stateStreamKey === streamKey;
+  const visibleEvents = identityMatches ? eventWindow.events : EMPTY_EVENTS;
+  const timeline = useMemo(() => buildTimeline(visibleEvents), [visibleEvents]);
+  return {
+    events: visibleEvents,
+    timeline,
+    sessionStatus: identityMatches ? sessionStatusProjection : null,
+    connectionState: identityMatches ? connectionState : "idle",
+    lastSequence: identityMatches ? lastSequenceRef.current : after,
+    windowBytes: identityMatches ? eventWindow.bytes : 2,
+    windowTruncated: identityMatches ? eventWindow.truncated : false,
+    initialLoading: fullReplay ? false : identityMatches ? initialLoading : true,
+    hasOlder: !identityMatches ? false : hasOlder,
+    loadingOlder: !identityMatches ? false : loadingOlder,
+    loadOlder,
+    hasNewer: !identityMatches ? false : hasNewer,
+    loadingNewer: !identityMatches ? false : loadingNewer,
+    loadNewer,
+    loadingOldest: !identityMatches ? false : loadingOldest,
+    loadOldest,
+    loadingLatest: !identityMatches ? false : loadingLatest,
+    jumpToLatest,
+    error: identityMatches ? 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.map(boundBrowserLegacyEvent);
+  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 (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 boundBrowserLegacyEvent(event) {
+  const serialized = browserSerialize(event);
+  const originalBytes = serialized.serializable ? encoder.encode(serialized.value).byteLength : null;
+  const typeIsSafe = browserUtf8Bytes(event.type) <= BROWSER_EVENT_TYPE_MAX_BYTES && !event.type.includes("\n") && !event.type.includes("\r");
+  const clientEventId = boundBrowserOptionalText(
+    event.clientEventId,
+    BROWSER_EVENT_CLIENT_ID_MAX_BYTES
+  );
+  const duplicateReason = boundBrowserOptionalText(
+    event.duplicateReason,
+    BROWSER_EVENT_DUPLICATE_REASON_MAX_BYTES
+  );
+  if (serialized.serializable && originalBytes !== null && originalBytes <= SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES && typeIsSafe && clientEventId === event.clientEventId && duplicateReason === event.duplicateReason) {
+    return event;
+  }
+  const envelopeProjection = [
+    !typeIsSafe ? browserEnvelopeFieldProjection("type", event.type, "session.event.envelope_omitted") : null,
+    clientEventId !== event.clientEventId ? browserEnvelopeFieldProjection("clientEventId", event.clientEventId, clientEventId) : null,
+    duplicateReason !== event.duplicateReason ? browserEnvelopeFieldProjection("duplicateReason", event.duplicateReason, duplicateReason) : null
+  ].filter((field) => field !== null);
+  const payloadSerialization = browserSerialize(event.payload);
+  const payloadBytes = payloadSerialization.serializable ? encoder.encode(payloadSerialization.value).byteLength : null;
+  const preview = truncateBrowserUtf8Middle(
+    payloadSerialization.value,
+    BROWSER_EVENT_PAYLOAD_PREVIEW_MAX_BYTES
+  );
+  const truncation = {
+    truncated: true,
+    surface: "browser_legacy_guard",
+    reason: serialized.serializable ? "event_envelope_bytes_exceeded" : "event_not_serializable",
+    originalBytes,
+    deliveredBytes: 0,
+    omittedBytes: originalBytes,
+    estimatedOriginalTokens: originalBytes === null ? null : Math.ceil(originalBytes / 4),
+    estimatedDeliveredTokens: 0,
+    fullEvidence: { available: false, reason: "not_retained" },
+    details: [
+      {
+        path: "$.payload",
+        kind: "payload_preview",
+        originalBytes: payloadBytes,
+        deliveredBytes: browserUtf8Bytes(preview)
+      }
+    ]
+  };
+  const payload = {
+    ...browserPayloadIdentity(event.payload),
+    preview,
+    ...envelopeProjection.length > 0 ? {
+      originalType: boundBrowserText(event.type, BROWSER_EVENT_TYPE_MAX_BYTES),
+      envelopeProjection: {
+        truncated: true,
+        surface: "browser_legacy_guard",
+        fields: envelopeProjection
+      }
+    } : {},
+    truncation
+  };
+  const bounded = {
+    id: boundBrowserText(event.id, BROWSER_EVENT_ID_MAX_BYTES),
+    workspaceId: boundBrowserText(event.workspaceId, BROWSER_EVENT_ID_MAX_BYTES),
+    sessionId: boundBrowserText(event.sessionId, BROWSER_EVENT_ID_MAX_BYTES),
+    sequence: event.sequence,
+    type: typeIsSafe ? event.type : "session.event.envelope_omitted",
+    payload,
+    occurredAt: boundBrowserText(event.occurredAt, BROWSER_EVENT_ID_MAX_BYTES),
+    clientEventId,
+    turnId: boundBrowserOptionalText(event.turnId, BROWSER_EVENT_ID_MAX_BYTES),
+    turnGeneration: event.turnGeneration,
+    turnAttemptId: boundBrowserOptionalText(event.turnAttemptId, BROWSER_EVENT_ID_MAX_BYTES),
+    turnAssociation: event.turnAssociation,
+    duplicateOfEventId: boundBrowserOptionalText(
+      event.duplicateOfEventId,
+      BROWSER_EVENT_ID_MAX_BYTES
+    ),
+    duplicateReason
+  };
+  settleBrowserEventTruncation(bounded, truncation);
+  if (browserJsonBytes(bounded) > SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES) {
+    payload.preview = truncateBrowserUtf8Middle(String(payload.preview), 4 * 1024);
+    truncation.details = truncation.details.slice(0, 1);
+    settleBrowserEventTruncation(bounded, truncation);
+  }
+  if (browserJsonBytes(bounded) > SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES) {
+    bounded.clientEventId = null;
+    bounded.duplicateReason = null;
+    payload.preview = "[legacy event omitted at the browser byte boundary]";
+    settleBrowserEventTruncation(bounded, truncation);
+  }
+  return bounded;
+}
+function browserJsonBytes(value) {
+  return encoder.encode(browserSerialize(value).value).byteLength;
+}
+function browserSerialize(value) {
+  try {
+    const serialized = JSON.stringify(value);
+    return { value: serialized === void 0 ? "null" : serialized, serializable: true };
+  } catch {
+    return {
+      value: '"[unserializable event payload omitted at browser boundary]"',
+      serializable: false
+    };
+  }
+}
+function browserPayloadIdentity(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return {};
+  const record = payload;
+  const identity = {};
+  for (const field of BROWSER_EVENT_PAYLOAD_IDENTITY_FIELDS) {
+    const value = record[field];
+    if (typeof value === "string") {
+      identity[field] = boundBrowserText(value, BROWSER_EVENT_ID_MAX_BYTES);
+    } else if (typeof value === "number" || typeof value === "boolean" || value === null) {
+      identity[field] = value;
+    }
+  }
+  return identity;
+}
+function browserEnvelopeFieldProjection(field, original, delivered) {
+  return {
+    field,
+    originalBytes: typeof original === "string" ? browserUtf8Bytes(original) : 0,
+    deliveredBytes: typeof delivered === "string" ? browserUtf8Bytes(delivered) : 0
+  };
+}
+function boundBrowserOptionalText(value, maxBytes) {
+  return typeof value === "string" ? boundBrowserText(value, maxBytes) : value;
+}
+function boundBrowserText(value, maxBytes) {
+  const bytes = encoder.encode(value);
+  if (bytes.byteLength <= maxBytes) return value;
+  const marker = "\u2026[truncated]";
+  const prefixBudget = Math.max(0, maxBytes - browserUtf8Bytes(marker));
+  let prefixEnd = Math.min(prefixBudget, bytes.byteLength);
+  while (prefixEnd > 0 && prefixEnd < bytes.byteLength && isBrowserUtf8Continuation(bytes[prefixEnd])) {
+    prefixEnd -= 1;
+  }
+  return `${decoder.decode(bytes.subarray(0, prefixEnd))}${marker}`;
+}
+function truncateBrowserUtf8Middle(value, maxBytes) {
+  const bytes = encoder.encode(value);
+  if (bytes.byteLength <= maxBytes) return value;
+  const marker = `\u2026[${bytes.byteLength - maxBytes} bytes omitted]\u2026`;
+  const contentBudget = Math.max(0, maxBytes - browserUtf8Bytes(marker));
+  const leftBudget = Math.floor(contentBudget / 2);
+  const rightBudget = contentBudget - leftBudget;
+  let leftEnd = Math.min(leftBudget, bytes.byteLength);
+  while (leftEnd > 0 && leftEnd < bytes.byteLength && isBrowserUtf8Continuation(bytes[leftEnd])) {
+    leftEnd -= 1;
+  }
+  let rightStart = Math.max(0, bytes.byteLength - rightBudget);
+  while (rightStart < bytes.byteLength && isBrowserUtf8Continuation(bytes[rightStart])) {
+    rightStart += 1;
+  }
+  return `${decoder.decode(bytes.subarray(0, leftEnd))}${marker}${decoder.decode(bytes.subarray(rightStart))}`;
+}
+function settleBrowserEventTruncation(event, truncation) {
+  for (let attempt = 0; attempt < 16; attempt += 1) {
+    const deliveredBytes = browserJsonBytes(event);
+    const omittedBytes = truncation.originalBytes === null ? null : Math.max(0, truncation.originalBytes - deliveredBytes);
+    const estimatedDeliveredTokens = Math.ceil(deliveredBytes / 4);
+    if (truncation.deliveredBytes === deliveredBytes && truncation.omittedBytes === omittedBytes && truncation.estimatedDeliveredTokens === estimatedDeliveredTokens) {
+      return;
+    }
+    truncation.deliveredBytes = deliveredBytes;
+    truncation.omittedBytes = omittedBytes;
+    truncation.estimatedDeliveredTokens = estimatedDeliveredTokens;
+  }
+  throw new RangeError("Browser event byte accounting did not converge");
+}
+function browserUtf8Bytes(value) {
+  return encoder.encode(value).byteLength;
+}
+function isBrowserUtf8Continuation(value) {
+  return (value & 192) === 128;
+}
+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 planForegroundCatchup(client, workspaceId, sessionId, cursor, options = {}) {
+  if (options.signal?.aborted) throw abortError();
+  const session = await client.getSession(workspaceId, sessionId, {
+    fresh: true,
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  if (options.signal?.aborted) throw abortError();
+  const durableHead = Math.max(cursor, session.lastSequence);
+  const rawGap = durableHead - cursor;
+  if (rawGap <= FOREGROUND_DIRECT_REPLAY_MAX_SEQUENCES) {
+    return { kind: "resume" };
+  }
+  if (rawGap > FOREGROUND_COMPACT_PROBE_MAX_SEQUENCES) {
+    return { kind: "reload" };
+  }
+  const page = await loadNextPage(client, workspaceId, sessionId, cursor, {
+    pageSize: rawGap,
+    ...options.signal ? { signal: options.signal } : {}
+  });
+  const events = page.filter((event) => eventResumeSequence(event) > cursor).map(boundBrowserLegacyEvent);
+  if (events.length === 0) {
+    return { kind: "reload" };
+  }
+  assertAscending(events);
+  const resumeSequence = maxResumeSequence(events);
+  if (resumeSequence < durableHead) {
+    return { kind: "reload" };
+  }
+  if (events.length > FOREGROUND_COMPACT_CATCHUP_MAX_EVENTS || groupCount(events) > FOREGROUND_COMPACT_CATCHUP_MAX_GROUPS || browserJsonBytes(events) > FOREGROUND_COMPACT_CATCHUP_MAX_BYTES) {
+    return { kind: "reload" };
+  }
+  return { kind: "append", events, resumeSequence };
+}
+async function loadEventWindow(client, workspaceId, sessionId, options) {
+  let cursor = options.before;
+  let buffer = [];
+  let reachedStart = false;
+  let fetches = 0;
+  while (fetches < options.maxFetches) {
+    if (buffer.length > 0 && groupCount(buffer) >= options.targetGroups) {
+      break;
+    }
+    const page = await loadPreviousPage(client, workspaceId, sessionId, cursor, {
+      pageSize: options.pageSize,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    fetches += 1;
+    if (page.length === 0) {
+      reachedStart = true;
+      break;
+    }
+    assertAscending(page);
+    buffer = [...page, ...buffer];
+    cursor = page[0].sequence;
+    if (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,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    fetches += 1;
+    snapPages += 1;
+    if (page.length === 0) {
+      reachedStart = true;
+      break;
+    }
+    assertAscending(page);
+    buffer = [...page, ...buffer];
+    cursor = page[0].sequence;
+    if (isLogStart(page[0])) {
+      reachedStart = true;
+      break;
+    }
+  }
+  if (!reachedStart) {
+    const boundary = findBoundaryIndex(buffer);
+    if (boundary > 0) {
+      buffer = buffer.slice(boundary);
+    }
+  }
+  const densityWindow = trimBackwardToGroupTarget(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,
+    hasOlder: buffer.length > 0 && (densityWindow.trimmed || !reachedStart && oldest?.type !== "session.created")
+  };
+}
+function findBoundaryIndex(events) {
+  for (let index = 0; index < events.length; index += 1) {
+    if (isTurnBoundary2(events[index])) {
+      return index;
+    }
+  }
+  return -1;
+}
+function isTurnBoundary2(event) {
+  return event.type === "session.created" || event.type === "user.message";
+}
+async function loadForwardEventWindow(client, workspaceId, sessionId, options) {
+  let cursor = options.after;
+  let buffer = [];
+  let fetches = 0;
+  let reachedEnd = false;
+  while (fetches < options.maxFetches) {
+    if (buffer.length > 0 && groupCount(buffer) >= options.targetGroups) {
+      break;
+    }
+    const page = await loadNextPage(client, workspaceId, sessionId, cursor, {
+      pageSize: options.pageSize,
+      ...options.signal ? { signal: options.signal } : {}
+    });
+    fetches += 1;
+    if (page.length === 0) {
+      reachedEnd = true;
+      break;
+    }
+    assertAscending(page);
+    buffer = [...buffer, ...page];
+    cursor = maxResumeSequence(page);
+  }
+  const densityWindow = trimForwardToGroupTarget(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,
+    hasNewer: buffer.length > 0 && (densityWindow.trimmed || !reachedEnd)
+  };
+}
+function trimBackwardToGroupTarget(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 (!isTurnBoundary2(events[index])) continue;
+    const candidate = events.slice(index);
+    if (groupCount(candidate) >= targetGroups) {
+      return { events: candidate, trimmed: true };
+    }
+  }
+  return { events, trimmed: false };
+}
+function trimForwardToGroupTarget(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 (!isTurnBoundary2(events[index])) continue;
+    const candidate = events.slice(0, index);
+    if (groupCount(candidate) >= targetGroups) {
+      return { events: candidate, trimmed: true };
+    }
+  }
+  return { events, trimmed: false };
+}
+async function loadPreviousPage(client, workspaceId, sessionId, before, options) {
+  if (options.signal?.aborted) {
+    throw abortError();
+  }
+  const requested = options.pageSize;
+  if (requested === 0) {
+    return Object.assign([], { requested });
+  }
+  const page = await client.listEvents(workspaceId, sessionId, {
+    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"
+  });
+  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 Object.assign([], { requested });
+  }
+  const page = await client.listEvents(workspaceId, sessionId, {
+    after,
+    limit: requested,
+    compact: true,
+    direction: "after",
+    payloadMode: "full"
+  });
+  if (options.signal?.aborted) {
+    throw abortError();
+  }
+  return Object.assign(page, { requested });
+}
+function groupCount(events) {
+  if (events.length === 0) {
+    return 0;
+  }
+  return groupTimeline(buildTimeline(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;
+}
+
+// src/hooks/use-session.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
+function isTitleEvent(event) {
+  return event.type === "session.title_set";
+}
+function isSessionDetailEvent(event) {
+  return isTitleEvent(event) || event.type.startsWith("session.command.");
+}
+function useSession(sessionId, options = {}) {
+  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSessionRead(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const [override, setOverride] = useState2(null);
+  const nextReadRevision = useRef2(0);
+  const nextReadGeneration = useRef2(0);
+  const beginRead = options.beginRead;
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
+  const load = useCallback2(
+    async (signal) => {
+      if (!sessionId) {
+        return null;
+      }
+      let readGeneration2 = 0;
+      const fetched = await client.getSession(workspaceId, sessionId, {
+        fresh: true,
+        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
+  });
+  useEffect2(() => {
+    if (enabled && workspaceControlEvent) void refresh();
+  }, [enabled, refresh, workspaceControlEvent]);
+  useEffect2(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "session", refresh);
+  }, [enabled, refresh, registerSessionReconciler, sessionId]);
+  const base = data?.session ?? null;
+  const readRevision = data?.revision ?? 0;
+  const readGeneration = data?.readGeneration ?? 0;
+  const session = useMemo2(
+    () => base && override && override.id === base.id ? { ...base, title: override.title, titleSource: override.titleSource } : base,
+    [base, override]
+  );
+  const sharedEvents = options.events;
+  const onTitleEvent = useCallback2(
+    (event) => {
+      if (sharedEvents?.some(
+        (item) => item.sessionId === sessionId && item.type.startsWith("session.command.") && item.sequence > (base?.lastSequence ?? -1)
+      )) {
+        void refresh();
+      } else if (event.type.startsWith("session.command.")) {
+        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 } : {}
+  });
+  const updateTitle = useCallback2(
+    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,
+    error,
+    readRevision,
+    readGeneration,
+    refresh,
+    updateTitle,
+    updating: mutating,
+    mutationError,
+    clearMutationError
+  };
+}
+
+// src/hooks/use-turn-queue.ts
+import { useCallback as useCallback3, 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 { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSession(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const targetKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const pageLive = usePageLiveActivity();
+  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);
+  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);
+    setMutationError(null);
+    setPendingByTurn({});
+    setAcceptedSteers([]);
+  }, [enabled, targetKey]);
+  useEffect3(() => {
+    if (acceptedSteers.length === 0 || options.events === void 0) return;
+    const durablyStartedTurnIds = new Set(
+      options.events.flatMap(
+        (event) => event.type === "turn.started" && event.turnId ? [event.turnId] : []
+      )
+    );
+    if (durablyStartedTurnIds.size === 0) return;
+    setAcceptedSteers(
+      (current) => current.filter((steer) => !durablyStartedTurnIds.has(steer.turnId))
+    );
+  }, [acceptedSteers.length, options.events]);
+  const acceptSnapshot = useCallback3(
+    (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 = useCallback3(
+    async (rejectOnFailure = false) => {
+      if (!sessionId) return;
+      const ownedTargetKey = `${workspaceId}\0${sessionId}`;
+      const ticket = ++readGeneration.current;
+      try {
+        const fetched = await client.getQueue(workspaceId, sessionId);
+        if (targetKeyRef.current !== ownedTargetKey) return;
+        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)) {
+          setError(asError(cause));
+          if (ticket === readGeneration.current) setLoading(false);
+        }
+        if (rejectOnFailure) throw cause;
+      }
+    },
+    [client, workspaceId, sessionId, acceptSnapshot]
+  );
+  useEffect3(() => {
+    if (!enabled || !pageLive) {
+      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;
+    };
+  }, [load, enabled, pageLive, options.pollIntervalMs]);
+  useEffect3(() => {
+    if (enabled && workspaceControlEvent) void load();
+  }, [enabled, load, workspaceControlEvent]);
+  useEffect3(() => {
+    if (!sessionId || !enabled) return;
+    return registerSessionReconciler(sessionId, "queue", load);
+  }, [enabled, load, registerSessionReconciler, sessionId]);
+  const scheduleRefresh = useDebouncedCallback(() => void load());
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    isTurnQueueEvent,
+    scheduleRefresh,
+    {
+      enabled,
+      ...options.events !== void 0 ? { events: options.events } : {}
+    },
+    async () => await load(true)
+  );
+  const mutate = useCallback3(
+    async (turnId, kind, command) => {
+      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) {
+          setMutationError(asError(cause));
+          await load();
+        }
+        return null;
+      } finally {
+        if (targetKeyRef.current === ownedTargetKey && turnId in pendingRef.current) {
+          const next = { ...pendingRef.current };
+          delete next[turnId];
+          pendingRef.current = next;
+          setPendingByTurn(next);
+        }
+      }
+    },
+    [acceptSnapshot, load, sessionId, targetKey]
+  );
+  const moveTurn = useCallback3(
+    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 = useCallback3(
+    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 steerTurn = useCallback3(
+    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("That queued prompt changed before Steer could be sent."));
+        await load();
+        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, load, mutate, sessionId, targetKey, workspaceId]
+  );
+  const removeTurn = useCallback3(
+    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 = identityMatches ? snapshot : null;
+  const visiblePendingByTurn = identityMatches ? pendingByTurn : EMPTY_PENDING_BY_TURN;
+  const mutating = useMemo3(
+    () => Object.keys(visiblePendingByTurn).length > 0,
+    [visiblePendingByTurn]
+  );
+  const mutationFor = useCallback3(
+    (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: identityMatches ? loading : enabled,
+    error: identityMatches ? error : null,
+    refresh: load,
+    moveTurn,
+    editTurn,
+    steerTurn,
+    removeTurn,
+    pendingByTurn: visiblePendingByTurn,
+    mutationFor,
+    mutating,
+    mutationError: identityMatches ? mutationError : null,
+    clearMutationError: useCallback3(() => {
+      if (targetKeyRef.current === targetKey) setMutationError(null);
+    }, [targetKey]),
+    acceptedSteers: identityMatches ? acceptedSteers : []
+  };
+}
+function operationKey() {
+  return globalThis.crypto.randomUUID();
+}
+function asError(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+function isOutcomeUnknownError(cause) {
+  return typeof cause === "object" && cause !== null && cause.outcomeUnknown === true;
+}
+
+// src/hooks/use-human-input.ts
+import { useCallback as useCallback4, useEffect as useEffect4, useRef as useRef4, useState as useState4 } 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 = useCallback4(
+    async () => sessionId ? await client.listHumanInputRequests(workspaceId, sessionId, { status: "pending" }) : [],
+    [client, sessionId, workspaceId]
+  );
+  const state = usePolledValue(load, {
+    enabled,
+    pollIntervalMs: options.pollIntervalMs
+  });
+  const loadedRequests = state.data;
+  const refreshRequests = state.refresh;
+  const mutation = useMutationRunner(`${workspaceId}\0${sessionId ?? ""}`);
+  const [respondingRequestId, setRespondingRequestId] = useState4(null);
+  const [deadlineVersion, setDeadlineVersion] = useState4(0);
+  const respondingRequestRef = useRef4(null);
+  useEffect4(() => {
+    respondingRequestRef.current = null;
+    setRespondingRequestId(null);
+  }, [sessionId, workspaceId]);
+  useEffect4(() => {
+    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 } : {}
+  });
+  useEffect4(() => {
+    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 = useCallback4(
+    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 ?? []].filter((request) => isActionableHumanInputRequest(request, now)).sort(
+      (left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id)
+    ),
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh,
+    respond,
+    respondingRequestId,
+    mutationError: mutation.mutationError,
+    clearMutationError: mutation.clearMutationError
+  };
+}
+
 export {
   isActionableHumanInputRequest,
   humanInputRequestFromEvent,
@@ -2139,6 +3842,19 @@ export {
   creditExhaustedFromEvents,
   sessionStatusFromEvents,
   groupTimeline,
-  extractSessionRef
+  extractSessionRef,
+  SESSION_EVENT_BROWSER_MAX_BYTES,
+  SESSION_EVENT_BROWSER_MAX_COUNT,
+  SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES,
+  SESSION_EVENT_BROWSER_PENDING_MAX_BYTES,
+  SESSION_EVENT_BROWSER_PENDING_MAX_COUNT,
+  useSessionEvents,
+  boundBrowserSessionEventWindow,
+  isTitleEvent,
+  useSession,
+  isTurnQueueEvent,
+  useTurnQueue,
+  isHumanInputEvent,
+  useHumanInputRequests
 };
-//# sourceMappingURL=chunk-FJBOU2TH.js.map
+//# sourceMappingURL=chunk-MOWYEBCQ.js.map