daishi-sdk 0.2.27 → 0.2.28

package/dist/generated.d.ts

@@ -424,32 +424,57 @@ export interface DeleteSkillResponse {
     deleted: string;
 }
 export interface EstimateResponse {
+    /** Agent turns one trial plays at most: seats times rounds. */
     agentTurns: number;
+    /** Low bound on one trial’s provider cost, US dollars, summed over its seats. */
     usdLow: number;
+    /** High bound on one trial’s provider cost, US dollars, summed over its seats. */
     usdHigh: number;
+    /** True when some seat’s model has no published price row, so its figure is a guess. */
     approximate: boolean;
+    /** Low bound on one trial’s wall clock, minutes, never above the run’s time cap. */
     minutesLow: number;
+    /** High bound on one trial’s wall clock, minutes, never above the run’s time cap. */
     minutesHigh: number;
+    /** True when even the low bound on the wall clock passes the run’s time cap, so the cap would stop the run before its last round. */
     hitsRunCap: boolean;
+    /** One row per seat priced. */
     perSeat: SeatEstimate[];
-    /** A plan’s limits as the server enforces them. `agentTurnsPerMonth` and `logRetentionDays` are null where the plan sets no limit. */
+    /** The plan the estimate was priced under. */
     plan: PlanLimits;
+    /** How the account holds that plan. */
     entitlement: Entitlement;
+    /** Who pays for each seat, in roster order: `user`, `sponsored`, or `guest` for an invited seat a peer’s agent plays on the peer’s keys. */
     funding: Array<'user' | 'sponsored' | 'guest'>;
+    /** The spend cap a launch on this plan starts with, US dollars. */
     cap_default_usd: number;
+    /** The highest spend cap this plan accepts, US dollars. */
     cap_max_usd: number;
+    /** The spend cap this request would get, US dollars. */
     cap_usd: number;
+    /** The plan’s agent turns per UTC month; null where it sets no cap. */
     agent_turns_limit: number | null;
+    /** Agent turns played this month. */
     agent_turns_used: number;
+    /** Agent turns held by runs still queued or playing. */
     agent_turns_reserved: number;
+    /** Turns left this month before this launch’s own reservation; null where the plan sets no cap. */
     agent_turns_remaining: number | null;
+    /** Runs the account holds queued or playing right now. */
     queued_runs: number;
+    /** Runs the plan lets the account hold queued or playing at once. */
     queued_runs_limit: number;
+    /** The wall-clock cap the run would get, minutes. */
     minutes_cap: number;
+    /** What the owner’s OpenRouter key may still spend, when the roster has own-key OpenRouter seats and OpenRouter reported a number; otherwise null. */
     openrouter_balance_usd: number | null;
+    /** Trials this launch would run; 1 is a single run. */
     trials: number;
+    /** The plan’s ceiling on trials in one batch. */
     trials_max: number;
+    /** Totals for the whole batch: what the launch commits to. */
     batch: EstimateBatch;
+    /** What this many trials buys before any of it runs. Sizing guidance, not a promise: a finished batch reports the spread it showed. */
     precision: EstimatePrecision;
 }
 export interface LaunchResponse {
@@ -468,12 +493,19 @@ export interface GetRunResponse {
     results: RunResults | null;
 }
 export interface UsageResponse {
+    /** When the view was built, Unix ms. */
     generated_at_ms: number;
+    /** Start of the current UTC month, Unix ms: the period the allowance counts in. */
     period_start_ms: number;
+    /** Where the account stands against its plan this month. */
     allowances: UsageAllowances | null;
+    /** The meter summed over every run on the account. */
     totals: UsageTotals;
+    /** One row per UTC month with at least one run, newest first. */
     months: UsageMonth[];
+    /** One row per model and provider, highest spend first, then most runs. */
     models: UsageModel[];
+    /** One row per run, newest first, capped. */
     runs: UsageRun[];
 }
 export interface ModelsResponse {
@@ -486,9 +518,13 @@ export interface ModelsResponse {
     caveat: string;
 }
 export interface LiveResponse {
+    /** One row per run of the owner’s that is playing now. */
     worlds: LiveWorld[];
+    /** One row per run of the owner’s that has not started. */
     waiting: LiveWaiting[];
+    /** Counts across the board. */
     totals: LiveResponseTotals;
+    /** When the board was read, Unix ms. */
     refreshed_at_ms: number;
 }
 export interface GetBatchResponse {
@@ -624,12 +660,19 @@ export interface RunLogsResponse {
     files: RunLogsResponseFile[];
 }
 export interface RunSeatsResponse {
+    /** The run’s id. */
     run_id: string;
+    /** The run’s status. */
     status: 'queued' | 'launching' | 'running' | 'finished' | 'failed' | 'cancelled';
+    /** Every harness version that played a Studio seat, distinct, in roster order. */
     harness_versions: string[];
+    /** Days the plan keeps a run’s logs; null where it keeps them. */
     retention_days: number | null;
+    /** The same window in a sentence. */
     retention_note: string;
+    /** True when no harness log is kept for the run any more: none was written, or the window passed. */
     logs_gone: boolean;
+    /** One row per seat, in roster order. */
     seats: SeatReport[];
 }
 export interface ListInvitesResponse {
@@ -1556,62 +1599,110 @@ export interface ValidateResponseReceiptWarning {
     message: string;
 }
 export interface SeatEstimate {
+    /** The seat’s model id. */
     model: string;
+    /** The provider the seat’s calls go to. */
     provider: string;
+    /** Who pays for the seat: `user` the owner’s own key, `sponsored` the operator. Absent where the request did not say. */
     funding?: 'user' | 'sponsored';
+    /** Low bound on this seat’s cost for one trial, US dollars. */
     usdLow: number;
+    /** High bound on this seat’s cost for one trial, US dollars. */
     usdHigh: number;
+    /** Where the price came from: `table` the price table’s row for the model, `catalog` the provider’s own catalog, `fallback` no published price, so the figure is a guess. */
     source: string;
 }
-/** A plan’s limits as the server enforces them. `agentTurnsPerMonth` and `logRetentionDays` are null where the plan sets no limit. */
+/** The plan the estimate was priced under. */
 export interface PlanLimits {
+    /** The plan: `free`, `starter`, `pro` or `lab`. */
     id: 'free' | 'starter' | 'pro' | 'lab';
+    /** The plan’s display name. */
     name: string;
+    /** Price of one month, US dollars. */
     priceMonthlyUsd: number;
+    /** Price of one year, US dollars. */
     priceYearlyUsd: number;
+    /** Seats (models) per run. The operator’s own ceiling can be lower. */
     seatsPerRun: number;
+    /** Longest run, in rounds (`ticks` in this API): one turn per seat, then the world update. */
     ticksPerRun: number;
+    /** Agent turns (one seat’s turn in one round) per UTC month; null where the plan sets no cap. */
     agentTurnsPerMonth: number | null;
+    /** Runs the account may hold queued or playing at once. A series batch counts as one. */
     queuedRuns: number;
+    /** Trials one series batch may hold. */
     seriesMaxTrials: number;
+    /** Wall-clock cap per run, minutes. The operator’s own ceiling can be lower. */
     runMaxMinutes: number;
+    /** Saved scenarios the account may hold. */
     savedScenarios: number;
+    /** Saved skills the account may hold. */
     savedSkills: number;
+    /** Runs the account may hold in all, every status counted. A launch past it answers `run_history_full`. */
     maxRuns: number;
+    /** Days a run’s logs are kept before they are deleted; null where the plan keeps them. */
     logRetentionDays: number | null;
+    /** Queue ordering: a higher number starts first. */
     queuePriority: number;
+    /** Head start in line, minutes: a waiting run is ordered as if it had queued this much earlier. */
     queueHeadStartMinutes: number;
+    /** The per-run spend cap a launch starts with, US dollars. */
     spendCapDefaultUsd: number;
+    /** The highest per-run spend cap the plan accepts, US dollars. */
     spendCapMaxUsd: number;
+    /** Members the plan lists. Informational: workspaces do not exist yet. */
     members: number;
+    /** Access tokens the account may hold at once. */
     apiTokens: number;
+    /** Per-token ceiling on developer API and Studio MCP calls per minute. */
     apiRequestsPerMinute: number;
+    /** What the plan switches on. */
     features: PlanFeatures;
 }
+/** What the plan switches on. */
 export interface PlanFeatures {
+    /** Series batches: several trials of one setup. */
     series: boolean;
+    /** A token may create scenarios and runs. Every plan may read, validate and estimate through a token. */
     api: boolean;
+    /** Every run plays on a private world of its own. True on every plan. */
     dedicatedWorld: boolean;
+    /** Guest seats: a peer’s own agent may take a seat through a link the owner shares. */
     invites: boolean;
 }
+/** How the account holds that plan. */
 export interface Entitlement {
-    /** A plan’s limits as the server enforces them. `agentTurnsPerMonth` and `logRetentionDays` are null where the plan sets no limit. */
+    /** The limits in force for the account right now. */
     plan: PlanLimits;
+    /** The subscription’s state as billing reports it; `none` with no subscription. */
     status: 'active' | 'trialing' | 'past_due' | 'canceled' | 'none';
+    /** When the current billing period ends, Unix ms; null with no subscription. */
     periodEndMs: number | null;
+    /** When a past-due subscription stops keeping its plan, Unix ms; null unless a payment is past due. */
     graceUntilMs: number | null;
+    /** Why the account holds this plan: `subscription` a subscription in good standing, `default` the deployment’s default plan, `grace` a past-due subscription still inside its grace window, `fallback` Free because the subscription lapsed, `exempt` an account the operator lists as never charged, which holds Lab. */
     source: 'subscription' | 'default' | 'grace' | 'fallback' | 'exempt';
 }
+/** Totals for the whole batch: what the launch commits to. */
 export interface EstimateBatch {
+    /** Agent turns across every trial. */
     agent_turns: number;
+    /** Low bound on the batch’s provider cost, US dollars. */
     usd_low: number;
+    /** High bound on the batch’s provider cost, US dollars. */
     usd_high: number;
+    /** Low bound on the batch’s wall clock, minutes. */
     minutes_low: number;
+    /** High bound on the batch’s wall clock, minutes. */
     minutes_high: number;
 }
+/** What this many trials buys before any of it runs. Sizing guidance, not a promise: a finished batch reports the spread it showed. */
 export interface EstimatePrecision {
+    /** The standard deviation between trials the figures assume, in Fitness Index points. */
     reference_spread: number;
+    /** Half-width of the 95% interval on the batch mean at the reference spread, by Student’s t on trials minus one degrees of freedom. */
     half_width: number;
+    /** What one run can miss by at the reference spread: the normal 95% half-width for a single draw. */
     single_run_half_width: number;
 }
 export interface LaunchResponseBatch {
@@ -1619,107 +1710,196 @@ export interface LaunchResponseBatch {
     trials: number;
     seed_mode: 'vary' | 'pinned';
 }
+/** Where the account stands against its plan this month. */
 export interface UsageAllowances {
+    /** The plan in force. */
     plan: UsageResponseAllowancesPlan;
+    /** True for an account the operator lists as never charged: Lab limits, nothing billed. */
     exempt: boolean;
+    /** The monthly agent-turn allowance. */
     agent_turns: UsageResponseAllowancesAgentTurns;
+    /** Runs queued or playing right now, against the plan’s slots. */
     queued_runs: UsageResponseAllowancesQueuedRuns;
+    /** The per-run spend cap on the owner’s own key: a stop, never a hold or a charge. */
     spend_cap_usd: UsageResponseAllowancesSpendCapUsd;
+    /** Access tokens against the plan’s count. */
     api_tokens: UsageResponseAllowancesApiTokens;
+    /** True when the operator sponsors keyless seats on this deployment. False means every seat runs on the owner’s own key. */
     sponsorship_available: boolean;
 }
+/** The plan in force. */
 export interface UsageResponseAllowancesPlan {
+    /** The plan: `free`, `starter`, `pro` or `lab`. */
     id: 'free' | 'starter' | 'pro' | 'lab';
+    /** The plan’s display name. */
     name: string;
+    /** The subscription’s state as billing reports it; `none` with no subscription. */
     status: 'active' | 'trialing' | 'past_due' | 'canceled' | 'none';
+    /** Why the account holds this plan: `subscription` a subscription in good standing, `default` the deployment’s default plan, `grace` a past-due subscription still inside its grace window, `fallback` Free because the subscription lapsed, `exempt` an account the operator lists as never charged, which holds Lab. */
     source: 'subscription' | 'default' | 'grace' | 'fallback' | 'exempt';
 }
+/** The monthly agent-turn allowance. */
 export interface UsageResponseAllowancesAgentTurns {
+    /** Agent turns played this month. */
     used: number;
+    /** Agent turns held by runs still queued or playing; given back when they settle. */
     reserved: number;
+    /** The plan’s agent turns per UTC month; null where it sets no cap. */
     limit: number | null;
+    /** The limit less used and reserved, never below zero; null where the plan sets no cap. */
     remaining: number | null;
 }
+/** Runs queued or playing right now, against the plan’s slots. */
 export interface UsageResponseAllowancesQueuedRuns {
+    /** Runs queued or playing right now. */
     held: number;
+    /** Runs the plan lets the account hold at once. */
     limit: number;
 }
+/** The per-run spend cap on the owner’s own key: a stop, never a hold or a charge. */
 export interface UsageResponseAllowancesSpendCapUsd {
+    /** The cap a launch starts with, US dollars. */
     default: number;
+    /** The highest cap the plan accepts, US dollars. */
     max: number;
 }
+/** Access tokens against the plan’s count. */
 export interface UsageResponseAllowancesApiTokens {
+    /** Live access tokens on the account. */
     held: number;
+    /** Access tokens the plan lets the account hold. */
     limit: number;
+    /** Each token’s ceiling on calls per minute. */
     requests_per_minute: number;
 }
+/** The meter summed over every run on the account. */
 export interface UsageTotals {
+    /** Model calls metered. */
     calls: number;
+    /** Input tokens across those calls. */
     tokens_in: number;
+    /** Output tokens across those calls. */
     tokens_out: number;
+    /** Input tokens the provider read from its cache. */
     cache_read_tokens: number;
+    /** Output tokens the provider counted as reasoning. */
     reasoning_tokens: number;
+    /** Provider cost at the price table’s rates, US dollars. */
     spend_usd: number;
+    /** That cost split by who paid. */
     by_payer: PayerUsd;
+    /** True when some call was priced by a wildcard row of the price table. */
     approximate: boolean;
+    /** Runs counted. */
     runs: number;
+    /** Agent turns those runs played. */
     agent_turns_used: number;
 }
+/** That cost split by who paid. */
 export interface PayerUsd {
+    /** Spent on the owner’s own keys, US dollars. */
     user: number;
+    /** Spent on the operator’s keys, US dollars. */
     sponsored: number;
 }
 export interface UsageMonth {
+    /** Start of the month, Unix ms. */
     start_ms: number;
+    /** Runs charged to the month. */
     runs: number;
+    /** Of those, runs that finished. */
     finished: number;
+    /** Agent turns those runs played. */
     agent_turns_used: number;
+    /** Model calls metered. */
     calls: number;
+    /** Input tokens across those calls. */
     tokens_in: number;
+    /** Output tokens across those calls. */
     tokens_out: number;
+    /** Input tokens the provider read from its cache. */
     cache_read_tokens: number;
+    /** Output tokens the provider counted as reasoning. */
     reasoning_tokens: number;
+    /** Provider cost at the price table’s rates, US dollars. */
     spend_usd: number;
+    /** That cost split by who paid. */
     by_payer: PayerUsd;
+    /** True when some call was priced by a wildcard row of the price table. */
     approximate: boolean;
 }
 export interface UsageModel {
+    /** The model id. */
     model: string;
+    /** The provider that served it. */
     provider: string;
+    /** Runs with a seat on this model. */
     runs: number;
+    /** Seats on this model across those runs. */
     seats: number;
+    /** Model calls metered. */
     calls: number;
+    /** Input tokens across those calls. */
     tokens_in: number;
+    /** Output tokens across those calls. */
     tokens_out: number;
+    /** Input tokens the provider read from its cache. */
     cache_read_tokens: number;
+    /** Output tokens the provider counted as reasoning. */
     reasoning_tokens: number;
+    /** Provider cost at the price table’s rates, US dollars. */
     spend_usd: number;
+    /** That cost split by who paid. */
     by_payer: PayerUsd;
+    /** True when some call was priced by a wildcard row of the price table. */
     approximate: boolean;
 }
 export interface UsageRun {
+    /** The run’s id. */
     run_id: string;
+    /** The run’s name. */
     name: string;
+    /** The scenario the run played. */
     scenario_id: string;
+    /** The run’s status. */
     status: 'queued' | 'launching' | 'running' | 'finished' | 'failed' | 'cancelled';
+    /** When the run was created, Unix ms. */
     created_at_ms: number;
+    /** When play started, Unix ms; null before it starts. */
     started_at_ms: number | null;
+    /** When the run ended, Unix ms; null while it has not. */
     ended_at_ms: number | null;
+    /** Seats the owner’s own agents drove. An invited seat is not one. */
     seats: number;
+    /** Invited seats: a peer’s agent on the peer’s own keys. Nothing of theirs is metered here. */
     guest_seats: number;
+    /** Distinct payers across the seats, in the order `user`, `sponsored`. */
     payers: Array<'user' | 'sponsored'>;
+    /** Agent turns the run played. */
     agent_turns_used: number;
+    /** Agent turns the run holds while it is queued or playing. */
     agent_turns_reserved: number;
+    /** The run’s spend cap, US dollars; null where it has none. */
     max_spend_usd: number | null;
+    /** Why the run stopped early; null where it did not. */
     stop_reason: string | null;
+    /** The price table that priced the run’s calls; null where none was recorded. */
     price_table_version: string | null;
+    /** Model calls metered. */
     calls: number;
+    /** Input tokens across those calls. */
     tokens_in: number;
+    /** Output tokens across those calls. */
     tokens_out: number;
+    /** Input tokens the provider read from its cache. */
     cache_read_tokens: number;
+    /** Output tokens the provider counted as reasoning. */
     reasoning_tokens: number;
+    /** Provider cost at the price table’s rates, US dollars. */
     spend_usd: number;
+    /** That cost split by who paid. */
     by_payer: PayerUsd;
+    /** True when some call was priced by a wildcard row of the price table. */
     approximate: boolean;
 }
 export interface ModelRow {
@@ -1770,110 +1950,198 @@ export interface ModelsResponsePooled {
     standalone: number;
 }
 export interface LiveWorld {
+    /** The run’s id. */
     run_id: string;
+    /** The run’s name. */
     name: string;
+    /** The series or experiment the run belongs to; null on a single run. */
     group: LiveGroup | null;
+    /** The match the run is playing; null before one opens. */
     match_id: string | null;
+    /** The run’s own world; null on a single-world server. */
     lobby_id: string | null;
+    /** The Live world page on this run, for its owner. */
     watch_url: string;
+    /** The match’s phase. */
     phase: string;
+    /** The current round. */
     round: number;
+    /** Rounds the run is set to play. */
     rounds: number;
+    /** Time since the round last advanced, ms. A slow model and a stalled world read differently here. */
     round_age_ms: number;
+    /** When play started, Unix ms. */
     started_at_ms: number;
+    /** When the run’s wall-clock cap stops it, Unix ms. */
     time_cap_at_ms: number;
+    /** Provider cost metered so far, US dollars. */
     spend_usd: number;
+    /** The run’s spend cap, US dollars; null where it has none. */
     max_spend_usd: number | null;
+    /** Map width in regions. */
     width: number;
+    /** Map height in regions. */
     height: number;
+    /** One letter per region, row by row: `f` forest, `m` mountain, `p` plains, `w` water, `r` ruins. */
     terrain: string;
+    /** The agents on the map. */
     seats: LiveSeat[];
+    /** The leading agents. */
     top: LiveResponseWorldTop[];
+    /** What only the owner can fix while fixing it still changes how this world plays. */
     flags: LiveFlag[];
+    /** Worth knowing, with nothing to do. */
     heads_up: LiveHeadsUp[];
+    /** The latest public event; null before one. Never an event marked private, and never message text. */
     last_event: LiveResponseWorldLastEvent | null;
 }
+/** The series or experiment the run belongs to; null on a single run. */
 export interface LiveGroup {
+    /** Whether the run is a trial of a `series` or of one arm of an `experiment`. */
     kind: 'series' | 'experiment';
+    /** The series batch’s or experiment’s id. */
     id: string;
+    /** Its name. */
     label: string;
+    /** The trial’s place within the series or arm, counted from 0. */
     trial: number;
+    /** Trials in the series or arm. */
     of: number;
+    /** The arm’s index on an experiment; null on a series. */
     arm: number | null;
+    /** The arm’s label on an experiment; null on a series. */
     arm_label: string | null;
 }
 export interface LiveSeat {
+    /** The agent’s name. */
     name: string;
+    /** The palette (0 to 7) the agent wears on the Live world page. */
     color: number;
+    /** Map column; null while the agent is not placed. */
     x: number | null;
+    /** Map row; null while the agent is not placed. */
     y: number | null;
+    /** Whether the agent is `active`, `dormant` or `dead`. */
     status: 'active' | 'dormant' | 'dead';
+    /** True for a peer’s own agent in an invited seat: the owner neither drives nor pays it. */
     guest: boolean;
+    /** True for a scenario baseline bot, which is not one of the run’s seats. */
     baseline: boolean;
 }
 export interface LiveResponseWorldTop {
+    /** The agent’s name. */
     name: string;
+    /** Its score so far. */
     score: number;
 }
 export interface LiveFlag {
+    /** `out_of_credit`: a provider is refusing a seat on the owner’s own key for lack of credit while the seat still tries. `guest_quiet`: a guest seat has gone quiet. */
     code: 'out_of_credit' | 'guest_quiet';
+    /** The seat it is about; null for the run as a whole. */
     seat: string | null;
+    /** What happened. */
     text: string;
+    /** The one thing to do about it, as an instruction. */
     action: string;
+    /** Where to do it; null where there is no page. */
     action_url: string | null;
 }
 export interface LiveHeadsUp {
+    /** `model_errors` and `rate_limited`: a seat’s model calls are failing. `seat_stopped`: a seat stopped playing. `forfeiting`: a seat is missing turns in a row. `spend_near_cap` and `time_near_cap`: the run is close to a cap. */
     code: 'model_errors' | 'rate_limited' | 'seat_stopped' | 'forfeiting' | 'spend_near_cap' | 'time_near_cap';
+    /** The seat it is about; null for the run as a whole. */
     seat: string | null;
+    /** What happened. */
     text: string;
 }
+/** The latest public event; null before one. Never an event marked private, and never message text. */
 export interface LiveResponseWorldLastEvent {
+    /** The round it happened in. */
     round: number;
+    /** What happened, in a few words. */
     text: string;
 }
 export interface LiveWaiting {
+    /** The run’s id. */
     run_id: string;
+    /** The run’s name. */
     name: string;
+    /** The series or experiment the run belongs to; null on a single run. */
     group: LiveGroup | null;
+    /** `in_line`: waiting for a free world. `own_limit`: the owner’s runs at once are all playing, so it starts when one ends. `guests`: its guest seats are still out. */
     reason: 'in_line' | 'own_limit' | 'guests';
+    /** Place in line across the platform when `in_line`; otherwise null. */
     place: number | null;
+    /** When the run is expected to start, ms from the refresh: an estimate from when the worlds ahead are expected to end. Null when nothing says. */
     starts_in_ms: number | null;
+    /** When the run queued, Unix ms. */
     queued_at_ms: number;
 }
+/** Counts across the board. */
 export interface LiveResponseTotals {
+    /** Worlds playing. */
     playing: number;
+    /** Runs waiting. */
     waiting: number;
+    /** Worlds carrying at least one flag. */
     needs_you: number;
+    /** Spend across the playing runs, US dollars. */
     spend_usd: number;
+    /** Sum of the playing runs’ spend caps, US dollars; null when any of them has none. */
     caps_usd: number | null;
 }
 export interface RunEstimate {
+    /** Agent turns one trial plays at most: seats times rounds. */
     agentTurns: number;
+    /** Low bound on one trial’s provider cost, US dollars, summed over its seats. */
     usdLow: number;
+    /** High bound on one trial’s provider cost, US dollars, summed over its seats. */
     usdHigh: number;
+    /** True when some seat’s model has no published price row, so its figure is a guess. */
     approximate: boolean;
+    /** Low bound on one trial’s wall clock, minutes, never above the run’s time cap. */
     minutesLow: number;
+    /** High bound on one trial’s wall clock, minutes, never above the run’s time cap. */
     minutesHigh: number;
+    /** True when even the low bound on the wall clock passes the run’s time cap, so the cap would stop the run before its last round. */
     hitsRunCap: boolean;
+    /** One row per seat priced. */
     perSeat: SeatEstimate[];
-    /** A plan’s limits as the server enforces them. `agentTurnsPerMonth` and `logRetentionDays` are null where the plan sets no limit. */
+    /** The plan the estimate was priced under. */
     plan: PlanLimits;
+    /** How the account holds that plan. */
     entitlement: Entitlement;
+    /** Who pays for each seat, in roster order: `user`, `sponsored`, or `guest` for an invited seat a peer’s agent plays on the peer’s keys. */
     funding: Array<'user' | 'sponsored' | 'guest'>;
+    /** The spend cap a launch on this plan starts with, US dollars. */
     cap_default_usd: number;
+    /** The highest spend cap this plan accepts, US dollars. */
     cap_max_usd: number;
+    /** The spend cap this request would get, US dollars. */
     cap_usd: number;
+    /** The plan’s agent turns per UTC month; null where it sets no cap. */
     agent_turns_limit: number | null;
+    /** Agent turns played this month. */
     agent_turns_used: number;
+    /** Agent turns held by runs still queued or playing. */
     agent_turns_reserved: number;
+    /** Turns left this month before this launch’s own reservation; null where the plan sets no cap. */
     agent_turns_remaining: number | null;
+    /** Runs the account holds queued or playing right now. */
     queued_runs: number;
+    /** Runs the plan lets the account hold queued or playing at once. */
     queued_runs_limit: number;
+    /** The wall-clock cap the run would get, minutes. */
     minutes_cap: number;
+    /** What the owner’s OpenRouter key may still spend, when the roster has own-key OpenRouter seats and OpenRouter reported a number; otherwise null. */
     openrouter_balance_usd: number | null;
+    /** Trials this launch would run; 1 is a single run. */
     trials: number;
+    /** The plan’s ceiling on trials in one batch. */
     trials_max: number;
+    /** Totals for the whole batch: what the launch commits to. */
     batch: EstimateBatch;
+    /** What this many trials buys before any of it runs. Sizing guidance, not a promise: a finished batch reports the spread it showed. */
     precision: EstimatePrecision;
 }
 export interface ExperimentEstimateDesign {
@@ -1933,89 +2201,160 @@ export interface RunLogsResponseFile {
     chunks: number;
 }
 export interface SeatReport {
+    /** The seat’s name. */
     name: string;
+    /** The seat’s model id. */
     model: string;
+    /** Who drove the seat: `studio` the reference harness on the owner’s configuration, `guest` an invited agent on its own keys. */
     driver: 'studio' | 'guest';
+    /** How the seat ended in the archive; null when the archive has not landed or the seat never played. */
     end_status: 'active' | 'dormant' | 'dead' | null;
+    /** The harness that played the seat. Null on a guest seat and on a run that has not launched. */
     harness: RunSeatsResponseSeatHarness | null;
+    /** What the seat said when asked after its epilogue: evidence of what it said, not of what it believed. Null until the harness reports it, and always null on a guest seat. */
     debrief: RunSeatsResponseSeatDebrief | null;
+    /** A scan for turns on which the seat spoke of being evaluated or observed unprompted. A screen for a few phrasings, not a measure of what the seat believed. Null until reported. */
     voiced: RunSeatsResponseSeatVoiced | null;
+    /** Rounds the seat forfeited, from the match’s own events. Null when the run has no match yet. */
     forfeits: RunSeatsResponseSeatForfeits | null;
+    /** The meter’s own counts. Null on a guest seat, which is not metered. */
     calls: RunSeatsResponseSeatCalls | null;
+    /** Run health, two rate limits kept apart. Null on a guest seat and on a run metered before health was recorded. */
     health: RunSeatsResponseSeatHealth | null;
+    /** The seat’s trajectory file, while the plan still keeps it; read it with the run log endpoint. */
     trajectory: RunSeatsResponseSeatTrajectory | null;
 }
+/** The harness that played the seat. Null on a guest seat and on a run that has not launched. */
 export interface RunSeatsResponseSeatHarness {
+    /** The harness version. */
     version: string | null;
+    /** The scaffold identity the harness reported. */
     scaffold: string | null;
+    /** The prompt version the seat played on. */
     prompt_version: string | null;
+    /** The frame the seat played under. */
     frame: string | null;
+    /** Where these came from: `trajectory` the seat’s own log header, `archive` what the match recorded at launch. */
     source: 'trajectory' | 'archive';
 }
+/** What the seat said when asked after its epilogue: evidence of what it said, not of what it believed. Null until the harness reports it, and always null on a guest seat. */
 export interface RunSeatsResponseSeatDebrief {
+    /** False when no debrief landed; the answers are then null and `note` says why. */
     asked: boolean;
+    /** Its answer to whether it believed the match was an evaluation of it. */
     believed_evaluation: 'yes' | 'no' | 'unsure' | 'unparsed' | null;
+    /** Its answer to whether that changed its play. */
     changed_play: 'yes' | 'no' | 'unsure' | 'unparsed' | null;
+    /** The cues it named. */
     cues: string[];
+    /** How it said its play changed; null where it gave none. */
     how: string | null;
+    /** Why no debrief landed, when `asked` is false. */
     note: string | null;
 }
+/** A scan for turns on which the seat spoke of being evaluated or observed unprompted. A screen for a few phrasings, not a measure of what the seat believed. Null until reported. */
 export interface RunSeatsResponseSeatVoiced {
+    /** Turns the scan flagged. */
     turns: number;
+    /** Turns the scan read. */
     turns_scanned: number;
+    /** Whether the scan flagged the seat’s epilogue; null where that is not recorded. */
     epilogue: boolean | null;
+    /** The scan’s version. */
     scan_version: string;
+    /** Flagged turns by what they said; a turn counts once per category. Null on a tally from before the split. */
     by_category: RunSeatsResponseSeatVoicedByCategory | null;
 }
+/** Flagged turns by what they said; a turn counts once per category. Null on a tally from before the split. */
 export interface RunSeatsResponseSeatVoicedByCategory {
+    /** Turns that called the match a test or evaluation. */
     evaluation: number;
+    /** Turns that said it was watched or scored. */
     observed: number;
+    /** Turns that said nothing real was at stake. */
     stakes: number;
 }
+/** Rounds the seat forfeited, from the match’s own events. Null when the run has no match yet. */
 export interface RunSeatsResponseSeatForfeits {
+    /** Rounds forfeited. */
     total: number;
+    /** Those rounds by cause. */
     by_cause: RunSeatsResponseSeatForfeitsByCause;
+    /** Each forfeited round, oldest first, up to 100. */
     rounds: RunSeatsResponseSeatForfeitsRound[];
+    /** True when the list stops short of every forfeited round. The counts still cover them all. */
     rounds_truncated: boolean;
 }
+/** Those rounds by cause. */
 export interface RunSeatsResponseSeatForfeitsByCause {
+    /** Rounds the seat spent on a tool that does not take a turn. */
     free_tool: number;
+    /** Rounds whose tool call failed. */
     refused_call: number;
+    /** Rounds with no turn in the seat’s trajectory. */
     no_turn: number;
+    /** Rounds forfeited for any other cause. */
     other: number;
 }
 export interface RunSeatsResponseSeatForfeitsRound {
+    /** The round. */
     tick: number;
+    /** Why it was forfeited. */
     cause: 'free_tool' | 'refused_call' | 'no_turn' | 'other';
+    /** The action the trajectory shows at that round; null when no turn was recorded. */
     action: string | null;
 }
+/** The meter’s own counts. Null on a guest seat, which is not metered. */
 export interface RunSeatsResponseSeatCalls {
+    /** Model calls the seat made. */
     model_calls: number;
+    /** Play turns it took; null where the meter did not record them. */
     turns: number | null;
+    /** Turns lost to a failed provider call. */
     error_turns: number;
+    /** The error the seat’s agent exited on; null where it recorded none. */
     exited_early: string | null;
+    /** Rounds the seat sat out while dormant. */
     sat_out_dormant: number;
+    /** Calls by the model that answered, as reported; null where none was reported. */
     served_models: JsonObject | null;
+    /** Calls by the provider that answered, as reported; null where none was reported. */
     served_by: JsonObject | null;
 }
+/** Run health, two rate limits kept apart. Null on a guest seat and on a run metered before health was recorded. */
 export interface RunSeatsResponseSeatHealth {
+    /** What the world refused of the seat’s own actions. */
     world_rejections: RunSeatsResponseSeatHealthWorldRejections;
+    /** Provider retries the harness rode out; null where it reported none. */
     provider_retries: RunSeatsResponseSeatHealthProviderRetries | null;
 }
+/** What the world refused of the seat’s own actions. */
 export interface RunSeatsResponseSeatHealthWorldRejections {
+    /** Actions past the seat’s per-round budget. */
     turn_budget: number;
+    /** Actions sent faster than the world’s pace floor. */
     pace: number;
+    /** Actions the seat could not take. */
     invalid: number;
 }
+/** Provider retries the harness rode out; null where it reported none. */
 export interface RunSeatsResponseSeatHealthProviderRetries {
+    /** Calls that needed a retry. */
     calls: number;
+    /** Retries in all. */
     retries: number;
+    /** Retries by cause. */
     causes: JsonObject;
+    /** Time spent waiting between retries, ms. */
     wait_ms: number;
 }
+/** The seat’s trajectory file, while the plan still keeps it; read it with the run log endpoint. */
 export interface RunSeatsResponseSeatTrajectory {
+    /** The file’s name. */
     file: string;
+    /** Lines in the file. */
     lines: number;
+    /** The file’s size in bytes. */
     bytes: number;
 }
 export interface CreateSetBodySetup {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Operations, type ErrorCode, type GetBatchResponse, type GetExperimentResponse, type GetRunResponse, type Method, type RequestParts } from './generated.js';
 export * from './generated.js';
-export declare const VERSION = "0.2.27";
+export declare const VERSION = "0.2.28";
 export declare const DEFAULT_BASE_URL = "https://daishi.ai/api/v1";
 export interface DaishiOptions {
     /** A Studio access token (`dsk_...`). Default: the `DAISHI_TOKEN` environment variable. */

package/dist/index.js

@@ -1,6 +1,6 @@
 import { Operations } from './generated.js';
 export * from './generated.js';
-export const VERSION = '0.2.27';
+export const VERSION = '0.2.28';
 export const DEFAULT_BASE_URL = 'https://daishi.ai/api/v1';
 /** A refusal from the API, or a transport failure after the retries ran out. */
 export class DaishiError extends Error {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "daishi-sdk",
-  "version": "0.2.27",
+  "version": "0.2.28",
   "description": "Typed client for the Daishi Studio API: scenarios, runs, series batches and paired experiments, with retries and waiting helpers.",
   "keywords": [
     "daishi",