tensorlake 0.5.29 → 0.5.31

package/dist/index.cjs

@@ -35,7 +35,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.29";
+    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";
@@ -195,13 +195,14 @@ function anySignal(signals) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var import_undici, HttpClient;
+var import_undici, REQUEST_TIMEOUT_HEADER, HttpClient;
 var init_http = __esm({
   "src/http.ts"() {
     "use strict";
     import_undici = require("undici");
     init_defaults();
     init_errors();
+    REQUEST_TIMEOUT_HEADER = "X-Tensorlake-Request-Timeout-Ms";
     (0, import_undici.setGlobalDispatcher)(
       new import_undici.Agent({
         keepAliveTimeout: 6e4,
@@ -220,10 +221,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}`;
         }
@@ -252,7 +256,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;
@@ -304,7 +311,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);
       }
@@ -314,7 +323,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;
@@ -325,10 +334,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 (0, import_undici.fetch)(url, {
@@ -337,22 +343,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;
             }
@@ -424,6 +430,7 @@ var init_models = __esm({
       SandboxStatus3["SUSPENDING"] = "suspending";
       SandboxStatus3["SUSPENDED"] = "suspended";
       SandboxStatus3["TERMINATED"] = "terminated";
+      SandboxStatus3["TIMEOUT"] = "timeout";
       return SandboxStatus3;
     })(SandboxStatus || {});
     SnapshotStatus = /* @__PURE__ */ ((SnapshotStatus2) => {
@@ -2969,6 +2976,14 @@ function resolveProxyTarget(proxyUrl, sandboxId) {
     };
   }
 }
+function sandboxUrlFromIngressEndpoint(ingressEndpoint, sandboxId, port = 9501) {
+  const parsed = new URL(ingressEndpoint);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("ingressEndpoint must be an absolute http(s) URL");
+  }
+  const label = port === 9501 ? sandboxId : `${port}-${sandboxId}`;
+  return `${parsed.protocol}//${label}.${parsed.host}`;
+}
 function resolveSandboxLifecycleUrl(apiUrl) {
   if (isLocalhost(apiUrl)) return apiUrl;
   try {
@@ -3027,7 +3042,13 @@ function sendPtyFrame(socket, frame) {
     socket.send(frame, (error) => error ? reject(error) : resolve());
   });
 }
-var import_ws2, DEFAULT_PROCESS_USER, PTY_OP_DATA, PTY_OP_RESIZE, PTY_OP_READY, PTY_OP_EXIT, Pty, Sandbox;
+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 import_ws2, 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"() {
     "use strict";
@@ -3041,6 +3062,99 @@ var init_sandbox = __esm({
     init_url();
     import_ws2 = __toESM(require("ws"), 1);
     DEFAULT_PROCESS_USER = "tl-user";
+    SandboxProxyConnection = class {
+      constructor(sandbox, options) {
+        this.sandbox = sandbox;
+        this.options = options;
+        this.routingHint = options.routingHint;
+        this.http = this.configureProxy(
+          options.proxyUrl ?? SANDBOX_PROXY_URL,
+          options.sandboxId,
+          options.routingHint
+        );
+        this.resolveProxyInfo = options.resolveProxyInfo;
+      }
+      baseUrl = "";
+      wsHeaders = {};
+      http;
+      resolveProxyInfo;
+      resolvePromise = null;
+      routingHint;
+      async ensureResolved() {
+        if (this.resolveProxyInfo == null) {
+          return;
+        }
+        if (this.resolvePromise != null) {
+          return this.resolvePromise;
+        }
+        this.resolvePromise = this.resolveProxyInfo(this.sandbox._getLifecycleIdentifier()).then((info) => {
+          this.resolveProxyInfo = void 0;
+          this.sandbox.traceId = info.traceId;
+          this.sandbox._setLifecycleIdentifier(info.sandboxId);
+          this.sandbox._setName(info.name ?? null);
+          this.routingHint = this.routingHint ?? info.routingHint;
+          const proxyUrl = info.ingressEndpoint ?? this.options.proxyUrl ?? SANDBOX_PROXY_URL;
+          const nextHttp = this.configureProxy(proxyUrl, info.sandboxId, this.routingHint);
+          this.http.close();
+          this.http = nextHttp;
+        }).finally(() => {
+          this.resolvePromise = null;
+        });
+        return this.resolvePromise;
+      }
+      async requestJson(method, path2, options) {
+        await this.ensureResolved();
+        return this.http.requestJson(method, path2, options);
+      }
+      async requestBytes(method, path2, options) {
+        await this.ensureResolved();
+        return this.http.requestBytes(method, path2, options);
+      }
+      async requestStream(method, path2, options) {
+        await this.ensureResolved();
+        return this.http.requestStream(method, path2, options);
+      }
+      async requestResponse(method, path2, options) {
+        await this.ensureResolved();
+        return this.http.requestResponse(method, path2, options);
+      }
+      close() {
+        this.http.close();
+      }
+      configureProxy(proxyUrl, sandboxId, routingHint) {
+        const { baseUrl, hostHeader, sandboxIdHeader } = resolveProxyTarget(
+          proxyUrl,
+          sandboxId
+        );
+        this.baseUrl = baseUrl;
+        this.wsHeaders = {};
+        if (this.options.apiKey) {
+          this.wsHeaders.Authorization = `Bearer ${this.options.apiKey}`;
+        }
+        if (this.options.organizationId) {
+          this.wsHeaders["X-Forwarded-Organization-Id"] = this.options.organizationId;
+        }
+        if (this.options.projectId) {
+          this.wsHeaders["X-Forwarded-Project-Id"] = this.options.projectId;
+        }
+        if (hostHeader) {
+          this.wsHeaders.Host = hostHeader;
+        }
+        if (sandboxIdHeader) {
+          this.wsHeaders["X-Tensorlake-Sandbox-Id"] = sandboxIdHeader;
+        }
+        return new HttpClient({
+          baseUrl,
+          apiKey: this.options.apiKey,
+          organizationId: this.options.organizationId,
+          projectId: this.options.projectId,
+          hostHeader,
+          sandboxIdHeader,
+          routingHint,
+          timeoutMs: this.options.requestTimeout != null ? secondsToMillis3(this.options.requestTimeout) : this.options.timeoutMs ?? null
+        });
+      }
+    };
     PTY_OP_DATA = 0;
     PTY_OP_RESIZE = 1;
     PTY_OP_READY = 2;
@@ -3206,9 +3320,8 @@ var init_sandbox = __esm({
     Sandbox = class {
       sandboxId;
       traceId = null;
+      proxy;
       http;
-      baseUrl;
-      wsHeaders;
       ownsSandbox = false;
       lifecycleClient = null;
       lifecycleIdentifier;
@@ -3216,34 +3329,14 @@ var init_sandbox = __esm({
       constructor(options) {
         this.sandboxId = options.sandboxId;
         this.lifecycleIdentifier = options.sandboxId;
-        const proxyUrl = options.proxyUrl ?? SANDBOX_PROXY_URL;
-        const { baseUrl, hostHeader, sandboxIdHeader } = resolveProxyTarget(proxyUrl, options.sandboxId);
-        this.baseUrl = baseUrl;
-        this.wsHeaders = {};
-        if (options.apiKey) {
-          this.wsHeaders.Authorization = `Bearer ${options.apiKey}`;
-        }
-        if (options.organizationId) {
-          this.wsHeaders["X-Forwarded-Organization-Id"] = options.organizationId;
-        }
-        if (options.projectId) {
-          this.wsHeaders["X-Forwarded-Project-Id"] = options.projectId;
-        }
-        if (hostHeader) {
-          this.wsHeaders.Host = hostHeader;
-        }
-        if (sandboxIdHeader) {
-          this.wsHeaders["X-Tensorlake-Sandbox-Id"] = sandboxIdHeader;
-        }
-        this.http = new HttpClient({
-          baseUrl,
-          apiKey: options.apiKey,
-          organizationId: options.organizationId,
-          projectId: options.projectId,
-          hostHeader,
-          sandboxIdHeader,
-          routingHint: options.routingHint
-        });
+        this.proxy = new SandboxProxyConnection(this, options);
+        this.http = this.proxy;
+      }
+      get baseUrl() {
+        return this.proxy.baseUrl;
+      }
+      get wsHeaders() {
+        return this.proxy.wsHeaders;
       }
       get name() {
         return this.sandboxName;
@@ -3256,6 +3349,10 @@ var init_sandbox = __esm({
       _setLifecycleIdentifier(identifier) {
         this.lifecycleIdentifier = identifier;
       }
+      /** @internal Used by the lazy proxy resolver. */
+      _getLifecycleIdentifier() {
+        return this.lifecycleIdentifier;
+      }
       /** @internal Used by SandboxClient.createAndConnect to set ownership. */
       _setOwner(client) {
         this.ownsSandbox = true;
@@ -3275,16 +3372,14 @@ 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.
        *
-       * Returns immediately without contacting the server. Call `sandbox.info()`
-       * to fetch the current state on demand. Does **not** auto-resume a suspended
-       * sandbox — call `sandbox.resume()` explicitly.
+       * When `proxyUrl` is omitted, resolves the sandbox first so the handle uses
+       * the correct cloud/region ingress endpoint. Does **not** auto-resume a
+       * suspended sandbox — call `sandbox.resume()` explicitly.
        */
       static async connect(options) {
         const { SandboxClient: SandboxClient2 } = await Promise.resolve().then(() => (init_client(), client_exports));
@@ -3296,7 +3391,8 @@ var init_sandbox = __esm({
         const sandbox = client.connect(
           options.sandboxId,
           options.proxyUrl,
-          options.routingHint
+          options.routingHint,
+          options.requestTimeout
         );
         sandbox.lifecycleClient = client;
         return sandbox;
@@ -3698,6 +3794,7 @@ var init_sandbox = __esm({
       }
       /** Attach to an existing PTY session by ID and token and return a connected `Pty` handle. */
       async connectPty(sessionId, token, options) {
+        await this.proxy.ensureResolved();
         const wsUrl = new URL(this.ptyWsUrl(sessionId, token));
         const authToken = wsUrl.searchParams.get("token") ?? token;
         const pty = new Pty({
@@ -3723,6 +3820,7 @@ var init_sandbox = __esm({
       }
       /** Open a TCP tunnel to a port inside the sandbox and return the local listener. */
       async createTunnel(remotePort, options) {
+        await this.proxy.ensureResolved();
         return TcpTunnel.listen({
           baseUrl: this.baseUrl,
           wsHeaders: this.wsHeaders,
@@ -3734,6 +3832,7 @@ var init_sandbox = __esm({
       }
       /** Connect to a sandbox VNC session for programmatic desktop control. */
       async connectDesktop(options) {
+        await this.proxy.ensureResolved();
         const port = options?.port ?? 5901;
         const connectTimeout = options?.connectTimeout ?? 10;
         const startMs = Date.now();
@@ -3818,6 +3917,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));
 }
@@ -3874,7 +3994,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";
@@ -3884,6 +4004,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;
@@ -3892,6 +4014,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) {
@@ -3905,13 +4030,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. */
@@ -3920,19 +4049,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);
@@ -3963,7 +4119,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 });
@@ -4053,6 +4213,7 @@ var init_client = __esm({
         return {
           allowUnauthenticatedAccess: info.allowUnauthenticatedAccess ?? false,
           exposedPorts: dedupeAndSortPorts(info.exposedPorts ?? []),
+          ingressEndpoint: info.ingressEndpoint,
           sandboxUrl: info.sandboxUrl
         };
       }
@@ -4156,7 +4317,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 });
@@ -4318,7 +4483,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,
@@ -4326,32 +4491,41 @@ var init_client = __esm({
           apiKey: this.apiKey,
           organizationId: this.organizationId,
           projectId: this.projectId,
-          routingHint
+          routingHint,
+          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) => {
-          const sandbox = this.connect(result.sandboxId, options?.proxyUrl, routingHint);
-          sandbox._setOwner(this);
+        const finishConnect = (routingHint, name, ingressEndpoint) => {
+          const sandbox = requestClient.connect(
+            result.sandboxId,
+            options?.proxyUrl ?? ingressEndpoint,
+            routingHint,
+            requestTimeout
+          );
+          sandbox._setOwner(requestClient);
           sandbox.traceId = result.traceId;
           sandbox._setLifecycleIdentifier(result.sandboxId);
           sandbox._setName(name ?? requestedName);
           return sandbox;
         };
         if (result.status === "running" /* RUNNING */) {
-          return finishConnect(result.routingHint, result.name);
+          return finishConnect(result.routingHint, result.name, result.ingressEndpoint);
         }
         if (result.status === "suspended" /* SUSPENDED */ || result.status === "terminated" /* TERMINATED */) {
           throw new SandboxError(
@@ -4361,11 +4535,20 @@ 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);
+            return finishConnect(info.routingHint, info.name, info.ingressEndpoint);
           }
           if (info.status === "suspended" /* SUSPENDED */ || info.status === "terminated" /* TERMINATED */) {
             throw new SandboxError(
@@ -4378,11 +4561,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`
         );
       }
     };
@@ -4772,7 +4955,8 @@ __export(index_exports, {
   StdinMode: () => StdinMode,
   TcpTunnel: () => TcpTunnel,
   createSandboxImage: () => createSandboxImage,
-  dockerfileContent: () => dockerfileContent
+  dockerfileContent: () => dockerfileContent,
+  sandboxUrlFromIngressEndpoint: () => sandboxUrlFromIngressEndpoint
 });
 module.exports = __toCommonJS(index_exports);
 init_client();
@@ -5165,6 +5349,7 @@ var APIClient = class {
 // src/index.ts
 init_sandbox_image();
 init_image();
+init_url();
 init_errors();
 init_models();
 // Annotate the CommonJS export names for ESM import in node:
@@ -5195,6 +5380,7 @@ init_models();
   StdinMode,
   TcpTunnel,
   createSandboxImage,
-  dockerfileContent
+  dockerfileContent,
+  sandboxUrlFromIngressEndpoint
 });
 //# sourceMappingURL=index.cjs.map