@opengeni/react 3.1.0 → 3.1.3-canary.38890816741001

package/dist/{chunk-YJFGAFBD.js → chunk-X5UVUIMF.js}

@@ -1,133 +1,671 @@
+"use client";
 import {
   buildTimeline,
-  createOlderHistoryLoadReceipt,
   groupTimeline,
-  isActionableHumanInputRequest,
   sessionStatusFromEvents
-} from "./chunk-D3UIAJKY.js";
+} from "./chunk-2SFFYIH3.js";
+import {
+  isActionableHumanInputRequest
+} from "./chunk-IZV5FTJC.js";
+import {
+  FILE_ONLY_MESSAGE_TEXT,
+  notifyObserver,
+  useComposer
+} from "./chunk-V5ZUJT2T.js";
+import {
+  coerceReasoningEffortForModel,
+  defaultEffortForModel,
+  projectPickerRows,
+  runnableLatencyModesForModel,
+  sortPickerRows
+} from "./chunk-KF33GTWN.js";
 import {
   useDebouncedCallback,
   useMutationRunner,
   usePageLiveActivity,
   usePolledValue,
   useSessionEventTrigger
-} from "./chunk-KZ73RL76.js";
+} from "./chunk-QHUE7E4N.js";
+import {
+  normalizeError,
+  useErrorMessage
+} from "./chunk-CM7LVUKC.js";
 import {
   useEmbeddedFileAttachments,
   useEmbeddedGoal,
   useEmbeddedHumanInputSession,
   useEmbeddedSession,
-  useEmbeddedSessionLineage,
-  useEmbeddedSessionMcpApprovalPolicy,
-  useEmbeddedSessionRead
-} from "./chunk-NEXLLTP4.js";
+  useEmbeddedSessionRead,
+  useOpenGeni,
+  useOpenGeniClient
+} from "./chunk-G76LSA76.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}`);
+// src/approvals.ts
+import {
+  parseToolDisplayMetadata
+} from "@opengeni/sdk";
+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 : {};
+    const display = parseToolDisplayMetadata(raw.display);
+    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"),
+      ...display ? { display } : {},
+      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;
     }
-    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
+  return pending;
+}
+
+// src/older-history.ts
+var activeReceiptCapture;
+var preserveTailForAutomaticLoad = false;
+function invokeOlderHistoryLoaderWithReceiptCapture(load, capture, preserveTail = false) {
+  const previousCapture = activeReceiptCapture;
+  const previousPreserveTail = preserveTailForAutomaticLoad;
+  activeReceiptCapture = capture;
+  preserveTailForAutomaticLoad = preserveTail;
+  try {
+    return load();
+  } finally {
+    activeReceiptCapture = previousCapture;
+    preserveTailForAutomaticLoad = previousPreserveTail;
+  }
+}
+function createOlderHistoryLoadReceipt(load) {
+  let resolveResult;
+  let rejectResult;
+  const result = new Promise((resolve, reject) => {
+    resolveResult = resolve;
+    rejectResult = reject;
+  });
+  result.committed = false;
+  result.tailPreserved = false;
+  activeReceiptCapture?.(result);
+  try {
+    const loaded = load(
+      () => {
+        result.committed = true;
+      },
+      preserveTailForAutomaticLoad,
+      () => {
+        result.tailPreserved = true;
+      }
     );
+    Promise.resolve(loaded).then(resolveResult, rejectResult);
+  } catch (error) {
+    rejectResult(error);
   }
-  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
+  return result;
+}
+
+// src/conversation-timeline.ts
+function conversationTimeline(items, queue, composer) {
+  const queued = new Set(
+    queue.queue.filter((turn) => turn.metadata.delivery !== "steer").map((turn) => turn.triggerEventId)
+  );
+  const pending = composer.optimisticMessages ?? [];
+  const pendingQueue = new Set(
+    pending.filter(
+      (message) => message.destination === "queue" && !(message.turnId && message.appliedQueueVersion != null && queue.snapshot && queue.snapshot.version >= message.appliedQueueVersion && !queue.queue.some((turn) => turn.id === message.turnId))
+    ).map((message) => `user-message:${message.clientEventId}`)
+  );
+  const visible = items.filter(
+    (item) => item.kind !== "user-message" || !queued.has(item.id) && !pendingQueue.has(item.reconciliationKey ?? "")
+  );
+  const keys = new Set(
+    visible.flatMap((item) => item.kind === "user-message" ? [item.reconciliationKey] : [])
+  );
+  const optimistic = pending.filter(
+    (message) => (message.destination === "chat" || message.state === "failed") && !keys.has(`user-message:${message.clientEventId}`) && !queue.queue.some((turn) => turn.id === message.turnId)
+  ).map((message) => ({
+    kind: "user-message",
+    id: `optimistic:${message.clientEventId}`,
+    reconciliationKey: `user-message:${message.clientEventId}`,
+    text: message.text,
+    annotations: message.annotations.map((annotation, ordinal) => ({ ...annotation, ordinal })),
+    resources: message.resources,
+    tools: [],
+    occurredAt: message.occurredAt,
+    delivery: {
+      state: message.state,
+      ...message.error ? { error: message.error } : {},
+      ...message.state === "failed" ? {
+        ...message.retryable !== false && composer.retryOptimisticMessage ? { onRetry: () => composer.retryOptimisticMessage?.(message.clientEventId) } : {},
+        ...message.retryable === false && composer.restoreOptimisticMessage ? { onEdit: () => composer.restoreOptimisticMessage?.(message.clientEventId) } : {},
+        onRemove: () => composer.removeOptimisticMessage?.(message.clientEventId)
+      } : {}
+    }
+  }));
+  const ids = new Set(visible.map((item) => item.id));
+  const steers = (queue.acceptedSteers ?? []).filter((steer) => !ids.has(steer.triggerEventId)).map((steer) => ({
+    kind: "user-message",
+    id: steer.triggerEventId,
+    text: steer.text,
+    annotations: steer.annotations,
+    resources: steer.resources,
+    tools: steer.tools,
+    occurredAt: steer.occurredAt,
+    delivery: { state: steer.state }
+  }));
+  return [...visible, ...optimistic, ...steers];
+}
+
+// src/hooks/use-available-models.ts
+import { useCallback } from "react";
+function useAvailableModels(options = {}) {
+  const client = useOpenGeniClient(options);
+  const load = useCallback(
+    async (signal) => await client.getClientConfig({ signal }),
+    [client]
+  );
+  const state = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled
   });
-  const saveComposerDraft = client.saveComposerDraft;
-  client.saveComposerDraft = async (workspaceId, sessionId, request) => mapDraft(await saveComposerDraft(workspaceId, sessionId, request), {
-    operation: "save",
-    workspaceId,
-    sessionId
+  return {
+    models: state.data?.models ?? [],
+    defaultModel: state.data?.defaultModel ?? null,
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh
+  };
+}
+function useWorkspaceModelCatalog(options) {
+  const client = useOpenGeniClient(options);
+  const load = useCallback(
+    async (signal) => {
+      if (!options.workspaceId) {
+        return { models: [], defaultModel: null };
+      }
+      const [catalog, config] = await Promise.all([
+        client.getWorkspaceModelCatalog(options.workspaceId, { signal }),
+        client.getClientConfig({ signal, workspaceId: options.workspaceId })
+      ]);
+      return {
+        models: catalog.models,
+        defaultModel: config.defaultModel
+      };
+    },
+    [client, options.workspaceId]
+  );
+  const state = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled !== false && Boolean(options.workspaceId)
   });
-  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
+  const rows = sortPickerRows(projectPickerRows(state.data?.models ?? []));
+  return {
+    models: state.data?.models ?? [],
+    rows,
+    defaultModel: state.data?.defaultModel ?? null,
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh
+  };
+}
+
+// src/hooks/use-file-attachments.ts
+import { useCallback as useCallback2, useEffect, useRef, useState } 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 formatError = useErrorMessage();
+  const pasteFilter = options.pasteFilter ?? isImage;
+  const [attachments, setAttachments] = useState([]);
+  const attachmentsRef = useRef(attachments);
+  attachmentsRef.current = attachments;
+  const sources = useRef(/* @__PURE__ */ new Map());
+  const previewUrls = useRef(/* @__PURE__ */ new Map());
+  const previewRetainers = useRef(/* @__PURE__ */ new Map());
+  const pendingPreviewRevocations = useRef(/* @__PURE__ */ new Set());
+  const revokePreview = useCallback2((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 = useCallback2(() => {
+    for (const id of previewUrls.current.keys()) revokePreview(id);
+  }, [revokePreview]);
+  const retainPreview = useCallback2(
+    (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 = useRef(/* @__PURE__ */ new Set());
+  useEffect(() => {
+    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 = useRef(0);
+  const previousScope = useRef({ client, workspaceId });
+  useEffect(() => {
+    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]);
+  useEffect(
+    () => () => {
+      scopeGeneration.current += 1;
+      sources.current.clear();
+      revokeAllPreviews();
+    },
+    [revokeAllPreviews]
+  );
+  const startUpload = useCallback2(
+    (id, file) => {
+      const generation = scopeGeneration.current;
+      void client.uploadFile(workspaceId, {
+        filename: file.name || "file",
+        contentType: file.type || "application/octet-stream",
+        data: file,
+        ...options.scope ? { scope: options.scope } : {}
+      }).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,
+              errorCause: 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: formatError(error),
+              errorCause: error
+            } : attachment
+          )
+        );
+      });
+    },
+    [client, workspaceId, options.scope, formatError]
+  );
+  const addFiles = useCallback2(
+    (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 = useCallback2(
+    (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,
+            errorCause: void 0
+          } : attachment
+        )
+      );
+      startUpload(id, file);
+    },
+    [startUpload]
+  );
+  const addFromPaste = useCallback2(
+    (event) => {
+      const clipboardFiles = event.clipboardData?.files;
+      if (!clipboardFiles) {
+        return;
+      }
+      const files = [...clipboardFiles].filter(pasteFilter);
+      if (files.length > 0) {
+        addFiles(files);
+      }
+    },
+    [addFiles, pasteFilter]
+  );
+  const restoreReadyFiles = useCallback2(
+    (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,
+            errorCause: 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 loadPreview = useCallback2(
+    async (id, signal) => {
+      const generation = scopeGeneration.current;
+      const attachment = attachmentsRef.current.find((candidate) => candidate.id === id);
+      const createDownloadUrl = client.createFileDownloadUrl;
+      if (!attachment || attachment.status !== "ready" || !attachment.file || !attachment.contentType.startsWith("image/") || typeof createDownloadUrl !== "function" || signal?.aborted) {
+        return void 0;
+      }
+      const fileId = attachment.file.id;
+      const signed = await createDownloadUrl.call(client, workspaceId, fileId, { signal });
+      if (scopeGeneration.current !== generation || signal?.aborted) return void 0;
+      const current = attachmentsRef.current.find((candidate) => candidate.id === id);
+      if (current?.status !== "ready" || current.file?.id !== fileId) return void 0;
+      return signed.url;
+    },
+    [client, workspaceId]
+  );
+  const remove = useCallback2(
+    (id) => {
+      sources.current.delete(id);
+      revokePreview(id);
+      setAttachments((current) => current.filter((attachment) => attachment.id !== id));
+    },
+    [revokePreview]
+  );
+  const removeReadyFiles = useCallback2((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 = useCallback2(() => {
+    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,
+    ...typeof client.createFileDownloadUrl === "function" ? { loadPreview } : {},
+    retry,
+    retainPreview,
+    remove,
+    removeReadyFiles,
+    clear
+  };
+}
+
+// src/hooks/use-human-input.ts
+import { useCallback as useCallback3, useEffect as useEffect2, useRef as useRef2, useState as useState2 } 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 = useCallback3(
+    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] = useState2(null);
+  const [deadlineVersion, setDeadlineVersion] = useState2(0);
+  const respondingRequestRef = useRef2(null);
+  useEffect2(() => {
+    respondingRequestRef.current = null;
+    setRespondingRequestId(null);
+  }, [sessionId, workspaceId]);
+  useEffect2(() => {
+    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 } : {}
+  });
+  useEffect2(() => {
+    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 = useCallback3(
+    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
   };
-  return client;
 }
 
 // src/hooks/use-session.ts
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useCallback as useCallback4, useEffect as useEffect3, useMemo, useRef as useRef3, useState as useState3 } from "react";
 function isTitleEvent(event) {
   return event.type === "session.title_set";
 }
+function isSessionDetailEvent(event) {
+  return isTitleEvent(event) || event.type.startsWith("session.command.") || event.type.startsWith("session.wait.") || event.type === "session.status.changed" || event.type === "system.update.pending";
+}
 function useSession(sessionId, options = {}) {
   const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } = useEmbeddedSessionRead(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
-  const [override, setOverride] = useState(null);
-  const nextReadRevision = useRef(0);
-  const nextReadGeneration = useRef(0);
+  const [override, setOverride] = useState3(null);
+  const nextReadRevision = useRef3(0);
+  const nextReadGeneration = useRef3(0);
   const beginRead = options.beginRead;
   const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
-  const load = useCallback(async () => {
-    if (!sessionId) {
-      return null;
-    }
-    let readGeneration2 = 0;
-    const fetched = await client.getSession(workspaceId, sessionId, {
-      fresh: true,
-      onRequestStart: () => {
-        readGeneration2 = beginRead?.() ?? ++nextReadGeneration.current;
+  const load = useCallback4(
+    async (signal) => {
+      if (!sessionId) {
+        return null;
       }
-    });
-    setOverride(null);
-    return {
-      session: fetched,
-      revision: ++nextReadRevision.current,
-      readGeneration: readGeneration2
-    };
-  }, [beginRead, client, workspaceId, sessionId]);
+      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(() => {
+  useEffect3(() => {
     if (enabled && workspaceControlEvent) void refresh();
   }, [enabled, refresh, workspaceControlEvent]);
-  useEffect(() => {
+  useEffect3(() => {
     if (!sessionId || !enabled) return;
     return registerSessionReconciler(sessionId, "session", refresh);
   }, [enabled, refresh, registerSessionReconciler, sessionId]);
@@ -138,8 +676,17 @@ function useSession(sessionId, options = {}) {
     () => base && override && override.id === base.id ? { ...base, title: override.title, titleSource: override.titleSource } : base,
     [base, override]
   );
-  const onTitleEvent = useCallback(
+  const sharedEvents = options.events;
+  const onTitleEvent = useCallback4(
     (event) => {
+      if (sharedEvents?.some(
+        (item) => item.sessionId === sessionId && !isTitleEvent(item) && isSessionDetailEvent(item) && item.sequence > (base?.lastSequence ?? -1)
+      )) {
+        void refresh();
+      } else if (!isTitleEvent(event)) {
+        if (!base || event.sequence > base.lastSequence) void refresh();
+        return;
+      }
       if (!base || event.sequence <= base.lastSequence) {
         return;
       }
@@ -154,13 +701,13 @@ function useSession(sessionId, options = {}) {
         return { ...next, title, titleSource: source };
       });
     },
-    [base]
+    [base, refresh, sharedEvents, sessionId]
   );
-  useSessionEventTrigger(client, workspaceId, sessionId, isTitleEvent, onTitleEvent, {
+  useSessionEventTrigger(client, workspaceId, sessionId, isSessionDetailEvent, onTitleEvent, {
     enabled,
     ...options.events !== void 0 ? { events: options.events } : {}
   });
-  const updateTitle = useCallback(
+  const updateTitle = useCallback4(
     async (title) => {
       if (!sessionId) {
         return null;
@@ -187,12 +734,109 @@ function useSession(sessionId, options = {}) {
   };
 }
 
+// src/hooks/use-session-control.ts
+import { useCallback as useCallback5, useLayoutEffect, useRef as useRef4 } from "react";
+function useSessionControl(sessionId, options = {}) {
+  const { client, workspaceId } = useEmbeddedSession(options);
+  const approvalTargetKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const pendingApproval = useRef4(null);
+  useLayoutEffect(() => {
+    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 = useCallback5(
+    async (reason) => {
+      if (!sessionId) {
+        return null;
+      }
+      return await runControl(
+        () => client.pauseSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
+      );
+    },
+    [client, workspaceId, sessionId, runControl]
+  );
+  const resume = useCallback5(
+    async (reason) => {
+      if (!sessionId) return null;
+      return await runControl(
+        () => client.resumeSession(workspaceId, sessionId, reason !== void 0 ? { reason } : {})
+      );
+    },
+    [client, workspaceId, sessionId, runControl]
+  );
+  const decide = useCallback5(
+    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 = useCallback5(
+    async (approvalId, message) => await decide(approvalId, "approve", message),
+    [decide]
+  );
+  const reject = useCallback5(
+    async (approvalId, message) => await decide(approvalId, "reject", message),
+    [decide]
+  );
+  const error = approvalError ?? controlError;
+  const clearError = useCallback5(() => {
+    clearControlError();
+    clearApprovalError();
+  }, [clearControlError, clearApprovalError]);
+  return {
+    pause,
+    resume,
+    controlling,
+    approve,
+    reject,
+    responding,
+    error,
+    clearError
+  };
+}
+
 // src/hooks/use-session-events.ts
-import { 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;
+import {
+  sessionEventStreamCoveredThrough
+} from "@opengeni/sdk";
+import { startTransition, useCallback as useCallback6, useEffect as useEffect4, useMemo as useMemo2, useRef as useRef5, useState as useState4 } from "react";
+var SESSION_HISTORY_PAGE_SIZE = 1e3;
 var INITIAL_FETCH_CAP = 1;
 var OLDER_GROUP_TARGET = 32;
 var OLDER_FETCH_CAP = 2;
@@ -200,35 +844,16 @@ 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 BOUNDARY_PAGE_CAP = 1;
+var FOREGROUND_DIRECT_REPLAY_MAX_SEQUENCES = 16;
+var FOREGROUND_COMPACT_PROBE_MAX_SEQUENCES = SESSION_HISTORY_PAGE_SIZE;
+var FOREGROUND_COMPACT_CATCHUP_MAX_EVENTS = 128;
+var FOREGROUND_COMPACT_CATCHUP_MAX_GROUPS = 16;
+var FOREGROUND_COMPACT_CATCHUP_MAX_BYTES = 512 * 1024;
 var EMPTY_EVENTS = [];
 var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-var BROWSER_EVENT_TYPE_MAX_BYTES = 256;
-var BROWSER_EVENT_ID_MAX_BYTES = 256;
-var BROWSER_EVENT_CLIENT_ID_MAX_BYTES = 4 * 1024;
-var BROWSER_EVENT_DUPLICATE_REASON_MAX_BYTES = 4 * 1024;
-var BROWSER_EVENT_PAYLOAD_PREVIEW_MAX_BYTES = 48 * 1024;
-var BROWSER_EVENT_PAYLOAD_IDENTITY_FIELDS = [
-  "id",
-  "callId",
-  "call_id",
-  "name",
-  "toolName",
-  "status",
-  "code",
-  "isError",
-  "stream",
-  "commandId",
-  "sequence",
-  "coalescedUntil",
-  "coalescedCount",
-  "firstSequence",
-  "lastSequence"
-];
-var SESSION_EVENT_BROWSER_MAX_BYTES = 8 * 1024 * 1024;
-var SESSION_EVENT_BROWSER_MAX_COUNT = 1e4;
-var SESSION_EVENT_BROWSER_SINGLE_EVENT_MAX_BYTES = 96 * 1024;
+var SESSION_EVENT_BROWSER_MAX_BYTES = 16 * 1024 * 1024;
+var SESSION_EVENT_BROWSER_MAX_COUNT = 2e4;
 var SESSION_EVENT_BROWSER_PENDING_MAX_BYTES = 1024 * 1024;
 var SESSION_EVENT_BROWSER_PENDING_MAX_COUNT = 256;
 var EMPTY_EVENT_WINDOW = {
@@ -245,43 +870,75 @@ function useSessionEvents(sessionId, options = {}) {
   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(
+  const navigationIdentityRef = useRef5({ client, streamKey, enabled });
+  if (navigationIdentityRef.current.client !== client || navigationIdentityRef.current.streamKey !== streamKey || navigationIdentityRef.current.enabled !== enabled) {
+    navigationIdentityRef.current = { client, streamKey, enabled };
+  }
+  const navigationIdentity = navigationIdentityRef.current;
+  const ownsNavigation = useCallback6(
+    () => navigationIdentityRef.current === navigationIdentity,
+    [navigationIdentity]
+  );
+  const [eventWindow, setEventWindow] = useState4(EMPTY_EVENT_WINDOW);
+  const [questionEvidence, setQuestionEvidence] = useState4(null);
+  const [connectionState, setConnectionState] = useState4("idle");
+  const [error, setError] = useState4(null);
+  const [newerError, setNewerError] = useState4(null);
+  const [hasOlder, setHasOlder] = useState4(false);
+  const [hasNewer, setHasNewer] = useState4(false);
+  const [sessionStatusProjection, setSessionStatusProjection] = useState4(
     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 streamAbortRef = useRef2(null);
-  const streamKeyRef = useRef2(null);
-  const generationRef = useRef2(0);
-  const eventWindowRef = useRef2(EMPTY_EVENT_WINDOW);
-  const sessionStatusRef = useRef2({
+  const [initialLoading, setInitialLoading] = useState4(true);
+  const [initialHistoryReady, setInitialHistoryReady] = useState4(false);
+  const [loadingOlder, setLoadingOlder] = useState4(false);
+  const [loadingNewer, setLoadingNewer] = useState4(false);
+  const [loadingOldest, setLoadingOldest] = useState4(false);
+  const [loadingLatest, setLoadingLatest] = useState4(false);
+  const [loadingTarget, setLoadingTarget] = useState4(false);
+  const loadingTargetRef = useRef5(false);
+  const [streamEpoch, setStreamEpoch] = useState4(0);
+  const [viewMode, setViewMode] = useState4("live");
+  const lastSequenceRef = useRef5(after);
+  const streamResumeSequenceRef = useRef5(after);
+  const oldestSequenceRef = useRef5(null);
+  const newestSequenceRef = useRef5(null);
+  const hasOlderRef = useRef5(false);
+  const hasNewerRef = useRef5(false);
+  const loadingOlderRef = useRef5(false);
+  const loadingNewerRef = useRef5(false);
+  const loadingOldestRef = useRef5(false);
+  const loadingLatestRef = useRef5(false);
+  const viewModeRef = useRef5("live");
+  const initialWindowLoadedRef = useRef5(false);
+  const reconcileAfterPageResumeRef = useRef5(false);
+  const streamAbortRef = useRef5(null);
+  const streamKeyRef = useRef5(null);
+  const generationRef = useRef5(0);
+  const navigationGenerationRef = useRef5(0);
+  const eventWindowRef = useRef5(EMPTY_EVENT_WINDOW);
+  const sessionStatusRef = useRef5({
     sequence: after,
     status: null
   });
-  const [stateStreamKey, setStateStreamKey] = useState2(streamKey);
-  useEffect2(() => {
+  const [stateStreamKey, setStateStreamKey] = useState4(streamKey);
+  useEffect4(() => {
+    navigationGenerationRef.current += 1;
+    setNewerError(null);
+    loadingOlderRef.current = false;
+    loadingNewerRef.current = false;
+    loadingOldestRef.current = false;
+    loadingTargetRef.current = false;
+    setQuestionEvidence(null);
+    setLoadingTarget(false);
+    setLoadingOlder(false);
+    setLoadingNewer(false);
+    setLoadingOldest(false);
+    return () => {
+      navigationGenerationRef.current += 1;
+    };
+  }, [client, workspaceId, sessionId, after, enabled, fullReplay]);
+  useEffect4(() => {
     if (streamKeyRef.current !== streamKey) {
       streamKeyRef.current = streamKey;
       setStateStreamKey(streamKey);
@@ -297,6 +954,7 @@ function useSessionEvents(sessionId, options = {}) {
       setLoadingOldest(false);
       setLoadingLatest(false);
       setInitialLoading(true);
+      setInitialHistoryReady(false);
       lastSequenceRef.current = after;
       streamResumeSequenceRef.current = after;
       oldestSequenceRef.current = null;
@@ -310,24 +968,27 @@ function useSessionEvents(sessionId, options = {}) {
       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;
+    const isCurrent = () => generationRef.current === generation && !controller.signal.aborted && navigationIdentityRef.current.client === client && navigationIdentityRef.current.streamKey === streamKey && navigationIdentityRef.current.enabled === enabled;
     streamAbortRef.current = controller;
     let pending = [];
     let pendingBytes = 2;
@@ -357,9 +1018,12 @@ function useSessionEvents(sessionId, options = {}) {
           batchResumeSequence
         );
       }
-      observeSessionStatus(batch, sessionStatusRef, setSessionStatusProjection);
+      const status = observeSessionStatus(batch, sessionStatusRef);
+      if (status !== void 0) {
+        setSessionStatusProjection(status);
+      }
       const current = eventWindowRef.current;
-      const next = boundBrowserSessionEventWindow([...current.events, ...batch]);
+      const next = appendBrowserSessionEventWindow(current, batch);
       const retained = {
         ...next,
         truncated: current.truncated || next.truncated
@@ -367,7 +1031,7 @@ function useSessionEvents(sessionId, options = {}) {
       eventWindowRef.current = retained;
       setEventWindow(retained);
       oldestSequenceRef.current = retained.events[0]?.sequence ?? null;
-      newestSequenceRef.current = retained.events.at(-1)?.sequence ?? null;
+      newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
       if (retained.truncated) {
         hasOlderRef.current = true;
         setHasOlder(true);
@@ -379,29 +1043,85 @@ function useSessionEvents(sessionId, options = {}) {
     };
     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 = appendBrowserSessionEventWindow(current, plan.events);
+            const retained = {
+              ...next,
+              truncated: current.truncated || next.truncated
+            };
+            eventWindowRef.current = retained;
+            oldestSequenceRef.current = retained.events[0]?.sequence ?? null;
+            newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
+            lastSequenceRef.current = Math.max(lastSequenceRef.current, plan.resumeSequence);
+            streamResumeSequenceRef.current = Math.max(
+              streamResumeSequenceRef.current,
+              plan.resumeSequence
+            );
+            if (status !== void 0) {
+              setSessionStatusProjection(status);
+            }
+            setEventWindow(retained);
+            if (retained.truncated) {
+              hasOlderRef.current = true;
+              setHasOlder(true);
+            }
+          } else if (plan.kind === "reload") {
+            initialWindowLoadedRef.current = false;
+            setError(null);
+          }
+        }
         if (!fullReplay && !initialWindowLoadedRef.current) {
           setConnectionState("connecting");
           const window = await loadEventWindow(client, workspaceId, sessionId, {
             before: Number.MAX_SAFE_INTEGER,
-            pageSize: INITIAL_TAIL_PAGE_SIZE,
+            pageSize: SESSION_HISTORY_PAGE_SIZE,
             targetGroups: Number.POSITIVE_INFINITY,
             maxFetches: INITIAL_FETCH_CAP,
+            boundaryPageCap: BOUNDARY_PAGE_CAP,
             signal: controller.signal
           });
           if (!isCurrent()) {
             return;
           }
-          observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+          const status = observeSessionStatus(window.events, sessionStatusRef);
           const retained = boundBrowserSessionEventWindow(window.events);
+          navigationGenerationRef.current += 1;
+          loadingOlderRef.current = false;
+          loadingNewerRef.current = false;
+          loadingOldestRef.current = false;
+          setLoadingOlder(false);
+          setLoadingNewer(false);
+          setLoadingOldest(false);
           eventWindowRef.current = retained;
-          setEventWindow(retained);
           oldestSequenceRef.current = retained.events[0]?.sequence ?? window.oldestSequence;
-          newestSequenceRef.current = retained.events.at(-1)?.sequence ?? window.newestSequence;
+          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;
+          setInitialHistoryReady(true);
+          setError(null);
+          if (status !== void 0) {
+            setSessionStatusProjection(status);
+          }
+          setEventWindow(retained);
           setHasOlder(window.hasOlder || retained.truncated);
           setHasNewer(false);
           setInitialLoading(false);
@@ -415,7 +1135,7 @@ function useSessionEvents(sessionId, options = {}) {
           onOpen: () => {
             void Promise.resolve().then(() => reconcileSession(sessionId)).catch((cause) => {
               if (isCurrent()) {
-                setError(cause instanceof Error ? cause : new Error(String(cause)));
+                setError(normalizeError(cause));
               }
             });
           },
@@ -427,7 +1147,7 @@ function useSessionEvents(sessionId, options = {}) {
         });
         for await (const event of stream) {
           if (!isCurrent()) break;
-          const boundedEvent = boundBrowserLegacyEvent(event);
+          const boundedEvent = event;
           const boundedEventBytes = browserJsonBytes(boundedEvent);
           const separatorBytes = pending.length === 0 ? 0 : 1;
           if (pending.length > 0 && (pending.length >= SESSION_EVENT_BROWSER_PENDING_MAX_COUNT || pendingBytes + separatorBytes + boundedEventBytes > SESSION_EVENT_BROWSER_PENDING_MAX_BYTES)) {
@@ -448,8 +1168,9 @@ function useSessionEvents(sessionId, options = {}) {
       } catch (cause) {
         if (isCurrent()) {
           flush();
-          setError(cause instanceof Error ? cause : new Error(String(cause)));
+          setError(normalizeError(cause));
           setConnectionState("error");
+          setInitialLoading(false);
         }
       }
     })();
@@ -470,6 +1191,8 @@ function useSessionEvents(sessionId, options = {}) {
     workspaceId,
     sessionId,
     after,
+    enabled,
+    pageLive,
     streamEnabled,
     fullReplay,
     streamKey,
@@ -477,10 +1200,10 @@ function useSessionEvents(sessionId, options = {}) {
     viewMode,
     reconcileSession
   ]);
-  const navigationBusy = () => loadingOlderRef.current || loadingNewerRef.current || loadingOldestRef.current || loadingLatestRef.current;
-  const loadOlder = useCallback2(
-    () => createOlderHistoryLoadReceipt(async (markCommitted) => {
-      if (!sessionId || navigationBusy() || !hasOlderRef.current) {
+  const navigationBusy = () => loadingTargetRef.current || loadingOlderRef.current || loadingNewerRef.current || loadingOldestRef.current || loadingLatestRef.current;
+  const loadOlder = useCallback6(
+    () => createOlderHistoryLoadReceipt(async (markCommitted, preserveTail, markTailPreserved) => {
+      if (!ownsNavigation() || !sessionId || navigationBusy() || !hasOlderRef.current) {
         return false;
       }
       const before = oldestSequenceRef.current;
@@ -490,17 +1213,20 @@ function useSessionEvents(sessionId, options = {}) {
         setHasOlder(false);
         return false;
       }
-      const generation = generationRef.current;
+      const generation = navigationGenerationRef.current;
+      const isCurrent = () => ownsNavigation() && navigationGenerationRef.current === generation;
       loadingOlderRef.current = true;
       setLoadingOlder(true);
+      let published = false;
       try {
         const window = await loadEventWindow(client, workspaceId, sessionId, {
           before,
-          pageSize: OLDER_PAGE_SIZE,
+          pageSize: SESSION_HISTORY_PAGE_SIZE,
           targetGroups: OLDER_GROUP_TARGET,
-          maxFetches: OLDER_FETCH_CAP
+          maxFetches: OLDER_FETCH_CAP,
+          isCurrent
         });
-        if (generationRef.current !== generation) {
+        if (!isCurrent()) {
           return false;
         }
         if (window.events.length === 0) {
@@ -511,11 +1237,14 @@ function useSessionEvents(sessionId, options = {}) {
         }
         const current = eventWindowRef.current;
         assertPrependOrder(current.events, window.events);
-        streamAbortRef.current?.abort();
-        observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
         const next = boundBrowserSessionEventWindow([...window.events, ...current.events], {
           direction: "oldest"
         });
+        if (preserveTail && maxResumeSequence(next.events) < maxResumeSequence(current.events)) {
+          markTailPreserved();
+          return false;
+        }
+        const status = observeSessionStatus(window.events, sessionStatusRef);
         const retained = {
           ...next,
           truncated: current.truncated || next.truncated
@@ -524,47 +1253,80 @@ function useSessionEvents(sessionId, options = {}) {
         if (retainedOldest === null || retainedOldest >= before) {
           throw new Error("@opengeni/react: loadOlder made no durable sequence progress");
         }
-        const retainedNewest = retained.events.at(-1)?.sequence ?? null;
+        const retainedNewest = maxResumeSequenceOrNull(retained.events);
+        const previousNewest = maxResumeSequenceOrNull(current.events);
+        const evictedLiveTail = previousNewest !== null && retainedNewest !== null && retainedNewest < previousNewest;
+        if (evictedLiveTail && viewModeRef.current === "live") {
+          streamAbortRef.current?.abort();
+        }
         eventWindowRef.current = retained;
         markCommitted();
-        setEventWindow(retained);
         oldestSequenceRef.current = retainedOldest;
         newestSequenceRef.current = retainedNewest;
-        streamResumeSequenceRef.current = maxResumeSequence(retained.events);
+        if (evictedLiveTail) {
+          streamResumeSequenceRef.current = maxResumeSequence(retained.events);
+        }
         const olderStillAvailable = window.hasOlder;
         hasOlderRef.current = olderStillAvailable;
-        setHasOlder(olderStillAvailable);
-        if (viewModeRef.current === "history") {
+        let newer = null;
+        let enterHistory = false;
+        if (viewModeRef.current === "history" || evictedLiveTail) {
           const highWater = lastSequenceRef.current;
-          const newer = retainedNewest !== null && (retainedNewest < highWater || retained.truncated);
+          newer = retainedNewest !== null && (retainedNewest < highWater || retained.truncated);
           hasNewerRef.current = newer;
-          setHasNewer(newer);
-        } else {
-          setStreamEpoch((epoch) => epoch + 1);
+          if (evictedLiveTail) {
+            viewModeRef.current = "history";
+            enterHistory = true;
+          }
         }
+        loadingOlderRef.current = false;
+        startTransition(() => {
+          if (status !== void 0) {
+            setSessionStatusProjection(status);
+          }
+          setEventWindow(retained);
+          setHasOlder(olderStillAvailable);
+          if (newer !== null) {
+            setHasNewer(newer);
+          }
+          if (enterHistory) {
+            setViewMode("history");
+          }
+          setLoadingOlder(false);
+        });
+        published = true;
         return olderStillAvailable;
+      } catch (reason) {
+        if (!isCurrent()) return false;
+        throw reason;
       } finally {
-        loadingOlderRef.current = false;
-        setLoadingOlder(false);
+        if (!published && isCurrent()) {
+          loadingOlderRef.current = false;
+          setLoadingOlder(false);
+        }
       }
     }),
-    [client, workspaceId, sessionId]
+    [client, workspaceId, sessionId, ownsNavigation]
   );
-  const loadOldest = useCallback2(async () => {
-    if (!sessionId || navigationBusy() || !hasOlderRef.current) {
+  const loadOldest = useCallback6(async () => {
+    if (!ownsNavigation() || !sessionId || navigationBusy() || !hasOlderRef.current) {
       return false;
     }
-    const generation = generationRef.current;
+    const generation = ++navigationGenerationRef.current;
+    const isCurrent = () => ownsNavigation() && navigationGenerationRef.current === generation;
+    setQuestionEvidence(null);
     loadingOldestRef.current = true;
     setLoadingOldest(true);
+    let published = false;
     try {
       const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
         after: 0,
-        pageSize: OLDEST_PAGE_SIZE,
+        pageSize: SESSION_HISTORY_PAGE_SIZE,
         targetGroups: OLDEST_GROUP_TARGET,
-        maxFetches: OLDEST_FETCH_CAP
+        maxFetches: OLDEST_FETCH_CAP,
+        isCurrent
       });
-      if (generationRef.current !== generation) {
+      if (!isCurrent()) {
         return false;
       }
       if (window.events.length === 0) {
@@ -573,32 +1335,48 @@ function useSessionEvents(sessionId, options = {}) {
         return false;
       }
       streamAbortRef.current?.abort();
-      observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+      const status = observeSessionStatus(window.events, sessionStatusRef);
       const retained = boundBrowserSessionEventWindow(window.events, { direction: "oldest" });
       const retainedOldest = retained.events[0]?.sequence ?? null;
-      const retainedNewest = retained.events.at(-1)?.sequence ?? null;
+      const retainedNewest = maxResumeSequenceOrNull(retained.events);
       eventWindowRef.current = retained;
-      setEventWindow(retained);
       oldestSequenceRef.current = retainedOldest;
       newestSequenceRef.current = retainedNewest;
       hasOlderRef.current = false;
-      setHasOlder(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;
-      setHasNewer(newer);
       initialWindowLoadedRef.current = true;
+      setInitialHistoryReady(true);
+      setError(null);
       viewModeRef.current = "history";
-      setViewMode("history");
+      loadingOldestRef.current = false;
+      setNewerError(null);
+      startTransition(() => {
+        if (status !== void 0) {
+          setSessionStatusProjection(status);
+        }
+        setEventWindow(retained);
+        setHasOlder(false);
+        setHasNewer(newer);
+        setViewMode("history");
+        setLoadingOldest(false);
+      });
+      published = true;
       return newer;
+    } catch (reason) {
+      if (!isCurrent()) return false;
+      throw reason;
     } finally {
-      loadingOldestRef.current = false;
-      setLoadingOldest(false);
+      if (!published && isCurrent()) {
+        loadingOldestRef.current = false;
+        setLoadingOldest(false);
+      }
     }
-  }, [client, workspaceId, sessionId]);
-  const loadNewer = useCallback2(async () => {
-    if (!sessionId || navigationBusy() || !hasNewerRef.current) {
+  }, [client, workspaceId, sessionId, ownsNavigation]);
+  const loadNewer = useCallback6(async () => {
+    if (!ownsNavigation() || !sessionId || navigationBusy() || !hasNewerRef.current) {
       return false;
     }
     const afterSequence = newestSequenceRef.current;
@@ -607,20 +1385,24 @@ function useSessionEvents(sessionId, options = {}) {
       setHasNewer(false);
       return false;
     }
-    const generation = generationRef.current;
+    const generation = navigationGenerationRef.current;
+    const isCurrent = () => ownsNavigation() && navigationGenerationRef.current === generation;
     loadingNewerRef.current = true;
     setLoadingNewer(true);
+    let published = false;
     try {
       const window = await loadForwardEventWindow(client, workspaceId, sessionId, {
         after: afterSequence,
-        pageSize: NEWER_PAGE_SIZE,
+        pageSize: SESSION_HISTORY_PAGE_SIZE,
         targetGroups: NEWER_GROUP_TARGET,
-        maxFetches: NEWER_FETCH_CAP
+        maxFetches: NEWER_FETCH_CAP,
+        isCurrent
       });
-      if (generationRef.current !== generation) {
+      if (!isCurrent()) {
         return false;
       }
       if (window.events.length === 0) {
+        setNewerError(null);
         hasNewerRef.current = false;
         setHasNewer(false);
         streamResumeSequenceRef.current = afterSequence;
@@ -631,85 +1413,246 @@ function useSessionEvents(sessionId, options = {}) {
       }
       const current = eventWindowRef.current;
       assertAppendOrder(current.events, window.events);
-      observeSessionStatus(window.events, sessionStatusRef, setSessionStatusProjection);
+      const status = observeSessionStatus(window.events, sessionStatusRef);
       const previousOldest = current.events[0]?.sequence ?? null;
-      const next = boundBrowserSessionEventWindow([...current.events, ...window.events], {
-        direction: "newest"
-      });
+      const next = appendBrowserSessionEventWindow(current, window.events);
       const retained = {
         ...next,
         truncated: current.truncated || next.truncated || window.hasNewer
       };
       const retainedOldest = retained.events[0]?.sequence ?? null;
-      const retainedNewest = retained.events.at(-1)?.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;
-      setEventWindow(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;
-        setHasOlder(true);
       }
+      const rearmedOlder = hasOlderRef.current;
       const highWater = Math.max(lastSequenceRef.current, retainedNewest);
       lastSequenceRef.current = highWater;
       const newer = window.hasNewer || retainedNewest < highWater;
       hasNewerRef.current = newer;
-      setHasNewer(newer);
+      let resumeLive = false;
       if (!newer) {
         streamResumeSequenceRef.current = retainedNewest;
         viewModeRef.current = "live";
-        setViewMode("live");
-        setStreamEpoch((epoch) => epoch + 1);
+        resumeLive = true;
       }
+      loadingNewerRef.current = false;
+      setNewerError(null);
+      startTransition(() => {
+        if (status !== void 0) {
+          setSessionStatusProjection(status);
+        }
+        setEventWindow(retained);
+        setHasOlder(rearmedOlder);
+        setHasNewer(newer);
+        if (resumeLive) {
+          setViewMode("live");
+          setStreamEpoch((epoch) => epoch + 1);
+        }
+        setLoadingNewer(false);
+      });
+      published = true;
       return newer;
+    } catch (reason) {
+      if (!isCurrent()) {
+        return false;
+      }
+      setNewerError(normalizeError(reason));
+      throw reason;
     } finally {
-      loadingNewerRef.current = false;
+      if (!published && isCurrent()) {
+        loadingNewerRef.current = false;
+        setLoadingNewer(false);
+      }
+    }
+  }, [client, workspaceId, sessionId, ownsNavigation]);
+  const jumpToSequence = useCallback6(
+    async (sequence, navigationOptions) => {
+      const signal = navigationOptions?.signal;
+      if (!ownsNavigation() || !sessionId || !Number.isSafeInteger(sequence) || sequence < 1)
+        return false;
+      if (signal?.aborted) return false;
+      const generation = ++navigationGenerationRef.current;
+      setQuestionEvidence(null);
+      const current = () => generation === navigationGenerationRef.current && ownsNavigation();
+      const previousMode = viewModeRef.current;
+      streamAbortRef.current?.abort();
+      generationRef.current += 1;
+      viewModeRef.current = "history";
+      setViewMode("history");
+      loadingOlderRef.current = loadingNewerRef.current = loadingOldestRef.current = false;
+      setLoadingOlder(false);
       setLoadingNewer(false);
+      setLoadingOldest(false);
+      loadingTargetRef.current = true;
+      setLoadingTarget(true);
+      let published = false;
+      try {
+        const [before, following] = await Promise.all([
+          loadPreviousPage(client, workspaceId, sessionId, sequence + 1, { pageSize: 128 }),
+          loadNextPage(client, workspaceId, sessionId, sequence, { pageSize: 128 })
+        ]);
+        if (signal?.aborted) return false;
+        if (!current()) return false;
+        if (!before.some((event) => event.sequence === sequence)) return false;
+        const prefix = boundBrowserSessionEventWindow(before, {
+          direction: "newest",
+          maxBytes: SESSION_EVENT_BROWSER_MAX_BYTES / 2
+        });
+        const retained = boundBrowserSessionEventWindow([...prefix.events, ...following], {
+          direction: "oldest"
+        });
+        if (!retained.events.some((event) => event.sequence === sequence)) return false;
+        streamAbortRef.current?.abort();
+        generationRef.current += 1;
+        const status = observeSessionStatus(retained.events, sessionStatusRef);
+        eventWindowRef.current = retained;
+        oldestSequenceRef.current = retained.events[0].sequence;
+        newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
+        lastSequenceRef.current = Math.max(lastSequenceRef.current, newestSequenceRef.current ?? 0);
+        hasOlderRef.current = !isLogStart(retained.events[0]);
+        hasNewerRef.current = following.length > 0 || retained.truncated || (newestSequenceRef.current ?? 0) < lastSequenceRef.current;
+        initialWindowLoadedRef.current = true;
+        setInitialHistoryReady(true);
+        setError(null);
+        viewModeRef.current = "history";
+        setEventWindow(retained);
+        setHasOlder(hasOlderRef.current);
+        setHasNewer(hasNewerRef.current);
+        setInitialLoading(false);
+        setViewMode("history");
+        setNewerError(null);
+        if (status !== void 0) setSessionStatusProjection(status);
+        published = true;
+        return true;
+      } catch (reason) {
+        if (!current() || signal?.aborted) return false;
+        throw reason;
+      } finally {
+        if (current()) {
+          loadingTargetRef.current = false;
+          setLoadingTarget(false);
+          if (!published && previousMode === "live") {
+            viewModeRef.current = "live";
+            setViewMode("live");
+            setStreamEpoch((epoch) => epoch + 1);
+          }
+        }
+      }
+    },
+    [client, workspaceId, sessionId, ownsNavigation]
+  );
+  const jumpToLatestQuestion = useCallback6(
+    async (questionOptions) => {
+      if (!sessionId || !ownsNavigation()) return null;
+      let generation = navigationGenerationRef.current;
+      const current = () => ownsNavigation() && generation === navigationGenerationRef.current;
+      try {
+        const { resolveLatestQuestion } = await import("./latest-question-R77KWSUP.js");
+        if (!current()) return null;
+        const destination = await resolveLatestQuestion({
+          client,
+          workspaceId,
+          sessionId,
+          isCurrent: current,
+          resumeSequence: maxResumeSequence,
+          options: questionOptions
+        });
+        if (!destination || !current()) return null;
+        if (!eventWindowRef.current.events.some((event) => event.sequence === destination.anchor)) {
+          const navigation = jumpToSequence(destination.anchor);
+          generation = navigationGenerationRef.current;
+          if (!await navigation || !current()) return null;
+        }
+        setQuestionEvidence({
+          client,
+          streamKey,
+          anchor: destination.anchor,
+          events: destination.events
+        });
+        return destination.questionSequence;
+      } catch (reason) {
+        if (!current()) return null;
+        throw reason;
+      }
+    },
+    [client, workspaceId, sessionId, streamKey, ownsNavigation, jumpToSequence]
+  );
+  const jumpToLatest = useCallback6(async () => {
+    if (!ownsNavigation()) return;
+    if (loadingTargetRef.current) {
+      navigationGenerationRef.current += 1;
+      loadingTargetRef.current = false;
+      setLoadingTarget(false);
     }
-  }, [client, workspaceId, sessionId]);
-  const jumpToLatest = useCallback2(async () => {
     if (!sessionId || navigationBusy()) {
       return;
     }
+    navigationGenerationRef.current += 1;
+    setQuestionEvidence(null);
     loadingLatestRef.current = true;
     setLoadingLatest(true);
+    setNewerError(null);
+    setError(null);
+    let published = false;
     try {
       streamAbortRef.current?.abort();
       hasNewerRef.current = false;
-      setHasNewer(false);
       hasOlderRef.current = false;
-      setHasOlder(false);
       newestSequenceRef.current = null;
       oldestSequenceRef.current = null;
       eventWindowRef.current = EMPTY_EVENT_WINDOW;
-      setEventWindow(EMPTY_EVENT_WINDOW);
       initialWindowLoadedRef.current = false;
       streamResumeSequenceRef.current = after;
-      setInitialLoading(true);
       viewModeRef.current = "live";
-      setViewMode("live");
-      setStreamEpoch((epoch) => epoch + 1);
+      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 {
-      loadingLatestRef.current = false;
-      setLoadingLatest(false);
+      if (!published) {
+        loadingLatestRef.current = false;
+        setLoadingLatest(false);
+      }
     }
-  }, [after, sessionId]);
+  }, [after, sessionId, ownsNavigation]);
   const identityMatches = stateStreamKey === streamKey;
   const visibleEvents = identityMatches ? eventWindow.events : EMPTY_EVENTS;
-  const timeline = useMemo2(() => buildTimeline(visibleEvents), [visibleEvents]);
+  const timeline = useMemo2(() => {
+    const witness = questionEvidence?.client === client && questionEvidence.streamKey === streamKey && visibleEvents.some((event) => event.sequence === questionEvidence.anchor) ? questionEvidence.events : EMPTY_EVENTS;
+    const timelineOptions = { partialStart: hasOlder || eventWindow.truncated || after > 0 };
+    if (witness.length === 0) return buildTimeline(visibleEvents, timelineOptions);
+    const ids = new Set(visibleEvents.map((event) => event.id));
+    return buildTimeline(
+      [...visibleEvents, ...witness.filter((event) => !ids.has(event.id))],
+      timelineOptions
+    );
+  }, [visibleEvents, hasOlder, eventWindow.truncated, after, questionEvidence, client, streamKey]);
   return {
     events: visibleEvents,
     timeline,
     sessionStatus: identityMatches ? sessionStatusProjection : null,
+    sessionStatusSequence: identityMatches ? sessionStatusRef.current.sequence : 0,
     connectionState: identityMatches ? connectionState : "idle",
     lastSequence: identityMatches ? lastSequenceRef.current : after,
     windowBytes: identityMatches ? eventWindow.bytes : 2,
     windowTruncated: identityMatches ? eventWindow.truncated : false,
     initialLoading: fullReplay ? false : identityMatches ? initialLoading : true,
+    initialHistoryReady: identityMatches && initialHistoryReady,
     hasOlder: !identityMatches ? false : hasOlder,
     loadingOlder: !identityMatches ? false : loadingOlder,
     loadOlder,
@@ -720,13 +1663,16 @@ function useSessionEvents(sessionId, options = {}) {
     loadOldest,
     loadingLatest: !identityMatches ? false : loadingLatest,
     jumpToLatest,
-    error: identityMatches ? error : null
+    jumpToLatestQuestion,
+    jumpToSequence,
+    loadingTarget: identityMatches && loadingTarget,
+    error: identityMatches ? newerError ?? error : null
   };
 }
 function boundBrowserSessionEventWindow(events, options = {}) {
   const maxBytes = Math.max(1024, options.maxBytes ?? SESSION_EVENT_BROWSER_MAX_BYTES);
   const maxCount = Math.max(1, Math.floor(options.maxCount ?? SESSION_EVENT_BROWSER_MAX_COUNT));
-  const safe = events.map(boundBrowserLegacyEvent);
+  const safe = events;
   const selected = [];
   let bytes = 2;
   const direction = options.direction ?? "newest";
@@ -737,7 +1683,7 @@ function boundBrowserSessionEventWindow(events, options = {}) {
     const event = safe[index];
     const eventBytes = browserJsonBytes(event);
     const separator = selected.length === 0 ? 0 : 1;
-    if (bytes + separator + eventBytes > maxBytes) break;
+    if (selected.length > 0 && bytes + separator + eventBytes > maxBytes) break;
     selected.push(event);
     bytes += separator + eventBytes;
   }
@@ -748,184 +1694,29 @@ function boundBrowserSessionEventWindow(events, options = {}) {
     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 appendBrowserSessionEventWindow(current, batch, options = {}) {
+  const maxBytes = Math.max(1024, options.maxBytes ?? SESSION_EVENT_BROWSER_MAX_BYTES);
+  const maxCount = Math.max(1, Math.floor(options.maxCount ?? SESSION_EVENT_BROWSER_MAX_COUNT));
+  const events = [...current.events, ...batch];
+  let bytes = current.bytes;
+  for (let index = 0; index < batch.length; index += 1) {
+    bytes += browserJsonBytes(batch[index]) + (current.events.length + index > 0 ? 1 : 0);
   }
-}
-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;
-    }
+  let start = 0;
+  while (events.length - start > 1 && (bytes > maxBytes || events.length - start > maxCount)) {
+    bytes -= browserJsonBytes(events[start]) + 1;
+    start += 1;
   }
-  return identity;
-}
-function browserEnvelopeFieldProjection(field, original, delivered) {
   return {
-    field,
-    originalBytes: typeof original === "string" ? browserUtf8Bytes(original) : 0,
-    deliveredBytes: typeof delivered === "string" ? browserUtf8Bytes(delivered) : 0
+    events: start === 0 ? events : events.slice(start),
+    bytes,
+    truncated: current.truncated || start > 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 browserJsonBytes(value) {
+  return encoder.encode(JSON.stringify(value)).byteLength;
 }
-function observeSessionStatus(events, ref, setStatus) {
+function observeSessionStatus(events, ref) {
   let latest = null;
   for (const event of events) {
     const status = sessionStatusFromEvents([event]);
@@ -933,9 +1724,42 @@ function observeSessionStatus(events, ref, setStatus) {
       latest = { sequence: event.sequence, status };
     }
   }
-  if (!latest || latest.sequence < ref.current.sequence) return;
-  ref.current = latest;
-  setStatus(latest.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);
+  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;
@@ -950,6 +1774,7 @@ async function loadEventWindow(client, workspaceId, sessionId, options) {
       pageSize: options.pageSize,
       ...options.signal ? { signal: options.signal } : {}
     });
+    if (options.isCurrent?.() === false) throw abortError();
     fetches += 1;
     if (page.length === 0) {
       reachedStart = true;
@@ -964,11 +1789,12 @@ async function loadEventWindow(client, workspaceId, sessionId, options) {
     }
   }
   let snapPages = 0;
-  while (!reachedStart && findBoundaryIndex(buffer) === -1 && snapPages < BOUNDARY_PAGE_CAP && fetches < options.maxFetches) {
+  while (!reachedStart && findBoundaryIndex(buffer) === -1 && snapPages < (options.boundaryPageCap ?? 0)) {
     const page = await loadPreviousPage(client, workspaceId, sessionId, cursor, {
       pageSize: options.pageSize,
       ...options.signal ? { signal: options.signal } : {}
     });
+    if (options.isCurrent?.() === false) throw abortError();
     fetches += 1;
     snapPages += 1;
     if (page.length === 0) {
@@ -989,24 +1815,28 @@ async function loadEventWindow(client, workspaceId, sessionId, options) {
       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 && !reachedStart && oldest?.type !== "session.created"
+    hasOlder: buffer.length > 0 && (densityWindow.trimmed || !reachedStart && oldest?.type !== "session.created")
   };
 }
 function findBoundaryIndex(events) {
   for (let index = 0; index < events.length; index += 1) {
-    const type = events[index].type;
-    if (type === "session.created" || type === "user.message") {
+    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 = [];
@@ -1020,6 +1850,7 @@ async function loadForwardEventWindow(client, workspaceId, sessionId, options) {
       pageSize: options.pageSize,
       ...options.signal ? { signal: options.signal } : {}
     });
+    if (options.isCurrent?.() === false) throw abortError();
     fetches += 1;
     if (page.length === 0) {
       reachedEnd = true;
@@ -1027,21 +1858,45 @@ async function loadForwardEventWindow(client, workspaceId, sessionId, options) {
     }
     assertAscending(page);
     buffer = [...buffer, ...page];
-    cursor = page[page.length - 1].sequence;
-    if (page.length < options.pageSize) {
-      reachedEnd = true;
-      break;
-    }
+    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 && !reachedEnd
+    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();
@@ -1097,13 +1952,13 @@ function isLogStart(event) {
 function maxResumeSequence(events) {
   return events.reduce((max, event) => Math.max(max, eventResumeSequence(event)), 0);
 }
-function eventResumeSequence(event) {
-  const payload = asRecord(event.payload);
-  const coalescedUntil = Number(payload.coalescedUntil);
-  return Math.max(event.sequence, Number.isFinite(coalescedUntil) ? Math.floor(coalescedUntil) : 0);
+function maxResumeSequenceOrNull(events) {
+  return events.length > 0 ? maxResumeSequence(events) : null;
 }
-function asRecord(value) {
-  return value && typeof value === "object" ? value : {};
+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) {
@@ -1115,272 +1970,31 @@ function assertAscending(events) {
 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/");
-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,
-              error: void 0
-            } : attachment
-          )
-        );
-      }).catch((error) => {
-        if (scopeGeneration.current !== generation) return;
-        setAttachments(
-          (current) => current.map(
-            (attachment) => attachment.id === id ? {
-              ...attachment,
-              status: "failed",
-              error: error instanceof Error ? error.message : String(error)
-            } : attachment
-          )
-        );
-      });
-    },
-    [client, workspaceId]
-  );
-  const addFiles = useCallback3(
-    (files) => {
-      for (const file of files) {
-        const id = crypto.randomUUID();
-        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", 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,
-            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
-  };
+  }
+  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-turn-queue.ts
-import { useCallback as useCallback4, useEffect as useEffect4, useLayoutEffect, useMemo as useMemo3, useRef as useRef4, useState as useState4 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect5, useLayoutEffect as useLayoutEffect2, useMemo as useMemo3, useRef as useRef6, useState as useState5 } 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.");
 }
@@ -1395,18 +2009,18 @@ function useTurnQueue(sessionId, 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(() => {
+  const [snapshot, setSnapshot] = useState5(null);
+  const [stateTargetKey, setStateTargetKey] = useState5(targetKey);
+  const [loading, setLoading] = useState5(enabled);
+  const [error, setError] = useState5(null);
+  const [mutationError, setMutationError] = useState5(null);
+  const [pendingByTurn, setPendingByTurn] = useState5({});
+  const [acceptedSteers, setAcceptedSteers] = useState5([]);
+  const pendingRef = useRef6({});
+  const readGeneration = useRef6(0);
+  const targetKeyRef = useRef6(targetKey);
+  const snapshotRef = useRef6(null);
+  useLayoutEffect2(() => {
     if (targetKeyRef.current === targetKey) return;
     targetKeyRef.current = targetKey;
     readGeneration.current += 1;
@@ -1420,7 +2034,7 @@ function useTurnQueue(sessionId, options = {}) {
     setPendingByTurn({});
     setAcceptedSteers([]);
   }, [enabled, targetKey]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (acceptedSteers.length === 0 || options.events === void 0) return;
     const durablyStartedTurnIds = new Set(
       options.events.flatMap(
@@ -1432,7 +2046,7 @@ function useTurnQueue(sessionId, options = {}) {
       (current) => current.filter((steer) => !durablyStartedTurnIds.has(steer.turnId))
     );
   }, [acceptedSteers.length, options.events]);
-  const acceptSnapshot = useCallback4(
+  const acceptSnapshot = useCallback7(
     (ownedTargetKey, next) => {
       if (targetKeyRef.current !== ownedTargetKey) return false;
       const current = snapshotRef.current;
@@ -1446,7 +2060,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     []
   );
-  const load = useCallback4(
+  const load = useCallback7(
     async (rejectOnFailure = false) => {
       if (!sessionId) return;
       const ownedTargetKey = `${workspaceId}\0${sessionId}`;
@@ -1477,7 +2091,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, workspaceId, sessionId, acceptSnapshot]
   );
-  useEffect4(() => {
+  useEffect5(() => {
     if (!enabled || !pageLive) {
       setLoading(false);
       return;
@@ -1506,10 +2120,10 @@ function useTurnQueue(sessionId, options = {}) {
       readGeneration.current += 1;
     };
   }, [load, enabled, pageLive, options.pollIntervalMs]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (enabled && workspaceControlEvent) void load();
   }, [enabled, load, workspaceControlEvent]);
-  useEffect4(() => {
+  useEffect5(() => {
     if (!sessionId || !enabled) return;
     return registerSessionReconciler(sessionId, "queue", load);
   }, [enabled, load, registerSessionReconciler, sessionId]);
@@ -1526,7 +2140,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     async () => await load(true)
   );
-  const mutate = useCallback4(
+  const mutate = useCallback7(
     async (turnId, kind, command) => {
       const ownedTargetKey = targetKey;
       if (!sessionId || targetKeyRef.current !== ownedTargetKey || pendingRef.current[turnId]) {
@@ -1568,7 +2182,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [acceptSnapshot, load, sessionId, targetKey]
   );
-  const moveTurn = useCallback4(
+  const moveTurn = useCallback7(
     async (turnId, beforeTurnId) => {
       const result = await mutate(
         turnId,
@@ -1583,7 +2197,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, mutate, sessionId, workspaceId]
   );
-  const editTurn = useCallback4(
+  const editTurn = useCallback7(
     async (turnId, edit) => {
       const result = await mutate(
         turnId,
@@ -1599,7 +2213,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, mutate, sessionId, workspaceId]
   );
-  const steerTurn = useCallback4(
+  const steerTurn = useCallback7(
     async (turnId) => {
       const ownedTargetKey = targetKey;
       const turn = snapshotRef.current?.items.find((candidate) => candidate.id === turnId);
@@ -1651,7 +2265,7 @@ function useTurnQueue(sessionId, options = {}) {
     },
     [client, load, mutate, sessionId, targetKey, workspaceId]
   );
-  const removeTurn = useCallback4(
+  const removeTurn = useCallback7(
     async (turnId) => {
       const result = await mutate(
         turnId,
@@ -1673,7 +2287,7 @@ function useTurnQueue(sessionId, options = {}) {
     () => Object.keys(visiblePendingByTurn).length > 0,
     [visiblePendingByTurn]
   );
-  const mutationFor = useCallback4(
+  const mutationFor = useCallback7(
     (turnId) => visiblePendingByTurn[turnId] ?? null,
     [visiblePendingByTurn]
   );
@@ -1696,7 +2310,7 @@ function useTurnQueue(sessionId, options = {}) {
     mutationFor,
     mutating,
     mutationError: identityMatches ? mutationError : null,
-    clearMutationError: useCallback4(() => {
+    clearMutationError: useCallback7(() => {
       if (targetKeyRef.current === targetKey) setMutationError(null);
     }, [targetKey]),
     acceptedSteers: identityMatches ? acceptedSteers : []
@@ -1706,15 +2320,175 @@ function operationKey() {
   return globalThis.crypto.randomUUID();
 }
 function asError(cause) {
-  return cause instanceof Error ? cause : new Error(String(cause));
+  return normalizeError(cause);
 }
 function isOutcomeUnknownError(cause) {
   return typeof cause === "object" && cause !== null && cause.outcomeUnknown === true;
 }
 
+// src/hooks/use-session-conversation.ts
+import { useLayoutEffect as useLayoutEffect3, useMemo as useMemo4, useRef as useRef7 } from "react";
+
+// src/hooks/use-client-config-flags.ts
+import { useEffect as useEffect6, useState as useState6 } from "react";
+var INITIAL_FLAGS = {
+  loaded: false,
+  uploads: false,
+  modelSelection: false,
+  sandboxFiles: false,
+  defaultReasoningEffort: null,
+  artifacts: true,
+  sessionCreation: true,
+  archive: true,
+  voiceInput: null,
+  realtimeVoice: false,
+  realtimeVoiceOffered: false
+};
+var configReads = /* @__PURE__ */ new WeakMap();
+function readClientConfig(client) {
+  let read = configReads.get(client);
+  if (!read) {
+    read = client.getClientConfig();
+    configReads.set(client, read);
+    read.catch(() => {
+      if (configReads.get(client) === read) configReads.delete(client);
+    });
+  }
+  return read;
+}
+function useClientConfigFlags(client) {
+  const [flags, setFlags] = useState6(INITIAL_FLAGS);
+  useEffect6(() => {
+    if (typeof client.getClientConfig !== "function") return;
+    let live = true;
+    readClientConfig(client).then(
+      (config) => {
+        if (live) {
+          setFlags({
+            loaded: true,
+            uploads: config.fileUploads?.enabled === true,
+            // Only an explicit offer shows end users the picker.
+            modelSelection: config.modelSelection === true,
+            sandboxFiles: config.sandboxFiles !== false,
+            defaultReasoningEffort: config.defaultReasoningEffort ?? null,
+            artifacts: config.artifacts !== false,
+            sessionCreation: config.sessionCreation !== false,
+            archive: config.archive !== false,
+            voiceInput: config.voiceInput?.available === true ? config.voiceInput : null,
+            realtimeVoice: config.realtimeVoice !== false,
+            realtimeVoiceOffered: config.realtimeVoice === true
+          });
+        }
+      },
+      () => void 0
+    );
+    return () => {
+      live = false;
+    };
+  }, [client]);
+  return flags;
+}
+
+// src/hooks/use-session-conversation.ts
+function useSessionConversation(sessionId, options = {}) {
+  const context = useOpenGeni(options);
+  const scope = { client: context.client, workspaceId: context.workspaceId };
+  const config = useClientConfigFlags(context.client);
+  const showModelPicker = options.modelPicker ?? config.modelSelection;
+  const catalog = useWorkspaceModelCatalog({ ...scope, enabled: showModelPicker });
+  const feed = useSessionEvents(sessionId, scope);
+  const eventOptions = { ...scope, events: feed.events };
+  const detail = useSession(sessionId, eventOptions);
+  const queue = useTurnQueue(sessionId, eventOptions);
+  const human = useHumanInputRequests(sessionId, eventOptions);
+  const control = useSessionControl(sessionId, scope);
+  const approvals = useMemo4(() => projectPendingApprovals(feed.events), [feed.events]);
+  const files = useFileAttachments(scope);
+  const clearFiles = files.clear;
+  const attachmentSession = useRef7(sessionId);
+  useLayoutEffect3(() => {
+    if (attachmentSession.current === sessionId) return;
+    attachmentSession.current = sessionId;
+    clearFiles();
+  }, [clearFiles, sessionId]);
+  const uploadsEnabled = (options.attachments ?? true) && config.uploads;
+  const status = feed.sessionStatus ?? detail.session?.status;
+  const terminal = status === "cancelled";
+  const importedArchive = detail.session?.importedArchive?.readOnly === true;
+  const host = options.composerOptions;
+  const resolveExtras = () => typeof host?.sendExtras === "function" ? host.sendExtras() : host?.sendExtras;
+  const releaseSentFiles = (input) => files.removeReadyFiles(
+    (input.resources ?? []).flatMap(
+      (resource) => resource.kind === "file" ? [resource.fileId] : []
+    )
+  );
+  const composer = useComposer(sessionId, {
+    ...eventOptions,
+    initialDraft: host?.initialDraft,
+    effectiveControl: queue.effectiveControl ?? detail.session?.effectiveControl,
+    sendDestination: () => queue.queue.length > 0 || status === "running" ? "queue" : "chat",
+    sendExtras: () => {
+      const extras = resolveExtras();
+      return {
+        ...extras,
+        resources: [...extras?.resources ?? [], ...uploadsEnabled ? files.readyResources : []]
+      };
+    },
+    sendBlocked: () => terminal || importedArchive || uploadsEnabled && files.hasUnresolved || host?.sendBlocked?.() === true,
+    onSubmitted: (text, input) => {
+      releaseSentFiles(input);
+      return host?.onSubmitted?.(text, input);
+    },
+    onSent: (text, input) => {
+      releaseSentFiles(input);
+      return host?.onSent?.(text, input);
+    },
+    onDeliveryError: host?.onDeliveryError
+  });
+  const timeline = useMemo4(
+    () => conversationTimeline(feed.timeline, queue, composer),
+    [feed.timeline, queue, composer]
+  );
+  const error = detail.error ?? feed.error ?? human.error;
+  const loadFailed = Boolean(feed.error) && !feed.initialHistoryReady;
+  const retry = async () => {
+    await Promise.all([
+      ...detail.error ? [detail.refresh()] : [],
+      ...human.error ? [human.refresh()] : [],
+      ...feed.error ? [feed.jumpToLatest()] : []
+    ]);
+  };
+  return {
+    ...scope,
+    sessionId,
+    config,
+    catalog,
+    showModelPicker,
+    feed,
+    detail,
+    queue,
+    human,
+    control,
+    approvals,
+    files,
+    uploadsEnabled,
+    composer,
+    /** The same live application context for text and durable voice messages. */
+    getModelContext: () => resolveExtras()?.modelContext,
+    timeline,
+    status,
+    terminal,
+    importedArchive,
+    running: status === "running" || status === "recovering" || status === "waiting_capacity",
+    error,
+    loadFailed,
+    retry
+  };
+}
+
 // 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";
+import { useCallback as useCallback8, useEffect as useEffect7, useLayoutEffect as useLayoutEffect4, useRef as useRef8, useState as useState7 } from "react";
 function isGoalEvent(event) {
   return event.type.startsWith("goal.");
 }
@@ -1728,20 +2502,38 @@ function useGoal(sessionId, options = {}) {
   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 [goal, setGoal] = useState7(null);
+  const [loading, setLoading] = useState7(enabled);
+  const [error, setError] = useState7(null);
   const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
-  const generation = useRef5(0);
-  const targetKeyRef = useRef5(null);
-  const load = useCallback5(async () => {
+  const generation = useRef8(0);
+  const targetKeyRef = useRef8(null);
+  const goalAbsentRef = useRef8(false);
+  const pendingRefreshRef = useRef8("none");
+  const sharedEventsRef = useRef8(sharedEvents);
+  useLayoutEffect4(() => {
+    sharedEventsRef.current = sharedEvents;
+  }, [sharedEvents]);
+  const loadAbort = useRef8(null);
+  const scheduleRefreshRef = useRef8(() => void 0);
+  const retireLoads = useCallback8(() => {
+    generation.current += 1;
+    loadAbort.current?.abort();
+    loadAbort.current = null;
+  }, []);
+  const load = useCallback8(async () => {
     if (!sessionId) {
       return;
     }
     const ticket = ++generation.current;
+    pendingRefreshRef.current = "none";
+    loadAbort.current?.abort();
+    const controller = new AbortController();
+    loadAbort.current = controller;
     try {
-      const fetched = await client.getGoal(workspaceId, sessionId);
+      const fetched = typeof client.findGoal === "function" ? await client.findGoal(workspaceId, sessionId, { signal: controller.signal }) : await client.getGoal(workspaceId, sessionId, { signal: controller.signal });
       if (ticket === generation.current) {
+        goalAbsentRef.current = fetched === null;
         setGoal(fetched);
         setError(null);
         setLoading(false);
@@ -1751,29 +2543,53 @@ function useGoal(sessionId, options = {}) {
         return;
       }
       if (cause instanceof OpenGeniApiError && cause.status === 404) {
+        goalAbsentRef.current = true;
         setGoal(null);
         setError(null);
       } else {
-        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        setError(normalizeError(cause));
       }
       setLoading(false);
+    } finally {
+      if (loadAbort.current === controller) loadAbort.current = null;
     }
+    if (ticket !== generation.current || pendingRefreshRef.current === "none") {
+      return;
+    }
+    if (goalAbsentRef.current && pendingRefreshRef.current === "refresh") {
+      const events = sharedEventsRef.current ?? [];
+      let latestGoalEvent;
+      for (let index = events.length - 1; index >= 0 && !latestGoalEvent; index -= 1) {
+        const event = events[index];
+        if (event && isGoalEvent(event)) latestGoalEvent = event;
+      }
+      if (!latestGoalEvent || latestGoalEvent.type === "goal.cleared") {
+        pendingRefreshRef.current = "none";
+        return;
+      }
+      pendingRefreshRef.current = "goal";
+    }
+    scheduleRefreshRef.current();
   }, [client, workspaceId, sessionId]);
-  useEffect5(() => {
+  useEffect7(() => {
     const targetKey = `${workspaceId} ${sessionId ?? ""}`;
     if (targetKeyRef.current !== targetKey) {
       targetKeyRef.current = targetKey;
+      goalAbsentRef.current = false;
+      pendingRefreshRef.current = "none";
       setGoal(null);
       setError(null);
     }
     if (!enabled || !pageLive) {
+      retireLoads();
       setLoading(false);
       return;
     }
     if (sharedFeed) {
-      setLoading(false);
+      setLoading(true);
+      void load();
       return () => {
-        generation.current += 1;
+        retireLoads();
       };
     }
     setLoading(true);
@@ -1781,7 +2597,7 @@ function useGoal(sessionId, options = {}) {
     if (pollIntervalMs === void 0 || pollIntervalMs <= 0) {
       void load();
       return () => {
-        generation.current += 1;
+        retireLoads();
       };
     }
     let cancelled = false;
@@ -1797,541 +2613,394 @@ function useGoal(sessionId, options = {}) {
     return () => {
       cancelled = true;
       if (timer !== null) clearTimeout(timer);
-      generation.current += 1;
+      retireLoads();
     };
-  }, [load, enabled, pageLive, workspaceId, sessionId, options.pollIntervalMs, sharedFeed]);
-  const scheduleRefresh = useDebouncedCallback(() => void load());
-  useSessionEventTrigger(client, workspaceId, sessionId, isGoalRefreshEvent, scheduleRefresh, {
+  }, [
+    load,
     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) {
+    pageLive,
+    workspaceId,
+    sessionId,
+    options.pollIntervalMs,
+    retireLoads,
+    sharedFeed
+  ]);
+  const scheduleRefresh = useDebouncedCallback(() => {
+    const pending = pendingRefreshRef.current;
+    if (pending === "none" || loadAbort.current !== null) return;
+    if (pending === "refresh" && goalAbsentRef.current) {
+      pendingRefreshRef.current = "none";
       return;
     }
-    const ok = await run(async () => {
-      await client.deleteGoal(workspaceId, sessionId);
-      return true;
-    });
-    if (ok) {
-      generation.current += 1;
-      setGoal(null);
-      setError(null);
-    }
-  }, [client, workspaceId, sessionId, run]);
-  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
+    void load();
   });
-  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 } : {}
+  useLayoutEffect4(() => {
+    scheduleRefreshRef.current = scheduleRefresh;
+  }, [scheduleRefresh]);
+  const isRefreshEvent = useCallback8(
+    (event) => goalAbsentRef.current ? isGoalEvent(event) : isGoalRefreshEvent(event),
+    []
+  );
+  const onRefreshEvent = useCallback8(
+    (event) => {
+      if (isGoalEvent(event)) pendingRefreshRef.current = "goal";
+      else if (pendingRefreshRef.current === "none") pendingRefreshRef.current = "refresh";
+      scheduleRefresh();
     },
-    async () => await refresh()
+    [scheduleRefresh]
   );
-  const update = useCallback7(
-    async (policy) => {
-      if (!sessionId || !serverId) {
+  useSessionEventTrigger(client, workspaceId, sessionId, isRefreshEvent, onRefreshEvent, {
+    enabled,
+    ...sharedEvents !== void 0 ? { events: sharedEvents } : {}
+  });
+  const pause = useCallback8(
+    async (rationale) => {
+      if (!sessionId) {
         return null;
       }
-      const response = await run(
-        () => client.updateSessionMcpApprovalPolicy(workspaceId, sessionId, serverId, {
-          requireApproval: policy
+      const result = await run(
+        () => client.updateGoal(workspaceId, sessionId, {
+          status: "paused",
+          ...rationale !== void 0 ? { rationale } : {}
         })
       );
-      if (response) {
-        authoritativeGeneration.current += 1;
-        setOverride(response.server);
-        void refresh();
+      if (result) {
+        setGoal(result);
       }
-      return response;
+      return result;
     },
-    [client, refresh, run, serverId, sessionId, workspaceId]
+    [client, workspaceId, sessionId, run]
   );
-  const server = override ?? data?.server ?? null;
+  const resume = useCallback8(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 = useCallback8(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 {
-    server,
-    policy: server?.requireApproval ?? null,
+    goal,
+    isActive: goal?.status === "active",
+    isPaused: goal?.status === "paused",
+    isCompleted: goal?.status === "completed",
     loading,
-    error: mutationError ?? loadError,
-    refresh: async () => {
-      await refresh();
-    },
-    update,
+    error,
+    refresh: load,
+    pause,
+    resume,
+    clearGoal,
+    deleteGoal: clearGoal,
     updating: mutating,
-    clearError: clearMutationError
+    mutationError,
+    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 () => {
-    if (!sessionId) {
-      return {
-        lineage: { ancestors: [], children: [], truncated: false },
-        readGeneration: 0
-      };
-    }
-    let readGeneration = 0;
-    const lineage = await client.getSessionLineage(workspaceId, sessionId, {
-      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(() => {
+// src/hooks/use-new-conversation.ts
+import {
+  OpenGeniApiError as OpenGeniApiError2
+} from "@opengeni/sdk";
+import { useLayoutEffect as useLayoutEffect5, useMemo as useMemo5, useRef as useRef9, useState as useState8 } from "react";
+var NOOP_ASYNC = async () => {
+};
+function useNewConversation(options = {}) {
+  const context = useOpenGeni(options);
+  const scope = { client: context.client, workspaceId: context.workspaceId };
+  const config = useClientConfigFlags(context.client);
+  const showModelPicker = options.modelPicker ?? config.modelSelection;
+  const catalog = useWorkspaceModelCatalog({ ...scope, enabled: showModelPicker });
+  const files = useFileAttachments(scope);
+  const uploadsEnabled = (options.attachments ?? true) && config.uploads;
+  const available = options.enabled !== false && (options.createSession !== void 0 || config.sessionCreation);
+  const [text, setText] = useState8("");
+  const [choice, setChoice] = useState8({});
+  const [sending, setSending] = useState8(false);
+  const [error, setError] = useState8(null);
+  const [pending, setPending] = useState8(null);
+  const [completion, setCompletion] = useState8(null);
+  const textRef = useRef9(text);
+  const textRevision = useRef9(0);
+  const choiceRef = useRef9(choice);
+  const filesRef = useRef9(files);
+  filesRef.current = files;
+  const pendingRef = useRef9(null);
+  const completionRef = useRef9(null);
+  const inFlight = useRef9(false);
+  const lifetime = useRef9({ mounted: true, generation: 0 }).current;
+  const identity = useMemo5(
+    () => ({
+      client: context.client,
+      workspaceId: context.workspaceId,
+      scopeKey: options.scopeKey
+    }),
+    [context.client, context.workspaceId, options.scopeKey]
+  );
+  const committedIdentity = useRef9(identity);
+  useLayoutEffect5(() => {
+    lifetime.mounted = true;
     return () => {
-      if (delayedChildRefreshRef.current !== null) {
-        clearTimeout(delayedChildRefreshRef.current);
-        delayedChildRefreshRef.current = null;
-      }
+      lifetime.mounted = false;
+      lifetime.generation++;
     };
-  }, [sessionId, workspaceId]);
-  const refreshAfterChildCreate = useCallback8(() => {
-    void refresh();
-    if (delayedChildRefreshRef.current !== null) {
-      clearTimeout(delayedChildRefreshRef.current);
+  }, [lifetime]);
+  useLayoutEffect5(() => {
+    if (committedIdentity.current === identity) return;
+    committedIdentity.current = identity;
+    lifetime.generation++;
+    inFlight.current = false;
+    pendingRef.current = null;
+    completionRef.current = null;
+    textRef.current = "";
+    textRevision.current = 0;
+    choiceRef.current = {};
+    setText("");
+    setChoice({});
+    setSending(false);
+    setError(null);
+    setPending(null);
+    setCompletion(null);
+    filesRef.current.clear();
+  }, [identity, lifetime]);
+  const ownsScope = () => lifetime.mounted && committedIdentity.current === identity;
+  const updateText = (value) => {
+    if (!ownsScope()) return;
+    if (value !== textRef.current) textRevision.current++;
+    textRef.current = value;
+    setText(value);
+  };
+  const updateChoice = (patch) => {
+    if (!ownsScope()) return;
+    const next = { ...choiceRef.current, ...patch };
+    const model = catalog.models.find((row) => row.id === (next.model ?? catalog.defaultModel));
+    if (model) {
+      if (next.reasoningEffort)
+        next.reasoningEffort = coerceReasoningEffortForModel(model, next.reasoningEffort);
+      if (next.latencyMode && !runnableLatencyModesForModel(model).includes(next.latencyMode))
+        next.latencyMode = "standard";
     }
-    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
+    choiceRef.current = next;
+    setChoice(choiceRef.current);
   };
-}
-
-// 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
-    };
+  const effectivePolicy = () => {
+    const model = choiceRef.current.model ?? catalog.defaultModel;
+    const definition = catalog.models.find((row) => row.id === model);
+    const effort = choiceRef.current.reasoningEffort ?? (definition ? defaultEffortForModel(definition) : config.defaultReasoningEffort ?? "medium");
+    return showModelPicker && model ? {
+      model,
+      reasoningEffort: definition ? coerceReasoningEffortForModel(definition, effort) : effort,
+      latencyMode: choiceRef.current.latencyMode ?? "standard"
+    } : void 0;
+  };
+  const create = options.createSession ?? (async (initialMessage, idempotencyKey, input) => {
+    const creator = context.client.createSession;
+    if (typeof creator !== "function")
+      throw new Error("New chats are not enabled for this product.");
+    const created = await creator.call(context.client, context.workspaceId, {
+      ...input.startMode === "realtime" ? {} : { initialMessage },
+      idempotencyKey,
+      ...input
+    });
+    return created.id;
   });
-}
-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;
+  const finishCreation = (accepted) => {
+    if (!lifetime.mounted || lifetime.generation !== accepted.generation) return;
+    const { attempt, sessionId } = accepted;
+    const sentFiles = new Set(attempt.options.resources?.map((resource) => resource.fileId) ?? []);
+    const policyChanged = ["model", "reasoningEffort", "latencyMode"].some(
+      (field) => choiceRef.current[field] !== attempt.options[field]
+    );
+    const draft = {
+      text: attempt.clearDraft && textRevision.current === attempt.textRevision ? "" : textRef.current,
+      resources: filesRef.current.readyResources.filter(
+        (resource) => !sentFiles.has(resource.fileId)
+      ),
+      // Unchanged choices are already part of the created session. Do not
+      // replace server-owned defaults with a browser's catalog estimate.
+      ...policyChanged ? { policy: effectivePolicy() } : {}
+    };
+    pendingRef.current = null;
+    completionRef.current = null;
+    setPending(null);
+    setCompletion(null);
+    updateText(draft.text);
+    filesRef.current.removeReadyFiles(sentFiles);
+    notifyObserver(options.onCreated, {
+      sessionId,
+      initialMessage: attempt.initialMessage,
+      draft,
+      ...attempt.realtimeModel ? { realtimeModel: attempt.realtimeModel } : {}
+    });
+  };
+  const finishRef = useRef9(finishCreation);
+  finishRef.current = finishCreation;
+  useLayoutEffect5(() => {
+    if (completion && !files.hasUnresolved) finishRef.current(completion);
+  }, [completion, files.hasUnresolved]);
+  const deliver = async (attempt) => {
+    if (!ownsScope() || inFlight.current || completionRef.current || !available) return false;
+    const ownedGeneration = lifetime.generation;
+    inFlight.current = true;
+    pendingRef.current = attempt;
+    setSending(true);
+    setError(null);
+    setPending(null);
+    try {
+      const sessionId = await attempt.create(
+        attempt.initialMessage,
+        attempt.key,
+        structuredClone(attempt.options)
+      );
+      if (!lifetime.mounted || lifetime.generation !== ownedGeneration) return true;
+      const accepted = { sessionId, attempt, generation: ownedGeneration };
+      completionRef.current = accepted;
+      if (filesRef.current.hasUnresolved) setCompletion(accepted);
+      else finishCreation(accepted);
+      return true;
+    } catch (cause) {
+      if (!lifetime.mounted || lifetime.generation !== ownedGeneration) return false;
+      setError({ cause });
+      if (cause instanceof OpenGeniApiError2 && cause.outcomeUnknown === false) {
+        pendingRef.current = null;
+      } else {
+        setPending(attempt);
       }
-      case "turn.completed":
-      case "turn.failed":
-      case "turn.cancelled": {
-        if (owningTurnId === null || event.turnId == null || event.turnId === owningTurnId) {
-          pending = [];
-          owningTurnId = null;
-        }
-        break;
+      return false;
+    } finally {
+      if (lifetime.mounted && lifetime.generation === ownedGeneration) {
+        inFlight.current = false;
+        setSending(false);
       }
-      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);
-        }
+  };
+  const submit = async (explicit) => {
+    if (!ownsScope() || !available || inFlight.current || pendingRef.current || uploadsEnabled && filesRef.current.hasUnresolved)
+      return false;
+    const resources = uploadsEnabled ? filesRef.current.readyResources : [];
+    const draftText = explicit ?? textRef.current;
+    const initialMessage = draftText.trim() || (resources.length > 0 ? FILE_ONLY_MESSAGE_TEXT : "");
+    if (!initialMessage) return false;
+    return deliver({
+      key: crypto.randomUUID(),
+      initialMessage,
+      textRevision: textRevision.current,
+      clearDraft: explicit === void 0,
+      create,
+      options: {
+        ...resources.length ? { resources: structuredClone(resources) } : {},
+        ...showModelPicker ? { ...choiceRef.current } : {}
       }
+    });
+  };
+  const startRealtime = async (model) => {
+    if (!ownsScope() || !available || inFlight.current || pendingRef.current || !config.realtimeVoice || !(options.realtimeVoice ?? config.realtimeVoiceOffered))
+      return false;
+    if (filesRef.current.hasUnresolved) return false;
+    return deliver({
+      key: crypto.randomUUID(),
+      initialMessage: "",
+      textRevision: textRevision.current,
+      clearDraft: false,
+      create,
+      options: { ...showModelPicker ? { ...choiceRef.current } : {}, startMode: "realtime" },
+      realtimeModel: model
+    });
+  };
+  const composer = {
+    value: text,
+    setValue: updateText,
+    hasDraftContent: () => textRef.current.length > 0 || filesRef.current.attachments.length > 0,
+    send: submit,
+    steer: submit,
+    sending,
+    canSend: available && !sending && !pending && !completion && (text.trim().length > 0 || uploadsEnabled && files.readyResources.length > 0) && !(uploadsEnabled && files.hasUnresolved),
+    pause: NOOP_ASYNC,
+    pausing: false,
+    resume: NOOP_ASYNC,
+    resumeScope: NOOP_ASYNC,
+    resuming: false,
+    draft: null,
+    draftRevision: 0,
+    draftLoading: false,
+    draftSaving: false,
+    draftConflict: null,
+    policy: effectivePolicy() ?? null,
+    setModel: (model) => updateChoice({ model }),
+    setReasoningEffort: (reasoningEffort) => updateChoice({ reasoningEffort }),
+    setLatencyMode: (latencyMode) => updateChoice({ latencyMode }),
+    draftPersistence: "disabled",
+    applyDraft: () => {
     },
-    [client, mutation, sessionId, state, workspaceId]
-  );
-  const now = Date.now();
-  void deadlineVersion;
+    reloadDraft: NOOP_ASYNC,
+    resolveDraftConflict: NOOP_ASYNC,
+    restoredResources: [],
+    removeRestoredResource: () => {
+    },
+    error: null,
+    clearError: () => {
+      if (ownsScope()) setError(null);
+    }
+  };
   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
+    ...scope,
+    config,
+    files,
+    uploadsEnabled,
+    available,
+    showModelPicker,
+    catalog,
+    composer,
+    realtimeVoiceEnabled: config.realtimeVoice && (options.realtimeVoice ?? config.realtimeVoiceOffered),
+    error,
+    finishingUploads: completion !== null,
+    pending: pending ? { idempotencyKey: pending.key, realtimeModel: pending.realtimeModel } : null,
+    retry: () => pendingRef.current ? deliver(pendingRef.current) : Promise.resolve(false),
+    startRealtime
   };
 }
 
 export {
-  createEmbeddedSessionClient,
+  approvalsFromRequiresAction,
+  projectPendingApprovals,
+  invokeOlderHistoryLoaderWithReceiptCapture,
+  createOlderHistoryLoadReceipt,
+  conversationTimeline,
+  useAvailableModels,
+  useWorkspaceModelCatalog,
+  useClientConfigFlags,
+  useFileAttachments,
+  isHumanInputEvent,
+  useHumanInputRequests,
   isTitleEvent,
   useSession,
+  useSessionControl,
   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,
+  useSessionConversation,
   isGoalEvent,
   useGoal,
-  useSessionControl,
-  isSessionMcpApprovalPolicyEvent,
-  useSessionMcpApprovalPolicy,
-  isLineageRefreshEvent,
-  useSessionLineage,
-  approvalsFromRequiresAction,
-  projectPendingApprovals,
-  isHumanInputEvent,
-  useHumanInputRequests
+  useNewConversation
 };
-//# sourceMappingURL=chunk-YJFGAFBD.js.map
+//# sourceMappingURL=chunk-X5UVUIMF.js.map