computesdk 1.8.7 → 1.9.0

package/dist/index.mjs

@@ -1,228 +1,767 @@
 // src/types/sandbox.ts
-var CommandExitError = class extends Error {
-  constructor(result) {
-    super(`Command exited with code ${result.exitCode}`);
-    this.result = result;
-    this.name = "CommandExitError";
-  }
+import { Sandbox } from "@computesdk/client";
+import {
+  CommandExitError,
+  isCommandExitError
+} from "@computesdk/client";
+
+// src/constants.ts
+var GATEWAY_URL = "https://gateway.computesdk.com";
+var PROVIDER_PRIORITY = [
+  "e2b",
+  "railway",
+  "daytona",
+  "modal",
+  "runloop",
+  "vercel",
+  "cloudflare",
+  "codesandbox",
+  "blaxel"
+];
+var PROVIDER_ENV_VARS = {
+  e2b: ["E2B_API_KEY"],
+  railway: ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"],
+  daytona: ["DAYTONA_API_KEY"],
+  modal: ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"],
+  runloop: ["RUNLOOP_API_KEY"],
+  vercel: ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"],
+  cloudflare: ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"],
+  codesandbox: ["CSB_API_KEY"],
+  blaxel: ["BL_API_KEY", "BL_WORKSPACE"]
 };
-function isCommandExitError(error) {
-  return typeof error === "object" && error !== null && "name" in error && error.name === "CommandExitError" && "result" in error;
-}
 
-// src/auth/license.ts
-async function authorizeApiKey(apiKey) {
-  try {
-    const response = await fetch("https://sandbox.computesdk.com/__api/license/authorize", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        key: apiKey,
-        increment_usage: 1
-      })
-    });
-    if (!response.ok) {
-      const errorText = await response.text().catch(() => response.statusText);
-      throw new Error(`License authorization failed (${response.status}): ${errorText}`);
-    }
-    const data = await response.json();
-    if (!data.access_token) {
-      throw new Error("No access token received from license server");
+// src/providers/gateway.ts
+import { Sandbox as ClientSandbox } from "@computesdk/client";
+
+// src/factory.ts
+import { cmd } from "@computesdk/cmd";
+var UnsupportedFileSystem = class {
+  constructor(providerName) {
+    this.providerName = providerName;
+  }
+  async readFile(_path) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  }
+  async writeFile(_path, _content) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  }
+  async mkdir(_path) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  }
+  async readdir(_path) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  }
+  async exists(_path) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  }
+  async remove(_path) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
+  }
+};
+var SupportedFileSystem = class {
+  constructor(sandbox, methods, allMethods) {
+    this.sandbox = sandbox;
+    this.methods = methods;
+    this.allMethods = allMethods;
+  }
+  async readFile(path) {
+    return this.methods.readFile(this.sandbox, path, this.allMethods.runCommand);
+  }
+  async writeFile(path, content) {
+    return this.methods.writeFile(this.sandbox, path, content, this.allMethods.runCommand);
+  }
+  async mkdir(path) {
+    return this.methods.mkdir(this.sandbox, path, this.allMethods.runCommand);
+  }
+  async readdir(path) {
+    return this.methods.readdir(this.sandbox, path, this.allMethods.runCommand);
+  }
+  async exists(path) {
+    return this.methods.exists(this.sandbox, path, this.allMethods.runCommand);
+  }
+  async remove(path) {
+    return this.methods.remove(this.sandbox, path, this.allMethods.runCommand);
+  }
+};
+var GeneratedSandbox = class {
+  constructor(sandbox, sandboxId, providerName, methods, config, destroyMethod, providerInstance) {
+    this.sandbox = sandbox;
+    this.methods = methods;
+    this.config = config;
+    this.destroyMethod = destroyMethod;
+    this.providerInstance = providerInstance;
+    this.sandboxId = sandboxId;
+    this.provider = providerName;
+    if (methods.filesystem) {
+      this.filesystem = new SupportedFileSystem(sandbox, methods.filesystem, methods);
+    } else {
+      this.filesystem = new UnsupportedFileSystem(providerName);
     }
-    if (!data.sandbox_url) {
-      throw new Error("No sandbox_url received from license server");
+  }
+  getInstance() {
+    if (this.methods.getInstance) {
+      return this.methods.getInstance(this.sandbox);
     }
-    if (!data.preview_url) {
-      throw new Error("No preview_url received from license server");
+    return this.sandbox;
+  }
+  async runCode(code, runtime) {
+    return await this.methods.runCode(this.sandbox, code, runtime, this.config);
+  }
+  async runCommand(commandOrArray, argsOrOptions, maybeOptions) {
+    let command;
+    let args;
+    let options;
+    if (Array.isArray(commandOrArray)) {
+      [command, ...args] = commandOrArray;
+      options = argsOrOptions;
+    } else {
+      command = commandOrArray;
+      args = Array.isArray(argsOrOptions) ? argsOrOptions : [];
+      options = Array.isArray(argsOrOptions) ? maybeOptions : argsOrOptions;
     }
-    return {
-      access_token: data.access_token,
-      sandbox_url: data.sandbox_url,
-      preview_url: data.preview_url
-    };
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("License authorization failed")) {
-      throw error;
+    const baseCommand = args.length > 0 ? [command, ...args] : [command];
+    if (options?.cwd || options?.background) {
+      const wrappedCommand = cmd(baseCommand, {
+        cwd: options.cwd,
+        background: options.background
+      });
+      const [wrappedCmd, ...wrappedArgs] = wrappedCommand;
+      return await this.methods.runCommand(this.sandbox, wrappedCmd, wrappedArgs, void 0);
     }
-    throw new Error(`Failed to authorize API key (network error): ${error instanceof Error ? error.message : String(error)}`);
+    return await this.methods.runCommand(this.sandbox, command, args, options);
   }
-}
-
-// src/compute-daemon/dependencies.ts
-async function isCommandAvailable(sandbox, command) {
-  const result = await sandbox.runCommand("sh", ["-c", `command -v ${command}`]);
-  return result.exitCode === 0;
-}
-async function detectPackageManager(sandbox) {
-  if (await isCommandAvailable(sandbox, "apk")) {
-    return "apk";
+  async getInfo() {
+    return await this.methods.getInfo(this.sandbox);
   }
-  if (await isCommandAvailable(sandbox, "apt-get")) {
-    return "apt";
+  async getUrl(options) {
+    return await this.methods.getUrl(this.sandbox, options);
   }
-  return null;
-}
-async function ensureDependencies(sandbox) {
-  const hasCurl = await isCommandAvailable(sandbox, "curl");
-  const hasBash = await isCommandAvailable(sandbox, "bash");
-  if (hasCurl && hasBash) {
-    return;
-  }
-  const packageManager = await detectPackageManager(sandbox);
-  if (!packageManager) {
-    throw new Error(
-      `Missing required tools (curl: ${hasCurl}, bash: ${hasBash}), but no supported package manager found.
-Supported package managers: apk (Alpine), apt-get (Debian/Ubuntu).
-Please use a sandbox image that includes curl and bash, or install them manually first.`
-    );
+  getProvider() {
+    return this.providerInstance;
   }
-  let installResult;
-  if (packageManager === "apk") {
-    installResult = await sandbox.runCommand("sh", ["-c", "apk add --no-cache curl bash 2>&1"]);
-  } else {
-    installResult = await sandbox.runCommand("sh", ["-c", "apt-get update -qq && apt-get install -qq -y curl bash 2>&1"]);
+  async kill() {
+    await this.destroy();
   }
-  if (installResult.exitCode !== 0) {
-    throw new Error(
-      `Failed to install curl and bash using ${packageManager}.
-Install output: ${installResult.stderr || installResult.stdout}
-Please install curl and bash manually or use a different sandbox image.`
-    );
+  async destroy() {
+    await this.destroyMethod(this.config, this.sandboxId);
   }
+};
+function getEffectiveMode(config, defaultMode) {
+  if (config.mode) {
+    return config.mode;
+  }
+  return defaultMode;
 }
-
-// src/compute-daemon/installer.ts
-async function isComputeInstalled(sandbox) {
-  const result = await sandbox.runCommand("sh", ["-c", 'test -f /usr/local/bin/compute && echo "exists" || echo "missing"']);
-  return result.stdout?.trim() === "exists";
-}
-async function downloadInstallScript(sandbox) {
-  const downloadResult = await sandbox.runCommand("sh", ["-c", "curl -fsSL https://computesdk.com/install.sh -o /tmp/compute-install.sh 2>&1"]);
-  if (downloadResult.exitCode !== 0) {
-    const errorOutput = downloadResult.stderr || downloadResult.stdout || "unknown error";
-    throw new Error(
-      `Failed to download install script from https://computesdk.com/install.sh: ${errorOutput}`
+var GeneratedSandboxManager = class {
+  constructor(config, providerName, methods, providerInstance, defaultMode) {
+    this.config = config;
+    this.providerName = providerName;
+    this.methods = methods;
+    this.providerInstance = providerInstance;
+    this.effectiveMode = getEffectiveMode(config, defaultMode);
+  }
+  async create(options) {
+    const optionsWithDefaults = { runtime: "node", ...options };
+    const result = await this.methods.create(this.config, optionsWithDefaults);
+    return new GeneratedSandbox(
+      result.sandbox,
+      result.sandboxId,
+      this.providerName,
+      this.methods,
+      this.config,
+      this.methods.destroy,
+      this.providerInstance
     );
   }
-}
-async function runInstallScript(sandbox, accessToken) {
-  const installCommand = accessToken ? `bash /tmp/compute-install.sh --non-interactive --access-token "${accessToken}" --location /usr/local/bin` : `bash /tmp/compute-install.sh --non-interactive --location /usr/local/bin`;
-  const installResult = await sandbox.runCommand("bash", ["-c", installCommand]);
-  if (installResult.exitCode !== 0) {
-    const errorOutput = installResult.stderr || installResult.stdout || "unknown error";
-    throw new Error(`Failed to install compute daemon: ${errorOutput}`);
+  async getById(sandboxId) {
+    const result = await this.methods.getById(this.config, sandboxId);
+    if (!result) {
+      return null;
+    }
+    return new GeneratedSandbox(
+      result.sandbox,
+      result.sandboxId,
+      this.providerName,
+      this.methods,
+      this.config,
+      this.methods.destroy,
+      this.providerInstance
+    );
   }
-}
-async function installComputeDaemon(sandbox, accessToken) {
-  if (await isComputeInstalled(sandbox)) {
-    return;
+  async list() {
+    const results = await this.methods.list(this.config);
+    return results.map((result) => new GeneratedSandbox(
+      result.sandbox,
+      result.sandboxId,
+      this.providerName,
+      this.methods,
+      this.config,
+      this.methods.destroy,
+      this.providerInstance
+    ));
   }
-  await ensureDependencies(sandbox);
-  await downloadInstallScript(sandbox);
-  await runInstallScript(sandbox, accessToken);
-  if (!await isComputeInstalled(sandbox)) {
-    throw new Error("Compute binary not found at /usr/local/bin/compute after installation");
+  async destroy(sandboxId) {
+    await this.methods.destroy(this.config, sandboxId);
   }
+};
+var GeneratedTemplateManager = class {
+  constructor(config, methods) {
+    this.config = config;
+    this.methods = methods;
+  }
+  async create(options) {
+    return await this.methods.create(this.config, options);
+  }
+  async list(options) {
+    return await this.methods.list(this.config, options);
+  }
+  async delete(templateId) {
+    return await this.methods.delete(this.config, templateId);
+  }
+};
+var GeneratedSnapshotManager = class {
+  constructor(config, methods) {
+    this.config = config;
+    this.methods = methods;
+  }
+  async create(sandboxId, options) {
+    return await this.methods.create(this.config, sandboxId, options);
+  }
+  async list(options) {
+    return await this.methods.list(this.config, options);
+  }
+  async delete(snapshotId) {
+    return await this.methods.delete(this.config, snapshotId);
+  }
+};
+var GeneratedProvider = class {
+  constructor(config, providerConfig) {
+    this.name = providerConfig.name;
+    this.sandbox = new GeneratedSandboxManager(
+      config,
+      providerConfig.name,
+      providerConfig.methods.sandbox,
+      this,
+      providerConfig.defaultMode ?? "gateway"
+    );
+    if (providerConfig.methods.template) {
+      this.template = new GeneratedTemplateManager(config, providerConfig.methods.template);
+    }
+    if (providerConfig.methods.snapshot) {
+      this.snapshot = new GeneratedSnapshotManager(config, providerConfig.methods.snapshot);
+    }
+  }
+  getSupportedRuntimes() {
+    return ["node", "python"];
+  }
+};
+function createProvider(providerConfig) {
+  return (config) => {
+    return new GeneratedProvider(config, providerConfig);
+  };
 }
 
-// src/sandbox/wrapper.ts
-import { ComputeClient } from "@computesdk/client";
-
 // src/compute-daemon/lifecycle.ts
-async function waitForComputeReady(client, maxRetries = 30, delayMs = 2e3) {
+async function waitForComputeReady(client, options = {}) {
+  const maxRetries = options.maxRetries ?? 30;
+  const initialDelayMs = options.initialDelayMs ?? 500;
+  const maxDelayMs = options.maxDelayMs ?? 5e3;
+  const backoffFactor = options.backoffFactor ?? 1.5;
   let lastError = null;
+  let currentDelay = initialDelayMs;
   for (let i = 0; i < maxRetries; i++) {
     try {
       await client.health();
+      if (process.env.COMPUTESDK_DEBUG) {
+        console.log(`[Lifecycle] Sandbox ready after ${i + 1} attempt${i === 0 ? "" : "s"}`);
+      }
       return;
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
       if (i === maxRetries - 1) {
         throw new Error(
-          `Compute daemon failed to start after ${maxRetries} attempts (${maxRetries * delayMs / 1e3}s).
+          `Sandbox failed to become ready after ${maxRetries} attempts.
 Last error: ${lastError.message}
-This could indicate:
-  1. The compute daemon failed to start in the sandbox
-  2. The sandbox_url is incorrect or unreachable
-  3. The sandbox is taking longer than expected to initialize`
+
+Possible causes:
+  1. Sandbox failed to start (check provider dashboard for errors)
+  2. Network connectivity issues between your app and the sandbox
+  3. Sandbox is taking longer than expected to initialize
+  4. Invalid sandbox URL or authentication credentials
+
+Troubleshooting:
+  - Check sandbox logs in your provider dashboard
+  - Verify your network connection
+  - Try increasing maxRetries if initialization is slow
+  - Enable debug mode: export COMPUTESDK_DEBUG=1`
         );
       }
-      await new Promise((resolve) => setTimeout(resolve, delayMs));
-    }
+      await new Promise((resolve) => setTimeout(resolve, currentDelay));
+      currentDelay = Math.min(currentDelay * backoffFactor, maxDelayMs);
+    }
+  }
+}
+
+// src/utils.ts
+function calculateBackoff(attempt, baseDelay = 1e3, jitterMax = 100) {
+  return baseDelay * Math.pow(2, attempt) + Math.random() * jitterMax;
+}
+
+// src/providers/gateway.ts
+import { Sandbox as Sandbox2 } from "@computesdk/client";
+var DEFAULT_GATEWAY_URL = "https://gateway.computesdk.com";
+var DEFAULT_REQUEST_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY = 1e3;
+var DEFAULT_RETRYABLE_STATUSES = [408, 429, 502, 503, 504];
+var hasWarnedAboutMissingToken = false;
+var GatewayError = class extends Error {
+  constructor(message, statusCode, provider, sandboxId, requestId) {
+    super(message);
+    this.statusCode = statusCode;
+    this.provider = provider;
+    this.sandboxId = sandboxId;
+    this.requestId = requestId;
+    this.name = "GatewayError";
+  }
+};
+async function gatewayFetch(url, config, options = {}) {
+  const timeout = config.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+  const maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY;
+  const retryableStatuses = config.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES;
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const startTime = Date.now();
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal,
+        headers: {
+          "Content-Type": "application/json",
+          "X-ComputeSDK-API-Key": config.apiKey,
+          "X-Provider": config.provider,
+          ...config.providerHeaders || {},
+          ...options.headers
+        }
+      });
+      clearTimeout(timeoutId);
+      const duration = Date.now() - startTime;
+      if (process.env.COMPUTESDK_DEBUG) {
+        console.log(`[Gateway] ${options.method || "GET"} ${url} - ${response.status} (${duration}ms)`);
+      }
+      if (!response.ok) {
+        if (response.status === 404) {
+          return { success: false };
+        }
+        const errorText = await response.text().catch(() => response.statusText);
+        const requestId = response.headers.get("x-request-id");
+        const isRetryable = retryableStatuses.includes(response.status);
+        const shouldRetry = isRetryable && attempt < maxRetries;
+        if (shouldRetry) {
+          const delay = calculateBackoff(attempt, retryDelay);
+          if (process.env.COMPUTESDK_DEBUG) {
+            console.log(`[Gateway] Retry ${attempt + 1}/${maxRetries} after ${delay.toFixed(0)}ms (status: ${response.status})...`);
+          }
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          continue;
+        }
+        let errorMessage = `Gateway API error: ${errorText}`;
+        if (response.status === 401) {
+          errorMessage = `Invalid ComputeSDK API key.
+
+Check your COMPUTESDK_API_KEY environment variable.
+Get your key at: https://computesdk.com/dashboard`;
+        } else if (response.status === 403) {
+          errorMessage = `Access forbidden. Your API key may not have permission to use provider "${config.provider}".
+
+Visit https://computesdk.com/dashboard to check your plan.`;
+        } else if (response.status === 429) {
+          errorMessage = `Rate limit exceeded. Please try again in a moment.
+
+If this persists, visit https://computesdk.com/dashboard to upgrade your plan.`;
+        } else if (response.status >= 500) {
+          errorMessage = `Gateway server error (${response.status}). This is temporary - please try again.
+
+If this persists, check status at https://status.computesdk.com`;
+        }
+        throw new GatewayError(
+          errorMessage,
+          response.status,
+          config.provider,
+          void 0,
+          requestId || void 0
+        );
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof GatewayError) {
+        lastError = error;
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        const timeoutError = new GatewayError(
+          `Request timed out after ${timeout}ms.
+
+The gateway may be experiencing high load or network issues.
+Check your connection and try again.`,
+          408,
+          config.provider
+        );
+        if (attempt < maxRetries) {
+          const delay = calculateBackoff(attempt, retryDelay);
+          if (process.env.COMPUTESDK_DEBUG) {
+            console.log(`[Gateway] Retry ${attempt + 1}/${maxRetries} after ${delay.toFixed(0)}ms (timeout)...`);
+          }
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          lastError = timeoutError;
+          continue;
+        }
+        throw timeoutError;
+      }
+      const networkError = new GatewayError(
+        `Failed to connect to gateway: ${error instanceof Error ? error.message : String(error)}
+
+Check your internet connection and gateway URL.`,
+        0,
+        config.provider
+      );
+      if (attempt < maxRetries) {
+        const delay = calculateBackoff(attempt, retryDelay);
+        if (process.env.COMPUTESDK_DEBUG) {
+          console.log(`[Gateway] Retry ${attempt + 1}/${maxRetries} after ${delay.toFixed(0)}ms (network error)...`);
+        }
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        lastError = networkError;
+        continue;
+      }
+      throw networkError;
+    }
+  }
+  throw lastError || new Error("Max retries exceeded");
+}
+var gateway = createProvider({
+  name: "gateway",
+  methods: {
+    sandbox: {
+      create: async (config, options) => {
+        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
+        const result = await gatewayFetch(`${gatewayUrl}/sandbox`, config, {
+          method: "POST",
+          body: JSON.stringify(options || {})
+        });
+        if (!result.success || !result.data) {
+          throw new Error(`Gateway returned invalid response: ${JSON.stringify(result)}`);
+        }
+        const { sandboxId, url, token, provider, metadata } = result.data;
+        if (process.env.COMPUTESDK_DEBUG) {
+          console.log(`[Gateway] Sandbox created:`, {
+            sandboxId,
+            url,
+            hasToken: !!token,
+            tokenPrefix: token ? token.substring(0, 10) + "..." : "none",
+            provider
+          });
+        }
+        if (!token && !hasWarnedAboutMissingToken) {
+          hasWarnedAboutMissingToken = true;
+          console.warn(
+            `[Gateway] No token received from gateway for sandbox ${sandboxId}. Falling back to API key for authentication. This may indicate the gateway is running an outdated version. Check gateway deployment at ${config.gatewayUrl || DEFAULT_GATEWAY_URL}`
+          );
+        }
+        const sandbox = new ClientSandbox({
+          sandboxUrl: url,
+          sandboxId,
+          provider,
+          token: token || config.apiKey,
+          // Use token from gateway, fallback to API key
+          metadata,
+          WebSocket: globalThis.WebSocket
+        });
+        await waitForComputeReady(sandbox);
+        return { sandbox, sandboxId };
+      },
+      getById: async (config, sandboxId) => {
+        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
+        const result = await gatewayFetch(`${gatewayUrl}/sandbox/${sandboxId}`, config);
+        if (!result.success || !result.data) {
+          return null;
+        }
+        const { url, token, provider, metadata } = result.data;
+        if (!token && !hasWarnedAboutMissingToken) {
+          hasWarnedAboutMissingToken = true;
+          console.warn(
+            `[Gateway] No token received when reconnecting to sandbox ${sandboxId}. Falling back to API key for authentication. This may indicate the gateway is running an outdated version.`
+          );
+        }
+        const sandbox = new ClientSandbox({
+          sandboxUrl: url,
+          sandboxId,
+          provider,
+          token: token || config.apiKey,
+          // Use token from gateway, fallback to API key
+          metadata,
+          WebSocket: globalThis.WebSocket
+        });
+        await waitForComputeReady(sandbox);
+        return { sandbox, sandboxId };
+      },
+      list: async () => {
+        throw new Error(
+          "Gateway provider does not support listing sandboxes. Use getById() with a known sandbox ID instead."
+        );
+      },
+      destroy: async (config, sandboxId) => {
+        const gatewayUrl = config.gatewayUrl || DEFAULT_GATEWAY_URL;
+        await gatewayFetch(`${gatewayUrl}/sandbox/${sandboxId}`, config, {
+          method: "DELETE"
+        });
+      },
+      // All operations delegate directly to ClientSandbox
+      runCode: async (sandbox, code, runtime) => sandbox.runCode(code, runtime),
+      runCommand: async (sandbox, command, args) => sandbox.runCommand(command, args),
+      getUrl: async (sandbox, options) => sandbox.getUrl(options),
+      getInfo: async (sandbox) => {
+        const info = await sandbox.getInfo();
+        return {
+          id: info.id,
+          provider: info.provider,
+          runtime: info.runtime,
+          status: info.status,
+          createdAt: info.createdAt,
+          timeout: info.timeout,
+          metadata: info.metadata || {}
+        };
+      },
+      // Filesystem delegates directly to ClientSandbox
+      filesystem: {
+        readFile: async (sandbox, path) => sandbox.filesystem.readFile(path),
+        writeFile: async (sandbox, path, content) => sandbox.filesystem.writeFile(path, content),
+        mkdir: async (sandbox, path) => sandbox.filesystem.mkdir(path),
+        readdir: async (sandbox, path) => sandbox.filesystem.readdir(path),
+        exists: async (sandbox, path) => sandbox.filesystem.exists(path),
+        remove: async (sandbox, path) => sandbox.filesystem.remove(path)
+      },
+      // getInstance returns the ClientSandbox directly
+      getInstance: (sandbox) => sandbox
+    }
+  }
+});
+
+// src/auto-detect.ts
+function isGatewayModeEnabled() {
+  return !!(typeof process !== "undefined" && process.env?.COMPUTESDK_API_KEY);
+}
+function hasProviderEnv(provider) {
+  if (typeof process === "undefined") return false;
+  const requiredVars = PROVIDER_ENV_VARS[provider];
+  if (!requiredVars) return false;
+  return requiredVars.every((varName) => !!process.env?.[varName]);
+}
+function getProviderEnvStatus(provider) {
+  const requiredVars = PROVIDER_ENV_VARS[provider];
+  if (typeof process === "undefined" || !requiredVars) {
+    return { provider, present: [], missing: requiredVars ? [...requiredVars] : [], isComplete: false };
+  }
+  const present = requiredVars.filter((varName) => !!process.env?.[varName]);
+  const missing = requiredVars.filter((varName) => !process.env?.[varName]);
+  return {
+    provider,
+    present: [...present],
+    missing: [...missing],
+    isComplete: missing.length === 0
+  };
+}
+function detectProvider() {
+  if (typeof process === "undefined") return null;
+  const explicit = process.env.COMPUTESDK_PROVIDER?.toLowerCase();
+  if (explicit && hasProviderEnv(explicit)) {
+    return explicit;
+  }
+  if (explicit && !hasProviderEnv(explicit)) {
+    console.warn(
+      `\u26A0\uFE0F  COMPUTESDK_PROVIDER is set to "${explicit}" but required credentials are missing.
+   Required: ${PROVIDER_ENV_VARS[explicit]?.join(", ") || "unknown"}
+   Falling back to auto-detection...`
+    );
+  }
+  for (const provider of PROVIDER_PRIORITY) {
+    if (hasProviderEnv(provider)) {
+      return provider;
+    }
+  }
+  return null;
+}
+function getProviderHeaders(provider) {
+  if (typeof process === "undefined") return {};
+  const headers = {};
+  switch (provider) {
+    case "e2b":
+      if (process.env.E2B_API_KEY) {
+        headers["X-E2B-API-Key"] = process.env.E2B_API_KEY;
+      }
+      break;
+    case "railway":
+      if (process.env.RAILWAY_API_KEY) {
+        headers["X-Railway-API-Key"] = process.env.RAILWAY_API_KEY;
+      }
+      if (process.env.RAILWAY_PROJECT_ID) {
+        headers["X-Railway-Project-ID"] = process.env.RAILWAY_PROJECT_ID;
+      }
+      if (process.env.RAILWAY_ENVIRONMENT_ID) {
+        headers["X-Railway-Environment-ID"] = process.env.RAILWAY_ENVIRONMENT_ID;
+      }
+      break;
+    case "daytona":
+      if (process.env.DAYTONA_API_KEY) {
+        headers["X-Daytona-API-Key"] = process.env.DAYTONA_API_KEY;
+      }
+      break;
+    case "modal":
+      if (process.env.MODAL_TOKEN_ID) {
+        headers["X-Modal-Token-ID"] = process.env.MODAL_TOKEN_ID;
+      }
+      if (process.env.MODAL_TOKEN_SECRET) {
+        headers["X-Modal-Token-Secret"] = process.env.MODAL_TOKEN_SECRET;
+      }
+      break;
+    case "runloop":
+      if (process.env.RUNLOOP_API_KEY) {
+        headers["X-Runloop-API-Key"] = process.env.RUNLOOP_API_KEY;
+      }
+      break;
+    case "vercel":
+      if (process.env.VERCEL_TOKEN) {
+        headers["X-Vercel-Token"] = process.env.VERCEL_TOKEN;
+      }
+      if (process.env.VERCEL_TEAM_ID) {
+        headers["X-Vercel-Team-ID"] = process.env.VERCEL_TEAM_ID;
+      }
+      if (process.env.VERCEL_PROJECT_ID) {
+        headers["X-Vercel-Project-ID"] = process.env.VERCEL_PROJECT_ID;
+      }
+      break;
+    case "cloudflare":
+      if (process.env.CLOUDFLARE_API_TOKEN) {
+        headers["X-Cloudflare-API-Token"] = process.env.CLOUDFLARE_API_TOKEN;
+      }
+      if (process.env.CLOUDFLARE_ACCOUNT_ID) {
+        headers["X-Cloudflare-Account-ID"] = process.env.CLOUDFLARE_ACCOUNT_ID;
+      }
+      break;
+    case "codesandbox":
+      if (process.env.CSB_API_KEY) {
+        headers["X-CodeSandbox-API-Key"] = process.env.CSB_API_KEY;
+      }
+      break;
+    case "blaxel":
+      if (process.env.BL_API_KEY) {
+        headers["X-Blaxel-API-Key"] = process.env.BL_API_KEY;
+      }
+      if (process.env.BL_WORKSPACE) {
+        headers["X-Blaxel-Workspace"] = process.env.BL_WORKSPACE;
+      }
+      break;
   }
+  return headers;
 }
+function autoConfigureCompute() {
+  if (!isGatewayModeEnabled()) {
+    return null;
+  }
+  const provider = detectProvider();
+  if (!provider) {
+    const detectionResults = PROVIDER_PRIORITY.map((p) => getProviderEnvStatus(p));
+    const statusLines = detectionResults.map((result) => {
+      const status = result.isComplete ? "\u2705" : result.present.length > 0 ? "\u26A0\uFE0F " : "\u274C";
+      const ratio = `${result.present.length}/${result.present.length + result.missing.length}`;
+      let line = `  ${status} ${result.provider.padEnd(12)} ${ratio} credentials`;
+      if (result.present.length > 0 && result.missing.length > 0) {
+        line += ` (missing: ${result.missing.join(", ")})`;
+      }
+      return line;
+    });
+    throw new Error(
+      `COMPUTESDK_API_KEY is set but no provider detected.
 
-// src/sandbox/wrapper.ts
-async function wrapWithComputeClient(originalSandbox, authResponse) {
-  const client = new ComputeClient({
-    sandboxUrl: authResponse.sandbox_url,
-    sandboxId: originalSandbox.sandboxId,
-    provider: originalSandbox.provider,
-    token: authResponse.access_token,
-    WebSocket: globalThis.WebSocket
-  });
-  await waitForComputeReady(client);
-  const wrappedSandbox = Object.assign(client, {
-    __originalSandbox: originalSandbox,
-    // Override getInstance to return the original provider's instance
-    getInstance: () => originalSandbox.getInstance(),
-    // Override getProvider to return the original provider
-    getProvider: () => originalSandbox.getProvider()
+Provider detection results:
+` + statusLines.join("\n") + `
+
+To fix this, set one of the following:
+
+  E2B:        export E2B_API_KEY=xxx
+  Railway:    export RAILWAY_API_KEY=xxx RAILWAY_PROJECT_ID=xxx RAILWAY_ENVIRONMENT_ID=xxx
+  Daytona:    export DAYTONA_API_KEY=xxx
+  Modal:      export MODAL_TOKEN_ID=xxx MODAL_TOKEN_SECRET=xxx
+  Runloop:    export RUNLOOP_API_KEY=xxx
+  Vercel:     export VERCEL_TOKEN=xxx VERCEL_TEAM_ID=xxx VERCEL_PROJECT_ID=xxx
+  Cloudflare: export CLOUDFLARE_API_TOKEN=xxx CLOUDFLARE_ACCOUNT_ID=xxx
+  CodeSandbox: export CSB_API_KEY=xxx
+  Blaxel:     export BL_API_KEY=xxx BL_WORKSPACE=xxx
+
+Or set COMPUTESDK_PROVIDER to specify explicitly:
+  export COMPUTESDK_PROVIDER=e2b
+
+Docs: https://computesdk.com/docs/quickstart`
+    );
+  }
+  const gatewayUrl = process.env.COMPUTESDK_GATEWAY_URL || GATEWAY_URL;
+  const computesdkApiKey = process.env.COMPUTESDK_API_KEY;
+  const providerHeaders = getProviderHeaders(provider);
+  try {
+    new URL(gatewayUrl);
+  } catch (error) {
+    throw new Error(
+      `Invalid gateway URL: "${gatewayUrl}"
+
+The URL must be a valid HTTP/HTTPS URL.
+Check your COMPUTESDK_GATEWAY_URL environment variable.`
+    );
+  }
+  if (process.env.COMPUTESDK_DEBUG) {
+    console.log(`\u2728 ComputeSDK: Auto-detected ${provider} provider`);
+    console.log(`\u{1F310} Gateway: ${gatewayUrl}`);
+    console.log(`\u{1F511} Provider headers:`, Object.keys(providerHeaders).join(", "));
+  }
+  return gateway({
+    gatewayUrl,
+    apiKey: computesdkApiKey,
+    provider,
+    providerHeaders
   });
-  return wrappedSandbox;
 }
 
 // src/compute.ts
 var ComputeManager = class {
   constructor() {
     this.config = null;
-    this.computeAuth = {};
+    this.autoConfigured = false;
     this.sandbox = {
       /**
        * Create a sandbox from a provider (or default provider if configured)
-       * 
+       *
        * @example
        * ```typescript
        * import { e2b } from '@computesdk/e2b'
        * import { compute } from 'computesdk'
-       * 
+       *
        * // With explicit provider
        * const sandbox = await compute.sandbox.create({
        *   provider: e2b({ apiKey: 'your-key' })
        * })
-       * 
-        * // With default provider (both forms work)
+       *
+        * // With default provider
         * compute.setConfig({ defaultProvider: e2b({ apiKey: 'your-key' }) })
-        * const sandbox1 = await compute.sandbox.create({})
-        * const sandbox2 = await compute.sandbox.create()
+        * const sandbox = await compute.sandbox.create()
        * ```
        */
       create: async (params) => {
         const provider = params && "provider" in params && params.provider ? params.provider : this.getDefaultProvider();
         const options = params?.options;
-        const sandbox = await provider.sandbox.create(options);
-        if (this.computeAuth.apiKey || this.computeAuth.accessToken) {
-          let authResponse = null;
-          let accessToken = this.computeAuth.accessToken;
-          if (this.computeAuth.apiKey && !accessToken) {
-            authResponse = await authorizeApiKey(this.computeAuth.apiKey);
-            accessToken = authResponse.access_token;
-          }
-          await installComputeDaemon(sandbox, accessToken);
-          if (authResponse) {
-            return await wrapWithComputeClient(sandbox, authResponse);
-          } else if (accessToken) {
-            const defaultAuthResponse = {
-              access_token: accessToken,
-              sandbox_url: "https://sandbox.computesdk.com",
-              preview_url: "https://preview.computesdk.com"
-            };
-            return await wrapWithComputeClient(sandbox, defaultAuthResponse);
-          }
-        }
-        return sandbox;
+        return await provider.sandbox.create(options);
       },
       /**
        * Get an existing sandbox by ID from a provider (or default provider if configured)
@@ -272,16 +811,9 @@ var ComputeManager = class {
       console.warn("Both defaultProvider and provider specified in setConfig. Using defaultProvider. The provider key is deprecated, please use defaultProvider instead.");
     }
     const actualProvider = config.defaultProvider || config.provider;
-    const accessToken = config.accessToken || config.jwt;
     this.config = {
       provider: actualProvider,
-      defaultProvider: actualProvider,
-      apiKey: config.apiKey,
-      accessToken
-    };
-    this.computeAuth = {
-      apiKey: config.apiKey,
-      accessToken
+      defaultProvider: actualProvider
     };
   }
   /**
@@ -296,39 +828,46 @@ var ComputeManager = class {
   clearConfig() {
     this.config = null;
   }
+  /**
+   * Lazy auto-configure from environment if not explicitly configured
+   */
+  ensureConfigured() {
+    if (this.config) return;
+    if (this.autoConfigured) return;
+    const provider = autoConfigureCompute();
+    this.autoConfigured = true;
+    if (provider) {
+      this.config = {
+        provider,
+        defaultProvider: provider
+      };
+    }
+  }
   /**
    * Get the default provider, throwing if not configured
    */
   getDefaultProvider() {
+    this.ensureConfigured();
     const provider = this.config?.defaultProvider || this.config?.provider;
     if (!provider) {
       throw new Error(
-        "No default provider configured. Either call compute.setConfig({ defaultProvider }) or pass provider explicitly."
+        "No default provider configured.\n\nOptions:\n1. Zero-config mode: Set COMPUTESDK_API_KEY and provider credentials (e.g., E2B_API_KEY)\n2. Explicit mode: Call compute.setConfig({ defaultProvider }) or pass provider to create()\n\nDocs: https://computesdk.com/docs/quickstart"
       );
     }
     return provider;
   }
-  // Future: compute.blob.*, compute.database.*, compute.git.* will be added here
-  // blob = new BlobManager();
-  // database = new DatabaseManager();  
-  // git = new GitManager();
 };
 var compute = new ComputeManager();
 function createCompute(config) {
   const manager = new ComputeManager();
+  if (!config) {
+    return manager;
+  }
   const actualProvider = config.defaultProvider || config.provider;
-  const accessToken = config.accessToken || config.jwt;
   manager["config"] = {
     provider: actualProvider,
-    defaultProvider: actualProvider,
-    apiKey: config.apiKey,
-    accessToken
+    defaultProvider: actualProvider
   };
-  manager["computeAuth"] = {
-    apiKey: config.apiKey,
-    accessToken
-  };
-  const isEnhanced = !!(config.apiKey || config.accessToken || config.jwt);
   return {
     setConfig: (cfg) => createCompute(cfg),
     getConfig: () => manager.getConfig(),
@@ -336,24 +875,15 @@ function createCompute(config) {
     sandbox: {
       create: async (params) => {
         const sandbox = await manager.sandbox.create(params);
-        if (isEnhanced) {
-          return sandbox;
-        }
         return sandbox;
       },
       getById: async (sandboxId) => {
         const sandbox = await manager.sandbox.getById(sandboxId);
         if (!sandbox) return null;
-        if (isEnhanced) {
-          return sandbox;
-        }
         return sandbox;
       },
       list: async () => {
         const sandboxes = await manager.sandbox.list();
-        if (isEnhanced) {
-          return sandboxes;
-        }
         return sandboxes;
       },
       destroy: async (sandboxId) => {
@@ -433,10 +963,9 @@ async function executeAction(body, provider) {
         sandboxId,
         provider: provider.name,
         result: {
-          stdout: result.stdout,
-          stderr: result.stderr,
+          output: result.output,
           exitCode: result.exitCode,
-          executionTime: result.executionTime
+          language: result.language
         }
       };
     }
@@ -451,9 +980,7 @@ async function executeAction(body, provider) {
           stdout: result.stdout,
           stderr: result.stderr,
           exitCode: result.exitCode,
-          executionTime: result.executionTime,
-          ...result.isBackground && { isBackground: result.isBackground },
-          ...result.pid && { pid: result.pid }
+          durationMs: result.durationMs
         }
       };
     }
@@ -565,316 +1092,22 @@ async function handleComputeRequest(paramsOrRequestOrBody, provider) {
     }, { status: 500 });
   }
 }
-
-// src/factory.ts
-function createBackgroundCommand(command, args = [], options) {
-  if (!options?.background) {
-    return { command, args, isBackground: false };
-  }
-  const fullCommand = args.length > 0 ? `${command} ${args.join(" ")}` : command;
-  return {
-    command: "sh",
-    args: ["-c", `${fullCommand} &`],
-    isBackground: true
-  };
-}
-var defaultFilesystemMethods = {
-  readFile: async (sandbox, path, runCommand) => {
-    const result = await runCommand(sandbox, "cat", [path]);
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to read file ${path}: ${result.stderr}`);
-    }
-    return result.stdout.replace(/\n$/, "");
-  },
-  writeFile: async (sandbox, path, content, runCommand) => {
-    const result = await runCommand(sandbox, "sh", ["-c", `echo ${JSON.stringify(content)} > ${JSON.stringify(path)}`]);
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to write file ${path}: ${result.stderr}`);
-    }
-  },
-  mkdir: async (sandbox, path, runCommand) => {
-    const result = await runCommand(sandbox, "mkdir", ["-p", path]);
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to create directory ${path}: ${result.stderr}`);
-    }
-  },
-  readdir: async (sandbox, path, runCommand) => {
-    let result = await runCommand(sandbox, "ls", ["-la", path]);
-    let hasDetailedOutput = true;
-    if (result.exitCode !== 0) {
-      result = await runCommand(sandbox, "ls", ["-l", path]);
-    }
-    if (result.exitCode !== 0) {
-      result = await runCommand(sandbox, "ls", [path]);
-      hasDetailedOutput = false;
-    }
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to list directory ${path}: ${result.stderr}`);
-    }
-    const lines = (result.stdout || "").split("\n").filter((line) => line.trim() && !line.startsWith("total"));
-    return lines.map((line) => {
-      if (hasDetailedOutput && line.includes(" ")) {
-        const parts = line.trim().split(/\s+/);
-        const name = parts[parts.length - 1];
-        const isDirectory = line.startsWith("d");
-        return {
-          name,
-          path: `${path}/${name}`,
-          isDirectory,
-          size: parseInt(parts[4]) || 0,
-          lastModified: /* @__PURE__ */ new Date()
-        };
-      } else {
-        const name = line.trim();
-        return {
-          name,
-          path: `${path}/${name}`,
-          isDirectory: false,
-          // Can't determine from simple ls
-          size: 0,
-          lastModified: /* @__PURE__ */ new Date()
-        };
-      }
-    });
-  },
-  exists: async (sandbox, path, runCommand) => {
-    const result = await runCommand(sandbox, "test", ["-e", path]);
-    return result.exitCode === 0;
-  },
-  remove: async (sandbox, path, runCommand) => {
-    const result = await runCommand(sandbox, "rm", ["-rf", path]);
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to remove ${path}: ${result.stderr}`);
-    }
-  }
-};
-var UnsupportedFileSystem = class {
-  constructor(providerName) {
-    this.providerName = providerName;
-  }
-  async readFile(_path) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
-  }
-  async writeFile(_path, _content) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
-  }
-  async mkdir(_path) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
-  }
-  async readdir(_path) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
-  }
-  async exists(_path) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
-  }
-  async remove(_path) {
-    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
-  }
-};
-var SupportedFileSystem = class {
-  constructor(sandbox, methods, allMethods) {
-    this.sandbox = sandbox;
-    this.methods = methods;
-    this.allMethods = allMethods;
-  }
-  async readFile(path) {
-    return this.methods.readFile(this.sandbox, path, this.allMethods.runCommand);
-  }
-  async writeFile(path, content) {
-    return this.methods.writeFile(this.sandbox, path, content, this.allMethods.runCommand);
-  }
-  async mkdir(path) {
-    return this.methods.mkdir(this.sandbox, path, this.allMethods.runCommand);
-  }
-  async readdir(path) {
-    return this.methods.readdir(this.sandbox, path, this.allMethods.runCommand);
-  }
-  async exists(path) {
-    return this.methods.exists(this.sandbox, path, this.allMethods.runCommand);
-  }
-  async remove(path) {
-    return this.methods.remove(this.sandbox, path, this.allMethods.runCommand);
-  }
-};
-var GeneratedSandbox = class {
-  constructor(sandbox, sandboxId, providerName, methods, config, destroyMethod, providerInstance) {
-    this.sandbox = sandbox;
-    this.methods = methods;
-    this.config = config;
-    this.destroyMethod = destroyMethod;
-    this.providerInstance = providerInstance;
-    this.sandboxId = sandboxId;
-    this.provider = providerName;
-    if (methods.filesystem) {
-      this.filesystem = new SupportedFileSystem(sandbox, methods.filesystem, methods);
-    } else {
-      this.filesystem = new UnsupportedFileSystem(providerName);
-    }
-  }
-  getInstance() {
-    if (this.methods.getInstance) {
-      return this.methods.getInstance(this.sandbox);
-    }
-    return this.sandbox;
-  }
-  async runCode(code, runtime) {
-    return await this.methods.runCode(this.sandbox, code, runtime, this.config);
-  }
-  async runCommand(command, args, options) {
-    return await this.methods.runCommand(this.sandbox, command, args, options);
-  }
-  async getInfo() {
-    return await this.methods.getInfo(this.sandbox);
-  }
-  async getUrl(options) {
-    return await this.methods.getUrl(this.sandbox, options);
-  }
-  getProvider() {
-    return this.providerInstance;
-  }
-  async kill() {
-    await this.destroy();
-  }
-  async destroy() {
-    await this.destroyMethod(this.config, this.sandboxId);
-  }
-};
-var GeneratedSandboxManager = class {
-  constructor(config, providerName, methods, providerInstance) {
-    this.config = config;
-    this.providerName = providerName;
-    this.methods = methods;
-    this.providerInstance = providerInstance;
-    this.activeSandboxes = /* @__PURE__ */ new Map();
-  }
-  async create(options) {
-    const optionsWithDefaults = { runtime: "node", ...options };
-    const result = await this.methods.create(this.config, optionsWithDefaults);
-    const sandbox = new GeneratedSandbox(
-      result.sandbox,
-      result.sandboxId,
-      this.providerName,
-      this.methods,
-      this.config,
-      this.methods.destroy,
-      this.providerInstance
-    );
-    this.activeSandboxes.set(result.sandboxId, sandbox);
-    return sandbox;
-  }
-  async getById(sandboxId) {
-    const existing = this.activeSandboxes.get(sandboxId);
-    if (existing) {
-      return existing;
-    }
-    const result = await this.methods.getById(this.config, sandboxId);
-    if (!result) {
-      return null;
-    }
-    const sandbox = new GeneratedSandbox(
-      result.sandbox,
-      result.sandboxId,
-      this.providerName,
-      this.methods,
-      this.config,
-      this.methods.destroy,
-      this.providerInstance
-    );
-    this.activeSandboxes.set(result.sandboxId, sandbox);
-    return sandbox;
-  }
-  async list() {
-    const results = await this.methods.list(this.config);
-    const sandboxes = [];
-    for (const result of results) {
-      let sandbox = this.activeSandboxes.get(result.sandboxId);
-      if (!sandbox) {
-        sandbox = new GeneratedSandbox(
-          result.sandbox,
-          result.sandboxId,
-          this.providerName,
-          this.methods,
-          this.config,
-          this.methods.destroy,
-          this.providerInstance
-        );
-        this.activeSandboxes.set(result.sandboxId, sandbox);
-      }
-      sandboxes.push(sandbox);
-    }
-    return sandboxes;
-  }
-  async destroy(sandboxId) {
-    await this.methods.destroy(this.config, sandboxId);
-    this.activeSandboxes.delete(sandboxId);
-  }
-};
-var GeneratedTemplateManager = class {
-  constructor(config, methods) {
-    this.config = config;
-    this.methods = methods;
-  }
-  async create(options) {
-    return await this.methods.create(this.config, options);
-  }
-  async list(options) {
-    return await this.methods.list(this.config, options);
-  }
-  async delete(templateId) {
-    return await this.methods.delete(this.config, templateId);
-  }
-};
-var GeneratedSnapshotManager = class {
-  constructor(config, methods) {
-    this.config = config;
-    this.methods = methods;
-  }
-  async create(sandboxId, options) {
-    return await this.methods.create(this.config, sandboxId, options);
-  }
-  async list(options) {
-    return await this.methods.list(this.config, options);
-  }
-  async delete(snapshotId) {
-    return await this.methods.delete(this.config, snapshotId);
-  }
-};
-var GeneratedProvider = class {
-  // Phantom type for TypeScript inference
-  constructor(config, providerConfig) {
-    this.name = providerConfig.name;
-    this.sandbox = new GeneratedSandboxManager(
-      config,
-      providerConfig.name,
-      providerConfig.methods.sandbox,
-      this
-    );
-    if (providerConfig.methods.template) {
-      this.template = new GeneratedTemplateManager(config, providerConfig.methods.template);
-    }
-    if (providerConfig.methods.snapshot) {
-      this.snapshot = new GeneratedSnapshotManager(config, providerConfig.methods.snapshot);
-    }
-  }
-  getSupportedRuntimes() {
-    return ["node", "python"];
-  }
-};
-function createProvider(providerConfig) {
-  if (!providerConfig.methods.sandbox.filesystem) {
-    providerConfig.methods.sandbox.filesystem = defaultFilesystemMethods;
-  }
-  return (config) => {
-    return new GeneratedProvider(config, providerConfig);
-  };
-}
 export {
   CommandExitError,
+  GATEWAY_URL,
+  PROVIDER_ENV_VARS,
+  PROVIDER_PRIORITY,
+  Sandbox,
+  autoConfigureCompute,
+  calculateBackoff,
   compute,
-  createBackgroundCommand,
   createCompute,
   createProvider,
+  detectProvider,
+  gateway,
+  getProviderHeaders,
   handleComputeRequest,
-  isCommandExitError
+  isCommandExitError,
+  isGatewayModeEnabled
 };
 //# sourceMappingURL=index.mjs.map