@tensorlakeai/tensorlake 0.5.157 → 0.5.159

package/dist/index.d.cts

@@ -67,6 +67,8 @@ interface NativeSandboxProxyClient {
 }
 interface NativeSandboxClient {
     createSandbox(requestJson: string): Promise<TracedJson>;
+    /** Blocking create for createAndConnect: a `running`, `failed` or `timeout` record. */
+    createSandboxAndWait(requestJson: string): Promise<TracedJson>;
     /** Wait-free create (`wait: false`, ADR 0086). */
     createSandboxNoWait(requestJson: string): Promise<TracedJson>;
     /** Poll the sandbox until it leaves `pending` or the budget runs out; resolves with the last `SandboxInfo`. */
@@ -84,6 +86,8 @@ interface NativeSandboxClient {
     deleteSandbox(sandboxId: string): Promise<string>;
     suspendSandbox(sandboxId: string): Promise<string>;
     resumeSandbox(sandboxId: string): Promise<string>;
+    suspendSandboxAndWait(sandboxId: string, waitSec: number): Promise<boolean>;
+    resumeSandboxAndWait(sandboxId: string, waitSec: number): Promise<boolean>;
     attachFileSystem(sandboxId: string, fileSystemId: string, mountPath: string, readOnly?: boolean | null, prefetch?: boolean | null, snapshotId?: string | null, owner?: string | null): Promise<TracedJson>;
     detachFileSystem(sandboxId: string, mountPath: string): Promise<TracedJson>;
     createSnapshot(sandboxId: string, snapshotType?: string | null): Promise<TracedJson>;
@@ -306,6 +310,8 @@ interface ClaimSandboxOptions {
     fileSystems?: FileSystemMount[];
 }
 interface CreateSandboxOptions {
+    /** Allow proxy traffic to wake a suspended sandbox (default true). False requires a named sandbox. */
+    autoResume?: boolean;
     /** Optional sandbox image name. GPU sandboxes require a CAS image; when omitted with a GPU request, Tensorlake uses the server's configured GPU default. */
     image?: string;
     /** CPU count. Defaults to 1 for fresh creates; snapshot restores inherit it when omitted. */
@@ -326,6 +332,10 @@ interface CreateSandboxOptions {
     allowOut?: string[];
     denyOut?: string[];
     snapshotId?: string;
+    /** Whether exposed user ports are reachable without Tensorlake auth. Defaults to false for fresh creates; snapshot restores inherit it when omitted. */
+    allowUnauthenticatedAccess?: boolean;
+    /** User ports routable through the sandbox proxy. Port 9501 is reserved. Snapshot restores inherit ports when omitted; [] clears them. Does not enable unauthenticated access. */
+    exposedPorts?: number[];
     /** Optional name for the sandbox. Named sandboxes support suspend/resume. When absent the sandbox is ephemeral. */
     name?: string;
     /** File systems to mount on fresh creation or warm-pool claim, each at its own absolute, unique guest mount path. */
@@ -375,6 +385,8 @@ interface SandboxResourceResizeInfo {
 }
 /** Wait options apply only to resource updates and are ignored for other properties. */
 interface UpdateSandboxOptions extends ResourceResizeWaitOptions {
+    /** Change wake-on-traffic policy without waking or suspending the sandbox. Omit to keep it unchanged; false requires a named sandbox. Cannot be combined with resource resizing. */
+    autoResume?: boolean;
     /** Whole live vCPU target; omitted retains the current allocation. */
     cpus?: number;
     /** Memory target in MiB, with the same units as create; never rounded by the SDK. */
@@ -470,6 +482,8 @@ interface CopySandboxResponse {
     sandboxes: CopiedSandboxResponse[];
 }
 interface SandboxInfo {
+    /** Whether proxy traffic may wake this sandbox; defaults to true on older servers. */
+    autoResume: boolean;
     /**
      * The runtime the server chose for this sandbox: `firecracker`,
      * `cloud-hypervisor` or `gvisor`. Informational only; it is never sent and
@@ -897,7 +911,10 @@ interface CreateAndConnectOptions extends CreateSandboxOptions {
      * false: throw `SandboxPending` and leave the sandbox queued.
      */
     cancelOnTimeout?: boolean;
-    /** Seconds between readiness polls. Default: 2. */
+    /**
+     * Seconds between readiness polls once the server's own wait has run out.
+     * Default: 2.
+     */
     pollInterval?: number;
 }
 /**
@@ -1115,8 +1132,8 @@ declare class Sandbox {
      *
      * Covers both fresh sandbox creation and restore-from-snapshot (set
      * `snapshotId`). With `wait` unset or `true` it blocks until the sandbox
-     * is `Running`: the create is sent with `wait: false` and the sandbox is
-     * polled every two seconds, with `requestTimeout` as the wait budget.
+     * is `Running`: the server waits and answers as soon as it runs, with
+     * `requestTimeout` as the wait budget.
      *
      * With `wait: false` it returns a {@link PendingSandbox} at once:
      * `pending.ready()` waits for it, `pending.status()` looks at it, and
@@ -1576,6 +1593,10 @@ declare class SandboxClient {
      * cannot. By default blocks until the sandbox is fully `Suspended`. Pass
      * `{ wait: false }` to return immediately after the request is sent
      * (fire-and-return); the server processes the suspend asynchronously.
+     *
+     * The server answers as soon as the suspend completes. When its wait runs
+     * out first, or the server does not support waiting, the rest of `timeout`
+     * is spent polling every `pollInterval` seconds.
      */
     suspend(sandboxId: string, options?: SuspendResumeOptions): Promise<void>;
     /**
@@ -1584,8 +1605,18 @@ declare class SandboxClient {
      * By default blocks until the sandbox is `Running` and routable. Pass
      * `{ wait: false }` to return immediately after the request is sent
      * (fire-and-return); the server processes the resume asynchronously.
+     *
+     * The server answers as soon as the sandbox runs. When its wait runs out
+     * first, or the server does not support waiting, the rest of `timeout` is
+     * spent polling every `pollInterval` seconds.
      */
     resume(sandboxId: string, options?: SuspendResumeOptions): Promise<void>;
+    /**
+     * Send a suspend or resume. With `wait`, the server waits for `target` and
+     * answers whether it was reached; when its wait runs out first, the rest of
+     * the timeout is spent polling.
+     */
+    private changeLifecycle;
     /**
      * Attach a registered file system to a running sandbox at `mountPath`.
      *
@@ -1669,10 +1700,9 @@ declare class SandboxClient {
     /**
      * Create a sandbox, wait for it to reach `Running`, and return a connected handle.
      *
-     * This is `create({ wait: false })` followed by `PendingSandbox.ready()`
-     * polling every `pollInterval` seconds, with `requestTimeout` as the wait
-     * budget, in one call. The returned `Sandbox` auto-terminates when
-     * `terminate()` is called.
+     * The create waits on the server, which answers as soon as the sandbox
+     * runs, with `requestTimeout` as the wait budget. The returned `Sandbox`
+     * auto-terminates when `terminate()` is called.
      *
      * **When the wait runs out the sandbox is not deleted.** A `SandboxPending`
      * is thrown with the sandbox id, and the sandbox keeps its place in the
@@ -2794,6 +2824,8 @@ declare class RemoteAPIError extends SandboxError {
     readonly statusCode: number;
     /** Original response body, retained for compatibility and diagnostics. */
     readonly responseMessage: string;
+    /** Machine-readable API error code, including proxy policy failures. */
+    readonly code?: string;
     readonly sandboxId?: string;
     /** Server reason, including unknown future reasons. */
     readonly reason?: string;

package/dist/index.d.ts

@@ -67,6 +67,8 @@ interface NativeSandboxProxyClient {
 }
 interface NativeSandboxClient {
     createSandbox(requestJson: string): Promise<TracedJson>;
+    /** Blocking create for createAndConnect: a `running`, `failed` or `timeout` record. */
+    createSandboxAndWait(requestJson: string): Promise<TracedJson>;
     /** Wait-free create (`wait: false`, ADR 0086). */
     createSandboxNoWait(requestJson: string): Promise<TracedJson>;
     /** Poll the sandbox until it leaves `pending` or the budget runs out; resolves with the last `SandboxInfo`. */
@@ -84,6 +86,8 @@ interface NativeSandboxClient {
     deleteSandbox(sandboxId: string): Promise<string>;
     suspendSandbox(sandboxId: string): Promise<string>;
     resumeSandbox(sandboxId: string): Promise<string>;
+    suspendSandboxAndWait(sandboxId: string, waitSec: number): Promise<boolean>;
+    resumeSandboxAndWait(sandboxId: string, waitSec: number): Promise<boolean>;
     attachFileSystem(sandboxId: string, fileSystemId: string, mountPath: string, readOnly?: boolean | null, prefetch?: boolean | null, snapshotId?: string | null, owner?: string | null): Promise<TracedJson>;
     detachFileSystem(sandboxId: string, mountPath: string): Promise<TracedJson>;
     createSnapshot(sandboxId: string, snapshotType?: string | null): Promise<TracedJson>;
@@ -306,6 +310,8 @@ interface ClaimSandboxOptions {
     fileSystems?: FileSystemMount[];
 }
 interface CreateSandboxOptions {
+    /** Allow proxy traffic to wake a suspended sandbox (default true). False requires a named sandbox. */
+    autoResume?: boolean;
     /** Optional sandbox image name. GPU sandboxes require a CAS image; when omitted with a GPU request, Tensorlake uses the server's configured GPU default. */
     image?: string;
     /** CPU count. Defaults to 1 for fresh creates; snapshot restores inherit it when omitted. */
@@ -326,6 +332,10 @@ interface CreateSandboxOptions {
     allowOut?: string[];
     denyOut?: string[];
     snapshotId?: string;
+    /** Whether exposed user ports are reachable without Tensorlake auth. Defaults to false for fresh creates; snapshot restores inherit it when omitted. */
+    allowUnauthenticatedAccess?: boolean;
+    /** User ports routable through the sandbox proxy. Port 9501 is reserved. Snapshot restores inherit ports when omitted; [] clears them. Does not enable unauthenticated access. */
+    exposedPorts?: number[];
     /** Optional name for the sandbox. Named sandboxes support suspend/resume. When absent the sandbox is ephemeral. */
     name?: string;
     /** File systems to mount on fresh creation or warm-pool claim, each at its own absolute, unique guest mount path. */
@@ -375,6 +385,8 @@ interface SandboxResourceResizeInfo {
 }
 /** Wait options apply only to resource updates and are ignored for other properties. */
 interface UpdateSandboxOptions extends ResourceResizeWaitOptions {
+    /** Change wake-on-traffic policy without waking or suspending the sandbox. Omit to keep it unchanged; false requires a named sandbox. Cannot be combined with resource resizing. */
+    autoResume?: boolean;
     /** Whole live vCPU target; omitted retains the current allocation. */
     cpus?: number;
     /** Memory target in MiB, with the same units as create; never rounded by the SDK. */
@@ -470,6 +482,8 @@ interface CopySandboxResponse {
     sandboxes: CopiedSandboxResponse[];
 }
 interface SandboxInfo {
+    /** Whether proxy traffic may wake this sandbox; defaults to true on older servers. */
+    autoResume: boolean;
     /**
      * The runtime the server chose for this sandbox: `firecracker`,
      * `cloud-hypervisor` or `gvisor`. Informational only; it is never sent and
@@ -897,7 +911,10 @@ interface CreateAndConnectOptions extends CreateSandboxOptions {
      * false: throw `SandboxPending` and leave the sandbox queued.
      */
     cancelOnTimeout?: boolean;
-    /** Seconds between readiness polls. Default: 2. */
+    /**
+     * Seconds between readiness polls once the server's own wait has run out.
+     * Default: 2.
+     */
     pollInterval?: number;
 }
 /**
@@ -1115,8 +1132,8 @@ declare class Sandbox {
      *
      * Covers both fresh sandbox creation and restore-from-snapshot (set
      * `snapshotId`). With `wait` unset or `true` it blocks until the sandbox
-     * is `Running`: the create is sent with `wait: false` and the sandbox is
-     * polled every two seconds, with `requestTimeout` as the wait budget.
+     * is `Running`: the server waits and answers as soon as it runs, with
+     * `requestTimeout` as the wait budget.
      *
      * With `wait: false` it returns a {@link PendingSandbox} at once:
      * `pending.ready()` waits for it, `pending.status()` looks at it, and
@@ -1576,6 +1593,10 @@ declare class SandboxClient {
      * cannot. By default blocks until the sandbox is fully `Suspended`. Pass
      * `{ wait: false }` to return immediately after the request is sent
      * (fire-and-return); the server processes the suspend asynchronously.
+     *
+     * The server answers as soon as the suspend completes. When its wait runs
+     * out first, or the server does not support waiting, the rest of `timeout`
+     * is spent polling every `pollInterval` seconds.
      */
     suspend(sandboxId: string, options?: SuspendResumeOptions): Promise<void>;
     /**
@@ -1584,8 +1605,18 @@ declare class SandboxClient {
      * By default blocks until the sandbox is `Running` and routable. Pass
      * `{ wait: false }` to return immediately after the request is sent
      * (fire-and-return); the server processes the resume asynchronously.
+     *
+     * The server answers as soon as the sandbox runs. When its wait runs out
+     * first, or the server does not support waiting, the rest of `timeout` is
+     * spent polling every `pollInterval` seconds.
      */
     resume(sandboxId: string, options?: SuspendResumeOptions): Promise<void>;
+    /**
+     * Send a suspend or resume. With `wait`, the server waits for `target` and
+     * answers whether it was reached; when its wait runs out first, the rest of
+     * the timeout is spent polling.
+     */
+    private changeLifecycle;
     /**
      * Attach a registered file system to a running sandbox at `mountPath`.
      *
@@ -1669,10 +1700,9 @@ declare class SandboxClient {
     /**
      * Create a sandbox, wait for it to reach `Running`, and return a connected handle.
      *
-     * This is `create({ wait: false })` followed by `PendingSandbox.ready()`
-     * polling every `pollInterval` seconds, with `requestTimeout` as the wait
-     * budget, in one call. The returned `Sandbox` auto-terminates when
-     * `terminate()` is called.
+     * The create waits on the server, which answers as soon as the sandbox
+     * runs, with `requestTimeout` as the wait budget. The returned `Sandbox`
+     * auto-terminates when `terminate()` is called.
      *
      * **When the wait runs out the sandbox is not deleted.** A `SandboxPending`
      * is thrown with the sandbox id, and the sandbox keeps its place in the
@@ -2794,6 +2824,8 @@ declare class RemoteAPIError extends SandboxError {
     readonly statusCode: number;
     /** Original response body, retained for compatibility and diagnostics. */
     readonly responseMessage: string;
+    /** Machine-readable API error code, including proxy policy failures. */
+    readonly code?: string;
     readonly sandboxId?: string;
     /** Server reason, including unknown future reasons. */
     readonly reason?: string;

package/dist/index.js

@@ -46,7 +46,7 @@ var init_defaults = __esm({
   "src/defaults.ts"() {
     "use strict";
     init_esm_shims();
-    SDK_VERSION = "0.5.157";
+    SDK_VERSION = "0.5.159";
     API_URL = process.env.TENSORLAKE_API_URL ?? "https://api.tensorlake.ai";
     API_KEY = process.env.TENSORLAKE_API_KEY ?? void 0;
     NAMESPACE = process.env.INDEXIFY_NAMESPACE ?? "default";
@@ -181,13 +181,17 @@ var init_errors = __esm({
       statusCode;
       /** Original response body, retained for compatibility and diagnostics. */
       responseMessage;
+      /** Machine-readable API error code, including proxy policy failures. */
+      code;
       errorDetails;
       constructor(statusCode, message) {
         let failure;
+        let code;
         try {
           const payload = JSON.parse(message);
           if (payload && typeof payload === "object" && !Array.isArray(payload)) {
             const record = payload;
+            if (typeof record.code === "string") code = record.code;
             if (typeof record.sandbox_id === "string" && record.sandbox_id.trim() && (record.status === "failed" || record.status === "terminated"))
               failure = record;
           }
@@ -213,6 +217,7 @@ var init_errors = __esm({
         this.name = "RemoteAPIError";
         this.statusCode = statusCode;
         this.responseMessage = message;
+        this.code = code;
       }
     };
     RequestNotFinishedError = class extends Error {
@@ -509,7 +514,7 @@ var init_native_worker_client = __esm({
       }
     };
     runtimeKey = /* @__PURE__ */ Symbol.for(
-      `tensorlake.native.worker.${false ? "source" : "0.5.157"}.v1`
+      `tensorlake.native.worker.${false ? "source" : "0.5.159"}.v1`
     );
     runtimes = globalThis;
   }
@@ -4930,6 +4935,12 @@ var init_client = __esm({
         if (options?.timeoutSecs != null) body.timeout_secs = options.timeoutSecs;
         if (options?.entrypoint != null) body.entrypoint = options.entrypoint;
         if (options?.snapshotId != null) body.snapshot_id = options.snapshotId;
+        if (options?.allowUnauthenticatedAccess != null) {
+          body.allow_unauthenticated_access = options.allowUnauthenticatedAccess;
+        }
+        if (options?.exposedPorts != null) {
+          body.exposed_ports = normalizeUserPorts(options.exposedPorts);
+        }
         if (options?.name != null) body.name = options.name;
         if (options?.fileSystems != null && options.fileSystems.length > 0) {
           body.file_systems = options.fileSystems.map(fileSystemMountToWire);
@@ -4941,6 +4952,7 @@ var init_client = __esm({
             deny_out: options?.denyOut ?? []
           };
         }
+        if (options?.autoResume != null) body.auto_resume = options.autoResume;
         if (options?.maxPendingSecs != null) {
           if (!Number.isInteger(options.maxPendingSecs) || options.maxPendingSecs < 0) {
             throw new SandboxError("maxPendingSecs must be a non-negative integer");
@@ -5057,13 +5069,14 @@ var init_client = __esm({
         const resizing = Object.keys(resources).length > 0;
         if (resizing) {
           validateResizeWait(options);
-          if (options.name != null || options.allowUnauthenticatedAccess != null || options.exposedPorts != null || options.network !== void 0) {
+          if (options.name != null || options.allowUnauthenticatedAccess != null || options.exposedPorts != null || options.autoResume != null || options.network !== void 0) {
             throw new SandboxError(
               "resources cannot be combined with other sandbox update fields"
             );
           }
           body.resources = resources;
         }
+        if (options.autoResume != null) body.auto_resume = options.autoResume;
         if (options.name != null) body.name = options.name;
         if (options.allowUnauthenticatedAccess != null) {
           body.allow_unauthenticated_access = options.allowUnauthenticatedAccess;
@@ -5158,28 +5171,19 @@ var init_client = __esm({
        * cannot. By default blocks until the sandbox is fully `Suspended`. Pass
        * `{ wait: false }` to return immediately after the request is sent
        * (fire-and-return); the server processes the suspend asynchronously.
+       *
+       * The server answers as soon as the suspend completes. When its wait runs
+       * out first, or the server does not support waiting, the rest of `timeout`
+       * is spent polling every `pollInterval` seconds.
        */
       async suspend(sandboxId, options) {
-        await callNative(() => this.native.suspendSandbox(sandboxId), {
+        await this.changeLifecycle(
           sandboxId,
-          notFoundKind: "sandbox"
-        });
-        if (options?.wait === false) return;
-        const timeout = options?.timeout ?? 300;
-        const pollInterval = options?.pollInterval ?? 1;
-        const deadline = Date.now() + timeout * 1e3;
-        while (Date.now() < deadline) {
-          const info = await this.get(sandboxId);
-          if (info.status === "suspended" /* SUSPENDED */) return;
-          if (info.status === "terminated" /* TERMINATED */) {
-            throw new SandboxError(
-              `Sandbox ${sandboxId} terminated while waiting for suspend`
-            );
-          }
-          await sleep2(pollInterval * 1e3);
-        }
-        throw new SandboxError(
-          `Sandbox ${sandboxId} did not suspend within ${timeout}s`
+          "suspend",
+          "suspended" /* SUSPENDED */,
+          () => this.native.suspendSandbox(sandboxId),
+          (waitSec) => this.native.suspendSandboxAndWait(sandboxId, waitSec),
+          options
         );
       }
       /**
@@ -5188,28 +5192,58 @@ var init_client = __esm({
        * By default blocks until the sandbox is `Running` and routable. Pass
        * `{ wait: false }` to return immediately after the request is sent
        * (fire-and-return); the server processes the resume asynchronously.
+       *
+       * The server answers as soon as the sandbox runs. When its wait runs out
+       * first, or the server does not support waiting, the rest of `timeout` is
+       * spent polling every `pollInterval` seconds.
        */
       async resume(sandboxId, options) {
-        await callNative(() => this.native.resumeSandbox(sandboxId), {
+        await this.changeLifecycle(
           sandboxId,
-          notFoundKind: "sandbox"
-        });
-        if (options?.wait === false) return;
+          "resume",
+          "running" /* RUNNING */,
+          () => this.native.resumeSandbox(sandboxId),
+          (waitSec) => this.native.resumeSandboxAndWait(sandboxId, waitSec),
+          options
+        );
+      }
+      /**
+       * Send a suspend or resume. With `wait`, the server waits for `target` and
+       * answers whether it was reached; when its wait runs out first, the rest of
+       * the timeout is spent polling.
+       */
+      async changeLifecycle(sandboxId, action, target, send, sendAndWait, options) {
+        const context = { sandboxId, notFoundKind: "sandbox" };
+        if (options?.wait === false) {
+          await callNative(send, context);
+          return;
+        }
         const timeout = options?.timeout ?? 300;
         const pollInterval = options?.pollInterval ?? 1;
         const deadline = Date.now() + timeout * 1e3;
+        let settled;
+        try {
+          settled = await callNative(() => sendAndWait(timeout), context);
+        } catch (error) {
+          if (!(error instanceof RemoteAPIError) || error.statusCode !== 409) {
+            throw error;
+          }
+          if ((await this.get(sandboxId)).status === target) return;
+          throw error;
+        }
+        if (settled) return;
         while (Date.now() < deadline) {
           const info = await this.get(sandboxId);
-          if (info.status === "running" /* RUNNING */) return;
+          if (info.status === target) return;
           if (info.status === "terminated" /* TERMINATED */) {
             throw new SandboxError(
-              `Sandbox ${sandboxId} terminated while waiting for resume`
+              `Sandbox ${sandboxId} terminated while waiting for ${action}`
             );
           }
           await sleep2(pollInterval * 1e3);
         }
         throw new SandboxError(
-          `Sandbox ${sandboxId} did not resume within ${timeout}s`
+          `Sandbox ${sandboxId} did not ${action} within ${timeout}s`
         );
       }
       /**
@@ -5472,10 +5506,9 @@ var init_client = __esm({
       /**
        * Create a sandbox, wait for it to reach `Running`, and return a connected handle.
        *
-       * This is `create({ wait: false })` followed by `PendingSandbox.ready()`
-       * polling every `pollInterval` seconds, with `requestTimeout` as the wait
-       * budget, in one call. The returned `Sandbox` auto-terminates when
-       * `terminate()` is called.
+       * The create waits on the server, which answers as soon as the sandbox
+       * runs, with `requestTimeout` as the wait budget. The returned `Sandbox`
+       * auto-terminates when `terminate()` is called.
        *
        * **When the wait runs out the sandbox is not deleted.** A `SandboxPending`
        * is thrown with the sandbox id, and the sandbox keeps its place in the
@@ -5487,6 +5520,11 @@ var init_client = __esm({
        * claim that is still starting is then waited on the same way.
        */
       async createAndConnect(options) {
+        if (options?.poolId != null && (options.allowUnauthenticatedAccess != null || options.exposedPorts != null)) {
+          throw new SandboxError(
+            "allowUnauthenticatedAccess and exposedPorts cannot be combined with poolId: pool claims inherit access settings from the pool."
+          );
+        }
         const opStart = nowMs();
         const requestTimeout = options?.requestTimeout ?? options?.startupTimeout ?? this.requestTimeoutMs / 1e3;
         const requestClient = this.withRequestTimeout(requestTimeout);
@@ -5497,11 +5535,13 @@ var init_client = __esm({
           pool_id: options?.poolId
         });
         const requestedName = options?.poolId != null ? null : options?.name ?? null;
-        let sandboxId;
-        let traceId;
         const createStart = nowMs();
+        let result;
+        if (options?.poolId != null && options.autoResume != null) {
+          throw new SandboxError("autoResume cannot be set when claiming from a pool");
+        }
         if (options?.poolId != null) {
-          const result = await requestClient.claim(options.poolId, {
+          result = await requestClient.claim(options.poolId, {
             fileSystems: options.fileSystems
           });
           logSdkTiming("sandbox.create", "claim_response", createStart, {
@@ -5509,84 +5549,55 @@ var init_client = __esm({
             status: result.status,
             server_trace_id: result.traceId
           });
-          if (result.status === "running" /* RUNNING */) {
-            const explicitProxyUrl = options?.proxyUrl ?? explicitProxyUrlOverride() ?? void 0;
-            const selectedProxyUrl = await this.native.selectSandboxProxyUrl(
-              result.sandboxId,
-              result.sandboxUrl ?? null,
-              result.ingressEndpoint ?? null,
-              explicitProxyUrl ?? null
-            );
-            const sandbox2 = requestClient.connect(
-              result.sandboxId,
-              selectedProxyUrl,
-              result.routingHint,
-              requestTimeout,
-              explicitProxyUrl
-            );
-            sandbox2._setOwner(requestClient);
-            sandbox2.traceId = result.traceId;
-            sandbox2._setLifecycleIdentifier(result.sandboxId);
-            sandbox2._setName(result.name ?? requestedName);
-            logSdkTiming("sandbox.create", "complete", opStart, {
-              sandbox_id: result.sandboxId,
-              status: "running" /* RUNNING */,
-              server_trace_id: result.traceId
-            });
-            return sandbox2;
-          }
-          if (result.status === "suspended" /* SUSPENDED */ || result.status === "terminated" /* TERMINATED */ || result.status === "failed" /* FAILED */) {
-            throw startupFailure(result.sandboxId, result.status, {
-              errorDetails: result.errorDetails,
-              terminationReason: result.terminationReason ?? result.reason
-            });
-          }
-          sandboxId = result.sandboxId;
-          traceId = result.traceId;
         } else {
-          const pending = await requestClient.requestPending(options, {
-            ownsSandbox: true
+          const body = _SandboxClient.buildCreateRequestBody({
+            ...options,
+            wait: void 0
           });
+          result = await requestClient.tracedJson(
+            () => requestClient.native.createSandboxAndWait(JSON.stringify(body)),
+            "sandboxId"
+          );
           logSdkTiming("sandbox.create", "create_response", createStart, {
-            sandbox_id: pending.sandboxId,
-            status: pending.state,
-            server_trace_id: pending.traceId
+            sandbox_id: result.sandboxId,
+            status: result.status,
+            server_trace_id: result.traceId
+          });
+        }
+        if (result.status === "running" /* RUNNING */) {
+          const explicitProxyUrl = options?.proxyUrl ?? explicitProxyUrlOverride() ?? void 0;
+          const selectedProxyUrl = await this.native.selectSandboxProxyUrl(
+            result.sandboxId,
+            result.sandboxUrl ?? null,
+            result.ingressEndpoint ?? null,
+            explicitProxyUrl ?? null
+          );
+          const sandbox2 = requestClient.connect(
+            result.sandboxId,
+            selectedProxyUrl,
+            result.routingHint,
+            requestTimeout,
+            explicitProxyUrl
+          );
+          sandbox2._setOwner(requestClient);
+          sandbox2.traceId = result.traceId;
+          sandbox2._setLifecycleIdentifier(result.sandboxId);
+          sandbox2._setName(result.name ?? requestedName);
+          logSdkTiming("sandbox.create", "complete", opStart, {
+            sandbox_id: result.sandboxId,
+            status: "running" /* RUNNING */,
+            server_trace_id: result.traceId
+          });
+          return sandbox2;
+        }
+        if (result.status === "suspended" /* SUSPENDED */ || result.status === "terminated" /* TERMINATED */ || result.status === "failed" /* FAILED */) {
+          throw startupFailure(result.sandboxId, result.status, {
+            errorDetails: result.errorDetails,
+            terminationReason: result.terminationReason ?? result.reason
           });
-          sandboxId = pending.sandboxId;
-          traceId = pending.traceId;
-          if (pending.state === "running" /* RUNNING */) {
-            const explicitProxyUrl = options?.proxyUrl ?? explicitProxyUrlOverride() ?? void 0;
-            const selectedProxyUrl = await this.native.selectSandboxProxyUrl(
-              sandboxId,
-              pending.sandboxUrl ?? null,
-              pending.ingressEndpoint ?? null,
-              explicitProxyUrl ?? null
-            );
-            const sandbox2 = requestClient.connect(
-              sandboxId,
-              selectedProxyUrl,
-              pending.routingHint,
-              requestTimeout,
-              explicitProxyUrl
-            );
-            sandbox2._setOwner(requestClient);
-            sandbox2.traceId = traceId;
-            sandbox2._setLifecycleIdentifier(sandboxId);
-            sandbox2._setName(pending.name ?? requestedName);
-            logSdkTiming("sandbox.create", "complete", opStart, {
-              sandbox_id: sandboxId,
-              status: "running" /* RUNNING */,
-              server_trace_id: traceId
-            });
-            return sandbox2;
-          }
-          if (pending.state === "terminated" /* TERMINATED */ || pending.state === "failed" /* FAILED */) {
-            throw startupFailure(sandboxId, pending.state, {
-              errorDetails: pending.errorDetails,
-              terminationReason: pending.terminationReason ?? pending.reason
-            });
-          }
         }
+        const sandboxId = result.sandboxId;
+        const traceId = result.traceId;
         const remaining = Math.max(0, (deadline - Date.now()) / 1e3);
         const observed = await requestClient.waitForSandbox(
           sandboxId,