@boatdev/sdk 1.7.0 → 1.8.0

package/.openapi-generator/FILES

@@ -79,6 +79,7 @@ docs/PromptRequest.md
 docs/PromptResponse.md
 docs/PromptRun.md
 docs/PromptRunResponse.md
+docs/Recover200Response.md
 docs/RepoSelectionRequest.md
 docs/RepoSelectionResponse.md
 docs/ReposResponse.md
@@ -122,6 +123,7 @@ docs/SteerEventData.md
 docs/SteerRequest.md
 docs/SteerResponse.md
 docs/StopOperation.md
+docs/StopOperationResponse.md
 docs/StopRequest.md
 docs/SuccessBase.md
 docs/UnknownEvent.md
@@ -221,6 +223,7 @@ src/models/PromptRequest.ts
 src/models/PromptResponse.ts
 src/models/PromptRun.ts
 src/models/PromptRunResponse.ts
+src/models/Recover200Response.ts
 src/models/RepoSelectionRequest.ts
 src/models/RepoSelectionResponse.ts
 src/models/ReposResponse.ts
@@ -264,6 +267,7 @@ src/models/SteerEventData.ts
 src/models/SteerRequest.ts
 src/models/SteerResponse.ts
 src/models/StopOperation.ts
+src/models/StopOperationResponse.ts
 src/models/StopRequest.ts
 src/models/SuccessBase.ts
 src/models/UnknownEvent.ts

package/dist/apis/BoatApi.d.ts

@@ -50,6 +50,7 @@ import { type OrgListResponse } from '../models/OrgListResponse';
 import { type PromptRequest } from '../models/PromptRequest';
 import { type PromptResponse } from '../models/PromptResponse';
 import { type PromptRunResponse } from '../models/PromptRunResponse';
+import { type Recover200Response } from '../models/Recover200Response';
 import { type RepoSelectionRequest } from '../models/RepoSelectionRequest';
 import { type RepoSelectionResponse } from '../models/RepoSelectionResponse';
 import { type ReposResponse } from '../models/ReposResponse';
@@ -73,6 +74,7 @@ import { type SshKeyRequest } from '../models/SshKeyRequest';
 import { type SshKeyResponse } from '../models/SshKeyResponse';
 import { type SteerRequest } from '../models/SteerRequest';
 import { type SteerResponse } from '../models/SteerResponse';
+import { type StopOperationResponse } from '../models/StopOperationResponse';
 import { type StopRequest } from '../models/StopRequest';
 import { type UpdateSandboxEnvironmentRequest } from '../models/UpdateSandboxEnvironmentRequest';
 import { type UpdateSandboxRequest } from '../models/UpdateSandboxRequest';
@@ -196,6 +198,10 @@ export interface GetSnapshotFileRequest {
 export interface GetSnapshotTreeRequest {
     snapshotId: string;
 }
+export interface GetStopRequest {
+    sandboxId: string;
+    stopId: string;
+}
 export interface GetWebhookRequest {
     webhookId: string;
 }
@@ -236,6 +242,9 @@ export interface ReadFileRequest {
     path: string;
     encoding?: ReadFileEncodingEnum;
 }
+export interface RecoverRequest {
+    sandboxId: string;
+}
 export interface ReposRequest {
     sync?: boolean;
     limit?: number;
@@ -381,10 +390,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     artifactRequestOpts(requestParameters: ArtifactRequest): Promise<runtime.RequestOpts>;
     /**
+     * Downloads one file of up to 50 MiB, under /home/user or /tmp, as raw bytes.
      * Download a sandbox artifact
      */
     artifactRaw(requestParameters: ArtifactRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>>;
     /**
+     * Downloads one file of up to 50 MiB, under /home/user or /tmp, as raw bytes.
      * Download a sandbox artifact
      */
     artifact(requestParameters: ArtifactRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blob>;
@@ -776,6 +787,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Get snapshot file tree
      */
     getSnapshotTree(requestParameters: GetSnapshotTreeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SnapshotTreeResponse>;
+    /**
+     * Creates request options for getStop without sending the request
+     */
+    getStopRequestOpts(requestParameters: GetStopRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Returns one stop of this sandbox by the id that `POST /sandboxes/{sandboxId}/stop` returned. Old stops stay readable after a resume or a later stop. Returns 404 when the id is unknown or belongs to another sandbox.
+     * Get a stop by id
+     */
+    getStopRaw(requestParameters: GetStopRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<StopOperationResponse>>;
+    /**
+     * Returns one stop of this sandbox by the id that `POST /sandboxes/{sandboxId}/stop` returned. Old stops stay readable after a resume or a later stop. Returns 404 when the id is unknown or belongs to another sandbox.
+     * Get a stop by id
+     */
+    getStop(requestParameters: GetStopRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<StopOperationResponse>;
     /**
      * Creates request options for getWebhook without sending the request
      */
@@ -949,13 +974,29 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     readFileRequestOpts(requestParameters: ReadFileRequest): Promise<runtime.RequestOpts>;
     /**
+     * Files up to 5 MiB. Use `GET /sandboxes/{sandboxId}/artifacts` for files up to 50 MiB, and SCP over SSH for larger ones.
      * Read a file from a sandbox
      */
     readFileRaw(requestParameters: ReadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FileReadResponse>>;
     /**
+     * Files up to 5 MiB. Use `GET /sandboxes/{sandboxId}/artifacts` for files up to 50 MiB, and SCP over SSH for larger ones.
      * Read a file from a sandbox
      */
     readFile(requestParameters: ReadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileReadResponse>;
+    /**
+     * Creates request options for recover without sending the request
+     */
+    recoverRequestOpts(requestParameters: RecoverRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or resume it from its last snapshot. - `reset_failed`: the power-cycle failed. Reply to the incident email.
+     * Recover a sandbox that stopped responding
+     */
+    recoverRaw(requestParameters: RecoverRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Recover200Response>>;
+    /**
+     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or resume it from its last snapshot. - `reset_failed`: the power-cycle failed. Reply to the incident email.
+     * Recover a sandbox that stopped responding
+     */
+    recover(requestParameters: RecoverRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Recover200Response>;
     /**
      * Creates request options for repos without sending the request
      */
@@ -1155,12 +1196,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     steerRequestOpts(input: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>): Promise<runtime.RequestOpts>;
     /**
-     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
+     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. `error.details.reason` says why: `turn_ended` (with `error.details.lastTurn.status` and `.error` of the newest turn), `turn_not_started` (the turn is starting; retry in a moment), `no_turn`, `not_running` (the sandbox is not running) or `delivery_failed` (the sandbox did not accept the steer; check the turn before sending more work). The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
      * Steer a running turn
      */
     steerRaw(requestParameters: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SteerResponse>>;
     /**
-     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
+     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. `error.details.reason` says why: `turn_ended` (with `error.details.lastTurn.status` and `.error` of the newest turn), `turn_not_started` (the turn is starting; retry in a moment), `no_turn`, `not_running` (the sandbox is not running) or `delivery_failed` (the sandbox did not accept the steer; check the turn before sending more work). The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
      * Steer a running turn
      */
     steer(requestParameters: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SteerResponse>;
@@ -1169,12 +1210,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.  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 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, keeping the last successful snapshot and losing everything written since then. This is irreversible; only reach for it after a stop has already failed. A force on a stop that is already pending escalates that stop.
      * 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.  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 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, keeping the last successful snapshot and losing everything written since then. This is irreversible; only reach for it after a stop has already failed. A force on a stop that is already pending escalates that stop.
      * Stop and archive sandbox
      */
     stop(requestParameters: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse>;
@@ -1277,10 +1318,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     writeFileRequestOpts(input: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>): Promise<runtime.RequestOpts>;
     /**
+     * Files up to 5 MiB after decoding. Use SCP over SSH for larger files.
      * Write a file in a sandbox
      */
     writeFileRaw(requestParameters: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FileWriteResponse>>;
     /**
+     * Files up to 5 MiB after decoding. Use SCP over SSH for larger files.
      * Write a file in a sandbox
      */
     writeFile(requestParameters: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileWriteResponse>;

package/dist/apis/BoatApi.js

@@ -88,6 +88,7 @@ const OrgListResponse_1 = require("../models/OrgListResponse");
 const PromptRequest_1 = require("../models/PromptRequest");
 const PromptResponse_1 = require("../models/PromptResponse");
 const PromptRunResponse_1 = require("../models/PromptRunResponse");
+const Recover200Response_1 = require("../models/Recover200Response");
 const RepoSelectionRequest_1 = require("../models/RepoSelectionRequest");
 const RepoSelectionResponse_1 = require("../models/RepoSelectionResponse");
 const ReposResponse_1 = require("../models/ReposResponse");
@@ -111,6 +112,7 @@ const SshKeyRequest_1 = require("../models/SshKeyRequest");
 const SshKeyResponse_1 = require("../models/SshKeyResponse");
 const SteerRequest_1 = require("../models/SteerRequest");
 const SteerResponse_1 = require("../models/SteerResponse");
+const StopOperationResponse_1 = require("../models/StopOperationResponse");
 const StopRequest_1 = require("../models/StopRequest");
 const UpdateSandboxEnvironmentRequest_1 = require("../models/UpdateSandboxEnvironmentRequest");
 const UpdateSandboxRequest_1 = require("../models/UpdateSandboxRequest");
@@ -286,6 +288,7 @@ class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
+     * Downloads one file of up to 50 MiB, under /home/user or /tmp, as raw bytes.
      * Download a sandbox artifact
      */
     async artifactRaw(requestParameters, initOverrides) {
@@ -294,6 +297,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.BlobApiResponse(response);
     }
     /**
+     * Downloads one file of up to 50 MiB, under /home/user or /tmp, as raw bytes.
      * Download a sandbox artifact
      */
     async artifact(requestParameters, initOverrides) {
@@ -1556,6 +1560,52 @@ class BoatApi extends runtime.BaseAPI {
         const response = await this.getSnapshotTreeRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for getStop without sending the request
+     */
+    async getStopRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling getStop().');
+        }
+        if (requestParameters['stopId'] == null) {
+            throw new runtime.RequiredError('stopId', 'Required parameter "stopId" was null or undefined when calling getStop().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/sandboxes/{sandboxId}/stops/{stopId}`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        urlPath = urlPath.replace('{stopId}', encodeURIComponent(String(requestParameters['stopId'])));
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Returns one stop of this sandbox by the id that `POST /sandboxes/{sandboxId}/stop` returned. Old stops stay readable after a resume or a later stop. Returns 404 when the id is unknown or belongs to another sandbox.
+     * Get a stop by id
+     */
+    async getStopRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.getStopRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, StopOperationResponse_1.StopOperationResponseFromJSON)(jsonValue));
+    }
+    /**
+     * Returns one stop of this sandbox by the id that `POST /sandboxes/{sandboxId}/stop` returned. Old stops stay readable after a resume or a later stop. Returns 404 when the id is unknown or belongs to another sandbox.
+     * Get a stop by id
+     */
+    async getStop(requestParameters, initOverrides) {
+        const response = await this.getStopRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for getWebhook without sending the request
      */
@@ -2117,6 +2167,7 @@ class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
+     * Files up to 5 MiB. Use `GET /sandboxes/{sandboxId}/artifacts` for files up to 50 MiB, and SCP over SSH for larger ones.
      * Read a file from a sandbox
      */
     async readFileRaw(requestParameters, initOverrides) {
@@ -2125,12 +2176,55 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, FileReadResponse_1.FileReadResponseFromJSON)(jsonValue));
     }
     /**
+     * Files up to 5 MiB. Use `GET /sandboxes/{sandboxId}/artifacts` for files up to 50 MiB, and SCP over SSH for larger ones.
      * Read a file from a sandbox
      */
     async readFile(requestParameters, initOverrides) {
         const response = await this.readFileRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for recover without sending the request
+     */
+    async recoverRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling recover().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("BoatBearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/sandboxes/{sandboxId}/recover`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or resume it from its last snapshot. - `reset_failed`: the power-cycle failed. Reply to the incident email.
+     * Recover a sandbox that stopped responding
+     */
+    async recoverRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.recoverRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, Recover200Response_1.Recover200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or resume it from its last snapshot. - `reset_failed`: the power-cycle failed. Reply to the incident email.
+     * Recover a sandbox that stopped responding
+     */
+    async recover(requestParameters, initOverrides) {
+        const response = await this.recoverRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for repos without sending the request
      */
@@ -2807,7 +2901,7 @@ class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
+     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. `error.details.reason` says why: `turn_ended` (with `error.details.lastTurn.status` and `.error` of the newest turn), `turn_not_started` (the turn is starting; retry in a moment), `no_turn`, `not_running` (the sandbox is not running) or `delivery_failed` (the sandbox did not accept the steer; check the turn before sending more work). The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
      * Steer a running turn
      */
     async steerRaw(requestParameters, initOverrides) {
@@ -2816,7 +2910,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, SteerResponse_1.SteerResponseFromJSON)(jsonValue));
     }
     /**
-     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
+     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. `error.details.reason` says why: `turn_ended` (with `error.details.lastTurn.status` and `.error` of the newest turn), `turn_not_started` (the turn is starting; retry in a moment), `no_turn`, `not_running` (the sandbox is not running) or `delivery_failed` (the sandbox did not accept the steer; check the turn before sending more work). The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
      * Steer a running turn
      */
     async steer(requestParameters, initOverrides) {
@@ -2852,7 +2946,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.  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 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, keeping the last successful snapshot and losing everything written since then. This is irreversible; only reach for it after a stop has already failed. A force on a stop that is already pending escalates that stop.
      * Stop and archive sandbox
      */
     async stopRaw(requestParameters, initOverrides) {
@@ -2861,7 +2955,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.  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 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, keeping the last successful snapshot and losing everything written since then. This is irreversible; only reach for it after a stop has already failed. A force on a stop that is already pending escalates that stop.
      * Stop and archive sandbox
      */
     async stop(requestParameters, initOverrides) {
@@ -3221,6 +3315,7 @@ class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
+     * Files up to 5 MiB after decoding. Use SCP over SSH for larger files.
      * Write a file in a sandbox
      */
     async writeFileRaw(requestParameters, initOverrides) {
@@ -3229,6 +3324,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, FileWriteResponse_1.FileWriteResponseFromJSON)(jsonValue));
     }
     /**
+     * Files up to 5 MiB after decoding. Use SCP over SSH for larger files.
      * Write a file in a sandbox
      */
     async writeFile(requestParameters, initOverrides) {

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

@@ -50,6 +50,7 @@ import { type OrgListResponse } from '../models/OrgListResponse';
 import { type PromptRequest } from '../models/PromptRequest';
 import { type PromptResponse } from '../models/PromptResponse';
 import { type PromptRunResponse } from '../models/PromptRunResponse';
+import { type Recover200Response } from '../models/Recover200Response';
 import { type RepoSelectionRequest } from '../models/RepoSelectionRequest';
 import { type RepoSelectionResponse } from '../models/RepoSelectionResponse';
 import { type ReposResponse } from '../models/ReposResponse';
@@ -73,6 +74,7 @@ import { type SshKeyRequest } from '../models/SshKeyRequest';
 import { type SshKeyResponse } from '../models/SshKeyResponse';
 import { type SteerRequest } from '../models/SteerRequest';
 import { type SteerResponse } from '../models/SteerResponse';
+import { type StopOperationResponse } from '../models/StopOperationResponse';
 import { type StopRequest } from '../models/StopRequest';
 import { type UpdateSandboxEnvironmentRequest } from '../models/UpdateSandboxEnvironmentRequest';
 import { type UpdateSandboxRequest } from '../models/UpdateSandboxRequest';
@@ -196,6 +198,10 @@ export interface GetSnapshotFileRequest {
 export interface GetSnapshotTreeRequest {
     snapshotId: string;
 }
+export interface GetStopRequest {
+    sandboxId: string;
+    stopId: string;
+}
 export interface GetWebhookRequest {
     webhookId: string;
 }
@@ -236,6 +242,9 @@ export interface ReadFileRequest {
     path: string;
     encoding?: ReadFileEncodingEnum;
 }
+export interface RecoverRequest {
+    sandboxId: string;
+}
 export interface ReposRequest {
     sync?: boolean;
     limit?: number;
@@ -381,10 +390,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     artifactRequestOpts(requestParameters: ArtifactRequest): Promise<runtime.RequestOpts>;
     /**
+     * Downloads one file of up to 50 MiB, under /home/user or /tmp, as raw bytes.
      * Download a sandbox artifact
      */
     artifactRaw(requestParameters: ArtifactRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>>;
     /**
+     * Downloads one file of up to 50 MiB, under /home/user or /tmp, as raw bytes.
      * Download a sandbox artifact
      */
     artifact(requestParameters: ArtifactRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blob>;
@@ -776,6 +787,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Get snapshot file tree
      */
     getSnapshotTree(requestParameters: GetSnapshotTreeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SnapshotTreeResponse>;
+    /**
+     * Creates request options for getStop without sending the request
+     */
+    getStopRequestOpts(requestParameters: GetStopRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Returns one stop of this sandbox by the id that `POST /sandboxes/{sandboxId}/stop` returned. Old stops stay readable after a resume or a later stop. Returns 404 when the id is unknown or belongs to another sandbox.
+     * Get a stop by id
+     */
+    getStopRaw(requestParameters: GetStopRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<StopOperationResponse>>;
+    /**
+     * Returns one stop of this sandbox by the id that `POST /sandboxes/{sandboxId}/stop` returned. Old stops stay readable after a resume or a later stop. Returns 404 when the id is unknown or belongs to another sandbox.
+     * Get a stop by id
+     */
+    getStop(requestParameters: GetStopRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<StopOperationResponse>;
     /**
      * Creates request options for getWebhook without sending the request
      */
@@ -949,13 +974,29 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     readFileRequestOpts(requestParameters: ReadFileRequest): Promise<runtime.RequestOpts>;
     /**
+     * Files up to 5 MiB. Use `GET /sandboxes/{sandboxId}/artifacts` for files up to 50 MiB, and SCP over SSH for larger ones.
      * Read a file from a sandbox
      */
     readFileRaw(requestParameters: ReadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FileReadResponse>>;
     /**
+     * Files up to 5 MiB. Use `GET /sandboxes/{sandboxId}/artifacts` for files up to 50 MiB, and SCP over SSH for larger ones.
      * Read a file from a sandbox
      */
     readFile(requestParameters: ReadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileReadResponse>;
+    /**
+     * Creates request options for recover without sending the request
+     */
+    recoverRequestOpts(requestParameters: RecoverRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or resume it from its last snapshot. - `reset_failed`: the power-cycle failed. Reply to the incident email.
+     * Recover a sandbox that stopped responding
+     */
+    recoverRaw(requestParameters: RecoverRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Recover200Response>>;
+    /**
+     * Power-cycle the machine of a sandbox that stopped answering. The disk is not touched. The sandbox usually answers again within 1-2 minutes and then saves your work by itself; `sandbox.recovered` fires when it does.  Refused with `409`: - `sandbox_is_reachable`: the sandbox answers normally. - `too_soon`: a recover started less than 10 minutes ago. - `no_machine`: the sandbox has no machine. Resume it instead. - `recover_unsupported`: its machine cannot be power-cycled. Wait for it to   answer, or resume it from its last snapshot. - `reset_failed`: the power-cycle failed. Reply to the incident email.
+     * Recover a sandbox that stopped responding
+     */
+    recover(requestParameters: RecoverRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Recover200Response>;
     /**
      * Creates request options for repos without sending the request
      */
@@ -1155,12 +1196,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     steerRequestOpts(input: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>): Promise<runtime.RequestOpts>;
     /**
-     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
+     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. `error.details.reason` says why: `turn_ended` (with `error.details.lastTurn.status` and `.error` of the newest turn), `turn_not_started` (the turn is starting; retry in a moment), `no_turn`, `not_running` (the sandbox is not running) or `delivery_failed` (the sandbox did not accept the steer; check the turn before sending more work). The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
      * Steer a running turn
      */
     steerRaw(requestParameters: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SteerResponse>>;
     /**
-     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
+     * Send a new message to a turn that is already running, without losing what the agent is doing. This is what typing into a coding agent while it works does: the instruction is taken into account and the work continues.  Where the harness has a native mid-turn primitive (Claude Code, Codex, pi, Prime Agent) nothing is interrupted and the response has `native: true`. Where it does not (OpenCode), Boat interrupts that turn and immediately continues the SAME conversation with the instruction, keeping the session and its memory, and the response has `native: false`.  Refused with **409 `no_running_turn`** when the conversation has nothing in flight; queue work with `POST /prompt` instead. `error.details.reason` says why: `turn_ended` (with `error.details.lastTurn.status` and `.error` of the newest turn), `turn_not_started` (the turn is starting; retry in a moment), `no_turn`, `not_running` (the sandbox is not running) or `delivery_failed` (the sandbox did not accept the steer; check the turn before sending more work). The steer shows up in `GET /events` as a `steer` event. See [Integrated agents](/integrated-agents).
      * Steer a running turn
      */
     steer(requestParameters: SteerOperationRequest | runtime.FlatBody<SteerOperationRequest, 'steerRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SteerResponse>;
@@ -1169,12 +1210,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.  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 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, keeping the last successful snapshot and losing everything written since then. This is irreversible; only reach for it after a stop has already failed. A force on a stop that is already pending escalates that stop.
      * 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.  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 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, keeping the last successful snapshot and losing everything written since then. This is irreversible; only reach for it after a stop has already failed. A force on a stop that is already pending escalates that stop.
      * Stop and archive sandbox
      */
     stop(requestParameters: StopOperationRequest | runtime.FlatBody<StopOperationRequest, 'stopRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxActionResponse>;
@@ -1277,10 +1318,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     writeFileRequestOpts(input: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>): Promise<runtime.RequestOpts>;
     /**
+     * Files up to 5 MiB after decoding. Use SCP over SSH for larger files.
      * Write a file in a sandbox
      */
     writeFileRaw(requestParameters: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FileWriteResponse>>;
     /**
+     * Files up to 5 MiB after decoding. Use SCP over SSH for larger files.
      * Write a file in a sandbox
      */
     writeFile(requestParameters: WriteFileRequest | runtime.FlatBody<WriteFileRequest, 'fileWriteRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FileWriteResponse>;