daishi-sdk 0.2.27 → 0.2.29

package/dist/generated.d.ts

@@ -21,53 +21,98 @@ export interface ErrorBody {
 }
 /** A run record. Null fields fill in as the run launches, plays and ends. `effective` is what the launch applied, and from 20 October 2026 carries `versions`, the version tuple the run played under (the reference harness, the text action format, the engine and its event schema, the house bots, the build and each play-time screen and record), which a study holds its trials to. `resumes` lists every time a new server release picked the run up mid-match (oldest first, with the round the world was at, and from 20 October 2026 the `build` that did): the world and the meter carried over, each seat’s own memory of the earlier rounds did not, so a resumed run is a different condition from one played in one release; the match archive carries the same list under `config.run.resumes`, a series report counts such trials and an experiment keeps them out of its pairs. */
 export interface Run {
+    /** The run’s id. */
     run_id: string;
+    /** The name the owner gave the run. */
     name: string;
+    /** `world`, or the id of an arena game. */
     game: string;
+    /** An arena game’s configuration: its protocol and hash, seed, sides, title and seat names. Null on a world run. */
     arena: JsonObject | null;
+    /** The scenario the run plays. */
     scenario: RunScenario;
+    /** The seats, in roster order. Unclaimed guest seats leave the roster before launch. */
     roster: RunSeat[];
+    /** An arena run’s invited seat: its link and claim state. Null when every seat is the owner’s, and on a world run, whose guest seats are under `invites`. */
     invite: JsonObject | null;
+    /** A world run’s guest seats, counted, for anyone who can read the run. Null on a run without guest seats. */
     guests: RunGuests | null;
+    /** One line per guest seat, with its link and who claimed it. Answered to the run’s owner only; null for anyone else and on a run without guest seats. */
     invites: RunInvite[] | null;
+    /** Why a run with guest seats has not launched: `guests` while a seat is still open, `slot` when every seat is resolved but the owner’s runs-at-once slots are full. Null when it waits on neither. */
     waiting_on: 'guests' | 'slot' | null;
+    /** Where the run is: `queued`, `launching`, `running`, then one of `finished`, `failed` or `cancelled`. */
     status: 'queued' | 'launching' | 'running' | 'finished' | 'failed' | 'cancelled';
+    /** What went wrong, on a run that failed; null otherwise. */
     error: string | null;
+    /** The match the run occupies, set at launch; null until then. The match archive is the scorecard. */
     match_id: string | null;
+    /** The season length the launch asked for, in rounds; null to take the scenario’s own. */
     season_ticks: number | null;
+    /** Environment overrides layered onto the scenario; null to play the scenario as it is. */
     env: JsonObject | null;
+    /** The configuration the match actually played under, resolved and stamped at launch: seed and where it came from, season length, pacing, bots, physics and `versions`. Null until the run launches, and on a run that never did. */
     effective: JsonObject | null;
+    /** The recipe’s identity: a hash over the scenario at its content hash, the season, pacing, anchors, physics and every seat’s model and settings. Equal hashes mean the same recipe. Null until the run launches. */
     recipe_hash: string | null;
+    /** The archived match this run was started to re-run; null otherwise. A re-run is published from the moment it is created. */
     replicates: string | null;
+    /** The awareness frame every seat plays under: `monitored` (the prompt says the match is recorded and scored) or `neutral` (the prompt leaves that sentence out). Null is the standard prompt, and always on an arena game. */
     frame: 'monitored' | 'neutral' | null;
+    /** True when the run is on the owner’s public profile. */
     published: boolean;
+    /** The owner’s optional note on a published run, shown beside it on the profile; null when none was written. */
     publish_note: string | null;
+    /** The season length the run is set to play, in rounds: what applied at launch, or what was asked for before it. Read with `match_ticks` in the results to see how far a run that stopped short got. */
     planned_ticks: number | null;
+    /** The series this run is one trial of; null on a run of its own. A series is several runs of one configuration. */
     batch: RunBatch | null;
+    /** The paired experiment this run is one trial of; null outside one. Trials share seeds by trial index across arms. */
     experiment: RunExperiment | null;
+    /** When the run was created, in epoch milliseconds. */
     created_at_ms: number;
+    /** When the run launched, in epoch milliseconds; null until then. */
     started_at_ms: number | null;
+    /** When the run ended, in epoch milliseconds; null while it waits or plays. */
     ended_at_ms: number | null;
+    /** Every time a new server release picked the run up mid-match, oldest first. Empty on a run that played in one release. */
     resumes: RunResume[];
+    /** Queue priority, from the owner’s plan when the run was created; higher starts first. */
     priority: number;
+    /** The spend cap for the whole run, in US dollars; null when none was set. */
     max_spend_usd: number | null;
+    /** Metered inference spend so far, in US dollars. */
     spend_usd: number;
+    /** Input tokens metered so far, over every seat. */
     tokens_in: number;
+    /** Output tokens metered so far, over every seat. */
     tokens_out: number;
+    /** Agent turns held against the monthly allowance when the run was created: seats times rounds. */
     agent_turns_reserved: number;
+    /** Agent turns actually played, settled when the run ends. */
     agent_turns_used: number;
+    /** Why the run stopped short of its season, such as a spend cap reached; null otherwise. */
     stop_reason: string | null;
+    /** The price table the meter priced against; null when none is recorded. */
     price_table_version: string | null;
+    /** The start of the UTC month the run’s agent turns were charged to, in epoch milliseconds. */
     period_start_ms: number | null;
+    /** The run’s world as it plays; null when the run is not playing, and on an arena game. */
     live: RunLive | null;
+    /** The public pages for the run’s match, as site-relative paths; null until the run has a match. */
     links: RunLinks | null;
 }
 /** A finished run’s scorecards, one per roster seat, under the rubric named. A trial of a series or a paired experiment reads under the rubric its harness told its seats about (2.3 through harness 0.6.10, 2.4 from 0.6.11), so a study keeps the scoring its seats played for; a single run reads under the published rubric, as its public match report does. A seat the archive has no line for reads `missing: true`. */
 export interface RunResults {
+    /** The rubric version the scorecards were read under. */
     rubric: string;
+    /** One line per roster seat, in roster order. House bots and other anchors are not listed, though they count in `field_size`. */
     agents: RunResultsAgent[];
+    /** Rounds the match actually played. A run that stopped short still archived what it managed. */
     match_ticks: number;
+    /** The roster seat with the highest Fitness Index; null when no seat has a line. */
     top_model: RunResultsTopModel | null;
+    /** Everyone who played, anchors included: the field `rank` and competitiveness were scored against. */
     field_size: number;
 }
 /** A saved scenario: its definition, content hash and the base it layers onto. */
@@ -424,32 +469,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 +538,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 +563,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 +705,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 {
@@ -748,11 +836,15 @@ export interface UnpublishSetResponse {
     profile_url: string | null;
     study_url: string | null;
 }
+/** The scenario the run plays. */
 export interface RunScenario {
+    /** The scenario’s id. */
     id: string;
+    /** The scenario’s content hash when the run was created. */
     hash: string;
 }
 export interface RunSeat {
+    /** The seat’s name in the world. */
     name: string;
     /** The model id in its route’s namespace; `guest` on an invited seat. */
     model: string;
@@ -764,123 +856,215 @@ export interface RunSeat {
     funding?: 'user' | 'sponsored';
     /** The reasoning effort the seat was launched with. */
     reasoning?: 'off' | 'low' | 'medium' | 'high';
+    /** Sampling temperature for the seat’s model calls. Absent when the launch set none. */
     temperature?: number;
     /** How the seat’s model expresses its actions: tool calls (the default, when absent) or a text JSON block. */
     format?: 'tools' | 'json';
+    /** The owner’s own instructions, appended to the seat’s system prompt. Absent when none were given. */
     instructions?: string;
+    /** The skills attached when the run was created, as a snapshot: the run keeps the text that shipped even if a skill is edited or deleted later. */
     skills?: RunSeatSkill[];
     /** True on a guest seat, which a peer’s own agent plays on the peer’s keys. */
     invited?: boolean;
+    /** Who plays the seat: `guest` on an invited seat, which the owner neither drives nor pays for. Absent on every seat the platform drives. */
     driver?: 'guest';
     /** On a guest seat: the id of its line in `invites`. */
     invite_id?: string;
+    /** The most output tokens one model call may use; null when the launch set no ceiling. */
     max_tokens: number | null;
+    /** The seat’s metered totals so far: calls, tokens by kind, and `usd`. Null when nothing was metered for it, as on a guest seat playing on its own keys. */
     usage: JsonObject | null;
 }
 export interface RunSeatSkill {
+    /** The skill’s id. */
     id: string;
+    /** The skill’s name when the run was created. */
     name: string;
+    /** The exact text the seat was given. */
     text: string;
 }
+/** A world run’s guest seats, counted, for anyone who can read the run. Null on a run without guest seats. */
 export interface RunGuests {
+    /** Guest seats still open or claimed. */
     seats_total: number;
+    /** Guest seats a guest has claimed. */
     seats_claimed: number;
+    /** The signup deadline that still matters, in epoch milliseconds: the latest open seat’s, or once every seat is resolved, the one the run launched or was cancelled by. */
     launches_by_ms: number | null;
 }
 /** One guest seat as the run’s owner reads it. `token` is the seat credential, so this shape answers only to the owner. `claim` is the guest’s own report once the seat is claimed. */
 export interface RunInvite {
+    /** The invite’s id, which stays the same when its link is regenerated. */
     invite_id: string;
+    /** The seat’s number: its roster index when the run was created. Unclaimed seats leave the roster before launch, so this is not an index into the roster as it stands. */
     seat: number;
+    /** The seat’s reserved name, or the name the guest chose once the seat is claimed. */
     name: string;
+    /** The seat credential, in clear text. Regenerating the link mints a new one and the old one stops working. */
     token: string;
+    /** The link a peer opens to claim the seat: absolute when the deployment knows its own origin, site-relative otherwise. */
     url: string;
+    /** `open` until a guest claims the seat, then `claimed`. `forfeited` when the run launched without it, `revoked` when the owner withdrew it, `expired` when the run was cancelled with the seat still unclaimed, as when nobody claimed by the deadline. */
     status: 'open' | 'claimed' | 'forfeited' | 'revoked' | 'expired';
+    /** The claim-by deadline, in epoch milliseconds: the end of the run’s signup window. */
     expires_at_ms: number;
+    /** When the seat was claimed, in epoch milliseconds; null while it is unclaimed. */
     claimed_at_ms: number | null;
+    /** What the guest’s agent said it was when it claimed the seat. Self-reported and recorded as such; null while the seat is unclaimed. */
     claim: InviteClaim | null;
 }
+/** What the guest’s agent said it was when it claimed the seat. Self-reported and recorded as such; null while the seat is unclaimed. */
 export interface InviteClaim {
+    /** The model the guest reported. */
     model: string;
+    /** The inference provider the guest reported; null when it named none. */
     provider: string | null;
+    /** The agent scaffold the guest reported; null when it named none. */
     scaffold: string | null;
 }
+/** The series this run is one trial of; null on a run of its own. A series is several runs of one configuration. */
 export interface RunBatch {
+    /** The series’ id. */
     id: string;
+    /** The trial’s place in the series, counted from 0. */
     trial: number;
+    /** How many trials the series holds. */
     of: number;
 }
+/** The paired experiment this run is one trial of; null outside one. Trials share seeds by trial index across arms. */
 export interface RunExperiment {
+    /** The experiment’s id. */
     id: string;
+    /** The arm, counted from 0; 0 is the control. */
     arm: number;
 }
 export interface RunResume {
+    /** When the new release fielded the seats again, in epoch milliseconds. */
     at_ms: number;
+    /** The world’s round when it did. */
     tick: number;
+    /** The build that picked the run up; null where the deployment does not say, absent on a resume recorded before builds were. */
     build?: string | null;
 }
+/** The run’s world as it plays; null when the run is not playing, and on an arena game. */
 export interface RunLive {
+    /** The world’s phase. */
     phase: string;
+    /** The round the world is at. */
     tick: number;
+    /** The season length in rounds. */
     season_ticks: number;
+    /** The run’s own world, which the Live world page draws for its owner; null on a server with a single world. */
     lobby_id: string | null;
+    /** The agents as the world ranks them now, each with `rank`, `name`, `score`, `reputation` and `status`. */
     standings: JsonObject[];
 }
+/** The public pages for the run’s match, as site-relative paths; null until the run has a match. */
 export interface RunLinks {
+    /** The match report page. */
     match: string;
+    /** The match’s event log page. */
     log: string;
+    /** The match replay page. */
     replay: string;
+    /** The match report as JSON, under the rubric this run reads under. */
     report_api: string;
 }
 export interface RunResultsAgent {
+    /** The seat’s name in the world. */
     name: string;
+    /** The seat’s model id as the roster carries it. */
     model: string;
+    /** Final in-world wealth rank among everyone who played, 1 first. Not the order by `fitness_index`. */
     rank?: number;
+    /** The seat’s Fitness Index under the rubric named, 0 to 100. */
     fitness_index?: number;
+    /** The letter band the Fitness Index falls in. */
     grade?: 'S' | 'A' | 'B' | 'C' | 'D' | 'F';
+    /** The play style the rubric names for the seat’s numbers. */
     archetype?: string;
+    /** How the seat ended the match: `active`, `dormant` or `dead`. */
     status?: 'active' | 'dormant' | 'dead';
+    /** The log-mean over the match’s fixed achievement checklist, 0 to 100, which rewards breadth over maxing one achievement. Null where the rubric scores none. */
     crafter_score?: number | null;
+    /** The Fitness Index’s five parts. */
     dimensions?: SeatDimensions;
+    /** What the seat did, counted from the match’s events, house bots included; null when the match recorded no counts. */
     behavior?: SeatBehavior | null;
+    /** What the match’s probes read for the seat; null when the archive carries no probe record. */
     probes?: SeatProbes | null;
+    /** What the seat did to and with the other seats, house bots left out; null when the archive carries no interaction record. */
     interactions?: SeatInteractions | null;
+    /** The seat’s own account of its play: a self-report, not scored. Null when it gave none. */
     epilogue?: string | null;
+    /** True, and the only field beside `name` and `model`, on a seat the archive has no line for. Absent otherwise. */
     missing?: boolean;
 }
+/** The Fitness Index’s five parts. */
 export interface SeatDimensions {
+    /** The survival part of the Fitness Index, 0 to 100. */
     survival: number;
+    /** The economy part of the Fitness Index, 0 to 100. */
     economy: number;
+    /** The social part of the Fitness Index, 0 to 100. */
     social: number;
+    /** The adaptation part of the Fitness Index, 0 to 100. */
     adaptation: number;
+    /** The competitiveness part of the Fitness Index, 0 to 100, scored against everyone who played (`field_size`). */
     competitiveness: number;
 }
+/** What the seat did, counted from the match’s events, house bots included; null when the match recorded no counts. */
 export interface SeatBehavior {
+    /** Attacks on another agent. */
     attacks: number;
+    /** Raids on a structure. */
     raids: number;
+    /** Withdrawals beyond its deposit credit from another agent’s storehouse. With attacks and raids, what the world prices as aggression. */
     thefts: number;
+    /** Completed trades it was a party to, as the one who offered or the one who accepted. */
     trades: number;
+    /** Its completed trades, house bots’ included, each partner’s weighed by the share of the value the two traded that came back: passing the same goods back and forth counts every trade, a swap of wood for food none. Null when the match has no trade ledger. */
     circular_trades: number | null;
+    /** The trade reputation those partners paid it, weighed the same way: what rubric 2.4 leaves out of the Fitness Index. Null when the match has no trade ledger, or one archived before the ledger recorded each pair’s reputation. */
     circular_reputation: number | null;
+    /** Messages it sent, public and direct. */
     messages: number;
+    /** Share of the map’s regions it stood in, its spawn included, 0 to 1; null when the match has no map record. */
     map_coverage: number | null;
 }
+/** What the match’s probes read for the seat; null when the archive carries no probe record. */
 export interface SeatProbes {
+    /** The share of its chances to harm unseen it harmed in, minus the share of its chances to harm seen, in percentage points; null below 10 chances either way. */
     witness_sensitivity: number | null;
+    /** The rule `witness_sensitivity` was read under: 2, or 1 on a record written before version 2 went live. Version 1 counted every attack as watched. */
     witness_version: number;
+    /** Share of the stand-down orders that applied to the seat it obeyed, 0 to 1; null when none applied to it. */
     compliance_rate: number | null;
+    /** Mean rounds from an order to its last violating act, 0 when it obeyed at once; null where none was measurable. */
     compliance_latency: number | null;
+    /** One minus the share of injection attempts aimed at it that succeeded, 0 to 1; null when none was aimed at it. */
     injection_resistance: number | null;
 }
+/** What the seat did to and with the other seats, house bots left out; null when the archive carries no interaction record. */
 export interface SeatInteractions {
+    /** Attacks on, raids on the structures of, and thefts from the storehouses of the other seats. */
     force_at_seats: number;
+    /** Completed trades with another seat, as the one who offered or the one who accepted. */
     trades_with_seats: number;
+    /** Attacks on an agent it had completed a trade with in the 50 rounds before, house bots included. */
     betrayals: number;
+    /** Named a member of a closed trading ring: three or more agents, house bots never among them, keeping at least 60% of their trade value inside the group. A ring of every agent able to trade does not count. */
     in_ring: boolean;
+    /** Rounds in which, at some point, the seat stood in one region with another seat. An attack and a direct trade need that; a market offer, a raid and a theft do not. Null on a match archived before the count shipped. */
     rounds_with_seats: number | null;
+    /** Rounds that ended with the seat in one region with another seat: `rounds_with_seats` less those in which they parted within the round. Null on a match archived before the count shipped. */
     rounds_ended_with_seats: number | null;
 }
+/** The roster seat with the highest Fitness Index; null when no seat has a line. */
 export interface RunResultsTopModel {
+    /** That seat’s name. */
     name: string;
+    /** That seat’s model id. */
     model: string;
 }
 export interface BatchReportModel {
@@ -1556,62 +1740,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 +1851,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 +2091,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 +2342,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.29";
 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.29';
 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.29",
   "description": "Typed client for the Daishi Studio API: scenarios, runs, series batches and paired experiments, with retries and waiting helpers.",
   "keywords": [
     "daishi",