runbios-sdk 0.2.1-rc.98 → 0.2.2-dev.171

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;
@@ -396,8 +396,9 @@ export interface DatasetPreview {
 }
 /** Parameters for importing a dataset from HuggingFace Hub. */
 export interface DatasetImportHFParams {
-    /** HuggingFace dataset repository ID (e.g. "databricks/dolly-15k"). */
+    /** HuggingFace dataset repository ID (e.g. "HuggingFaceH4/ultrachat_200k"). */
     repoId: string;
+    revision?: string;
     /** Display name for the imported dataset. */
     name?: string;
     /** Dataset subset/config to import. */
@@ -418,6 +419,7 @@ export interface DatasetImportHFParams {
 /** Parameters for registering a HuggingFace dataset without an integration. */
 export interface DatasetRegisterHFParams {
     repoId: string;
+    revision?: string;
     name?: string;
     workspaceId?: string;
     description?: string;
@@ -441,6 +443,7 @@ export interface DatasetHubSearchParams {
 export interface DatasetHubPreviewParams {
     /** HuggingFace dataset ID. */
     datasetId: string;
+    integrationId?: string;
     /** Split to preview. Defaults to "train". */
     split?: string;
     /** Subset/config name. */
@@ -545,6 +548,21 @@ export interface TrainingCreateParams {
      * large dataset without importing a trimmed copy.
      */
     datasetSampleLimits?: Record<string, number>;
+    /**
+     * Per-dataset sampling (key = a dataset ID from datasetIds): exactly one of
+     * `rows` or `percent` (of the dataset's usable rows for this method). Asking
+     * for more than the dataset holds uses every usable row and the run says
+     * so. Resolved to a row count identically by preflight and create, recorded
+     * in the mix manifest, and reproduced exactly on resume.
+     */
+    datasetSampling?: Record<string, DatasetSampling>;
+    /**
+     * How sampled rows are chosen: `first` (default) keeps the first N usable
+     * rows in file order -- what a curriculum wants; `random` draws a seeded
+     * uniform sample of the usable rows (kept in file order, seed = the mixing
+     * plan's seed, so a resume draws the same rows).
+     */
+    datasetSamplingStrategy?: 'first' | 'random';
     /** Training method. */
     method: TrainingMethod;
     /** Adapter type. */
@@ -565,8 +583,10 @@ export interface TrainingCreateParams {
     name?: string;
     /** Target workspace ID. */
     workspaceId?: string;
-    /** Number of training epochs. */
+    /** Number of training epochs. Governs the full run when maxSteps is omitted. */
     epochs?: number;
+    /** Optional hard step cap that overrides epochs. Omit for no cap and all configured epochs. */
+    maxSteps?: number;
     /** Training batch size per device. */
     batchSize?: number;
     /** Gradient accumulation steps. */
@@ -609,7 +629,7 @@ export interface TrainingCreateParams {
     integrationId?: string;
     /** Existing network volume to attach. */
     networkVolumeId?: string;
-    /** Cache the composed dataset for retry/resume. Defaults to true server-side. */
+    /** @deprecated No effect. Prepared data is transient; exact resume rebuilds it from pinned source metadata and verifies its checksum. */
     cacheDataset?: boolean;
     /** Legacy dataset ordering mode. Prefer mixing for weighted/phased plans. */
     datasetMixing?: 'shuffle' | 'sequential' | 'interleave' | 'random' | 'curriculum';
@@ -681,6 +701,13 @@ export interface TrainingJob {
     status: TrainingJobStatus;
     error_message?: string | null;
     error_code?: string | null;
+    /**
+     * Who ended a `stopped` run: `user` (Stop button, API, queue cancel) or
+     * `platform` (wallet exhausted, account block). Empty when the run is not
+     * stopped, or was stopped before this was recorded. A `failed` run is a
+     * different fact and never carries a stop origin.
+     */
+    stop_origin?: 'user' | 'platform' | '';
     current_step?: number;
     total_steps?: number;
     current_loss?: number | null;
@@ -754,12 +781,37 @@ export interface TrainingListResponse {
     limit: number;
     offset: number;
 }
+export interface TrainingDeviceMetrics {
+    memory_used_mib: number | null;
+    memory_total_mib: number | null;
+    utilization_pct: number | null;
+    temperature_c: number | null;
+}
+export interface TrainingResourceMetrics {
+    scope: 'worker';
+    sampled_at: string | null;
+    received_at: string;
+    gpu_count: number | null;
+    gpu_memory_used_mib: number | null;
+    gpu_memory_total_mib: number | null;
+    gpu_utilization_pct: number | null;
+    gpu_temperature_c: number | null;
+    host_ram_used_gib: number | null;
+    host_ram_limit_gib: number | null;
+    host_ram_pct: number | null;
+    host_cpu_usage_pct: number | null;
+    host_cpu_limit_cores: number | null;
+    disk_used_gib: number | null;
+    disk_total_gib: number | null;
+    gpus: TrainingDeviceMetrics[];
+}
 /** Training metrics for a job. */
 export interface TrainingMetrics {
     metrics: MetricPoint[];
     training_method?: string | null;
     rlhf_type?: string | null;
     graph_configs: MetricGraphConfig[];
+    resource_metrics?: TrainingResourceMetrics | null;
     /** @deprecated Use metrics. Populated as a compatibility alias. */
     steps?: MetricPoint[];
 }
@@ -877,6 +929,8 @@ export interface TrainingPreflightDataset {
 export interface TrainingPreflightWarning {
     code: string;
     message: string;
+    /** Request field the warning is about (e.g. `per_device_train_batch_size`), when there is one. */
+    field?: string;
 }
 /** Side-effect-free validation/sizing result; this endpoint never creates or bills a job. */
 export interface TrainingPreflightResponse {
@@ -897,6 +951,131 @@ export interface TrainingPreflightResponse {
     queue_eligible: boolean;
     warnings: TrainingPreflightWarning[];
     checked_at: string;
+    /**
+     * The trainer image's own sizing verdict for the requested GPU shape:
+     * recommended microbatch/accumulation/learning rate, predicted peak memory,
+     * minimum GPU count, wall-clock estimate, and whether the per-device batch
+     * you asked for is predicted to fit. Absent when no advisor is deployed.
+     */
+    advisor?: TrainingAdvisorVerdict;
+}
+/** Parameters for `training.recommend()` (GET /api/training/recommend). */
+export interface TrainingRecommendParams {
+    model: string;
+    modelRevision?: string;
+    integrationId?: string;
+    gpuType: string;
+    gpuCount?: number;
+    adapter?: 'full' | 'lora' | 'qlora';
+    method?: 'sft' | 'cpt' | 'pt';
+    maxLength?: number;
+    epochs?: number;
+    maxSteps?: number;
+    /** Your own microbatch, to be judged against the model. */
+    perDeviceTrainBatchSize?: number;
+    gradientAccumulationSteps?: number;
+    /** Datasets the job will train on; their measured token statistics feed the sizing. */
+    datasetIds?: string[];
+    workspaceId?: string;
+}
+/** Basis of one recommended value: measured on hardware, derived through a stated model, or an argued default. */
+export type TrainingAdvisorBasis = 'measured' | 'derived' | 'judgement';
+export interface TrainingAdvisorJustification {
+    field: string;
+    value: string;
+    reason: string;
+    basis: TrainingAdvisorBasis;
+}
+export interface TrainingAdvisorRecommendation {
+    per_device_train_batch_size: number;
+    gradient_accumulation_steps: number;
+    global_batch_size: number;
+    activation_checkpoint: string;
+    compile: boolean;
+    learning_rate: number;
+    warmup_steps: number;
+    parallelism: {
+        dp_replicate: number;
+        dp_shard: number;
+        tp: number;
+        pp: number;
+        cp: number;
+        ep: number;
+    };
+    /** Predicted peak reserved GPU memory per device, GiB. */
+    predicted_peak_gb: number;
+    /** (median, worst) percent the prediction ran over measurement on the calibration rows. */
+    memory_band_percent: [number, number];
+    memory_class: string;
+    predicted_mfu: number;
+    supervised_tokens_per_step: number;
+    predicted_roughness: number;
+    tokens_per_second: number;
+    throughput_basis: 'measured' | 'derived';
+    wall_clock: {
+        steps_per_epoch: number;
+        total_steps: number;
+        training_hours: number;
+        startup_minutes_estimate: number;
+        basis: TrainingAdvisorBasis;
+    } | null;
+}
+export interface TrainingAdvisorUserShape {
+    per_device_train_batch_size: number;
+    fits: boolean;
+    largest_fitting_batch?: number;
+    predicted_peak_gb?: number;
+    reason?: string;
+    /** Same global batch, a microbatch that fits. Present only when `fits` is false. */
+    suggested?: {
+        per_device_train_batch_size: number;
+        gradient_accumulation_steps: number;
+        reason: string;
+    };
+}
+/**
+ * Verdict of the training advisor. `available: false` means no advisor is
+ * deployed or it did not answer; nothing else is populated then.
+ */
+export interface TrainingAdvisorVerdict {
+    available: boolean;
+    reason?: string;
+    fits?: boolean;
+    /** Smallest GPU count of this type the job fits on; null when none up to the per-job cap. */
+    min_gpu_count?: number | null;
+    gpu?: {
+        platform_type: string;
+        sized_as: string;
+        capacity_gb: number;
+        capacity_measured: boolean;
+    };
+    model?: {
+        params_total_b: number;
+        params_active_b: number;
+        is_moe: boolean;
+        is_vlm: boolean;
+        has_linear_attention: boolean;
+    };
+    dataset_measured?: boolean;
+    seq_len?: number;
+    gpu_count?: number;
+    recommended?: TrainingAdvisorRecommendation;
+    user_shape?: TrainingAdvisorUserShape;
+    justifications?: TrainingAdvisorJustification[];
+    warnings?: string[];
+    dataset_stats_used?: {
+        num_rows: number;
+        avg_tokens_per_sample?: number;
+        avg_supervised_tokens_per_sample?: number;
+        has_images: boolean;
+        estimated: boolean;
+    };
+    measured_history?: {
+        tokens_per_second: number;
+        memory_anchors: number;
+    };
+    model_id?: string;
+    model_revision?: string;
 }
 /** One method, algorithm, or adapter reported by the pinned training engine. */
 export interface TrainingCapabilityChoice {
@@ -916,6 +1095,8 @@ export interface TrainingConfigFieldCapability {
     label: string;
     type: 'integer' | 'number' | 'boolean' | 'string' | 'string_array' | 'string_or_string_array' | 'object';
     default: unknown;
+    default_by_adapter?: Record<string, number>;
+    requires_step_horizon?: boolean;
     enabled: boolean;
     disabled_reason?: string;
     aliases?: string[];
@@ -1052,6 +1233,12 @@ export interface GPUPricingResponse {
     stale?: boolean;
     stale_message?: string;
 }
+/** One dataset's sampling request: exactly one of rows or percent. */
+export interface DatasetSampling {
+    rows?: number;
+    /** Percent (0-100) of the dataset's usable rows for the training method. */
+    percent?: number;
+}
 /** Parameters understood by the authenticated training GPU-options endpoint. */
 export interface GPUOptionsParams {
     modelId: string;
@@ -1067,6 +1254,17 @@ export interface GPUOptionsParams {
     rlhfType?: RLHFAlgorithm | string;
     modelParamsB?: number;
     modelActiveParamsB?: number;
+    /** Training sequence length the sizing should assume (tokens). */
+    maxLength?: number;
+    /**
+     * Effective batch (samples per optimizer step) -- the quality decision made
+     * before a GPU is chosen. Each option then answers with the per-device split
+     * that runs it there (`recommended_micro_batch` x `recommended_grad_accum`
+     * x `required_count`), and the minimum GPU count is sized at micro-batch 1.
+     */
+    effectiveBatch?: number;
+    /** Per-device batch to size as typed instead (ignored when effectiveBatch is set). */
+    perDeviceTrainBatchSize?: number;
 }
 /** One model-aware GPU option with live stock and total-price context. */
 export interface GPUOption {
@@ -1087,6 +1285,10 @@ export interface GPUOption {
     bookable: boolean;
     reason?: string;
     checked_at?: string;
+    /** Present when the request stated an effective batch: its split on this card at required_count. */
+    effective_batch?: number;
+    recommended_micro_batch?: number;
+    recommended_grad_accum?: number;
 }
 /** Actionable alternative returned when no GPU option is currently bookable. */
 export interface GPUOptionSuggestion {
@@ -1116,6 +1318,10 @@ export interface GPUOptionsResponse {
         storage_gb: number;
         price_per_hour_cents: number;
         total_price_per_hour_cents: number;
+        /** Present when the request stated an effective batch. */
+        effective_batch?: number;
+        per_device_train_batch_size?: number;
+        gradient_accumulation_steps?: number;
     };
     suggestions?: GPUOptionSuggestion[];
 }
@@ -1817,7 +2023,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';
@@ -1953,3 +2159,1771 @@ 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' | 'kto';
+/** Who judged an answer. */
+export type LoopSource = 'human' | 'verifier' | 'judge' | 'behavioural';
+/** The judgement itself. */
+/**
+ * The judgement recorded on an answer.
+ *
+ * `accepted` / `rejected` are the thumbs (see `upvote` / `downvote`).
+ * `edited` says the model was WRONG and carries the better answer.
+ * `gold` records the reference answer for the question, making no claim about
+ * whether the model was right — which is why it is separate from `edited`.
+ */
+export type LoopVerdict = 'accepted' | 'rejected' | 'edited' | 'scored' | 'gold';
+/** 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 LoopImportParams {
+    /**
+     * Where this came from. Required, and becomes the id every imported
+     * conversation is filed under, so the import stays sliceable later.
+     */
+    source: string;
+    /** The file, already parsed. At most 5000 rows per call. */
+    rows: Record<string, unknown>[];
+    /** Which model produced these, when the rows do not say per-row. */
+    model?: string;
+    /** Applied to every row: importing a dump is when somebody knows what it is. */
+    labels?: string[];
+    attributes?: Record<string, string>;
+    /**
+     * Repeat the `import_id` a previous call reported to make this call a RETRY
+     * of that one: rows that already arrived come back under `already_present`
+     * instead of being stored again.
+     *
+     * Leave it out and this call is its own import. The endpoint will NOT guess:
+     * two calls carrying the same rows are as likely to be two pages of one
+     * export as one call sent twice, and guessing "retry" silently drops the
+     * second copy of every conversation a file lists more than once. Every
+     * response carries the token it was filed under, so a retry is always
+     * available and never has to be inferred.
+     *
+     * SEND THE ROWS AS YOU SENT THEM. Without `row_ids` a row is matched on its
+     * text, and the match survives re-ordered keys and different whitespace but
+     * NOT a number that has been re-spelled: `100`, `1e2` and `100.0` are three
+     * different rows. A round trip through most JSON libraries re-spells numbers
+     * (Python turns `1e2` into `100.0`), so a retry built by re-serialising a
+     * parsed file can store rows a second time. Keep the bytes you sent, or send
+     * `row_ids` and stop depending on the text at all.
+     */
+    import_id?: string;
+    /**
+     * Where this page starts in the file, counting from 0. Send it when you split
+     * one import across several calls under one `import_id`, so two pages are not
+     * matched against each other row for row. Ignored when you send `row_ids`.
+     */
+    row_offset?: number;
+    /**
+     * Your own id for each row, in the same order as `rows`: a ticket number, a
+     * conversation id, whatever the export already carries.
+     *
+     * The strongest form of identity, and the one to reach for with a file big
+     * enough to page. It SUPERSEDES `import_id` and `row_offset`: with it,
+     * chunking, ordering and subsets all stop mattering and any part of the file
+     * can be re-sent exactly. One per row or none at all, and no two rows in a
+     * call may share an id: both are refused rather than silently merging two
+     * conversations into one.
+     *
+     * THE ID IS THE IDENTITY, AND THE ROW'S TEXT IS NOT PART OF IT. A row sent
+     * again under an id this source already imported comes back under
+     * `already_present` and the stored conversation is left as it was, even if
+     * you changed its text. A CORRECTION DOES NOT LAND THIS WAY: send it under a
+     * new id. That is the trade for making every retry, page and subset safe -
+     * the text is never compared, so nothing your serialiser does to it can turn
+     * a retry into a second import.
+     */
+    row_ids?: string[];
+}
+/**
+ * What an import did.
+ *
+ * A call where every row stored resolves with this. A call where SOME rows
+ * could not be stored rejects with {@link LoopImportIncompleteError}, whose
+ * `outcome` is this same shape: the counts are the whole answer either way, so
+ * read them from the error exactly as you would from a success.
+ */
+export interface LoopImportResult {
+    /**
+     * The token this call was filed under, whether you sent one or it was minted
+     * for you. Send the same rows again with this `import_id` to retry the call.
+     * Present on every response, success or failure, because a call can succeed
+     * and still need retrying when the answer never reached you.
+     */
+    import_id?: string;
+    /** How many conversations this call created. */
+    imported: number;
+    /**
+     * How many rows an earlier call under the SAME `import_id` (or carrying the
+     * same `row_ids`) had already imported, and so were not stored a second time.
+     * Zero on a first import, and zero on any call that repeated neither: a call
+     * that does not say it is a retry is its own import, which is what lets a
+     * file sent in pages land complete.
+     */
+    already_present?: number;
+    /**
+     * How many verdicts THIS CALL WROTE. Reported apart from `imported` because
+     * it is the difference between data you can train on and data somebody still
+     * has to look at.
+     *
+     * Re-sending a row whose verdict already landed writes nothing and counts
+     * nothing, so a plain retry reads 0. Re-sending one that came back in
+     * `verdicts_not_saved` DOES count here when the write succeeds this time,
+     * even though the row itself is counted under `already_present`: that is the
+     * first time anybody recorded that verdict, not a second reviewer. This is
+     * the field to read to confirm a repair landed.
+     */
+    reviewed: number;
+    needs_review: number;
+    /**
+     * How many rows could not be READ as a conversation. The file's shape is
+     * wrong, and changing the file is what fixes it.
+     */
+    refused: number;
+    /**
+     * How many rows were understood and then could not be stored. Counted apart
+     * from `refused`, because the two are different claims and rewriting a file
+     * that was already correct fixes nothing. A call with any of these rejects
+     * rather than resolving; read it off {@link LoopImportIncompleteError.outcome}.
+     */
+    not_saved?: number;
+    /**
+     * WHICH rows those were, counting from 1 in the order you sent them, so you
+     * can say what is missing rather than only how much.
+     *
+     * NOT A SMALLER FILE TO SEND BACK unless you sent `row_ids`. Without them a
+     * row is identified by its place in the call, so a shorter list moves every
+     * row after the gap and each one is stored again. Re-send the whole set of
+     * rows, in the same order, with the same `import_id`; what already arrived
+     * comes back under `already_present`. With `row_ids` a row carries its own
+     * identity and any subset is exact.
+     */
+    not_saved_rows?: number[];
+    /**
+     * Rows whose CONVERSATION stored and whose VERDICT did not, and which rows
+     * those were. A preference pair or a thumbs label is two writes, and the
+     * second can fail on its own: the conversation is then in the loop carrying
+     * nobody's judgement, counted under `needs_review` rather than `reviewed`,
+     * and not trainable. The call rejects with {@link LoopImportIncompleteError},
+     * and sending the rows again under the same `import_id` records the verdict
+     * without storing the conversation twice.
+     */
+    verdicts_not_saved?: number;
+    verdicts_not_saved_rows?: number[];
+    /**
+     * How many conversations of each shape THIS CALL created. Rows that were
+     * refused, rows that failed to store and rows an earlier import already had
+     * are not in here: the counts and the sentences in `notes` describe the same
+     * call, so neither can claim a conversation is waiting for review when none
+     * was written.
+     */
+    by_shape: Record<string, number>;
+    refused_why: Record<string, number>;
+    /**
+     * The conversations from this file that are now in the loop, in file order:
+     * the ones this call created and the ones it found already there. Without
+     * them a caller whose import half-failed has a number and no way to reach
+     * what landed: no way to label it, review it, or delete it and start again.
+     */
+    trace_ids?: string[];
+    notes: 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;
+    /** One bare tag. A tag with children matches them too. */
+    label?: string;
+    /**
+     * Named dimensions, ANDed together: `{ category: 'billing', language: 'es' }`.
+     * Exact within their key — `source=support` does not match `team=support`.
+     */
+    attributes?: Record<string, string>;
+    /** Only the conversations nobody has described yet. */
+    unlabelled?: boolean;
+    limit?: number;
+    offset?: number;
+    /** Only what ONE model answered — the filter distillation is made of. */
+    model?: string;
+    /** `captured` (our model's own behaviour) or `imported` (a file somebody brought). */
+    origin?: 'captured' | 'imported';
+}
+export interface LoopTraceListResponse {
+    traces: LoopTrace[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export interface LoopDatasetCreateParams {
+    name: string;
+    method: LoopMethod;
+    deployment_id?: string;
+    from?: string;
+    to?: string;
+    /** Narrow to one slice. A label with children selects them too. */
+    label?: string;
+    /**
+     * Take this many of what the filters matched. Which ones is arbitrary but
+     * REPEATABLE: the same conversations always give the same slice, so two
+     * builds of one spec describe the same set.
+     */
+    sample?: number;
+    /** Holds back your most recent work, not a random slice. 0-50. */
+    holdout_percent?: number;
+    max_items?: number;
+    /**
+     * Named dimensions, ANDed with each other and with `label`:
+     * `{ category: 'billing', language: 'es' }`. This is what turns one captured
+     * corpus into a different dataset for every task somebody trains for.
+     */
+    attributes?: Record<string, string>;
+    /** Only the conversations nobody has described yet. */
+    unlabelled?: boolean;
+    /** Only what ONE model answered — the filter distillation is made of. */
+    model?: string;
+    /** `captured` (our model's own behaviour) or `imported` (a file somebody brought). */
+    origin?: 'captured' | 'imported';
+}
+export interface LoopDataset {
+    id: string;
+    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;
+    auto_grade: boolean;
+}
+export interface LoopBuildRuleParams {
+    name: string;
+    method: string;
+    /**
+     * How many rows reviewed SINCE THE LAST BUILD must exist before this fires
+     * again. Minimum 10. Counting the whole corpus instead would fire the rule
+     * every interval forever, because a total that has crossed a threshold stays
+     * across it.
+     */
+    min_new_rows?: number;
+    enabled?: boolean;
+    /** The same selection `createDataset` takes, replayed verbatim. */
+    spec?: LoopDatasetCreateParams;
+}
+export interface LoopBuildRule {
+    id: string;
+    workspace_id: string;
+    name: string;
+    method: string;
+    spec: Record<string, unknown>;
+    min_new_rows: number;
+    enabled: boolean;
+    last_built_at: string | null;
+    last_dataset_id: string | null;
+    /**
+     * Why the rule did not fire last time it was checked. A rule quiet because
+     * it is waiting looks exactly like one quiet because it is broken; this is
+     * the difference.
+     */
+    last_reason: string | null;
+    last_checked_at: string | null;
+    created_by: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface LoopConfigParams {
+    enabled: boolean;
+    retention_days?: number;
+    /** Deterministic per conversation, so turns are never split. 0 < rate <= 1. */
+    sample_rate?: number;
+    /**
+     * Continuous rule-based scoring for this source. OMITTED MEANS UNCHANGED:
+     * a caller saving retention must not switch grading off for a workspace
+     * that turned it on.
+     */
+    auto_grade?: boolean;
+}
+/** One thing a judge scores, separately from the others. */
+export interface LoopJudgeDimension {
+    key: string;
+    description?: string;
+}
+/** Which slice of the corpus a judge is responsible for. */
+export interface LoopJudgeSelection {
+    label?: string;
+    deployment_id?: string;
+    from?: string;
+    to?: string;
+    sample?: number;
+    /** Skip conversations that already carry a judge verdict. */
+    only_unscored?: boolean;
+}
+export interface LoopJudge {
+    id: string;
+    workspace_id: string;
+    name: string;
+    instructions: string;
+    dimensions: LoopJudgeDimension[];
+    selection: LoopJudgeSelection;
+    model: string | null;
+    write_gold: boolean;
+    enabled: boolean;
+    /** The platform's agent runs this judge, on the workspace's own serverless account. */
+    auto: boolean;
+    /**
+     * Was automatic when the agent was turned off. Turning the agent back on
+     * restores exactly these judges.
+     */
+    auto_paused: boolean;
+    /**
+     * Why the last turn-on did NOT restore this judge. Null is the ordinary
+     * state. Set when the resume declined to make it automatic because the model
+     * it names is not one the serving gateway will route — handing it back would
+     * buy a run that fails every conversation. It stays paused, so pointing it at
+     * a model that routes and turning the agent on again brings it back.
+     */
+    auto_pause_reason: string | null;
+    created_by: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface LoopJudgeParams {
+    name: string;
+    instructions: string;
+    dimensions: LoopJudgeDimension[];
+    selection?: LoopJudgeSelection;
+    model?: string;
+    /**
+     * Let this judge write the answer that should have been given, not just a
+     * score. Off by default: a reference answer written by a model and then
+     * trained on is distillation, which is a decision you make deliberately.
+     */
+    write_gold?: boolean;
+    enabled?: boolean;
+    /**
+     * Hand the running of this judge to the platform's agent: new conversations
+     * in its slice are scored as they arrive, one model call each, on THIS
+     * WORKSPACE'S OWN serverless account (the agent spends through a managed key
+     * of yours, "Conscious Loop" in your key list). Requires `model`. Off, you
+     * run the model yourself with startRun / takeWork / postVerdicts.
+     */
+    auto?: boolean;
+}
+/** One pass of one rubric over one slice. */
+export interface LoopJudgeRun {
+    id: string;
+    judge_id: string;
+    judge_name?: string;
+    /**
+     * `abandoned` is a run you opened and never drained: nothing was scored on
+     * it for a week and items were still waiting. Nothing is deleted and posting
+     * verdicts to it still works and still closes it as done. It exists so that
+     * `open` keeps meaning "somebody is working on this".
+     *
+     * `stopped` is a run somebody closed on purpose before it finished, with
+     * `stopRun`. Separate from `done` because a run that covered three of forty
+     * conversations did not finish its work: every score it recorded is kept
+     * either way, and reading one as the other overstates what was evaluated.
+     */
+    status: 'open' | 'done' | 'abandoned' | 'stopped';
+    instructions: string;
+    dimensions: LoopJudgeDimension[];
+    model: string | null;
+    selected: number;
+    scored: number;
+    failed: number;
+    /** Who drains it: your own code ('caller') or the platform's agent ('platform'). */
+    runner: 'caller' | 'platform';
+    /** The agent's last complaint about this run, or null while it is working. */
+    last_error: string | null;
+    last_activity_at: string | null;
+    created_by: string | null;
+    created_at: string;
+    finished_at: string | null;
+}
+/** The workspace's managed serverless key the agent spends through. Never the secret. */
+export interface LoopAgentCredential {
+    workspace_id: string;
+    key_id: string;
+    key_prefix: string;
+    created_by: string | null;
+    created_at: string;
+    updated_at: string;
+    last_used_at: string | null;
+    last_error: string | null;
+    revoked_at: string | null;
+    /**
+     * The most the agent's key may spend on model calls in a calendar month,
+     * in cents. `null` = no cap (the default): the agent can spend up to the
+     * workspace's serverless balance. Once reached, the agent's model calls
+     * are refused until next month and its runs pause with that reason.
+     */
+    monthly_spend_cap_cents: number | null;
+}
+export interface LoopAgentStatus {
+    /** An agent can exist in this environment at all. */
+    available: boolean;
+    /** Which piece is missing when it cannot. */
+    reason: string;
+    /** A worker has checked in within the last minute. */
+    online: boolean;
+    agent: {
+        seen_at: string;
+        passes: number;
+        judge_items: number;
+        samples: number;
+    } | null;
+    credential: LoopAgentCredential | null;
+    open_judge_runs: number;
+    open_sample_runs: number;
+    auto_judges: number;
+}
+export interface LoopSampleSelection extends LoopJudgeSelection {
+    /** Skip conversations that already have alternatives. */
+    only_unsampled?: boolean;
+}
+export interface LoopSampleRunParams {
+    /** The model that writes the alternatives. For distillation, the teacher. */
+    model: string;
+    /** Alternatives per conversation, 1-8. Default 4. */
+    n?: number;
+    /** 0-2. Default 0.8; 0 makes every sample the same answer. */
+    temperature?: number;
+    /** 16-8192. Default 1024. */
+    max_tokens?: number;
+    /** Score each sample with this judge as it is written. */
+    judge_id?: string;
+    selection?: LoopSampleSelection;
+}
+/** "Write N alternatives to each conversation in this slice, and score them." */
+export interface LoopSampleRun {
+    id: string;
+    workspace_id: string;
+    model: string;
+    n: number;
+    temperature: number;
+    max_tokens: number;
+    judge_id: string | null;
+    judge_name: string | null;
+    selection: LoopSampleSelection;
+    status: 'open' | 'done';
+    selected: number;
+    done: number;
+    failed: number;
+    samples: number;
+    last_error: string | null;
+    last_activity_at: string | null;
+    created_by: string | null;
+    created_at: string;
+    finished_at: string | null;
+}
+/**
+ * One conversation to score, already rendered into the prompt to send.
+ *
+ * Send `prompt` as-is. Assembling it yourself is how two callers end up giving
+ * the same rubric different instructions, and two judges given different
+ * instructions are not one judge.
+ */
+export interface LoopJudgeWorkItem {
+    trace_id: string;
+    messages: Array<{
+        role: string;
+        content?: string;
+    }>;
+    answer: string;
+    prompt: string;
+}
+export interface LoopJudgeWork {
+    run: LoopJudgeRun;
+    items: LoopJudgeWorkItem[];
+    remaining: number;
+}
+export type LoopJudgeRunItemStatus = 'pending' | 'scored' | 'failed';
+/** What happened to one conversation in one run. */
+export interface LoopJudgeRunItem {
+    trace_id: string;
+    status: LoopJudgeRunItemStatus;
+    /**
+     * Why this one could not be scored, as the caller reported it. This is where
+     * a wrong model name or a refused key shows up; null for anything that is
+     * not failed.
+     */
+    error: string | null;
+    scored_at: string | null;
+}
+export interface LoopJudgeRunItems {
+    run: LoopJudgeRun;
+    items: LoopJudgeRunItem[];
+    /** True when the page ended before the run did. */
+    has_more: boolean;
+    /** Where to carry on from. Present only when `has_more`. */
+    next_offset?: number;
+}
+/** One scored conversation going back. */
+export interface LoopJudgeVerdict {
+    trace_id: string;
+    /** One score per dimension the rubric asked for, each between 0 and 1. */
+    scores?: Record<string, number>;
+    /** Your own combination of them. Left out, the plain mean is used. */
+    overall?: number;
+    reason?: string;
+    /** Only stored if the judge was created with `write_gold`. */
+    gold?: string;
+    /** Mark an item you could not score, instead of dropping it silently. */
+    error?: string;
+}
+export interface LoopJudgeVerdictResult {
+    run: LoopJudgeRun;
+    recorded: number;
+    failed: number;
+    rejected: Array<{
+        trace_id: string;
+        error: string;
+    }>;
+}
+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;
+}
+/**
+ * The deterministic checks a grader can perform.
+ *
+ * `matches_gold` is the one kind with no expected value of its own: it
+ * compares each answer to the gold answer recorded on that same conversation
+ * (or the human correction when there is no gold), scores sampled
+ * alternatives against the same gold, and is NOT APPLIED to a conversation
+ * that carries neither, so it never marks down an unlabelled answer.
+ */
+export type LoopGraderKind = 'matches_gold' | 'exact_match' | 'contains' | 'regex' | 'json_valid' | 'numeric' | 'tool_called';
+export interface LoopGraderConfig {
+    expected?: string;
+    /** Every phrase that must appear. */
+    required?: string[];
+    /** Phrases that must not. On their own these are passed by silence. */
+    forbidden?: string[];
+    pattern?: string;
+    /** Keys the answer must carry, for `json_valid`. */
+    keys?: string[];
+    /**
+     * How far from `expected` still counts, for `numeric`. For `matches_gold`,
+     * how far from the gold answer still counts when both are bare numbers.
+     */
+    tolerance?: number;
+    /** The function that must have been called, for `tool_called`. */
+    function?: string;
+    case_sensitive?: boolean;
+}
+export interface LoopGraderParams {
+    name: string;
+    kind: LoopGraderKind;
+    config: LoopGraderConfig;
+    /** The multiplier. Twice as important, twice the weight. Must exceed zero. */
+    weight?: number;
+    enabled?: boolean;
+    /** Limit the rule to one capture source. Omit to apply it everywhere. */
+    deployment_id?: string;
+    /**
+     * Aim the rule at one slice of the corpus. A master group covers its
+     * children. Outside that slice the rule is NOT APPLIED, rather than failed,
+     * so it stays out of the score entirely. Omit to apply it everywhere.
+     */
+    label?: string;
+}
+export interface LoopGrader extends LoopGraderParams {
+    id: string;
+    workspace_id: string;
+    weight: number;
+    enabled: boolean;
+    created_by: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface LoopGraderResult {
+    grader_id: string;
+    name: string;
+    kind: string;
+    weight: number;
+    passed: boolean;
+    score: number;
+    /** What happened, in words -- "failed" alone sends you to read the rule. */
+    detail: string;
+    /** The rule had no opinion. Excluded from the score rather than counted 0. */
+    skipped: boolean;
+}
+export interface LoopGradeReport {
+    /** Weighted mean over the rules that applied, 0 to 1. */
+    score: number;
+    results: LoopGraderResult[];
+    /** The denominator. 1.0 from one rule is not 1.0 from six. */
+    applied: number;
+    skipped: number;
+}
+export interface LoopGradeResult {
+    report: LoopGradeReport;
+    /** Null when no rule applied, because no verdict was invented. */
+    signal_id: string | null;
+    candidates_graded: number;
+}
+export interface LoopLabel {
+    label: string;
+    /** The master group this label belongs to, if any. */
+    parent: string | null;
+    created_by: string | null;
+    created_at: string;
+    /** The dimension this value belongs to. `tag` for a bare name. */
+    key: string;
+}
+/** One master group, and how many of a label's conversations are in it. */
+export interface LoopLabelParentCount {
+    parent: string;
+    traces: number;
+}
+export interface LoopLabelCount {
+    label: string;
+    /**
+     * The master group ALL of this label's conversations are in, and nothing
+     * else. Null when they disagree: the registry used to answer the
+     * alphabetically last parent over a mixed group, so `billing` was reported
+     * under `support` while seven of its twelve conversations were in no group
+     * at all. Render "(in x)" from this field only.
+     */
+    parent: string | null;
+    /**
+     * Every master group ANY of them are in, sorted, with how many of this
+     * label's conversations are in each. Empty when there are none.
+     *
+     * Read this, not `parent`, to discover which master groups exist: a label
+     * whose conversations disagree still belongs partly to a real group, and
+     * `parent` is null for it, so a picker built from `parent` alone loses the
+     * group along with the false claim. The count is per group rather than the
+     * label's own total, because adding a label's whole count to its parent is
+     * the same mistake one level down. What is in no group at all is `traces`
+     * minus the sum of these.
+     */
+    parents: LoopLabelParentCount[];
+    traces: number;
+    key: string;
+}
+export type TrainingCadence = 'none' | 'daily' | 'weekly';
+export type TrainingCombinator = 'and' | 'or';
+/** What answers the customer's traffic today, and therefore what promotion re-points. */
+export type ServingKind = 'serverless_slug' | 'deployment';
+export type TrainingRulePausedReason = 'consent_invalid' | 'insufficient_funds' | 'authorizer_not_member' | 'model_not_trainable' | 'platform_capacity'
+/** A peer was unreachable when the rule was saved, so it has not been validated yet. */
+ | 'validation_pending';
+/**
+ * How a training rule trains, on the wire of the automatic-training routes.
+ *
+ * DELIBERATELY NOT {@link TrainingMethod}. That union -- 'sft' | 'pt' -- is
+ * training-service's, and the two services enumerate different things: a
+ * training job can be a plain pre-training run, and a training rule cannot,
+ * while a rule may ask for preference training and a job asks for that through
+ * a different field. The values here are the loop service's own constants
+ * (TrainingMethodSFT / TrainingMethodRLHF in
+ * services/loop-service/cmd/training_types.go), which is what these routes
+ * accept and return. Sharing the training-service union here advertised 'pt',
+ * which this service refuses, and made 'rlhf', which it returns, unspellable.
+ *
+ * `rlhf_type` stays a plain string on purpose: the platform refuses it until
+ * capabilities enable preference training, and an SDK union would have to be
+ * republished to keep up with a server-side capability flag.
+ */
+export type LoopTrainingMethod = 'sft' | 'rlhf';
+export type TrainType = 'lora' | 'qlora' | 'full';
+export type GradersScope = 'source' | 'all' | 'none';
+export type TrainingTrigger = 'rows' | 'cadence' | 'both' | 'manual';
+export type TrainingRunState = 'built' | 'registering' | 'dataset_validating' | 'preflighting' | 'job_creating' | 'training' | 'checkpoint_ready' | 'candidate_booking' | 'candidate_running' | 'evaluating' | 'reported' | 'awaiting_review' | 'promoting' | 'waiting_funds' | 'promoted' | 'rejected' | 'expired' | 'failed' | 'budget_stopped' | 'cancelled' | 'superseded' | 'rolled_back';
+/** The closed set a run never leaves. */
+export declare const TERMINAL_RUN_STATES: readonly TrainingRunState[];
+export type TrainingVerdict = 'better' | 'not_better' | 'inconclusive' | 'not_evaluated';
+export type TrainingDecision = 'auto_promoted' | 'promoted' | 'rejected' | 'auto_rejected' | 'rolled_back';
+export type NotifyState = 'none' | 'pending' | 'sending' | 'sent' | 'suppressed' | 'failed';
+export type EvaluationStatus = 'open' | 'done' | 'failed' | 'budget_stopped';
+export type EvaluationItemStatus = 'pending' | 'working' | 'done' | 'failed';
+export type EvaluationWinner = 'candidate' | 'incumbent' | 'tie';
+/** Typed warning codes. Each surface renders its own plain sentence. */
+export type EvaluationWarningCode = 'holdout_too_small' | 'judge_unreliable' | 'graders_not_applied' | 'many_failures' | 'no_judge' | 'judge_labelled_training_rows' | 'capture_source_moved';
+export type ConsentVia = 'console' | 'api_key' | 'sdk' | 'mcp';
+/** A function an assistant turn asked to invoke. `arguments` is JSON-encoded. */
+export interface TrainingToolCall {
+    id?: string;
+    type?: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** One conversational turn, in the chat-completions shape. */
+export interface TrainingMessage {
+    role: string;
+    content?: string;
+    tool_calls?: TrainingToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+/** What serves this model today. The name is also the alias a promotion writes. */
+export interface TrainingRuleServing {
+    kind: ServingKind;
+    name: string;
+    /** Set only when kind is 'deployment'. */
+    deployment_id: string | null;
+}
+/** One rung of a ranked GPU ladder. The provider is the neutral public brand. */
+export interface TrainingGPURung {
+    gpu_type: string;
+    gpu_count: number;
+    provider: string;
+    region: string;
+    tier: string;
+}
+/** The consent object: one standing instruction to train, judge and possibly promote. */
+export interface TrainingRule {
+    id: string;
+    workspace_id: string;
+    build_rule_id: string;
+    name: string;
+    enabled: boolean;
+    /** Why the platform stopped firing this rule. Waiting must not look like broken. */
+    paused_reason: TrainingRulePausedReason | null;
+    cadence: TrainingCadence;
+    cadence_hour_utc: number;
+    cadence_weekday: number | null;
+    combinator: TrainingCombinator;
+    min_new_rows: number | null;
+    /** Spreads firings across the hour so every daily rule does not land on one minute. */
+    jitter_seconds: number;
+    next_due_at: string | null;
+    last_checked_at: string | null;
+    last_fired_at: string | null;
+    last_run_id: string | null;
+    /** Rendered verbatim: "waiting: ...", "due, but ...", "fired: run 7 from ...". */
+    last_reason: string | null;
+    serving: TrainingRuleServing;
+    model_id: string;
+    /** A 40-hex commit, pinned when the rule is saved. */
+    model_revision: string;
+    training_method: LoopTrainingMethod;
+    /** Refused by the platform until capabilities enable preference training. */
+    rlhf_type: string | null;
+    train_type: TrainType;
+    config: Record<string, unknown>;
+    train_gpu_priorities: TrainingGPURung[];
+    train_max_price_hour_cents: number;
+    deploy_gpu_priorities: TrainingGPURung[];
+    deploy_max_price_hour_cents: number;
+    training_ceiling_cents: number;
+    candidate_ceiling_cents: number;
+    /** A dollar figure, never a call count. */
+    eval_ceiling_cents: number;
+    monthly_ceiling_cents: number | null;
+    eval_judge_id: string | null;
+    eval_judge_model: string | null;
+    eval_graders_scope: GradersScope;
+    eval_max_rows: number;
+    eval_max_tokens: number;
+    min_holdout_rows: number;
+    /**
+     * The standing benchmark replayed on every run of this rule, beside the
+     * per-run comparison and never instead of it. Null is the ordinary state.
+     *
+     * Set with `setTrainingRuleBenchmark`, not by an update to the rule: it is a
+     * decision to replay a fixed set on every future run, and it has refusals of
+     * its own. It raises no amount, so it does not invalidate consent.
+     */
+    benchmark_id: string | null;
+    auto_promote: boolean;
+    promote_margin: number;
+    promote_min_win_rate: number;
+    /** A gate, not a badge. */
+    min_judge_agreement: number;
+    review_window_hours: number;
+    candidate_boot_deadline_minutes: number;
+    keep_candidate_warm_minutes: number;
+    /** The member whose wallet pays, and the identity every peer call is stamped with. */
+    authorized_by: string;
+    terms_version: string;
+    revision: number;
+    /** Equal to revision only while the consent is current. */
+    accepted_revision: number;
+    accepted_at: string | null;
+    deleted_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/** One append-only record of a member agreeing to spend, with the words they read. */
+export interface TrainingRuleConsent {
+    id: number;
+    rule_id: string;
+    workspace_id: string;
+    revision: number;
+    terms_version: string;
+    terms_text: string;
+    snapshot: Record<string, unknown>;
+    accepted_by: string;
+    accepted_via: ConsentVia;
+    accepted_at: string;
+}
+export interface TrainingRulePreflightRefusal {
+    stage: string;
+    code: string;
+    message: string;
+}
+/** One key that cannot follow a cutover, named so the caller can say which. */
+export interface TrainingRuleKeyRef {
+    key_id: string;
+    prefix: string;
+    name: string;
+}
+export interface TrainingRuleKeyCheck {
+    keys_missing_deployments_read: TrainingRuleKeyRef[];
+}
+/** The side-effect-free estimate, and the exact sentence the member will accept. */
+export interface TrainingRulePreflight {
+    valid: boolean;
+    model_revision: string;
+    worst_hourly_training_cents: number;
+    worst_hourly_candidate_cents: number;
+    max_training_hours: number;
+    max_candidate_hours: number;
+    /** Informational. The fence on evaluation is the dollar ceiling, never this. */
+    eval_calls_max: number;
+    training_ceiling_cents: number;
+    candidate_ceiling_cents: number;
+    eval_ceiling_cents: number;
+    warnings: string[];
+    refusals: TrainingRulePreflightRefusal[];
+    /**
+     * Every peer the platform could not reach on this pass, one entry each, in
+     * the same `{stage, code, message}` shape as a refusal.
+     *
+     * A warning, not a refusal: an unreachable peer judged nothing, so it never
+     * refuses a save. It is still why the rule cannot fire — both
+     * `worst_hourly_*` come back `0` — so `valid` is `false`. Key a "cannot
+     * save" state on this when `refusals` is empty; the same sentences are also
+     * in `warnings`, so render one or the other.
+     *
+     * Key it on THIS, not on `model_revision`. A degraded pass echoes back the
+     * `model_revision` the request carried rather than emptying it, so
+     * `if (!model_revision)` is false on exactly the passes it was meant to
+     * catch. Use `unreachable.length > 0`, or `/^[0-9a-f]{40}$/`.
+     */
+    unreachable: TrainingRulePreflightRefusal[];
+    key_check: TrainingRuleKeyCheck;
+    terms_text: string;
+    terms_version: string;
+}
+export interface TrainingRuleBuildSpec {
+    method: string;
+    spec: Record<string, unknown>;
+}
+/**
+ * The editable half of a build rule.
+ *
+ * Deliberately not `LoopBuildRuleParams`: that type requires `name` and
+ * `method`, which the PUT route does not accept, so an edit written against it
+ * would have to resend two fields the platform ignores and a caller could not
+ * tell that changing them did nothing.
+ */
+export interface LoopBuildRuleUpdateParams {
+    enabled?: boolean;
+    /** Rows reviewed SINCE THE LAST BUILD before this fires again. Minimum 10. */
+    min_new_rows?: number;
+    /** The same selection `createDataset` takes, replayed verbatim. */
+    spec?: LoopDatasetCreateParams;
+}
+/**
+ * `?` means absent: leave that part of the sentence alone. `null` is only
+ * allowed where the column is nullable and clearing it is a real edit, and it
+ * is spelled out field by field rather than applied to the whole object.
+ */
+export interface TrainingRuleTriggerInput {
+    cadence?: TrainingCadence;
+    cadence_hour_utc?: number;
+    /** null drops the weekday, which is what a weekly rule moved to daily needs. */
+    cadence_weekday?: number | null;
+    combinator?: TrainingCombinator;
+    /** null removes the row floor, leaving the schedule as the only trigger. */
+    min_new_rows?: number | null;
+}
+export interface TrainingRuleTrainingInput {
+    model_id?: string;
+    model_revision?: string;
+    training_method?: LoopTrainingMethod;
+    /**
+     * A plain string, refused by the platform until capabilities enable
+     * preference training. null clears it, which is what moving a rule back to
+     * plain supervised training means.
+     */
+    rlhf_type?: string | null;
+    train_type?: TrainType;
+    config?: Record<string, unknown>;
+    train_gpu_priorities?: TrainingGPURung[];
+    train_max_price_hour_cents?: number;
+}
+export interface TrainingRuleDeployInput {
+    deploy_gpu_priorities?: TrainingGPURung[];
+    deploy_max_price_hour_cents?: number;
+    context_length?: number;
+    quant?: string;
+    serving_config?: Record<string, unknown>;
+    hf_integration_id?: string;
+}
+export interface TrainingRuleMoneyInput {
+    training_ceiling_cents?: number;
+    candidate_ceiling_cents?: number;
+    eval_ceiling_cents?: number;
+    /** null removes the monthly cap. Absent leaves it exactly where it stands. */
+    monthly_ceiling_cents?: number | null;
+    eval_max_rows?: number;
+}
+export interface TrainingRuleEvaluationInput {
+    /** null removes the judge from this rule. */
+    judge_id?: string | null;
+    /** null drops the override, returning to the judge's own advisory model. */
+    judge_model?: string | null;
+    graders_scope?: GradersScope;
+    min_holdout_rows?: number;
+    eval_max_tokens?: number;
+}
+export interface TrainingRulePromotionInput {
+    auto_promote?: boolean;
+    promote_margin?: number;
+    promote_min_win_rate?: number;
+    min_judge_agreement?: number;
+    review_window_hours?: number;
+    keep_candidate_warm_minutes?: number;
+}
+/**
+ * The version of the terms the member read and accepted.
+ *
+ * Send back the `terms_version` the preflight returned. The SDK deliberately
+ * ships no constant for it: a pinned version in a published package goes stale
+ * the moment the platform revises the terms, and the value a member consented
+ * to has to be the one they were actually shown.
+ */
+export interface TrainingRuleAcceptTerms {
+    terms_version: string;
+}
+/** The create body without the yes. The preflight route takes exactly this. */
+export interface TrainingRulePreflightRequest {
+    workspace_id?: string;
+    name?: string;
+    /** Exactly one of build_rule_id and build is given. */
+    build_rule_id?: string;
+    build?: TrainingRuleBuildSpec;
+    trigger?: TrainingRuleTriggerInput;
+    serving?: TrainingRuleServing;
+    training?: TrainingRuleTrainingInput;
+    deploy?: TrainingRuleDeployInput;
+    money?: TrainingRuleMoneyInput;
+    evaluation?: TrainingRuleEvaluationInput;
+    promotion?: TrainingRulePromotionInput;
+    enabled?: boolean;
+}
+export interface TrainingRuleCreateRequest extends TrainingRulePreflightRequest {
+    /** Absent is a refusal, not a default. */
+    accept_terms?: TrainingRuleAcceptTerms;
+    /**
+     * The standing benchmark this rule replays, set here so it applies to the
+     * rule's FIRST run.
+     *
+     * A rule can fire within seconds of being created, and every step of a run
+     * reads the benchmark off the rule as it stood at that moment. Attaching one
+     * afterwards with `setTrainingRuleBenchmark` applies from the next run and
+     * says nothing about the first, which is the run somebody is watching.
+     *
+     * Refused on the same terms the attach route refuses it: `404` when it is not
+     * this workspace's, `409 BENCHMARK_RETIRED` when it has been retired. Use
+     * `setTrainingRuleBenchmark` to change or remove it later; it is not on the
+     * preflight body and not on the update body.
+     */
+    benchmark_id?: string;
+}
+export interface TrainingRuleUpdateRequest extends TrainingRulePreflightRequest {
+    expected_revision?: number;
+    accept_terms?: TrainingRuleAcceptTerms;
+}
+export interface TrainingRuleConsentRequest {
+    terms_version: string;
+    revision: number;
+}
+export interface TrainingRuleListParams {
+    enabled?: boolean;
+    limit?: number;
+    offset?: number;
+}
+export interface TrainingRunPromoteRequest {
+    expected_revision?: number;
+    /** Required to promote an inconclusive comparison. */
+    force?: boolean;
+}
+export interface TrainingRunRejectRequest {
+    reason?: string;
+}
+export interface TrainingRunRollbackRequest {
+    reason?: string;
+}
+export interface TrainingRunCancelRequest {
+    reason?: string;
+}
+export interface TrainingRunListParams {
+    rule_id?: string;
+    state?: TrainingRunState;
+    limit?: number;
+    offset?: number;
+}
+/** One firing, from the curated set to the decision. Money is frozen at fire time. */
+export interface TrainingRun {
+    id: string;
+    rule_id: string | null;
+    rule_name: string | null;
+    workspace_id: string;
+    seq: number;
+    rule_revision: number;
+    authorized_by: string;
+    rule_snapshot: Record<string, unknown>;
+    trigger: TrainingTrigger;
+    fired_reason: string | null;
+    state: TrainingRunState;
+    state_entered_at: string;
+    attempts: number;
+    next_poll_at: string | null;
+    last_reason: string | null;
+    error_code: string | null;
+    last_error: string | null;
+    training_ceiling_cents: number;
+    candidate_ceiling_cents: number;
+    eval_ceiling_cents: number;
+    billed_training_cents: number;
+    billed_candidate_cents: number;
+    spent_eval_cents: number;
+    loop_dataset_id: string | null;
+    train_rows: number | null;
+    holdout_rows: number | null;
+    train_dataset_id: string | null;
+    holdout_dataset_id: string | null;
+    training_job_id: string | null;
+    job_status: string | null;
+    queue_deadline_at: string | null;
+    checkpoint_id: string | null;
+    checkpoint_step: number | null;
+    training_eval_loss: number | null;
+    candidate_deployment_id: string | null;
+    candidate_name: string | null;
+    candidate_seq: number;
+    candidate_status: string | null;
+    candidate_deadline_at: string | null;
+    candidate_cleanup_at: string | null;
+    evaluation_id: string | null;
+    /** This run's replay of the rule's standing benchmark, if it had one. */
+    benchmark_run_id: string | null;
+    /**
+     * What the replay's calls cost. Kept apart from `spent_eval_cents` so a
+     * report can say what the comparison cost and what the benchmark cost; both
+     * come out of `eval_ceiling_cents` and their sum can never exceed it, so
+     * anything totalling what a run cost has to add this one too.
+     */
+    benchmark_spent_cents: number;
+    alias_name: string | null;
+    alias_written_at: string | null;
+    serving_before: TrainingRuleServing | null;
+    rollback_available_until: string | null;
+    verdict: TrainingVerdict | null;
+    decision: TrainingDecision | null;
+    decided_by: string | null;
+    decided_at: string | null;
+    auto_promote_at: string | null;
+    review_deadline_at: string | null;
+    notify_state: NotifyState;
+    notify_event: string | null;
+    notify_error: string | null;
+    notify_attempts: number;
+    created_at: string;
+    updated_at: string;
+    finished_at: string | null;
+}
+/** One row of the Runs table, carrying everything the list draws. */
+export interface TrainingRunSummary {
+    id: string;
+    rule_id: string | null;
+    rule_name: string | null;
+    workspace_id: string;
+    seq: number;
+    trigger: TrainingTrigger;
+    state: TrainingRunState;
+    state_entered_at: string;
+    last_reason: string | null;
+    error_code: string | null;
+    verdict: TrainingVerdict | null;
+    decision: TrainingDecision | null;
+    train_rows: number | null;
+    holdout_rows: number | null;
+    billed_training_cents: number;
+    billed_candidate_cents: number;
+    spent_eval_cents: number;
+    /** The fourth money column. A row that leaves it out adds up short. */
+    benchmark_spent_cents: number;
+    training_job_id: string | null;
+    candidate_deployment_id: string | null;
+    evaluation_id: string | null;
+    review_deadline_at: string | null;
+    auto_promote_at: string | null;
+    notify_state: NotifyState;
+    created_at: string;
+    finished_at: string | null;
+}
+/** One line of the timeline. detail holds codes, ids and cents, never prompt text. */
+export interface TrainingRunEvent {
+    seq: number;
+    ts: string;
+    from_state: TrainingRunState | null;
+    to_state: TrainingRunState;
+    reason: string;
+    error_code: string | null;
+    detail: Record<string, unknown>;
+    actor: string;
+}
+export interface TrainingRunLinks {
+    training_job_url: string | null;
+    candidate_url: string | null;
+    dataset_url: string | null;
+    evaluation_url: string | null;
+    /** The TREND the benchmark number belongs to, not the one replay. */
+    benchmark_url: string | null;
+}
+/** What this reader may do right now. A button that cannot work is never shown. */
+export interface TrainingRunActions {
+    promote: boolean;
+    reject: boolean;
+    rollback: boolean;
+    cancel: boolean;
+}
+export interface EvaluationRef {
+    kind: ServingKind;
+    name: string;
+    deployment_id: string | null;
+    model_version: string | null;
+}
+/** Frozen on the evaluation. Both sides are regenerated with identical decoding. */
+export interface EvaluationDecoding {
+    temperature: number;
+    max_tokens: number;
+    stream: boolean;
+}
+export interface EvaluationJudgeDimension {
+    key: string;
+    description: string;
+}
+export interface EvaluationDimensionScore {
+    dimension: string;
+    incumbent: number;
+    candidate: number;
+    delta: number;
+}
+export interface EvaluationGraderScore {
+    grader_id: string;
+    name: string;
+    incumbent: number;
+    candidate: number;
+    delta: number;
+    /** A grader that applied to four rows has not measured anything. */
+    items_applied: number;
+}
+export interface EvaluationWarning {
+    code: EvaluationWarningCode;
+    message: string;
+}
+/** The thresholds this verdict was measured against, frozen with the report. */
+export interface EvaluationMargin {
+    promote_margin: number;
+    promote_min_win_rate: number;
+    min_judge_agreement: number;
+    min_holdout_rows: number;
+}
+/**
+ * One rubric dimension of a judge-versus-human agreement.
+ *
+ * Deliberately not EvaluationDimensionScore: that type carries `incumbent` and
+ * `candidate`, which are the two models being compared, and an agreement has
+ * neither. `pairs` is per dimension because a reviewer who rated one dimension
+ * and skipped another leaves a different denominator behind each number.
+ */
+export interface JudgeAgreementDimension {
+    dimension: string;
+    pairs: number;
+    agreement: number | null;
+    mean_abs_error: number | null;
+}
+/** How often this judge agreed with the workspace's own reviewers. */
+export interface JudgeAgreement {
+    judge_id: string;
+    pairs: number;
+    agreement: number | null;
+    mean_abs_error: number | null;
+    per_dimension: JudgeAgreementDimension[];
+    window_days: number;
+    computed_at: string;
+    /** "Not enough reviewer overlap yet" is an answer; 100% of two is not. */
+    enough_pairs: boolean;
+}
+/** The comparison report: the candidate against what serves today, same rows. */
+export interface Evaluation {
+    id: string;
+    run_id: string;
+    workspace_id: string;
+    loop_dataset_id: string | null;
+    split: string;
+    incumbent_ref: EvaluationRef;
+    candidate_ref: EvaluationRef;
+    judge_id: string | null;
+    judge_name: string | null;
+    judge_model: string | null;
+    judge_instructions: string | null;
+    judge_dimensions: EvaluationJudgeDimension[];
+    judge_system_prompt: string | null;
+    grader_ids: string[];
+    decoding: EvaluationDecoding;
+    rows_selected: number;
+    rows_scored: number;
+    rows_failed: number;
+    /** win_rate is wins / (wins + losses). Ties are excluded and reported separately. */
+    wins: number | null;
+    losses: number | null;
+    ties: number | null;
+    win_rate: number | null;
+    incumbent_mean: number | null;
+    candidate_mean: number | null;
+    mean_delta: number | null;
+    judge_incumbent_mean: number | null;
+    judge_candidate_mean: number | null;
+    grader_incumbent_mean: number | null;
+    grader_candidate_mean: number | null;
+    grader_items_applied: number;
+    per_dimension: EvaluationDimensionScore[];
+    per_grader: EvaluationGraderScore[];
+    judge_agreement: JudgeAgreement | null;
+    /** Informational: there is no incumbent counterpart to compare it against. */
+    trainer_eval_loss: number | null;
+    warnings: EvaluationWarning[];
+    verdict: TrainingVerdict | null;
+    verdict_reason: string | null;
+    margin_used: EvaluationMargin | null;
+    prompt_tokens: number;
+    completion_tokens: number;
+    spent_cents: number;
+    status: EvaluationStatus;
+    last_error: string | null;
+    created_at: string;
+    finished_at: string | null;
+}
+/** One model's answer to one held-out conversation, with the scores it earned. */
+export interface EvaluationItemSide {
+    completion: string | null;
+    tool_calls: TrainingToolCall[] | null;
+    grader: Record<string, unknown> | null;
+    judge: Record<string, unknown> | null;
+    score: number | null;
+    model_version: string | null;
+}
+/**
+ * One paired conversation behind the numbers.
+ *
+ * trace_id is nullable on purpose: deleting one conversation must not shrink a
+ * finished report so that its stated n and its visible rows disagree.
+ */
+export interface EvaluationItem {
+    id: number;
+    dataset_item_id: number;
+    trace_id: string | null;
+    trace_url: string | null;
+    prompt: TrainingMessage[];
+    tools: unknown[] | null;
+    incumbent: EvaluationItemSide;
+    candidate: EvaluationItemSide;
+    human_verdict: number | null;
+    winner: EvaluationWinner | null;
+    status: EvaluationItemStatus;
+    error: string | null;
+}
+export interface EvaluationItemListParams {
+    winner?: EvaluationWinner;
+    /** Capped at 100 by the service. */
+    limit?: number;
+    offset?: number;
+}
+export interface JudgeAgreementParams {
+    /** RFC 3339. Narrows the window the agreement is computed over. */
+    from?: string;
+    to?: string;
+}
+/** Which model, whose words, how much. The cap is pushed to the workspace key. */
+export interface AgentSettings {
+    workspace_id: string;
+    default_model: string | null;
+    judge_system_prompt: string | null;
+    sampler_system_prompt: string | null;
+    eval_monthly_cap_cents: number | null;
+    updated_by: string | null;
+    updated_at: string;
+}
+/** Absent leaves a setting alone; a present null returns it to the platform default. */
+export interface AgentSettingsRequest {
+    default_model?: string | null;
+    judge_system_prompt?: string | null;
+    sampler_system_prompt?: string | null;
+    eval_monthly_cap_cents?: number | null;
+}
+/** A re-pointable public handle. Promotion is one row write here. */
+export interface InferenceAlias {
+    workspace_id: string;
+    name: string;
+    target_inference_id: string;
+    previous_target_inference_id: string | null;
+    /** Set only at adoption, when the alias takes over a deployment's own name. */
+    shadows_inference_id: string | null;
+    set_by: string;
+    origin: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface InferenceAliasRequest {
+    target_inference_id: string;
+    origin?: string;
+}
+/**
+ * A benchmark is active until it is retired. There is no delete and no update:
+ * the series of numbers measured against a set is what a benchmark is for, so
+ * an edit would make every number before it incomparable with every number
+ * after it, and a delete throws the series away.
+ */
+export type BenchmarkStatus = 'active' | 'retired';
+/** Where the pinned conversations are copied from. Read once, at creation. */
+export type BenchmarkSourceKind = 'traces' | 'dataset';
+/**
+ * The life of one replay.
+ *
+ * `budget_stopped` reached the amount left for it inside the run's own ceiling,
+ * and `abandoned` ran out of the time the run sets aside for it. Both are
+ * points on the trend carrying `status_reason`, never silent gaps.
+ */
+export type BenchmarkRunStatus = 'open' | 'done' | 'failed' | 'budget_stopped' | 'abandoned';
+/**
+ * How the pinned conversations become one number, frozen on the benchmark.
+ *
+ * `require_all_rows` is what makes the number comparable at all: a mean over
+ * whichever conversations happened to succeed is a measurement of a different
+ * set, so a short replay publishes no score and says why. A partial benchmark
+ * is a missing number, never a lower one.
+ */
+export interface BenchmarkScoring {
+    metric: string;
+    scale: string;
+    aggregate: string;
+    require_all_rows: boolean;
+}
+/**
+ * One rubric dimension of one replay, for both models.
+ *
+ * Deliberately not `EvaluationDimensionScore`: these are absolute means on a
+ * fixed set and those are paired means on that run's own held-back rows.
+ */
+export interface BenchmarkDimensionScore {
+    dimension: string;
+    incumbent: number;
+    candidate: number;
+    delta: number;
+}
+/**
+ * The frozen definition: the oracle, the scoring rule and the fingerprint of
+ * the set. The conversations themselves are their own paged route.
+ */
+export interface Benchmark {
+    id: string;
+    workspace_id: string;
+    name: string;
+    status: BenchmarkStatus;
+    /** Provenance only: everything needed from the judge is copied below it. */
+    judge_id: string | null;
+    judge_name: string;
+    judge_model: string;
+    judge_instructions: string;
+    judge_dimensions: EvaluationJudgeDimension[];
+    judge_system_prompt: string | null;
+    decoding: EvaluationDecoding;
+    scoring: BenchmarkScoring;
+    item_count: number;
+    /** Recomputed from the rows and compared at the start of every replay. */
+    items_digest: string;
+    /** A cap INSIDE the run's own amount for judge calls, never an addition to it. */
+    per_run_ceiling_cents: number;
+    created_by: string;
+    created_at: string;
+    retired_at: string | null;
+    retired_by: string | null;
+}
+/**
+ * One pinned conversation.
+ *
+ * `source_trace_id` is a link and is allowed to go null: the prompt was copied
+ * at pin time, so retention removing the conversation takes away the ability to
+ * open it and takes away nothing else. Every number already measured stays
+ * exactly as comparable as it was.
+ */
+export interface BenchmarkItem {
+    id: number;
+    ordinal: number;
+    source_trace_id: string | null;
+    source_trace_url: string | null;
+    prompt: TrainingMessage[];
+    tools: unknown[] | null;
+}
+/**
+ * One replay: this benchmark, on this training run, against both models.
+ *
+ * IT DOES NOT GATE PROMOTION. The paired comparison applies the judge to both
+ * sides of one conversation in one pass, so most of the judge's variance
+ * cancels in its delta; an absolute mean carries that variance whole. What
+ * ships here is the number, the difference against what serves today on the
+ * same set, and the history. A person reads the trend.
+ */
+export interface BenchmarkRun {
+    id: string;
+    benchmark_id: string;
+    benchmark_name: string;
+    run_id: string;
+    workspace_id: string;
+    incumbent_ref: EvaluationRef;
+    candidate_ref: EvaluationRef;
+    /** The set actually scored, recorded beside the score. */
+    items_digest: string;
+    rows_total: number;
+    rows_scored: number;
+    rows_failed: number;
+    /** Absolute, on the frozen judge's scale, and null unless every row scored. */
+    candidate_score: number | null;
+    incumbent_score: number | null;
+    score_delta: number | null;
+    per_dimension: BenchmarkDimensionScore[];
+    prompt_tokens: number;
+    completion_tokens: number;
+    spent_cents: number;
+    ceiling_cents: number;
+    status: BenchmarkRunStatus;
+    /** The whole explanation when there is no score, so never empty on one. */
+    status_reason: string | null;
+    created_at: string;
+    finished_at: string | null;
+}
+/**
+ * One point on the trend line.
+ *
+ * It carries the checkpoint and what the person then decided, because a trend
+ * with no idea what changed between two points is a chart rather than an
+ * answer.
+ */
+export interface BenchmarkHistoryPoint {
+    benchmark_run_id: string;
+    run_id: string;
+    run_seq: number;
+    rule_id: string | null;
+    rule_name: string | null;
+    created_at: string;
+    candidate_score: number | null;
+    incumbent_score: number | null;
+    score_delta: number | null;
+    checkpoint_id: string | null;
+    decision: TrainingDecision | null;
+    status: BenchmarkRunStatus;
+    status_reason: string | null;
+}
+/** Where the conversations are copied FROM. Read once, at creation, never again. */
+export interface BenchmarkSource {
+    kind: BenchmarkSourceKind;
+    trace_ids?: string[];
+    dataset_id?: string;
+    split?: string;
+}
+/**
+ * The pin: 10 to 200 conversations, and a judge with a rubric to measure them.
+ *
+ * A conversation with nothing to ask a model is refused rather than skipped.
+ * Pinning 47 of the 50 somebody chose is the set being wrong from the first
+ * day, and they would never find out.
+ */
+export interface BenchmarkCreateParams {
+    name: string;
+    judge_id: string;
+    source: BenchmarkSource;
+    /** Absent uses the judge's own model, and absent that the workspace default. */
+    judge_model?: string;
+    /** What both models are given to answer in. A shorter answer is a different answer. */
+    max_tokens?: number;
+    per_run_ceiling_cents: number;
+}
+export interface BenchmarkListParams {
+    status?: BenchmarkStatus;
+    limit?: number;
+    offset?: number;
+}
+export interface BenchmarkItemListParams {
+    /** Capped at 100 by the service. */
+    limit?: number;
+    offset?: number;
+}
+export interface BenchmarkHistoryParams {
+    limit?: number;
+    offset?: number;
+}
+/** A reason is a courtesy here, not a requirement. */
+export interface BenchmarkRetireParams {
+    reason?: string;
+}
+/**
+ * Attach a benchmark to a rule, or detach it with a present null.
+ *
+ * Not optional, and not omittable: this route sets the field, so an absent key
+ * would be a request with nothing in it. Send the id to attach, null to detach.
+ */
+export interface TrainingRuleBenchmarkRequest {
+    benchmark_id: string | null;
+}
+export interface TrainingRuleListResponse {
+    rules: TrainingRule[];
+    total: number;
+}
+export interface TrainingRuleResponse {
+    rule: TrainingRule;
+    recent_runs: TrainingRunSummary[];
+    month_spent_cents: number;
+    judge_agreement: JudgeAgreement | null;
+}
+export interface TrainingRuleMutationResponse {
+    rule: TrainingRule;
+    /** The rule will not fire again until someone confirms the new amounts. */
+    consent_required: boolean;
+    preflight: TrainingRulePreflight | null;
+}
+export interface TrainingRuleDeleteResponse {
+    deleted: boolean;
+    rule_id: string;
+    /**
+     * The name this delete just spent. The delete is a soft delete and the name
+     * index carries no partial predicate, so the row goes on holding the name
+     * after it has left every list you can read, and no later rule in the
+     * workspace can be called that. There is no purge and no undelete.
+     */
+    retained_name: string;
+    cancelled_run_id: string | null;
+}
+export interface TrainingRunListResponse {
+    runs: TrainingRunSummary[];
+    total: number;
+}
+export interface TrainingRunResponse {
+    run: TrainingRun;
+    timeline: TrainingRunEvent[];
+    /**
+     * The standing benchmark's two absolute numbers for this run, beside the
+     * paired verdict and never in place of it. Null when no benchmark is
+     * attached to the rule.
+     */
+    benchmark: BenchmarkRun | null;
+    links: TrainingRunLinks;
+    available_actions: TrainingRunActions;
+}
+export interface TrainingRunActionResponse {
+    run: TrainingRun;
+    /** Set on rollback, the one action that changes what answers the traffic. */
+    serving: TrainingRuleServing | null;
+}
+export interface EvaluationItemsResponse {
+    items: EvaluationItem[];
+    total: number;
+}
+export interface AgentSettingsResponse {
+    settings: AgentSettings;
+}
+export interface InferenceAliasListResponse {
+    aliases: InferenceAlias[];
+}
+export interface InferenceAliasResponse {
+    alias: InferenceAlias;
+}
+export interface InferenceAliasDeleteResponse {
+    deleted: boolean;
+}
+export interface BenchmarkListResponse {
+    benchmarks: Benchmark[];
+    total: number;
+}
+export interface BenchmarkItemsResponse {
+    items: BenchmarkItem[];
+    total: number;
+}
+/** The trend, newest first. Every replay is a point, including the scoreless ones. */
+export interface BenchmarkHistoryResponse {
+    benchmark_id: string;
+    points: BenchmarkHistoryPoint[];
+    total: number;
+}