runbios-sdk 0.2.1-dev.115 → 0.2.1-dev.117

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.1-dev.115";
+export declare const VERSION = "0.2.1-dev.117";
 export declare class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     readonly models: Models;
@@ -75,4 +75,4 @@ 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, } from './resources/inference.js';
-export type { BiOSConfig, PaginatedResponse, ApiErrorBody, AvailableGpuAlternative, CapacityMinimumRequirement, InferenceBookingAccepted, Model, ModelSearchParams, ModelSearchResponse, ModelDetailResponse, 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, 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, } from './types.js';
+export type { BiOSConfig, PaginatedResponse, ApiErrorBody, AvailableGpuAlternative, CapacityMinimumRequirement, InferenceBookingAccepted, Model, ModelSearchParams, ModelSearchResponse, ModelDetailResponse, 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, } 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.1-dev.115';
+export const VERSION = '0.2.1-dev.117';
 export class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     models;

package/dist/resources/loop.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { LoopTrace, LoopTraceListResponse, LoopTraceListParams, LoopCaptureParams, LoopCaptureResult, LoopSignal, LoopSignalParams, LoopCandidate, LoopCandidateParams, LoopGrader, LoopGraderParams, LoopLabel, LoopLabelCount, LoopGradeResult, LoopDataset, LoopDatasetListParams, LoopDatasetItem, LoopDatasetCreateParams, LoopConfig, LoopConfigParams, LoopStats, LoopJudge, LoopJudgeParams, LoopJudgeRun, LoopJudgeWork, LoopJudgeVerdict, LoopJudgeVerdictResult } from '../types.js';
+import type { LoopTrace, LoopTraceListResponse, LoopTraceListParams, LoopCaptureParams, LoopCaptureResult, LoopImportParams, LoopImportResult, LoopSignal, LoopSignalParams, LoopCandidate, LoopCandidateParams, LoopGrader, LoopGraderParams, LoopLabel, LoopLabelCount, LoopGradeResult, LoopDataset, LoopDatasetListParams, LoopDatasetItem, LoopDatasetCreateParams, LoopConfig, LoopConfigParams, LoopStats, LoopJudge, LoopJudgeParams, LoopJudgeRun, LoopJudgeWork, LoopJudgeVerdict, LoopJudgeVerdictResult } from '../types.js';
 /**
  * The Conscious Loop -- capture what your model was asked and answered, record
  * whether it was right, and turn those judgements into training data.
@@ -59,6 +59,33 @@ export declare class Loop {
      * your application.
      */
     capture(params: LoopCaptureParams): Promise<LoopCaptureResult>;
+    /**
+     * Bring data you already have into the loop.
+     *
+     * This does NOT create a training set. It creates conversations, in the same
+     * place captured ones live and subject to the same review, rules, judges and
+     * labels. A row becomes trainable when something says it is good, never
+     * because it arrived in a file -- which is the one guarantee that separates
+     * a corpus from a pile.
+     *
+     * Each row is read for what it actually is. A `prompt`/`chosen`/`rejected`
+     * triple becomes a preference pair; an answer plus a yes-or-no becomes a
+     * thumbs verdict; a question and an answer waits for review; a question with
+     * no answer waits for an answer; a paragraph of prose is refused, because it
+     * is not a conversation.
+     *
+     * A verdict that arrives *with* the file is kept -- discarding somebody's
+     * judgement would be worse -- but it is recorded as having come from your
+     * earlier process rather than from a reviewer here, and the conversation
+     * records that it was imported. Neither fact can be reconstructed later, so
+     * both are written at the door.
+     *
+     * `source` is required and becomes the id every imported conversation is
+     * filed under: "everything in one bucket called import" is a corpus nobody
+     * can slice afterwards. At most 5000 rows per call, because the call is
+     * synchronous and somebody is waiting on it.
+     */
+    importRows(params: LoopImportParams): Promise<LoopImportResult>;
     /** List captured conversations, newest first. */
     listTraces(params?: LoopTraceListParams): Promise<LoopTraceListResponse>;
     /** Read one conversation, with every verdict recorded on it. */

package/dist/resources/loop.js

@@ -62,6 +62,35 @@ export class Loop {
     async capture(params) {
         return this._http.fetchPost('/api/loop/traces', params);
     }
+    /**
+     * Bring data you already have into the loop.
+     *
+     * This does NOT create a training set. It creates conversations, in the same
+     * place captured ones live and subject to the same review, rules, judges and
+     * labels. A row becomes trainable when something says it is good, never
+     * because it arrived in a file -- which is the one guarantee that separates
+     * a corpus from a pile.
+     *
+     * Each row is read for what it actually is. A `prompt`/`chosen`/`rejected`
+     * triple becomes a preference pair; an answer plus a yes-or-no becomes a
+     * thumbs verdict; a question and an answer waits for review; a question with
+     * no answer waits for an answer; a paragraph of prose is refused, because it
+     * is not a conversation.
+     *
+     * A verdict that arrives *with* the file is kept -- discarding somebody's
+     * judgement would be worse -- but it is recorded as having come from your
+     * earlier process rather than from a reviewer here, and the conversation
+     * records that it was imported. Neither fact can be reconstructed later, so
+     * both are written at the door.
+     *
+     * `source` is required and becomes the id every imported conversation is
+     * filed under: "everything in one bucket called import" is a corpus nobody
+     * can slice afterwards. At most 5000 rows per call, because the call is
+     * synchronous and somebody is waiting on it.
+     */
+    async importRows(params) {
+        return this._http.fetchPost('/api/loop/import', params);
+    }
     // ── traces ────────────────────────────────────────────────────────────
     /** List captured conversations, newest first. */
     async listTraces(params = {}) {

package/dist/resources/training.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { TrainingCreateParams, TrainingListParams, TrainingJob, TrainingListResponse, TrainingMetrics, TrainingCheckpoint, TrainingLogs, TrainingStopResponse, TrainingResumeResponse, TrainingPreflightResponse, TrainingCapabilities } from '../types.js';
+import type { TrainingCreateParams, TrainingListParams, TrainingJob, TrainingListResponse, TrainingMetrics, TrainingCheckpoint, TrainingLogs, TrainingStopResponse, TrainingResumeResponse, TrainingPreflightResponse, TrainingRecommendParams, TrainingAdvisorVerdict, TrainingCapabilities } from '../types.js';
 /**
  * Create, monitor, and manage fine-tuning training jobs.
  */
@@ -55,6 +55,14 @@ export declare class Training {
     create(params: TrainingCreateParams): Promise<TrainingJob>;
     /** Validate and canonicalize a training request without creating or billing a job. */
     preflight(params: TrainingCreateParams): Promise<TrainingPreflightResponse>;
+    /**
+     * Ask the trainer's own sizing model what to run: per-device batch,
+     * accumulation, learning rate, warmup, predicted peak memory, minimum GPU
+     * count and a wall-clock estimate for this model on this GPU type, with the
+     * basis of every number. Side-effect free. When `available` is false no
+     * advisor is deployed and the other fields are absent -- nothing is guessed.
+     */
+    recommend(params: TrainingRecommendParams): Promise<TrainingAdvisorVerdict>;
     /** Return one server-driven page with pagination metadata. */
     listPage(params?: TrainingListParams): Promise<TrainingListResponse>;
     /**

package/dist/resources/training.js

@@ -244,6 +244,41 @@ export class Training {
         const { body } = buildTrainingRequest(params);
         return this._http.fetchPost('/api/training/preflight', body);
     }
+    /**
+     * Ask the trainer's own sizing model what to run: per-device batch,
+     * accumulation, learning rate, warmup, predicted peak memory, minimum GPU
+     * count and a wall-clock estimate for this model on this GPU type, with the
+     * basis of every number. Side-effect free. When `available` is false no
+     * advisor is deployed and the other fields are absent -- nothing is guessed.
+     */
+    async recommend(params) {
+        const q = new URLSearchParams({ model_id: params.model, gpu_type: params.gpuType });
+        if (params.modelRevision)
+            q.set('model_revision', params.modelRevision);
+        if (params.integrationId)
+            q.set('integration_id', params.integrationId);
+        if (params.gpuCount !== undefined)
+            q.set('gpu_count', String(params.gpuCount));
+        if (params.adapter)
+            q.set('train_type', params.adapter);
+        if (params.method)
+            q.set('method', params.method === 'cpt' ? 'pt' : params.method);
+        if (params.maxLength !== undefined)
+            q.set('max_length', String(params.maxLength));
+        if (params.epochs !== undefined)
+            q.set('num_train_epochs', String(params.epochs));
+        if (params.maxSteps !== undefined)
+            q.set('max_steps', String(params.maxSteps));
+        if (params.perDeviceTrainBatchSize !== undefined)
+            q.set('per_device_train_batch_size', String(params.perDeviceTrainBatchSize));
+        if (params.gradientAccumulationSteps !== undefined)
+            q.set('gradient_accumulation_steps', String(params.gradientAccumulationSteps));
+        if (params.datasetIds?.length)
+            q.set('dataset_ids', params.datasetIds.join(','));
+        if (params.workspaceId)
+            q.set('workspace_id', params.workspaceId);
+        return this._http.fetchGet(`/api/training/recommend?${q}`);
+    }
     /** Return one server-driven page with pagination metadata. */
     async listPage(params = {}) {
         const q = new URLSearchParams();

package/dist/types.d.ts

@@ -907,6 +907,8 @@ export interface TrainingPreflightDataset {
 export interface TrainingPreflightWarning {
     code: string;
     message: string;
+    /** Request field the warning is about (e.g. `per_device_train_batch_size`), when there is one. */
+    field?: string;
 }
 /** Side-effect-free validation/sizing result; this endpoint never creates or bills a job. */
 export interface TrainingPreflightResponse {
@@ -927,6 +929,131 @@ export interface TrainingPreflightResponse {
     queue_eligible: boolean;
     warnings: TrainingPreflightWarning[];
     checked_at: string;
+    /**
+     * The trainer image's own sizing verdict for the requested GPU shape:
+     * recommended microbatch/accumulation/learning rate, predicted peak memory,
+     * minimum GPU count, wall-clock estimate, and whether the per-device batch
+     * you asked for is predicted to fit. Absent when no advisor is deployed.
+     */
+    advisor?: TrainingAdvisorVerdict;
+}
+/** Parameters for `training.recommend()` (GET /api/training/recommend). */
+export interface TrainingRecommendParams {
+    model: string;
+    modelRevision?: string;
+    integrationId?: string;
+    gpuType: string;
+    gpuCount?: number;
+    adapter?: 'full' | 'lora' | 'qlora';
+    method?: 'sft' | 'cpt' | 'pt';
+    maxLength?: number;
+    epochs?: number;
+    maxSteps?: number;
+    /** Your own microbatch, to be judged against the model. */
+    perDeviceTrainBatchSize?: number;
+    gradientAccumulationSteps?: number;
+    /** Datasets the job will train on; their measured token statistics feed the sizing. */
+    datasetIds?: string[];
+    workspaceId?: string;
+}
+/** Basis of one recommended value: measured on hardware, derived through a stated model, or an argued default. */
+export type TrainingAdvisorBasis = 'measured' | 'derived' | 'judgement';
+export interface TrainingAdvisorJustification {
+    field: string;
+    value: string;
+    reason: string;
+    basis: TrainingAdvisorBasis;
+}
+export interface TrainingAdvisorRecommendation {
+    per_device_train_batch_size: number;
+    gradient_accumulation_steps: number;
+    global_batch_size: number;
+    activation_checkpoint: string;
+    compile: boolean;
+    learning_rate: number;
+    warmup_steps: number;
+    parallelism: {
+        dp_replicate: number;
+        dp_shard: number;
+        tp: number;
+        pp: number;
+        cp: number;
+        ep: number;
+    };
+    /** Predicted peak reserved GPU memory per device, GiB. */
+    predicted_peak_gb: number;
+    /** (median, worst) percent the prediction ran over measurement on the calibration rows. */
+    memory_band_percent: [number, number];
+    memory_class: string;
+    predicted_mfu: number;
+    supervised_tokens_per_step: number;
+    predicted_roughness: number;
+    tokens_per_second: number;
+    throughput_basis: 'measured' | 'derived';
+    wall_clock: {
+        steps_per_epoch: number;
+        total_steps: number;
+        training_hours: number;
+        startup_minutes_estimate: number;
+        basis: TrainingAdvisorBasis;
+    } | null;
+}
+export interface TrainingAdvisorUserShape {
+    per_device_train_batch_size: number;
+    fits: boolean;
+    largest_fitting_batch?: number;
+    predicted_peak_gb?: number;
+    reason?: string;
+    /** Same global batch, a microbatch that fits. Present only when `fits` is false. */
+    suggested?: {
+        per_device_train_batch_size: number;
+        gradient_accumulation_steps: number;
+        reason: string;
+    };
+}
+/**
+ * Verdict of the training advisor. `available: false` means no advisor is
+ * deployed or it did not answer; nothing else is populated then.
+ */
+export interface TrainingAdvisorVerdict {
+    available: boolean;
+    reason?: string;
+    fits?: boolean;
+    /** Smallest GPU count of this type the job fits on; null when none up to the per-job cap. */
+    min_gpu_count?: number | null;
+    gpu?: {
+        platform_type: string;
+        sized_as: string;
+        capacity_gb: number;
+        capacity_measured: boolean;
+    };
+    model?: {
+        params_total_b: number;
+        params_active_b: number;
+        is_moe: boolean;
+        is_vlm: boolean;
+        has_linear_attention: boolean;
+    };
+    dataset_measured?: boolean;
+    seq_len?: number;
+    gpu_count?: number;
+    recommended?: TrainingAdvisorRecommendation;
+    user_shape?: TrainingAdvisorUserShape;
+    justifications?: TrainingAdvisorJustification[];
+    warnings?: string[];
+    dataset_stats_used?: {
+        num_rows: number;
+        avg_tokens_per_sample?: number;
+        avg_supervised_tokens_per_sample?: number;
+        has_images: boolean;
+        estimated: boolean;
+    };
+    measured_history?: {
+        tokens_per_second: number;
+        memory_anchors: number;
+    };
+    model_id?: string;
+    model_revision?: string;
 }
 /** One method, algorithm, or adapter reported by the pinned training engine. */
 export interface TrainingCapabilityChoice {
@@ -2046,6 +2173,35 @@ export interface LoopCaptureResult {
     /** Why nothing was stored, e.g. `capture_disabled`, `not_sampled`. */
     reason?: string;
 }
+export interface LoopImportParams {
+    /**
+     * Where this came from. Required, and becomes the id every imported
+     * conversation is filed under, so the import stays sliceable later.
+     */
+    source: string;
+    /** The file, already parsed. At most 5000 rows per call. */
+    rows: Record<string, unknown>[];
+    /** Which model produced these, when the rows do not say per-row. */
+    model?: string;
+    /** Applied to every row: importing a dump is when somebody knows what it is. */
+    labels?: string[];
+    attributes?: Record<string, string>;
+}
+export interface LoopImportResult {
+    imported: number;
+    /**
+     * How many arrived carrying a verdict. Reported apart from `imported`
+     * because it is the difference between data you can train on and data
+     * somebody still has to look at.
+     */
+    reviewed: number;
+    needs_review: number;
+    refused: number;
+    /** How many rows of each recognised shape, so a mis-shaped file is visible. */
+    by_shape: Record<string, number>;
+    refused_why: Record<string, number>;
+    notes: string[];
+}
 export interface LoopSignal {
     id: string;
     trace_id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runbios-sdk",
-  "version": "0.2.1-dev.115",
+  "version": "0.2.1-dev.117",
   "description": "Official TypeScript SDK for the Run BiOS training and deployment platform API",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,7 +20,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "test": "npm run build && node --test test/contracts.test.mjs test/capacity-contract.test.mjs test/contract-drift.test.mjs test/inference-param-naming.test.mjs test/coming-soon.test.mjs",
+    "test": "npm run build && node --test \"test/*.test.mjs\"",
     "clean": "rm -rf dist",
     "prepack": "npm run clean && npm run build"
   },