tensorlake 0.5.131 → 0.5.133

package/dist/sandbox-image.cjs

@@ -44,12 +44,12 @@ var init_cjs_shims = __esm({
 });
 
 // src/defaults.ts
-var SDK_VERSION, API_URL, API_KEY, NAMESPACE, SANDBOX_PROXY_URL, DEFAULT_HTTP_TIMEOUT_MS, MAX_RETRIES, RETRY_BACKOFF_MS, RETRYABLE_STATUS_CODES;
+var SDK_VERSION, API_URL, API_KEY, NAMESPACE, SANDBOX_PROXY_URL, DEFAULT_HTTP_TIMEOUT_MS, MAX_RETRIES, RETRY_BACKOFF_MS;
 var init_defaults = __esm({
   "src/defaults.ts"() {
     "use strict";
     init_cjs_shims();
-    SDK_VERSION = "0.5.131";
+    SDK_VERSION = "0.5.133";
     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";
@@ -57,33 +57,10 @@ var init_defaults = __esm({
     DEFAULT_HTTP_TIMEOUT_MS = 3e5;
     MAX_RETRIES = 3;
     RETRY_BACKOFF_MS = 500;
-    RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
   }
 });
 
 // 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);
-}
 function formatErrorDetails(errorDetails) {
   if (errorDetails == null) return void 0;
   if (typeof errorDetails === "string") {
@@ -197,360 +174,464 @@ var init_errors = __esm({
   }
 });
 
-// src/sdk-timings.ts
-function sdkTimingsEnabled() {
-  const value = process.env[SDK_TIMINGS_ENV_VAR];
-  return value === "1" || value === "true" || value === "yes";
-}
-function sdkTimingPayloadsEnabled() {
-  const value = process.env[SDK_TIMING_PAYLOADS_ENV_VAR];
-  return value === "1" || value === "true" || value === "yes";
-}
-function nowMs() {
-  return performance.now();
-}
-function logSdkTiming(op, phase, startedAt, fields = {}) {
-  if (!sdkTimingsEnabled()) return;
-  logSdkTimingEvent(op, phase, {
-    ...fields,
-    duration_ms: Math.round((nowMs() - startedAt) * 100) / 100
-  });
-}
-function logSdkTimingEvent(op, phase, fields = {}) {
-  if (!sdkTimingsEnabled()) return;
-  const parts = [
-    "[tensorlake:sdk-timing]",
-    `op=${op}`,
-    `phase=${phase}`
-  ];
-  for (const [key, value] of Object.entries(fields)) {
-    if (value == null) continue;
-    parts.push(`${key}=${formatSdkTimingValue(value)}`);
-  }
-  console.error(parts.join(" "));
-}
-function formatSdkTimingValue(value) {
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
+// src/native-worker-protocol.ts
+var cancelNativeCall, closeNativeHandle;
+var init_native_worker_protocol = __esm({
+  "src/native-worker-protocol.ts"() {
+    "use strict";
+    init_cjs_shims();
+    cancelNativeCall = /* @__PURE__ */ Symbol.for("tensorlake.native.cancel.v1");
+    closeNativeHandle = /* @__PURE__ */ Symbol.for("tensorlake.native.close.v1");
   }
-  if (/^[A-Za-z0-9_./:@-]+$/.test(value)) {
-    return value;
+});
+
+// src/url.ts
+function trimTrailingSlashes(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function resolveProxyTarget(proxyUrl, sandboxId) {
+  try {
+    const parsed = new URL(proxyUrl);
+    const host = parsed.hostname;
+    if (host === "localhost" || host === "127.0.0.1") {
+      return {
+        baseUrl: trimTrailingSlashes(proxyUrl),
+        hostHeader: `${sandboxId}.local`,
+        sandboxIdHeader: void 0
+      };
+    }
+    const port = parsed.port ? `:${parsed.port}` : "";
+    return {
+      baseUrl: `${parsed.protocol}//${host}${port}`,
+      hostHeader: void 0,
+      sandboxIdHeader: sandboxId
+    };
+  } catch {
+    return {
+      baseUrl: `${trimTrailingSlashes(proxyUrl)}/${sandboxId}`,
+      hostHeader: void 0,
+      sandboxIdHeader: void 0
+    };
   }
-  return JSON.stringify(value);
 }
-var SDK_TIMINGS_ENV_VAR, SDK_TIMING_PAYLOADS_ENV_VAR;
-var init_sdk_timings = __esm({
-  "src/sdk-timings.ts"() {
+var init_url = __esm({
+  "src/url.ts"() {
     "use strict";
     init_cjs_shims();
-    SDK_TIMINGS_ENV_VAR = "TENSORLAKE_SDK_TIMINGS";
-    SDK_TIMING_PAYLOADS_ENV_VAR = "TENSORLAKE_SDK_TIMING_PAYLOADS";
+    init_defaults();
   }
 });
 
-// src/http.ts
-function withTraceId(value, traceId) {
-  if (value == null) {
-    return { traceId };
-  }
-  return Object.assign(value, { traceId });
+// src/native-worker-client.ts
+function createWorkerBinding(runtime) {
+  return {
+    NativeCloudClient: class {
+      constructor(...args) {
+        return runtime.handle("NativeCloudClient", args);
+      }
+    },
+    NativeSandboxClient: class {
+      constructor(...args) {
+        return runtime.handle("NativeSandboxClient", args);
+      }
+    },
+    NativeSandboxProxyClient: class {
+      constructor(...args) {
+        return runtime.handle("NativeSandboxProxyClient", args);
+      }
+    },
+    NativeRepositoryClient: class {
+      constructor(...args) {
+        return runtime.handle("NativeRepositoryClient", args);
+      }
+    },
+    validateManagedName: (name) => runtime.call(void 0, "validateManagedName", [name])
+  };
 }
-function hasHeader(headers, name) {
-  const lowered = name.toLowerCase();
-  return Object.keys(headers).some((key) => key.toLowerCase() === lowered);
+function workerBinding() {
+  return createWorkerBinding(
+    runtimes[runtimeKey] ??= new NativeWorkerClient()
+  );
 }
-function normalizeRequestBody(body) {
-  if (body == null) {
-    return void 0;
-  }
-  if (body instanceof Uint8Array) {
-    return Uint8Array.from(body).buffer;
-  }
-  return body;
+function releaseNativeHandle(handle) {
+  handle?.[closeNativeHandle]?.();
 }
-function stripPathPayload(path3) {
-  const queryStart = path3.search(/[?#]/);
-  return queryStart === -1 ? path3 : path3.slice(0, queryStart);
+var import_node_module, import_node_worker_threads, NativeWorkerClient, runtimeKey, runtimes;
+var init_native_worker_client = __esm({
+  "src/native-worker-client.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_module = require("module");
+    import_node_worker_threads = require("worker_threads");
+    init_native_worker_protocol();
+    init_url();
+    NativeWorkerClient = class {
+      constructor(workerPath = () => (0, import_node_module.createRequire)(importMetaUrl).resolve(
+        "tensorlake/internal/native-worker"
+      )) {
+        this.workerPath = workerPath;
+      }
+      worker;
+      nextId = 1;
+      registered = /* @__PURE__ */ new Set();
+      pending = /* @__PURE__ */ new Map();
+      finalizers = new FinalizationRegistry(
+        (id) => this.release(id)
+      );
+      handle(kind, args, parent) {
+        const handle = { id: this.nextId++, kind, args, parent };
+        this.finalizers.register(handle, handle.id);
+        let closed = false;
+        return new Proxy(
+          {},
+          {
+            get: (_target, method) => {
+              if (method === "then") return void 0;
+              if (method === closeNativeHandle)
+                return () => {
+                  closed = true;
+                  this.release(handle.id);
+                };
+              if (method === "connectProxy")
+                return (...proxyArgs) => {
+                  if (closed) throw new Error("Tensorlake native client is closed");
+                  return this.handle("NativeSandboxProxyClient", proxyArgs, handle);
+                };
+              if (method === "baseUrl")
+                return () => resolveProxyTarget(String(args[0]), String(args[1])).baseUrl;
+              if (typeof method !== "string") return void 0;
+              return (...callArgs) => {
+                if (closed)
+                  return Promise.reject(
+                    new Error("Tensorlake native client is closed")
+                  );
+                const emit = typeof callArgs.at(-1) === "function" ? callArgs.pop() : void 0;
+                return this.call(handle, method, callArgs, emit);
+              };
+            }
+          }
+        );
+      }
+      call(handle, method, args, emit) {
+        const id = this.nextId++;
+        let worker;
+        const promise = new Promise((resolve, reject) => {
+          try {
+            worker = this.getWorker();
+            this.pending.set(id, { resolve, reject, emit, handle });
+            worker.ref();
+            if (handle) this.register(handle, worker);
+            this.send(worker, {
+              type: "call",
+              id,
+              handleId: handle?.id,
+              method,
+              args,
+              stream: !!emit
+            });
+          } catch (error) {
+            this.pending.delete(id);
+            this.unrefIfIdle();
+            reject(error);
+          }
+        });
+        promise[cancelNativeCall] = () => {
+          const pending = this.pending.get(id);
+          if (pending && worker) {
+            pending.emit = void 0;
+            this.send(worker, { type: "cancel", id });
+          }
+        };
+        return promise;
+      }
+      getWorker() {
+        if (this.worker) return this.worker;
+        const worker = new import_node_worker_threads.Worker(this.workerPath(), {
+          // The bundled worker needs no application loaders or telemetry preloads.
+          // NODE_OPTIONS is parsed independently of execArgv by Node.
+          execArgv: [],
+          env: { ...process.env, NODE_OPTIONS: "" },
+          name: "tensorlake-native"
+        });
+        this.worker = worker;
+        worker.on("message", (message) => {
+          const pending = this.pending.get(message.id);
+          if (!pending || this.worker !== worker) return;
+          if (message.type === "event") {
+            Promise.resolve().then(() => pending.emit?.(message.value)).then(
+              () => {
+                if (this.worker === worker)
+                  this.send(worker, { type: "ack", id: message.id });
+              },
+              (error) => {
+                this.send(worker, { type: "cancel", id: message.id });
+                pending.reject(error);
+              }
+            );
+            return;
+          }
+          this.pending.delete(message.id);
+          if (message.type === "error") {
+            const error = new Error(message.error.message);
+            error.name = message.error.name;
+            error.stack = message.error.stack ?? error.stack;
+            pending.reject(error);
+          } else {
+            pending.resolve(message.value);
+          }
+          this.unrefIfIdle();
+        });
+        const fail = (error) => {
+          if (this.worker !== worker) return;
+          this.worker = void 0;
+          this.registered.clear();
+          for (const pending of this.pending.values()) pending.reject(error);
+          this.pending.clear();
+          void worker.terminate();
+        };
+        worker.on("error", fail);
+        worker.on("messageerror", fail);
+        worker.on(
+          "exit",
+          (code) => fail(
+            new Error(
+              `Tensorlake native worker exited (${code}); in-flight operations were not retried`
+            )
+          )
+        );
+        worker.unref();
+        return worker;
+      }
+      register(handle, worker) {
+        if (this.registered.has(handle.id)) return;
+        if (handle.parent) this.register(handle.parent, worker);
+        this.send(worker, {
+          type: "create",
+          handle: { id: handle.id, kind: handle.kind, args: handle.args },
+          parentId: handle.parent?.id
+        });
+        this.registered.add(handle.id);
+      }
+      release(handleId) {
+        if (this.worker && this.registered.delete(handleId))
+          this.send(this.worker, { type: "release", handleId });
+      }
+      send(worker, message) {
+        worker.postMessage(message);
+      }
+      unrefIfIdle() {
+        if (this.pending.size === 0) this.worker?.unref();
+      }
+    };
+    runtimeKey = /* @__PURE__ */ Symbol.for(
+      `tensorlake.native.worker.${false ? "source" : "0.5.133"}.v1`
+    );
+    runtimes = globalThis;
+  }
+});
+
+// src/native-sandbox.ts
+function loadNativeSandboxBinding() {
+  return cachedBinding ??= workerBinding();
 }
-function throwMappedError(status, body, path3) {
-  let message = body;
+function parseNativeError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (!message) return null;
   try {
-    const parsed = JSON.parse(body);
-    if (parsed.message) message = parsed.message;
-    else if (parsed.error) message = parsed.error;
+    const parsed = JSON.parse(message);
+    if (parsed && typeof parsed.category === "string") {
+      return {
+        category: parsed.category,
+        status: typeof parsed.status === "number" ? parsed.status : null,
+        message: typeof parsed.message === "string" ? parsed.message : message
+      };
+    }
   } catch {
   }
+  return null;
+}
+function translateNativeError(error, context) {
+  const payload = parseNativeError(error);
+  if (!payload) {
+    if (error instanceof Error) return error;
+    return new SandboxError(String(error));
+  }
+  const { category, status, message } = payload;
+  if (category === "connection") {
+    return new SandboxConnectionError(message, { cause: error });
+  }
   if (status === 404) {
-    if (path3.includes("sandbox-pools") || path3.includes("pools")) {
-      const match = path3.match(/sandbox-pools\/([^/]+)/);
-      if (match) throw new PoolNotFoundError(match[1]);
+    if (context?.notFoundKind === "pool" && context.poolId) {
+      return new PoolNotFoundError(context.poolId);
     }
-    if (path3.includes("sandboxes")) {
-      const match = path3.match(/sandboxes\/([^/]+)/);
-      if (match) throw new SandboxNotFoundError(match[1]);
+    if (context?.notFoundKind === "sandbox" && context.sandboxId) {
+      return new SandboxNotFoundError(context.sandboxId);
     }
-    throw new RemoteAPIError(404, message);
+    return new RemoteAPIError(404, message);
   }
-  if (status === 409) {
-    if (path3.includes("sandbox-pools") || path3.includes("pools")) {
-      const match = path3.match(/sandbox-pools\/([^/]+)/);
-      if (match) throw new PoolInUseError(match[1], message);
-    }
+  if (status === 409 && context?.poolId) {
+    return new PoolInUseError(context.poolId, message);
   }
-  throw new RemoteAPIError(status, message);
+  if (typeof status === "number") {
+    return new RemoteAPIError(status, message);
+  }
+  return new SandboxError(message);
 }
-function anySignal(signals) {
-  const controller = new AbortController();
-  for (const signal of signals) {
-    if (signal.aborted) {
-      controller.abort(signal.reason);
-      return controller.signal;
-    }
-    signal.addEventListener("abort", () => controller.abort(signal.reason), {
-      once: true
-    });
+async function callNative(fn, context) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw translateNativeError(error, context);
   }
-  return controller.signal;
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+async function* nativeEventStream(start, context, signal) {
+  if (signal?.aborted) return;
+  const queue = [];
+  let wake;
+  let finished = false;
+  let stopped = false;
+  let failure;
+  const notify = () => {
+    const resolve = wake;
+    wake = void 0;
+    resolve?.();
+  };
+  const emit = (value) => {
+    if (stopped) return Promise.resolve();
+    return new Promise((consumed) => {
+      queue.push({ value, consumed });
+      notify();
+    });
+  };
+  let call;
+  const onAbort = () => {
+    stopped = true;
+    call?.[cancelNativeCall]?.();
+    notify();
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    call = start(emit);
+    void call.catch((error) => {
+      failure = error;
+    }).finally(() => {
+      finished = true;
+      notify();
+    });
+    while (!stopped) {
+      const event = queue.shift();
+      if (event) {
+        try {
+          yield JSON.parse(event.value);
+        } finally {
+          event.consumed();
+        }
+      } else if (finished) {
+        break;
+      } else {
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+    }
+    if (!stopped && failure !== void 0) throw translateNativeError(failure, context);
+  } finally {
+    stopped = true;
+    signal?.removeEventListener("abort", onAbort);
+    call?.[cancelNativeCall]?.();
+    for (const event of queue) event.consumed();
+  }
 }
-var import_undici, REQUEST_TIMEOUT_HEADER, HttpClient;
-var init_http = __esm({
-  "src/http.ts"() {
+var cachedBinding;
+var init_native_sandbox = __esm({
+  "src/native-sandbox.ts"() {
     "use strict";
     init_cjs_shims();
-    import_undici = require("undici");
-    init_defaults();
     init_errors();
-    init_sdk_timings();
-    REQUEST_TIMEOUT_HEADER = "X-Tensorlake-Request-Timeout-Ms";
-    (0, import_undici.setGlobalDispatcher)(
-      new import_undici.Agent({
-        keepAliveTimeout: 6e4,
-        allowH2: true
-      })
-    );
-    HttpClient = class _HttpClient {
-      baseUrl;
-      headers;
-      maxRetries;
-      retryBackoffMs;
-      timeoutMs;
-      abortController = null;
+    init_native_worker_client();
+    init_native_worker_protocol();
+  }
+});
+
+// src/native-cloud.ts
+async function serializeRequest(method, path3, options) {
+  const headers = { ...options?.headers };
+  let body = options?.body;
+  if (options?.json !== void 0) {
+    body = JSON.stringify(options.json);
+    if (!Object.keys(headers).some((key) => key.toLowerCase() === "content-type")) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  const request = {
+    method,
+    path: path3,
+    headersJson: JSON.stringify(headers),
+    statusOnlyCodes: [...options?.statusOnlyCodes ?? []]
+  };
+  if (body instanceof FormData) {
+    request.parts = [];
+    for (const [name, value] of body.entries()) {
+      request.parts.push(typeof value === "string" ? { name, data: Buffer.from(value) } : { name, data: Buffer.from(await value.arrayBuffer()), filename: value.name, contentType: value.type || "application/octet-stream" });
+    }
+  } else if (body !== void 0) {
+    if (body instanceof Blob) request.body = Buffer.from(await body.arrayBuffer());
+    else if (typeof body === "string") request.body = Buffer.from(body);
+    else if (body instanceof ArrayBuffer) request.body = Buffer.from(new Uint8Array(body));
+    else request.body = Buffer.from(body);
+  }
+  return request;
+}
+var NativeCloudTransport;
+var init_native_cloud = __esm({
+  "src/native-cloud.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_native_sandbox();
+    init_native_worker_client();
+    NativeCloudTransport = class {
       constructor(options) {
-        const url = options.baseUrl;
-        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 === 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}`;
-        }
-        if (options.organizationId) {
-          this.headers["X-Forwarded-Organization-Id"] = options.organizationId;
-        }
-        if (options.projectId) {
-          this.headers["X-Forwarded-Project-Id"] = options.projectId;
-        }
-        if (options.hostHeader) {
-          this.headers["Host"] = options.hostHeader;
-        }
-        if (options.sandboxIdHeader) {
-          this.headers["X-Tensorlake-Sandbox-Id"] = options.sandboxIdHeader;
+        this.options = options;
+        if (!Number.isSafeInteger(options.maxRetries) || options.maxRetries < 0 || options.maxRetries > 4294967295) {
+          throw new RangeError("maxRetries must be a non-negative 32-bit integer");
         }
-        if (options.routingHint) {
-          this.headers["X-Tensorlake-Route-Hint"] = options.routingHint;
+        if (!Number.isFinite(options.retryBackoffMs) || options.retryBackoffMs < 0) {
+          throw new RangeError("retryBackoffMs must be a non-negative finite number");
         }
       }
+      native;
+      closed = false;
+      client() {
+        if (this.closed) throw new Error("Tensorlake native client is closed");
+        if (this.native) return this.native;
+        const ctor = loadNativeSandboxBinding().NativeCloudClient;
+        if (!ctor) throw new Error("Native binding does not export NativeCloudClient; rebuild with 'npm run build:native'");
+        return this.native = new ctor(JSON.stringify(this.options));
+      }
       close() {
-        this.abortController?.abort();
-        this.abortController = null;
-      }
-      /** Make a JSON request, returning the parsed response body. */
-      async requestJson(method, path3, options) {
-        const response = await this.requestResponse(method, path3, {
-          json: options?.body,
-          headers: options?.headers,
-          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;
-        return withTraceId(data, response.traceId);
-      }
-      /** Make a request returning raw bytes. */
-      async requestBytes(method, path3, options) {
-        const headers = { ...options?.headers ?? {} };
-        if (options?.contentType) {
-          headers["Content-Type"] = options.contentType;
-        }
-        const response = await this.requestResponse(method, path3, {
-          body: options?.body,
-          headers,
-          signal: options?.signal
-        });
-        const buffer = await response.arrayBuffer();
-        return withTraceId(new Uint8Array(buffer), response.traceId);
-      }
-      /** Make a request and return the response body as an SSE stream. */
-      async requestStream(method, path3, options) {
-        const response = await this.requestResponse(method, path3, {
-          json: options?.json,
-          headers: { Accept: "text/event-stream" },
-          signal: options?.signal
-        });
-        if (!response.body) {
-          throw new RemoteAPIError(
-            response.status,
-            "No response body for SSE stream"
-          );
-        }
-        return withTraceId(response.body, response.traceId);
+        this.closed = true;
+        releaseNativeHandle(this.native ?? null);
+        this.native = void 0;
       }
-      /** Make a request and return the raw Response. */
       async requestResponse(method, path3, options) {
-        const headers = {
-          ...this.headers,
-          ...options?.headers ?? {}
-        };
-        const hasJsonBody = options?.json !== void 0;
-        if (hasJsonBody && !hasHeader(headers, "Content-Type")) {
-          headers["Content-Type"] = "application/json";
-        }
-        const body = hasJsonBody ? JSON.stringify(options?.json) : normalizeRequestBody(options?.body);
-        const { response, traceId } = await this.doFetch(
-          method,
-          path3,
-          body,
-          headers,
-          options?.signal,
-          options?.allowHttpErrors ?? false,
-          options?.retryableStatusCodes ?? RETRYABLE_STATUS_CODES,
-          options?.allowedErrorStatusCodes ?? /* @__PURE__ */ new Set()
-        );
-        return withTraceId(response, traceId);
-      }
-      static makeTraceparent() {
-        const randomHex = (bytes) => Array.from(crypto.getRandomValues(new Uint8Array(bytes))).map((b) => b.toString(16).padStart(2, "0")).join("");
-        const traceId = randomHex(16);
-        const spanId = randomHex(8);
-        return { traceparent: `00-${traceId}-${spanId}-01`, traceId };
-      }
-      async doFetch(method, path3, body, headers, signal, allowHttpErrors = false, retryableStatusCodes = RETRYABLE_STATUS_CODES, allowedErrorStatusCodes = /* @__PURE__ */ new Set()) {
-        const url = `${this.baseUrl}${path3}`;
-        const { traceparent, traceId } = _HttpClient.makeTraceparent();
-        headers["traceparent"] = traceparent;
-        let lastError;
-        const operationStart = nowMs();
-        const timingPath = sdkTimingPayloadsEnabled() ? path3 : stripPathPayload(path3);
-        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
-          if (attempt > 0) {
-            const delay = this.retryBackoffMs * Math.pow(2, attempt - 1);
-            logSdkTimingEvent("http.request", "retry_sleep_start", {
-              method,
-              path: timingPath,
-              attempt,
-              delay_ms: delay,
-              server_trace_id: traceId
-            });
-            await sleep(delay);
-          }
-          this.abortController = new AbortController();
-          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;
-          const attemptStart = nowMs();
-          try {
-            const response = await (0, import_undici.fetch)(url, {
-              method,
-              headers,
-              body,
-              signal: combinedSignal
-            });
-            if (timeoutId != null) clearTimeout(timeoutId);
-            logSdkTiming("http.request", "headers", attemptStart, {
-              method,
-              path: timingPath,
-              status: response.status,
-              attempt,
-              server_trace_id: traceId
-            });
-            if (response.ok) {
-              logSdkTiming("http.request", "complete", operationStart, {
-                method,
-                path: timingPath,
-                status: response.status,
-                attempts: attempt + 1,
-                server_trace_id: traceId
-              });
-              return { response, traceId };
-            }
-            if (retryableStatusCodes.has(response.status) && attempt < this.maxRetries) {
-              lastError = new RemoteAPIError(
-                response.status,
-                await response.text().catch(() => "")
-              );
-              logSdkTimingEvent("http.request", "retryable_status", {
-                method,
-                path: timingPath,
-                status: response.status,
-                attempt,
-                server_trace_id: traceId
-              });
-              continue;
-            }
-            if (allowHttpErrors || allowedErrorStatusCodes.has(response.status)) {
-              logSdkTiming("http.request", "complete", operationStart, {
-                method,
-                path: timingPath,
-                status: response.status,
-                attempts: attempt + 1,
-                server_trace_id: traceId
-              });
-              return { response, traceId };
-            }
-            const errorBody = await response.text().catch(() => "");
-            throwMappedError(response.status, errorBody, path3);
-          } catch (err) {
-            if (timeoutId != null) clearTimeout(timeoutId);
-            if (err instanceof RemoteAPIError || err instanceof SandboxNotFoundError || err instanceof PoolNotFoundError || err instanceof PoolInUseError) {
-              throw err;
-            }
-            if (signal?.aborted && !timedOut) {
-              throw new SandboxConnectionError("request aborted by caller", {
-                cause: err
-              });
-            }
-            lastError = err instanceof Error ? err : new Error(String(err));
-            logSdkTiming("http.request", "error", attemptStart, {
-              method,
-              path: timingPath,
-              attempt,
-              server_trace_id: traceId,
-              error: timedOut ? `request timed out after ${this.timeoutMs}ms` : describeError(err)
-            });
-            if (attempt >= this.maxRetries) {
-              const detail = timedOut ? `request timed out after ${this.timeoutMs}ms` : describeError(err);
-              throw new SandboxConnectionError(detail, { cause: err });
-            }
-          }
-        }
-        throw new SandboxConnectionError(
-          lastError ? describeError(lastError) : "request failed",
-          { cause: lastError }
+        const request = await serializeRequest(method, path3, options);
+        const raw = await callNative(() => this.client().request(request));
+        const response = new Response(
+          [204, 205, 304].includes(raw.status) ? null : Uint8Array.from(raw.data).buffer,
+          { status: raw.status, headers: JSON.parse(raw.headersJson) }
         );
+        return Object.assign(response, { traceId: raw.traceId });
+      }
+      async requestJson(method, path3) {
+        const response = await this.requestResponse(method, path3);
+        const text = await response.text();
+        const value = text ? JSON.parse(text) : null;
+        return Object.assign(value ?? {}, { traceId: response.traceId });
+      }
+      async *stream(method, path3, signal) {
+        if (signal?.aborted) return;
+        const request = await serializeRequest(method, path3, { headers: { Accept: "text/event-stream" } });
+        yield* nativeEventStream((emit) => this.client().stream(request, emit), void 0, signal);
       }
     };
   }
@@ -606,65 +687,6 @@ var init_models = __esm({
   }
 });
 
-// src/sse.ts
-async function* parseSSEMessages(stream, signal) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (true) {
-      if (signal?.aborted) break;
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const parts = buffer.split(/\r?\n\r?\n/);
-      buffer = parts.pop() ?? "";
-      for (const part of parts) {
-        const lines = part.split(/\r?\n/);
-        const dataLines = [];
-        let event;
-        let id;
-        for (const line of lines) {
-          if (!line || line.startsWith(":")) continue;
-          const separator = line.indexOf(":");
-          const field = separator === -1 ? line : line.slice(0, separator);
-          let value2 = separator === -1 ? "" : line.slice(separator + 1);
-          if (value2.startsWith(" ")) {
-            value2 = value2.slice(1);
-          }
-          if (field === "data") {
-            dataLines.push(value2);
-          } else if (field === "event") {
-            event = value2;
-          } else if (field === "id") {
-            id = value2;
-          }
-        }
-        if (dataLines.length > 0 || event || id) {
-          yield { data: dataLines.join("\n"), event, id };
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-}
-async function* parseSSEStream(stream, signal) {
-  for await (const message of parseSSEMessages(stream, signal)) {
-    if (!message.data) continue;
-    try {
-      yield JSON.parse(message.data);
-    } catch {
-    }
-  }
-}
-var init_sse = __esm({
-  "src/sse.ts"() {
-    "use strict";
-    init_cjs_shims();
-  }
-});
-
 // src/cloud-client.ts
 function secretFromMetadata(metadata) {
   return {
@@ -726,7 +748,7 @@ function createApplicationBuildForm(request, imageContexts) {
   }
   return form;
 }
-function trimTrailingSlashes(value) {
+function trimTrailingSlashes2(value) {
   return value.endsWith("/") ? value.slice(0, -1) : value;
 }
 function nextRequestPath(next) {
@@ -764,11 +786,10 @@ var init_cloud_client = __esm({
     init_cjs_shims();
     import_nanoid = require("nanoid");
     init_defaults();
-    init_http();
+    init_native_cloud();
     init_models();
-    init_sse();
     CloudClient = class _CloudClient {
-      http;
+      transport;
       organizationId;
       projectId;
       namespace;
@@ -776,20 +797,22 @@ var init_cloud_client = __esm({
         this.organizationId = options?.organizationId;
         this.projectId = options?.projectId;
         this.namespace = options?.namespace ?? NAMESPACE;
-        this.http = new HttpClient({
+        this.transport = new NativeCloudTransport({
           baseUrl: options?.apiUrl ?? API_URL,
           apiKey: options?.apiKey ?? API_KEY,
           organizationId: this.organizationId,
           projectId: this.projectId,
           maxRetries: options?.maxRetries ?? MAX_RETRIES,
-          retryBackoffMs: options?.retryBackoffMs ?? RETRY_BACKOFF_MS
+          retryBackoffMs: options?.retryBackoffMs ?? RETRY_BACKOFF_MS,
+          timeoutMs: DEFAULT_HTTP_TIMEOUT_MS,
+          userAgent: `tensorlake-typescript-sdk/${SDK_VERSION}`
         });
       }
       static forCloud(options) {
         return new _CloudClient(options);
       }
       close() {
-        this.http.close();
+        this.transport.close();
       }
       async upsertApplication(manifest, codeZip, upgradeRunningRequests = false) {
         const applicationManifest = { ...manifest };
@@ -817,18 +840,18 @@ var init_cloud_client = __esm({
           "upgrade_requests_to_latest_code",
           String(upgradeRunningRequests)
         );
-        await this.http.requestResponse("POST", this.namespacePath("applications"), {
+        await this.transport.requestResponse("POST", this.namespacePath("applications"), {
           body: form
         });
       }
       async deleteApplication(applicationName) {
-        await this.http.requestResponse(
+        await this.transport.requestResponse(
           "DELETE",
           this.namespacePath(`applications/${encodeURIComponent(applicationName)}`)
         );
       }
       async deleteSandboxImage(imageName) {
-        await this.http.requestResponse(
+        await this.transport.requestResponse(
           "DELETE",
           this.namespacePath(`sandbox-images/${encodeURIComponent(imageName)}`)
         );
@@ -847,10 +870,10 @@ var init_cloud_client = __esm({
           options?.organizationId,
           options?.projectId
         );
-        const response = await this.http.requestResponse(
+        const response = await this.transport.requestResponse(
           "GET",
           `${base}/by-name/${encodeURIComponent(imageName)}`,
-          { allowedErrorStatusCodes: /* @__PURE__ */ new Set([404]) }
+          { statusOnlyCodes: /* @__PURE__ */ new Set([404]) }
         );
         if (response.status === 404) {
           return null;
@@ -872,7 +895,7 @@ var init_cloud_client = __esm({
         let path3 = `${base}?pageSize=100`;
         const templates = [];
         while (path3 !== null) {
-          const page = await this.http.requestJson(
+          const page = await this.transport.requestJson(
             "GET",
             path3
           );
@@ -885,7 +908,7 @@ var init_cloud_client = __esm({
         return templates;
       }
       async applications() {
-        const raw = await this.http.requestJson(
+        const raw = await this.transport.requestJson(
           "GET",
           this.namespacePath("applications")
         );
@@ -894,7 +917,7 @@ var init_cloud_client = __esm({
         );
       }
       async applicationManifest(applicationName) {
-        const raw = await this.http.requestJson(
+        const raw = await this.transport.requestJson(
           "GET",
           this.namespacePath(`applications/${encodeURIComponent(applicationName)}`)
         );
@@ -904,10 +927,10 @@ var init_cloud_client = __esm({
         const path3 = this.namespacePath(
           `applications/${encodeURIComponent(applicationName)}`
         );
-        const response = inputs.length === 0 ? await this.http.requestResponse("POST", path3, {
+        const response = inputs.length === 0 ? await this.transport.requestResponse("POST", path3, {
           body: new Uint8Array(),
           headers: { Accept: "application/json" }
-        }) : inputs.length === 1 && inputs[0].name === "0" ? await this.http.requestResponse("POST", path3, {
+        }) : inputs.length === 1 && inputs[0].name === "0" ? await this.transport.requestResponse("POST", path3, {
           body: toRequestBody(inputs[0].data),
           headers: {
             Accept: "application/json",
@@ -922,13 +945,13 @@ var init_cloud_client = __esm({
         return requestId;
       }
       async waitOnRequestCompletion(applicationName, requestId) {
-        const stream = await this.http.requestStream(
+        const stream = this.transport.stream(
           "GET",
           this.namespacePath(
             `applications/${encodeURIComponent(applicationName)}/requests/${encodeURIComponent(requestId)}/progress`
           )
         );
-        for await (const event of parseSSEStream(stream)) {
+        for await (const event of stream) {
           if (Object.prototype.hasOwnProperty.call(event, "RequestFinished")) {
             return;
           }
@@ -936,7 +959,7 @@ var init_cloud_client = __esm({
         throw new Error("progress stream ended before request completion");
       }
       async requestMetadata(applicationName, requestId) {
-        const raw = await this.http.requestJson(
+        const raw = await this.transport.requestJson(
           "GET",
           this.namespacePath(
             `applications/${encodeURIComponent(applicationName)}/requests/${encodeURIComponent(requestId)}`
@@ -945,7 +968,7 @@ var init_cloud_client = __esm({
         return fromSnakeKeys(raw);
       }
       async requestOutput(applicationName, requestId) {
-        const response = await this.http.requestResponse(
+        const response = await this.transport.requestResponse(
           "GET",
           this.namespacePath(
             `applications/${encodeURIComponent(applicationName)}/requests/${encodeURIComponent(requestId)}/output`
@@ -963,7 +986,7 @@ var init_cloud_client = __esm({
           options?.organizationId,
           options?.projectId
         );
-        const raw = await this.http.requestJson("GET", base);
+        const raw = await this.transport.requestJson("GET", base);
         const pageSize = Math.max(0, options?.pageSize ?? 100);
         return Object.assign(
           {
@@ -978,7 +1001,7 @@ var init_cloud_client = __esm({
           options?.organizationId,
           options?.projectId
         );
-        const raw = await this.http.requestJson(
+        const raw = await this.transport.requestJson(
           "GET",
           `${base}/${encodeURIComponent(secretId)}`
         );
@@ -1003,24 +1026,24 @@ var init_cloud_client = __esm({
           options?.organizationId,
           options?.projectId
         );
-        await this.http.requestResponse(
+        await this.transport.requestResponse(
           "DELETE",
           `${base}/${encodeURIComponent(secretId)}`
         );
       }
       async upsertSecret(base, secret) {
-        let response = await this.http.requestResponse("POST", base, {
+        let response = await this.transport.requestResponse("POST", base, {
           json: secret,
           headers: { "Idempotency-Key": (0, import_nanoid.nanoid)() },
-          allowedErrorStatusCodes: /* @__PURE__ */ new Set([409])
+          statusOnlyCodes: /* @__PURE__ */ new Set([409])
         });
         if (response.status === 409) {
           const prefix = base.slice(0, -"/secrets".length);
-          const existing = await this.http.requestJson(
+          const existing = await this.transport.requestJson(
             "GET",
             `${prefix}/secret-names/${encodeURIComponent(secret.name)}`
           );
-          response = await this.http.requestResponse(
+          response = await this.transport.requestResponse(
             "POST",
             `${base}/${encodeURIComponent(existing.id)}/versions`,
             {
@@ -1046,9 +1069,9 @@ var init_cloud_client = __esm({
           new Blob([toBlobPart(request.buildContext)]),
           "context.tar.gz"
         );
-        const response = await this.http.requestResponse(
+        const response = await this.transport.requestResponse(
           "PUT",
-          `${trimTrailingSlashes(buildServicePath)}/builds`,
+          `${trimTrailingSlashes2(buildServicePath)}/builds`,
           { body: form }
         );
         const raw = await parseJsonResponse(response);
@@ -1056,48 +1079,48 @@ var init_cloud_client = __esm({
       }
       async createApplicationBuild(buildServicePath, request, imageContexts) {
         const form = createApplicationBuildForm(request, imageContexts);
-        const response = await this.http.requestResponse(
+        const response = await this.transport.requestResponse(
           "POST",
-          trimTrailingSlashes(buildServicePath),
+          trimTrailingSlashes2(buildServicePath),
           { body: form }
         );
         const raw = await parseJsonResponse(response);
         return fromSnakeKeys(raw);
       }
       async applicationBuildInfo(buildServicePath, applicationBuildId) {
-        const raw = await this.http.requestJson(
+        const raw = await this.transport.requestJson(
           "GET",
-          `${trimTrailingSlashes(buildServicePath)}/${encodeURIComponent(applicationBuildId)}`
+          `${trimTrailingSlashes2(buildServicePath)}/${encodeURIComponent(applicationBuildId)}`
         );
         return fromSnakeKeys(raw);
       }
       async cancelApplicationBuild(buildServicePath, applicationBuildId) {
-        const raw = await this.http.requestJson(
+        const raw = await this.transport.requestJson(
           "POST",
-          `${trimTrailingSlashes(buildServicePath)}/${encodeURIComponent(applicationBuildId)}/cancel`
+          `${trimTrailingSlashes2(buildServicePath)}/${encodeURIComponent(applicationBuildId)}/cancel`
         );
         return fromSnakeKeys(raw);
       }
       async buildInfo(buildServicePath, buildId) {
-        const raw = await this.http.requestJson(
+        const raw = await this.transport.requestJson(
           "GET",
-          `${trimTrailingSlashes(buildServicePath)}/builds/${encodeURIComponent(buildId)}`
+          `${trimTrailingSlashes2(buildServicePath)}/builds/${encodeURIComponent(buildId)}`
         );
         return fromSnakeKeys(raw);
       }
       async cancelBuild(buildServicePath, buildId) {
-        await this.http.requestResponse(
+        await this.transport.requestResponse(
           "POST",
-          `${trimTrailingSlashes(buildServicePath)}/builds/${encodeURIComponent(buildId)}/cancel`
+          `${trimTrailingSlashes2(buildServicePath)}/builds/${encodeURIComponent(buildId)}/cancel`
         );
       }
       async *streamBuildLogs(buildServicePath, buildId, signal) {
-        const stream = await this.http.requestStream(
+        const stream = this.transport.stream(
           "GET",
-          `${trimTrailingSlashes(buildServicePath)}/builds/${encodeURIComponent(buildId)}/logs`,
-          { signal }
+          `${trimTrailingSlashes2(buildServicePath)}/builds/${encodeURIComponent(buildId)}/logs`,
+          signal
         );
-        for await (const event of parseSSEStream(stream, signal)) {
+        for await (const event of stream) {
           yield fromSnakeKeys(event);
         }
       }
@@ -1110,7 +1133,7 @@ var init_cloud_client = __esm({
             input.name
           );
         }
-        return this.http.requestResponse("POST", path3, {
+        return this.transport.requestResponse("POST", path3, {
           body: form,
           headers: { Accept: "application/json" }
         });
@@ -1119,10 +1142,10 @@ var init_cloud_client = __esm({
         return `/v1/namespaces/${encodeURIComponent(this.namespace)}/${subpath.replace(/^\/+/, "")}`;
       }
       async existingApplicationPublicEndpointId(applicationName) {
-        const response = await this.http.requestResponse(
+        const response = await this.transport.requestResponse(
           "GET",
           this.namespacePath(`applications/${encodeURIComponent(applicationName)}`),
-          { allowedErrorStatusCodes: /* @__PURE__ */ new Set([404]) }
+          { statusOnlyCodes: /* @__PURE__ */ new Set([404]) }
         );
         if (response.status === 404) {
           return void 0;
@@ -1390,7 +1413,7 @@ function nativePackageName(platform = process.platform, arch = process.arch, opt
 function loadNative() {
   const target = nativeTargetId();
   const bindingPath = nativeBindingPath();
-  const require2 = (0, import_node_module.createRequire)(importMetaUrl);
+  const require2 = (0, import_node_module2.createRequire)(importMetaUrl);
   if (fs.existsSync(bindingPath)) return require2(bindingPath);
   const packageName = nativePackageName();
   if (!packageName) {
@@ -1409,14 +1432,14 @@ function loadNative() {
   }
   return require2(packageEntry);
 }
-var import_libc, fs, import_node_module, import_node_path, import_node_url, NATIVE_PACKAGES, cachedLinuxLibc;
+var import_libc, fs, import_node_module2, import_node_path, import_node_url, NATIVE_PACKAGES, cachedLinuxLibc;
 var init_native_binding = __esm({
   "src/native-binding.ts"() {
     "use strict";
     init_cjs_shims();
     import_libc = __toESM(require_libc(), 1);
     fs = __toESM(require("fs"), 1);
-    import_node_module = require("module");
+    import_node_module2 = require("module");
     import_node_path = __toESM(require("path"), 1);
     import_node_url = require("url");
     NATIVE_PACKAGES = {