@opengeni/react 3.1.0 → 3.1.2

package/src/hooks/use-connect.ts

@@ -0,0 +1,23 @@
+import type { ConnectController } from "@opengeni/connect";
+import { useMemo, useSyncExternalStore } from "react";
+
+/** Internal consumers import the hook directly so setup surfaces stay lazy. */
+export function useConnect(controller: ConnectController) {
+  const snapshot = useSyncExternalStore(
+    controller.subscribe,
+    controller.getSnapshot,
+    controller.getSnapshot,
+  );
+  const actions = useMemo(
+    () => ({
+      begin: controller.begin.bind(controller),
+      recover: controller.recover.bind(controller),
+      refresh: controller.refresh.bind(controller),
+      waitForAction: controller.waitForAction.bind(controller),
+      advance: controller.advance.bind(controller),
+      cancel: controller.cancel.bind(controller),
+    }),
+    [controller],
+  );
+  return useMemo(() => ({ ...snapshot, ...actions }), [snapshot, actions]);
+}

package/src/hooks/use-desktop-stream.ts

@@ -6,7 +6,15 @@ import {
   type DesktopRfbLike,
   type DesktopStreamCapability,
 } from "@opengeni/sdk";
-import { type RefObject, useCallback, useEffect, useRef, useState } from "react";
+import {
+  type RefObject,
+  useCallback,
+  useEffect,
+  useRef,
+  useState,
+  useSyncExternalStore,
+} from "react";
+import { desktopViewerPeers } from "../lib/workbench-peers";
 import { type DesktopWebSocketFactory, useRelayFrameStream } from "./use-relay-frame-stream";
 
 export type UseDesktopStreamOptions = {
@@ -17,7 +25,7 @@ export type UseDesktopStreamOptions = {
   /** Read-only by default (v1 ruling H). interactive only when cap.mode allows. */
   interactive?: boolean | undefined;
   scaleViewport?: boolean | undefined;
-  /** Custom RFB factory (tests / a WebRTC swap). Defaults to a lazy @novnc/novnc. */
+  /** Custom RFB factory. Otherwise call enableDesktopViewer() on the desktop subpath. */
   rfbFactory?: DesktopRfbFactory | undefined;
   /** Additional WebSocket protocols for an authenticated placement proxy. */
   webSocketProtocols?: string[] | undefined;
@@ -35,29 +43,6 @@ export type UseDesktopStreamResult = {
   sendKey?: ((keysym: number, code: string, down?: boolean) => boolean) | undefined;
 };
 
-/** Lazy-load @novnc/novnc's RFB as the default factory. Imported inside the
- *  connect effect so SSR / non-desktop bundles never pull the DOM-only lib.
- *  @novnc/novnc ships no types and a single `export default class RFB`. The
- *  specifier is STATIC (`import("@novnc/novnc")`) so Vite can pre-bundle and
- *  resolve it — a runtime-string indirection with `@vite-ignore` (the previous
- *  approach) hands the browser a bare specifier and throws
- *  "Failed to resolve module specifier '@novnc/novnc'". The dynamic form keeps
- *  it out of the SSR / non-desktop critical path while staying resolvable. */
-async function defaultRfbFactory(): Promise<DesktopRfbFactory> {
-  const mod = (await import("@novnc/novnc")) as unknown as {
-    default: new (
-      t: HTMLElement,
-      u: string,
-      o: {
-        credentials?: { password?: string | undefined } | undefined;
-        wsProtocols?: string[] | undefined;
-      },
-    ) => DesktopRfbLike;
-  };
-  const RFB = mod.default;
-  return (target, url, opts) => new RFB(target, url, opts);
-}
-
 /**
  * Drive the noVNC RFB lifecycle from a `DesktopStreamCapability`, using the
  * SDK's `desktop.ts` reducer + `desktopSocketUrl`. SSR-safe: the RFB import and
@@ -87,6 +72,12 @@ export function useDesktopStream(options: UseDesktopStreamOptions): UseDesktopSt
     webSocketProtocols,
     webSocketFactory,
   } = options;
+  const peerRevision = useSyncExternalStore(
+    desktopViewerPeers.subscribe,
+    desktopViewerPeers.revision,
+    desktopViewerPeers.revision,
+  );
+  const factoryRevision = rfbFactory ? 0 : peerRevision;
 
   // The self-hosted PNG-frame path. Always invoked (rules of hooks); dormant
   // unless `transport === "relay-frames"`, in which case it owns the surface.
@@ -188,7 +179,7 @@ export function useDesktopStream(options: UseDesktopStreamOptions): UseDesktopSt
 
     void (async () => {
       try {
-        const factory = rfbFactoryRef.current ?? (await defaultRfbFactory());
+        const factory = rfbFactoryRef.current ?? (await desktopViewerPeers.load());
         if (disposed) return;
         const socketUrl = desktopSocketUrl({ url });
         setBoth(nextDesktopState(stateRef.current, { type: "negotiated" }));
@@ -232,11 +223,11 @@ export function useDesktopStream(options: UseDesktopStreamOptions): UseDesktopSt
     };
     // ONLY a real transport change reconnects: a fresh url (rotation), a new
     // credential (RFB password OR bearer subprotocol), the transport flipping,
-    // or an explicit manual reconnect
+    // a newly registered default peer loader, or an explicit manual reconnect
     // (`nonce`). `interactive`/`scaleViewport`/`mode`/`rfbFactory` are read via
     // refs and applied live below — they must never re-open the socket.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [url, token, transport, webSocketProtocolsKey, nonce]);
+  }, [url, token, transport, webSocketProtocolsKey, nonce, factoryRevision]);
 
   // Apply take-control / return-control to the OPEN connection in place. noVNC
   // honours `viewOnly` live, so flipping it neither blinks the surface nor drops

package/src/hooks/use-file-attachments.ts

@@ -4,6 +4,7 @@ import {
   useEmbeddedFileAttachments,
   type EmbeddedFileAttachmentClientOverride,
 } from "../session-context";
+import { useErrorMessage } from "../lib/error-message";
 
 export type UseFileAttachmentsOptions = EmbeddedFileAttachmentClientOverride & {
   /**
@@ -13,6 +14,8 @@ export type UseFileAttachmentsOptions = EmbeddedFileAttachmentClientOverride & {
    * UseFileAttachmentsResult.addFiles} (the explicit picker / drop path)
    * bypasses it.
    */
+  /** Retain original uploads in the chat owner’s personal scope when private. */
+  scope?: "workspace" | "personal";
   pasteFilter?: ((file: File) => boolean) | undefined;
 };
 
@@ -26,7 +29,11 @@ export type FileAttachment = {
   file?: FileAsset | undefined;
   /** Object-URL for an inline preview; minted for `image/*` files only. */
   previewUrl?: string | undefined;
+  /** Stable SDK failure code for UI behavior that must not parse error copy. */
+  errorCode?: "secure_context_required" | undefined;
   error?: string | undefined;
+  /** Original diagnostic failure; presentation copy is kept separately in `error`. */
+  errorCause?: unknown;
 };
 
 export type UseFileAttachmentsResult = {
@@ -50,6 +57,12 @@ export type UseFileAttachmentsResult = {
   addFromPaste: (event: { clipboardData: DataTransfer | null }) => void;
   /** Restore already-ready server assets without recreating browser-local bytes. */
   restoreReadyFiles: (files: Iterable<FileAsset>) => void;
+  /**
+   * Resolve a ready image's short-lived server preview URL on demand. Optional
+   * for upload-only embedded clients; local object-URL previews remain usable
+   * without it.
+   */
+  loadPreview?: ((id: string, signal?: AbortSignal) => Promise<string | undefined>) | undefined;
   /**
    * Re-run the upload for a `failed` attachment, in place (same id, same
    * source file). No-op for an id that isn't a known failed upload.
@@ -76,6 +89,27 @@ export type UseFileAttachmentsResult = {
 
 const isImage = (file: File): boolean => file.type.startsWith("image/");
 
+let fallbackAttachmentId = 0;
+
+function createAttachmentId(): string {
+  const cryptoSource = globalThis.crypto;
+  if (typeof cryptoSource?.randomUUID === "function") return cryptoSource.randomUUID();
+  fallbackAttachmentId += 1;
+  // This id is only a browser-local React key and retry lookup, never durable
+  // authority. Keep attachment tracking usable when HTTP withholds randomUUID
+  // or Web Crypto is unavailable so the SDK's typed failure reaches the card.
+  return `attachment:${Date.now().toString(36)}:${fallbackAttachmentId.toString(36)}`;
+}
+
+function secureContextRequiredErrorCode(error: unknown): "secure_context_required" | undefined {
+  return typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    error.code === "secure_context_required"
+    ? error.code
+    : undefined;
+}
+
 /**
  * Upload-and-track state for files attached to the next message. Owns the
  * full client-side upload layer: a per-file `uploading | ready | failed`
@@ -89,8 +123,11 @@ export function useFileAttachments(
   options: UseFileAttachmentsOptions = {},
 ): UseFileAttachmentsResult {
   const { client, workspaceId } = useEmbeddedFileAttachments(options);
+  const formatError = useErrorMessage();
   const pasteFilter = options.pasteFilter ?? isImage;
   const [attachments, setAttachments] = useState<FileAttachment[]>([]);
+  const attachmentsRef = useRef(attachments);
+  attachmentsRef.current = attachments;
   // Keep the source File per attachment id so a failed upload can be retried
   // in place. Cleared on remove/clear so it never outlives its attachment.
   const sources = useRef<Map<string, File>>(new Map());
@@ -181,6 +218,7 @@ export function useFileAttachments(
           filename: file.name || "file",
           contentType: file.type || "application/octet-stream",
           data: file,
+          ...(options.scope ? { scope: options.scope } : {}),
         })
         .then((asset) => {
           if (scopeGeneration.current !== generation) return;
@@ -198,7 +236,9 @@ export function useFileAttachments(
                     name: asset.filename,
                     contentType: asset.contentType,
                     sizeBytes: asset.sizeBytes,
+                    errorCode: undefined,
                     error: undefined,
+                    errorCause: undefined,
                   }
                 : attachment,
             ),
@@ -212,20 +252,22 @@ export function useFileAttachments(
                 ? {
                     ...attachment,
                     status: "failed",
-                    error: error instanceof Error ? error.message : String(error),
+                    errorCode: secureContextRequiredErrorCode(error),
+                    error: formatError(error),
+                    errorCause: error,
                   }
                 : attachment,
             ),
           );
         });
     },
-    [client, workspaceId],
+    [client, workspaceId, options.scope, formatError],
   );
 
   const addFiles = useCallback(
     (files: Iterable<File>) => {
       for (const file of files) {
-        const id = crypto.randomUUID();
+        const id = createAttachmentId();
         sources.current.set(id, file);
         const previewUrl = isImage(file) ? URL.createObjectURL(file) : undefined;
         if (previewUrl) previewUrls.current.set(id, previewUrl);
@@ -255,7 +297,13 @@ export function useFileAttachments(
       setAttachments((current) =>
         current.map((attachment) =>
           attachment.id === id
-            ? { ...attachment, status: "uploading", error: undefined }
+            ? {
+                ...attachment,
+                status: "uploading",
+                errorCode: undefined,
+                error: undefined,
+                errorCause: undefined,
+              }
             : attachment,
         ),
       );
@@ -305,7 +353,9 @@ export function useFileAttachments(
                 sizeBytes: file.sizeBytes,
                 status: "ready",
                 file,
+                errorCode: undefined,
                 error: undefined,
+                errorCause: undefined,
               }
             : {
                 id: `restored:${file.id}`,
@@ -327,6 +377,31 @@ export function useFileAttachments(
     [workspaceId],
   );
 
+  const loadPreview = useCallback(
+    async (id: string, signal?: AbortSignal): Promise<string | undefined> => {
+      const generation = scopeGeneration.current;
+      const attachment = attachmentsRef.current.find((candidate) => candidate.id === id);
+      const createDownloadUrl = client.createFileDownloadUrl;
+      if (
+        !attachment ||
+        attachment.status !== "ready" ||
+        !attachment.file ||
+        !attachment.contentType.startsWith("image/") ||
+        typeof createDownloadUrl !== "function" ||
+        signal?.aborted
+      ) {
+        return undefined;
+      }
+      const fileId = attachment.file.id;
+      const signed = await createDownloadUrl.call(client, workspaceId, fileId, { signal });
+      if (scopeGeneration.current !== generation || signal?.aborted) return undefined;
+      const current = attachmentsRef.current.find((candidate) => candidate.id === id);
+      if (current?.status !== "ready" || current.file?.id !== fileId) return undefined;
+      return signed.url;
+    },
+    [client, workspaceId],
+  );
+
   const remove = useCallback(
     (id: string) => {
       sources.current.delete(id);
@@ -368,6 +443,7 @@ export function useFileAttachments(
     addFiles,
     addFromPaste,
     restoreReadyFiles,
+    ...(typeof client.createFileDownloadUrl === "function" ? { loadPreview } : {}),
     retry,
     retainPreview,
     remove,

package/src/hooks/use-goal.ts

@@ -1,6 +1,7 @@
 import { OpenGeniApiError, type SessionEvent, type SessionGoal } from "@opengeni/sdk";
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
 import { useEmbeddedGoal, type EmbeddedGoalClientOverride } from "../session-context";
+import { normalizeError } from "../lib/error-message";
 import {
   useDebouncedCallback,
   useMutationRunner,
@@ -64,7 +65,8 @@ export type UseGoalResult = {
 /**
  * The session's goal: state, the autonomy counters (`autoContinuations`,
  * `noProgressStreak`), and pause/resume control. A goal-less session yields
- * `goal: null` (the 404 is absorbed). Live-updates on goal, turn, session,
+ * `goal: null`: read through `findGoal` as a successful null when the client
+ * has it, otherwise from an absorbed 404. Live-updates on goal, turn, session,
  * control, and system-update events — pass `options.events` from
  * `useSessionEvents` to reuse its stream.
  */
@@ -83,15 +85,45 @@ export function useGoal(
   const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
   const generation = useRef(0);
   const targetKeyRef = useRef<string | null>(null);
+  // True after the server answered that no goal exists. Only a goal event can
+  // create a goal, so turn/session traffic must not refetch while none exists.
+  const goalAbsentRef = useRef(false);
+  // Refresh events not yet covered by a read: "goal" when any was a goal.*
+  // event. Events that arrive while a read is in flight are decided when it
+  // settles, so the stream's opening burst never re-reads a goal-less session.
+  const pendingRefreshRef = useRef<"none" | "refresh" | "goal">("none");
+  const sharedEventsRef = useRef(sharedEvents);
+  useLayoutEffect(() => {
+    sharedEventsRef.current = sharedEvents;
+  }, [sharedEvents]);
+  const loadAbort = useRef<AbortController | null>(null);
+  const scheduleRefreshRef = useRef<() => void>(() => undefined);
+
+  const retireLoads = useCallback(() => {
+    generation.current += 1;
+    loadAbort.current?.abort();
+    loadAbort.current = null;
+  }, []);
 
   const load = useCallback(async (): Promise<void> => {
     if (!sessionId) {
       return;
     }
     const ticket = ++generation.current;
+    pendingRefreshRef.current = "none";
+    loadAbort.current?.abort();
+    const controller = new AbortController();
+    loadAbort.current = controller;
     try {
-      const fetched = await client.getGoal(workspaceId, sessionId);
+      // findGoal reads a goal-less session as a successful null, so no failed
+      // request reaches the browser console. Custom clients without it keep
+      // getGoal, whose 404 is absorbed below (as it is from older servers).
+      const fetched =
+        typeof client.findGoal === "function"
+          ? await client.findGoal(workspaceId, sessionId, { signal: controller.signal })
+          : await client.getGoal(workspaceId, sessionId, { signal: controller.signal });
       if (ticket === generation.current) {
+        goalAbsentRef.current = fetched === null;
         setGoal(fetched);
         setError(null);
         setLoading(false);
@@ -102,30 +134,58 @@ 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 {
-        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        setError(normalizeError(cause));
       }
       setLoading(false);
+    } finally {
+      if (loadAbort.current === controller) loadAbort.current = null;
+    }
+    if (ticket !== generation.current || pendingRefreshRef.current === "none") {
+      return;
     }
+    // Events arrived during this read. A shared feed's first batch reports only
+    // its latest match, so a goal.* event behind newer turn traffic is visible
+    // only in the log: re-read when its latest goal event is not a clear.
+    if (goalAbsentRef.current && pendingRefreshRef.current === "refresh") {
+      const events = sharedEventsRef.current ?? [];
+      let latestGoalEvent: SessionEvent | undefined;
+      for (let index = events.length - 1; index >= 0 && !latestGoalEvent; index -= 1) {
+        const event = events[index];
+        if (event && isGoalEvent(event)) latestGoalEvent = event;
+      }
+      if (!latestGoalEvent || latestGoalEvent.type === "goal.cleared") {
+        pendingRefreshRef.current = "none";
+        return;
+      }
+      pendingRefreshRef.current = "goal";
+    }
+    scheduleRefreshRef.current();
   }, [client, workspaceId, sessionId]);
 
   useEffect(() => {
     const targetKey = `${workspaceId} ${sessionId ?? ""}`;
     if (targetKeyRef.current !== targetKey) {
       targetKeyRef.current = targetKey;
+      goalAbsentRef.current = false;
+      pendingRefreshRef.current = "none";
       setGoal(null);
       setError(null);
     }
     if (!enabled || !pageLive) {
+      retireLoads();
       setLoading(false);
       return;
     }
     if (sharedFeed) {
-      setLoading(false);
+      // A shared log supplies invalidations, not the authoritative goal snapshot.
+      setLoading(true);
+      void load();
       return () => {
-        generation.current += 1;
+        retireLoads();
       };
     }
     setLoading(true);
@@ -133,7 +193,7 @@ export function useGoal(
     if (pollIntervalMs === undefined || pollIntervalMs <= 0) {
       void load();
       return () => {
-        generation.current += 1;
+        retireLoads();
       };
     }
     let cancelled = false;
@@ -149,12 +209,46 @@ export function useGoal(
     return () => {
       cancelled = true;
       if (timer !== null) clearTimeout(timer);
-      generation.current += 1;
+      retireLoads();
     };
-  }, [load, enabled, pageLive, workspaceId, sessionId, options.pollIntervalMs, sharedFeed]);
+  }, [
+    load,
+    enabled,
+    pageLive,
+    workspaceId,
+    sessionId,
+    options.pollIntervalMs,
+    retireLoads,
+    sharedFeed,
+  ]);
 
-  const scheduleRefresh = useDebouncedCallback(() => void load());
-  useSessionEventTrigger(client, workspaceId, sessionId, isGoalRefreshEvent, scheduleRefresh, {
+  const scheduleRefresh = useDebouncedCallback(() => {
+    const pending = pendingRefreshRef.current;
+    // An in-flight read settles pending events itself.
+    if (pending === "none" || loadAbort.current !== null) return;
+    if (pending === "refresh" && goalAbsentRef.current) {
+      pendingRefreshRef.current = "none";
+      return;
+    }
+    void load();
+  });
+  useLayoutEffect(() => {
+    scheduleRefreshRef.current = scheduleRefresh;
+  }, [scheduleRefresh]);
+  const isRefreshEvent = useCallback(
+    (event: SessionEvent) =>
+      goalAbsentRef.current ? isGoalEvent(event) : isGoalRefreshEvent(event),
+    [],
+  );
+  const onRefreshEvent = useCallback(
+    (event: SessionEvent) => {
+      if (isGoalEvent(event)) pendingRefreshRef.current = "goal";
+      else if (pendingRefreshRef.current === "none") pendingRefreshRef.current = "refresh";
+      scheduleRefresh();
+    },
+    [scheduleRefresh],
+  );
+  useSessionEventTrigger(client, workspaceId, sessionId, isRefreshEvent, onRefreshEvent, {
     enabled,
     ...(sharedEvents !== undefined ? { events: sharedEvents } : {}),
   });
@@ -203,11 +297,11 @@ export function useGoal(
       return true as const;
     });
     if (ok) {
-      generation.current += 1;
+      retireLoads();
       setGoal(null);
       setError(null);
     }
-  }, [client, workspaceId, sessionId, run]);
+  }, [client, workspaceId, sessionId, run, retireLoads]);
 
   return {
     goal,

package/src/hooks/use-last-started-turn-policy.ts

@@ -1,4 +1,10 @@
-import type { LatencyMode, ReasoningEffort, SessionEvent, SessionTurn } from "@opengeni/sdk";
+import type {
+  LatencyMode,
+  ReasoningEffort,
+  SessionEvent,
+  SessionTurn,
+  SessionModelAccountChoiceResponse,
+} from "@opengeni/sdk";
 import { useCallback, useEffect } from "react";
 import { useOpenGeni, type ClientOverride } from "../session-context";
 import { usePolledValue, useSessionEventTrigger, type SessionEventFeedOptions } from "./internal";
@@ -18,6 +24,8 @@ export type LastStartedTurnPolicy = {
 export type UseLastStartedTurnPolicyOptions = ClientOverride &
   SessionEventFeedOptions & {
     pollIntervalMs?: number | undefined;
+    /** Project the last lease-backed serving model without changing the accepted policy. */
+    includeServingModel?: boolean | undefined;
   };
 
 export type UseLastStartedTurnPolicyResult = {
@@ -38,6 +46,20 @@ function policyFromTurn(turn: SessionTurn | null | undefined): LastStartedTurnPo
   };
 }
 
+/** Never project an earlier turn's selection onto newly admitted work. */
+export function withServingModel(
+  policy: LastStartedTurnPolicy | null,
+  serving: SessionModelAccountChoiceResponse["serving"],
+): LastStartedTurnPolicy | null {
+  if (!policy || !serving || serving.turnId !== policy.turnId) return policy;
+  return {
+    turnId: policy.turnId,
+    model: serving.modelId,
+    reasoningEffort: serving.reasoningEffort,
+    latencyMode: serving.latencyMode,
+  };
+}
+
 /**
  * Model·effort·latency of the newest admitted turn (`turn.started`). This is
  * historical runtime truth for the session header — not the composer next-turn
@@ -47,25 +69,30 @@ export function useLastStartedTurnPolicy(
   sessionId: string | null | undefined,
   options: UseLastStartedTurnPolicyOptions = {},
 ): UseLastStartedTurnPolicyResult {
-  const { client, workspaceId, workspaceControlEvent, registerSessionReconciler } =
-    useOpenGeni(options);
+  const { client, workspaceId, registerSessionReconciler } = useOpenGeni(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const includeServingModel = options.includeServingModel === true;
 
-  const load = useCallback(async (): Promise<LastStartedTurnPolicy | null> => {
-    if (!sessionId) return null;
-    const turns = await client.listTurns(workspaceId, sessionId, { latestStarted: true });
-    return policyFromTurn(turns[0]);
-  }, [client, workspaceId, sessionId]);
+  const load = useCallback(
+    async (signal?: AbortSignal): Promise<LastStartedTurnPolicy | null> => {
+      if (!sessionId) return null;
+      const turns = await client.listTurns(workspaceId, sessionId, {
+        latestStarted: true,
+        signal,
+      });
+      const policy = policyFromTurn(turns[0]);
+      if (!includeServingModel || !policy || !client.getSessionModelAccount) return policy;
+      const choice = await client.getSessionModelAccount(workspaceId, sessionId);
+      return withServingModel(policy, choice.serving);
+    },
+    [client, workspaceId, sessionId, includeServingModel],
+  );
 
   const { data, loading, error, refresh } = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,
     enabled,
   });
 
-  useEffect(() => {
-    if (enabled && workspaceControlEvent) void refresh();
-  }, [enabled, refresh, workspaceControlEvent]);
-
   useEffect(() => {
     if (!sessionId || !enabled) return;
     return registerSessionReconciler(sessionId, "last-started-turn-policy", refresh);
@@ -73,12 +100,17 @@ export function useLastStartedTurnPolicy(
 
   // Shared-feed only: the session header lives outside the route event log and
   // must not open a second SSE. Without `events`, rely on the initial fetch +
-  // optional poll / workspace-control / reconciler.
+  // optional poll / reconciler. Pause/resume controls do not change the last
+  // admitted turn; its own turn.started event supplies that invalidation.
   useSessionEventTrigger(
     client,
     workspaceId,
     sessionId,
-    isLastStartedTurnPolicyEvent,
+    (event) =>
+      isLastStartedTurnPolicyEvent(event) ||
+      (includeServingModel &&
+        (event.type === "subscription.account.selected" ||
+          event.type === "subscription.account.switched")),
     () => void refresh(),
     {
       events: options.events,

package/src/hooks/use-machines.ts

@@ -158,6 +158,10 @@ function swapFailureMessage(result: SwapActiveSandboxResponse): string {
       return "The selected machine is offline.";
     case "concurrent_swap":
       return "The session route changed concurrently. Refresh and try again.";
+    case "personal_machine_permission_required":
+      return "The machine's owner has not allowed this chat to use it.";
+    case "personal_machine_not_permitted":
+      return "Only the machine's owner can use it in this chat.";
     default:
       return "The session stayed on its current sandbox.";
   }