computesdk 2.5.3 → 2.6.0

package/dist/index.mjs

@@ -3491,16 +3491,15 @@ API request failed (${response.status}): ${error}`
     const parts = url.hostname.split(".");
     const subdomain = parts[0];
     const baseDomain = parts.slice(1).join(".");
-    const previewDomain = baseDomain.replace("sandbox.computesdk.com", "preview.computesdk.com");
-    return `${protocol}://${subdomain}-${options.port}.${previewDomain}`;
+    return `${protocol}://${subdomain}-${options.port}.${baseDomain}`;
   }
   /**
    * Get provider instance
-   * Note: Not available when using Sandbox directly - only available through gateway provider
+   * Note: Not available on direct Sandbox client instances
    */
   getProvider() {
     throw new Error(
-      "getProvider() is not available on Sandbox. This method is only available when using provider sandboxes through the gateway."
+      "getProvider() is not available on Sandbox. This method is only available on provider SDK sandbox wrappers."
     );
   }
   /**
@@ -3513,7 +3512,7 @@ API request failed (${response.status}): ${error}`
   /**
    * Destroy the sandbox (Sandbox interface method)
    * 
-   * If a destroyHandler was provided (e.g., from gateway), calls it to destroy
+   * If a destroyHandler was provided, calls it to destroy
    * the sandbox on the backend. Otherwise, only disconnects the WebSocket.
    */
   async destroy() {
@@ -3574,1003 +3573,331 @@ var encodeSetupPayload = (options) => {
   return encodeBase64(JSON.stringify(payload));
 };
 
-// src/provider-config.ts
-var PROVIDER_AUTH = {
-  e2b: [["E2B_API_KEY"]],
-  modal: [["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"]],
-  railway: [["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"]],
-  render: [["RENDER_API_KEY", "RENDER_OWNER_ID"]],
-  daytona: [["DAYTONA_API_KEY"]],
-  vercel: [
-    ["VERCEL_OIDC_TOKEN"],
-    ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"]
-  ],
-  runloop: [["RUNLOOP_API_KEY"]],
-  cloudflare: [
-    ["CLOUDFLARE_SANDBOX_URL", "CLOUDFLARE_SANDBOX_SECRET"],
-    ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"]
-  ],
-  codesandbox: [["CSB_API_KEY"]],
-  blaxel: [["BL_API_KEY", "BL_WORKSPACE"]],
-  namespace: [["NSC_TOKEN"], ["NSC_TOKEN_FILE"]],
-  hopx: [["HOPX_API_KEY"]],
-  beam: [["BEAM_TOKEN", "BEAM_WORKSPACE_ID"]],
-  sprites: [["SPRITES_TOKEN"]],
-  freestyle: [["FREESTYLE_API_KEY"]],
-  upstash: [["UPSTASH_BOX_API_KEY"]],
-  "just-bash": [[]],
-  "secure-exec": [[]]
-};
-var PROVIDER_NAMES = Object.keys(PROVIDER_AUTH);
-var PROVIDER_HEADERS = {
-  e2b: {
-    apiKey: "X-E2B-API-Key"
-  },
-  modal: {
-    tokenId: "X-Modal-Token-Id",
-    tokenSecret: "X-Modal-Token-Secret"
-  },
-  railway: {
-    apiToken: "X-Railway-API-Key",
-    projectId: "X-Railway-Project-ID",
-    environmentId: "X-Railway-Environment-ID"
-  },
-  render: {
-    apiKey: "X-Render-API-Key",
-    ownerId: "X-Render-Owner-ID"
-  },
-  daytona: {
-    apiKey: "X-Daytona-API-Key"
-  },
-  vercel: {
-    oidcToken: "X-Vercel-OIDC-Token",
-    token: "X-Vercel-Token",
-    teamId: "X-Vercel-Team-Id",
-    projectId: "X-Vercel-Project-Id"
-  },
-  runloop: {
-    apiKey: "X-Runloop-API-Key"
-  },
-  cloudflare: {
-    sandboxUrl: "X-Cloudflare-Sandbox-Url",
-    sandboxSecret: "X-Cloudflare-Sandbox-Secret",
-    apiToken: "X-Cloudflare-API-Token",
-    accountId: "X-Cloudflare-Account-Id"
-  },
-  codesandbox: {
-    apiKey: "X-CODESANDBOX-API-Key"
-  },
-  blaxel: {
-    apiKey: "X-Blaxel-API-Key",
-    workspace: "X-Blaxel-Workspace"
-  },
-  namespace: {
-    token: "X-Namespace-Token"
-  },
-  hopx: {
-    apiKey: "X-HOPX-API-Key"
-  },
-  beam: {
-    token: "X-Beam-Token",
-    workspaceId: "X-Beam-Workspace-Id"
-  },
-  sprites: {
-    apiKey: "X-Sprites-Token"
-  },
-  freestyle: {
-    apiKey: "X-Freestyle-API-Key"
-  },
-  upstash: {
-    apiKey: "X-Upstash-Box-API-Key"
-  },
-  "just-bash": {},
-  "secure-exec": {}
-};
-var PROVIDER_ENV_MAP = {
-  e2b: {
-    E2B_API_KEY: "apiKey"
-  },
-  modal: {
-    MODAL_TOKEN_ID: "tokenId",
-    MODAL_TOKEN_SECRET: "tokenSecret"
-  },
-  railway: {
-    RAILWAY_API_KEY: "apiToken",
-    RAILWAY_PROJECT_ID: "projectId",
-    RAILWAY_ENVIRONMENT_ID: "environmentId"
-  },
-  render: {
-    RENDER_API_KEY: "apiKey",
-    RENDER_OWNER_ID: "ownerId"
-  },
-  daytona: {
-    DAYTONA_API_KEY: "apiKey"
-  },
-  vercel: {
-    VERCEL_OIDC_TOKEN: "oidcToken",
-    VERCEL_TOKEN: "token",
-    VERCEL_TEAM_ID: "teamId",
-    VERCEL_PROJECT_ID: "projectId"
-  },
-  runloop: {
-    RUNLOOP_API_KEY: "apiKey"
-  },
-  cloudflare: {
-    CLOUDFLARE_SANDBOX_URL: "sandboxUrl",
-    CLOUDFLARE_SANDBOX_SECRET: "sandboxSecret",
-    CLOUDFLARE_API_TOKEN: "apiToken",
-    CLOUDFLARE_ACCOUNT_ID: "accountId"
-  },
-  codesandbox: {
-    CSB_API_KEY: "apiKey"
-  },
-  blaxel: {
-    BL_API_KEY: "apiKey",
-    BL_WORKSPACE: "workspace"
-  },
-  namespace: {
-    NSC_TOKEN: "token",
-    NSC_TOKEN_FILE: "tokenFile"
-  },
-  hopx: {
-    HOPX_API_KEY: "apiKey"
-  },
-  beam: {
-    BEAM_TOKEN: "token",
-    BEAM_WORKSPACE_ID: "workspaceId"
-  },
-  sprites: {
-    SPRITES_TOKEN: "apiKey"
-  },
-  freestyle: {
-    FREESTYLE_API_KEY: "apiKey"
-  },
-  upstash: {
-    UPSTASH_BOX_API_KEY: "apiKey"
-  },
-  "just-bash": {},
-  "secure-exec": {}
-};
-var PROVIDER_DASHBOARD_URLS = {
-  e2b: "https://e2b.dev/dashboard",
-  modal: "https://modal.com/settings",
-  railway: "https://railway.app/account/tokens",
-  render: "https://dashboard.render.com/account",
-  daytona: "https://daytona.io/dashboard",
-  vercel: "https://vercel.com/account/tokens",
-  runloop: "https://runloop.ai/dashboard",
-  cloudflare: "https://dash.cloudflare.com/profile/api-tokens",
-  codesandbox: "https://codesandbox.io/dashboard/settings",
-  blaxel: "https://blaxel.ai/dashboard",
-  namespace: "https://cloud.namespace.so",
-  hopx: "https://hopx.ai/dashboard",
-  beam: "https://app.beam.cloud",
-  sprites: "https://sprites.dev",
-  freestyle: "https://dash.freestyle.sh",
-  upstash: "https://console.upstash.com",
-  "just-bash": "https://github.com/vercel-labs/just-bash",
-  "secure-exec": "https://github.com/anomalyco/secure-exec"
-};
-function isValidProvider(name) {
-  return name in PROVIDER_AUTH;
-}
-function buildProviderHeaders(provider, config) {
-  const headers = {};
-  const headerMap = PROVIDER_HEADERS[provider];
-  for (const [configKey, headerName] of Object.entries(headerMap)) {
-    const value = config[configKey];
-    if (value) {
-      headers[headerName] = value;
-    }
-  }
-  return headers;
-}
-function getProviderConfigFromEnv(provider) {
-  const config = {};
-  const envMap = PROVIDER_ENV_MAP[provider];
-  for (const [envVar, configKey] of Object.entries(envMap)) {
-    const value = process.env[envVar];
-    if (value) {
-      config[configKey] = value;
-    }
-  }
-  return config;
-}
-function isProviderAuthComplete(provider) {
-  const authOptions = PROVIDER_AUTH[provider];
-  for (const option of authOptions) {
-    const allPresent = option.every((envVar) => !!process.env[envVar]);
-    if (allPresent) return true;
-  }
-  return false;
-}
-function getMissingEnvVars(provider) {
-  const authOptions = PROVIDER_AUTH[provider];
-  let bestOption = null;
-  for (const option of authOptions) {
-    const missing = [];
-    let presentCount = 0;
-    for (const envVar of option) {
-      if (process.env[envVar]) {
-        presentCount++;
-      } else {
-        missing.push(envVar);
-      }
-    }
-    if (missing.length === 0) return [];
-    if (!bestOption || presentCount > bestOption.presentCount) {
-      bestOption = { presentCount, missing };
-    }
-  }
-  return bestOption?.missing ?? [];
-}
-
-// src/constants.ts
-var TRIBUTARY_URL = "https://tributary.edge.computesdk.com";
-var PROVIDER_PRIORITY = [
-  "e2b",
-  "railway",
-  "render",
-  "daytona",
-  "modal",
-  "runloop",
-  "vercel",
-  "cloudflare",
-  "codesandbox",
-  "blaxel",
-  "namespace",
-  "hopx",
-  "beam",
-  "sprites",
-  "freestyle",
-  "upstash",
-  "secure-exec"
-];
-var PROVIDER_ENV_VARS = {
-  e2b: ["E2B_API_KEY"],
-  railway: ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"],
-  render: ["RENDER_API_KEY", "RENDER_OWNER_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"],
-  namespace: ["NSC_TOKEN"],
-  hopx: ["HOPX_API_KEY"],
-  beam: ["BEAM_TOKEN", "BEAM_WORKSPACE_ID"],
-  sprites: ["SPRITES_TOKEN"],
-  freestyle: ["FREESTYLE_API_KEY"],
-  upstash: ["UPSTASH_BOX_API_KEY"],
-  "just-bash": [],
-  "secure-exec": []
-};
-
-// 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 || requiredVars.length === 0) 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;
-    case "namespace":
-      if (process.env.NSC_TOKEN) {
-        headers["X-Namespace-Token"] = process.env.NSC_TOKEN;
-      }
-      break;
-    case "hopx":
-      if (process.env.HOPX_API_KEY) {
-        headers["X-HOPX-API-Key"] = process.env.HOPX_API_KEY;
-      }
-      break;
-    case "render":
-      if (process.env.RENDER_API_KEY) {
-        headers["X-Render-API-Key"] = process.env.RENDER_API_KEY;
-      }
-      if (process.env.RENDER_OWNER_ID) {
-        headers["X-Render-Owner-ID"] = process.env.RENDER_OWNER_ID;
-      }
-      break;
-    case "beam":
-      if (process.env.BEAM_TOKEN) {
-        headers["X-Beam-Token"] = process.env.BEAM_TOKEN;
-      }
-      if (process.env.BEAM_WORKSPACE_ID) {
-        headers["X-Beam-Workspace-Id"] = process.env.BEAM_WORKSPACE_ID;
-      }
-      break;
-    case "sprites":
-      if (process.env.SPRITES_TOKEN) {
-        headers["X-Sprites-Token"] = process.env.SPRITES_TOKEN;
-      }
-      break;
-    case "just-bash":
-      break;
-    case "secure-exec":
-      break;
-    case "upstash":
-      if (process.env.UPSTASH_BOX_API_KEY) {
-        headers["X-Upstash-Box-API-Key"] = process.env.UPSTASH_BOX_API_KEY;
-      }
-      break;
-  }
-  return headers;
+// src/compute.ts
+function isProviderLike(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  const sandbox = candidate.sandbox;
+  return !!(sandbox && typeof sandbox.create === "function" && typeof sandbox.getById === "function" && typeof sandbox.destroy === "function");
 }
-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.
-
-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
-  Namespace:  export NSC_TOKEN=xxx
-  HopX:       export HOPX_API_KEY=xxx
-  Render:     export RENDER_API_KEY=xxx RENDER_OWNER_ID=xxx
-  Beam:       export BEAM_TOKEN=xxx BEAM_WORKSPACE_ID=xxx
-  Sprites:    export SPRITES_TOKEN=xxx
-  Upstash:    export UPSTASH_BOX_API_KEY=xxx
-  just-bash:  (no credentials needed - local sandbox)
-  secure-exec: (no credentials needed - local sandbox)
-
-Or set COMPUTESDK_PROVIDER to specify explicitly:
-  export COMPUTESDK_PROVIDER=<provider>
-
-Docs: https://computesdk.com/docs/quickstart`
-    );
-  }
-  const gatewayUrl = process.env.COMPUTESDK_TRIBUTARY_URL || TRIBUTARY_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_TRIBUTARY_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(", "));
-  }
-  const config = {
-    apiKey: computesdkApiKey,
-    gatewayUrl,
-    provider,
-    providerHeaders
-  };
-  return config;
+function getProviderLabel(provider, index) {
+  return provider.name || `provider-${index + 1}`;
 }
-
-// src/explicit-config.ts
-function buildProviderHeaders2(config) {
-  const headers = {};
-  const provider = config.provider;
-  const headerMap = PROVIDER_HEADERS[provider];
-  const providerConfig = config[provider];
-  if (!providerConfig || !headerMap) return headers;
-  for (const [configKey, headerName] of Object.entries(headerMap)) {
-    const value = providerConfig[configKey];
-    if (value) {
-      headers[headerName] = value;
-    }
+function getProviderErrorDetail(error) {
+  if (error instanceof Error) {
+    return error.message;
   }
-  return headers;
+  return String(error);
 }
-function validateProviderConfig(config) {
-  const provider = config.provider;
-  const authOptions = PROVIDER_AUTH[provider];
-  const providerConfig = config[provider];
-  const dashboardUrl = PROVIDER_DASHBOARD_URLS[provider];
-  if (!authOptions) {
-    throw new Error(`Unknown provider: ${provider}`);
-  }
-  for (const option of authOptions) {
-    const allPresent = option.every((envVar) => {
-      const configField = envVarToConfigField(provider, envVar);
-      return providerConfig?.[configField];
-    });
-    if (allPresent) return;
+function resolveProviders(config) {
+  const candidates = [];
+  if (config.provider) {
+    candidates.push(config.provider);
+  }
+  if (Array.isArray(config.providers)) {
+    candidates.push(...config.providers);
+  }
+  const providers = [];
+  const seen = /* @__PURE__ */ new Set();
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (!isProviderLike(candidate)) continue;
+    if (seen.has(candidate)) continue;
+    const name = candidate.name;
+    if (name && seenNames.has(name)) continue;
+    providers.push(candidate);
+    seen.add(candidate);
+    if (name) {
+      seenNames.add(name);
+    }
+  }
+  if (providers.length > 0) {
+    return providers;
   }
-  const configExample = buildConfigExample(provider, authOptions);
   throw new Error(
-    `Missing ${provider} configuration. When using provider: '${provider}', you must provide:
-${configExample}
-
-Get your credentials at: ${dashboardUrl}`
-  );
-}
-function envVarToConfigField(provider, envVar) {
-  return PROVIDER_ENV_MAP[provider]?.[envVar] ?? envVar.toLowerCase();
-}
-function buildConfigExample(provider, authOptions) {
-  if (authOptions.length === 1) {
-    const fields = authOptions[0].map((envVar) => {
-      const field = envVarToConfigField(provider, envVar);
-      return `${field}: '...'`;
-    });
-    return `  ${provider}: { ${fields.join(", ")} }`;
-  }
-  const options = authOptions.map((option, i) => {
-    const fields = option.map((envVar) => {
-      const field = envVarToConfigField(provider, envVar);
-      return `${field}: '...'`;
-    });
-    return `  Option ${i + 1}:
-    ${provider}: { ${fields.join(", ")} }`;
-  });
-  return options.join("\n\n");
-}
-function createConfigFromExplicit(config) {
-  const computesdkApiKey = config.computesdkApiKey || config.apiKey;
-  if (!computesdkApiKey) {
-    throw new Error(
-      `Missing ComputeSDK API key. Set 'computesdkApiKey' in your config.
-
-Example:
-  compute.setConfig({
-    provider: 'e2b',
-    computesdkApiKey: process.env.COMPUTESDK_API_KEY,
-    e2b: { apiKey: process.env.E2B_API_KEY }
-  })
-
-Get your API key at: https://computesdk.com/dashboard`
-    );
-  }
-  validateProviderConfig(config);
-  const providerHeaders = buildProviderHeaders2(config);
-  return {
-    apiKey: computesdkApiKey,
-    gatewayUrl: config.gatewayUrl || process.env.COMPUTESDK_TRIBUTARY_URL || TRIBUTARY_URL,
-    provider: config.provider,
-    providerHeaders,
-    requestTimeoutMs: config.requestTimeoutMs,
-    WebSocket: config.WebSocket
-  };
-}
-
-// src/compute-daemon/lifecycle.ts
-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(
-          `Sandbox failed to become ready after ${maxRetries} attempts.
-Last error: ${lastError.message}
-
-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, currentDelay));
-      currentDelay = Math.min(currentDelay * backoffFactor, maxDelayMs);
-    }
-  }
-}
-
-// src/compute.ts
-async function tributaryFetch(url, config, options = {}) {
-  const timeout = config.requestTimeoutMs ?? 3e4;
-  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);
-    if (!response.ok) {
-      if (response.status === 404) {
-        return { success: false };
-      }
-      const errorText = await response.text().catch(() => response.statusText);
-      let errorMessage = `Gateway API error: ${errorText}`;
-      if (response.status === 401) {
-        errorMessage = `Invalid ComputeSDK API key. Check your COMPUTESDK_API_KEY environment variable.`;
-      } else if (response.status === 403) {
-        errorMessage = `Access forbidden. Your API key may not have permission to use provider "${config.provider}".`;
-      }
-      throw new Error(errorMessage);
-    }
-    return await response.json();
-  } catch (error) {
-    clearTimeout(timeoutId);
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error(`Request timed out after ${timeout}ms`);
-    }
-    throw error;
-  }
-}
-async function waitForSandboxStatus(config, endpoint, body, options = {}) {
-  const maxWaitMs = options.maxWaitMs ?? 6e4;
-  const initialDelayMs = 500;
-  const maxDelayMs = 2e3;
-  const backoffFactor = 1.5;
-  const startTime = Date.now();
-  let currentDelay = initialDelayMs;
-  while (Date.now() - startTime < maxWaitMs) {
-    const result = await tributaryFetch(endpoint, config, {
-      method: "POST",
-      body: JSON.stringify(body)
-    });
-    if (!result.success || !result.data) {
-      return result;
-    }
-    if (result.data.status !== "creating") {
-      return result;
-    }
-    if (process.env.COMPUTESDK_DEBUG) {
-      console.log(`[Compute] Sandbox still creating, waiting ${currentDelay}ms...`);
-    }
-    await new Promise((resolve) => setTimeout(resolve, currentDelay));
-    currentDelay = Math.min(currentDelay * backoffFactor, maxDelayMs);
-  }
-  throw new Error(
-    `Sandbox is still being created after ${maxWaitMs}ms. This may indicate the sandbox failed to start. Check your provider dashboard.`
+    "No provider instance configured.\n\nConfigure compute with provider instances:\n\n  compute.setConfig({ providers: [e2b({...}), modal({...})] })\n  // or: compute.setConfig({ provider: e2b({...}) })"
   );
 }
 var ComputeManager = class {
   constructor() {
-    this.config = null;
-    this.autoConfigured = false;
+    this.providers = [];
+    this.providerStrategy = "priority";
+    this.fallbackOnError = true;
+    this.roundRobinCursor = 0;
+    this.sandboxProviders = /* @__PURE__ */ new Map();
+    this.snapshotProviders = /* @__PURE__ */ new Map();
     this.sandbox = {
-      /**
-       * Create a new sandbox
-       *
-       * @example
-       * ```typescript
-       * const sandbox = await compute.sandbox.create({
-       *   directory: '/custom/path',
-       *   overlays: [
-       *     {
-       *       source: '/templates/nextjs',
-       *       target: 'app',
-       *       strategy: 'smart',
-       *     },
-       *   ],
-       *   servers: [
-       *     {
-       *       slug: 'web',
-       *       start: 'npm run dev',
-       *       path: '/app',
-       *     },
-       *   ],
-       * });
-       * ```
-       */
       create: async (options) => {
-        const config = this.getGatewayConfig();
-        const result = await tributaryFetch(`${config.gatewayUrl}/v1/sandboxes`, config, {
-          method: "POST",
-          body: JSON.stringify(options || {})
-        });
-        if (!result.success || !result.data) {
-          throw new Error(`Gateway returned invalid response`);
-        }
-        const { sandboxId, url, token, provider, metadata, name, namespace, overlays, servers } = result.data;
-        const sandbox = new Sandbox({
-          sandboxUrl: url,
-          sandboxId,
-          provider,
-          token: token || config.apiKey,
-          metadata: {
-            ...metadata,
-            ...name && { name },
-            ...namespace && { namespace },
-            ...overlays && { overlays },
-            ...servers && { servers }
-          },
-          WebSocket: config.WebSocket || globalThis.WebSocket,
-          destroyHandler: async () => {
-            await tributaryFetch(`${config.gatewayUrl}/v1/sandboxes/${sandboxId}`, config, {
-              method: "DELETE"
-            });
-          }
-        });
-        await waitForComputeReady(sandbox);
-        return sandbox;
+        return this.createWithFallback(options);
       },
-      /**
-       * Get an existing sandbox by ID
-       */
       getById: async (sandboxId) => {
-        const config = this.getGatewayConfig();
-        const result = await tributaryFetch(`${config.gatewayUrl}/v1/sandboxes/${sandboxId}`, config);
-        if (!result.success || !result.data) {
-          return null;
-        }
-        const { url, token, provider, metadata } = result.data;
-        const sandbox = new Sandbox({
-          sandboxUrl: url,
-          sandboxId,
-          provider,
-          token: token || config.apiKey,
-          metadata,
-          WebSocket: config.WebSocket || globalThis.WebSocket,
-          destroyHandler: async () => {
-            await tributaryFetch(`${config.gatewayUrl}/v1/sandboxes/${sandboxId}`, config, {
-              method: "DELETE"
-            });
+        for (const provider of this.getByIdCandidates(sandboxId)) {
+          const sandbox = await provider.sandbox.getById(sandboxId);
+          if (sandbox) {
+            this.registerSandboxProvider(sandbox, provider);
+            return sandbox;
           }
-        });
-        await waitForComputeReady(sandbox);
-        return sandbox;
+        }
+        this.sandboxProviders.delete(sandboxId);
+        return null;
       },
-      /**
-       * List all active sandboxes
-       */
       list: async () => {
-        throw new Error(
-          "The gateway does not support listing sandboxes. Use getById() with a known sandbox ID instead."
-        );
+        const all = [];
+        for (const provider of this.getProviders()) {
+          if (!provider.sandbox.list) {
+            continue;
+          }
+          const sandboxes = await provider.sandbox.list();
+          for (const sandbox of sandboxes) {
+            this.registerSandboxProvider(sandbox, provider);
+          }
+          all.push(...sandboxes);
+        }
+        return all;
       },
-      /**
-       * Destroy a sandbox
-       */
       destroy: async (sandboxId) => {
-        const config = this.getGatewayConfig();
-        await tributaryFetch(`${config.gatewayUrl}/v1/sandboxes/${sandboxId}`, config, {
-          method: "DELETE"
-        });
-      },
-      /**
-       * Find existing or create new sandbox by (namespace, name)
-       */
-      findOrCreate: async (options) => {
-        const config = this.getGatewayConfig();
-        const { name, namespace, ...restOptions } = options;
-        const result = await waitForSandboxStatus(
-          config,
-          `${config.gatewayUrl}/v1/sandboxes/find-or-create`,
-          {
-            namespace: namespace || "default",
-            name,
-            ...restOptions
+        const candidates = this.getByIdCandidates(sandboxId);
+        const errors = [];
+        for (const [index, provider] of candidates.entries()) {
+          try {
+            await provider.sandbox.destroy(sandboxId);
+            this.sandboxProviders.delete(sandboxId);
+            return;
+          } catch (error) {
+            errors.push(`${getProviderLabel(provider, index)}: ${getProviderErrorDetail(error)}`);
           }
-        );
-        if (!result.success || !result.data) {
-          throw new Error(`Gateway returned invalid response`);
         }
-        const { sandboxId, url, token, provider, metadata } = result.data;
-        const sandbox = new Sandbox({
-          sandboxUrl: url,
-          sandboxId,
-          provider,
-          token: token || config.apiKey,
-          metadata: {
-            ...metadata,
-            name: result.data.name,
-            namespace: result.data.namespace
-          },
-          WebSocket: config.WebSocket || globalThis.WebSocket,
-          destroyHandler: async () => {
-            await tributaryFetch(`${config.gatewayUrl}/v1/sandboxes/${sandboxId}`, config, {
-              method: "DELETE"
-            });
-          }
-        });
-        await waitForComputeReady(sandbox);
-        return sandbox;
+        throw new Error(
+          `Failed to destroy sandbox "${sandboxId}" across ${candidates.length} provider(s).
+` + errors.map((error) => `- ${error}`).join("\n")
+        );
+      },
+      findOrCreate: async (options) => {
+        return this.findOrCreateWithFallback(options);
       },
-      /**
-       * Find existing sandbox by (namespace, name) without creating
-       */
       find: async (options) => {
-        const config = this.getGatewayConfig();
-        const result = await waitForSandboxStatus(
-          config,
-          `${config.gatewayUrl}/v1/sandboxes/find`,
-          {
-            namespace: options.namespace || "default",
-            name: options.name
+        const preferredProviderName = options.provider;
+        const { provider: _providerName, ...providerOptions } = options;
+        const candidates = this.getCreateCandidates(preferredProviderName);
+        for (const provider of candidates) {
+          if (!provider.sandbox.find) {
+            continue;
           }
-        );
-        if (!result.success || !result.data) {
-          return null;
-        }
-        const { sandboxId, url, token, provider, metadata, name, namespace } = result.data;
-        const sandbox = new Sandbox({
-          sandboxUrl: url,
-          sandboxId,
-          provider,
-          token: token || config.apiKey,
-          metadata: {
-            ...metadata,
-            name,
-            namespace
-          },
-          WebSocket: config.WebSocket || globalThis.WebSocket,
-          destroyHandler: async () => {
-            await tributaryFetch(`${config.gatewayUrl}/v1/sandboxes/${sandboxId}`, config, {
-              method: "DELETE"
-            });
+          const sandbox = await provider.sandbox.find(providerOptions);
+          if (sandbox) {
+            this.registerSandboxProvider(sandbox, provider);
+            return sandbox;
           }
-        });
-        await waitForComputeReady(sandbox);
-        return sandbox;
+        }
+        return null;
       },
-      /**
-       * Extend sandbox timeout/expiration
-       */
       extendTimeout: async (sandboxId, options) => {
-        const config = this.getGatewayConfig();
-        const duration = options?.duration ?? 9e5;
-        await tributaryFetch(`${config.gatewayUrl}/v1/sandboxes/${sandboxId}/extend`, config, {
-          method: "POST",
-          body: JSON.stringify({ duration })
-        });
+        const candidates = this.getByIdCandidates(sandboxId);
+        const errors = [];
+        for (const [index, provider] of candidates.entries()) {
+          if (!provider.sandbox.extendTimeout) {
+            errors.push(`${getProviderLabel(provider, index)}: extendTimeout() not supported`);
+            continue;
+          }
+          try {
+            await provider.sandbox.extendTimeout(sandboxId, options);
+            this.sandboxProviders.set(sandboxId, provider);
+            return;
+          } catch (error) {
+            errors.push(`${getProviderLabel(provider, index)}: ${getProviderErrorDetail(error)}`);
+          }
+        }
+        throw new Error(
+          `Failed to extend timeout for sandbox "${sandboxId}" across ${candidates.length} provider(s).
+` + errors.map((error) => `- ${error}`).join("\n")
+        );
       }
     };
     this.snapshot = {
-      /**
-       * Create a snapshot from a running sandbox
-       * 
-       * @param sandboxId ID of the sandbox to snapshot
-       * @param options Snapshot options (name, metadata)
-       */
       create: async (sandboxId, options) => {
-        const config = this.getGatewayConfig();
-        const result = await tributaryFetch(`${config.gatewayUrl}/v1/snapshots`, config, {
-          method: "POST",
-          body: JSON.stringify({ sandboxId, ...options })
-        });
-        if (!result.success || !result.data) {
-          throw new Error(`Gateway returned invalid response`);
+        const preferredProviderName = options?.provider;
+        const { provider: _providerName, ...providerOptions } = options || {};
+        const candidates = this.getSnapshotCreateCandidates(sandboxId, preferredProviderName);
+        const errors = [];
+        for (const [index, provider] of candidates.entries()) {
+          if (!provider.snapshot) {
+            errors.push(`${getProviderLabel(provider, index)}: snapshots not supported`);
+            continue;
+          }
+          try {
+            const snapshot = await provider.snapshot.create(sandboxId, providerOptions);
+            this.snapshotProviders.set(snapshot.id, provider);
+            return {
+              ...snapshot,
+              createdAt: new Date(snapshot.createdAt)
+            };
+          } catch (error) {
+            errors.push(`${getProviderLabel(provider, index)}: ${getProviderErrorDetail(error)}`);
+          }
         }
-        return {
-          ...result.data,
-          createdAt: new Date(result.data.createdAt)
-        };
+        throw new Error(
+          `Failed to create snapshot for sandbox "${sandboxId}" across ${candidates.length} provider(s).
+` + errors.map((error) => `- ${error}`).join("\n")
+        );
       },
-      /**
-       * List all snapshots
-       */
       list: async () => {
-        const config = this.getGatewayConfig();
-        const result = await tributaryFetch(`${config.gatewayUrl}/v1/snapshots`, config);
-        if (!result.success || !result.data) {
-          return [];
+        const snapshots = [];
+        for (const provider of this.getProviders()) {
+          if (!provider.snapshot) continue;
+          const listed = await provider.snapshot.list();
+          for (const snapshot of listed) {
+            this.snapshotProviders.set(snapshot.id, provider);
+            snapshots.push({
+              ...snapshot,
+              createdAt: new Date(snapshot.createdAt)
+            });
+          }
         }
-        return result.data.map((s) => ({
-          ...s,
-          createdAt: new Date(s.createdAt)
-        }));
+        return snapshots;
       },
-      /**
-       * Delete a snapshot
-       */
       delete: async (snapshotId) => {
-        const config = this.getGatewayConfig();
-        await tributaryFetch(`${config.gatewayUrl}/v1/snapshots/${snapshotId}`, config, {
-          method: "DELETE"
-        });
+        const candidates = this.getSnapshotDeleteCandidates(snapshotId);
+        const errors = [];
+        for (const [index, provider] of candidates.entries()) {
+          if (!provider.snapshot) continue;
+          try {
+            await provider.snapshot.delete(snapshotId);
+            this.snapshotProviders.delete(snapshotId);
+            return;
+          } catch (error) {
+            errors.push(`${getProviderLabel(provider, index)}: ${getProviderErrorDetail(error)}`);
+          }
+        }
+        throw new Error(
+          `Failed to delete snapshot "${snapshotId}" across ${candidates.length} provider(s).
+` + errors.map((error) => `- ${error}`).join("\n")
+        );
       }
     };
   }
-  /**
-   * Lazy auto-configure from environment if not explicitly configured
-   */
-  ensureConfigured() {
-    if (this.config) return;
-    if (this.autoConfigured) return;
-    const config = autoConfigureCompute();
-    this.autoConfigured = true;
-    if (config) {
-      this.config = config;
-    }
-  }
-  /**
-   * Get gateway config, throwing if not configured
-   */
-  getGatewayConfig() {
-    this.ensureConfigured();
-    if (!this.config) {
+  getProviders() {
+    if (this.providers.length === 0) {
       throw new Error(
-        `No ComputeSDK configuration found.
-
-Options:
-1. Zero-config: Set COMPUTESDK_API_KEY and provider credentials (e.g., E2B_API_KEY)
-2. Explicit: Call compute.setConfig({ provider: "e2b", computesdkApiKey: "...", e2b: { apiKey: "..." } })
-3. Use provider directly: import { e2b } from '@computesdk/e2b'
-
-Docs: https://computesdk.com/docs/quickstart`
+        "No compute provider configured.\n\nOptions:\n1. Configure providers: compute.setConfig({ providers: [e2b({...}), modal({...})] })\n2. Configure a single provider: compute.setConfig({ provider: e2b({...}) })\n3. Use provider directly: const sdk = e2b({...}); await sdk.sandbox.create()"
       );
     }
-    return this.config;
+    return this.providers;
+  }
+  getProviderByName(name) {
+    const provider = this.getProviders().find((p) => p.name === name);
+    if (!provider) {
+      const names = this.getProviders().map((p, i) => getProviderLabel(p, i)).join(", ");
+      throw new Error(`Provider "${name}" is not configured. Configured providers: ${names || "(none)"}.`);
+    }
+    return provider;
+  }
+  registerSandboxProvider(sandbox, provider) {
+    const sandboxId = sandbox?.sandboxId;
+    if (sandboxId) {
+      this.sandboxProviders.set(sandboxId, provider);
+    }
+  }
+  getCreateCandidates(preferredProviderName) {
+    const providers = this.getProviders();
+    if (preferredProviderName) {
+      return [this.getProviderByName(preferredProviderName)];
+    }
+    if (providers.length <= 1 || this.providerStrategy === "priority") {
+      return [...providers];
+    }
+    const start = this.roundRobinCursor % providers.length;
+    this.roundRobinCursor = (this.roundRobinCursor + 1) % providers.length;
+    return [
+      ...providers.slice(start),
+      ...providers.slice(0, start)
+    ];
+  }
+  getByIdCandidates(sandboxId) {
+    const known = this.sandboxProviders.get(sandboxId);
+    if (!known) return this.getProviders();
+    const providers = this.getProviders();
+    return [known, ...providers.filter((p) => p !== known)];
+  }
+  getSnapshotDeleteCandidates(snapshotId) {
+    const known = this.snapshotProviders.get(snapshotId);
+    const providers = this.getProviders().filter((p) => !!p.snapshot);
+    if (!known) return providers;
+    return [known, ...providers.filter((p) => p !== known)];
+  }
+  getSnapshotCreateCandidates(sandboxId, preferredProviderName) {
+    if (preferredProviderName) {
+      return [this.getProviderByName(preferredProviderName)];
+    }
+    const known = this.sandboxProviders.get(sandboxId);
+    const providers = this.getProviders().filter((p) => !!p.snapshot);
+    if (known && known.snapshot) {
+      return [known, ...providers.filter((p) => p !== known)];
+    }
+    return providers;
+  }
+  async createWithFallback(options) {
+    const preferredProviderName = options?.provider;
+    const { provider: _providerName, ...providerOptions } = options || {};
+    const candidates = this.getCreateCandidates(preferredProviderName);
+    const canFallback = this.fallbackOnError && !preferredProviderName;
+    const errors = [];
+    for (const [index, provider] of candidates.entries()) {
+      try {
+        const sandbox = await provider.sandbox.create(providerOptions);
+        this.registerSandboxProvider(sandbox, provider);
+        return sandbox;
+      } catch (error) {
+        errors.push(`${getProviderLabel(provider, index)}: ${getProviderErrorDetail(error)}`);
+        if (!canFallback) {
+          throw error;
+        }
+      }
+    }
+    throw new Error(
+      `Failed to create sandbox across ${candidates.length} provider(s).
+` + errors.map((error) => `- ${error}`).join("\n")
+    );
+  }
+  async findOrCreateWithFallback(options) {
+    const preferredProviderName = options.provider;
+    const { provider: _providerName, ...providerOptions } = options;
+    const candidates = this.getCreateCandidates(preferredProviderName);
+    const canFallback = this.fallbackOnError && !preferredProviderName;
+    const errors = [];
+    for (const [index, provider] of candidates.entries()) {
+      try {
+        if (!provider.sandbox.findOrCreate) {
+          errors.push(`${getProviderLabel(provider, index)}: findOrCreate() not supported`);
+          continue;
+        }
+        const sandbox = await provider.sandbox.findOrCreate(providerOptions);
+        this.registerSandboxProvider(sandbox, provider);
+        return sandbox;
+      } catch (error) {
+        errors.push(`${getProviderLabel(provider, index)}: ${getProviderErrorDetail(error)}`);
+        if (!canFallback) {
+          throw error;
+        }
+      }
+    }
+    throw new Error(
+      `Failed to findOrCreate sandbox across ${candidates.length} provider(s).
+` + errors.map((error) => `- ${error}`).join("\n")
+    );
   }
-  /**
-   * Explicitly configure the compute singleton
-   * 
-   * @example
-   * ```typescript
-   * import { compute } from 'computesdk';
-   * 
-   * compute.setConfig({
-   *   provider: 'e2b',
-   *   apiKey: 'computesdk_xxx',
-   *   e2b: { apiKey: 'e2b_xxx' }
-   * });
-   * 
-   * const sandbox = await compute.sandbox.create();
-   * ```
-   */
   setConfig(config) {
-    const gatewayConfig = createConfigFromExplicit(config);
-    this.config = gatewayConfig;
-    this.autoConfigured = false;
+    this.providers = resolveProviders(config);
+    this.providerStrategy = config.providerStrategy ?? "priority";
+    this.fallbackOnError = config.fallbackOnError ?? true;
+    this.roundRobinCursor = 0;
+    this.sandboxProviders.clear();
+    this.snapshotProviders.clear();
   }
 };
 var singletonInstance = new ComputeManager();
 function computeFactory(config) {
-  const gatewayConfig = createConfigFromExplicit(config);
   const manager = new ComputeManager();
-  manager["config"] = gatewayConfig;
+  manager.setConfig(config);
   return manager;
 }
 var compute = new Proxy(
@@ -4592,33 +3919,15 @@ var compute = new Proxy(
 export {
   CommandExitError,
   FileWatcher,
-  Sandbox as GatewaySandbox,
   MessageType,
-  PROVIDER_AUTH,
-  PROVIDER_DASHBOARD_URLS,
-  PROVIDER_ENV_MAP,
-  PROVIDER_ENV_VARS,
-  PROVIDER_HEADERS,
-  PROVIDER_NAMES,
-  PROVIDER_PRIORITY,
   Sandbox,
   SignalService,
-  TRIBUTARY_URL,
   TerminalInstance,
-  autoConfigureCompute,
-  buildProviderHeaders,
   buildSetupPayload,
   compute,
   decodeBinaryMessage,
-  detectProvider,
   encodeBinaryMessage,
   encodeSetupPayload,
-  getMissingEnvVars,
-  getProviderConfigFromEnv,
-  getProviderHeaders,
-  isCommandExitError,
-  isGatewayModeEnabled,
-  isProviderAuthComplete,
-  isValidProvider
+  isCommandExitError
 };
 //# sourceMappingURL=index.mjs.map