codai-sdk 0.54.1 → 0.55.0

package/dist/index.d.ts

@@ -3055,6 +3055,126 @@ type paths$1 = {
     readonly patch?: never;
     readonly trace?: never;
   };
+  readonly '/v1/sandboxes/{id}/fork': {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: never;
+      readonly path?: never;
+      readonly cookie?: never;
+    };
+    readonly get?: never;
+    readonly put?: never;
+    /**
+     * Fork a running sandbox (v2)
+     * @description Snapshots the running sandbox (it keeps running) and starts `count` new sandboxes from that snapshot, each with its own id, workspace copy and kernel state. Per child, `restored: false` means it started cold; a child that failed carries `error` and is not running.
+     */
+    readonly post: operations$1['forkSandbox'];
+    readonly delete?: never;
+    readonly options?: never;
+    readonly head?: never;
+    readonly patch?: never;
+    readonly trace?: never;
+  };
+  readonly '/v1/sandboxes/{id}/kernel/reset': {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: never;
+      readonly path?: never;
+      readonly cookie?: never;
+    };
+    readonly get?: never;
+    readonly put?: never;
+    /**
+     * Restart the kernel (v2)
+     * @description Restarts the persistent Python kernel; all globals are lost, the workspace is kept.
+     */
+    readonly post: operations$1['resetSandboxKernel'];
+    readonly delete?: never;
+    readonly options?: never;
+    readonly head?: never;
+    readonly patch?: never;
+    readonly trace?: never;
+  };
+  readonly '/v1/sandboxes/{id}/pause': {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: never;
+      readonly path?: never;
+      readonly cookie?: never;
+    };
+    readonly get?: never;
+    readonly put?: never;
+    /**
+     * Pause a sandbox (v2)
+     * @description Takes a memory snapshot (processes, kernel state and `/workspace`), then stops the pod. The sandbox moves to status `paused`; only snapshot storage is billed while paused (€0.05 per GB-month).
+     */
+    readonly post: operations$1['pauseSandbox'];
+    readonly delete?: never;
+    readonly options?: never;
+    readonly head?: never;
+    readonly patch?: never;
+    readonly trace?: never;
+  };
+  readonly '/v1/sandboxes/{id}/preview': {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: never;
+      readonly path?: never;
+      readonly cookie?: never;
+    };
+    readonly get?: never;
+    readonly put?: never;
+    /**
+     * Get a preview URL for a port (v2)
+     * @description Signs a temporary HTTPS URL on `*.sbx.codai.ro` that forwards to a port inside the sandbox (for example a dev server, or noVNC on 6080 in the `desktop` template). The URL needs no key; it expires after `ttl_seconds` (default 900, at most 1 h).
+     */
+    readonly post: operations$1['previewSandbox'];
+    readonly delete?: never;
+    readonly options?: never;
+    readonly head?: never;
+    readonly patch?: never;
+    readonly trace?: never;
+  };
+  readonly '/v1/sandboxes/{id}/resume': {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: never;
+      readonly path?: never;
+      readonly cookie?: never;
+    };
+    readonly get?: never;
+    readonly put?: never;
+    /**
+     * Resume a paused sandbox (v2)
+     * @description Restores the sandbox from its pause snapshot. `restored` tells whether the memory state came back (`true`) or the pod started cold from the workspace only (`false`); `ready_ms` is the time until the sandbox answered.
+     */
+    readonly post: operations$1['resumeSandbox'];
+    readonly delete?: never;
+    readonly options?: never;
+    readonly head?: never;
+    readonly patch?: never;
+    readonly trace?: never;
+  };
+  readonly '/v1/sandboxes/{id}/run_code': {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: never;
+      readonly path?: never;
+      readonly cookie?: never;
+    };
+    readonly get?: never;
+    readonly put?: never;
+    /**
+     * Run code in the persistent kernel (v2)
+     * @description Runs Python in the sandbox kernel, which keeps its globals between calls, across pause/resume and into forks. The last expression of the cell is returned as `result` (repr, at most 64 KB). A call past its timeout restarts the kernel (`kernel_restarted: true`, state lost). Only for `backend: "v2"` sandboxes (closed canary).
+     */
+    readonly post: operations$1['runSandboxCode'];
+    readonly delete?: never;
+    readonly options?: never;
+    readonly head?: never;
+    readonly patch?: never;
+    readonly trace?: never;
+  };
   readonly '/v1/sandboxes/{id}/snapshot': {
     readonly parameters: {
       readonly query?: never;
@@ -12410,6 +12530,11 @@ type components$1 = {
     };
     /** Sandbox */
     readonly Sandbox: {
+      /**
+       * @description Backend chosen at create time.
+       * @enum {string}
+       */
+      readonly backend: 'v1' | 'v2';
       /** Format: date-time */
       readonly created_at: string;
       readonly egress: components$1['schemas']['SandboxEgress'];
@@ -12424,8 +12549,10 @@ type components$1 = {
       };
       /** @enum {string} */
       readonly object: 'sandbox';
+      /** @description Only on create of a `v2` sandbox: true when it started from a warm template snapshot. */
+      readonly restored?: boolean;
       /** @enum {string} */
-      readonly status: 'running' | 'stopped' | 'expired' | 'destroyed';
+      readonly status: 'running' | 'paused' | 'stopped' | 'expired' | 'destroyed';
       readonly template: string;
       readonly usage: {
         readonly exec_count: number;
@@ -12457,19 +12584,25 @@ type components$1 = {
     };
     /** Create sandbox request */
     readonly SandboxCreate: {
+      /**
+       * @description Execution backend: `v1` (default, workspace snapshots between execs) or `v2` (closed canary: long-lived pod with memory snapshots, pause/resume, fork, persistent kernel and preview URLs; no network egress).
+       * @default v1
+       * @enum {string}
+       */
+      readonly backend?: 'v1' | 'v2';
       readonly egress?: components$1['schemas']['SandboxEgress'];
       /** @description Your own labels, returned as-is. */
       readonly metadata?: {
         readonly [key: string]: string;
       };
       /**
-       * @description Image template.
+       * @description Image template. `v1`: `codai-base` only. `v2`: `codai-base`, `brivio-acte` (office toolchain warmed up) or `desktop` (a Linux desktop over noVNC on port 6080).
        * @default codai-base
        * @enum {string}
        */
-      readonly template?: 'codai-base';
+      readonly template?: 'codai-base' | 'brivio-acte' | 'desktop';
       /**
-       * @description Lifetime; the sandbox expires afterwards (sliding for chat sessions).
+       * @description Lifetime; the sandbox expires afterwards (sliding for chat sessions). At most 86400 on `v1` and 604800 on `v2`.
        * @default 3600
        */
       readonly ttl_seconds?: number;
@@ -12517,6 +12650,7 @@ type components$1 = {
       readonly changed: readonly string[];
       readonly cpu_ms: number;
       readonly duration_ms: number;
+      /** @description The command's own exit status; `128 + n` when it was ended by signal `n`. `null` only when the exec timed out (`timed_out: true`) or the process could not be started. */
       readonly exit_code: number | null;
       readonly generation: number;
       readonly receipt: components$1['schemas']['SandboxReceipt'];
@@ -12567,7 +12701,7 @@ type components$1 = {
       /** @description Present on `/v1/sandboxes/run`. */
       readonly artifacts?: readonly components$1['schemas']['SandboxArtifact'][];
       readonly duration_ms: number;
-      /** @description `null` when the process was killed. */
+      /** @description The command's own exit status; `128 + n` when it was ended by signal `n`. `null` only when the exec timed out (`timed_out: true`) or the process could not be started. */
       readonly exit_code: number | null;
       readonly receipt: components$1['schemas']['SandboxReceipt'];
       /** @description Standard error (at most 1 MB). */
@@ -12594,6 +12728,33 @@ type components$1 = {
       readonly path: string;
       readonly sha256: string;
     };
+    /** Fork sandbox request */
+    readonly SandboxForkRequest: {
+      /** @description How many children to start (1–5). */
+      readonly count: number;
+      /** @description Lifetime of each child in seconds (default: what is left of the parent). */
+      readonly ttl_seconds?: number;
+    };
+    /** Fork result */
+    readonly SandboxForkResult: {
+      readonly data: readonly {
+        /** @description Why this child failed (it is not running). */
+        readonly error?: {
+          readonly code: string;
+          readonly message: string;
+        };
+        /** Format: uuid */
+        readonly id: string;
+        /** @description Milliseconds until the child answered. */
+        readonly ready_ms: number;
+        /** @description True when the child started from the memory snapshot, false when it started cold. */
+        readonly restored: boolean;
+      }[];
+      /** @enum {string} */
+      readonly object: 'list';
+      /** Format: uuid */
+      readonly parent_id: string;
+    };
     /**
      * Sandbox input file
      * @description One input file: inline `base64` or an https `url`; `sha256` is verified when given.
@@ -12612,6 +12773,27 @@ type components$1 = {
       /** @enum {string} */
       readonly object?: 'list';
     };
+    /** Preview URL */
+    readonly SandboxPreview: {
+      /** Format: date-time */
+      readonly expires_at: string;
+      readonly port: number;
+      /**
+       * Format: uri
+       * @description Signed HTTPS URL; anyone holding it reaches the port until it expires.
+       */
+      readonly url: string;
+    };
+    /** Preview URL request */
+    readonly SandboxPreviewRequest: {
+      /** @description Port inside the sandbox (1024–65535, not 8080). */
+      readonly port: number;
+      /**
+       * @description Validity in seconds (60–3600, default 900).
+       * @default 900
+       */
+      readonly ttl_seconds?: number;
+    };
     /**
      * Reproducibility receipt
      * @description What ran and what it produced: image digest, hashes of the inputs and the command, every output file with its SHA-256, and the workspace generations before and after.
@@ -12629,6 +12811,44 @@ type components$1 = {
       }[];
       readonly template: string;
     };
+    /** Resumed sandbox */
+    readonly SandboxResumed: components$1['schemas']['Sandbox'] & {
+      /** @description Milliseconds until the sandbox answered. */
+      readonly ready_ms: number;
+      /** @description True when the memory state was restored, false on a cold start. */
+      readonly restored: boolean;
+    };
+    /** Run code request */
+    readonly SandboxRunCodeRequest: {
+      /** @description Python source of the cell. */
+      readonly code: string;
+      /**
+       * @description Seconds before the kernel is restarted (default 60, max 900).
+       * @default 60
+       */
+      readonly timeout_seconds?: number;
+    };
+    /** Run code result */
+    readonly SandboxRunCodeResult: {
+      /** @description Wall-clock milliseconds. */
+      readonly duration_ms: number;
+      /** @description The uncaught exception, or null. */
+      readonly error: {
+        readonly name: string;
+        readonly traceback: string;
+        readonly value: string;
+      } | null;
+      /** @description Kernel execution counter. */
+      readonly execution_count: number;
+      /** @description True when the kernel was restarted (timeout or crash) and its state is lost. */
+      readonly kernel_restarted: boolean;
+      /** @description repr of the last expression, or null. */
+      readonly result: string | null;
+      /** @description Text printed to stderr during the cell. */
+      readonly stderr: string;
+      /** @description Text printed to stdout during the cell. */
+      readonly stdout: string;
+    };
     /**
      * One-shot run request
      * @description The fields of `SandboxCreate` plus those of `SandboxExecRequest`.
@@ -21974,7 +22194,7 @@ interface operations$1 {
     readonly parameters: {
       readonly query?: {
         /** @description Only sandboxes in this status. */
-        readonly status?: 'running' | 'stopped' | 'expired' | 'destroyed';
+        readonly status?: 'running' | 'paused' | 'stopped' | 'expired' | 'destroyed';
       };
       readonly header?: {
         /** @description Client correlation id; echoed back as `x-codai-trace-id` and persisted on the usage row. */
@@ -22395,6 +22615,318 @@ interface operations$1 {
       };
     };
   };
+  readonly forkSandbox: {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: {
+        /** @description Client correlation id; echoed back as `x-codai-trace-id` and persisted on the usage row. */
+        readonly 'x-request-id'?: components$1['parameters']['RequestId'];
+      };
+      readonly path: {
+        /** @description Sandbox id (uuid). */
+        readonly id: string;
+      };
+      readonly cookie?: never;
+    };
+    readonly requestBody: {
+      readonly content: {
+        readonly 'application/json': components$1['schemas']['SandboxForkRequest'];
+      };
+    };
+    readonly responses: {
+      /** @description The children. */
+      readonly 200: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['SandboxForkResult'];
+        };
+      };
+      readonly 400: components$1['responses']['BadRequest'];
+      readonly 401: components$1['responses']['Unauthorized'];
+      readonly 402: components$1['responses']['PaymentRequired'];
+      /** @description The key does not reach tool level `l3_sandbox`. */
+      readonly 403: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+      readonly 404: components$1['responses']['NotFound'];
+      /** @description The sandbox is not a `backend: "v2"` sandbox (`requires_v2`), is not running (`sandbox_not_running`) or another operation holds it (`sandbox_busy`). */
+      readonly 409: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+      /** @description The fork would take this key above 6 live sandboxes (`sandbox_concurrency_limit`). */
+      readonly 429: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+    };
+  };
+  readonly resetSandboxKernel: {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: {
+        /** @description Client correlation id; echoed back as `x-codai-trace-id` and persisted on the usage row. */
+        readonly 'x-request-id'?: components$1['parameters']['RequestId'];
+      };
+      readonly path: {
+        /** @description Sandbox id (uuid). */
+        readonly id: string;
+      };
+      readonly cookie?: never;
+    };
+    readonly requestBody?: never;
+    readonly responses: {
+      /** @description The kernel was restarted. */
+      readonly 200: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': {
+            /** @enum {boolean} */
+            readonly ok: true;
+          };
+        };
+      };
+      readonly 400: components$1['responses']['BadRequest'];
+      readonly 401: components$1['responses']['Unauthorized'];
+      readonly 402: components$1['responses']['PaymentRequired'];
+      /** @description The key does not reach tool level `l3_sandbox`. */
+      readonly 403: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+      readonly 404: components$1['responses']['NotFound'];
+      /** @description The sandbox is not a `backend: "v2"` sandbox (`requires_v2`), is not running (`sandbox_not_running`) or another operation holds it (`sandbox_busy`). */
+      readonly 409: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+    };
+  };
+  readonly pauseSandbox: {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: {
+        /** @description Client correlation id; echoed back as `x-codai-trace-id` and persisted on the usage row. */
+        readonly 'x-request-id'?: components$1['parameters']['RequestId'];
+      };
+      readonly path: {
+        /** @description Sandbox id (uuid). */
+        readonly id: string;
+      };
+      readonly cookie?: never;
+    };
+    readonly requestBody?: never;
+    readonly responses: {
+      /** @description The paused sandbox. */
+      readonly 200: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Sandbox'];
+        };
+      };
+      readonly 400: components$1['responses']['BadRequest'];
+      readonly 401: components$1['responses']['Unauthorized'];
+      readonly 402: components$1['responses']['PaymentRequired'];
+      /** @description The key does not reach tool level `l3_sandbox`. */
+      readonly 403: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+      readonly 404: components$1['responses']['NotFound'];
+      /** @description The sandbox is not a `backend: "v2"` sandbox (`requires_v2`), is not running (`sandbox_not_running`) or another operation holds it (`sandbox_busy`). */
+      readonly 409: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+    };
+  };
+  readonly previewSandbox: {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: {
+        /** @description Client correlation id; echoed back as `x-codai-trace-id` and persisted on the usage row. */
+        readonly 'x-request-id'?: components$1['parameters']['RequestId'];
+      };
+      readonly path: {
+        /** @description Sandbox id (uuid). */
+        readonly id: string;
+      };
+      readonly cookie?: never;
+    };
+    readonly requestBody: {
+      readonly content: {
+        readonly 'application/json': components$1['schemas']['SandboxPreviewRequest'];
+      };
+    };
+    readonly responses: {
+      /** @description The signed preview URL. */
+      readonly 200: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['SandboxPreview'];
+        };
+      };
+      readonly 400: components$1['responses']['BadRequest'];
+      readonly 401: components$1['responses']['Unauthorized'];
+      readonly 402: components$1['responses']['PaymentRequired'];
+      /** @description The key does not reach tool level `l3_sandbox`. */
+      readonly 403: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+      readonly 404: components$1['responses']['NotFound'];
+      /** @description The sandbox is not a `backend: "v2"` sandbox (`requires_v2`), is not running (`sandbox_not_running`) or another operation holds it (`sandbox_busy`). */
+      readonly 409: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+    };
+  };
+  readonly resumeSandbox: {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: {
+        /** @description Client correlation id; echoed back as `x-codai-trace-id` and persisted on the usage row. */
+        readonly 'x-request-id'?: components$1['parameters']['RequestId'];
+      };
+      readonly path: {
+        /** @description Sandbox id (uuid). */
+        readonly id: string;
+      };
+      readonly cookie?: never;
+    };
+    readonly requestBody?: never;
+    readonly responses: {
+      /** @description The resumed sandbox. */
+      readonly 200: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['SandboxResumed'];
+        };
+      };
+      readonly 400: components$1['responses']['BadRequest'];
+      readonly 401: components$1['responses']['Unauthorized'];
+      readonly 402: components$1['responses']['PaymentRequired'];
+      /** @description The key does not reach tool level `l3_sandbox`. */
+      readonly 403: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+      readonly 404: components$1['responses']['NotFound'];
+      /** @description The sandbox is not a `backend: "v2"` sandbox (`requires_v2`), is not paused (`sandbox_not_paused`) or another operation holds it (`sandbox_busy`). */
+      readonly 409: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+    };
+  };
+  readonly runSandboxCode: {
+    readonly parameters: {
+      readonly query?: never;
+      readonly header?: {
+        /** @description Client correlation id; echoed back as `x-codai-trace-id` and persisted on the usage row. */
+        readonly 'x-request-id'?: components$1['parameters']['RequestId'];
+      };
+      readonly path: {
+        /** @description Sandbox id (uuid). */
+        readonly id: string;
+      };
+      readonly cookie?: never;
+    };
+    readonly requestBody: {
+      readonly content: {
+        readonly 'application/json': components$1['schemas']['SandboxRunCodeRequest'];
+      };
+    };
+    readonly responses: {
+      /** @description The cell result. */
+      readonly 200: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['SandboxRunCodeResult'];
+        };
+      };
+      readonly 400: components$1['responses']['BadRequest'];
+      readonly 401: components$1['responses']['Unauthorized'];
+      readonly 402: components$1['responses']['PaymentRequired'];
+      /** @description The key does not reach tool level `l3_sandbox`. */
+      readonly 403: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+      readonly 404: components$1['responses']['NotFound'];
+      /** @description The sandbox is not a `backend: "v2"` sandbox (`requires_v2`), is not running (`sandbox_not_running`) or another operation holds it (`sandbox_busy`). */
+      readonly 409: {
+        headers: {
+          readonly [name: string]: unknown;
+        };
+        content: {
+          readonly 'application/json': components$1['schemas']['Error'];
+        };
+      };
+    };
+  };
   readonly snapshotSandbox: {
     readonly parameters: {
       readonly query?: never;
@@ -34013,6 +34545,32 @@ export type SandboxFileWritten = Reply<'putSandboxFile'>;
 export type SandboxSnapshot = Reply<'snapshotSandbox'>;
 export type SandboxStatus = Sandbox['status'];
 export type SandboxSnapshotInput = Mutable<NonNullable<Body<'snapshotSandbox'>>>;
+export type SandboxBackend = NonNullable<SandboxCreateInput['backend']>;
+export type SandboxTemplate = NonNullable<SandboxCreateInput['template']>;
+export type SandboxRunCodeResult = Schema<'SandboxRunCodeResult'>;
+export type SandboxResumed = Reply<'resumeSandbox'>;
+export type SandboxForkResult = Reply<'forkSandbox'>;
+export type SandboxPreview = Reply<'previewSandbox'>;
+/** Input of {@link Sandboxes.runCode}. */
+export interface SandboxRunCodeInput {
+  code: string;
+  /** Seconds before the kernel is restarted (1–900, server default 60). */
+  timeoutSeconds?: number;
+}
+/** Input of {@link Sandboxes.fork}. */
+export interface SandboxForkInput {
+  /** Children to start (1–5). */
+  count: number;
+  /** Lifetime of each child; default what is left of the parent. */
+  ttlSeconds?: number;
+}
+/** Input of {@link Sandboxes.preview}. */
+export interface SandboxPreviewInput {
+  /** Port inside the sandbox (1024–65535, not 8080). */
+  port: number;
+  /** URL validity in seconds (60–3600, server default 900). */
+  ttlSeconds?: number;
+}
 type CallOpts$5 = {
   ext?: CodaiRequestExtensions;
   signal?: AbortSignal;
@@ -34040,7 +34598,11 @@ export declare class Sandboxes {
   private readonly http;
   readonly files: SandboxFiles;
   constructor(http: HttpClient);
-  /** `POST /v1/sandboxes` — start a sandbox (`ttl_seconds` 60–86400, default 3600; `egress` none by default). */
+  /**
+   * `POST /v1/sandboxes` — start a sandbox (`ttl_seconds` 60–86400, default 3600; `egress` none by default).
+   * `backend: 'v2'` (closed canary) starts a long-lived pod with memory snapshots and accepts `template`
+   * `codai-base` | `brivio-acte` | `desktop`; its reply may carry `restored`.
+   */
   create(input?: SandboxCreateInput, opts?: CallOpts$5): Promise<Sandbox>;
   /** `GET /v1/sandboxes` — your sandboxes, newest first, optionally one `status`. */
   list(query?: {
@@ -34062,6 +34624,21 @@ export declare class Sandboxes {
   artifacts(id: string, opts?: CallOpts$5): Promise<SandboxArtifactList>;
   /** `POST /v1/sandboxes/{id}/snapshot` — store a compressed copy of the workspace. */
   snapshot(id: string, input?: SandboxSnapshotInput, opts?: CallOpts$5): Promise<SandboxSnapshot>;
+  /**
+   * `POST /v1/sandboxes/{id}/run_code` (v2) — run Python in the persistent kernel; globals survive between
+   * calls, pause/resume and forks. The last expression comes back as `result`.
+   */
+  runCode(id: string, input: SandboxRunCodeInput, opts?: CallOpts$5): Promise<SandboxRunCodeResult>;
+  /** `POST /v1/sandboxes/{id}/kernel/reset` (v2) — restart the kernel; globals are lost, files kept. */
+  resetKernel(id: string, opts?: CallOpts$5): Promise<void>;
+  /** `POST /v1/sandboxes/{id}/pause` (v2) — memory snapshot, then stop the pod (status `paused`). */
+  pause(id: string, opts?: CallOpts$5): Promise<Sandbox>;
+  /** `POST /v1/sandboxes/{id}/resume` (v2) — restore a paused sandbox; `restored: false` = cold start. */
+  resume(id: string, opts?: CallOpts$5): Promise<SandboxResumed>;
+  /** `POST /v1/sandboxes/{id}/fork` (v2) — start 1–5 copies of a running sandbox from a memory snapshot. */
+  fork(id: string, input: SandboxForkInput, opts?: CallOpts$5): Promise<SandboxForkResult>;
+  /** `POST /v1/sandboxes/{id}/preview` (v2) — signed HTTPS URL on `*.sbx.codai.ro` for a port (≤ 1 h). */
+  preview(id: string, input: SandboxPreviewInput, opts?: CallOpts$5): Promise<SandboxPreview>;
   /** `DELETE /v1/sandboxes/{id}` — destroy the sandbox and its workspace (204). */
   delete(id: string, opts?: CallOpts$5): Promise<void>;
   /**