tensorlake 0.5.38 → 0.5.40

package/dist/index.js

@@ -19,7 +19,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.38";
+    SDK_VERSION = "0.5.40";
     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";
@@ -139,364 +139,154 @@ 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)}`);
+// src/native-sandbox.ts
+import { createRequire } from "module";
+function resolveRequire() {
+  if (typeof module !== "undefined" && module.exports != null && typeof __require !== "undefined") {
+    return __require;
   }
-  console.error(parts.join(" "));
+  return createRequire(import.meta.url);
 }
-function formatSdkTimingValue(value) {
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
+function loadNativeSandboxBinding() {
+  if (cachedBinding) return cachedBinding;
+  if (cachedBindingError) throw cachedBindingError;
+  try {
+    const { loadNative } = resolveRequire()("../lib/runtime.cjs");
+    const binding = loadNative();
+    if (binding == null || typeof binding.NativeSandboxClient !== "function" || typeof binding.NativeSandboxProxyClient !== "function") {
+      throw new SandboxError(
+        "native binding does not export the sandbox clients; rebuild with 'npm run build:native'"
+      );
+    }
+    cachedBinding = binding;
+    return cachedBinding;
+  } catch (error) {
+    cachedBindingError = error instanceof Error ? error : new Error(String(error));
+    throw cachedBindingError;
   }
-  if (/^[A-Za-z0-9_./:@-]+$/.test(value)) {
-    return value;
+}
+function parseNativeError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "";
+  if (!message) return null;
+  try {
+    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 JSON.stringify(value);
+  return null;
 }
-var SDK_TIMINGS_ENV_VAR, SDK_TIMING_PAYLOADS_ENV_VAR;
-var init_sdk_timings = __esm({
-  "src/sdk-timings.ts"() {
-    "use strict";
-    SDK_TIMINGS_ENV_VAR = "TENSORLAKE_SDK_TIMINGS";
-    SDK_TIMING_PAYLOADS_ENV_VAR = "TENSORLAKE_SDK_TIMING_PAYLOADS";
+function translateNativeError(error, context) {
+  const payload = parseNativeError(error);
+  if (!payload) {
+    if (error instanceof Error) return error;
+    return new SandboxError(String(error));
   }
-});
-
-// src/http.ts
-import {
-  Agent,
-  fetch as undiciFetch,
-  setGlobalDispatcher
-} from "undici";
-function withTraceId(value, traceId) {
-  if (value == null) {
-    return { traceId };
+  const { category, status, message } = payload;
+  if (category === "connection") {
+    return new SandboxConnectionError(message, { cause: error });
   }
-  return Object.assign(value, { traceId });
-}
-function hasHeader(headers, name) {
-  const lowered = name.toLowerCase();
-  return Object.keys(headers).some((key) => key.toLowerCase() === lowered);
-}
-function normalizeRequestBody(body) {
-  if (body == null) {
-    return void 0;
+  if (status === 404) {
+    if (context?.notFoundKind === "pool" && context.poolId) {
+      return new PoolNotFoundError(context.poolId);
+    }
+    if (context?.notFoundKind === "sandbox" && context.sandboxId) {
+      return new SandboxNotFoundError(context.sandboxId);
+    }
+    return new RemoteAPIError(404, message);
   }
-  if (body instanceof Uint8Array) {
-    return Uint8Array.from(body).buffer;
+  if (status === 409 && context?.poolId) {
+    return new PoolInUseError(context.poolId, message);
   }
-  return body;
-}
-function stripPathPayload(path2) {
-  const queryStart = path2.search(/[?#]/);
-  return queryStart === -1 ? path2 : path2.slice(0, queryStart);
+  if (typeof status === "number") {
+    return new RemoteAPIError(status, message);
+  }
+  return new SandboxError(message);
 }
-function throwMappedError(status, body, path2) {
-  let message = body;
+async function callNative(fn, context) {
   try {
-    const parsed = JSON.parse(body);
-    if (parsed.message) message = parsed.message;
-    else if (parsed.error) message = parsed.error;
-  } catch {
+    return await fn();
+  } catch (error) {
+    throw translateNativeError(error, context);
   }
-  if (status === 404) {
-    if (path2.includes("sandbox-pools") || path2.includes("pools")) {
-      const match = path2.match(/sandbox-pools\/([^/]+)/);
-      if (match) throw new PoolNotFoundError(match[1]);
+}
+async function* nativeEventStream(start, context, signal) {
+  const queue = [];
+  let wake = null;
+  let finished = false;
+  let failure = null;
+  const notify = () => {
+    if (wake) {
+      const w = wake;
+      wake = null;
+      w();
     }
-    if (path2.includes("sandboxes")) {
-      const match = path2.match(/sandboxes\/([^/]+)/);
-      if (match) throw new SandboxNotFoundError(match[1]);
+  };
+  const emit = (eventJson) => {
+    queue.push(eventJson);
+    notify();
+  };
+  const onAbort = () => notify();
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const startPromise = start(emit).catch((error) => {
+    failure = error;
+  }).finally(() => {
+    finished = true;
+    notify();
+  });
+  try {
+    while (true) {
+      if (queue.length > 0) {
+        yield JSON.parse(queue.shift());
+        continue;
+      }
+      if (signal?.aborted) break;
+      if (finished) break;
+      await new Promise((resolve) => {
+        wake = resolve;
+      });
     }
-    throw new RemoteAPIError(404, message);
-  }
-  if (status === 409) {
-    if (path2.includes("sandbox-pools") || path2.includes("pools")) {
-      const match = path2.match(/sandbox-pools\/([^/]+)/);
-      if (match) throw new PoolInUseError(match[1], message);
+    if (failure != null) {
+      throw translateNativeError(failure, context);
     }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    void startPromise.catch(() => {
+    });
   }
-  throw new RemoteAPIError(status, message);
 }
-function anySignal(signals) {
-  const controller = new AbortController();
-  for (const signal of signals) {
-    if (signal.aborted) {
-      controller.abort(signal.reason);
-      return controller.signal;
+function assembleCommandResult(events) {
+  const stdoutLines = [];
+  const stderrLines = [];
+  let exitCode = -1;
+  for (const eventJson of events) {
+    const raw = JSON.parse(eventJson);
+    if (typeof raw.line === "string") {
+      if (raw.stream === "stderr") {
+        stderrLines.push(raw.line);
+      } else {
+        stdoutLines.push(raw.line);
+      }
+    } else if ("exit_code" in raw || "signal" in raw) {
+      if (typeof raw.exit_code === "number") {
+        exitCode = raw.exit_code;
+      } else if (typeof raw.signal === "number") {
+        exitCode = -raw.signal;
+      }
     }
-    signal.addEventListener("abort", () => controller.abort(signal.reason), {
-      once: true
-    });
   }
-  return controller.signal;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return { exitCode, stdout: stdoutLines.join("\n"), stderr: stderrLines.join("\n") };
 }
-var REQUEST_TIMEOUT_HEADER, HttpClient;
-var init_http = __esm({
-  "src/http.ts"() {
+var cachedBinding, cachedBindingError;
+var init_native_sandbox = __esm({
+  "src/native-sandbox.ts"() {
     "use strict";
-    init_defaults();
     init_errors();
-    init_sdk_timings();
-    REQUEST_TIMEOUT_HEADER = "X-Tensorlake-Request-Timeout-Ms";
-    setGlobalDispatcher(
-      new Agent({
-        keepAliveTimeout: 6e4,
-        allowH2: true
-      })
-    );
-    HttpClient = class _HttpClient {
-      baseUrl;
-      headers;
-      maxRetries;
-      retryBackoffMs;
-      timeoutMs;
-      abortController = null;
-      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;
-        }
-        if (options.routingHint) {
-          this.headers["X-Tensorlake-Route-Hint"] = options.routingHint;
-        }
-      }
-      close() {
-        this.abortController?.abort();
-        this.abortController = null;
-      }
-      /** Make a JSON request, returning the parsed response body. */
-      async requestJson(method, path2, options) {
-        const response = await this.requestResponse(method, path2, {
-          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, path2, options) {
-        const headers = { ...options?.headers ?? {} };
-        if (options?.contentType) {
-          headers["Content-Type"] = options.contentType;
-        }
-        const response = await this.requestResponse(method, path2, {
-          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, path2, options) {
-        const response = await this.requestResponse(method, path2, {
-          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);
-      }
-      /** Make a request and return the raw Response. */
-      async requestResponse(method, path2, 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,
-          path2,
-          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, 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;
-        let lastError;
-        const operationStart = nowMs();
-        const timingPath = sdkTimingPayloadsEnabled() ? path2 : stripPathPayload(path2);
-        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 undiciFetch(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, path2);
-          } 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 }
-        );
-      }
-    };
   }
 });
 
@@ -3005,71 +2795,63 @@ var init_desktop = __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();
-  }
+// src/sdk-timings.ts
+function sdkTimingsEnabled() {
+  const value = process.env[SDK_TIMINGS_ENV_VAR];
+  return value === "1" || value === "true" || value === "yes";
 }
-async function* parseSSEStream(stream, signal) {
-  for await (const message of parseSSEMessages(stream, signal)) {
-    if (!message.data) continue;
-    try {
-      yield JSON.parse(message.data);
-    } catch {
-    }
-  }
+function sdkTimingPayloadsEnabled() {
+  const value = process.env[SDK_TIMING_PAYLOADS_ENV_VAR];
+  return value === "1" || value === "true" || value === "yes";
 }
-var init_sse = __esm({
-  "src/sse.ts"() {
-    "use strict";
-  }
-});
-
-// src/url.ts
-function trimTrailingSlashes(url) {
-  return url.endsWith("/") ? url.slice(0, -1) : url;
+function nowMs() {
+  return performance.now();
 }
-function isLocalhost(apiUrl) {
-  try {
-    const parsed = new URL(apiUrl);
+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);
+  }
+  if (/^[A-Za-z0-9_./:@-]+$/.test(value)) {
+    return value;
+  }
+  return JSON.stringify(value);
+}
+var SDK_TIMINGS_ENV_VAR, SDK_TIMING_PAYLOADS_ENV_VAR;
+var init_sdk_timings = __esm({
+  "src/sdk-timings.ts"() {
+    "use strict";
+    SDK_TIMINGS_ENV_VAR = "TENSORLAKE_SDK_TIMINGS";
+    SDK_TIMING_PAYLOADS_ENV_VAR = "TENSORLAKE_SDK_TIMING_PAYLOADS";
+  }
+});
+
+// src/url.ts
+function trimTrailingSlashes(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function isLocalhost(apiUrl) {
+  try {
+    const parsed = new URL(apiUrl);
     return parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
   } catch {
     return false;
@@ -3123,24 +2905,6 @@ function sandboxUrlFromIngressEndpoint(ingressEndpoint, sandboxId, port = 9501)
   const label = port === 9501 ? sandboxId : `${port}-${sandboxId}`;
   return `${parsed.protocol}//${label}.${parsed.host}`;
 }
-function resolveSandboxLifecycleUrl(apiUrl) {
-  if (isLocalhost(apiUrl)) return apiUrl;
-  try {
-    const parsed = new URL(apiUrl);
-    if (parsed.hostname.startsWith("api.")) {
-      parsed.hostname = "sandbox." + parsed.hostname.slice(4);
-      return parsed.toString().replace(/\/$/, "");
-    }
-  } catch {
-  }
-  return apiUrl;
-}
-function lifecyclePath(path2, isLocal, namespace) {
-  if (isLocal) {
-    return `/v1/namespaces/${namespace}/${path2}`;
-  }
-  return `/${path2}`;
-}
 var init_url = __esm({
   "src/url.ts"() {
     "use strict";
@@ -3152,7 +2916,7 @@ var init_url = __esm({
 import WebSocket2 from "ws";
 function processUserPayload(user) {
   if (user == null) {
-    return DEFAULT_PROCESS_USER;
+    return void 0;
   }
   if (typeof user === "string" && user.trim() === "") {
     throw new SandboxError("process user must not be empty");
@@ -3182,32 +2946,24 @@ 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 DEFAULT_PROCESS_USER, SandboxProxyConnection, PTY_OP_DATA, PTY_OP_RESIZE, PTY_OP_READY, PTY_OP_EXIT, Pty, Sandbox;
+var SandboxProxyConnection, PTY_OP_DATA, PTY_OP_RESIZE, PTY_OP_READY, PTY_OP_EXIT, Pty, Sandbox;
 var init_sandbox = __esm({
   "src/sandbox.ts"() {
     "use strict";
     init_desktop();
     init_defaults();
     init_errors();
-    init_http();
+    init_native_sandbox();
     init_models();
     init_tunnel();
-    init_sse();
     init_sdk_timings();
     init_url();
-    DEFAULT_PROCESS_USER = "tl-user";
     SandboxProxyConnection = class {
       constructor(sandbox, options) {
         this.sandbox = sandbox;
         this.options = options;
         this.routingHint = options.routingHint;
-        this.http = this.configureProxy(
+        this.nativeProxy = this.configureProxy(
           options.proxyUrl ?? SANDBOX_PROXY_URL,
           options.sandboxId,
           options.routingHint
@@ -3216,7 +2972,7 @@ var init_sandbox = __esm({
       }
       baseUrl = "";
       wsHeaders = {};
-      http;
+      nativeProxy;
       resolveProxyInfo;
       resolvePromise = null;
       routingHint;
@@ -3239,9 +2995,11 @@ var init_sandbox = __esm({
           this.sandbox._setName(info.name ?? null);
           this.routingHint = this.routingHint ?? info.routingHint;
           const proxyUrl = info.ingressEndpoint ?? this.options.proxyUrl ?? SANDBOX_PROXY_URL;
-          const nextHttp = this.configureProxy(proxyUrl, info.sandboxId, this.routingHint);
-          this.http.close();
-          this.http = nextHttp;
+          this.nativeProxy = this.configureProxy(
+            proxyUrl,
+            info.sandboxId,
+            this.routingHint
+          );
           logSdkTiming("sandbox.proxy", "resolve_complete", resolveStart, {
             sandbox_id: info.sandboxId,
             server_trace_id: info.traceId,
@@ -3253,24 +3011,12 @@ var init_sandbox = __esm({
         });
         return this.resolvePromise;
       }
-      async requestJson(method, path2, options) {
-        await this.ensureResolved();
-        return this.http.requestJson(method, path2, options);
-      }
-      async requestBytes(method, path2, options) {
-        await this.ensureResolved();
-        return this.http.requestBytes(method, path2, options);
-      }
-      async requestStream(method, path2, options) {
-        await this.ensureResolved();
-        return this.http.requestStream(method, path2, options);
-      }
-      async requestResponse(method, path2, options) {
+      /** Await proxy resolution and return the Rust-backed proxy client. */
+      async client() {
         await this.ensureResolved();
-        return this.http.requestResponse(method, path2, options);
+        return this.nativeProxy;
       }
       close() {
-        this.http.close();
       }
       configureProxy(proxyUrl, sandboxId, routingHint) {
         const { baseUrl, hostHeader, sandboxIdHeader } = resolveProxyTarget(
@@ -3294,16 +3040,34 @@ var init_sandbox = __esm({
         if (sandboxIdHeader) {
           this.wsHeaders["X-Tensorlake-Sandbox-Id"] = sandboxIdHeader;
         }
-        return new HttpClient({
-          baseUrl,
-          apiKey: this.options.apiKey,
-          organizationId: this.options.organizationId,
-          projectId: this.options.projectId,
-          hostHeader,
-          sandboxIdHeader,
-          routingHint,
-          timeoutMs: this.options.requestTimeout != null ? secondsToMillis3(this.options.requestTimeout) : this.options.timeoutMs ?? null
-        });
+        if (this.options.nativeClient) {
+          return this.options.nativeClient.connectProxy(
+            proxyUrl,
+            sandboxId,
+            routingHint ?? null,
+            this.proxyRequestTimeoutSec()
+          );
+        }
+        const binding = loadNativeSandboxBinding();
+        return new binding.NativeSandboxProxyClient(
+          proxyUrl,
+          sandboxId,
+          this.options.apiKey ?? null,
+          this.options.organizationId ?? null,
+          this.options.projectId ?? null,
+          routingHint ?? null,
+          null,
+          this.proxyRequestTimeoutSec()
+        );
+      }
+      proxyRequestTimeoutSec() {
+        if (this.options.requestTimeout != null) {
+          return this.options.requestTimeout;
+        }
+        if (this.options.timeoutMs != null) {
+          return this.options.timeoutMs / 1e3;
+        }
+        return null;
       }
     };
     PTY_OP_DATA = 0;
@@ -3472,7 +3236,6 @@ var init_sandbox = __esm({
       sandboxId;
       traceId = null;
       proxy;
-      http;
       ownsSandbox = false;
       lifecycleClient = null;
       lifecycleIdentifier;
@@ -3481,7 +3244,6 @@ var init_sandbox = __esm({
         this.sandboxId = options.sandboxId;
         this.lifecycleIdentifier = options.sandboxId;
         this.proxy = new SandboxProxyConnection(this, options);
-        this.http = this.proxy;
       }
       get baseUrl() {
         return this.proxy.baseUrl;
@@ -3686,9 +3448,9 @@ var init_sandbox = __esm({
         const filtered = all.filter((s) => s.sandboxId === this.lifecycleIdentifier);
         return Object.assign(filtered, { traceId: all.traceId });
       }
-      /** Close the HTTP client. The sandbox keeps running. */
+      /** Close the proxy connection. The sandbox keeps running. */
       close() {
-        this.http.close();
+        this.proxy.close();
       }
       /** Terminate the sandbox and release all resources. */
       async terminate() {
@@ -3715,51 +3477,18 @@ var init_sandbox = __esm({
         if (options?.workingDir) body.working_dir = options.workingDir;
         if (options?.timeout != null) body.timeout = options.timeout;
         const user = processUserPayload(options?.user);
-        body.user = user;
+        if (user !== void 0) body.user = user;
         logSdkTimingEvent("sandbox.run", "start", {
           sandbox_id: this.sandboxId,
           command: sdkTimingPayloadsEnabled() ? command : void 0,
           command_length: command.length
         });
-        const requestStart = nowMs();
-        const sseStream = await this.http.requestStream(
-          "POST",
-          "/api/v1/processes/run",
-          { json: body }
+        const proxy = await this.proxy.client();
+        const { traceId, events } = await callNative(
+          () => proxy.runProcess(JSON.stringify(body)),
+          { sandboxId: this.sandboxId }
         );
-        const traceId = sseStream.traceId;
-        logSdkTiming("sandbox.run", "stream_headers", requestStart, {
-          sandbox_id: this.sandboxId,
-          server_trace_id: traceId,
-          command: sdkTimingPayloadsEnabled() ? command : void 0,
-          command_length: command.length
-        });
-        const stdoutLines = [];
-        const stderrLines = [];
-        let exitCode = -1;
-        const streamStart = nowMs();
-        for await (const raw of parseSSEStream(sseStream)) {
-          if (typeof raw.line === "string") {
-            if (raw.stream === "stderr") {
-              stderrLines.push(raw.line);
-            } else {
-              stdoutLines.push(raw.line);
-            }
-          } else if ("exit_code" in raw || "signal" in raw) {
-            if (typeof raw.exit_code === "number") {
-              exitCode = raw.exit_code;
-            } else if (typeof raw.signal === "number") {
-              exitCode = -raw.signal;
-            }
-          }
-        }
-        logSdkTiming("sandbox.run", "stream_complete", streamStart, {
-          sandbox_id: this.sandboxId,
-          server_trace_id: traceId,
-          command: sdkTimingPayloadsEnabled() ? command : void 0,
-          command_length: command.length,
-          exit_code: exitCode
-        });
+        const { exitCode, stdout, stderr } = assembleCommandResult(events);
         logSdkTiming("sandbox.run", "complete", opStart, {
           sandbox_id: this.sandboxId,
           server_trace_id: traceId,
@@ -3767,10 +3496,7 @@ var init_sandbox = __esm({
           command_length: command.length,
           exit_code: exitCode
         });
-        return Object.assign(
-          { exitCode, stdout: stdoutLines.join("\n"), stderr: stderrLines.join("\n") },
-          { traceId }
-        );
+        return Object.assign({ exitCode, stdout, stderr }, { traceId });
       }
       // --- Process management ---
       /**
@@ -3787,7 +3513,7 @@ var init_sandbox = __esm({
         if (options?.env != null) payload.env = options.env;
         if (options?.workingDir != null) payload.working_dir = options.workingDir;
         const user = processUserPayload(options?.user);
-        payload.user = user;
+        if (user !== void 0) payload.user = user;
         if (options?.stdinMode != null && options.stdinMode !== "closed" /* CLOSED */) {
           payload.stdin_mode = options.stdinMode;
         }
@@ -3802,97 +3528,101 @@ var init_sandbox = __esm({
         if (options?.healthCheck != null) {
           payload.health_check = toSnakeKeys(options.healthCheck);
         }
-        const raw = await this.http.requestJson(
-          "POST",
-          "/api/v1/processes",
-          { body: payload }
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(
+          () => proxy.startProcess(JSON.stringify(payload)),
+          { sandboxId: this.sandboxId }
         );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), { traceId });
       }
       /** List all processes (running and exited) tracked by the sandbox daemon. */
       async listProcesses() {
-        const raw = await this.http.requestJson(
-          "GET",
-          "/api/v1/processes"
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(() => proxy.listProcesses(), {
+          sandboxId: this.sandboxId
+        });
+        const parsed = JSON.parse(json);
+        const processes = (parsed.processes ?? []).map(
+          (p) => fromSnakeKeys(p)
         );
-        const processes = (raw.processes ?? []).map((p) => fromSnakeKeys(p));
-        return Object.assign(processes, { traceId: raw.traceId });
+        return Object.assign(processes, { traceId });
       }
       /** Get current status and metadata for a process by PID. */
       async getProcess(pid) {
-        const raw = await this.http.requestJson(
-          "GET",
-          `/api/v1/processes/${pid}`
-        );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(() => proxy.getProcess(pid), {
+          sandboxId: this.sandboxId
+        });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), { traceId });
       }
       /** Send SIGKILL to a process. */
       async killProcess(pid) {
-        await this.http.requestJson("DELETE", `/api/v1/processes/${pid}`);
+        const proxy = await this.proxy.client();
+        await callNative(() => proxy.killProcess(pid), { sandboxId: this.sandboxId });
       }
       /** Restart a managed process by PID. */
       async restartProcess(pid) {
-        const raw = await this.http.requestJson(
-          "POST",
-          `/api/v1/processes/${pid}/restart`
-        );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(() => proxy.restartProcess(pid), {
+          sandboxId: this.sandboxId
+        });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), { traceId });
       }
       /** Send an arbitrary signal to a process (e.g. `15` for SIGTERM, `9` for SIGKILL). */
       async sendSignal(pid, signal) {
-        const raw = await this.http.requestJson(
-          "POST",
-          `/api/v1/processes/${pid}/signal`,
-          { body: { signal } }
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(
+          () => proxy.sendSignal(pid, signal),
+          { sandboxId: this.sandboxId }
         );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), {
+          traceId
+        });
       }
       // --- Process I/O ---
       /** Write bytes to a process's stdin. The process must have been started with `stdinMode: StdinMode.PIPE`. */
       async writeStdin(pid, data) {
-        await this.http.requestBytes("POST", `/api/v1/processes/${pid}/stdin`, {
-          body: data,
-          contentType: "application/octet-stream"
+        const proxy = await this.proxy.client();
+        await callNative(() => proxy.writeStdin(pid, Buffer.from(data)), {
+          sandboxId: this.sandboxId
         });
       }
       /** Close a process's stdin pipe, signalling EOF to the process. */
       async closeStdin(pid) {
-        await this.http.requestJson("POST", `/api/v1/processes/${pid}/stdin/close`);
+        const proxy = await this.proxy.client();
+        await callNative(() => proxy.closeStdin(pid), { sandboxId: this.sandboxId });
       }
       /** Return all captured stdout lines produced so far by a process. */
       async getStdout(pid) {
-        const raw = await this.http.requestJson(
-          "GET",
-          `/api/v1/processes/${pid}/stdout`
-        );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(() => proxy.getStdout(pid), {
+          sandboxId: this.sandboxId
+        });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), { traceId });
       }
       /** Return all captured stderr lines produced so far by a process. */
       async getStderr(pid) {
-        const raw = await this.http.requestJson(
-          "GET",
-          `/api/v1/processes/${pid}/stderr`
-        );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(() => proxy.getStderr(pid), {
+          sandboxId: this.sandboxId
+        });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), { traceId });
       }
       /** Return all captured stdout+stderr lines produced so far by a process. */
       async getOutput(pid) {
-        const raw = await this.http.requestJson(
-          "GET",
-          `/api/v1/processes/${pid}/output`
-        );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(() => proxy.getOutput(pid), {
+          sandboxId: this.sandboxId
+        });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), { traceId });
       }
       // --- Streaming (SSE) ---
       /** Stream stdout events from a process until it exits. Yields one `OutputEvent` per line. */
       async *followStdout(pid, options) {
-        const stream = await this.http.requestStream(
-          "GET",
-          `/api/v1/processes/${pid}/stdout/follow`,
-          options
-        );
-        for await (const raw of parseSSEStream(
-          stream,
+        const proxy = await this.proxy.client();
+        for await (const raw of nativeEventStream(
+          (emit) => proxy.followStdout(pid, emit),
+          { sandboxId: this.sandboxId },
           options?.signal
         )) {
           yield fromSnakeKeys(raw);
@@ -3900,13 +3630,10 @@ var init_sandbox = __esm({
       }
       /** Stream stderr events from a process until it exits. Yields one `OutputEvent` per line. */
       async *followStderr(pid, options) {
-        const stream = await this.http.requestStream(
-          "GET",
-          `/api/v1/processes/${pid}/stderr/follow`,
-          options
-        );
-        for await (const raw of parseSSEStream(
-          stream,
+        const proxy = await this.proxy.client();
+        for await (const raw of nativeEventStream(
+          (emit) => proxy.followStderr(pid, emit),
+          { sandboxId: this.sandboxId },
           options?.signal
         )) {
           yield fromSnakeKeys(raw);
@@ -3914,13 +3641,10 @@ var init_sandbox = __esm({
       }
       /** Stream combined stdout+stderr events from a process until it exits. Yields one `OutputEvent` per line. */
       async *followOutput(pid, options) {
-        const stream = await this.http.requestStream(
-          "GET",
-          `/api/v1/processes/${pid}/output/follow`,
-          options
-        );
-        for await (const raw of parseSSEStream(
-          stream,
+        const proxy = await this.proxy.client();
+        for await (const raw of nativeEventStream(
+          (emit) => proxy.followOutput(pid, emit),
+          { sandboxId: this.sandboxId },
           options?.signal
         )) {
           yield fromSnakeKeys(raw);
@@ -3929,33 +3653,33 @@ var init_sandbox = __esm({
       // --- File operations ---
       /** Read a file from the sandbox and return its raw bytes. */
       async readFile(path2) {
-        return this.http.requestBytes(
-          "GET",
-          `/api/v1/files?path=${encodeURIComponent(path2)}`
-        );
+        const proxy = await this.proxy.client();
+        const { traceId, data } = await callNative(() => proxy.readFile(path2), {
+          sandboxId: this.sandboxId
+        });
+        return Object.assign(Uint8Array.from(data), { traceId });
       }
       /** Write raw bytes to a file in the sandbox, creating it if it does not exist. */
       async writeFile(path2, content) {
-        await this.http.requestBytes(
-          "PUT",
-          `/api/v1/files?path=${encodeURIComponent(path2)}`,
-          { body: content, contentType: "application/octet-stream" }
-        );
+        const proxy = await this.proxy.client();
+        await callNative(() => proxy.writeFile(path2, Buffer.from(content)), {
+          sandboxId: this.sandboxId
+        });
       }
       /** Delete a file from the sandbox. */
       async deleteFile(path2) {
-        await this.http.requestJson(
-          "DELETE",
-          `/api/v1/files?path=${encodeURIComponent(path2)}`
-        );
+        const proxy = await this.proxy.client();
+        await callNative(() => proxy.deleteFile(path2), { sandboxId: this.sandboxId });
       }
       /** List the contents of a directory in the sandbox. */
       async listDirectory(path2) {
-        const raw = await this.http.requestJson(
-          "GET",
-          `/api/v1/files/list?path=${encodeURIComponent(path2)}`
-        );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(() => proxy.listDirectory(path2), {
+          sandboxId: this.sandboxId
+        });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), {
+          traceId
+        });
       }
       // --- PTY ---
       /** Create an interactive PTY session. Returns a `sessionId` and `token` for WebSocket connection via `connectPty()`. */
@@ -3968,12 +3692,12 @@ var init_sandbox = __esm({
         if (options.args != null) payload.args = options.args;
         if (options.env != null) payload.env = options.env;
         if (options.workingDir != null) payload.working_dir = options.workingDir;
-        const raw = await this.http.requestJson(
-          "POST",
-          "/api/v1/pty",
-          { body: payload }
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(
+          () => proxy.createPtySession(JSON.stringify(payload)),
+          { sandboxId: this.sandboxId }
         );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), { traceId });
       }
       /** Create a PTY session and connect to it immediately. Cleans up the session if the WebSocket connection fails. */
       async createPty(options) {
@@ -3983,7 +3707,8 @@ var init_sandbox = __esm({
           return await this.connectPty(session.sessionId, session.token, { onData, onExit });
         } catch (error) {
           try {
-            await this.http.requestResponse("DELETE", `/api/v1/pty/${session.sessionId}`);
+            const proxy = await this.proxy.client();
+            await proxy.deletePtySession(session.sessionId);
           } catch {
           }
           throw error;
@@ -4003,7 +3728,8 @@ var init_sandbox = __esm({
             "X-PTY-Token": authToken
           },
           killSession: async () => {
-            await this.http.requestResponse("DELETE", `/api/v1/pty/${sessionId}`);
+            const proxy = await this.proxy.client();
+            await proxy.deletePtySession(sessionId);
           }
         });
         if (options?.onData) {
@@ -4091,19 +3817,19 @@ var init_sandbox = __esm({
       // --- Health ---
       /** Check the sandbox daemon health. */
       async health() {
-        const raw = await this.http.requestJson(
-          "GET",
-          "/api/v1/health"
-        );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(() => proxy.health(), {
+          sandboxId: this.sandboxId
+        });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), { traceId });
       }
       /** Get sandbox daemon info (version, uptime, process counts). */
       async daemonInfo() {
-        const raw = await this.http.requestJson(
-          "GET",
-          "/api/v1/info"
-        );
-        return Object.assign(fromSnakeKeys(raw), { traceId: raw.traceId });
+        const proxy = await this.proxy.client();
+        const { traceId, json } = await callNative(() => proxy.info(), {
+          sandboxId: this.sandboxId
+        });
+        return Object.assign(fromSnakeKeys(JSON.parse(json)), { traceId });
       }
     };
   }
@@ -4160,7 +3886,7 @@ async function readCloudInitBase64(cloudInit) {
 }
 function resolveRequestTimeoutMs(options) {
   if (options?.requestTimeout != null) {
-    return secondsToMillis4(options.requestTimeout);
+    return secondsToMillis3(options.requestTimeout);
   }
   if (options?.timeoutMs != null) {
     validateTimeoutMs(options.timeoutMs);
@@ -4168,7 +3894,7 @@ function resolveRequestTimeoutMs(options) {
   }
   return DEFAULT_HTTP_TIMEOUT_MS;
 }
-function secondsToMillis4(seconds) {
+function secondsToMillis3(seconds) {
   if (!Number.isFinite(seconds) || seconds <= 0) {
     throw new SandboxError("requestTimeout must be a positive number of seconds");
   }
@@ -4179,7 +3905,7 @@ function validateTimeoutMs(timeoutMs) {
     throw new SandboxError("timeoutMs must be a positive number of milliseconds");
   }
 }
-function sleep2(ms) {
+function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function snapshotStatusSatisfiesWaitCondition(status, waitUntil) {
@@ -4235,31 +3961,25 @@ function validateUserPort(port) {
 function dedupeAndSortPorts(ports) {
   return [...new Set(ports)].sort((a, b) => a - b);
 }
-var CREATE_SANDBOX_RETRYABLE_STATUS_CODES, CREATE_SANDBOX_ALLOWED_ERROR_STATUS_CODES, COPY_SANDBOX_ALLOWED_ERROR_STATUS_CODES, MAX_CLOUD_INIT_USER_DATA_BYTES, SandboxClient, RESERVED_SANDBOX_MANAGEMENT_PORT;
+var MAX_CLOUD_INIT_USER_DATA_BYTES, SandboxClient, RESERVED_SANDBOX_MANAGEMENT_PORT;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
     init_defaults();
     init_errors();
-    init_http();
+    init_native_sandbox();
     init_models();
     init_sandbox();
     init_sdk_timings();
     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]);
     MAX_CLOUD_INIT_USER_DATA_BYTES = 16 * 1024;
     SandboxClient = class _SandboxClient {
-      http;
+      native;
       apiUrl;
       apiKey;
       organizationId;
       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) {
@@ -4273,19 +3993,17 @@ var init_client = __esm({
         this.organizationId = options?.organizationId;
         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: this.maxRetries,
-          retryBackoffMs: this.retryBackoffMs,
-          timeoutMs: this.requestTimeoutMs
-        });
+        const binding = loadNativeSandboxBinding();
+        this.native = new binding.NativeSandboxClient(
+          this.apiUrl,
+          this.apiKey ?? null,
+          this.organizationId ?? null,
+          this.projectId ?? null,
+          this.namespace,
+          null,
+          this.requestTimeoutMs / 1e3
+        );
       }
       /** Create a client for the TensorLake cloud platform. */
       static forCloud(options) {
@@ -4308,13 +4026,12 @@ var init_client = __esm({
         });
       }
       close() {
-        this.http.close();
       }
       withRequestTimeout(requestTimeout) {
         if (requestTimeout == null) {
           return this;
         }
-        const timeoutMs = secondsToMillis4(requestTimeout);
+        const timeoutMs = secondsToMillis3(requestTimeout);
         if (timeoutMs === this.requestTimeoutMs) {
           return this;
         }
@@ -4325,17 +4042,24 @@ var init_client = __esm({
             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);
+      // --- Native marshalling helpers ---
+      /** Run a native JSON call and reshape it into a `Traced<T>`. */
+      async tracedJson(fn, idField, context) {
+        const { traceId, json } = await callNative(fn, context);
+        return Object.assign(fromSnakeKeys(JSON.parse(json), idField), {
+          traceId
+        });
+      }
+      /** Run a native JSON call and reshape it into a plain `T` (no trace id). */
+      async plainJson(fn, idField, context) {
+        const { json } = await callNative(fn, context);
+        return fromSnakeKeys(JSON.parse(json), idField);
       }
       // --- Sandbox CRUD ---
       /** Create a new sandbox. Returns immediately; the sandbox may still be starting. Use `createAndConnect()` for a blocking, ready-to-use handle. */
@@ -4361,36 +4085,27 @@ var init_client = __esm({
             deny_out: options?.denyOut ?? []
           };
         }
-        const raw = await this.http.requestJson(
-          "POST",
-          this.path("sandboxes"),
-          {
-            body,
-            retryableStatusCodes: CREATE_SANDBOX_RETRYABLE_STATUS_CODES,
-            allowedErrorStatusCodes: CREATE_SANDBOX_ALLOWED_ERROR_STATUS_CODES
-          }
+        return this.tracedJson(
+          () => this.native.createSandbox(JSON.stringify(body)),
+          "sandboxId"
         );
-        const result = fromSnakeKeys(raw, "sandboxId");
-        return Object.assign(result, { traceId: raw.traceId });
       }
       /** Get current state and metadata for a sandbox by ID. */
       async get(sandboxId) {
-        const raw = await this.http.requestJson(
-          "GET",
-          this.path(`sandboxes/${sandboxId}`)
+        return this.tracedJson(
+          () => this.native.getSandbox(sandboxId),
+          "sandboxId",
+          { sandboxId, notFoundKind: "sandbox" }
         );
-        return Object.assign(fromSnakeKeys(raw, "sandboxId"), { traceId: raw.traceId });
       }
       /** List all sandboxes in the namespace. */
       async list() {
-        const raw = await this.http.requestJson(
-          "GET",
-          this.path("sandboxes")
-        );
-        const sandboxes = (raw.sandboxes ?? []).map(
+        const { traceId, json } = await callNative(() => this.native.listSandboxes());
+        const parsed = JSON.parse(json);
+        const sandboxes = (parsed.sandboxes ?? []).map(
           (s) => fromSnakeKeys(s, "sandboxId")
         );
-        return Object.assign(sandboxes, { traceId: raw.traceId });
+        return Object.assign(sandboxes, { traceId });
       }
       /**
        * List archived (terminated) sandboxes in the namespace.
@@ -4399,37 +4114,30 @@ var init_client = __esm({
        * archived sandboxes store until the server-configured TTL expires.
        */
       async listArchived(options) {
-        const query = [];
-        if (options?.limit != null) {
-          query.push(`limit=${encodeURIComponent(String(options.limit))}`);
-        }
-        if (options?.cursor != null) {
-          query.push(`cursor=${encodeURIComponent(options.cursor)}`);
-        }
-        if (options?.direction != null) {
-          query.push(`direction=${encodeURIComponent(options.direction)}`);
-        }
-        const suffix = query.length ? `?${query.join("&")}` : "";
-        const raw = await this.http.requestJson("GET", this.path(`archived-sandboxes${suffix}`));
-        const sandboxes = (raw.sandboxes ?? []).map(
+        const { traceId, json } = await callNative(
+          () => this.native.listArchivedSandboxes(
+            options?.limit ?? null,
+            options?.cursor ?? null,
+            options?.direction ?? null
+          )
+        );
+        const parsed = JSON.parse(json);
+        const sandboxes = (parsed.sandboxes ?? []).map(
           (s) => fromSnakeKeys(s, "sandboxId")
         );
         const response = {
           sandboxes,
-          prevCursor: raw.prev_cursor,
-          nextCursor: raw.next_cursor
+          prevCursor: parsed.prev_cursor,
+          nextCursor: parsed.next_cursor
         };
-        return Object.assign(response, { traceId: raw.traceId });
+        return Object.assign(response, { traceId });
       }
       /** Get a single archived sandbox by id. */
       async getArchived(sandboxId) {
-        const raw = await this.http.requestJson(
-          "GET",
-          this.path(`archived-sandboxes/${encodeURIComponent(sandboxId)}`)
-        );
-        return Object.assign(
-          fromSnakeKeys(raw, "sandboxId"),
-          { traceId: raw.traceId }
+        return this.tracedJson(
+          () => this.native.getArchivedSandbox(sandboxId),
+          "sandboxId",
+          { sandboxId, notFoundKind: "sandbox" }
         );
       }
       /** Update sandbox properties such as name, exposed ports, and proxy auth settings. */
@@ -4445,12 +4153,11 @@ var init_client = __esm({
         if (Object.keys(body).length === 0) {
           throw new SandboxError("At least one sandbox update field must be provided.");
         }
-        const raw = await this.http.requestJson(
-          "PATCH",
-          this.path(`sandboxes/${sandboxId}`),
-          { body }
+        return this.tracedJson(
+          () => this.native.updateSandbox(sandboxId, JSON.stringify(body)),
+          "sandboxId",
+          { sandboxId, notFoundKind: "sandbox" }
         );
-        return Object.assign(fromSnakeKeys(raw, "sandboxId"), { traceId: raw.traceId });
       }
       /** Get the current proxy port settings for a sandbox. */
       async getPortAccess(sandboxId) {
@@ -4488,10 +4195,7 @@ var init_client = __esm({
       }
       /** Terminate and delete a sandbox. */
       async delete(sandboxId) {
-        await this.http.requestJson(
-          "DELETE",
-          this.path(`sandboxes/${sandboxId}`)
-        );
+        await callNative(() => this.native.deleteSandbox(sandboxId), { sandboxId, notFoundKind: "sandbox" });
       }
       /**
        * Suspend a named sandbox, preserving its state for later resume.
@@ -4500,18 +4204,9 @@ var init_client = __esm({
        * cannot. By default blocks until the sandbox is fully `Suspended`. Pass
        * `{ wait: false }` to return immediately after the request is sent
        * (fire-and-return); the server processes the suspend asynchronously.
-       *
-       * @param sandboxId - ID or name of the sandbox.
-       * @param options.wait - If `true` (default), poll until `Suspended`. Pass `false` to fire-and-return.
-       * @param options.timeout - Max seconds to wait when `wait=true` (default 300).
-       * @param options.pollInterval - Seconds between status polls when `wait=true` (default 1).
-       * @throws {SandboxError} If `wait=true` and the sandbox does not reach `Suspended` within `timeout`.
        */
       async suspend(sandboxId, options) {
-        await this.http.requestResponse(
-          "POST",
-          this.path(`sandboxes/${sandboxId}/suspend`)
-        );
+        await callNative(() => this.native.suspendSandbox(sandboxId), { sandboxId, notFoundKind: "sandbox" });
         if (options?.wait === false) return;
         const timeout = options?.timeout ?? 300;
         const pollInterval = options?.pollInterval ?? 1;
@@ -4522,7 +4217,7 @@ var init_client = __esm({
           if (info.status === "terminated" /* TERMINATED */) {
             throw new SandboxError(`Sandbox ${sandboxId} terminated while waiting for suspend`);
           }
-          await sleep2(pollInterval * 1e3);
+          await sleep(pollInterval * 1e3);
         }
         throw new SandboxError(`Sandbox ${sandboxId} did not suspend within ${timeout}s`);
       }
@@ -4532,18 +4227,9 @@ var init_client = __esm({
        * By default blocks until the sandbox is `Running` and routable. Pass
        * `{ wait: false }` to return immediately after the request is sent
        * (fire-and-return); the server processes the resume asynchronously.
-       *
-       * @param sandboxId - ID or name of the sandbox.
-       * @param options.wait - If `true` (default), poll until `Running`. Pass `false` to fire-and-return.
-       * @param options.timeout - Max seconds to wait when `wait=true` (default 300).
-       * @param options.pollInterval - Seconds between status polls when `wait=true` (default 1).
-       * @throws {SandboxError} If `wait=true` and the sandbox does not reach `Running` within `timeout`.
        */
       async resume(sandboxId, options) {
-        await this.http.requestResponse(
-          "POST",
-          this.path(`sandboxes/${sandboxId}/resume`)
-        );
+        await callNative(() => this.native.resumeSandbox(sandboxId), { sandboxId, notFoundKind: "sandbox" });
         if (options?.wait === false) return;
         const timeout = options?.timeout ?? 300;
         const pollInterval = options?.pollInterval ?? 1;
@@ -4554,22 +4240,17 @@ var init_client = __esm({
           if (info.status === "terminated" /* TERMINATED */) {
             throw new SandboxError(`Sandbox ${sandboxId} terminated while waiting for resume`);
           }
-          await sleep2(pollInterval * 1e3);
+          await sleep(pollInterval * 1e3);
         }
         throw new SandboxError(`Sandbox ${sandboxId} did not resume within ${timeout}s`);
       }
       /** Claim a warm sandbox from a pool, creating one if no warm containers are available. */
       async claim(poolId) {
-        const raw = await this.http.requestJson(
-          "POST",
-          this.path(`sandbox-pools/${poolId}/sandboxes`),
-          {
-            retryableStatusCodes: CREATE_SANDBOX_RETRYABLE_STATUS_CODES,
-            allowedErrorStatusCodes: CREATE_SANDBOX_ALLOWED_ERROR_STATUS_CODES
-          }
+        return this.tracedJson(
+          () => this.native.claimSandbox(poolId),
+          "sandboxId",
+          { poolId, notFoundKind: "pool" }
         );
-        const result = fromSnakeKeys(raw, "sandboxId");
-        return Object.assign(result, { traceId: raw.traceId });
       }
       /**
        * Live-copy a running sandbox.
@@ -4584,13 +4265,11 @@ var init_client = __esm({
           throw new SandboxError("times must be a positive integer");
         }
         const client = this.withRequestTimeout(options?.requestTimeout);
-        const raw = await client.http.requestJson(
-          "POST",
-          client.path(`sandboxes/${sandboxId}/copy?times=${encodeURIComponent(String(times))}`),
-          { allowedErrorStatusCodes: COPY_SANDBOX_ALLOWED_ERROR_STATUS_CODES }
+        return client.tracedJson(
+          () => client.native.copySandbox(sandboxId, times),
+          "sandboxId",
+          { sandboxId, notFoundKind: "sandbox" }
         );
-        const result = fromSnakeKeys(raw, "sandboxId");
-        return Object.assign(result, { traceId: raw.traceId });
       }
       // --- Snapshots ---
       /**
@@ -4600,44 +4279,33 @@ var init_client = __esm({
        * status — the snapshot is created asynchronously. Poll `getSnapshot()` until
        * `local_ready`, `completed`, or `failed`, or use `snapshotAndWait()` to
        * block automatically.
-       *
-       * @param options.snapshotType - `"filesystem"` for cold-boot snapshots (e.g. image builds).
-       *   Omit to use the server default (`filesystem`).
        */
       async snapshot(sandboxId, options) {
-        const requestOptions = options?.snapshotType != null ? { body: { snapshot_type: options.snapshotType } } : void 0;
-        const raw = await this.http.requestJson(
-          "POST",
-          this.path(`sandboxes/${sandboxId}/snapshot`),
-          requestOptions
+        return this.plainJson(
+          () => this.native.createSnapshot(sandboxId, options?.snapshotType ?? null),
+          "snapshotId",
+          { sandboxId, notFoundKind: "sandbox" }
         );
-        return fromSnakeKeys(raw, "snapshotId");
       }
       /** Get current status and metadata for a snapshot by ID. */
       async getSnapshot(snapshotId) {
-        const raw = await this.http.requestJson(
-          "GET",
-          this.path(`snapshots/${snapshotId}`)
+        return this.tracedJson(
+          () => this.native.getSnapshot(snapshotId),
+          "snapshotId"
         );
-        return Object.assign(fromSnakeKeys(raw, "snapshotId"), { traceId: raw.traceId });
       }
       /** List all snapshots in the namespace. */
       async listSnapshots() {
-        const raw = await this.http.requestJson(
-          "GET",
-          this.path("snapshots")
-        );
-        const snapshots = (raw.snapshots ?? []).map(
+        const { traceId, json } = await callNative(() => this.native.listSnapshots());
+        const parsed = JSON.parse(json);
+        const snapshots = (parsed.snapshots ?? []).map(
           (s) => fromSnakeKeys(s, "snapshotId")
         );
-        return Object.assign(snapshots, { traceId: raw.traceId });
+        return Object.assign(snapshots, { traceId });
       }
       /** Delete a snapshot by ID. */
       async deleteSnapshot(snapshotId) {
-        await this.http.requestJson(
-          "DELETE",
-          this.path(`snapshots/${snapshotId}`)
-        );
+        await callNative(() => this.native.deleteSnapshot(snapshotId));
       }
       /**
        * Create a snapshot and block until it is locally ready.
@@ -4645,14 +4313,6 @@ var init_client = __esm({
        * Combines `snapshot()` with polling `getSnapshot()` until `local_ready`
        * or `completed`. Pass `{ waitUntil: "completed" }` when durable
        * `snapshotUri` metadata is required.
-       * Prefer `sandbox.checkpoint()` on a `Sandbox` handle for the same behavior
-       * without managing the client separately.
-       *
-       * @param sandboxId - ID of the running sandbox to snapshot.
-       * @param options.timeout - Max seconds to wait (default 300).
-       * @param options.pollInterval - Seconds between status polls (default 1).
-       * @param options.snapshotType - Snapshot type passed through to `snapshot()`.
-       * @throws {SandboxError} If the snapshot fails or `timeout` elapses.
        */
       async snapshotAndWait(sandboxId, options) {
         const timeout = options?.timeout ?? 300;
@@ -4670,7 +4330,7 @@ var init_client = __esm({
               `Snapshot ${result.snapshotId} failed: ${info.error}`
             );
           }
-          await sleep2(pollInterval * 1e3);
+          await sleep(pollInterval * 1e3);
         }
         throw new SandboxError(
           `Snapshot ${result.snapshotId} did not reach ${waitUntil} within ${timeout}s`
@@ -4691,31 +4351,27 @@ var init_client = __esm({
         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;
-        const raw = await this.http.requestJson(
-          "POST",
-          this.path("sandbox-pools"),
-          { body }
+        return this.plainJson(
+          () => this.native.createPool(JSON.stringify(body)),
+          "poolId"
         );
-        return fromSnakeKeys(raw, "poolId");
       }
       /** Get current state and metadata for a sandbox pool by ID. */
       async getPool(poolId) {
-        const raw = await this.http.requestJson(
-          "GET",
-          this.path(`sandbox-pools/${poolId}`)
+        return this.plainJson(
+          () => this.native.getPool(poolId),
+          "poolId",
+          { poolId, notFoundKind: "pool" }
         );
-        return fromSnakeKeys(raw, "poolId");
       }
       /** List all sandbox pools in the namespace. */
       async listPools() {
-        const raw = await this.http.requestJson(
-          "GET",
-          this.path("sandbox-pools")
-        );
-        const pools = (raw.pools ?? []).map(
+        const { traceId, json } = await callNative(() => this.native.listPools());
+        const parsed = JSON.parse(json);
+        const pools = (parsed.pools ?? []).map(
           (p) => fromSnakeKeys(p, "poolId")
         );
-        return Object.assign(pools, { traceId: raw.traceId });
+        return Object.assign(pools, { traceId });
       }
       /** Replace the configuration of an existing sandbox pool. */
       async updatePool(poolId, options) {
@@ -4731,19 +4387,15 @@ var init_client = __esm({
         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;
-        const raw = await this.http.requestJson(
-          "PUT",
-          this.path(`sandbox-pools/${poolId}`),
-          { body }
+        return this.plainJson(
+          () => this.native.updatePool(poolId, JSON.stringify(body)),
+          "poolId",
+          { poolId, notFoundKind: "pool" }
         );
-        return fromSnakeKeys(raw, "poolId");
       }
       /** Delete a sandbox pool. Fails if the pool has active containers. */
       async deletePool(poolId) {
-        await this.http.requestJson(
-          "DELETE",
-          this.path(`sandbox-pools/${poolId}`)
-        );
+        await callNative(() => this.native.deletePool(poolId), { poolId, notFoundKind: "pool" });
       }
       // --- Connect ---
       /** Return a `Sandbox` handle for an existing running sandbox without verifying it exists. */
@@ -4757,7 +4409,8 @@ var init_client = __esm({
           projectId: this.projectId,
           routingHint,
           resolveProxyInfo: proxyUrl == null ? async (currentIdentifier) => this.get(currentIdentifier) : void 0,
-          requestTimeout
+          requestTimeout,
+          nativeClient: this.native
         });
       }
       /**
@@ -4765,10 +4418,6 @@ var init_client = __esm({
        *
        * Blocks until the sandbox is ready or `requestTimeout` elapses. The returned
        * `Sandbox` auto-terminates when `terminate()` is called.
-       *
-       * @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) {
         if (options?.poolId != null && options?.cloudInit != null) {
@@ -4830,7 +4479,7 @@ var init_client = __esm({
             `Sandbox ${result.sandboxId} did not start within ${requestTimeout}s`
           );
         }
-        const deadline = Date.now() + secondsToMillis4(requestTimeout);
+        const deadline = Date.now() + secondsToMillis3(requestTimeout);
         while (Date.now() < deadline) {
           const pollStart = nowMs();
           const info = await requestClient.get(result.sandboxId);
@@ -4850,7 +4499,7 @@ var init_client = __esm({
               })
             );
           }
-          await sleep2(500);
+          await sleep(500);
         }
         try {
           await requestClient.delete(result.sandboxId);
@@ -4996,21 +4645,21 @@ __export(sandbox_image_exports, {
   createSandboxImage: () => createSandboxImage,
   runCreateSandboxImageCli: () => runCreateSandboxImageCli
 });
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 import path from "path";
 import { existsSync } from "fs";
 import { parseArgs } from "util";
-function resolveRequire() {
+function resolveRequire2() {
   if (typeof module !== "undefined" && module.exports != null && typeof __require !== "undefined") {
     return __require;
   }
-  return createRequire(import.meta.url);
+  return createRequire2(import.meta.url);
 }
 function loadNativeBinding() {
   if (cachedNativeBinding) return cachedNativeBinding;
   if (cachedNativeBindingError) throw cachedNativeBindingError;
   try {
-    const { loadNative } = resolveRequire()("../lib/runtime.cjs");
+    const { loadNative } = resolveRequire2()("../lib/runtime.cjs");
     cachedNativeBinding = loadNative();
     return cachedNativeBinding;
   } catch (error) {
@@ -5226,9 +4875,369 @@ init_tunnel();
 
 // src/cloud-client.ts
 init_defaults();
-init_http();
+
+// src/http.ts
+init_defaults();
+init_errors();
+init_sdk_timings();
+import {
+  Agent,
+  fetch as undiciFetch,
+  setGlobalDispatcher
+} from "undici";
+var REQUEST_TIMEOUT_HEADER = "X-Tensorlake-Request-Timeout-Ms";
+setGlobalDispatcher(
+  new Agent({
+    keepAliveTimeout: 6e4,
+    allowH2: true
+  })
+);
+function withTraceId(value, traceId) {
+  if (value == null) {
+    return { traceId };
+  }
+  return Object.assign(value, { traceId });
+}
+var HttpClient = class _HttpClient {
+  baseUrl;
+  headers;
+  maxRetries;
+  retryBackoffMs;
+  timeoutMs;
+  abortController = null;
+  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;
+    }
+    if (options.routingHint) {
+      this.headers["X-Tensorlake-Route-Hint"] = options.routingHint;
+    }
+  }
+  close() {
+    this.abortController?.abort();
+    this.abortController = null;
+  }
+  /** Make a JSON request, returning the parsed response body. */
+  async requestJson(method, path2, options) {
+    const response = await this.requestResponse(method, path2, {
+      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, path2, options) {
+    const headers = { ...options?.headers ?? {} };
+    if (options?.contentType) {
+      headers["Content-Type"] = options.contentType;
+    }
+    const response = await this.requestResponse(method, path2, {
+      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, path2, options) {
+    const response = await this.requestResponse(method, path2, {
+      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);
+  }
+  /** Make a request and return the raw Response. */
+  async requestResponse(method, path2, 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,
+      path2,
+      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, 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;
+    let lastError;
+    const operationStart = nowMs();
+    const timingPath = sdkTimingPayloadsEnabled() ? path2 : stripPathPayload(path2);
+    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 sleep2(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 undiciFetch(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, path2);
+      } 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 }
+    );
+  }
+};
+function hasHeader(headers, name) {
+  const lowered = name.toLowerCase();
+  return Object.keys(headers).some((key) => key.toLowerCase() === lowered);
+}
+function normalizeRequestBody(body) {
+  if (body == null) {
+    return void 0;
+  }
+  if (body instanceof Uint8Array) {
+    return Uint8Array.from(body).buffer;
+  }
+  return body;
+}
+function stripPathPayload(path2) {
+  const queryStart = path2.search(/[?#]/);
+  return queryStart === -1 ? path2 : path2.slice(0, queryStart);
+}
+function throwMappedError(status, body, path2) {
+  let message = body;
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed.message) message = parsed.message;
+    else if (parsed.error) message = parsed.error;
+  } catch {
+  }
+  if (status === 404) {
+    if (path2.includes("sandbox-pools") || path2.includes("pools")) {
+      const match = path2.match(/sandbox-pools\/([^/]+)/);
+      if (match) throw new PoolNotFoundError(match[1]);
+    }
+    if (path2.includes("sandboxes")) {
+      const match = path2.match(/sandboxes\/([^/]+)/);
+      if (match) throw new SandboxNotFoundError(match[1]);
+    }
+    throw new RemoteAPIError(404, message);
+  }
+  if (status === 409) {
+    if (path2.includes("sandbox-pools") || path2.includes("pools")) {
+      const match = path2.match(/sandbox-pools\/([^/]+)/);
+      if (match) throw new PoolInUseError(match[1], message);
+    }
+  }
+  throw new RemoteAPIError(status, 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
+    });
+  }
+  return controller.signal;
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/cloud-client.ts
 init_models();
-init_sse();
+
+// 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 {
+    }
+  }
+}
+
+// src/cloud-client.ts
 var CloudClient = class _CloudClient {
   http;
   organizationId;