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

package/dist/chunk-IB27C53Y.js

@@ -1,2582 +0,0 @@
-import {
-  useDebouncedCallback,
-  useMutationRunner,
-  usePageLiveActivity,
-  usePolledValue,
-  useSessionEventTrigger
-} from "./chunk-KZ73RL76.js";
-import {
-  useEmbeddedFileAttachments,
-  useEmbeddedGoal,
-  useEmbeddedHumanInputSession,
-  useEmbeddedSession,
-  useEmbeddedSessionLineage,
-  useEmbeddedSessionMcpApprovalPolicy,
-  useEmbeddedSessionRead
-} from "./chunk-NEXLLTP4.js";
-import {
-  buildTimeline,
-  createOlderHistoryLoadReceipt,
-  groupTimeline,
-  isActionableHumanInputRequest,
-  sessionStatusFromEvents
-} from "./chunk-TJFMMDQU.js";
-
-// src/embedded-session-client.ts
-var requiredMethods = [
-  "getSession",
-  "listEvents",
-  "streamEvents",
-  "getComposerDraft",
-  "saveComposerDraft",
-  "submitComposerDraft",
-  "sendMessage",
-  "steerMessage",
-  "getQueue",
-  "moveQueueItem",
-  "editQueueItem",
-  "steerQueueItem",
-  "deleteQueueItem",
-  "pauseSession",
-  "resumeSession",
-  "sendApprovalDecision"
-];
-function createEmbeddedSessionClient(base, options = {}) {
-  const overrides = options.overrides ?? {};
-  const client = {};
-  for (const key of requiredMethods) {
-    const override = overrides[key];
-    const method = override ?? base[key];
-    if (typeof method !== "function") {
-      throw new TypeError(`Embedded session client method is required: ${key}`);
-    }
-    client[key] = method.bind(override === void 0 ? base : overrides);
-  }
-  const inferenceOverride = overrides.setWorkspaceInferenceState;
-  const inferenceBase = base.setWorkspaceInferenceState;
-  const inferenceMethod = inferenceOverride ?? inferenceBase;
-  if (typeof inferenceMethod === "function") {
-    client.setWorkspaceInferenceState = inferenceMethod.bind(
-      inferenceOverride === void 0 ? base : overrides
-    );
-  }
-  const mapDraft = options.mapComposerDraft;
-  if (!mapDraft) return client;
-  const getComposerDraft = client.getComposerDraft;
-  client.getComposerDraft = async (workspaceId, sessionId) => mapDraft(await getComposerDraft(workspaceId, sessionId), {
-    operation: "read",
-    workspaceId,
-    sessionId
-  });
-  const saveComposerDraft = client.saveComposerDraft;
-  client.saveComposerDraft = async (workspaceId, sessionId, request) => mapDraft(await saveComposerDraft(workspaceId, sessionId, request), {
-    operation: "save",
-    workspaceId,
-    sessionId
-  });
-  const submitComposerDraft = client.submitComposerDraft;
-  client.submitComposerDraft = async (workspaceId, sessionId, request) => {
-    const response = await submitComposerDraft(workspaceId, sessionId, request);
-    return {
-      ...response,
-      draft: mapDraft(response.draft, {
-        operation: "submit",
-        workspaceId,
-        sessionId
-      })
-    };
-  };
-  return client;
-}
-
-// src/hooks/use-session.ts
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-function isTitleEvent(event) {
-  return event.type === "session.title_set";
-}
-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 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
-  });
-  useEffect(() => {
-    if (enabled && workspaceControlEvent) void refresh();
-  }, [enabled, refresh, workspaceControlEvent]);
-  useEffect(() => {
-    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 = useMemo(
-    () => base && override && override.id === base.id ? { ...base, title: override.title, titleSource: override.titleSource } : base,
-    [base, override]
-  );
-  const onTitleEvent = useCallback(
-    (event) => {
-      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]
-  );
-  useSessionEventTrigger(client, workspaceId, sessionId, isTitleEvent, onTitleEvent, {
-    enabled,
-    ...options.events !== void 0 ? { events: options.events } : {}
-  });
-  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,
-    error,
-    readRevision,
-    readGeneration,
-    refresh,
-    updateTitle,
-    updating: mutating,
-    mutationError,
-    clearMutationError
-  };
-}
-
-// src/hooks/use-session-events.ts
-import {
-  sessionEventStreamCoveredThrough
-} from "@opengeni/sdk";
-import { startTransition, useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState as useState2 } from "react";
-var INITIAL_TAIL_PAGE_SIZE = 1e3;
-var OLDER_PAGE_SIZE = 5e3;
-var NEWER_PAGE_SIZE = 5e3;
-var OLDEST_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 = 4;
-var FOREGROUND_DIRECT_REPLAY_MAX_SEQUENCES = 16;
-var FOREGROUND_COMPACT_PROBE_MAX_SEQUENCES = 5e3;
-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] = useState2(EMPTY_EVENT_WINDOW);
-  const [connectionState, setConnectionState] = useState2("idle");
-  const [error, setError] = useState2(null);
-  const [hasOlder, setHasOlder] = useState2(false);
-  const [hasNewer, setHasNewer] = useState2(false);
-  const [sessionStatusProjection, setSessionStatusProjection] = useState2(
-    null
-  );
-  const [initialLoading, setInitialLoading] = useState2(true);
-  const [loadingOlder, setLoadingOlder] = useState2(false);
-  const [loadingNewer, setLoadingNewer] = useState2(false);
-  const [loadingOldest, setLoadingOldest] = useState2(false);
-  const [loadingLatest, setLoadingLatest] = useState2(false);
-  const [streamEpoch, setStreamEpoch] = useState2(0);
-  const [viewMode, setViewMode] = useState2("live");
-  const lastSequenceRef = useRef2(after);
-  const streamResumeSequenceRef = useRef2(after);
-  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 reconcileAfterPageResumeRef = useRef2(false);
-  const streamAbortRef = useRef2(null);
-  const streamKeyRef = useRef2(null);
-  const generationRef = useRef2(0);
-  const eventWindowRef = useRef2(EMPTY_EVENT_WINDOW);
-  const sessionStatusRef = useRef2({
-    sequence: after,
-    status: null
-  });
-  const [stateStreamKey, setStateStreamKey] = useState2(streamKey);
-  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);
-      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 (loadingOlderRef.current) {
-      loadingOlderRef.current = false;
-      setLoadingOlder(false);
-    }
-    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") {
-            eventWindowRef.current = EMPTY_EVENT_WINDOW;
-            oldestSequenceRef.current = null;
-            newestSequenceRef.current = null;
-            hasOlderRef.current = false;
-            hasNewerRef.current = false;
-            initialWindowLoadedRef.current = false;
-            streamResumeSequenceRef.current = after;
-            setEventWindow(EMPTY_EVENT_WINDOW);
-            setHasOlder(false);
-            setHasNewer(false);
-            setInitialLoading(true);
-            setError(null);
-          }
-        }
-        if (!fullReplay && !initialWindowLoadedRef.current) {
-          setConnectionState("connecting");
-          const window = await loadEventWindow(client, workspaceId, sessionId, {
-            before: Number.MAX_SAFE_INTEGER,
-            pageSize: INITIAL_TAIL_PAGE_SIZE,
-            targetGroups: Number.POSITIVE_INFINITY,
-            maxFetches: INITIAL_FETCH_CAP,
-            signal: controller.signal
-          });
-          if (!isCurrent()) {
-            return;
-          }
-          const status = observeSessionStatus(window.events, sessionStatusRef);
-          const retained = boundBrowserSessionEventWindow(window.events);
-          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 = useCallback2(
-    () => 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 = generationRef.current;
-      loadingOlderRef.current = true;
-      setLoadingOlder(true);
-      let published = false;
-      try {
-        const window = await loadEventWindow(client, workspaceId, sessionId, {
-          before,
-          pageSize: OLDER_PAGE_SIZE,
-          targetGroups: OLDER_GROUP_TARGET,
-          maxFetches: OLDER_FETCH_CAP
-        });
-        if (generationRef.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) {
-          loadingOlderRef.current = false;
-          setLoadingOlder(false);
-        }
-      }
-    }),
-    [client, workspaceId, sessionId]
-  );
-  const loadOldest = useCallback2(async () => {
-    if (!sessionId || navigationBusy() || !hasOlderRef.current) {
-      return false;
-    }
-    const generation = generationRef.current;
-    loadingOldestRef.current = true;
-    setLoadingOldest(true);
-    let published = false;
-    try {
-      const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
-        after: 0,
-        pageSize: OLDEST_PAGE_SIZE,
-        targetGroups: OLDEST_GROUP_TARGET,
-        maxFetches: OLDEST_FETCH_CAP
-      });
-      if (generationRef.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) {
-        loadingOldestRef.current = false;
-        setLoadingOldest(false);
-      }
-    }
-  }, [client, workspaceId, sessionId]);
-  const loadNewer = useCallback2(async () => {
-    if (!sessionId || navigationBusy() || !hasNewerRef.current) {
-      return false;
-    }
-    const afterSequence = newestSequenceRef.current;
-    if (afterSequence === null) {
-      hasNewerRef.current = false;
-      setHasNewer(false);
-      return false;
-    }
-    const generation = generationRef.current;
-    loadingNewerRef.current = true;
-    setLoadingNewer(true);
-    let published = false;
-    try {
-      const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
-        after: afterSequence,
-        pageSize: NEWER_PAGE_SIZE,
-        targetGroups: NEWER_GROUP_TARGET,
-        maxFetches: NEWER_FETCH_CAP
-      });
-      if (generationRef.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) {
-        loadingNewerRef.current = false;
-        setLoadingNewer(false);
-      }
-    }
-  }, [client, workspaceId, sessionId]);
-  const jumpToLatest = useCallback2(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 = useMemo2(() => 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 < BOUNDARY_PAGE_CAP && fetches < options.maxFetches) {
-    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 (isTurnBoundary(events[index])) {
-      return index;
-    }
-  }
-  return -1;
-}
-function isTurnBoundary(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 (!isTurnBoundary(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 (!isTurnBoundary(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-file-attachments.ts
-import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
-var isImage = (file) => file.type.startsWith("image/");
-var fallbackAttachmentId = 0;
-function createAttachmentId() {
-  const cryptoSource = globalThis.crypto;
-  if (typeof cryptoSource?.randomUUID === "function") return cryptoSource.randomUUID();
-  fallbackAttachmentId += 1;
-  return `attachment:${Date.now().toString(36)}:${fallbackAttachmentId.toString(36)}`;
-}
-function secureContextRequiredErrorCode(error) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === "secure_context_required" ? error.code : void 0;
-}
-function useFileAttachments(options = {}) {
-  const { client, workspaceId } = useEmbeddedFileAttachments(options);
-  const pasteFilter = options.pasteFilter ?? isImage;
-  const [attachments, setAttachments] = useState3([]);
-  const sources = useRef3(/* @__PURE__ */ new Map());
-  const previewUrls = useRef3(/* @__PURE__ */ new Map());
-  const previewRetainers = useRef3(/* @__PURE__ */ new Map());
-  const pendingPreviewRevocations = useRef3(/* @__PURE__ */ new Set());
-  const revokePreview = useCallback3((id) => {
-    const previewUrl = previewUrls.current.get(id);
-    if (!previewUrl) return;
-    if ((previewRetainers.current.get(id) ?? 0) > 0) {
-      pendingPreviewRevocations.current.add(id);
-      return;
-    }
-    previewUrls.current.delete(id);
-    pendingPreviewRevocations.current.delete(id);
-    URL.revokeObjectURL(previewUrl);
-  }, []);
-  const revokeAllPreviews = useCallback3(() => {
-    for (const id of previewUrls.current.keys()) revokePreview(id);
-  }, [revokePreview]);
-  const retainPreview = useCallback3(
-    (id) => {
-      if (!previewUrls.current.has(id)) return void 0;
-      previewRetainers.current.set(id, (previewRetainers.current.get(id) ?? 0) + 1);
-      let released = false;
-      return () => {
-        if (released) return;
-        released = true;
-        const remaining = (previewRetainers.current.get(id) ?? 1) - 1;
-        if (remaining > 0) {
-          previewRetainers.current.set(id, remaining);
-          return;
-        }
-        previewRetainers.current.delete(id);
-        if (pendingPreviewRevocations.current.has(id)) revokePreview(id);
-      };
-    },
-    [revokePreview]
-  );
-  const committedAttachmentIds = useRef3(/* @__PURE__ */ new Set());
-  useEffect3(() => {
-    const currentIds = new Set(attachments.map((attachment) => attachment.id));
-    for (const id of committedAttachmentIds.current) {
-      if (!currentIds.has(id)) revokePreview(id);
-    }
-    committedAttachmentIds.current = currentIds;
-  }, [attachments, revokePreview]);
-  const scopeGeneration = useRef3(0);
-  const previousScope = useRef3({ client, workspaceId });
-  useEffect3(() => {
-    const previous = previousScope.current;
-    if (previous.client === client && previous.workspaceId === workspaceId) return;
-    previousScope.current = { client, workspaceId };
-    scopeGeneration.current += 1;
-    sources.current.clear();
-    revokeAllPreviews();
-    setAttachments([]);
-  }, [client, revokeAllPreviews, workspaceId]);
-  useEffect3(
-    () => () => {
-      scopeGeneration.current += 1;
-      sources.current.clear();
-      revokeAllPreviews();
-    },
-    [revokeAllPreviews]
-  );
-  const startUpload = useCallback3(
-    (id, file) => {
-      const generation = scopeGeneration.current;
-      void client.uploadFile(workspaceId, {
-        filename: file.name || "file",
-        contentType: file.type || "application/octet-stream",
-        data: file
-      }).then((asset) => {
-        if (scopeGeneration.current !== generation) return;
-        sources.current.delete(id);
-        setAttachments(
-          (current) => current.map(
-            (attachment) => attachment.id === id ? {
-              ...attachment,
-              status: "ready",
-              file: asset,
-              name: asset.filename,
-              contentType: asset.contentType,
-              sizeBytes: asset.sizeBytes,
-              errorCode: void 0,
-              error: void 0
-            } : attachment
-          )
-        );
-      }).catch((error) => {
-        if (scopeGeneration.current !== generation) return;
-        setAttachments(
-          (current) => current.map(
-            (attachment) => attachment.id === id ? {
-              ...attachment,
-              status: "failed",
-              errorCode: secureContextRequiredErrorCode(error),
-              error: error instanceof Error ? error.message : String(error)
-            } : attachment
-          )
-        );
-      });
-    },
-    [client, workspaceId]
-  );
-  const addFiles = useCallback3(
-    (files) => {
-      for (const file of files) {
-        const id = createAttachmentId();
-        sources.current.set(id, file);
-        const previewUrl = isImage(file) ? URL.createObjectURL(file) : void 0;
-        if (previewUrl) previewUrls.current.set(id, previewUrl);
-        setAttachments((current) => [
-          ...current,
-          {
-            id,
-            name: file.name || "image",
-            contentType: file.type || "application/octet-stream",
-            sizeBytes: file.size,
-            status: "uploading",
-            ...previewUrl ? { previewUrl } : {}
-          }
-        ]);
-        startUpload(id, file);
-      }
-    },
-    [startUpload]
-  );
-  const retry = useCallback3(
-    (id) => {
-      const file = sources.current.get(id);
-      if (!file) {
-        return;
-      }
-      setAttachments(
-        (current) => current.map(
-          (attachment) => attachment.id === id ? { ...attachment, status: "uploading", errorCode: void 0, error: void 0 } : attachment
-        )
-      );
-      startUpload(id, file);
-    },
-    [startUpload]
-  );
-  const addFromPaste = useCallback3(
-    (event) => {
-      const clipboardFiles = event.clipboardData?.files;
-      if (!clipboardFiles) {
-        return;
-      }
-      const files = [...clipboardFiles].filter(pasteFilter);
-      if (files.length > 0) {
-        addFiles(files);
-      }
-    },
-    [addFiles, pasteFilter]
-  );
-  const restoreReadyFiles = useCallback3(
-    (files) => {
-      const incoming = /* @__PURE__ */ new Map();
-      for (const file of files) {
-        if (file.status === "ready" && file.workspaceId === workspaceId) {
-          incoming.set(file.id, file);
-        }
-      }
-      setAttachments((current) => {
-        const unresolved = current.filter((attachment) => attachment.status !== "ready");
-        const existingReady = new Map(
-          current.flatMap(
-            (attachment) => attachment.status === "ready" && attachment.file ? [[attachment.file.id, attachment]] : []
-          )
-        );
-        const restored = [...incoming.values()].map((file) => {
-          const existing = existingReady.get(file.id);
-          return existing ? {
-            ...existing,
-            name: file.filename,
-            contentType: file.contentType,
-            sizeBytes: file.sizeBytes,
-            status: "ready",
-            file,
-            errorCode: void 0,
-            error: void 0
-          } : {
-            id: `restored:${file.id}`,
-            name: file.filename,
-            contentType: file.contentType,
-            sizeBytes: file.sizeBytes,
-            status: "ready",
-            file
-            // No source File and no object URL: server metadata is the
-            // only authority restored across page/device boundaries.
-          };
-        });
-        return [...unresolved, ...restored];
-      });
-    },
-    [workspaceId]
-  );
-  const remove = useCallback3(
-    (id) => {
-      sources.current.delete(id);
-      revokePreview(id);
-      setAttachments((current) => current.filter((attachment) => attachment.id !== id));
-    },
-    [revokePreview]
-  );
-  const removeReadyFiles = useCallback3((fileIds) => {
-    const accepted = new Set(fileIds);
-    if (accepted.size === 0) return;
-    setAttachments(
-      (current) => current.filter((attachment) => {
-        return !(attachment.status === "ready" && attachment.file !== void 0 && accepted.has(attachment.file.id));
-      })
-    );
-  }, []);
-  const clear = useCallback3(() => {
-    sources.current.clear();
-    revokeAllPreviews();
-    setAttachments([]);
-  }, [revokeAllPreviews]);
-  return {
-    attachments,
-    readyResources: attachments.flatMap(
-      (attachment) => attachment.status === "ready" && attachment.file ? [{ kind: "file", fileId: attachment.file.id }] : []
-    ),
-    uploading: attachments.some((attachment) => attachment.status === "uploading"),
-    hasUnresolved: attachments.some((attachment) => attachment.status !== "ready"),
-    addFiles,
-    addFromPaste,
-    restoreReadyFiles,
-    retry,
-    retainPreview,
-    remove,
-    removeReadyFiles,
-    clear
-  };
-}
-
-// src/hooks/use-turn-queue.ts
-import { useCallback as useCallback4, useEffect as useEffect4, useLayoutEffect, useMemo as useMemo3, useRef as useRef4, useState as useState4 } 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] = useState4(null);
-  const [stateTargetKey, setStateTargetKey] = useState4(targetKey);
-  const [loading, setLoading] = useState4(enabled);
-  const [error, setError] = useState4(null);
-  const [mutationError, setMutationError] = useState4(null);
-  const [pendingByTurn, setPendingByTurn] = useState4({});
-  const [acceptedSteers, setAcceptedSteers] = useState4([]);
-  const pendingRef = useRef4({});
-  const readGeneration = useRef4(0);
-  const targetKeyRef = useRef4(targetKey);
-  const snapshotRef = useRef4(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]);
-  useEffect4(() => {
-    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 = 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) => {
-      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]
-  );
-  useEffect4(() => {
-    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]);
-  useEffect4(() => {
-    if (enabled && workspaceControlEvent) void load();
-  }, [enabled, load, workspaceControlEvent]);
-  useEffect4(() => {
-    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 = useCallback4(
-    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 = 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 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("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 = 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 = identityMatches ? snapshot : null;
-  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: identityMatches ? loading : enabled,
-    error: identityMatches ? error : null,
-    refresh: load,
-    moveTurn,
-    editTurn,
-    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 cause instanceof Error ? cause : new Error(String(cause));
-}
-function isOutcomeUnknownError(cause) {
-  return typeof cause === "object" && cause !== null && cause.outcomeUnknown === true;
-}
-
-// src/hooks/use-goal.ts
-import { OpenGeniApiError } from "@opengeni/sdk";
-import { useCallback as useCallback5, useEffect as useEffect5, useRef as useRef5, useState as useState5 } 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] = useState5(null);
-  const [loading, setLoading] = useState5(enabled);
-  const [error, setError] = useState5(null);
-  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
-  const generation = useRef5(0);
-  const targetKeyRef = useRef5(null);
-  const loadAbort = useRef5(null);
-  const retireLoads = useCallback5(() => {
-    generation.current += 1;
-    loadAbort.current?.abort();
-    loadAbort.current = null;
-  }, []);
-  const load = useCallback5(async () => {
-    if (!sessionId) {
-      return;
-    }
-    const ticket = ++generation.current;
-    loadAbort.current?.abort();
-    const controller = new AbortController();
-    loadAbort.current = controller;
-    try {
-      const fetched = await client.getGoal(workspaceId, sessionId, {
-        signal: controller.signal
-      });
-      if (ticket === generation.current) {
-        setGoal(fetched);
-        setError(null);
-        setLoading(false);
-      }
-    } catch (cause) {
-      if (ticket !== generation.current) {
-        return;
-      }
-      if (cause instanceof OpenGeniApiError && cause.status === 404) {
-        setGoal(null);
-        setError(null);
-      } else {
-        setError(cause instanceof Error ? cause : new Error(String(cause)));
-      }
-      setLoading(false);
-    } finally {
-      if (loadAbort.current === controller) loadAbort.current = null;
-    }
-  }, [client, workspaceId, sessionId]);
-  useEffect5(() => {
-    const targetKey = `${workspaceId} ${sessionId ?? ""}`;
-    if (targetKeyRef.current !== targetKey) {
-      targetKeyRef.current = targetKey;
-      setGoal(null);
-      setError(null);
-    }
-    if (!enabled || !pageLive) {
-      retireLoads();
-      setLoading(false);
-      return;
-    }
-    if (sharedFeed) {
-      setLoading(false);
-      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(() => void load());
-  useSessionEventTrigger(client, workspaceId, sessionId, isGoalRefreshEvent, scheduleRefresh, {
-    enabled,
-    ...sharedEvents !== void 0 ? { events: sharedEvents } : {}
-  });
-  const pause = useCallback5(
-    async (rationale) => {
-      if (!sessionId) {
-        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]
-  );
-  const resume = useCallback5(async () => {
-    if (!sessionId) {
-      return null;
-    }
-    const result = await run(() => client.updateGoal(workspaceId, sessionId, { status: "active" }));
-    if (result) {
-      setGoal(result);
-    }
-    return result;
-  }, [client, workspaceId, sessionId, run]);
-  const clearGoal = useCallback5(async () => {
-    if (!sessionId) {
-      return;
-    }
-    const ok = await run(async () => {
-      await client.deleteGoal(workspaceId, sessionId);
-      return true;
-    });
-    if (ok) {
-      retireLoads();
-      setGoal(null);
-      setError(null);
-    }
-  }, [client, workspaceId, sessionId, run, retireLoads]);
-  return {
-    goal,
-    isActive: goal?.status === "active",
-    isPaused: goal?.status === "paused",
-    isCompleted: goal?.status === "completed",
-    loading,
-    error,
-    refresh: load,
-    pause,
-    resume,
-    clearGoal,
-    deleteGoal: clearGoal,
-    updating: mutating,
-    mutationError,
-    clearMutationError
-  };
-}
-
-// src/hooks/use-session-control.ts
-import { useCallback as useCallback6, useLayoutEffect as useLayoutEffect2, useRef as useRef6 } from "react";
-function useSessionControl(sessionId, options = {}) {
-  const { client, workspaceId } = useEmbeddedSession(options);
-  const approvalTargetKey = `${workspaceId}\0${sessionId ?? ""}`;
-  const pendingApproval = useRef6(null);
-  useLayoutEffect2(() => {
-    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) => {
-      if (!sessionId) {
-        return null;
-      }
-      const decisionKey = JSON.stringify([approvalId, decision, message ?? 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 } : {},
-          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) => await decide(approvalId, "approve", message),
-    [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-session-mcp-approval-policy.ts
-import { useCallback as useCallback7, useEffect as useEffect6, useLayoutEffect as useLayoutEffect3, useMemo as useMemo4, useRef as useRef7, useState as useState6 } from "react";
-function isSessionMcpApprovalPolicyEvent(event, serverId) {
-  if (event.type !== "session.mcp.approval_policy.updated") {
-    return false;
-  }
-  if (serverId === void 0) {
-    return true;
-  }
-  const payload = event.payload;
-  return payload?.serverId === serverId;
-}
-function useSessionMcpApprovalPolicy(sessionId, serverId, options = {}) {
-  const { client, workspaceId } = useEmbeddedSessionMcpApprovalPolicy(options);
-  const enabled = (options.enabled ?? true) && Boolean(sessionId && serverId);
-  const [override, setOverride] = useState6(null);
-  const targetKey = `${workspaceId}\0${sessionId ?? ""}\0${serverId ?? ""}`;
-  const authoritativeGeneration = useRef7(0);
-  const mutationIdentity = useMemo4(() => ({ client, targetKey }), [client, targetKey]);
-  const { run, mutating, mutationError, clearMutationError } = useMutationRunner(mutationIdentity);
-  useLayoutEffect3(() => {
-    authoritativeGeneration.current += 1;
-    setOverride(null);
-  }, [client, targetKey]);
-  const load = useCallback7(async () => {
-    const generation = authoritativeGeneration.current;
-    if (!sessionId || !serverId) {
-      return { targetKey, generation, server: null };
-    }
-    const session = await client.getSession(workspaceId, sessionId);
-    return {
-      targetKey,
-      generation,
-      server: session.mcpServers.find((server2) => server2.id === serverId) ?? null
-    };
-  }, [client, serverId, sessionId, targetKey, workspaceId]);
-  const {
-    data,
-    loading,
-    error: loadError,
-    refresh
-  } = usePolledValue(load, {
-    enabled,
-    pollIntervalMs: options.pollIntervalMs
-  });
-  useEffect6(() => {
-    if (data?.targetKey === targetKey && data.generation === authoritativeGeneration.current) {
-      setOverride(null);
-    }
-  }, [data, targetKey]);
-  const scheduleRefresh = useDebouncedCallback(() => void refresh());
-  const matchesPolicyEvent = useCallback7(
-    (event) => isSessionMcpApprovalPolicyEvent(event, serverId ?? void 0),
-    [serverId]
-  );
-  useSessionEventTrigger(
-    client,
-    workspaceId,
-    sessionId,
-    matchesPolicyEvent,
-    scheduleRefresh,
-    {
-      enabled,
-      ...options.events !== void 0 ? { events: options.events } : {}
-    },
-    async () => await refresh()
-  );
-  const update = useCallback7(
-    async (policy) => {
-      if (!sessionId || !serverId) {
-        return null;
-      }
-      const response = await run(
-        () => client.updateSessionMcpApprovalPolicy(workspaceId, sessionId, serverId, {
-          requireApproval: policy
-        })
-      );
-      if (response) {
-        authoritativeGeneration.current += 1;
-        setOverride(response.server);
-        void refresh();
-      }
-      return response;
-    },
-    [client, refresh, run, serverId, sessionId, workspaceId]
-  );
-  const server = override ?? data?.server ?? null;
-  return {
-    server,
-    policy: server?.requireApproval ?? null,
-    loading,
-    error: mutationError ?? loadError,
-    refresh: async () => {
-      await refresh();
-    },
-    update,
-    updating: mutating,
-    clearError: clearMutationError
-  };
-}
-
-// src/hooks/use-session-lineage.ts
-import { useCallback as useCallback8, useEffect as useEffect7, useRef as useRef8 } from "react";
-function isLineageRefreshEvent(event) {
-  if (event.type === "session.status.changed" || event.type === "session.created") {
-    return true;
-  }
-  if (event.type === "agent.toolCall.output") {
-    const payload = event.payload;
-    const name = typeof payload?.name === "string" ? payload.name : typeof payload?.toolName === "string" ? payload.toolName : "";
-    return name === "session_create" || name.endsWith("__session_create");
-  }
-  return false;
-}
-function isSessionCreateToolCallCreated(event) {
-  if (event.type !== "agent.toolCall.created") {
-    return false;
-  }
-  const payload = event.payload;
-  const name = typeof payload?.name === "string" ? payload.name : typeof payload?.toolName === "string" ? payload.toolName : "";
-  return name === "session_create" || name.endsWith("__session_create");
-}
-function useSessionLineage(sessionId, options = {}) {
-  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSessionLineage(options);
-  const enabled = (options.enabled ?? true) && Boolean(sessionId);
-  const nextReadGeneration = useRef8(0);
-  const beginRead = options.beginRead;
-  const load = useCallback8(
-    async (signal) => {
-      if (!sessionId) {
-        return {
-          lineage: { ancestors: [], children: [], truncated: false },
-          readGeneration: 0
-        };
-      }
-      let readGeneration = 0;
-      const lineage = await client.getSessionLineage(workspaceId, sessionId, {
-        signal,
-        onRequestStart: (sharedReadGeneration) => {
-          readGeneration = sharedReadGeneration ?? beginRead?.() ?? ++nextReadGeneration.current;
-        }
-      });
-      return {
-        lineage,
-        readGeneration
-      };
-    },
-    [beginRead, client, workspaceId, sessionId]
-  );
-  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled });
-  const refresh = state.refresh;
-  useEffect7(() => {
-    if (enabled && workspaceControlEvent) void refresh();
-  }, [enabled, refresh, workspaceControlEvent]);
-  useEffect7(() => {
-    if (!sessionId || !enabled) return;
-    return registerSessionReconciler(sessionId, "lineage", refresh);
-  }, [enabled, refresh, registerSessionReconciler, sessionId]);
-  const refreshSoon = useDebouncedCallback(() => void refresh(), 150);
-  const delayedChildRefreshRef = useRef8(null);
-  useEffect7(() => {
-    return () => {
-      if (delayedChildRefreshRef.current !== null) {
-        clearTimeout(delayedChildRefreshRef.current);
-        delayedChildRefreshRef.current = null;
-      }
-    };
-  }, [sessionId, workspaceId]);
-  const refreshAfterChildCreate = useCallback8(() => {
-    void refresh();
-    if (delayedChildRefreshRef.current !== null) {
-      clearTimeout(delayedChildRefreshRef.current);
-    }
-    delayedChildRefreshRef.current = setTimeout(() => {
-      delayedChildRefreshRef.current = null;
-      void refresh();
-    }, 2500);
-  }, [refresh]);
-  useSessionEventTrigger(
-    client,
-    workspaceId,
-    sessionId,
-    isLineageRefreshEvent,
-    refreshSoon,
-    // SHARED-FEED ONLY: without a caller-provided events log the trigger would
-    // open its OWN streamEvents tail — a second live SSE connection next to the
-    // session route's useSessionEvents. A caller with no feed opts into polling
-    // (pollIntervalMs), never a duplicate stream.
-    { events: options.events, enabled: enabled && options.events !== void 0 }
-  );
-  useSessionEventTrigger(
-    client,
-    workspaceId,
-    sessionId,
-    isSessionCreateToolCallCreated,
-    refreshAfterChildCreate,
-    { events: options.events, enabled: enabled && options.events !== void 0 }
-  );
-  return {
-    lineage: state.data?.lineage ?? null,
-    loading: state.loading,
-    error: state.error,
-    readGeneration: state.data?.readGeneration ?? 0,
-    refresh
-  };
-}
-
-// src/approvals.ts
-function approvalsFromRequiresAction(payload) {
-  const approvals = payload && typeof payload === "object" ? payload.approvals : void 0;
-  if (!Array.isArray(approvals)) {
-    return [];
-  }
-  return approvals.map((approval, index) => {
-    const raw = approval && typeof approval === "object" ? approval : {};
-    const rawItem = raw.rawItem && typeof raw.rawItem === "object" ? raw.rawItem : {};
-    return {
-      // Mirror the runtime's canonical interruption identity before retaining
-      // the legacy top-level callId fallback for already-normalized payloads.
-      id: String(rawItem.callId ?? rawItem.id ?? raw.id ?? raw.callId ?? raw.name ?? index),
-      name: String(raw.name ?? raw.toolName ?? rawItem.name ?? "approval"),
-      arguments: raw.arguments ?? rawItem.arguments,
-      raw: approval
-    };
-  });
-}
-function projectPendingApprovals(events) {
-  let pending = [];
-  let owningTurnId = null;
-  for (const event of events) {
-    switch (event.type) {
-      case "session.requiresAction": {
-        pending = approvalsFromRequiresAction(event.payload);
-        owningTurnId = event.turnId ?? null;
-        break;
-      }
-      case "user.approvalDecision": {
-        const payload = event.payload && typeof event.payload === "object" ? event.payload : {};
-        if (typeof payload.approvalId === "string") {
-          pending = pending.filter((approval) => approval.id !== payload.approvalId);
-        }
-        break;
-      }
-      case "turn.completed":
-      case "turn.failed":
-      case "turn.cancelled": {
-        if (owningTurnId === null || event.turnId == null || event.turnId === owningTurnId) {
-          pending = [];
-          owningTurnId = null;
-        }
-        break;
-      }
-      default:
-        break;
-    }
-  }
-  return pending;
-}
-
-// src/hooks/use-human-input.ts
-import { useCallback as useCallback9, useEffect as useEffect8, useRef as useRef9, useState as useState7 } 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 = useCallback9(
-    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] = useState7(null);
-  const [deadlineVersion, setDeadlineVersion] = useState7(0);
-  const respondingRequestRef = useRef9(null);
-  useEffect8(() => {
-    respondingRequestRef.current = null;
-    setRespondingRequestId(null);
-  }, [sessionId, workspaceId]);
-  useEffect8(() => {
-    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 } : {}
-  });
-  useEffect8(() => {
-    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 = useCallback9(
-    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 {
-  createEmbeddedSessionClient,
-  isTitleEvent,
-  useSession,
-  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,
-  useFileAttachments,
-  isTurnQueueEvent,
-  useTurnQueue,
-  isGoalEvent,
-  useGoal,
-  useSessionControl,
-  isSessionMcpApprovalPolicyEvent,
-  useSessionMcpApprovalPolicy,
-  isLineageRefreshEvent,
-  useSessionLineage,
-  approvalsFromRequiresAction,
-  projectPendingApprovals,
-  isHumanInputEvent,
-  useHumanInputRequests
-};
-//# sourceMappingURL=chunk-IB27C53Y.js.map