@beeuni/sdk 0.1.0

package/dist/react/use-runtime-reconnect.js

@@ -0,0 +1,248 @@
+'use client';
+import { useEffect, useRef } from 'react';
+import { getSupabaseAccessToken } from '../core/http/auth.js';
+import { CONNECTION_FAULT_GRACE_MS, getSessionHealth, isRuntimeReady, } from '../core/session/index.js';
+import { incrementSandboxFail, markInitialCheckDone, resetForServerSwitch, resetSandboxFail, setRuntimeHealth, setRuntimeCapabilities, setSandboxStatus, useSandboxConnectionStore, } from '../browser/stores/sandbox-connection-store.js';
+import { useServerStore } from '../browser/stores/server-store.js';
+import { isRuntimeGoneResponse, noteRuntimeGone } from '../core/session/runtime-gone.js';
+export const FAIL_THRESHOLD_FIRST = 5;
+export const FAIL_THRESHOLD_RECONNECT = 2;
+export const POLL_CONNECTED = 30_000;
+export const POLL_FAILING = 150;
+export const POLL_UNREACHABLE = 5_000;
+export const POLL_RECHECK = 1_000;
+export const POLL_PARKED = 15_000;
+export const CHECK_TIMEOUT = 20_000;
+export const RUNTIME_EVIDENCE_FRESH_MS = 15_000;
+export function shouldIgnoreProbeFailure(lastRuntimeEvidenceAt, now) {
+    if (lastRuntimeEvidenceAt === null)
+        return false;
+    return now - lastRuntimeEvidenceAt < RUNTIME_EVIDENCE_FRESH_MS;
+}
+export function shouldCountProbeFailure(input) {
+    if (input.hop === 'control_plane' || input.hop === 'upstream_port')
+        return false;
+    if (shouldIgnoreProbeFailure(input.lastRuntimeEvidenceAt, input.nowMs))
+        return false;
+    return true;
+}
+export function runtimeErrorFromHealth(health) {
+    return health?.boot_error ?? null;
+}
+export function isImmediateOfflineStatus(status) {
+    return status === 502 || status === 503 || status === 504;
+}
+export function isImmediateOfflineSignal(status, body) {
+    return isImmediateOfflineStatus(status) || /no service is responding|not reachable/i.test(body);
+}
+export function classifyProbeResult(result) {
+    if (result.status === 401 || result.status === 403) {
+        return { kind: 'auth-error' };
+    }
+    if (result.status === 503) {
+        return { kind: 'booting', health: result.health };
+    }
+    if (!result.ok) {
+        return {
+            kind: 'failure',
+            immediateOffline: isImmediateOfflineSignal(result.status, result.body),
+            hop: result.hop ?? null,
+            upstreamStatus: result.upstreamStatus ?? null,
+        };
+    }
+    return { kind: 'healthy', health: result.health };
+}
+export function computeFailureStatus(failCount, wasConnected, immediateOffline, failingForMs) {
+    if (failingForMs !== undefined && failingForMs < CONNECTION_FAULT_GRACE_MS)
+        return null;
+    if (immediateOffline)
+        return 'unreachable';
+    const threshold = wasConnected ? FAIL_THRESHOLD_RECONNECT : FAIL_THRESHOLD_FIRST;
+    return failCount >= threshold ? 'unreachable' : null;
+}
+export function shouldHoldHealthy(input) {
+    if (input.healthy !== true)
+        return false;
+    if (shouldIgnoreProbeFailure(input.lastRuntimeEvidenceAt, input.nowMs))
+        return true;
+    return input.nowMs - input.notReadySinceMs < CONNECTION_FAULT_GRACE_MS;
+}
+export function nextPollDelay(status, healthy, parked = false, failing = false) {
+    if (failing && status === 'connected')
+        return POLL_RECHECK;
+    if (status === 'connected' && healthy === false) {
+        return parked ? POLL_PARKED : POLL_FAILING;
+    }
+    if (status === 'connected')
+        return POLL_CONNECTED;
+    if (status === 'unreachable')
+        return POLL_UNREACHABLE;
+    return POLL_FAILING;
+}
+export function useRuntimeReconnect() {
+    const manualRetryNonce = useSandboxConnectionStore((state) => state.manualRetryNonce);
+    const timerRef = useRef(null);
+    const abortRef = useRef(null);
+    const isMountRef = useRef(true);
+    useEffect(() => {
+        void manualRetryNonce;
+        const isFirstMount = isMountRef.current;
+        isMountRef.current = false;
+        if (isFirstMount) {
+            resetForServerSwitch(useServerStore.getState().getActiveServerUrl() ?? undefined);
+        }
+        let alive = true;
+        let failingSince = null;
+        let notReadySince = null;
+        async function check() {
+            if (!alive)
+                return;
+            if (useSandboxConnectionStore.getState().streamDriven) {
+                scheduleNext();
+                return;
+            }
+            let url;
+            let token;
+            try {
+                url = useServerStore.getState().getActiveServerUrl();
+                if (!url) {
+                    scheduleNext();
+                    return;
+                }
+                token = await getSupabaseAccessToken();
+                if (!token) {
+                    scheduleNext();
+                    return;
+                }
+            }
+            catch {
+                if (alive)
+                    scheduleNext();
+                return;
+            }
+            abortRef.current?.abort();
+            const controller = new AbortController();
+            abortRef.current = controller;
+            let immediateOffline = false;
+            let failed = false;
+            let hop = null;
+            try {
+                const timer = setTimeout(() => controller.abort(), CHECK_TIMEOUT);
+                const result = await getSessionHealth(url, { signal: controller.signal });
+                clearTimeout(timer);
+                if (!alive)
+                    return;
+                const outcome = classifyProbeResult(result);
+                switch (outcome.kind) {
+                    case 'auth-error': {
+                        failed = true;
+                        immediateOffline = false;
+                        break;
+                    }
+                    case 'booting': {
+                        resetSandboxFail();
+                        failingSince = null;
+                        const parked = result.hop === 'control_plane';
+                        const now = Date.now();
+                        const { healthy, lastRuntimeEvidenceAt } = useSandboxConnectionStore.getState();
+                        if (parked && shouldIgnoreProbeFailure(lastRuntimeEvidenceAt, now))
+                            break;
+                        notReadySince ??= now;
+                        if (!parked && shouldHoldHealthy({ healthy, notReadySinceMs: notReadySince, nowMs: now, lastRuntimeEvidenceAt })) {
+                            break;
+                        }
+                        if (parked) {
+                            setRuntimeHealth(false, outcome.health?.version, null, { parked: true });
+                        }
+                        else {
+                            setSandboxStatus('connected');
+                            setRuntimeCapabilities(outcome.health?.capabilities ?? null);
+                            setRuntimeHealth(false, outcome.health?.version, runtimeErrorFromHealth(outcome.health));
+                        }
+                        break;
+                    }
+                    case 'failure': {
+                        failed = true;
+                        immediateOffline = outcome.immediateOffline;
+                        hop = outcome.hop;
+                        if (isRuntimeGoneResponse(result.status, result.body))
+                            noteRuntimeGone(url);
+                        break;
+                    }
+                    case 'healthy': {
+                        resetSandboxFail();
+                        failingSince = null;
+                        const ready = isRuntimeReady(outcome.health);
+                        if (ready) {
+                            notReadySince = null;
+                        }
+                        else {
+                            const now = Date.now();
+                            notReadySince ??= now;
+                            const { healthy, lastRuntimeEvidenceAt } = useSandboxConnectionStore.getState();
+                            if (shouldHoldHealthy({ healthy, notReadySinceMs: notReadySince, nowMs: now, lastRuntimeEvidenceAt })) {
+                                setSandboxStatus('connected');
+                                break;
+                            }
+                        }
+                        setSandboxStatus('connected');
+                        setRuntimeCapabilities(outcome.health?.capabilities ?? null);
+                        setRuntimeHealth(ready, outcome.health?.version, runtimeErrorFromHealth(outcome.health));
+                        break;
+                    }
+                }
+            }
+            catch {
+                if (!alive)
+                    return;
+                failed = true;
+                immediateOffline = false;
+                hop = null;
+            }
+            finally {
+                if (failed &&
+                    !shouldCountProbeFailure({
+                        hop,
+                        lastRuntimeEvidenceAt: useSandboxConnectionStore.getState().lastRuntimeEvidenceAt,
+                        nowMs: Date.now(),
+                    })) {
+                    failed = false;
+                }
+                if (failed) {
+                    incrementSandboxFail();
+                    const now = Date.now();
+                    failingSince ??= now;
+                    const { failCount, wasConnected } = useSandboxConnectionStore.getState();
+                    const nextStatus = computeFailureStatus(failCount, wasConnected, immediateOffline, now - failingSince);
+                    if (nextStatus)
+                        setSandboxStatus(nextStatus);
+                }
+                if (alive) {
+                    markInitialCheckDone();
+                    scheduleNext();
+                }
+            }
+        }
+        function scheduleNext() {
+            if (!alive)
+                return;
+            if (timerRef.current)
+                clearTimeout(timerRef.current);
+            const { status, healthy, parked } = useSandboxConnectionStore.getState();
+            const failing = failingSince !== null || (notReadySince !== null && healthy === true);
+            timerRef.current = setTimeout(check, nextPollDelay(status, healthy, parked, failing));
+        }
+        check();
+        const unsubscribeStream = useSandboxConnectionStore.subscribe((state, previous) => {
+            if (previous.streamDriven && !state.streamDriven && alive)
+                void check();
+        });
+        return () => {
+            unsubscribeStream();
+            alive = false;
+            abortRef.current?.abort();
+            if (timerRef.current)
+                clearTimeout(timerRef.current);
+        };
+    }, [manualRetryNonce]);
+}

package/dist/react/use-runtime-supports.d.ts

@@ -0,0 +1,2 @@
+import { type RuntimeCapability } from '../core/session/health.js';
+export declare function useRuntimeSupports(capability: RuntimeCapability): boolean;

package/dist/react/use-runtime-supports.js

@@ -0,0 +1,5 @@
+import { useSandboxConnectionStore } from '../browser/stores/sandbox-connection-store.js';
+import { runtimeSupports } from '../core/session/health.js';
+export function useRuntimeSupports(capability) {
+    return useSandboxConnectionStore((state) => runtimeSupports(state.runtimeCapabilities, capability));
+}

package/dist/react/use-sandbox-image.d.ts

@@ -0,0 +1,33 @@
+export declare const IMAGE_AUTO_LOAD_LIMIT_BYTES: number;
+type SandboxImagePhase = 'probing' | 'load' | 'tap-to-load' | 'error';
+export declare function decideImageLoad({ contentLength, limitBytes, }: {
+    contentLength: number | null;
+    limitBytes: number;
+}): 'load' | 'tap-to-load';
+export declare function parseContentLength(header: string | null): number | null;
+export declare function formatMegabytes(bytes: number): string;
+export interface ProbeCache {
+    has(url: string): boolean;
+    get(url: string): number | null | undefined;
+    set(url: string, contentLength: number | null): void;
+    size(): number;
+}
+export declare function createProbeCache(limit: number): ProbeCache;
+export declare function useSandboxImage({ sandboxUrl, filePath, enabled, }: {
+    sandboxUrl: string | undefined;
+    filePath: string;
+    enabled: boolean;
+}): {
+    phase: SandboxImagePhase;
+    source: {
+        uri: string;
+        headers: {
+            Authorization: string;
+        } | undefined;
+    } | undefined;
+    sizeBytes: number | null;
+    attempt: number;
+    loadAnyway: () => void;
+    handleError: () => void;
+};
+export {};

package/dist/react/use-sandbox-image.js

@@ -0,0 +1,119 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { authenticatedFetch, getAuthToken } from '../core/http/auth.js';
+export const IMAGE_AUTO_LOAD_LIMIT_BYTES = 8 * 1024 * 1024;
+export function decideImageLoad({ contentLength, limitBytes, }) {
+    if (contentLength === null)
+        return 'load';
+    return contentLength > limitBytes ? 'tap-to-load' : 'load';
+}
+export function parseContentLength(header) {
+    if (header === null)
+        return null;
+    const trimmed = header.trim();
+    if (!/^\d+$/.test(trimmed))
+        return null;
+    const value = Number(trimmed);
+    return Number.isSafeInteger(value) ? value : null;
+}
+export function formatMegabytes(bytes) {
+    const mb = bytes / (1024 * 1024);
+    return mb < 10 ? `${mb.toFixed(1)} MB` : `${Math.round(mb)} MB`;
+}
+export function createProbeCache(limit) {
+    const entries = new Map();
+    return {
+        has: (url) => entries.has(url),
+        get(url) {
+            if (!entries.has(url))
+                return undefined;
+            const value = entries.get(url);
+            entries.delete(url);
+            entries.set(url, value);
+            return value;
+        },
+        set(url, contentLength) {
+            entries.delete(url);
+            entries.set(url, contentLength);
+            while (entries.size > limit) {
+                const oldest = entries.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                entries.delete(oldest);
+            }
+        },
+        size: () => entries.size,
+    };
+}
+const imageProbeCache = createProbeCache(200);
+export function useSandboxImage({ sandboxUrl, filePath, enabled, }) {
+    const rawUrl = sandboxUrl && filePath ? `${sandboxUrl}/file/raw?path=${encodeURIComponent(filePath)}` : null;
+    const [phase, setPhase] = useState('probing');
+    const [token, setToken] = useState(null);
+    const [sizeBytes, setSizeBytes] = useState(null);
+    const [attempt, setAttempt] = useState(0);
+    const retriedRef = useRef(false);
+    const aliveRef = useRef(true);
+    useEffect(() => {
+        aliveRef.current = true;
+        return () => {
+            aliveRef.current = false;
+        };
+    }, []);
+    useEffect(() => {
+        if (!enabled || !rawUrl)
+            return;
+        const controller = new AbortController();
+        let cancelled = false;
+        retriedRef.current = false;
+        setPhase('probing');
+        (async () => {
+            const authToken = await getAuthToken().catch(() => null);
+            if (cancelled)
+                return;
+            let contentLength = null;
+            if (imageProbeCache.has(rawUrl)) {
+                contentLength = imageProbeCache.get(rawUrl) ?? null;
+            }
+            else {
+                try {
+                    const res = await authenticatedFetch(rawUrl, { method: 'HEAD', signal: controller.signal }, { retryOnAuthError: false, timeoutMs: null });
+                    if (res.ok) {
+                        contentLength = parseContentLength(res.headers.get('content-length'));
+                        imageProbeCache.set(rawUrl, contentLength);
+                    }
+                }
+                catch {
+                }
+            }
+            if (cancelled)
+                return;
+            setToken(authToken);
+            setSizeBytes(contentLength);
+            setPhase(decideImageLoad({ contentLength, limitBytes: IMAGE_AUTO_LOAD_LIMIT_BYTES }));
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
+    }, [enabled, rawUrl]);
+    const loadAnyway = useCallback(() => setPhase('load'), []);
+    const handleError = useCallback(() => {
+        if (retriedRef.current) {
+            setPhase('error');
+            return;
+        }
+        retriedRef.current = true;
+        getAuthToken()
+            .catch(() => null)
+            .then((fresh) => {
+            if (!aliveRef.current)
+                return;
+            setToken(fresh);
+            setAttempt((n) => n + 1);
+        });
+    }, []);
+    const source = useMemo(() => rawUrl
+        ? { uri: rawUrl, headers: token ? { Authorization: `Bearer ${token}` } : undefined }
+        : undefined, [rawUrl, token]);
+    return { phase, source, sizeBytes, attempt, loadAnyway, handleError };
+}

package/dist/react/use-session-audit.d.ts

@@ -0,0 +1,4 @@
+import { type SessionAudit } from '../core/rest/projects-client/sessions.js';
+export declare function readSessionAudit(projectId: string | undefined, sessionId: string | undefined, cached: SessionAudit | undefined, limit: number, options?: {
+    showErrors?: boolean;
+}): Promise<SessionAudit>;

package/dist/react/use-session-audit.js

@@ -0,0 +1,25 @@
+'use client';
+import { claimOpenBundle, openBundleAudit } from '../core/session/open-bundle.js';
+import { getSessionAudit } from '../core/rest/projects-client/sessions.js';
+const EMPTY_AUDIT = {
+    session_id: '',
+    agent: null,
+    audit_access: false,
+    count: 0,
+    actions: [],
+};
+export async function readSessionAudit(projectId, sessionId, cached, limit, options) {
+    if (!projectId || !sessionId)
+        return cached ?? EMPTY_AUDIT;
+    const claimed = cached === undefined ? claimOpenBundle(projectId, sessionId) : null;
+    if (claimed) {
+        const bundle = await claimed;
+        const bundled = bundle ? openBundleAudit(bundle) : null;
+        if (bundled)
+            return bundled;
+    }
+    return getSessionAudit(projectId, sessionId, limit, {
+        includeEvents: false,
+        showErrors: options?.showErrors,
+    });
+}

package/dist/react/use-session-message-authors.d.ts

@@ -0,0 +1 @@
+export declare function useSessionMessageAuthors(projectId: string | null | undefined, sessionId: string | null | undefined, revision: number | string): import("@tanstack/react-query").UseQueryResult<import("../index.js").SessionMessageAuthors, Error>;

package/dist/react/use-session-message-authors.js

@@ -0,0 +1,14 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getSessionMessageAuthors } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export function useSessionMessageAuthors(projectId, sessionId, revision) {
+    return useQuery({
+        queryKey: [...qk.project.sessionMessageAuthors(projectId ?? '', sessionId ?? ''), revision],
+        queryFn: () => getSessionMessageAuthors(projectId, sessionId),
+        enabled: !!projectId && !!sessionId,
+        placeholderData: (previous) => previous,
+        ...contract('inventory'),
+    });
+}

package/dist/react/use-session-messages.d.ts

@@ -0,0 +1,11 @@
+import { type MessageWithParts } from '../browser/stores/sync-store.js';
+export interface SessionMessagesSource {
+    projectId: string;
+    sessionId: string;
+    runtimeSessionId?: string | null;
+    opencodeSessionId?: string | null;
+}
+export interface SessionMessagesOptions {
+    throttleMs?: number;
+}
+export declare function useSessionMessages(session: SessionMessagesSource, options?: SessionMessagesOptions): MessageWithParts[];

package/dist/react/use-session-messages.js

@@ -0,0 +1,62 @@
+'use client';
+import { useEffect, useMemo, useState } from 'react';
+import { useSyncStore } from '../browser/stores/sync-store.js';
+import { messagesBeforeRewind } from '../core/session/rewind.js';
+import { selectSessionRows, useReadableSessionId } from './session-transcript-subscription.js';
+const EMPTY_ROWS = [];
+export function useSessionMessages(session, options = {}) {
+    const throttleMs = options.throttleMs && options.throttleMs > 0 ? options.throttleMs : 0;
+    const ocSessionId = session.runtimeSessionId ?? session.opencodeSessionId ?? '';
+    const readableSessionId = useReadableSessionId(ocSessionId, `${session.projectId}/${session.sessionId}`);
+    const select = (state) => readableSessionId ? selectSessionRows(state, readableSessionId) : EMPTY_ROWS;
+    const liveRows = useSyncStore((state) => (throttleMs ? null : select(state)));
+    const pacedRows = usePacedRows(readableSessionId, throttleMs);
+    const rows = liveRows ?? pacedRows;
+    const rewind = useSyncStore((state) => state.sessionRevert[ocSessionId] ?? null);
+    return useMemo(() => messagesBeforeRewind(rows, rewind), [rows, rewind]);
+}
+function usePacedRows(readableSessionId, throttleMs) {
+    const read = () => readableSessionId ? selectSessionRows(useSyncStore.getState(), readableSessionId) : EMPTY_ROWS;
+    const [state, setState] = useState(() => ({ id: readableSessionId, rows: read() }));
+    useEffect(() => {
+        if (!throttleMs)
+            return;
+        let lastShownAt = -Infinity;
+        let timer = null;
+        let shown = null;
+        const now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
+        const flush = () => {
+            timer = null;
+            const rows = read();
+            if (rows === shown)
+                return;
+            shown = rows;
+            lastShownAt = now();
+            setState({ id: readableSessionId, rows });
+        };
+        const initial = read();
+        shown = initial;
+        setState((prev) => prev.id === readableSessionId && prev.rows === initial
+            ? prev
+            : { id: readableSessionId, rows: initial });
+        const unsubscribe = useSyncStore.subscribe(() => {
+            if (read() === shown)
+                return;
+            const wait = throttleMs - (now() - lastShownAt);
+            if (wait <= 0) {
+                if (timer !== null)
+                    clearTimeout(timer);
+                flush();
+            }
+            else if (timer === null) {
+                timer = setTimeout(flush, wait);
+            }
+        });
+        return () => {
+            unsubscribe();
+            if (timer !== null)
+                clearTimeout(timer);
+        };
+    }, [readableSessionId, throttleMs]);
+    return state.id === readableSessionId ? state.rows : read();
+}

package/dist/react/use-session-model-selection.d.ts

@@ -0,0 +1,8 @@
+import { type RuntimeLocal, type UseRuntimeLocalOptions } from './use-opencode-local.js';
+import { type UseModelDefaults } from './use-model-defaults.js';
+export interface SessionModelSelection extends RuntimeLocal {
+    model: RuntimeLocal['model'] & {
+        defaults: UseModelDefaults;
+    };
+}
+export declare function useSessionModelSelection(options: UseRuntimeLocalOptions): SessionModelSelection;

package/dist/react/use-session-model-selection.js

@@ -0,0 +1,20 @@
+'use client';
+import { useRuntimeLocal, } from './use-opencode-local.js';
+import { useModelDefaults, } from './use-model-defaults.js';
+import { useBeeuniRouteProjectId } from './route-project.js';
+export function useSessionModelSelection(options) {
+    const projectId = useBeeuniRouteProjectId();
+    const defaults = useModelDefaults(projectId);
+    const base = useRuntimeLocal({
+        ...options,
+        freeTier: options.freeTier ?? defaults.freeTier,
+        resolveServerDefault: options.resolveServerDefault ?? defaults.resolveDefaultFor,
+    });
+    return {
+        ...base,
+        model: {
+            ...base.model,
+            defaults,
+        },
+    };
+}

package/dist/react/use-session-model-usage.d.ts

@@ -0,0 +1 @@
+export declare function useSessionModelUsage(projectId: string | null | undefined, sessionId: string | null | undefined): import("@tanstack/react-query").UseQueryResult<import("../index.js").SessionModelUsage, Error>;

package/dist/react/use-session-model-usage.js

@@ -0,0 +1,13 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getSessionModelUsage } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export function useSessionModelUsage(projectId, sessionId) {
+    return useQuery({
+        queryKey: qk.project.sessionModelUsage(projectId ?? '', sessionId ?? ''),
+        queryFn: () => getSessionModelUsage(projectId, sessionId),
+        enabled: !!projectId && !!sessionId,
+        ...contract('inventory'),
+    });
+}

package/dist/react/use-session-participants.d.ts

@@ -0,0 +1,4 @@
+import { type SessionParticipants } from '../core/rest/projects-client/index.js';
+export declare function useSessionParticipants(projectId: string | undefined, sessionId: string | undefined, options?: {
+    enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<SessionParticipants, Error>;

package/dist/react/use-session-participants.js

@@ -0,0 +1,13 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getSessionParticipants } from '../core/rest/projects-client/index.js';
+import { contract } from './query-contracts.js';
+import { qk } from './query-keys.js';
+export function useSessionParticipants(projectId, sessionId, options) {
+    return useQuery({
+        queryKey: qk.project.sessionParticipants(projectId ?? '', sessionId ?? ''),
+        queryFn: () => getSessionParticipants(projectId, sessionId),
+        enabled: Boolean(projectId) && Boolean(sessionId) && (options?.enabled ?? true),
+        ...contract('inventory'),
+    });
+}

package/dist/react/use-session-phase.d.ts

@@ -0,0 +1,8 @@
+import type { SessionPhase } from './use-session.js';
+export declare function derivePhase(input: {
+    terminal: boolean;
+    startError: unknown;
+    runtimeError: unknown;
+    startSettled: boolean;
+    switched: boolean;
+}): SessionPhase;

package/dist/react/use-session-phase.js

@@ -0,0 +1,9 @@
+export function derivePhase(input) {
+    if (input.terminal || input.startError)
+        return 'error';
+    if (input.runtimeError && input.startSettled)
+        return 'error';
+    if (input.runtimeError)
+        return 'starting';
+    return input.switched ? 'ready' : 'starting';
+}

package/dist/react/use-session-picks.d.ts

@@ -0,0 +1,13 @@
+import type { ModelKey } from './use-model-store.js';
+export interface SessionPicks {
+    model: ModelKey | null;
+    agent: string | null;
+    variant: string | null;
+    setModel: (model: ModelKey | null) => void;
+    setAgent: (agent: string | null) => void;
+    setVariant: (variant: string | null) => void;
+}
+export type SessionPickValues = Pick<SessionPicks, 'model' | 'agent' | 'variant'>;
+export declare const EMPTY_SESSION_PICKS: SessionPickValues;
+export declare function parseSessionPicks(raw: string | null | undefined): SessionPickValues;
+export declare function useSessionPicks(sessionId: string): SessionPicks;