@boatdev/sdk 1.3.0 → 1.5.0

package/.openapi-generator/FILES

@@ -104,6 +104,7 @@ docs/SecretsUpdateRequest.md
 docs/SelectedRepository.md
 docs/SetEnvironmentSecretFileRequest.md
 docs/SetEnvironmentVarRequest.md
+docs/Share200Response.md
 docs/SnapshotChunk.md
 docs/SnapshotDownloadResponse.md
 docs/SnapshotDownloadResponseAllOfInventory.md
@@ -243,6 +244,7 @@ src/models/SecretsUpdateRequest.ts
 src/models/SelectedRepository.ts
 src/models/SetEnvironmentSecretFileRequest.ts
 src/models/SetEnvironmentVarRequest.ts
+src/models/Share200Response.ts
 src/models/SnapshotChunk.ts
 src/models/SnapshotDownloadResponse.ts
 src/models/SnapshotDownloadResponseAllOfInventory.ts

package/dist/apis/BoatApi.d.ts

@@ -64,6 +64,7 @@ import { type SecretsResponse } from '../models/SecretsResponse';
 import { type SecretsUpdateRequest } from '../models/SecretsUpdateRequest';
 import { type SetEnvironmentSecretFileRequest } from '../models/SetEnvironmentSecretFileRequest';
 import { type SetEnvironmentVarRequest } from '../models/SetEnvironmentVarRequest';
+import { type Share200Response } from '../models/Share200Response';
 import { type SnapshotDownloadResponse } from '../models/SnapshotDownloadResponse';
 import { type SnapshotLatestResponse } from '../models/SnapshotLatestResponse';
 import { type SnapshotListResponse } from '../models/SnapshotListResponse';
@@ -257,6 +258,8 @@ export interface RotateWebhookSigningSecretRequest {
     webhookId: string;
 }
 export interface SandboxesRequest {
+    org?: string;
+    xBoatOrg?: string;
     limit?: number;
     cursor?: string | null;
     sort?: SandboxesSortEnum;
@@ -280,6 +283,9 @@ export interface SetEnvironmentVarOperationRequest {
     key: string;
     setEnvironmentVarRequest: SetEnvironmentVarRequest;
 }
+export interface ShareRequest {
+    sandboxId: string;
+}
 export interface SshKeyOperationRequest {
     sandboxId: string;
     sshKeyRequest: SshKeyRequest;
@@ -387,12 +393,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     commandRequestOpts(input: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>): Promise<runtime.RequestOpts>;
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     commandRaw(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Command200Response>>;
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     command(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Command200Response>;
@@ -1023,10 +1029,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     sandboxesRequestOpts(requestParameters: SandboxesRequest): Promise<runtime.RequestOpts>;
     /**
+     * Your sandboxes. In an organization\'s scope (the active wallet, `org`, or `X-Boat-Org`) the list also holds every sandbox that organization pays for, whoever created it; `createdBy` and `access` say whose it is and what you may do with it.
      * List sandboxes
      */
     sandboxesRaw(requestParameters: SandboxesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxListResponse>>;
     /**
+     * Your sandboxes. In an organization\'s scope (the active wallet, `org`, or `X-Boat-Org`) the list also holds every sandbox that organization pays for, whoever created it; `createdBy` and `access` say whose it is and what you may do with it.
      * List sandboxes
      */
     sandboxes(requestParameters?: SandboxesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxListResponse>;
@@ -1114,6 +1122,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Set one environment variable
      */
     setEnvironmentVar(requestParameters: SetEnvironmentVarOperationRequest | runtime.FlatBody<SetEnvironmentVarOperationRequest, 'setEnvironmentVarRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse>;
+    /**
+     * Creates request options for share without sending the request
+     */
+    shareRequestOpts(requestParameters: ShareRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Let every member of the organization that pays for this sandbox use it.  Your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. One-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`).  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op.
+     * Share sandbox with the organization
+     */
+    shareRaw(requestParameters: ShareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Share200Response>>;
+    /**
+     * Let every member of the organization that pays for this sandbox use it.  Your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. One-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`).  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op.
+     * Share sandbox with the organization
+     */
+    share(requestParameters: ShareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Share200Response>;
     /**
      * Creates request options for sshKey without sending the request
      */

package/dist/apis/BoatApi.js

@@ -102,6 +102,7 @@ const SecretsResponse_1 = require("../models/SecretsResponse");
 const SecretsUpdateRequest_1 = require("../models/SecretsUpdateRequest");
 const SetEnvironmentSecretFileRequest_1 = require("../models/SetEnvironmentSecretFileRequest");
 const SetEnvironmentVarRequest_1 = require("../models/SetEnvironmentVarRequest");
+const Share200Response_1 = require("../models/Share200Response");
 const SnapshotDownloadResponse_1 = require("../models/SnapshotDownloadResponse");
 const SnapshotLatestResponse_1 = require("../models/SnapshotLatestResponse");
 const SnapshotListResponse_1 = require("../models/SnapshotListResponse");
@@ -331,7 +332,7 @@ class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     async commandRaw(requestParameters, initOverrides) {
@@ -340,7 +341,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, Command200Response_1.Command200ResponseFromJSON)(jsonValue));
     }
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     async command(requestParameters, initOverrides) {
@@ -2360,6 +2361,9 @@ class BoatApi extends runtime.BaseAPI {
      */
     async sandboxesRequestOpts(requestParameters) {
         const queryParameters = {};
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
         if (requestParameters['limit'] != null) {
             queryParameters['limit'] = requestParameters['limit'];
         }
@@ -2373,6 +2377,9 @@ class BoatApi extends runtime.BaseAPI {
             queryParameters['state'] = requestParameters['state'];
         }
         const headerParameters = {};
+        if (requestParameters['xBoatOrg'] != null) {
+            headerParameters['X-Boat-Org'] = String(requestParameters['xBoatOrg']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("BoatBearerAuth", []);
@@ -2389,6 +2396,7 @@ class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
+     * Your sandboxes. In an organization\'s scope (the active wallet, `org`, or `X-Boat-Org`) the list also holds every sandbox that organization pays for, whoever created it; `createdBy` and `access` say whose it is and what you may do with it.
      * List sandboxes
      */
     async sandboxesRaw(requestParameters, initOverrides) {
@@ -2397,6 +2405,7 @@ class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, SandboxListResponse_1.SandboxListResponseFromJSON)(jsonValue));
     }
     /**
+     * Your sandboxes. In an organization\'s scope (the active wallet, `org`, or `X-Boat-Org`) the list also holds every sandbox that organization pays for, whoever created it; `createdBy` and `access` say whose it is and what you may do with it.
      * List sandboxes
      */
     async sandboxes(requestParameters = {}, initOverrides) {
@@ -2673,6 +2682,48 @@ class BoatApi extends runtime.BaseAPI {
         const response = await this.setEnvironmentVarRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for share without sending the request
+     */
+    async shareRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling share().');
+        }
+        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}/share`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Let every member of the organization that pays for this sandbox use it.  Your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. One-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`).  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op.
+     * Share sandbox with the organization
+     */
+    async shareRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.shareRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, Share200Response_1.Share200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     * Let every member of the organization that pays for this sandbox use it.  Your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. One-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`).  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op.
+     * Share sandbox with the organization
+     */
+    async share(requestParameters, initOverrides) {
+        const response = await this.shareRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for sshKey without sending the request
      */

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

@@ -64,6 +64,7 @@ import { type SecretsResponse } from '../models/SecretsResponse';
 import { type SecretsUpdateRequest } from '../models/SecretsUpdateRequest';
 import { type SetEnvironmentSecretFileRequest } from '../models/SetEnvironmentSecretFileRequest';
 import { type SetEnvironmentVarRequest } from '../models/SetEnvironmentVarRequest';
+import { type Share200Response } from '../models/Share200Response';
 import { type SnapshotDownloadResponse } from '../models/SnapshotDownloadResponse';
 import { type SnapshotLatestResponse } from '../models/SnapshotLatestResponse';
 import { type SnapshotListResponse } from '../models/SnapshotListResponse';
@@ -257,6 +258,8 @@ export interface RotateWebhookSigningSecretRequest {
     webhookId: string;
 }
 export interface SandboxesRequest {
+    org?: string;
+    xBoatOrg?: string;
     limit?: number;
     cursor?: string | null;
     sort?: SandboxesSortEnum;
@@ -280,6 +283,9 @@ export interface SetEnvironmentVarOperationRequest {
     key: string;
     setEnvironmentVarRequest: SetEnvironmentVarRequest;
 }
+export interface ShareRequest {
+    sandboxId: string;
+}
 export interface SshKeyOperationRequest {
     sandboxId: string;
     sshKeyRequest: SshKeyRequest;
@@ -387,12 +393,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     commandRequestOpts(input: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>): Promise<runtime.RequestOpts>;
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     commandRaw(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Command200Response>>;
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     command(requestParameters: CommandOperationRequest | runtime.FlatBody<CommandOperationRequest, 'commandRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Command200Response>;
@@ -1023,10 +1029,12 @@ export declare class BoatApi extends runtime.BaseAPI {
      */
     sandboxesRequestOpts(requestParameters: SandboxesRequest): Promise<runtime.RequestOpts>;
     /**
+     * Your sandboxes. In an organization\'s scope (the active wallet, `org`, or `X-Boat-Org`) the list also holds every sandbox that organization pays for, whoever created it; `createdBy` and `access` say whose it is and what you may do with it.
      * List sandboxes
      */
     sandboxesRaw(requestParameters: SandboxesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SandboxListResponse>>;
     /**
+     * Your sandboxes. In an organization\'s scope (the active wallet, `org`, or `X-Boat-Org`) the list also holds every sandbox that organization pays for, whoever created it; `createdBy` and `access` say whose it is and what you may do with it.
      * List sandboxes
      */
     sandboxes(requestParameters?: SandboxesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SandboxListResponse>;
@@ -1114,6 +1122,20 @@ export declare class BoatApi extends runtime.BaseAPI {
      * Set one environment variable
      */
     setEnvironmentVar(requestParameters: SetEnvironmentVarOperationRequest | runtime.FlatBody<SetEnvironmentVarOperationRequest, 'setEnvironmentVarRequest'>, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<EnvironmentItemChangeResponse>;
+    /**
+     * Creates request options for share without sending the request
+     */
+    shareRequestOpts(requestParameters: ShareRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Let every member of the organization that pays for this sandbox use it.  Your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. One-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`).  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op.
+     * Share sandbox with the organization
+     */
+    shareRaw(requestParameters: ShareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Share200Response>>;
+    /**
+     * Let every member of the organization that pays for this sandbox use it.  Your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. One-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`).  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op.
+     * Share sandbox with the organization
+     */
+    share(requestParameters: ShareRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Share200Response>;
     /**
      * Creates request options for sshKey without sending the request
      */

package/dist/esm/apis/BoatApi.js

@@ -66,6 +66,7 @@ import { SecretsResponseFromJSON, } from '../models/SecretsResponse';
 import { SecretsUpdateRequestToJSON, } from '../models/SecretsUpdateRequest';
 import { SetEnvironmentSecretFileRequestToJSON, } from '../models/SetEnvironmentSecretFileRequest';
 import { SetEnvironmentVarRequestToJSON, } from '../models/SetEnvironmentVarRequest';
+import { Share200ResponseFromJSON, } from '../models/Share200Response';
 import { SnapshotDownloadResponseFromJSON, } from '../models/SnapshotDownloadResponse';
 import { SnapshotLatestResponseFromJSON, } from '../models/SnapshotLatestResponse';
 import { SnapshotListResponseFromJSON, } from '../models/SnapshotListResponse';
@@ -295,7 +296,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     async commandRaw(requestParameters, initOverrides) {
@@ -304,7 +305,7 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => Command200ResponseFromJSON(jsonValue));
     }
     /**
-     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
+     * Runs the command synchronously by default (timeout configurable via `timeoutSeconds`, 600s cap). With `detached: true` the command starts in the background and a process id is returned immediately; poll `/sandboxes/{sandboxId}/commands/{processId}` for status and logs. With `stream: true` the output arrives as the command writes it, as newline-delimited JSON (`application/x-ndjson`): `{\"type\":\"started\"}`, then `{\"type\":\"stdout\"|\"stderr\",\"data\":\"...\"}` per chunk, and last `{\"type\":\"exit\",...}` (the synchronous result without stdout/stderr) or `{\"type\":\"error\",\"error\":\"...\",\"message\":\"...\"}`. Returns 400 invalid_timeout when `timeoutSeconds` is not an integer in 1-600. A command sent while the sandbox is still starting (right after a resume) waits up to 60s for it to be ready instead of failing; 409 boat_starting (retryable) is returned only if it is still not ready by then. A sandbox that is not starting (`error`, `stopped`) returns 409 sandbox_not_ready with `retryable: false` and its `state` at once: resume or recover it first. Command execution is never retried automatically: a 502 boat_direct_failed means the command may already be running on the sandbox.
      * Execute a command in a sandbox
      */
     async command(requestParameters, initOverrides) {
@@ -2324,6 +2325,9 @@ export class BoatApi extends runtime.BaseAPI {
      */
     async sandboxesRequestOpts(requestParameters) {
         const queryParameters = {};
+        if (requestParameters['org'] != null) {
+            queryParameters['org'] = requestParameters['org'];
+        }
         if (requestParameters['limit'] != null) {
             queryParameters['limit'] = requestParameters['limit'];
         }
@@ -2337,6 +2341,9 @@ export class BoatApi extends runtime.BaseAPI {
             queryParameters['state'] = requestParameters['state'];
         }
         const headerParameters = {};
+        if (requestParameters['xBoatOrg'] != null) {
+            headerParameters['X-Boat-Org'] = String(requestParameters['xBoatOrg']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("BoatBearerAuth", []);
@@ -2353,6 +2360,7 @@ export class BoatApi extends runtime.BaseAPI {
         };
     }
     /**
+     * Your sandboxes. In an organization\'s scope (the active wallet, `org`, or `X-Boat-Org`) the list also holds every sandbox that organization pays for, whoever created it; `createdBy` and `access` say whose it is and what you may do with it.
      * List sandboxes
      */
     async sandboxesRaw(requestParameters, initOverrides) {
@@ -2361,6 +2369,7 @@ export class BoatApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => SandboxListResponseFromJSON(jsonValue));
     }
     /**
+     * Your sandboxes. In an organization\'s scope (the active wallet, `org`, or `X-Boat-Org`) the list also holds every sandbox that organization pays for, whoever created it; `createdBy` and `access` say whose it is and what you may do with it.
      * List sandboxes
      */
     async sandboxes(requestParameters = {}, initOverrides) {
@@ -2637,6 +2646,48 @@ export class BoatApi extends runtime.BaseAPI {
         const response = await this.setEnvironmentVarRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     * Creates request options for share without sending the request
+     */
+    async shareRequestOpts(requestParameters) {
+        if (requestParameters['sandboxId'] == null) {
+            throw new runtime.RequiredError('sandboxId', 'Required parameter "sandboxId" was null or undefined when calling share().');
+        }
+        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}/share`;
+        urlPath = urlPath.replace('{sandboxId}', encodeURIComponent(String(requestParameters['sandboxId'])));
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+    /**
+     * Let every member of the organization that pays for this sandbox use it.  Your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. One-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`).  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op.
+     * Share sandbox with the organization
+     */
+    async shareRaw(requestParameters, initOverrides) {
+        const requestOptions = await this.shareRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => Share200ResponseFromJSON(jsonValue));
+    }
+    /**
+     * Let every member of the organization that pays for this sandbox use it.  Your personal logins (GitHub token, Claude and Codex logins, environment secrets, the sandbox\'s own CLI key) are never pushed to it again and are wiped off its disk at its next start, so a teammate never acts as you. Files you wrote stay. One-way: the sandbox stays like a `noEnv` sandbox from then on. A running sandbox stays `view` for the organization until you stop and resume it (`restartRequired`).  Only the person who created the sandbox can share it, and only a sandbox billed to an organization. Sharing an already shared sandbox is a no-op.
+     * Share sandbox with the organization
+     */
+    async share(requestParameters, initOverrides) {
+        const response = await this.shareRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * Creates request options for sshKey without sending the request
      */

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

@@ -54,7 +54,7 @@ export interface CreateSandboxRequest {
      */
     snapshots?: boolean;
     /**
-     * Pass `true` to get a sandbox only if a machine of this type is ready right now. The call answers within about 1.5 s: either the usual `202` with the sandbox, or `503` `no_ready_machine` with nothing created, billed, or counted against your start limits, so you can retry or fall back at once. Without it, a create waits for a machine to be built when none is ready. Not combinable with `from`.
+     * Pass `true` to get a sandbox only if a machine of this type is ready right now. The call answers within about 1.5 s: either the usual `202` with the sandbox, or `503` `no_ready_machine` with nothing created, billed, or counted against your start limits, so you can retry or fall back at once. Without it, a create waits for a machine to be built when none is ready. Works with `from`; fork and resume take it too.
      * @type {boolean}
      * @memberof CreateSandboxRequest
      */

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

@@ -15,6 +15,12 @@
  * @interface ForkRequest
  */
 export interface ForkRequest {
+    /**
+     * Pass `true` to fork only if a machine is ready right now. Within about 1.5 s you get the usual `202`, or `503` `no_ready_machine` with no fork created and nothing counted against your start limits.
+     * @type {boolean}
+     * @memberof ForkRequest
+     */
+    failFast?: boolean;
     /**
      * Replaces the env the fork would otherwise inherit from the source sandbox. Same validation rules as `CreateSandboxRequest.env`.
      * @type {{ [key: string]: string; }}

package/dist/esm/models/ForkRequest.js

@@ -33,6 +33,7 @@ export function ForkRequestFromJSONTyped(json, ignoreDiscriminator) {
         return json;
     }
     return {
+        'failFast': json['failFast'] == null ? undefined : json['failFast'],
         'env': json['env'] == null ? undefined : json['env'],
         'environment': json['environment'] == null ? undefined : json['environment'],
         'noEnv': json['noEnv'] == null ? undefined : json['noEnv'],
@@ -48,6 +49,7 @@ export function ForkRequestToJSONTyped(value, ignoreDiscriminator = false) {
         return value;
     }
     return {
+        'failFast': value['failFast'],
         'env': value['env'],
         'environment': value['environment'],
         'noEnv': value['noEnv'],

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

@@ -40,6 +40,12 @@ export interface PromptRequest {
      * @memberof PromptRequest
      */
     reasoningEffort?: string | null;
+    /**
+     * Optional. `true` runs this prompt in fast mode. The model stays the same and gives output faster. The provider bills fast mode at its higher fast rate. Omit to use the choice saved on the Agents dashboard for that model. `false` forces standard speed. Only models with `fastMode` set to `true` in `GET /provider-models` accept `true`. Other models return 400 `fast_mode_not_supported`.
+     * @type {boolean}
+     * @memberof PromptRequest
+     */
+    fast?: boolean | null;
     /**
      * Start a NEW conversation on the sandbox (runs in parallel with any existing ones) instead of continuing the most-recently-active one. Mutually exclusive with `conversationId`.
      * @type {boolean}

package/dist/esm/models/PromptRequest.js

@@ -46,6 +46,7 @@ export function PromptRequestFromJSONTyped(json, ignoreDiscriminator) {
         'provider': json['provider'],
         'model': json['model'] == null ? undefined : json['model'],
         'reasoningEffort': json['reasoningEffort'] == null ? undefined : json['reasoningEffort'],
+        'fast': json['fast'] == null ? undefined : json['fast'],
         '_new': json['new'] == null ? undefined : json['new'],
         'conversationId': json['conversationId'] == null ? undefined : json['conversationId'],
         'prompt': json['prompt'],
@@ -62,6 +63,7 @@ export function PromptRequestToJSONTyped(value, ignoreDiscriminator = false) {
         'provider': value['provider'],
         'model': value['model'],
         'reasoningEffort': value['reasoningEffort'],
+        'fast': value['fast'],
         'new': value['_new'],
         'conversationId': value['conversationId'],
         'prompt': value['prompt'],

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

@@ -76,6 +76,12 @@ export interface PromptResponse {
      * @memberof PromptResponse
      */
     reasoningEffort?: string | null;
+    /**
+     * The prompt runs in fast mode.
+     * @type {boolean}
+     * @memberof PromptResponse
+     */
+    fast?: boolean;
 }
 /**
  * @export

package/dist/esm/models/PromptResponse.js

@@ -62,6 +62,7 @@ export function PromptResponseFromJSONTyped(json, ignoreDiscriminator) {
         'provider': json['provider'],
         'model': json['model'] == null ? undefined : json['model'],
         'reasoningEffort': json['reasoningEffort'] == null ? undefined : json['reasoningEffort'],
+        'fast': json['fast'] == null ? undefined : json['fast'],
     };
 }
 export function PromptResponseToJSON(json) {
@@ -82,5 +83,6 @@ export function PromptResponseToJSONTyped(value, ignoreDiscriminator = false) {
         'provider': value['provider'],
         'model': value['model'],
         'reasoningEffort': value['reasoningEffort'],
+        'fast': value['fast'],
     };
 }

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

@@ -63,6 +63,12 @@ export interface PromptRun {
      * @memberof PromptRun
      */
     reasoningEffort?: string | null;
+    /**
+     * The prompt runs in fast mode. `null` means no speed is set yet. The prompt waits without a speed choice, or it ended without running (`done` is true). The speed is set when the prompt starts, for the model that runs.
+     * @type {boolean}
+     * @memberof PromptRun
+     */
+    fast?: boolean | null;
     /**
      * The conversation this prompt ran in. A Sandbox runs many conversations in parallel; see [Integrated agents](/integrated-agents).
      * @type {string}

package/dist/esm/models/PromptRun.js

@@ -54,6 +54,7 @@ export function PromptRunFromJSONTyped(json, ignoreDiscriminator) {
         'createdAt': json['createdAt'] == null ? undefined : (new Date(json['createdAt'])),
         'model': json['model'] == null ? undefined : json['model'],
         'reasoningEffort': json['reasoningEffort'] == null ? undefined : json['reasoningEffort'],
+        'fast': json['fast'] == null ? undefined : json['fast'],
         'conversationId': json['conversationId'] == null ? undefined : json['conversationId'],
     };
 }
@@ -73,6 +74,7 @@ export function PromptRunToJSONTyped(value, ignoreDiscriminator = false) {
         'createdAt': value['createdAt'] == null ? value['createdAt'] : value['createdAt'].toISOString(),
         'model': value['model'],
         'reasoningEffort': value['reasoningEffort'],
+        'fast': value['fast'],
         'conversationId': value['conversationId'],
     };
 }

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

@@ -15,6 +15,12 @@
  * @interface ResumeRequest
  */
 export interface ResumeRequest {
+    /**
+     * Pass `true` to resume only if a machine is ready right now. Within about 1.5 s you get the usual `202`, or `503` `no_ready_machine` with the sandbox left stopped and nothing counted against your start limits.
+     * @type {boolean}
+     * @memberof ResumeRequest
+     */
+    failFast?: boolean;
     /**
      * Resume onto a different machine size. Omit to keep the sandbox's current type. A resume already restores onto a fresh machine, so changing size costs nothing extra. Shrinking is rejected with `type_too_small` when the sandbox's data would not fit the smaller disk.
      * @type {ResumeRequestTypeEnum}

package/dist/esm/models/ResumeRequest.js

@@ -33,6 +33,7 @@ export function ResumeRequestFromJSONTyped(json, ignoreDiscriminator) {
         return json;
     }
     return {
+        'failFast': json['failFast'] == null ? undefined : json['failFast'],
         'type': json['type'] == null ? undefined : json['type'],
         'env': json['env'] == null ? undefined : json['env'],
         'environment': json['environment'] == null ? undefined : json['environment'],
@@ -48,6 +49,7 @@ export function ResumeRequestToJSONTyped(value, ignoreDiscriminator = false) {
         return value;
     }
     return {
+        'failFast': value['failFast'],
         'type': value['type'],
         'env': value['env'],
         'environment': value['environment'],