@opengeni/react 0.46.1 → 0.52.1

package/src/hooks/use-turn-queue.ts

@@ -12,6 +12,7 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } fr
 import { useEmbeddedSession, type EmbeddedSessionClientOverride } from "../session-context";
 import {
   useDebouncedCallback,
+  usePageLiveActivity,
   useSessionEventTrigger,
   type SessionEventFeedOptions,
 } from "./internal";
@@ -91,6 +92,7 @@ export function useTurnQueue(
     useEmbeddedSession(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
   const targetKey = `${workspaceId}\u0000${sessionId ?? ""}`;
+  const pageLive = usePageLiveActivity();
   const [snapshot, setSnapshot] = useState<SessionQueueSnapshot | null>(null);
   const [stateTargetKey, setStateTargetKey] = useState(targetKey);
   const [loading, setLoading] = useState(enabled);
@@ -174,24 +176,34 @@ export function useTurnQueue(
   );
 
   useEffect(() => {
-    if (!enabled) {
+    if (!enabled || !pageLive) {
       setLoading(false);
       return;
     }
     setLoading(true);
-    void load();
     const pollIntervalMs = options.pollIntervalMs;
     if (pollIntervalMs === undefined || pollIntervalMs <= 0) {
+      void load();
       return () => {
         readGeneration.current += 1;
       };
     }
-    const timer = setInterval(() => void load(), pollIntervalMs);
+    let cancelled = false;
+    let timer: ReturnType<typeof setTimeout> | null = null;
+    const schedule = () => {
+      if (cancelled) return;
+      timer = setTimeout(() => {
+        timer = null;
+        void load().finally(schedule);
+      }, pollIntervalMs);
+    };
+    void load().finally(schedule);
     return () => {
-      clearInterval(timer);
+      cancelled = true;
+      if (timer !== null) clearTimeout(timer);
       readGeneration.current += 1;
     };
-  }, [load, enabled, options.pollIntervalMs]);
+  }, [load, enabled, pageLive, options.pollIntervalMs]);
 
   useEffect(() => {
     if (enabled && workspaceControlEvent) void load();

package/src/hooks/use-video-artifact-playback.ts

@@ -0,0 +1,28 @@
+import { useMemo } from "react";
+import type { VideoArtifactPlaybackLoader } from "../timeline";
+import { useOpenGeni, type ClientOverride } from "../session-context";
+
+/**
+ * Bind the current public SDK client/workspace to MessageTimeline's renewable
+ * video-source boundary. Proxy hosts may omit the method until they support
+ * retained video; the failure remains local to the player instead of loading
+ * any video bytes through React.
+ */
+export function useVideoArtifactPlaybackLoader(
+  options: ClientOverride = {},
+): VideoArtifactPlaybackLoader {
+  const { client, workspaceId } = useOpenGeni(options);
+  return useMemo(
+    () => async (artifactId: string, signal?: AbortSignal) => {
+      if (typeof client.createVideoArtifactPlaybackSource !== "function") {
+        throw new Error("This OpenGeni host does not expose retained-video playback.");
+      }
+      return await client.createVideoArtifactPlaybackSource(
+        workspaceId,
+        artifactId,
+        signal ? { signal } : {},
+      );
+    },
+    [client, workspaceId],
+  );
+}

package/src/hooks/use-voice-input.ts

@@ -1,4 +1,4 @@
-import type { ClientVoiceInputConfig, OpenGeniClient } from "@opengeni/sdk";
+import { OpenGeniApiError, type ClientVoiceInputConfig, type OpenGeniClient } from "@opengeni/sdk";
 import { useCallback, useEffect, useRef, useState } from "react";
 import {
   IndexedDbVoiceRecordingStore,
@@ -21,6 +21,7 @@ export type VoiceInputStatus =
   | "recording"
   | "saving"
   | "transcribing"
+  | "retrying"
   | "recovered"
   | "transcript-ready"
   | "error";
@@ -39,6 +40,8 @@ export type UseVoiceInputOptions = {
   createRecordingId?: (() => string) | undefined;
   createOwnerId?: (() => string) | undefined;
   now?: (() => Date) | undefined;
+  /** Test/embed seam. Production uses bounded exponential recovery backoff. */
+  automaticRetryDelayMilliseconds?: number | undefined;
 };
 
 type ResumableVoiceInputClient = Pick<
@@ -86,7 +89,6 @@ export const VOICE_RECORDING_RESUMABLE_CLIENT_MAX_DURATION_SECONDS = 8 * 60 * 60
 export const VOICE_RECORDING_RECOVERY_STATUS_POLL_MILLISECONDS = 2_000;
 export const VOICE_RECORDING_RECOVERY_MAX_MUTATION_DELAY_MILLISECONDS = 30_000;
 const TRANSCRIPTION_RECORDING_RECOVERY_RETRY_AFTER_MILLISECONDS = 5_000;
-
 const MIME_PREFERENCES = ["audio/webm;codecs=opus", "audio/mp4", "audio/ogg;codecs=opus"];
 const createDefaultVoiceRecordingId = () => crypto.randomUUID();
 const currentDate = () => new Date();
@@ -132,6 +134,7 @@ export function useVoiceInput({
   createRecordingId = createDefaultVoiceRecordingId,
   createOwnerId,
   now = currentDate,
+  automaticRetryDelayMilliseconds,
 }: UseVoiceInputOptions): UseVoiceInputResult {
   const [status, setStatus] = useState<VoiceInputStatus>("idle");
   const [error, setError] = useState<string | null>(null);
@@ -156,6 +159,8 @@ export function useVoiceInput({
   const recorderRef = useRef<MediaRecorder | null>(null);
   const streamRef = useRef<MediaStream | null>(null);
   const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const automaticRetryTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const automaticRetryAttemptRef = useRef(0);
   const ownerHeartbeatTimerRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const controllerRef = useRef<AbortController | null>(null);
   const valueRef = useRef(value);
@@ -211,6 +216,7 @@ export function useVoiceInput({
     setRecordingId(null);
     setDurationSeconds(0);
     setLocallySaved(false);
+    automaticRetryAttemptRef.current = 0;
   }, [stopOwnerHeartbeat]);
 
   const ensureStore = useCallback(async (): Promise<VoiceRecordingStore> => {
@@ -348,7 +354,9 @@ export function useVoiceInput({
           setStatus(
             claimed.finalizationState === "transcript-ready" && claimed.transcriptText !== null
               ? "transcript-ready"
-              : "recovered",
+              : claimed.recoveryMode === "automatic"
+                ? "retrying"
+                : "recovered",
           );
           setError(null);
           return;
@@ -415,7 +423,12 @@ export function useVoiceInput({
         if (chunks.length === 0) {
           const retained = await store.updateManifest(
             transcribing.recordingId,
-            { uploadState: "retrying", transcriptionState: "retrying" },
+            {
+              uploadState: "retrying",
+              transcriptionState: "retrying",
+              recoveryMode: "manual",
+              handoffMode: "explicit",
+            },
             readNow().toISOString(),
             ownerIdRef.current ?? undefined,
           );
@@ -447,6 +460,14 @@ export function useVoiceInput({
         if (!active()) return;
         rememberManifest(ready);
 
+        automaticRetryAttemptRef.current = 0;
+        if (ready.handoffMode === "explicit") {
+          setStatus("transcript-ready");
+          setError("handoff_uncertain");
+          focusInput();
+          return;
+        }
+
         const next = appendFinalTranscript(valueRef.current, response.text);
         if (next !== valueRef.current) {
           valueRef.current = next;
@@ -490,16 +511,22 @@ export function useVoiceInput({
         await loadNextRecoverable(generation);
       } catch (reason) {
         if (!active()) return;
+        const code = controller.signal.aborted ? null : errorCode(reason);
+        const retryable = !controller.signal.aborted && isRetryableVoiceInputError(reason);
         const retained = await updateManifestBestEffort(transcribing, {
           uploadState: "retrying",
           transcriptionState: "retrying",
+          recoveryMode: retryable ? "automatic" : "manual",
+          handoffMode: "explicit",
         });
         if (!active()) return;
-        await preserveForRetry(
-          retained,
-          controller.signal.aborted ? null : errorCode(reason),
-          generation,
-        );
+        if (retryable) {
+          rememberManifest(retained);
+          setStatus("retrying");
+          setError(code);
+        } else {
+          await preserveForRetry(retained, code, generation);
+        }
       } finally {
         if (controllerRef.current === controller) controllerRef.current = null;
       }
@@ -519,6 +546,61 @@ export function useVoiceInput({
       workspaceId,
     ],
   );
+  // Live session renders must not postpone a durable retry deadline. Execute the
+  // latest finalizer without making its callback identity part of the timer key.
+  const finalizePersistedRecordingRef = useRef(finalizePersistedRecording);
+  finalizePersistedRecordingRef.current = finalizePersistedRecording;
+  const clientAvailable = client !== null && client !== undefined;
+
+  useEffect(() => {
+    if (
+      status !== "retrying" ||
+      !manifestRef.current ||
+      manifestRef.current.recoveryMode !== "automatic" ||
+      manifestRef.current.workspaceId !== workspaceId ||
+      !clientAvailable ||
+      disabled ||
+      !enabled
+    ) {
+      return;
+    }
+    const generation = generationRef.current;
+    let started = false;
+    const run = () => {
+      if (
+        started ||
+        generation !== generationRef.current ||
+        statusRef.current !== "retrying" ||
+        workspaceIdRef.current !== workspaceId
+      ) {
+        return;
+      }
+      started = true;
+      if (automaticRetryTimerRef.current) clearTimeout(automaticRetryTimerRef.current);
+      automaticRetryTimerRef.current = null;
+      automaticRetryAttemptRef.current += 1;
+      void finalizePersistedRecordingRef.current(generation);
+    };
+    const onOnline = () => run();
+    globalThis.addEventListener?.("online", onOnline);
+    if (typeof navigator !== "undefined" && navigator.onLine === false) {
+      return () => globalThis.removeEventListener?.("online", onOnline);
+    }
+    const delay = Math.max(
+      0,
+      automaticRetryDelayMilliseconds ??
+        transcriptionRecoveryMutationDelayMilliseconds(
+          TRANSCRIPTION_RECORDING_RECOVERY_RETRY_AFTER_MILLISECONDS,
+          automaticRetryAttemptRef.current,
+        ),
+    );
+    automaticRetryTimerRef.current = setTimeout(run, delay);
+    return () => {
+      globalThis.removeEventListener?.("online", onOnline);
+      if (automaticRetryTimerRef.current) clearTimeout(automaticRetryTimerRef.current);
+      automaticRetryTimerRef.current = null;
+    };
+  }, [automaticRetryDelayMilliseconds, clientAvailable, disabled, enabled, status, workspaceId]);
 
   const stop = useCallback(() => {
     const recorder = recorderRef.current;
@@ -540,6 +622,7 @@ export function useVoiceInput({
       status === "recording" ||
       status === "saving" ||
       status === "transcribing" ||
+      status === "retrying" ||
       !navigator.mediaDevices?.getUserMedia ||
       typeof MediaRecorder === "undefined"
     ) {
@@ -716,11 +799,19 @@ export function useVoiceInput({
             }
             rememberManifest(stopped);
             if (attemptPersistenceError) {
-              await preserveForRetry(stopped, "storage_unavailable", generation);
+              const retained = await updateManifestBestEffort(stopped, {
+                recoveryMode: "manual",
+                handoffMode: "explicit",
+              });
+              await preserveForRetry(retained, "storage_unavailable", generation);
               return;
             }
             if (attemptCaptureLimitError) {
-              await preserveForRetry(stopped, attemptCaptureLimitError, generation);
+              const retained = await updateManifestBestEffort(stopped, {
+                recoveryMode: "manual",
+                handoffMode: "explicit",
+              });
+              await preserveForRetry(retained, attemptCaptureLimitError, generation);
               return;
             }
             await finalizePersistedRecording(generation);
@@ -826,9 +917,29 @@ export function useVoiceInput({
     }
     const generation = ++generationRef.current;
     controllerRef.current?.abort();
+    if (automaticRetryTimerRef.current) clearTimeout(automaticRetryTimerRef.current);
+    automaticRetryTimerRef.current = null;
+    automaticRetryAttemptRef.current = 0;
     setError(null);
-    void finalizePersistedRecording(generation);
-  }, [client, disabled, enabled, finalizePersistedRecording, status, workspaceId]);
+    const manifest = manifestRef.current;
+    void updateManifestBestEffort(manifest, {
+      recoveryMode: "automatic",
+      handoffMode: "append",
+    }).then((retained) => {
+      if (generation !== generationRef.current) return;
+      rememberManifest(retained);
+      void finalizePersistedRecording(generation);
+    });
+  }, [
+    client,
+    disabled,
+    enabled,
+    finalizePersistedRecording,
+    rememberManifest,
+    status,
+    updateManifestBestEffort,
+    workspaceId,
+  ]);
 
   const insertSavedTranscript = useCallback(async (): Promise<void> => {
     const manifest = manifestRef.current;
@@ -951,10 +1062,12 @@ export function useVoiceInput({
       void discard();
       return;
     }
-    if (status === "saving" || status === "transcribing") {
+    if (status === "saving" || status === "transcribing" || status === "retrying") {
       const generation = ++generationRef.current;
       controllerRef.current?.abort();
       controllerRef.current = null;
+      if (automaticRetryTimerRef.current) clearTimeout(automaticRetryTimerRef.current);
+      automaticRetryTimerRef.current = null;
       const captureSettled = status === "saving" ? captureSettledRef.current : Promise.resolve();
       void captureSettled.then(async () => {
         const manifest = manifestRef.current;
@@ -963,6 +1076,8 @@ export function useVoiceInput({
           captureState: "stopped",
           uploadState: "retrying",
           transcriptionState: "retrying",
+          recoveryMode: "manual",
+          handoffMode: "explicit",
         });
         await preserveForRetry(retained, null, generation);
       });
@@ -996,7 +1111,12 @@ export function useVoiceInput({
             {
               ...(current.captureState === "capturing" ? { captureState: "stopped" as const } : {}),
               ...(wasProcessing
-                ? { uploadState: "retrying" as const, transcriptionState: "retrying" as const }
+                ? {
+                    uploadState: "retrying" as const,
+                    transcriptionState: "retrying" as const,
+                    recoveryMode: "automatic" as const,
+                    handoffMode: "explicit" as const,
+                  }
                 : {}),
               ownerId: null,
               ownerHeartbeatAt: null,
@@ -1028,7 +1148,8 @@ export function useVoiceInput({
         (status === "requesting-permission" ||
           status === "recording" ||
           status === "saving" ||
-          status === "transcribing")
+          status === "transcribing" ||
+          status === "retrying")
       ) {
         event.preventDefault();
         cancel();
@@ -1043,6 +1164,8 @@ export function useVoiceInput({
       generationRef.current += 1;
       controllerRef.current?.abort();
       controllerRef.current = null;
+      if (automaticRetryTimerRef.current) clearTimeout(automaticRetryTimerRef.current);
+      automaticRetryTimerRef.current = null;
       const manifest = manifestRef.current;
       const ownerReady = ownerIdPromiseRef.current;
       stopOwnerHeartbeat();
@@ -1061,7 +1184,9 @@ export function useVoiceInput({
           const store = storeRef.current;
           if (store && manifest && ownerId) {
             const wasProcessing =
-              statusRef.current === "saving" || statusRef.current === "transcribing";
+              statusRef.current === "saving" ||
+              statusRef.current === "transcribing" ||
+              statusRef.current === "retrying";
             await store
               .updateManifest(
                 manifest.recordingId,
@@ -1073,6 +1198,8 @@ export function useVoiceInput({
                     ? {
                         uploadState: "retrying" as const,
                         transcriptionState: "retrying" as const,
+                        recoveryMode: "automatic" as const,
+                        handoffMode: "explicit" as const,
                       }
                     : {}),
                   ownerId: null,
@@ -1232,7 +1359,7 @@ async function transcribePersistedRecording(input: {
         break;
       case "failed": {
         if (!remote.recording.retryable) {
-          throw { code: remote.recording.errorCode ?? "unknown" };
+          throw { code: remote.recording.errorCode ?? "unknown", retryable: false };
         }
         const retried =
           remote.recording.segmentCount === 0
@@ -1247,7 +1374,10 @@ async function transcribePersistedRecording(input: {
                 { signal: input.signal },
               );
         if (retried.recording.state === "failed") {
-          throw { code: retried.recording.errorCode ?? "unknown" };
+          throw {
+            code: retried.recording.errorCode ?? "unknown",
+            retryable: retried.recording.retryable,
+          };
         }
         remote = retried;
         scheduleRecoveryMutation(remote);
@@ -1350,6 +1480,9 @@ function chooseMimeType(accepted: string[]): string | undefined {
 }
 
 function errorCode(error: unknown): string {
+  if (error instanceof OpenGeniApiError && typeof error.details?.transcriptionCode === "string") {
+    return error.details.transcriptionCode;
+  }
   if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
     return error.code;
   }
@@ -1357,3 +1490,14 @@ function errorCode(error: unknown): string {
   if (error instanceof DOMException && error.name === "NotSupportedError") return "not_supported";
   return "unknown";
 }
+
+function isRetryableVoiceInputError(error: unknown): boolean {
+  if (error instanceof OpenGeniApiError) {
+    return error.retryable && error.status !== 409;
+  }
+  if (error instanceof TypeError) return true;
+  if (error && typeof error === "object" && "retryable" in error) {
+    return error.retryable === true;
+  }
+  return false;
+}

package/src/hooks/use-windowed-sections.ts

@@ -108,16 +108,18 @@ export function useWindowedSections(opts: {
     Array.from({ length: count }, (_, i) => estimateHeight(i)),
   );
 
-  // Re-seed heights when the section count changes (a new diff arrives), keeping
-  // any already-measured heights for surviving indices.
+  // Re-seed when the estimate function changes as well as when the count changes.
+  // A replacement diff can contain the same number of files but radically
+  // different section sizes; retaining measurements by index would then place
+  // every unvisited section at an offset belonging to the previous diff.
   useEffect(() => {
     setHeights((prev) => {
-      if (prev.length === count) return prev;
-      return Array.from({ length: count }, (_, i) => prev[i] ?? estimateHeight(i));
+      const next = Array.from({ length: count }, (_, i) => estimateHeight(i));
+      return prev.length === next.length && prev.every((height, index) => height === next[index])
+        ? prev
+        : next;
     });
-    // estimateHeight is expected stable; count is the real trigger.
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [count]);
+  }, [count, estimateHeight]);
 
   const heightsRef = useRef(heights);
   heightsRef.current = heights;

package/src/hooks/use-workspace-edit.ts

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { useOpenGeni, type ClientOverride } from "../provider";
+import { sandboxAcceptsLiveIo } from "../lib/sandbox-liveness";
 
 /**
  * The wake-on-edit state machine. This hook owns the logic and the UI renders
@@ -73,7 +74,7 @@ export type UseWorkspaceEditResult = {
 };
 
 function isLive(liveness: string | undefined): boolean {
-  return liveness === "warm" || liveness === "draining";
+  return sandboxAcceptsLiveIo(liveness);
 }
 
 /**

package/src/index.ts

@@ -3,14 +3,18 @@
 
 // @opengeni/react — hooks + styled components on @opengeni/sdk.
 //
-// Import the styles once in your Tailwind entry CSS:
-//   @import "@opengeni/react/styles.css";
-//   @source "../node_modules/@opengeni/react/src";
+// Import the ready-to-use styles once:
+//   import "@opengeni/react/compiled.css";
+// Tailwind v4 hosts may instead use the additive styles.css + @source bridge;
+// container-responsive composers additionally import responsive.css.
 
 export type {
+  EmbeddedBrowserInteractionClientLike,
+  EmbeddedComputerInteractionClientLike,
   EmbeddedFileAttachmentClientLike,
   EmbeddedGoalClientLike,
   EmbeddedHumanInputSessionClientLike,
+  EmbeddedInteractionClientLike,
   EmbeddedSessionEventClientLike,
   EmbeddedSessionLineageClientLike,
   EmbeddedSessionMcpApprovalPolicyClientLike,
@@ -21,7 +25,9 @@ export type {
 export { OpenGeniProvider } from "./provider";
 export type { OpenGeniProviderProps } from "./provider";
 export { useOpenGeni, useOpenGeniClient } from "./session-context";
+export { useVideoArtifactPlaybackLoader } from "./hooks/use-video-artifact-playback";
 export type { ClientOverride, OpenGeniContextValue } from "./session-context";
+export { usePageLiveActivity } from "./hooks/internal";
 
 // Hooks
 export { useSession, isTitleEvent } from "./hooks/use-session";
@@ -79,7 +85,9 @@ export type {
   VoiceRecordingChunk,
   VoiceRecordingChunkUploadState,
   VoiceRecordingFinalizationState,
+  VoiceRecordingHandoffMode,
   VoiceRecordingManifest,
+  VoiceRecordingRecoveryMode,
   VoiceRecordingStore,
   VoiceRecordingTranscriptionState,
   VoiceRecordingUploadState,
@@ -229,12 +237,14 @@ export type {
   CapturedFileUnavailableReason,
   FileTreeNode,
   FileTreeStatus,
+  SandboxFilesGitSummary,
   SandboxWriteFileOptions,
   UseSandboxFilesOptions,
   UseSandboxFilesResult,
 } from "./hooks/use-sandbox-files";
 export { useSandboxGit } from "./hooks/use-sandbox-git";
 export type {
+  SandboxGitComparison,
   SandboxGitFileDiff,
   UseSandboxGitOptions,
   UseSandboxGitResult,
@@ -326,6 +336,9 @@ export {
 } from "./timeline";
 export type {
   CreateToolRegistryOptions,
+  RetainedArtifactLoader,
+  RetainedScreenshotLoader,
+  VideoArtifactPlaybackLoader,
   ToolRegistry,
   ToolRegistryEntry,
   ToolRenderer,
@@ -364,7 +377,7 @@ export type {
   TurnSummaryProps,
 } from "./timeline";
 
-// Pure provider-shape parsers (exec banner, V4A diff, secret redaction, …)
+// Pure provider-shape parsers (exec banner, V4A diff, tool arguments, …)
 export {
   applyPatchOps,
   applyPatchOpsFromToolItem,
@@ -376,7 +389,6 @@ export {
   parseExecBannerSessionId,
   parseFreeformApplyPatch,
   parseToolArgs,
-  redactSecrets,
   sandboxCommandExitCode,
   stripExecBanner,
   tailPeek,
@@ -423,7 +435,7 @@ export type {
   ComposerTranscriptionMessages,
 } from "./components/composer-transcription-control";
 export { defaultChatComposerMessages } from "./components/composer";
-export type { ChatComposerMessages } from "./components/composer";
+export type { ChatComposerMessages, ResponsiveBasis } from "./components/composer";
 export { ModelPicker } from "./components/model-picker";
 export type { ModelPickerProps } from "./components/model-picker";
 export {
@@ -459,6 +471,8 @@ export {
 } from "./model-policy";
 export type { LatencyModeId, PickerBillingClass, PickerModelRow } from "./model-policy";
 export { MessageTimeline, TimelineRow } from "./components/message-timeline";
+export { GeneratedVideoPlayer } from "./components/generated-video-player";
+export type { GeneratedVideoPlayerProps } from "./components/generated-video-player";
 export type { MessageTimelineProps } from "./components/message-timeline";
 export { UserMessageBody, userMessageLikelyNeedsDisclosure } from "./components/user-message-body";
 export type { UserMessageBodyProps } from "./components/user-message-body";
@@ -506,6 +520,7 @@ export {
   WORKBENCH_TAB_CHANGES,
   WORKBENCH_TAB_FILES,
   WORKBENCH_TAB_TERMINAL,
+  WORKBENCH_TAB_BROWSER,
   WORKBENCH_TAB_DESKTOP,
   WORKBENCH_SURFACES,
 } from "./components/sandbox-workspace";

package/src/interaction.ts

@@ -0,0 +1,71 @@
+// @opengeni/react/interaction — standalone Browser/Computer resource UI.
+// Framework hosts may pass a narrow structural client instead of the full provider.
+export type {
+  EmbeddedBrowserInteractionClientLike,
+  EmbeddedComputerInteractionClientLike,
+  EmbeddedInteractionClientLike,
+} from "./client";
+export {
+  useEmbeddedBrowserInteraction,
+  useEmbeddedComputerInteraction,
+  useEmbeddedInteraction,
+} from "./session-context";
+export type {
+  EmbeddedBrowserInteractionClientOverride,
+  EmbeddedComputerInteractionClientOverride,
+  EmbeddedInteractionClientOverride,
+} from "./session-context";
+export { useAttachedBrowsers } from "./hooks/use-attached-browsers";
+export type {
+  AttachedBrowsersClient,
+  UseAttachedBrowsersOptions,
+  UseAttachedBrowsersResult,
+} from "./hooks/use-attached-browsers";
+export { useBrowserSessions } from "./hooks/use-browser-sessions";
+export type {
+  BrowserSessionsClient,
+  UseBrowserSessionsOptions,
+  UseBrowserSessionsResult,
+} from "./hooks/use-browser-sessions";
+export { useBrowserIdentities } from "./hooks/use-browser-identities";
+export type {
+  BrowserIdentitiesClient,
+  UseBrowserIdentitiesOptions,
+  UseBrowserIdentitiesResult,
+} from "./hooks/use-browser-identities";
+export { useBrowserSession } from "./hooks/use-browser-session";
+export type {
+  UseBrowserSessionOptions,
+  UseBrowserSessionResult,
+} from "./hooks/use-browser-session";
+export { useBrowserFrameStream } from "./hooks/use-browser-frame-stream";
+export type {
+  BrowserFrameConnectionState,
+  BrowserFrameWebSocket,
+  BrowserFrameWebSocketFactory,
+  UseBrowserFrameStreamOptions,
+  UseBrowserFrameStreamResult,
+} from "./hooks/use-browser-frame-stream";
+export { BrowserViewer } from "./components/browser-viewer";
+export type { BrowserViewerNotification, BrowserViewerProps } from "./components/browser-viewer";
+export { useComputerSessions } from "./hooks/use-computer-sessions";
+export type {
+  ComputerSessionsClient,
+  UseComputerSessionsOptions,
+  UseComputerSessionsResult,
+} from "./hooks/use-computer-sessions";
+export { useComputerSession } from "./hooks/use-computer-session";
+export type {
+  UseComputerSessionOptions,
+  UseComputerSessionResult,
+} from "./hooks/use-computer-session";
+export { useComputerFrameStream } from "./hooks/use-computer-frame-stream";
+export type {
+  ComputerFrameConnectionState,
+  ComputerFrameWebSocket,
+  ComputerFrameWebSocketFactory,
+  UseComputerFrameStreamOptions,
+  UseComputerFrameStreamResult,
+} from "./hooks/use-computer-frame-stream";
+export { ComputerViewer } from "./components/computer-viewer";
+export type { ComputerViewerNotification, ComputerViewerProps } from "./components/computer-viewer";