@opengeni/react 1.3.0 → 1.4.2

package/src/components/tool-review-history.tsx

@@ -1,7 +1,6 @@
 import { createContext, useContext, useEffect, useMemo, useState, type ReactNode } from "react";
 import type { SessionEvent, ToolActionReview } from "@opengeni/sdk";
 import { approvalsFromRequiresAction } from "../approvals";
-import { ToolActionReviewCard } from "./tool-action-review";
 
 type HistoryContext = {
   approvalIds: ReadonlySet<string>;
@@ -55,59 +54,35 @@ export function useHasToolReview(approvalId: string | null): boolean {
   return Boolean(approvalId && history?.approvalIds.has(approvalId));
 }
 
-/** Recorded calls have details, never another decision button. */
-export function ToolReviewHistoryReceipt({ approvalId }: { approvalId: string }) {
+/**
+ * The saved review for one recorded call, or null while it loads or when it is
+ * unavailable (callers then keep their ordinary tool row).
+ */
+export function useRecordedToolReview(approvalId: string | null): {
+  review: ToolActionReview | null;
+  onViewDetails: ((path: string) => void) | undefined;
+} {
   const history = useContext(History);
   const [review, setReview] = useState<ToolActionReview | null>(null);
-  const [failed, setFailed] = useState(false);
-  const [retry, setRetry] = useState(0);
   const load = history?.load;
   const revision = history?.revision;
   useEffect(() => {
-    if (!load) return;
+    if (!load || !approvalId) return;
     let active = true;
-    setFailed(false);
     void load(approvalId).then(
       (value) => {
-        if (active) {
-          if (value.id === approvalId) setReview(value);
-          else setFailed(true);
-        }
-      },
-      () => {
-        if (active) setFailed(true);
+        if (active && value.id === approvalId) setReview(value);
       },
+      () => undefined,
     );
     return () => {
       active = false;
     };
-  }, [approvalId, load, revision, retry]);
-  if (!history) return null;
-  if (failed)
-    return (
-      <p className="text-og-sm text-og-fg-muted" role="alert">
-        Review details unavailable.{" "}
-        <button
-          type="button"
-          className="min-h-11 underline"
-          onClick={() => setRetry((value) => value + 1)}
-        >
-          Try again
-        </button>
-      </p>
-    );
-  if (!review)
-    return (
-      <p role="status" className="text-og-sm text-og-fg-muted">
-        Loading reviewed action…
-      </p>
-    );
-  return (
-    <div data-approval-id={approvalId} data-review-origin="history">
-      <ToolActionReviewCard
-        review={{ ...review, availableActions: [] }}
-        onViewDetails={(path) => history.onViewDetails(review, path)}
-      />
-    </div>
-  );
+  }, [approvalId, load, revision]);
+  const onViewDetails = history?.onViewDetails;
+  return {
+    review: review && review.id === approvalId ? review : null,
+    onViewDetails:
+      review && onViewDetails ? (path: string) => onViewDetails(review, path) : undefined,
+  };
 }

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

@@ -0,0 +1,110 @@
+import type { ClientVoiceInputConfig, ReasoningEffort } from "@opengeni/sdk";
+import { useEffect, useState } from "react";
+
+/** The client-config fields the stock conversation and chat read. */
+export type ClientConfigFlagsSource = {
+  getClientConfig: () => Promise<{
+    fileUploads?: { enabled?: boolean };
+    modelSelection?: boolean | undefined;
+    sandboxFiles?: boolean | undefined;
+    defaultReasoningEffort?: ReasoningEffort | undefined;
+    artifacts?: unknown;
+    sessionCreation?: boolean | undefined;
+    archive?: boolean | undefined;
+    voiceInput?: ClientVoiceInputConfig | undefined;
+    realtimeVoice?: boolean | undefined;
+  }>;
+};
+
+export type ClientConfigFlags = {
+  /** Whether the config has loaded. Proxy capability flags stay `true` until it says otherwise. */
+  loaded: boolean;
+  uploads: boolean;
+  modelSelection: boolean;
+  sandboxFiles: boolean;
+  defaultReasoningEffort: ReasoningEffort | null;
+  /**
+   * Inline Site previews and the artifact viewer. `false` only when a session
+   * proxy says it does not serve them; native deployments omit the flag.
+   */
+  artifacts: boolean;
+  /** Browser chat creation. `false` only when a session proxy has no `createSession` hook. */
+  sessionCreation: boolean;
+  /** Chat archive/restore. `false` only when a session proxy disables it. */
+  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 = {
+  loaded: false,
+  uploads: false,
+  modelSelection: false,
+  sandboxFiles: false,
+  defaultReasoningEffort: null,
+  artifacts: true,
+  sessionCreation: true,
+  archive: true,
+  voiceInput: null,
+  realtimeVoice: false,
+};
+
+type ClientConfigFlagsInput = Awaited<ReturnType<ClientConfigFlagsSource["getClientConfig"]>>;
+
+// One read per client: the chat, its list, the new-chat composer and the
+// conversation all ask, and behind a session proxy each read is a round trip.
+const configReads = new WeakMap<object, Promise<ClientConfigFlagsInput>>();
+
+function readClientConfig(client: ClientConfigFlagsSource): Promise<ClientConfigFlagsInput> {
+  let read = configReads.get(client);
+  if (!read) {
+    read = client.getClientConfig();
+    configReads.set(client, read);
+    // A failed read is retried by the next mount rather than cached.
+    read.catch(() => {
+      if (configReads.get(client) === read) configReads.delete(client);
+    });
+  }
+  return read;
+}
+
+/** Deployment and session-proxy capabilities from the client config. */
+export function useClientConfigFlags(
+  client: Partial<ClientConfigFlagsSource> | ClientConfigFlagsSource,
+): ClientConfigFlags {
+  const [flags, setFlags] = useState<ClientConfigFlags>(INITIAL_FLAGS);
+  useEffect(() => {
+    // Custom clients without a config read keep the defaults.
+    if (typeof client.getClientConfig !== "function") return;
+    let live = true;
+    readClientConfig(client as ClientConfigFlagsSource).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,
+          });
+        }
+      },
+      () => undefined,
+    );
+    return () => {
+      live = false;
+    };
+  }, [client]);
+  return flags;
+}

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;
+}

package/src/hooks/use-session-events.ts

@@ -225,8 +225,8 @@ export function useSessionEvents(
   // new stream identity cannot expose the previous session's event log.
   const [stateStreamKey, setStateStreamKey] = useState(streamKey);
 
-  // Reopening SSE after a prepend must not cancel the next history page.
-  // Navigation belongs to the session/client lifetime, not the transport.
+  // Navigation belongs to the session/client lifetime, not the transport: an
+  // SSE reconnect must never cancel an in-flight history page.
   useEffect(() => {
     navigationGenerationRef.current += 1;
     setNewerError(null);
@@ -621,9 +621,6 @@ export function useSessionEvents(
           }
           const current = eventWindowRef.current;
           assertPrependOrder(current.events, window.events);
-          // Freeze the live iterator before replacing its in-memory window. Rows
-          // pending in the aborted iterator were never cursor-committed and will
-          // be replayed from the retained high-water mark below.
           const next = boundBrowserSessionEventWindow([...window.events, ...current.events], {
             direction: "oldest",
           });
@@ -633,7 +630,6 @@ export function useSessionEvents(
             markTailPreserved();
             return false;
           }
-          streamAbortRef.current?.abort();
           const status = observeSessionStatus(window.events, sessionStatusRef);
           const retained = {
             ...next,
@@ -645,21 +641,28 @@ export function useSessionEvents(
           }
           const retainedNewest = maxResumeSequenceOrNull(retained.events);
           const previousNewest = maxResumeSequenceOrNull(current.events);
+          const evictedLiveTail =
+            previousNewest !== null && retainedNewest !== null && retainedNewest < previousNewest;
+          if (evictedLiveTail && viewModeRef.current === "live") {
+            // The prepend leaves the live tip. Freeze the iterator before the
+            // window is replaced so a late flush cannot append live rows onto
+            // (and newest-bound away) the history the reader just requested.
+            streamAbortRef.current?.abort();
+          }
           eventWindowRef.current = retained;
           markCommitted();
           oldestSequenceRef.current = retainedOldest;
           newestSequenceRef.current = retainedNewest;
-          streamResumeSequenceRef.current = maxResumeSequence(retained.events);
+          if (evictedLiveTail) {
+            streamResumeSequenceRef.current = maxResumeSequence(retained.events);
+          }
           // Oldest-directed eviction can discard newer in-memory rows. That fact
           // keeps windowTruncated true, but it does not imply older durable rows
           // exist; only the backward DB page can answer hasOlder truthfully.
           const olderStillAvailable = window.hasOlder;
           hasOlderRef.current = olderStillAvailable;
-          const evictedLiveTail =
-            previousNewest !== null && retainedNewest !== null && retainedNewest < previousNewest;
           let newer: boolean | null = null;
           let enterHistory = false;
-          let reconnectLive = false;
           if (viewModeRef.current === "history" || evictedLiveTail) {
             const highWater = lastSequenceRef.current;
             newer = retainedNewest !== null && (retainedNewest < highWater || retained.truncated);
@@ -672,11 +675,13 @@ export function useSessionEvents(
               viewModeRef.current = "history";
               enterHistory = true;
             }
-          } else {
-            // The retained merge is still one contiguous live suffix. Restart
-            // SSE from its cursor so events queued during the fetch are replayed.
-            reconnectLive = true;
           }
+          // Otherwise the merge is still one contiguous live suffix and the open
+          // SSE iterator keeps appending to it: every flush reads
+          // eventWindowRef, so rows delivered during or after this fetch land
+          // once, in order, on the prepended window. Reopening the stream here
+          // would flash a connecting state and re-run session reconciliation on
+          // every scroll-up for no data benefit.
           loadingOlderRef.current = false;
           startTransition(() => {
             if (status !== undefined) {
@@ -689,8 +694,6 @@ export function useSessionEvents(
             }
             if (enterHistory) {
               setViewMode("history");
-            } else if (reconnectLive) {
-              setStreamEpoch((epoch) => epoch + 1);
             }
             setLoadingOlder(false);
           });

package/src/hooks/use-transcription.ts

@@ -611,6 +611,12 @@ function classifyStartError(error: unknown): TranscriptionErrorCode {
 
 export function normalizeTranscriptionErrorCode(code: unknown): TranscriptionErrorCode {
   switch (code) {
+    case "insufficient_credits":
+    case "allowance_exhausted":
+    case "monthly_model_cost_limit":
+    case "unavailable":
+    case "too_large":
+    case "invalid_audio":
     case "permission_denied":
     case "not_supported":
     case "network":