daishi-sdk 0.2.26 → 0.2.28

package/dist/generated.d.ts

@@ -29,7 +29,7 @@ export interface Run {
     roster: RunSeat[];
     invite: JsonObject | null;
     guests: RunGuests | null;
-    invites: JsonObject[] | null;
+    invites: RunInvite[] | null;
     waiting_on: 'guests' | 'slot' | null;
     status: 'queued' | 'launching' | 'running' | 'finished' | 'failed' | 'cancelled';
     error: string | null;
@@ -335,6 +335,40 @@ export interface SkillBody {
     /** The directions. Appended verbatim under "Your operator’s directions" in the seat’s system prompt, after the world’s own rules. */
     text: string;
 }
+export interface IndexResponse {
+    api: string;
+    version: number;
+    docs: string;
+    openapi: string;
+    mcp: string;
+    auth: string;
+    endpoints: string[];
+}
+export interface MeResponse {
+    user: MeResponseUser;
+    plan: MeResponsePlan;
+    api_access: 'read' | 'full';
+    token: MeResponseToken;
+    limits: MeResponseLimits;
+}
+export interface LibraryScenariosResponse {
+    scenarios: LibraryScenario[];
+}
+export interface LibraryAnchorsResponse {
+    policies: LibraryAnchorsResponsePolicy[];
+    populations: LibraryAnchorsResponsePopulation[];
+}
+export interface TemplatesResponse {
+    templates: StudioTemplate[];
+    experiment_size: string;
+}
+export interface ValidateResponse {
+    valid: boolean;
+    scenario: ValidateResponseScenario;
+    hash: string;
+    base: RunScenario;
+    receipt: ScenarioReceipt;
+}
 export interface ListScenariosResponse {
     scenarios: Scenario[];
 }
@@ -389,6 +423,60 @@ export interface DeleteSkillResponse {
     ok: boolean;
     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[];
+    /** 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 {
     ok: boolean;
     run: Run;
@@ -404,12 +492,52 @@ export interface GetRunResponse {
     run: Run;
     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 {
+    models: ModelRow[];
+    head_to_head: ModelsResponseHeadToHead[];
+    finished_runs: number;
+    points: ModelPoint[];
+    pooled: ModelsResponsePooled;
+    rubric: string;
+    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 {
     batch: BatchReport;
     runs: Run[];
     arena: JsonObject | null;
     caveat: string;
 }
+export interface EstimateExperimentResponse {
+    arms: RunEstimate[];
+    design: ExperimentEstimateDesign;
+    rerun: StudyRerun | null;
+}
 export interface CreateExperimentResponse {
     ok: boolean;
     experiment: Experiment;
@@ -525,10 +653,52 @@ export interface UnpublishBatchResponse {
     profile_url: string | null;
     study_url: string | null;
 }
+export interface RunLogsResponse {
+    run_id: string;
+    retention_days: number | null;
+    retention_note: string;
+    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 {
+    run_id: string;
+    invites: RunInvite[];
+}
 export interface ExtendInvitesBody {
     /** The new deadline, minutes from now, for every open seat. */
     minutes: number;
 }
+export interface ExtendInvitesResponse {
+    ok: boolean;
+    run_id: string;
+    invites: RunInvite[];
+}
+export interface RegenerateInviteResponse {
+    ok: boolean;
+    /** 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. */
+    invite: RunInvite;
+}
+export interface RevokeInviteResponse {
+    ok: boolean;
+    /** 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. */
+    invite: RunInvite;
+    run: Run;
+}
 export interface ListSetsResponse {
     sets: RunSet[];
 }
@@ -660,6 +830,23 @@ export interface RunGuests {
     seats_claimed: number;
     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 {
+    invite_id: string;
+    seat: number;
+    name: string;
+    token: string;
+    url: string;
+    status: 'open' | 'claimed' | 'forfeited' | 'revoked' | 'expired';
+    expires_at_ms: number;
+    claimed_at_ms: number | null;
+    claim: InviteClaim | null;
+}
+export interface InviteClaim {
+    model: string;
+    provider: string | null;
+    scaffold: string | null;
+}
 export interface RunBatch {
     id: string;
     trial: number;
@@ -1296,11 +1483,694 @@ export interface ExperimentArmSeat {
     /** Extra system instructions for this seat, appended verbatim after any skills. Skills plus instructions may total 8000 characters. Any skill or instruction stamps +custom.<hash> onto the seat’s scaffold identity. */
     instructions?: string;
 }
+export interface MeResponseUser {
+    id: string;
+    email?: string;
+    handle: string | null;
+}
+export interface MeResponsePlan {
+    id: 'free' | 'starter' | 'pro' | 'lab';
+    name: string;
+    status: 'active' | 'trialing' | 'past_due' | 'canceled' | 'none';
+    source: 'subscription' | 'default' | 'grace' | 'fallback' | 'exempt';
+    period_end_ms: number | null;
+}
+export interface MeResponseToken {
+    name: string;
+    prefix: string;
+    scopes: string[];
+    expires_at_ms: number | null;
+}
+export interface MeResponseLimits {
+    seats_per_run: number;
+    ticks_per_run: number;
+    agent_turns_per_month: number | null;
+    queued_runs: number;
+    series_max_trials: number;
+    saved_scenarios: number;
+    saved_skills: number;
+    access_tokens: number;
+    requests_per_minute: number;
+}
+export interface LibraryScenario {
+    id: string;
+    title: string;
+    kind: string;
+    description: string;
+    hash: string;
+    season_ticks: number;
+    roster: LibraryScenariosResponseScenarioRoster;
+    seed_policy: string;
+    turn_based: boolean;
+    anchors: string[];
+    resource_multipliers: JsonObject;
+}
+export interface LibraryScenariosResponseScenarioRoster {
+    min_agents: number;
+    max_agents: number;
+}
+export interface LibraryAnchorsResponsePolicy {
+    id: string;
+    description: string;
+}
+export interface LibraryAnchorsResponsePopulation {
+    id: string;
+    anchors: string[];
+    description: string;
+}
+/** One ready-made study. `arms`, `metric` and `secondary_metrics` are present on an experiment template only; `arms` is the word `per_seat` where each picked model becomes its own arm. */
+export interface StudioTemplate {
+    id: string;
+    kind: 'run' | 'series' | 'experiment';
+    title: string;
+    question: string;
+    setup: string;
+    shows: string;
+    cannot: string;
+    pick: string;
+    name: string;
+    min_seats: number;
+    run: TemplatesResponseTemplateRun;
+    trials: number;
+    seed_mode: 'vary' | 'pinned';
+    arms?: 'per_seat' | TemplateArm[];
+    metric?: 'fitness_index' | 'rank' | 'survived' | 'index_survival' | 'index_economy' | 'index_social' | 'index_adaptation' | 'index_competitiveness' | 'aggression_per_100_rounds' | 'trades_per_100_rounds' | 'circular_trades_per_100_rounds' | 'messages_per_100_rounds' | 'map_coverage' | 'witness_sensitivity' | 'compliance_rate' | 'compliance_latency' | 'injection_resistance' | 'output_tokens_per_turn' | 'said_evaluated' | 'aggression_between_seats_per_100_rounds' | 'trades_between_seats_per_100_rounds' | 'betrayals_per_100_rounds' | 'ring_share';
+    secondary_metrics?: Array<'fitness_index' | 'rank' | 'survived' | 'index_survival' | 'index_economy' | 'index_social' | 'index_adaptation' | 'index_competitiveness' | 'aggression_per_100_rounds' | 'trades_per_100_rounds' | 'circular_trades_per_100_rounds' | 'messages_per_100_rounds' | 'map_coverage' | 'witness_sensitivity' | 'compliance_rate' | 'compliance_latency' | 'injection_resistance' | 'output_tokens_per_turn' | 'said_evaluated' | 'aggression_between_seats_per_100_rounds' | 'trades_between_seats_per_100_rounds' | 'betrayals_per_100_rounds' | 'ring_share'>;
+}
+export interface TemplatesResponseTemplateRun {
+    scenario_id: string;
+    season_ticks: number;
+    env: TemplatesResponseTemplateRunEnv;
+}
+export interface TemplatesResponseTemplateRunEnv {
+    anchors: string[];
+    turn_timeout_ms?: number;
+}
+export interface TemplateArm {
+    label: string;
+    frame?: 'neutral' | 'monitored';
+    seat?: TemplatesResponseTemplateArmSeat;
+    instructions?: 'a' | 'b';
+    changed_seats?: number;
+}
+export interface TemplatesResponseTemplateArmSeat {
+    reasoning?: 'off' | 'low' | 'medium' | 'high';
+    max_tokens?: number;
+}
+export interface ValidateResponseScenario {
+    name: string;
+    description: string;
+    season_ticks: number | null;
+    env: JsonObject;
+}
+export interface ScenarioReceipt {
+    plan: ValidateResponseReceiptPlan;
+    warnings: ValidateResponseReceiptWarning[];
+}
+export interface ValidateResponseReceiptPlan {
+    id: string;
+    name: string;
+    ticks_per_run: number;
+    seats_per_run: number;
+    saved_scenarios: number;
+}
+export interface ValidateResponseReceiptWarning {
+    code: string;
+    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;
+}
+/** 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 {
+    /** 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 {
     id: string;
     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 {
+    model: string;
+    runs: number;
+    agents: number;
+    avg_fitness: number;
+    best_fitness: number;
+    worst_fitness: number;
+    wins: number;
+    survival_rate: number;
+    survived: number;
+    median_fitness: number;
+    worlds: number;
+    fitness_ci: Interval | null;
+    survival_ci: Interval | null;
+    provisional: boolean;
+}
+export interface ModelsResponseHeadToHead {
+    a: string;
+    b: string;
+    a_wins: number;
+    b_wins: number;
+    ties: number;
+}
+export interface ModelPoint {
+    run_id: string;
+    run_name: string;
+    match_id: string | null;
+    agent: string;
+    model: string;
+    ended_at_ms: number | null;
+    scenario_id: string;
+    scenario_hash: string;
+    rubric: string;
+    fitness_index: number;
+    rank: number;
+    field_size: number;
+    grade: string;
+    archetype: string;
+    status: string;
+    dimensions: JsonObject;
+}
+export interface ModelsResponsePooled {
+    runs: number;
+    experiments: number;
+    series: number;
+    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[];
+    /** 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 {
+    arms: number;
+    trials: number;
+    rule: StoppingRule;
+    metric: 'fitness_index' | 'rank' | 'survived' | 'index_survival' | 'index_economy' | 'index_social' | 'index_adaptation' | 'index_competitiveness' | 'aggression_per_100_rounds' | 'trades_per_100_rounds' | 'circular_trades_per_100_rounds' | 'messages_per_100_rounds' | 'map_coverage' | 'witness_sensitivity' | 'compliance_rate' | 'compliance_latency' | 'injection_resistance' | 'output_tokens_per_turn' | 'said_evaluated' | 'aggression_between_seats_per_100_rounds' | 'trades_between_seats_per_100_rounds' | 'betrayals_per_100_rounds' | 'ring_share';
+    focal: ExperimentReportFocal;
+    detectable_gap: EstimateExperimentResponseDesignDetectableGap;
+    usd_low: number;
+    usd_high: number;
+    minutes_low: number;
+    minutes_high: number;
+    slots: number;
+    equivalence_margin: number | null;
+}
+export interface EstimateExperimentResponseDesignDetectableGap {
+    seat_spread: number | null;
+    sd_diff: number | null;
+    gap: number | null;
+    power: number;
+    by_world: ExperimentReportDetectableGapByWorld | null;
+    at_trials: EstimateExperimentResponseDesignDetectableGapAtTrial[];
+    reference: SpreadReference | null;
+}
+export interface EstimateExperimentResponseDesignDetectableGapAtTrial {
+    trials: number;
+    gap: number | null;
+}
 /** A party outside Daishi that was handed the design’s SHA-256 (never the text) when the design was stored: `rfc3161`, a timestamp authority whose signed reply states the time (`attested_at_ms`, from its own clock), or `opentimestamps`, the public calendars, whose proof is `pending` until a Bitcoin block includes it and then `anchored` in `bitcoin_block`. `created_at_ms` is when this server received the proof. Once a trial is published, the design’s public page links each proof file (`.tsr` or `.ots`, as `proof_format` says) for checking with `openssl ts -verify` or `ots verify`. */
 export interface DesignWitness {
     kind: 'opentimestamps' | 'rfc3161';
@@ -1325,6 +2195,168 @@ export interface Study {
     published: number;
     pending: number;
 }
+export interface RunLogsResponseFile {
+    file: string;
+    bytes: number;
+    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 {
     /** 1 to 32 characters of a-z, 0-9, _ or -, starting with a letter or digit. Fixed once created. */
     key: string;
@@ -1345,7 +2377,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-index
      */
-    index(): Promise<JsonObject>;
+    index(): Promise<IndexResponse>;
     /**
      * OpenAPI document.
      *
@@ -1361,7 +2393,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-me
      */
-    me(): Promise<JsonObject>;
+    me(): Promise<MeResponse>;
     /**
      * Scenario schema.
      *
@@ -1377,7 +2409,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-library-scenarios
      */
-    libraryScenarios(): Promise<JsonObject>;
+    libraryScenarios(): Promise<LibraryScenariosResponse>;
     /**
      * Anchor bots.
      *
@@ -1385,7 +2417,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-library-anchors
      */
-    libraryAnchors(): Promise<JsonObject>;
+    libraryAnchors(): Promise<LibraryAnchorsResponse>;
     /**
      * Studio templates.
      *
@@ -1393,7 +2425,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-templates
      */
-    templates(): Promise<JsonObject>;
+    templates(): Promise<TemplatesResponse>;
     /**
      * Validate a scenario.
      *
@@ -1401,7 +2433,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-validate
      */
-    validate(body: ScenarioBody): Promise<JsonObject>;
+    validate(body: ScenarioBody): Promise<ValidateResponse>;
     /**
      * List your scenarios.
      *
@@ -1489,7 +2521,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-estimate
      */
-    estimate(body: RunBody): Promise<JsonObject>;
+    estimate(body: RunBody): Promise<EstimateResponse>;
     /**
      * Launch a run.
      *
@@ -1524,7 +2556,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-usage
      */
-    usage(): Promise<JsonObject>;
+    usage(): Promise<UsageResponse>;
     /**
      * Your models.
      *
@@ -1532,7 +2564,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-models
      */
-    models(): Promise<JsonObject>;
+    models(): Promise<ModelsResponse>;
     /**
      * Live worlds.
      *
@@ -1540,7 +2572,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-live
      */
-    live(): Promise<JsonObject>;
+    live(): Promise<LiveResponse>;
     /**
      * Get a batch report.
      *
@@ -1556,7 +2588,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-estimate-experiment
      */
-    estimateExperiment(body: ExperimentBody): Promise<JsonObject>;
+    estimateExperiment(body: ExperimentBody): Promise<EstimateExperimentResponse>;
     /**
      * Create an experiment.
      *
@@ -1692,7 +2724,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-run-logs
      */
-    runLogs(id: string): Promise<JsonObject>;
+    runLogs(id: string): Promise<RunLogsResponse>;
     /**
      * Read a run log.
      *
@@ -1708,7 +2740,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-run-seats
      */
-    runSeats(id: string): Promise<JsonObject>;
+    runSeats(id: string): Promise<RunSeatsResponse>;
     /**
      * List a run’s guest seats.
      *
@@ -1716,7 +2748,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-list-invites
      */
-    listInvites(id: string): Promise<JsonObject>;
+    listInvites(id: string): Promise<ListInvitesResponse>;
     /**
      * Extend the signup window.
      *
@@ -1724,7 +2756,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-extend-invites
      */
-    extendInvites(id: string, body: ExtendInvitesBody): Promise<JsonObject>;
+    extendInvites(id: string, body: ExtendInvitesBody): Promise<ExtendInvitesResponse>;
     /**
      * Regenerate a seat’s link.
      *
@@ -1732,7 +2764,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-regenerate-invite
      */
-    regenerateInvite(id: string, inviteId: string): Promise<JsonObject>;
+    regenerateInvite(id: string, inviteId: string): Promise<RegenerateInviteResponse>;
     /**
      * Withdraw a seat.
      *
@@ -1740,7 +2772,7 @@ export declare abstract class Operations {
      *
      * @see https://daishi.ai/docs/developer/rest#ep-revoke-invite
      */
-    revokeInvite(id: string, inviteId: string): Promise<JsonObject>;
+    revokeInvite(id: string, inviteId: string): Promise<RevokeInviteResponse>;
     /**
      * List run sets.
      *

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