runbios-sdk 0.2.1-dev.120 → 0.2.1-dev.126

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.120";
+export declare const VERSION = "0.2.1-dev.126";
 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.120';
+export const VERSION = '0.2.1-dev.126';
 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, 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/resources/training.js

@@ -69,6 +69,10 @@ function buildTrainingRequest(params) {
         body.network_volume_id = params.networkVolumeId;
     if (params.datasetSampleLimits !== undefined)
         body.dataset_sample_limits = params.datasetSampleLimits;
+    if (params.datasetSampling !== undefined)
+        body.dataset_sampling = params.datasetSampling;
+    if (params.datasetSamplingStrategy !== undefined)
+        body.dataset_sampling_strategy = params.datasetSamplingStrategy;
     if (params.datasetMixing !== undefined)
         body.dataset_mixing = params.datasetMixing;
     if (params.mixing !== undefined)

package/dist/types.d.ts

@@ -548,6 +548,21 @@ export interface TrainingCreateParams {
      * large dataset without importing a trimmed copy.
      */
     datasetSampleLimits?: Record<string, number>;
+    /**
+     * Per-dataset sampling (key = a dataset ID from datasetIds): exactly one of
+     * `rows` or `percent` (of the dataset's usable rows for this method). Asking
+     * for more than the dataset holds uses every usable row and the run says
+     * so. Resolved to a row count identically by preflight and create, recorded
+     * in the mix manifest, and reproduced exactly on resume.
+     */
+    datasetSampling?: Record<string, DatasetSampling>;
+    /**
+     * How sampled rows are chosen: `first` (default) keeps the first N usable
+     * rows in file order -- what a curriculum wants; `random` draws a seeded
+     * uniform sample of the usable rows (kept in file order, seed = the mixing
+     * plan's seed, so a resume draws the same rows).
+     */
+    datasetSamplingStrategy?: 'first' | 'random';
     /** Training method. */
     method: TrainingMethod;
     /** Adapter type. */
@@ -1211,6 +1226,12 @@ export interface GPUPricingResponse {
     stale?: boolean;
     stale_message?: string;
 }
+/** One dataset's sampling request: exactly one of rows or percent. */
+export interface DatasetSampling {
+    rows?: number;
+    /** Percent (0-100) of the dataset's usable rows for the training method. */
+    percent?: number;
+}
 /** Parameters understood by the authenticated training GPU-options endpoint. */
 export interface GPUOptionsParams {
     modelId: string;
@@ -2286,6 +2307,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[];
@@ -2314,6 +2339,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;
@@ -2357,12 +2386,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.120",
+  "version": "0.2.1-dev.126",
   "description": "Official TypeScript SDK for the Run BiOS training and deployment platform API",
   "type": "module",
   "main": "./dist/index.js",