bios-sdk 0.1.0-dev.1

package/dist/resources/inference.js

@@ -0,0 +1,529 @@
+import { ApiError } from '../client.js';
+import { normalizeGPUPlacement } from './gpu-priorities.js';
+const FUNCTION_NAME = /^[A-Za-z0-9_-]{1,64}$/;
+const ROLES = new Set(['system', 'developer', 'user', 'assistant', 'tool', 'function']);
+const INFERENCE_IDEMPOTENCY_KEY = /^[A-Za-z0-9._:-]{8,128}$/;
+const INFERENCE_TOOL_CALL_PARSERS = new Set([
+    'deepseekv3', 'deepseekv31', 'deepseekv32',
+    'glm', 'glm45', 'glm47', 'gpt-oss', 'kimi_k2',
+    'lfm2', 'llama3', 'mimo', 'mistral',
+    'omega17', 'omega17_exp', 'omega17_vl_exp', 'pythonic',
+    'qwen', 'qwen25', 'qwen3_coder', 'step3', 'step3p5',
+    'minimax-m2', 'trinity', 'interns1', 'hermes', 'gigachat3',
+    'usf_omega', 'usf_milli', 'usf_mini',
+]);
+function inferenceIdempotencyKey(value) {
+    const key = value?.trim();
+    if (!INFERENCE_IDEMPOTENCY_KEY.test(key)) {
+        throw new Error("BiOS: idempotencyKey is required and must be 8-128 characters using letters, numbers, '.', '_', ':', or '-'");
+    }
+    return key;
+}
+function buildInferenceRequest(params) {
+    const queueEnabled = params.allowCapacityQueue ?? false;
+    const placement = normalizeGPUPlacement(params.gpuPriorities, queueEnabled, params.gpuType, params.gpuCount, 'allowCapacityQueue');
+    if (!params.name?.trim())
+        throw new Error('BiOS: deployment name is required');
+    if (!placement.gpuType)
+        throw new Error('BiOS: gpuType is required');
+    if (!Number.isInteger(placement.gpuCount) || placement.gpuCount < 1 || placement.gpuCount > 8) {
+        throw new Error('BiOS: gpuCount must be an integer between 1 and 8');
+    }
+    if (params.sourceType === 'checkpoint') {
+        if (!params.sourceJobId || !params.sourceCheckpointId) {
+            throw new Error('BiOS: checkpoint deployments require sourceJobId and sourceCheckpointId');
+        }
+    }
+    else if (params.sourceType === 'hf_model') {
+        if (!params.hfModelId)
+            throw new Error('BiOS: hf_model deployments require hfModelId');
+        if (params.servingMode !== undefined && params.servingMode !== 'full') {
+            throw new Error('BiOS: hf_model deployments use servingMode=full; checkpoint modes are derived from the verified artifact');
+        }
+    }
+    else {
+        throw new Error('BiOS: sourceType must be checkpoint or hf_model');
+    }
+    if (params.servingMode !== undefined && !['full', 'adapter', 'merged'].includes(params.servingMode)) {
+        throw new Error('BiOS: servingMode must be full, adapter, or merged');
+    }
+    if (params.gpuTier !== undefined && params.gpuTier !== 'secure') {
+        throw new Error('BiOS: gpuTier must be secure; other deployment capacity tiers are not supported');
+    }
+    const requestedParser = params.servingConfig?.tool_call_parser;
+    if (requestedParser !== undefined && !INFERENCE_TOOL_CALL_PARSERS.has(requestedParser)) {
+        throw new Error('BiOS: servingConfig.tool_call_parser must name a parser supported by the deployed SGLang runtime');
+    }
+    const body = {
+        name: params.name.trim(),
+        source_type: params.sourceType,
+        gpu_type: placement.gpuType,
+        gpu_count: placement.gpuCount,
+        gpu_tier: params.gpuTier || 'secure',
+        allow_capacity_queue: queueEnabled,
+    };
+    if (placement.priorities !== undefined)
+        body.gpu_priorities = placement.priorities;
+    if (params.sourceJobId !== undefined)
+        body.source_job_id = params.sourceJobId;
+    if (params.sourceCheckpointId !== undefined)
+        body.source_checkpoint_id = params.sourceCheckpointId;
+    if (params.hfModelId !== undefined)
+        body.hf_model_id = params.hfModelId;
+    if (params.hfModelRevision !== undefined)
+        body.hf_model_revision = params.hfModelRevision;
+    if (params.hfIntegrationId !== undefined)
+        body.hf_integration_id = params.hfIntegrationId;
+    if (params.baseModelId !== undefined)
+        body.base_model_id = params.baseModelId;
+    if (params.baseModelRevision !== undefined)
+        body.base_model_revision = params.baseModelRevision;
+    if (params.servingMode !== undefined)
+        body.serving_mode = params.servingMode;
+    if (params.modelTask !== undefined)
+        body.model_task = params.modelTask;
+    if (params.supportsImages !== undefined)
+        body.supports_images = params.supportsImages;
+    if (params.storageGb !== undefined)
+        body.storage_gb = params.storageGb;
+    if (params.contextLength !== undefined)
+        body.context_length = params.contextLength;
+    if (params.quant !== undefined)
+        body.quant = params.quant;
+    if (params.servingConfig !== undefined)
+        body.serving_config = params.servingConfig;
+    if (params.maxPriceHourCents !== undefined)
+        body.max_price_hour_cents = params.maxPriceHourCents;
+    return body;
+}
+export function validateChatRequest(body) {
+    const messages = body.messages;
+    if (!Array.isArray(messages) || messages.length === 0) {
+        throw new Error('messages must be a non-empty array');
+    }
+    const tools = body.tools ?? [];
+    if (!Array.isArray(tools))
+        throw new Error('tools must be an array');
+    const names = [];
+    for (const rawTool of tools) {
+        if (!rawTool || typeof rawTool !== 'object')
+            throw new Error('each tool must be an object');
+        const tool = rawTool;
+        if ((tool.type ?? 'function') !== 'function')
+            throw new Error('each tool must have type="function"');
+        const fn = tool.function;
+        if (!fn || typeof fn !== 'object')
+            throw new Error('each tool requires a function object');
+        const definition = fn;
+        if (typeof definition.name !== 'string' || !FUNCTION_NAME.test(definition.name)) {
+            throw new Error('tool function names must be 1-64 safe characters');
+        }
+        const parameters = definition.parameters;
+        if (parameters !== undefined && (!parameters || typeof parameters !== 'object' || Array.isArray(parameters)
+            || (parameters.type ?? 'object') !== 'object')) {
+            throw new Error('tool parameters must be a JSON Schema object');
+        }
+        names.push(definition.name);
+    }
+    if (new Set(names).size !== names.length)
+        throw new Error('tool function names must be unique');
+    const choice = body.tool_choice;
+    if (choice && typeof choice === 'object') {
+        const fn = choice.function;
+        const selected = fn && typeof fn === 'object' ? fn.name : undefined;
+        if (typeof selected !== 'string' || !names.includes(selected)) {
+            throw new Error('tool_choice references an undefined function');
+        }
+    }
+    else if ((choice === 'auto' || choice === 'required') && tools.length === 0) {
+        throw new Error('tool_choice requires at least one tool');
+    }
+    const pending = new Set();
+    for (const rawMessage of messages) {
+        if (!rawMessage || typeof rawMessage !== 'object')
+            throw new Error('every message must be an object');
+        const message = rawMessage;
+        const role = message.role;
+        if (typeof role !== 'string' || !ROLES.has(role))
+            throw new Error('every message requires a valid role');
+        const calls = message.tool_calls;
+        if (calls !== undefined && role !== 'assistant')
+            throw new Error('tool_calls are only valid on assistant messages');
+        if (role === 'assistant' && Array.isArray(calls) && calls.length > 0) {
+            if (pending.size > 0)
+                throw new Error('tool calls must be resolved before the next turn');
+            for (const rawCall of calls) {
+                if (!rawCall || typeof rawCall !== 'object')
+                    throw new Error('assistant tool calls must be objects');
+                const call = rawCall;
+                const id = call.id;
+                const fn = call.function;
+                if (typeof id !== 'string' || !id)
+                    throw new Error('assistant tool calls require a non-empty id');
+                if (pending.has(id))
+                    throw new Error('assistant tool call ids must be unique');
+                if (!fn || typeof fn !== 'object')
+                    throw new Error('assistant tool calls require a function');
+                const functionCall = fn;
+                if (tools.length > 0 && !names.includes(String(functionCall.name ?? ''))) {
+                    throw new Error('assistant tool call references an undefined function');
+                }
+                let args = functionCall.arguments;
+                if (typeof args === 'string') {
+                    try {
+                        args = JSON.parse(args);
+                    }
+                    catch {
+                        throw new Error('tool call arguments must be valid JSON');
+                    }
+                }
+                if (!args || typeof args !== 'object' || Array.isArray(args)) {
+                    throw new Error('tool call arguments must encode a JSON object');
+                }
+                pending.add(id);
+            }
+        }
+        else if (role === 'tool') {
+            const id = message.tool_call_id;
+            if (typeof id !== 'string' || !pending.delete(id)) {
+                throw new Error('tool message references an unknown tool_call_id');
+            }
+        }
+        else if (pending.size > 0) {
+            throw new Error('tool calls must be resolved before the next turn');
+        }
+    }
+    if (pending.size > 0)
+        throw new Error('assistant tool calls are missing tool response messages');
+}
+function extractFrames(buffer, final = false) {
+    const frames = [];
+    let rest = buffer;
+    while (true) {
+        const match = /\r\n\r\n|\n\n|\r\r/.exec(rest);
+        if (!match || match.index === undefined)
+            break;
+        frames.push(rest.slice(0, match.index));
+        rest = rest.slice(match.index + match[0].length);
+    }
+    if (final && rest) {
+        frames.push(rest);
+        rest = '';
+    }
+    return { frames, rest };
+}
+function dataFromFrame(frame) {
+    const data = [];
+    for (const line of frame.replaceAll('\r\n', '\n').replaceAll('\r', '\n').split('\n')) {
+        if (!line || line.startsWith(':'))
+            continue;
+        const colon = line.indexOf(':');
+        const field = colon < 0 ? line : line.slice(0, colon);
+        let value = colon < 0 ? '' : line.slice(colon + 1);
+        if (value.startsWith(' '))
+            value = value.slice(1);
+        if (field === 'data')
+            data.push(value);
+    }
+    return data.length > 0 ? data.join('\n') : undefined;
+}
+export async function* parseSSE(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const extracted = extractFrames(buffer);
+            buffer = extracted.rest;
+            for (const frame of extracted.frames) {
+                const data = dataFromFrame(frame);
+                if (data !== undefined)
+                    yield data;
+            }
+        }
+        buffer += decoder.decode();
+        const extracted = extractFrames(buffer, true);
+        for (const frame of extracted.frames) {
+            const data = dataFromFrame(frame);
+            if (data !== undefined)
+                yield data;
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+async function apiError(response) {
+    const text = await response.text().catch(() => '');
+    let body = { error: text || `Inference API error ${response.status}` };
+    try {
+        body = JSON.parse(text);
+    }
+    catch { /* use text envelope */ }
+    return new ApiError(response.status, body);
+}
+/**
+ * Inference surface. Combines control-plane management of model-serving
+ * deployments (`/api/inference*`) with OpenAI-compatible key-scoped inference
+ * (`/v1/chat/completions`). Requests are dispatched once; an idempotency header
+ * is forwarded but server-side replay is not assumed.
+ */
+export class Inference {
+    key;
+    baseUrl;
+    timeout;
+    _http;
+    constructor(config = {}, http) {
+        this.key = config.inferenceKey;
+        this.baseUrl = (config.baseUrl || 'https://api-dev.usbios.ai').replace(/\/+$/, '');
+        this.timeout = config.timeout ?? 900_000;
+        this._http = http;
+    }
+    /** @internal Control-plane transport; present when constructed by the SDK client. */
+    get http() {
+        if (!this._http) {
+            throw new Error('BiOS: control-plane inference management requires an SDK client (apiKey or accessToken)');
+        }
+        return this._http;
+    }
+    // --------------------------------------------------------------------------
+    // Control-plane deployment management — `/api/inference*`
+    // --------------------------------------------------------------------------
+    /** Side-effect-free validation with authoritative stock, prices, alternatives, and hold terms. */
+    preflight(params) {
+        return this.http.fetchPost('/api/inference/preflight', buildInferenceRequest(params));
+    }
+    /** Create after preflight. Reuse idempotencyKey after a timeout to recover the same deployment and inference key. */
+    create(params, idempotencyKey) {
+        return this.http.fetchPost('/api/inference', buildInferenceRequest(params), {
+            'Idempotency-Key': inferenceIdempotencyKey(idempotencyKey),
+        });
+    }
+    /** Fetch one bounded newest-first page. Reuse next_cursor with unchanged filters. */
+    async listPage(params = {}) {
+        const query = new URLSearchParams();
+        if (params.limit !== undefined) {
+            if (!Number.isInteger(params.limit) || params.limit < 1) {
+                throw new Error('BiOS: deployment list limit must be a positive integer');
+            }
+            query.set('limit', String(Math.min(params.limit, 200)));
+        }
+        if (params.cursor)
+            query.set('cursor', params.cursor);
+        if (params.status && params.status !== 'all')
+            query.set('status', params.status);
+        if (params.search?.trim())
+            query.set('search', params.search.trim());
+        const suffix = query.toString();
+        const response = await this.http.fetchGet(`/api/inference${suffix ? `?${suffix}` : ''}`);
+        // Compatibility with pre-pagination servers during a rolling release.
+        if (Array.isArray(response)) {
+            return { deployments: response, has_more: false, next_cursor: null, limit: response.length };
+        }
+        return {
+            deployments: response.deployments || [],
+            has_more: response.has_more === true,
+            next_cursor: response.next_cursor ?? null,
+            limit: response.limit || params.limit || 50,
+        };
+    }
+    /** Compatibility helper returning only one bounded page. Prefer listPage for pagination. */
+    async list(params = {}) {
+        return (await this.listPage(params)).deployments;
+    }
+    /** Lazily traverse pages without materializing an unbounded tenant list. */
+    async *iterate(params = {}) {
+        let cursor;
+        do {
+            const page = await this.listPage({ ...params, cursor });
+            for (const deployment of page.deployments)
+                yield deployment;
+            cursor = page.has_more && page.next_cursor ? page.next_cursor : undefined;
+        } while (cursor);
+    }
+    /** Current durable lifecycle, queue, price-cap, and wallet-authorization state. */
+    get(id) {
+        return this.http.fetchGet(`/api/inference/${encodeURIComponent(id)}`);
+    }
+    /** Alias for get(), useful in polling automations. */
+    status(id) {
+        return this.get(id);
+    }
+    /** Durable email delivery history, including bounded retries and dead letters. */
+    async notifications(id, limit = 50) {
+        const safeLimit = Math.max(1, Math.min(100, Math.trunc(limit)));
+        const response = await this.http.fetchGet(`/api/inference/${encodeURIComponent(id)}/notifications?limit=${safeLimit}`);
+        return response.notifications || [];
+    }
+    stop(id) {
+        return this.http.fetchPost(`/api/inference/${encodeURIComponent(id)}/stop`);
+    }
+    resume(id) {
+        return this.http.fetchPost(`/api/inference/${encodeURIComponent(id)}/resume`);
+    }
+    restart(id) {
+        return this.http.fetchPost(`/api/inference/${encodeURIComponent(id)}/restart`);
+    }
+    update(id, params) {
+        const body = {};
+        if (params.allowCapacityQueue !== undefined)
+            body.allow_capacity_queue = params.allowCapacityQueue;
+        if (params.maxPriceHourCents !== undefined)
+            body.max_price_hour_cents = params.maxPriceHourCents;
+        if (params.contextLength !== undefined)
+            body.context_length = params.contextLength;
+        if (params.quant !== undefined)
+            body.quant = params.quant;
+        if (params.servingConfig !== undefined)
+            body.serving_config = params.servingConfig;
+        return this.http.fetchPatch(`/api/inference/${encodeURIComponent(id)}`, body);
+    }
+    delete(id) {
+        return this.http.fetchDelete(`/api/inference/${encodeURIComponent(id)}`);
+    }
+    /** Model-fit GPU choices joined to the authoritative deployment market snapshot. */
+    getGPUOptions(params) {
+        if (params.gpuTier !== undefined && params.gpuTier !== 'secure') {
+            throw new Error('BiOS: gpuTier must be secure; other deployment capacity tiers are not supported');
+        }
+        const query = new URLSearchParams({ params_b: String(params.paramsB) });
+        if (params.activeParamsB !== undefined)
+            query.set('active_params_b', String(params.activeParamsB));
+        if (params.isMoe !== undefined)
+            query.set('is_moe', String(params.isMoe));
+        if (params.quant !== undefined)
+            query.set('quant', params.quant);
+        if (params.contextLength !== undefined)
+            query.set('context_length', String(params.contextLength));
+        if (params.kvHeads !== undefined)
+            query.set('kv_heads', String(params.kvHeads));
+        if (params.numLayers !== undefined)
+            query.set('num_layers', String(params.numLayers));
+        if (params.kvLayers !== undefined)
+            query.set('kv_layers', String(params.kvLayers));
+        if (params.headDim !== undefined)
+            query.set('head_dim', String(params.headDim));
+        if (params.attention !== undefined)
+            query.set('attn', params.attention);
+        if (params.numAttentionHeads !== undefined)
+            query.set('num_attention_heads', String(params.numAttentionHeads));
+        if (params.kvLoraRank !== undefined)
+            query.set('kv_lora_rank', String(params.kvLoraRank));
+        if (params.qkRopeHeadDim !== undefined)
+            query.set('qk_rope_head_dim', String(params.qkRopeHeadDim));
+        if (params.gpuTier !== undefined)
+            query.set('gpu_tier', params.gpuTier);
+        return this.http.fetchGet(`/api/inference/gpu-options?${query}`);
+    }
+    // --------------------------------------------------------------------------
+    // OpenAI-compatible key-scoped inference — `/v1/chat/completions`
+    // --------------------------------------------------------------------------
+    prepare(params, stream) {
+        const { messages, model, tools, toolChoice, inferenceKey, idempotencyKey, requestId, signal, ...extra } = params;
+        const key = inferenceKey || this.key;
+        if (!key)
+            throw new Error('an inferenceKey is required');
+        const body = { ...extra, messages, stream };
+        if (model)
+            body.model = model;
+        if (tools !== undefined)
+            body.tools = tools;
+        if (toolChoice !== undefined)
+            body.tool_choice = toolChoice;
+        validateChatRequest(body);
+        const headers = {
+            Authorization: `Bearer ${key}`,
+            Accept: stream ? 'text/event-stream' : 'application/json',
+            'Content-Type': 'application/json',
+            'X-Request-ID': requestId || crypto.randomUUID(),
+        };
+        if (idempotencyKey)
+            headers['Idempotency-Key'] = idempotencyKey;
+        return { body, key, headers, signal };
+    }
+    abortContext(signal) {
+        const controller = new AbortController();
+        const relay = () => controller.abort(signal?.reason);
+        if (signal?.aborted)
+            relay();
+        else
+            signal?.addEventListener('abort', relay, { once: true });
+        const timeoutId = setTimeout(() => controller.abort(new Error(`Inference timed out after ${this.timeout}ms`)), this.timeout);
+        return {
+            controller,
+            timeoutId,
+            remove: () => signal?.removeEventListener('abort', relay),
+        };
+    }
+    async chatCompletions(params) {
+        const prepared = this.prepare(params, false);
+        const abort = this.abortContext(prepared.signal);
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+                method: 'POST', headers: prepared.headers, body: JSON.stringify(prepared.body), signal: abort.controller.signal,
+            });
+            if (!response.ok)
+                throw await apiError(response);
+            return await response.json();
+        }
+        catch (error) {
+            if (abort.controller.signal.aborted && !(error instanceof ApiError)) {
+                throw new ApiError(0, { error: String(abort.controller.signal.reason || 'Inference request aborted') });
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(abort.timeoutId);
+            abort.remove();
+        }
+    }
+    async *streamChatCompletions(params) {
+        const prepared = this.prepare(params, true);
+        const abort = this.abortContext(prepared.signal);
+        try {
+            const response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
+                method: 'POST', headers: prepared.headers, body: JSON.stringify(prepared.body), signal: abort.controller.signal,
+            });
+            if (!response.ok)
+                throw await apiError(response);
+            const contentType = response.headers.get('content-type')?.toLowerCase() ?? '';
+            if (!contentType.includes('text/event-stream')) {
+                throw new ApiError(response.status, { error: `Expected text/event-stream, received ${contentType || 'no content type'}` });
+            }
+            if (!response.body)
+                throw new ApiError(0, { error: 'Inference response has no body' });
+            for await (const data of parseSSE(response.body)) {
+                if (data === '[DONE]')
+                    return;
+                let event;
+                try {
+                    event = JSON.parse(data);
+                }
+                catch {
+                    throw new ApiError(0, { error: 'Invalid JSON SSE event' });
+                }
+                if (event && typeof event === 'object' && 'error' in event) {
+                    throw new ApiError(0, event);
+                }
+                yield event;
+            }
+        }
+        catch (error) {
+            if (abort.controller.signal.aborted && !(error instanceof ApiError)) {
+                throw new ApiError(0, { error: String(abort.controller.signal.reason || 'Inference request aborted') });
+            }
+            throw error;
+        }
+        finally {
+            abort.controller.abort('stream closed');
+            clearTimeout(abort.timeoutId);
+            abort.remove();
+        }
+    }
+}
+export { buildInferenceRequest };

package/dist/resources/models.d.ts

@@ -0,0 +1,75 @@
+import type { HttpClient } from '../client.js';
+import type { ModelSearchParams, ModelSearchResponse, ModelConfig, AdapterCompatibilityParams, AdapterCompatibilityResponse, ArchitectureScope, SupportedArchitecturesResponse } from '../types.js';
+/**
+ * Access the BIOS model catalog -- search HuggingFace models, fetch
+ * training-relevant configuration, and check adapter compatibility.
+ */
+export declare class Models {
+    private readonly _http;
+    /** @internal */
+    constructor(_http: HttpClient);
+    /**
+     * Search the HuggingFace model catalog for fine-tunable models.
+     *
+     * Results are filtered to exclude quantized derivatives (GGUF, GPTQ, AWQ)
+     * and adapters by default -- pass `kind: "adapter"` to find LoRA adapters.
+     *
+     * @example
+     * ```ts
+     * const res = await client.models.search({ query: 'llama', type: 'llm', limit: 10 });
+     * for (const m of res.models) {
+     *   console.log(`${m.id} -- ${m.totalParams}B params`);
+     * }
+     * ```
+     */
+    search(params?: ModelSearchParams): Promise<ModelSearchResponse>;
+    /**
+     * Fetch the training configuration for a specific model from HuggingFace.
+     *
+     * Returns parameter counts, architecture type, and whether the model
+     * uses Mixture-of-Experts -- information needed to choose the right
+     * GPU and adapter configuration.
+     *
+     * @param modelId - Full HuggingFace model ID (e.g. "meta-llama/Llama-3.1-8B").
+     *
+     * @example
+     * ```ts
+     * const config = await client.models.getConfig('meta-llama/Llama-3.1-8B');
+     * console.log(`${config.totalParams}B params, MoE: ${config.isMoE}`);
+     * ```
+     */
+    getConfig(modelId: string): Promise<ModelConfig>;
+    /**
+     * Check which adapters are compatible with a given architecture,
+     * training method, and (optionally) RLHF algorithm.
+     *
+     * @example
+     * ```ts
+     * const compat = await client.models.getAdapterCompatibility({
+     *   modelType: 'llama',
+     *   trainingMethod: 'rlhf',
+     *   rlhfAlgorithm: 'dpo',
+     * });
+     * const usable = compat.adapters.filter(a => a.compatible);
+     * console.log(`${usable.length} compatible adapters`);
+     * ```
+     */
+    getAdapterCompatibility(params?: AdapterCompatibilityParams): Promise<AdapterCompatibilityResponse>;
+    /**
+     * List the architectures the platform supports for a given scope. This is
+     * the authoritative registry the platform gates on:
+     *  - `inference` — HF architecture classes that can be served (deployed).
+     *  - `training` — architecture keys the fine-tuning wizard/gate accepts.
+     *
+     * A `count` of 0 means the registry is empty and nothing is explicitly
+     * restricted (every architecture the engine supports is allowed).
+     *
+     * ```ts
+     * const { architectures } = await client.models.getSupportedArchitectures({ scope: 'inference' });
+     * const servable = architectures.filter(a => a.enabled).map(a => a.architecture);
+     * ```
+     */
+    getSupportedArchitectures(params?: {
+        scope?: ArchitectureScope;
+    }): Promise<SupportedArchitecturesResponse>;
+}