runbios-sdk 0.4.0-rc.337 → 0.5.0-dev.338

package/dist/types.d.ts

@@ -8,13 +8,13 @@ export interface BiOSConfig {
     orgId?: string;
     /** Workspace ID. Optional when using API keys (resolved from the key). Can override for multi-workspace keys. */
     workspaceId?: string;
-    /** Base URL for the API. Falls back to the RUNBIOS_BASE_URL environment variable (legacy: BIOS_BASE_URL), then the canonical https://api-staging.runbios.ai hostname. */
+    /** Base URL for the API. Falls back to the RUNBIOS_BASE_URL environment variable (legacy: BIOS_BASE_URL), then the canonical https://api-dev.runbios.ai hostname. */
     baseUrl?: string;
     /** Request timeout in milliseconds. Defaults to 30000. */
     timeout?: number;
     /** Default per-deployment inference key. Can be overridden per inference call. */
     inferenceKey?: string;
-    /** Inference base URL. Defaults to baseUrl, then https://api-staging.runbios.ai. */
+    /** Inference base URL. Defaults to baseUrl, then https://api-dev.runbios.ai. */
     inferenceBaseUrl?: string;
     /** End-to-end inference timeout in milliseconds. Defaults to 15 minutes. */
     inferenceTimeout?: number;
@@ -3094,6 +3094,14 @@ export interface LoopMetricPoint {
     benchmark_spent_cents: number;
     /** Scoring the samples nobody reviewed, in the passes the attempt took when it was booked. */
     sample_scoring_cents?: number;
+    /**
+     * The run priced as its attempt row prices it (`cost_cents` on
+     * {@link PipelineAttempt}), so the points add up to the pipeline's
+     * `totals.spent_cents`; `cost_up_to` true means it is the most it can have
+     * cost: say "at most". Absent from a service from before they were sent.
+     */
+    cost_cents?: number;
+    cost_up_to?: boolean;
     evaluation_id: string | null;
     rows_scored: number | null;
     rows_failed: number | null;
@@ -3223,8 +3231,9 @@ export type TrainingRulePausedReason = 'consent_invalid' | 'insufficient_funds'
 /**
  * Why a run fired, as the run stores it: `rows` (enough new samples),
  * `cadence` (the schedule), `both`, `manual` (train now), `challenger` (the
- * pipeline's challenger model, trained from its own base on every sample the
- * attempt before it could train on), `rebuild` (a member deleted a
+ * pipeline's second model on the same samples as the attempt before it: built
+ * on its own latest version, or from its original model on every sample while
+ * it has none), `rebuild` (a member deleted a
  * conversation the live version learned from, so the model is trained again
  * from the base on every remaining sample), or `variant` (a recipe variant,
  * retired: the same base model on the same conversations with one training
@@ -3237,15 +3246,19 @@ export type TrainingTrigger = 'rows' | 'cadence' | 'both' | 'manual' | 'variant'
  * side of an attempt comparison.
  *
  * `trained_from` is `versions` when the attempt trained a new adapter on top
- * of the live version: the pipeline's pinned base with the versions in
- * `built_on` (oldest first) merged into it in that order. It is `base` when
- * it started from the base model, and `from_base_reason` says why:
- * `first_version`, `challenger` (the second model never builds on another
- * model's versions), `rebuild` (a deleted conversation, with `rebuild` true;
- * or, with `rebuild` false, a live version already built on 64 versions, the
- * most one attempt can build on), `model_cannot_build_on` or
- * `chain_link_unreadable` (an earlier version could not be read). Null when
- * it built on versions.
+ * of its model's own latest version -- the live one, or, while the other
+ * model's version is live, its own -- the pipeline's pinned base with the
+ * versions in `built_on` (oldest first) merged into it in that order. Each
+ * model keeps its own line: neither builds on the other's versions. It is
+ * `base` when it started from its original model, and `from_base_reason` says
+ * why: `first_version`, `challenger` (the second model has no version of its
+ * own yet), `rebuild` (a deleted conversation, with `rebuild` true; or, with
+ * `rebuild` false, its own latest version already built on 64 versions, the
+ * most one attempt can build on, so its line starts again),
+ * `model_cannot_build_on`, `chain_link_unreadable` (an earlier version could
+ * not be read) or `line_learned_deleted` (a version of its own line learned a
+ * sample a member deleted, so its line starts again without it). Null when it
+ * built on versions.
  *
  * What it trained on (`train_rows`) is `new_samples` (new since the attempt
  * before it) + `carried_samples` (trained by the attempts in
@@ -3278,7 +3291,7 @@ export interface Lineage {
     learned_before: number | null;
     rebuild: boolean;
     learned_deleted_conversation: boolean;
-    from_base_reason: 'first_version' | 'challenger' | 'rebuild' | 'model_cannot_build_on' | 'chain_link_unreadable' | null;
+    from_base_reason: 'first_version' | 'challenger' | 'rebuild' | 'model_cannot_build_on' | 'chain_link_unreadable' | 'line_learned_deleted' | null;
 }
 /**
  * The four training settings a recipe variant may change, as the run was
@@ -3380,6 +3393,16 @@ export interface TrainingRunRejectRequest {
 export interface TrainingRunRollbackRequest {
     reason?: string;
 }
+/**
+ * The machine codes `retestTrainingRun` can be refused with, beside the ones
+ * Train now answers (`PIPELINE_NEEDS_SAVE`, `RULE_PAUSED`, `RUN_ACTIVE`,
+ * `MONTHLY_LIMIT_REACHED`, `AGENT_OFF`, `SCORING_CAPPED`).
+ *
+ * - `CANNOT_TEST_AGAIN` (409): the training cannot be tested again; the
+ *   message says why (already tested, went live, never finished training,
+ *   still under way, the amount set aside for testing it spent, ...).
+ */
+export type TrainingRunRetestRefusalCode = 'CANNOT_TEST_AGAIN' | 'PIPELINE_NEEDS_SAVE' | 'RULE_PAUSED' | 'RUN_ACTIVE' | 'MONTHLY_LIMIT_REACHED' | 'AGENT_OFF' | 'SCORING_CAPPED';
 /**
  * The machine codes `rollbackTrainingRun` can be refused with.
  *
@@ -3436,6 +3459,11 @@ export interface TrainingRun {
     seq: number;
     rule_revision: number;
     trigger: TrainingTrigger;
+    /**
+     * Which of the pipeline's models it trained: `main`, or `second` for the
+     * second model (trigger `challenger`). Absent from an older service.
+     */
+    model_role?: PipelineModelRole;
     /**
      * For a recipe variant, what it changed, in plain words ("half the learning
      * rate"). Null for every run that trained on the ordinary recipe.
@@ -3465,6 +3493,12 @@ export interface TrainingRun {
      * training started; nothing was charged and the next attempt asks again).
      * `STEP_STALLED:TRAINING_SERVICE_BEHIND` is the same for one that waited
      * six hours for that update; the pipeline tries again on its own.
+     * `STEP_STALLED:SERVING_NOT_CERTIFIED`: the platform had not yet checked
+     * that it can test new versions of its model on the current serving engine,
+     * so it waited six hours before its training and stood down; nothing was
+     * charged, the pipeline is not paused, and its next training waits the same
+     * way until that check is done. `CHECKPOINT_NOT_DEPLOYABLE:SERVING_NOT_CERTIFIED`
+     * is the same found at its comparison, after it trained.
      * `ENV_GATED:SWITCHED_OFF`: the Conscious Loop was switched off on the
      * platform before its training started, so it stopped there; no GPU time
      * was charged, and the pipeline trains again on its own once the loop is
@@ -3498,11 +3532,11 @@ export interface TrainingRun {
      */
     billed_candidate_up_to: boolean;
     /**
-     * What was taken off for comparison machines that never started (never
-     * reached running): the platform charged nothing for them, so neither does
-     * the attempt -- say "Comparison machine: not charged (it never started)",
-     * or, while a comparison machine that ran is still charged beside it, that
-     * the one that never started was not charged. 0 when none; the cost figures
+     * What was taken off for test machines that never started (never reached
+     * running): the platform charged nothing for them, so neither does the
+     * training -- say "Test machine: not charged (it never started)", or, while
+     * a test machine that ran is still charged beside it, that the one that
+     * never started was not charged. 0 when none; the cost figures
      * beside it are already net of it.
      */
     comparison_returned_cents: number;
@@ -3554,6 +3588,13 @@ export interface TrainingRun {
      * before it was sent.
      */
     trained_on?: TrainedOn | null;
+    /**
+     * Whether its comparison measured anything: at least one question of its
+     * automatic test scored, or a benchmark that stood in for it published a
+     * score. A training never tested can never go live (`NOT_TESTED`) and,
+     * while its trained model is kept, can be tested again.
+     */
+    tested: boolean;
     candidate_deployment_id: string | null;
     candidate_name: string | null;
     candidate_seq: number;
@@ -3682,10 +3723,16 @@ export interface TrainingRunLinks {
 }
 /** What this reader may do right now. A button that cannot work is never shown. */
 export interface TrainingRunActions {
+    /** Never for a training that was never tested: that answers NOT_TESTED. */
     promote: boolean;
     reject: boolean;
     rollback: boolean;
     cancel: boolean;
+    /**
+     * Test again ({@link LoopResource.retestTrainingRun}): a training that
+     * trained and was never tested, whose trained model is kept.
+     */
+    retest: boolean;
 }
 export interface EvaluationRef {
     kind: ServingKind;
@@ -4290,6 +4337,85 @@ export interface BenchmarkHistoryParams {
 export interface BenchmarkRetireParams {
     reason?: string;
 }
+/** What `listBenchmarkQuestions` asks for. */
+export interface BenchmarkQuestionsParams {
+    /** The pipeline whose trainings to show (its id, `rule_id`). Required: training numbers are per pipeline. */
+    pipeline: string;
+    /** How many of its newest trainings: 5 when absent, 1 to 20. */
+    trainings?: number;
+    /** Questions per page: 50 when absent; at most 200. */
+    limit?: number;
+    offset?: number;
+}
+/** One training whose results a benchmark's questions carry. */
+export interface BenchmarkQuestionsTraining {
+    /** The training (`getTrainingRun(run_id)`). */
+    run_id: string;
+    /** Its number in its pipeline. */
+    attempt: number | null;
+    /** The version it became; null when it did not become one. */
+    version: number | null;
+    /** Its replay of this benchmark (`getBenchmarkRun`). */
+    benchmark_run_id: string;
+    /** That replay's status: anything but `done` scored only some questions. */
+    status: BenchmarkRunStatus;
+}
+/** One training's result on one question; `passed` and `score` are null when it did not score it. */
+export interface BenchmarkQuestionResult {
+    attempt: number | null;
+    /** A score of 0.70 or more. */
+    passed: boolean | null;
+    score: number | null;
+}
+/** One pinned question, with every listed training's result on it, in the order of `trainings`. */
+export interface BenchmarkQuestion {
+    item_id: number;
+    ordinal: number;
+    /** The last thing the user said in the pinned conversation (`listBenchmarkItems` has all of it). */
+    question: string;
+    /** The right answer's text, null when nobody gave one (or it is tool calls only: see `reference`). */
+    right_answer: string | null;
+    reference: EvaluationReference | null;
+    results: BenchmarkQuestionResult[];
+}
+/** Every question of a benchmark with how one pipeline's newest trainings did on each, oldest training first. */
+export interface BenchmarkQuestionsResponse {
+    benchmark_id: string;
+    pipeline_id: string;
+    trainings: BenchmarkQuestionsTraining[];
+    items: BenchmarkQuestion[];
+    /** How many questions the benchmark has. */
+    total: number;
+    limit: number;
+    offset: number;
+}
+/** One step of a training's chart. */
+export interface TrainingCurvePoint {
+    step: number;
+    /** Its loss on the samples it trained on; null at a practice check the thinned series did not keep. */
+    train_loss: number | null;
+    /** Its loss on the practice questions it set aside and did not train on; null at a step it did not check. */
+    check_loss: number | null;
+}
+/**
+ * How a training went while it trained (`getTrainingCurve`): at most 200
+ * points, every practice check among them, and the step whose model it kept.
+ * No points and a plain `reason` when there is nothing to chart (no training
+ * job yet, or it never checked itself on practice questions).
+ */
+export interface TrainingCurve {
+    run_id: string;
+    points: TrainingCurvePoint[];
+    /** The step whose model it kept; null until it kept one. */
+    kept_step: number | null;
+    /** The steps it trained (so far, while it trains). */
+    trained_steps: number | null;
+    /** The steps it planned. */
+    planned_steps: number | null;
+    /** It keeps its last step, not the one that did best on the practice questions (a Gemma 4 training). */
+    keeps_last: boolean;
+    reason: string | null;
+}
 /**
  * The machine codes `runPipeline` (train now) can be refused with: every one
  * the run route answers (the SDK's tests read them off the service). Each is
@@ -4390,8 +4516,11 @@ export type TrainingRuleRunRefusalCode = 'NOT_ENOUGH_SAMPLES' | 'PIPELINE_NEEDS_
  *   that meets it at fire time is paused `training_not_enabled` instead (see
  *   {@link TrainingRulePausedReason}); switching it back on later starts it
  *   again.
- * - `METHOD_NOT_ENABLED` (422): the platform has switched off the training
- *   method pipelines train with.
+ * - `METHOD_NOT_ENABLED` (422): the body asks for preference or reward
+ *   training -- a `training_method`, `rlhf_type`, `method` or `algorithm`
+ *   naming rlhf, dpo, kto, grpo or the like, at the top or under `training` --
+ *   which is not available yet (the message says so in one sentence), or the
+ *   platform has switched off the training method pipelines train with.
  * - `CEILING_TOO_LOW` (422): the platform's own runaway limits cannot cover
  *   the machines it chose for the model. Nothing in the request sets them.
  * - `MODELS_UNAVAILABLE`, `GPU_OPTIONS_UNAVAILABLE`, `AGENT_COULD_NOT_START`
@@ -4494,7 +4623,10 @@ export interface PipelineActiveRun {
 /**
  * One version: an attempt that was put live -- promoted by the pipeline's
  * rule or by a member. Only winners are versions, numbered v1, v2, ... in the
- * order they went live; numbers only go up and a rollback renumbers nothing.
+ * order they went live; version numbers count up and a rollback renumbers
+ * nothing (a later version can still score lower: a member may approve one).
+ * Nothing untested goes live any more; `tested` says whether an older version
+ * was tested.
  */
 export interface PipelineVersion {
     version: number;
@@ -4518,6 +4650,12 @@ export interface PipelineVersion {
     holdout_rows: number | null;
     /** What it was trained on top of, and on which samples. See {@link Lineage}. */
     lineage: Lineage;
+    /**
+     * Whether its comparison measured anything. Every version put live since
+     * nothing untested goes live was; a rebuild put live untested before that
+     * says false.
+     */
+    tested: boolean;
     /** Head-to-head against the champion of its day, on conversations neither trained on. */
     rows_scored: number | null;
     win_rate: number | null;
@@ -4595,12 +4733,42 @@ export interface PipelineVersion {
  */
 /**
  * Why an attempt was made: new data (`data`, a recipe variant included), the
- * schedule (`schedule`), a member's train-now (`manual`), the challenger
- * model trained from its own base on all samples (`challenger`), or a rebuild
- * from the base after a member deleted a conversation the live version
- * learned from (`rebuild`).
+ * schedule (`schedule`), a member's train-now (`manual`), the second model on
+ * the same samples (`challenger`: it builds on its own latest version, or
+ * trains from its original model on all samples while it has none), or a
+ * rebuild from the base after a member deleted a conversation the live
+ * version learned from (`rebuild`).
  */
 export type PipelineAttemptTrigger = 'data' | 'schedule' | 'manual' | 'challenger' | 'rebuild';
+/**
+ * Which of a pipeline's models an attempt trained. Each model keeps its own
+ * line of versions: each builds on its own latest version, never the other's,
+ * and each training that wins becomes the next version, in turn.
+ */
+export type PipelineModelRole = 'main' | 'second';
+/** Where a pipeline's second model stands (`second_model` on a pipeline). */
+export type PipelineSecondModelState = 'waiting' | 'training' | 'tested' | 'skipped' | 'held' | 'none';
+/**
+ * Where a pipeline's second model stands: `training` (a training of it is
+ * under way), `tested` (its training on the main model's newest samples was
+ * tested), `skipped` (it did not train on them, and will not -- reason says
+ * why), `held` (it is owed a training and a money limit, a scoring key, a
+ * live version that cannot answer or a paused pipeline holds it), `waiting`
+ * (it trains next, or after the main model's next training), `none` (the
+ * pipeline trains neither model now). A skipped set is never a training.
+ */
+export interface PipelineSecondModel {
+    model_id: string;
+    state: PipelineSecondModelState;
+    /** The training the state is about; null when it waits for the main model's next training. */
+    for_training: number | null;
+    /** Its newest training that ended, in either role. */
+    last_training: number | null;
+    /** Its own latest version, which it builds on next; null when it trains from its original. */
+    own_latest_version: number | null;
+    /** The state in one plain sentence. */
+    reason: string | null;
+}
 /**
  * What became of an attempt. `inconclusive` is a held-back test that ran and
  * could not decide; `not_tested` is an attempt that ended before it was tested
@@ -4613,6 +4781,13 @@ export interface PipelineAttempt {
     run_id: string;
     state: TrainingRunState;
     trigger: PipelineAttemptTrigger;
+    /**
+     * Which of the pipeline's models it trained: `main`, or `second` for its
+     * second model (trigger `challenger`) -- the role it had when it trained,
+     * and the words of `model=` on `listPipelineAttempts`. Absent from an older
+     * service.
+     */
+    model_role?: PipelineModelRole;
     base_model_id: string | null;
     model_family: string | null;
     outcome: PipelineAttemptOutcome;
@@ -4673,9 +4848,46 @@ export interface PipelineAttempt {
      * {@link TrainedOn}. Null when its set is gone.
      */
     trained_on?: TrainedOn | null;
+    /** The version it was built on; null when it trained from the original model. */
+    builds_on_version?: number | null;
+    /**
+     * What its automatic test asked as the opponent, recorded when the test
+     * opened: `compared_with` is `version` (then `compared_with_version` is
+     * the version), `original` (the original model, while no version was live)
+     * or null (not tested, or nothing recorded which). These four are absent
+     * from a service from before they were sent.
+     */
+    compared_with_version?: number | null;
+    compared_with?: PipelineComparedWith | null;
+    /**
+     * For `not_better` and `inconclusive`, the first bar its automatic test
+     * missed; null otherwise, and when the bars do not explain the verdict.
+     */
+    missed_bar?: AttemptMissedBar | null;
+    /**
+     * Whether its comparison measured anything. A training never tested can
+     * never go live (`NOT_TESTED`) and, while its trained model is kept, can be
+     * tested again ({@link LoopResource.retestTrainingRun}).
+     */
+    tested: boolean;
+}
+/** What a training's automatic test asked as its opponent. */
+export type PipelineComparedWith = 'version' | 'original';
+/**
+ * The first bar a training's automatic test missed: `key` is the bar
+ * (`rows_scored`, `failures`, `rubric`, `mean_change`, `win_rate` or
+ * `beyond_chance`, as {@link VerdictCheck.key}), `what` says it and what the
+ * training got in plain words, and `needed` and `got` are on the bar's own
+ * scale (null where it has none).
+ */
+export interface AttemptMissedBar {
+    key: string;
+    what: string;
+    needed: number | null;
+    got: number | null;
 }
 /**
- * An attempt's outcome in plain words: `headline` ("Could not be tested"),
+ * An attempt's outcome in plain words: `headline` ("Couldn't be tested"),
  * `detail` (what happened and why) and `next` (what happens now; null when
  * there is nothing to say).
  */
@@ -4955,11 +5167,14 @@ export interface Pipeline {
      */
     capture: LoopCaptureHealth | null;
     /**
-     * A second base model, trained from its own base on all samples after each
-     * attempt (it never builds on this pipeline's versions, which are another
-     * model); it becomes the next version only if it beats the live one, and then it
+     * A second model, a different one from the main model, trained on the same
+     * samples after each training of the main model: each model keeps its own
+     * line of versions, so it builds on its own latest version (never the main
+     * model's), or from its original model on all samples while it has none.
+     * Whichever does better becomes the next version; a winning second model
      * becomes the pipeline's model (`base_model_id`) while the model it replaced
-     * becomes this one. `revision` is the commit the server pinned.
+     * becomes this one. `revision` is the commit the server pinned. Where it
+     * stands is `second_model`.
      */
     challenger_model: PipelineModelRef | null;
     train_when: PipelineTrainWhen;
@@ -4989,6 +5204,13 @@ export interface Pipeline {
     live_deployment: PipelineLiveDeployment | null;
     /** The live version as the versions merged into it. See {@link PipelineChain}. */
     chain: PipelineChain | null;
+    /**
+     * Where the second model stands, and its own latest version. Null when the
+     * pipeline names no second model -- and on the list only, also when where
+     * it stands could not be read just then (`challenger_model` still names
+     * it; the detail answers it or fails); absent from an older service.
+     */
+    second_model?: PipelineSecondModel | null;
     /** What the pipeline's history takes up in storage. */
     storage: LoopStorage;
     /** The name the app calls. It does not change when a version is promoted. */
@@ -5026,6 +5248,12 @@ export interface Pipeline {
     versions_total: number;
     /** How many attempts it has made; `attempts` holds only the latest of them. */
     attempts_total: number;
+    /**
+     * Every training it made, what became of them and what they cost in all,
+     * on `listPipelines` and `getPipeline` alike. See {@link PipelineTotals}.
+     * Absent from a service from before it was sent.
+     */
+    totals?: PipelineTotals;
     /** Winners only, v1 first: every one from `getPipeline`, the latest few and the live one on `listPipelines`. */
     versions: PipelineVersion[];
     /**
@@ -5035,6 +5263,83 @@ export interface Pipeline {
      */
     attempts: PipelineAttempt[];
 }
+/**
+ * A pipeline's trainings, all of them. `spent_cents` is every attempt's
+ * `cost_cents` added up (one price for both, so paging through every attempt
+ * gives exactly `spent_cents - scoring_not_yet_in_a_training_cents`) plus the
+ * scoring of unreviewed samples no training has taken yet, and `spent_parts`
+ * adds up to it. Say it by both flags together: neither -> "$X";
+ * `spent_up_to` only -> "at most $X" (at least one part is an upper bound);
+ * `spent_so_far` only -> "$X so far" (the figure can still grow); both ->
+ * "at most $X so far". Training and testing only: the live version's serving
+ * is billed on its deployment.
+ */
+export interface PipelineTotals {
+    /** Every numbered attempt, running ones included (= `attempts_total`). */
+    trainings: number;
+    trainings_finished: number;
+    /**
+     * Trainings that trained a model and are no longer running, whose
+     * automatic test graded nothing and that no benchmark scored.
+     */
+    trainings_untested: number;
+    /** By outcome, each training once (`running` excludes `waiting_for_review`). */
+    trainings_by_result: PipelineTrainingsByResult;
+    trainings_by_model: PipelineTrainingsByModel;
+    /** How many became versions (= `versions_total`). */
+    versions: number;
+    spent_cents: number;
+    /**
+     * True when at least one part of `spent_cents` is an upper bound (an
+     * attempt's `cost_up_to`): say "at most", with "so far" too when
+     * `spent_so_far` is also true ("at most $X so far").
+     */
+    spent_up_to: boolean;
+    /**
+     * True while `spent_cents` can still change: a training is running or
+     * waiting for a member, billing has not yet settled a finished one's
+     * training time, or a scoring pass is still running. Say "so far" -- "$X
+     * so far", or "at most $X so far" when `spent_up_to` is also true. Never
+     * "at most" for this flag alone: the figure is still growing.
+     */
+    spent_so_far: boolean;
+    /**
+     * What scoring the samples nobody reviewed cost that no training has taken
+     * yet (the next training takes it when it starts). It is in `spent_cents`
+     * and in `spent_parts.sample_scoring_cents`; no attempt row carries it.
+     */
+    scoring_not_yet_in_a_training_cents: number;
+    spent_parts: PipelineSpentParts;
+    /** Every training's GPU time added up; 0 when none was recorded. */
+    gpu_seconds: number;
+    /** When the first and the latest training were made; null before the first. */
+    first_training_at: string | null;
+    last_training_at: string | null;
+}
+/** {@link PipelineTotals.trainings} by outcome. */
+export interface PipelineTrainingsByResult {
+    became_version: number;
+    not_better: number;
+    inconclusive: number;
+    not_tested: number;
+    stopped: number;
+    failed: number;
+    running: number;
+    waiting_for_review: number;
+}
+/** {@link PipelineTotals.trainings} by the model they trained. */
+export interface PipelineTrainingsByModel {
+    main: number;
+    second: number;
+}
+/** {@link PipelineTotals.spent_cents} part by part; the parts add up to it. */
+export interface PipelineSpentParts {
+    training_cents: number;
+    test_machine_cents: number;
+    grading_cents: number;
+    benchmark_cents: number;
+    sample_scoring_cents: number;
+}
 export interface TrainingRuleDeleteResponse {
     deleted: boolean;
     rule_id: string;
@@ -5100,6 +5405,19 @@ export interface TrainingRunResponse {
      * before it was sent.
      */
     explanation?: AttemptExplanation | null;
+    /**
+     * The attempt row's {@link PipelineAttempt.model_role},
+     * `builds_on_version`, `compared_with_version`, `compared_with` and
+     * `missed_bar`: which model it trained, what it built on, what its
+     * automatic test asked and the first bar a training that was not better
+     * missed. `model_role` is "" for a run that is not a numbered attempt.
+     * Absent from a service from before they were sent.
+     */
+    model_role?: PipelineModelRole | '';
+    builds_on_version?: number | null;
+    compared_with_version?: number | null;
+    compared_with?: PipelineComparedWith | null;
+    missed_bar?: AttemptMissedBar | null;
     /**
      * True when this service lists an attempt's own samples
      * (`listTraces({ attempt, split })`). Absent from a service that cannot.
@@ -5167,8 +5485,8 @@ export interface TrainingRunCost {
     total_cents: number;
     up_to: boolean;
     /**
-     * What was taken off `comparison_cents` for comparison machines that never
-     * started: "Comparison machine: not charged (it never started)" (with
+     * What was taken off `comparison_cents` for test machines that never
+     * started: "Test machine: not charged (it never started)" (with
      * `comparison_cents` above 0, only the one that never started). 0 when
      * none.
      */
@@ -5387,7 +5705,8 @@ export interface PipelineFloors {
  * The held-back rule: a pipeline holds back max(`min_rows`, its percent of its
  * samples), and chooses the percent from `default_percent` to `max_percent`
  * (the body's `holdout.percent`). Each attempt is judged on at most
- * `scored_rows` of them (the same ones every time); a share that holds back
+ * `scored_rows` of them (the ones held back longest first, so later trainings
+ * are mostly asked the same questions); a share that holds back
  * more than that only keeps samples out of training.
  */
 export interface HeldBackFloors {
@@ -5519,6 +5838,12 @@ export interface PromotionOutcome {
     decided_by: string;
     reason: string;
     auto_promote_allowed: boolean;
+    /**
+     * Why a better version waits for a member instead of going live by itself:
+     * a benchmark with no score for it, or one it got significantly worse on,
+     * named. Absent otherwise.
+     */
+    held_for_review?: string;
     weighted_delta: number | null;
     measurements: PromotionMeasurement[];
 }
@@ -5530,6 +5855,30 @@ export interface VersionHoldout {
     /** The share each side passed (score 0.70 or more). */
     incumbent_pass_rate: number | null;
     candidate_pass_rate: number | null;
+    /**
+     * The share of the response's `common_set` this version got right (score
+     * 0.70 or more), over `common_rows`, the questions of that set its own test
+     * graded against the same right answer: one fixed set for every version,
+     * so these may be drawn as one line across versions. `common_rows` can
+     * differ between versions: a question a test could not grade, or a sample
+     * deleted or past its retention before a later version's test, is not in
+     * that version's count -- "every version answered the same N questions"
+     * holds only when every version's `common_rows` is N. Null when its test
+     * graded none of them, and absent from a service from before they were sent.
+     */
+    common_pass_rate?: number | null;
+    common_rows?: number | null;
+}
+/**
+ * The fixed questions every version's `holdout.common_pass_rate` is measured
+ * on: the samples held back before the first version that was tested (`from`,
+ * "samples held back before v1"), each once, at most 1,500, read from the
+ * answers already stored -- kept after the samples themselves are deleted or
+ * expire. `rows` 0 and `from` null while no version was tested.
+ */
+export interface VersionCommonSet {
+    rows: number;
+    from: string | null;
 }
 /** One version with every measurement it has. */
 export interface VersionScores {
@@ -5543,7 +5892,38 @@ export interface VersionScores {
     verdict: string | null;
     decision: string | null;
     compared_at: string | null;
+    /**
+     * Whether its comparison measured anything, as on {@link PipelineVersion.tested}:
+     * nothing untested goes live any more; a rebuild put live untested before
+     * that says false.
+     */
+    tested: boolean;
     holdout: VersionHoldout;
+    /**
+     * When it first went live; whether it answers the pipeline's name now;
+     * whether it was rolled back. This field and the eleven after it are absent
+     * from a service from before they were sent.
+     */
+    promoted_at?: string;
+    is_live?: boolean;
+    rolled_back?: boolean;
+    /** The model it was trained from, and which of the pipeline's models that was. */
+    model_id?: string | null;
+    model_role?: PipelineModelRole;
+    /** Its training's cost, "at most" flag and GPU time, as its attempt row says them. */
+    cost_cents?: number;
+    cost_up_to?: boolean;
+    gpu_seconds?: number | null;
+    /**
+     * What its training trained on, and the samples it learned that no version
+     * it builds on had (new plus carried from trainings that did not become a
+     * version; null on a training from before those were counted).
+     */
+    train_rows?: number | null;
+    learned_new?: number | null;
+    /** What its automatic test asked as the opponent, as on {@link PipelineAttempt}. */
+    compared_with_version?: number | null;
+    compared_with?: PipelineComparedWith | null;
     /** One entry per entry of the response's `benchmarks`, in the same order. */
     benchmarks: VersionBenchmarkScore[];
     promotion: PromotionOutcome | null;
@@ -5566,6 +5946,8 @@ export interface VersionCompareResponse {
     a: number | null;
     b: number | null;
     differences: VersionScoreDifference[];
+    /** The fixed questions `holdout.common_pass_rate` is measured on; absent from a service from before it was sent. */
+    common_set?: VersionCommonSet;
 }
 /** Which two versions to set side by side, by VERSION number (v1 is 1). */
 export interface VersionCompareParams {
@@ -5796,9 +6178,85 @@ export interface LoopDataset {
     in_benchmarks: number;
     /** The pipelines that train on it. */
     used_by: LoopDatasetPipelineRef[];
+    /** Who saved it; null for a dataset saved before that was recorded. */
+    created_by: LoopDatasetCreator | null;
+    /**
+     * The trainings that learned from it, newest first, at most 50: every
+     * numbered training whose own set took this dataset and that kept a model,
+     * or is still training. One that ended without learning anything (stopped
+     * before it trained) is not listed. Read from each training's set, not from
+     * today's settings.
+     */
+    learned_by: LoopDatasetLearnedBy[];
+    /** How many trainings learned from it in all (`learned_by` lists at most 50). */
+    learned_by_total: number;
     created_at: string;
     updated_at: string;
 }
+/** The member who saved a dataset. */
+export interface LoopDatasetCreator {
+    id: string;
+    /** Their name (or email) as the platform has it; null when it could not be looked up just now. */
+    name: string | null;
+}
+/** One training that learned from a dataset. */
+export interface LoopDatasetLearnedBy {
+    pipeline_id: string;
+    pipeline_name: string;
+    /** The training (`getTrainingRun(run_id)`). */
+    run_id: string;
+    /** Its number in its pipeline. */
+    attempt: number;
+    /** The version it became; null when it did not become one. */
+    version: number | null;
+}
+/** What `exportDataset` asks for. */
+export interface LoopDatasetExportParams {
+    /** `jsonl`, the default and the only format. */
+    format?: 'jsonl';
+    /** At most this many samples, oldest first; every one when absent. */
+    limit?: number;
+}
+/**
+ * One line of an exported dataset: one sample in the import's chat format,
+ * so the file imports again (`importRows`) with its feedback. A sample with
+ * an answer is `messages`, the answer last; one nobody answered is its
+ * question, `prompt`. The feedback a person gave is in the import's words:
+ * Good is `label: true`, Wrong `label: false`, Wrong + right answer
+ * `correction`; a right answer given as the gold answer, or written on a
+ * question nobody answered, is `ground_truth`. No feedback writes none of
+ * them.
+ */
+export interface LoopDatasetExportLine {
+    /** The sample's id; the import does not read it. */
+    sample_id: string;
+    /** The conversation, the model's answer last; absent for a question nobody answered. */
+    messages?: LoopMessage[];
+    /** A question nobody answered: the conversation so far, with `ground_truth` when a person gave its right answer. */
+    prompt?: LoopMessage[];
+    /** The tools the conversation offered, as recorded. */
+    tools?: unknown;
+    /** The model that answered. */
+    model?: string;
+    label?: boolean;
+    correction?: string;
+    ground_truth?: string;
+}
+/**
+ * An exported dataset. `jsonl` is the file exactly as sent (one line a
+ * sample, nothing else); `lines` is each line parsed. A sample whose text
+ * could not be read (kept in the workspace's own storage and refused just
+ * now, or gone) is left out: `stored_elsewhere` is how many of the dataset's
+ * samples have no conversation kept with them on the platform -- kept in your
+ * own storage, or none at all -- which is the most that can be left out (0:
+ * none can be). The exact count left out is the response's `X-Loop-Skipped`
+ * HTTP trailer, which `fetch` does not expose.
+ */
+export interface LoopDatasetExport {
+    jsonl: string;
+    lines: LoopDatasetExportLine[];
+    stored_elsewhere: number | null;
+}
 /**
  * The body of `updateDataset`: every field optional. Unknown keys are refused
  * 400 naming them. An absent key is left as it is, null clears `origin`,
@@ -5862,6 +6320,8 @@ export interface LoopDatasetPreview {
     models: LoopDatasetPreviewModel[];
 }
 export interface LoopDatasetListParams {
+    /** Only the datasets whose name contains this, whatever its case (at most 80 characters). */
+    q?: string;
     /** 50 when absent; at most 200. */
     limit?: number;
     offset?: number;