runbios-sdk 0.2.1-rc.138 → 0.2.1-rc.147

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import type { BiOSConfig, ApiErrorBody, AvailableGpuAlternative, CapacityMinimumRequirement } from './types.js';
+import type { BiOSConfig, ApiErrorBody, AvailableGpuAlternative, CapacityMinimumRequirement, LoopImportResult } from './types.js';
 /**
  * Typed error thrown by every SDK method when the API returns a non-2xx status.
  *
@@ -135,6 +135,53 @@ export declare const COMING_SOON_CODES: readonly ["TRAINING_COMING_SOON", "DATAS
 export declare class ComingSoonError extends ApiError {
     constructor(status: number, body: ApiErrorBody);
 }
+/** The code an import answers with when some rows were understood and then could not be stored. */
+export declare const IMPORT_INCOMPLETE_CODE = "IMPORT_INCOMPLETE";
+/**
+ * An import that did not finish: some rows could not be stored, or some
+ * verdicts that arrived with them could not be written.
+ *
+ * The rows it names were read and understood, so there is nothing to fix in
+ * the file: this is a storage failure, not a shape one. The full outcome is on
+ * {@link LoopImportIncompleteError.outcome} — what landed, which conversations
+ * it became, and which row positions did not — because a failure that reports
+ * only "it failed" leaves the caller with no move except sending everything
+ * again.
+ *
+ * HOW TO RECOVER. Send the same rows again with `importId`, the token this
+ * call was filed under. That is what makes the second call a RETRY: rows that
+ * already arrived come back under `already_present` instead of being stored
+ * twice, and a verdict that failed to write is attempted again. Repeat it
+ * exactly; a call that repeats nothing is a second import, on purpose, because
+ * a repeat is otherwise indistinguishable from the next page of a longer file.
+ *
+ * THE WHOLE FILE, not the rows this names, 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 is imported again.
+ */
+export declare class LoopImportIncompleteError extends ApiError {
+    /** Counts, notes and ids for the import, in the same shape a success returns. */
+    readonly outcome: LoopImportResult;
+    constructor(status: number, body: ApiErrorBody);
+    /**
+     * The token to repeat as `import_id` to retry this call. Without it the retry
+     * is a second import rather than a retry, and what already landed is stored
+     * again.
+     */
+    get importId(): string | undefined;
+    /**
+     * Row positions that were not stored, counting from 1 in the order you sent
+     * them. They say what is missing; they are a smaller file to send back only
+     * if you sent `row_ids`.
+     */
+    get notSavedRows(): number[];
+    /**
+     * Row positions whose conversation stored and whose verdict did not. Those
+     * conversations are in the loop waiting for review; retrying records the
+     * verdict.
+     */
+    get verdictsNotSavedRows(): number[];
+}
 /** Whether a machine code is one of the permanent GPU rejections. */
 export declare function isPermanentGpuCode(code: string | undefined): boolean;
 /**

package/dist/client.js

@@ -191,6 +191,63 @@ export class ComingSoonError extends ApiError {
         this.name = 'ComingSoonError';
     }
 }
+/** The code an import answers with when some rows were understood and then could not be stored. */
+export const IMPORT_INCOMPLETE_CODE = 'IMPORT_INCOMPLETE';
+/**
+ * An import that did not finish: some rows could not be stored, or some
+ * verdicts that arrived with them could not be written.
+ *
+ * The rows it names were read and understood, so there is nothing to fix in
+ * the file: this is a storage failure, not a shape one. The full outcome is on
+ * {@link LoopImportIncompleteError.outcome} — what landed, which conversations
+ * it became, and which row positions did not — because a failure that reports
+ * only "it failed" leaves the caller with no move except sending everything
+ * again.
+ *
+ * HOW TO RECOVER. Send the same rows again with `importId`, the token this
+ * call was filed under. That is what makes the second call a RETRY: rows that
+ * already arrived come back under `already_present` instead of being stored
+ * twice, and a verdict that failed to write is attempted again. Repeat it
+ * exactly; a call that repeats nothing is a second import, on purpose, because
+ * a repeat is otherwise indistinguishable from the next page of a longer file.
+ *
+ * THE WHOLE FILE, not the rows this names, 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 is imported again.
+ */
+export class LoopImportIncompleteError extends ApiError {
+    /** Counts, notes and ids for the import, in the same shape a success returns. */
+    outcome;
+    constructor(status, body) {
+        super(status, body);
+        this.name = 'LoopImportIncompleteError';
+        this.outcome = body;
+    }
+    /**
+     * The token to repeat as `import_id` to retry this call. Without it the retry
+     * is a second import rather than a retry, and what already landed is stored
+     * again.
+     */
+    get importId() {
+        return this.outcome.import_id;
+    }
+    /**
+     * Row positions that were not stored, counting from 1 in the order you sent
+     * them. They say what is missing; they are a smaller file to send back only
+     * if you sent `row_ids`.
+     */
+    get notSavedRows() {
+        return this.outcome.not_saved_rows ?? [];
+    }
+    /**
+     * Row positions whose conversation stored and whose verdict did not. Those
+     * conversations are in the loop waiting for review; retrying records the
+     * verdict.
+     */
+    get verdictsNotSavedRows() {
+        return this.outcome.verdicts_not_saved_rows ?? [];
+    }
+}
 /** Whether a machine code is one of the permanent GPU rejections. */
 export function isPermanentGpuCode(code) {
     return typeof code === 'string' && PERMANENT_GPU_CODES.includes(code);
@@ -225,6 +282,12 @@ export function buildApiError(status, body) {
     if (code && COMING_SOON_CODES.includes(code)) {
         return new ComingSoonError(status, body);
     }
+    // A half-finished import carries its whole outcome in the body. Leaving it as
+    // a plain ApiError makes the counts reachable only by casting `.body`, which
+    // is the same as not publishing them.
+    if (code === IMPORT_INCOMPLETE_CODE) {
+        return new LoopImportIncompleteError(status, body);
+    }
     return new ApiError(status, body);
 }
 // ============================================================================

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-rc.138";
+export declare const VERSION = "0.2.1-rc.147";
 export declare class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     readonly models: Models;
@@ -67,7 +67,7 @@ export declare class RunBiOS {
 }
 /** @deprecated Use {@link RunBiOS}. */
 export { RunBiOS as BiOS };
-export { ApiError, GpuRejectionError, CapacityUnavailableError, ComingSoonError, CAPACITY_UNAVAILABLE_CODE, COMING_SOON_CODES, PERMANENT_GPU_CODES, isPermanentGpuCode, gpuRejectionCodeForReason, } from './client.js';
+export { ApiError, GpuRejectionError, CapacityUnavailableError, ComingSoonError, LoopImportIncompleteError, CAPACITY_UNAVAILABLE_CODE, COMING_SOON_CODES, IMPORT_INCOMPLETE_CODE, PERMANENT_GPU_CODES, isPermanentGpuCode, gpuRejectionCodeForReason, } from './client.js';
 export { Models } from './resources/models.js';
 export { Datasets } from './resources/datasets.js';
 export { Integrations, type HuggingFaceIntegration, type IntegrationBrowseParams } from './resources/integrations.js';
@@ -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-rc.138';
+export const VERSION = '0.2.1-rc.147';
 export class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     models;
@@ -95,7 +95,7 @@ export { RunBiOS as BiOS };
 // ---------------------------------------------------------------------------
 // Re-exports
 // ---------------------------------------------------------------------------
-export { ApiError, GpuRejectionError, CapacityUnavailableError, ComingSoonError, CAPACITY_UNAVAILABLE_CODE, COMING_SOON_CODES, PERMANENT_GPU_CODES, isPermanentGpuCode, gpuRejectionCodeForReason, } from './client.js';
+export { ApiError, GpuRejectionError, CapacityUnavailableError, ComingSoonError, LoopImportIncompleteError, CAPACITY_UNAVAILABLE_CODE, COMING_SOON_CODES, IMPORT_INCOMPLETE_CODE, PERMANENT_GPU_CODES, isPermanentGpuCode, gpuRejectionCodeForReason, } from './client.js';
 export { Models } from './resources/models.js';
 export { Datasets } from './resources/datasets.js';
 export { Integrations } from './resources/integrations.js';
@@ -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, 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, 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.
@@ -84,6 +84,37 @@ export declare class Loop {
      * filed under: "everything in one bucket called import" is a corpus nobody
      * can slice afterwards. At most 5000 rows per call, because the call is
      * synchronous and somebody is waiting on it.
+     *
+     * WHAT COMES BACK. `imported` is what this call created and `trace_ids` names
+     * the conversations from the file that are now in the loop, so a caller can
+     * label, review or delete them. `by_shape`, `reviewed` and `needs_review`
+     * count what THIS CALL created, not what was merely recognised and not rows
+     * an earlier import already had, and the sentences in `notes` are written
+     * from those counts, so the numbers and the prose describe the same call and
+     * a re-send cannot report a reviewed conversation as waiting for review.
+     * `refused` is rows whose shape could not be read, which the file fixes;
+     * `not_saved` is rows that were understood and then could not be stored,
+     * which the file cannot fix.
+     *
+     * A call with any `not_saved`, or any `verdicts_not_saved` (the conversation
+     * stored and the judgement that came with it did not), REJECTS with
+     * `LoopImportIncompleteError`, whose `outcome` carries all of the above and
+     * whose `notSavedRows` and `verdictsNotSavedRows` name the positions.
+     *
+     * HOW A RETRY IS SAFE. Every response carries `import_id`, the token this
+     * call was filed under. Send the same rows again with it, and rows that
+     * already arrived come back on `already_present` instead of being stored
+     * twice, while a verdict that failed to write is attempted again. A call that
+     * repeats no token is its own import, deliberately: two calls carrying the
+     * same rows are as likely to be two pages of one export as one call twice,
+     * and guessing "retry" silently drops the second copy of every conversation a
+     * file lists more than once.
+     *
+     * SENDING A FILE IN PAGES. Either give each row its own `row_ids` entry, and
+     * then chunking, ordering and subsets all stop mattering; or send one
+     * `import_id` with the `row_offset` each page starts at. Do not send back
+     * only the rows `notSavedRows` names unless you used `row_ids`: without them
+     * a shorter list moves every row after the gap and imports it again.
      */
     importRows(params: LoopImportParams): Promise<LoopImportResult>;
     /** List captured conversations, newest first. */
@@ -398,6 +429,25 @@ export declare class Loop {
      * 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
@@ -420,6 +470,12 @@ export declare class Loop {
      * 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
@@ -457,4 +513,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>;
 }