bios-sdk 0.1.0-dev.1

package/dist/resources/gpu.js

@@ -0,0 +1,101 @@
+/**
+ * View GPU pricing, availability, and get recommendations for your model.
+ */
+export class GPU {
+    _http;
+    /** @internal */
+    constructor(_http) {
+        this._http = _http;
+    }
+    /**
+     * Get pricing and availability for all GPU types.
+     *
+     * Returns the full catalog of GPUs with per-hour pricing, VRAM,
+     * and which training methods each supports.
+     *
+     * @example
+     * ```ts
+     * const pricing = await client.gpu.getPricing();
+     * for (const gpu of pricing.gpus) {
+     *   console.log(`${gpu.display_name}: ${gpu.price_display} -- ${gpu.vram_gb}GB VRAM`);
+     * }
+     * ```
+     */
+    async getPricing() {
+        return this._http.fetchGet('/api/public/gpu-pricing');
+    }
+    /**
+     * Get authoritative, model-aware training GPU options with live stock,
+     * required counts, total prices, and alternatives when nothing is bookable.
+     */
+    async getOptions(params) {
+        const q = new URLSearchParams({
+            model_id: params.modelId,
+            train_type: String(params.trainType || params.adapter || 'lora'),
+        });
+        if (params.modelRevision)
+            q.set('model_revision', params.modelRevision);
+        if (params.integrationId)
+            q.set('integration_id', params.integrationId);
+        if (params.method)
+            q.set('method', params.method);
+        if (params.rlhfType)
+            q.set('rlhf_type', params.rlhfType);
+        if (params.modelParamsB !== undefined)
+            q.set('model_params_b', String(params.modelParamsB));
+        if (params.modelActiveParamsB !== undefined) {
+            q.set('model_active_params_b', String(params.modelActiveParamsB));
+        }
+        return this._http.fetchGet(`/api/training/gpu-options?${q}`);
+    }
+    /**
+     * Get the recommended GPU configuration for a specific model.
+     *
+     * Uses the model's parameter count and architecture to suggest
+     * the best GPU type and count for training.
+     *
+     * @param modelId - Full HuggingFace model ID (e.g. "meta-llama/Llama-3.1-8B-Instruct").
+     *
+     * @example
+     * ```ts
+     * const rec = await client.gpu.getRecommended('meta-llama/Llama-3.1-8B-Instruct');
+     * if (rec) {
+     *   console.log(`Recommended: ${rec.display_name} x${rec.recommended_count}`);
+     * }
+     * ```
+    */
+    async getRecommended(modelId) {
+        const options = await this.getOptions({ modelId, trainType: 'lora', method: 'sft' });
+        const recommended = options.recommended;
+        if (!recommended)
+            return null;
+        const option = options.options.find((item) => item.gpu_type === recommended.gpu_type);
+        if (!option?.bookable)
+            return null;
+        // Preserve the legacy recommendation shape while deriving sizing, stock,
+        // and total cost from the same authoritative endpoint as job creation.
+        const pricing = await this.getPricing();
+        const catalog = pricing.gpus.find((item) => item.gpu_type === recommended.gpu_type);
+        const pricePerGPU = recommended.price_per_hour_cents || option.price_per_hour_cents;
+        return {
+            gpu_type: recommended.gpu_type,
+            display_name: catalog?.display_name || option.display_name,
+            vram_gb: catalog?.vram_gb || option.vram_gb,
+            tier: catalog?.tier || '',
+            best_for: catalog?.best_for || '',
+            max_gpu_count: catalog?.max_gpu_count || option.max_gpu_count,
+            default_storage_gb: recommended.storage_gb,
+            param_range: catalog?.param_range || '',
+            methods: catalog?.methods || '',
+            available: option.available,
+            available_count: option.available_count,
+            price_per_hour_cents: pricePerGPU,
+            price_display: catalog?.price_display || `$${(pricePerGPU / 100).toFixed(2)}/hr`,
+            recommended_count: recommended.gpu_count,
+            total_vram_gb: option.vram_gb * recommended.gpu_count,
+            estimated_cost_per_hour_cents: recommended.total_price_per_hour_cents,
+            model_params_b: options.model_params_b,
+            reason: 'Cheapest currently bookable configuration that meets the model and adapter requirements',
+        };
+    }
+}

package/dist/resources/inference.d.ts

@@ -0,0 +1,82 @@
+import type { HttpClient } from '../client.js';
+import type { InferenceDeployment, InferenceCreateParams, InferenceCreateResponse, InferenceDeleteResponse, InferenceGPUOptionsParams, InferenceGPUOptionsResponse, InferenceLifecycleResponse, InferenceListParams, InferenceListResponse, InferenceNotificationListResponse, InferencePreflightResponse, InferenceUpdateResponse, InferenceUpdateParams } from '../types.js';
+declare function buildInferenceRequest(params: InferenceCreateParams): Record<string, unknown>;
+export interface ChatMessage extends Record<string, unknown> {
+    role: 'system' | 'developer' | 'user' | 'assistant' | 'tool' | 'function';
+    content?: unknown;
+}
+export interface FunctionTool extends Record<string, unknown> {
+    type: 'function';
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+        strict?: boolean;
+    };
+}
+export interface ChatCompletionParams extends Record<string, unknown> {
+    messages: ChatMessage[];
+    model?: string;
+    tools?: FunctionTool[];
+    toolChoice?: 'none' | 'auto' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    inferenceKey?: string;
+    idempotencyKey?: string;
+    requestId?: string;
+    signal?: AbortSignal;
+}
+export type ChatCompletionResponse = Record<string, unknown>;
+export type ChatCompletionChunk = Record<string, unknown>;
+export declare function validateChatRequest(body: Record<string, unknown>): void;
+export declare function parseSSE(body: ReadableStream<Uint8Array>): AsyncGenerator<string>;
+/**
+ * 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 declare class Inference {
+    private readonly key;
+    private readonly baseUrl;
+    private readonly timeout;
+    private readonly _http;
+    constructor(config?: {
+        inferenceKey?: string;
+        baseUrl?: string;
+        timeout?: number;
+    }, http?: HttpClient);
+    /** @internal Control-plane transport; present when constructed by the SDK client. */
+    private get http();
+    /** Side-effect-free validation with authoritative stock, prices, alternatives, and hold terms. */
+    preflight(params: InferenceCreateParams): Promise<InferencePreflightResponse>;
+    /** Create after preflight. Reuse idempotencyKey after a timeout to recover the same deployment and inference key. */
+    create(params: InferenceCreateParams, idempotencyKey: string): Promise<InferenceCreateResponse>;
+    /** Fetch one bounded newest-first page. Reuse next_cursor with unchanged filters. */
+    listPage(params?: InferenceListParams): Promise<InferenceListResponse>;
+    /** Compatibility helper returning only one bounded page. Prefer listPage for pagination. */
+    list(params?: InferenceListParams): Promise<InferenceDeployment[]>;
+    /** Lazily traverse pages without materializing an unbounded tenant list. */
+    iterate(params?: Omit<InferenceListParams, 'cursor'>): AsyncGenerator<InferenceDeployment, void, void>;
+    /** Current durable lifecycle, queue, price-cap, and wallet-authorization state. */
+    get(id: string): Promise<InferenceDeployment>;
+    /** Alias for get(), useful in polling automations. */
+    status(id: string): Promise<InferenceDeployment>;
+    /** Durable email delivery history, including bounded retries and dead letters. */
+    notifications(id: string, limit?: number): Promise<InferenceNotificationListResponse['notifications']>;
+    stop(id: string): Promise<InferenceLifecycleResponse>;
+    resume(id: string): Promise<InferenceLifecycleResponse>;
+    restart(id: string): Promise<InferenceLifecycleResponse>;
+    update(id: string, params: InferenceUpdateParams): Promise<InferenceUpdateResponse>;
+    delete(id: string): Promise<InferenceDeleteResponse>;
+    /** Model-fit GPU choices joined to the authoritative deployment market snapshot. */
+    getGPUOptions(params: InferenceGPUOptionsParams): Promise<InferenceGPUOptionsResponse>;
+    private prepare;
+    private abortContext;
+    chatCompletions(params: ChatCompletionParams): Promise<ChatCompletionResponse>;
+    streamChatCompletions(params: ChatCompletionParams): AsyncGenerator<ChatCompletionChunk>;
+}
+export { buildInferenceRequest };