runbios-sdk 0.2.1-dev.137 → 0.2.1-dev.140

package/dist/index.d.ts

@@ -36,7 +36,7 @@ import { Loop } from './resources/loop.js';
  * SDK version. Sent as part of the User-Agent header.
  * Must match package.json "version" -- enforced by a contract test.
  */
-export declare const VERSION = "0.2.1-dev.137";
+export declare const VERSION = "0.2.1-dev.140";
 export declare class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     readonly models: Models;
@@ -75,4 +75,6 @@ export { Training } from './resources/training.js';
 export { Wallet } from './resources/wallet.js';
 export { GPU, type GPURecommendation } from './resources/gpu.js';
 export { Inference, validateChatRequest, parseSSE, buildInferenceRequest, contextSizingBasis, type ContextSizingBasis, CONTEXT_DEFAULT_CEILING, CONTEXT_EDITABLE_FLOOR, type ChatMessage, type FunctionTool, type ChatCompletionParams, type ChatCompletionResponse, type ChatCompletionChunk, } from './resources/inference.js';
-export type { BiOSConfig, PaginatedResponse, ApiErrorBody, AvailableGpuAlternative, CapacityMinimumRequirement, InferenceBookingAccepted, Model, ModelSearchParams, ModelSearchResponse, ModelDetailResponse, ModelConfig, Dataset, DatasetListParams, DatasetListResponse, DatasetUploadParams, DatasetPreview, DatasetPreviewParams, DatasetImportHFParams, DatasetRegisterHFParams, DatasetHubSearchParams, DatasetHubPreviewParams, DatasetValidation, DatasetFormatVariant, DatasetFormatSpec, DatasetFormatSpecs, DatasetStorageUsage, TrainingMethod, RLHFAlgorithm, AdapterType, TrainingJobStatus, TrainingStatusFilter, TrainingCreateParams, TrainingListParams, TrainingListResponse, TrainingJob, TrainingMetrics, TrainingResourceMetrics, TrainingDeviceMetrics, MetricPoint, MetricGraphConfig, TrainingCheckpoint, TrainingLogs, TrainingLogEntry, TrainingStopResponse, TrainingResumeResponse, CanonicalTrainingRequest, TrainingPreflightDataset, TrainingPreflightWarning, TrainingPreflightResponse, TrainingCapabilityChoice, TrainingConfigFieldCapability, TrainingCapabilities, GPUChoice, WalletBalance, Transaction, TransactionListResponse, TransactionListParams, GPUInfo, GPUPricingResponse, GPUOptionsParams, TrainingRecommendParams, TrainingAdvisorVerdict, TrainingAdvisorRecommendation, TrainingAdvisorUserShape, TrainingAdvisorJustification, TrainingAdvisorBasis, GPUOption, GPUOptionSuggestion, GPUOptionsResponse, InferenceStatus, InferenceCreateParams, InferenceUpdateParams, InferenceDeployment, InferenceDeploymentSummary, InferenceCreateResponse, InferenceListResponse, InferenceUpdateResponse, InferenceLifecycleResponse, InferenceDeleteResponse, InferenceGPUOptionMarket, InferenceGPUOption, InferenceGPUAlternative, InferenceGPUOptionsParams, InferenceGPUOptionsResponse, InferenceCanonicalRequest, InferencePreflightWarning, InferencePreflightResponse, AdapterCompatibility, AdapterCompatibilityResponse, AdapterCompatibilityParams, SupportedArchitecture, ArchitectureScope, SupportedArchitecturesResponse, ApiKey, ApiKeyScope, ApiKeyIntrospection, Organization, OrgMember, OrgInvite, Workspace, Integration, IntegrationCreateParams, StorageUsage, StorageObject, PromptTokensDetails, ChatCompletionUsage, } from './types.js';
+export type { BiOSConfig, PaginatedResponse, ApiErrorBody, AvailableGpuAlternative, CapacityMinimumRequirement, InferenceBookingAccepted, Model, ModelSearchParams, ModelSearchResponse, ModelDetailResponse, ModelConfig, Dataset, DatasetListParams, DatasetListResponse, DatasetUploadParams, DatasetPreview, DatasetPreviewParams, DatasetImportHFParams, DatasetRegisterHFParams, DatasetHubSearchParams, DatasetHubPreviewParams, DatasetValidation, DatasetFormatVariant, DatasetFormatSpec, DatasetFormatSpecs, DatasetStorageUsage, TrainingMethod, RLHFAlgorithm, AdapterType, TrainingJobStatus, TrainingStatusFilter, TrainingCreateParams, TrainingListParams, TrainingListResponse, TrainingJob, TrainingMetrics, TrainingResourceMetrics, TrainingDeviceMetrics, MetricPoint, MetricGraphConfig, TrainingCheckpoint, TrainingLogs, TrainingLogEntry, TrainingStopResponse, TrainingResumeResponse, CanonicalTrainingRequest, TrainingPreflightDataset, TrainingPreflightWarning, TrainingPreflightResponse, TrainingCapabilityChoice, TrainingConfigFieldCapability, TrainingCapabilities, GPUChoice, WalletBalance, Transaction, TransactionListResponse, TransactionListParams, GPUInfo, GPUPricingResponse, GPUOptionsParams, TrainingRecommendParams, TrainingAdvisorVerdict, TrainingAdvisorRecommendation, TrainingAdvisorUserShape, TrainingAdvisorJustification, TrainingAdvisorBasis, GPUOption, GPUOptionSuggestion, GPUOptionsResponse, InferenceStatus, InferenceCreateParams, InferenceUpdateParams, InferenceDeployment, InferenceDeploymentSummary, InferenceCreateResponse, InferenceListResponse, InferenceUpdateResponse, InferenceLifecycleResponse, InferenceDeleteResponse, InferenceGPUOptionMarket, InferenceGPUOption, InferenceGPUAlternative, InferenceGPUOptionsParams, InferenceGPUOptionsResponse, InferenceCanonicalRequest, InferencePreflightWarning, InferencePreflightResponse, AdapterCompatibility, AdapterCompatibilityResponse, AdapterCompatibilityParams, SupportedArchitecture, ArchitectureScope, SupportedArchitecturesResponse, ApiKey, ApiKeyScope, ApiKeyIntrospection, Organization, OrgMember, OrgInvite, Workspace, Integration, IntegrationCreateParams, StorageUsage, StorageObject, PromptTokensDetails, ChatCompletionUsage, TrainingCadence, TrainingCombinator, ServingKind, TrainingRulePausedReason, LoopTrainingMethod, TrainType, GradersScope, TrainingTrigger, TrainingRunState, TrainingVerdict, TrainingDecision, NotifyState, EvaluationStatus, EvaluationItemStatus, EvaluationWinner, EvaluationWarningCode, ConsentVia, TrainingToolCall, TrainingMessage, TrainingRuleServing, TrainingGPURung, TrainingRule, TrainingRuleConsent, TrainingRulePreflightRefusal, TrainingRuleKeyRef, TrainingRuleKeyCheck, TrainingRulePreflight, TrainingRuleBuildSpec, TrainingRuleTriggerInput, TrainingRuleTrainingInput, TrainingRuleDeployInput, TrainingRuleMoneyInput, TrainingRuleEvaluationInput, TrainingRulePromotionInput, TrainingRuleAcceptTerms, TrainingRulePreflightRequest, TrainingRuleCreateRequest, TrainingRuleUpdateRequest, TrainingRuleConsentRequest, TrainingRuleListParams, TrainingRunPromoteRequest, TrainingRunRejectRequest, TrainingRunRollbackRequest, TrainingRunCancelRequest, TrainingRunListParams, TrainingRun, TrainingRunSummary, TrainingRunEvent, TrainingRunLinks, TrainingRunActions, EvaluationRef, EvaluationDecoding, EvaluationJudgeDimension, EvaluationDimensionScore, EvaluationGraderScore, EvaluationWarning, EvaluationMargin, JudgeAgreementDimension, JudgeAgreement, Evaluation, EvaluationItemSide, EvaluationItem, EvaluationItemListParams, JudgeAgreementParams, AgentSettings, AgentSettingsRequest, InferenceAlias, InferenceAliasRequest, TrainingRuleListResponse, TrainingRuleResponse, TrainingRuleMutationResponse, TrainingRuleDeleteResponse, TrainingRunListResponse, TrainingRunResponse, TrainingRunActionResponse, EvaluationItemsResponse, AgentSettingsResponse, InferenceAliasListResponse, InferenceAliasResponse, InferenceAliasDeleteResponse, } from './types.js';
+/** The closed set of run states a training run never leaves. */
+export { TERMINAL_RUN_STATES } from './types.js';

package/dist/index.js

@@ -36,7 +36,7 @@ import { Loop } from './resources/loop.js';
  * SDK version. Sent as part of the User-Agent header.
  * Must match package.json "version" -- enforced by a contract test.
  */
-export const VERSION = '0.2.1-dev.137';
+export const VERSION = '0.2.1-dev.140';
 export class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     models;
@@ -103,3 +103,5 @@ export { Training } from './resources/training.js';
 export { Wallet } from './resources/wallet.js';
 export { GPU } from './resources/gpu.js';
 export { Inference, validateChatRequest, parseSSE, buildInferenceRequest, contextSizingBasis, CONTEXT_DEFAULT_CEILING, CONTEXT_EDITABLE_FLOOR, } from './resources/inference.js';
+/** The closed set of run states a training run never leaves. */
+export { TERMINAL_RUN_STATES } from './types.js';

package/dist/resources/inference.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { InferenceDeployment, InferenceDeploymentSummary, InferenceBookingAccepted, InferenceCreateParams, InferenceCreateResponse, InferenceDeleteResponse, InferenceGPUOptionsParams, InferenceGPUOptionsResponse, InferenceLifecycleResponse, InferenceListParams, InferenceListResponse, InferenceNotificationListResponse, InferencePreflightResponse, InferenceUpdateResponse, InferenceUpdateParams } from '../types.js';
+import type { InferenceDeployment, InferenceDeploymentSummary, InferenceBookingAccepted, InferenceCreateParams, InferenceCreateResponse, InferenceDeleteResponse, InferenceGPUOptionsParams, InferenceGPUOptionsResponse, InferenceLifecycleResponse, InferenceListParams, InferenceListResponse, InferenceNotificationListResponse, InferencePreflightResponse, InferenceUpdateResponse, InferenceUpdateParams, InferenceAlias, InferenceAliasRequest, InferenceAliasDeleteResponse } from '../types.js';
 /**
  * Serving context-length policy, owned and enforced by the server. Mirrored
  * here for documentation only -- never to pre-empt a server verdict.
@@ -213,6 +213,31 @@ export declare class Inference {
     restart(id: string): Promise<InferenceLifecycleResponse>;
     update(id: string, params: InferenceUpdateParams): Promise<InferenceUpdateResponse>;
     delete(id: string): Promise<InferenceDeleteResponse>;
+    /**
+     * Point a name at a deployment, creating the alias or moving an existing one.
+     *
+     * THIS CHANGES WHAT ANSWERS YOUR TRAFFIC the moment it returns. The reply
+     * carries `previous_target_inference_id`, which is what to put back if the
+     * new target turns out to be wrong.
+     *
+     * `origin` records why the handle moved -- a run id, a person, a script --
+     * and is worth setting: an alias that changed with no reason recorded is an
+     * incident nobody can reconstruct.
+     *
+     * Refused when the name already belongs to a live deployment
+     * (`ALIAS_NAME_IS_A_DEPLOYMENT`), when the target is not running, degraded or
+     * provisioning (`TARGET_NOT_SERVABLE`), and with `404` when the target is not
+     * in this workspace.
+     */
+    setAlias(name: string, params: InferenceAliasRequest): Promise<InferenceAlias>;
+    /** Every alias in the workspace, with what each one points at today. */
+    listAliases(): Promise<InferenceAlias[]>;
+    /**
+     * Remove an alias. The name goes back to the deployment that owns it, if one
+     * does; callers still using the alias stop resolving, so move it rather than
+     * delete it when something is still calling it.
+     */
+    deleteAlias(name: string): Promise<InferenceAliasDeleteResponse>;
     /**
      * Model-fit GPU choices joined to the authoritative deployment market
      * snapshot. MODEL-ADDRESSED (recommended, book-first §2): pass `model` (or

package/dist/resources/inference.js

@@ -629,6 +629,51 @@ export class Inference {
     delete(id) {
         return this.http.fetchDelete(`/api/inference/${encodeURIComponent(id)}`);
     }
+    // --------------------------------------------------------------------------
+    // Aliases -- re-pointable public handles
+    // --------------------------------------------------------------------------
+    //
+    // An alias is a name your callers use that you can move to a different
+    // deployment without them changing anything. It is what the automatic
+    // training loop re-points when it promotes a candidate, and it is what makes
+    // a rollback one row write rather than a redeployment.
+    //
+    // Reads carry `deployments:read` and writes `deployments:write`: an alias
+    // decides which model answers a customer's traffic, so it is fenced like the
+    // deployment it points at rather than like a label.
+    /**
+     * Point a name at a deployment, creating the alias or moving an existing one.
+     *
+     * THIS CHANGES WHAT ANSWERS YOUR TRAFFIC the moment it returns. The reply
+     * carries `previous_target_inference_id`, which is what to put back if the
+     * new target turns out to be wrong.
+     *
+     * `origin` records why the handle moved -- a run id, a person, a script --
+     * and is worth setting: an alias that changed with no reason recorded is an
+     * incident nobody can reconstruct.
+     *
+     * Refused when the name already belongs to a live deployment
+     * (`ALIAS_NAME_IS_A_DEPLOYMENT`), when the target is not running, degraded or
+     * provisioning (`TARGET_NOT_SERVABLE`), and with `404` when the target is not
+     * in this workspace.
+     */
+    async setAlias(name, params) {
+        const res = await this.http.fetchPut(`/api/inference/aliases/${encodeURIComponent(name)}`, params);
+        return res.alias;
+    }
+    /** Every alias in the workspace, with what each one points at today. */
+    async listAliases() {
+        const res = await this.http.fetchGet('/api/inference/aliases');
+        return res.aliases || [];
+    }
+    /**
+     * Remove an alias. The name goes back to the deployment that owns it, if one
+     * does; callers still using the alias stop resolving, so move it rather than
+     * delete it when something is still calling it.
+     */
+    async deleteAlias(name) {
+        return this.http.fetchDelete(`/api/inference/aliases/${encodeURIComponent(name)}`);
+    }
     /**
      * Model-fit GPU choices joined to the authoritative deployment market
      * snapshot. MODEL-ADDRESSED (recommended, book-first §2): pass `model` (or

package/dist/resources/loop.d.ts

@@ -1,5 +1,5 @@
 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, LoopStats, LoopJudge, LoopJudgeParams, LoopAgentCredential, LoopAgentStatus, LoopSampleRun, LoopSampleRunParams, LoopJudgeRun, LoopJudgeWork, LoopJudgeVerdict, LoopJudgeVerdictResult } from '../types.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, 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, AgentSettings, AgentSettingsRequest } 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.
@@ -457,4 +457,199 @@ export declare class Loop {
     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.
+     */
+    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.
+     *
+     * @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 it has spent this month, 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.
+     */
+    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 -- bumps `revision`, clears the recorded consent and STOPS the rule
+     * firing until someone accepts the new amounts. 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.
+     */
+    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.
+     */
+    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 and the consent all still apply, so this can answer `409
+     * CONSENT_REQUIRED` or `422 NOT_ENOUGH_ROWS` with the counts it needed.
+     */
+    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. */
+    listTrainingRuns(params?: TrainingRunListParams): Promise<TrainingRunListResponse>;
+    /**
+     * One run with its timeline, the addresses of everything it created, and
+     * what you may do with it right now.
+     *
+     * `timeline` is written in the same transaction as each state change, so it
+     * is the record of what actually happened rather than a reconstruction.
+     * `available_actions` is the honest answer to "can I promote this": a button
+     * that cannot work should never be offered.
+     */
+    getTrainingRun(id: string): Promise<TrainingRunResponse>;
+    /**
+     * Promote the candidate by hand: re-point the public handle at the new model.
+     *
+     * This changes what answers your customers. Pass `expected_revision` to be
+     * refused rather than promote against a consent that moved underneath the
+     * decision, and `force` only to promote a comparison the evaluation called
+     * inconclusive -- without it that case is refused with
+     * `INCONCLUSIVE_REQUIRES_FORCE`.
+     */
+    promoteTrainingRun(id: string, params?: TrainingRunPromoteRequest): Promise<TrainingRunActionResponse>;
+    /** Retire the candidate. What serves your traffic does not change. */
+    rejectTrainingRun(id: string, params?: TrainingRunRejectRequest): Promise<TrainingRunActionResponse>;
+    /**
+     * Undo a promotion, inside the rollback window the run reports in
+     * `rollback_available_until` (30 days).
+     *
+     * The reply carries `serving`: this is the one action besides promotion that
+     * changes what answers your traffic, so what it was put back to is returned
+     * rather than left to be looked up.
+     */
+    rollbackTrainingRun(id: string, params?: TrainingRunRollbackRequest): Promise<TrainingRunActionResponse>;
+    /**
+     * Stop a run that is still moving. Work already paid for is still billed --
+     * cancelling a training job does not refund the hours it burned.
+     */
+    cancelTrainingRun(id: string, params?: TrainingRunCancelRequest): Promise<TrainingRunActionResponse>;
+    /**
+     * The comparison behind a verdict: both models on the same held-out rows,
+     * with identical decoding, judge and grader names resolved.
+     *
+     * 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
+     * your own reviewers, is reported with the warning that says so rather than
+     * withheld. `margin_used` is the thresholds this verdict was measured
+     * against, frozen with the report, so a later policy change cannot rewrite
+     * what a past decision meant.
+     */
+    getEvaluation(id: string): Promise<Evaluation>;
+    /**
+     * 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.
+     */
+    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>;
+    /**
+     * 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>;
 }

package/dist/resources/loop.js

@@ -639,4 +639,306 @@ export class Loop {
         const res = await this._http.fetchGet(`/api/loop/sample-runs/${encodeURIComponent(runId)}`);
         return res.run;
     }
+    // ── automatic training ────────────────────────────────────────────────
+    //
+    // A training rule is a STANDING INSTRUCTION, not a job. Once it is accepted
+    // the platform builds a set, trains a model, books a candidate, compares it
+    // against what serves your traffic today and -- if you asked for that --
+    // re-points the alias at the winner, on its own schedule, with nobody
+    // watching. Every one of those steps spends money from the authorising
+    // member's wallet.
+    //
+    // So the order is always the same: preflight for the estimate and the exact
+    // words of the terms, show them to the person whose wallet pays, and only
+    // then create with `accept_terms` carrying the `terms_version` they read.
+    // Money-bearing edits bump `revision`, clear the consent and stop the rule
+    // firing until someone accepts the new amounts.
+    //
+    // Requires `loop:write` for every mutation, including `preflightTrainingRule`:
+    // it is the estimate step of a create, and a key that may not create a rule
+    // has no reason to price one.
+    /**
+     * 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.
+     */
+    async preflightTrainingRule(params) {
+        return this._http.fetchPost('/api/loop/training-rules/preflight', params);
+    }
+    /**
+     * 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.
+     *
+     * @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 },
+     * });
+     * ```
+     */
+    async createTrainingRule(params) {
+        // Refused here rather than on the wire: a create without a recorded
+        // acceptance is a request to spend somebody's money with no record that
+        // they agreed, and the SDK should never be the thing that sends it.
+        if (!params.accept_terms || !params.accept_terms.terms_version) {
+            throw new Error('RunBiOS: createTrainingRule requires accept_terms.terms_version. '
+                + 'Call preflightTrainingRule, show the member terms_text and the ceilings, '
+                + 'and send back the terms_version they accepted -- this rule spends from their wallet.');
+        }
+        const res = await this._http.fetchPost('/api/loop/training-rules', params);
+        return res.rule;
+    }
+    /**
+     * 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.
+     */
+    async listTrainingRules(params = {}) {
+        const q = new URLSearchParams();
+        if (params.enabled != null)
+            q.set('enabled', String(params.enabled));
+        if (params.limit != null)
+            q.set('limit', String(params.limit));
+        if (params.offset != null)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        return this._http.fetchGet(`/api/loop/training-rules${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * Read one rule with its recent runs, what it has spent this month, 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.
+     */
+    async getTrainingRule(id) {
+        return this._http.fetchGet(`/api/loop/training-rules/${encodeURIComponent(id)}`);
+    }
+    /**
+     * 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 -- bumps `revision`, clears the recorded consent and STOPS the rule
+     * firing until someone accepts the new amounts. 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.
+     */
+    async updateTrainingRule(id, params) {
+        return this._http.fetchPut(`/api/loop/training-rules/${encodeURIComponent(id)}`, params);
+    }
+    /**
+     * 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.
+     */
+    async consentTrainingRule(id, params) {
+        const res = await this._http.fetchPost(`/api/loop/training-rules/${encodeURIComponent(id)}/consent`, params);
+        return res.rule;
+    }
+    /**
+     * Fire a rule now, without waiting for its cadence.
+     *
+     * Bypasses the schedule and `min_new_rows` only. The row floors, the money
+     * ceilings and the consent all still apply, so this can answer `409
+     * CONSENT_REQUIRED` or `422 NOT_ENOUGH_ROWS` with the counts it needed.
+     */
+    async runTrainingRule(id) {
+        const res = await this._http.fetchPost(`/api/loop/training-rules/${encodeURIComponent(id)}/run`, {});
+        return res.run;
+    }
+    /**
+     * Delete a rule. An active run is cancelled; runs that already finished, and
+     * anything already promoted, are kept.
+     */
+    async deleteTrainingRule(id) {
+        return this._http.fetchDelete(`/api/loop/training-rules/${encodeURIComponent(id)}`);
+    }
+    /**
+     * 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.
+     */
+    async updateBuildRule(id, params) {
+        const res = await this._http.fetchPut(`/api/loop/build-rules/${encodeURIComponent(id)}`, params);
+        return res.rule;
+    }
+    // ── training runs ─────────────────────────────────────────────────────
+    /** Firings, newest first. Filter by rule or by the state they are sitting in. */
+    async listTrainingRuns(params = {}) {
+        const q = new URLSearchParams();
+        if (params.rule_id)
+            q.set('rule_id', params.rule_id);
+        if (params.state)
+            q.set('state', params.state);
+        if (params.limit != null)
+            q.set('limit', String(params.limit));
+        if (params.offset != null)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        return this._http.fetchGet(`/api/loop/training-runs${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * One run with its timeline, the addresses of everything it created, and
+     * what you may do with it right now.
+     *
+     * `timeline` is written in the same transaction as each state change, so it
+     * is the record of what actually happened rather than a reconstruction.
+     * `available_actions` is the honest answer to "can I promote this": a button
+     * that cannot work should never be offered.
+     */
+    async getTrainingRun(id) {
+        return this._http.fetchGet(`/api/loop/training-runs/${encodeURIComponent(id)}`);
+    }
+    /**
+     * Promote the candidate by hand: re-point the public handle at the new model.
+     *
+     * This changes what answers your customers. Pass `expected_revision` to be
+     * refused rather than promote against a consent that moved underneath the
+     * decision, and `force` only to promote a comparison the evaluation called
+     * inconclusive -- without it that case is refused with
+     * `INCONCLUSIVE_REQUIRES_FORCE`.
+     */
+    async promoteTrainingRun(id, params = {}) {
+        return this._http.fetchPost(`/api/loop/training-runs/${encodeURIComponent(id)}/promote`, params);
+    }
+    /** Retire the candidate. What serves your traffic does not change. */
+    async rejectTrainingRun(id, params = {}) {
+        return this._http.fetchPost(`/api/loop/training-runs/${encodeURIComponent(id)}/reject`, params);
+    }
+    /**
+     * Undo a promotion, inside the rollback window the run reports in
+     * `rollback_available_until` (30 days).
+     *
+     * The reply carries `serving`: this is the one action besides promotion that
+     * changes what answers your traffic, so what it was put back to is returned
+     * rather than left to be looked up.
+     */
+    async rollbackTrainingRun(id, params = {}) {
+        return this._http.fetchPost(`/api/loop/training-runs/${encodeURIComponent(id)}/rollback`, params);
+    }
+    /**
+     * Stop a run that is still moving. Work already paid for is still billed --
+     * cancelling a training job does not refund the hours it burned.
+     */
+    async cancelTrainingRun(id, params = {}) {
+        return this._http.fetchPost(`/api/loop/training-runs/${encodeURIComponent(id)}/cancel`, params);
+    }
+    // ── the comparison report ─────────────────────────────────────────────
+    /**
+     * The comparison behind a verdict: both models on the same held-out rows,
+     * with identical decoding, judge and grader names resolved.
+     *
+     * 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
+     * your own reviewers, is reported with the warning that says so rather than
+     * withheld. `margin_used` is the thresholds this verdict was measured
+     * against, frozen with the report, so a later policy change cannot rewrite
+     * what a past decision meant.
+     */
+    async getEvaluation(id) {
+        return this._http.fetchGet(`/api/loop/evaluations/${encodeURIComponent(id)}`);
+    }
+    /**
+     * 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.
+     */
+    async listEvaluationItems(id, params = {}) {
+        const q = new URLSearchParams();
+        if (params.winner)
+            q.set('winner', params.winner);
+        if (params.limit != null)
+            q.set('limit', String(params.limit));
+        if (params.offset != null)
+            q.set('offset', String(params.offset));
+        const qs = q.toString();
+        return this._http.fetchGet(`/api/loop/evaluations/${encodeURIComponent(id)}/items${qs ? `?${qs}` : ''}`);
+    }
+    /**
+     * 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.
+     */
+    async getJudgeAgreement(judgeId, params = {}) {
+        const q = new URLSearchParams();
+        if (params.from)
+            q.set('from', params.from);
+        if (params.to)
+            q.set('to', params.to);
+        const qs = q.toString();
+        return this._http.fetchGet(`/api/loop/judges/${encodeURIComponent(judgeId)}/agreement${qs ? `?${qs}` : ''}`);
+    }
+    // ── agent settings ────────────────────────────────────────────────────
+    /**
+     * 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.
+     */
+    async getAgentSettings() {
+        const res = await this._http.fetchGet('/api/loop/agent/settings');
+        return res.settings;
+    }
+    /**
+     * 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.
+     */
+    async updateAgentSettings(params) {
+        const res = await this._http.fetchPut('/api/loop/agent/settings', params);
+        return res.settings;
+    }
 }