runbios-sdk 0.4.0-rc.337 → 0.5.0-dev.338

package/CHANGELOG.md

@@ -5,6 +5,43 @@ surface is added, renamed or removed, the patch for a fix inside an unchanged
 surface. The SDK, the Python SDK (`runbios-sdk` on PyPI) and the MCP server
 (`runbios-mcp`) are released together, at one version.
 
+## 0.5.0
+
+Added
+
+- Conscious Loop, `loop.chat({ pipeline, messages, model? })`: one call asks a
+  model with the pipeline ID in the `X-Loop-Pipeline` header (it is
+  `inference.chatCompletions` with the `loop` option, a normal billed call)
+  and returns `{ answer, sample_id, raw, good(), bad(), correct(text) }`.
+  `good`, `bad` and `correct` send the feedback words `good`, `bad` and
+  `corrected` on the sample ID, and wait and send again while the sample is
+  still being saved (`409 SAMPLE_NOT_YET_RECORDED`), as `signal` does; on an
+  answer with no sample ID they throw before any request. `model` defaults to
+  the pipeline's own model, `loop-<pipeline ID>`; while the pipeline has no
+  live version nothing answers to that name, and `chat` then rejects with
+  `LoopNoVersionError`, an `ApiError` (the API's 404: its `status`, `code`,
+  `requestId` and `body`, with a plain message; `pipeline`, `model`, and the
+  original error as `cause`). The pipeline ID is lowercased before it names
+  the header and the model, as the platform reads it, and anything that is
+  not a pipeline ID (lowercase letters, digits, dot, dash or underscore, at
+  most 63) is refused before any request.
+  Exported: `LoopChatParams`, `LoopChatResult`, `LoopNoVersionError`.
+- README: a Conscious Loop section, "What it is" and the three steps.
+
+Changed
+
+- `client.loop` is given the client's `Inference` resource, so `loop.chat`
+  uses the same key resolution and base URL as `client.inference`.
+- The loop's module comments say what is saved: a call carrying the
+  pipeline ID header is saved whatever the recording switches say (the header
+  is the consent for that one call); they no longer say nothing is captured
+  until a source is switched on, and no longer offer DPO or GRPO. They no
+  longer name an environment: where the platform has the loop switched off,
+  every method answers `LOOP_COMING_SOON`.
+- README: the one-header section says pipeline ID and sample ID, not tag and
+  trace id; going back to the version before is possible for 30 days (it
+  said always).
+
 ## 0.4.0
 
 Added

package/README.md

@@ -219,27 +219,32 @@ POSTs are retried automatically, and `idempotencyKey` is sent only if supplied.
 
 #### Record conversations into a Conscious Loop pipeline (one header)
 
-Add `loop: { pipeline: '<tag>' }` to `chatCompletions`, `streamChatCompletions`,
-`messages` or `streamMessages` and the call is sent exactly as before with one
-more header, `X-Loop-Pipeline: <tag>` (several tags: `pipeline: ['a', 'b']`).
-The gateway records the exchange -- what was asked, what the model answered and
-its tool calls -- as a sample of the pipelines those tags feed (a pipeline's
-`own_tag`), even where recording is off for that model: the header is your
-consent for that one exchange. With `chatCompletions` and `streamChatCompletions`
-it works for serverless models and dedicated deployments, including the
-pipeline's own `loop-<tag>` model. `messages` and `streamMessages` (the
-Anthropic shape) work for serverless models; a dedicated deployment, and so a
-pipeline's `loop-<tag>` model, serves the OpenAI shape and refuses
-`/v1/messages` with 400, so call it with `chatCompletions`. Only the tags of a
-pipeline that exists are recorded: a call naming a misspelt tag, or a deleted
-pipeline's, is not recorded under it, and `client.loop.stats()` lists such
-calls under `capture`.
+Add `loop: { pipeline: '<pipeline ID>' }` to `chatCompletions`,
+`streamChatCompletions`, `messages` or `streamMessages` and the call is sent
+exactly as before with one more header, `X-Loop-Pipeline: <pipeline ID>`
+(several pipelines: `pipeline: ['a', 'b']`). The gateway records the exchange
+-- what was asked, what the model answered and its tool calls -- as a sample of
+the pipelines those pipeline IDs name (a pipeline's `own_tag`, read in
+lowercase), even where recording is off for that model: the header is your
+consent for that one exchange. With `chatCompletions` and
+`streamChatCompletions` it works for serverless models and dedicated
+deployments, including the pipeline's own `loop-<pipeline ID>` model.
+`messages` and `streamMessages` (the Anthropic shape) work for serverless
+models; a dedicated deployment, and so a pipeline's `loop-<pipeline ID>` model,
+serves the OpenAI shape and refuses `/v1/messages` with 400, so call it with
+`chatCompletions`. Only the pipeline IDs of pipelines that exist are recorded:
+a call naming a misspelt ID, or a deleted pipeline's, is not recorded under it.
+The reply still carries a sample ID: if recording is switched on for that
+model, the call is still recorded the way that model records every call and
+feedback on it is accepted; when nothing records it, feedback on it is
+refused. `client.loop.stats()` lists such calls under `capture`.
 
 The gateway answers with the sample's id in `X-Loop-Sample-Id`. A non-streaming
 result carries it as `loop_sample_id` (non-enumerable: it is never part of the
 answer's JSON), and `loop.onSampleId` hears it as soon as the headers arrive,
 before the first streamed chunk. It is `null` when the gateway recorded nothing.
-Send feedback on that id; it is the trace id the feedback calls take.
+Send feedback on that sample ID: `client.loop.upvote`, `downvote` and `correct`
+take it.
 
 ```typescript
 const reply = await client.inference.chatCompletions({
@@ -319,6 +324,109 @@ includes failed admitted requests. The saved workspace RPM cap is a subdivision
 of the org's tier allowance, not a claim about effective remaining RPM.
 An incomplete 200 response is an error, never "zero usage" or "unlimited".
 
+### Conscious Loop
+
+#### What it is
+
+The Conscious Loop keeps improving a model from your app's conversations and
+your feedback. You make a pipeline for one use case (in the console, or with
+`client.loop.createPipeline`). Your app's conversations are saved to it as
+samples, you say how each answer did, and when enough samples have feedback
+a training starts: your model learns from them. Every training is tested before
+it can go live: on questions from your own samples that it never trained on, and on
+your benchmarks if you add any. A training that does better, or that you
+approve, becomes the next version: v1, v2, v3 and on, with no limit. The
+**live version** is the version your app gets answers from right now. It
+answers to the model name `loop-<pipeline ID>`, and each new version takes
+that name over. For 30 days after a new version goes live you can go back to
+the one before.
+
+Two names to know:
+
+- **Pipeline ID**, e.g. `support-replies`: made from the pipeline's name when
+  you created it, and it never changes. The pipeline's Connect page shows it.
+  It is the `pipeline` you pass here, sent as the `X-Loop-Pipeline` header.
+- **Sample ID**: comes back in the reply's headers (`X-Loop-Sample-Id`), and
+  feedback names it. `client.loop.chat` hands it to you as `sample_id` and
+  sends the feedback for you. It is missing only when the platform is not
+  recording calls just then; then nothing was saved. A sample ID does not
+  prove the pipeline ID is right: if no pipeline has that ID (misspelt, or
+  the pipeline was deleted), the conversation is not saved under it. If
+  recording is switched on for the model that answered, the call is still
+  recorded the way that model records every call, and feedback on it is then
+  accepted; when nothing records it, feedback on it is refused (first "not
+  recorded yet", then "not found"). `client.loop.stats()` counts such calls
+  under `capture` (reason `no_pipeline`), and the pipeline's Connect page
+  shows its pipeline ID.
+
+The API key needs `serverless` to call a serverless model (`deployments:read`
+for a deployment and for the pipeline's own `loop-` model) and `loop:write` to
+send feedback.
+
+#### The three steps
+
+**1. Send your app's conversations.** `client.loop.chat` is a normal, billed
+model call with the pipeline ID added, and the conversation is saved as a
+sample of the pipeline:
+
+```typescript
+const reply = await client.loop.chat({
+  pipeline: 'support-replies',
+  messages: [{ role: 'user', content: 'Where is my order?' }],
+  model: 'meta-llama/Llama-3.1-8B-Instruct', // before v1: the model your app uses now
+});
+console.log(reply.answer, reply.sample_id);
+```
+
+Before the pipeline's first version, pass `model`. Left out, `chat` asks
+`loop-support-replies`, and while no version is live nothing answers to that
+name: it rejects with `LoopNoVersionError` (an `ApiError`) and says so in plain
+words. The pipeline ID is sent in lowercase, as the platform reads it. Any
+other chat parameter (`temperature`, `max_tokens`, `tools`, ...) is passed on.
+Already calling `client.inference.chatCompletions`? Add
+`loop: { pipeline: 'support-replies' }` instead (see the one-header section
+above; it also works when streaming).
+
+**2. Tell it how each answer did.**
+
+```typescript
+await reply.good();                              // Good
+// await reply.bad();                            // Wrong
+// await reply.correct('It ships on Monday.');   // Wrong + the right answer
+```
+
+Feedback sent the instant an answer arrives can reach the platform before the
+conversation is saved (`409 SAMPLE_NOT_YET_RECORDED`): `good`, `bad` and
+`correct` wait 2 seconds and send it again, up to 6 tries. With a sample ID
+from elsewhere, `client.loop.upvote(id)`, `downvote(id)` and
+`correct(id, text)` do the same.
+
+What your feedback does:
+
+| Feedback | What happens |
+|---|---|
+| Good | The answer is learned as it is. |
+| Wrong | The answer is not learned. |
+| Wrong + right answer | The right answer is learned instead. |
+| No feedback | If automatic scoring is on, the judge scores it. The judge is an AI that compares each answer with the right answer; where nobody gave one, as here, it scores the answer on its instructions alone. 0.8 or more is learned like Good. |
+
+Training that learns from rankings or rewards (like DPO or GRPO) is not
+available yet; every version learns from your good and corrected answers.
+Samples and feedback are kept 30 days by default. Right answers are cleaned of
+emails, long numbers and keys before they are saved.
+
+**3. Use the improved model.** Leave `model` out once a version is live:
+
+```typescript
+const next = await client.loop.chat({
+  pipeline: 'support-replies',
+  messages: [{ role: 'user', content: 'Can I return a gift?' }],
+}); // asks loop-support-replies, the live version
+```
+
+Any OpenAI-compatible client can call `loop-support-replies` too. It always
+answers with the live version, and each new version takes over the name.
+
 ### Models
 
 The catalog lists only models hosted on Run BiOS (the platform's own verified

package/dist/client.d.ts

@@ -160,6 +160,26 @@ export declare class ComingSoonError extends ApiError {
 }
 /** 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";
+/**
+ * `client.loop.chat` was asked to use the pipeline's own model
+ * (`loop-<pipeline ID>`) and nothing answers to that name: the pipeline has no
+ * live version right now -- before its first version, or after its only live
+ * version was taken back -- or no pipeline has that ID. Pass `model`, the
+ * model your app uses now, until a version is live.
+ *
+ * It is the API's own 404 with a plain message: an `ApiError` (`status`,
+ * `code`, `requestId` and `body` are the refusal's), so `instanceof ApiError`
+ * still catches it. `cause` is the original error.
+ */
+export declare class LoopNoVersionError extends ApiError {
+    /** The pipeline ID that was asked. */
+    readonly pipeline: string;
+    /** The model name that answered nothing. */
+    readonly model: string;
+    /** The API's own refusal (a 404). */
+    readonly cause: ApiError;
+    constructor(pipeline: string, model: string, cause: ApiError);
+}
 /**
  * An import that did not finish: some rows could not be stored, or some
  * verdicts that arrived with them could not be written.
@@ -261,6 +281,22 @@ export declare class HttpClient {
      * Throws {@link ApiError} on non-2xx responses.
      */
     request<T>(method: string, path: string, body?: unknown, extraHeaders?: Record<string, string>): Promise<T>;
+    /**
+     * Send a GET and answer the body as text, with the response's headers: for
+     * the routes that answer a file rather than JSON (a dataset's export).
+     * Throws {@link ApiError} on non-2xx responses, read from the JSON error
+     * envelope as every other call is.
+     *
+     * THE TIMEOUT IS A WAIT FOR THE NEXT PART, NOT FOR THE WHOLE FILE. A file
+     * is streamed: a large dataset takes minutes to arrive, steadily. The
+     * client's `timeout` bounds the wait for the answer to start and then for
+     * each next part of it, so a long file that keeps coming is read whole,
+     * and one that stops coming is still given up on.
+     */
+    fetchText(path: string): Promise<{
+        text: string;
+        headers: Headers;
+    }>;
     /** Send a GET request. */
     fetchGet<T>(path: string, extraHeaders?: Record<string, string>): Promise<T>;
     /** Send a POST request with a JSON body. */

package/dist/client.js

@@ -231,6 +231,38 @@ export class ComingSoonError extends ApiError {
 }
 /** The code an import answers with when some rows were understood and then could not be stored. */
 export const IMPORT_INCOMPLETE_CODE = 'IMPORT_INCOMPLETE';
+/**
+ * `client.loop.chat` was asked to use the pipeline's own model
+ * (`loop-<pipeline ID>`) and nothing answers to that name: the pipeline has no
+ * live version right now -- before its first version, or after its only live
+ * version was taken back -- or no pipeline has that ID. Pass `model`, the
+ * model your app uses now, until a version is live.
+ *
+ * It is the API's own 404 with a plain message: an `ApiError` (`status`,
+ * `code`, `requestId` and `body` are the refusal's), so `instanceof ApiError`
+ * still catches it. `cause` is the original error.
+ */
+export class LoopNoVersionError extends ApiError {
+    /** The pipeline ID that was asked. */
+    pipeline;
+    /** The model name that answered nothing. */
+    model;
+    /** The API's own refusal (a 404). */
+    cause;
+    constructor(pipeline, model, cause) {
+        super(cause.status, cause.body);
+        this.message =
+            `Pipeline "${pipeline}" has no live version right now, so nothing answers to "${model}". ` +
+                'Until a version is live, pass model: the model your app uses now ' +
+                '(the conversations still go to the pipeline). ' +
+                'If the pipeline has a live version, check the pipeline ID on its Connect page.';
+        this.name = 'LoopNoVersionError';
+        this.retryAfter = cause.retryAfter;
+        this.pipeline = pipeline;
+        this.model = model;
+        this.cause = cause;
+    }
+}
 /**
  * An import that did not finish: some rows could not be stored, or some
  * verdicts that arrived with them could not be written.
@@ -364,6 +396,27 @@ export function envInferenceKey() {
 export function envBaseUrl() {
     return envVar('RUNBIOS_BASE_URL') ?? envVar('BIOS_BASE_URL');
 }
+/**
+ * A response's body as text, read part by part, calling `progressed` before
+ * each read so the caller's timer measures the wait for the next part rather
+ * than for the whole body. A body that cannot be streamed is read whole.
+ */
+async function readTextAsItArrives(res, progressed) {
+    if (!res.body)
+        return res.text();
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    const parts = [];
+    for (;;) {
+        progressed();
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        parts.push(decoder.decode(value, { stream: true }));
+    }
+    parts.push(decoder.decode());
+    return parts.join('');
+}
 // ============================================================================
 // HttpClient — shared HTTP transport used by resource modules via composition
 // ============================================================================
@@ -378,7 +431,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-staging.runbios.ai').replace(/\/+$/, '');
+        this.baseUrl = (config.baseUrl || envBaseUrl() || 'https://api-dev.runbios.ai').replace(/\/+$/, '');
         this.apiKey = config.apiKey ?? envApiKey();
         this.accessToken = config.accessToken;
         this.orgId = config.orgId;
@@ -469,6 +522,58 @@ export class HttpClient {
         }
         return data;
     }
+    /**
+     * Send a GET and answer the body as text, with the response's headers: for
+     * the routes that answer a file rather than JSON (a dataset's export).
+     * Throws {@link ApiError} on non-2xx responses, read from the JSON error
+     * envelope as every other call is.
+     *
+     * THE TIMEOUT IS A WAIT FOR THE NEXT PART, NOT FOR THE WHOLE FILE. A file
+     * is streamed: a large dataset takes minutes to arrive, steadily. The
+     * client's `timeout` bounds the wait for the answer to start and then for
+     * each next part of it, so a long file that keeps coming is read whole,
+     * and one that stops coming is still given up on.
+     */
+    async fetchText(path) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = this.buildHeaders({ 'Accept': 'application/x-ndjson, application/json' });
+        const controller = new AbortController();
+        let timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const progressed = () => {
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        };
+        let res;
+        let text;
+        let reading = false;
+        try {
+            res = await fetch(url, { method: 'GET', headers, signal: controller.signal });
+            reading = true;
+            text = await readTextAsItArrives(res, progressed);
+        }
+        catch (err) {
+            if (controller.signal.aborted || (err instanceof DOMException && err.name === 'AbortError')) {
+                throw new ApiError(0, {
+                    error: reading
+                        ? `Request timed out: nothing more arrived for ${this.timeout}ms`
+                        : `Request timed out after ${this.timeout}ms`,
+                });
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+        if (!res.ok) {
+            let data = {};
+            try {
+                data = JSON.parse(text);
+            }
+            catch { /* a body that is not JSON carries no envelope */ }
+            throw errorFromResponse(res, data);
+        }
+        return { text, headers: res.headers };
+    }
     /** Send a GET request. */
     fetchGet(path, extraHeaders) {
         return this.request('GET', path, undefined, extraHeaders);

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.4.0-rc.337";
+export declare const VERSION = "0.5.0-dev.338";
 export declare class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     readonly models: Models;
@@ -55,9 +55,12 @@ export declare class RunBiOS {
      */
     readonly inference: Inference;
     /**
-     * The Conscious Loop. Capture what your model was asked and answered, record
-     * whether it was right, and turn those judgements into training data for
-     * SFT, DPO or GRPO. Nothing is captured until you turn it on for a source.
+     * The Conscious Loop: pipelines that keep improving a model from your app's
+     * conversations and your feedback. `loop.chat` asks a model and saves the
+     * conversation as a sample; `good()`, `bad()` and `correct(text)` on its
+     * answer say how it did. A call is saved only when it carries the pipeline
+     * ID (`chat`, or the `loop` option of `inference`), or when recording is
+     * switched on for its source.
      */
     readonly loop: Loop;
     /** @internal */
@@ -74,8 +77,9 @@ export { Integrations, type HuggingFaceIntegration, type IntegrationBrowseParams
 export { Training } from './resources/training.js';
 export { Wallet } from './resources/wallet.js';
 export { GPU, type GPURecommendation } from './resources/gpu.js';
+export { LoopNoVersionError, type LoopChatParams, type LoopChatResult, } from './resources/loop-chat.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 AnthropicMessageResponse, type LoopCaptureOption, type LoopSampleIdOnResult, LOOP_PIPELINE_HEADER, LOOP_SAMPLE_ID_HEADER, 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, TrainingStartFromParams, TrainingStartFrom, TrainingExportStep, 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, AttemptExplanation, PipelineAttemptListParams, PipelineAttemptListResponse, PipelineAttemptModelFilter, PipelineAttemptResultFilter, PipelineAttemptTrigger, Lineage, PipelineChain, PipelineChainRebuild, TrainingRunRollbackRefusalCode, LoopTraceRebuild, LoopTraceDeleteResponse, PipelineAttemptOutcome, PipelineLiveDeploymentStatus, PipelineLiveDeployment, LoopStorageWhere, LoopStorage, Pipeline, PipelineListParams, PipelineListStatus, PipelineListResponse, PipelineTrainingSettings, PipelineTrainingDefaults, PipelineTrainingRequest, PipelineResponse, PipelineTrainWhen, PipelineSchedule, PipelineWriteRequest, PipelineMutationResponse, PipelineImportParams, PipelineFloors, HeldBackFloors, LoopModel, LoopModelsResponse, LoopUnavailableModel, LoopUnavailableReasonCode, LoopTracePipeline, LoopTracePipelinesResponse, LoopMetricsHistoryParams, LoopMetricPoint, LoopSignalDay, LoopMetricsHistory, LoopCaptureFeedback, LoopFeedbackWord, LoopCaptureHealth, LoopCaptureMiss, LoopSignalManyItem, LoopSignalManyResult, 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, LoopTraceJudge, LoopJudgeFilter, LoopSampleState, LoopSampleStateName, LoopSampleDay, LoopImportRefusal, PipelineAutoScoring, PipelineAutoScoringStatus, LoopDatasetFeedback, LoopSampleOrigin, LoopFeedbackCounts, LoopPipelineCounts, LoopDatasetPipelineRef, LoopDataset, LoopDatasetWrite, LoopDatasetCreate, LoopDatasetPreviewParams, LoopDatasetPreviewModel, LoopDatasetPreview, LoopDatasetListParams, LoopDatasetListResponse, LoopDatasetDeleteResponse, PipelineDatasetRef, PipelineConditions, PipelineConditionsWrite, TrainedOnDataset, TrainedOn, } 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, TrainingExportStep, 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, BenchmarkQuestionsParams, BenchmarkQuestionsTraining, BenchmarkQuestionResult, BenchmarkQuestion, BenchmarkQuestionsResponse, TrainingCurvePoint, TrainingCurve, TrainingRuleRunRefusalCode, TrainingRuleSaveRefusalCode, TrainingRuleMonthlyLimitRefusal, PipelineStatus, PipelineActiveRun, PipelineVersion, PipelineAttempt, AttemptExplanation, AttemptMissedBar, PipelineModelRole, PipelineComparedWith, PipelineTotals, PipelineTrainingsByResult, PipelineTrainingsByModel, PipelineSpentParts, PipelineAttemptListParams, PipelineAttemptListResponse, PipelineAttemptModelFilter, PipelineAttemptResultFilter, PipelineAttemptTrigger, PipelineSecondModel, PipelineSecondModelState, Lineage, PipelineChain, PipelineChainRebuild, TrainingRunRollbackRefusalCode, TrainingRunRetestRefusalCode, LoopTraceRebuild, LoopTraceDeleteResponse, PipelineAttemptOutcome, PipelineLiveDeploymentStatus, PipelineLiveDeployment, LoopStorageWhere, LoopStorage, Pipeline, PipelineListParams, PipelineListStatus, PipelineListResponse, PipelineTrainingSettings, PipelineTrainingDefaults, PipelineTrainingRequest, PipelineResponse, PipelineTrainWhen, PipelineSchedule, PipelineWriteRequest, PipelineMutationResponse, PipelineImportParams, PipelineFloors, HeldBackFloors, LoopModel, LoopModelsResponse, LoopUnavailableModel, LoopUnavailableReasonCode, LoopTracePipeline, LoopTracePipelinesResponse, LoopMetricsHistoryParams, LoopMetricPoint, LoopSignalDay, LoopMetricsHistory, LoopCaptureFeedback, LoopFeedbackWord, LoopCaptureHealth, LoopCaptureMiss, LoopSignalManyItem, LoopSignalManyResult, PromotionPolicyState, RuleBenchmark, PipelineBenchmarksResponse, PipelineBenchmarkAttachParams, PipelineBenchmarkMoveParams, CompareBenchmark, VersionBenchmarkScore, PromotionMeasurement, PromotionOutcome, VersionHoldout, VersionCommonSet, VersionScores, VersionScoreDifference, VersionCompareResponse, VersionCompareParams, TrainingRunPromotion, VerdictCheck, VerdictCheckKey, VerdictChecksWithheld, TrainingRunCost, AttemptDirection, AttemptHoldout, AttemptCompareSide, AttemptSharedSample, AttemptSharedFigures, AttemptBenchmarkSide, AttemptCompareBenchmark, AttemptCompareItemSide, AttemptCompareItem, AttemptCompareResponse, AttemptCompareParams, LoopTraceJudge, LoopJudgeFilter, LoopSampleState, LoopSampleStateName, LoopSampleDay, LoopImportRefusal, PipelineAutoScoring, PipelineAutoScoringStatus, LoopDatasetFeedback, LoopSampleOrigin, LoopFeedbackCounts, LoopPipelineCounts, LoopDatasetPipelineRef, LoopDataset, LoopDatasetWrite, LoopDatasetCreate, LoopDatasetPreviewParams, LoopDatasetPreviewModel, LoopDatasetPreview, LoopDatasetListParams, LoopDatasetListResponse, LoopDatasetCreator, LoopDatasetLearnedBy, LoopDatasetExportParams, LoopDatasetExportLine, LoopDatasetExport, LoopDatasetDeleteResponse, PipelineDatasetRef, PipelineConditions, PipelineConditionsWrite, TrainedOnDataset, TrainedOn, } 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.4.0-rc.337';
+export const VERSION = '0.5.0-dev.338';
 export class RunBiOS {
     /** Search models, fetch configs, check adapter compatibility. */
     models;
@@ -55,9 +55,12 @@ export class RunBiOS {
      */
     inference;
     /**
-     * The Conscious Loop. Capture what your model was asked and answered, record
-     * whether it was right, and turn those judgements into training data for
-     * SFT, DPO or GRPO. Nothing is captured until you turn it on for a source.
+     * The Conscious Loop: pipelines that keep improving a model from your app's
+     * conversations and your feedback. `loop.chat` asks a model and saves the
+     * conversation as a sample; `good()`, `bad()` and `correct(text)` on its
+     * answer say how it did. A call is saved only when it carries the pipeline
+     * ID (`chat`, or the `loop` option of `inference`), or when recording is
+     * switched on for its source.
      */
     loop;
     /** @internal */
@@ -71,7 +74,6 @@ export class RunBiOS {
         this.training = new Training(http);
         this.wallet = new Wallet(http);
         this.gpu = new GPU(http);
-        this.loop = new Loop(http);
         // Inference-key resolution, most specific first:
         //   1. an explicit inferenceKey (a per-deployment sk-bios-... key)
         //   2. RUNBIOS_INFERENCE_KEY from the environment (legacy: BIOS_INFERENCE_KEY)
@@ -85,6 +87,9 @@ export class RunBiOS {
             baseUrl: config.inferenceBaseUrl || config.baseUrl,
             timeout: config.inferenceTimeout,
         }, http);
+        // Loop.chat asks a model through the same Inference resource, so it uses
+        // the same key resolution and base URL as client.inference.
+        this.loop = new Loop(http, this.inference);
     }
     async introspect() {
         return this._http.fetchGet('/api/api-keys/introspect');
@@ -102,6 +107,7 @@ export { Integrations } from './resources/integrations.js';
 export { Training } from './resources/training.js';
 export { Wallet } from './resources/wallet.js';
 export { GPU } from './resources/gpu.js';
+export { LoopNoVersionError, } from './resources/loop-chat.js';
 export { Inference, validateChatRequest, parseSSE, buildInferenceRequest, contextSizingBasis, CONTEXT_DEFAULT_CEILING, CONTEXT_EDITABLE_FLOOR, LOOP_PIPELINE_HEADER, LOOP_SAMPLE_ID_HEADER, } 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.js

@@ -373,7 +373,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-staging.runbios.ai').replace(/\/+$/, '');
+        this.baseUrl = (config.baseUrl || envBaseUrl() || 'https://api-dev.runbios.ai').replace(/\/+$/, '');
         this.timeout = config.timeout ?? 900_000;
         this._http = http;
     }

package/dist/resources/loop-chat.d.ts

@@ -0,0 +1,87 @@
+import type { LoopSignal } from '../types.js';
+import type { ChatMessage, ChatCompletionParams, ChatCompletionResponse } from './inference.js';
+/** The model name a pipeline's live version answers to: `loop-` and its pipeline ID. */
+export declare const PIPELINE_MODEL_PREFIX = "loop-";
+/**
+ * A pipeline ID as the platform reads it. The gateways trim and lowercase the
+ * `X-Loop-Pipeline` header and keep only this shape, and the pipeline's own
+ * model name is `loop-` and the ID exactly, matched case for case. So `chat`
+ * lowercases the ID before it names the header and the model, and refuses
+ * anything else before any request: sent, it would be dropped and nothing saved.
+ */
+export declare const PIPELINE_ID_PATTERN: RegExp;
+/**
+ * What `client.loop.chat` takes: the pipeline ID, the conversation, and
+ * optionally the model to ask. Anything else (`temperature`, `max_tokens`,
+ * `tools`, `requestId`, ...) is passed to `client.inference.chatCompletions`
+ * as it is.
+ */
+export interface LoopChatParams extends Record<string, unknown> {
+    /**
+     * The pipeline ID (its `own_tag`, e.g. `support-replies`): made from the
+     * pipeline's name when it was created, and it never changes. The Connect
+     * page shows it. Sent as the `X-Loop-Pipeline` header, lowercased as the
+     * platform reads it.
+     */
+    pipeline: string;
+    /** The conversation to send, as for `chatCompletions`. */
+    messages: ChatMessage[];
+    /**
+     * The model to ask. Leave it out to ask the pipeline's own model,
+     * `loop-<pipeline ID>`, which answers with the live version. Before the
+     * pipeline's first version nothing answers to that name: pass the model your
+     * app uses now (a serverless model id or a deployment name).
+     */
+    model?: string;
+    tools?: ChatCompletionParams['tools'];
+    toolChoice?: ChatCompletionParams['toolChoice'];
+    reasoningEffort?: ChatCompletionParams['reasoningEffort'];
+    inferenceKey?: string;
+    idempotencyKey?: string;
+    requestId?: string;
+    signal?: AbortSignal;
+}
+/**
+ * The answer `client.loop.chat` returns, with the feedback for it one call
+ * away. `good()`, `bad()` and `correct(text)` send feedback on `sample_id`,
+ * and wait and send again while the sample is still being saved (409
+ * `SAMPLE_NOT_YET_RECORDED`), as `signal` does.
+ */
+export interface LoopChatResult {
+    /**
+     * The model's answer as text: `choices[0].message.content`. Empty when the
+     * model answered only with tool calls; `raw` has them.
+     */
+    readonly answer: string;
+    /**
+     * The sample ID the reply's `X-Loop-Sample-Id` header carried, which
+     * feedback names. null when no sample ID came back (the platform was not
+     * recording calls just then), so the answer was not saved as a sample and
+     * cannot take feedback. A sample ID does not prove the pipeline ID is
+     * right: when no pipeline has it (misspelt, or the pipeline was deleted),
+     * the conversation is not saved under it. If recording is switched on for
+     * the model that answered, the call is still recorded the way that model
+     * records every call, and feedback on it is then accepted; when nothing
+     * records it, feedback on it is refused (409 `SAMPLE_NOT_YET_RECORDED` at
+     * first, 404 later). `stats()` counts such calls under `capture` (reason
+     * `no_pipeline`); the pipeline's Connect page shows its pipeline ID.
+     */
+    readonly sample_id: string | null;
+    /** The whole `/v1/chat/completions` answer, exactly as the endpoint sent it. */
+    readonly raw: ChatCompletionResponse;
+    /** Good: the answer is learned as it is. */
+    good(reason?: string): Promise<LoopSignal>;
+    /** Wrong: the answer is not learned. If you know the right answer, `correct` is worth far more. */
+    bad(reason?: string): Promise<LoopSignal>;
+    /** Wrong, and here is the right answer: the right answer is learned instead of the model's. */
+    correct(rightAnswer: string, reason?: string): Promise<LoopSignal>;
+}
+/**
+ * The error `client.loop.chat` rejects with when the pipeline's own model
+ * answers nothing. It is defined in client.ts beside the SDK's other
+ * `ApiError` subclasses: a class that extends `ApiError` is built when its
+ * module loads, and client.ts must have finished loading by then.
+ */
+export { LoopNoVersionError } from '../client.js';
+/** The answer's text: a string content, or the text parts of a list of parts. */
+export declare function chatAnswerText(raw: ChatCompletionResponse): string;

package/dist/resources/loop-chat.js

@@ -0,0 +1,32 @@
+/** The model name a pipeline's live version answers to: `loop-` and its pipeline ID. */
+export const PIPELINE_MODEL_PREFIX = 'loop-';
+/**
+ * A pipeline ID as the platform reads it. The gateways trim and lowercase the
+ * `X-Loop-Pipeline` header and keep only this shape, and the pipeline's own
+ * model name is `loop-` and the ID exactly, matched case for case. So `chat`
+ * lowercases the ID before it names the header and the model, and refuses
+ * anything else before any request: sent, it would be dropped and nothing saved.
+ */
+export const PIPELINE_ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,62}$/;
+/**
+ * The error `client.loop.chat` rejects with when the pipeline's own model
+ * answers nothing. It is defined in client.ts beside the SDK's other
+ * `ApiError` subclasses: a class that extends `ApiError` is built when its
+ * module loads, and client.ts must have finished loading by then.
+ */
+export { LoopNoVersionError } from '../client.js';
+/** The answer's text: a string content, or the text parts of a list of parts. */
+export function chatAnswerText(raw) {
+    const choices = raw.choices;
+    const first = Array.isArray(choices) ? choices[0] : undefined;
+    const content = first?.message?.content;
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => (part && typeof part === 'object' && typeof part.text === 'string'
+            ? part.text : ''))
+            .join('');
+    }
+    return '';
+}