@opengeni/react 1.4.0 → 1.4.2

package/src/components/composer-transcription-control.tsx

@@ -1,3 +1,7 @@
+import {
+  COMPOSER_VOICE_INPUT_START_EVENT,
+  composerVoiceEventScope,
+} from "../composer-voice-events";
 import type {
   ClientVoiceInputConfig,
   OpenGeniClient,
@@ -35,6 +39,10 @@ export type ComposerTranscriptionMessages = {
   stop: string;
   cancel: string;
   retry: string;
+  /** Transcribe a recording that was stopped without transcribing or recovered. */
+  transcribeSaved: string;
+  /** Shown near the automatic stop; `{seconds}` is replaced. */
+  timeRemaining: string;
   pauseRetrying: string;
   requestingPermission: string;
   recording: string;
@@ -64,32 +72,34 @@ export type ComposerTranscriptionMessages = {
 const defaultMessages: ComposerTranscriptionMessages = {
   start: "Start voice input",
   stop: "Stop and transcribe",
-  cancel: "Cancel recording",
+  cancel: "Stop without transcribing",
   retry: "Retry voice input",
+  transcribeSaved: "Transcribe saved recording",
+  timeRemaining: "Stops and transcribes in {seconds}s",
   pauseRetrying: "Pause automatic retry",
   requestingPermission: "Requesting microphone…",
-  recording: "Recording. Press Escape to cancel.",
+  recording: "Recording. Press Escape to stop without transcribing.",
   saving: "Saving audio locally…",
   transcribing: "Transcribing…",
-  retrying: "Recording saved. Retrying automatically…",
-  recovered: "Recording recovered and saved locally.",
-  recoveredTranscript: "Transcript saved locally. Check your draft before inserting.",
+  retrying: "Saved. Retrying transcription…",
+  recovered: "Recording saved on this device.",
+  recoveredTranscript: "Transcript saved. Insert it into your draft?",
   insertRecoveredTranscript: "Insert saved transcript",
   discardRecovered: "Discard saved recording",
   unavailableDisabled: "Voice input is unavailable while the composer is disabled.",
   unavailable: "Voice input is unavailable for this workspace.",
-  errorPermissionDenied: "Microphone permission was denied. Your draft was not changed.",
+  errorPermissionDenied: "Microphone access is blocked. Allow it in site settings, then try again.",
   errorNotSupported: "Voice input is not supported on this device.",
   errorUnavailable: "Voice input is not configured.",
   errorInsufficientCredits:
-    "Voice input needs Opengeni credits. Add credits, then retry your saved recording.",
-  errorAllowanceExhausted: "Your usage limit was reached. Your recording is saved for later.",
+    "Voice input needs credits. Recording saved; retry after adding credits.",
+  errorAllowanceExhausted: "Usage limit reached. Recording saved for later.",
   errorPolicyBlocked: "Voice input isn't allowed for this account or workspace.",
   errorTooLarge: "Recording is too large. Try a shorter message.",
   errorInvalidAudio: "The recording could not be read. Try again.",
   errorStorageUnavailable: "Voice input stopped because audio could not be saved safely.",
-  errorRetryable: "Recording is saved locally. Retry transcription when ready.",
-  errorHandoffUncertain: "Transcript is saved. Check your draft before inserting it again.",
+  errorRetryable: "Saved. Transcription failed, retry when ready.",
+  errorHandoffUncertain: "Transcript saved. Check your draft before inserting again.",
   errorUnknown: "Voice input could not start. Try again.",
 };
 
@@ -153,12 +163,18 @@ export function ComposerTranscriptionControl({
   const capturing = status === "requesting-permission" || status === "recording";
 
   const cancelTranscription = transcription.cancel;
+  const discardTranscription = transcription.discard;
+  const hasRecoverableRecording = transcription.hasRecoverableRecording;
   useEffect(() => {
     if (!suppressed) return;
     if (status === "recording" || status === "requesting-permission") {
       cancelTranscription();
+    } else if (status === "error" && !hasRecoverableRecording) {
+      // Live voice took over: a stale start error (nothing saved) would only
+      // duplicate whatever live voice reports next to it.
+      void discardTranscription();
     }
-  }, [cancelTranscription, status, suppressed]);
+  }, [cancelTranscription, discardTranscription, hasRecoverableRecording, status, suppressed]);
   const active = capturing || status === "saving" || status === "transcribing";
   const recoverable =
     transcription.hasRecoverableRecording &&
@@ -194,11 +210,22 @@ export function ComposerTranscriptionControl({
                     ? (errorMessage ?? messages.errorUnknown)
                     : unavailableMessage;
 
+  const recoveredLabel = savedTranscript
+    ? (errorMessage ?? messages.recoveredTranscript)
+    : retrying
+      ? messages.retrying
+      : status === "error"
+        ? (errorMessage ?? messages.errorRetryable)
+        : messages.recovered;
+
   function start(event: MouseEvent<HTMLButtonElement>) {
     if (unavailableMessage) {
       event.preventDefault();
       return;
     }
+    composerVoiceEventScope(event.currentTarget)?.dispatchEvent(
+      new Event(COMPOSER_VOICE_INPUT_START_EVENT),
+    );
     void transcription.start();
   }
 
@@ -220,6 +247,9 @@ export function ComposerTranscriptionControl({
           )}
           data-transcription-status={status}
           data-transcription-capturing={capturing ? "" : undefined}
+          data-transcription-attention={
+            !capturing && (recoverable || (status === "error" && errorMessage)) ? "" : undefined
+          }
         >
           <span className="inline-flex min-w-0 items-center gap-1.5">
             <AnimatePresence mode="popLayout" initial={false}>
@@ -235,14 +265,11 @@ export function ComposerTranscriptionControl({
                     "bg-og-surface-2/70 pl-2 pr-1 pointer-coarse:h-11",
                   )}
                 >
-                  <span className="og-transcription-recovered-label max-w-44 truncate text-og-xs text-og-fg-muted max-sm:max-w-28">
-                    {savedTranscript
-                      ? (errorMessage ?? messages.recoveredTranscript)
-                      : retrying
-                        ? messages.retrying
-                        : status === "error"
-                          ? (errorMessage ?? messages.errorRetryable)
-                          : messages.recovered}
+                  <span
+                    title={recoveredLabel}
+                    className="og-transcription-recovered-label max-w-56 line-clamp-2 text-og-xs leading-tight text-og-fg-muted max-sm:max-w-32"
+                  >
+                    {recoveredLabel}
                   </span>
                   <Tip
                     tip={
@@ -250,7 +277,9 @@ export function ComposerTranscriptionControl({
                         ? messages.insertRecoveredTranscript
                         : retrying
                           ? messages.pauseRetrying
-                          : messages.retry
+                          : status === "recovered"
+                            ? messages.transcribeSaved
+                            : messages.retry
                     }
                   >
                     <button
@@ -268,7 +297,9 @@ export function ComposerTranscriptionControl({
                           ? messages.insertRecoveredTranscript
                           : retrying
                             ? messages.pauseRetrying
-                            : messages.retry
+                            : status === "recovered"
+                              ? messages.transcribeSaved
+                              : messages.retry
                       }
                       className={cn(
                         "inline-flex size-7 shrink-0 items-center justify-center rounded-og-sm",
@@ -330,6 +361,13 @@ export function ComposerTranscriptionControl({
                         stream={status === "recording" ? transcription.stream : null}
                         mode={status === "recording" ? "recording" : "transcribing"}
                       />
+                      {status === "recording" && transcription.recordingStartedAt !== null ? (
+                        <RecordingClock
+                          startedAt={transcription.recordingStartedAt}
+                          maxSeconds={transcription.maxRecordingSeconds}
+                          remainingLabel={messages.timeRemaining}
+                        />
+                      ) : null}
                     </span>
                   )}
                   {status === "recording" ? (
@@ -401,14 +439,22 @@ export function ComposerTranscriptionControl({
               )}
             </AnimatePresence>
             {status === "error" && errorMessage && !recoverable ? (
-              <Tip tip={errorMessage}>
-                <span
-                  aria-hidden="true"
-                  className="og-transcription-error-label max-w-40 truncate text-og-xs text-og-status-failed max-sm:max-w-24"
-                >
+              // Nothing is saved in this state, so dismissing loses no speech.
+              <button
+                type="button"
+                title={errorMessage}
+                aria-label={`Dismiss: ${errorMessage}`}
+                onClick={() => void transcription.discard()}
+                className={cn(
+                  "inline-flex min-w-0 items-center gap-1 rounded-og-sm text-left outline-hidden",
+                  "text-og-status-failed focus-visible:ring-2 focus-visible:ring-og-accent/45",
+                )}
+              >
+                <span className="og-transcription-error-label max-w-56 line-clamp-2 text-og-xs leading-tight max-sm:max-w-32">
                   {errorMessage}
                 </span>
-              </Tip>
+                <XIcon className="size-3 shrink-0 opacity-70" aria-hidden />
+              </button>
             ) : null}
             <span
               className="sr-only"
@@ -424,6 +470,42 @@ export function ComposerTranscriptionControl({
   );
 }
 
+/** Elapsed dictation time; warns before the automatic stop-and-transcribe. */
+function RecordingClock({
+  startedAt,
+  maxSeconds,
+  remainingLabel,
+}: {
+  startedAt: number;
+  maxSeconds: number | null;
+  remainingLabel: string;
+}) {
+  const [now, setNow] = useState(() => Date.now());
+  useEffect(() => {
+    const timer = setInterval(() => setNow(Date.now()), 500);
+    return () => clearInterval(timer);
+  }, []);
+  const elapsed = Math.max(0, Math.floor((now - startedAt) / 1_000));
+  const remaining = maxSeconds === null ? null : Math.max(0, maxSeconds - elapsed);
+  const warn = remaining !== null && remaining <= 15;
+  const label = `${Math.floor(elapsed / 60)}:${String(elapsed % 60).padStart(2, "0")}`;
+  return (
+    <span
+      data-recording-clock
+      title={warn ? remainingLabel.replace("{seconds}", String(remaining)) : undefined}
+      className={cn(
+        "min-w-[2.25rem] text-right text-og-xs tabular-nums",
+        warn ? "font-medium text-og-status-failed" : "text-og-fg-muted",
+      )}
+    >
+      {label}
+      {warn ? (
+        <span className="sr-only">{remainingLabel.replace("{seconds}", String(remaining))}</span>
+      ) : null}
+    </span>
+  );
+}
+
 function VoiceWaveform({
   stream,
   mode,

package/src/components/markdown.tsx

@@ -230,7 +230,7 @@ const baseComponents: Components = {
   ),
   td: ({ children, ...props }) => (
     <td
-      className="border-b border-og-border/70 px-0 py-1.5 pr-4 align-top text-og-fg-muted [tr:last-child>&]:border-b-0"
+      className="border-b border-og-border/70 px-0 py-1.5 pr-4 align-top text-og-fg-muted"
       {...props}
     >
       {children}
@@ -615,7 +615,12 @@ function MarkdownTable({ children, className, ...props }: ComponentPropsWithoutR
       <div className="overflow-x-auto" tabIndex={0}>
         <table
           ref={tableRef}
-          className={cn("w-full min-w-0 border-collapse text-og-base", className)}
+          className={cn(
+            // Leading `&` only: a trailing one (`tr:last-child>&`) under the scoped
+            // selector list needs `:is()`, which bundlers warn about for older targets.
+            "w-full min-w-0 border-collapse text-og-base [&_tr:last-child>td]:border-b-0",
+            className,
+          )}
           {...props}
         >
           {children}

package/src/components/message-timeline.tsx

@@ -2496,6 +2496,16 @@ export function MessageTimeline({
     }
     releasePinAfterScrollSettled(node);
   };
+  // React 18 has no `onScrollEnd` prop: it warns and never calls it, while
+  // `supportsScrollEndEvent()` still makes the camera wait for scrollend. A
+  // native listener (re-bound each commit, so it always sees this render's
+  // handler and scroller) works on every supported React version.
+  useEffect(() => {
+    const node = scrollRef.current;
+    if (!node) return;
+    node.addEventListener("scrollend", onScrollEnd);
+    return () => node.removeEventListener("scrollend", onScrollEnd);
+  });
 
   const timeline = (
     <AllowancePresentationProvider
@@ -2538,7 +2548,6 @@ export function MessageTimeline({
                           }
                           tabIndex={-1}
                           onScroll={onScroll}
-                          onScrollEnd={onScrollEnd}
                           onWheel={onWheel}
                           onTouchStart={(event) => {
                             stopSettlement();

package/src/components/session-conversation.tsx

@@ -34,6 +34,7 @@ import {
   createWorkspaceRetainedArtifactLoader,
   createWorkspaceRetainedVideoLoader,
 } from "../timeline/retained-loaders";
+import { useRealtimeVoiceModels } from "../hooks/use-realtime-voice-models";
 import { projectPendingApprovals } from "../approvals";
 import { ApprovalSurface } from "./approval-surface";
 import { ChatComposer, type ChatComposerProps } from "./chat-composer";
@@ -126,6 +127,12 @@ export type SessionConversationProps = ClientOverride &
      * (`createSessionProxyHandler({ voiceInput: false })` turns it off).
      */
     voiceInput?: boolean | undefined;
+    /**
+     * Live speech-to-speech voice in the composer. Defaults to true; the voice
+     * button appears only when the workspace offers an available voice model
+     * and the proxy has not turned it off (`realtimeVoice: false`).
+     */
+    realtimeVoice?: boolean | undefined;
     /**
      * Show the model/reasoning picker. End users of an embedded product rarely
      * choose models, so it is hidden unless this is `true` or the client config
@@ -210,6 +217,7 @@ function Conversation({
   allowanceExhaustedLabels,
   attachments: attachmentsRequested = true,
   voiceInput: voiceInputRequested = true,
+  realtimeVoice: realtimeVoiceRequested = true,
   modelPicker,
   modelPickerProps,
   userMessageDisclosureLabels,
@@ -319,6 +327,30 @@ function Conversation({
     if (feed.error) void feed.jumpToLatest();
   };
   const running = status === "running" || status === "recovering" || status === "waiting_capacity";
+  const voiceModels = useRealtimeVoiceModels(
+    context.client,
+    context.workspaceId,
+    realtimeVoiceRequested && config.realtimeVoice && !importedArchive,
+  );
+  const [voiceActive, setVoiceActive] = useState(false);
+  const voiceControl =
+    composer.effectiveControl ?? queue.effectiveControl ?? detail.session?.effectiveControl;
+  const voice =
+    voiceModels.length > 0 && status && !terminal && voiceControl ? (
+      <Suspense fallback={null}>
+        <LazyEmbeddedRealtimeVoice
+          client={context.client}
+          workspaceId={context.workspaceId}
+          models={voiceModels}
+          sessionId={sessionId}
+          sessionStatus={status}
+          effectiveControl={voiceControl}
+          events={feed.events}
+          eventsReady={!feed.initialLoading}
+          onVoiceActiveChange={setVoiceActive}
+        />
+      </Suspense>
+    ) : null;
   return (
     <div
       className={cn(
@@ -467,6 +499,17 @@ function Conversation({
               {...(transcription && composerProps?.transcription === undefined
                 ? { transcription }
                 : {})}
+              actionsStart={
+                voice ? (
+                  <>
+                    {composerProps?.actionsStart}
+                    {voice}
+                  </>
+                ) : (
+                  composerProps?.actionsStart
+                )
+              }
+              transcriptionSuppressed={composerProps?.transcriptionSuppressed ?? voiceActive}
               composer={composer}
               attachments={uploadsEnabled ? files : undefined}
               disabled={terminal || composerProps?.disabled}
@@ -534,6 +577,7 @@ function GoalChrome({ sessionId, client, workspaceId, events, chrome }: Conversa
   });
   return <SessionChrome {...chrome} goal={goal} />;
 }
+const LazyEmbeddedRealtimeVoice = lazy(() => import("../realtime/embedded-voice"));
 
 const LazyChatInteractiveBlock = lazy(() =>
   import("./artifacts/chat-interactive-block").then((module) => ({

package/src/components/session-proxy-scope.tsx

@@ -1,4 +1,9 @@
-import { OpenGeniBrowserClient, type FetchLike } from "@opengeni/sdk/browser";
+import {
+  formatErrorMessage,
+  OpenGeniApiError,
+  OpenGeniBrowserClient,
+  type FetchLike,
+} from "@opengeni/sdk/browser";
 import { useEffect, useMemo, useRef, useState, type ReactNode } from "react";
 import type { SessionClientLike } from "../client";
 import { OpenGeniProvider } from "../provider";
@@ -26,6 +31,25 @@ export type SessionProxyBaseUrl = {
   fetch?: FetchLike | undefined;
 };
 
+/**
+ * End-user copy for a failed first load. The proxy calls Opengeni with the
+ * server's key, so Opengeni's own `unauthenticated` refusal means that key was
+ * rejected (the server logs what to fix), not that this person must sign in.
+ * A host's own 401 from `resolve` carries no Opengeni code and still reads as
+ * "Sign in to continue."
+ */
+function proxyLoadErrorMessage(error: unknown): string {
+  if (
+    error instanceof OpenGeniApiError &&
+    error.status === 401 &&
+    error.code === "unauthenticated"
+  ) {
+    const message = "Chat is unavailable right now. Ask an administrator for help.";
+    return error.correlationId ? `${message} Reference: ${error.correlationId}.` : message;
+  }
+  return formatErrorMessage(error, "Could not load the conversation.");
+}
+
 type ScopeState =
   | { status: "loading" }
   | { status: "ready"; workspaceId: string }
@@ -103,10 +127,7 @@ export function SessionProxyScope({
       },
       (error: unknown) => {
         if (!active) return;
-        setState({
-          status: "error",
-          message: error instanceof Error ? error.message : "Could not load the conversation.",
-        });
+        setState({ status: "error", message: proxyLoadErrorMessage(error) });
       },
     );
     return () => {

package/src/composer-voice-events.ts

@@ -0,0 +1,12 @@
+/**
+ * Internal DOM signal between the composer's two voice controls: dictation
+ * starting supersedes a stale live-voice start failure in the same composer.
+ * Not part of the public package surface.
+ */
+export const COMPOSER_VOICE_INPUT_START_EVENT = "opengeni:composer-voice-input-start";
+
+/** Closest composer root shared by both voice controls (falls back to the document). */
+export function composerVoiceEventScope(element: Element | null): EventTarget | null {
+  if (!element) return null;
+  return element.closest(".og-composer") ?? element.ownerDocument;
+}

package/src/connection-discovery.tsx

@@ -92,7 +92,10 @@ function ScopedDiscovery({
               (item) =>
                 item.kind === "mcp" &&
                 item.authKind === "oauth2" &&
-                Boolean(item.mcpUrl ?? item.endpointUrl),
+                Boolean(item.mcpUrl ?? item.endpointUrl) &&
+                // The provider refuses self-registration and this deployment
+                // has no operator client for it: Connect cannot succeed.
+                (item.enabled || item.runtime?.operatorOAuthClient?.configured !== false),
             ),
           );
         }

package/src/hooks/use-client-config-flags.ts

@@ -12,6 +12,7 @@ export type ClientConfigFlagsSource = {
     sessionCreation?: boolean | undefined;
     archive?: boolean | undefined;
     voiceInput?: ClientVoiceInputConfig | undefined;
+    realtimeVoice?: boolean | undefined;
   }>;
 };
 
@@ -33,6 +34,11 @@ export type ClientConfigFlags = {
   archive: boolean;
   /** Native voice input when the deployment can transcribe, else null. */
   voiceInput: ClientVoiceInputConfig | null;
+  /**
+   * Live voice. `false` until the config loads and when a session proxy turns
+   * it off; availability otherwise comes from the realtime model catalog.
+   */
+  realtimeVoice: boolean;
 };
 
 const INITIAL_FLAGS: ClientConfigFlags = {
@@ -45,6 +51,7 @@ const INITIAL_FLAGS: ClientConfigFlags = {
   sessionCreation: true,
   archive: true,
   voiceInput: null,
+  realtimeVoice: false,
 };
 
 type ClientConfigFlagsInput = Awaited<ReturnType<ClientConfigFlagsSource["getClientConfig"]>>;
@@ -89,6 +96,7 @@ export function useClientConfigFlags(
             sessionCreation: config.sessionCreation !== false,
             archive: config.archive !== false,
             voiceInput: config.voiceInput?.available === true ? config.voiceInput : null,
+            realtimeVoice: config.realtimeVoice !== false,
           });
         }
       },

package/src/hooks/use-goal.ts

@@ -84,6 +84,9 @@ export function useGoal(
   const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
   const generation = useRef(0);
   const targetKeyRef = useRef<string | null>(null);
+  // True after the server answered 404. Only a goal event can create a goal,
+  // so turn/session traffic must not refetch (and 404) while none exists.
+  const goalAbsentRef = useRef(false);
   const loadAbort = useRef<AbortController | null>(null);
 
   const retireLoads = useCallback(() => {
@@ -105,6 +108,7 @@ export function useGoal(
         signal: controller.signal,
       });
       if (ticket === generation.current) {
+        goalAbsentRef.current = false;
         setGoal(fetched);
         setError(null);
         setLoading(false);
@@ -115,6 +119,7 @@ export function useGoal(
       }
       if (cause instanceof OpenGeniApiError && cause.status === 404) {
         // No goal is a normal state, not an error.
+        goalAbsentRef.current = true;
         setGoal(null);
         setError(null);
       } else {
@@ -130,6 +135,7 @@ export function useGoal(
     const targetKey = `${workspaceId} ${sessionId ?? ""}`;
     if (targetKeyRef.current !== targetKey) {
       targetKeyRef.current = targetKey;
+      goalAbsentRef.current = false;
       setGoal(null);
       setError(null);
     }
@@ -181,7 +187,12 @@ export function useGoal(
   ]);
 
   const scheduleRefresh = useDebouncedCallback(() => void load());
-  useSessionEventTrigger(client, workspaceId, sessionId, isGoalRefreshEvent, scheduleRefresh, {
+  const isRefreshEvent = useCallback(
+    (event: SessionEvent) =>
+      goalAbsentRef.current ? isGoalEvent(event) : isGoalRefreshEvent(event),
+    [],
+  );
+  useSessionEventTrigger(client, workspaceId, sessionId, isRefreshEvent, scheduleRefresh, {
     enabled,
     ...(sharedEvents !== undefined ? { events: sharedEvents } : {}),
   });

package/src/hooks/use-realtime-voice-models.ts

@@ -0,0 +1,67 @@
+import type { WorkspaceRealtimeModelCatalogResponse } from "@opengeni/sdk";
+import { useEffect, useState } from "react";
+
+type CatalogClient = {
+  getWorkspaceRealtimeModelCatalog?: (
+    workspaceId: string,
+    options?: { signal?: AbortSignal | undefined },
+  ) => Promise<WorkspaceRealtimeModelCatalogResponse>;
+};
+
+type AvailableVoiceModels = WorkspaceRealtimeModelCatalogResponse["models"];
+
+const CACHE_TTL_MS = 60_000;
+const cache = new WeakMap<
+  object,
+  Map<string, { models: Promise<AvailableVoiceModels>; expiresAt: number }>
+>();
+
+function load(client: CatalogClient, workspaceId: string): Promise<AvailableVoiceModels> {
+  let byWorkspace = cache.get(client);
+  if (!byWorkspace) {
+    byWorkspace = new Map();
+    cache.set(client, byWorkspace);
+  }
+  const hit = byWorkspace.get(workspaceId);
+  if (hit && hit.expiresAt > Date.now()) return hit.models;
+  // A throwing structural client (one without voice) just means no voice.
+  const models = Promise.resolve()
+    .then(() => client.getWorkspaceRealtimeModelCatalog!(workspaceId))
+    .then((catalog) => catalog.models.filter((model) => model.available));
+  const entry = { models, expiresAt: Date.now() + CACHE_TTL_MS };
+  byWorkspace.set(workspaceId, entry);
+  models.catch(() => {
+    if (byWorkspace.get(workspaceId) === entry) byWorkspace.delete(workspaceId);
+  });
+  return models;
+}
+
+/**
+ * Voice models this user can start right now in the workspace, or an empty
+ * list while unknown, disabled, unsupported (older API or proxy), or failed.
+ * Availability is advisory; Opengeni still admits and meters every call.
+ */
+export function useRealtimeVoiceModels(
+  client: unknown,
+  workspaceId: string,
+  enabled: boolean,
+): AvailableVoiceModels {
+  const [models, setModels] = useState<AvailableVoiceModels>([]);
+  useEffect(() => {
+    setModels([]);
+    const catalogClient = client as CatalogClient;
+    if (!enabled || !workspaceId) return;
+    if (typeof catalogClient.getWorkspaceRealtimeModelCatalog !== "function") return;
+    let live = true;
+    load(catalogClient, workspaceId).then(
+      (available) => {
+        if (live) setModels(available);
+      },
+      () => undefined,
+    );
+    return () => {
+      live = false;
+    };
+  }, [client, workspaceId, enabled]);
+  return models;
+}