@beeuni/sdk 0.1.0

package/dist/core/http/fresh-sessions.d.ts

@@ -0,0 +1,3 @@
+export declare function markSessionFresh(id: string | null | undefined): void;
+export declare function isSessionFresh(id: string | null | undefined): boolean;
+export declare function clearSessionFresh(id: string | null | undefined): void;

package/dist/core/http/fresh-sessions.js

@@ -0,0 +1,17 @@
+const freshSessions = new Set();
+const MAX_FRESH_SESSIONS = 500;
+export function markSessionFresh(id) {
+    if (!id)
+        return;
+    freshSessions.add(id);
+    if (freshSessions.size > MAX_FRESH_SESSIONS) {
+        freshSessions.delete(freshSessions.values().next().value);
+    }
+}
+export function isSessionFresh(id) {
+    return !!id && freshSessions.has(id);
+}
+export function clearSessionFresh(id) {
+    if (id)
+        freshSessions.delete(id);
+}

package/dist/core/http/impersonation.d.ts

@@ -0,0 +1,14 @@
+export declare const IMPERSONATION_HEADER = "X-Beeuni-Impersonate";
+export interface ImpersonationSession {
+    grantId: string;
+    accountId: string;
+    accountName?: string | null;
+    expiresAt: string;
+}
+export declare function isImpersonationSessionLive(session: ImpersonationSession | null | undefined, now?: number): boolean;
+export declare function getImpersonationSession(): ImpersonationSession | null;
+export declare function setImpersonationSession(session: ImpersonationSession | null): void;
+export declare function clearImpersonationSession(): void;
+export declare function subscribeToImpersonation(listener: () => void): () => void;
+export declare function shouldAttachImpersonation(url: string): boolean;
+export declare function impersonationHeaders(url?: string): Record<string, string>;

package/dist/core/http/impersonation.js

@@ -0,0 +1,110 @@
+export const IMPERSONATION_HEADER = 'X-Beeuni-Impersonate';
+const STORAGE_KEY = 'beeuni.impersonation';
+let current = null;
+let hydrated = false;
+const listeners = new Set();
+function storage() {
+    try {
+        if (typeof sessionStorage === 'undefined')
+            return null;
+        return sessionStorage;
+    }
+    catch {
+        return null;
+    }
+}
+export function isImpersonationSessionLive(session, now = Date.now()) {
+    if (!session || !session.grantId || !session.accountId)
+        return false;
+    const expiry = Date.parse(session.expiresAt);
+    return Number.isFinite(expiry) && expiry > now;
+}
+function parse(raw) {
+    if (!raw)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed?.grantId !== 'string' || typeof parsed?.accountId !== 'string')
+            return null;
+        return {
+            grantId: parsed.grantId,
+            accountId: parsed.accountId,
+            accountName: typeof parsed.accountName === 'string' ? parsed.accountName : null,
+            expiresAt: typeof parsed.expiresAt === 'string' ? parsed.expiresAt : '',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function notify() {
+    for (const listener of listeners) {
+        try {
+            listener();
+        }
+        catch {
+        }
+    }
+}
+export function getImpersonationSession() {
+    if (!hydrated) {
+        hydrated = true;
+        current = parse(storage()?.getItem(STORAGE_KEY) ?? null);
+    }
+    if (current && !isImpersonationSessionLive(current)) {
+        clearImpersonationSession();
+        return null;
+    }
+    return current;
+}
+export function setImpersonationSession(session) {
+    hydrated = true;
+    if (!session) {
+        clearImpersonationSession();
+        return;
+    }
+    current = session;
+    try {
+        storage()?.setItem(STORAGE_KEY, JSON.stringify(session));
+    }
+    catch {
+    }
+    notify();
+}
+export function clearImpersonationSession() {
+    hydrated = true;
+    const had = current !== null;
+    current = null;
+    try {
+        storage()?.removeItem(STORAGE_KEY);
+    }
+    catch {
+    }
+    if (had)
+        notify();
+}
+export function subscribeToImpersonation(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+const ADMIN_CONSOLE_PATH_RE = /(^|\/)admin\/(api|analytics)(\/|$)/;
+export function shouldAttachImpersonation(url) {
+    let path = url;
+    if (/^https?:\/\//.test(url)) {
+        try {
+            path = new URL(url).pathname;
+        }
+        catch {
+            path = url;
+        }
+    }
+    return !ADMIN_CONSOLE_PATH_RE.test(path);
+}
+export function impersonationHeaders(url) {
+    if (url !== undefined && !shouldAttachImpersonation(url))
+        return {};
+    const session = getImpersonationSession();
+    return session ? { [IMPERSONATION_HEADER]: session.grantId } : {};
+}

package/dist/core/http/instance-routes.d.ts

@@ -0,0 +1,16 @@
+export declare const ACTIVE_INSTANCE_COOKIE = "beeuni-active-instance";
+export declare const INSTANCE_SCOPED_ROUTES: readonly ["/dashboard", "/agents", "/p", "/workspace", "/settings", "/browser", "/desktop", "/services", "/sessions", "/terminal", "/files", "/scheduled-tasks", "/commands", "/tools", "/configuration", "/changelog", "/legacy", "/credits-explained"];
+export declare function isInstanceScopedAppPath(pathname: string): boolean;
+export declare function extractInstanceRoute(pathname: string): {
+    instanceId: string;
+    innerPath: string;
+} | null;
+export declare function isInstanceDetailPath(pathname: string): boolean;
+export declare function stripInstancePrefix(pathname: string): string;
+export declare function buildInstancePath(instanceId: string, pathname: string): string;
+export declare function getCurrentInstanceIdFromPathname(pathname: string | null | undefined): string | null;
+export declare function getCurrentInstanceIdFromWindow(): string | null;
+export declare function getActiveInstanceIdFromCookie(): string | null;
+export declare function setActiveInstanceCookie(instanceId?: string | null): void;
+export declare function toInstanceAwarePath(pathname: string, instanceId?: string | null): string;
+export declare function normalizeAppPathname(pathname: string): string;

package/dist/core/http/instance-routes.js

@@ -0,0 +1,99 @@
+export const ACTIVE_INSTANCE_COOKIE = 'beeuni-active-instance';
+export const INSTANCE_SCOPED_ROUTES = [
+    '/dashboard',
+    '/agents',
+    '/p',
+    '/workspace',
+    '/settings',
+    '/browser',
+    '/desktop',
+    '/services',
+    '/sessions',
+    '/terminal',
+    '/files',
+    '/scheduled-tasks',
+    '/commands',
+    '/tools',
+    '/configuration',
+    '/changelog',
+    '/legacy',
+    '/credits-explained',
+];
+export function isInstanceScopedAppPath(pathname) {
+    return INSTANCE_SCOPED_ROUTES.some((route) => pathname === route || pathname.startsWith(`${route}/`));
+}
+export function extractInstanceRoute(pathname) {
+    const match = pathname.match(/^\/instances\/([^/]+)(?:\/(.*))?$/);
+    if (!match)
+        return null;
+    const instanceId = decodeURIComponent(match[1]);
+    const rest = match[2] ?? '';
+    return {
+        instanceId,
+        innerPath: rest ? `/${rest}` : '',
+    };
+}
+export function isInstanceDetailPath(pathname) {
+    const parsed = extractInstanceRoute(pathname);
+    return !!parsed && parsed.innerPath === '';
+}
+export function stripInstancePrefix(pathname) {
+    const parsed = extractInstanceRoute(pathname);
+    if (!parsed || !parsed.innerPath)
+        return pathname;
+    return parsed.innerPath;
+}
+export function buildInstancePath(instanceId, pathname) {
+    if (!instanceId)
+        return pathname;
+    if (!pathname.startsWith('/'))
+        pathname = `/${pathname}`;
+    if (pathname.startsWith('/instances/')) {
+        const parsed = extractInstanceRoute(pathname);
+        if (!parsed)
+            return pathname;
+        return `/instances/${encodeURIComponent(instanceId)}${parsed.innerPath}`;
+    }
+    if (!isInstanceScopedAppPath(pathname))
+        return pathname;
+    return `/instances/${encodeURIComponent(instanceId)}${pathname}`;
+}
+export function getCurrentInstanceIdFromPathname(pathname) {
+    if (!pathname)
+        return null;
+    return extractInstanceRoute(pathname)?.instanceId ?? null;
+}
+export function getCurrentInstanceIdFromWindow() {
+    if (typeof window === 'undefined')
+        return null;
+    return getCurrentInstanceIdFromPathname(window.location.pathname) || getActiveInstanceIdFromCookie();
+}
+export function getActiveInstanceIdFromCookie() {
+    if (typeof document === 'undefined')
+        return null;
+    const match = document.cookie.match(new RegExp(`(?:^|; )${ACTIVE_INSTANCE_COOKIE}=([^;]+)`));
+    return match ? decodeURIComponent(match[1]) : null;
+}
+export function setActiveInstanceCookie(instanceId) {
+    if (typeof document === 'undefined')
+        return;
+    const writeCookie = (value) => { document.cookie = value; };
+    if (typeof window !== 'undefined' && window.location.pathname.startsWith('/projects')) {
+        writeCookie(`${ACTIVE_INSTANCE_COOKIE}=; Max-Age=0; Path=/; SameSite=Lax`);
+        return;
+    }
+    if (!instanceId) {
+        writeCookie(`${ACTIVE_INSTANCE_COOKIE}=; Max-Age=0; Path=/; SameSite=Lax`);
+        return;
+    }
+    writeCookie(`${ACTIVE_INSTANCE_COOKIE}=${encodeURIComponent(instanceId)}; Path=/; SameSite=Lax`);
+}
+export function toInstanceAwarePath(pathname, instanceId) {
+    return instanceId ? buildInstancePath(instanceId, pathname) : pathname;
+}
+export function normalizeAppPathname(pathname) {
+    const parsed = extractInstanceRoute(pathname);
+    if (!parsed)
+        return pathname;
+    return parsed.innerPath || '/dashboard';
+}

package/dist/core/http/logger.d.ts

@@ -0,0 +1,10 @@
+interface LogExtra {
+    [key: string]: unknown;
+}
+export declare const logger: {
+    readonly debug: (message: string, extra?: LogExtra) => void;
+    readonly info: (message: string, extra?: LogExtra) => void;
+    readonly warn: (message: string, extra?: LogExtra) => void;
+    readonly error: (message: string, extra?: LogExtra) => void;
+};
+export {};

package/dist/core/http/logger.js

@@ -0,0 +1,29 @@
+import { getClient } from '../runtime/client.js';
+const SERVICE_NAME = 'frontend';
+function send(level, message, extra) {
+    const consoleFn = level === 'error'
+        ? console.error
+        : level === 'warn'
+            ? console.warn
+            : level === 'debug'
+                ? console.debug
+                : console.log;
+    consoleFn(`[${SERVICE_NAME}] ${message}`, ...(extra ? [extra] : []));
+    try {
+        const client = getClient();
+        client.app.log({
+            service: SERVICE_NAME,
+            level,
+            message,
+            extra,
+        });
+    }
+    catch {
+    }
+}
+export const logger = {
+    debug: (message, extra) => send('debug', message, extra),
+    info: (message, extra) => send('info', message, extra),
+    warn: (message, extra) => send('warn', message, extra),
+    error: (message, extra) => send('error', message, extra),
+};

package/dist/core/http/request.d.ts

@@ -0,0 +1,2 @@
+import type { ApiClientOptions, ApiResponse } from './api-client.js';
+export declare function makeRequest<T = any>(url: string, options?: RequestInit & ApiClientOptions): Promise<ApiResponse<T>>;

package/dist/core/http/request.js

@@ -0,0 +1,194 @@
+import { abortable, abortableDelay, createAbortError } from './abort.js';
+import { ApiError, AuthError } from './api/errors.js';
+import { platformConfig } from './config.js';
+import { handleErrorResponse } from './response-error.js';
+import { send } from './transport.js';
+const getApiUrl = () => platformConfig().backendUrl || '';
+const TRANSIENT_GATEWAY_STATUSES = new Set([502, 503, 504]);
+const isTransientGatewayStatus = (status) => TRANSIENT_GATEWAY_STATUSES.has(status);
+const isIdempotentMethod = (method) => {
+    const m = (method ?? 'GET').toUpperCase();
+    return m === 'GET' || m === 'HEAD';
+};
+const isRetryableOnTransportFailure = (method) => isIdempotentMethod(method) || (method ?? 'GET').toUpperCase() === 'DELETE';
+const TRANSIENT_READ_RETRIES = 2;
+const isAbortError = (error) => error?.name === 'AbortError' ||
+    error?.name === 'AbortSignal' ||
+    (error instanceof Error && error.message.includes('aborted'));
+export async function makeRequest(url, options = {}) {
+    const { showErrors = true, errorContext, timeout = 30000, deadlineCoversBody = false, ...fetchOptions } = options;
+    const controller = new AbortController();
+    const state = {
+        activeController: controller,
+        timeoutId: null,
+        isAborted: false,
+        didTimeout: false,
+    };
+    const abortFromCaller = () => state.activeController.abort();
+    fetchOptions.signal?.addEventListener('abort', abortFromCaller, { once: true });
+    try {
+        return await executeRequest(url, fetchOptions, showErrors, errorContext, timeout, deadlineCoversBody, controller, state);
+    }
+    finally {
+        fetchOptions.signal?.removeEventListener('abort', abortFromCaller);
+    }
+}
+async function executeRequest(url, fetchOptions, showErrors, errorContext, timeout, deadlineCoversBody, controller, state) {
+    try {
+        if (fetchOptions.signal?.aborted)
+            throw createAbortError();
+        state.timeoutId = setTimeout(() => {
+            if (!state.isAborted && !controller.signal.aborted) {
+                state.isAborted = true;
+                state.didTimeout = true;
+                controller.abort();
+            }
+        }, timeout);
+        const headers = {
+            ...(fetchOptions.body instanceof FormData ? {} : { 'Content-Type': 'application/json' }),
+            ...fetchOptions.headers,
+        };
+        const response = await retryRequest(url, fetchOptions, headers, timeout, deadlineCoversBody, controller, state);
+        if (response instanceof AuthError)
+            return { error: response, success: false };
+        if (!response.ok) {
+            return await handleErrorResponse(response, state.activeController.signal, showErrors, errorContext);
+        }
+        let data;
+        const contentType = response.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+            data = await abortable(response.json(), state.activeController.signal);
+        }
+        else if (contentType?.includes('text/')) {
+            data = (await abortable(response.text(), state.activeController.signal));
+        }
+        else {
+            data = (await abortable(response.blob(), state.activeController.signal));
+        }
+        return {
+            data,
+            success: true,
+            headers: response.headers,
+        };
+    }
+    catch (error) {
+        return handleRequestFailure(error, url, fetchOptions.method, showErrors, errorContext, timeout, state);
+    }
+    finally {
+        clearDeadline(state);
+    }
+}
+function clearDeadline(state) {
+    if (state.timeoutId)
+        clearTimeout(state.timeoutId);
+    state.timeoutId = null;
+}
+async function discardRetryResponse(response, signal, state) {
+    try {
+        await abortable(response.arrayBuffer(), signal);
+    }
+    catch (error) {
+        if (isAbortError(error))
+            throw error;
+    }
+    finally {
+        clearDeadline(state);
+    }
+}
+async function retryRequest(url, fetchOptions, headers, timeout, deadlineCoversBody, controller, state) {
+    const retryableRead = isIdempotentMethod(fetchOptions.method);
+    const retryableTransport = isRetryableOnTransportFailure(fetchOptions.method);
+    const maxAttempts = retryableTransport ? TRANSIENT_READ_RETRIES + 1 : 1;
+    let response;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        if (attempt > 0) {
+            await abortableDelay(250 * 2 ** (attempt - 1), fetchOptions.signal ?? undefined);
+        }
+        const attemptController = attempt === 0 ? controller : new AbortController();
+        state.activeController = attemptController;
+        if (fetchOptions.signal?.aborted)
+            attemptController.abort();
+        if (attempt > 0) {
+            state.timeoutId = setTimeout(() => {
+                state.didTimeout = true;
+                attemptController.abort();
+            }, timeout);
+        }
+        try {
+            response = await abortable(send(url, {
+                ...fetchOptions,
+                headers,
+                signal: attemptController.signal,
+                credentials: fetchOptions.credentials ?? 'omit',
+            }, { timeoutMs: null }), attemptController.signal);
+        }
+        catch (error) {
+            if (state.timeoutId) {
+                clearTimeout(state.timeoutId);
+                state.timeoutId = null;
+            }
+            if (error instanceof AuthError) {
+                return new AuthError();
+            }
+            const selfTimedOut = state.didTimeout && isAbortError(error) && !fetchOptions.signal?.aborted;
+            if (selfTimedOut && retryableTransport && attempt < maxAttempts - 1) {
+                state.didTimeout = false;
+                continue;
+            }
+            if (isAbortError(error) || attempt === maxAttempts - 1) {
+                throw error;
+            }
+            continue;
+        }
+        if (!retryableRead ||
+            !isTransientGatewayStatus(response.status) ||
+            attempt === maxAttempts - 1) {
+            if (!deadlineCoversBody)
+                clearDeadline(state);
+            return response;
+        }
+        await discardRetryResponse(response, attemptController.signal, state);
+    }
+    return response;
+}
+function handleRequestFailure(error, url, method, showErrors, errorContext, timeout, state) {
+    clearDeadline(state);
+    const requestWasAborted = isAbortError(error);
+    if (requestWasAborted) {
+        state.isAborted = true;
+    }
+    let apiError;
+    if (requestWasAborted) {
+        if (!state.didTimeout) {
+            return {
+                error: new ApiError('Request aborted', {
+                    name: 'AbortError',
+                    code: 'ABORTED',
+                }),
+                success: false,
+            };
+        }
+        const endpoint = url.replace(getApiUrl(), '') || url;
+        apiError = new ApiError(`Request timed out after ${Math.round(timeout / 1000)}s: ${endpoint}`, {
+            code: 'TIMEOUT',
+            url,
+            endpoint,
+            timeout,
+        });
+    }
+    else if (error instanceof Error) {
+        apiError = new ApiError(method === 'POST' && error instanceof TypeError && error.message === 'Failed to fetch'
+            ? `Failed to fetch: POST ${url.replace(getApiUrl(), '') || url}`
+            : error.message, { name: error.name || 'ApiError', stack: error.stack });
+        if (showErrors) {
+            platformConfig().onError?.(apiError, errorContext);
+        }
+    }
+    else {
+        apiError = new ApiError(String(error));
+        if (showErrors) {
+            platformConfig().onError?.(apiError, errorContext);
+        }
+    }
+    return { error: apiError, success: false };
+}

package/dist/core/http/response-error.d.ts

@@ -0,0 +1,2 @@
+import type { ApiResponse, ErrorContext } from './api-client.js';
+export declare function handleErrorResponse<T>(response: Response, signal: AbortSignal, showErrors: boolean, errorContext?: ErrorContext): Promise<ApiResponse<T>>;

package/dist/core/http/response-error.js

@@ -0,0 +1,92 @@
+import { abortable, createAbortError } from './abort.js';
+import { ACCOUNTS_LIST_UNAVAILABLE_CODE, ANALYTICS_UNAVAILABLE_CODE, FEATURE_NOT_SUPPORTED_CODE, MODEL_NOT_SERVABLE_CODE, PROVISION_IN_FLIGHT_CODE, } from './api-client.js';
+import { ApiError, RequestTooLargeError, parseBillingError } from './api/errors.js';
+import { platformConfig } from './config.js';
+const REQUEST_DEADLINE_CODE = 'request_deadline';
+const LEGACY_REQUEST_DEADLINE_MESSAGE = /^Request exceeded the \d+s server processing deadline$/;
+const isRequestDeadlineResponse = (status, errorData, message) => {
+    if (status !== 503)
+        return false;
+    const code = typeof errorData === 'object' && errorData !== null && 'code' in errorData
+        ? errorData.code
+        : undefined;
+    return code === REQUEST_DEADLINE_CODE || LEGACY_REQUEST_DEADLINE_MESSAGE.test(message);
+};
+const GIT_MIRROR_UNAVAILABLE_CODE = 'git_mirror_unavailable';
+const LEGACY_GIT_MIRROR_UNAVAILABLE_MESSAGE = /^git mirror is temporarily unavailable$/;
+const isGitMirrorUnavailableResponse = (status, errorData, message) => {
+    if (status !== 503)
+        return false;
+    const code = typeof errorData === 'object' && errorData !== null && 'code' in errorData
+        ? errorData.code
+        : undefined;
+    return (code === GIT_MIRROR_UNAVAILABLE_CODE || LEGACY_GIT_MIRROR_UNAVAILABLE_MESSAGE.test(message));
+};
+async function readErrorBody(response, signal) {
+    let message = `HTTP ${response.status}: ${response.statusText}`;
+    let data = null;
+    try {
+        data = await abortable(response.json(), signal);
+        if (typeof data.message === 'string')
+            message = data.message;
+        else if (data.error && typeof data.error === 'string')
+            message = data.error;
+        else if (typeof data.detail === 'string')
+            message = data.detail;
+        else if (typeof data.detail?.message === 'string')
+            message = data.detail.message;
+        else if (typeof data.reason === 'string')
+            message = data.reason;
+    }
+    catch { }
+    if (signal.aborted)
+        throw createAbortError();
+    return { message, data };
+}
+function isExpectedResponse(status, data, message) {
+    return (isRequestDeadlineResponse(status, data, message) ||
+        isGitMirrorUnavailableResponse(status, data, message) ||
+        (status === 501 && data?.code === FEATURE_NOT_SUPPORTED_CODE) ||
+        (status === 409 &&
+            (data?.code === MODEL_NOT_SERVABLE_CODE || data?.code === PROVISION_IN_FLIGHT_CODE)) ||
+        (status === 503 &&
+            (data?.code === ANALYTICS_UNAVAILABLE_CODE || data?.code === ACCOUNTS_LIST_UNAVAILABLE_CODE)));
+}
+export async function handleErrorResponse(response, signal, showErrors, errorContext) {
+    const { message, data } = await readErrorBody(response, signal);
+    let error = new ApiError(message, {
+        status: response.status,
+        response,
+        details: data || undefined,
+        data,
+        detail: data?.detail,
+        code: isRequestDeadlineResponse(response.status, data, message)
+            ? REQUEST_DEADLINE_CODE
+            : data?.code || data?.error_code || data?.detail?.error_code || response.status.toString(),
+    });
+    if (response.status === 402)
+        error = parseBillingError(error);
+    const remedyEvent = response.status !== 403
+        ? null
+        : data?.code === 'account_mfa_required'
+            ? 'beeuni:mfa-required'
+            : data?.code === 'sso_required'
+                ? 'beeuni:sso-required'
+                : null;
+    if (remedyEvent && typeof window !== 'undefined' && typeof window.dispatchEvent === 'function') {
+        try {
+            window.dispatchEvent(new CustomEvent(remedyEvent));
+        }
+        catch { }
+    }
+    if (response.status === 431) {
+        error = new RequestTooLargeError(431, {
+            message: 'Request is too large to process',
+            suggestion: 'Try uploading files one at a time, or reduce the number of files attached to your message.',
+        });
+    }
+    if (showErrors && !isExpectedResponse(response.status, data, message)) {
+        platformConfig().onError?.(error, errorContext);
+    }
+    return { error, success: false };
+}

package/dist/core/http/runtime-errors.d.ts

@@ -0,0 +1,32 @@
+export interface RuntimeConfigIssue {
+    path?: unknown[];
+    message?: string;
+}
+export interface RuntimeConfigInvalidError {
+    name: 'ConfigInvalidError';
+    data?: {
+        path?: string;
+        issues?: RuntimeConfigIssue[];
+    };
+}
+export type OpenCodeConfigIssue = RuntimeConfigIssue;
+export type OpenCodeConfigInvalidError = RuntimeConfigInvalidError;
+export declare function parseRuntimeErrorPayload(error: unknown): unknown;
+export declare const parseOpenCodeErrorPayload: typeof parseRuntimeErrorPayload;
+export declare function getRuntimeConfigInvalidError(error: unknown): RuntimeConfigInvalidError | null;
+export declare const getOpenCodeConfigInvalidError: typeof getRuntimeConfigInvalidError;
+export declare function isRuntimeConfigInvalidError(error: unknown): boolean;
+export declare const isOpenCodeConfigInvalidError: typeof isRuntimeConfigInvalidError;
+export declare const RUNTIME_NOT_READY_MARKERS: readonly ["runtime_not_ready", "sandbox runtime not ready", "opencode not ready"];
+export declare function isRuntimeNotReadyResponse(error: unknown): boolean;
+export declare function isSandboxNotReadyError(error: unknown): boolean;
+export declare function isRuntimeStartingError(error: unknown): boolean;
+export declare class SandboxNotReadyError extends Error {
+    constructor(detail?: string);
+}
+export declare function formatRuntimeError(error: unknown): {
+    title: string;
+    message: string;
+    detail?: string;
+};
+export declare const formatOpenCodeRuntimeError: typeof formatRuntimeError;