@opengeni/react 3.1.0 → 3.1.3-canary.38890816741001

package/src/hooks/use-browser-sessions.ts

@@ -71,17 +71,19 @@ export function useBrowserSessions(
     id: 0,
     controller: null,
   });
+  const loadQueueRef = useRef<{ pending: boolean; promise: Promise<void> } | null>(null);
   const mountedRef = useRef(true);
 
   const visibleState = state.workspaceId === workspaceId ? state : emptyState(workspaceId, enabled);
 
   const cancelLoad = useCallback(() => {
+    loadQueueRef.current = null;
     const id = requestRef.current.id + 1;
     requestRef.current.controller?.abort();
     requestRef.current = { id, controller: null };
   }, []);
 
-  const load = useCallback(
+  const loadOnce = useCallback(
     async (foreground: boolean): Promise<void> => {
       if (!enabled) return;
       const id = requestRef.current.id + 1;
@@ -128,6 +130,35 @@ export function useBrowserSessions(
     [client, enabled, workspaceId],
   );
 
+  const load = useCallback(
+    (foreground: boolean): Promise<void> => {
+      const current = loadQueueRef.current;
+      if (current) {
+        current.pending = true;
+        return current.promise;
+      }
+      const queue = { pending: false, promise: Promise.resolve() };
+      loadQueueRef.current = queue;
+      queue.promise = Promise.resolve()
+        .then(async () => {
+          // A slow read must be allowed to finish. Invalidations and polling
+          // coalesce into one trailing read instead of repeatedly aborting it.
+          while (loadQueueRef.current === queue) {
+            queue.pending = false;
+            await loadOnce(foreground);
+            foreground = false;
+            if (!queue.pending) break;
+          }
+          if (loadQueueRef.current === queue) loadQueueRef.current = null;
+        })
+        .finally(() => {
+          if (loadQueueRef.current === queue) loadQueueRef.current = null;
+        });
+      return queue.promise;
+    },
+    [loadOnce],
+  );
+
   const refresh = useCallback(async () => await load(false), [load]);
 
   useEffect(() => {

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

@@ -0,0 +1,118 @@
+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;
+  /**
+   * The host explicitly offers live voice to end users (a session proxy with
+   * `realtimeVoice: true`). Embedded conversations show the voice button only
+   * then or when their `realtimeVoice` prop is `true`.
+   */
+  realtimeVoiceOffered: 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,
+  realtimeVoiceOffered: 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,
+            realtimeVoiceOffered: config.realtimeVoice === true,
+          });
+        }
+      },
+      () => undefined,
+    );
+    return () => {
+      live = false;
+    };
+  }, [client]);
+  return flags;
+}

package/src/hooks/use-codex-accounts.ts

@@ -3,41 +3,158 @@ import type {
   CodexAccount,
   CodexAccountsResponse,
   CodexRotationSettings,
+  CodexUsageMap,
+  SessionCodexAccountsResponse,
   SessionEvent,
 } from "@opengeni/sdk";
 import { useOpenGeni, type ClientOverride } from "../provider";
 import {
   useMutationRunner,
-  usePolledValue,
   useSessionEventTrigger,
   type SessionEventFeedOptions,
 } from "./internal";
+import {
+  invalidateSharedQueries,
+  peekSharedQuery,
+  sharedQueryWriter,
+  useSharedQuery,
+  useSharedQueryValue,
+  type SharedQueryKey,
+  type SharedQueryWriter,
+} from "./shared-query";
+
+/**
+ * Shared-cache keys for Codex reads. Every surface that reads the same thing
+ * through the same client (the session switcher, Settings > Models) shares one
+ * entry, so a revisit renders the last rows at once and re-reads quietly.
+ * Internal: not exported from the package root.
+ */
+export const codexAccountsQueryKey = (workspaceId: string, sessionId?: string | null) =>
+  (sessionId
+    ? ["codex-accounts", workspaceId, "session", sessionId]
+    : ["codex-accounts", workspaceId]) as SharedQueryKey;
+/** The last LIVE provider usage per account, written by every live usage read. */
+export const codexLiveUsageQueryKey = (workspaceId: string) =>
+  ["codex-live-usage", workspaceId] as SharedQueryKey;
+
+/**
+ * The last LIVE provider reading per account and when each one was taken. Only
+ * live provider reads write it, never the server's cached limit columns.
+ */
+export type CodexLiveUsageSnapshot = {
+  usage: CodexUsageMap;
+  /** Epoch milliseconds of each account's reading. */
+  readAt: Record<string, number>;
+};
+
+/**
+ * Record live readings through a writer created before the read started.
+ * `replace` is a read of every account (the batch); `merge` updates only the
+ * accounts in `readings` and leaves the others' readings and times alone.
+ */
+export function recordCodexLiveUsage(
+  write: SharedQueryWriter,
+  scope: object,
+  workspaceId: string,
+  readings: CodexUsageMap,
+  mode: "replace" | "merge",
+): boolean {
+  const key = codexLiveUsageQueryKey(workspaceId);
+  const previous =
+    mode === "merge" ? peekSharedQuery<CodexLiveUsageSnapshot>(scope, key)?.data : null;
+  const now = Date.now();
+  return write<CodexLiveUsageSnapshot>(key, {
+    usage: { ...previous?.usage, ...readings },
+    readAt: {
+      ...previous?.readAt,
+      ...Object.fromEntries(Object.keys(readings).map((id) => [id, now])),
+    },
+  });
+}
+
+/** When the oldest reading in the snapshot was taken (epoch ms), or null. */
+function oldestReading(snapshot: CodexLiveUsageSnapshot | null | undefined): number | null {
+  const times = Object.values(snapshot?.readAt ?? {});
+  return times.length > 0 ? Math.min(...times) : null;
+}
+
+const liveUsageReads = new WeakMap<object, Map<string, Promise<CodexUsageMap>>>();
+
+/** One live usage refresh per client + workspace at a time; joiners share it. */
+function sharedLiveUsageRead(
+  scope: object,
+  workspaceId: string,
+  read: () => Promise<{ usage: CodexUsageMap }>,
+): Promise<CodexUsageMap> {
+  let reads = liveUsageReads.get(scope);
+  if (!reads) {
+    reads = new Map();
+    liveUsageReads.set(scope, reads);
+  }
+  const existing = reads.get(workspaceId);
+  if (existing) return existing;
+  // Bound to the identity epoch the read starts in: a clear meanwhile drops it.
+  const write = sharedQueryWriter(scope);
+  const request = read().then((fresh) => {
+    recordCodexLiveUsage(write, scope, workspaceId, fresh.usage, "replace");
+    return fresh.usage;
+  });
+  const settle = () => {
+    if (reads!.get(workspaceId) === request) reads!.delete(workspaceId);
+  };
+  request.then(settle, settle);
+  reads.set(workspaceId, request);
+  return request;
+}
 
 /** Events that change which Codex account a session runs on (or just ran). */
 export function isCodexAccountEvent(event: Pick<SessionEvent, "type">): boolean {
-  return event.type === "codex.account.switched";
+  return [
+    "codex.credential.selected",
+    "codex.account.switched",
+    "codex.account.selection.changed",
+    "model_account.selection.changed",
+    "codex.capacity.waiting",
+    "codex.capacity.resumed",
+    "codex.capacity.superseded",
+    "turn.completed",
+    "turn.failed",
+    "turn.cancelled",
+    "turn.requires_action",
+    "session.status.changed",
+  ].includes(event.type);
 }
 
 /**
  * The structural slice of the SDK client the Codex-accounts surface needs. Method
  * NAMES + SIGNATURES match `OpenGeniClient` so the real client satisfies it
  * directly; declared structurally (not a hard Pick) so a test/Geni client can
- * stand in. `getSession` reads the session's pin/last; `pinSessionCodexAccount`
+ * stand in. `listSessionCodexAccounts` reads the accepted selection and choices
+ * atomically; `pinSessionCodexAccount`
  * is the optional mutation (absent ⇒ the indicator hides the switch affordance).
  */
 export type CodexAccountsClientLike = {
   listCodexAccounts: (workspaceId: string) => Promise<CodexAccountsResponse>;
+  /** Required for session-scoped use; never fall back to another pool. */
+  listSessionCodexAccounts?: (
+    workspaceId: string,
+    sessionId: string,
+  ) => Promise<SessionCodexAccountsResponse>;
   getSession?: (
     workspaceId: string,
     sessionId: string,
-  ) => Promise<{ codexPinnedCredentialId?: string | null; codexLastCredentialId?: string | null }>;
+  ) => Promise<{
+    codexPinnedCredentialId?: string | null;
+    codexLastCredentialId?: string | null;
+    codexCurrentSelection?: { credentialId: string | null; waiting: boolean } | null;
+  }>;
   pinSessionCodexAccount?: (
     workspaceId: string,
     sessionId: string,
     target: string,
-  ) => Promise<{ pinned: string }>;
+  ) => Promise<{ pinned: string; appliedTo?: "waiting_turn" | "next_turn" }>;
   /** Optional (absent ⇒ the card hides live refresh): batched live /wham/usage refresh. */
-  refreshCodexUsage?: (workspaceId: string) => Promise<{ usage: Record<string, unknown> }>;
+  refreshCodexUsage?: (workspaceId: string) => Promise<{ usage: CodexUsageMap }>;
 };
 
 export type UseCodexAccountsOptions = ClientOverride &
@@ -51,23 +168,33 @@ export type UseCodexAccountsOptions = ClientOverride &
 
 export type UseCodexAccountsResult = {
   accounts: CodexAccount[];
-  /** The workspace ACTIVE account (used when a session is unpinned). */
+  /** The ACTIVE account for the retry pool, or current workspace pool for new work. */
   activeAccountId: string | null;
   /** The session's PINNED account (null ⇒ following workspace active). */
   pinnedAccountId: string | null;
-  /** The account the next turn will run on: pin > workspace active. */
+  /** Current preference only; automatic allocation can choose another account. */
   effectiveAccountId: string | null;
+  currentSelection: { credentialId: string | null; waiting: boolean } | null;
+  /** The accepted account can differ from the choices for the next turn. */
+  currentAccount: CodexAccount | null;
+  switchAppliedTo: "waiting_turn" | "next_turn" | null;
   /** The account the session's last turn ACTUALLY ran on (the "Running on:" source). */
   lastAccountId: string | null;
   settings: CodexRotationSettings;
   loading: boolean;
+  error: Error | null;
   refresh: () => Promise<void>;
   /**
    * Trigger a LIVE batched /wham/usage refresh across all accounts, then re-read
    * the cached metadata so the new windows land on `accounts`. Modeled on `pin`.
    * No-op (resolves false) when the client can't refresh usage.
+   * With `maxAgeMs`, live readings younger than that are reused instead.
    */
-  refreshUsage: () => Promise<boolean>;
+  refreshUsage: (options?: { maxAgeMs?: number | undefined }) => Promise<boolean>;
+  /** Live provider readings override stale cached labels after refreshUsage. */
+  liveUsage: CodexUsageMap;
+  /** When the live readings in `liveUsage` were taken (epoch ms), or null. */
+  liveUsageUpdatedAt: number | null;
   /** True while a live usage refresh is in flight (drives the bar skeleton). */
   refreshingUsage: boolean;
   /** Pin (or unpin via "auto") the session's account; returns true on success. */
@@ -78,6 +205,8 @@ export type UseCodexAccountsResult = {
   mutationError: Error | null;
 };
 
+const EMPTY_USAGE: CodexUsageMap = {};
+
 const EMPTY_SETTINGS: CodexRotationSettings = {
   rotationEnabled: false,
   rotationStrategy: "sharded",
@@ -85,6 +214,8 @@ const EMPTY_SETTINGS: CodexRotationSettings = {
 };
 
 type CodexAccountsState = {
+  currentAccount: CodexAccount | null;
+  currentSelection: { credentialId: string | null; waiting: boolean } | null;
   accounts: CodexAccount[];
   activeAccountId: string | null;
   settings: CodexRotationSettings;
@@ -93,6 +224,8 @@ type CodexAccountsState = {
 };
 
 const EMPTY_STATE: CodexAccountsState = {
+  currentAccount: null,
+  currentSelection: null,
   accounts: [],
   activeAccountId: null,
   settings: EMPTY_SETTINGS,
@@ -101,10 +234,11 @@ const EMPTY_STATE: CodexAccountsState = {
 };
 
 /**
- * The workspace's Codex accounts + the per-workspace active pointer + (when
- * session-scoped) the session pin and last-ran-on account. Composed like
- * `useMachines`: slow polling (the realtime work is done by the
- * `codex.account.switched` event trigger) + a `pin` mutation.
+ * The workspace's Codex accounts, or session-authorized retry/next-turn choices
+ * and accepted current account. Reads go through the client-scoped shared cache
+ * (`useSharedQuery`): a remount renders the retained rows at once and re-reads
+ * in the background; slow polling plus the `codex.account.switched` event
+ * trigger keep them current, and `pin` invalidates the workspace's entries.
  * Dual-consumer safe via the structural `CodexAccountsClientLike` surface.
  */
 export function useCodexAccounts(options: UseCodexAccountsOptions = {}): UseCodexAccountsResult {
@@ -113,33 +247,52 @@ export function useCodexAccounts(options: UseCodexAccountsOptions = {}): UseCode
   const sessionId = options.sessionId;
   const sharedEvents = options.events;
 
-  const load = useCallback(async (): Promise<CodexAccountsState> => {
-    const accountsP = codexClient.listCodexAccounts(workspaceId);
-    const sessionP =
-      sessionId && codexClient.getSession
-        ? codexClient.getSession(workspaceId, sessionId).catch(() => null)
-        : Promise.resolve(null);
-    const [acc, session] = await Promise.all([accountsP, sessionP]);
-    return {
-      accounts: acc.accounts,
-      activeAccountId: acc.activeAccountId,
-      settings: acc.settings,
-      pinnedAccountId: session?.codexPinnedCredentialId ?? null,
-      lastAccountId: session?.codexLastCredentialId ?? null,
-    };
+  const load = useCallback(async (): Promise<
+    CodexAccountsResponse | SessionCodexAccountsResponse
+  > => {
+    if (sessionId) {
+      if (!codexClient.listSessionCodexAccounts)
+        throw new Error("Session Codex account projection is unavailable");
+      return await codexClient.listSessionCodexAccounts(workspaceId, sessionId);
+    }
+    return await codexClient.listCodexAccounts(workspaceId);
   }, [codexClient, workspaceId, sessionId]);
 
   const {
-    data: loadedData,
+    data: response,
     loading,
+    error,
     refresh,
-  } = usePolledValue(load, {
+  } = useSharedQuery(codexClient, codexAccountsQueryKey(workspaceId, sessionId), load, {
     pollIntervalMs: options.pollIntervalMs,
     enabled: options.enabled,
   });
+  // Never read on mount: only an explicit live refresh writes this entry.
+  const liveUsageQuery = useSharedQueryValue<CodexLiveUsageSnapshot>(
+    codexClient,
+    codexLiveUsageQueryKey(workspaceId),
+  );
+  const loadedData: CodexAccountsState | null = !response
+    ? null
+    : sessionId
+      ? (response as SessionCodexAccountsResponse)
+      : {
+          currentSelection: null,
+          currentAccount: null,
+          accounts: response.accounts,
+          activeAccountId: response.activeAccountId,
+          settings: response.settings,
+          pinnedAccountId: null,
+          lastAccountId: null,
+        };
   const { run: runMutation, mutating: pinning, mutationError } = useMutationRunner();
   const { run: runUsageMutation, mutating: refreshingUsage } = useMutationRunner();
+  const liveUsage = liveUsageQuery.data?.usage ?? EMPTY_USAGE;
   const [pinningTarget, setPinningTarget] = useState<string | null>(null);
+  const [switchReceipt, setSwitchReceipt] = useState<{
+    sessionId: string;
+    appliedTo: "waiting_turn" | "next_turn";
+  } | null>(null);
 
   // Refresh only after the durable post-selection event. `turn.started` is
   // emitted before account selection settles and races this authoritative read.
@@ -161,45 +314,92 @@ export function useCodexAccounts(options: UseCodexAccountsOptions = {}): UseCode
         return false;
       }
       setPinningTarget(target);
+      setSwitchReceipt(null);
+      const invalidated: { current: Promise<void> | null } = { current: null };
       const result = await runMutation(async () => {
-        await codexClient.pinSessionCodexAccount!(workspaceId, sessionId, target);
+        const receipt = await codexClient.pinSessionCodexAccount!(workspaceId, sessionId, target);
+        // Every retained Codex read for this workspace may now be wrong. This
+        // runs even if the component unmounted meanwhile (the runner then
+        // resolves null), so no other surface keeps showing the old choice.
+        invalidated.current = invalidateSharedQueries(
+          codexClient,
+          codexAccountsQueryKey(workspaceId),
+        );
+        setSwitchReceipt({ sessionId, appliedTo: receipt.appliedTo ?? "next_turn" });
         return true;
       });
       setPinningTarget(null);
-      if (result) await refresh();
+      if (result) await invalidated.current;
       return result === true;
     },
-    [codexClient, workspaceId, sessionId, runMutation, refresh],
+    [codexClient, workspaceId, sessionId, runMutation],
   );
 
   // Live usage refresh: hit the batched provider read, then re-read cached
   // metadata so the fresh windows land on `accounts`. The provider read writes the
-  // cache columns server-side; state.refresh() pulls them back.
-  const refreshUsage = useCallback(async (): Promise<boolean> => {
-    if (!codexClient.refreshCodexUsage) {
-      return false;
-    }
-    const result = await runUsageMutation(async () => {
-      await codexClient.refreshCodexUsage!(workspaceId);
-      return true;
-    });
-    if (result) await refresh();
-    return result === true;
-  }, [codexClient, workspaceId, runUsageMutation, refresh]);
-
-  const data = loadedData ?? EMPTY_STATE;
+  // cache columns server-side; refresh() pulls them back. Concurrent callers share
+  // one provider read, and `maxAgeMs` reuses readings that are recent enough for
+  // every listed account (a single-account refresh elsewhere never counts for all).
+  const listedAccountIds = response?.accounts.map((account) => account.id).join("\n") ?? null;
+  const refreshUsage = useCallback(
+    async (refreshOptions: { maxAgeMs?: number | undefined } = {}): Promise<boolean> => {
+      if (!codexClient.refreshCodexUsage) {
+        return false;
+      }
+      const maxAgeMs = refreshOptions.maxAgeMs;
+      const retained = peekSharedQuery<CodexLiveUsageSnapshot>(
+        codexClient,
+        codexLiveUsageQueryKey(workspaceId),
+      )?.data;
+      const ids = listedAccountIds ? listedAccountIds.split("\n") : [];
+      if (
+        maxAgeMs !== undefined &&
+        retained &&
+        ids.length > 0 &&
+        ids.every((id) => {
+          const readAt = retained.readAt[id];
+          return readAt !== undefined && Date.now() - readAt < maxAgeMs;
+        })
+      ) {
+        return true;
+      }
+      const result = await runUsageMutation(async () => {
+        await sharedLiveUsageRead(codexClient, workspaceId, () =>
+          codexClient.refreshCodexUsage!(workspaceId),
+        );
+        return true;
+      });
+      if (result) await refresh();
+      return result === true;
+    },
+    [codexClient, workspaceId, runUsageMutation, refresh, listedAccountIds],
+  );
+
+  // Reauthorization failure must remove a previously visible session pool.
+  const data = (sessionId && error ? null : loadedData) ?? EMPTY_STATE;
   const effectiveAccountId = data.pinnedAccountId ?? data.activeAccountId;
+  const withLiveUsage = (account: CodexAccount): CodexAccount => {
+    const live = liveUsage[account.id]?.usage;
+    return live ? { ...account, fiveHour: live.fiveHour, weekly: live.weekly } : account;
+  };
 
   return {
-    accounts: data.accounts,
+    currentAccount: data.currentAccount ? withLiveUsage(data.currentAccount) : null,
+    currentSelection: data.currentSelection,
+    switchAppliedTo:
+      switchReceipt?.sessionId === sessionId ? (switchReceipt?.appliedTo ?? null) : null,
+    accounts: data.accounts.map(withLiveUsage),
     activeAccountId: data.activeAccountId,
     pinnedAccountId: data.pinnedAccountId,
     effectiveAccountId,
     lastAccountId: data.lastAccountId,
     settings: data.settings,
     loading,
+    error,
     refresh,
     refreshUsage,
+    liveUsage,
+    liveUsageUpdatedAt: oldestReading(liveUsageQuery.data),
     refreshingUsage,
     pin,
     pinning,