@tensorlakeai/tensorlake 0.5.156 → 0.5.158

package/dist/index.d.cts

@@ -67,6 +67,8 @@ interface NativeSandboxProxyClient {
 }
 interface NativeSandboxClient {
     createSandbox(requestJson: string): Promise<TracedJson>;
+    /** Blocking create for createAndConnect: a `running`, `failed` or `timeout` record. */
+    createSandboxAndWait(requestJson: string): Promise<TracedJson>;
     /** Wait-free create (`wait: false`, ADR 0086). */
     createSandboxNoWait(requestJson: string): Promise<TracedJson>;
     /** Poll the sandbox until it leaves `pending` or the budget runs out; resolves with the last `SandboxInfo`. */
@@ -89,6 +91,7 @@ interface NativeSandboxClient {
     createSnapshot(sandboxId: string, snapshotType?: string | null): Promise<TracedJson>;
     getSnapshot(snapshotId: string): Promise<TracedJson>;
     listSnapshots(): Promise<TracedJson>;
+    listSandboxSnapshots(sandboxId: string): Promise<TracedJson>;
     deleteSnapshot(snapshotId: string): Promise<string>;
     createPool(requestJson: string): Promise<TracedJson>;
     getPool(poolId: string): Promise<TracedJson>;
@@ -896,7 +899,10 @@ interface CreateAndConnectOptions extends CreateSandboxOptions {
      * false: throw `SandboxPending` and leave the sandbox queued.
      */
     cancelOnTimeout?: boolean;
-    /** Seconds between readiness polls. Default: 2. */
+    /**
+     * Seconds between readiness polls once the server's own wait has run out.
+     * Default: 2.
+     */
     pollInterval?: number;
 }
 /**
@@ -1114,8 +1120,8 @@ declare class Sandbox {
      *
      * Covers both fresh sandbox creation and restore-from-snapshot (set
      * `snapshotId`). With `wait` unset or `true` it blocks until the sandbox
-     * is `Running`: the create is sent with `wait: false` and the sandbox is
-     * polled every two seconds, with `requestTimeout` as the wait budget.
+     * is `Running`: the server waits and answers as soon as it runs, with
+     * `requestTimeout` as the wait budget.
      *
      * With `wait: false` it returns a {@link PendingSandbox} at once:
      * `pending.ready()` waits for it, `pending.status()` looks at it, and
@@ -1629,6 +1635,11 @@ declare class SandboxClient {
     getSnapshot(snapshotId: string): Promise<Traced<SnapshotInfo>>;
     /** List all snapshots in the namespace. */
     listSnapshots(): Promise<Traced<SnapshotInfo[]>>;
+    /**
+     * List snapshots taken from one sandbox (its ID or name), from the
+     * sandbox's own listing rather than the whole namespace's.
+     */
+    listSandboxSnapshots(sandboxId: string): Promise<Traced<SnapshotInfo[]>>;
     /** Delete a snapshot by ID. */
     deleteSnapshot(snapshotId: string): Promise<void>;
     /**
@@ -1663,10 +1674,9 @@ declare class SandboxClient {
     /**
      * Create a sandbox, wait for it to reach `Running`, and return a connected handle.
      *
-     * This is `create({ wait: false })` followed by `PendingSandbox.ready()`
-     * polling every `pollInterval` seconds, with `requestTimeout` as the wait
-     * budget, in one call. The returned `Sandbox` auto-terminates when
-     * `terminate()` is called.
+     * The create waits on the server, which answers as soon as the sandbox
+     * runs, with `requestTimeout` as the wait budget. The returned `Sandbox`
+     * auto-terminates when `terminate()` is called.
      *
      * **When the wait runs out the sandbox is not deleted.** A `SandboxPending`
      * is thrown with the sandbox id, and the sandbox keeps its place in the

package/dist/index.d.ts

@@ -67,6 +67,8 @@ interface NativeSandboxProxyClient {
 }
 interface NativeSandboxClient {
     createSandbox(requestJson: string): Promise<TracedJson>;
+    /** Blocking create for createAndConnect: a `running`, `failed` or `timeout` record. */
+    createSandboxAndWait(requestJson: string): Promise<TracedJson>;
     /** Wait-free create (`wait: false`, ADR 0086). */
     createSandboxNoWait(requestJson: string): Promise<TracedJson>;
     /** Poll the sandbox until it leaves `pending` or the budget runs out; resolves with the last `SandboxInfo`. */
@@ -89,6 +91,7 @@ interface NativeSandboxClient {
     createSnapshot(sandboxId: string, snapshotType?: string | null): Promise<TracedJson>;
     getSnapshot(snapshotId: string): Promise<TracedJson>;
     listSnapshots(): Promise<TracedJson>;
+    listSandboxSnapshots(sandboxId: string): Promise<TracedJson>;
     deleteSnapshot(snapshotId: string): Promise<string>;
     createPool(requestJson: string): Promise<TracedJson>;
     getPool(poolId: string): Promise<TracedJson>;
@@ -896,7 +899,10 @@ interface CreateAndConnectOptions extends CreateSandboxOptions {
      * false: throw `SandboxPending` and leave the sandbox queued.
      */
     cancelOnTimeout?: boolean;
-    /** Seconds between readiness polls. Default: 2. */
+    /**
+     * Seconds between readiness polls once the server's own wait has run out.
+     * Default: 2.
+     */
     pollInterval?: number;
 }
 /**
@@ -1114,8 +1120,8 @@ declare class Sandbox {
      *
      * Covers both fresh sandbox creation and restore-from-snapshot (set
      * `snapshotId`). With `wait` unset or `true` it blocks until the sandbox
-     * is `Running`: the create is sent with `wait: false` and the sandbox is
-     * polled every two seconds, with `requestTimeout` as the wait budget.
+     * is `Running`: the server waits and answers as soon as it runs, with
+     * `requestTimeout` as the wait budget.
      *
      * With `wait: false` it returns a {@link PendingSandbox} at once:
      * `pending.ready()` waits for it, `pending.status()` looks at it, and
@@ -1629,6 +1635,11 @@ declare class SandboxClient {
     getSnapshot(snapshotId: string): Promise<Traced<SnapshotInfo>>;
     /** List all snapshots in the namespace. */
     listSnapshots(): Promise<Traced<SnapshotInfo[]>>;
+    /**
+     * List snapshots taken from one sandbox (its ID or name), from the
+     * sandbox's own listing rather than the whole namespace's.
+     */
+    listSandboxSnapshots(sandboxId: string): Promise<Traced<SnapshotInfo[]>>;
     /** Delete a snapshot by ID. */
     deleteSnapshot(snapshotId: string): Promise<void>;
     /**
@@ -1663,10 +1674,9 @@ declare class SandboxClient {
     /**
      * Create a sandbox, wait for it to reach `Running`, and return a connected handle.
      *
-     * This is `create({ wait: false })` followed by `PendingSandbox.ready()`
-     * polling every `pollInterval` seconds, with `requestTimeout` as the wait
-     * budget, in one call. The returned `Sandbox` auto-terminates when
-     * `terminate()` is called.
+     * The create waits on the server, which answers as soon as the sandbox
+     * runs, with `requestTimeout` as the wait budget. The returned `Sandbox`
+     * auto-terminates when `terminate()` is called.
      *
      * **When the wait runs out the sandbox is not deleted.** A `SandboxPending`
      * is thrown with the sandbox id, and the sandbox keeps its place in the

package/dist/index.js

@@ -46,7 +46,7 @@ var init_defaults = __esm({
   "src/defaults.ts"() {
     "use strict";
     init_esm_shims();
-    SDK_VERSION = "0.5.156";
+    SDK_VERSION = "0.5.158";
     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";
@@ -509,7 +509,7 @@ var init_native_worker_client = __esm({
       }
     };
     runtimeKey = /* @__PURE__ */ Symbol.for(
-      `tensorlake.native.worker.${false ? "source" : "0.5.156"}.v1`
+      `tensorlake.native.worker.${false ? "source" : "0.5.158"}.v1`
     );
     runtimes = globalThis;
   }
@@ -4085,9 +4085,7 @@ var init_sandbox = __esm({
        */
       async listSnapshots() {
         const client = this.requireLifecycleClient("listSnapshots");
-        const all = await client.listSnapshots();
-        const filtered = all.filter((s) => s.sandboxId === this.lifecycleIdentifier);
-        return Object.assign(filtered, { traceId: all.traceId });
+        return client.listSandboxSnapshots(this.lifecycleIdentifier);
       }
       /** Close the proxy connection. The sandbox keeps running. */
       close() {
@@ -4635,6 +4633,18 @@ function validateResizeWait(options) {
     throw new SandboxError("pollInterval must be finite and positive");
   }
 }
+function parseSnapshotList({ traceId, json }) {
+  const parsed = JSON.parse(json);
+  if (parsed !== null && (typeof parsed !== "object" || Array.isArray(parsed))) {
+    throw new SandboxError("Invalid snapshot list response: expected an object");
+  }
+  const records = parsed?.snapshots ?? [];
+  if (!Array.isArray(records)) {
+    throw new SandboxError("Invalid snapshot list response: snapshots must be an array");
+  }
+  const snapshots = records.map((s) => parseSnapshot(s));
+  return Object.assign(snapshots, { traceId });
+}
 var DEFAULT_WAIT_POLL_INTERVAL_SEC, GPU_MODELS, SandboxClient, RESERVED_SANDBOX_MANAGEMENT_PORT;
 var init_client = __esm({
   "src/client.ts"() {
@@ -5304,19 +5314,18 @@ var init_client = __esm({
       }
       /** List all snapshots in the namespace. */
       async listSnapshots() {
-        const { traceId, json } = await callNative(
-          () => this.native.listSnapshots()
+        return parseSnapshotList(
+          await callNative(() => this.native.listSnapshots())
+        );
+      }
+      /**
+       * List snapshots taken from one sandbox (its ID or name), from the
+       * sandbox's own listing rather than the whole namespace's.
+       */
+      async listSandboxSnapshots(sandboxId) {
+        return parseSnapshotList(
+          await callNative(() => this.native.listSandboxSnapshots(sandboxId))
         );
-        const parsed = JSON.parse(json);
-        if (parsed !== null && (typeof parsed !== "object" || Array.isArray(parsed))) {
-          throw new SandboxError("Invalid snapshot list response: expected an object");
-        }
-        const records = parsed?.snapshots ?? [];
-        if (!Array.isArray(records)) {
-          throw new SandboxError("Invalid snapshot list response: snapshots must be an array");
-        }
-        const snapshots = records.map((s) => parseSnapshot(s));
-        return Object.assign(snapshots, { traceId });
       }
       /** Delete a snapshot by ID. */
       async deleteSnapshot(snapshotId) {
@@ -5463,10 +5472,9 @@ var init_client = __esm({
       /**
        * Create a sandbox, wait for it to reach `Running`, and return a connected handle.
        *
-       * This is `create({ wait: false })` followed by `PendingSandbox.ready()`
-       * polling every `pollInterval` seconds, with `requestTimeout` as the wait
-       * budget, in one call. The returned `Sandbox` auto-terminates when
-       * `terminate()` is called.
+       * The create waits on the server, which answers as soon as the sandbox
+       * runs, with `requestTimeout` as the wait budget. The returned `Sandbox`
+       * auto-terminates when `terminate()` is called.
        *
        * **When the wait runs out the sandbox is not deleted.** A `SandboxPending`
        * is thrown with the sandbox id, and the sandbox keeps its place in the
@@ -5488,11 +5496,10 @@ var init_client = __esm({
           pool_id: options?.poolId
         });
         const requestedName = options?.poolId != null ? null : options?.name ?? null;
-        let sandboxId;
-        let traceId;
         const createStart = nowMs();
+        let result;
         if (options?.poolId != null) {
-          const result = await requestClient.claim(options.poolId, {
+          result = await requestClient.claim(options.poolId, {
             fileSystems: options.fileSystems
           });
           logSdkTiming("sandbox.create", "claim_response", createStart, {
@@ -5500,84 +5507,55 @@ var init_client = __esm({
             status: result.status,
             server_trace_id: result.traceId
           });
-          if (result.status === "running" /* RUNNING */) {
-            const explicitProxyUrl = options?.proxyUrl ?? explicitProxyUrlOverride() ?? void 0;
-            const selectedProxyUrl = await this.native.selectSandboxProxyUrl(
-              result.sandboxId,
-              result.sandboxUrl ?? null,
-              result.ingressEndpoint ?? null,
-              explicitProxyUrl ?? null
-            );
-            const sandbox2 = requestClient.connect(
-              result.sandboxId,
-              selectedProxyUrl,
-              result.routingHint,
-              requestTimeout,
-              explicitProxyUrl
-            );
-            sandbox2._setOwner(requestClient);
-            sandbox2.traceId = result.traceId;
-            sandbox2._setLifecycleIdentifier(result.sandboxId);
-            sandbox2._setName(result.name ?? requestedName);
-            logSdkTiming("sandbox.create", "complete", opStart, {
-              sandbox_id: result.sandboxId,
-              status: "running" /* RUNNING */,
-              server_trace_id: result.traceId
-            });
-            return sandbox2;
-          }
-          if (result.status === "suspended" /* SUSPENDED */ || result.status === "terminated" /* TERMINATED */ || result.status === "failed" /* FAILED */) {
-            throw startupFailure(result.sandboxId, result.status, {
-              errorDetails: result.errorDetails,
-              terminationReason: result.terminationReason ?? result.reason
-            });
-          }
-          sandboxId = result.sandboxId;
-          traceId = result.traceId;
         } else {
-          const pending = await requestClient.requestPending(options, {
-            ownsSandbox: true
+          const body = _SandboxClient.buildCreateRequestBody({
+            ...options,
+            wait: void 0
           });
+          result = await requestClient.tracedJson(
+            () => requestClient.native.createSandboxAndWait(JSON.stringify(body)),
+            "sandboxId"
+          );
           logSdkTiming("sandbox.create", "create_response", createStart, {
-            sandbox_id: pending.sandboxId,
-            status: pending.state,
-            server_trace_id: pending.traceId
+            sandbox_id: result.sandboxId,
+            status: result.status,
+            server_trace_id: result.traceId
+          });
+        }
+        if (result.status === "running" /* RUNNING */) {
+          const explicitProxyUrl = options?.proxyUrl ?? explicitProxyUrlOverride() ?? void 0;
+          const selectedProxyUrl = await this.native.selectSandboxProxyUrl(
+            result.sandboxId,
+            result.sandboxUrl ?? null,
+            result.ingressEndpoint ?? null,
+            explicitProxyUrl ?? null
+          );
+          const sandbox2 = requestClient.connect(
+            result.sandboxId,
+            selectedProxyUrl,
+            result.routingHint,
+            requestTimeout,
+            explicitProxyUrl
+          );
+          sandbox2._setOwner(requestClient);
+          sandbox2.traceId = result.traceId;
+          sandbox2._setLifecycleIdentifier(result.sandboxId);
+          sandbox2._setName(result.name ?? requestedName);
+          logSdkTiming("sandbox.create", "complete", opStart, {
+            sandbox_id: result.sandboxId,
+            status: "running" /* RUNNING */,
+            server_trace_id: result.traceId
+          });
+          return sandbox2;
+        }
+        if (result.status === "suspended" /* SUSPENDED */ || result.status === "terminated" /* TERMINATED */ || result.status === "failed" /* FAILED */) {
+          throw startupFailure(result.sandboxId, result.status, {
+            errorDetails: result.errorDetails,
+            terminationReason: result.terminationReason ?? result.reason
           });
-          sandboxId = pending.sandboxId;
-          traceId = pending.traceId;
-          if (pending.state === "running" /* RUNNING */) {
-            const explicitProxyUrl = options?.proxyUrl ?? explicitProxyUrlOverride() ?? void 0;
-            const selectedProxyUrl = await this.native.selectSandboxProxyUrl(
-              sandboxId,
-              pending.sandboxUrl ?? null,
-              pending.ingressEndpoint ?? null,
-              explicitProxyUrl ?? null
-            );
-            const sandbox2 = requestClient.connect(
-              sandboxId,
-              selectedProxyUrl,
-              pending.routingHint,
-              requestTimeout,
-              explicitProxyUrl
-            );
-            sandbox2._setOwner(requestClient);
-            sandbox2.traceId = traceId;
-            sandbox2._setLifecycleIdentifier(sandboxId);
-            sandbox2._setName(pending.name ?? requestedName);
-            logSdkTiming("sandbox.create", "complete", opStart, {
-              sandbox_id: sandboxId,
-              status: "running" /* RUNNING */,
-              server_trace_id: traceId
-            });
-            return sandbox2;
-          }
-          if (pending.state === "terminated" /* TERMINATED */ || pending.state === "failed" /* FAILED */) {
-            throw startupFailure(sandboxId, pending.state, {
-              errorDetails: pending.errorDetails,
-              terminationReason: pending.terminationReason ?? pending.reason
-            });
-          }
         }
+        const sandboxId = result.sandboxId;
+        const traceId = result.traceId;
         const remaining = Math.max(0, (deadline - Date.now()) / 1e3);
         const observed = await requestClient.waitForSandbox(
           sandboxId,