runbios-sdk 0.2.14-dev.246 → 0.2.14-dev.248

package/README.md

@@ -186,6 +186,37 @@ if (answer) {
 Streaming billing is charged server-side on completed usage; the SDK only needs
 to request `usage` where the endpoint exposes it (no client change).
 
+#### Other supported `/v1` inference tasks
+
+Serverless catalogs serve OpenAI chat and, when the model supports that dialect,
+Anthropic Messages (`inference.messages` / `streamMessages`). Serverless does
+**not** serve `/v1/completions`, `/v1/embeddings`, or `/v1/rerank`. Those three
+routes require a dedicated deployment that actually advertises the matching
+task and a credential with `deployments:read` or `deployments:write`; a chat-only
+deployment cannot embed or rerank. The server's preflight/status result, not the
+model name, determines serving mode. The SDK forwards a dedicated `inferenceKey`
+when configured, otherwise the workspace platform `apiKey`.
+
+```typescript
+import { Inference } from 'runbios-sdk';
+const reply = await client.inference.messages({
+  model: 'catalog-model-with-messages-support', max_tokens: 64,
+  messages: [{ role: 'user', content: 'Hello.' }],
+});
+
+const dedicated = new Inference();
+const text = await dedicated.completions({ model: 'completion-deployment', prompt: 'Continue' });
+const vectors = await dedicated.embeddings({ model: 'embedding-deployment', input: ['First', 'Second'] });
+const ranking = await dedicated.rerank({ model: 'rerank-deployment', query: 'Question', documents: ['A', 'B'] });
+for await (const event of dedicated.streamCompletions({ model: 'completion-deployment', prompt: 'Continue' })) {
+  console.log(event);
+}
+```
+
+`streamMessages` also yields each Anthropic SSE event in order. Both streaming
+methods close the upstream reader when iteration ends. None of the inference
+POSTs are retried automatically, and `idempotencyKey` is sent only if supplied.
+
 #### Workspace serverless usage and limits (read-only)
 
 A workspace-bound platform key or hosted OAuth grant with `analytics:read` can

package/dist/index.d.ts

@@ -36,7 +36,7 @@ import { Loop } from './resources/loop.js';
  * SDK version. Sent as part of the User-Agent header.
  * Must match package.json "version" -- enforced by a contract test.
  */
-export declare const VERSION = "0.2.14-dev.246";
+export declare const VERSION = "0.2.14-dev.248";
 export declare class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     readonly models: Models;
@@ -74,7 +74,7 @@ export { Integrations, type HuggingFaceIntegration, type IntegrationBrowseParams
 export { Training } from './resources/training.js';
 export { Wallet } from './resources/wallet.js';
 export { GPU, type GPURecommendation } from './resources/gpu.js';
-export { Inference, validateChatRequest, parseSSE, buildInferenceRequest, contextSizingBasis, type ContextSizingBasis, CONTEXT_DEFAULT_CEILING, CONTEXT_EDITABLE_FLOOR, type ChatMessage, type FunctionTool, type ChatCompletionParams, type ChatCompletionResponse, type ChatCompletionChunk, type ServerlessUsageWindow, type ServerlessTimeseriesMetric, type ServerlessWorkspaceLimits, type ServerlessUsageEnvelope, type ServerlessUsageOverviewResponse, type ServerlessUsageRowsResponse, type ServerlessUsageTimeseriesResponse, type ServerlessUsageDailyResponse, type ServerlessSavingsTotals, type ServerlessSavingsPeriod, type ServerlessUsageSavingsResponse, } from './resources/inference.js';
+export { Inference, validateChatRequest, parseSSE, buildInferenceRequest, contextSizingBasis, type ContextSizingBasis, CONTEXT_DEFAULT_CEILING, CONTEXT_EDITABLE_FLOOR, type ChatMessage, type FunctionTool, type ChatCompletionParams, type ChatCompletionResponse, type ChatCompletionChunk, type InferenceVerbParams, type CompletionParams, type EmbeddingParams, type RerankParams, type AnthropicMessageParams, type ServerlessUsageWindow, type ServerlessTimeseriesMetric, type ServerlessWorkspaceLimits, type ServerlessUsageEnvelope, type ServerlessUsageOverviewResponse, type ServerlessUsageRowsResponse, type ServerlessUsageTimeseriesResponse, type ServerlessUsageDailyResponse, type ServerlessSavingsTotals, type ServerlessSavingsPeriod, type ServerlessUsageSavingsResponse, } from './resources/inference.js';
 export type { BiOSConfig, PaginatedResponse, ApiErrorBody, AvailableGpuAlternative, CapacityMinimumRequirement, InferenceBookingAccepted, Model, ModelSearchParams, ModelSearchResponse, ModelDetailResponse, InferenceModel, InferenceModelListResponse, ModelConfig, Dataset, DatasetListParams, DatasetListResponse, DatasetUploadParams, DatasetPreview, DatasetPreviewParams, DatasetImportHFParams, DatasetRegisterHFParams, DatasetHubSearchParams, DatasetHubPreviewParams, DatasetValidation, DatasetFormatVariant, DatasetFormatSpec, DatasetFormatSpecs, DatasetStorageUsage, TrainingMethod, RLHFAlgorithm, AdapterType, TrainingJobStatus, TrainingStatusFilter, TrainingCreateParams, TrainingListParams, TrainingListResponse, TrainingJob, TrainingMetrics, TrainingResourceMetrics, TrainingDeviceMetrics, MetricPoint, MetricGraphConfig, TrainingCheckpoint, TrainingLogs, TrainingLogEntry, TrainingStopResponse, TrainingResumeResponse, CanonicalTrainingRequest, TrainingPreflightDataset, TrainingPreflightWarning, TrainingPreflightResponse, TrainingCapabilityChoice, TrainingConfigFieldCapability, TrainingCapabilities, GPUChoice, WalletBalance, Transaction, TransactionListResponse, TransactionListParams, GPUInfo, GPUPricingResponse, GPUOptionsParams, TrainingRecommendParams, TrainingAdvisorVerdict, TrainingAdvisorRecommendation, TrainingAdvisorUserShape, TrainingAdvisorJustification, TrainingAdvisorBasis, GPUOption, GPUOptionSuggestion, GPUOptionsResponse, InferenceStatus, InferenceCreateParams, InferenceUpdateParams, InferenceDeployment, InferenceDeploymentSummary, InferenceCreateResponse, InferenceListResponse, InferenceUpdateResponse, InferenceLifecycleResponse, InferenceDeleteResponse, InferenceGPUOptionMarket, InferenceGPUOption, InferenceGPUAlternative, InferenceGPUOptionsParams, InferenceGPUOptionsResponse, InferenceCanonicalRequest, InferencePreflightWarning, InferencePreflightResponse, AdapterCompatibility, AdapterCompatibilityResponse, AdapterCompatibilityParams, SupportedArchitecture, ArchitectureScope, SupportedArchitecturesResponse, ApiKey, ApiKeyScope, ApiKeyIntrospection, Organization, OrgMember, OrgInvite, Workspace, Integration, IntegrationCreateParams, StorageUsage, StorageObject, PromptTokensDetails, ChatCompletionUsage, TrainingCadence, TrainingCombinator, ServingKind, TrainingRulePausedReason, LoopTrainingMethod, TrainType, GradersScope, TrainingTrigger, TrainingRecipe, TrainingRunState, TrainingVerdict, TrainingDecision, NotifyState, EvaluationStatus, EvaluationItemStatus, EvaluationWinner, EvaluationWarningCode, ConsentVia, TrainingToolCall, TrainingMessage, TrainingRuleServing, TrainingGPURung, TrainingRule, TrainingRuleConsent, TrainingRulePreflightRefusal, TrainingRuleKeyRef, TrainingRuleKeyCheck, TrainingRulePreflight, TrainingRuleBuildSpec, TrainingRuleTriggerInput, TrainingRuleTrainingInput, TrainingRuleDeployInput, TrainingRuleMoneyInput, TrainingRuleEvaluationInput, TrainingRulePromotionInput, TrainingRuleAcceptTerms, TrainingRulePreflightRequest, TrainingRuleCreateRequest, TrainingRuleUpdateRequest, TrainingRuleConsentRequest, TrainingRuleListParams, TrainingRunPromoteRequest, TrainingRunRejectRequest, TrainingRunRollbackRequest, TrainingRunCancelRequest, TrainingRunListParams, TrainingRun, TrainingRunSummary, TrainingRunEvent, TrainingRunLinks, TrainingRunActions, EvaluationRef, EvaluationDecoding, EvaluationJudgeDimension, EvaluationDimensionScore, EvaluationGraderScore, EvaluationWarning, EvaluationMargin, JudgeAgreementDimension, JudgeAgreement, Evaluation, EvaluationItemSide, EvaluationItem, EvaluationItemListParams, JudgeAgreementParams, AgentSettings, AgentSettingsRequest, BenchmarkStatus, BenchmarkSourceKind, BenchmarkRunStatus, BenchmarkScoring, BenchmarkDimensionScore, Benchmark, BenchmarkItem, BenchmarkRun, BenchmarkHistoryPoint, BenchmarkSource, BenchmarkCreateParams, BenchmarkListParams, BenchmarkItemListParams, BenchmarkHistoryParams, BenchmarkRetireParams, TrainingRuleBenchmarkRequest, InferenceAlias, InferenceAliasRequest, TrainingRuleListResponse, TrainingRuleResponse, TrainingRuleMutationResponse, TrainingRuleDeleteResponse, TrainingRunListResponse, TrainingRunResponse, TrainingRunActionResponse, EvaluationItemsResponse, AgentSettingsResponse, InferenceAliasListResponse, InferenceAliasResponse, InferenceAliasDeleteResponse, BenchmarkListResponse, BenchmarkItemsResponse, BenchmarkHistoryResponse, TrainingRuleRunRefusalCode, TrainingRuleMonthlyLimitRefusal, LoopDatasetDeleteRefusalCode, PipelineStatus, PipelineRecipeExploration, PipelineActiveRun, PipelineVersion, Pipeline, PipelineListResponse, PipelineResponse, } from './types.js';
 /** The closed set of run states a training run never leaves. */
 export { TERMINAL_RUN_STATES } from './types.js';

package/dist/index.js

@@ -36,7 +36,7 @@ import { Loop } from './resources/loop.js';
  * SDK version. Sent as part of the User-Agent header.
  * Must match package.json "version" -- enforced by a contract test.
  */
-export const VERSION = '0.2.14-dev.246';
+export const VERSION = '0.2.14-dev.248';
 export class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     models;

package/dist/resources/inference.d.ts

@@ -78,6 +78,28 @@ export interface ChatCompletionParams extends Record<string, unknown> {
 }
 export type ChatCompletionResponse = Record<string, unknown>;
 export type ChatCompletionChunk = Record<string, unknown>;
+export interface InferenceVerbParams extends Record<string, unknown> {
+    model?: string;
+    inferenceKey?: string;
+    idempotencyKey?: string;
+    requestId?: string;
+    signal?: AbortSignal;
+}
+export interface CompletionParams extends InferenceVerbParams {
+    prompt: string | string[] | number[] | number[][];
+}
+export interface EmbeddingParams extends InferenceVerbParams {
+    input: string | string[] | number[] | number[][];
+}
+export interface RerankParams extends InferenceVerbParams {
+    query: string;
+    documents: Array<string | Record<string, unknown>>;
+}
+export interface AnthropicMessageParams extends InferenceVerbParams {
+    messages: Array<Record<string, unknown>>;
+    max_tokens: number;
+    anthropicVersion?: string;
+}
 export type ServerlessUsageWindow = '1h' | '24h' | '7d' | '30d' | '90d';
 export type ServerlessTimeseriesMetric = 'requests' | 'tokens' | 'spend' | 'ttft_p50' | 'ttft_p95' | 'tps';
 export interface ServerlessWorkspaceLimits {
@@ -151,8 +173,8 @@ 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
+ * deployments (`/api/inference*`) with key-scoped inference on the supported
+ * `/v1` task routes. Requests are dispatched once; an idempotency header
  * is forwarded but server-side replay is not assumed.
  */
 export declare class Inference {
@@ -330,7 +352,16 @@ export declare class Inference {
     getGPUOptions(params: InferenceGPUOptionsParams): Promise<InferenceGPUOptionsResponse>;
     private prepare;
     private abortContext;
+    private prepareVerb;
+    private sendVerb;
     private modelRead;
+    private streamVerb;
+    completions(params: CompletionParams): Promise<Record<string, unknown>>;
+    embeddings(params: EmbeddingParams): Promise<Record<string, unknown>>;
+    rerank(params: RerankParams): Promise<Record<string, unknown>>;
+    messages(params: AnthropicMessageParams): Promise<Record<string, unknown>>;
+    streamCompletions(params: CompletionParams): AsyncGenerator<Record<string, unknown>>;
+    streamMessages(params: AnthropicMessageParams): AsyncGenerator<Record<string, unknown>>;
     listModels(inferenceKey?: string): Promise<InferenceModelListResponse>;
     retrieveModel(modelId: string, inferenceKey?: string): Promise<InferenceModel>;
     chatCompletions(params: ChatCompletionParams): Promise<ChatCompletionResponse>;

package/dist/resources/inference.js

@@ -318,8 +318,8 @@ async function apiError(response) {
 }
 /**
  * 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
+ * deployments (`/api/inference*`) with key-scoped inference on the supported
+ * `/v1` task routes. Requests are dispatched once; an idempotency header
  * is forwarded but server-side replay is not assumed.
  */
 export class Inference {
@@ -830,6 +830,61 @@ export class Inference {
             remove: () => signal?.removeEventListener('abort', relay),
         };
     }
+    prepareVerb(params, stream, anthropic) {
+        const { inferenceKey, idempotencyKey, requestId, signal, anthropicVersion, stream: requestedStream, ...payload } = params;
+        if (requestedStream !== undefined)
+            throw new Error('Choose the streaming method instead of setting stream in a request body');
+        const key = inferenceKey || this.key;
+        if (!key)
+            throw new Error('an inferenceKey is required');
+        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;
+        if (anthropic) {
+            if (anthropicVersion !== undefined && typeof anthropicVersion !== 'string') {
+                throw new Error('anthropicVersion must be a string');
+            }
+            headers['Anthropic-Version'] = anthropicVersion || '2023-06-01';
+        }
+        return { body: stream ? { ...payload, stream: true } : payload, headers, signal };
+    }
+    async sendVerb(path, params, anthropic = false) {
+        const prepared = this.prepareVerb(params, false, anthropic);
+        const abort = this.abortContext(prepared.signal);
+        try {
+            const response = await fetch(`${this.baseUrl}${path}`, {
+                method: 'POST', headers: prepared.headers, body: JSON.stringify(prepared.body), signal: abort.controller.signal,
+            });
+            if (!response.ok)
+                throw await apiError(response);
+            let payload;
+            try {
+                payload = await response.json();
+            }
+            catch {
+                throw new ApiError(response.status, { error: 'Inference endpoint returned invalid JSON' });
+            }
+            if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+                throw new ApiError(response.status, { error: 'Inference endpoint returned no response object' });
+            }
+            return payload;
+        }
+        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 modelRead(path, inferenceKey) {
         const key = inferenceKey || this.key;
         if (!key)
@@ -861,6 +916,75 @@ export class Inference {
             abort.remove();
         }
     }
+    async *streamVerb(path, params, anthropic = false) {
+        const prepared = this.prepareVerb(params, true, anthropic);
+        const abort = this.abortContext(prepared.signal);
+        try {
+            const response = await fetch(`${this.baseUrl}${path}`, {
+                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 stream returned no body' });
+            for await (const data of parseSSE(response.body)) {
+                if (data === '[DONE]') {
+                    if (anthropic)
+                        throw new ApiError(0, { error: 'Anthropic stream ended without message_stop' });
+                    return;
+                }
+                let event;
+                try {
+                    event = JSON.parse(data);
+                }
+                catch {
+                    throw new ApiError(0, { error: 'Invalid JSON SSE event' });
+                }
+                if (!event || typeof event !== 'object' || Array.isArray(event)) {
+                    throw new ApiError(0, { error: 'Inference stream returned an invalid event' });
+                }
+                if ('error' in event)
+                    throw new ApiError(0, event);
+                yield event;
+                if (anthropic && event.type === 'message_stop')
+                    return;
+            }
+            throw new ApiError(0, { error: 'Inference stream ended before completion marker' });
+        }
+        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();
+        }
+    }
+    completions(params) {
+        return this.sendVerb('/v1/completions', params);
+    }
+    embeddings(params) {
+        return this.sendVerb('/v1/embeddings', params);
+    }
+    rerank(params) {
+        return this.sendVerb('/v1/rerank', params);
+    }
+    messages(params) {
+        return this.sendVerb('/v1/messages', params, true);
+    }
+    async *streamCompletions(params) {
+        yield* this.streamVerb('/v1/completions', params);
+    }
+    async *streamMessages(params) {
+        yield* this.streamVerb('/v1/messages', params, true);
+    }
     async listModels(inferenceKey) {
         return asInferenceModelList(await this.modelRead('/v1/models', inferenceKey));
     }
@@ -922,6 +1046,7 @@ export class Inference {
                 }
                 yield event;
             }
+            throw new ApiError(0, { error: 'Inference stream ended before completion marker [DONE]' });
         }
         catch (error) {
             if (abort.controller.signal.aborted && !(error instanceof ApiError)) {

package/dist/types.d.ts

@@ -1453,11 +1453,13 @@ export interface GPUOptionsResponse {
     availability_known: boolean;
     no_fit?: boolean;
     adapter_unavailable?: boolean;
+    method_unavailable?: boolean;
     host_memory_unverified?: boolean;
     model_support?: {
         tier?: string;
         adapters?: string[];
         verified_adapters?: string[];
+        admissible_method_adapters?: Record<string, string[]>;
         objectives?: string[];
         [key: string]: unknown;
     } | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runbios-sdk",
-  "version": "0.2.14-dev.246",
+  "version": "0.2.14-dev.248",
   "description": "Official TypeScript SDK for the Run BiOS training and deployment platform API",
   "type": "module",
   "main": "./dist/index.js",