@kortix/sdk 0.9.98

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

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

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

@@ -0,0 +1,183 @@
+import { type KortixSendError } from './use-session.js';
+import { type PromptPart, type SendMessageOptions } from './use-opencode-sessions/index.js';
+import { type StartStash } from './session-start-stash.js';
+/**
+ * Add a user message to the sync store optimistically (before the server has
+ * accepted it) and flip the session busy. Both actions are independent
+ * zustand writes (neither depends on the other's result), so callers that
+ * used to fire them in the opposite order see no observable difference.
+ */
+export declare function beginOptimisticSend(sessionId: string, messageId: string, text: string, partIds?: string[]): void;
+/**
+ * A send that never reached the network at all (e.g. building the outgoing
+ * parts — file uploads — threw before `promptOpenCodeMessage` was even
+ * called). There is nothing to rehydrate from the server since it never saw
+ * this message, so just clear busy and drop the optimistic message outright
+ * — unlike `recoverFromSendFailure`, which keeps it pending a rehydrate.
+ */
+export declare function abandonOptimisticSend(sessionId: string, messageId: string): void;
+/** The minimal slice of `OpencodeClient` the recovery rehydrate needs. */
+export interface OpenCodeMessagesClient {
+    session: {
+        messages: (args: {
+            sessionID: string;
+        }) => Promise<{
+            data?: unknown;
+        }>;
+    };
+}
+export interface SendRecoveryOptions {
+    /** Resolve the client used to rehydrate messages on failure. Defaults to
+     * the SDK's `getClient` — inject a stub in tests, or a different client in
+     * a host that doesn't use the singleton runtime client. */
+    getClient?: () => OpenCodeMessagesClient;
+    /** Classify the raw error into a `KortixSendError`. Defaults to
+     * `classifySendError` — a host with richer message formatting (e.g.
+     * apps/web's `ProviderModelNotFoundError` special-casing) injects its own
+     * classifier that wraps it. */
+    classify?: (error: unknown) => KortixSendError;
+}
+/**
+ * A send reached the network and failed (or the network dispatch itself
+ * threw). Classify the error, clear busy, and either rehydrate real messages
+ * from the server (keeping the optimistic message visible until then — some
+ * error paths never emit a `session.error` SSE event) or drop the optimistic
+ * message if the server has no record of it. The rehydrate is fire-and-forget
+ * (matches the original inline `.then()/.catch()` — callers don't await it),
+ * so this function itself resolves synchronously with the classified error.
+ */
+export declare function recoverFromSendFailure(sessionId: string, messageId: string, error: unknown, options?: SendRecoveryOptions): KortixSendError;
+export interface SendAndRecoverArgs {
+    sessionId: string;
+    /** The optimistic message id to keep-or-drop on failure. */
+    messageId: string;
+    parts: PromptPart[];
+    options?: SendMessageOptions;
+    getClient?: () => OpenCodeMessagesClient;
+    classify?: (error: unknown) => KortixSendError;
+}
+export type SendAndRecoverResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: KortixSendError;
+    cause: unknown;
+};
+/**
+ * Send already-built parts via `promptOpenCodeMessage` (which owns network
+ * retry — this never re-wraps it) and run `recoverFromSendFailure` on
+ * failure. Assumes the optimistic message was already added by the caller
+ * (via `beginOptimisticSend`) — callers add it at different points relative
+ * to building `parts` (e.g. before vs. after an upload step that can itself
+ * fail), so this only owns the network call + failure recovery.
+ */
+export declare function sendAndRecover(args: SendAndRecoverArgs): Promise<SendAndRecoverResult>;
+/**
+ * Optimistically mark the session idle and patch an "aborted" error onto the
+ * last assistant message that doesn't already have one, so an "Interrupted"
+ * label can render instantly instead of waiting for the SSE `session.error`
+ * round-trip. Call this immediately before issuing the actual abort request.
+ */
+export declare function applyOptimisticAbort(sessionId: string): void;
+/** A timer handle — opaque, only ever round-tripped through the injected timers. */
+export type StashReplayTimerHandle = unknown;
+/** Injectable timer seam — defaults to the real globals. Lets tests drive the
+ * write-race/readiness-poll timing deterministically instead of depending on
+ * real wall-clock delays. */
+export interface StashReplayTimers {
+    setTimeout: (handler: () => void, ms: number) => StashReplayTimerHandle;
+    clearTimeout: (handle: StashReplayTimerHandle | undefined) => void;
+}
+export interface PreparedStashSend {
+    /** The optimistic message id to add + keep-or-drop on failure. */
+    messageId: string;
+    /** Optimistic text to render immediately (may include e.g. upload markup —
+     * distinct from the actual outgoing parts, which `buildParts` builds). */
+    optimisticText: string;
+    partIds?: string[];
+    sendOptions?: SendMessageOptions;
+    /** Build the parts to actually send over the wire (e.g. after uploading
+     * attached files). Thrown failures are treated exactly like a network-send
+     * failure (stash restored, `onFailure` invoked with the classified error). */
+    buildParts: () => Promise<PromptPart[]>;
+}
+export interface StartStashReplayOptions<TReady> {
+    sessionId: string;
+    /** Defaults to the SDK's `readStartStash`; overridable for tests. */
+    readStash?: (sessionId: string) => StartStash | null;
+    /** How many `writeRaceIntervalMs`-spaced attempts to retry reading the
+     * stash before giving up — handles the write race where this can run
+     * before the producer (the "new session" screen) has written it. Default 5. */
+    writeRaceAttempts?: number;
+    /** Default 50ms. */
+    writeRaceIntervalMs?: number;
+    /**
+     * Poll for readiness (e.g. a selectable model) before sending. Return the
+     * resolved value once ready, or `null` to keep polling. Called with the
+     * stash on every attempt so a host can seed its own agent/model stores
+     * from it as a side effect (matching the original inline behavior) —
+     * deliberately host-owned so this module never hardcodes a model store.
+     */
+    checkReadiness: (stash: StartStash) => TReady | null;
+    /** Default 120. */
+    readinessAttempts?: number;
+    /** Default 250ms. */
+    readinessIntervalMs?: number;
+    /** The readiness poll never resolved within `readinessAttempts`. */
+    onReadinessTimeout?: (stash: StartStash) => void;
+    /** Called once ready — build the optimistic message + parts to send. */
+    prepare: (stash: StartStash, ready: TReady) => PreparedStashSend;
+    /**
+     * Called on ANY send failure (building parts OR the network call). By the
+     * time this fires, the stash has already been restored (`writeStartStash`)
+     * and the optimistic message already recovered (idle + rehydrate-or-remove,
+     * via `recoverFromSendFailure`) — use this for host-specific extras (e.g.
+     * restoring pending file uploads, resetting an "already handled" flag,
+     * surfacing the classified error).
+     */
+    onFailure?: (stash: StartStash, error: unknown, classified: KortixSendError) => void;
+    getClient?: () => OpenCodeMessagesClient;
+    classify?: (error: unknown) => KortixSendError;
+    timers?: StashReplayTimers;
+}
+export interface StartStashReplayHandle {
+    /** Stop all pending retries/polls and abandon any in-flight send's failure
+     * handling. Idempotent. */
+    cancel: () => void;
+}
+/**
+ * Read a stashed new-session prompt (retrying across the producer's write
+ * race), poll for host-defined send readiness, then send it — restoring the
+ * stash (+ recovering the optimistic message) on any failure. Framework-free:
+ * safe to call from a `useEffect` (as apps/web's `session-chat.tsx` does) or
+ * any other host.
+ */
+export declare function replayStartStash<TReady>(options: StartStashReplayOptions<TReady>): StartStashReplayHandle;
+export interface UseSessionSendOptions {
+    getClient?: () => OpenCodeMessagesClient;
+    classify?: (error: unknown) => KortixSendError;
+}
+export interface SendCallOptions {
+    /** Optimistic message id. Auto-generated (via the sync store's ascending
+     * id scheme) if omitted. */
+    messageId?: string;
+    /** Text to show optimistically before the server echoes it back. Defaults
+     * to the first text part's `text`. */
+    optimisticText?: string;
+    /** Part ids to reuse for the optimistic message (so the server's echo
+     * updates the same part instead of duplicating it). */
+    partIds?: string[];
+}
+export interface UseSessionSendResult {
+    send: (parts: PromptPart[], options?: SendMessageOptions, callOptions?: SendCallOptions) => Promise<SendAndRecoverResult>;
+    /** Abort the run and optimistically patch the last assistant message +
+     * session status (see `applyOptimisticAbort`). No-ops while a previous
+     * abort is still in flight. */
+    stop: () => void;
+    isSending: boolean;
+    isStopping: boolean;
+    /** Last `send` failure, or null. Reset on every new `send` call. */
+    sendError: KortixSendError | null;
+}
+export declare function useSessionSend(sessionId: string, options?: UseSessionSendOptions): UseSessionSendResult;
+//# sourceMappingURL=use-session-send.d.ts.map

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

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

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

@@ -0,0 +1,287 @@
+'use client';
+import { useCallback, useState } from 'react';
+import { getClient } from '../opencode/client.js';
+import { ascendingId, useSyncStore } from '../state/sync-store.js';
+import { classifySendError } from './use-session.js';
+import { promptOpenCodeMessage, useAbortOpenCodeSession, } from './use-opencode-sessions/index.js';
+import { readStartStash, writeStartStash } from './session-start-stash.js';
+// ============================================================================
+// Optimistic-send bookkeeping — pure sync-store mechanics, shared by every
+// send path.
+// ============================================================================
+/**
+ * Add a user message to the sync store optimistically (before the server has
+ * accepted it) and flip the session busy. Both actions are independent
+ * zustand writes (neither depends on the other's result), so callers that
+ * used to fire them in the opposite order see no observable difference.
+ */
+export function beginOptimisticSend(sessionId, messageId, text, partIds) {
+    const parts = text.trim()
+        ? [
+            {
+                id: partIds?.[0] ?? ascendingId('prt'),
+                sessionID: sessionId,
+                messageID: messageId,
+                type: 'text',
+                text,
+            },
+        ]
+        : [];
+    // Minimal optimistic stub — omits `agent`/`model` (required on the real
+    // `UserMessage`) since the server fills those in; same stub-message
+    // convention used by the sync store's own SSE handlers.
+    const info = {
+        id: messageId,
+        sessionID: sessionId,
+        role: 'user',
+        time: { created: Date.now() },
+    };
+    useSyncStore.getState().optimisticAdd(sessionId, info, parts);
+    useSyncStore.getState().setStatus(sessionId, { type: 'busy' });
+}
+/**
+ * A send that never reached the network at all (e.g. building the outgoing
+ * parts — file uploads — threw before `promptOpenCodeMessage` was even
+ * called). There is nothing to rehydrate from the server since it never saw
+ * this message, so just clear busy and drop the optimistic message outright
+ * — unlike `recoverFromSendFailure`, which keeps it pending a rehydrate.
+ */
+export function abandonOptimisticSend(sessionId, messageId) {
+    useSyncStore.getState().setStatus(sessionId, { type: 'idle' });
+    useSyncStore.getState().optimisticRemove(sessionId, messageId);
+}
+/**
+ * A send reached the network and failed (or the network dispatch itself
+ * threw). Classify the error, clear busy, and either rehydrate real messages
+ * from the server (keeping the optimistic message visible until then — some
+ * error paths never emit a `session.error` SSE event) or drop the optimistic
+ * message if the server has no record of it. The rehydrate is fire-and-forget
+ * (matches the original inline `.then()/.catch()` — callers don't await it),
+ * so this function itself resolves synchronously with the classified error.
+ */
+export function recoverFromSendFailure(sessionId, messageId, error, options = {}) {
+    const classify = options.classify ?? classifySendError;
+    const resolveClient = options.getClient ?? getClient;
+    const classified = classify(error);
+    useSyncStore.getState().setStatus(sessionId, { type: 'idle' });
+    let client;
+    try {
+        client = resolveClient();
+    }
+    catch {
+        useSyncStore.getState().optimisticRemove(sessionId, messageId);
+        return classified;
+    }
+    client.session
+        .messages({ sessionID: sessionId })
+        .then((res) => {
+        if (res?.data) {
+            // hydrate() already drops superseded optimistic messages AND bridges
+            // their text onto the real server message. Do NOT also call
+            // clearOptimisticMessages here: on an error send whose user message
+            // the server hasn't persisted yet, that wipes the user's typed text
+            // and leaves an empty bubble. Keeping the optimistic message means
+            // the user always still sees what they sent.
+            useSyncStore.getState().hydrate(sessionId, res.data);
+        }
+        else {
+            // No server data — just remove the optimistic message.
+            useSyncStore.getState().optimisticRemove(sessionId, messageId);
+        }
+    })
+        .catch(() => {
+        // Fetch failed — fall back to removing the optimistic message.
+        useSyncStore.getState().optimisticRemove(sessionId, messageId);
+    });
+    return classified;
+}
+/**
+ * Send already-built parts via `promptOpenCodeMessage` (which owns network
+ * retry — this never re-wraps it) and run `recoverFromSendFailure` on
+ * failure. Assumes the optimistic message was already added by the caller
+ * (via `beginOptimisticSend`) — callers add it at different points relative
+ * to building `parts` (e.g. before vs. after an upload step that can itself
+ * fail), so this only owns the network call + failure recovery.
+ */
+export async function sendAndRecover(args) {
+    try {
+        await promptOpenCodeMessage({
+            sessionId: args.sessionId,
+            parts: args.parts,
+            options: args.options,
+        });
+        return { ok: true };
+    }
+    catch (cause) {
+        const error = recoverFromSendFailure(args.sessionId, args.messageId, cause, {
+            getClient: args.getClient,
+            classify: args.classify,
+        });
+        return { ok: false, error, cause };
+    }
+}
+// ============================================================================
+// Optimistic abort patch — the generic half of apps/web's `handleStop`. Pure
+// sync-store manipulation (no web-specific concepts), so it's extracted; the
+// abort mutation itself stays a shared per-host instance (apps/web fans it
+// out to multiple call sites beyond stop, so `useSessionSend` deliberately
+// does NOT own a second competing `useAbortOpenCodeSession()` instance for
+// hosts that already have one — see `useSessionSend.stop` below for a host
+// that doesn't).
+// ============================================================================
+/**
+ * Optimistically mark the session idle and patch an "aborted" error onto the
+ * last assistant message that doesn't already have one, so an "Interrupted"
+ * label can render instantly instead of waiting for the SSE `session.error`
+ * round-trip. Call this immediately before issuing the actual abort request.
+ */
+export function applyOptimisticAbort(sessionId) {
+    useSyncStore.getState().setStatus(sessionId, { type: 'idle' });
+    const store = useSyncStore.getState();
+    const msgs = store.messages[sessionId];
+    if (!msgs)
+        return;
+    for (let i = msgs.length - 1; i >= 0; i--) {
+        const msg = msgs[i];
+        if (msg.role === 'assistant' && !msg.error) {
+            // Typed as the wider `MessageError` (not just the literal shape below)
+            // so the assertion further down overlaps with `AssistantMessage.error`'s
+            // real union — see `MessageError` in the sync store.
+            const error = {
+                name: 'AbortError',
+                data: { message: 'The operation was aborted.' },
+            };
+            // `error`'s shape (`SyntheticAbortError`) isn't part of the SDK's
+            // `AssistantMessage.error` union — see `MessageError` in the sync
+            // store. TS flags the direct assertion as an insufficient-overlap
+            // mistake because it narrows the literal's `error` field back down to
+            // `SyntheticAbortError`; route through `unknown` as TS itself suggests.
+            const patched = { ...msg, error };
+            store.upsertMessage(sessionId, patched);
+            break;
+        }
+    }
+}
+const realStashReplayTimers = {
+    setTimeout: (handler, ms) => setTimeout(handler, ms),
+    clearTimeout: (handle) => clearTimeout(handle),
+};
+/**
+ * Read a stashed new-session prompt (retrying across the producer's write
+ * race), poll for host-defined send readiness, then send it — restoring the
+ * stash (+ recovering the optimistic message) on any failure. Framework-free:
+ * safe to call from a `useEffect` (as apps/web's `session-chat.tsx` does) or
+ * any other host.
+ */
+export function replayStartStash(options) {
+    const { sessionId, readStash = readStartStash, writeRaceAttempts = 5, writeRaceIntervalMs = 50, checkReadiness, readinessAttempts = 120, readinessIntervalMs = 250, onReadinessTimeout, prepare, onFailure, getClient: getClientOpt, classify, } = options;
+    const t = options.timers ?? realStashReplayTimers;
+    let cancelled = false;
+    let timer;
+    const fail = (stash, messageId, error) => {
+        writeStartStash(sessionId, stash);
+        const classified = recoverFromSendFailure(sessionId, messageId, error, {
+            getClient: getClientOpt,
+            classify,
+        });
+        onFailure?.(stash, error, classified);
+    };
+    const attemptSend = (stash, ready) => {
+        const prepared = prepare(stash, ready);
+        beginOptimisticSend(sessionId, prepared.messageId, prepared.optimisticText, prepared.partIds);
+        void (async () => {
+            let parts;
+            try {
+                parts = await prepared.buildParts();
+            }
+            catch (err) {
+                // Unconditional — matches the original inline effect, which recovered
+                // this failure even if `cancel()` had already fired (only the
+                // network-send catch below was guarded there).
+                fail(stash, prepared.messageId, err);
+                return;
+            }
+            try {
+                await promptOpenCodeMessage({ sessionId, parts, options: prepared.sendOptions });
+            }
+            catch (err) {
+                if (!cancelled)
+                    fail(stash, prepared.messageId, err);
+            }
+        })();
+    };
+    const pollReadiness = (stash, attempt) => {
+        if (cancelled)
+            return;
+        const ready = checkReadiness(stash);
+        if (ready !== null) {
+            attemptSend(stash, ready);
+            return;
+        }
+        if (attempt < readinessAttempts) {
+            timer = t.setTimeout(() => pollReadiness(stash, attempt + 1), readinessIntervalMs);
+            return;
+        }
+        onReadinessTimeout?.(stash);
+    };
+    const readWithRetry = (attempt) => {
+        if (cancelled)
+            return;
+        const stash = readStash(sessionId);
+        if (!stash?.prompt) {
+            if (attempt < writeRaceAttempts) {
+                timer = t.setTimeout(() => readWithRetry(attempt + 1), writeRaceIntervalMs);
+                return;
+            }
+            return;
+        }
+        // Carry the attempt count forward into the readiness poll (matches the
+        // original inline effect, which used one shared counter across both
+        // loops) rather than resetting to 0 — the write-race retry only ever
+        // consumes a handful of attempts before finding the stash, so this only
+        // trims the readiness budget by that same handful, never resets it.
+        pollReadiness(stash, attempt);
+    };
+    readWithRetry(0);
+    return {
+        cancel: () => {
+            cancelled = true;
+            if (timer !== undefined)
+                t.clearTimeout(timer);
+        },
+    };
+}
+export function useSessionSend(sessionId, options = {}) {
+    const { getClient: getClientOpt, classify } = options;
+    const [sendError, setSendError] = useState(null);
+    const [isSending, setIsSending] = useState(false);
+    const abortMutation = useAbortOpenCodeSession();
+    const send = useCallback(async (parts, sendOptions, callOptions = {}) => {
+        setSendError(null);
+        const messageId = callOptions.messageId ?? ascendingId('msg');
+        const firstText = parts.find((p) => p.type === 'text');
+        const optimisticText = callOptions.optimisticText ?? firstText?.text ?? '';
+        beginOptimisticSend(sessionId, messageId, optimisticText, callOptions.partIds);
+        setIsSending(true);
+        const result = await sendAndRecover({
+            sessionId,
+            messageId,
+            parts,
+            options: sendOptions,
+            getClient: getClientOpt,
+            classify,
+        });
+        setIsSending(false);
+        if (!result.ok)
+            setSendError(result.error);
+        return result;
+    }, [sessionId, getClientOpt, classify]);
+    const stop = useCallback(() => {
+        if (!sessionId || abortMutation.isPending)
+            return;
+        applyOptimisticAbort(sessionId);
+        abortMutation.mutate(sessionId);
+    }, [sessionId, abortMutation]);
+    return { send, stop, isSending, isStopping: abortMutation.isPending, sendError };
+}
+//# sourceMappingURL=use-session-send.js.map

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

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

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

@@ -0,0 +1,24 @@
+import type { SessionStatus, Todo } from "@opencode-ai/sdk/v2/client";
+type FileDiff = Omit<import('@opencode-ai/sdk/v2/client').SnapshotFileDiff, 'patch'> & {
+    patch?: string;
+    before?: string;
+    after?: string;
+};
+import { type MessageWithParts } from "../state/sync-store.js";
+/**
+ * Single hook that provides all session data from the sync store.
+ * Replaces: useOpenCodeMessages + useOpenCodeSessionStatusStore + useOpenCodePendingStore
+ *
+ * On first access, fetches messages from the server and populates the store.
+ * After that, SSE events keep the store updated in real time.
+ */
+export declare function useSessionSync(sessionId: string): {
+    messages: MessageWithParts[];
+    status: SessionStatus;
+    isBusy: boolean;
+    isLoading: boolean;
+    diffs: FileDiff[];
+    todos: Todo[];
+};
+export {};
+//# sourceMappingURL=use-session-sync.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-session-sync.d.ts","sourceRoot":"","sources":["../../src/react/use-session-sync.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGX,aAAa,EACb,IAAI,EACJ,MAAM,4BAA4B,CAAC;AAKpC,KAAK,QAAQ,GAAG,IAAI,CAAC,OAAO,4BAA4B,EAAE,gBAAgB,EAAE,OAAO,CAAC,GAAG;IACtF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AACF,OAAO,EACN,KAAK,gBAAgB,EAErB,MAAM,qBAAqB,CAAC;AAuF7B;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM;;;;;;;EAoT/C"}