tensorlake 0.5.30 → 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.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";
@@ -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) => {
@@ -3035,6 +3042,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 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"() {
@@ -3137,7 +3150,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
         });
       }
     };
@@ -3358,9 +3372,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.
@@ -3379,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;
@@ -3904,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));
 }
@@ -3960,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";
@@ -3970,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;
@@ -3978,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) {
@@ -3991,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. */
@@ -4006,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);
@@ -4049,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 });
@@ -4243,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 });
@@ -4405,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,
@@ -4414,29 +4492,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);
@@ -4453,9 +4535,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);
           }
@@ -4470,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`
         );
       }
     };