runbios-sdk 0.2.1-dev.104 → 0.2.1-dev.106

package/dist/index.d.ts

@@ -30,11 +30,12 @@ import { Training } from './resources/training.js';
 import { Wallet } from './resources/wallet.js';
 import { GPU } from './resources/gpu.js';
 import { Inference } from './resources/inference.js';
+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.104";
+export declare const VERSION = "0.2.1-dev.106";
 export declare class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     readonly models: Models;
@@ -51,6 +52,12 @@ export declare class RunBiOS {
      * serving deployments, plus OpenAI-compatible non-streaming and SSE calls.
      */
     readonly inference: Inference;
+    /**
+     * The Conscious Loop. Capture what your model was asked and answered, record
+     * whether it was right, and turn those judgements into training data for
+     * SFT, DPO or GRPO. Nothing is captured until you turn it on for a source.
+     */
+    readonly loop: Loop;
     /** @internal */
     private readonly _http;
     constructor(config: BiOSConfig);

package/dist/index.js

@@ -30,11 +30,12 @@ import { Training } from './resources/training.js';
 import { Wallet } from './resources/wallet.js';
 import { GPU } from './resources/gpu.js';
 import { Inference } from './resources/inference.js';
+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.104';
+export const VERSION = '0.2.1-dev.106';
 export class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     models;
@@ -51,6 +52,12 @@ export class RunBiOS {
      * serving deployments, plus OpenAI-compatible non-streaming and SSE calls.
      */
     inference;
+    /**
+     * The Conscious Loop. Capture what your model was asked and answered, record
+     * whether it was right, and turn those judgements into training data for
+     * SFT, DPO or GRPO. Nothing is captured until you turn it on for a source.
+     */
+    loop;
     /** @internal */
     _http;
     constructor(config) {
@@ -61,6 +68,7 @@ export class RunBiOS {
         this.training = new Training(http);
         this.wallet = new Wallet(http);
         this.gpu = new GPU(http);
+        this.loop = new Loop(http);
         // Inference-key resolution, most specific first:
         //   1. an explicit inferenceKey (a per-deployment sk-bios-... key)
         //   2. RUNBIOS_INFERENCE_KEY from the environment (legacy: BIOS_INFERENCE_KEY)

package/dist/resources/loop.d.ts

@@ -0,0 +1,200 @@
+import type { HttpClient } from '../client.js';
+import type { LoopTrace, LoopTraceListResponse, LoopTraceListParams, LoopCaptureParams, LoopCaptureResult, LoopSignal, LoopSignalParams, LoopCandidate, LoopCandidateParams, LoopDataset, LoopDatasetListParams, LoopDatasetItem, LoopDatasetCreateParams, LoopConfig, LoopConfigParams, LoopStats } 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.
+ *
+ * Nothing is captured until you turn it on for a source, and you can turn it
+ * off again at any time. Anything that looks like a credential or a personal
+ * detail is removed before the record is written, never afterwards.
+ *
+ * Requires an API key carrying `loop:read` and/or `loop:write`. Those scopes are
+ * deliberately absent from the Read Only preset, because what they return is
+ * your raw prompts and completions rather than catalog metadata.
+ *
+ * @example
+ * ```ts
+ * // 1. Decide that this source is recorded.
+ * await client.loop.setConfig('my-agent', { enabled: true, retention_days: 30 });
+ *
+ * // 2. Send what your model was asked and what it answered. Works whoever
+ * //    served it -- us, another provider, or your own servers.
+ * const { trace_id } = await client.loop.capture({
+ *   deployment_id: 'my-agent',
+ *   model: 'gpt-4o',
+ *   messages: [{ role: 'user', content: 'what is our refund window' }],
+ *   completion: 'thirty days',
+ * });
+ *
+ * // 3. Say whether it was right. A rewrite is the most valuable answer here:
+ * //    the model learns your version AND learns to avoid its own.
+ * await client.loop.signal(trace_id, {
+ *   verdict: 'edited',
+ *   correction: 'Thirty days from delivery, no questions asked.',
+ * });
+ *
+ * // 4. Turn the judgements into a training set and take the file.
+ * const ds = await client.loop.createDataset({ name: 'support', method: 'sft' });
+ * const jsonl = await client.loop.downloadDataset(ds.id);
+ * ```
+ */
+export declare class Loop {
+    private readonly _http;
+    /** @internal */
+    constructor(_http: HttpClient);
+    /**
+     * Send one exchange to be captured.
+     *
+     * Works regardless of who served the model: ours, OpenAI, Fireworks, your own
+     * own servers, an agent framework. Pass `tool_calls` and `tools` when the turn
+     * invoked a function -- without them a tool-using exchange trains the model to
+     * answer in prose where it should have called something.
+     *
+     * The returned `trace_id` is OURS. If you pass your own `request_id` it is
+     * kept as an idempotency handle: sending the same one again returns the same
+     * trace rather than storing a second copy, so a retry is safe.
+     *
+     * When the source is not enabled this resolves with `captured: false` and a
+     * reason instead of throwing -- capture must never be the thing that breaks
+     * your application.
+     */
+    capture(params: LoopCaptureParams): Promise<LoopCaptureResult>;
+    /** List captured conversations, newest first. */
+    listTraces(params?: LoopTraceListParams): Promise<LoopTraceListResponse>;
+    /** Read one conversation, with every verdict recorded on it. */
+    getTrace(id: string): Promise<LoopTrace>;
+    /**
+     * Delete a conversation.
+     *
+     * It also leaves every training set built from it, including sets already
+     * exported -- so a customer asking you to delete a conversation genuinely
+     * removes it from what the model will learn next. Training runs that have
+     * already finished are not affected.
+     */
+    deleteTrace(id: string): Promise<{
+        deleted: boolean;
+        trace_id: string;
+    }>;
+    /**
+     * Record a verdict on a conversation.
+     *
+     * Append-only: posting a second verdict does not replace the first. Two
+     * reviewers disagreeing about an answer is information worth keeping.
+     *
+     * `source` says who judged: `human`, `verifier` (a deterministic check --
+     * tests passed, schema valid), `judge` (a model grading a model), or
+     * `behavioural` (what the user did next). When several disagree, a human
+     * outranks a verifier, a verifier outranks a judge, and a judge outranks a
+     * behavioural hint.
+     */
+    signal(traceId: string, params: LoopSignalParams): Promise<LoopSignal>;
+    /** Every verdict on one conversation, oldest first. */
+    listSignals(traceId: string): Promise<LoopSignal[]>;
+    /**
+     * Submit an alternative answer to a prompt already captured.
+     *
+     * This is what makes preference learning scale. A human rewrite is the best
+     * signal there is and the least available -- somebody has to sit down and
+     * write it. Sample the model several times for the same prompt, score the
+     * samples, and a DPO pair falls out automatically: best becomes chosen,
+     * worst becomes rejected. Point a stronger model at the prompt instead and
+     * the same machinery does distillation.
+     *
+     * Score them, or they cannot pair: an unscored alternative says nothing about
+     * which answer anybody prefers. `score_source` is required alongside a score,
+     * because precedence between a verifier, a judge and a person is the whole
+     * reason we record who judged.
+     *
+     * A human correction always outranks any score.
+     *
+     * @example
+     * ```ts
+     * for (const sample of await sampleMyModel(prompt, 4)) {
+     *   await client.loop.addCandidate(traceId, {
+     *     completion: sample.text,
+     *     score: await myVerifier(sample.text),
+     *     score_source: 'verifier',
+     *   });
+     * }
+     * ```
+     */
+    addCandidate(traceId: string, params: LoopCandidateParams): Promise<LoopCandidate>;
+    /** Every alternative answer recorded for one prompt, oldest first. */
+    listCandidates(traceId: string): Promise<LoopCandidate[]>;
+    /**
+     * Build a training set from the feedback recorded so far.
+     *
+     * The three methods need genuinely different things, so one set cannot be
+     * reshaped into another afterwards:
+     *
+     * - `sft` -- answers you marked right, and answers you rewrote.
+     * - `dpo` -- answers you REWROTE, so a better and a worse version of the same
+     *   reply exist. Nothing else produces a pair.
+     * - `grpo` -- answers with a value or fact they can be checked against.
+     *
+     * `holdout_percent` holds back your most recent work rather than a random
+     * slice, so the evaluation measures whether the model generalised instead of
+     * memorised the same week.
+     *
+     * The result always reports `rejected_counts`: why rows were left out. A
+     * small set with a reason is useful; a small set without one is just alarming.
+     */
+    createDataset(params: LoopDatasetCreateParams): Promise<LoopDataset>;
+    /** List training sets, newest first. */
+    listDatasets(params?: LoopDatasetListParams): Promise<LoopDataset[]>;
+    /** Read one training set and its curation report. */
+    getDataset(id: string): Promise<LoopDataset>;
+    /**
+     * Page through the rows a training set actually contains.
+     *
+     * Worth reading before you spend money on a run: each row carries the address
+     * of the conversation it was built from.
+     */
+    listDatasetItems(id: string, params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<LoopDatasetItem[]>;
+    /**
+     * Download a training set as JSONL -- one training row per line, the format
+     * every trainer in this space reads.
+     *
+     * `split` defaults to the training rows; pass `holdout` for the slice held
+     * back, or `all` for both.
+     */
+    downloadDataset(id: string, split?: 'train' | 'holdout' | 'all'): Promise<string>;
+    /**
+     * Delete a training set.
+     *
+     * The conversations it was built from are untouched -- a set is a selection,
+     * and discarding the selection must not discard the evidence.
+     */
+    deleteDataset(id: string): Promise<{
+        deleted: boolean;
+        dataset_id: string;
+    }>;
+    /** Every source this workspace has configured. */
+    listConfigs(): Promise<LoopConfig[]>;
+    /**
+     * Read the capture setting for one source. A source nobody has configured
+     * reads back as disabled rather than missing, because "we are not recording
+     * this" is the honest answer.
+     */
+    getConfig(source: string): Promise<LoopConfig>;
+    /**
+     * Turn capture on or off for a source, and choose how long it is kept.
+     *
+     * This is the consent decision the whole feature rests on: nothing is
+     * recorded until it is made, and the row remembers who made it and when.
+     * `sample_rate` below 1 records a deterministic fraction, chosen so that every
+     * turn of one conversation is captured or skipped together -- half a
+     * conversation makes training rows with holes in them.
+     */
+    setConfig(source: string, params: LoopConfigParams): Promise<LoopConfig>;
+    /**
+     * How much there is, and how much of it each method could actually use.
+     *
+     * The `ready` numbers are upper bounds: duplicate questions are folded into
+     * one row while a set is built, so the finished count can be lower.
+     */
+    stats(): Promise<LoopStats>;
+}

package/dist/resources/loop.js

@@ -0,0 +1,277 @@
+/**
+ * The Conscious Loop -- capture what your model was asked and answered, record
+ * whether it was right, and turn those judgements into training data.
+ *
+ * Nothing is captured until you turn it on for a source, and you can turn it
+ * off again at any time. Anything that looks like a credential or a personal
+ * detail is removed before the record is written, never afterwards.
+ *
+ * Requires an API key carrying `loop:read` and/or `loop:write`. Those scopes are
+ * deliberately absent from the Read Only preset, because what they return is
+ * your raw prompts and completions rather than catalog metadata.
+ *
+ * @example
+ * ```ts
+ * // 1. Decide that this source is recorded.
+ * await client.loop.setConfig('my-agent', { enabled: true, retention_days: 30 });
+ *
+ * // 2. Send what your model was asked and what it answered. Works whoever
+ * //    served it -- us, another provider, or your own servers.
+ * const { trace_id } = await client.loop.capture({
+ *   deployment_id: 'my-agent',
+ *   model: 'gpt-4o',
+ *   messages: [{ role: 'user', content: 'what is our refund window' }],
+ *   completion: 'thirty days',
+ * });
+ *
+ * // 3. Say whether it was right. A rewrite is the most valuable answer here:
+ * //    the model learns your version AND learns to avoid its own.
+ * await client.loop.signal(trace_id, {
+ *   verdict: 'edited',
+ *   correction: 'Thirty days from delivery, no questions asked.',
+ * });
+ *
+ * // 4. Turn the judgements into a training set and take the file.
+ * const ds = await client.loop.createDataset({ name: 'support', method: 'sft' });
+ * const jsonl = await client.loop.downloadDataset(ds.id);
+ * ```
+ */
+export class Loop {
+    _http;
+    /** @internal */
+    constructor(_http) {
+        this._http = _http;
+    }
+    // ── capture ───────────────────────────────────────────────────────────
+    /**
+     * Send one exchange to be captured.
+     *
+     * Works regardless of who served the model: ours, OpenAI, Fireworks, your own
+     * own servers, an agent framework. Pass `tool_calls` and `tools` when the turn
+     * invoked a function -- without them a tool-using exchange trains the model to
+     * answer in prose where it should have called something.
+     *
+     * The returned `trace_id` is OURS. If you pass your own `request_id` it is
+     * kept as an idempotency handle: sending the same one again returns the same
+     * trace rather than storing a second copy, so a retry is safe.
+     *
+     * When the source is not enabled this resolves with `captured: false` and a
+     * reason instead of throwing -- capture must never be the thing that breaks
+     * your application.
+     */
+    async capture(params) {
+        return this._http.fetchPost('/api/loop/traces', params);
+    }
+    // ── traces ────────────────────────────────────────────────────────────
+    /** List captured conversations, newest first. */
+    async listTraces(params = {}) {
+        const q = new URLSearchParams();
+        if (params.deployment_id)
+            q.set('deployment_id', params.deployment_id);
+        if (params.conversation_id)
+            q.set('conversation_id', params.conversation_id);
+        if (params.from)
+            q.set('from', params.from);
+        if (params.to)
+            q.set('to', params.to);
+        if (params.signalled)
+            q.set('signalled', 'true');
+        if (params.limit != null)
+            q.set('limit', String(params.limit));
+        if (params.offset != null)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        return this._http.fetchGet(`/api/loop/traces${qs ? `?${qs}` : ''}`);
+    }
+    /** Read one conversation, with every verdict recorded on it. */
+    async getTrace(id) {
+        const res = await this._http.fetchGet(`/api/loop/traces/${encodeURIComponent(id)}`);
+        return res.trace;
+    }
+    /**
+     * Delete a conversation.
+     *
+     * It also leaves every training set built from it, including sets already
+     * exported -- so a customer asking you to delete a conversation genuinely
+     * removes it from what the model will learn next. Training runs that have
+     * already finished are not affected.
+     */
+    async deleteTrace(id) {
+        return this._http.fetchDelete(`/api/loop/traces/${encodeURIComponent(id)}`);
+    }
+    // ── feedback ──────────────────────────────────────────────────────────
+    /**
+     * Record a verdict on a conversation.
+     *
+     * Append-only: posting a second verdict does not replace the first. Two
+     * reviewers disagreeing about an answer is information worth keeping.
+     *
+     * `source` says who judged: `human`, `verifier` (a deterministic check --
+     * tests passed, schema valid), `judge` (a model grading a model), or
+     * `behavioural` (what the user did next). When several disagree, a human
+     * outranks a verifier, a verifier outranks a judge, and a judge outranks a
+     * behavioural hint.
+     */
+    async signal(traceId, params) {
+        const res = await this._http.fetchPost(`/api/loop/traces/${encodeURIComponent(traceId)}/signals`, params);
+        return res.signal;
+    }
+    /** Every verdict on one conversation, oldest first. */
+    async listSignals(traceId) {
+        const res = await this._http.fetchGet(`/api/loop/traces/${encodeURIComponent(traceId)}/signals`);
+        return res.signals;
+    }
+    // ── alternative answers ───────────────────────────────────────────────
+    /**
+     * Submit an alternative answer to a prompt already captured.
+     *
+     * This is what makes preference learning scale. A human rewrite is the best
+     * signal there is and the least available -- somebody has to sit down and
+     * write it. Sample the model several times for the same prompt, score the
+     * samples, and a DPO pair falls out automatically: best becomes chosen,
+     * worst becomes rejected. Point a stronger model at the prompt instead and
+     * the same machinery does distillation.
+     *
+     * Score them, or they cannot pair: an unscored alternative says nothing about
+     * which answer anybody prefers. `score_source` is required alongside a score,
+     * because precedence between a verifier, a judge and a person is the whole
+     * reason we record who judged.
+     *
+     * A human correction always outranks any score.
+     *
+     * @example
+     * ```ts
+     * for (const sample of await sampleMyModel(prompt, 4)) {
+     *   await client.loop.addCandidate(traceId, {
+     *     completion: sample.text,
+     *     score: await myVerifier(sample.text),
+     *     score_source: 'verifier',
+     *   });
+     * }
+     * ```
+     */
+    async addCandidate(traceId, params) {
+        const res = await this._http.fetchPost(`/api/loop/traces/${encodeURIComponent(traceId)}/candidates`, params);
+        return res.candidate;
+    }
+    /** Every alternative answer recorded for one prompt, oldest first. */
+    async listCandidates(traceId) {
+        const res = await this._http.fetchGet(`/api/loop/traces/${encodeURIComponent(traceId)}/candidates`);
+        return res.candidates;
+    }
+    // ── training sets ─────────────────────────────────────────────────────
+    /**
+     * Build a training set from the feedback recorded so far.
+     *
+     * The three methods need genuinely different things, so one set cannot be
+     * reshaped into another afterwards:
+     *
+     * - `sft` -- answers you marked right, and answers you rewrote.
+     * - `dpo` -- answers you REWROTE, so a better and a worse version of the same
+     *   reply exist. Nothing else produces a pair.
+     * - `grpo` -- answers with a value or fact they can be checked against.
+     *
+     * `holdout_percent` holds back your most recent work rather than a random
+     * slice, so the evaluation measures whether the model generalised instead of
+     * memorised the same week.
+     *
+     * The result always reports `rejected_counts`: why rows were left out. A
+     * small set with a reason is useful; a small set without one is just alarming.
+     */
+    async createDataset(params) {
+        const res = await this._http.fetchPost('/api/loop/datasets', params);
+        return res.dataset;
+    }
+    /** List training sets, newest first. */
+    async listDatasets(params = {}) {
+        const q = new URLSearchParams();
+        if (params.method)
+            q.set('method', params.method);
+        if (params.limit != null)
+            q.set('limit', String(params.limit));
+        if (params.offset != null)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        const res = await this._http.fetchGet(`/api/loop/datasets${qs ? `?${qs}` : ''}`);
+        return res.datasets;
+    }
+    /** Read one training set and its curation report. */
+    async getDataset(id) {
+        const res = await this._http.fetchGet(`/api/loop/datasets/${encodeURIComponent(id)}`);
+        return res.dataset;
+    }
+    /**
+     * Page through the rows a training set actually contains.
+     *
+     * Worth reading before you spend money on a run: each row carries the address
+     * of the conversation it was built from.
+     */
+    async listDatasetItems(id, params = {}) {
+        const q = new URLSearchParams();
+        if (params.limit != null)
+            q.set('limit', String(params.limit));
+        if (params.offset != null)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        const res = await this._http.fetchGet(`/api/loop/datasets/${encodeURIComponent(id)}/items${qs ? `?${qs}` : ''}`);
+        return res.items;
+    }
+    /**
+     * Download a training set as JSONL -- one training row per line, the format
+     * every trainer in this space reads.
+     *
+     * `split` defaults to the training rows; pass `holdout` for the slice held
+     * back, or `all` for both.
+     */
+    async downloadDataset(id, split) {
+        const qs = split ? `?split=${split}` : '';
+        return this._http.fetchGet(`/api/loop/datasets/${encodeURIComponent(id)}/download${qs}`);
+    }
+    /**
+     * Delete a training set.
+     *
+     * The conversations it was built from are untouched -- a set is a selection,
+     * and discarding the selection must not discard the evidence.
+     */
+    async deleteDataset(id) {
+        return this._http.fetchDelete(`/api/loop/datasets/${encodeURIComponent(id)}`);
+    }
+    // ── capture settings ──────────────────────────────────────────────────
+    /** Every source this workspace has configured. */
+    async listConfigs() {
+        const res = await this._http.fetchGet('/api/loop/configs');
+        return res.configs;
+    }
+    /**
+     * Read the capture setting for one source. A source nobody has configured
+     * reads back as disabled rather than missing, because "we are not recording
+     * this" is the honest answer.
+     */
+    async getConfig(source) {
+        const res = await this._http.fetchGet(`/api/loop/configs/${encodeURIComponent(source)}`);
+        return res.config;
+    }
+    /**
+     * Turn capture on or off for a source, and choose how long it is kept.
+     *
+     * This is the consent decision the whole feature rests on: nothing is
+     * recorded until it is made, and the row remembers who made it and when.
+     * `sample_rate` below 1 records a deterministic fraction, chosen so that every
+     * turn of one conversation is captured or skipped together -- half a
+     * conversation makes training rows with holes in them.
+     */
+    async setConfig(source, params) {
+        const res = await this._http.fetchPut(`/api/loop/configs/${encodeURIComponent(source)}`, params);
+        return res.config;
+    }
+    /**
+     * How much there is, and how much of it each method could actually use.
+     *
+     * The `ready` numbers are upper bounds: duplicate questions are folded into
+     * one row while a set is built, so the finished count can be lower.
+     */
+    async stats() {
+        const res = await this._http.fetchGet('/api/loop/stats');
+        return res.stats;
+    }
+}

package/dist/types.d.ts

@@ -1819,7 +1819,7 @@ export interface ApiKey {
  * on purpose: a scope added to the catalog must not make an existing SDK build
  * reject a key it just read back from the API.
  */
-export type ApiKeyScope = 'models:read' | 'datasets:read' | 'datasets:write' | 'training:read' | 'training:write' | 'billing:read' | 'deployments:read' | 'deployments:write' | 'analytics:read' | 'integrations:read' | 'integrations:write' | 'skills:read' | 'skills:write' | 'serverless' | (string & {});
+export type ApiKeyScope = 'models:read' | 'datasets:read' | 'datasets:write' | 'training:read' | 'training:write' | 'billing:read' | 'deployments:read' | 'deployments:write' | 'analytics:read' | 'integrations:read' | 'integrations:write' | 'skills:read' | 'skills:write' | 'loop:read' | 'loop:write' | 'serverless' | (string & {});
 /** Result of introspecting an API key — shows what it can do. */
 export interface ApiKeyIntrospection {
     auth_type: 'api_key' | 'jwt';
@@ -1955,3 +1955,215 @@ export interface ChatCompletionUsage {
     total_tokens: number;
     prompt_tokens_details?: PromptTokensDetails;
 }
+/** What a training set is shaped for. The three need different things. */
+export type LoopMethod = 'sft' | 'dpo' | 'grpo';
+/** Who judged an answer. */
+export type LoopSource = 'human' | 'verifier' | 'judge' | 'behavioural';
+/** The judgement itself. */
+export type LoopVerdict = 'accepted' | 'rejected' | 'edited' | 'scored';
+/** A function an assistant turn asked to invoke. `arguments` is JSON-encoded. */
+export interface LoopToolCall {
+    id?: string;
+    type?: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** One conversational turn, in the chat-completions shape. */
+export interface LoopMessage {
+    role: string;
+    content?: string;
+    tool_calls?: LoopToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+export interface LoopCaptureParams {
+    /** The source being recorded. Must be enabled first, or nothing is stored. */
+    deployment_id: string;
+    model: string;
+    messages: LoopMessage[];
+    completion?: string;
+    /** What the answering turn invoked, if anything. */
+    tool_calls?: LoopToolCall[];
+    /** The tool schema the model was offered. Without it, tool training invents names. */
+    tools?: unknown;
+    model_version?: string;
+    /** Ties multi-turn work together. */
+    conversation_id?: string;
+    /** Your own idempotency handle. Replaying it returns the same trace. */
+    request_id?: string;
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    latency_ms?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface LoopCaptureResult {
+    captured: boolean;
+    /** Present when captured. Ours, never the id you sent. */
+    trace_id?: string;
+    /** Set when something was removed before the record was written. */
+    redacted?: boolean;
+    download_url?: string;
+    /** Why nothing was stored, e.g. `capture_disabled`, `not_sampled`. */
+    reason?: string;
+}
+export interface LoopSignal {
+    id: string;
+    trace_id: string;
+    source: LoopSource;
+    verdict: LoopVerdict;
+    correction: string | null;
+    score: number | null;
+    ground_truth: string | null;
+    reason: string | null;
+    author: string | null;
+    created_at: string;
+}
+export interface LoopSignalParams {
+    verdict: LoopVerdict;
+    source?: LoopSource;
+    /** Required when verdict is `edited`. The answer the model should have given. */
+    correction?: string;
+    /** Required when verdict is `scored`. */
+    score?: number;
+    /** A value or fact the answer can be checked against. GRPO needs one. */
+    ground_truth?: string;
+    reason?: string;
+    author?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface LoopTrace {
+    id: string;
+    workspace_id: string;
+    deployment_id: string | null;
+    model: string;
+    model_version: string | null;
+    messages: LoopMessage[];
+    completion: string;
+    tool_calls?: LoopToolCall[];
+    tools?: unknown;
+    conversation_id: string | null;
+    request_id: string | null;
+    prompt_tokens: number | null;
+    completion_tokens: number | null;
+    latency_ms: number | null;
+    redacted_at: string | null;
+    /** What the redaction pass removed, counted by rule. */
+    redaction_report?: Record<string, number>;
+    created_at: string;
+    expires_at: string;
+    signals?: LoopSignal[];
+}
+export interface LoopTraceListParams {
+    deployment_id?: string;
+    conversation_id?: string;
+    from?: string;
+    to?: string;
+    /** Only conversations that already carry a verdict. */
+    signalled?: boolean;
+    limit?: number;
+    offset?: number;
+}
+export interface LoopTraceListResponse {
+    traces: LoopTrace[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export interface LoopDatasetCreateParams {
+    name: string;
+    method: LoopMethod;
+    deployment_id?: string;
+    from?: string;
+    to?: string;
+    /** Holds back your most recent work, not a random slice. 0-50. */
+    holdout_percent?: number;
+    max_items?: number;
+}
+export interface LoopDataset {
+    id: string;
+    workspace_id: string;
+    name: string;
+    method: LoopMethod;
+    status: string;
+    spec: Record<string, unknown>;
+    item_count: number;
+    considered_count: number;
+    /** Why rows were left out, by reason. */
+    rejected_counts: Record<string, number>;
+    holdout_count: number;
+    holdout_cutoff: string | null;
+    created_by: string | null;
+    created_at: string;
+    completed_at: string | null;
+    download_url: string;
+}
+export interface LoopDatasetListParams {
+    method?: LoopMethod;
+    limit?: number;
+    offset?: number;
+}
+export interface LoopDatasetItem {
+    id: number;
+    trace_id: string;
+    split: 'train' | 'holdout';
+    payload: Record<string, unknown>;
+    dedup_key: string;
+    created_at: string;
+    /** The conversation this row was built from. */
+    trace_url: string;
+}
+export interface LoopConfig {
+    deployment_id: string;
+    workspace_id: string;
+    enabled: boolean;
+    retention_days: number;
+    sample_rate: number;
+    enabled_by: string | null;
+    enabled_at: string | null;
+    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;
+}
+export interface LoopStats {
+    traces: number;
+    signalled_traces: number;
+    signals: number;
+    by_verdict: Record<string, number>;
+    by_source: Record<string, number>;
+    datasets: number;
+    /** Upper bounds: deduplication runs when a set is built. */
+    ready: Record<LoopMethod, number>;
+}
+export interface LoopCandidateParams {
+    completion?: string;
+    /** An alternative that is itself a tool call. */
+    tool_calls?: LoopToolCall[];
+    /** Which model produced this alternative. The teacher, when distilling. */
+    model?: string;
+    model_version?: string;
+    /** Unscored alternatives cannot pair -- a missing score is not a low one. */
+    score?: number;
+    /** Required alongside a score: human | verifier | judge | behavioural. */
+    score_source?: LoopSource;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface LoopCandidate {
+    id: string;
+    trace_id: string;
+    model: string | null;
+    model_version: string | null;
+    completion: string;
+    tool_calls?: LoopToolCall[];
+    score: number | null;
+    score_source: LoopSource | null;
+    reason: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+}

package/package.json

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