@kortix/sdk 0.9.98

package/dist/react/use-question-self-heal.js

@@ -0,0 +1,95 @@
+'use client';
+import { useEffect, useMemo, useRef } from 'react';
+import { getClient } from '../opencode/client.js';
+import { useOpenCodePendingStore } from '../state/opencode-pending-store.js';
+/**
+ * True when any assistant message has a `question` tool part still
+ * running/pending — the signal `useQuestionSelfHeal` reacts to. Pure so it's
+ * independently testable without rendering the hook.
+ */
+export function hasRunningQuestionTool(messages) {
+    if (!messages)
+        return false;
+    return messages.some((m) => {
+        if (m.info.role !== 'assistant')
+            return false;
+        return m.parts.some((p) => {
+            if (p.type !== 'tool')
+                return false;
+            const tool = p;
+            if (tool.tool !== 'question')
+                return false;
+            return tool.state.status === 'running' || tool.state.status === 'pending';
+        });
+    });
+}
+/**
+ * Self-heals a missed `question.asked` SSE event: when a `question` tool part
+ * is rendering as running/pending but the pending-request store has nothing
+ * for this session, re-hydrate from `question.list()`.
+ *
+ * This is a LIVE-CONNECTION safety net, distinct from `useOpenCodeEventStream`'s
+ * reconnect-gap hydration (which only re-hydrates questions/permissions after
+ * an SSE gap >5s): it covers a `question.asked` event being dropped, or racing
+ * the `message.part.updated` event that renders the tool as running, while the
+ * stream stays connected the whole time — the first `question.list()` call can
+ * itself race the backend's request creation and return an empty list, so this
+ * keeps polling (every 2s, rate-limited to one in-flight call every 1.5s) for
+ * as long as the tool shows running with nothing pending, and stops the moment
+ * a pending question shows up (from either this poll or the SSE event finally
+ * arriving).
+ */
+export function useQuestionSelfHeal(sessionId, messages, options = {}) {
+    const { enabled = true, isSuppressed } = options;
+    const addQuestion = useOpenCodePendingStore((s) => s.addQuestion);
+    const pendingCount = useOpenCodePendingStore((s) => Object.values(s.questions).filter((q) => q.sessionID === sessionId && !isSuppressed?.(q.id))
+        .length);
+    const running = useMemo(() => hasRunningQuestionTool(messages), [messages]);
+    const inFlightRef = useRef(false);
+    const lastAtRef = useRef(0);
+    useEffect(() => {
+        if (!enabled || !running || pendingCount > 0)
+            return;
+        let cancelled = false;
+        const hydrate = () => {
+            if (inFlightRef.current || cancelled)
+                return;
+            const now = Date.now();
+            if (now - lastAtRef.current < 1500)
+                return;
+            // Acquire the client lazily: during the sandbox-loading window
+            // getClient() throws "Server URL not ready". Skip this tick and let the
+            // interval retry once the runtime URL is pinned — never throw here.
+            let client;
+            try {
+                client = getClient();
+            }
+            catch {
+                return;
+            }
+            inFlightRef.current = true;
+            lastAtRef.current = now;
+            void client.question
+                .list()
+                .then((res) => {
+                if (!res.data || cancelled)
+                    return;
+                res.data.forEach((q) => {
+                    if (!q?.id || isSuppressed?.(q.id))
+                        return;
+                    addQuestion(q);
+                });
+            })
+                .finally(() => {
+                inFlightRef.current = false;
+            });
+        };
+        hydrate();
+        const timer = setInterval(hydrate, 2000);
+        return () => {
+            cancelled = true;
+            clearInterval(timer);
+        };
+    }, [enabled, running, pendingCount, addQuestion, isSuppressed]);
+}
+//# sourceMappingURL=use-question-self-heal.js.map

package/dist/react/use-question-self-heal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-question-self-heal.js","sourceRoot":"","sources":["../../src/react/use-question-self-heal.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+export type RuntimePhase = 'connecting' | 'booting' | 'ready' | 'unreachable';
+/**
+ * Coarse, render-friendly runtime connection phase for boot/reconnect UI. Reads
+ * the SDK's connection store — the host never touches it directly. `useSession`
+ * also returns this as `runtimePhase`; use this standalone hook when you want the
+ * phase without a full session (e.g. a lightweight status pill).
+ */
+export declare function useRuntimePhase(): RuntimePhase;
+//# sourceMappingURL=use-runtime-phase.d.ts.map

package/dist/react/use-runtime-phase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-runtime-phase.d.ts","sourceRoot":"","sources":["../../src/react/use-runtime-phase.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,SAAS,GAAG,OAAO,GAAG,aAAa,CAAC;AAE9E;;;;;GAKG;AACH,wBAAgB,eAAe,IAAI,YAAY,CAO9C"}

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

@@ -0,0 +1,20 @@
+'use client';
+import { useSandboxConnectionStore } from '../state/sandbox-connection-store.js';
+/**
+ * Coarse, render-friendly runtime connection phase for boot/reconnect UI. Reads
+ * the SDK's connection store — the host never touches it directly. `useSession`
+ * also returns this as `runtimePhase`; use this standalone hook when you want the
+ * phase without a full session (e.g. a lightweight status pill).
+ */
+export function useRuntimePhase() {
+    const status = useSandboxConnectionStore((s) => s.status);
+    const healthy = useSandboxConnectionStore((s) => s.healthy);
+    if (status === 'unreachable')
+        return 'unreachable';
+    if (healthy === true)
+        return 'ready';
+    if (status === 'connected')
+        return 'booting'; // reachable, OpenCode still warming
+    return 'connecting';
+}
+//# sourceMappingURL=use-runtime-phase.js.map

package/dist/react/use-runtime-phase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-runtime-phase.js","sourceRoot":"","sources":["../../src/react/use-runtime-phase.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAI9E;;;;;GAKG;AACH,MAAM,UAAU,eAAe;IAC7B,MAAM,MAAM,GAAG,yBAAyB,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAC1D,MAAM,OAAO,GAAG,yBAAyB,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;IAC5D,IAAI,MAAM,KAAK,aAAa;QAAE,OAAO,aAAa,CAAC;IACnD,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,OAAO,CAAC;IACrC,IAAI,MAAM,KAAK,WAAW;QAAE,OAAO,SAAS,CAAC,CAAC,oCAAoC;IAClF,OAAO,YAAY,CAAC;AACtB,CAAC"}

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

@@ -0,0 +1,90 @@
+import { type SessionHealthResponse } from '../session/index.js';
+import { type SandboxConnectionStatus } from '../state/sandbox-connection-store.js';
+/**
+ * Number of consecutive failures before marking as unreachable
+ * when this is the FIRST connection (never been connected).
+ * Set high enough to ride through transient proxy startup delays.
+ */
+export declare const FAIL_THRESHOLD_FIRST = 5;
+/**
+ * For reconnection (was connected, then failed) — require two consecutive
+ * failures before declaring the instance unreachable. The first miss drops
+ * into a lightweight reconnecting state so transient timeouts don't kick the
+ * user to an offline/error UI.
+ */
+export declare const FAIL_THRESHOLD_RECONNECT = 2;
+/** Interval between health checks (ms) */
+export declare const POLL_CONNECTED = 30000;
+export declare const POLL_FAILING = 150;
+export declare const POLL_UNREACHABLE = 5000;
+export declare const CHECK_TIMEOUT = 20000;
+/** Statuses whose HTTP response itself signals "nothing is home" — no threshold needed. */
+export declare function isImmediateOfflineStatus(status: number): boolean;
+/**
+ * Whether a resolved-but-failed probe response should be treated as an
+ * immediate "unreachable" signal rather than counted against the normal
+ * failure threshold — either a proxy-dead HTTP status, or a body that
+ * explicitly says no service answered.
+ */
+export declare function isImmediateOfflineSignal(status: number, body: string): boolean;
+/**
+ * The result of interpreting one resolved `getSessionHealth` response. Pure —
+ * given the same `SessionHealthResult` shape it always classifies the same
+ * way, independent of the store or the network. A thrown/aborted probe
+ * (network error, `CHECK_TIMEOUT` abort) never reaches this function — the
+ * hook folds those into `{ kind: 'failure', immediateOffline: false }` itself,
+ * since there is no HTTP status/body to classify.
+ */
+export type ProbeOutcome = {
+    kind: 'auth-error';
+} | {
+    kind: 'booting';
+    health: SessionHealthResponse | null;
+} | {
+    kind: 'failure';
+    immediateOffline: boolean;
+} | {
+    kind: 'healthy';
+    health: SessionHealthResponse | null;
+};
+export interface ProbeResultLike {
+    status: number;
+    ok: boolean;
+    health: SessionHealthResponse | null;
+    body: string;
+}
+export declare function classifyProbeResult(result: ProbeResultLike): ProbeOutcome;
+/**
+ * Threshold counting — the one piece of state this machine actually needs to
+ * decide a transition. `failCount` is the count AFTER the current failure has
+ * been recorded (matches `incrementSandboxFail()` semantics: increment, then
+ * read). Returns the next status, or `null` for "no status change" (still
+ * below threshold on a first-ever connection, which stays in whatever status
+ * it already had — normally "connecting").
+ */
+export declare function computeFailureStatus(failCount: number, wasConnected: boolean, immediateOffline: boolean): SandboxConnectionStatus | null;
+/**
+ * Next poll interval, purely a function of the current store status/healthy
+ * pair — fast while anything is unresolved or unhealthy, slow once truly
+ * settled into "connected and healthy".
+ */
+export declare function nextPollDelay(status: SandboxConnectionStatus, healthy: boolean | null): number;
+/**
+ * useRuntimeReconnect — monitors the active session's runtime reachability
+ * mid-session (see `react/opencode.ts` for how this fits alongside the
+ * server-truth boot readiness and the SSE heartbeat).
+ *
+ * Probes `getSessionHealth` (the SDK's `/kortix/health`) and maps the result
+ * into the shared `sandbox-connection-store`. Behaviour:
+ *   - On first failure, immediately switches to fast polling.
+ *   - If the user was previously connected, the first failure moves to
+ *     "connecting" and the second consecutive failure marks unreachable.
+ *   - If it's the first connection, requires FAIL_THRESHOLD_FIRST failures.
+ *
+ * The transition logic itself (`classifyProbeResult`, `computeFailureStatus`,
+ * `nextPollDelay`) is pure and exported above — this hook is thin glue that
+ * wires those decisions to a `setTimeout` loop and the store's action
+ * functions, since the repo has no harness to render-test a hook directly.
+ */
+export declare function useRuntimeReconnect(): void;
+//# sourceMappingURL=use-runtime-reconnect.d.ts.map

package/dist/react/use-runtime-reconnect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-runtime-reconnect.d.ts","sourceRoot":"","sources":["../../src/react/use-runtime-reconnect.ts"],"names":[],"mappings":"AAIA,OAAO,EAAoC,KAAK,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAC1F,OAAO,EASL,KAAK,uBAAuB,EAC7B,MAAM,mCAAmC,CAAC;AAG3C;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAE1C,0CAA0C;AAC1C,eAAO,MAAM,cAAc,QAAS,CAAC;AAMrC,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,eAAO,MAAM,gBAAgB,OAAQ,CAAC;AAEtC,eAAO,MAAM,aAAa,QAAS,CAAC;AAEpC,2FAA2F;AAC3F,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9E;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI,CAAA;CAAE,GACzD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,gBAAgB,EAAE,OAAO,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI,CAAA;CAAE,CAAC;AAE9D,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,eAAe,GAAG,YAAY,CAqBzE;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,OAAO,EACrB,gBAAgB,EAAE,OAAO,GACxB,uBAAuB,GAAG,IAAI,CAOhC;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,uBAAuB,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,MAAM,CAQ9F;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,SAoIlC"}

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

@@ -0,0 +1,234 @@
+'use client';
+import { useEffect, useRef } from 'react';
+import { getSupabaseAccessToken } from '../platform/auth.js';
+import { getSessionHealth, isRuntimeReady } from '../session/index.js';
+import { incrementSandboxFail, markInitialCheckDone, resetForServerSwitch, resetSandboxFail, setOpenCodeHealth, setSandboxStatus, setSandboxVersion, useSandboxConnectionStore, } from '../state/sandbox-connection-store.js';
+import { useServerStore } from '../state/server-store.js';
+/**
+ * Number of consecutive failures before marking as unreachable
+ * when this is the FIRST connection (never been connected).
+ * Set high enough to ride through transient proxy startup delays.
+ */
+export const FAIL_THRESHOLD_FIRST = 5;
+/**
+ * For reconnection (was connected, then failed) — require two consecutive
+ * failures before declaring the instance unreachable. The first miss drops
+ * into a lightweight reconnecting state so transient timeouts don't kick the
+ * user to an offline/error UI.
+ */
+export const FAIL_THRESHOLD_RECONNECT = 2;
+/** Interval between health checks (ms) */
+export const POLL_CONNECTED = 30_000; // 30s when healthy
+// Tight cadence while a sandbox is booting/unhealthy. This is the gate between
+// "sandbox active" and "OpenCode healthy" AND the enable-gate for the opencode
+// session list — so every extra interval is visible dead time after the backend
+// is already ready. 150ms keeps the healthy flip (and the session-list start)
+// tracking actual daemon readiness tightly; the health probe is a cheap GET.
+export const POLL_FAILING = 150;
+export const POLL_UNREACHABLE = 5_000; // 5s when confirmed unreachable
+export const CHECK_TIMEOUT = 20_000;
+/** Statuses whose HTTP response itself signals "nothing is home" — no threshold needed. */
+export function isImmediateOfflineStatus(status) {
+    return status === 502 || status === 503 || status === 504;
+}
+/**
+ * Whether a resolved-but-failed probe response should be treated as an
+ * immediate "unreachable" signal rather than counted against the normal
+ * failure threshold — either a proxy-dead HTTP status, or a body that
+ * explicitly says no service answered.
+ */
+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) {
+        // Treat auth errors like any other failure — respect the threshold
+        // instead of immediately marking unreachable. During transitions (e.g.
+        // provisioning → dashboard), the proxy may briefly return 401 before auth
+        // propagates.
+        return { kind: 'auth-error' };
+    }
+    if (result.status === 503) {
+        // OpenCode still booting behind an already-live sandbox proxy — this is
+        // progress, not failure: reset the fail counter and report "connected"
+        // (sandbox is up) with `healthy: false` (OpenCode isn't yet).
+        return { kind: 'booting', health: result.health };
+    }
+    if (!result.ok) {
+        return { kind: 'failure', immediateOffline: isImmediateOfflineSignal(result.status, result.body) };
+    }
+    return { kind: 'healthy', health: result.health };
+}
+/**
+ * Threshold counting — the one piece of state this machine actually needs to
+ * decide a transition. `failCount` is the count AFTER the current failure has
+ * been recorded (matches `incrementSandboxFail()` semantics: increment, then
+ * read). Returns the next status, or `null` for "no status change" (still
+ * below threshold on a first-ever connection, which stays in whatever status
+ * it already had — normally "connecting").
+ */
+export function computeFailureStatus(failCount, wasConnected, immediateOffline) {
+    if (immediateOffline)
+        return 'unreachable';
+    const threshold = wasConnected ? FAIL_THRESHOLD_RECONNECT : FAIL_THRESHOLD_FIRST;
+    if (failCount >= threshold)
+        return 'unreachable';
+    if (wasConnected)
+        return 'connecting';
+    return null;
+}
+/**
+ * Next poll interval, purely a function of the current store status/healthy
+ * pair — fast while anything is unresolved or unhealthy, slow once truly
+ * settled into "connected and healthy".
+ */
+export function nextPollDelay(status, healthy) {
+    if (status === 'connected' && healthy === false)
+        return POLL_FAILING;
+    if (status === 'connected')
+        return POLL_CONNECTED;
+    if (status === 'unreachable')
+        return POLL_UNREACHABLE;
+    // Initial "connecting" phase (sandbox just went active, opencode still
+    // booting) — poll fast so the runtime appears the moment it's healthy
+    // instead of waiting out a long interval.
+    return POLL_FAILING;
+}
+/**
+ * useRuntimeReconnect — monitors the active session's runtime reachability
+ * mid-session (see `react/opencode.ts` for how this fits alongside the
+ * server-truth boot readiness and the SSE heartbeat).
+ *
+ * Probes `getSessionHealth` (the SDK's `/kortix/health`) and maps the result
+ * into the shared `sandbox-connection-store`. Behaviour:
+ *   - On first failure, immediately switches to fast polling.
+ *   - If the user was previously connected, the first failure moves to
+ *     "connecting" and the second consecutive failure marks unreachable.
+ *   - If it's the first connection, requires FAIL_THRESHOLD_FIRST failures.
+ *
+ * The transition logic itself (`classifyProbeResult`, `computeFailureStatus`,
+ * `nextPollDelay`) is pure and exported above — this hook is thin glue that
+ * wires those decisions to a `setTimeout` loop and the store's action
+ * functions, since the repo has no harness to render-test a hook directly.
+ */
+export function useRuntimeReconnect() {
+    const timerRef = useRef(null);
+    const abortRef = useRef(null);
+    const isMountRef = useRef(true);
+    useEffect(() => {
+        const isFirstMount = isMountRef.current;
+        isMountRef.current = false;
+        if (isFirstMount) {
+            // Full reset — clears wasConnected, failCount, status, everything.
+            resetForServerSwitch();
+        }
+        let alive = true;
+        async function check() {
+            if (!alive)
+                return;
+            const url = useServerStore.getState().getActiveServerUrl();
+            if (!url) {
+                scheduleNext();
+                return;
+            }
+            // Don't fire health checks until auth is ready — avoids naked requests
+            // that return synthetic 401s and cause false "unreachable" status.
+            const token = await getSupabaseAccessToken();
+            if (!token) {
+                scheduleNext();
+                return;
+            }
+            abortRef.current?.abort();
+            const controller = new AbortController();
+            abortRef.current = controller;
+            let immediateOffline = false;
+            let failed = false;
+            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();
+                        setSandboxStatus('connected');
+                        setOpenCodeHealth(false, outcome.health?.version, outcome.health?.boot_error ?? outcome.health?.message ?? outcome.health?.reason ?? null);
+                        if (outcome.health?.version) {
+                            setSandboxVersion(outcome.health.version);
+                        }
+                        break;
+                    }
+                    case 'failure': {
+                        failed = true;
+                        immediateOffline = outcome.immediateOffline;
+                        break;
+                    }
+                    case 'healthy': {
+                        resetSandboxFail();
+                        setSandboxStatus('connected');
+                        setOpenCodeHealth(isRuntimeReady(outcome.health), outcome.health?.version, outcome.health?.boot_error ?? outcome.health?.message ?? outcome.health?.reason ?? null);
+                        if (outcome.health?.version) {
+                            setSandboxVersion(outcome.health.version);
+                        }
+                        break;
+                    }
+                }
+            }
+            catch {
+                // Network error or `CHECK_TIMEOUT` abort — no HTTP status/body to
+                // classify, so this always counts as a plain (non-immediate) failure;
+                // the threshold decides whether it flips the status.
+                if (!alive)
+                    return;
+                failed = true;
+                immediateOffline = false;
+            }
+            finally {
+                if (failed) {
+                    incrementSandboxFail();
+                    if (immediateOffline) {
+                        setSandboxStatus('unreachable');
+                    }
+                    else {
+                        const { failCount, wasConnected } = useSandboxConnectionStore.getState();
+                        const nextStatus = computeFailureStatus(failCount, wasConnected, immediateOffline);
+                        if (nextStatus)
+                            setSandboxStatus(nextStatus);
+                    }
+                }
+                // Reschedule from finally so EVERY path re-arms the poll loop —
+                // notably the "booting" branch returns early; without this it stops
+                // polling and `healthy` never flips, so useSessionSync and the SSE
+                // (both gated on healthy) never subscribe and a fresh session's first
+                // turn stays invisible until a manual reload.
+                if (alive) {
+                    markInitialCheckDone();
+                    scheduleNext();
+                }
+            }
+        }
+        function scheduleNext() {
+            if (!alive)
+                return;
+            if (timerRef.current)
+                clearTimeout(timerRef.current);
+            const { status, healthy } = useSandboxConnectionStore.getState();
+            timerRef.current = setTimeout(check, nextPollDelay(status, healthy));
+        }
+        check();
+        return () => {
+            alive = false;
+            abortRef.current?.abort();
+            if (timerRef.current)
+                clearTimeout(timerRef.current);
+        };
+    }, []);
+}
+//# sourceMappingURL=use-runtime-reconnect.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-runtime-reconnect.js","sourceRoot":"","sources":["../../src/react/use-runtime-reconnect.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,17 @@
+import type { ModelKey } from './use-model-store.js';
+/**
+ * Per-session model + agent selection, persisted locally. The lists come from the
+ * server-side hooks (`useProjectModels`, `useVisibleAgents`); this just remembers
+ * which one is chosen for a session and feeds it to send. `null` means "use the
+ * project/agent default" — the field is omitted and the runtime decides. Owned by
+ * the SDK so every host shares one implementation (and `useSession` can apply the
+ * picks to send without the host wiring it).
+ */
+export interface SessionPicks {
+    model: ModelKey | null;
+    agent: string | null;
+    setModel: (model: ModelKey | null) => void;
+    setAgent: (agent: string | null) => void;
+}
+export declare function useSessionPicks(sessionId: string): SessionPicks;
+//# sourceMappingURL=use-session-picks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-session-picks.d.ts","sourceRoot":"","sources":["../../src/react/use-session-picks.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,QAAQ,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,KAAK,IAAI,CAAC;IAC3C,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CAC1C;AAID,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CAiC/D"}

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

@@ -0,0 +1,36 @@
+'use client';
+import { useEffect, useState } from 'react';
+const storageKey = (sessionId) => `kortix:picks:${sessionId}`;
+export function useSessionPicks(sessionId) {
+    const [picks, setPicks] = useState({
+        model: null,
+        agent: null,
+    });
+    useEffect(() => {
+        // Always reset on session change — a host page instance is reused across
+        // session navigation, so without resetting a new session would inherit the
+        // previous one's picks (and persist them under the wrong key).
+        try {
+            const raw = localStorage.getItem(storageKey(sessionId));
+            setPicks(raw ? JSON.parse(raw) : { model: null, agent: null });
+        }
+        catch {
+            setPicks({ model: null, agent: null });
+        }
+    }, [sessionId]);
+    const update = (patch) => setPicks((prev) => {
+        const next = { ...prev, ...patch };
+        try {
+            localStorage.setItem(storageKey(sessionId), JSON.stringify(next));
+        }
+        catch { }
+        return next;
+    });
+    return {
+        model: picks.model,
+        agent: picks.agent,
+        setModel: (model) => update({ model }),
+        setAgent: (agent) => update({ agent }),
+    };
+}
+//# sourceMappingURL=use-session-picks.js.map

package/dist/react/use-session-picks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-session-picks.js","sourceRoot":"","sources":["../../src/react/use-session-picks.ts"],"names":[],"mappings":"AAAA,YAAY,CAAC;AAEb,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAkB5C,MAAM,UAAU,GAAG,CAAC,SAAiB,EAAE,EAAE,CAAC,gBAAgB,SAAS,EAAE,CAAC;AAEtE,MAAM,UAAU,eAAe,CAAC,SAAiB;IAC/C,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAmD;QACnF,KAAK,EAAE,IAAI;QACX,KAAK,EAAE,IAAI;KACZ,CAAC,CAAC;IAEH,SAAS,CAAC,GAAG,EAAE;QACb,yEAAyE;QACzE,2EAA2E;QAC3E,+DAA+D;QAC/D,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC;YACxD,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACjE,CAAC;QAAC,MAAM,CAAC;YACP,QAAQ,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACzC,CAAC;IACH,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;IAEhB,MAAM,MAAM,GAAG,CAAC,KAAgE,EAAE,EAAE,CAClF,QAAQ,CAAC,CAAC,IAAI,EAAE,EAAE;QAChB,MAAM,IAAI,GAAG,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,EAAE,CAAC;QACnC,IAAI,CAAC;YACH,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;QACpE,CAAC;QAAC,MAAM,CAAC,CAAA,CAAC;QACV,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;IAEL,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;QACtC,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;KACvC,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,18 @@
+import { type Session } from "./use-opencode-sessions/index.js";
+/**
+ * Prefetch a single session's messages into the sync store + IDB cache.
+ * Skips if the session is already in the sync store.
+ */
+export declare function prefetchSession(sessionId: string): Promise<void>;
+/**
+ * Reset prefetch tracking (e.g., on server switch).
+ */
+export declare function resetPrefetchState(): void;
+/**
+ * Hook: background-prefetch top N sessions after session list loads.
+ * Uses requestIdleCallback to avoid blocking UI.
+ */
+export declare function useBackgroundSessionPrefetch(sessions: Session[] | undefined): {
+    prefetchOnHover: (sessionId: string) => void;
+};
+//# sourceMappingURL=use-session-prefetch.d.ts.map

package/dist/react/use-session-prefetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-session-prefetch.d.ts","sourceRoot":"","sources":["../../src/react/use-session-prefetch.ts"],"names":[],"mappings":"AAWA,OAAO,EAA2B,KAAK,OAAO,EAAE,MAAM,yBAAyB,CAAC;AAKhF;;;GAGG;AACH,wBAAsB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiDtE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAGzC;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,SAAS;iCAM1B,MAAM;EAKvD"}

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

@@ -0,0 +1,84 @@
+"use client";
+import { useCallback, useEffect } from "react";
+import { getClient } from "../opencode/client.js";
+import { useSyncStore } from "../state/sync-store.js";
+import { useSandboxConnectionStore } from "../state/sandbox-connection-store.js";
+import { saveSessionToIDB, loadSessionFromIDB, pruneIDBCache, } from "../state/idb-sync-cache.js";
+import { canQueryOpenCodeSession } from "./use-opencode-sessions/index.js";
+const prefetchedSessions = new Set();
+const inFlightPrefetches = new Map();
+/**
+ * Prefetch a single session's messages into the sync store + IDB cache.
+ * Skips if the session is already in the sync store.
+ */
+export async function prefetchSession(sessionId) {
+    if (!canQueryOpenCodeSession(sessionId))
+        return;
+    if (useSandboxConnectionStore.getState().healthy !== true)
+        return;
+    if (prefetchedSessions.has(sessionId))
+        return;
+    const existingPrefetch = inFlightPrefetches.get(sessionId);
+    if (existingPrefetch)
+        return existingPrefetch;
+    const run = (async () => {
+        const state = useSyncStore.getState();
+        if (sessionId in state.messages && (state.messages[sessionId]?.length ?? 0) > 0) {
+            prefetchedSessions.add(sessionId);
+            return;
+        }
+        // Try IDB cache first
+        const cached = await loadSessionFromIDB(sessionId);
+        if (cached && cached.messages.length > 0) {
+            const currentState = useSyncStore.getState();
+            if (!(sessionId in currentState.messages) || (currentState.messages[sessionId]?.length ?? 0) === 0) {
+                currentState.hydrate(sessionId, cached.messages.map((info) => ({
+                    info,
+                    parts: cached.parts[info.id] ?? [],
+                })));
+            }
+        }
+        // Fetch fresh data from server in background
+        try {
+            const res = await getClient().session.messages({ sessionID: sessionId });
+            const data = res.data ?? [];
+            if (data.length > 0) {
+                useSyncStore.getState().hydrate(sessionId, data);
+                const parts = useSyncStore.getState().parts;
+                const msgs = useSyncStore.getState().messages[sessionId] ?? [];
+                saveSessionToIDB(sessionId, msgs, parts);
+            }
+            prefetchedSessions.add(sessionId);
+        }
+        catch {
+            // Non-critical — cache is still warm from IDB
+        }
+    })().finally(() => {
+        inFlightPrefetches.delete(sessionId);
+    });
+    inFlightPrefetches.set(sessionId, run);
+    return run;
+}
+/**
+ * Reset prefetch tracking (e.g., on server switch).
+ */
+export function resetPrefetchState() {
+    prefetchedSessions.clear();
+    inFlightPrefetches.clear();
+}
+/**
+ * Hook: background-prefetch top N sessions after session list loads.
+ * Uses requestIdleCallback to avoid blocking UI.
+ */
+export function useBackgroundSessionPrefetch(sessions) {
+    useEffect(() => {
+        if (!sessions || sessions.length === 0)
+            return;
+        void pruneIDBCache();
+    }, [sessions]);
+    const prefetchOnHover = useCallback((sessionId) => {
+        prefetchSession(sessionId);
+    }, []);
+    return { prefetchOnHover };
+}
+//# sourceMappingURL=use-session-prefetch.js.map