@opengeni/react 3.1.0 → 3.1.2

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

@@ -69,24 +69,28 @@ export function useSessionLineage(
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
   const nextReadGeneration = useRef(0);
   const beginRead = options.beginRead;
-  const load = useCallback(async () => {
-    if (!sessionId) {
+  const load = useCallback(
+    async (signal?: AbortSignal) => {
+      if (!sessionId) {
+        return {
+          lineage: { ancestors: [], children: [], truncated: false },
+          readGeneration: 0,
+        };
+      }
+      let readGeneration = 0;
+      const lineage = await client.getSessionLineage(workspaceId, sessionId, {
+        signal,
+        onRequestStart: (sharedReadGeneration) => {
+          readGeneration = sharedReadGeneration ?? beginRead?.() ?? ++nextReadGeneration.current;
+        },
+      });
       return {
-        lineage: { ancestors: [], children: [], truncated: false },
-        readGeneration: 0,
+        lineage,
+        readGeneration,
       };
-    }
-    let readGeneration = 0;
-    const lineage = await client.getSessionLineage(workspaceId, sessionId, {
-      onRequestStart: (sharedReadGeneration) => {
-        readGeneration = sharedReadGeneration ?? beginRead?.() ?? ++nextReadGeneration.current;
-      },
-    });
-    return {
-      lineage,
-      readGeneration,
-    };
-  }, [beginRead, client, workspaceId, sessionId]);
+    },
+    [beginRead, client, workspaceId, sessionId],
+  );
   const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled });
   const refresh = state.refresh;
   useEffect(() => {

package/src/hooks/use-session-mcp-approval-policy.ts

@@ -1,7 +1,7 @@
 import type {
   SessionEvent,
   SessionMcpApprovalPolicy,
-  SessionMcpServerMetadata,
+  SessionMcpApprovalPolicyTarget,
   UpdateSessionMcpApprovalPolicyResponse,
 } from "@opengeni/sdk";
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
@@ -38,7 +38,7 @@ export type UseSessionMcpApprovalPolicyOptions = EmbeddedSessionMcpApprovalPolic
   };
 
 export type UseSessionMcpApprovalPolicyResult = {
-  server: SessionMcpServerMetadata | null;
+  server: SessionMcpApprovalPolicyTarget | null;
   policy: SessionMcpApprovalPolicy | null;
   loading: boolean;
   error: Error | null;
@@ -61,7 +61,7 @@ export function useSessionMcpApprovalPolicy(
 ): UseSessionMcpApprovalPolicyResult {
   const { client, workspaceId } = useEmbeddedSessionMcpApprovalPolicy(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId && serverId);
-  const [override, setOverride] = useState<SessionMcpServerMetadata | null>(null);
+  const [override, setOverride] = useState<SessionMcpApprovalPolicyTarget | null>(null);
   const targetKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${serverId ?? ""}`;
   const authoritativeGeneration = useRef(0);
   const mutationIdentity = useMemo(() => ({ client, targetKey }), [client, targetKey]);
@@ -75,7 +75,7 @@ export function useSessionMcpApprovalPolicy(
   type PolicyRead = {
     targetKey: string;
     generation: number;
-    server: SessionMcpServerMetadata | null;
+    server: SessionMcpApprovalPolicyTarget | null;
   };
   const load = useCallback(async (): Promise<PolicyRead> => {
     const generation = authoritativeGeneration.current;
@@ -86,7 +86,15 @@ export function useSessionMcpApprovalPolicy(
     return {
       targetKey,
       generation,
-      server: session.mcpServers.find((server) => server.id === serverId) ?? null,
+      server:
+        session.mcpServers.find((server) => server.id === serverId) ??
+        (session.mcpApprovalPolicies && Object.hasOwn(session.mcpApprovalPolicies, serverId)
+          ? {
+              id: serverId,
+              source: "workspace",
+              requireApproval: session.mcpApprovalPolicies[serverId]!,
+            }
+          : null),
     };
   }, [client, serverId, sessionId, targetKey, workspaceId]);
   const {

package/src/hooks/use-session-model-account.ts

@@ -0,0 +1,174 @@
+import { useCallback, useState } from "react";
+import type {
+  ModelAccountPreferences,
+  SessionEvent,
+  SessionModelAccountChoiceResponse,
+  SetSessionModelAccountChoiceRequest,
+  SetSessionModelAccountChoiceResponse,
+  UpdateModelAccountPreferencesRequest,
+} from "@opengeni/sdk";
+import { useOpenGeni, type ClientOverride } from "../provider";
+import {
+  useMutationRunner,
+  usePolledValue,
+  useSessionEventTrigger,
+  type SessionEventFeedOptions,
+} from "./internal";
+
+/** Events after which the session's model account may have changed. */
+export function isModelAccountEvent(event: Pick<SessionEvent, "type">): boolean {
+  return [
+    "model_account.selection.changed",
+    "codex.account.selection.changed",
+    "subscription.account.selected",
+    "subscription.account.switched",
+    "turn.completed",
+    "turn.failed",
+    "turn.cancelled",
+    "turn.requires_action",
+    "session.status.changed",
+  ].includes(event.type);
+}
+
+/**
+ * The structural slice of the SDK client the model-account picker needs.
+ * Method names and signatures match `OpenGeniClient`, so the real client
+ * satisfies it directly and a test client can stand in.
+ */
+export type ModelAccountClientLike = {
+  getSessionModelAccount: (
+    workspaceId: string,
+    sessionId: string,
+  ) => Promise<SessionModelAccountChoiceResponse>;
+  setSessionModelAccount?: (
+    workspaceId: string,
+    sessionId: string,
+    request: SetSessionModelAccountChoiceRequest,
+  ) => Promise<SetSessionModelAccountChoiceResponse>;
+  updateModelAccountPreferences?: (
+    organizationId: string,
+    request: UpdateModelAccountPreferencesRequest,
+  ) => Promise<ModelAccountPreferences>;
+};
+
+export type UseSessionModelAccountOptions = ClientOverride &
+  SessionEventFeedOptions & {
+    sessionId: string;
+    /** Scope choices, including Automatic, to this provider. Omit for a whole-session reset. */
+    provider?: string | null | undefined;
+    /** The session's organization; needed to change the personal-fallback opt-in. */
+    organizationId?: string | null | undefined;
+    pollIntervalMs?: number | undefined;
+    modelAccountClient?: ModelAccountClientLike | undefined;
+  };
+
+export type UseSessionModelAccountResult = {
+  choice: SessionModelAccountChoiceResponse | null;
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+  /** Choose an account, or `null` for automatic selection; true on success. */
+  choose: (connectionId: string | null) => Promise<boolean>;
+  choosing: boolean;
+  /** The in-flight target (`null` is automatic; `undefined` when idle). */
+  choosingTarget: string | null | undefined;
+  appliedTo: "waiting_turn" | "next_turn" | null;
+  /** Turn the caller's own personal-fallback opt-in on or off; true on success. */
+  setFallbackOptIn: (optIn: boolean) => Promise<boolean>;
+  canChangeFallback: boolean;
+  mutationError: Error | null;
+};
+
+/**
+ * The session's model account across every provider on the shared
+ * subscription core: the accounts it may use (the workspace's shared accounts
+ * and the caller's own personal accounts), the explicit choice, and the
+ * caller's personal-fallback opt-in. The server decides what may be chosen;
+ * this hook only reflects and requests.
+ */
+export function useSessionModelAccount(
+  options: UseSessionModelAccountOptions,
+): UseSessionModelAccountResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const accountClient = options.modelAccountClient ?? (client as unknown as ModelAccountClientLike);
+  const { sessionId, organizationId, provider } = options;
+  const sharedEvents = options.events;
+
+  const load = useCallback(
+    async () => await accountClient.getSessionModelAccount(workspaceId, sessionId),
+    [accountClient, workspaceId, sessionId],
+  );
+  const { data, loading, error, refresh } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled,
+  });
+  const { run, mutating, mutationError } = useMutationRunner(sessionId);
+  const [choosingTarget, setChoosingTarget] = useState<string | null | undefined>(undefined);
+  const [receipt, setReceipt] = useState<{
+    sessionId: string;
+    appliedTo: "waiting_turn" | "next_turn";
+  } | null>(null);
+
+  useSessionEventTrigger(
+    client,
+    workspaceId,
+    sessionId,
+    isModelAccountEvent,
+    () => void refresh(),
+    {
+      enabled: options.enabled ?? true,
+      ...(sharedEvents !== undefined ? { events: sharedEvents } : {}),
+    },
+  );
+
+  const choose = useCallback(
+    async (connectionId: string | null): Promise<boolean> => {
+      if (!accountClient.setSessionModelAccount) return false;
+      setChoosingTarget(connectionId);
+      setReceipt(null);
+      const result = await run(async () => {
+        const response = await accountClient.setSessionModelAccount!(workspaceId, sessionId, {
+          connectionId,
+          ...(provider != null ? { provider } : {}),
+        });
+        setReceipt({ sessionId, appliedTo: response.appliedTo });
+        return true;
+      });
+      setChoosingTarget(undefined);
+      if (result) await refresh();
+      return result === true;
+    },
+    [accountClient, workspaceId, sessionId, provider, run, refresh],
+  );
+
+  const canChangeFallback = Boolean(organizationId && accountClient.updateModelAccountPreferences);
+  const setFallbackOptIn = useCallback(
+    async (optIn: boolean): Promise<boolean> => {
+      if (!organizationId || !accountClient.updateModelAccountPreferences) return false;
+      const result = await run(async () => {
+        await accountClient.updateModelAccountPreferences!(organizationId, {
+          personalFallbackOptIn: optIn,
+        });
+        return true;
+      });
+      if (result) await refresh();
+      return result === true;
+    },
+    [accountClient, organizationId, run, refresh],
+  );
+
+  return {
+    // A failed reauthorization must not keep showing a previous session's accounts.
+    choice: error ? null : data,
+    loading,
+    error,
+    refresh,
+    choose,
+    choosing: mutating,
+    choosingTarget,
+    appliedTo: receipt?.sessionId === sessionId ? receipt.appliedTo : null,
+    setFallbackOptIn,
+    canChangeFallback,
+    mutationError,
+  };
+}

package/src/hooks/use-session.ts

@@ -38,6 +38,16 @@ export function isTitleEvent(event: Pick<SessionEvent, "type">): boolean {
   return event.type === "session.title_set";
 }
 
+function isSessionDetailEvent(event: Pick<SessionEvent, "type">): boolean {
+  return (
+    isTitleEvent(event) ||
+    event.type.startsWith("session.command.") ||
+    event.type.startsWith("session.wait.") ||
+    event.type === "session.status.changed" ||
+    event.type === "system.update.pending"
+  );
+}
+
 /** Fetch one session (with optional polling), live-patching its title on `session.title_set`. */
 export function useSession(
   sessionId: string | null | undefined,
@@ -51,25 +61,29 @@ export function useSession(
   const nextReadGeneration = useRef(0);
   const beginRead = options.beginRead;
   const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
-  const load = useCallback(async () => {
-    if (!sessionId) {
-      return null;
-    }
-    let readGeneration = 0;
-    const fetched = await client.getSession(workspaceId, sessionId, {
-      fresh: true,
-      onRequestStart: () => {
-        readGeneration = beginRead?.() ?? ++nextReadGeneration.current;
-      },
-    });
-    // A fresh server read supersedes any optimistic/event-driven override.
-    setOverride(null);
-    return {
-      session: fetched,
-      revision: ++nextReadRevision.current,
-      readGeneration,
-    };
-  }, [beginRead, client, workspaceId, sessionId]);
+  const load = useCallback(
+    async (signal?: AbortSignal) => {
+      if (!sessionId) {
+        return null;
+      }
+      let readGeneration = 0;
+      const fetched = await client.getSession(workspaceId, sessionId, {
+        fresh: true,
+        signal,
+        onRequestStart: () => {
+          readGeneration = beginRead?.() ?? ++nextReadGeneration.current;
+        },
+      });
+      // A fresh server read supersedes any optimistic/event-driven override.
+      setOverride(null);
+      return {
+        session: fetched,
+        revision: ++nextReadRevision.current,
+        readGeneration,
+      };
+    },
+    [beginRead, client, workspaceId, sessionId],
+  );
   const { data, loading, error, refresh } = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,
     enabled,
@@ -95,10 +109,28 @@ export function useSession(
     [base, override],
   );
 
+  const sharedEvents = options.events;
+
   // Live-patch the title on auto (agent) + cross-client (user/agent) renames so
   // the UI reflects the new title without polling or a full re-fetch.
   const onTitleEvent = useCallback(
     (event: SessionEvent) => {
+      // Reconciliation emits only the last matching member of a shared batch.
+      // A later title must not hide an earlier command activity change.
+      if (
+        sharedEvents?.some(
+          (item) =>
+            item.sessionId === sessionId &&
+            !isTitleEvent(item) &&
+            isSessionDetailEvent(item) &&
+            item.sequence > (base?.lastSequence ?? -1),
+        )
+      ) {
+        void refresh();
+      } else if (!isTitleEvent(event)) {
+        if (!base || event.sequence > base.lastSequence) void refresh();
+        return;
+      }
       // The fetched session row is the authoritative title projection through
       // lastSequence. Shared feeds may replay that historical tail after the
       // fetch; applying it would undo a row-only migration quarantine. Only an
@@ -118,9 +150,9 @@ export function useSession(
         return { ...next, title, titleSource: source };
       });
     },
-    [base],
+    [base, refresh, sharedEvents, sessionId],
   );
-  useSessionEventTrigger(client, workspaceId, sessionId, isTitleEvent, onTitleEvent, {
+  useSessionEventTrigger(client, workspaceId, sessionId, isSessionDetailEvent, onTitleEvent, {
     enabled,
     ...(options.events !== undefined ? { events: options.events } : {}),
   });

package/src/hooks/use-slash-commands.ts

@@ -1,5 +1,6 @@
 import type { KeyboardEvent } from "react";
 import { useCallback, useMemo, useRef, useState } from "react";
+import { useErrorMessage } from "../lib/error-message";
 import {
   argHint,
   filterCommands,
@@ -81,6 +82,7 @@ export type UseSlashCommandsResult = {
 };
 
 export function useSlashCommands(options: UseSlashCommandsOptions): UseSlashCommandsResult {
+  const formatError = useErrorMessage();
   const { commands, context, handlers, value, setValue } = options;
   const [highlight, setHighlight] = useState(0);
   // Escape closes the palette but keeps the draft. We remember the dismissed
@@ -153,9 +155,9 @@ export function useSlashCommands(options: UseSlashCommandsOptions): UseSlashComm
       if (!context) {
         return null;
       }
-      return { ...context, ...handlers, confirm: () => handlers.confirm(command) };
+      return { ...context, ...handlers, formatError, confirm: () => handlers.confirm(command) };
     },
-    [context, handlers],
+    [context, handlers, formatError],
   );
 
   const execute = useCallback(
@@ -173,10 +175,10 @@ export function useSlashCommands(options: UseSlashCommandsOptions): UseSlashComm
           setValue("");
         }
       } catch (cause) {
-        ctx.notice({ tone: "error", message: errorMessage(cause) });
+        ctx.notice({ tone: "error", message: formatError(cause) });
       }
     },
-    [buildContext, setValue],
+    [buildContext, setValue, formatError],
   );
 
   const autocomplete = useCallback(
@@ -359,10 +361,3 @@ export function useSlashCommands(options: UseSlashCommandsOptions): UseSlashComm
     autocompleteHighlighted,
   };
 }
-
-function errorMessage(cause: unknown): string {
-  if (cause instanceof Error) {
-    return cause.message;
-  }
-  return String(cause);
-}

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

@@ -2,7 +2,12 @@ import type { SuperGrokAccount, SuperGrokAccountsResponse } from "@opengeni/sdk"
 import { useCallback } from "react";
 
 import { useOpenGeni, type ClientOverride } from "../provider";
-import { useMutationRunner, usePolledValue } from "./internal";
+import { useMutationRunner } from "./internal";
+import { invalidateSharedQueries, useSharedQuery, type SharedQueryKey } from "./shared-query";
+
+/** Shared-cache key for a workspace's SuperGrok accounts (internal; see `useSharedQuery`). */
+export const superGrokAccountsQueryKey = (workspaceId: string) =>
+  ["supergrok-accounts", workspaceId] as SharedQueryKey;
 
 export type SuperGrokAccountsClientLike = {
   listSuperGrokAccounts: (workspaceId: string) => Promise<SuperGrokAccountsResponse>;
@@ -39,7 +44,10 @@ const EMPTY: SuperGrokAccountsResponse = {
   },
 };
 
-/** Workspace-visible xAI accounts. Workspace scope is the connection default. */
+/**
+ * Workspace-visible xAI accounts. Workspace scope is the connection default.
+ * Reads share the client-scoped cache, so a remount renders retained rows at once.
+ */
 export function useSuperGrokAccounts(
   options: UseSuperGrokAccountsOptions = {},
 ): UseSuperGrokAccountsResult {
@@ -50,22 +58,28 @@ export function useSuperGrokAccounts(
     async () => await supergrokClient.listSuperGrokAccounts(workspaceId),
     [supergrokClient, workspaceId],
   );
-  const { data, loading, refresh } = usePolledValue(load, {
-    enabled: options.enabled,
-    pollIntervalMs: options.pollIntervalMs,
-  });
+  const { data, loading, refresh } = useSharedQuery(
+    supergrokClient,
+    superGrokAccountsQueryKey(workspaceId),
+    load,
+    { enabled: options.enabled, pollIntervalMs: options.pollIntervalMs },
+  );
   const { run, mutating: activating, mutationError } = useMutationRunner();
   const activate = useCallback(
     async (accountId: string): Promise<boolean> => {
       if (!supergrokClient.activateSuperGrokAccount) return false;
+      const invalidated: { current: Promise<void> | null } = { current: null };
       const result = await run(async () => {
         await supergrokClient.activateSuperGrokAccount!(workspaceId, accountId);
+        // Invalidate even if this component unmounted meanwhile (the runner
+        // then resolves null): other surfaces must not keep the old primary.
+        invalidated.current = invalidateSharedQueries(supergrokClient, ["supergrok-accounts"]);
         return true;
       });
-      if (result) await refresh();
+      if (result) await invalidated.current;
       return result === true;
     },
-    [refresh, run, supergrokClient, workspaceId],
+    [run, supergrokClient, workspaceId],
   );
   const state = data ?? EMPTY;
   return {