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

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.117";
+export declare const VERSION = "0.2.1-dev.123";
 export declare class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     readonly models: Models;

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.117';
+export const VERSION = '0.2.1-dev.123';
 export class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     models;

package/dist/resources/gpu.js

@@ -46,6 +46,13 @@ export class GPU {
         if (params.modelActiveParamsB !== undefined) {
             q.set('model_active_params_b', String(params.modelActiveParamsB));
         }
+        if (params.maxLength !== undefined)
+            q.set('max_length', String(params.maxLength));
+        if (params.effectiveBatch !== undefined)
+            q.set('effective_batch', String(params.effectiveBatch));
+        else if (params.perDeviceTrainBatchSize !== undefined) {
+            q.set('per_device_train_batch_size', String(params.perDeviceTrainBatchSize));
+        }
         return this._http.fetchGet(`/api/training/gpu-options?${q}`);
     }
     /**

package/dist/resources/loop.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.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';
+import type { LoopTrace, LoopTraceListResponse, LoopTraceListParams, LoopCaptureParams, LoopCaptureResult, LoopImportParams, LoopImportResult, LoopSignal, LoopSignalParams, LoopCandidate, LoopCandidateParams, LoopGrader, LoopGraderParams, LoopLabel, LoopLabelCount, LoopGradeResult, LoopDataset, LoopDatasetListParams, LoopDatasetItem, LoopDatasetCreateParams, LoopConfig, LoopConfigParams, LoopBuildRule, LoopBuildRuleParams, 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.
@@ -238,6 +238,32 @@ export declare class Loop {
      */
     createDataset(params: LoopDatasetCreateParams): Promise<LoopDataset>;
     /** List training sets, newest first. */
+    /**
+     * Stand up a rule that builds a set whenever enough new work exists.
+     *
+     * The manual path asks somebody to notice that enough conversations have
+     * been reviewed, remember which filters describe the slice they want, and
+     * press build — every time. A rule is that instruction, stored.
+     *
+     * `spec` is the same selection `createDataset` takes and is replayed
+     * verbatim, so an automatic set is identical to a hand-made one.
+     *
+     * `min_new_rows` counts only work reviewed SINCE THE LAST BUILD. Counting
+     * the whole corpus would fire the rule every interval forever, because a
+     * total that has crossed a threshold stays across it.
+     */
+    createBuildRule(params: LoopBuildRuleParams): Promise<LoopBuildRule>;
+    /**
+     * Every build rule, with what each one last did and why.
+     *
+     * `last_reason` is the field worth reading: a rule quiet because it is
+     * waiting looks exactly like one quiet because it is broken.
+     */
+    listBuildRules(): Promise<LoopBuildRule[]>;
+    /** Stop a standing build rule. Sets it already produced are untouched. */
+    deleteBuildRule(id: string): Promise<{
+        deleted: boolean;
+    }>;
     listDatasets(params?: LoopDatasetListParams): Promise<LoopDataset[]>;
     /** Read one training set and its curation report. */
     getDataset(id: string): Promise<LoopDataset>;

package/dist/resources/loop.js

@@ -113,6 +113,10 @@ export class Loop {
             if (k && v)
                 q.append('attr', `${k}:${v}`);
         }
+        if (params.model)
+            q.set('model', params.model);
+        if (params.origin)
+            q.set('origin', params.origin);
         if (params.unlabelled)
             q.set('unlabelled', 'true');
         if (params.limit != null)
@@ -309,6 +313,39 @@ export class Loop {
         return res.dataset;
     }
     /** List training sets, newest first. */
+    // ── build rules ───────────────────────────────────────────────────────
+    /**
+     * Stand up a rule that builds a set whenever enough new work exists.
+     *
+     * The manual path asks somebody to notice that enough conversations have
+     * been reviewed, remember which filters describe the slice they want, and
+     * press build — every time. A rule is that instruction, stored.
+     *
+     * `spec` is the same selection `createDataset` takes and is replayed
+     * verbatim, so an automatic set is identical to a hand-made one.
+     *
+     * `min_new_rows` counts only work reviewed SINCE THE LAST BUILD. Counting
+     * the whole corpus would fire the rule every interval forever, because a
+     * total that has crossed a threshold stays across it.
+     */
+    async createBuildRule(params) {
+        const res = await this._http.fetchPost('/api/loop/build-rules', params);
+        return res.rule;
+    }
+    /**
+     * Every build rule, with what each one last did and why.
+     *
+     * `last_reason` is the field worth reading: a rule quiet because it is
+     * waiting looks exactly like one quiet because it is broken.
+     */
+    async listBuildRules() {
+        const res = await this._http.fetchGet('/api/loop/build-rules');
+        return res.rules ?? [];
+    }
+    /** Stop a standing build rule. Sets it already produced are untouched. */
+    async deleteBuildRule(id) {
+        return this._http.fetchDelete(`/api/loop/build-rules/${encodeURIComponent(id)}`);
+    }
     async listDatasets(params = {}) {
         const q = new URLSearchParams();
         if (params.method)

package/dist/types.d.ts

@@ -1226,6 +1226,17 @@ export interface GPUOptionsParams {
     rlhfType?: RLHFAlgorithm | string;
     modelParamsB?: number;
     modelActiveParamsB?: number;
+    /** Training sequence length the sizing should assume (tokens). */
+    maxLength?: number;
+    /**
+     * Effective batch (samples per optimizer step) -- the quality decision made
+     * before a GPU is chosen. Each option then answers with the per-device split
+     * that runs it there (`recommended_micro_batch` x `recommended_grad_accum`
+     * x `required_count`), and the minimum GPU count is sized at micro-batch 1.
+     */
+    effectiveBatch?: number;
+    /** Per-device batch to size as typed instead (ignored when effectiveBatch is set). */
+    perDeviceTrainBatchSize?: number;
 }
 /** One model-aware GPU option with live stock and total-price context. */
 export interface GPUOption {
@@ -1246,6 +1257,10 @@ export interface GPUOption {
     bookable: boolean;
     reason?: string;
     checked_at?: string;
+    /** Present when the request stated an effective batch: its split on this card at required_count. */
+    effective_batch?: number;
+    recommended_micro_batch?: number;
+    recommended_grad_accum?: number;
 }
 /** Actionable alternative returned when no GPU option is currently bookable. */
 export interface GPUOptionSuggestion {
@@ -1275,6 +1290,10 @@ export interface GPUOptionsResponse {
         storage_gb: number;
         price_per_hour_cents: number;
         total_price_per_hour_cents: number;
+        /** Present when the request stated an effective batch. */
+        effective_batch?: number;
+        per_device_train_batch_size?: number;
+        gradient_accumulation_steps?: number;
     };
     suggestions?: GPUOptionSuggestion[];
 }
@@ -2267,6 +2286,10 @@ export interface LoopTraceListParams {
     unlabelled?: boolean;
     limit?: number;
     offset?: number;
+    /** Only what ONE model answered — the filter distillation is made of. */
+    model?: string;
+    /** `captured` (our model's own behaviour) or `imported` (a file somebody brought). */
+    origin?: 'captured' | 'imported';
 }
 export interface LoopTraceListResponse {
     traces: LoopTrace[];
@@ -2295,6 +2318,10 @@ export interface LoopDatasetCreateParams {
     attributes?: Record<string, string>;
     /** Only the conversations nobody has described yet. */
     unlabelled?: boolean;
+    /** Only what ONE model answered — the filter distillation is made of. */
+    model?: string;
+    /** `captured` (our model's own behaviour) or `imported` (a file somebody brought). */
+    origin?: 'captured' | 'imported';
 }
 export interface LoopDataset {
     id: string;
@@ -2338,12 +2365,54 @@ export interface LoopConfig {
     enabled_by: string | null;
     enabled_at: string | null;
     updated_at: string;
+    auto_grade: boolean;
+}
+export interface LoopBuildRuleParams {
+    name: string;
+    method: string;
+    /**
+     * How many rows reviewed SINCE THE LAST BUILD must exist before this fires
+     * again. Minimum 10. Counting the whole corpus instead would fire the rule
+     * every interval forever, because a total that has crossed a threshold stays
+     * across it.
+     */
+    min_new_rows?: number;
+    enabled?: boolean;
+    /** The same selection `createDataset` takes, replayed verbatim. */
+    spec?: LoopDatasetCreateParams;
+}
+export interface LoopBuildRule {
+    id: string;
+    workspace_id: string;
+    name: string;
+    method: string;
+    spec: Record<string, unknown>;
+    min_new_rows: number;
+    enabled: boolean;
+    last_built_at: string | null;
+    last_dataset_id: string | null;
+    /**
+     * Why the rule did not fire last time it was checked. A rule quiet because
+     * it is waiting looks exactly like one quiet because it is broken; this is
+     * the difference.
+     */
+    last_reason: string | null;
+    last_checked_at: string | null;
+    created_by: string | null;
+    created_at: string;
+    updated_at: string;
 }
 export interface LoopConfigParams {
     enabled: boolean;
     retention_days?: number;
     /** Deterministic per conversation, so turns are never split. 0 < rate <= 1. */
     sample_rate?: number;
+    /**
+     * Continuous rule-based scoring for this source. OMITTED MEANS UNCHANGED:
+     * a caller saving retention must not switch grading off for a workspace
+     * that turned it on.
+     */
+    auto_grade?: boolean;
 }
 /** One thing a judge scores, separately from the others. */
 export interface LoopJudgeDimension {

package/package.json

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