@boatdev/sdk 1.5.0 → 1.7.0

package/.openapi-generator/FILES

@@ -62,6 +62,7 @@ docs/LimitsResponse.md
 docs/MeResponse.md
 docs/MeResponseAllOfUser.md
 docs/NamedSnapshot.md
+docs/NamedSnapshotAllowance.md
 docs/NamedSnapshotDeletedResponse.md
 docs/NamedSnapshotInfoResponse.md
 docs/NamedSnapshotListResponse.md
@@ -120,6 +121,7 @@ docs/SteerEvent.md
 docs/SteerEventData.md
 docs/SteerRequest.md
 docs/SteerResponse.md
+docs/StopOperation.md
 docs/StopRequest.md
 docs/SuccessBase.md
 docs/UnknownEvent.md
@@ -202,6 +204,7 @@ src/models/LimitsResponse.ts
 src/models/MeResponse.ts
 src/models/MeResponseAllOfUser.ts
 src/models/NamedSnapshot.ts
+src/models/NamedSnapshotAllowance.ts
 src/models/NamedSnapshotDeletedResponse.ts
 src/models/NamedSnapshotInfoResponse.ts
 src/models/NamedSnapshotListResponse.ts
@@ -260,6 +263,7 @@ src/models/SteerEvent.ts
 src/models/SteerEventData.ts
 src/models/SteerRequest.ts
 src/models/SteerResponse.ts
+src/models/StopOperation.ts
 src/models/StopRequest.ts
 src/models/SuccessBase.ts
 src/models/UnknownEvent.ts

package/dist/apis/BoatApi.d.ts

@@ -1169,12 +1169,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     stopRequestOpts(input: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>): Promise<runtime.RequestOpts>;
     /**
-     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
+     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
      * Stop and archive sandbox
      */
     stopRaw(requestParameters: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxActionResponse>>;
     /**
-     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
+     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
      * Stop and archive sandbox
      */
     stop(requestParameters: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse>;

package/dist/apis/BoatApi.js

@@ -2852,7 +2852,7 @@ class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
+     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
      * Stop and archive sandbox
      */
     async stopRaw(requestParameters, initOverrides) {
@@ -2861,7 +2861,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, SandboxActionResponse_1.SandboxActionResponseFromJSON)(jsonValue));
     }
     /**
-     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
+     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
      * Stop and archive sandbox
      */
     async stop(requestParameters, initOverrides) {

package/dist/boat-helpers.d.ts

@@ -53,6 +53,12 @@ export declare function stopAndRemove(api: BoatApi, sandboxId: string, options?:
 }): Promise<import("./models").DeletionOperationResponse | import("./models").SandboxActionResponse>;
 export declare function readText(api: BoatApi, sandboxId: string, path: string): Promise<string>;
 export declare function writeText(api: BoatApi, sandboxId: string, path: string, content: string): Promise<import("./models").FileWriteResponse>;
+/**
+ * Run a command and return its result.
+ *
+ * Safe to call right after `resume()`: a refusal that never ran the command
+ * (`retryable: true`, the sandbox is still restoring) is resent for up to 60 s.
+ */
 export declare function execCommand(api: BoatApi, sandboxId: string, command: string, cwd?: string, timeoutSeconds?: number): Promise<import("./models").Command200Response>;
 /** One line of a streamed command, as sent (an `exit` frame also carries e.g. `signal`, `oomKilled`). */
 export type CommandFrame = CommandStreamFrame & Record<string, unknown>;

package/dist/boat-helpers.js

@@ -172,12 +172,36 @@ async function readText(api, sandboxId, path) {
 async function writeText(api, sandboxId, path, content) {
     return api.writeFile({ sandboxId, fileWriteRequest: { path, content, encoding: 'utf8' } });
 }
-async function execCommand(api, sandboxId, command, cwd, timeoutSeconds = 30) {
-    return api.command({ sandboxId, commandRequest: { command, cwd, timeoutSeconds } });
-}
 // A refusal that provably never ran the command (the sandbox is still restoring
-// its disk, `retryable: true` before `started`) is retried for this long.
+// its disk, `retryable: true`) is retried for this long.
 const STREAM_RETRY_MS = 60000;
+async function isRetryable(e) {
+    const response = e === null || e === void 0 ? void 0 : e.response;
+    if (!response)
+        return false;
+    const body = await response.clone().json().catch(() => undefined);
+    return (body === null || body === void 0 ? void 0 : body.retryable) === true;
+}
+/**
+ * Run a command and return its result.
+ *
+ * Safe to call right after `resume()`: a refusal that never ran the command
+ * (`retryable: true`, the sandbox is still restoring) is resent for up to 60 s.
+ */
+async function execCommand(api, sandboxId, command, cwd, timeoutSeconds = 30) {
+    const deadline = Date.now() + STREAM_RETRY_MS;
+    for (;;) {
+        try {
+            return await api.command({ sandboxId, commandRequest: { command, cwd, timeoutSeconds } });
+        }
+        catch (e) {
+            // The 1 s pause before the resend must also fit before the deadline.
+            if (Date.now() + 1000 >= deadline || !(await isRetryable(e)))
+                throw e;
+        }
+        await delay(1000);
+    }
+}
 async function* ndjsonFrames(response) {
     if (!response.body)
         throw new Error('The command stream has no body');

package/dist/esm/apis/BoatApi.d.ts

@@ -1169,12 +1169,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     stopRequestOpts(input: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>): Promise<runtime.RequestOpts>;
     /**
-     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
+     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
      * Stop and archive sandbox
      */
     stopRaw(requestParameters: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxActionResponse>>;
     /**
-     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
+     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
      * Stop and archive sandbox
      */
     stop(requestParameters: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse>;

package/dist/esm/apis/BoatApi.js

@@ -2816,7 +2816,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
+     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
      * Stop and archive sandbox
      */
     async stopRaw(requestParameters, initOverrides) {
@@ -2825,7 +2825,7 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => SandboxActionResponseFromJSON(jsonValue));
     }
     /**
-     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
+     * Stop active work and archive/snapshot the sandbox for later resume or fork.  A stop always saves the sandbox\'s disk first. If that save is failing, the stop is refused and the sandbox keeps running so your work is not discarded, we retry automatically and email you. You are not billed for time spent in that state.  The stop is an operation: the response and the sandbox carry it as `stop`, with an `id` and a `status`. Poll `GET /sandboxes/{sandboxId}` until `stop.status` is `completed`. A failed attempt shows `failing` with its `error` and is retried until the sandbox archives; commands and prompts you send meanwhile do not cancel it. Only a resume ends it early (`superseded`). Calling stop again while one is pending returns the same `id`.  Set `force: true` to stop anyway, accepting the loss of everything written since the last successful snapshot. This is irreversible; only reach for it after a stop has already failed.
      * Stop and archive sandbox
      */
     async stop(requestParameters, initOverrides) {

package/dist/esm/boat-helpers.d.ts

@@ -53,6 +53,12 @@ export declare function stopAndRemove(api: BoatApi, sandboxId: string, options?:
 }): Promise<import("./models").DeletionOperationResponse | import("./models").SandboxActionResponse>;
 export declare function readText(api: BoatApi, sandboxId: string, path: string): Promise<string>;
 export declare function writeText(api: BoatApi, sandboxId: string, path: string, content: string): Promise<import("./models").FileWriteResponse>;
+/**
+ * Run a command and return its result.
+ *
+ * Safe to call right after `resume()`: a refusal that never ran the command
+ * (`retryable: true`, the sandbox is still restoring) is resent for up to 60 s.
+ */
 export declare function execCommand(api: BoatApi, sandboxId: string, command: string, cwd?: string, timeoutSeconds?: number): Promise<import("./models").Command200Response>;
 /** One line of a streamed command, as sent (an `exit` frame also carries e.g. `signal`, `oomKilled`). */
 export type CommandFrame = CommandStreamFrame & Record<string, unknown>;

package/dist/esm/boat-helpers.js

@@ -158,12 +158,36 @@ export async function readText(api, sandboxId, path) {
 export async function writeText(api, sandboxId, path, content) {
     return api.writeFile({ sandboxId, fileWriteRequest: { path, content, encoding: 'utf8' } });
 }
-export async function execCommand(api, sandboxId, command, cwd, timeoutSeconds = 30) {
-    return api.command({ sandboxId, commandRequest: { command, cwd, timeoutSeconds } });
-}
 // A refusal that provably never ran the command (the sandbox is still restoring
-// its disk, `retryable: true` before `started`) is retried for this long.
+// its disk, `retryable: true`) is retried for this long.
 const STREAM_RETRY_MS = 60000;
+async function isRetryable(e) {
+    const response = e === null || e === void 0 ? void 0 : e.response;
+    if (!response)
+        return false;
+    const body = await response.clone().json().catch(() => undefined);
+    return (body === null || body === void 0 ? void 0 : body.retryable) === true;
+}
+/**
+ * Run a command and return its result.
+ *
+ * Safe to call right after `resume()`: a refusal that never ran the command
+ * (`retryable: true`, the sandbox is still restoring) is resent for up to 60 s.
+ */
+export async function execCommand(api, sandboxId, command, cwd, timeoutSeconds = 30) {
+    const deadline = Date.now() + STREAM_RETRY_MS;
+    for (;;) {
+        try {
+            return await api.command({ sandboxId, commandRequest: { command, cwd, timeoutSeconds } });
+        }
+        catch (e) {
+            // The 1 s pause before the resend must also fit before the deadline.
+            if (Date.now() + 1000 >= deadline || !(await isRetryable(e)))
+                throw e;
+        }
+        await delay(1000);
+    }
+}
 async function* ndjsonFrames(response) {
     if (!response.body)
         throw new Error('The command stream has no body');

package/dist/esm/models/Conversation.d.ts

@@ -46,7 +46,7 @@ export interface Conversation {
      */
     running: boolean;
     /**
-     * Harness the most recent prompt ran on (`claude`, `codex`, `pi`, `opencode`, `prime-agent`, `kimi`).
+     * Harness the most recent prompt ran on (`claude`, `codex`, `pi`, `opencode`, `prime-agent`, `kimi`, `mistral`).
      * @type {string}
      * @memberof Conversation
      */

package/dist/esm/models/NamedSnapshotAllowance.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * What the request's wallet (your active organization, `?org=`, or personal) pays for named snapshots. 10 are free per wallet; each one above costs $1.70 a month, charged daily from usage. An organization's count includes every member's names billed to it.
+ * @export
+ * @interface NamedSnapshotAllowance
+ */
+export interface NamedSnapshotAllowance {
+    /**
+     * Organization the numbers are for. null = personal.
+     * @type {string}
+     * @memberof NamedSnapshotAllowance
+     */
+    org?: string | null;
+    /**
+     * That organization's name.
+     * @type {string}
+     * @memberof NamedSnapshotAllowance
+     */
+    orgName?: string | null;
+    /**
+     * Named snapshots kept for free.
+     * @type {number}
+     * @memberof NamedSnapshotAllowance
+     */
+    free?: number;
+    /**
+     * Named snapshots this wallet keeps.
+     * @type {number}
+     * @memberof NamedSnapshotAllowance
+     */
+    used?: number;
+    /**
+     * Named snapshots above the free ones.
+     * @type {number}
+     * @memberof NamedSnapshotAllowance
+     */
+    extra?: number;
+    /**
+     * What the extra ones cost per month.
+     * @type {number}
+     * @memberof NamedSnapshotAllowance
+     */
+    extraMonthlyDollars?: number;
+    /**
+     * Boat time the extra ones take per day, in dollars (the daily charge).
+     * @type {number}
+     * @memberof NamedSnapshotAllowance
+     */
+    extraDailyDollars?: number;
+    /**
+     * Monthly price of one extra named snapshot.
+     * @type {number}
+     * @memberof NamedSnapshotAllowance
+     */
+    pricePerExtraMonthlyDollars?: number;
+}
+/**
+ * Check if a given object implements the NamedSnapshotAllowance interface.
+ */
+export declare function instanceOfNamedSnapshotAllowance(value: object): value is NamedSnapshotAllowance;
+export declare function NamedSnapshotAllowanceFromJSON(json: any): NamedSnapshotAllowance;
+export declare function NamedSnapshotAllowanceFromJSONTyped(json: any, ignoreDiscriminator: boolean): NamedSnapshotAllowance;
+export declare function NamedSnapshotAllowanceToJSON(json: any): NamedSnapshotAllowance;
+export declare function NamedSnapshotAllowanceToJSONTyped(value?: NamedSnapshotAllowance | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/NamedSnapshotAllowance.js

@@ -0,0 +1,55 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Check if a given object implements the NamedSnapshotAllowance interface.
+ */
+export function instanceOfNamedSnapshotAllowance(value) {
+    return true;
+}
+export function NamedSnapshotAllowanceFromJSON(json) {
+    return NamedSnapshotAllowanceFromJSONTyped(json, false);
+}
+export function NamedSnapshotAllowanceFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'org': json['org'] == null ? undefined : json['org'],
+        'orgName': json['orgName'] == null ? undefined : json['orgName'],
+        'free': json['free'] == null ? undefined : json['free'],
+        'used': json['used'] == null ? undefined : json['used'],
+        'extra': json['extra'] == null ? undefined : json['extra'],
+        'extraMonthlyDollars': json['extraMonthlyDollars'] == null ? undefined : json['extraMonthlyDollars'],
+        'extraDailyDollars': json['extraDailyDollars'] == null ? undefined : json['extraDailyDollars'],
+        'pricePerExtraMonthlyDollars': json['pricePerExtraMonthlyDollars'] == null ? undefined : json['pricePerExtraMonthlyDollars'],
+    };
+}
+export function NamedSnapshotAllowanceToJSON(json) {
+    return NamedSnapshotAllowanceToJSONTyped(json, false);
+}
+export function NamedSnapshotAllowanceToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'org': value['org'],
+        'orgName': value['orgName'],
+        'free': value['free'],
+        'used': value['used'],
+        'extra': value['extra'],
+        'extraMonthlyDollars': value['extraMonthlyDollars'],
+        'extraDailyDollars': value['extraDailyDollars'],
+        'pricePerExtraMonthlyDollars': value['pricePerExtraMonthlyDollars'],
+    };
+}

package/dist/esm/models/NamedSnapshotListResponse.d.ts

@@ -9,6 +9,7 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+import type { NamedSnapshotAllowance } from './NamedSnapshotAllowance';
 import type { NamedSnapshot } from './NamedSnapshot';
 /**
  *
@@ -34,6 +35,12 @@ export interface NamedSnapshotListResponse {
      * @memberof NamedSnapshotListResponse
      */
     snapshots: Array<NamedSnapshot>;
+    /**
+     *
+     * @type {NamedSnapshotAllowance}
+     * @memberof NamedSnapshotListResponse
+     */
+    allowance?: NamedSnapshotAllowance;
 }
 /**
  * @export

package/dist/esm/models/NamedSnapshotListResponse.js

@@ -11,6 +11,7 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+import { NamedSnapshotAllowanceFromJSON, NamedSnapshotAllowanceToJSON, } from './NamedSnapshotAllowance';
 import { NamedSnapshotFromJSON, NamedSnapshotToJSON, } from './NamedSnapshot';
 /**
  * @export
@@ -41,6 +42,7 @@ export function NamedSnapshotListResponseFromJSONTyped(json, ignoreDiscriminator
         'ok': json['ok'],
         'type': json['type'],
         'snapshots': (json['snapshots'].map(NamedSnapshotFromJSON)),
+        'allowance': json['allowance'] == null ? undefined : NamedSnapshotAllowanceFromJSON(json['allowance']),
     };
 }
 export function NamedSnapshotListResponseToJSON(json) {
@@ -54,5 +56,6 @@ export function NamedSnapshotListResponseToJSONTyped(value, ignoreDiscriminator
         'ok': value['ok'],
         'type': value['type'],
         'snapshots': (value['snapshots'].map(NamedSnapshotToJSON)),
+        'allowance': NamedSnapshotAllowanceToJSON(value['allowance']),
     };
 }

package/dist/esm/models/PromptRequest.d.ts

@@ -12,7 +12,7 @@
 /**
  * Work item to queue inside an existing sandbox. Provider credentials must already be configured in the Boat dashboard.
  *
- * **Providers (harnesses):** `codex`, `claude-code` (alias `claude`), `pi`, `opencode`, `prime-agent` (alias `prime`), `kimi` (Kimi Code CLI, alias `kimi-code`). Omit `provider` to use the harness the user selected on the Agents dashboard.
+ * **Providers (harnesses):** `codex`, `claude-code` (alias `claude`), `pi`, `opencode`, `prime-agent` (alias `prime`), `kimi` (Kimi Code CLI, alias `kimi-code`), `mistral` (Mistral Vibe). Omit `provider` to use the harness the user selected on the Agents dashboard.
  *
  * **Models & reasoning effort** are harness- and model-specific and change over time. Fetch the live catalog (every provider's models and which reasoning-effort levels each accepts) from `GET /provider-models`. Some models accept no reasoning control. `pi`, `opencode` and `prime-agent` also expose models routed through OpenRouter and llmgateway (ids like `openrouter:anthropic/claude-sonnet-4.5`).
  *
@@ -78,6 +78,7 @@ export declare const PromptRequestProviderEnum: {
     readonly Prime: 'prime';
     readonly Kimi: 'kimi';
     readonly KimiCode: 'kimi-code';
+    readonly Mistral: 'mistral';
 };
 export type PromptRequestProviderEnum = typeof PromptRequestProviderEnum[keyof typeof PromptRequestProviderEnum];
 /**

package/dist/esm/models/PromptRequest.js

@@ -23,7 +23,8 @@ export const PromptRequestProviderEnum = {
     PrimeAgent: 'prime-agent',
     Prime: 'prime',
     Kimi: 'kimi',
-    KimiCode: 'kimi-code'
+    KimiCode: 'kimi-code',
+    Mistral: 'mistral'
 };
 /**
  * Check if a given object implements the PromptRequest interface.

package/dist/esm/models/Sandbox.d.ts

@@ -10,6 +10,7 @@
  * Do not edit the class manually.
  */
 import type { SandboxTeam } from './SandboxTeam';
+import type { StopOperation } from './StopOperation';
 /**
  *
  * @export
@@ -58,6 +59,18 @@ export interface Sandbox {
      * @memberof Sandbox
      */
     degradedSince?: Date | null;
+    /**
+     * True once every file of the sandbox's snapshot is on its disk. A resumed or forked sandbox is usable before that: its files keep copying in the background, and its docker volumes move onto the real disk near the end. Its docker containers start earlier; at that point their volume mounts move onto the real disk in place, without a restart. The `sandbox.hydrated` webhook fires at the same moment this turns true. A sandbox that restored nothing is hydrated from the start.
+     * @type {boolean}
+     * @memberof Sandbox
+     */
+    hydrated?: boolean;
+    /**
+     * When the last resume or fork finished copying files in, or null.
+     * @type {Date}
+     * @memberof Sandbox
+     */
+    hydratedAt?: Date | null;
     /**
      * Current machine size: what the sandbox was created with, or the size it was last resumed or forked onto.
      * @type {SandboxTypeEnum}
@@ -238,6 +251,12 @@ export interface Sandbox {
      * @memberof Sandbox
      */
     environmentVersion?: number | null;
+    /**
+     * The last stop you requested (`POST /sandboxes/{sandboxId}/stop`), or null if you never stopped this sandbox.
+     * @type {StopOperation}
+     * @memberof Sandbox
+     */
+    stop?: StopOperation | null;
 }
 /**
  * @export

package/dist/esm/models/Sandbox.js

@@ -12,6 +12,7 @@
  * Do not edit the class manually.
  */
 import { SandboxTeamFromJSON, SandboxTeamToJSON, } from './SandboxTeam';
+import { StopOperationFromJSON, StopOperationToJSON, } from './StopOperation';
 /**
  * @export
  */
@@ -108,6 +109,8 @@ export function SandboxFromJSONTyped(json, ignoreDiscriminator) {
         'health': json['health'] == null ? undefined : json['health'],
         'healthReason': json['healthReason'] == null ? undefined : json['healthReason'],
         'degradedSince': json['degradedSince'] == null ? undefined : (new Date(json['degradedSince'])),
+        'hydrated': json['hydrated'] == null ? undefined : json['hydrated'],
+        'hydratedAt': json['hydratedAt'] == null ? undefined : (new Date(json['hydratedAt'])),
         'type': json['type'] == null ? undefined : json['type'],
         'vcpu': json['vcpu'] == null ? undefined : json['vcpu'],
         'memoryGB': json['memoryGB'] == null ? undefined : json['memoryGB'],
@@ -138,6 +141,7 @@ export function SandboxFromJSONTyped(json, ignoreDiscriminator) {
         'setupError': json['setupError'] == null ? undefined : json['setupError'],
         'environment': json['environment'] == null ? undefined : json['environment'],
         'environmentVersion': json['environmentVersion'] == null ? undefined : json['environmentVersion'],
+        'stop': json['stop'] == null ? undefined : StopOperationFromJSON(json['stop']),
     };
 }
 export function SandboxToJSON(json) {
@@ -155,6 +159,8 @@ export function SandboxToJSONTyped(value, ignoreDiscriminator = false) {
         'health': value['health'],
         'healthReason': value['healthReason'],
         'degradedSince': value['degradedSince'] == null ? value['degradedSince'] : value['degradedSince'].toISOString(),
+        'hydrated': value['hydrated'],
+        'hydratedAt': value['hydratedAt'] == null ? value['hydratedAt'] : value['hydratedAt'].toISOString(),
         'type': value['type'],
         'vcpu': value['vcpu'],
         'memoryGB': value['memoryGB'],
@@ -185,5 +191,6 @@ export function SandboxToJSONTyped(value, ignoreDiscriminator = false) {
         'setupError': value['setupError'],
         'environment': value['environment'],
         'environmentVersion': value['environmentVersion'],
+        'stop': StopOperationToJSON(value['stop']),
     };
 }

package/dist/esm/models/StopOperation.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Boat Public API v1
+ * Public JSON API for creating, operating, prompting, observing, and exposing sandboxes from backend services, CI jobs, hosted workers, and Boat automation products.  The v1 reference intentionally documents the developer integration surface only. Dashboard billing actions are not part of v1.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface StopOperation
+ */
+export interface StopOperation {
+    /**
+     * Stable id of this stop. Calling stop again while it is pending returns the same id.
+     * @type {string}
+     * @memberof StopOperation
+     */
+    id: string;
+    /**
+     * `pending`: accepted, the sandbox is archiving. `failing`: the last attempt failed (see `error`); it is retried automatically until the sandbox archives. Running commands or prompts does not cancel it. `completed`: the sandbox is archived. `superseded`: a resume ended it before it completed.
+     * @type {StopOperationStatusEnum}
+     * @memberof StopOperation
+     */
+    status: StopOperationStatusEnum;
+    /**
+     * When the stop was accepted. Null once it has ended.
+     * @type {Date}
+     * @memberof StopOperation
+     */
+    requestedAt: Date | null;
+    /**
+     * When the last archival attempt ended.
+     * @type {Date}
+     * @memberof StopOperation
+     */
+    lastAttemptAt: Date | null;
+    /**
+     * Why the last attempt failed, while `status` is `failing`. Otherwise null.
+     * @type {string}
+     * @memberof StopOperation
+     */
+    error: string | null;
+    /**
+     * When the stop completed or was superseded.
+     * @type {Date}
+     * @memberof StopOperation
+     */
+    endedAt: Date | null;
+}
+/**
+ * @export
+ */
+export declare const StopOperationStatusEnum: {
+    readonly Pending: 'pending';
+    readonly Failing: 'failing';
+    readonly Completed: 'completed';
+    readonly Superseded: 'superseded';
+};
+export type StopOperationStatusEnum = typeof StopOperationStatusEnum[keyof typeof StopOperationStatusEnum];
+/**
+ * Check if a given object implements the StopOperation interface.
+ */
+export declare function instanceOfStopOperation(value: object): value is StopOperation;
+export declare function StopOperationFromJSON(json: any): StopOperation;
+export declare function StopOperationFromJSONTyped(json: any, ignoreDiscriminator: boolean): StopOperation;
+export declare function StopOperationToJSON(json: any): StopOperation;
+export declare function StopOperationToJSONTyped(value?: StopOperation | null, ignoreDiscriminator?: boolean): any;