@beeuni/sdk 0.1.0

package/dist/core/http/runtime-errors.js

@@ -0,0 +1,116 @@
+function rawErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object') {
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return String(error);
+        }
+    }
+    return String(error ?? '');
+}
+export function parseRuntimeErrorPayload(error) {
+    const raw = rawErrorMessage(error).trim();
+    if (!raw)
+        return null;
+    const candidates = [
+        raw,
+        raw.replace(/^Failed to perform action:\s*/i, '').trim(),
+    ];
+    const objectStart = raw.indexOf('{');
+    if (objectStart >= 0)
+        candidates.push(raw.slice(objectStart));
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        try {
+            return JSON.parse(candidate);
+        }
+        catch {
+        }
+    }
+    return null;
+}
+export const parseOpenCodeErrorPayload = parseRuntimeErrorPayload;
+export function getRuntimeConfigInvalidError(error) {
+    const payload = parseRuntimeErrorPayload(error);
+    if (!payload || typeof payload !== 'object')
+        return null;
+    const maybe = payload;
+    return maybe.name === 'ConfigInvalidError' ? maybe : null;
+}
+export const getOpenCodeConfigInvalidError = getRuntimeConfigInvalidError;
+export function isRuntimeConfigInvalidError(error) {
+    return getRuntimeConfigInvalidError(error) !== null;
+}
+export const isOpenCodeConfigInvalidError = isRuntimeConfigInvalidError;
+const SANDBOX_NOT_READY_PATTERNS = [
+    /sandbox not ready/i,
+    /sandbox is not (?:ready|running)/i,
+    /opencode (?:session )?(?:is )?not ready/i,
+    /\bsandbox_not_ready\b/,
+    /\bsandbox_lifecycle_unavailable\b/,
+];
+export const RUNTIME_NOT_READY_MARKERS = [
+    'runtime_not_ready',
+    'sandbox runtime not ready',
+    'opencode not ready',
+];
+const RUNTIME_NOT_READY_PATTERN = /\bruntime_not_ready\b|sandbox runtime not ready|opencode not ready/i;
+export function isRuntimeNotReadyResponse(error) {
+    return RUNTIME_NOT_READY_PATTERN.test(rawErrorMessage(error));
+}
+export function isSandboxNotReadyError(error) {
+    const raw = rawErrorMessage(error);
+    if (!raw)
+        return false;
+    return isRuntimeNotReadyResponse(raw) || SANDBOX_NOT_READY_PATTERNS.some((pattern) => pattern.test(raw));
+}
+const RUNTIME_URL_NOT_PINNED = /server url not ready|sandbox is still loading/i;
+export function isRuntimeStartingError(error) {
+    return RUNTIME_URL_NOT_PINNED.test(rawErrorMessage(error)) || isSandboxNotReadyError(error);
+}
+export class SandboxNotReadyError extends Error {
+    constructor(detail) {
+        const trimmed = detail?.trim();
+        super(trimmed && isSandboxNotReadyError(trimmed)
+            ? trimmed
+            : trimmed
+                ? `sandbox not ready: ${trimmed}`
+                : 'sandbox not ready');
+        this.name = 'SandboxNotReadyError';
+    }
+}
+export function formatRuntimeError(error) {
+    const configError = getRuntimeConfigInvalidError(error);
+    if (configError) {
+        const workspacePath = configError.data?.path ?? 'OpenCode config';
+        const repoPath = workspacePath.replace(/^\/workspace\//, '');
+        const issue = configError.data?.issues?.[0]?.message;
+        const issuePath = configError.data?.issues?.[0]?.path?.join('.');
+        const permissionHint = issuePath?.startsWith('permission')
+            ? 'Remove the invalid permission frontmatter entry or replace it with valid OpenCode permission config.'
+            : 'Fix the invalid config entry, then restart this session.';
+        return {
+            title: 'OpenCode config is invalid',
+            message: `${repoPath} is preventing OpenCode from loading. ${permissionHint}`,
+            detail: issue ? `${issuePath ? `${issuePath}: ` : ''}${issue}` : undefined,
+        };
+    }
+    const raw = rawErrorMessage(error);
+    if (isSandboxNotReadyError(raw)) {
+        return {
+            title: 'Session is waking up',
+            message: 'This session slept to save compute. Your conversation is safe — sending a message wakes it back up.',
+        };
+    }
+    return {
+        title: 'The session runtime failed to load',
+        message: raw || 'The sandbox is running, but its runtime returned an error.',
+    };
+}
+export const formatOpenCodeRuntimeError = formatRuntimeError;

package/dist/core/http/session-stopped.d.ts

@@ -0,0 +1,2 @@
+export declare function noteSessionStopped(sessionId: string): void;
+export declare function onSessionStopped(listener: (sessionId: string) => void): () => void;

package/dist/core/http/session-stopped.js

@@ -0,0 +1,16 @@
+const stoppedListeners = new Set();
+export function noteSessionStopped(sessionId) {
+    for (const listener of stoppedListeners) {
+        try {
+            listener(sessionId);
+        }
+        catch {
+        }
+    }
+}
+export function onSessionStopped(listener) {
+    stoppedListeners.add(listener);
+    return () => {
+        stoppedListeners.delete(listener);
+    };
+}

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

@@ -0,0 +1,20 @@
+type Fetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export interface SendOptions {
+    retryOnAuthError?: boolean;
+    timeoutMs?: number | null;
+    fetch?: Fetch;
+}
+export declare function setAdminBypass(enabled: boolean): void;
+export declare function isAdminBypassEnabled(): boolean;
+export declare function platformRequestHeaders(url: string, base?: HeadersInit): Promise<{
+    headers: Headers;
+    rejected: () => void;
+}>;
+export declare function hostToken(options?: {
+    attempts: number;
+    baseDelayMs: number;
+}): Promise<string | null>;
+export declare function invalidateHostToken(rejectedToken?: string | null): void;
+export declare function send(input: RequestInfo | URL, init?: RequestInit, options?: SendOptions): Promise<Response>;
+export declare function sendChecked(input: RequestInfo | URL, init: RequestInit, options: SendOptions, fallbackMessage: string): Promise<Response>;
+export {};

package/dist/core/http/transport.js

@@ -0,0 +1,133 @@
+import { DEFAULT_FETCH_TIMEOUT_MS, withDefaultTimeout, withTokenRetry, } from '../../platform/auth-core.js';
+import { abortable, createAbortError } from './abort.js';
+import { ApiError, AuthError } from './api/errors.js';
+import { platformConfig } from './config.js';
+import { impersonationHeaders } from './impersonation.js';
+let adminBypassEnabled = false;
+export function setAdminBypass(enabled) {
+    adminBypassEnabled = enabled;
+}
+export function isAdminBypassEnabled() {
+    return adminBypassEnabled;
+}
+function entriesOf(headers) {
+    if (!headers)
+        return [];
+    if (headers instanceof Headers || Array.isArray(headers))
+        return [...new Headers(headers).entries()];
+    return Object.entries(headers);
+}
+function hasHeader(headers, name) {
+    const lower = name.toLowerCase();
+    return Object.keys(headers).some((key) => key.toLowerCase() === lower);
+}
+function setHeader(headers, name, value) {
+    const lower = name.toLowerCase();
+    for (const key of Object.keys(headers))
+        if (key.toLowerCase() === lower)
+            delete headers[key];
+    headers[name] = value;
+}
+function callerHeaders(input, init) {
+    const headers = {};
+    const sources = [input instanceof Request ? input.headers : undefined, init.headers];
+    for (const [name, value] of sources.flatMap(entriesOf))
+        setHeader(headers, name, value);
+    return headers;
+}
+function withPlatformHeaders(url, base, token) {
+    const headers = { ...base };
+    const clientVersion = platformConfig().clientVersion?.trim();
+    if (clientVersion && !hasHeader(headers, 'x-beeuni-client-version')) {
+        setHeader(headers, 'X-Beeuni-Client-Version', clientVersion);
+    }
+    if (adminBypassEnabled)
+        setHeader(headers, 'x-beeuni-admin-bypass', '1');
+    for (const [name, value] of Object.entries(impersonationHeaders(url)))
+        setHeader(headers, name, value);
+    if (!hasHeader(headers, 'authorization'))
+        setHeader(headers, 'Authorization', `Bearer ${token}`);
+    return headers;
+}
+export async function platformRequestHeaders(url, base) {
+    const token = await currentToken();
+    if (!token)
+        throw new AuthError();
+    return {
+        headers: new Headers(withPlatformHeaders(url, callerHeaders(url, { headers: base }), token)),
+        rejected: () => invalidateHostToken(token),
+    };
+}
+function hasOneShotBody(init) {
+    return typeof ReadableStream !== 'undefined' && init.body instanceof ReadableStream;
+}
+function dispatch(fetchImpl, input, init, token, signal) {
+    if (input instanceof Request) {
+        const headers = new Headers(withPlatformHeaders(input.url, callerHeaders(input, init), token));
+        return fetchImpl(new Request(input, { headers, ...(signal ? { signal } : {}) }));
+    }
+    const url = String(input);
+    const headers = withPlatformHeaders(url, callerHeaders(input, init), token);
+    const sameOrigin = url.startsWith('/') && !url.startsWith('//');
+    return fetchImpl(url, {
+        ...init,
+        headers,
+        ...(sameOrigin ? { credentials: 'same-origin' } : {}),
+        ...(signal ? { signal } : {}),
+    });
+}
+let lastIssuedToken = null;
+export async function hostToken(options) {
+    const token = await withTokenRetry(() => platformConfig().getToken(), options);
+    if (token)
+        lastIssuedToken = token;
+    return token;
+}
+const currentToken = hostToken;
+export function invalidateHostToken(rejectedToken = lastIssuedToken) {
+    if (rejectedToken)
+        platformConfig().getToken.invalidate?.(rejectedToken);
+}
+const refreshes = new Map();
+function refreshedToken(rejectedToken) {
+    const pending = refreshes.get(rejectedToken);
+    if (pending)
+        return pending;
+    const refresh = (async () => {
+        invalidateHostToken(rejectedToken);
+        return currentToken({ attempts: 2, baseDelayMs: 200 });
+    })().finally(() => refreshes.delete(rejectedToken));
+    refreshes.set(rejectedToken, refresh);
+    return refresh;
+}
+export async function send(input, init = {}, options = {}) {
+    const { retryOnAuthError = true, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS } = options;
+    const fetchImpl = options.fetch ?? platformConfig().fetch ?? fetch;
+    const signal = timeoutMs === null
+        ? ((input instanceof Request ? input.signal : init.signal) ?? undefined)
+        : withDefaultTimeout(input, init, timeoutMs);
+    if (signal?.aborted)
+        throw createAbortError();
+    const token = await (signal ? abortable(currentToken(), signal) : currentToken());
+    if (!token)
+        throw new AuthError();
+    const canRetry = retryOnAuthError && !hasOneShotBody(init) && !hasHeader(callerHeaders(input, init), 'authorization');
+    const retryInput = canRetry && input instanceof Request ? input.clone() : input;
+    const response = await dispatch(fetchImpl, input, init, token, signal);
+    if (response.status !== 401 || !canRetry)
+        return response;
+    const fresh = await refreshedToken(token);
+    if (!fresh || fresh === token)
+        return response;
+    return dispatch(fetchImpl, retryInput, init, fresh, signal);
+}
+export async function sendChecked(input, init, options, fallbackMessage) {
+    const response = await send(input, init, options);
+    if (response.ok)
+        return response;
+    const text = await response.text().catch(() => '');
+    throw new ApiError(text || `${fallbackMessage} (HTTP ${response.status})`, {
+        status: response.status,
+        response,
+    });
+}

package/dist/core/models/bedrock-invokable.d.ts

@@ -0,0 +1,3 @@
+import type { FlatModel } from './model-flatten.js';
+import type { ModelKey } from './model-key.js';
+export declare function healBedrockModelKey(key: ModelKey | undefined, offered: FlatModel[]): ModelKey | undefined;

package/dist/core/models/bedrock-invokable.js

@@ -0,0 +1,22 @@
+import { autoSeedDefaultModel, bedrockInferenceProfileRank } from '@beeuni/llm-catalog/lite';
+import { GATEWAY_PROVIDER_IDS } from './provider-selection.js';
+export function healBedrockModelKey(key, offered) {
+    if (!key)
+        return key;
+    if (GATEWAY_PROVIDER_IDS.has(key.providerID))
+        return key;
+    if (bedrockInferenceProfileRank(key.modelID) > 0)
+        return key;
+    const siblings = offered.filter((model) => model.providerID === key.providerID && model.enabled !== false);
+    if (!siblings.some((model) => bedrockInferenceProfileRank(model.modelID) > 0))
+        return key;
+    const isRegionalTwin = (modelID) => bedrockInferenceProfileRank(modelID) === 1 &&
+        modelID.slice(modelID.indexOf('.') + 1) === key.modelID;
+    const twin = siblings.find((model) => model.modelID === `global.${key.modelID}`) ??
+        siblings.find((model) => isRegionalTwin(model.modelID));
+    const replacement = twin?.modelID ??
+        autoSeedDefaultModel(siblings.map((model) => ({ id: model.modelID, released: model.releaseDate })))?.id;
+    if (!replacement || replacement === key.modelID)
+        return key;
+    return { ...key, modelID: replacement };
+}

package/dist/core/models/composer-model.d.ts

@@ -0,0 +1,20 @@
+import type { ProviderListResponse } from '../runtime/runtime-types.js';
+import type { ModelDefaultsResponse } from '../rest/projects-client/model-defaults.js';
+import { type FlatModel } from './model-flatten.js';
+import { type ModelKey } from './model-key.js';
+export declare function resolveModelDefault(data: ModelDefaultsResponse | undefined, agentName: string | undefined): ModelKey | undefined;
+export interface ComposerModelResolution {
+    model: ModelKey | undefined;
+    explicit: ModelKey | undefined;
+    fallback: ModelKey | undefined;
+}
+export declare function resolveComposerModel(input: {
+    models: FlatModel[];
+    picks?: ReadonlyArray<ModelKey | undefined>;
+    serverDefault?: ModelKey;
+    globalDefault?: ModelKey;
+    agentModel?: ModelKey;
+    configModel?: string;
+    recent?: ReadonlyArray<ModelKey>;
+    providers?: ProviderListResponse;
+}): ComposerModelResolution;

package/dist/core/models/composer-model.js

@@ -0,0 +1,57 @@
+import { autoSeedableModels } from '@beeuni/llm-catalog/lite';
+import { healBedrockModelKey } from './bedrock-invokable.js';
+import { isOfferedModel } from './model-flatten.js';
+import { wireToModelKey } from './model-key.js';
+export function resolveModelDefault(data, agentName) {
+    const wire = (agentName ? data?.agentDefaults?.[agentName] : undefined) ??
+        data?.projectDefault ??
+        data?.accountDefault ??
+        data?.platformDefault;
+    return wire ? wireToModelKey(wire) : undefined;
+}
+export function resolveComposerModel(input) {
+    const { models, providers } = input;
+    const isValid = (model) => isOfferedModel(models, model);
+    const firstValid = (candidates) => candidates.find((model) => !!model && isValid(model));
+    const fallback = (() => {
+        if (input.configModel) {
+            const parts = input.configModel.split('/');
+            if (parts.length >= 2) {
+                const [providerID, ...rest] = parts;
+                const modelID = rest.join('/');
+                if (isValid({ providerID, modelID })) {
+                    return { providerID, modelID };
+                }
+            }
+        }
+        for (const item of input.recent ?? []) {
+            if (isValid(item)) {
+                return item;
+            }
+        }
+        if (providers) {
+            const defaults = providers.default || {};
+            const all = Array.isArray(providers.all) ? providers.all : [];
+            const connectedIds = Array.isArray(providers.connected) ? providers.connected : [];
+            const connected = all.filter((p) => connectedIds.includes(p.id));
+            for (const p of connected) {
+                const configured = defaults[p.id];
+                if (configured) {
+                    const key = { providerID: p.id, modelID: configured };
+                    if (isValid(key))
+                        return key;
+                }
+                for (const model of autoSeedableModels(Object.keys(p.models).map((modelID) => ({ id: modelID })))) {
+                    const key = { providerID: p.id, modelID: model.id };
+                    if (isValid(key))
+                        return key;
+                }
+            }
+        }
+        return undefined;
+    })();
+    const explicit = firstValid(input.picks ?? []);
+    const resolved = explicit ??
+        firstValid([input.serverDefault, input.globalDefault, input.agentModel, fallback]);
+    return { model: healBedrockModelKey(resolved, models), explicit, fallback };
+}

package/dist/core/models/model-flatten.d.ts

@@ -0,0 +1,43 @@
+import { type ProviderListResponse } from './provider-selection.js';
+export interface FlatModel {
+    providerID: string;
+    providerName: string;
+    modelID: string;
+    modelName: string;
+    variants?: Record<string, Record<string, unknown>>;
+    capabilities?: {
+        reasoning?: boolean;
+        vision?: boolean;
+        toolcall?: boolean;
+    };
+    contextWindow?: number;
+    releaseDate?: string;
+    family?: string;
+    cost?: {
+        input: number;
+        output: number;
+    };
+    providerSource?: string;
+    provider?: string;
+    reasoningOptions?: Array<{
+        type: string;
+        values?: string[];
+        min?: number;
+        max?: number;
+    }>;
+    description?: string;
+    openWeights?: boolean;
+    lastUpdated?: string;
+    enabled?: boolean;
+    free?: boolean;
+}
+export interface ModelOption extends FlatModel {
+    id: string;
+}
+export declare function isOfferedModel(models: FlatModel[], key: {
+    providerID: string;
+    modelID: string;
+}): boolean;
+export declare function flattenModels(providers: ProviderListResponse | undefined, opts?: {
+    providerMode?: 'gateway' | 'native';
+}): ModelOption[];

package/dist/core/models/model-flatten.js

@@ -0,0 +1,73 @@
+import { modelKeyToWire } from './model-key.js';
+import { GATEWAY_PROVIDER_IDS } from './provider-selection.js';
+function hasCapabilities(model) {
+    return 'capabilities' in model && model.capabilities != null;
+}
+export function isOfferedModel(models, key) {
+    const model = models.find((m) => m.providerID === key.providerID && m.modelID === key.modelID);
+    return !!model && model.enabled !== false;
+}
+export function flattenModels(providers, opts) {
+    if (!providers)
+        return [];
+    const providerMode = opts?.providerMode ?? 'gateway';
+    const all = Array.isArray(providers.all) ? providers.all : [];
+    const connected = Array.isArray(providers.connected) ? providers.connected : [];
+    const result = [];
+    for (const p of all) {
+        if (!connected.includes(p.id))
+            continue;
+        if (providerMode === 'gateway' ? !GATEWAY_PROVIDER_IDS.has(p.id) : GATEWAY_PROVIDER_IDS.has(p.id))
+            continue;
+        for (const [modelID, model] of Object.entries(p.models)) {
+            if (modelID === 'auto' || modelID === 'beeuni/auto')
+                continue;
+            let capabilities;
+            if (hasCapabilities(model)) {
+                const caps = model.capabilities;
+                capabilities = {
+                    reasoning: caps.reasoning ?? false,
+                    vision: caps.input ? (caps.input.image ?? false) : undefined,
+                    toolcall: caps.toolcall ?? false,
+                };
+            }
+            else {
+                const modalityInput = model.modalities?.input;
+                capabilities = {
+                    reasoning: model.reasoning ?? false,
+                    vision: modalityInput
+                        ? modalityInput.includes('image')
+                        : model.attachment,
+                    toolcall: model.tool_call ?? false,
+                };
+            }
+            result.push({
+                id: modelKeyToWire({ providerID: p.id, modelID }),
+                providerID: p.id,
+                providerName: model.provider_name ?? p.name,
+                modelID,
+                modelName: (model.name || modelID).replace('(latest)', '').trim(),
+                variants: model.variants,
+                capabilities,
+                contextWindow: model.limit?.context,
+                releaseDate: model.release_date,
+                family: model.family,
+                cost: model.cost
+                    ? {
+                        input: model.cost.input ?? 0,
+                        output: model.cost.output ?? 0,
+                    }
+                    : undefined,
+                providerSource: p.source,
+                provider: model.provider,
+                reasoningOptions: model.reasoning_options,
+                description: model.description,
+                openWeights: model.open_weights,
+                lastUpdated: model.last_updated,
+                enabled: model.enabled,
+                free: model.free === true,
+            });
+        }
+    }
+    return result;
+}

package/dist/core/models/model-key.d.ts

@@ -0,0 +1,8 @@
+export type ModelKey = {
+    providerID: string;
+    modelID: string;
+    provider?: string;
+};
+export declare function modelKeyToWire(model: ModelKey): string;
+export declare function wireToModelKey(wire: string): ModelKey;
+export declare function modelRefToKey(ref: string, gatewayEnabled: boolean): ModelKey;

package/dist/core/models/model-key.js

@@ -0,0 +1,18 @@
+export function modelKeyToWire(model) {
+    if (model.providerID === 'beeuni' || model.providerID === 'opencode')
+        return model.modelID;
+    return `${model.providerID}/${model.modelID}`;
+}
+export function wireToModelKey(wire) {
+    return { providerID: 'beeuni', modelID: wire };
+}
+export function modelRefToKey(ref, gatewayEnabled) {
+    const wire = ref.startsWith('beeuni/') ? ref.slice('beeuni/'.length) : ref;
+    if (!gatewayEnabled) {
+        const slash = wire.indexOf('/');
+        if (slash > 0 && slash < wire.length - 1) {
+            return { providerID: wire.slice(0, slash), modelID: wire.slice(slash + 1) };
+        }
+    }
+    return wireToModelKey(wire);
+}

package/dist/core/models/model-lookup.d.ts

@@ -0,0 +1,2 @@
+import type { FlatModel } from './model-flatten.js';
+export declare function createModelLookup(models: FlatModel[]): Map<string, FlatModel>;

package/dist/core/models/model-lookup.js

@@ -0,0 +1,3 @@
+export function createModelLookup(models) {
+    return new Map(models.map((model) => [`${model.providerID}:${model.modelID}`, model]));
+}

package/dist/core/models/model-visibility.d.ts

@@ -0,0 +1,28 @@
+import type { FlatModel } from './model-flatten.js';
+import type { ModelKey } from './model-key.js';
+export declare function hasUsableModel(allModels: FlatModel[], opts: {
+    connectedProviderIds?: Set<string>;
+    freeTier?: boolean;
+}): boolean;
+export declare function isDefaultVisible(model: ModelKey): boolean;
+export declare function computeLatestSet(models: FlatModel[]): Set<string>;
+export interface ModelVisibilityPin extends ModelKey {
+    visibility: 'show' | 'hide';
+}
+export declare function createModelVisibility(input: {
+    catalogModels: FlatModel[];
+    pins?: ReadonlyArray<ModelVisibilityPin>;
+    connectedProviderIds?: Set<string>;
+    freeTier?: boolean;
+}): (model: ModelKey) => boolean;
+export declare function modelInDefaultView(model: FlatModel, input: {
+    search: string;
+    isStoreVisible: (model: {
+        providerID: string;
+        modelID: string;
+    }) => boolean;
+    selected: {
+        providerID: string;
+        modelID: string;
+    } | null;
+}): boolean;