runbios-sdk 0.2.17-rc.269 → 0.2.18-dev.271

package/dist/resources/loop.d.ts

@@ -1,12 +1,18 @@
 import type { HttpClient } from '../client.js';
-import type { LoopTrace, LoopTraceListResponse, LoopTraceListParams, LoopCaptureParams, LoopCaptureResult, LoopImportParams, LoopImportResult, LoopSignal, LoopSignalParams, LoopCandidate, LoopCandidateParams, LoopGrader, LoopGraderParams, LoopLabel, LoopLabelCount, LoopGradeResult, LoopDataset, LoopDatasetListParams, LoopDatasetItem, LoopDatasetCreateParams, LoopConfig, LoopConfigParams, LoopBuildRule, LoopBuildRuleParams, LoopBuildRuleUpdateParams, LoopStats, LoopJudge, LoopJudgeParams, LoopAgentCredential, LoopAgentStatus, LoopSampleRun, LoopSampleRunParams, LoopJudgeRun, LoopJudgeRunItems, LoopJudgeRunItemStatus, LoopJudgeWork, LoopJudgeVerdict, LoopJudgeVerdictResult, TrainingRule, TrainingRulePreflight, TrainingRulePreflightRequest, TrainingRuleCreateRequest, TrainingRuleUpdateRequest, TrainingRuleConsentRequest, TrainingRuleListParams, TrainingRuleListResponse, TrainingRuleResponse, TrainingRuleMutationResponse, TrainingRuleDeleteResponse, TrainingRun, TrainingRunListParams, TrainingRunListResponse, TrainingRunResponse, TrainingRunActionResponse, TrainingRunPromoteRequest, TrainingRunRejectRequest, TrainingRunRollbackRequest, TrainingRunCancelRequest, Evaluation, EvaluationItemListParams, EvaluationItemsResponse, JudgeAgreement, JudgeAgreementParams, Benchmark, BenchmarkCreateParams, BenchmarkHistoryParams, BenchmarkHistoryResponse, BenchmarkItemListParams, BenchmarkItemsResponse, BenchmarkListParams, BenchmarkListResponse, BenchmarkRetireParams, BenchmarkRun, TrainingRuleBenchmarkRequest, AgentSettings, AgentSettingsRequest, Pipeline, PipelineListResponse } from '../types.js';
+import type { LoopTrace, LoopTraceListResponse, LoopTraceListParams, LoopCaptureParams, LoopCaptureResult, LoopImportParams, LoopImportResult, LoopSignal, LoopSignalParams, LoopLabel, LoopLabelCount, LoopConfig, LoopConfigParams, LoopStats, LoopTracePipelinesResponse, LoopMetricsHistory, LoopMetricsHistoryParams, TrainingRuleDeleteResponse, TrainingRunListParams, TrainingRunListResponse, TrainingRunResponse, TrainingRunActionResponse, TrainingRunPromoteRequest, TrainingRunRejectRequest, TrainingRunRollbackRequest, TrainingRunCancelRequest, Evaluation, EvaluationItemListParams, EvaluationItemsResponse, Benchmark, BenchmarkCreateParams, BenchmarkHistoryParams, BenchmarkHistoryResponse, BenchmarkItemListParams, BenchmarkItemsResponse, BenchmarkListParams, BenchmarkListResponse, BenchmarkRetireParams, BenchmarkRun, Pipeline, PipelineListParams, PipelineListResponse, PipelineWriteRequest, PipelineMutationResponse, LoopModelsResponse, PipelineImportParams, PipelineBenchmarksResponse, PipelineBenchmarkAttachParams, PipelineBenchmarkMoveParams, VersionCompareResponse, VersionCompareParams } from '../types.js';
 /**
- * The Conscious Loop -- capture what your model was asked and answered, record
- * whether it was right, and turn those judgements into training data.
+ * The Conscious Loop -- pipelines that keep improving a model from the
+ * conversations you send them.
  *
- * Nothing is captured until you turn it on for a source, and you can turn it
- * off again at any time. Anything that looks like a credential or a personal
- * detail is removed before the record is written, never afterwards.
+ * A pipeline is one use case: a model, the tags whose samples train it, when
+ * to train, and how a new version is promoted. Every time it trains it makes
+ * an attempt; an attempt that beats the live model becomes the next version.
+ *
+ * Nothing is captured until a source is switched on, and you can switch it
+ * off again at any time. Creating a pipeline switches on the source named by
+ * its own tag (`own_tag`), stamping that tag, and deleting it switches that
+ * source off again. Anything that looks like a credential or a personal detail
+ * is removed before the record is written, never afterwards.
  *
  * Requires an API key carrying `loop:read` and/or `loop:write`. Those scopes are
  * deliberately absent from the Read Only preset, because what they return is
@@ -19,28 +25,30 @@ import type { LoopTrace, LoopTraceListResponse, LoopTraceListParams, LoopCapture
  *
  * @example
  * ```ts
- * // 1. Decide that this source is recorded.
- * await client.loop.setConfig('my-agent', { enabled: true, retention_days: 30 });
+ * // 1. A pipeline: a model it can train, and its own tag.
+ * const { models } = await client.loop.listModels();
+ * const { pipeline } = await client.loop.createPipeline({
+ *   name: 'Support replies',
+ *   model: { id: models[0].id },
+ * });
  *
- * // 2. Send what your model was asked and what it answered. Works whoever
- * //    served it -- us, another provider, or your own servers.
- * const { trace_id } = await client.loop.capture({
- *   deployment_id: 'my-agent',
+ * // 2. Send samples from your app to the pipeline's own source: its create
+ * //    switched that source on, and it tags everything it records.
+ * const sent = await client.loop.capture({
+ *   deployment_id: pipeline.own_tag!,
  *   model: 'gpt-4o',
  *   messages: [{ role: 'user', content: 'what is our refund window' }],
  *   completion: 'thirty days',
  * });
  *
- * // 3. Say whether it was right. A rewrite is the most valuable answer here:
- * //    the model learns your version AND learns to avoid its own.
- * await client.loop.signal(trace_id, {
- *   verdict: 'edited',
- *   correction: 'Thirty days from delivery, no questions asked.',
- * });
+ * // 3. Say whether it was right, on the trace_id the capture answered with.
+ * //    A correction is the most valuable answer.
+ * if (sent.trace_id) {
+ *   await client.loop.correct(sent.trace_id, 'Thirty days from delivery, no questions asked.');
+ * }
  *
- * // 4. Turn the judgements into a training set and take the file.
- * const ds = await client.loop.createDataset({ name: 'support', method: 'sft' });
- * const jsonl = await client.loop.downloadDataset(ds.id);
+ * // 4. Once it has its minimum, it trains; versions appear on the pipeline.
+ * const p = await client.loop.getPipeline(pipeline.rule_id);
  * ```
  */
 export declare class Loop {
@@ -57,19 +65,25 @@ export declare class Loop {
      *
      * The returned `trace_id` is OURS. If you pass your own `request_id` it is
      * kept as an idempotency handle: sending the same one again returns the same
-     * trace rather than storing a second copy, so a retry is safe.
+     * trace rather than storing a second copy, so a retry is safe. Send feedback
+     * on that `trace_id`.
+     *
+     * `deployment_id` is the source. A pipeline's `own_tag` is a source its
+     * create switched on, and it stamps that tag on everything it records;
+     * `labels` add tags of your own, so the same conversation can feed other
+     * pipelines too.
      *
-     * When the source is not enabled this resolves with `captured: false` and a
-     * reason instead of throwing -- capture must never be the thing that breaks
-     * your application.
+     * When the source is not switched on this resolves with `captured: false`
+     * and a reason instead of throwing -- capture must never be the thing that
+     * breaks your application.
      */
     capture(params: LoopCaptureParams): Promise<LoopCaptureResult>;
     /**
      * Bring data you already have into the loop.
      *
-     * This does NOT create a training set. It creates conversations, in the same
-     * place captured ones live and subject to the same review, rules, judges and
-     * labels. A row becomes trainable when something says it is good, never
+     * This does NOT create a training set. It creates conversations (samples),
+     * in the same place captured ones live and subject to the same feedback and
+     * tags. A row becomes trainable when something says it is good, never
      * because it arrived in a file -- which is the one guarantee that separates
      * a corpus from a pile.
      *
@@ -190,36 +204,15 @@ export declare class Loop {
     /** Every verdict on one conversation, oldest first. */
     listSignals(traceId: string): Promise<LoopSignal[]>;
     /**
-     * Submit an alternative answer to a prompt already captured.
-     *
-     * This is what makes preference learning scale. A human rewrite is the best
-     * signal there is and the least available -- somebody has to sit down and
-     * write it. Sample the model several times for the same prompt, score the
-     * samples, and a DPO pair falls out automatically: best becomes chosen,
-     * worst becomes rejected. Point a stronger model at the prompt instead and
-     * the same machinery does distillation.
-     *
-     * Score them, or they cannot pair: an unscored alternative says nothing about
-     * which answer anybody prefers. `score_source` is required alongside a score,
-     * because precedence between a verifier, a judge and a person is the whole
-     * reason we record who judged.
-     *
-     * A human correction always outranks any score.
-     *
-     * @example
-     * ```ts
-     * for (const sample of await sampleMyModel(prompt, 4)) {
-     *   await client.loop.addCandidate(traceId, {
-     *     completion: sample.text,
-     *     score: await myVerifier(sample.text),
-     *     score_source: 'verifier',
-     *   });
-     * }
-     * ```
-     */
-    addCandidate(traceId: string, params: LoopCandidateParams): Promise<LoopCandidate>;
-    /** Every alternative answer recorded for one prompt, oldest first. */
-    listCandidates(traceId: string): Promise<LoopCandidate[]>;
+     * The pipelines one conversation feeds: every live pipeline whose tags
+     * select it, and whether each is switched on.
+     *
+     * Being listed means the pipeline would select it, not that it will be
+     * trained on -- a set still drops answers it cannot use and duplicates, and
+     * holds some back to judge by; `note` says so. An empty list is a real
+     * answer: the conversation trains nothing until it carries a pipeline's tag.
+     */
+    getTracePipelines(traceId: string): Promise<LoopTracePipelinesResponse>;
     /**
      * Label a conversation, so it can be selected later.
      *
@@ -273,139 +266,6 @@ export declare class Loop {
      * conversations in it that nobody had put there.
      */
     listLabels(): Promise<LoopLabelCount[]>;
-    /**
-     * Build a training set from the feedback recorded so far.
-     *
-     * The three methods need genuinely different things, so one set cannot be
-     * reshaped into another afterwards:
-     *
-     * - `sft` -- answers you marked right, and answers you rewrote.
-     * - `dpo` -- answers you REWROTE, so a better and a worse version of the same
-     *   reply exist. Nothing else produces a pair.
-     * - `grpo` -- answers with a value or fact they can be checked against, or
-     *   a judge rubric, which scores answers the run has not written yet.
-     * - `kto` -- anything carrying a yes or a no, INCLUDING a thumbs-down with
-     *   nothing written. That row trains nothing under the other three methods,
-     *   which is why this one exists: it is the feedback people actually give.
-     *
-     * `holdout_percent` holds back your most recent work rather than a random
-     * slice, so the evaluation measures whether the model generalised instead of
-     * memorised the same week.
-     *
-     * The result always reports `rejected_counts`: why rows were left out. A
-     * small set with a reason is useful; a small set without one is just alarming.
-     */
-    createDataset(params: LoopDatasetCreateParams): Promise<LoopDataset>;
-    /** List training sets, newest first. */
-    /**
-     * Stand up a rule that builds a set whenever enough new work exists.
-     *
-     * The manual path asks somebody to notice that enough conversations have
-     * been reviewed, remember which filters describe the slice they want, and
-     * press build — every time. A rule is that instruction, stored.
-     *
-     * `spec` is the same selection `createDataset` takes and is replayed
-     * verbatim, so an automatic set is identical to a hand-made one.
-     *
-     * `min_new_rows` counts only work reviewed SINCE THE LAST BUILD. Counting
-     * the whole corpus would fire the rule every interval forever, because a
-     * total that has crossed a threshold stays across it. It is at least 100,
-     * and 100 when absent: a set built from fewer is too small to learn from.
-     */
-    createBuildRule(params: LoopBuildRuleParams): Promise<LoopBuildRule>;
-    /**
-     * Every build rule, with what each one last did and why.
-     *
-     * `last_reason` is the field worth reading: a rule quiet because it is
-     * waiting looks exactly like one quiet because it is broken.
-     */
-    listBuildRules(): Promise<LoopBuildRule[]>;
-    /** Stop a standing build rule. Sets it already produced are untouched. */
-    deleteBuildRule(id: string): Promise<{
-        deleted: boolean;
-    }>;
-    listDatasets(params?: LoopDatasetListParams): Promise<LoopDataset[]>;
-    /** Read one training set and its curation report. */
-    getDataset(id: string): Promise<LoopDataset>;
-    /**
-     * Page through the rows a training set actually contains.
-     *
-     * Worth reading before you spend money on a run: each row carries the address
-     * of the conversation it was built from.
-     */
-    listDatasetItems(id: string, params?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<LoopDatasetItem[]>;
-    /**
-     * Download a training set as JSONL -- one training row per line, the format
-     * every trainer in this space reads.
-     *
-     * `split` defaults to the training rows; pass `holdout` for the slice held
-     * back, or `all` for both.
-     */
-    downloadDataset(id: string, split?: 'train' | 'holdout' | 'all'): Promise<string>;
-    /**
-     * Delete a training set.
-     *
-     * The conversations it was built from are untouched -- a set is a selection,
-     * and discarding the selection must not discard the evidence. A set a
-     * training run was trained on is refused `409 DATASET_IN_USE` and kept, as
-     * the record of what that run learned from. See
-     * `LoopDatasetDeleteRefusalCode`.
-     */
-    deleteDataset(id: string): Promise<{
-        deleted: boolean;
-        dataset_id: string;
-    }>;
-    /**
-     * Write a rule that scores answers without a person.
-     *
-     * Human review is the most trustworthy feedback and the least available. A
-     * grader is written once and applied to every answer afterwards: did it
-     * contain the required phrase, did it parse as the schema you asked for, is
-     * the number within tolerance of the known answer, did it call the function
-     * it should have.
-     *
-     * Every kind here is DETERMINISTIC -- no model call, no network. That is why
-     * a verifier outranks a judge when they disagree: it cannot be flattered and
-     * it cannot drift between runs.
-     *
-     * `weight` is the multiplier: a criterion that matters twice as much gets
-     * twice the weight, and the combined score is the weighted mean over the
-     * rules that actually applied.
-     *
-     * `matches_gold` needs no `expected`: it compares each answer to the gold
-     * answer recorded on that same conversation, or the human correction when
-     * there is no gold, and scores sampled alternatives against the same gold.
-     * A conversation with neither is skipped, not failed, so one rule checks
-     * every labelled question without punishing the unlabelled ones. An
-     * optional `tolerance` widens the match when both sides are bare numbers.
-     *
-     * A caution worth knowing before you write a set: a rule made only of
-     * `forbidden` phrases is satisfied VACUOUSLY by an answer that says nothing.
-     * Pair it with a `required` phrase, or you are rewarding silence.
-     */
-    createGrader(params: LoopGraderParams): Promise<LoopGrader>;
-    /** Every rule this workspace has written. */
-    listGraders(): Promise<LoopGrader[]>;
-    deleteGrader(id: string): Promise<{
-        deleted: boolean;
-        grader_id: string;
-    }>;
-    /**
-     * Apply this workspace's rules to one captured answer AND to every
-     * alternative sampled for it.
-     *
-     * Grading both in one pass is the point: scoring only the original gives a
-     * verdict, while scoring the samples as well gives the preference pair. Sample
-     * your model, call this, and you have DPO data with nobody reading anything.
-     *
-     * A run where no rule could apply writes NOTHING -- no verdict, no scores.
-     * Recording a zero that no rule produced would poison curation with a
-     * judgement nobody reached, so `applied: 0` is reported instead.
-     */
-    grade(traceId: string): Promise<LoopGradeResult>;
     /** Every source this workspace has configured. */
     listConfigs(): Promise<LoopConfig[]>;
     /**
@@ -425,299 +285,23 @@ export declare class Loop {
      */
     setConfig(source: string, params: LoopConfigParams): Promise<LoopConfig>;
     /**
-     * How much there is, and how much of it each method could actually use.
+     * How much there is, and how many samples a pipeline could train on now
+     * (`ready.sft`: the ones marked good or corrected).
      *
-     * The `ready` numbers are upper bounds: duplicate questions are folded into
-     * one row while a set is built, so the finished count can be lower.
+     * `ready.sft` is an upper bound: duplicates, the held-back set and
+     * conversations too long to train on come out of it when an attempt trains.
      */
     stats(): Promise<LoopStats>;
-    /** Write a rubric: what makes an answer good here, and what to score. */
-    createJudge(params: LoopJudgeParams): Promise<LoopJudge>;
-    listJudges(): Promise<LoopJudge[]>;
     /**
-     * Rewrite a rubric. Runs already recorded keep the instructions they used:
-     * a verdict has to keep meaning what it meant when it was given.
+     * How the loop moved over time: every attempt as a point, oldest first --
+     * its attempt number, the version it became (null when it did not), its
+     * base model, its win rate, what it cost -- and each day's feedback counted
+     * by verdict. `rule_id` narrows the attempts to one pipeline; the feedback
+     * counts are the workspace's. `truncated` says older attempts exist beyond
+     * `limit`.
      */
-    updateJudge(judgeId: string, params: LoopJudgeParams): Promise<LoopJudge>;
-    /**
-     * Retire a rubric. Its runs go with it; the verdicts they wrote stay. A score
-     * is evidence about an answer, and it does not stop being true because the
-     * rubric was retired.
-     */
-    deleteJudge(judgeId: string): Promise<void>;
-    /**
-     * Open a run: select the conversations now, and freeze the rubric onto them.
-     *
-     * The selection is fixed at this moment on purpose. A run whose selection is
-     * a live query silently grows as conversations arrive, so "we scored the
-     * refunds slice" becomes a claim about a set that no longer exists.
-     */
-    startRun(judgeId: string, limit?: number): Promise<LoopJudgeRun>;
-    listRuns(judgeId?: string): Promise<LoopJudgeRun[]>;
-    getRun(runId: string): Promise<LoopJudgeRun>;
-    /**
-     * Take the next conversations to score, each rendered into a ready-to-send
-     * prompt. Nothing is marked taken, so a caller that dies half way loses
-     * nothing: ask again and the same items come back.
-     */
-    takeWork(runId: string, limit?: number): Promise<LoopJudgeWork>;
-    /**
-     * What happened to each conversation in a run, and why.
-     *
-     * `takeWork` hands out what is still PENDING, so a finished run answers it
-     * with an empty list. This answers with every item and the outcome on it:
-     * `status`, `scored_at`, and `error` — the reason the caller gave for an
-     * item it could not score, which is where a wrong model slug or a refused
-     * key actually shows up. A run that ends "scored 0, failed 3" is otherwise a
-     * number with no detail behind it.
-     *
-     * Pass `status: 'failed'` for the usual question. At most 500 items come
-     * back at a time; when `has_more` is true, call again with the `next_offset`
-     * from the reply.
-     */
-    listRunItems(runId: string, opts?: {
-        status?: LoopJudgeRunItemStatus;
-        limit?: number;
-        offset?: number;
-    }): Promise<LoopJudgeRunItems>;
-    /**
-     * Hand the scores back. A verdict for a conversation outside this run, or
-     * scoring something the rubric never asked for, is refused and reported in
-     * `rejected` rather than silently dropped.
-     *
-     * Pass `finish` to close the run in the same call once you have nothing left
-     * to send. To close a run WITHOUT scores, call `stopRun`: an empty verdict
-     * list with `finish` does the same thing and reads like a mistake.
-     */
-    postVerdicts(runId: string, verdicts: LoopJudgeVerdict[], finish?: boolean): Promise<LoopJudgeVerdictResult>;
-    /**
-     * Close a run that has not finished.
-     *
-     * A judge may have one open run of its own at a time, so an open run BLOCKS
-     * the next one, and the runs that most need closing are the ones nobody can
-     * wait out: a run the agent has parked on an empty balance or a refused key
-     * stays open until the reason is fixed or somebody stops it.
-     *
-     * Nothing is deleted. Every verdict already recorded stays recorded, the
-     * counters keep saying how much of the selection was covered, and the
-     * conversations the run was holding are free for the next one. The run ends
-     * as `stopped` rather than `done`, so an interrupted pass and a completed
-     * one do not read alike.
-     *
-     * A run that finished on its own is not rewritten: stopping one answers 409.
-     *
-     * Returns the stopped run itself, like `startRun` and `getRun`, not the
-     * `{run}` envelope the service sends. Every other single-run method in this
-     * class unwraps, and `Loop.stop_run` in the Python SDK does too, so a
-     * caller who wrote `(await loop.stopRun(id)).status` against one of its
-     * siblings is right here as well.
-     */
-    stopRun(runId: string): Promise<LoopJudgeRun>;
-    /**
-     * Can an agent run here, is one running, and is it on for this workspace.
-     * `available` is about the environment; `online` about the worker;
-     * `credential` about this workspace.
-     */
-    agentStatus(): Promise<LoopAgentStatus>;
-    /**
-     * Turn the agent on: mints the workspace's managed serverless key and
-     * resumes the automatic judges a previous turn-off paused. After this,
-     * automatic judges and sample runs make model calls billed to the
-     * workspace. Idempotent.
-     *
-     * A judge whose model the serving gateway will not route is NOT resumed:
-     * making it automatic would buy a run that fails every conversation. It
-     * stays paused, `judges_still_paused` counts those, and each one carries
-     * `auto_pause_reason` saying so. Point it at a model that is served and
-     * turn the agent on again.
-     *
-     * `monthly_spend_cap_cents` caps what that key may spend on model calls in
-     * a calendar month. Omitted = no cap on a fresh key, and an existing cap is
-     * left as it is; sent while the agent is already on, it moves the cap on
-     * the existing key without minting a new one. When the cap is reached the
-     * agent's model calls are refused until next month and its runs pause with
-     * that reason.
-     */
-    enableAgent(opts?: {
-        monthly_spend_cap_cents?: number;
-    }): Promise<LoopAgentCredential>;
-    /**
-     * Turn the agent off: revokes its key and pauses every automatic judge in
-     * the workspace (`judges_paused`; each judge shows `auto_paused`). Turning
-     * it back on resumes exactly those judges. Open runs stop where they are
-     * and continue if it is turned back on. Nothing already scored or written
-     * is removed.
-     */
-    disableAgent(): Promise<{
-        revoked: boolean;
-        judges_paused: number;
-        message: string;
-    }>;
-    /**
-     * Ask the agent to write `n` alternative answers to each conversation in a
-     * slice with `model`, score each with `judge_id`, and store them as
-     * candidates. This is how preference pairs are made without a person
-     * writing each one: the curation pass pairs the best sample against the
-     * worst wherever the gap is real.
-     *
-     * Cost: up to `n` calls to write plus `n` to judge, per conversation, at the
-     * workspace's serverless rate; `selection.sample` caps the conversations
-     * (max 200) and `n` is capped at 8. Opening a run turns the agent on if it
-     * is off.
-     */
-    createSampleRun(params: LoopSampleRunParams): Promise<LoopSampleRun>;
-    listSampleRuns(): Promise<LoopSampleRun[]>;
-    getSampleRun(runId: string): Promise<LoopSampleRun>;
-    /**
-     * Price a training rule before anyone agrees to it. Writes nothing.
-     *
-     * Takes the create body without `accept_terms` and answers with the estimate
-     * a member has to see first: the pinned model revision, the worst hourly
-     * price each GPU ladder can reach, how many hours each ceiling buys, any
-     * refusals that would stop a create, the API keys that cannot follow a
-     * cutover because they lack `deployments:read`, and `terms_text` -- the
-     * exact sentence to show, with real figures in it.
-     *
-     * Send the `terms_version` it returns back in `createTrainingRule`. Read the
-     * figures out of this response rather than inventing ceilings of your own.
-     *
-     * `valid: false` with an EMPTY `refusals` list is not nothing: check
-     * `unreachable`, which names every peer the platform could not reach. The
-     * rule is savable in that state and would be paused, but the estimate around
-     * it is not trustworthy -- both `worst_hourly_*` are `0`, and so are both
-     * `max_*_hours` beside them -- so do not quote those figures to anyone.
-     * `model_revision` is empty unless training-service actually pinned a
-     * commit; test `unreachable.length > 0` to tell a degraded pass from a
-     * refusal.
-     *
-     * A `TRAINING_NOT_ENABLED` refusal is neither: training is in beta and this
-     * organisation does not hold the grant. It is in `refusals`, never in
-     * `unreachable`, and nothing in the request can lift it.
-     */
-    preflightTrainingRule(params: TrainingRulePreflightRequest): Promise<TrainingRulePreflight>;
-    /**
-     * Create a training rule and record the consent that pays for it.
-     *
-     * ACCEPTING THE TERMS AUTHORISES SPENDING FROM YOUR WALLET WHILE YOU ARE NOT
-     * PRESENT. From here on the platform may, on its own schedule and without
-     * asking again, build a training set, run a training job on rented GPUs,
-     * book a second deployment to compare against the one serving your traffic,
-     * and pay for the model calls that judge the two. Those charges come out of
-     * the wallet of the member whose credentials make this call, up to the
-     * ceilings in `money`, and they keep recurring for as long as the rule is
-     * enabled. If `promotion.auto_promote` is set, the platform will also
-     * re-point your public handle at the new model with nobody reviewing it.
-     *
-     * `accept_terms` is therefore required, and this method refuses to send the
-     * request without it rather than letting the server decide. Call
-     * {@link preflightTrainingRule} first, show the person whose wallet pays the
-     * `terms_text` and the figures it returns, get an explicit yes, and send the
-     * `terms_version` they were shown. Do not invent ceilings or price caps on
-     * their behalf.
-     *
-     * Refused `409 TRAINING_NOT_ENABLED`, with nothing saved, while training is
-     * in beta and this organisation does not hold the grant: do not retry, ask
-     * the platform team to enable it. See `TrainingRuleSaveRefusalCode`.
-     *
-     * @example
-     * ```ts
-     * const estimate = await client.loop.preflightTrainingRule(draft);
-     * // show estimate.terms_text and the ceilings to the member, get a yes
-     * const rule = await client.loop.createTrainingRule({
-     *   ...draft,
-     *   accept_terms: { terms_version: estimate.terms_version },
-     * });
-     * ```
-     */
-    createTrainingRule(params: TrainingRuleCreateRequest): Promise<TrainingRule>;
-    /**
-     * Every training rule in the workspace, with what each one last did and why.
-     *
-     * `last_reason` and `paused_reason` are the fields worth reading: a rule
-     * quiet because it is waiting looks exactly like one quiet because its
-     * consent went stale.
-     */
-    listTrainingRules(params?: TrainingRuleListParams): Promise<TrainingRuleListResponse>;
-    /**
-     * Read one rule with its recent runs, what its runs this month have cost at
-     * most, and how far its judge agrees with your own reviewers.
-     *
-     * Returned whole rather than unwrapped to the rule: `month_spent_cents` is
-     * the number that says whether the monthly ceiling is about to stop it. It
-     * is an upper bound, not an exact spend: see `Pipeline.month_spent_cents`.
-     */
-    getTrainingRule(id: string): Promise<TrainingRuleResponse>;
-    /**
-     * Edit or pause a rule. Absent means unchanged; a null clears the fields
-     * that can be cleared.
-     *
-     * A money-bearing change -- a ceiling, a model, a GPU ladder, the promotion
-     * policy, or changing `explore_recipes` in EITHER direction -- bumps
-     * `revision`, clears the recorded consent and STOPS the rule firing until
-     * someone accepts the new amounts. Turning recipe variants OFF does this
-     * too: the pipeline then makes no version at all, variant or not, until the
-     * terms are accepted again. The reply says so in
-     * `consent_required`, and carries a fresh `preflight` with the new figures.
-     * Pass `expected_revision` to be refused with `REVISION_MISMATCH` rather
-     * than overwrite an edit somebody else made in the meantime.
-     *
-     * Switching a rule on, switching it into preference training or carrying
-     * `accept_terms` re-runs the preflight, and can be refused
-     * `409 TRAINING_NOT_ENABLED` like a create. A rule paused
-     * `training_not_enabled` is started again by a save of it once the
-     * organisation has been enabled.
-     */
-    updateTrainingRule(id: string, params: TrainingRuleUpdateRequest): Promise<TrainingRuleMutationResponse>;
-    /**
-     * Accept the rule's current terms, so it may fire again.
-     *
-     * ACCEPTING THE TERMS AUTHORISES SPENDING FROM YOUR WALLET WHILE YOU ARE NOT
-     * PRESENT, on the amounts as they stand right now. This is the same
-     * authorisation {@link createTrainingRule} records, given again because a
-     * money-bearing edit cleared the old one: training, a candidate deployment
-     * and the judge's model calls are charged to the wallet of the member making
-     * this call, up to the rule's ceilings, every time it fires.
-     *
-     * Show the member the current `terms_text` from a fresh
-     * {@link preflightTrainingRule} or from the `preflight` on the update reply,
-     * and send the `revision` those figures belong to. A stale revision is
-     * refused with `409`, which is the point: it means the amounts moved again
-     * after they were read. `409 TRAINING_NOT_ENABLED` means training is in beta
-     * and this organisation does not hold the grant.
-     */
-    consentTrainingRule(id: string, params: TrainingRuleConsentRequest): Promise<TrainingRule>;
-    /**
-     * Fire a rule now, without waiting for its cadence.
-     *
-     * Bypasses the schedule and `min_new_rows` only. The row floors, the money
-     * ceilings, the consent, the version limit and the monthly limit all still
-     * apply, so this can answer `409 CONSENT_REQUIRED`, `409 RULE_PAUSED`,
-     * `409 RUN_ACTIVE`, `409 VERSION_LIMIT_REACHED` (the pipeline has made
-     * `max_versions` versions), `409 MONTHLY_LIMIT_REACHED` (the most this
-     * month's runs can have cost plus the most one run may cost would pass the
-     * monthly limit; the error
-     * body carries `month_spent_cents`, `monthly_ceiling_cents`, `run_max_cents`
-     * and `resumes_at`), `409 AGENT_OFF` (the workspace's Conscious Loop agent
-     * is not turned on, so a trained model could not be compared) or
-     * `422 NOT_ENOUGH_ROWS` with the counts it needed. See
-     * `TrainingRuleRunRefusalCode`.
-     */
-    runTrainingRule(id: string): Promise<TrainingRun>;
-    /**
-     * Delete a rule. An active run is cancelled; runs that already finished, and
-     * anything already promoted, are kept.
-     */
-    deleteTrainingRule(id: string): Promise<TrainingRuleDeleteResponse>;
-    /**
-     * Edit or pause a build rule -- the standing instruction that assembles the
-     * training set a training rule then trains on.
-     *
-     * Changing `spec.deployment_id` while an enabled training rule owns this
-     * build rule is refused with `409`: it would silently retrain the next model
-     * on a different source's conversations.
-     */
-    updateBuildRule(id: string, params: LoopBuildRuleUpdateParams): Promise<LoopBuildRule>;
-    /** Firings, newest first. Filter by rule or by the state they are sitting in. */
+    getMetricsHistory(params?: LoopMetricsHistoryParams): Promise<LoopMetricsHistory>;
+    /** Attempts, newest first. Filter by pipeline (`rule_id`) or by the state they are sitting in. */
     listTrainingRuns(params?: TrainingRunListParams): Promise<TrainingRunListResponse>;
     /**
      * One run with its timeline, the addresses of everything it created, and
@@ -756,24 +340,19 @@ export declare class Loop {
      */
     cancelTrainingRun(id: string, params?: TrainingRunCancelRequest): Promise<TrainingRunActionResponse>;
     /**
-     * Every training rule in the workspace, seen as the series of versions it
-     * produced: which exist, which one serves (`champion_version`), how each did
-     * against the champion of its day and on the standing benchmark, the run in
-     * flight and which version it will be, and what the pipeline is waiting for.
-     *
-     * Read-only. Every decision stays on the route that owns it -- promote,
-     * reject and roll back on the run, the version limit and `explore_recipes`
-     * on the rule.
+     * Every pipeline in the workspace: its versions (the attempts that became
+     * the live model), every attempt, which version is live, the attempt in
+     * flight, and what the pipeline is waiting for.
      *
      * RETURNED WITH ITS ENVELOPE, because the list is not always all of them:
-     * the service returns the newest 100, `total` is every pipeline in the
-     * workspace and `truncated` is true when more exist than were returned. A
-     * caller that shows `pipelines` alone presents a short list as the whole of
-     * it. The rest are reached through `listTrainingRules`, which pages.
+     * the service returns a page of 100, newest first, `total` is every
+     * pipeline in the workspace and `truncated` is true when more exist after
+     * this page. A caller that shows `pipelines` alone presents a short list as
+     * the whole of it; the next page is `{ offset: offset + pipelines.length }`.
      */
-    listPipelines(): Promise<PipelineListResponse>;
+    listPipelines(params?: PipelineListParams): Promise<PipelineListResponse>;
     /**
-     * One pipeline, by its training rule's id.
+     * One pipeline, by its id.
      *
      * `status` says whether it is the platform working (`running`), the member
      * who has to act (`needs_review`, `needs_funds`), or nothing at all until
@@ -783,9 +362,71 @@ export declare class Loop {
      * at most, not an exact spend.
      */
     getPipeline(id: string): Promise<Pipeline>;
+    /**
+     * The base models a pipeline can train: only those the engine trains with
+     * LoRA SFT and the platform can serve for the comparison, recommended first.
+     * The one list {@link createPipeline} accepts a `model.id` from, with the
+     * `floors` a new pipeline is held to: the samples its first attempt needs and
+     * the smallest `train_when.min_samples`.
+     */
+    listModels(): Promise<LoopModelsResponse>;
+    /**
+     * Create a pipeline -- one use case.
+     *
+     * SAVING IT AUTHORISES SPENDING FROM YOUR WALLET WHILE YOU ARE NOT PRESENT:
+     * whenever its data has grown enough (and at its schedule, when it has one),
+     * the platform trains a new version on GPUs it chooses, compares it with what
+     * serves your traffic, and promotes it by the pipeline's promotion policy.
+     * What is charged is the GPU time the runs actually use; the platform's own
+     * per-run and monthly limits stop a run that goes wrong.
+     */
+    createPipeline(params: PipelineWriteRequest): Promise<PipelineMutationResponse>;
+    /**
+     * Edit a pipeline. Only the fields sent change; `max_versions: null` removes
+     * the limit and `challenger_model: null` removes the challenger. `promotion`
+     * is how the promotion policy is set. Saving is the authorization, as on a
+     * create.
+     */
+    updatePipeline(id: string, params: PipelineWriteRequest): Promise<PipelineMutationResponse>;
+    /**
+     * Delete a pipeline: an attempt still running is cancelled; the versions it
+     * made, what serves your app, and its samples and tags are kept. Recording
+     * to its own tag stops.
+     */
+    deletePipeline(id: string): Promise<TrainingRuleDeleteResponse>;
+    /**
+     * Train now: skips the schedule, never the minimum. A pipeline short of its
+     * samples is refused 422 `NOT_ENOUGH_SAMPLES` with `have` and `need` -- the
+     * numbers `minimums` shows. 503 `AGENT_COULD_NOT_START` means the key the
+     * attempt would be scored with could not be renewed just then: nothing was
+     * started, so press train now again in a minute. Every refusal is a
+     * `TrainingRuleRunRefusalCode`.
+     */
+    runPipeline(id: string): Promise<PipelineMutationResponse>;
+    /**
+     * {@link importRows}, with every row given the pipeline's own tag. `source`
+     * defaults to that tag; the rows, the answer and the retry rules are the
+     * import door's own. `default_feedback: 'good'` records every answered row
+     * that brought no verdict of its own as a good example to learn from.
+     */
+    importIntoPipeline(id: string, params: PipelineImportParams): Promise<LoopImportResult>;
+    /** The pipeline's benchmarks in priority order (1 is the primary), the ones it stopped using, and its promotion policy. */
+    listPipelineBenchmarks(id: string): Promise<PipelineBenchmarksResponse>;
+    /** Add a benchmark to a pipeline, last unless `priority` says where. Every version from now on is replayed on it. */
+    attachPipelineBenchmark(id: string, params: PipelineBenchmarkAttachParams): Promise<PipelineBenchmarksResponse>;
+    /** Move a benchmark on a pipeline's list; priority 1 makes it the primary. */
+    movePipelineBenchmark(id: string, benchmarkId: string, params: PipelineBenchmarkMoveParams): Promise<PipelineBenchmarksResponse>;
+    /** Stop using a benchmark. Every score it produced is kept. */
+    removePipelineBenchmark(id: string, benchmarkId: string): Promise<PipelineBenchmarksResponse>;
+    /**
+     * Every version's scores side by side: its head-to-head and every benchmark,
+     * `not_measured` where a benchmark was added after it. `a` and `b` are
+     * VERSION numbers; with both, `differences` says b minus a per benchmark.
+     */
+    compareVersions(id: string, params?: VersionCompareParams): Promise<VersionCompareResponse>;
     /**
      * The comparison behind a verdict: both models on the same held-out rows,
-     * with identical decoding, judge and grader names resolved.
+     * with identical decoding, scored by the same judge.
      *
      * Read `warnings` before you read `win_rate`. A win rate over a holdout too
      * small to mean anything, or one measured by a judge that disagrees with
@@ -799,20 +440,12 @@ export declare class Loop {
      * The paired conversations behind the numbers: one prompt, both answers, the
      * scores each earned, and which won.
      *
-     * Filter by `winner` to read the losses first, which is where a verdict is
-     * actually checked. `limit` is capped at 100 by the service.
+     * Filter by `winner` -- `candidate` (the attempt won), `serving` (the version
+     * serving today won; the item itself says `incumbent`) or `tie` -- and read
+     * `serving` first: the pairs the attempt lost are where a verdict is actually
+     * checked. `limit` is 50 when absent and at most 200.
      */
     listEvaluationItems(id: string, params?: EvaluationItemListParams): Promise<EvaluationItemsResponse>;
-    /**
-     * How far a judge agrees with your own reviewers, over the conversations
-     * both have scored.
-     *
-     * This is a gate, not a badge: a rule's `min_judge_agreement` refuses to
-     * promote on the word of a judge that does not agree with the people whose
-     * product it is. `enough_pairs` is the field to read first -- "not enough
-     * reviewer overlap yet" is an answer, and 100% of two pairs is not.
-     */
-    getJudgeAgreement(judgeId: string, params?: JudgeAgreementParams): Promise<JudgeAgreement>;
     /**
      * Pin a fixed set of conversations, with a judge frozen beside them, and
      * measure every future run against it.
@@ -828,9 +461,10 @@ export declare class Loop {
      * is refused rather than skipped, because pinning 47 of the 50 you chose is
      * the set being wrong from the first day and you would never find out.
      *
-     * It raises no amount you have already agreed to. The replay's calls come
-     * out of the rule's existing `eval_ceiling_cents`, and
-     * `per_run_ceiling_cents` can only lower what is spent inside that.
+     * The platform freezes the judge and the model it scores on (the ones every
+     * pipeline comparison uses), gives both models the comparison's own answer
+     * length, and sets what one replay may spend, inside the attempt's own
+     * scoring limit; none of that is sent.
      */
     createBenchmark(params: BenchmarkCreateParams): Promise<Benchmark>;
     /** Your benchmarks, newest first. Filter by `status` to hide retired ones. */
@@ -845,7 +479,7 @@ export declare class Loop {
      */
     getBenchmark(id: string): Promise<Benchmark>;
     /**
-     * The pinned conversations, paged. `limit` is capped at 100 by the service.
+     * The pinned conversations, paged. `limit` is 50 when absent and at most 200.
      *
      * `source_trace_id` and `source_trace_url` come back null once the
      * conversation a row was copied from has been deleted. The row itself stays
@@ -864,7 +498,7 @@ export declare class Loop {
      */
     getBenchmarkHistory(id: string, params?: BenchmarkHistoryParams): Promise<BenchmarkHistoryResponse>;
     /**
-     * Stop replaying a benchmark, and detach it from every rule that names it.
+     * Stop replaying a benchmark, and detach it from every pipeline using it.
      *
      * Nothing measured is removed. There is no delete and no update on purpose:
      * the series of numbers measured against a set is what a benchmark is for,
@@ -888,36 +522,4 @@ export declare class Loop {
      * different set, which is the exact defect a standing benchmark removes.
      */
     getBenchmarkRun(id: string): Promise<BenchmarkRun>;
-    /**
-     * Attach a benchmark to a rule, or send `{ benchmark_id: null }` to detach
-     * it.
-     *
-     * Its own route rather than a field on the rule body, because it is a
-     * decision to replay a fixed set on every future run of this rule for as
-     * long as it stands, and its refusals -- retired, or belonging to another
-     * workspace -- are about the benchmark rather than about the rule.
-     *
-     * It does not invalidate consent and the reply says so: attaching raises
-     * neither the amount set aside for judge calls nor the amount set aside for
-     * keeping the new model available, so nobody is asked to read the same
-     * sentence again. A retired benchmark is refused with `BENCHMARK_RETIRED`,
-     * because a rule pointed at one would report no number on every run and say
-     * nothing about why.
-     */
-    setTrainingRuleBenchmark(id: string, params: TrainingRuleBenchmarkRequest): Promise<TrainingRuleMutationResponse>;
-    /**
-     * The workspace's agent options: which model it defaults to, the system
-     * prompts it judges and samples with, and the monthly cap on what its model
-     * calls may spend.
-     */
-    getAgentSettings(): Promise<AgentSettings>;
-    /**
-     * Change them. An absent key leaves that setting exactly where it is; a
-     * present null returns it to the platform default. Those are three
-     * instructions, not two, so `{}` changes nothing.
-     *
-     * `eval_monthly_cap_cents` is pushed to the workspace's managed key, so it
-     * caps what the agent can spend even if a rule's own ceilings are higher.
-     */
-    updateAgentSettings(params: AgentSettingsRequest): Promise<AgentSettings>;
 }