@beeuni/sdk 0.1.0

package/dist/react/use-opencode-sessions/keys.js

@@ -0,0 +1,38 @@
+'use client';
+import { useSandboxConnectionStore } from '../../browser/stores/sandbox-connection-store.js';
+import { getActiveRuntimeUrl } from '../../core/session/server-store/active.js';
+import { useCurrentRuntime } from '../use-current-runtime.js';
+import { activeServerKey } from './shared.js';
+export const runtimeKeys = {
+    all: ['opencode'],
+    sessions: (serverId) => ['opencode', 'sessions', serverId ?? activeServerKey()],
+    session: (id) => ['opencode', 'session', id],
+    messages: (sessionId) => ['opencode', 'session', sessionId, 'messages'],
+    sessionTodo: (sessionId) => ['opencode', 'session-todo', sessionId],
+    runtimeSession: (id, serverId) => ['opencode', 'session', id, serverId ?? activeServerKey()],
+    runtimeMessages: (sessionId, serverId) => ['opencode', 'session', sessionId, 'messages', serverId ?? activeServerKey()],
+    agents: () => ['opencode', 'agents', activeServerKey()],
+    toolIds: () => ['opencode', 'tool-ids', activeServerKey()],
+    tools: (providerID, modelID) => ['opencode', 'tools', providerID, modelID, activeServerKey()],
+    skills: () => ['opencode', 'skills', activeServerKey()],
+    projects: () => ['opencode', 'projects', activeServerKey()],
+    currentProject: () => ['opencode', 'project', 'current', activeServerKey()],
+    commands: () => ['opencode', 'commands', activeServerKey()],
+    providers: () => ['opencode', 'providers', activeServerKey()],
+    pathInfo: () => ['opencode', 'path-info', activeServerKey()],
+    mcpStatus: () => ['opencode', 'mcp-status', activeServerKey()],
+    worktrees: () => ['opencode', 'worktrees', activeServerKey()],
+    vcsDiff: (mode, serverId) => ['opencode', 'vcs-diff', mode, serverId ?? activeServerKey()],
+    vcsDiffAll: () => ['opencode', 'vcs-diff'],
+};
+export function resetRuntimeQueries(queryClient) {
+    queryClient.removeQueries({ queryKey: runtimeKeys.all });
+}
+export function useRuntimeReady() {
+    const connectedHealthy = useSandboxConnectionStore((s) => s.status === 'connected' && s.healthy === true);
+    const runtimeUrl = useCurrentRuntime((s) => s.url);
+    const hasUrl = !!(runtimeUrl || getActiveRuntimeUrl());
+    return connectedHealthy && hasUrl;
+}
+export const opencodeKeys = runtimeKeys;
+export const useOpenCodeRuntimeReady = useRuntimeReady;

package/dist/react/use-opencode-sessions/mcp.d.ts

@@ -0,0 +1,2 @@
+import type { McpStatus } from '../../core/runtime/runtime-types.js';
+export declare function useOpenCodeMcpStatus(): import("@tanstack/react-query").UseQueryResult<Record<string, McpStatus>, Error>;

package/dist/react/use-opencode-sessions/mcp.js

@@ -0,0 +1,19 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../../core/runtime/client.js';
+import { runtimeKeys, useRuntimeReady } from './keys.js';
+import { unwrap } from './shared.js';
+export function useOpenCodeMcpStatus() {
+    const runtimeReady = useRuntimeReady();
+    return useQuery({
+        queryKey: runtimeKeys.mcpStatus(),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.mcp.status();
+            return unwrap(result);
+        },
+        enabled: runtimeReady,
+        staleTime: Infinity,
+        gcTime: 5 * 60 * 1000,
+    });
+}

package/dist/react/use-opencode-sessions/messages.d.ts

@@ -0,0 +1,57 @@
+import { type MessageWithParts } from '../../browser/stores/sync-store.js';
+import type { PromptPart, SendMessageOptions } from './keys.js';
+export declare function extractSendErrorMessage(error: unknown): string;
+export declare function isRuntimeNotReadyError(error: unknown): boolean;
+export declare function isTransientSendStatus(status: number | undefined): boolean;
+export declare function getSendRetryDelayMs(attempt: number, status: number | undefined, error: unknown): number | null;
+export declare function useRuntimeMessages(sessionId: string, options?: {
+    ignoreStreamedText?: boolean;
+}): {
+    data: MessageWithParts[] | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    error: null;
+    refetch: () => Promise<{
+        data: MessageWithParts[];
+    }>;
+};
+export declare function ascendingId(prefix?: 'msg' | 'prt'): string;
+export declare function mintSessionWireMessageId(sessionId: string, clientMessageId?: string): string;
+export declare function abortInFlightDeliveries(sessionId: string): number;
+export interface SendRuntimeMessageArgs {
+    sessionId: string;
+    parts: PromptPart[];
+    options?: SendMessageOptions;
+    messageID?: string;
+    clientMessageId?: string;
+}
+export interface SendRuntimeMessageError extends Error {
+    status?: number;
+    response?: {
+        status: number;
+    };
+    data?: unknown;
+}
+export declare function promptRuntimeMessage({ sessionId, parts, options, messageID, clientMessageId, }: SendRuntimeMessageArgs): Promise<void>;
+export declare function useSendRuntimeMessage(): import("@tanstack/react-query").UseMutationResult<void, Error, SendRuntimeMessageArgs, unknown>;
+export declare function abortRuntimeSession(sessionId: string): Promise<void>;
+export declare function useAbortRuntimeSession(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+export type AbortSettlement = {
+    status: 'aborted';
+} | {
+    status: 'failed';
+    error: unknown;
+} | {
+    status: 'timed-out';
+} | {
+    status: 'skipped';
+};
+export declare function awaitAbortSettlement(runAbort: () => Promise<void>, timeoutMs?: number): Promise<AbortSettlement>;
+export declare const isOpenCodeNotReadyError: typeof isRuntimeNotReadyError;
+export declare const useOpenCodeMessages: typeof useRuntimeMessages;
+export type SendOpenCodeMessageArgs = SendRuntimeMessageArgs;
+export type SendOpenCodeMessageError = SendRuntimeMessageError;
+export declare const promptOpenCodeMessage: typeof promptRuntimeMessage;
+export declare const useSendOpenCodeMessage: typeof useSendRuntimeMessage;
+export declare const abortOpenCodeSession: typeof abortRuntimeSession;
+export declare const useAbortOpenCodeSession: typeof useAbortRuntimeSession;

package/dist/react/use-opencode-sessions/messages.js

@@ -0,0 +1,342 @@
+'use client';
+import { useMutation } from '@tanstack/react-query';
+import { useEffect, useRef } from 'react';
+import { getClient } from '../../core/runtime/client.js';
+import { logger } from '../../core/http/logger.js';
+import { isAbortError } from '../../core/http/abort-error.js';
+import { useSyncStore } from '../../browser/stores/sync-store.js';
+import { mintWireMessageId } from '../../core/session/wire-message-id.js';
+import { canQueryRuntimeSession, unwrap } from './shared.js';
+const TRANSIENT_BACKOFF_MS = [400, 1000, 2000];
+const BOOT_BACKOFF_MS = [400, 800, 1500, 2500, 4000, 4000, 4000, 4000, 4000, 4000];
+export function extractSendErrorMessage(error) {
+    if (!error)
+        return '';
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'object') {
+        const err = error;
+        const root = err.data ?? err;
+        const msg = root.message || err.message || root.error || err.error;
+        if (typeof msg === 'string')
+            return msg;
+        try {
+            return JSON.stringify(err);
+        }
+        catch {
+            return '';
+        }
+    }
+    return String(error);
+}
+export function isRuntimeNotReadyError(error) {
+    return /opencode not ready|not ready|not yet ready|waking|booting|still booting|provision/i.test(extractSendErrorMessage(error));
+}
+export function isTransientSendStatus(status) {
+    return status === undefined || status >= 500 || status === 408 || status === 429;
+}
+export function getSendRetryDelayMs(attempt, status, error) {
+    const isBoot = status === 503 || isRuntimeNotReadyError(error);
+    const schedule = isBoot
+        ? BOOT_BACKOFF_MS
+        : isTransientSendStatus(status)
+            ? TRANSIENT_BACKOFF_MS
+            : null;
+    if (!schedule)
+        return null;
+    if (attempt < 1 || attempt > schedule.length)
+        return null;
+    return schedule[attempt - 1];
+}
+export function useRuntimeMessages(sessionId, options = {}) {
+    const { ignoreStreamedText = false } = options;
+    useEffect(() => {
+        if (!canQueryRuntimeSession(sessionId))
+            return;
+        return useSyncStore.getState().retainSession(sessionId);
+    }, [sessionId]);
+    const structuralRef = useRef(null);
+    const messages = useSyncStore((s) => {
+        const rows = s.buildSessionMessages(sessionId, s.messages[sessionId], s.parts);
+        if (!ignoreStreamedText)
+            return rows;
+        const previous = structuralRef.current;
+        if (previous && previous.sessionId === sessionId && sameStructure(previous.rows, rows)) {
+            return previous.rows;
+        }
+        structuralRef.current = { sessionId, rows };
+        return rows;
+    });
+    const isLoading = !useSyncStore((s) => sessionId in s.messages);
+    return {
+        data: messages.length > 0 ? messages : undefined,
+        isLoading,
+        isError: false,
+        error: null,
+        refetch: async () => ({ data: messages }),
+    };
+}
+function isStreamedTextPart(part) {
+    return part.type === 'text' || part.type === 'reasoning';
+}
+function sameStructure(a, b) {
+    if (a === b)
+        return true;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const left = a[i];
+        const right = b[i];
+        if (left === right)
+            continue;
+        if (left.info !== right.info)
+            return false;
+        if (left.parts === right.parts)
+            continue;
+        let j = 0;
+        let k = 0;
+        for (;;) {
+            while (j < left.parts.length && isStreamedTextPart(left.parts[j]))
+                j++;
+            while (k < right.parts.length && isStreamedTextPart(right.parts[k]))
+                k++;
+            if (j === left.parts.length || k === right.parts.length) {
+                if (j !== left.parts.length || k !== right.parts.length)
+                    return false;
+                break;
+            }
+            if (left.parts[j] !== right.parts[k])
+                return false;
+            j++;
+            k++;
+        }
+        if (countStreamed(left.parts) !== countStreamed(right.parts))
+            return false;
+    }
+    return true;
+}
+function countStreamed(parts) {
+    let count = 0;
+    for (const part of parts)
+        if (isStreamedTextPart(part))
+            count++;
+    return count;
+}
+let lastIdTimestamp = 0;
+let idCounter = 0;
+export function ascendingId(prefix = 'msg') {
+    const now = Date.now();
+    if (now !== lastIdTimestamp) {
+        lastIdTimestamp = now;
+        idCounter = 0;
+    }
+    idCounter++;
+    const encoded = BigInt(now) * BigInt(0x1000) + BigInt(idCounter);
+    const hex = encoded.toString(16).padStart(12, '0').slice(0, 12);
+    const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+    let rand = '';
+    const bytes = new Uint8Array(32);
+    while (rand.length < 14) {
+        crypto.getRandomValues(bytes);
+        for (const b of bytes)
+            if (b < 248 && rand.length < 14)
+                rand += chars[b % 62];
+    }
+    return `${prefix}_${hex}${rand}`;
+}
+let lastMintedSessionId = '';
+let lastMintedWireId = '';
+function mintPromptMessageId(sessionId) {
+    const known = (useSyncStore.getState().messages[sessionId] ?? []).map((message) => message?.id);
+    if (sessionId === lastMintedSessionId && lastMintedWireId)
+        known.push(lastMintedWireId);
+    const minted = mintWireMessageId({ after: known });
+    lastMintedSessionId = sessionId;
+    lastMintedWireId = minted;
+    return minted;
+}
+const MAX_REMEMBERED_SUBMISSIONS = 256;
+const submissionWireIds = new Map();
+function submissionWireId(sessionId, clientMessageId) {
+    if (!clientMessageId)
+        return mintPromptMessageId(sessionId);
+    const key = `${sessionId}\0${clientMessageId}`;
+    const known = submissionWireIds.get(key);
+    if (known)
+        return known;
+    const minted = mintPromptMessageId(sessionId);
+    submissionWireIds.set(key, minted);
+    while (submissionWireIds.size > MAX_REMEMBERED_SUBMISSIONS) {
+        const oldest = submissionWireIds.keys().next().value;
+        if (oldest === undefined)
+            break;
+        submissionWireIds.delete(oldest);
+    }
+    return minted;
+}
+export function mintSessionWireMessageId(sessionId, clientMessageId) {
+    return submissionWireId(sessionId, clientMessageId);
+}
+const inFlightDeliveries = new Map();
+function registerDelivery(sessionId, controller) {
+    let set = inFlightDeliveries.get(sessionId);
+    if (!set) {
+        set = new Set();
+        inFlightDeliveries.set(sessionId, set);
+    }
+    set.add(controller);
+    return () => {
+        set?.delete(controller);
+        if (set && set.size === 0)
+            inFlightDeliveries.delete(sessionId);
+    };
+}
+export function abortInFlightDeliveries(sessionId) {
+    const set = inFlightDeliveries.get(sessionId);
+    if (!set || set.size === 0)
+        return 0;
+    const controllers = [...set];
+    for (const controller of controllers)
+        controller.abort();
+    return controllers.length;
+}
+function deliveryAbortError() {
+    const err = new Error('The operation was aborted.');
+    err.name = 'AbortError';
+    return err;
+}
+function abortableDelay(ms, signal) {
+    if (signal.aborted)
+        return Promise.reject(deliveryAbortError());
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(deliveryAbortError());
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+export async function promptRuntimeMessage({ sessionId, parts, options, messageID, clientMessageId, }) {
+    const mappedParts = parts.map((p) => {
+        if (p.type === 'file')
+            return { type: 'file', mime: p.mime, url: p.url, filename: p.filename, source: p.source };
+        if (p.type === 'agent')
+            return { type: 'agent', name: p.name, source: p.source };
+        return { type: 'text', text: p.text };
+    });
+    const promptMessageId = messageID ?? submissionWireId(sessionId, clientMessageId);
+    const payload = {
+        sessionID: sessionId,
+        parts: mappedParts,
+        messageID: promptMessageId,
+        ...(options?.directory && { directory: options.directory }),
+        ...(options?.model && { model: options.model }),
+        ...(options?.agent && { agent: options.agent }),
+        ...(options?.variant && { variant: options.variant }),
+    };
+    const controller = new AbortController();
+    const unregister = registerDelivery(sessionId, controller);
+    try {
+        for (let attempt = 1;; attempt++) {
+            if (controller.signal.aborted)
+                throw deliveryAbortError();
+            let status;
+            let error;
+            try {
+                const client = getClient();
+                const result = await client.session.promptAsync(payload, { signal: controller.signal });
+                if (!result?.error)
+                    return;
+                error = result.error;
+                status = result.response?.status;
+            }
+            catch (err) {
+                if (controller.signal.aborted || isAbortError(err))
+                    throw deliveryAbortError();
+                error = err;
+            }
+            const delay = getSendRetryDelayMs(attempt, status, error);
+            if (delay === null) {
+                const err = error && typeof error === 'object' ? error : undefined;
+                const errData = err?.data && typeof err.data === 'object' ? err.data : undefined;
+                const message = errData?.message || err?.message || 'Failed to send message';
+                const wrapped = new Error(typeof message === 'string' ? message : 'Failed to send message');
+                if (status) {
+                    wrapped.status = status;
+                    wrapped.response = { status };
+                }
+                wrapped.data = err?.data ?? err;
+                throw wrapped;
+            }
+            logger.warn('promptRuntimeMessage retrying send', { sessionId, attempt, status });
+            await abortableDelay(delay, controller.signal);
+        }
+    }
+    finally {
+        unregister();
+    }
+}
+export function useSendRuntimeMessage() {
+    return useMutation({
+        mutationFn: promptRuntimeMessage,
+        retry: false,
+    });
+}
+export async function abortRuntimeSession(sessionId) {
+    const client = getClient();
+    const result = await client.session.abort({ sessionID: sessionId });
+    unwrap(result);
+    try {
+        const statusResult = await client.session.status();
+        const statuses = statusResult.data;
+        const serverStatus = statuses?.[sessionId];
+        if (serverStatus && serverStatus.type !== 'idle') {
+            useSyncStore.getState().setStatus(sessionId, serverStatus);
+        }
+    }
+    catch {
+    }
+}
+export function useAbortRuntimeSession() {
+    return useMutation({
+        mutationFn: abortRuntimeSession,
+        retry: 2,
+        retryDelay: 300,
+        onError: () => { },
+    });
+}
+const DEFAULT_ABORT_SETTLEMENT_TIMEOUT_MS = 5000;
+export async function awaitAbortSettlement(runAbort, timeoutMs = DEFAULT_ABORT_SETTLEMENT_TIMEOUT_MS) {
+    let timer;
+    const timedOut = new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ status: 'timed-out' }), timeoutMs);
+    });
+    const settled = (async () => {
+        try {
+            await runAbort();
+            return { status: 'aborted' };
+        }
+        catch (error) {
+            return { status: 'failed', error };
+        }
+    })();
+    try {
+        return await Promise.race([settled, timedOut]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+export const isOpenCodeNotReadyError = isRuntimeNotReadyError;
+export const useOpenCodeMessages = useRuntimeMessages;
+export const promptOpenCodeMessage = promptRuntimeMessage;
+export const useSendOpenCodeMessage = useSendRuntimeMessage;
+export const abortOpenCodeSession = abortRuntimeSession;
+export const useAbortOpenCodeSession = useAbortRuntimeSession;

package/dist/react/use-opencode-sessions/no-compaction-model-error.d.ts

@@ -0,0 +1,3 @@
+export declare class NoCompactionModelError extends Error {
+    constructor(message?: string);
+}

package/dist/react/use-opencode-sessions/no-compaction-model-error.js

@@ -0,0 +1,6 @@
+export class NoCompactionModelError extends Error {
+    constructor(message = 'No model available for compaction. Please configure a model in settings.') {
+        super(message);
+        this.name = 'NoCompactionModelError';
+    }
+}

package/dist/react/use-opencode-sessions/parts.d.ts

@@ -0,0 +1,12 @@
+import type { Part } from '../../core/runtime/runtime-types.js';
+export declare function useUpdatePart(): import("@tanstack/react-query").UseMutationResult<import("../../index.js").BeeuniPart, Error, {
+    sessionId: string;
+    messageId: string;
+    partId: string;
+    part: Partial<Part>;
+}, unknown>;
+export declare function useDeletePart(): import("@tanstack/react-query").UseMutationResult<boolean, Error, {
+    sessionId: string;
+    messageId: string;
+    partId: string;
+}, unknown>;

package/dist/react/use-opencode-sessions/parts.js

@@ -0,0 +1,31 @@
+'use client';
+import { useMutation } from '@tanstack/react-query';
+import { getClient } from '../../core/runtime/client.js';
+import { unwrap } from './shared.js';
+export function useUpdatePart() {
+    return useMutation({
+        mutationFn: async ({ sessionId, messageId, partId, part, }) => {
+            const client = getClient();
+            const result = await client.part.update({
+                sessionID: sessionId,
+                messageID: messageId,
+                partID: partId,
+                part: part,
+            });
+            return unwrap(result);
+        },
+    });
+}
+export function useDeletePart() {
+    return useMutation({
+        mutationFn: async ({ sessionId, messageId, partId, }) => {
+            const client = getClient();
+            const result = await client.part.delete({
+                sessionID: sessionId,
+                messageID: messageId,
+                partID: partId,
+            });
+            return unwrap(result);
+        },
+    });
+}

package/dist/react/use-opencode-sessions/permissions.d.ts

@@ -0,0 +1,5 @@
+export declare function replyToPermission(requestId: string, reply: 'once' | 'always' | 'reject', message?: string): Promise<void>;
+export declare function allowAllPermissionsForSession(sessionID: string): Promise<void>;
+export declare function resetSessionPermissions(sessionID: string): Promise<void>;
+export declare function replyToQuestion(requestId: string, answers: string[][]): Promise<void>;
+export declare function rejectQuestion(requestId: string): Promise<void>;

package/dist/react/use-opencode-sessions/permissions.js

@@ -0,0 +1,44 @@
+import { getClient } from '../../core/runtime/client.js';
+import { unwrap } from './shared.js';
+export async function replyToPermission(requestId, reply, message) {
+    const client = getClient();
+    const result = await client.permission.reply({ requestID: requestId, reply, message });
+    unwrap(result);
+}
+const KNOWN_PERMISSION_TYPES = [
+    'bash',
+    'edit',
+    'write',
+    'read',
+    'webfetch',
+    'mcp',
+    'doom_loop',
+];
+export async function allowAllPermissionsForSession(sessionID) {
+    const client = getClient();
+    const ruleset = [
+        { permission: '*', pattern: '*', action: 'allow' },
+        ...KNOWN_PERMISSION_TYPES.map((permission) => ({
+            permission,
+            pattern: '*',
+            action: 'allow',
+        })),
+    ];
+    const result = await client.session.update({ sessionID, permission: ruleset });
+    unwrap(result);
+}
+export async function resetSessionPermissions(sessionID) {
+    const client = getClient();
+    const result = await client.session.update({ sessionID, permission: [] });
+    unwrap(result);
+}
+export async function replyToQuestion(requestId, answers) {
+    const client = getClient();
+    const result = await client.question.reply({ requestID: requestId, answers });
+    unwrap(result);
+}
+export async function rejectQuestion(requestId) {
+    const client = getClient();
+    const result = await client.question.reject({ requestID: requestId });
+    unwrap(result);
+}

package/dist/react/use-opencode-sessions/projects.d.ts

@@ -0,0 +1,6 @@
+import type { Project, Path as PathInfo } from '../../core/runtime/runtime-types.js';
+export declare function useOpenCodeProjects(): import("@tanstack/react-query").UseQueryResult<Project[], Error>;
+export declare function useRuntimeCurrentProject(): import("@tanstack/react-query").UseQueryResult<Project, Error>;
+export declare function useRuntimePathInfo(): import("@tanstack/react-query").UseQueryResult<PathInfo, Error>;
+export declare const useOpenCodeCurrentProject: typeof useRuntimeCurrentProject;
+export declare const useOpenCodePathInfo: typeof useRuntimePathInfo;

package/dist/react/use-opencode-sessions/projects.js

@@ -0,0 +1,49 @@
+'use client';
+import { useQuery } from '@tanstack/react-query';
+import { getClient } from '../../core/runtime/client.js';
+import { runtimeKeys, useRuntimeReady } from './keys.js';
+import { unwrap } from './shared.js';
+export function useOpenCodeProjects() {
+    const runtimeReady = useRuntimeReady();
+    return useQuery({
+        queryKey: runtimeKeys.projects(),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.project.list();
+            return unwrap(result);
+        },
+        enabled: runtimeReady,
+        staleTime: Infinity,
+        gcTime: 5 * 60 * 1000,
+    });
+}
+export function useRuntimeCurrentProject() {
+    const runtimeReady = useRuntimeReady();
+    return useQuery({
+        queryKey: runtimeKeys.currentProject(),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.project.current();
+            return unwrap(result);
+        },
+        enabled: runtimeReady,
+        staleTime: Infinity,
+        gcTime: 5 * 60 * 1000,
+    });
+}
+export function useRuntimePathInfo() {
+    const runtimeReady = useRuntimeReady();
+    return useQuery({
+        queryKey: runtimeKeys.pathInfo(),
+        queryFn: async () => {
+            const client = getClient();
+            const result = await client.path.get();
+            return unwrap(result);
+        },
+        enabled: runtimeReady,
+        staleTime: Infinity,
+        gcTime: 10 * 60 * 1000,
+    });
+}
+export const useOpenCodeCurrentProject = useRuntimeCurrentProject;
+export const useOpenCodePathInfo = useRuntimePathInfo;

package/dist/react/use-opencode-sessions/provider-load-plan.d.ts

@@ -0,0 +1,5 @@
+export declare function shouldLoadProjectModelPicker(input: {
+    projectId: string | null;
+    projectModeKnown: boolean;
+    projectGatewayEnabled: boolean;
+}): boolean;

package/dist/react/use-opencode-sessions/provider-load-plan.js

@@ -0,0 +1,3 @@
+export function shouldLoadProjectModelPicker(input) {
+    return Boolean(input.projectId && (!input.projectModeKnown || input.projectGatewayEnabled));
+}

package/dist/react/use-opencode-sessions/providers.d.ts

@@ -0,0 +1,10 @@
+import { GATEWAY_PROVIDER_IDS } from '../../core/models/provider-selection.js';
+export { GATEWAY_PROVIDER_IDS };
+export declare function useRuntimeProviders(): import("@tanstack/react-query").UseQueryResult<{
+    all: Array<import("../../index.js").Provider>;
+    default: {
+        [key: string]: string;
+    };
+    connected: Array<string>;
+}, Error>;
+export declare const useOpenCodeProviders: typeof useRuntimeProviders;