@opengeni/react 0.28.2 → 0.32.1

package/dist/components/stream-reveal.d.ts

@@ -0,0 +1,37 @@
+/** Keep in sync with `--og-duration-stream` / `.og-stream-ink` in styles. */
+export declare const INK_FADE_MS: number;
+/** @deprecated Use {@link INK_FADE_MS}. */
+export declare const WORD_ANIMATION_MS: number;
+export type StreamReveal = {
+    /** Register the full current source text; new suffix becomes an ink batch. */
+    observe(text: string, now: number): void;
+    /**
+     * CSS animation-delay (ms) for the run covering `offset`, or null when that
+     * ink has settled and should render as plain text. Negative = resume mid-fade.
+     */
+    delayFor(offset: number, now: number): number | null;
+    /** True while any batch is still inside its fade window. */
+    hasActive(now: number): boolean;
+};
+export declare function createStreamReveal(): StreamReveal;
+type HastText = {
+    type: "text";
+    value: string;
+    position?: {
+        start?: {
+            offset?: number | undefined;
+        } | undefined;
+    } | undefined;
+};
+type HastParent = {
+    type: string;
+    tagName?: string;
+    value?: string;
+    children?: HastChild[];
+};
+type HastChild = (HastText | HastParent) & Record<string, unknown>;
+export declare function rehypeStreamReveal(options: {
+    reveal: StreamReveal;
+    now: number;
+}): (tree: HastParent) => void;
+export {};

package/dist/components/tip-follow.d.ts

@@ -0,0 +1,139 @@
+/** Calm ease while live: remaining debt shrinks ~63% every τ_max ms. */
+export declare const TIP_FOLLOW_TAU_MAX_MS: number;
+/** Catch-up ease under large tip-debt (reader far behind / big paste). */
+export declare const TIP_FOLLOW_TAU_MIN_MS: number;
+/**
+ * Idle settle τ — stream quiet, soft landing into the tip. Longer than live
+ * calm so the last pixels decelerate instead of linear-crawling then stopping.
+ */
+export declare const TIP_FOLLOW_SETTLE_TAU_MS: number;
+/** Debt that saturates urgency toward τ_min. */
+export declare const TIP_FOLLOW_CATCHUP_DEBT_PX = 240;
+/** Keep the rAF alive this long after the last height growth. */
+export declare const TIP_FOLLOW_HOT_IDLE_MS: number;
+/** Cold oversized debt snaps (session switch / huge fold), not eases. */
+export declare const TIP_FOLLOW_SNAP_PX = 480;
+/** Soft speed floor while live with tiny debt (px/s). */
+export declare const TIP_FOLLOW_CALM_MAX_PX_S: number;
+/** Soft speed ceiling while catching a fast stream / modest tip-debt (px/s). */
+export declare const TIP_FOLLOW_BURST_MAX_PX_S: number;
+/** Ceiling for huge tip-debt / large single-frame walls (px/s). */
+export declare const TIP_FOLLOW_SURGE_MAX_PX_S: number;
+/**
+ * @deprecated Position growth-track removed — camera is velocity-smoothed.
+ * Kept so older tests/imports do not break.
+ */
+export declare const TIP_FOLLOW_GROWTH_TRACK = 0;
+/** @deprecated */
+export declare const TIP_FOLLOW_LINE_TRACK = 0;
+/** @deprecated Sub-line special-case removed with growth-track. */
+export declare const TIP_FOLLOW_TOKEN_GROWTH_PX = 10;
+/** Hot line-sized tip-debt uses the short {@link TIP_FOLLOW_LINE_TAU_MS}. */
+export declare const TIP_FOLLOW_LINE_GROWTH_PX = 48;
+/** Hot τ ceiling while closing a line-sized tip-debt (ms). */
+export declare const TIP_FOLLOW_LINE_TAU_MS: number;
+/**
+ * Velocity ease-in/out: scrollVel approaches desiredVel with this fraction of τ.
+ * Lower → snappier accel; higher → softer start (and slower reaction).
+ */
+export declare const TIP_FOLLOW_ACCEL_TAU_FRAC = 0.45;
+/** @deprecated Soft-rise FLIP removed — line glue was the bug. */
+export declare const TIP_FOLLOW_SOFT_RISE_MS = 0;
+/** @deprecated */
+export declare const TIP_FOLLOW_SOFT_RISE_MAX_PX = 96;
+/** @deprecated */
+export declare const TIP_FOLLOW_SOFT_RISE_EASING = "cubic-bezier(0.22, 1, 0.36, 1)";
+/** Ignore sub-pixel / reflow height noise for shrink compensate. */
+export declare const TIP_FOLLOW_SHRINK_EPS_PX = 4;
+/** Growth speed (px/s) that saturates velocity urgency. */
+export declare const TIP_FOLLOW_VELOCITY_REF_PX_S: number;
+/**
+ * Tip-debt below which growth velocity must not tighten τ.
+ * Sparse tokens are high-velocity by nature; only arm once actually behind.
+ */
+export declare const TIP_FOLLOW_VELOCITY_ARM_DEBT_PX = 72;
+/** EMA decay τ for growthVelocity when height is flat (ms). */
+export declare const TIP_FOLLOW_VELOCITY_DECAY_MS: number;
+/** Reader-up pixels above clamp budget that count as leaving the tip. */
+export declare const TIP_FOLLOW_READER_UP_EPS_PX = 2;
+/** @deprecated Shrink lock removed; kept so old imports do not break. */
+export declare const TIP_FOLLOW_SHRINK_LOCK_MS = 0;
+/** @deprecated Absorb thresholds removed — growth track is continuous. */
+export declare const TIP_FOLLOW_GROWTH_ABSORB_PX = 96;
+/**
+ * ScrollTop decrease not explained by a maxScroll clamp (fold / composer
+ * shrink). Fold clamp: top falls by ≈ maxScroll fall → 0. Real scroll-up:
+ * top falls while maxScroll holds → positive. No timers.
+ */
+export declare function readerScrollUpPx(prevTop: number, nextTop: number, prevMaxScroll: number, nextMaxScroll: number): number;
+export type TipFollowState = {
+    running: boolean;
+    hotUntil: number;
+    lastTs: number;
+    lastHeight: number;
+    lastGrowthAt: number;
+    /** EMA of recent height growth (px/s); nudges τ / ceiling under bursts. */
+    growthVelocity: number;
+    /** Camera velocity toward tip (px/s). Smoothed — never jumps with debt. */
+    scrollVelocity: number;
+};
+export type TipFollowStepInput = {
+    scrollTop: number;
+    scrollHeight: number;
+    clientHeight: number;
+    now: number;
+    pinned: boolean;
+    reducedMotion: boolean;
+    revealed: boolean;
+};
+export type TipFollowStepResult = {
+    scrollTop: number;
+    state: TipFollowState;
+};
+export declare function createTipFollowState(): TipFollowState;
+export declare function tipFollowCancel(state: TipFollowState): TipFollowState;
+/**
+ * Record content height. Positive growth extends the hot window so sparse
+ * lines do not tear down the follow loop between appends.
+ */
+export declare function tipFollowNoteGrowth(state: TipFollowState, height: number, now: number): TipFollowState;
+/**
+ * Adaptive τ: small debt → calm; large debt / armed velocity → catch-up.
+ * While hot, floor urgency so live streams are not stuck on calm τ.
+ * Idle settle uses the longer settle τ.
+ */
+export declare function tipFollowTauMs(debtPx: number, growthVelocityPxPerSec?: number, settling?: boolean, hot?: boolean): number;
+/**
+ * Soft speed ceiling from continuous signals (debt, velocity EMA, this-frame
+ * growth). No mode switches — larger inputs raise the ceiling smoothly.
+ */
+export declare function tipFollowMaxStepPx(debtPx: number, growthVelocityPxPerSec: number, dtMs: number, frameGrowthPx?: number, hot?: boolean): number;
+/**
+ * Counter-offset for soft-rise after tip-glue: start from the mid-flight
+ * translateY (if any) plus this frame's glued scroll delta, capped.
+ * Shell applies translateY(from) → 0 over {@link TIP_FOLLOW_SOFT_RISE_MS}.
+ */
+export declare function tipFollowSoftRiseFrom(currentTranslateY: number, gluedScrollDelta: number, maxPx?: number): number;
+/** Read live translateY from a transformed content column (mid soft-rise). */
+export declare function readTranslateY(el: HTMLElement): number;
+/**
+ * Cancel the tip-glue pop: start at translateY(+δ) and ease to 0.
+ * Uses WAAPI — a same-frame CSS transition never paints the counter-offset,
+ * so the scroll jump stays an instant one-line pop.
+ */
+export declare function tipFollowPlaySoftRise(el: HTMLElement, gluedScrollDelta: number, opts?: {
+    durationMs?: number;
+    maxPx?: number;
+    easing?: string;
+}): void;
+/** Stop soft-rise and clear any CSS transform residue. */
+export declare function tipFollowClearSoftRise(el: HTMLElement): void;
+/**
+ * Height left the document (settle collapse / composer). Keep the same pixels
+ * on screen: scrollTop -= Δh, clamped to the new max.
+ */
+export declare function tipFollowCompensateShrink(scrollTop: number, previousHeight: number, nextHeight: number, clientHeight: number, epsPx?: number): number;
+/**
+ * One camera step. Shell schedules the next rAF while `result.state.running`.
+ */
+export declare function tipFollowStep(state: TipFollowState, input: TipFollowStepInput): TipFollowStepResult;

package/dist/components/tooltip.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Token-styled Radix tooltip — SDK counterpart to apps/web `components/ui/tooltip`.
+ * Portals copy `--og-*` tokens so embeds keep the host theme outside `.og-root`.
+ *
+ * Background/foreground are applied as inline styles (not only Tailwind
+ * utilities): `.og-root` sets `color: var(--og-color-fg)` after utilities in the
+ * consumer CSS cascade, which would otherwise paint light-on-light inverted
+ * tips and look like a blank white bubble.
+ */
+import { Tooltip as TooltipPrimitive } from "radix-ui";
+import { type ComponentProps } from "react";
+declare function TooltipProvider({ delayDuration, ...props }: ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ children, ...props }: ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ asChild, ...props }: ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, style, ...props }: ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/components/workbench-changes.d.ts

@@ -0,0 +1,34 @@
+import type { SandboxGitFileDiff } from "../hooks/use-sandbox-git";
+export type WorkbenchChangesProps = {
+    /** The changed files (`useSandboxGit().diff`). Assumed non-empty by the caller. */
+    diff: SandboxGitFileDiff[];
+    /** Which source the diff came from — drives the "live" vs "as of turn" badge. */
+    source: "live" | "capture" | null;
+    /** When the served capture was taken (ISO), when `source === "capture"`. */
+    capturedAt: string | null;
+    /** The capture's turn revision, for the "as of turn N" badge. */
+    captureRevision?: number | null | undefined;
+    themeType?: "dark" | "light" | undefined;
+    /** Route a guarded binary/oversize file into the live Files surface. */
+    onOpenFile?: ((path: string) => void) | undefined;
+    className?: string | undefined;
+};
+type RailRow = {
+    kind: "group";
+    label: string;
+    count: number;
+} | {
+    kind: "file";
+    file: SandboxGitFileDiff;
+    index: number;
+};
+/** Order the files and build the rail rows (grouped past the threshold). The
+ *  returned `orderedFiles` drives BOTH the rail and the diff pane so a rail row's
+ *  `index` addresses the matching pane section. Exported for tests. */
+export declare function buildRail(files: SandboxGitFileDiff[]): {
+    orderedFiles: SandboxGitFileDiff[];
+    rows: RailRow[];
+    grouped: boolean;
+};
+export declare function WorkbenchChanges({ diff, source, capturedAt, captureRevision, themeType, onOpenFile, className, }: WorkbenchChangesProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/workspace-dock.d.ts

@@ -0,0 +1,35 @@
+import { type ReactNode } from "react";
+export type WorkspaceTab = {
+    id: string;
+    label: ReactNode;
+    /** Rendered as the active surface. */
+    content: ReactNode;
+    /** A small badge after the label (e.g. dirty count, live pill). */
+    badge?: ReactNode | undefined;
+};
+export type WorkspaceDockProps = {
+    /** The chat / primary pane shown beside the dock. */
+    primary: ReactNode;
+    tabs: WorkspaceTab[];
+    /** Controlled active tab. Falls back to the first tab. */
+    activeTab?: string | undefined;
+    onActiveTabChange?: ((id: string) => void) | undefined;
+    /** Controlled collapsed state for hosts that expose their own dock toggle. */
+    collapsed?: boolean | undefined;
+    onCollapsedChange?: ((collapsed: boolean) => void) | undefined;
+    /** A status accessory pinned to the right of the tab strip, left of the
+     *  maximize/collapse controls (e.g. the machine-state chip). Renders in both
+     *  the docked header and the full-screen overlay header. */
+    headerAccessory?: ReactNode | undefined;
+    /** Optional host navigation shown at the start of the phone overlay header.
+     *  It is intentionally absent from desktop dock chrome. */
+    mobileLeadingControl?: ReactNode | undefined;
+    /** Persisted layout id (localStorage key) for react-resizable-panels. */
+    autoSaveId?: string | undefined;
+    /** Default dock width as a percent of the session area. */
+    defaultSize?: number | undefined;
+    minSize?: number | undefined;
+    maxSize?: number | undefined;
+    className?: string | undefined;
+};
+export declare function WorkspaceDock({ primary, tabs, activeTab, onActiveTabChange, collapsed: collapsedProp, onCollapsedChange, headerAccessory, mobileLeadingControl, autoSaveId, defaultSize, minSize, maxSize, className, }: WorkspaceDockProps): import("react/jsx-runtime").JSX.Element;

package/dist/composer.d.ts

@@ -1,7 +1,11 @@
-export { A as Actions, s as AttachButton, v as Attachments, w as ChatComposerContextValue, x as ChatComposerController, c as ChatComposerMessages, y as CommandPalette, z as ComposerActionsProps, B as ComposerAttachButtonProps, D as ComposerCommandPaletteProps, C as ComposerControlLinks, E as ComposerControlState, F as ComposerControlsProps, G as ComposerDelivery, H as ComposerDraftState, J as ComposerFooterProps, K as ComposerFrameProps, L as ComposerHintProps, M as ComposerInputProps, P as ComposerModelPickerProps, Q as ComposerPauseButtonProps, R as ComposerRootProps, V as ComposerSendButtonProps, W as ComposerSubmitBlocker, X as ComposerSubmitMode, Y as ComposerSurfaceProps, g as ComposerTranscriptionControl, a as ComposerTranscriptionControlProps, h as ComposerTranscriptionMessages, Z as Confirmation, _ as Controls, $ as Footer, a0 as Frame, a1 as Help, a2 as Hint, a3 as Input, a4 as ModelPicker, O as OPEN_WORKSTREAM_CONTROL_EVENT, a5 as PauseButton, a6 as PausedState, a7 as RestoredResources, a8 as Root, a9 as SendButton, aa as Status, ab as Surface, ac as UseChatComposerControllerOptions, q as defaultChatComposerMessages, ad as useChatComposer, ae as useChatComposerController } from './composer-BMzimGTO.js';
-import 'react/jsx-runtime';
-import 'react';
-import '@opengeni/sdk';
-import './session-context-CAjlaeZb.js';
-import './use-composer-ClHy1rkL.js';
-import './use-file-attachments-BmT8WtqO.js';
+/**
+ * Advanced chat-composer framework. Import this subpath as a namespace:
+ *
+ * `import * as Composer from "@opengeni/react/composer"`.
+ */
+export { Actions, AttachButton, Attachments, CommandPalette, Confirmation, Controls, Footer, Frame, Help, Hint, Input, ModelPicker, OPEN_WORKSTREAM_CONTROL_EVENT, PauseButton, PausedState, RestoredResources, Root, SendButton, Status, Surface, defaultChatComposerMessages, useChatComposer, useChatComposerController, } from "./components/composer";
+export type { ChatComposerController, ChatComposerContextValue, ChatComposerMessages, ComposerActionsProps, ComposerAttachButtonProps, ComposerCommandPaletteProps, ComposerControlLinks, ComposerControlState, ComposerControlsProps, ComposerDelivery, ComposerDraftState, ComposerFooterProps, ComposerFrameProps, ComposerHintProps, ComposerInputProps, ComposerModelPickerProps, ComposerPauseButtonProps, ComposerRootProps, ComposerSendButtonProps, ComposerSubmitBlocker, ComposerSubmitMode, ComposerSurfaceProps, UseChatComposerControllerOptions, } from "./components/composer";
+export { ComposerTranscriptionControl } from "./components/composer-transcription-control";
+export type { ComposerTranscriptionControlProps, ComposerTranscriptionMessages, } from "./components/composer-transcription-control";
+export { useVoiceInput } from "./hooks/use-voice-input";
+export type { UseVoiceInputOptions, UseVoiceInputResult, VoiceInputStatus, } from "./hooks/use-voice-input";

package/dist/composer.js

@@ -22,12 +22,14 @@ import {
   Surface,
   defaultChatComposerMessages,
   useChatComposer,
-  useChatComposerController
-} from "./chunk-XVVQP7A4.js";
+  useChatComposerController,
+  useVoiceInput
+} from "./chunk-WY2QN2CX.js";
+import "./chunk-KZRUYCL4.js";
+import "./chunk-7CJOAW3V.js";
+import "./chunk-U255M5EZ.js";
 import "./chunk-TK7G6XLT.js";
-import "./chunk-4F2YLLHP.js";
-import "./chunk-HQFPO7VX.js";
-import "./chunk-M7X4JZOD.js";
+import "./chunk-4QOQ2DSR.js";
 export {
   Actions,
   AttachButton,
@@ -52,6 +54,7 @@ export {
   Surface,
   defaultChatComposerMessages,
   useChatComposer,
-  useChatComposerController
+  useChatComposerController,
+  useVoiceInput
 };
 //# sourceMappingURL=composer.js.map

package/dist/hooks/internal.d.ts

@@ -0,0 +1,46 @@
+import type { SessionEvent } from "@opengeni/sdk";
+import type { EmbeddedSessionEventClientLike } from "../client";
+export type AsyncListState<T> = {
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+/**
+ * Shared fetch + optional polling loop for the list/read hooks. Stale
+ * responses (superseded by a newer load or an unmount) are dropped.
+ */
+export declare function usePolledValue<T>(load: (signal?: AbortSignal) => Promise<T>, options?: {
+    pollIntervalMs?: number | undefined;
+    enabled?: boolean | undefined;
+}): AsyncListState<T>;
+export type MutationState = {
+    mutating: boolean;
+    mutationError: Error | null;
+    clearMutationError: () => void;
+};
+/**
+ * Shared async mutation runner for the write hooks. `run` resolves with the
+ * operation's value, or `null` after capturing the error in `mutationError`
+ * (callers then roll back optimistic state).
+ */
+export declare function useMutationRunner(identity?: unknown): MutationState & {
+    run: <T>(operation: () => Promise<T>) => Promise<T | null>;
+};
+export type SessionEventFeedOptions = {
+    /**
+     * Share an existing event log (from `useSessionEvents`) instead of opening
+     * a second stream. When omitted the hook tails the session's event stream
+     * itself, starting at the current `lastSequence`.
+     */
+    events?: SessionEvent[] | undefined;
+    enabled?: boolean | undefined;
+};
+/**
+ * Invoke `onEvent` for every session event matching `match` — the live-update
+ * primitive behind `useTurnQueue` and `useGoal`. Either watches a shared
+ * `events` log or tails the stream directly (reconnect handled by the SDK).
+ */
+export declare function useSessionEventTrigger(client: EmbeddedSessionEventClientLike, workspaceId: string, sessionId: string | null | undefined, match: (event: SessionEvent) => boolean, onEvent: (event: SessionEvent) => void, options?: SessionEventFeedOptions, reconcileBeforeLive?: (() => void | Promise<void>) | undefined): void;
+/** Debounce rapid event bursts into one trailing call (default 150ms). */
+export declare function useDebouncedCallback(callback: () => void, delayMs?: number): () => void;

package/dist/hooks/use-available-models.d.ts

@@ -0,0 +1,37 @@
+import type { WorkspaceModelCatalogModel } from "@opengeni/sdk";
+import { type PickerModelRow } from "../model-policy";
+import { type ClientOverride } from "../provider";
+export type UseAvailableModelsOptions = Pick<ClientOverride, "client"> & {
+    /** Refresh interval (ms). Off by default — the host model list rarely moves. */
+    pollIntervalMs?: number | undefined;
+    enabled?: boolean | undefined;
+};
+export type UseAvailableModelsResult = {
+    models: import("@opengeni/sdk").ClientModel[];
+    defaultModel: string | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+export type UseWorkspaceModelCatalogOptions = Pick<ClientOverride, "client"> & {
+    workspaceId: string | null;
+    pollIntervalMs?: number | undefined;
+    enabled?: boolean | undefined;
+};
+export type UseWorkspaceModelCatalogResult = {
+    models: WorkspaceModelCatalogModel[];
+    rows: PickerModelRow[];
+    defaultModel: string | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+/**
+ * The host-exposed model list for a <ModelPicker>: fetches the deployment's
+ * public client config (`GET /v1/config/client`) and surfaces the richer
+ * provider-grouped `models` plus the `defaultModel` the picker should preselect.
+ * Deployment-scoped, so it only needs the client (no workspace).
+ */
+export declare function useAvailableModels(options?: UseAvailableModelsOptions): UseAvailableModelsResult;
+/** Workspace-scoped catalog with selectability and billing-class picker rows. */
+export declare function useWorkspaceModelCatalog(options: UseWorkspaceModelCatalogOptions): UseWorkspaceModelCatalogResult;

package/dist/hooks/use-billing-usage.d.ts

@@ -0,0 +1,26 @@
+import type { BillingBalance, UsageEvent } from "@opengeni/sdk";
+import { type ClientOverride } from "../provider";
+export type UseBillingUsageOptions = Pick<ClientOverride, "client"> & {
+    /** Account to read. Defaults to the caller's default account server-side. */
+    accountId?: string | undefined;
+    /** Filter usage to one workspace. */
+    workspaceId?: string | undefined;
+    /** Refresh interval (ms) for live billing meters. Off by default. */
+    pollIntervalMs?: number | undefined;
+    enabled?: boolean | undefined;
+};
+export type UseBillingUsageResult = {
+    /** Prepaid credit balance (micro-USD), null until loaded. */
+    balance: BillingBalance | null;
+    /** Recent usage events (runs, tokens, cost, uploads, ...). */
+    usage: UsageEvent[];
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+/**
+ * Account billing usage: credit balance + recent usage events — the data
+ * behind per-call billing meters. Account-scoped, so it only needs the
+ * client; pass `workspaceId` to narrow usage to one workspace.
+ */
+export declare function useBillingUsage(options?: UseBillingUsageOptions): UseBillingUsageResult;

package/dist/hooks/use-codex-accounts.d.ts

@@ -0,0 +1,69 @@
+import type { CodexAccount, CodexAccountsResponse, CodexRotationSettings, SessionEvent } from "@opengeni/sdk";
+import { type ClientOverride } from "../provider";
+import { type SessionEventFeedOptions } from "./internal";
+/** Events that change which Codex account a session runs on (or just ran). */
+export declare function isCodexAccountEvent(event: Pick<SessionEvent, "type">): boolean;
+/**
+ * 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`
+ * is the optional mutation (absent ⇒ the indicator hides the switch affordance).
+ */
+export type CodexAccountsClientLike = {
+    listCodexAccounts: (workspaceId: string) => Promise<CodexAccountsResponse>;
+    getSession?: (workspaceId: string, sessionId: string) => Promise<{
+        codexPinnedCredentialId?: string | null;
+        codexLastCredentialId?: string | null;
+    }>;
+    pinSessionCodexAccount?: (workspaceId: string, sessionId: string, target: string) => Promise<{
+        pinned: string;
+    }>;
+    /** Optional (absent ⇒ the card hides live refresh): batched live /wham/usage refresh. */
+    refreshCodexUsage?: (workspaceId: string) => Promise<{
+        usage: Record<string, unknown>;
+    }>;
+};
+export type UseCodexAccountsOptions = ClientOverride & SessionEventFeedOptions & {
+    pollIntervalMs?: number | undefined;
+    /** Scope to a session so the hook resolves the pin + the effective account. */
+    sessionId?: string | undefined;
+    /** Override the client with one implementing `CodexAccountsClientLike`. */
+    codexClient?: CodexAccountsClientLike | undefined;
+};
+export type UseCodexAccountsResult = {
+    accounts: CodexAccount[];
+    /** The workspace ACTIVE account (used when a session is unpinned). */
+    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. */
+    effectiveAccountId: string | null;
+    /** The account the session's last turn ACTUALLY ran on (the "Running on:" source). */
+    lastAccountId: string | null;
+    settings: CodexRotationSettings;
+    loading: boolean;
+    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.
+     */
+    refreshUsage: () => Promise<boolean>;
+    /** 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. */
+    pin: (target: string) => Promise<boolean>;
+    pinning: boolean;
+    /** The target of the in-flight pin (for per-row spinner gating). */
+    pinningTarget: string | null;
+    mutationError: Error | null;
+};
+/**
+ * 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` / `turn.started` event trigger) + a `pin` mutation.
+ * Dual-consumer safe via the structural `CodexAccountsClientLike` surface.
+ */
+export declare function useCodexAccounts(options?: UseCodexAccountsOptions): UseCodexAccountsResult;

package/dist/{use-composer-ClHy1rkL.d.ts → hooks/use-composer.d.ts}

@@ -1,22 +1,12 @@
-import { SessionEvent, EffectiveControlResumeOption, ComposerDraft, ResourceRef, SendMessageInput, EffectiveSessionControl } from '@opengeni/sdk';
-import { a as EmbeddedSessionClientOverride } from './session-context-CAjlaeZb.js';
-
-type SessionEventFeedOptions = {
-    /**
-     * Share an existing event log (from `useSessionEvents`) instead of opening
-     * a second stream. When omitted the hook tails the session's event stream
-     * itself, starting at the current `lastSequence`.
-     */
-    events?: SessionEvent[] | undefined;
-    enabled?: boolean | undefined;
-};
-
-type ComposerSendExtras = Omit<SendMessageInput, "text" | "clientEventId">;
-type UseComposerOptions = EmbeddedSessionClientOverride & SessionEventFeedOptions & {
+import type { ComposerDraft, EffectiveControlResumeOption, EffectiveSessionControl, ResourceRef, SendMessageInput, SessionEvent } from "@opengeni/sdk";
+import { type EmbeddedSessionClientOverride } from "../session-context";
+import { type SessionEventFeedOptions } from "./internal";
+export type ComposerSendExtras = Omit<SendMessageInput, "text" | "clientEventId">;
+export type UseComposerOptions = EmbeddedSessionClientOverride & SessionEventFeedOptions & {
     /** Called with the exact accepted wire input after a successful send. */
     onSent?: ((text: string, input: SendMessageInput) => void) | undefined;
     /**
-     * Extra message fields (resources, tools, model, reasoningEffort) merged
+     * Extra message fields (resources, tools, model, reasoningEffort, latencyMode) merged
      * into every send. A function is evaluated at send time so it can read the
      * surrounding UI state (attachment pickers, model selectors, ...).
      */
@@ -34,7 +24,7 @@ type UseComposerOptions = EmbeddedSessionClientOverride & SessionEventFeedOption
     /** Disable remote composer-draft reads and writes for embedded hosts. */
     draftPersistence?: "durable" | "disabled" | undefined;
 };
-type ComposerState = {
+export type ComposerState = {
     value: string;
     setValue: (value: string) => void;
     /** Read the current draft synchronously before a destructive replacement. */
@@ -73,21 +63,25 @@ type ComposerState = {
  * more hostile than losing a typed message); each send carries a generated
  * `clientEventId` so retries stay idempotent server-side.
  */
-declare function useComposer(sessionId: string | null | undefined, options?: UseComposerOptions): ComposerState;
+export declare function useComposer(sessionId: string | null | undefined, options?: UseComposerOptions): ComposerState;
+/** Events that can atomically replace or clear this subject's durable draft. */
+export declare function isComposerDraftEvent(event: Pick<SessionEvent, "type">): boolean;
 /**
  * Default text for a file-only message (attachment(s) present, no typed draft).
  * Kept non-empty so the wire contract (`text: z.string().min(1)`) and the
  * worker's non-whitespace guard accept it; the attached files still ride in
  * `resources`. Exported for tests.
  */
-declare const FILE_ONLY_MESSAGE_TEXT = "(see attached files)";
+export declare const FILE_ONLY_MESSAGE_TEXT = "(see attached files)";
+/** Resolve possibly-deferred extras to a concrete bag (function evaluated now). */
+export declare function resolveSendExtras(extras: ComposerSendExtras | (() => ComposerSendExtras) | undefined): ComposerSendExtras;
 /**
  * Merge the draft text + idempotency key with caller-provided extras. The
  * text and clientEventId always win over extras. Exported for tests.
  */
-declare function composeSendInput(text: string, clientEventId: string, extras: ComposerSendExtras | (() => ComposerSendExtras) | undefined, bound?: Partial<SendMessageInput>): SendMessageInput;
+export declare function composeSendInput(text: string, clientEventId: string, extras: ComposerSendExtras | (() => ComposerSendExtras) | undefined, bound?: Partial<SendMessageInput>): SendMessageInput;
 /** Submit on plain Enter; Shift+Enter inserts a newline. Exported for tests. */
-declare function shouldSubmitOnKey(event: {
+export declare function shouldSubmitOnKey(event: {
     key: string;
     shiftKey: boolean;
     metaKey?: boolean;
@@ -97,9 +91,7 @@ declare function shouldSubmitOnKey(event: {
     };
 }): boolean;
 /** Cmd/Ctrl+Enter steers; ordinary Enter appends to the queue. */
-declare function shouldSteerOnKey(event: {
+export declare function shouldSteerOnKey(event: {
     metaKey?: boolean;
     ctrlKey?: boolean;
 }): boolean;
-
-export { type ComposerState as C, FILE_ONLY_MESSAGE_TEXT as F, type SessionEventFeedOptions as S, type UseComposerOptions as U, type ComposerSendExtras as a, shouldSubmitOnKey as b, composeSendInput as c, shouldSteerOnKey as s, useComposer as u };

package/dist/hooks/use-desktop-stream.d.ts

@@ -0,0 +1,43 @@
+import { type DesktopConnectionState, type DesktopRfbFactory, type DesktopStreamCapability } from "@opengeni/sdk";
+import { type RefObject } from "react";
+import { type DesktopWebSocketFactory } from "./use-relay-frame-stream";
+export type UseDesktopStreamOptions = {
+    /** The desktop cell of the negotiated capabilities (`capabilities.DesktopStream`). */
+    capability: DesktopStreamCapability | null;
+    /** The mount target. RFB (or the frame canvas) attaches here on connect. */
+    containerRef: RefObject<HTMLDivElement | null>;
+    /** 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. */
+    rfbFactory?: DesktopRfbFactory | undefined;
+    /** Custom socket factory for the `relay-frames` transport (tests). Defaults to
+     *  `new WebSocket(url)`. Mirrors `rfbFactory` for the frame renderer. */
+    webSocketFactory?: DesktopWebSocketFactory | undefined;
+};
+export type UseDesktopStreamResult = {
+    state: DesktopConnectionState;
+    error: Error | null;
+    /** Manual reconnect (e.g. after a securityfailure once a fresh URL arrives). */
+    reconnect: () => void;
+};
+/**
+ * Drive the noVNC RFB lifecycle from a `DesktopStreamCapability`, using the
+ * SDK's `desktop.ts` reducer + `desktopSocketUrl`. SSR-safe: the RFB import and
+ * the DOM attach happen inside `useEffect`, so a server render is a no-op and
+ * the component shows its placeholder until hydration.
+ *
+ * Read-only is enforced at three layers: `capability.mode` (server) →
+ * `interactive` prop → `RFB.viewOnly`. v1 always resolves to read-only. On a
+ * capability `url` change (a rotation), the old RFB disconnects and a fresh one
+ * connects to the new URL — a brief "desktop blink", acceptable on rollover.
+ *
+ * Transport dispatch: a Modal box negotiates `transport: "vnc-ws"` and drives the
+ * noVNC RFB below. A SELF-HOSTED machine negotiates `transport: "relay-frames"`
+ * (PNG-per-frame over the relay, view-only) — that path is delegated to
+ * `useRelayFrameStream`, which paints a `<canvas>`. Both hooks are ALWAYS called
+ * (rules of hooks); each is dormant for the other's transport, and we return the
+ * result of whichever owns the surface. The public interface is identical either
+ * way, so `DesktopViewer` is transport-agnostic.
+ */
+export declare function useDesktopStream(options: UseDesktopStreamOptions): UseDesktopStreamResult;