@opengeni/react 1.0.1 → 2.3.0-canary.0

package/src/hooks/use-sandbox-git.ts

@@ -233,12 +233,14 @@ export function useSandboxGit(
   // survive renders, so they must be fenced/reset when that identity changes.
   const refreshGenerationRef = useRef(0);
   const refreshAbortRef = useRef<AbortController | null>(null);
+  const refreshInFlightRef = useRef<Promise<void> | null>(null);
+  const refreshPendingRef = useRef(false);
+  const refreshWorkerEpochRef = useRef(0);
   const lastChangeRef = useRef(0);
-  const commandRefreshTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const eventRefreshTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
-  const refresh = useCallback(async () => {
+  const performRefresh = useCallback(async () => {
     if (!sessionId) return;
-    refreshAbortRef.current?.abort();
     const refreshAbort = new AbortController();
     refreshAbortRef.current = refreshAbort;
     const generation = (refreshGenerationRef.current += 1);
@@ -377,6 +379,32 @@ export function useSandboxGit(
     comparison,
   ]);
 
+  // Provider reads cannot be undispatched after they reach a remote sandbox.
+  // Keep exactly one refresh in flight and collapse any burst of invalidations
+  // into one trailing read. Aborting and replacing every tool-output refresh
+  // used to leave several Modal reads contending for the same provider lock.
+  const performRefreshRef = useRef(performRefresh);
+  performRefreshRef.current = performRefresh;
+  const refresh = useCallback(async () => {
+    refreshPendingRef.current = true;
+    const existing = refreshInFlightRef.current;
+    if (existing) return await existing;
+
+    const workerEpoch = refreshWorkerEpochRef.current;
+    const run = (async () => {
+      while (refreshPendingRef.current && refreshWorkerEpochRef.current === workerEpoch) {
+        refreshPendingRef.current = false;
+        await performRefreshRef.current();
+      }
+    })();
+    refreshInFlightRef.current = run;
+    try {
+      await run;
+    } finally {
+      if (refreshInFlightRef.current === run) refreshInFlightRef.current = null;
+    }
+  }, []);
+
   // Serve the requested review scope from a capture when that scope exists.
   const seedFromCapture = useCallback(
     (manifest: WorkspaceCaptureManifest) => {
@@ -432,9 +460,17 @@ export function useSandboxGit(
     // true data-identity change clears rendered state and the event high-water mark.
     refreshAbortRef.current?.abort();
     refreshAbortRef.current = null;
+    refreshPendingRef.current = false;
     refreshGenerationRef.current += 1;
     const identityChanged = previousIdentityRef.current !== identityKey;
     previousIdentityRef.current = identityKey;
+    if (identityChanged) {
+      // Different sessions target different provider identities. Fence the old
+      // worker and let the new session load immediately instead of waiting for a
+      // stuck request that has already been aborted.
+      refreshWorkerEpochRef.current += 1;
+      refreshInFlightRef.current = null;
+    }
     if (identityChanged || !enabled) {
       lastChangeRef.current = 0;
       setDiff([]);
@@ -466,6 +502,7 @@ export function useSandboxGit(
     return () => {
       refreshAbortRef.current?.abort();
       refreshAbortRef.current = null;
+      refreshPendingRef.current = false;
       refreshGenerationRef.current += 1;
     };
   }, [
@@ -479,15 +516,15 @@ export function useSandboxGit(
     seedFromCapture,
   ]);
 
-  // git.changed → re-fetch the LIVE diff. Agent tool completion is also an
-  // invalidation point because shell/apply-patch writes can bypass Channel-A and
-  // therefore emit no git.changed event. This is event-driven, never polling.
+  // Structured Git changes are debounced into one live reconcile. Generic
+  // command/tool output performs no provider reads: the canonical turn-end
+  // capture advances `captureRevision`, which refreshes after the burst settles.
   const events = options.events;
   useEffect(() => {
     if (!enabled || !events) {
-      if (commandRefreshTimerRef.current) {
-        clearTimeout(commandRefreshTimerRef.current);
-        commandRefreshTimerRef.current = null;
+      if (eventRefreshTimerRef.current) {
+        clearTimeout(eventRefreshTimerRef.current);
+        eventRefreshTimerRef.current = null;
       }
       return;
     }
@@ -498,43 +535,35 @@ export function useSandboxGit(
       for (const event of events) {
         if (event.sequence > lastChangeRef.current) lastChangeRef.current = event.sequence;
       }
-      if (commandRefreshTimerRef.current) {
-        clearTimeout(commandRefreshTimerRef.current);
-        commandRefreshTimerRef.current = null;
+      if (eventRefreshTimerRef.current) {
+        clearTimeout(eventRefreshTimerRef.current);
+        eventRefreshTimerRef.current = null;
       }
       return;
     }
     let latest = lastChangeRef.current;
-    let immediate = false;
-    let commandDelta = false;
+    let changed = false;
     for (const event of events) {
       if (event.sequence <= latest) continue;
-      if (event.type === "git.changed" || event.type === "agent.toolCall.output") {
-        latest = event.sequence;
-        immediate = true;
-      } else if (event.type === "sandbox.command.output.delta") {
+      if (event.type === "git.changed") {
         latest = event.sequence;
-        commandDelta = true;
+        changed = true;
       }
     }
     if (latest > lastChangeRef.current) {
       lastChangeRef.current = latest;
-      if (immediate) {
-        if (commandRefreshTimerRef.current) clearTimeout(commandRefreshTimerRef.current);
-        commandRefreshTimerRef.current = null;
+      if (!changed) return;
+      if (eventRefreshTimerRef.current) clearTimeout(eventRefreshTimerRef.current);
+      eventRefreshTimerRef.current = setTimeout(() => {
+        eventRefreshTimerRef.current = null;
         if (acceptsEventReadsRef.current) void refresh();
-      } else if (commandDelta && !commandRefreshTimerRef.current) {
-        commandRefreshTimerRef.current = setTimeout(() => {
-          commandRefreshTimerRef.current = null;
-          if (acceptsEventReadsRef.current) void refresh();
-        }, 1_000);
-      }
+      }, 150);
     }
   }, [enabled, active, acceptsEventReads, events, refresh]);
 
   useEffect(
     () => () => {
-      if (commandRefreshTimerRef.current) clearTimeout(commandRefreshTimerRef.current);
+      if (eventRefreshTimerRef.current) clearTimeout(eventRefreshTimerRef.current);
     },
     [],
   );

package/src/hooks/use-session-background-commands.ts

@@ -0,0 +1,56 @@
+import type { SessionBackgroundCommand } from "@opengeni/sdk";
+import { useCallback } from "react";
+
+import { useOpenGeni, type ClientOverride } from "../provider";
+import { usePolledValue } from "./internal";
+
+export type UseSessionBackgroundCommandsOptions = ClientOverride & {
+  pollIntervalMs?: number | undefined;
+  enabled?: boolean | undefined;
+};
+
+export type UseSessionBackgroundCommandsResult = {
+  commands: SessionBackgroundCommand[];
+  loading: boolean;
+  error: Error | null;
+  refresh: () => Promise<void>;
+  cancel: (commandId: string) => Promise<void>;
+};
+
+export function useSessionBackgroundCommands(
+  sessionId: string | null | undefined,
+  options: UseSessionBackgroundCommandsOptions = {},
+): UseSessionBackgroundCommandsResult {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const load = useCallback(async () => {
+    if (!sessionId) return { commands: [] };
+    if (!client.listSessionBackgroundCommands) {
+      throw new Error("The configured OpenGeni client does not support background commands");
+    }
+    return await client.listSessionBackgroundCommands(workspaceId, sessionId);
+  }, [client, workspaceId, sessionId]);
+  const state = usePolledValue(load, {
+    enabled,
+    pollIntervalMs: options.pollIntervalMs,
+  });
+  const refresh = state.refresh;
+  const cancel = useCallback(
+    async (commandId: string): Promise<void> => {
+      if (!sessionId) return;
+      if (!client.cancelSessionBackgroundCommand) {
+        throw new Error("The configured OpenGeni client does not support background commands");
+      }
+      await client.cancelSessionBackgroundCommand(workspaceId, sessionId, commandId);
+      await refresh();
+    },
+    [client, workspaceId, sessionId, refresh],
+  );
+  return {
+    commands: state.data?.commands ?? [],
+    loading: state.loading,
+    error: state.error,
+    refresh,
+    cancel,
+  };
+}

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

@@ -283,6 +283,11 @@ export function useSessionCapabilities(
           })
           .catch((cause) => {
             if (!cancelled) {
+              if (isSandboxOwnershipDisabledError(cause)) {
+                setState("on-demand");
+                setError(null);
+                return;
+              }
               setState("error");
               setError(cause instanceof Error ? cause : new Error(String(cause)));
             }
@@ -453,6 +458,11 @@ export function useSessionCapabilities(
         }
       } catch (cause) {
         if (cancelled) return;
+        if (isSandboxOwnershipDisabledError(cause)) {
+          setState("on-demand");
+          setError(null);
+          return;
+        }
         if (cause instanceof OpenGeniApiError && cause.status === 403) {
           setState("error");
           setError(new Error("not permitted to view this session's sandbox"));
@@ -524,3 +534,11 @@ export function useSessionCapabilities(
     renegotiate,
   };
 }
+
+function isSandboxOwnershipDisabledError(error: unknown): boolean {
+  return (
+    error instanceof OpenGeniApiError &&
+    error.status === 404 &&
+    error.message.includes("sandbox ownership is not enabled")
+  );
+}

package/src/hooks/use-turn-queue.ts

@@ -42,6 +42,17 @@ function queueSnapshotCovers(
 export type QueueMutationKind = "move" | "edit" | "steer" | "delete";
 const EMPTY_PENDING_BY_TURN: Readonly<Record<string, QueueMutationKind>> = {};
 
+export type AcceptedQueueSteer = {
+  turnId: string;
+  triggerEventId: string;
+  text: string;
+  annotations: SessionTurn["annotations"];
+  resources: SessionTurn["resources"];
+  tools: SessionTurn["tools"];
+  occurredAt: string;
+  state: "sending" | "queued";
+};
+
 export type UseTurnQueueOptions = EmbeddedSessionClientOverride &
   SessionEventFeedOptions & {
     pollIntervalMs?: number | undefined;
@@ -77,6 +88,8 @@ export type UseTurnQueueResult = {
   mutating: boolean;
   mutationError: Error | null;
   clearMutationError: () => void;
+  /** Immediate chat bridge while the durable Steer event catches up over SSE. */
+  acceptedSteers?: AcceptedQueueSteer[] | undefined;
 };
 
 /**
@@ -99,6 +112,7 @@ export function useTurnQueue(
   const [error, setError] = useState<Error | null>(null);
   const [mutationError, setMutationError] = useState<Error | null>(null);
   const [pendingByTurn, setPendingByTurn] = useState<Record<string, QueueMutationKind>>({});
+  const [acceptedSteers, setAcceptedSteers] = useState<AcceptedQueueSteer[]>([]);
   const pendingRef = useRef<Record<string, QueueMutationKind>>({});
   const readGeneration = useRef(0);
   const targetKeyRef = useRef(targetKey);
@@ -118,8 +132,26 @@ export function useTurnQueue(
     setError(null);
     setMutationError(null);
     setPendingByTurn({});
+    setAcceptedSteers([]);
   }, [enabled, targetKey]);
 
+  useEffect(() => {
+    if (acceptedSteers.length === 0 || options.events === undefined) return;
+    const durablyStartedTurnIds = new Set(
+      options.events.flatMap((event) =>
+        event.type === "turn.started" && event.turnId ? [event.turnId] : [],
+      ),
+    );
+    if (durablyStartedTurnIds.size === 0) return;
+    // steer_requested can reach the browser before the timeline projection
+    // that moves the queued user.message into chat. Keep this bridge through
+    // physical cancellation; turn.started is the first boundary at which the
+    // replacement timeline must already be visible.
+    setAcceptedSteers((current) =>
+      current.filter((steer) => !durablyStartedTurnIds.has(steer.turnId)),
+    );
+  }, [acceptedSteers.length, options.events]);
+
   const acceptSnapshot = useCallback(
     (ownedTargetKey: string, next: SessionQueueSnapshot | null): boolean => {
       if (targetKeyRef.current !== ownedTargetKey) return false;
@@ -234,6 +266,7 @@ export function useTurnQueue(
       command: (
         current: SessionQueueSnapshot,
         turn: SessionTurn,
+        clientEventId: string,
       ) => Promise<SessionQueueMutationResponse>,
     ): Promise<SessionQueueMutationResponse | null> => {
       const ownedTargetKey = targetKey;
@@ -247,8 +280,17 @@ export function useTurnQueue(
       setStateTargetKey(ownedTargetKey);
       setPendingByTurn(pendingRef.current);
       setMutationError(null);
+      const clientEventId = operationKey();
       try {
-        const result = await command(current, turn);
+        let result: SessionQueueMutationResponse;
+        try {
+          result = await command(current, turn, clientEventId);
+        } catch (cause) {
+          if (!isOutcomeUnknownError(cause)) throw cause;
+          // Same-key replay is a fact check against the durable receipt. It
+          // cannot duplicate the command even if the first response was lost.
+          result = await command(current, turn, clientEventId);
+        }
         if (targetKeyRef.current !== ownedTargetKey) return null;
         acceptSnapshot(ownedTargetKey, result.snapshot);
         return result;
@@ -272,9 +314,9 @@ export function useTurnQueue(
 
   const moveTurn = useCallback(
     async (turnId: string, beforeTurnId: string | null): Promise<boolean> => {
-      const result = await mutate(turnId, "move", (current) =>
+      const result = await mutate(turnId, "move", (current, _turn, clientEventId) =>
         client.moveQueueItem(workspaceId, sessionId!, turnId, {
-          clientEventId: operationKey(),
+          clientEventId,
           expectedQueueVersion: current.version,
           beforeTurnId,
         }),
@@ -289,9 +331,9 @@ export function useTurnQueue(
       turnId: string,
       edit: { expectedDraftRevision: number; replaceDraft: boolean },
     ): Promise<ComposerDraft | null> => {
-      const result = await mutate(turnId, "edit", (_current, turn) =>
+      const result = await mutate(turnId, "edit", (_current, turn, clientEventId) =>
         client.editQueueItem(workspaceId, sessionId!, turnId, {
-          clientEventId: operationKey(),
+          clientEventId,
           expectedTurnVersion: turn.version,
           expectedDraftRevision: edit.expectedDraftRevision,
           replaceDraft: edit.replaceDraft,
@@ -304,23 +346,71 @@ export function useTurnQueue(
 
   const steerTurn = useCallback(
     async (turnId: string): Promise<boolean> => {
-      const result = await mutate(turnId, "steer", (current, turn) =>
+      const ownedTargetKey = targetKey;
+      const turn = snapshotRef.current?.items.find((candidate) => candidate.id === turnId);
+      if (targetKeyRef.current !== ownedTargetKey) return false;
+      if (!turn) {
+        setMutationError(new Error("That queued prompt changed before Steer could be sent."));
+        await load();
+        return false;
+      }
+      const optimistic: AcceptedQueueSteer = {
+        turnId: turn.id,
+        triggerEventId: turn.triggerEventId,
+        text: turn.prompt,
+        annotations: turn.annotations ?? [],
+        resources: turn.resources,
+        tools: turn.tools,
+        occurredAt: new Date().toISOString(),
+        state: "sending",
+      };
+      setAcceptedSteers((current) => [
+        ...current.filter((steer) => steer.turnId !== turnId),
+        optimistic,
+      ]);
+      const result = await mutate(turnId, "steer", (current, queuedTurn, clientEventId) =>
         client.steerQueueItem(workspaceId, sessionId!, turnId, {
-          clientEventId: operationKey(),
-          expectedTurnVersion: turn.version,
+          clientEventId,
+          expectedTurnVersion: queuedTurn.version,
           controlEtag: current.effectiveControl.controlEtag,
         }),
       );
-      return result !== null;
+      if (targetKeyRef.current !== ownedTargetKey) return false;
+      // The active turn can finish while the operator clicks Steer. In that
+      // race the queued prompt is atomically claimed before the steer command,
+      // so the command conflicts but the user's prompt already advanced into
+      // chat. Reconciled absence is success, not a scary unknown-outcome lie.
+      const advancedWithoutSteer =
+        result === null &&
+        snapshotRef.current !== null &&
+        !snapshotRef.current.items.some((candidate) => candidate.id === turnId);
+      if (advancedWithoutSteer) {
+        setMutationError(null);
+        setAcceptedSteers((current) => current.filter((steer) => steer.turnId !== turnId));
+        return true;
+      }
+      const accepted =
+        result !== null ||
+        snapshotRef.current?.items.some(
+          (candidate) => candidate.id === turnId && candidate.metadata.delivery === "steer",
+        ) === true;
+      setAcceptedSteers((current) =>
+        accepted
+          ? current.map((steer) =>
+              steer.turnId === turnId ? { ...steer, state: "queued" as const } : steer,
+            )
+          : current.filter((steer) => steer.turnId !== turnId),
+      );
+      return accepted;
     },
-    [client, mutate, sessionId, workspaceId],
+    [client, load, mutate, sessionId, targetKey, workspaceId],
   );
 
   const removeTurn = useCallback(
     async (turnId: string): Promise<boolean> => {
-      const result = await mutate(turnId, "delete", (_current, turn) =>
+      const result = await mutate(turnId, "delete", (_current, turn, clientEventId) =>
         client.deleteQueueItem(workspaceId, sessionId!, turnId, {
-          clientEventId: operationKey(),
+          clientEventId,
           expectedTurnVersion: turn.version,
           reason: "Deleted from the prompt queue",
         }),
@@ -364,6 +454,7 @@ export function useTurnQueue(
     clearMutationError: useCallback(() => {
       if (targetKeyRef.current === targetKey) setMutationError(null);
     }, [targetKey]),
+    acceptedSteers: identityMatches ? acceptedSteers : [],
   };
 }
 
@@ -374,3 +465,11 @@ function operationKey(): string {
 function asError(cause: unknown): Error {
   return cause instanceof Error ? cause : new Error(String(cause));
 }
+
+function isOutcomeUnknownError(cause: unknown): boolean {
+  return (
+    typeof cause === "object" &&
+    cause !== null &&
+    (cause as { outcomeUnknown?: unknown }).outcomeUnknown === true
+  );
+}

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

@@ -10,6 +10,7 @@ export type UseWorkspaceSessionsOptions = ClientOverride & {
   search?: string | undefined;
   /** Return only the complete personal pinned projection. */
   pinsOnly?: boolean | undefined;
+  archivedOnly?: boolean | undefined;
   /** Refresh interval (ms) for fleet/manager views. Off by default. */
   pollIntervalMs?: number | undefined;
   enabled?: boolean | undefined;
@@ -41,6 +42,7 @@ export function useWorkspaceSessions(
   const cursor = options.cursor;
   const search = options.search;
   const pinsOnly = options.pinsOnly;
+  const archivedOnly = options.archivedOnly;
   const enabled = options.enabled ?? true;
   const queryKey = [
     workspaceId,
@@ -49,6 +51,7 @@ export function useWorkspaceSessions(
     cursor ?? "",
     search ?? "",
     pinsOnly ? "1" : "",
+    archivedOnly ? "archived" : "active",
   ].join("\u0000");
   const previousQueryKey = useRef(queryKey);
   const queryKeyTransition = previousQueryKey.current !== queryKey;
@@ -64,9 +67,10 @@ export function useWorkspaceSessions(
         ...(cursor !== undefined ? { cursor } : {}),
         ...(search !== undefined ? { search } : {}),
         ...(pinsOnly ? { pinsOnly: true } : {}),
+        ...(archivedOnly ? { archivedOnly: true } : {}),
       }),
     }),
-    [client, workspaceId, limit, parentSessionId, cursor, search, pinsOnly, queryKey],
+    [client, workspaceId, limit, parentSessionId, cursor, search, pinsOnly, archivedOnly, queryKey],
   );
   const state = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,

package/src/index.ts

@@ -54,7 +54,13 @@ export {
   shouldSubmitOnKey,
   FILE_ONLY_MESSAGE_TEXT,
 } from "./hooks/use-composer";
-export type { ComposerSendExtras, ComposerState, UseComposerOptions } from "./hooks/use-composer";
+export type {
+  ComposerControllerState,
+  ComposerPolicy,
+  ComposerSendExtras,
+  ComposerState,
+  UseComposerOptions,
+} from "./hooks/use-composer";
 export {
   VOICE_RECORDING_CLIENT_MAX_DURATION_SECONDS,
   VOICE_RECORDING_OWNER_HEARTBEAT_MILLISECONDS,
@@ -129,7 +135,12 @@ export type {
 } from "./hooks/use-last-started-turn-policy";
 export { QueueSurface } from "./components/queue-surface";
 export type { QueueSurfaceProps } from "./components/queue-surface";
-export { SessionChrome, sessionChromeGoalPillState } from "./components/session-chrome";
+export {
+  SessionChrome,
+  sessionChromeGoalPillExplanation,
+  sessionChromeGoalPillLabel,
+  sessionChromeGoalPillState,
+} from "./components/session-chrome";
 export type {
   SessionChromeAgentsSignal,
   SessionChromeProps,
@@ -163,6 +174,11 @@ export type {
   UseWorkspaceSessionsOptions,
   UseWorkspaceSessionsResult,
 } from "./hooks/use-workspace-sessions";
+export { useSessionBackgroundCommands } from "./hooks/use-session-background-commands";
+export type {
+  UseSessionBackgroundCommandsOptions,
+  UseSessionBackgroundCommandsResult,
+} from "./hooks/use-session-background-commands";
 export { useSessionLineage, isLineageRefreshEvent } from "./hooks/use-session-lineage";
 export type {
   UseSessionLineageOptions,
@@ -315,6 +331,8 @@ export type {
   AuthNeededItem,
   ContextCompactionItem,
   GoalItem,
+  HumanInputAnswerSummary,
+  HumanInputItem,
   MachineInputBatchItem,
   MachineInputMember,
   NoticeItem,
@@ -478,10 +496,14 @@ export type { GeneratedVideoPlayerProps } from "./components/generated-video-pla
 export type { MessageTimelineProps } from "./components/message-timeline";
 export { UserMessageBody, userMessageLikelyNeedsDisclosure } from "./components/user-message-body";
 export type { UserMessageBodyProps } from "./components/user-message-body";
-export { Markdown } from "./components/markdown";
+export {
+  Markdown,
+  sandboxFileLocationFromHref,
+  sandboxFilePathFromHref,
+} from "./components/markdown";
+export type { MarkdownProps, SandboxFileLocation } from "./components/markdown";
 export { CopyButton, CopyHoverFrame } from "./components/copy-button";
 export { copyTextToClipboard, tableElementToTsv } from "./lib/clipboard";
-export type { MarkdownProps } from "./components/markdown";
 export { SessionStatus, StatusDot, SESSION_STATUS_META } from "./components/session-status";
 export type {
   SessionStatusProps,

package/src/lib/interaction-errors.ts

@@ -0,0 +1,18 @@
+import { OpenGeniApiError } from "@opengeni/sdk";
+
+export function isNonRetryableInteractionError(error: unknown): error is OpenGeniApiError {
+  return error instanceof OpenGeniApiError && error.retryable === false;
+}
+
+export function isSourcePlacementChangedError(
+  error: unknown,
+  resource: "browser_session" | "computer_session",
+): error is OpenGeniApiError {
+  return (
+    isNonRetryableInteractionError(error) &&
+    error.status === 409 &&
+    error.details?.interactionResource === resource &&
+    error.details?.interactionFailureCode === "source_placement_changed" &&
+    error.details?.interactionLifecycle === "lost"
+  );
+}

package/src/machines.ts

@@ -9,6 +9,7 @@
 export type {
   ConnectionStatus,
   MachineKind,
+  MachineOperationPolicy,
   MachineMetricsSeriesResponse,
   MachineState,
   MachineView,
@@ -48,6 +49,8 @@ export type {
 } from "./components/machines/metric-history-chart";
 export { MachineDetail } from "./components/machines/machine-detail";
 export type { MachineDetailProps } from "./components/machines/machine-detail";
+export { MachineOperationPolicyEditor } from "./components/machines/machine-operation-policy";
+export type { MachineOperationPolicyEditorProps } from "./components/machines/machine-operation-policy";
 export { METRICS, METRIC_WINDOWS, WINDOW_LABEL, pointsFor } from "./components/machines/series";
 export type { MetricDef, MetricKey, MetricWindow } from "./components/machines/series";
 export { MachinesDashboard } from "./components/machines-dashboard";
@@ -68,7 +71,12 @@ export type {
   EnrollmentConsentPhase,
   EnrollmentConsentProps,
 } from "./components/enrollment-consent";
-export { useMachines } from "./hooks/use-machines";
+export {
+  useMachines,
+  MACHINES_COMPOSER_POLL_MS,
+  MACHINES_DASHBOARD_POLL_MS,
+  MACHINES_SESSION_POLL_MS,
+} from "./hooks/use-machines";
 export type {
   MachinesClientLike,
   UseMachinesOptions,

package/src/model-policy.ts

@@ -2,6 +2,7 @@ import type { ClientModel, ReasoningEffort, WorkspaceModelCatalogModel } from "@
 
 export type PickerBillingClass =
   | "opengeni_credits"
+  | "external"
   | "codex_subscription"
   | "supergrok_subscription"
   | "byok";
@@ -24,6 +25,7 @@ export type LatencyModeId = "standard" | "priority" | "fast";
 
 const BILLING_CLASS_ORDER: PickerBillingClass[] = [
   "opengeni_credits",
+  "external",
   "codex_subscription",
   "supergrok_subscription",
   "byok",
@@ -31,6 +33,7 @@ const BILLING_CLASS_ORDER: PickerBillingClass[] = [
 
 const BILLING_CLASS_LABELS: Record<PickerBillingClass, string> = {
   opengeni_credits: "OpenGeni",
+  external: "External",
   codex_subscription: "Codex",
   supergrok_subscription: "SuperGrok",
   byok: "Your Gateway",
@@ -47,6 +50,9 @@ const AVAILABILITY_REASON_LABELS: Record<string, string> = {
 };
 
 export function billingClassForModel(model: ClientModel): PickerBillingClass {
+  if (model.billing?.metering === "external" && model.billing.upstreamPayer === "deployment") {
+    return "external";
+  }
   if (model.source === "supergrok") {
     return "supergrok_subscription";
   }
@@ -153,13 +159,15 @@ export function payerSummaryForModel(model: ClientModel): string {
   if (billing.upstreamPayer === "workspace") {
     return "Billed to your AI Gateway";
   }
-  return "Deployment route · external billing";
+  return "External provider · no OpenGeni credits";
 }
 
 export function advancedSourceSummary(model: ClientModel): string | null {
   const source = model.credentialSource;
   if (!source) {
-    return null;
+    return model.billing?.metering === "external" && model.billing.upstreamPayer === "deployment"
+      ? "Deployment route · no authentication"
+      : null;
   }
   if (source.kind === "connected_subscription") {
     return source.provider === "xai"