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

package/dist/types.d.ts

@@ -2783,3 +2783,688 @@ export interface LoopLabelCount {
     traces: number;
     key: string;
 }
+export type TrainingCadence = 'none' | 'daily' | 'weekly';
+export type TrainingCombinator = 'and' | 'or';
+/** What answers the customer's traffic today, and therefore what promotion re-points. */
+export type ServingKind = 'serverless_slug' | 'deployment';
+export type TrainingRulePausedReason = 'consent_invalid' | 'insufficient_funds' | 'authorizer_not_member' | 'model_not_trainable' | 'platform_capacity'
+/** A peer was unreachable when the rule was saved, so it has not been validated yet. */
+ | 'validation_pending';
+/**
+ * How a training rule trains, on the wire of the automatic-training routes.
+ *
+ * DELIBERATELY NOT {@link TrainingMethod}. That union -- 'sft' | 'pt' -- is
+ * training-service's, and the two services enumerate different things: a
+ * training job can be a plain pre-training run, and a training rule cannot,
+ * while a rule may ask for preference training and a job asks for that through
+ * a different field. The values here are the loop service's own constants
+ * (TrainingMethodSFT / TrainingMethodRLHF in
+ * services/loop-service/cmd/training_types.go), which is what these routes
+ * accept and return. Sharing the training-service union here advertised 'pt',
+ * which this service refuses, and made 'rlhf', which it returns, unspellable.
+ *
+ * `rlhf_type` stays a plain string on purpose: the platform refuses it until
+ * capabilities enable preference training, and an SDK union would have to be
+ * republished to keep up with a server-side capability flag.
+ */
+export type LoopTrainingMethod = 'sft' | 'rlhf';
+export type TrainType = 'lora' | 'qlora' | 'full';
+export type GradersScope = 'source' | 'all' | 'none';
+export type TrainingTrigger = 'rows' | 'cadence' | 'both' | 'manual';
+export type TrainingRunState = 'built' | 'registering' | 'dataset_validating' | 'preflighting' | 'job_creating' | 'training' | 'checkpoint_ready' | 'candidate_booking' | 'candidate_running' | 'evaluating' | 'reported' | 'awaiting_review' | 'promoting' | 'waiting_funds' | 'promoted' | 'rejected' | 'expired' | 'failed' | 'budget_stopped' | 'cancelled' | 'superseded' | 'rolled_back';
+/** The closed set a run never leaves. */
+export declare const TERMINAL_RUN_STATES: readonly TrainingRunState[];
+export type TrainingVerdict = 'better' | 'not_better' | 'inconclusive' | 'not_evaluated';
+export type TrainingDecision = 'auto_promoted' | 'promoted' | 'rejected' | 'auto_rejected' | 'rolled_back';
+export type NotifyState = 'none' | 'pending' | 'sending' | 'sent' | 'suppressed' | 'failed';
+export type EvaluationStatus = 'open' | 'done' | 'failed' | 'budget_stopped';
+export type EvaluationItemStatus = 'pending' | 'working' | 'done' | 'failed';
+export type EvaluationWinner = 'candidate' | 'incumbent' | 'tie';
+/** Typed warning codes. Each surface renders its own plain sentence. */
+export type EvaluationWarningCode = 'holdout_too_small' | 'judge_unreliable' | 'graders_not_applied' | 'many_failures' | 'no_judge' | 'judge_labelled_training_rows' | 'capture_source_moved';
+export type ConsentVia = 'console' | 'api_key' | 'sdk' | 'mcp';
+/** A function an assistant turn asked to invoke. `arguments` is JSON-encoded. */
+export interface TrainingToolCall {
+    id?: string;
+    type?: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** One conversational turn, in the chat-completions shape. */
+export interface TrainingMessage {
+    role: string;
+    content?: string;
+    tool_calls?: TrainingToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+/** What serves this model today. The name is also the alias a promotion writes. */
+export interface TrainingRuleServing {
+    kind: ServingKind;
+    name: string;
+    /** Set only when kind is 'deployment'. */
+    deployment_id: string | null;
+}
+/** One rung of a ranked GPU ladder. The provider is the neutral public brand. */
+export interface TrainingGPURung {
+    gpu_type: string;
+    gpu_count: number;
+    provider: string;
+    region: string;
+    tier: string;
+}
+/** The consent object: one standing instruction to train, judge and possibly promote. */
+export interface TrainingRule {
+    id: string;
+    workspace_id: string;
+    build_rule_id: string;
+    name: string;
+    enabled: boolean;
+    /** Why the platform stopped firing this rule. Waiting must not look like broken. */
+    paused_reason: TrainingRulePausedReason | null;
+    cadence: TrainingCadence;
+    cadence_hour_utc: number;
+    cadence_weekday: number | null;
+    combinator: TrainingCombinator;
+    min_new_rows: number | null;
+    /** Spreads firings across the hour so every daily rule does not land on one minute. */
+    jitter_seconds: number;
+    next_due_at: string | null;
+    last_checked_at: string | null;
+    last_fired_at: string | null;
+    last_run_id: string | null;
+    /** Rendered verbatim: "waiting: ...", "due, but ...", "fired: run 7 from ...". */
+    last_reason: string | null;
+    serving: TrainingRuleServing;
+    model_id: string;
+    /** A 40-hex commit, pinned when the rule is saved. */
+    model_revision: string;
+    training_method: LoopTrainingMethod;
+    /** Refused by the platform until capabilities enable preference training. */
+    rlhf_type: string | null;
+    train_type: TrainType;
+    config: Record<string, unknown>;
+    train_gpu_priorities: TrainingGPURung[];
+    train_max_price_hour_cents: number;
+    deploy_gpu_priorities: TrainingGPURung[];
+    deploy_max_price_hour_cents: number;
+    training_ceiling_cents: number;
+    candidate_ceiling_cents: number;
+    /** A dollar figure, never a call count. */
+    eval_ceiling_cents: number;
+    monthly_ceiling_cents: number | null;
+    eval_judge_id: string | null;
+    eval_judge_model: string | null;
+    eval_graders_scope: GradersScope;
+    eval_max_rows: number;
+    eval_max_tokens: number;
+    min_holdout_rows: number;
+    auto_promote: boolean;
+    promote_margin: number;
+    promote_min_win_rate: number;
+    /** A gate, not a badge. */
+    min_judge_agreement: number;
+    review_window_hours: number;
+    candidate_boot_deadline_minutes: number;
+    keep_candidate_warm_minutes: number;
+    /** The member whose wallet pays, and the identity every peer call is stamped with. */
+    authorized_by: string;
+    terms_version: string;
+    revision: number;
+    /** Equal to revision only while the consent is current. */
+    accepted_revision: number;
+    accepted_at: string | null;
+    deleted_at: string | null;
+    created_at: string;
+    updated_at: string;
+}
+/** One append-only record of a member agreeing to spend, with the words they read. */
+export interface TrainingRuleConsent {
+    id: number;
+    rule_id: string;
+    workspace_id: string;
+    revision: number;
+    terms_version: string;
+    terms_text: string;
+    snapshot: Record<string, unknown>;
+    accepted_by: string;
+    accepted_via: ConsentVia;
+    accepted_at: string;
+}
+export interface TrainingRulePreflightRefusal {
+    stage: string;
+    code: string;
+    message: string;
+}
+/** One key that cannot follow a cutover, named so the caller can say which. */
+export interface TrainingRuleKeyRef {
+    key_id: string;
+    prefix: string;
+    name: string;
+}
+export interface TrainingRuleKeyCheck {
+    keys_missing_deployments_read: TrainingRuleKeyRef[];
+}
+/** The side-effect-free estimate, and the exact sentence the member will accept. */
+export interface TrainingRulePreflight {
+    valid: boolean;
+    model_revision: string;
+    worst_hourly_training_cents: number;
+    worst_hourly_candidate_cents: number;
+    max_training_hours: number;
+    max_candidate_hours: number;
+    /** Informational. The fence on evaluation is the dollar ceiling, never this. */
+    eval_calls_max: number;
+    training_ceiling_cents: number;
+    candidate_ceiling_cents: number;
+    eval_ceiling_cents: number;
+    warnings: string[];
+    refusals: TrainingRulePreflightRefusal[];
+    key_check: TrainingRuleKeyCheck;
+    terms_text: string;
+    terms_version: string;
+}
+export interface TrainingRuleBuildSpec {
+    method: string;
+    spec: Record<string, unknown>;
+}
+/**
+ * The editable half of a build rule.
+ *
+ * Deliberately not `LoopBuildRuleParams`: that type requires `name` and
+ * `method`, which the PUT route does not accept, so an edit written against it
+ * would have to resend two fields the platform ignores and a caller could not
+ * tell that changing them did nothing.
+ */
+export interface LoopBuildRuleUpdateParams {
+    enabled?: boolean;
+    /** Rows reviewed SINCE THE LAST BUILD before this fires again. Minimum 10. */
+    min_new_rows?: number;
+    /** The same selection `createDataset` takes, replayed verbatim. */
+    spec?: LoopDatasetCreateParams;
+}
+/**
+ * `?` means absent: leave that part of the sentence alone. `null` is only
+ * allowed where the column is nullable and clearing it is a real edit, and it
+ * is spelled out field by field rather than applied to the whole object.
+ */
+export interface TrainingRuleTriggerInput {
+    cadence?: TrainingCadence;
+    cadence_hour_utc?: number;
+    /** null drops the weekday, which is what a weekly rule moved to daily needs. */
+    cadence_weekday?: number | null;
+    combinator?: TrainingCombinator;
+    /** null removes the row floor, leaving the schedule as the only trigger. */
+    min_new_rows?: number | null;
+}
+export interface TrainingRuleTrainingInput {
+    model_id?: string;
+    model_revision?: string;
+    training_method?: LoopTrainingMethod;
+    /**
+     * A plain string, refused by the platform until capabilities enable
+     * preference training. null clears it, which is what moving a rule back to
+     * plain supervised training means.
+     */
+    rlhf_type?: string | null;
+    train_type?: TrainType;
+    config?: Record<string, unknown>;
+    train_gpu_priorities?: TrainingGPURung[];
+    train_max_price_hour_cents?: number;
+}
+export interface TrainingRuleDeployInput {
+    deploy_gpu_priorities?: TrainingGPURung[];
+    deploy_max_price_hour_cents?: number;
+    context_length?: number;
+    quant?: string;
+    serving_config?: Record<string, unknown>;
+    hf_integration_id?: string;
+}
+export interface TrainingRuleMoneyInput {
+    training_ceiling_cents?: number;
+    candidate_ceiling_cents?: number;
+    eval_ceiling_cents?: number;
+    /** null removes the monthly cap. Absent leaves it exactly where it stands. */
+    monthly_ceiling_cents?: number | null;
+    eval_max_rows?: number;
+}
+export interface TrainingRuleEvaluationInput {
+    /** null removes the judge from this rule. */
+    judge_id?: string | null;
+    /** null drops the override, returning to the judge's own advisory model. */
+    judge_model?: string | null;
+    graders_scope?: GradersScope;
+    min_holdout_rows?: number;
+    eval_max_tokens?: number;
+}
+export interface TrainingRulePromotionInput {
+    auto_promote?: boolean;
+    promote_margin?: number;
+    promote_min_win_rate?: number;
+    min_judge_agreement?: number;
+    review_window_hours?: number;
+    keep_candidate_warm_minutes?: number;
+}
+/**
+ * The version of the terms the member read and accepted.
+ *
+ * Send back the `terms_version` the preflight returned. The SDK deliberately
+ * ships no constant for it: a pinned version in a published package goes stale
+ * the moment the platform revises the terms, and the value a member consented
+ * to has to be the one they were actually shown.
+ */
+export interface TrainingRuleAcceptTerms {
+    terms_version: string;
+}
+/** The create body without the yes. The preflight route takes exactly this. */
+export interface TrainingRulePreflightRequest {
+    workspace_id?: string;
+    name?: string;
+    /** Exactly one of build_rule_id and build is given. */
+    build_rule_id?: string;
+    build?: TrainingRuleBuildSpec;
+    trigger?: TrainingRuleTriggerInput;
+    serving?: TrainingRuleServing;
+    training?: TrainingRuleTrainingInput;
+    deploy?: TrainingRuleDeployInput;
+    money?: TrainingRuleMoneyInput;
+    evaluation?: TrainingRuleEvaluationInput;
+    promotion?: TrainingRulePromotionInput;
+    enabled?: boolean;
+}
+export interface TrainingRuleCreateRequest extends TrainingRulePreflightRequest {
+    /** Absent is a refusal, not a default. */
+    accept_terms?: TrainingRuleAcceptTerms;
+}
+export interface TrainingRuleUpdateRequest extends TrainingRulePreflightRequest {
+    expected_revision?: number;
+    accept_terms?: TrainingRuleAcceptTerms;
+}
+export interface TrainingRuleConsentRequest {
+    terms_version: string;
+    revision: number;
+}
+export interface TrainingRuleListParams {
+    enabled?: boolean;
+    limit?: number;
+    offset?: number;
+}
+export interface TrainingRunPromoteRequest {
+    expected_revision?: number;
+    /** Required to promote an inconclusive comparison. */
+    force?: boolean;
+}
+export interface TrainingRunRejectRequest {
+    reason?: string;
+}
+export interface TrainingRunRollbackRequest {
+    reason?: string;
+}
+export interface TrainingRunCancelRequest {
+    reason?: string;
+}
+export interface TrainingRunListParams {
+    rule_id?: string;
+    state?: TrainingRunState;
+    limit?: number;
+    offset?: number;
+}
+/** One firing, from the curated set to the decision. Money is frozen at fire time. */
+export interface TrainingRun {
+    id: string;
+    rule_id: string | null;
+    rule_name: string | null;
+    workspace_id: string;
+    seq: number;
+    rule_revision: number;
+    authorized_by: string;
+    rule_snapshot: Record<string, unknown>;
+    trigger: TrainingTrigger;
+    fired_reason: string | null;
+    state: TrainingRunState;
+    state_entered_at: string;
+    attempts: number;
+    next_poll_at: string | null;
+    last_reason: string | null;
+    error_code: string | null;
+    last_error: string | null;
+    training_ceiling_cents: number;
+    candidate_ceiling_cents: number;
+    eval_ceiling_cents: number;
+    billed_training_cents: number;
+    billed_candidate_cents: number;
+    spent_eval_cents: number;
+    loop_dataset_id: string | null;
+    train_rows: number | null;
+    holdout_rows: number | null;
+    train_dataset_id: string | null;
+    holdout_dataset_id: string | null;
+    training_job_id: string | null;
+    job_status: string | null;
+    queue_deadline_at: string | null;
+    checkpoint_id: string | null;
+    checkpoint_step: number | null;
+    training_eval_loss: number | null;
+    candidate_deployment_id: string | null;
+    candidate_name: string | null;
+    candidate_seq: number;
+    candidate_status: string | null;
+    candidate_deadline_at: string | null;
+    candidate_cleanup_at: string | null;
+    evaluation_id: string | null;
+    alias_name: string | null;
+    alias_written_at: string | null;
+    serving_before: TrainingRuleServing | null;
+    rollback_available_until: string | null;
+    verdict: TrainingVerdict | null;
+    decision: TrainingDecision | null;
+    decided_by: string | null;
+    decided_at: string | null;
+    auto_promote_at: string | null;
+    review_deadline_at: string | null;
+    notify_state: NotifyState;
+    notify_event: string | null;
+    notify_error: string | null;
+    notify_attempts: number;
+    created_at: string;
+    updated_at: string;
+    finished_at: string | null;
+}
+/** One row of the Runs table, carrying everything the list draws. */
+export interface TrainingRunSummary {
+    id: string;
+    rule_id: string | null;
+    rule_name: string | null;
+    workspace_id: string;
+    seq: number;
+    trigger: TrainingTrigger;
+    state: TrainingRunState;
+    state_entered_at: string;
+    last_reason: string | null;
+    error_code: string | null;
+    verdict: TrainingVerdict | null;
+    decision: TrainingDecision | null;
+    train_rows: number | null;
+    holdout_rows: number | null;
+    billed_training_cents: number;
+    billed_candidate_cents: number;
+    spent_eval_cents: number;
+    training_job_id: string | null;
+    candidate_deployment_id: string | null;
+    evaluation_id: string | null;
+    review_deadline_at: string | null;
+    auto_promote_at: string | null;
+    notify_state: NotifyState;
+    created_at: string;
+    finished_at: string | null;
+}
+/** One line of the timeline. detail holds codes, ids and cents, never prompt text. */
+export interface TrainingRunEvent {
+    seq: number;
+    ts: string;
+    from_state: TrainingRunState | null;
+    to_state: TrainingRunState;
+    reason: string;
+    error_code: string | null;
+    detail: Record<string, unknown>;
+    actor: string;
+}
+export interface TrainingRunLinks {
+    training_job_url: string | null;
+    candidate_url: string | null;
+    dataset_url: string | null;
+    evaluation_url: string | null;
+}
+/** What this reader may do right now. A button that cannot work is never shown. */
+export interface TrainingRunActions {
+    promote: boolean;
+    reject: boolean;
+    rollback: boolean;
+    cancel: boolean;
+}
+export interface EvaluationRef {
+    kind: ServingKind;
+    name: string;
+    deployment_id: string | null;
+    model_version: string | null;
+}
+/** Frozen on the evaluation. Both sides are regenerated with identical decoding. */
+export interface EvaluationDecoding {
+    temperature: number;
+    max_tokens: number;
+    stream: boolean;
+}
+export interface EvaluationJudgeDimension {
+    key: string;
+    description: string;
+}
+export interface EvaluationDimensionScore {
+    dimension: string;
+    incumbent: number;
+    candidate: number;
+    delta: number;
+}
+export interface EvaluationGraderScore {
+    grader_id: string;
+    name: string;
+    incumbent: number;
+    candidate: number;
+    delta: number;
+    /** A grader that applied to four rows has not measured anything. */
+    items_applied: number;
+}
+export interface EvaluationWarning {
+    code: EvaluationWarningCode;
+    message: string;
+}
+/** The thresholds this verdict was measured against, frozen with the report. */
+export interface EvaluationMargin {
+    promote_margin: number;
+    promote_min_win_rate: number;
+    min_judge_agreement: number;
+    min_holdout_rows: number;
+}
+/**
+ * One rubric dimension of a judge-versus-human agreement.
+ *
+ * Deliberately not EvaluationDimensionScore: that type carries `incumbent` and
+ * `candidate`, which are the two models being compared, and an agreement has
+ * neither. `pairs` is per dimension because a reviewer who rated one dimension
+ * and skipped another leaves a different denominator behind each number.
+ */
+export interface JudgeAgreementDimension {
+    dimension: string;
+    pairs: number;
+    agreement: number | null;
+    mean_abs_error: number | null;
+}
+/** How often this judge agreed with the workspace's own reviewers. */
+export interface JudgeAgreement {
+    judge_id: string;
+    pairs: number;
+    agreement: number | null;
+    mean_abs_error: number | null;
+    per_dimension: JudgeAgreementDimension[];
+    window_days: number;
+    computed_at: string;
+    /** "Not enough reviewer overlap yet" is an answer; 100% of two is not. */
+    enough_pairs: boolean;
+}
+/** The comparison report: the candidate against what serves today, same rows. */
+export interface Evaluation {
+    id: string;
+    run_id: string;
+    workspace_id: string;
+    loop_dataset_id: string | null;
+    split: string;
+    incumbent_ref: EvaluationRef;
+    candidate_ref: EvaluationRef;
+    judge_id: string | null;
+    judge_name: string | null;
+    judge_model: string | null;
+    judge_instructions: string | null;
+    judge_dimensions: EvaluationJudgeDimension[];
+    judge_system_prompt: string | null;
+    grader_ids: string[];
+    decoding: EvaluationDecoding;
+    rows_selected: number;
+    rows_scored: number;
+    rows_failed: number;
+    /** win_rate is wins / (wins + losses). Ties are excluded and reported separately. */
+    wins: number | null;
+    losses: number | null;
+    ties: number | null;
+    win_rate: number | null;
+    incumbent_mean: number | null;
+    candidate_mean: number | null;
+    mean_delta: number | null;
+    judge_incumbent_mean: number | null;
+    judge_candidate_mean: number | null;
+    grader_incumbent_mean: number | null;
+    grader_candidate_mean: number | null;
+    grader_items_applied: number;
+    per_dimension: EvaluationDimensionScore[];
+    per_grader: EvaluationGraderScore[];
+    judge_agreement: JudgeAgreement | null;
+    /** Informational: there is no incumbent counterpart to compare it against. */
+    trainer_eval_loss: number | null;
+    warnings: EvaluationWarning[];
+    verdict: TrainingVerdict | null;
+    verdict_reason: string | null;
+    margin_used: EvaluationMargin | null;
+    prompt_tokens: number;
+    completion_tokens: number;
+    spent_cents: number;
+    status: EvaluationStatus;
+    last_error: string | null;
+    created_at: string;
+    finished_at: string | null;
+}
+/** One model's answer to one held-out conversation, with the scores it earned. */
+export interface EvaluationItemSide {
+    completion: string | null;
+    tool_calls: TrainingToolCall[] | null;
+    grader: Record<string, unknown> | null;
+    judge: Record<string, unknown> | null;
+    score: number | null;
+    model_version: string | null;
+}
+/**
+ * One paired conversation behind the numbers.
+ *
+ * trace_id is nullable on purpose: deleting one conversation must not shrink a
+ * finished report so that its stated n and its visible rows disagree.
+ */
+export interface EvaluationItem {
+    id: number;
+    dataset_item_id: number;
+    trace_id: string | null;
+    trace_url: string | null;
+    prompt: TrainingMessage[];
+    tools: unknown[] | null;
+    incumbent: EvaluationItemSide;
+    candidate: EvaluationItemSide;
+    human_verdict: number | null;
+    winner: EvaluationWinner | null;
+    status: EvaluationItemStatus;
+    error: string | null;
+}
+export interface EvaluationItemListParams {
+    winner?: EvaluationWinner;
+    /** Capped at 100 by the service. */
+    limit?: number;
+    offset?: number;
+}
+export interface JudgeAgreementParams {
+    /** RFC 3339. Narrows the window the agreement is computed over. */
+    from?: string;
+    to?: string;
+}
+/** Which model, whose words, how much. The cap is pushed to the workspace key. */
+export interface AgentSettings {
+    workspace_id: string;
+    default_model: string | null;
+    judge_system_prompt: string | null;
+    sampler_system_prompt: string | null;
+    eval_monthly_cap_cents: number | null;
+    updated_by: string | null;
+    updated_at: string;
+}
+/** Absent leaves a setting alone; a present null returns it to the platform default. */
+export interface AgentSettingsRequest {
+    default_model?: string | null;
+    judge_system_prompt?: string | null;
+    sampler_system_prompt?: string | null;
+    eval_monthly_cap_cents?: number | null;
+}
+/** A re-pointable public handle. Promotion is one row write here. */
+export interface InferenceAlias {
+    workspace_id: string;
+    name: string;
+    target_inference_id: string;
+    previous_target_inference_id: string | null;
+    /** Set only at adoption, when the alias takes over a deployment's own name. */
+    shadows_inference_id: string | null;
+    set_by: string;
+    origin: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface InferenceAliasRequest {
+    target_inference_id: string;
+    origin?: string;
+}
+export interface TrainingRuleListResponse {
+    rules: TrainingRule[];
+    total: number;
+}
+export interface TrainingRuleResponse {
+    rule: TrainingRule;
+    recent_runs: TrainingRunSummary[];
+    month_spent_cents: number;
+    judge_agreement: JudgeAgreement | null;
+}
+export interface TrainingRuleMutationResponse {
+    rule: TrainingRule;
+    /** The rule will not fire again until someone confirms the new amounts. */
+    consent_required: boolean;
+    preflight: TrainingRulePreflight | null;
+}
+export interface TrainingRuleDeleteResponse {
+    deleted: boolean;
+    rule_id: string;
+    cancelled_run_id: string | null;
+}
+export interface TrainingRunListResponse {
+    runs: TrainingRunSummary[];
+    total: number;
+}
+export interface TrainingRunResponse {
+    run: TrainingRun;
+    timeline: TrainingRunEvent[];
+    links: TrainingRunLinks;
+    available_actions: TrainingRunActions;
+}
+export interface TrainingRunActionResponse {
+    run: TrainingRun;
+    /** Set on rollback, the one action that changes what answers the traffic. */
+    serving: TrainingRuleServing | null;
+}
+export interface EvaluationItemsResponse {
+    items: EvaluationItem[];
+    total: number;
+}
+export interface AgentSettingsResponse {
+    settings: AgentSettings;
+}
+export interface InferenceAliasListResponse {
+    aliases: InferenceAlias[];
+}
+export interface InferenceAliasResponse {
+    alias: InferenceAlias;
+}
+export interface InferenceAliasDeleteResponse {
+    deleted: boolean;
+}

package/dist/types.js

@@ -1,4 +1,14 @@
 // ============================================================================
 // Run BiOS SDK — Type Definitions
 // ============================================================================
-export {};
+/** The closed set a run never leaves. */
+export const TERMINAL_RUN_STATES = [
+    'promoted',
+    'rejected',
+    'expired',
+    'failed',
+    'budget_stopped',
+    'cancelled',
+    'superseded',
+    'rolled_back',
+];