runbios-sdk 0.2.22 → 0.3.0-dev.323

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.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.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;
@@ -565,6 +565,11 @@ export interface GPUChoice {
  * adapter merged into one model: a checkpoint of format `merged`, which is
  * what deploys (the job's own adapters are not deployable alone).
  *
+ * `exportStep` says which of this job's steps that merged model is made of:
+ * `'best'` (the default) is the step the validation loss picked, `'final'`
+ * the last step trained. It needs `exportMerged: true`; without it the SDK
+ * refuses before sending, as the API does (400 on `start_from.export_step`).
+ *
  * Refusals, all before anything is charged: 404 for an unknown, deleted or
  * other-workspace checkpoint; 422 START_FROM_BASE_MISMATCH,
  * START_FROM_CHAIN_BROKEN or START_FROM_LINK_UNREADABLE naming the `index`;
@@ -579,14 +584,22 @@ export interface TrainingStartFromParams {
         checkpointId: string;
     }[];
     exportMerged?: boolean;
+    exportStep?: TrainingExportStep;
 }
-/** `start_from` as the API echoes it on create, preflight and the job, with the digest of the chain's exact bytes. */
+/** Which step of a `start_from` job its merged model is made of: the step validation picked, or the last one trained. */
+export type TrainingExportStep = 'best' | 'final';
+/**
+ * `start_from` as the API echoes it on create, preflight and the job, with the
+ * digest of the chain's exact bytes. `export_step` is echoed only when the
+ * request named it; absent, the merged model is of the `'best'` step.
+ */
 export interface TrainingStartFrom {
     adapters: {
         job_id: string;
         checkpoint_id: string;
     }[];
     export_merged: boolean;
+    export_step?: TrainingExportStep;
     chain_digest?: string;
 }
 /** Parameters for creating a training job. */
@@ -1727,6 +1740,14 @@ export interface InferenceDeploymentSummary {
      * unreachable or slow (a money read never blocks the list).
      */
     charged_cents?: number | null;
+    /**
+     * A Conscious Loop comparison machine that no model name points at: the
+     * loop's own machine for comparing an attempt, listed and billed like any
+     * other, but never a model to offer. Leave it out of a model picker; the
+     * pipeline's own name (`loop-<tag>`) is the one to call. Absent from a
+     * service from before it was sent.
+     */
+    loop_comparison?: boolean;
     /** History view (`include_terminated`) only: how the lifecycle closed, and when. */
     disposition?: string;
     deleted_at?: string | null;
@@ -2403,7 +2424,11 @@ export interface ChatCompletionUsage {
     total_tokens: number;
     prompt_tokens_details?: PromptTokensDetails;
 }
-/** Who gave a verdict. Feedback you send is `human` unless you say otherwise. */
+/**
+ * Who gave a verdict a sample carries. Feedback you send is always `human`:
+ * `verifier`, `judge` and `behavioural` are written by the platform's own
+ * scoring, and the feedback route refuses them (400).
+ */
 export type LoopSource = 'human' | 'verifier' | 'judge' | 'behavioural';
 /**
  * The judgement recorded on an answer.
@@ -2414,8 +2439,18 @@ export type LoopSource = 'human' | 'verifier' | 'judge' | 'behavioural';
  * trained on in place of the model's.
  * `gold` records the reference answer for the question, making no claim about
  * whether the model was right; it is trained on the same way.
+ * `scored` is a score the platform's own scoring wrote; it is read, never sent.
  */
 export type LoopVerdict = 'accepted' | 'rejected' | 'edited' | 'scored' | 'gold';
+/** The verdicts feedback can send: a person's good, bad, correction or reference answer. */
+export type LoopFeedbackVerdict = 'accepted' | 'rejected' | 'edited' | 'gold';
+/**
+ * The plain words for the three common verdicts: `good` is `accepted`, `bad`
+ * is `rejected` and `corrected` is `edited` (with its `correction`). A capture's
+ * `feedback` takes them, and so does `signal`; the stored verdict, and the one
+ * a signal answers with, is the `LoopVerdict` word.
+ */
+export type LoopFeedbackWord = 'good' | 'bad' | 'corrected';
 /** A function an assistant turn asked to invoke. `arguments` is JSON-encoded. */
 export interface LoopToolCall {
     id?: string;
@@ -2463,6 +2498,19 @@ export interface LoopCaptureParams {
      * one conversation reaches another pipeline too. At most 32 in all.
      */
     labels?: string[];
+    /**
+     * The feedback you already have for this exchange, written with it, so no
+     * second call is needed. Refused (400) before anything is stored when it is
+     * unusable. Send `request_id` too: a retry under it records the feedback
+     * once.
+     */
+    feedback?: LoopCaptureFeedback;
+}
+/** Feedback sent with a capture: good, bad, or corrected with the right answer. */
+export interface LoopCaptureFeedback {
+    verdict: LoopFeedbackWord;
+    /** Required with `corrected`, and read only then: the answer that should have been given. */
+    correction?: string;
 }
 export interface LoopCaptureResult {
     captured: boolean;
@@ -2641,13 +2689,23 @@ export interface LoopSignal {
     metadata: Record<string, unknown> | null;
     created_at: string;
 }
+/** One feedback item for `loop.signalMany`: the sample's id and its feedback. */
+export interface LoopSignalManyItem extends LoopSignalParams {
+    trace_id: string;
+}
+/** What became of one `signalMany` item: its signal, or the error it ended with. */
+export interface LoopSignalManyResult {
+    trace_id: string;
+    signal?: LoopSignal;
+    error?: unknown;
+}
 export interface LoopSignalParams {
-    verdict: LoopVerdict;
-    source?: LoopSource;
-    /** Required when verdict is `edited`. The answer the model should have given. */
+    /** A `LoopFeedbackVerdict`, or its plain word (`good`, `bad`, `corrected`: see `LoopFeedbackWord`). */
+    verdict: LoopFeedbackVerdict | LoopFeedbackWord;
+    /** Always `human` when sent: feedback is a person's. Other sources are refused 400. */
+    source?: 'human';
+    /** Required when verdict is `edited`, `corrected` or `gold`. The answer the model should have given. */
     correction?: string;
-    /** Required when verdict is `scored`: above zero trains the answer as it stands, otherwise it is left out. */
-    score?: number;
     /** A value or fact the answer can be checked against. Kept with the verdict; a pipeline trains on `correction`, not on this. */
     ground_truth?: string;
     reason?: string;
@@ -2771,12 +2829,23 @@ export interface LoopTraceListParams {
     signal?: 'good' | 'bad' | 'corrected';
     /** Only the conversations nobody has given feedback on yet. */
     unsignalled?: boolean;
+    /**
+     * Text search: 2 to 200 characters, case-insensitive, matched as written
+     * (`%` and `_` are plain characters) in every message, the answer and the
+     * answer's tool calls. Combines with every other filter.
+     */
+    q?: string;
 }
 export interface LoopTraceListResponse {
     traces: LoopTrace[];
     total: number;
     limit: number;
     offset: number;
+    /**
+     * Present only when `q` was sent: how many of the samples the other filters
+     * select keep their text in your own storage and so were not searched.
+     */
+    unsearched?: number;
 }
 export interface LoopConfig {
     deployment_id: string;
@@ -2817,6 +2886,32 @@ export interface LoopStats {
     ready: {
         sft: number;
     };
+    /**
+     * The calls sent with `X-Loop-Pipeline` in the last `days` days (UTC) that
+     * were not recorded under a tag, most first. Empty when every one was.
+     */
+    capture: LoopCaptureHealth;
+}
+/** `LoopStats.capture` and `Pipeline.capture`: what the one-header capture did not record. */
+export interface LoopCaptureHealth {
+    /** The window, in days, today included. */
+    days: number;
+    not_recorded: LoopCaptureMiss[];
+}
+/**
+ * Calls under ONE tag that were not recorded, and why. A call naming two tags
+ * is counted under each, so rows are not added up as calls.
+ */
+export interface LoopCaptureMiss {
+    tag: string;
+    /**
+     * `no_pipeline`: no pipeline has the tag (misspelt, never made, or deleted).
+     * `too_large`: the answer was larger than the platform keeps for a sample.
+     * `incomplete`: the answer was cut short, or had no text and no tool call.
+     */
+    reason: 'no_pipeline' | 'too_large' | 'incomplete';
+    calls: number;
+    last_at: string;
 }
 /** One pipeline a conversation falls inside (GET /api/loop/traces/{id}/pipelines). */
 export interface LoopTracePipeline {
@@ -2982,8 +3077,9 @@ export type TrainingTrigger = 'rows' | 'cadence' | 'both' | 'manual' | 'variant'
  * What it trained on (`train_rows`) is `new_samples` (new since the attempt
  * before it) + `carried_samples` (trained by the attempts in
  * `carried_from_attempts`, which did not go live) + `replayed_samples` (about
- * a fifth of what it trained on, drawn at random from what the versions it
- * builds on already learned, so it does not forget them). `learned_before` is
+ * half of what it trained on -- as many as it had not learned, or all the
+ * versions it builds on learned when that is fewer -- drawn at random from
+ * what they already learned, so it does not forget them). `learned_before` is
  * how many samples those versions had learned: they are not trained again,
  * except the replayed ones. An attempt from the base trains on every sample
  * it can: `new_samples` is all of them, and the other three counts are 0.
@@ -2994,8 +3090,9 @@ export type TrainingTrigger = 'rows' | 'cadence' | 'both' | 'manual' | 'variant'
  * `served_as` is `adapter` for an attempt from the base and `merged` for one
  * built on versions (one model with every version merged in). A winner is
  * merged in and served as one model. `learned_deleted_conversation` is true
- * when a conversation it trained on has since been deleted: a rebuild
- * without it is on its way, and it can no longer be rolled back to.
+ * when it -- or a version it was built on, whose model is merged into it --
+ * learned a conversation that has since been deleted: a rebuild without it is
+ * on its way, and it can no longer be rolled back to.
  */
 export interface Lineage {
     trained_from: 'base' | 'versions';
@@ -3022,6 +3119,12 @@ export interface TrainingRecipe {
     num_train_epochs: number | null;
     lora_rank: number | null;
     lora_alpha: number | null;
+    /**
+     * True when one of the pipeline's own training settings ({@link Pipeline.training})
+     * was applied over the automatic recipe for this run, frozen when it started;
+     * false when it trained on automatic settings throughout.
+     */
+    custom: boolean;
 }
 export type TrainingRunState = 'built' | 'registering' | 'dataset_validating' | 'preflighting' | 'job_creating' | 'training' | 'checkpoint_ready' | 'candidate_booking' | 'candidate_running' | 'evaluating' | 'reported' | 'awaiting_review' | 'promoting' | 'waiting_funds'
 /**
@@ -3249,6 +3352,15 @@ export interface TrainingRun {
     candidate_name: string | null;
     candidate_seq: number;
     candidate_status: string | null;
+    /**
+     * One boot window after the comparison machine was first seen on a GPU, set
+     * once per booking (a booking after a wait for GPUs sets its own). Not
+     * always the deadline the boot is held to: time the machine has no pod while
+     * it waits for another GPU is not counted (except while a base model's
+     * machine bills beside it), so the attempt can stay in candidate_booking
+     * past this time, by at most one more window. An attempt that ran out
+     * gives the deadline it was held to on its expiry event (deadline_at).
+     */
     candidate_deadline_at: string | null;
     candidate_cleanup_at: string | null;
     evaluation_id: string | null;
@@ -3916,6 +4028,8 @@ export interface BenchmarkItemListParams {
     offset?: number;
 }
 export interface BenchmarkHistoryParams {
+    /** Only the points of this pipeline's attempts (its id, `rule_id`). */
+    pipeline?: string;
     /** 50 when absent; at most 200. */
     limit?: number;
     offset?: number;
@@ -3944,10 +4058,10 @@ export interface BenchmarkRetireParams {
  *   after a deleted conversation (`chain.rebuild`) is not held by the limit:
  *   Train now starts it, and each one that goes live is a version, so the
  *   pipeline can end past its limit.
- * - `MONTHLY_LIMIT_REACHED` (409): the most this month's attempts can have
- *   cost plus the most one more may cost would pass the pipeline's internal
- *   monthly limit. The body carries the figures:
- *   see {@link TrainingRuleMonthlyLimitRefusal}.
+ * - `MONTHLY_LIMIT_REACHED` (409): the pipeline has reached its monthly
+ *   safety limit. The body carries `resumes_at`, and `error.message` says
+ *   what holds the pipeline and when the next attempt can start, with no
+ *   amount: see {@link TrainingRuleMonthlyLimitRefusal}.
  * - `SCORING_CAPPED` (409): the key the comparison runs under is at its
  *   monthly cap, so what this attempt trained could not be scored. The body
  *   carries `resumes_at`, when the cap lifts (the next UTC month, or sooner
@@ -4002,6 +4116,8 @@ export type TrainingRuleRunRefusalCode = 'NOT_ENOUGH_SAMPLES' | 'PIPELINE_NEEDS_
  *   pipeline's current one (ignoring case) is kept, and whether it can still
  *   be trained is checked when an attempt starts.
  * - `NO_GPU_FITS` (422): no machines can train or serve the model right now.
+ * - `TRAINING_SETTING_OUT_OF_RANGE` (422): a `training` setting is outside its
+ *   range; the message names the field and the range. Nothing was saved.
  * - `MODEL_REVISION_UNAVAILABLE` (422): the model could not be pinned to an
  *   exact revision because the training service did not answer. Try again
  *   once it does.
@@ -4028,37 +4144,25 @@ export type TrainingRuleRunRefusalCode = 'NOT_ENOUGH_SAMPLES' | 'PIPELINE_NEEDS_
  *   the key every comparison is scored with) did not answer just then. Try
  *   again in a minute.
  */
-export type TrainingRuleSaveRefusalCode = 'PIPELINE_NAME_TAKEN' | 'OWN_TAG_TAKEN' | 'REVISION_MISMATCH' | 'RUN_ACTIVE' | 'NOT_A_SIMPLE_PIPELINE' | 'MODEL_NOT_TRAINABLE' | 'NO_GPU_FITS' | 'MODEL_REVISION_UNAVAILABLE' | 'NO_JUDGE_MODEL' | 'PROMOTION_POLICY_UNKNOWN' | 'PROMOTION_K_REQUIRED' | 'PROMOTION_K_UNREACHABLE' | 'PROMOTION_POLICY_NEEDS_BENCHMARK' | 'TRAINING_NOT_ENABLED' | 'METHOD_NOT_ENABLED' | 'CEILING_TOO_LOW' | 'MODELS_UNAVAILABLE' | 'GPU_OPTIONS_UNAVAILABLE' | 'AGENT_COULD_NOT_START';
+export type TrainingRuleSaveRefusalCode = 'PIPELINE_NAME_TAKEN' | 'OWN_TAG_TAKEN' | 'REVISION_MISMATCH' | 'RUN_ACTIVE' | 'NOT_A_SIMPLE_PIPELINE' | 'MODEL_NOT_TRAINABLE' | 'NO_GPU_FITS' | 'TRAINING_SETTING_OUT_OF_RANGE' | 'MODEL_REVISION_UNAVAILABLE' | 'NO_JUDGE_MODEL' | 'PROMOTION_POLICY_UNKNOWN' | 'PROMOTION_K_REQUIRED' | 'PROMOTION_K_UNREACHABLE' | 'PROMOTION_POLICY_NEEDS_BENCHMARK' | 'TRAINING_NOT_ENABLED' | 'METHOD_NOT_ENABLED' | 'CEILING_TOO_LOW' | 'MODELS_UNAVAILABLE' | 'GPU_OPTIONS_UNAVAILABLE' | 'AGENT_COULD_NOT_START';
 /**
  * The body of a manual run refused `409 MONTHLY_LIMIT_REACHED`, as
- * `ApiError.body` carries it.
- *
- * The test is the worst case, not the average: a run may start only if the
- * most the rule's runs this UTC calendar month can have cost
- * (`month_spent_cents`), plus the most the run about to start may spend
- * (`run_max_cents`), fits under the limit.
+ * `ApiError.body` carries it: the pipeline's monthly safety limit holds it.
+ * The limit is the platform's guard, set from the model's prices; the member
+ * never sets it, so its figures are neither fields of the answer nor in
+ * `message`, which says what holds the pipeline and when the next attempt can
+ * start.
  */
 export interface TrainingRuleMonthlyLimitRefusal {
     error: {
         code: 'MONTHLY_LIMIT_REACHED';
         message: string;
     };
-    /** What this rule's runs have cost at most this UTC calendar month; see {@link Pipeline.month_spent_cents}. */
-    month_spent_cents: number;
-    /** The rule's monthly limit. */
-    monthly_ceiling_cents: number;
-    /**
-     * The most one attempt of this rule may spend: its training, its comparison
-     * machine and its judging. While no version is live that machine also
-     * answers as the base model, so a pipeline's own attempt counts one; a
-     * challenger's attempt also counts the base model's own machine beside it.
-     */
-    run_max_cents: number;
     /**
-     * The first instant of the next UTC month, when the counted spend starts
-     * again from nothing. When `run_max_cents` alone exceeds the limit, no month
-     * will ever fit: saving the pipeline sets the limit again from its model's
-     * prices, and nothing else changes it; `message` says which.
+     * The first instant of the next UTC month, when the month's count starts
+     * again from nothing. When one attempt alone can cost more than the whole
+     * limit, no month will ever fit: saving the pipeline sets the limit again
+     * from its model's prices, and nothing else changes it; `message` says which.
      */
     resumes_at: string;
 }
@@ -4136,10 +4240,8 @@ export interface PipelineVersion {
     verdict: TrainingVerdict | null;
     decision: TrainingDecision | null;
     decided_at: string | null;
-    /** True for the version the app is served by today (the same as `is_champion`). */
-    is_live: boolean;
     /** True for the version the app is served by today. */
-    is_champion: boolean;
+    is_live: boolean;
     /** When it was first put live. */
     promoted_at: string | null;
     checkpoint_id: string | null;
@@ -4261,6 +4363,69 @@ export interface PipelineAttempt {
     evaluation_id: string | null;
     /** Its last sentence. */
     reason: string | null;
+    /**
+     * What became of it in plain words, written by the service from its state,
+     * verdict and error. See {@link AttemptExplanation}.
+     */
+    explanation: AttemptExplanation | null;
+}
+/**
+ * An attempt's outcome in plain words: `headline` ("Could not be tested"),
+ * `detail` (what happened and why) and `next` (what happens now; null when
+ * there is nothing to say).
+ */
+export interface AttemptExplanation {
+    headline: string;
+    detail: string;
+    next: string | null;
+}
+/**
+ * A pipeline's own training settings, each null while it is automatic (the
+ * platform's value for its model, {@link PipelineTrainingDefaults}). A change
+ * applies from the next attempt, and every attempt keeps the settings it
+ * trained with on its `recipe` (`custom` true when one of these applied).
+ * LoRA only: there is no full fine-tune, so the rank and alpha always apply.
+ */
+export interface PipelineTrainingSettings {
+    /** Passes over the data, 1 to 15. */
+    epochs: number | null;
+    /** 1e-6 to 1e-2. */
+    learning_rate: number | null;
+    /** 4, 8, 16, 32 or 64. */
+    lora_rank: number | null;
+    /** 1 to 512. */
+    lora_alpha: number | null;
+    /**
+     * 0 to 50: the share of already-learned samples an attempt replays when it
+     * builds on the live version, so the new version does not forget them.
+     */
+    replay_percent: number | null;
+}
+/**
+ * What automatic means for this pipeline's model: what an attempt trains with
+ * where {@link PipelineTrainingSettings} says null. The automatic recipe picks
+ * its passes from `min_epochs` to `max_epochs` (at least 8 for Gemma 4).
+ */
+export interface PipelineTrainingDefaults {
+    learning_rate: number;
+    lora_rank: number;
+    lora_alpha: number;
+    replay_percent: number;
+    min_epochs: number;
+    max_epochs: number;
+}
+/**
+ * The training settings a create or edit sends. Every key is three-state:
+ * absent keeps the pipeline's, null puts it back to automatic, a number sets
+ * it. Out of range is refused 422 `TRAINING_SETTING_OUT_OF_RANGE` naming the
+ * field and its range.
+ */
+export interface PipelineTrainingRequest {
+    epochs?: number | null;
+    learning_rate?: number | null;
+    lora_rank?: number | null;
+    lora_alpha?: number | null;
+    replay_percent?: number | null;
 }
 /** A model and the exact commit of it. */
 export interface PipelineModelRef {
@@ -4374,7 +4539,8 @@ export interface PipelineChainRebuild {
  * pipeline trained is live on its current model, and when the pipeline does
  * not build on its live version (then every attempt trains from the base on
  * all samples). `learned_samples` is how many samples those versions learned
- * (the next attempt does not train them again, except a replayed fifth);
+ * (the next attempt does not train them again, except the replay, about
+ * half of what it trains on);
  * `not_learned_samples` is how many were trained by attempts that did not go
  * live, so the next attempt trains them again. Null on the list.
  */
@@ -4401,6 +4567,15 @@ export interface Pipeline {
     own_tag: string | null;
     /** A conversation carrying ANY of these tags is this pipeline's data. */
     tags: string[];
+    /**
+     * The calls sent with `X-Loop-Pipeline` in the last `days` days that were
+     * not recorded: under this pipeline's tags (an answer too large to keep, or
+     * cut short), and under any tag no pipeline had (`no_pipeline`: a misspelt
+     * tag, or a deleted pipeline's). One row per tag: a call naming two tags is
+     * counted under each, so rows are not added up as calls. Null on the list,
+     * and when it could not be read: only `pipelines.get` reads it.
+     */
+    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
@@ -4414,6 +4589,10 @@ export interface Pipeline {
     holdout: PipelineHoldout;
     /** Rows the next version holds back and never trains on. Detail only; null on the list. */
     holdout_size: number | null;
+    /** Its training settings, each null while automatic. See {@link PipelineTrainingSettings}. */
+    training: PipelineTrainingSettings;
+    /** What automatic means for its model. See {@link PipelineTrainingDefaults}. */
+    training_defaults: PipelineTrainingDefaults;
     minimums: PipelineMinimums;
     /**
      * The pinned base every version is trained over: from it, or, where the
@@ -4424,8 +4603,6 @@ export interface Pipeline {
     base_model_revision: string;
     /** The version serving now; null when what serves is not a version of this pipeline. */
     live_version: number | null;
-    /** The same number under its older name. */
-    champion_version: number | null;
     /**
      * Whether the deployment the live version answers from is up, as the
      * platform last checked it. Null when there is no live version, when what
@@ -4444,10 +4621,6 @@ export interface Pipeline {
      * does. Null when nothing has taken the name over.
      */
     serving_taken_over_by: string | null;
-    benchmark_id: string | null;
-    benchmark_name: string | null;
-    /** The least a benchmark's score has to rise by to count as an improvement under a policy that reads benchmarks. */
-    benchmark_min_delta: number;
     status: PipelineStatus;
     /**
      * The rule's own sentence about what it is waiting for or why it stopped,
@@ -4457,7 +4630,6 @@ export interface Pipeline {
     next_reason: string | null;
     last_checked_at: string | null;
     next_due_at: string | null;
-    auto_promote: boolean;
     /**
      * Why the platform stopped firing this rule, or null. `consent_invalid` is
      * a pipeline whose settings changed since it was last saved: saving it
@@ -4471,26 +4643,18 @@ export interface Pipeline {
      * trains on its own: an attempt would train and could not be compared.
      */
     scoring_capped_until: string | null;
-    /** The rule's monthly limit. Null means it has none. */
-    monthly_ceiling_cents: number | null;
-    /**
-     * What this rule's runs have cost at most, counted toward the monthly limit
-     * this UTC calendar month -- the figure the limit is enforced against. An
-     * upper bound, not an exact spend. A run counts toward the month it was
-     * created in, and a run still in progress also counts toward the current
-     * month, at the most it may cost (as `run_max_cents` counts it, a base
-     * model's machine included where the attempt has one of its own) or what it
-     * has been billed when that is more. A finished run counts what it was billed, and its comparison
-     * machines are billed at the most they could have cost (each machine's
-     * hourly cap for the time it was up, never more than its own amount). A run created in
-     * an earlier month that finishes in this one counts here only while it is
-     * still running.
-     */
-    month_spent_cents: number;
     active_run: PipelineActiveRun | null;
-    /** Winners only, v1 first. */
+    /** How many versions it has made: every one is in `versions` from `getPipeline`, only the latest few and the live one on `listPipelines`. */
+    versions_total: number;
+    /** How many attempts it has made; `attempts` holds only the latest of them. */
+    attempts_total: number;
+    /** Winners only, v1 first: every one from `getPipeline`, the latest few and the live one on `listPipelines`. */
     versions: PipelineVersion[];
-    /** Every attempt, attempt 1 first. */
+    /**
+     * Its latest attempts, in attempt order: 20 from `getPipeline`, 5 on each
+     * pipeline of `listPipelines`. `attempts_total` says how many there are,
+     * and `listPipelineAttempts` pages through every one.
+     */
     attempts: PipelineAttempt[];
 }
 export interface TrainingRuleDeleteResponse {
@@ -4647,12 +4811,23 @@ export interface BenchmarkHistoryResponse {
     points: BenchmarkHistoryPoint[];
     total: number;
 }
+/**
+ * The pipeline list's `status` filter: `training` (an attempt is running),
+ * `needs_you` (waiting on a member: a review or funds), `serving` (its live
+ * version answers) and `paused`.
+ */
+export type PipelineListStatus = 'training' | 'needs_you' | 'serving' | 'paused';
 export interface PipelineListParams {
+    /** 100 when absent; at most 100. */
+    limit?: number;
     /** How many of the newest pipelines to skip: the page after one that started at N starts at N + its length. */
     offset?: number;
+    /** A case-insensitive substring of the name, the tag or the model. */
+    q?: string;
+    status?: PipelineListStatus;
 }
 export interface PipelineListResponse {
-    /** The newest pipelines first, at most the service's page (100). */
+    /** The newest pipelines first, one page (100 unless `limit` says; at most 100). */
     pipelines: Pipeline[];
     /** Every pipeline in the workspace, including any not returned. */
     total: number;
@@ -4662,6 +4837,22 @@ export interface PipelineListResponse {
 export interface PipelineResponse {
     pipeline: Pipeline;
 }
+/** What became of an attempt, as `listPipelineAttempts` filters it. */
+export type PipelineAttemptResultFilter = 'became_version' | 'not_better' | 'inconclusive' | 'failed' | 'stopped' | 'running' | 'waiting_for_review';
+/** Which model's attempts: the pipeline's own (`main`) or its second model's (`second`). */
+export type PipelineAttemptModelFilter = 'main' | 'second';
+export interface PipelineAttemptListParams {
+    /** 50 when absent; at most 200. */
+    limit?: number;
+    offset?: number;
+    result?: PipelineAttemptResultFilter;
+    model?: PipelineAttemptModelFilter;
+}
+/** One page of a pipeline's attempts, newest first. `total` follows the filters. */
+export interface PipelineAttemptListResponse {
+    attempts: PipelineAttempt[];
+    total: number;
+}
 /**
  * The body of `POST /api/loop/pipelines` and (every field optional)
  * `PUT /api/loop/pipelines/{id}`. Everything else -- the machines, the money,
@@ -4718,6 +4909,12 @@ export interface PipelineWriteRequest {
     /** 1 to 100, or null for no limit (the default). Counts versions, not attempts. */
     max_versions?: number | null;
     enabled?: boolean;
+    /**
+     * The pipeline's training settings. Absent: unchanged on an edit (automatic
+     * on a create). null: every one back to automatic. An object: only the keys
+     * it carries change, each null for automatic. See {@link PipelineTrainingRequest}.
+     */
+    training?: PipelineTrainingRequest | null;
     /** An edit's compare-and-set. */
     expected_revision?: number;
 }
@@ -4770,8 +4967,25 @@ export interface HeldBackFloors {
     max_percent: number;
     scored_rows: number;
 }
+/** Why a model is not offered for a pipeline ({@link LoopUnavailableModel.reason_code}). */
+export type LoopUnavailableReasonCode = 'not_trainable_sft_lora' | 'not_servable_as_adapter' | 'too_large_for_available_gpus' | 'not_verified' | 'registry_missing';
+/**
+ * A model the platform knows that a pipeline cannot use, and why. `reason` is
+ * one plain sentence to show as it is; `reason_code` is one of
+ * {@link LoopUnavailableReasonCode}, typed as a string so a code added later
+ * still carries its sentence.
+ */
+export interface LoopUnavailableModel {
+    id: string;
+    name: string;
+    family: string | null;
+    reason_code: string;
+    reason: string;
+}
 export interface LoopModelsResponse {
     models: LoopModel[];
+    /** Every other model the platform knows, each with why it is not offered here. */
+    unavailable: LoopUnavailableModel[];
     floors: PipelineFloors;
 }
 /** The promotion rule as the API reads it back. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runbios-sdk",
-  "version": "0.2.22",
+  "version": "0.3.0-dev.323",
   "description": "Official TypeScript SDK for the Run BiOS training and deployment platform API",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,7 +16,8 @@
     "dist/**/*.d.ts",
     "!dist/**/*.map",
     "!dist/**/*.d.ts.map",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "build": "tsc",