@vercel/sandbox 2.0.0-beta.4 → 2.0.0-beta.7

package/README.md

@@ -52,7 +52,9 @@ async function main() {
     resources: { vcpus: 4 },
     ports: [3000],
     runtime: "node24",
+    name: "vercel-sandbox-example",
   });
+  console.log(`Sandbox ${sandbox.name} created`);
 
   console.log(`Installing dependencies...`);
   const install = await sandbox.runCommand({
@@ -62,7 +64,7 @@ async function main() {
     stdout: process.stdout,
   });
 
-  if (install.exitCode != 0) {
+  if (install.exitCode !== 0) {
     console.log("installing packages failed");
     process.exit(1);
   }
@@ -98,6 +100,43 @@ This will:
 
 All while streaming logs to your local terminal.
 
+Sandboxes are persistent by default. To resume a sandbox with its previous state:
+
+Create a `resume.mts` file:
+
+```ts
+import { Sandbox } from "@vercel/sandbox";
+import { setTimeout } from "timers/promises";
+import { spawn } from "child_process";
+
+async function main() {
+  const sandbox = await Sandbox.get({
+    name: "vercel-sandbox-example",
+  });
+  console.log(`Sandbox ${sandbox.name} resumed`);
+
+  console.log(`Starting the development server...`);
+  await sandbox.runCommand({
+    cmd: "npm",
+    args: ["run", "dev"],
+    stderr: process.stderr,
+    stdout: process.stdout,
+    detached: true,
+  });
+
+  await setTimeout(500);
+  spawn("open", [sandbox.domain(3000)]);
+}
+
+main().catch(console.error);
+```
+
+Run it:
+
+```sh
+node --experimental-strip-types --env-file .env.local resume.mts
+```
+
 ## Authentication
 
 ### Vercel OIDC token

package/dist/api-client/api-client.d.ts

@@ -1,5 +1,5 @@
 import { BaseClient, type Parsed, type RequestParams } from "./base-client";
-import { type CommandFinishedData, SandboxResponse, CommandResponse, CommandFinishedResponse, type LogLineStdout, type LogLineStderr, ExtendTimeoutResponse, UpdateNetworkPolicyResponse, SnapshotResponse, CreateSnapshotResponse, type CommandData } from "./validators";
+import { type CommandFinishedData, SessionResponse, CommandResponse, CommandFinishedResponse, type LogLineStdout, type LogLineStderr, SnapshotResponse, CreateSnapshotResponse, type CommandData } from "./validators";
 import { FileWriter } from "./file-writer";
 import { z } from "zod";
 import { Readable } from "stream";
@@ -21,11 +21,11 @@ export declare class APIClient extends BaseClient {
     });
     private ensureValidToken;
     protected request(path: string, params?: RequestParams): Promise<Response>;
-    getSandbox(params: WithPrivate<{
-        sandboxId: string;
+    getSession(params: WithPrivate<{
+        sessionId: string;
         signal?: AbortSignal;
     }>): Promise<Parsed<{
-        sandbox: {
+        session: {
             id: string;
             memory: number;
             vcpus: number;
@@ -73,6 +73,8 @@ export declare class APIClient extends BaseClient {
                 ingress: number;
                 egress: number;
             } | undefined;
+        } & {
+            [k: string]: unknown;
         };
         routes: {
             url: string;
@@ -106,9 +108,10 @@ export declare class APIClient extends BaseClient {
         runtime?: RUNTIMES | (string & {});
         networkPolicy?: NetworkPolicy;
         env?: Record<string, string>;
+        tags?: Record<string, string>;
         signal?: AbortSignal;
     }>): Promise<Parsed<{
-        sandbox: {
+        session: {
             id: string;
             memory: number;
             vcpus: number;
@@ -156,24 +159,27 @@ export declare class APIClient extends BaseClient {
                 ingress: number;
                 egress: number;
             } | undefined;
+        } & {
+            [k: string]: unknown;
         };
         routes: {
             url: string;
             subdomain: string;
             port: number;
         }[];
-        namedSandbox: {
-            memory: number;
-            vcpus: number;
-            region: string;
-            runtime: string;
-            timeout: number;
+        sandbox: {
             status: "aborted" | "pending" | "running" | "stopping" | "stopped" | "failed" | "snapshotting";
             createdAt: number;
             updatedAt: number;
             name: string;
             persistent: boolean;
-            currentSandboxId: string;
+            currentSessionId: string;
+            memory?: number | undefined;
+            vcpus?: number | undefined;
+            region?: string | undefined;
+            runtime?: string | undefined;
+            timeout?: number | undefined;
+            cwd?: string | undefined;
             networkPolicy?: z.objectInputType<{
                 mode: z.ZodLiteral<"allow-all">;
             }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
@@ -202,10 +208,11 @@ export declare class APIClient extends BaseClient {
             totalActiveCpuDurationMs?: number | undefined;
             totalDurationMs?: number | undefined;
             currentSnapshotId?: string | undefined;
+            tags?: Record<string, string> | undefined;
         };
     }>>;
     runCommand(params: {
-        sandboxId: string;
+        sessionId: string;
         cwd?: string;
         command: string;
         args: string[];
@@ -218,7 +225,7 @@ export declare class APIClient extends BaseClient {
         finished: Promise<CommandFinishedData>;
     }>;
     runCommand(params: {
-        sandboxId: string;
+        sessionId: string;
         cwd?: string;
         command: string;
         args: string[];
@@ -228,83 +235,91 @@ export declare class APIClient extends BaseClient {
         signal?: AbortSignal;
     }): Promise<Parsed<z.infer<typeof CommandResponse>>>;
     getCommand(params: {
-        sandboxId: string;
+        sessionId: string;
         cmdId: string;
         wait: true;
         signal?: AbortSignal;
     }): Promise<Parsed<z.infer<typeof CommandFinishedResponse>>>;
     getCommand(params: {
-        sandboxId: string;
+        sessionId: string;
         cmdId: string;
         wait?: boolean;
         signal?: AbortSignal;
     }): Promise<Parsed<z.infer<typeof CommandResponse>>>;
     mkDir(params: {
-        sandboxId: string;
+        sessionId: string;
         path: string;
         cwd?: string;
         signal?: AbortSignal;
     }): Promise<Parsed<{}>>;
     getFileWriter(params: {
-        sandboxId: string;
+        sessionId: string;
         extractDir: string;
         signal?: AbortSignal;
     }): {
         response: Promise<Response>;
         writer: FileWriter;
     };
-    listSandboxes(params: {
+    listSessions(params: {
         /**
-         * The ID or name of the project to which the sandboxes belong.
+         * The ID or name of the project to which the sessions belong.
          * @example "my-project"
          */
         projectId: string;
         /**
-         * Filter sandboxes by named sandbox name.
+         * Filter sessions by sandbox name.
          */
         name?: string;
         /**
-         * Maximum number of sandboxes to list from a request.
+         * Maximum number of sessions to list from a request.
          * @example 10
          */
         limit?: number;
         /**
-         * Get sandboxes created after this JavaScript timestamp.
+         * Get sessions created after this JavaScript timestamp.
          * @example 1540095775941
          */
         since?: number | Date;
         /**
-         * Get sandboxes created before this JavaScript timestamp.
+         * Get sessions created before this JavaScript timestamp.
          * @example 1540095775951
          */
         until?: number | Date;
         signal?: AbortSignal;
     }): Promise<Parsed<{
-        sandboxes: {
-            id: string;
-            memory: number;
-            vcpus: number;
-            region: string;
-            runtime: string;
-            timeout: number;
-            status: "aborted" | "pending" | "running" | "stopping" | "stopped" | "failed" | "snapshotting";
-            requestedAt: number;
-            createdAt: number;
-            cwd: string;
-            updatedAt: number;
-            startedAt?: number | undefined;
-            requestedStopAt?: number | undefined;
-            stoppedAt?: number | undefined;
-            abortedAt?: number | undefined;
-            duration?: number | undefined;
-            sourceSnapshotId?: string | undefined;
-            snapshottedAt?: number | undefined;
-            interactivePort?: number | undefined;
-            networkPolicy?: z.objectInputType<{
+        sessions: z.objectInputType<{
+            id: z.ZodString;
+            memory: z.ZodNumber;
+            vcpus: z.ZodNumber;
+            region: z.ZodString;
+            runtime: z.ZodString;
+            timeout: z.ZodNumber;
+            status: z.ZodEnum<["pending", "running", "stopping", "stopped", "failed", "aborted", "snapshotting"]>;
+            requestedAt: z.ZodNumber;
+            startedAt: z.ZodOptional<z.ZodNumber>;
+            requestedStopAt: z.ZodOptional<z.ZodNumber>;
+            stoppedAt: z.ZodOptional<z.ZodNumber>;
+            abortedAt: z.ZodOptional<z.ZodNumber>;
+            duration: z.ZodOptional<z.ZodNumber>;
+            sourceSnapshotId: z.ZodOptional<z.ZodString>;
+            snapshottedAt: z.ZodOptional<z.ZodNumber>;
+            createdAt: z.ZodNumber;
+            cwd: z.ZodString;
+            updatedAt: z.ZodNumber;
+            interactivePort: z.ZodOptional<z.ZodNumber>;
+            networkPolicy: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
                 mode: z.ZodLiteral<"allow-all">;
-            }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                mode: z.ZodLiteral<"allow-all">;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                mode: z.ZodLiteral<"allow-all">;
+            }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
                 mode: z.ZodLiteral<"deny-all">;
-            }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                mode: z.ZodLiteral<"deny-all">;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                mode: z.ZodLiteral<"deny-all">;
+            }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
                 mode: z.ZodLiteral<"custom">;
                 allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                 allowedCIDRs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -322,13 +337,55 @@ export declare class APIClient extends BaseClient {
                     headers?: Record<string, string> | undefined;
                     headerNames?: string[] | undefined;
                 }>, "many">>;
-            }, z.ZodTypeAny, "passthrough"> | undefined;
-            activeCpuDurationMs?: number | undefined;
-            networkTransfer?: {
+            }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                mode: z.ZodLiteral<"custom">;
+                allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                allowedCIDRs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                deniedCIDRs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                injectionRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    domain: z.ZodString;
+                    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    headerNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    domain: string;
+                    headers?: Record<string, string> | undefined;
+                    headerNames?: string[] | undefined;
+                }, {
+                    domain: string;
+                    headers?: Record<string, string> | undefined;
+                    headerNames?: string[] | undefined;
+                }>, "many">>;
+            }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                mode: z.ZodLiteral<"custom">;
+                allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                allowedCIDRs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                deniedCIDRs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                injectionRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    domain: z.ZodString;
+                    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    headerNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    domain: string;
+                    headers?: Record<string, string> | undefined;
+                    headerNames?: string[] | undefined;
+                }, {
+                    domain: string;
+                    headers?: Record<string, string> | undefined;
+                    headerNames?: string[] | undefined;
+                }>, "many">>;
+            }, z.ZodTypeAny, "passthrough">>]>>;
+            activeCpuDurationMs: z.ZodOptional<z.ZodNumber>;
+            networkTransfer: z.ZodOptional<z.ZodObject<{
+                ingress: z.ZodNumber;
+                egress: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
                 ingress: number;
                 egress: number;
-            } | undefined;
-        }[];
+            }, {
+                ingress: number;
+                egress: number;
+            }>>;
+        }, z.ZodTypeAny, "passthrough">[];
         pagination: {
             count: number;
             next: number | null;
@@ -342,7 +399,7 @@ export declare class APIClient extends BaseClient {
          */
         projectId: string;
         /**
-         * Filter snapshots by named sandbox name.
+         * Filter snapshots by sandbox name.
          */
         name?: string;
         /**
@@ -373,13 +430,13 @@ export declare class APIClient extends BaseClient {
             status: "failed" | "created" | "deleted";
             createdAt: number;
             updatedAt: number;
-            sourceSandboxId: string;
+            sourceSessionId: string;
             sizeBytes: number;
             expiresAt?: number | undefined;
         }[];
     }>>;
     writeFiles(params: {
-        sandboxId: string;
+        sessionId: string;
         cwd: string;
         files: {
             path: string;
@@ -389,19 +446,19 @@ export declare class APIClient extends BaseClient {
         signal?: AbortSignal;
     }): Promise<void>;
     readFile(params: {
-        sandboxId: string;
+        sessionId: string;
         path: string;
         cwd?: string;
         signal?: AbortSignal;
     }): Promise<Readable | null>;
     killCommand(params: {
-        sandboxId: string;
+        sessionId: string;
         commandId: string;
         signal: number;
         abortSignal?: AbortSignal;
     }): Promise<Parsed<{
         command: {
-            sandboxId: string;
+            sessionId: string;
             id: string;
             startedAt: number;
             cwd: string;
@@ -411,29 +468,29 @@ export declare class APIClient extends BaseClient {
         };
     }>>;
     getLogs(params: {
-        sandboxId: string;
+        sessionId: string;
         cmdId: string;
         signal?: AbortSignal;
     }): AsyncGenerator<z.infer<typeof LogLineStdout> | z.infer<typeof LogLineStderr>, void, void> & Disposable & {
         close(): void;
     };
-    stopSandbox(params: {
-        sandboxId: string;
+    stopSession(params: {
+        sessionId: string;
         signal?: AbortSignal;
         blocking?: boolean;
-    }): Promise<Parsed<z.infer<typeof SandboxResponse>>>;
+    }): Promise<Parsed<z.infer<typeof SessionResponse>>>;
     updateNetworkPolicy(params: {
-        sandboxId: string;
+        sessionId: string;
         networkPolicy: NetworkPolicy;
         signal?: AbortSignal;
-    }): Promise<Parsed<z.infer<typeof UpdateNetworkPolicyResponse>>>;
+    }): Promise<Parsed<z.infer<typeof SessionResponse>>>;
     extendTimeout(params: {
-        sandboxId: string;
+        sessionId: string;
         duration: number;
         signal?: AbortSignal;
-    }): Promise<Parsed<z.infer<typeof ExtendTimeoutResponse>>>;
+    }): Promise<Parsed<z.infer<typeof SessionResponse>>>;
     createSnapshot(params: {
-        sandboxId: string;
+        sessionId: string;
         expiration?: number;
         signal?: AbortSignal;
     }): Promise<Parsed<z.infer<typeof CreateSnapshotResponse>>>;
@@ -445,13 +502,13 @@ export declare class APIClient extends BaseClient {
         snapshotId: string;
         signal?: AbortSignal;
     }): Promise<Parsed<z.infer<typeof SnapshotResponse>>>;
-    getNamedSandbox(params: {
+    getSandbox(params: WithPrivate<{
         name: string;
         projectId: string;
         resume?: boolean;
         signal?: AbortSignal;
-    }): Promise<Parsed<{
-        sandbox: {
+    }>): Promise<Parsed<{
+        session: {
             id: string;
             memory: number;
             vcpus: number;
@@ -499,24 +556,27 @@ export declare class APIClient extends BaseClient {
                 ingress: number;
                 egress: number;
             } | undefined;
+        } & {
+            [k: string]: unknown;
         };
         routes: {
             url: string;
             subdomain: string;
             port: number;
         }[];
-        namedSandbox: {
-            memory: number;
-            vcpus: number;
-            region: string;
-            runtime: string;
-            timeout: number;
+        sandbox: {
             status: "aborted" | "pending" | "running" | "stopping" | "stopped" | "failed" | "snapshotting";
             createdAt: number;
             updatedAt: number;
             name: string;
             persistent: boolean;
-            currentSandboxId: string;
+            currentSessionId: string;
+            memory?: number | undefined;
+            vcpus?: number | undefined;
+            region?: string | undefined;
+            runtime?: string | undefined;
+            timeout?: number | undefined;
+            cwd?: string | undefined;
             networkPolicy?: z.objectInputType<{
                 mode: z.ZodLiteral<"allow-all">;
             }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
@@ -545,68 +605,68 @@ export declare class APIClient extends BaseClient {
             totalActiveCpuDurationMs?: number | undefined;
             totalDurationMs?: number | undefined;
             currentSnapshotId?: string | undefined;
+            tags?: Record<string, string> | undefined;
         };
     }>>;
-    listNamedSandboxes(params: {
+    listSandboxes(params: {
         projectId: string;
         limit?: number;
         sortBy?: "createdAt" | "name";
         namePrefix?: string;
         cursor?: string;
+        tags?: Record<string, string>;
         signal?: AbortSignal;
-    }): Promise<{
-        json: {
-            sandboxes: {
-                memory: number;
-                vcpus: number;
-                region: string;
-                runtime: string;
-                timeout: number;
-                status: "aborted" | "pending" | "running" | "stopping" | "stopped" | "failed" | "snapshotting";
-                createdAt: number;
-                updatedAt: number;
-                name: string;
-                persistent: boolean;
-                currentSandboxId: string;
-                networkPolicy?: z.objectInputType<{
-                    mode: z.ZodLiteral<"allow-all">;
-                }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
-                    mode: z.ZodLiteral<"deny-all">;
-                }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
-                    mode: z.ZodLiteral<"custom">;
-                    allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-                    allowedCIDRs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-                    deniedCIDRs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-                    injectionRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                        domain: z.ZodString;
-                        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-                        headerNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-                    }, "strip", z.ZodTypeAny, {
-                        domain: string;
-                        headers?: Record<string, string> | undefined;
-                        headerNames?: string[] | undefined;
-                    }, {
-                        domain: string;
-                        headers?: Record<string, string> | undefined;
-                        headerNames?: string[] | undefined;
-                    }>, "many">>;
-                }, z.ZodTypeAny, "passthrough"> | undefined;
-                totalEgressBytes?: number | undefined;
-                totalIngressBytes?: number | undefined;
-                totalActiveCpuDurationMs?: number | undefined;
-                totalDurationMs?: number | undefined;
-                currentSnapshotId?: string | undefined;
-            }[];
-            pagination: {
-                count: number;
-                next: string | null;
-                total: number;
-            };
+    }): Promise<Parsed<{
+        pagination: {
+            count: number;
+            next: string | null;
+            total: number;
         };
-        response: Response;
-        text: string;
-    }>;
-    updateNamedSandbox(params: {
+        sandboxes: {
+            status: "aborted" | "pending" | "running" | "stopping" | "stopped" | "failed" | "snapshotting";
+            createdAt: number;
+            updatedAt: number;
+            name: string;
+            persistent: boolean;
+            currentSessionId: string;
+            memory?: number | undefined;
+            vcpus?: number | undefined;
+            region?: string | undefined;
+            runtime?: string | undefined;
+            timeout?: number | undefined;
+            cwd?: string | undefined;
+            networkPolicy?: z.objectInputType<{
+                mode: z.ZodLiteral<"allow-all">;
+            }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+                mode: z.ZodLiteral<"deny-all">;
+            }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
+                mode: z.ZodLiteral<"custom">;
+                allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                allowedCIDRs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                deniedCIDRs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                injectionRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    domain: z.ZodString;
+                    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+                    headerNames: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    domain: string;
+                    headers?: Record<string, string> | undefined;
+                    headerNames?: string[] | undefined;
+                }, {
+                    domain: string;
+                    headers?: Record<string, string> | undefined;
+                    headerNames?: string[] | undefined;
+                }>, "many">>;
+            }, z.ZodTypeAny, "passthrough"> | undefined;
+            totalEgressBytes?: number | undefined;
+            totalIngressBytes?: number | undefined;
+            totalActiveCpuDurationMs?: number | undefined;
+            totalDurationMs?: number | undefined;
+            currentSnapshotId?: string | undefined;
+            tags?: Record<string, string> | undefined;
+        }[];
+    }>>;
+    updateSandbox(params: {
         name: string;
         projectId: string;
         persistent?: boolean;
@@ -617,20 +677,22 @@ export declare class APIClient extends BaseClient {
         runtime?: RUNTIMES | (string & {});
         timeout?: number;
         networkPolicy?: NetworkPolicy;
+        tags?: Record<string, string>;
         signal?: AbortSignal;
     }): Promise<Parsed<{
-        namedSandbox: {
-            memory: number;
-            vcpus: number;
-            region: string;
-            runtime: string;
-            timeout: number;
+        sandbox: {
             status: "aborted" | "pending" | "running" | "stopping" | "stopped" | "failed" | "snapshotting";
             createdAt: number;
             updatedAt: number;
             name: string;
             persistent: boolean;
-            currentSandboxId: string;
+            currentSessionId: string;
+            memory?: number | undefined;
+            vcpus?: number | undefined;
+            region?: string | undefined;
+            runtime?: string | undefined;
+            timeout?: number | undefined;
+            cwd?: string | undefined;
             networkPolicy?: z.objectInputType<{
                 mode: z.ZodLiteral<"allow-all">;
             }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
@@ -659,26 +721,27 @@ export declare class APIClient extends BaseClient {
             totalActiveCpuDurationMs?: number | undefined;
             totalDurationMs?: number | undefined;
             currentSnapshotId?: string | undefined;
+            tags?: Record<string, string> | undefined;
         };
     }>>;
-    deleteNamedSandbox(params: {
+    deleteSandbox(params: {
         name: string;
         projectId: string;
-        preserveSnapshots?: boolean;
         signal?: AbortSignal;
     }): Promise<Parsed<{
-        namedSandbox: {
-            memory: number;
-            vcpus: number;
-            region: string;
-            runtime: string;
-            timeout: number;
+        sandbox: {
             status: "aborted" | "pending" | "running" | "stopping" | "stopped" | "failed" | "snapshotting";
             createdAt: number;
             updatedAt: number;
             name: string;
             persistent: boolean;
-            currentSandboxId: string;
+            currentSessionId: string;
+            memory?: number | undefined;
+            vcpus?: number | undefined;
+            region?: string | undefined;
+            runtime?: string | undefined;
+            timeout?: number | undefined;
+            cwd?: string | undefined;
             networkPolicy?: z.objectInputType<{
                 mode: z.ZodLiteral<"allow-all">;
             }, z.ZodTypeAny, "passthrough"> | z.objectInputType<{
@@ -707,6 +770,7 @@ export declare class APIClient extends BaseClient {
             totalActiveCpuDurationMs?: number | undefined;
             totalDurationMs?: number | undefined;
             currentSnapshotId?: string | undefined;
+            tags?: Record<string, string> | undefined;
         };
     }>>;
 }