daishi-sdk 0.2.28 → 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. */
@@ -791,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;
@@ -807,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 {

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.28";
+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.28';
+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.28",
+  "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",