tensorlake 0.5.30 → 0.5.33

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.33";
     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";
@@ -48,6 +48,28 @@ var init_defaults = __esm({
 });
 
 // src/errors.ts
+function describeError(err) {
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = err;
+  for (let depth = 0; depth < 6; depth++) {
+    if (current == null || typeof current !== "object" || seen.has(current)) {
+      break;
+    }
+    seen.add(current);
+    const e = current;
+    const message = typeof e.message === "string" ? e.message.trim() : "";
+    const code = typeof e.code === "string" ? e.code : void 0;
+    let segment = message;
+    if (code && (!message || !message.includes(code))) {
+      segment = segment ? `${segment} (${code})` : code;
+    }
+    if (segment && !parts.includes(segment)) parts.push(segment);
+    current = e.cause;
+  }
+  if (parts.length > 0) return parts.join(": ");
+  return err instanceof Error ? err.message : String(err);
+}
 var SandboxException, SandboxError, SandboxConnectionError, SandboxNotFoundError, PoolNotFoundError, PoolInUseError, RemoteAPIError, RequestNotFinishedError, RequestFailedError, RequestExecutionError;
 var init_errors = __esm({
   "src/errors.ts"() {
@@ -65,9 +87,10 @@ var init_errors = __esm({
       }
     };
     SandboxConnectionError = class extends SandboxError {
-      constructor(message) {
+      constructor(message, options) {
         super(`Connection error: ${message}`);
         this.name = "SandboxConnectionError";
+        if (options?.cause !== void 0) this.cause = options.cause;
       }
     };
     SandboxNotFoundError = class extends SandboxError {
@@ -195,13 +218,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 +244,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 +279,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 +334,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 +346,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 +357,11 @@ var init_http = __esm({
             await sleep(delay);
           }
           this.abortController = new AbortController();
-          const timeoutId = setTimeout(
-            () => this.abortController?.abort(),
-            this.timeoutMs
-          );
+          let timedOut = false;
+          const timeoutId = this.timeoutMs == null ? null : setTimeout(() => {
+            timedOut = true;
+            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,35 +370,41 @@ 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;
             }
-            if (signal?.aborted) {
-              throw new SandboxConnectionError("Request aborted");
+            if (signal?.aborted && !timedOut) {
+              throw new SandboxConnectionError("request aborted by caller", {
+                cause: err
+              });
             }
             lastError = err instanceof Error ? err : new Error(String(err));
             if (attempt >= this.maxRetries) {
-              throw new SandboxConnectionError(lastError.message);
+              const detail = timedOut ? `request timed out after ${this.timeoutMs}ms` : describeError(err);
+              throw new SandboxConnectionError(detail, { cause: err });
             }
           }
         }
-        throw new SandboxConnectionError(lastError?.message ?? "Request failed");
+        throw new SandboxConnectionError(
+          lastError ? describeError(lastError) : "request failed",
+          { cause: lastError }
+        );
       }
     };
   }
@@ -424,6 +463,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 +3075,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 +3183,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 +3405,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 +3424,8 @@ var init_sandbox = __esm({
         const sandbox = client.connect(
           options.sandboxId,
           options.proxyUrl,
-          options.routingHint
+          options.routingHint,
+          options.requestTimeout
         );
         sandbox.lifecycleClient = client;
         return sandbox;
@@ -3488,6 +3534,11 @@ var init_sandbox = __esm({
         const client = this.requireLifecycleClient("resume");
         await client.resume(this.lifecycleIdentifier, options);
       }
+      /** Live-copy this running sandbox. */
+      async copy(options) {
+        const client = this.requireLifecycleClient("copy");
+        return client.copy(this.lifecycleIdentifier, options);
+      }
       /**
        * Create a checkpoint of this sandbox and wait for it to be locally ready.
        *
@@ -3904,6 +3955,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 +4032,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, COPY_SANDBOX_ALLOWED_ERROR_STATUS_CODES, SandboxClient, RESERVED_SANDBOX_MANAGEMENT_PORT;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
@@ -3970,6 +4042,9 @@ 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]);
+    COPY_SANDBOX_ALLOWED_ERROR_STATUS_CODES = /* @__PURE__ */ new Set([422, 504]);
     SandboxClient = class _SandboxClient {
       http;
       apiUrl;
@@ -3978,6 +4053,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 +4069,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 +4088,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);
@@ -4034,7 +4143,6 @@ var init_client = __esm({
           }
         };
         if (options?.image != null) body.image = options.image;
-        if (options?.secretNames != null) body.secret_names = options.secretNames;
         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;
@@ -4049,7 +4157,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 +4355,32 @@ 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 });
+      }
+      /**
+       * Live-copy a running sandbox.
+       *
+       * The server creates `times` running copies from the source sandbox. Partial
+       * responses can include failed copies; inspect each returned sandbox's
+       * `status` and `reason`.
+       */
+      async copy(sandboxId, options) {
+        const times = options?.times ?? 1;
+        if (!Number.isInteger(times) || times < 1) {
+          throw new SandboxError("times must be a positive integer");
+        }
+        const client = this.withRequestTimeout(options?.requestTimeout);
+        const raw = await client.http.requestJson(
+          "POST",
+          client.path(`sandbox/${sandboxId}/copy?times=${encodeURIComponent(String(times))}`),
+          { allowedErrorStatusCodes: COPY_SANDBOX_ALLOWED_ERROR_STATUS_CODES }
         );
         const result = fromSnakeKeys(raw, "sandboxId");
         return Object.assign(result, { traceId: raw.traceId });
@@ -4344,7 +4481,6 @@ var init_client = __esm({
           },
           timeout_secs: options.timeoutSecs ?? 0
         };
-        if (options.secretNames != null) body.secret_names = options.secretNames;
         if (options.entrypoint != null) body.entrypoint = options.entrypoint;
         if (options.maxContainers != null) body.max_containers = options.maxContainers;
         if (options.warmContainers != null) body.warm_containers = options.warmContainers;
@@ -4385,7 +4521,6 @@ var init_client = __esm({
           },
           timeout_secs: options.timeoutSecs ?? 0
         };
-        if (options.secretNames != null) body.secret_names = options.secretNames;
         if (options.entrypoint != null) body.entrypoint = options.entrypoint;
         if (options.maxContainers != null) body.max_containers = options.maxContainers;
         if (options.warmContainers != null) body.warm_containers = options.warmContainers;
@@ -4405,7 +4540,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 +4549,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 +4592,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 +4618,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`
         );
       }
     };