runbios-sdk 0.2.21 → 0.2.22-rc.308

package/dist/client.js

@@ -344,7 +344,7 @@ export class HttpClient {
     constructor(config) {
         // Default host stays api.runbios.ai for now; cutover to api.runbios.ai is
         // planned once its DNS exists.
-        this.baseUrl = (config.baseUrl || envBaseUrl() || 'https://api.runbios.ai').replace(/\/+$/, '');
+        this.baseUrl = (config.baseUrl || envBaseUrl() || 'https://api-staging.runbios.ai').replace(/\/+$/, '');
         this.apiKey = config.apiKey ?? envApiKey();
         this.accessToken = config.accessToken;
         this.orgId = config.orgId;

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.21";
+export declare const VERSION = "0.2.22-rc.308";
 export declare class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     readonly models: Models;
@@ -75,7 +75,7 @@ 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, type InferenceVerbParams, type CompletionParams, type EmbeddingParams, type RerankParams, type AnthropicMessageParams, type ServerlessUsageWindow, type ServerlessTimeseriesMetric, type ServerlessWorkspaceLimits, type ServerlessUsageEnvelope, type ServerlessUsageOverviewResponse, type ServerlessUsageRowsResponse, type ServerlessUsageTimeseriesResponse, type ServerlessUsageDailyResponse, type ServerlessSavingsTotals, type ServerlessSavingsPeriod, type ServerlessUsageSavingsResponse, } from './resources/inference.js';
-export type { BiOSConfig, PaginatedResponse, ApiErrorBody, AvailableGpuAlternative, CapacityMinimumRequirement, InferenceBookingAccepted, Model, ModelSearchParams, ModelSearchResponse, ModelDetailResponse, InferenceModel, InferenceModelListResponse, 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, ServingKind, TrainingRulePausedReason, TrainingTrigger, TrainingRecipe, TrainingRunState, TrainingVerdict, TrainingDecision, EvaluationStatus, EvaluationItemStatus, ItemErrorCode, EvaluationWinner, EvaluationItemWinnerFilter, ReportStatusFilter, ReportSort, EvaluationWarningCode, TrainingToolCall, TrainingMessage, TrainingRuleServing, TrainingRunPromoteRequest, TrainingRunRejectRequest, TrainingRunRollbackRequest, TrainingRunCancelRequest, TrainingRunListParams, TrainingRun, TrainingRunSummary, TrainingRunEvent, TrainingRunLinks, TrainingRunActions, EvaluationRef, EvaluationDecoding, EvaluationJudgeDimension, EvaluationDimensionScore, EvaluationWarning, EvaluationMargin, Evaluation, EvaluationItemJudge, EvaluationReferenceKind, EvaluationReference, EvaluationPairwiseOrder, EvaluationItemPairwise, EvaluationItemSide, EvaluationItem, EvaluationItemListParams, BenchmarkStatus, BenchmarkSourceKind, BenchmarkRunStatus, BenchmarkScoring, BenchmarkCheck, BenchmarkDimensionScore, Benchmark, BenchmarkItem, BenchmarkRun, BenchmarkRunItemSide, BenchmarkRunItem, BenchmarkRunItemListParams, BenchmarkHistoryPoint, BenchmarkSource, BenchmarkCreateParams, BenchmarkListParams, BenchmarkItemListParams, BenchmarkHistoryParams, BenchmarkRetireParams, InferenceAlias, InferenceAliasRequest, TrainingRuleDeleteResponse, TrainingRunListResponse, TrainingRunBenchmarkRun, TrainingRunResponse, TrainingRunActionResponse, EvaluationItemsResponse, BenchmarkRunItemsResponse, InferenceAliasListResponse, InferenceAliasResponse, InferenceAliasDeleteResponse, BenchmarkListResponse, BenchmarkItemsResponse, BenchmarkHistoryResponse, TrainingRuleRunRefusalCode, TrainingRuleSaveRefusalCode, TrainingRuleMonthlyLimitRefusal, PipelineStatus, PipelineActiveRun, PipelineVersion, PipelineAttempt, PipelineAttemptTrigger, PipelineAttemptOutcome, PipelineLiveDeploymentStatus, PipelineLiveDeployment, LoopStorageWhere, LoopStorage, Pipeline, PipelineListParams, PipelineListResponse, PipelineResponse, PipelineTrainWhen, PipelineSchedule, PipelineWriteRequest, PipelineMutationResponse, PipelineImportParams, PipelineFloors, HeldBackFloors, LoopModel, LoopModelsResponse, LoopTracePipeline, LoopTracePipelinesResponse, LoopMetricsHistoryParams, LoopMetricPoint, LoopSignalDay, LoopMetricsHistory, PromotionPolicyState, RuleBenchmark, PipelineBenchmarksResponse, PipelineBenchmarkAttachParams, PipelineBenchmarkMoveParams, CompareBenchmark, VersionBenchmarkScore, PromotionMeasurement, PromotionOutcome, VersionHoldout, VersionScores, VersionScoreDifference, VersionCompareResponse, VersionCompareParams, TrainingRunPromotion, VerdictCheck, VerdictCheckKey, VerdictChecksWithheld, TrainingRunCost, AttemptDirection, AttemptHoldout, AttemptCompareSide, AttemptSharedSample, AttemptSharedFigures, AttemptBenchmarkSide, AttemptCompareBenchmark, AttemptCompareItemSide, AttemptCompareItem, AttemptCompareResponse, AttemptCompareParams, } from './types.js';
+export type { BiOSConfig, PaginatedResponse, ApiErrorBody, AvailableGpuAlternative, CapacityMinimumRequirement, InferenceBookingAccepted, Model, ModelSearchParams, ModelSearchResponse, ModelDetailResponse, InferenceModel, InferenceModelListResponse, ModelConfig, Dataset, DatasetListParams, DatasetListResponse, DatasetUploadParams, DatasetPreview, DatasetPreviewParams, DatasetImportHFParams, DatasetRegisterHFParams, DatasetHubSearchParams, DatasetHubPreviewParams, DatasetValidation, DatasetFormatVariant, DatasetFormatSpec, DatasetFormatSpecs, DatasetStorageUsage, TrainingMethod, RLHFAlgorithm, AdapterType, TrainingJobStatus, TrainingStatusFilter, TrainingCreateParams, TrainingStartFromParams, TrainingStartFrom, TrainingListParams, TrainingListResponse, TrainingJob, TrainingMetrics, TrainingResourceMetrics, TrainingDeviceMetrics, MetricPoint, MetricGraphConfig, TrainingCheckpoint, TrainingLogs, TrainingLogEntry, TrainingStopResponse, TrainingResumeResponse, CanonicalTrainingRequest, TrainingPreflightDataset, TrainingPreflightWarning, TrainingPreflightResponse, TrainingCapabilityChoice, TrainingConfigFieldCapability, TrainingCapabilities, TrainingFeature, 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, ServingKind, TrainingRulePausedReason, TrainingTrigger, TrainingRecipe, TrainingRunState, TrainingVerdict, TrainingDecision, EvaluationStatus, EvaluationItemStatus, ItemErrorCode, EvaluationWinner, EvaluationItemWinnerFilter, ReportStatusFilter, ReportSort, EvaluationWarningCode, TrainingToolCall, TrainingMessage, TrainingRuleServing, TrainingRunPromoteRequest, TrainingRunRejectRequest, TrainingRunRollbackRequest, TrainingRunCancelRequest, TrainingRunListParams, TrainingRun, TrainingRunSummary, TrainingRunEvent, TrainingRunLinks, TrainingRunActions, EvaluationRef, EvaluationDecoding, EvaluationJudgeDimension, EvaluationDimensionScore, EvaluationWarning, EvaluationMargin, Evaluation, EvaluationItemJudge, EvaluationReferenceKind, EvaluationReference, EvaluationPairwiseOrder, EvaluationItemPairwise, EvaluationItemSide, EvaluationItem, EvaluationItemListParams, BenchmarkStatus, BenchmarkSourceKind, BenchmarkRunStatus, BenchmarkScoring, BenchmarkCheck, BenchmarkDimensionScore, Benchmark, BenchmarkItem, BenchmarkRun, BenchmarkRunItemSide, BenchmarkRunItem, BenchmarkRunItemListParams, BenchmarkHistoryPoint, BenchmarkSource, BenchmarkCreateParams, BenchmarkListParams, BenchmarkItemListParams, BenchmarkHistoryParams, BenchmarkRetireParams, InferenceAlias, InferenceAliasRequest, TrainingRuleDeleteResponse, TrainingRunListResponse, TrainingRunBenchmarkRun, TrainingRunResponse, TrainingRunActionResponse, EvaluationItemsResponse, BenchmarkRunItemsResponse, InferenceAliasListResponse, InferenceAliasResponse, InferenceAliasDeleteResponse, BenchmarkListResponse, BenchmarkItemsResponse, BenchmarkHistoryResponse, TrainingRuleRunRefusalCode, TrainingRuleSaveRefusalCode, TrainingRuleMonthlyLimitRefusal, PipelineStatus, PipelineActiveRun, PipelineVersion, PipelineAttempt, PipelineAttemptTrigger, Lineage, PipelineChain, PipelineChainRebuild, TrainingRunRollbackRefusalCode, LoopTraceRebuild, LoopTraceDeleteResponse, PipelineAttemptOutcome, PipelineLiveDeploymentStatus, PipelineLiveDeployment, LoopStorageWhere, LoopStorage, Pipeline, PipelineListParams, PipelineListResponse, PipelineResponse, PipelineTrainWhen, PipelineSchedule, PipelineWriteRequest, PipelineMutationResponse, PipelineImportParams, PipelineFloors, HeldBackFloors, LoopModel, LoopModelsResponse, LoopTracePipeline, LoopTracePipelinesResponse, LoopMetricsHistoryParams, LoopMetricPoint, LoopSignalDay, LoopMetricsHistory, PromotionPolicyState, RuleBenchmark, PipelineBenchmarksResponse, PipelineBenchmarkAttachParams, PipelineBenchmarkMoveParams, CompareBenchmark, VersionBenchmarkScore, PromotionMeasurement, PromotionOutcome, VersionHoldout, VersionScores, VersionScoreDifference, VersionCompareResponse, VersionCompareParams, TrainingRunPromotion, VerdictCheck, VerdictCheckKey, VerdictChecksWithheld, TrainingRunCost, AttemptDirection, AttemptHoldout, AttemptCompareSide, AttemptSharedSample, AttemptSharedFigures, AttemptBenchmarkSide, AttemptCompareBenchmark, AttemptCompareItemSide, AttemptCompareItem, AttemptCompareResponse, AttemptCompareParams, } from './types.js';
 /** The closed set of run states a training run never leaves. */
 export { TERMINAL_RUN_STATES } from './types.js';
 /** The most versions a pipeline may be set to make. */

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.21';
+export const VERSION = '0.2.22-rc.308';
 export class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     models;

package/dist/resources/inference.js

@@ -336,7 +336,7 @@ export class Inference {
         this.key = config.inferenceKey || envInferenceKey() || envApiKey();
         // Same default host as HttpClient (api.runbios.ai); api.runbios.ai cutover
         // is planned once its DNS exists — update both call sites together.
-        this.baseUrl = (config.baseUrl || envBaseUrl() || 'https://api.runbios.ai').replace(/\/+$/, '');
+        this.baseUrl = (config.baseUrl || envBaseUrl() || 'https://api-staging.runbios.ai').replace(/\/+$/, '');
         this.timeout = config.timeout ?? 900_000;
         this._http = http;
     }

package/dist/resources/loop.d.ts

@@ -1,12 +1,15 @@
 import type { HttpClient } from '../client.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, BenchmarkRunItemListParams, BenchmarkRunItemsResponse, Pipeline, PipelineListParams, PipelineListResponse, PipelineWriteRequest, PipelineMutationResponse, LoopModelsResponse, PipelineImportParams, PipelineBenchmarksResponse, PipelineBenchmarkAttachParams, PipelineBenchmarkMoveParams, VersionCompareResponse, VersionCompareParams, AttemptCompareResponse, AttemptCompareParams } from '../types.js';
+import type { LoopTrace, LoopTraceDeleteResponse, 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, BenchmarkRunItemListParams, BenchmarkRunItemsResponse, Pipeline, PipelineListParams, PipelineListResponse, PipelineWriteRequest, PipelineMutationResponse, LoopModelsResponse, PipelineImportParams, PipelineBenchmarksResponse, PipelineBenchmarkAttachParams, PipelineBenchmarkMoveParams, VersionCompareResponse, VersionCompareParams, AttemptCompareResponse, AttemptCompareParams } from '../types.js';
 /**
  * The Conscious Loop -- pipelines that keep improving a model from the
  * conversations you send them.
  *
  * 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.
+ * an attempt; an attempt that goes live becomes the next version: one that
+ * beats the live model, one a member approves, or, after a deleted
+ * conversation, a rebuild without it that is not clearly worse (a `manual`
+ * pipeline waits for a member even then).
  *
  * 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
@@ -152,13 +155,16 @@ export declare class Loop {
      *
      * It also leaves every training set built from it, including sets already
      * exported -- so a customer asking you to delete a conversation genuinely
-     * removes it from what the model will learn next. Training runs that have
-     * already finished are not affected.
+     * removes it from what the model will learn next. Where the live version of
+     * a pipeline learned from it, that pipeline rebuilds its model from the
+     * base on every remaining sample, without it: `rebuilds` names each one.
+     * Until the rebuild goes live, the live version still holds what it
+     * learned; once it does, no version that learned the conversation can be
+     * rolled back to, and their stored weights are deleted. Other finished runs
+     * are not affected, and a conversation that expires under the retention
+     * setting rebuilds nothing.
      */
-    deleteTrace(id: string): Promise<{
-        deleted: boolean;
-        trace_id: string;
-    }>;
+    deleteTrace(id: string): Promise<LoopTraceDeleteResponse>;
     /**
      * Record a verdict on a conversation.
      *
@@ -334,6 +340,14 @@ export declare class Loop {
      * 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.
+     *
+     * Where the pipeline builds on its live version, the version put back is
+     * what the next attempt builds on, and it trains again on what the
+     * rolled-back version learned. Refusals are a
+     * `TrainingRunRollbackRefusalCode`: `RUN_ACTIVE` also while an attempt is
+     * being built on this version (cancel it with {@link cancelTrainingRun}
+     * first), and `ROLLBACK_DELETED_DATA` when the version it would put back
+     * learned from a conversation that was deleted since.
      */
     rollbackTrainingRun(id: string, params?: TrainingRunRollbackRequest): Promise<TrainingRunActionResponse>;
     /**
@@ -370,11 +384,16 @@ export declare class Loop {
      * The one list {@link createPipeline} accepts a `model.id` from, with the
      * fixed `floors` a pipeline is held to: the samples its first attempt
      * needs, and the new samples each later attempt waits for
-     * (`new_samples`, or `new_samples_percent` of the rows the last trained
-     * attempt trained on when that is more), and the held-back rule
+     * (`new_samples`, counted since the last trained attempt, however many
+     * rows that attempt trained on), and the held-back rule
      * (`held_back`: at least `min_rows`, or the share a pipeline chooses from
      * `default_percent` to `max_percent` if that is more, and each attempt is
      * judged on at most `scored_rows` of them). They are read-only.
+     * Where a pipeline builds on its live version (its `chain` is set), each
+     * attempt trains a new adapter on top of the live version, on what it has
+     * not learned yet plus a replay of what it already learned (about a fifth
+     * of what it trains on, picked at random, so it is not forgotten), and a
+     * winner is merged in and served as one model.
      * When the list cannot be read it throws `ApiError` 503
      * `MODELS_UNAVAILABLE`, whose `body.floors` still carries the floors.
      */
@@ -386,6 +405,11 @@ export declare class Loop {
      * 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.
+     * Where the pipeline builds on its live version (`chain`), each attempt
+     * waits for 1,000 new samples and trains a new adapter on top of the live
+     * version, on what it has not learned plus a replay of what it already
+     * learned (about a fifth of what it trains on, picked at random); a winner
+     * is merged in.
      * 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. `holdout.percent`
      * (5 to 20, default 5) is the share of its samples held back to judge each
@@ -423,6 +447,8 @@ export declare class Loop {
      * `TrainingRuleRunRefusalCode`. When the attempt in flight is waiting for
      * GPUs to compare (`active_run.state` `waiting_gpus`), this books its two
      * comparison machines again at once instead of starting another attempt.
+     * With a rebuild on its way (`chain.rebuild`), it starts the rebuild: from
+     * the base on every remaining sample, with no wait for new ones.
      */
     runPipeline(id: string): Promise<PipelineMutationResponse>;
     /**
@@ -495,7 +521,8 @@ export declare class Loop {
      * `agreed` or `disagreed`), `has_reference`, `status` (`scored`, `failed`),
      * order by `sort` (`score_change`: the attempt's score less the other's,
      * largest first), and search with `q` (2 to 200 characters) over each
-     * conversation, its right answer, both answers and every reason; `searched`
+     * conversation (not the system prompt every row shares), its right answer,
+     * both answers and every reason; `searched`
      * says how many rows were searched.
      */
     listEvaluationItems(id: string, params?: EvaluationItemListParams): Promise<EvaluationItemsResponse>;

package/dist/resources/loop.js

@@ -4,7 +4,10 @@
  *
  * 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.
+ * an attempt; an attempt that goes live becomes the next version: one that
+ * beats the live model, one a member approves, or, after a deleted
+ * conversation, a rebuild without it that is not clearly worse (a `manual`
+ * pipeline waits for a member even then).
  *
  * 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
@@ -199,8 +202,14 @@ export class Loop {
      *
      * It also leaves every training set built from it, including sets already
      * exported -- so a customer asking you to delete a conversation genuinely
-     * removes it from what the model will learn next. Training runs that have
-     * already finished are not affected.
+     * removes it from what the model will learn next. Where the live version of
+     * a pipeline learned from it, that pipeline rebuilds its model from the
+     * base on every remaining sample, without it: `rebuilds` names each one.
+     * Until the rebuild goes live, the live version still holds what it
+     * learned; once it does, no version that learned the conversation can be
+     * rolled back to, and their stored weights are deleted. Other finished runs
+     * are not affected, and a conversation that expires under the retention
+     * setting rebuilds nothing.
      */
     async deleteTrace(id) {
         return this._http.fetchDelete(`/api/loop/traces/${encodeURIComponent(id)}`);
@@ -401,7 +410,7 @@ export class Loop {
     // ── attempts ──────────────────────────────────────────────────────────
     //
     // Every time a pipeline trains it makes an attempt (a training run). The
-    // attempts that beat the live model became its versions.
+    // attempts that went live became its versions.
     /** Attempts, newest first. Filter by pipeline (`rule_id`) or by the state they are sitting in. */
     async listTrainingRuns(params = {}) {
         const q = new URLSearchParams();
@@ -451,6 +460,14 @@ export class Loop {
      * 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.
+     *
+     * Where the pipeline builds on its live version, the version put back is
+     * what the next attempt builds on, and it trains again on what the
+     * rolled-back version learned. Refusals are a
+     * `TrainingRunRollbackRefusalCode`: `RUN_ACTIVE` also while an attempt is
+     * being built on this version (cancel it with {@link cancelTrainingRun}
+     * first), and `ROLLBACK_DELETED_DATA` when the version it would put back
+     * learned from a conversation that was deleted since.
      */
     async rollbackTrainingRun(id, params = {}) {
         return this._http.fetchPost(`/api/loop/training-runs/${encodeURIComponent(id)}/rollback`, params);
@@ -514,11 +531,16 @@ export class Loop {
      * The one list {@link createPipeline} accepts a `model.id` from, with the
      * fixed `floors` a pipeline is held to: the samples its first attempt
      * needs, and the new samples each later attempt waits for
-     * (`new_samples`, or `new_samples_percent` of the rows the last trained
-     * attempt trained on when that is more), and the held-back rule
+     * (`new_samples`, counted since the last trained attempt, however many
+     * rows that attempt trained on), and the held-back rule
      * (`held_back`: at least `min_rows`, or the share a pipeline chooses from
      * `default_percent` to `max_percent` if that is more, and each attempt is
      * judged on at most `scored_rows` of them). They are read-only.
+     * Where a pipeline builds on its live version (its `chain` is set), each
+     * attempt trains a new adapter on top of the live version, on what it has
+     * not learned yet plus a replay of what it already learned (about a fifth
+     * of what it trains on, picked at random, so it is not forgotten), and a
+     * winner is merged in and served as one model.
      * When the list cannot be read it throws `ApiError` 503
      * `MODELS_UNAVAILABLE`, whose `body.floors` still carries the floors.
      */
@@ -533,6 +555,11 @@ export class Loop {
      * 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.
+     * Where the pipeline builds on its live version (`chain`), each attempt
+     * waits for 1,000 new samples and trains a new adapter on top of the live
+     * version, on what it has not learned plus a replay of what it already
+     * learned (about a fifth of what it trains on, picked at random); a winner
+     * is merged in.
      * 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. `holdout.percent`
      * (5 to 20, default 5) is the share of its samples held back to judge each
@@ -576,6 +603,8 @@ export class Loop {
      * `TrainingRuleRunRefusalCode`. When the attempt in flight is waiting for
      * GPUs to compare (`active_run.state` `waiting_gpus`), this books its two
      * comparison machines again at once instead of starting another attempt.
+     * With a rebuild on its way (`chain.rebuild`), it starts the rebuild: from
+     * the base on every remaining sample, with no wait for new ones.
      */
     async runPipeline(id) {
         return this._http.fetchPost(`/api/loop/pipelines/${encodeURIComponent(id)}/run`, {});
@@ -683,7 +712,8 @@ export class Loop {
      * `agreed` or `disagreed`), `has_reference`, `status` (`scored`, `failed`),
      * order by `sort` (`score_change`: the attempt's score less the other's,
      * largest first), and search with `q` (2 to 200 characters) over each
-     * conversation, its right answer, both answers and every reason; `searched`
+     * conversation (not the system prompt every row shares), its right answer,
+     * both answers and every reason; `searched`
      * says how many rows were searched.
      */
     async listEvaluationItems(id, params = {}) {

package/dist/resources/training.js

@@ -7,6 +7,22 @@ function trainingIdempotencyKey(explicit) {
     }
     return key;
 }
+/**
+ * `start_from` on the wire. The adapters stay in the order given (oldest
+ * first: the order they are merged in), and an empty list is refused here
+ * rather than sent, since the API refuses it too.
+ */
+function startFromBody(sf) {
+    if (!Array.isArray(sf.adapters) || sf.adapters.length === 0) {
+        throw new Error('RunBiOS: startFrom.adapters must name at least one adapter checkpoint, oldest first');
+    }
+    const body = {
+        adapters: sf.adapters.map((a) => ({ job_id: a.jobId, checkpoint_id: a.checkpointId })),
+    };
+    if (sf.exportMerged !== undefined)
+        body.export_merged = sf.exportMerged;
+    return body;
+}
 function buildTrainingRequest(params) {
     let trainingMethod = params.method;
     // Legacy alias from SDK versions that modeled VLM training as a method;
@@ -80,6 +96,8 @@ function buildTrainingRequest(params) {
         body.dataset_mixing = params.datasetMixing;
     if (params.mixing !== undefined)
         body.mixing = params.mixing;
+    if (params.startFrom !== undefined)
+        body.start_from = startFromBody(params.startFrom);
     const config = {};
     if (params.epochs !== undefined)
         config.num_train_epochs = params.epochs;

package/dist/types.d.ts

@@ -8,13 +8,13 @@ export interface BiOSConfig {
     orgId?: string;
     /** Workspace ID. Optional when using API keys (resolved from the key). Can override for multi-workspace keys. */
     workspaceId?: string;
-    /** Base URL for the API. Falls back to the RUNBIOS_BASE_URL environment variable (legacy: BIOS_BASE_URL), then the canonical https://api.runbios.ai hostname. */
+    /** Base URL for the API. Falls back to the RUNBIOS_BASE_URL environment variable (legacy: BIOS_BASE_URL), then the canonical https://api-staging.runbios.ai hostname. */
     baseUrl?: string;
     /** Request timeout in milliseconds. Defaults to 30000. */
     timeout?: number;
     /** Default per-deployment inference key. Can be overridden per inference call. */
     inferenceKey?: string;
-    /** Inference base URL. Defaults to baseUrl, then https://api.runbios.ai. */
+    /** Inference base URL. Defaults to baseUrl, then https://api-staging.runbios.ai. */
     inferenceBaseUrl?: string;
     /** End-to-end inference timeout in milliseconds. Defaults to 15 minutes. */
     inferenceTimeout?: number;
@@ -547,15 +547,60 @@ export interface GPUChoice {
     /** Native market tier; training and deployment capacity are secure-only. */
     tier?: 'secure';
 }
+/**
+ * Train a new LoRA adapter on top of earlier LoRA versions of the same base
+ * model (`start_from` on create and preflight). Feature-gated: only when
+ * `training.capabilities()` lists the `start_from_adapters` feature as
+ * enabled; otherwise the API answers 400 TRAINING_FEATURE_DISABLED with the
+ * feature's reason.
+ *
+ * `adapters` are 1 to 64 adapter checkpoints of earlier jobs, OLDEST FIRST:
+ * the job trains on the base with every one of them merged into it in that
+ * order. Each must be an exact adapter checkpoint of a completed or stopped
+ * LoRA job in the same workspace, on the same pinned model and revision, and
+ * each earlier job must itself have started from exactly the adapters before
+ * it. The method must be sft or pt and the adapter lora.
+ *
+ * `exportMerged` also writes the base, the adapters and this job's selected
+ * adapter merged into one model: a checkpoint of format `merged`, which is
+ * what deploys (the job's own adapters are not deployable alone).
+ *
+ * Refusals, all before anything is charged: 404 for an unknown, deleted or
+ * other-workspace checkpoint; 422 START_FROM_BASE_MISMATCH,
+ * START_FROM_CHAIN_BROKEN or START_FROM_LINK_UNREADABLE naming the `index`;
+ * 422 START_FROM_NOT_SUPPORTED (a model type or qlora that cannot chain).
+ * A job trained this way cannot be resumed (422
+ * START_FROM_RESUME_UNSUPPORTED): start it again. If the merged model cannot
+ * be saved after training, the job fails with MERGED_EXPORT_FAILED.
+ */
+export interface TrainingStartFromParams {
+    adapters: {
+        jobId: string;
+        checkpointId: string;
+    }[];
+    exportMerged?: boolean;
+}
+/** `start_from` as the API echoes it on create, preflight and the job, with the digest of the chain's exact bytes. */
+export interface TrainingStartFrom {
+    adapters: {
+        job_id: string;
+        checkpoint_id: string;
+    }[];
+    export_merged: boolean;
+    chain_digest?: string;
+}
 /** Parameters for creating a training job. */
 export interface TrainingCreateParams {
+    /** Train on top of earlier LoRA versions of the same base. See {@link TrainingStartFromParams}. */
+    startFrom?: TrainingStartFromParams;
     /** Stable retry key. Reuse it after a timeout; a new value creates a new job. Auto-generated when omitted. */
     idempotencyKey?: string;
     /**
      * Model id to fine-tune. Must be hosted on Run BiOS — pick from the platform's
      * own catalog (client.models.search); arbitrary Hugging Face ids are
-     * rejected. Training FROM a fine-tuned model (adapter stacking) is not
-     * supported; every job starts from a catalog base model.
+     * rejected. Every job starts from a catalog base model; `startFrom` (where
+     * the platform enables it) trains a new LoRA adapter on top of earlier LoRA
+     * versions of that same base.
      */
     model: string;
     /** Optional model branch, tag, or commit; the API canonicalizes it to an exact commit. */
@@ -744,6 +789,10 @@ export interface TrainingJob {
     created_at?: string;
     billing_started_at?: string;
     resume_from_job_id?: string | null;
+    /** The earlier LoRA versions this job trained on top of; absent for a job from the base. See {@link TrainingStartFromParams}. */
+    start_from?: TrainingStartFrom;
+    /** The job's merged model (a checkpoint of format `merged`) once it is saved; null until then. Only on a job with `start_from`. */
+    merged_checkpoint_id?: string | null;
     resume_count?: number;
     can_resume?: boolean;
     has_cached_dataset?: boolean;
@@ -979,6 +1028,17 @@ export interface TrainingCheckpoint {
     base_model_id: string;
     base_model_revision: string;
     created_at: string;
+    /**
+     * What the stored weights are: `adapter`, `full`, or `merged` -- the base
+     * with the job's `start_from` adapters and its selected adapter merged into
+     * one model, named "merged model (step B)", with `step` the adapter step it
+     * was merged from. A merged model is never final, best or pruned, and is
+     * what deploys: an adapter of a job with `start_from` is refused by
+     * deployments (CHAINED_ADAPTER_NOT_DEPLOYABLE). Absent on an older service.
+     */
+    format?: 'adapter' | 'full' | 'merged';
+    /** On a merged model: the adapter checkpoint it was merged from. */
+    merged_of_checkpoint_id?: string;
 }
 /** Training logs response. */
 export interface TrainingLogs {
@@ -1245,6 +1305,24 @@ export interface TrainingConfigFieldCapability {
     adapters?: string[];
     description?: string;
 }
+/**
+ * A whole capability of GET /api/training/capabilities that is on or off as a
+ * unit (`features`), such as `start_from_adapters` (training on top of
+ * earlier LoRA versions, `start_from`). Check `enabled` before using it; when
+ * it is off, `disabled_reason` says why, in words for a person.
+ */
+export interface TrainingFeature {
+    id: string;
+    name: string;
+    enabled: boolean;
+    disabled_reason?: string;
+    /** The adapter types it works with, e.g. `["lora"]`. */
+    train_types?: string[];
+    /** The most adapters one `start_from` may name. */
+    max_adapters?: number;
+    /** Model types it cannot be used with. */
+    unsupported_model_types?: string[];
+}
 /** Dynamic contract returned by GET /api/training/capabilities. */
 export interface TrainingCapabilities {
     contract_version: string;
@@ -1258,6 +1336,14 @@ export interface TrainingCapabilities {
         when: Record<string, unknown>;
         message: string;
     }>;
+    /**
+     * Whole capabilities that are on or off as a unit, such as
+     * `start_from_adapters`. Optional: an older training service does not send
+     * it, and a feature it does not list is not available.
+     */
+    features?: TrainingFeature[];
+    /** The training engine's native Hugging Face architecture classes, when the service sends them. */
+    architectures?: string[];
 }
 /**
  * Wallet balance (`GET /api/billing/wallet`).
@@ -2869,11 +2955,61 @@ export type TrainingRulePausedReason = 'consent_invalid' | 'insufficient_funds'
 /**
  * Why a run fired, as the run stores it: `rows` (enough new samples),
  * `cadence` (the schedule), `both`, `manual` (train now), `challenger` (the
- * pipeline's challenger model trained on the same data as the attempt before
- * it), or `variant` (a recipe variant, retired: the same base model on the
- * same conversations with one training setting changed; old runs only).
+ * pipeline's challenger model, trained from its own base on every sample the
+ * attempt before it could train on), `rebuild` (a member deleted a
+ * conversation the live version learned from, so the model is trained again
+ * from the base on every remaining sample), or `variant` (a recipe variant,
+ * retired: the same base model on the same conversations with one training
+ * setting changed; old runs only).
+ */
+export type TrainingTrigger = 'rows' | 'cadence' | 'both' | 'manual' | 'variant' | 'challenger' | 'rebuild';
+/**
+ * What an attempt was trained on top of, and on which samples: `lineage` on a
+ * run, on a pipeline's versions, attempts and attempt in flight, and on each
+ * side of an attempt comparison.
+ *
+ * `trained_from` is `versions` when the attempt trained a new adapter on top
+ * of the live version: the pipeline's pinned base with the versions in
+ * `built_on` (oldest first) merged into it in that order. It is `base` when
+ * it started from the base model, and `from_base_reason` says why:
+ * `first_version`, `challenger` (the second model never builds on another
+ * model's versions), `rebuild` (a deleted conversation, with `rebuild` true;
+ * or, with `rebuild` false, a live version already built on 64 versions, the
+ * most one attempt can build on), `model_cannot_build_on` or
+ * `chain_link_unreadable` (an earlier version could not be read). Null when
+ * it built on versions.
+ *
+ * What it trained on (`train_rows`) is `new_samples` (new since the attempt
+ * before it) + `carried_samples` (trained by the attempts in
+ * `carried_from_attempts`, which did not go live) + `replayed_samples` (about
+ * a fifth of what it trained on, drawn at random from what the versions it
+ * builds on already learned, so it does not forget them). `learned_before` is
+ * how many samples those versions had learned: they are not trained again,
+ * except the replayed ones. An attempt from the base trains on every sample
+ * it can: `new_samples` is all of them, and the other three counts are 0.
+ * The four counts are null on an attempt from before the chain and on every
+ * attempt of a pipeline that does not build on its live version: only
+ * `train_rows` is known then.
+ *
+ * `served_as` is `adapter` for an attempt from the base and `merged` for one
+ * built on versions (one model with every version merged in). A winner is
+ * merged in and served as one model. `learned_deleted_conversation` is true
+ * when a conversation it trained on has since been deleted: a rebuild
+ * without it is on its way, and it can no longer be rolled back to.
  */
-export type TrainingTrigger = 'rows' | 'cadence' | 'both' | 'manual' | 'variant' | 'challenger';
+export interface Lineage {
+    trained_from: 'base' | 'versions';
+    built_on: number[];
+    served_as: 'adapter' | 'merged';
+    new_samples: number | null;
+    carried_samples: number | null;
+    carried_from_attempts: number[];
+    replayed_samples: number | null;
+    learned_before: number | null;
+    rebuild: boolean;
+    learned_deleted_conversation: boolean;
+    from_base_reason: 'first_version' | 'challenger' | 'rebuild' | 'model_cannot_build_on' | 'chain_link_unreadable' | null;
+}
 /**
  * The four training settings a recipe variant may change, as the run was
  * actually trained: the training service's own defaults are filled in where
@@ -2968,6 +3104,39 @@ export interface TrainingRunRejectRequest {
 export interface TrainingRunRollbackRequest {
     reason?: string;
 }
+/**
+ * The machine codes `rollbackTrainingRun` can be refused with.
+ *
+ * - `NOT_PROMOTED` (409): the run never went live.
+ * - `ROLLBACK_WINDOW_CLOSED` (409): more than 30 days since it went live.
+ * - `ROLLBACK_SUPERSEDED` (409): a later version went live since; roll that
+ *   one back.
+ * - `NOTHING_TO_RESTORE` (409): nothing is recorded as serving before it.
+ * - `RUN_ACTIVE` (409): an attempt is being compared with this version, or is
+ *   being built on top of it. Cancel that attempt (`cancelTrainingRun`)
+ *   first, or wait for it to finish.
+ * - `ROLLBACK_DELETED_DATA` (409): the version it would put back learned from
+ *   a conversation a member deleted since, so it never answers again; a
+ *   rebuild without that conversation replaces it.
+ */
+export type TrainingRunRollbackRefusalCode = 'NOT_PROMOTED' | 'ROLLBACK_WINDOW_CLOSED' | 'ROLLBACK_SUPERSEDED' | 'NOTHING_TO_RESTORE' | 'RUN_ACTIVE' | 'ROLLBACK_DELETED_DATA';
+/** A pipeline whose model a trace delete rebuilds: its live version learned from the deleted conversation. */
+export interface LoopTraceRebuild {
+    pipeline_id: string;
+    pipeline_name: string;
+}
+/**
+ * `DELETE /api/loop/traces/{id}`. `rebuilds` names every pipeline whose live
+ * version learned from the conversation: each rebuilds its model from the
+ * base without it. A pipeline that is switched off is named too; its rebuild
+ * starts when it is switched back on. Empty when none did; absent on an
+ * older service.
+ */
+export interface LoopTraceDeleteResponse {
+    deleted: boolean;
+    trace_id: string;
+    rebuilds?: LoopTraceRebuild[];
+}
 export interface TrainingRunCancelRequest {
     reason?: string;
 }
@@ -3004,6 +3173,13 @@ export interface TrainingRun {
     attempts: number;
     next_poll_at: string | null;
     last_reason: string | null;
+    /**
+     * Why it failed or was set aside, as a code. Two belong to a pipeline that
+     * builds on its live version: `CHAIN_MOVED` (it was built on a version that
+     * was rolled back while it trained; it is superseded, no comparison was
+     * paid for, and its samples go to the next attempt) and `NO_MERGED_EXPORT`
+     * (its training finished without the merged model it is served as).
+     */
     error_code: string | null;
     last_error: string | null;
     /**
@@ -3030,6 +3206,8 @@ export interface TrainingRun {
     spent_eval_cents: number;
     train_rows: number | null;
     holdout_rows: number | null;
+    /** What it was trained on top of, and on which samples. See {@link Lineage}. */
+    lineage: Lineage;
     train_dataset_id: string | null;
     /** Null on a run made since the held-back rows stopped leaving the loop; set on older runs. */
     holdout_dataset_id: string | null;
@@ -3056,8 +3234,17 @@ export interface TrainingRun {
     model_family: string | null;
     /** Machine time the run held (training job plus comparison machine); null until known. */
     gpu_seconds: number | null;
-    /** The trainer's loss on its validation slice, as {@link Evaluation.trainer_eval_loss}. */
+    /** The trainer's loss on its validation slice, as {@link Evaluation.trainer_eval_loss}: at the checkpoint the attempt kept. */
     training_eval_loss: number | null;
+    /** Optimizer steps the attempt's training job took, as the trainer counted them. Null until the job has ended. */
+    trained_steps: number | null;
+    /**
+     * One plain sentence about how the platform trained the attempt: the steps
+     * it took, the passes planned over its samples and the checkpoint it kept.
+     * Null on an attempt the step-aware recipe did not train, and until its job
+     * has ended.
+     */
+    training_summary: string | null;
     candidate_deployment_id: string | null;
     candidate_name: string | null;
     candidate_seq: number;
@@ -3354,7 +3541,8 @@ export type ReportSort = 'ordinal' | 'score_change';
  * `candidate_passed: false, incumbent_passed: true` is the regressions,
  * `candidate_passed: false` alone every row the new model did not pass.
  * `q` (2 to 200 characters) searches, case-insensitively, what a
- * reader of each row sees -- the conversation, the right answer, both answers
+ * reader of each row sees -- the conversation (not the system prompt every row
+ * shares), the right answer, both answers
  * and their tool calls, every reason -- read from storage by the service; the
  * answer's `searched` says how many rows it searched. A search can be refused
  * 429 `RATE_LIMITED`, with `Retry-After`, while this workspace already has a
@@ -3577,6 +3765,13 @@ export interface BenchmarkRun {
     prompt_tokens: number;
     completion_tokens: number;
     spent_cents: number;
+    /**
+     * How many of the conversations this replay asked the version under test
+     * learned -- trained on itself, or learned by a version it was built on
+     * ("N of these conversations were learned by this version"): a score on
+     * those is partly recall. Null for a version the merge chain did not build.
+     */
+    learned_by_version: number | null;
     status: BenchmarkRunStatus;
     /** The whole explanation when there is no score, so never empty on one. */
     status_reason: string | null;
@@ -3609,6 +3804,8 @@ export interface BenchmarkHistoryPoint {
     incumbent_pass_rate: number | null;
     candidate_pass_rate: number | null;
     checkpoint_id: string | null;
+    /** The replay's {@link BenchmarkRun.learned_by_version}. */
+    learned_by_version: number | null;
     decision: TrainingDecision | null;
     status: BenchmarkRunStatus;
     status_reason: string | null;
@@ -3743,7 +3940,10 @@ export interface BenchmarkRetireParams {
  *   it (`paused_reason` says why).
  * - `RUN_ACTIVE` (409): one attempt at a time, so two cannot race to promote.
  * - `VERSION_LIMIT_REACHED` (409): the pipeline has made `max_versions`
- *   versions. Raise the limit or remove it.
+ *   versions and owes no rebuild. Raise the limit or remove it. A rebuild
+ *   after a deleted conversation (`chain.rebuild`) is not held by the limit:
+ *   Train now starts it, and each one that goes live is a version, so the
+ *   pipeline can end past its limit.
  * - `MONTHLY_LIMIT_REACHED` (409): the most this month's attempts can have
  *   cost plus the most one more may cost would pass the pipeline's internal
  *   monthly limit. The body carries the figures:
@@ -3909,6 +4109,8 @@ export interface PipelineActiveRun {
     last_error: string | null;
     train_rows: number | null;
     holdout_rows: number | null;
+    /** What it trains on top of, and on which samples. See {@link Lineage}. */
+    lineage: Lineage;
     /**
      * Its comparison scored at least one conversation. False on a reported run
      * means the held-back set was too small to compare anything: that run is
@@ -3943,6 +4145,8 @@ export interface PipelineVersion {
     checkpoint_id: string | null;
     train_rows: number | null;
     holdout_rows: number | null;
+    /** What it was trained on top of, and on which samples. See {@link Lineage}. */
+    lineage: Lineage;
     /** Head-to-head against the champion of its day, on conversations neither trained on. */
     rows_scored: number | null;
     win_rate: number | null;
@@ -4010,10 +4214,12 @@ export interface PipelineVersion {
  */
 /**
  * Why an attempt was made: new data (`data`, a recipe variant included), the
- * schedule (`schedule`), a member's train-now (`manual`), or the challenger
- * model trained on the same data as the attempt before it (`challenger`).
+ * schedule (`schedule`), a member's train-now (`manual`), the challenger
+ * model trained from its own base on all samples (`challenger`), or a rebuild
+ * from the base after a member deleted a conversation the live version
+ * learned from (`rebuild`).
  */
-export type PipelineAttemptTrigger = 'data' | 'schedule' | 'manual' | 'challenger';
+export type PipelineAttemptTrigger = 'data' | 'schedule' | 'manual' | 'challenger' | 'rebuild';
 /** What became of an attempt. */
 export type PipelineAttemptOutcome = 'became_version' | 'not_better' | 'inconclusive' | 'stopped' | 'failed' | 'running' | 'waiting_for_review';
 /** One attempt: every training run a pipeline makes, winner or not. */
@@ -4033,6 +4239,8 @@ export interface PipelineAttempt {
     /** The samples its set trained on and held back; null until its set was built. */
     train_rows: number | null;
     holdout_rows: number | null;
+    /** What it was trained on top of, and on which samples. See {@link Lineage}. */
+    lineage: Lineage;
     /** The version it became, when it became one. */
     version: number | null;
     created_at: string;
@@ -4062,7 +4270,10 @@ export interface PipelineModelRef {
 /**
  * When a new version takes over. `holdout` (the default) when it wins on the
  * held-back set; `all`, `primary`, `k_of_n` (with `k`) and `weighted` also
- * weigh the pipeline's benchmarks; `manual` never on its own.
+ * weigh the pipeline's benchmarks; `manual` never on its own. A rebuild after
+ * a deleted conversation (trigger `rebuild`) is the exception under every
+ * policy but `manual`: it goes live unless it is clearly worse than the live
+ * version. Under `manual` it waits for a member like any attempt.
  */
 export interface PipelinePromotion {
     policy: 'holdout' | 'all' | 'primary' | 'k_of_n' | 'weighted' | 'manual';
@@ -4113,8 +4324,8 @@ export interface PipelineHoldout {
  * `first_version`: `needed` usable samples the first attempt needs -- the
  * rows it trains on plus the ones held back to judge it. `new_rows`: `needed`
  * usable samples the last trained attempt did not have, which is
- * `floors.new_samples` or `floors.new_samples_percent` of the rows that
- * attempt trained on, whichever is more. `have`, `short` and `message` are
+ * `floors.new_samples` (1,000), however many rows that attempt trained on.
+ * `have`, `short` and `message` are
  * measured on the detail only. There, after an attempt has trained, `short`
  * is how many more new samples have to arrive: new samples fill the held-back
  * set first, so after the held-back share is raised it can be more than
@@ -4146,6 +4357,34 @@ export interface PipelineLiveDeployment {
     status: PipelineLiveDeploymentStatus;
     checked_at: string;
 }
+/**
+ * A rebuild on its way: a member deleted `conversations` conversations the
+ * live version learned from, first at `since`. The next attempt trains from
+ * the base on every remaining sample without waiting for new ones; until it
+ * goes live, the live version still holds what it learned from them.
+ */
+export interface PipelineChainRebuild {
+    reason: 'conversation_deleted';
+    conversations: number;
+    since: string;
+}
+/**
+ * The live version as what it is made of: the pinned base with `versions`
+ * merged into it in that order, the live one last. Null when nothing this
+ * pipeline trained is live on its current model, and when the pipeline does
+ * not build on its live version (then every attempt trains from the base on
+ * all samples). `learned_samples` is how many samples those versions learned
+ * (the next attempt does not train them again, except a replayed fifth);
+ * `not_learned_samples` is how many were trained by attempts that did not go
+ * live, so the next attempt trains them again. Null on the list.
+ */
+export interface PipelineChain {
+    versions: number[];
+    live_version: number;
+    learned_samples: number;
+    not_learned_samples: number | null;
+    rebuild: PipelineChainRebuild | null;
+}
 export interface Pipeline {
     rule_id: string;
     rule_name: string;
@@ -4163,8 +4402,9 @@ export interface Pipeline {
     /** A conversation carrying ANY of these tags is this pipeline's data. */
     tags: string[];
     /**
-     * A second base model trained on the same data after each attempt; it
-     * becomes the next version only if it beats the live one, and then it
+     * A second base model, trained from its own base on all samples after each
+     * attempt (it never builds on this pipeline's versions, which are another
+     * model); it becomes the next version only if it beats the live one, and then it
      * becomes the pipeline's model (`base_model_id`) while the model it replaced
      * becomes this one. `revision` is the commit the server pinned.
      */
@@ -4175,7 +4415,11 @@ export interface Pipeline {
     /** Rows the next version holds back and never trains on. Detail only; null on the list. */
     holdout_size: number | null;
     minimums: PipelineMinimums;
-    /** The pinned base every version is a fresh adapter over, which is what makes their scores comparable. */
+    /**
+     * The pinned base every version is trained over: from it, or, where the
+     * pipeline builds on its live version (`chain`), on top of the versions
+     * before it merged into it.
+     */
     base_model_id: string;
     base_model_revision: string;
     /** The version serving now; null when what serves is not a version of this pipeline. */
@@ -4188,6 +4432,8 @@ export interface Pipeline {
      * serves is not a deployment, or before the first check of that deployment.
      */
     live_deployment: PipelineLiveDeployment | null;
+    /** The live version as the versions merged into it. See {@link PipelineChain}. */
+    chain: PipelineChain | null;
     /** What the pipeline's history takes up in storage. */
     storage: LoopStorage;
     /** The name the app calls. It does not change when a version is promoted. */
@@ -4503,13 +4749,11 @@ export interface PipelineFloors {
      * back more needs more; its own `minimums` says how many).
      */
     first_version_samples: number;
-    /** The fewest new samples any later attempt waits for. */
-    new_samples: number;
     /**
-     * The share, in percent, of the rows the last trained attempt trained on
-     * that a later attempt must add when that is more than `new_samples`.
+     * The new samples every later attempt waits for, counted since the last
+     * trained attempt, however many rows that attempt trained on.
      */
-    new_samples_percent: number;
+    new_samples: number;
     /** The held-back rule a pipeline chooses its share within. */
     held_back: HeldBackFloors;
 }
@@ -4603,6 +4847,8 @@ export interface VersionBenchmarkScore {
     rows_scored: number | null;
     rows_total: number | null;
     items_digest: string | null;
+    /** The replay's {@link BenchmarkRun.learned_by_version}; null when not measured. */
+    learned_by_version: number | null;
     comparable: boolean;
     why: string | null;
     /** The share each side passed (score 0.70 or more); null when there is no score. */
@@ -4725,6 +4971,8 @@ export interface AttemptCompareSide {
     decision: TrainingDecision | null;
     train_rows: number | null;
     holdout_rows: number | null;
+    /** What it was trained on top of, and on which samples. See {@link Lineage}. */
+    lineage: Lineage;
     finished_at: string | null;
     holdout: AttemptHoldout;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runbios-sdk",
-  "version": "0.2.21",
+  "version": "0.2.22-rc.308",
   "description": "Official TypeScript SDK for the Run BiOS training and deployment platform API",
   "type": "module",
   "main": "./dist/index.js",