tensorlake 0.5.30 → 0.5.31

package/dist/index.d.cts

@@ -24,7 +24,8 @@ declare enum SandboxStatus {
     SNAPSHOTTING = "snapshotting",
     SUSPENDING = "suspending",
     SUSPENDED = "suspended",
-    TERMINATED = "terminated"
+    TERMINATED = "terminated",
+    TIMEOUT = "timeout"
 }
 declare enum SnapshotStatus {
     IN_PROGRESS = "in_progress",
@@ -332,6 +333,10 @@ interface SandboxClientOptions {
     namespace?: string;
     maxRetries?: number;
     retryBackoffMs?: number;
+    /** Total HTTP request timeout in seconds. Default: 300. */
+    requestTimeout?: number;
+    /** @deprecated Use requestTimeout. Total HTTP request timeout in milliseconds. */
+    timeoutMs?: number;
 }
 interface SandboxOptions {
     sandboxId: string;
@@ -343,10 +348,17 @@ interface SandboxOptions {
     resolveProxyInfo?: (identifier: string) => Promise<SandboxInfo & {
         readonly traceId: string;
     }>;
+    /** Optional total HTTP request timeout in seconds for sandbox proxy operations. Omit for no total proxy timeout. */
+    requestTimeout?: number;
+    /** @deprecated Use requestTimeout. Optional total HTTP request timeout in milliseconds for sandbox proxy operations. */
+    timeoutMs?: number;
 }
 interface CreateAndConnectOptions extends CreateSandboxOptions {
     poolId?: string;
     proxyUrl?: string;
+    /** Total HTTP request timeout in seconds for sandbox startup. Default: client requestTimeout. */
+    requestTimeout?: number;
+    /** @deprecated Use requestTimeout. */
     startupTimeout?: number;
 }
 interface SuspendResumeOptions {
@@ -694,6 +706,9 @@ declare class SandboxClient {
     private readonly projectId;
     private readonly namespace;
     private readonly local;
+    private readonly maxRetries;
+    private readonly retryBackoffMs;
+    private readonly requestTimeoutMs;
     /** @internal Pass `true` to suppress the deprecation warning when used by `Sandbox.create()` / `Sandbox.connect()`. */
     constructor(options?: SandboxClientOptions, _internal?: boolean);
     /** Create a client for the TensorLake cloud platform. */
@@ -702,13 +717,18 @@ declare class SandboxClient {
         organizationId?: string;
         projectId?: string;
         apiUrl?: string;
+        requestTimeout?: number;
+        timeoutMs?: number;
     }): SandboxClient;
     /** Create a client for a local Indexify server. */
     static forLocalhost(options?: {
         apiUrl?: string;
         namespace?: string;
+        requestTimeout?: number;
+        timeoutMs?: number;
     }): SandboxClient;
     close(): void;
+    private withRequestTimeout;
     private path;
     /** Create a new sandbox. Returns immediately; the sandbox may still be starting. Use `createAndConnect()` for a blocking, ready-to-use handle. */
     create(options?: CreateSandboxOptions): Promise<Traced<CreateSandboxResponse>>;
@@ -813,14 +833,15 @@ declare class SandboxClient {
     /** Delete a sandbox pool. Fails if the pool has active containers. */
     deletePool(poolId: string): Promise<void>;
     /** Return a `Sandbox` handle for an existing running sandbox without verifying it exists. */
-    connect(identifier: string, proxyUrl?: string, routingHint?: string): Sandbox;
+    connect(identifier: string, proxyUrl?: string, routingHint?: string, requestTimeout?: number): Sandbox;
     /**
      * Create a sandbox, wait for it to reach `Running`, and return a connected handle.
      *
-     * Blocks until the sandbox is ready or `startupTimeout` elapses. The returned
+     * Blocks until the sandbox is ready or `requestTimeout` elapses. The returned
      * `Sandbox` auto-terminates when `terminate()` is called.
      *
-     * @param options.startupTimeout - Max seconds to wait for `Running` status (default 60).
+     * @param options.requestTimeout - Max seconds to wait for `Running` status (default: client requestTimeout).
+     * @param options.startupTimeout - Deprecated alias for `requestTimeout`.
      * @throws {SandboxError} If the sandbox terminates during startup or the timeout elapses.
      */
     createAndConnect(options?: CreateAndConnectOptions): Promise<Sandbox>;

package/dist/index.d.ts

@@ -24,7 +24,8 @@ declare enum SandboxStatus {
     SNAPSHOTTING = "snapshotting",
     SUSPENDING = "suspending",
     SUSPENDED = "suspended",
-    TERMINATED = "terminated"
+    TERMINATED = "terminated",
+    TIMEOUT = "timeout"
 }
 declare enum SnapshotStatus {
     IN_PROGRESS = "in_progress",
@@ -332,6 +333,10 @@ interface SandboxClientOptions {
     namespace?: string;
     maxRetries?: number;
     retryBackoffMs?: number;
+    /** Total HTTP request timeout in seconds. Default: 300. */
+    requestTimeout?: number;
+    /** @deprecated Use requestTimeout. Total HTTP request timeout in milliseconds. */
+    timeoutMs?: number;
 }
 interface SandboxOptions {
     sandboxId: string;
@@ -343,10 +348,17 @@ interface SandboxOptions {
     resolveProxyInfo?: (identifier: string) => Promise<SandboxInfo & {
         readonly traceId: string;
     }>;
+    /** Optional total HTTP request timeout in seconds for sandbox proxy operations. Omit for no total proxy timeout. */
+    requestTimeout?: number;
+    /** @deprecated Use requestTimeout. Optional total HTTP request timeout in milliseconds for sandbox proxy operations. */
+    timeoutMs?: number;
 }
 interface CreateAndConnectOptions extends CreateSandboxOptions {
     poolId?: string;
     proxyUrl?: string;
+    /** Total HTTP request timeout in seconds for sandbox startup. Default: client requestTimeout. */
+    requestTimeout?: number;
+    /** @deprecated Use requestTimeout. */
     startupTimeout?: number;
 }
 interface SuspendResumeOptions {
@@ -694,6 +706,9 @@ declare class SandboxClient {
     private readonly projectId;
     private readonly namespace;
     private readonly local;
+    private readonly maxRetries;
+    private readonly retryBackoffMs;
+    private readonly requestTimeoutMs;
     /** @internal Pass `true` to suppress the deprecation warning when used by `Sandbox.create()` / `Sandbox.connect()`. */
     constructor(options?: SandboxClientOptions, _internal?: boolean);
     /** Create a client for the TensorLake cloud platform. */
@@ -702,13 +717,18 @@ declare class SandboxClient {
         organizationId?: string;
         projectId?: string;
         apiUrl?: string;
+        requestTimeout?: number;
+        timeoutMs?: number;
     }): SandboxClient;
     /** Create a client for a local Indexify server. */
     static forLocalhost(options?: {
         apiUrl?: string;
         namespace?: string;
+        requestTimeout?: number;
+        timeoutMs?: number;
     }): SandboxClient;
     close(): void;
+    private withRequestTimeout;
     private path;
     /** Create a new sandbox. Returns immediately; the sandbox may still be starting. Use `createAndConnect()` for a blocking, ready-to-use handle. */
     create(options?: CreateSandboxOptions): Promise<Traced<CreateSandboxResponse>>;
@@ -813,14 +833,15 @@ declare class SandboxClient {
     /** Delete a sandbox pool. Fails if the pool has active containers. */
     deletePool(poolId: string): Promise<void>;
     /** Return a `Sandbox` handle for an existing running sandbox without verifying it exists. */
-    connect(identifier: string, proxyUrl?: string, routingHint?: string): Sandbox;
+    connect(identifier: string, proxyUrl?: string, routingHint?: string, requestTimeout?: number): Sandbox;
     /**
      * Create a sandbox, wait for it to reach `Running`, and return a connected handle.
      *
-     * Blocks until the sandbox is ready or `startupTimeout` elapses. The returned
+     * Blocks until the sandbox is ready or `requestTimeout` elapses. The returned
      * `Sandbox` auto-terminates when `terminate()` is called.
      *
-     * @param options.startupTimeout - Max seconds to wait for `Running` status (default 60).
+     * @param options.requestTimeout - Max seconds to wait for `Running` status (default: client requestTimeout).
+     * @param options.startupTimeout - Deprecated alias for `requestTimeout`.
      * @throws {SandboxError} If the sandbox terminates during startup or the timeout elapses.
      */
     createAndConnect(options?: CreateAndConnectOptions): Promise<Sandbox>;

package/dist/index.js

@@ -19,7 +19,7 @@ var SDK_VERSION, API_URL, API_KEY, NAMESPACE, SANDBOX_PROXY_URL, DEFAULT_HTTP_TI
 var init_defaults = __esm({
   "src/defaults.ts"() {
     "use strict";
-    SDK_VERSION = "0.5.30";
+    SDK_VERSION = "0.5.31";
     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";
@@ -184,12 +184,13 @@ function anySignal(signals) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var HttpClient;
+var REQUEST_TIMEOUT_HEADER, HttpClient;
 var init_http = __esm({
   "src/http.ts"() {
     "use strict";
     init_defaults();
     init_errors();
+    REQUEST_TIMEOUT_HEADER = "X-Tensorlake-Request-Timeout-Ms";
     setGlobalDispatcher(
       new Agent({
         keepAliveTimeout: 6e4,
@@ -208,10 +209,13 @@ var init_http = __esm({
         this.baseUrl = url.endsWith("/") ? url.slice(0, -1) : url;
         this.maxRetries = options.maxRetries ?? MAX_RETRIES;
         this.retryBackoffMs = options.retryBackoffMs ?? RETRY_BACKOFF_MS;
-        this.timeoutMs = options.timeoutMs ?? DEFAULT_HTTP_TIMEOUT_MS;
+        this.timeoutMs = options.timeoutMs === void 0 ? DEFAULT_HTTP_TIMEOUT_MS : options.timeoutMs;
         this.headers = {
           "User-Agent": `tensorlake-typescript-sdk/${SDK_VERSION}`
         };
+        if (this.timeoutMs != null) {
+          this.headers[REQUEST_TIMEOUT_HEADER] = String(this.timeoutMs);
+        }
         if (options.apiKey) {
           this.headers["Authorization"] = `Bearer ${options.apiKey}`;
         }
@@ -240,7 +244,10 @@ var init_http = __esm({
         const response = await this.requestResponse(method, path2, {
           json: options?.body,
           headers: options?.headers,
-          signal: options?.signal
+          signal: options?.signal,
+          retryableStatusCodes: options?.retryableStatusCodes,
+          allowedErrorStatusCodes: options?.allowedErrorStatusCodes,
+          allowHttpErrors: options?.allowHttpErrors
         });
         const text = await response.text();
         const data = text ? JSON.parse(text) : void 0;
@@ -292,7 +299,9 @@ var init_http = __esm({
           body,
           headers,
           options?.signal,
-          options?.allowHttpErrors ?? false
+          options?.allowHttpErrors ?? false,
+          options?.retryableStatusCodes ?? RETRYABLE_STATUS_CODES,
+          options?.allowedErrorStatusCodes ?? /* @__PURE__ */ new Set()
         );
         return withTraceId(response, traceId);
       }
@@ -302,7 +311,7 @@ var init_http = __esm({
         const spanId = randomHex(8);
         return { traceparent: `00-${traceId}-${spanId}-01`, traceId };
       }
-      async doFetch(method, path2, body, headers, signal, allowHttpErrors = false) {
+      async doFetch(method, path2, body, headers, signal, allowHttpErrors = false, retryableStatusCodes = RETRYABLE_STATUS_CODES, allowedErrorStatusCodes = /* @__PURE__ */ new Set()) {
         const url = `${this.baseUrl}${path2}`;
         const { traceparent, traceId } = _HttpClient.makeTraceparent();
         headers["traceparent"] = traceparent;
@@ -313,10 +322,7 @@ var init_http = __esm({
             await sleep(delay);
           }
           this.abortController = new AbortController();
-          const timeoutId = setTimeout(
-            () => this.abortController?.abort(),
-            this.timeoutMs
-          );
+          const timeoutId = this.timeoutMs == null ? null : setTimeout(() => this.abortController?.abort(), this.timeoutMs);
           const combinedSignal = signal ? anySignal([signal, this.abortController.signal]) : this.abortController.signal;
           try {
             const response = await undiciFetch(url, {
@@ -325,22 +331,22 @@ var init_http = __esm({
               body,
               signal: combinedSignal
             });
-            clearTimeout(timeoutId);
+            if (timeoutId != null) clearTimeout(timeoutId);
             if (response.ok) return { response, traceId };
-            if (RETRYABLE_STATUS_CODES.has(response.status) && attempt < this.maxRetries) {
+            if (retryableStatusCodes.has(response.status) && attempt < this.maxRetries) {
               lastError = new RemoteAPIError(
                 response.status,
                 await response.text().catch(() => "")
               );
               continue;
             }
-            if (allowHttpErrors) {
+            if (allowHttpErrors || allowedErrorStatusCodes.has(response.status)) {
               return { response, traceId };
             }
             const errorBody = await response.text().catch(() => "");
             throwMappedError(response.status, errorBody, path2);
           } catch (err) {
-            clearTimeout(timeoutId);
+            if (timeoutId != null) clearTimeout(timeoutId);
             if (err instanceof RemoteAPIError || err instanceof SandboxNotFoundError || err instanceof PoolNotFoundError || err instanceof PoolInUseError) {
               throw err;
             }
@@ -412,6 +418,7 @@ var init_models = __esm({
       SandboxStatus3["SUSPENDING"] = "suspending";
       SandboxStatus3["SUSPENDED"] = "suspended";
       SandboxStatus3["TERMINATED"] = "terminated";
+      SandboxStatus3["TIMEOUT"] = "timeout";
       return SandboxStatus3;
     })(SandboxStatus || {});
     SnapshotStatus = /* @__PURE__ */ ((SnapshotStatus2) => {
@@ -3024,6 +3031,12 @@ function sendPtyFrame(socket, frame) {
     socket.send(frame, (error) => error ? reject(error) : resolve());
   });
 }
+function secondsToMillis3(seconds) {
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new SandboxError("requestTimeout must be a positive number of seconds");
+  }
+  return Math.ceil(seconds * 1e3);
+}
 var DEFAULT_PROCESS_USER, SandboxProxyConnection, PTY_OP_DATA, PTY_OP_RESIZE, PTY_OP_READY, PTY_OP_EXIT, Pty, Sandbox;
 var init_sandbox = __esm({
   "src/sandbox.ts"() {
@@ -3125,7 +3138,8 @@ var init_sandbox = __esm({
           projectId: this.options.projectId,
           hostHeader,
           sandboxIdHeader,
-          routingHint
+          routingHint,
+          timeoutMs: this.options.requestTimeout != null ? secondsToMillis3(this.options.requestTimeout) : this.options.timeoutMs ?? null
         });
       }
     };
@@ -3346,9 +3360,7 @@ var init_sandbox = __esm({
           /* _internal */
           true
         );
-        const sandbox = await client.createAndConnect(options);
-        sandbox.lifecycleClient = client;
-        return sandbox;
+        return client.createAndConnect(options);
       }
       /**
        * Attach to an existing sandbox and return a connected handle.
@@ -3367,7 +3379,8 @@ var init_sandbox = __esm({
         const sandbox = client.connect(
           options.sandboxId,
           options.proxyUrl,
-          options.routingHint
+          options.routingHint,
+          options.requestTimeout
         );
         sandbox.lifecycleClient = client;
         return sandbox;
@@ -3892,6 +3905,27 @@ var client_exports = {};
 __export(client_exports, {
   SandboxClient: () => SandboxClient
 });
+function resolveRequestTimeoutMs(options) {
+  if (options?.requestTimeout != null) {
+    return secondsToMillis4(options.requestTimeout);
+  }
+  if (options?.timeoutMs != null) {
+    validateTimeoutMs(options.timeoutMs);
+    return options.timeoutMs;
+  }
+  return DEFAULT_HTTP_TIMEOUT_MS;
+}
+function secondsToMillis4(seconds) {
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    throw new SandboxError("requestTimeout must be a positive number of seconds");
+  }
+  return Math.ceil(seconds * 1e3);
+}
+function validateTimeoutMs(timeoutMs) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new SandboxError("timeoutMs must be a positive number of milliseconds");
+  }
+}
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -3948,7 +3982,7 @@ function validateUserPort(port) {
 function dedupeAndSortPorts(ports) {
   return [...new Set(ports)].sort((a, b) => a - b);
 }
-var SandboxClient, RESERVED_SANDBOX_MANAGEMENT_PORT;
+var CREATE_SANDBOX_RETRYABLE_STATUS_CODES, CREATE_SANDBOX_ALLOWED_ERROR_STATUS_CODES, SandboxClient, RESERVED_SANDBOX_MANAGEMENT_PORT;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
@@ -3958,6 +3992,8 @@ var init_client = __esm({
     init_models();
     init_sandbox();
     init_url();
+    CREATE_SANDBOX_RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([502, 503]);
+    CREATE_SANDBOX_ALLOWED_ERROR_STATUS_CODES = /* @__PURE__ */ new Set([504]);
     SandboxClient = class _SandboxClient {
       http;
       apiUrl;
@@ -3966,6 +4002,9 @@ var init_client = __esm({
       projectId;
       namespace;
       local;
+      maxRetries;
+      retryBackoffMs;
+      requestTimeoutMs;
       /** @internal Pass `true` to suppress the deprecation warning when used by `Sandbox.create()` / `Sandbox.connect()`. */
       constructor(options, _internal = false) {
         if (!_internal) {
@@ -3979,13 +4018,17 @@ var init_client = __esm({
         this.projectId = options?.projectId;
         this.namespace = options?.namespace ?? NAMESPACE;
         this.local = isLocalhost(this.apiUrl);
+        this.maxRetries = options?.maxRetries ?? MAX_RETRIES;
+        this.retryBackoffMs = options?.retryBackoffMs ?? RETRY_BACKOFF_MS;
+        this.requestTimeoutMs = resolveRequestTimeoutMs(options);
         this.http = new HttpClient({
           baseUrl: resolveSandboxLifecycleUrl(this.apiUrl),
           apiKey: this.apiKey,
           organizationId: this.organizationId,
           projectId: this.projectId,
-          maxRetries: options?.maxRetries ?? MAX_RETRIES,
-          retryBackoffMs: options?.retryBackoffMs ?? RETRY_BACKOFF_MS
+          maxRetries: this.maxRetries,
+          retryBackoffMs: this.retryBackoffMs,
+          timeoutMs: this.requestTimeoutMs
         });
       }
       /** Create a client for the TensorLake cloud platform. */
@@ -3994,19 +4037,46 @@ var init_client = __esm({
           apiUrl: options?.apiUrl ?? "https://api.tensorlake.ai",
           apiKey: options?.apiKey,
           organizationId: options?.organizationId,
-          projectId: options?.projectId
+          projectId: options?.projectId,
+          requestTimeout: options?.requestTimeout,
+          timeoutMs: options?.timeoutMs
         });
       }
       /** Create a client for a local Indexify server. */
       static forLocalhost(options) {
         return new _SandboxClient({
           apiUrl: options?.apiUrl ?? "http://localhost:8900",
-          namespace: options?.namespace ?? "default"
+          namespace: options?.namespace ?? "default",
+          requestTimeout: options?.requestTimeout,
+          timeoutMs: options?.timeoutMs
         });
       }
       close() {
         this.http.close();
       }
+      withRequestTimeout(requestTimeout) {
+        if (requestTimeout == null) {
+          return this;
+        }
+        const timeoutMs = secondsToMillis4(requestTimeout);
+        if (timeoutMs === this.requestTimeoutMs) {
+          return this;
+        }
+        return new _SandboxClient(
+          {
+            apiUrl: this.apiUrl,
+            apiKey: this.apiKey,
+            organizationId: this.organizationId,
+            projectId: this.projectId,
+            namespace: this.namespace,
+            maxRetries: this.maxRetries,
+            retryBackoffMs: this.retryBackoffMs,
+            timeoutMs
+          },
+          /* _internal */
+          true
+        );
+      }
       // --- Path helper ---
       path(subpath) {
         return lifecyclePath(subpath, this.local, this.namespace);
@@ -4037,7 +4107,11 @@ var init_client = __esm({
         const raw = await this.http.requestJson(
           "POST",
           this.path("sandboxes"),
-          { body }
+          {
+            body,
+            retryableStatusCodes: CREATE_SANDBOX_RETRYABLE_STATUS_CODES,
+            allowedErrorStatusCodes: CREATE_SANDBOX_ALLOWED_ERROR_STATUS_CODES
+          }
         );
         const result = fromSnakeKeys(raw, "sandboxId");
         return Object.assign(result, { traceId: raw.traceId });
@@ -4231,7 +4305,11 @@ var init_client = __esm({
       async claim(poolId) {
         const raw = await this.http.requestJson(
           "POST",
-          this.path(`sandbox-pools/${poolId}/sandboxes`)
+          this.path(`sandbox-pools/${poolId}/sandboxes`),
+          {
+            retryableStatusCodes: CREATE_SANDBOX_RETRYABLE_STATUS_CODES,
+            allowedErrorStatusCodes: CREATE_SANDBOX_ALLOWED_ERROR_STATUS_CODES
+          }
         );
         const result = fromSnakeKeys(raw, "sandboxId");
         return Object.assign(result, { traceId: raw.traceId });
@@ -4393,7 +4471,7 @@ var init_client = __esm({
       }
       // --- Connect ---
       /** Return a `Sandbox` handle for an existing running sandbox without verifying it exists. */
-      connect(identifier, proxyUrl, routingHint) {
+      connect(identifier, proxyUrl, routingHint, requestTimeout) {
         const resolvedProxy = proxyUrl ?? resolveProxyUrl(this.apiUrl);
         return new Sandbox({
           sandboxId: identifier,
@@ -4402,29 +4480,33 @@ var init_client = __esm({
           organizationId: this.organizationId,
           projectId: this.projectId,
           routingHint,
-          resolveProxyInfo: proxyUrl == null ? async (currentIdentifier) => this.get(currentIdentifier) : void 0
+          resolveProxyInfo: proxyUrl == null ? async (currentIdentifier) => this.get(currentIdentifier) : void 0,
+          requestTimeout
         });
       }
       /**
        * Create a sandbox, wait for it to reach `Running`, and return a connected handle.
        *
-       * Blocks until the sandbox is ready or `startupTimeout` elapses. The returned
+       * Blocks until the sandbox is ready or `requestTimeout` elapses. The returned
        * `Sandbox` auto-terminates when `terminate()` is called.
        *
-       * @param options.startupTimeout - Max seconds to wait for `Running` status (default 60).
+       * @param options.requestTimeout - Max seconds to wait for `Running` status (default: client requestTimeout).
+       * @param options.startupTimeout - Deprecated alias for `requestTimeout`.
        * @throws {SandboxError} If the sandbox terminates during startup or the timeout elapses.
        */
       async createAndConnect(options) {
-        const startupTimeout = options?.startupTimeout ?? 60;
-        const result = options?.poolId != null ? await this.claim(options.poolId) : await this.create(options);
+        const requestTimeout = options?.requestTimeout ?? options?.startupTimeout ?? this.requestTimeoutMs / 1e3;
+        const requestClient = this.withRequestTimeout(requestTimeout);
+        const result = options?.poolId != null ? await requestClient.claim(options.poolId) : await requestClient.create(options);
         const requestedName = options?.poolId != null ? null : options?.name ?? null;
         const finishConnect = (routingHint, name, ingressEndpoint) => {
-          const sandbox = this.connect(
+          const sandbox = requestClient.connect(
             result.sandboxId,
             options?.proxyUrl ?? ingressEndpoint,
-            routingHint
+            routingHint,
+            requestTimeout
           );
-          sandbox._setOwner(this);
+          sandbox._setOwner(requestClient);
           sandbox.traceId = result.traceId;
           sandbox._setLifecycleIdentifier(result.sandboxId);
           sandbox._setName(name ?? requestedName);
@@ -4441,9 +4523,18 @@ var init_client = __esm({
             })
           );
         }
-        const deadline = Date.now() + startupTimeout * 1e3;
+        if (result.status === "timeout" /* TIMEOUT */) {
+          try {
+            await requestClient.delete(result.sandboxId);
+          } catch {
+          }
+          throw new SandboxError(
+            `Sandbox ${result.sandboxId} did not start within ${requestTimeout}s`
+          );
+        }
+        const deadline = Date.now() + secondsToMillis4(requestTimeout);
         while (Date.now() < deadline) {
-          const info = await this.get(result.sandboxId);
+          const info = await requestClient.get(result.sandboxId);
           if (info.status === "running" /* RUNNING */) {
             return finishConnect(info.routingHint, info.name, info.ingressEndpoint);
           }
@@ -4458,11 +4549,11 @@ var init_client = __esm({
           await sleep2(500);
         }
         try {
-          await this.delete(result.sandboxId);
+          await requestClient.delete(result.sandboxId);
         } catch {
         }
         throw new SandboxError(
-          `Sandbox ${result.sandboxId} did not start within ${startupTimeout}s`
+          `Sandbox ${result.sandboxId} did not start within ${requestTimeout}s`
         );
       }
     };