@beeuni/sdk 0.1.0

package/dist/react/session-start-stash.d.ts

@@ -0,0 +1,17 @@
+export interface StartStash {
+    prompt: string;
+    model: {
+        providerID: string;
+        modelID: string;
+    } | null;
+    agent: string | null;
+    variant?: string | null;
+    at?: number;
+}
+export declare const START_STASH_TTL_MS: number;
+export declare function startStashKey(sessionId: string): string;
+export declare function writeStartStash(sessionId: string, stash: StartStash): void;
+export declare function readStartStash(sessionId: string): StartStash | null;
+export declare function clearStartStash(sessionId: string): void;
+export declare function migrateStash(fromSessionId: string, toSessionId: string): void;
+export declare function migrateLegacyStash(fromPromptKey: string, fromOptionsKey: string, toSessionId: string): void;

package/dist/react/session-start-stash.js

@@ -0,0 +1,146 @@
+export const START_STASH_TTL_MS = 10 * 60_000;
+export function startStashKey(sessionId) {
+    return `beeuni:start:${sessionId}`;
+}
+function sanitizeStartModel(model) {
+    if (!model)
+        return null;
+    if (model.modelID === 'auto' || model.modelID === 'beeuni/auto')
+        return null;
+    return model;
+}
+function sanitizeStartStash(stash) {
+    return { ...stash, model: sanitizeStartModel(stash.model) };
+}
+export function writeStartStash(sessionId, stash) {
+    try {
+        sessionStorage.setItem(startStashKey(sessionId), JSON.stringify({ ...sanitizeStartStash(stash), at: Date.now() }));
+    }
+    catch { }
+}
+function legacyPromptKey(sessionId) {
+    return `opencode_pending_prompt:${sessionId}`;
+}
+function legacyOptionsKey(sessionId) {
+    return `opencode_pending_options:${sessionId}`;
+}
+function parseLegacyModel(value) {
+    if (!value)
+        return null;
+    if (typeof value === 'object') {
+        const obj = value;
+        if (typeof obj.providerID === 'string' && typeof obj.modelID === 'string') {
+            return sanitizeStartModel({ providerID: obj.providerID, modelID: obj.modelID });
+        }
+        return null;
+    }
+    if (typeof value === 'string') {
+        const idx = value.indexOf('/');
+        if (idx > 0 && idx < value.length - 1) {
+            return sanitizeStartModel({
+                providerID: value.slice(0, idx),
+                modelID: value.slice(idx + 1),
+            });
+        }
+    }
+    return null;
+}
+function readLegacyStash(sessionId) {
+    try {
+        const prompt = sessionStorage.getItem(legacyPromptKey(sessionId));
+        if (!prompt)
+            return null;
+        let agent = null;
+        let model = null;
+        let variant = null;
+        const raw = sessionStorage.getItem(legacyOptionsKey(sessionId));
+        if (raw) {
+            const parsed = JSON.parse(raw);
+            if (parsed?.agent)
+                agent = parsed.agent;
+            if (parsed?.model)
+                model = parseLegacyModel(parsed.model);
+            if (parsed?.variant)
+                variant = parsed.variant;
+        }
+        return { prompt, model, agent, variant };
+    }
+    catch {
+        return null;
+    }
+}
+function clearLegacyStash(sessionId) {
+    try {
+        sessionStorage.removeItem(legacyPromptKey(sessionId));
+        sessionStorage.removeItem(legacyOptionsKey(sessionId));
+    }
+    catch { }
+}
+export function readStartStash(sessionId) {
+    try {
+        const raw = sessionStorage.getItem(startStashKey(sessionId));
+        if (raw) {
+            const stash = JSON.parse(raw);
+            if (typeof stash.at === 'number' && Date.now() - stash.at > START_STASH_TTL_MS) {
+                clearStartStash(sessionId);
+                return null;
+            }
+            const { at: _at, ...payload } = stash;
+            return sanitizeStartStash(payload);
+        }
+    }
+    catch {
+    }
+    return readLegacyStash(sessionId);
+}
+export function clearStartStash(sessionId) {
+    try {
+        sessionStorage.removeItem(startStashKey(sessionId));
+    }
+    catch { }
+    clearLegacyStash(sessionId);
+}
+export function migrateStash(fromSessionId, toSessionId) {
+    if (fromSessionId === toSessionId)
+        return;
+    try {
+        if (!readStartStash(toSessionId)) {
+            const stash = readStartStash(fromSessionId);
+            if (stash)
+                writeStartStash(toSessionId, stash);
+        }
+    }
+    finally {
+        clearStartStash(fromSessionId);
+    }
+}
+export function migrateLegacyStash(fromPromptKey, fromOptionsKey, toSessionId) {
+    try {
+        const prompt = sessionStorage.getItem(fromPromptKey);
+        if (prompt && !readStartStash(toSessionId)) {
+            let agent = null;
+            let model = null;
+            let variant = null;
+            const raw = sessionStorage.getItem(fromOptionsKey);
+            if (raw) {
+                const parsed = JSON.parse(raw);
+                if (parsed?.agent)
+                    agent = parsed.agent;
+                if (parsed?.model)
+                    model = parseLegacyModel(parsed.model);
+                if (parsed?.variant)
+                    variant = parsed.variant;
+            }
+            writeStartStash(toSessionId, { prompt, model, agent, variant });
+        }
+    }
+    catch {
+    }
+    finally {
+        try {
+            sessionStorage.removeItem(fromPromptKey);
+            sessionStorage.removeItem(fromOptionsKey);
+        }
+        catch { }
+    }
+}

package/dist/react/session-stop.d.ts

@@ -0,0 +1,20 @@
+import { type AbortSettlement } from './use-opencode-sessions/index.js';
+export declare function applyOptimisticAbort(sessionId: string): void;
+export declare const STOP_HOLD_DEADLINE_MS = 1500;
+export interface StopWithReceiptOptions {
+    workingSessionId?: string;
+    projectId?: string;
+    inboxSessionId?: string;
+    holdInboxPrompts?: (projectId: string, sessionId: string, held: boolean) => Promise<unknown>;
+    holdDeadlineMs?: number;
+}
+export declare function stopWithReceipt(sessionId: string, runAbort: () => Promise<void>, options?: StopWithReceiptOptions): Promise<AbortSettlement>;
+export interface CancelSessionTurnArgs {
+    projectId: string;
+    sessionId: string;
+    runtimeSessionId: string;
+    runtimeActionReady: boolean;
+    runAbort: () => Promise<void>;
+    holdInboxPrompts?: (projectId: string, sessionId: string, held: boolean) => Promise<unknown>;
+}
+export declare function cancelSessionTurn(args: CancelSessionTurnArgs): Promise<AbortSettlement>;

package/dist/react/session-stop.js

@@ -0,0 +1,63 @@
+import { useSessionWorkingStore } from '../browser/stores/session-working-store.js';
+import { useSyncStore } from '../browser/stores/sync-store.js';
+import { holdSessionPrompts } from '../core/rest/projects-client/index.js';
+import { abortInFlightDeliveries, awaitAbortSettlement, } from './use-opencode-sessions/index.js';
+export function applyOptimisticAbort(sessionId) {
+    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')
+            continue;
+        if (msg.error || msg.time?.completed != null)
+            break;
+        {
+            const error = {
+                name: 'AbortError',
+                data: { message: 'The operation was aborted.', reason: 'user' },
+            };
+            const patched = { ...msg, error };
+            store.upsertMessage(sessionId, patched);
+            break;
+        }
+    }
+}
+export const STOP_HOLD_DEADLINE_MS = 1_500;
+export async function stopWithReceipt(sessionId, runAbort, options = {}) {
+    const workingSessionId = options.workingSessionId ?? sessionId;
+    const store = useSessionWorkingStore.getState();
+    store.clearSendReceipt(workingSessionId);
+    store.noteAbortReceipt(workingSessionId, Date.now());
+    applyOptimisticAbort(sessionId);
+    abortInFlightDeliveries(sessionId);
+    if (options.projectId) {
+        const inboxSessionId = options.inboxSessionId ?? workingSessionId;
+        const hold = options.holdInboxPrompts ?? holdSessionPrompts;
+        const deadlineMs = options.holdDeadlineMs ?? STOP_HOLD_DEADLINE_MS;
+        await Promise.race([
+            hold(options.projectId, inboxSessionId, true).catch((error) => {
+                console.warn('[useSessionSend] failed to hold the prompt inbox on stop', error);
+            }),
+            new Promise((resolve) => setTimeout(resolve, deadlineMs)),
+        ]);
+    }
+    const settlement = awaitAbortSettlement(runAbort);
+    void settlement.then((result) => {
+        if (result?.status === 'timed-out')
+            return;
+        useSessionWorkingStore.getState().settleAbortReceipt(workingSessionId, Date.now());
+    });
+    return settlement;
+}
+export function cancelSessionTurn(args) {
+    if (!args.runtimeActionReady)
+        return Promise.resolve({ status: 'skipped' });
+    return stopWithReceipt(args.runtimeSessionId, args.runAbort, {
+        workingSessionId: args.sessionId,
+        inboxSessionId: args.sessionId,
+        ...(args.projectId ? { projectId: args.projectId } : {}),
+        ...(args.holdInboxPrompts ? { holdInboxPrompts: args.holdInboxPrompts } : {}),
+    });
+}

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

@@ -0,0 +1,12 @@
+import type { QueryClient } from '@tanstack/react-query';
+type SessionTitleQueryClient = Pick<QueryClient, 'getQueryData' | 'refetchQueries'> & {
+    getQueryState?: QueryClient['getQueryState'];
+};
+interface SessionTitleRefreshOptions {
+    delaysMs?: number[];
+    signal?: AbortSignal;
+    sleep?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+}
+export declare function refreshSessionTitleQueryUntilResolved(queryClient: SessionTitleQueryClient, projectId: string, sessionId: string, options?: SessionTitleRefreshOptions): Promise<boolean>;
+export declare function reconcileHydratedSessionTitle(queryClient: SessionTitleQueryClient, projectId: string, sessionId: string, userMessageCount: number, options?: SessionTitleRefreshOptions): Promise<boolean>;
+export {};

package/dist/react/session-title-sync.js

@@ -0,0 +1,88 @@
+import { sessionStartKey } from '../core/rest/projects-client/index.js';
+import { qk } from './query-keys.js';
+const DEFAULT_TITLE_REFRESH_DELAYS_MS = [0, 5_000, 5_000, 10_000, 10_000, 15_000, 20_000];
+function readRealTitle(value) {
+    const title = typeof value === 'string' ? value.trim() : '';
+    if (!title || /^new (?:session|agent)\b/i.test(title))
+        return null;
+    return title;
+}
+function cachedSessionHasTitle(queryClient, projectId, sessionId) {
+    const list = queryClient.getQueryData(qk.project.sessions(projectId));
+    const detail = queryClient.getQueryData(qk.project.session(projectId, sessionId));
+    const paged = queryClient.getQueryData(qk.project.sessionsPaged(projectId));
+    const pagedRows = paged && typeof paged === 'object' && Array.isArray(paged.pages)
+        ? paged.pages.flatMap((page) => Array.isArray(page?.items) ? page.items : [])
+        : [];
+    const candidates = [...(Array.isArray(list) ? list : []), ...pagedRows, detail];
+    return candidates.some((candidate) => {
+        if (!candidate || typeof candidate !== 'object')
+            return false;
+        const session = candidate;
+        const candidateId = typeof session.session_id === 'string'
+            ? session.session_id
+            : typeof session.sessionId === 'string'
+                ? session.sessionId
+                : null;
+        if (candidateId !== sessionId)
+            return false;
+        return Boolean(readRealTitle(session.custom_name) || readRealTitle(session.name));
+    });
+}
+function refetchSessionTitleQueries(queryClient, projectId, sessionId) {
+    const startFetching = queryClient.getQueryState?.(sessionStartKey(projectId, sessionId))?.fetchStatus === 'fetching';
+    return Promise.all([
+        ...(startFetching
+            ? []
+            : [
+                queryClient.refetchQueries({
+                    queryKey: [...qk.project.sessionsScope(projectId), 'list'],
+                    type: 'active',
+                }),
+                queryClient.refetchQueries({
+                    queryKey: [...qk.project.sessionsScope(projectId), 'list-paged'],
+                    type: 'active',
+                }),
+            ]),
+        queryClient.refetchQueries({
+            queryKey: qk.project.session(projectId, sessionId),
+            exact: true,
+            type: 'active',
+        }),
+    ]);
+}
+function sleep(delayMs, signal) {
+    if (delayMs <= 0 || signal?.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const finish = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', finish);
+            resolve();
+        };
+        const timer = setTimeout(finish, delayMs);
+        signal?.addEventListener('abort', finish, { once: true });
+    });
+}
+export async function refreshSessionTitleQueryUntilResolved(queryClient, projectId, sessionId, options = {}) {
+    const delays = options.delaysMs ?? DEFAULT_TITLE_REFRESH_DELAYS_MS;
+    const wait = options.sleep ?? sleep;
+    for (const delayMs of delays) {
+        await wait(delayMs, options.signal);
+        if (options.signal?.aborted)
+            return false;
+        if (cachedSessionHasTitle(queryClient, projectId, sessionId))
+            return true;
+        await refetchSessionTitleQueries(queryClient, projectId, sessionId);
+        if (cachedSessionHasTitle(queryClient, projectId, sessionId))
+            return true;
+    }
+    return false;
+}
+export async function reconcileHydratedSessionTitle(queryClient, projectId, sessionId, userMessageCount, options = {}) {
+    if (userMessageCount <= 0)
+        return false;
+    if (cachedSessionHasTitle(queryClient, projectId, sessionId))
+        return true;
+    return refreshSessionTitleQueryUntilResolved(queryClient, projectId, sessionId, options);
+}

package/dist/react/session-transcript-subscription.d.ts

@@ -0,0 +1,7 @@
+import { useSyncStore } from '../browser/stores/sync-store.js';
+import type { MessageWithParts } from '../browser/stores/sync-store.js';
+export declare function useReadableSessionId(sessionId: string, beeuniSessionScope?: string): string;
+type SyncSnapshot = ReturnType<typeof useSyncStore.getState>;
+export declare function selectSessionRows(state: SyncSnapshot, sessionId: string): MessageWithParts[];
+export declare function selectTranscriptShapeKey(state: SyncSnapshot, sessionId: string): string;
+export {};

package/dist/react/session-transcript-subscription.js

@@ -0,0 +1,71 @@
+'use client';
+import { getSessionCacheOwnership, resolveSessionCacheOwnerScope, sessionCacheOwnerScopesConflict, } from '../browser/session-sync/session-cache-ownership.js';
+import { useCurrentRuntime } from './use-current-runtime.js';
+export function useReadableSessionId(sessionId, beeuniSessionScope) {
+    const runtimeScope = useCurrentRuntime((state) => state.sandboxId) ?? 'none';
+    const cacheOwnerScope = resolveSessionCacheOwnerScope(runtimeScope, beeuniSessionScope);
+    const currentOwner = getSessionCacheOwnership(sessionId);
+    const cacheBelongsToAnotherRuntime = !!sessionId && sessionCacheOwnerScopesConflict(currentOwner, cacheOwnerScope);
+    return cacheBelongsToAnotherRuntime ? '' : sessionId;
+}
+export function selectSessionRows(state, sessionId) {
+    return state.buildSessionMessages(sessionId, state.messages[sessionId], state.parts);
+}
+const toolSignatures = new WeakMap();
+function toolSignature(parts) {
+    if (!parts)
+        return '';
+    const cached = toolSignatures.get(parts);
+    if (cached !== undefined)
+        return cached;
+    let signature = '';
+    for (const part of parts) {
+        if (part.type !== 'tool')
+            continue;
+        const input = part.state.input;
+        const hasInput = !!input && typeof input === 'object' && Object.keys(input).length > 0;
+        signature += `,${part.id}:${part.state.status}:${hasInput ? 1 : 0}`;
+    }
+    toolSignatures.set(parts, signature);
+    return signature;
+}
+const SHAPE_CACHE_LIMIT = 20;
+const shapeKeys = new Map();
+export function selectTranscriptShapeKey(state, sessionId) {
+    const messages = state.messages[sessionId];
+    if (!messages)
+        return '';
+    const cached = shapeKeys.get(sessionId);
+    if (cached && cached.messages === messages) {
+        let same = true;
+        for (let i = 0; i < messages.length; i++) {
+            const ref = state.parts[messages[i].id];
+            if (ref === cached.partRefs[i])
+                continue;
+            if (messages[i].role === 'assistant' && toolSignature(ref) !== toolSignature(cached.partRefs[i])) {
+                same = false;
+                break;
+            }
+            cached.partRefs[i] = ref;
+        }
+        if (same)
+            return cached.key;
+    }
+    let key = `${messages.length}`;
+    const partRefs = [];
+    for (const info of messages) {
+        const parts = state.parts[info.id];
+        partRefs.push(parts);
+        key += `|${info.id}`;
+        if (info.role === 'assistant')
+            key += toolSignature(parts);
+    }
+    shapeKeys.delete(sessionId);
+    shapeKeys.set(sessionId, { messages, partRefs, key });
+    if (shapeKeys.size > SHAPE_CACHE_LIMIT) {
+        const oldest = shapeKeys.keys().next().value;
+        if (oldest !== undefined)
+            shapeKeys.delete(oldest);
+    }
+    return key;
+}