computesdk 2.5.4 → 2.6.0

package/dist/index.d.ts

@@ -10,11 +10,11 @@
  * - terminal, server, watcher, auth, env, etc.
  *
  * Providers can implement as much or as little as makes sense for their platform.
- * The gateway Sandbox class implements the full specification.
+ * The Sandbox client class implements the full specification.
  *
  * **Note on naming:** This interface is named "Sandbox" in this file for clarity,
  * but is exported as "SandboxInterface" from the main computesdk package to avoid
- * collision with the gateway Sandbox class. The rename happens at export time in
+ * collision with the Sandbox client class. The rename happens at export time in
  * src/index.ts. Providers using @computesdk/provider will only see "SandboxInterface".
  *
  * @example Minimal implementation
@@ -183,7 +183,7 @@ interface SandboxServerConfig {
 interface Sandbox$1 {
     /** Unique identifier for the sandbox */
     readonly sandboxId: string;
-    /** Provider name (e2b, railway, modal, gateway, etc.) */
+    /** Provider name (e2b, railway, modal, etc.) */
     readonly provider: string;
     /** Execute code in the sandbox */
     runCode(code: string, runtime?: Runtime): Promise<CodeResult$1>;
@@ -207,57 +207,57 @@ interface Sandbox$1 {
     readonly filesystem: SandboxFileSystem;
     /**
      * Terminal management (interactive PTY and exec modes)
-     * Available in: gateway, e2b (potentially)
+     * Available in: sandbox client, e2b (potentially)
      */
     readonly terminal?: any;
     /**
      * Code and command execution namespace
-     * Available in: gateway
+     * Available in: sandbox client
      */
     readonly run?: any;
     /**
      * Managed server operations
-     * Available in: gateway
+     * Available in: sandbox client
      */
     readonly server?: any;
     /**
      * File watcher with real-time change events
-     * Available in: gateway
+     * Available in: sandbox client
      */
     readonly watcher?: any;
     /**
      * Session token management
-     * Available in: gateway
+     * Available in: sandbox client
      */
     readonly sessionToken?: any;
     /**
      * Magic link authentication
-     * Available in: gateway
+     * Available in: sandbox client
      */
     readonly magicLink?: any;
     /**
      * Signal service for port/error events
-     * Available in: gateway
+     * Available in: sandbox client
      */
     readonly signal?: any;
     /**
      * File operations namespace
-     * Available in: gateway
+     * Available in: sandbox client
      */
     readonly file?: any;
     /**
      * Environment variable management
-     * Available in: gateway
+     * Available in: sandbox client
      */
     readonly env?: any;
     /**
      * Authentication operations
-     * Available in: gateway
+     * Available in: sandbox client
      */
     readonly auth?: any;
     /**
      * Child sandbox management
-     * Available in: gateway
+     * Available in: sandbox client
      */
     readonly child?: any;
 }
@@ -2257,7 +2257,7 @@ declare class Run {
 /**
  * Client Types
  *
- * Types specific to the gateway Sandbox client implementation.
+ * Types specific to the Sandbox client implementation.
  * Core universal types are imported from ../types/universal-sandbox
  */
 
@@ -2266,7 +2266,7 @@ declare class Run {
  */
 type SandboxStatus = 'running' | 'stopped' | 'error';
 /**
- * Provider-agnostic sandbox info (alias for SandboxInfo for backward compatibility)
+ * Provider-agnostic sandbox info
  */
 interface ProviderSandboxInfo {
     /** Unique identifier for the sandbox */
@@ -2461,13 +2461,13 @@ type WebSocketConstructor = new (url: string) => WebSocket;
  * Configuration options for creating a Sandbox
  */
 interface SandboxConfig {
-    /** API endpoint URL (e.g., https://sandbox-123.sandbox.computesdk.com). Optional in browser - can be auto-detected from URL query param or localStorage */
+    /** API endpoint URL (e.g., https://sandbox-123.sandbox.computesdk.com). Optional in browser - can be detected from URL query param or localStorage */
     sandboxUrl?: string;
     /** Sandbox ID */
     sandboxId: string;
-    /** Provider name (e.g., 'e2b', 'gateway') */
+    /** Provider name (e.g., 'e2b', 'modal') */
     provider: string;
-    /** Access token or session token for authentication. Optional in browser - can be auto-detected from URL query param or localStorage */
+    /** Access token or session token for authentication. Optional in browser - can be detected from URL query param or localStorage */
     token?: string;
     /** Optional headers to include with all requests */
     headers?: Record<string, string>;
@@ -2481,7 +2481,7 @@ interface SandboxConfig {
     metadata?: Record<string, unknown>;
     /**
      * Handler called when destroy() is invoked.
-     * If provided, this is called to destroy the sandbox (e.g., via gateway API).
+     * If provided, this is called to destroy the sandbox through an external API.
      * If not provided, destroy() only disconnects the WebSocket.
      * @internal
      */
@@ -3023,7 +3023,7 @@ interface BatchWriteResponse {
     };
 }
 /**
- * Sandbox - Full-featured gateway sandbox implementation
+ * Sandbox - Full-featured sandbox client implementation
  *
  * Provides complete feature set including:
  * - Interactive terminals (PTY and exec modes)
@@ -3775,7 +3775,7 @@ declare class Sandbox {
     }): Promise<string>;
     /**
      * Get provider instance
-     * Note: Not available when using Sandbox directly - only available through gateway provider
+     * Note: Not available on direct Sandbox client instances
      */
     getProvider(): never;
     /**
@@ -3786,7 +3786,7 @@ declare class Sandbox {
     /**
      * 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.
      */
     destroy(): Promise<void>;
@@ -3823,198 +3823,12 @@ declare const buildSetupPayload: (options: BuildSetupPayloadOptions) => SetupPay
 declare const encodeSetupPayload: (options: BuildSetupPayloadOptions) => string;
 
 /**
- * Unified Provider Configuration
+ * Compute API - Direct Provider Implementation
  *
- * Single source of truth for all provider auth requirements.
- * Used by both explicit mode (computesdk) and magic mode (workbench).
+ * Gateway/control-plane transport has been removed from this package.
+ * `compute` now delegates to one or more configured provider instances directly.
  */
-/**
- * Provider auth requirements
- *
- * Structure: { provider: [[option1_vars], [option2_vars], ...] }
- * - Outer array: OR conditions (any option can satisfy auth)
- * - Inner arrays: AND conditions (all vars in option must be present)
- *
- * Example: vercel: [['OIDC_TOKEN'], ['TOKEN', 'TEAM_ID', 'PROJECT_ID']]
- *   -> Ready if OIDC_TOKEN is set, OR if all three traditional vars are set
- */
-declare const PROVIDER_AUTH: {
-    readonly computesdk: readonly [readonly ["COMPUTESDK_API_KEY"]];
-    readonly e2b: readonly [readonly ["E2B_API_KEY"]];
-    readonly modal: readonly [readonly ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"]];
-    readonly railway: readonly [readonly ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"]];
-    readonly render: readonly [readonly ["RENDER_API_KEY", "RENDER_OWNER_ID"]];
-    readonly daytona: readonly [readonly ["DAYTONA_API_KEY"]];
-    readonly vercel: readonly [readonly ["VERCEL_OIDC_TOKEN"], readonly ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"]];
-    readonly runloop: readonly [readonly ["RUNLOOP_API_KEY"]];
-    readonly cloudflare: readonly [readonly ["CLOUDFLARE_SANDBOX_URL", "CLOUDFLARE_SANDBOX_SECRET"], readonly ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"]];
-    readonly codesandbox: readonly [readonly ["CSB_API_KEY"]];
-    readonly blaxel: readonly [readonly ["BL_API_KEY", "BL_WORKSPACE"]];
-    readonly namespace: readonly [readonly ["NSC_TOKEN"], readonly ["NSC_TOKEN_FILE"]];
-    readonly hopx: readonly [readonly ["HOPX_API_KEY"]];
-    readonly beam: readonly [readonly ["BEAM_TOKEN", "BEAM_WORKSPACE_ID"]];
-    readonly sprites: readonly [readonly ["SPRITES_TOKEN"]];
-    readonly agentuity: readonly [readonly ["AGENTUITY_SDK_KEY"]];
-    readonly freestyle: readonly [readonly ["FREESTYLE_API_KEY"]];
-    readonly upstash: readonly [readonly ["UPSTASH_BOX_API_KEY"]];
-    readonly 'just-bash': readonly [readonly []];
-    readonly 'secure-exec': readonly [readonly []];
-};
-/**
- * All supported provider names (excluding gateway which is special)
- */
-declare const PROVIDER_NAMES: ProviderName[];
-/**
- * Provider name type derived from PROVIDER_AUTH
- */
-type ProviderName = keyof typeof PROVIDER_AUTH;
-/**
- * Header mapping for each provider
- * Maps config field names to HTTP header names
- */
-declare const PROVIDER_HEADERS: Record<ProviderName, Record<string, string>>;
-/**
- * Environment variable to config field mapping for each provider
- */
-declare const PROVIDER_ENV_MAP: Record<ProviderName, Record<string, string>>;
-/**
- * Dashboard URLs for each provider (for error messages)
- */
-declare const PROVIDER_DASHBOARD_URLS: Record<ProviderName, string>;
-/**
- * Check if a provider name is valid
- */
-declare function isValidProvider(name: string): name is ProviderName;
-/**
- * Build headers from provider config
- */
-declare function buildProviderHeaders(provider: ProviderName, config: Record<string, string | undefined>): Record<string, string>;
-/**
- * Get provider config from environment variables
- */
-declare function getProviderConfigFromEnv(provider: ProviderName): Record<string, string>;
-/**
- * Check if provider has complete auth from environment
- */
-declare function isProviderAuthComplete(provider: ProviderName): boolean;
-/**
- * Get missing env vars for a provider (returns the option closest to completion)
- */
-declare function getMissingEnvVars(provider: ProviderName): string[];
 
-/**
- * Compute API - Gateway HTTP Implementation
- *
- * Provides the unified compute.* API using direct HTTP calls to the gateway.
- * The `compute` export works as both a singleton and a callable function:
- *
- * - Singleton: `compute.sandbox.create()` (auto-detects from env vars)
- * - Callable: `compute({ provider: 'e2b', ... }).sandbox.create()` (explicit config)
- */
-
-/**
- * Explicit compute configuration for callable mode
- */
-interface ExplicitComputeConfig {
-    /** Provider name to use */
-    provider: ProviderName;
-    /**
-     * ComputeSDK API key (required for gateway mode)
-     * @deprecated Use `computesdkApiKey` for clarity
-     */
-    apiKey?: string;
-    /** ComputeSDK API key (required for gateway mode) */
-    computesdkApiKey?: string;
-    /** Optional gateway URL override */
-    gatewayUrl?: string;
-    /** HTTP request timeout for gateway calls in milliseconds */
-    requestTimeoutMs?: number;
-    /**
-     * WebSocket implementation for environments without native WebSocket support.
-     * In Node.js < 22, pass the 'ws' package: `import WebSocket from 'ws'`
-     */
-    WebSocket?: WebSocketConstructor;
-    /** Provider-specific configurations */
-    e2b?: {
-        apiKey?: string;
-        projectId?: string;
-        templateId?: string;
-    };
-    modal?: {
-        tokenId?: string;
-        tokenSecret?: string;
-    };
-    railway?: {
-        apiToken?: string;
-        projectId?: string;
-        environmentId?: string;
-    };
-    render?: {
-        apiKey?: string;
-        serviceId?: string;
-    };
-    daytona?: {
-        apiKey?: string;
-    };
-    vercel?: {
-        oidcToken?: string;
-        token?: string;
-        teamId?: string;
-        projectId?: string;
-    };
-    runloop?: {
-        apiKey?: string;
-    };
-    cloudflare?: {
-        apiToken?: string;
-        accountId?: string;
-    };
-    codesandbox?: {
-        apiKey?: string;
-        templateId?: string;
-        timeout?: number;
-    };
-    blaxel?: {
-        apiKey?: string;
-        workspace?: string;
-        image?: string;
-        region?: string;
-        memory?: number;
-    };
-    namespace?: {
-        token?: string;
-    };
-    hopx?: {
-        apiKey?: string;
-    };
-    beam?: {
-        token?: string;
-        workspaceId?: string;
-    };
-    sprites?: {
-        apiKey?: string;
-    };
-    agentuity?: {
-        apiKey?: string;
-        region?: string;
-        baseURL?: string;
-    };
-    freestyle?: {
-        apiKey?: string;
-    };
-    upstash?: {
-        apiKey?: string;
-    };
-    'just-bash'?: {};
-    'secure-exec'?: {};
-    computesdk?: {};
-}
-/**
- * Options for creating a sandbox via the gateway
- *
- * Note: Runtime is determined by the provider, not specified at creation time.
- * Use sandbox.runCode(code, runtime) to specify which runtime to use for execution.
- */
 interface CreateSandboxOptions {
     timeout?: number;
     templateId?: string;
@@ -4025,263 +3839,123 @@ interface CreateSandboxOptions {
     directory?: string;
     overlays?: SetupOverlayConfig[];
     servers?: ServerStartOptions[];
-    /** Docker image to use for the sandbox (for infrastructure providers like Railway) */
     image?: string;
-    /** Provider-specific snapshot to create from (e.g., Vercel snapshots) */
     snapshotId?: string;
+    /** Optional provider name override (must match provider.name) */
+    provider?: string;
 }
-/**
- * Options for finding or creating a named sandbox
- */
 interface FindOrCreateSandboxOptions extends CreateSandboxOptions {
     name: string;
     namespace?: string;
 }
-/**
- * Options for finding a named sandbox
- */
 interface FindSandboxOptions {
     name: string;
     namespace?: string;
+    /** Optional provider name override (must match provider.name) */
+    provider?: string;
 }
-/**
- * Options for extending sandbox timeout
- */
 interface ExtendTimeoutOptions {
     duration?: number;
 }
+interface CreateSnapshotOptions {
+    name?: string;
+    metadata?: Record<string, any>;
+    /** Optional provider name override (must match provider.name) */
+    provider?: string;
+}
+interface ProviderSandboxManager {
+    create(options?: CreateSandboxOptions): Promise<Sandbox$1>;
+    getById(sandboxId: string): Promise<Sandbox$1 | null>;
+    list?(): Promise<Sandbox$1[]>;
+    destroy(sandboxId: string): Promise<void>;
+    findOrCreate?(options: FindOrCreateSandboxOptions): Promise<Sandbox$1>;
+    find?(options: FindSandboxOptions): Promise<Sandbox$1 | null>;
+    extendTimeout?(sandboxId: string, options?: ExtendTimeoutOptions): Promise<void>;
+}
+interface ProviderSnapshotManager {
+    create(sandboxId: string, options?: {
+        name?: string;
+        metadata?: Record<string, any>;
+    }): Promise<{
+        id: string;
+        provider: string;
+        createdAt: Date | string;
+        metadata?: Record<string, any>;
+    }>;
+    list(): Promise<Array<{
+        id: string;
+        provider: string;
+        createdAt: Date | string;
+        metadata?: Record<string, any>;
+    }>>;
+    delete(snapshotId: string): Promise<void>;
+}
+interface DirectProvider {
+    readonly name?: string;
+    readonly sandbox: ProviderSandboxManager;
+    readonly snapshot?: ProviderSnapshotManager;
+}
 /**
- * Compute singleton implementation
+ * Explicit compute configuration for callable mode.
+ *
+ * Use `provider` for single-provider mode or `providers` for multi-provider mode.
  */
+interface ExplicitComputeConfig {
+    /** Single-provider mode */
+    provider?: DirectProvider;
+    /** Multi-provider mode (recommended for resilient routing) */
+    providers?: DirectProvider[];
+    /** Provider selection strategy when no explicit provider is passed */
+    providerStrategy?: 'priority' | 'round-robin';
+    /** Retry the next provider when create/find-or-create fails */
+    fallbackOnError?: boolean;
+}
 declare class ComputeManager {
-    private config;
-    private autoConfigured;
-    /**
-     * Lazy auto-configure from environment if not explicitly configured
-     */
-    private ensureConfigured;
-    /**
-     * Get gateway config, throwing if not configured
-     */
-    private getGatewayConfig;
-    /**
-     * 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();
-     * ```
-     */
+    private providers;
+    private providerStrategy;
+    private fallbackOnError;
+    private roundRobinCursor;
+    private sandboxProviders;
+    private snapshotProviders;
+    private getProviders;
+    private getProviderByName;
+    private registerSandboxProvider;
+    private getCreateCandidates;
+    private getByIdCandidates;
+    private getSnapshotDeleteCandidates;
+    private getSnapshotCreateCandidates;
+    private createWithFallback;
+    private findOrCreateWithFallback;
     setConfig(config: ExplicitComputeConfig): void;
     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: (options?: CreateSandboxOptions) => Promise<Sandbox>;
-        /**
-         * Get an existing sandbox by ID
-         */
-        getById: (sandboxId: string) => Promise<Sandbox | null>;
-        /**
-         * List all active sandboxes
-         */
-        list: () => Promise<Sandbox[]>;
-        /**
-         * Destroy a sandbox
-         */
+        create: (options?: CreateSandboxOptions) => Promise<Sandbox$1>;
+        getById: (sandboxId: string) => Promise<Sandbox$1 | null>;
+        list: () => Promise<Sandbox$1[]>;
         destroy: (sandboxId: string) => Promise<void>;
-        /**
-         * Find existing or create new sandbox by (namespace, name)
-         */
-        findOrCreate: (options: FindOrCreateSandboxOptions) => Promise<Sandbox>;
-        /**
-         * Find existing sandbox by (namespace, name) without creating
-         */
-        find: (options: FindSandboxOptions) => Promise<Sandbox | null>;
-        /**
-         * Extend sandbox timeout/expiration
-         */
+        findOrCreate: (options: FindOrCreateSandboxOptions) => Promise<Sandbox$1>;
+        find: (options: FindSandboxOptions) => Promise<Sandbox$1 | null>;
         extendTimeout: (sandboxId: string, options?: ExtendTimeoutOptions) => Promise<void>;
     };
     snapshot: {
-        /**
-         * Create a snapshot from a running sandbox
-         *
-         * @param sandboxId ID of the sandbox to snapshot
-         * @param options Snapshot options (name, metadata)
-         */
-        create: (sandboxId: string, options?: {
-            name?: string;
-            metadata?: Record<string, any>;
-        }) => Promise<{
+        create: (sandboxId: string, options?: CreateSnapshotOptions) => Promise<{
             id: string;
             provider: string;
             createdAt: Date;
             metadata?: Record<string, any>;
         }>;
-        /**
-         * List all snapshots
-         */
         list: () => Promise<Array<{
             id: string;
             provider: string;
             createdAt: Date;
             metadata?: Record<string, any>;
         }>>;
-        /**
-         * Delete a snapshot
-         */
         delete: (snapshotId: string) => Promise<void>;
     };
 }
-/**
- * Callable compute interface - dual nature as both singleton and factory
- *
- * This interface represents the compute export's two modes:
- * 1. As a ComputeManager singleton (accessed via properties like compute.sandbox)
- * 2. As a factory function (called with config to create new instances)
- */
 interface CallableCompute extends ComputeManager {
-    /** Create a new compute instance with explicit configuration */
     (config: ExplicitComputeConfig): ComputeManager;
-    /** Explicitly configure the singleton */
     setConfig(config: ExplicitComputeConfig): void;
 }
-/**
- * Callable compute - works as both singleton and factory function
- *
- * @example
- * ```typescript
- * import { compute } from 'computesdk';
- *
- * // Singleton mode (auto-detects from env vars)
- * const sandbox1 = await compute.sandbox.create();
- *
- * // Callable mode (explicit config)
- * const sandbox2 = await compute({
- *   provider: 'e2b',
- *   apiKey: 'computesdk_xxx',
- *   e2b: { apiKey: 'e2b_xxx' }
- * }).sandbox.create();
- * ```
- */
 declare const compute: CallableCompute;
 
-/**
- * Auto-Detection Module
- *
- * Automatically detects gateway mode and provider from environment variables.
- * Enables zero-config usage of ComputeSDK.
- */
-
-/**
- * Check if gateway mode is enabled
- * Gateway mode requires COMPUTESDK_API_KEY to be set
- */
-declare function isGatewayModeEnabled(): boolean;
-/**
- * Detect which provider to use from environment variables
- *
- * Detection order:
- * 1. Check for explicit COMPUTESDK_PROVIDER override
- * 2. Auto-detect based on PROVIDER_PRIORITY order
- *
- * @returns Provider name or null if none detected
- */
-declare function detectProvider(): string | null;
-/**
- * Build provider-specific headers from environment variables
- * These headers are passed through to the gateway
- */
-declare function getProviderHeaders(provider: string): Record<string, string>;
-/**
- * Gateway configuration object
- */
-interface GatewayConfig {
-    apiKey: string;
-    gatewayUrl: string;
-    provider: string;
-    providerHeaders: Record<string, string>;
-    requestTimeoutMs?: number;
-    WebSocket?: WebSocketConstructor;
-}
-/**
- * Main auto-configuration function
- * Returns gateway configuration or null if auto-detection not possible
- *
- * @throws Error if COMPUTESDK_API_KEY is set but no provider detected
- */
-declare function autoConfigureCompute(): GatewayConfig | null;
-
-/**
- * ComputeSDK Constants
- *
- * Default configuration values and provider definitions
- */
-
-/**
- * Default gateway URL for sandbox lifecycle operations
- */
-declare const TRIBUTARY_URL = "https://tributary.edge.computesdk.com";
-/**
- * Provider detection priority order
- * When multiple provider credentials are detected, use the first one in this list
- */
-declare const PROVIDER_PRIORITY: readonly ["e2b", "railway", "render", "daytona", "modal", "runloop", "vercel", "cloudflare", "codesandbox", "blaxel", "namespace", "hopx", "beam", "sprites", "agentuity", "freestyle", "upstash", "secure-exec"];
-/**
- * Required environment variables for each provider
- * @deprecated Use PROVIDER_AUTH from provider-config instead
- */
-declare const PROVIDER_ENV_VARS: {
-    readonly computesdk: readonly ["COMPUTESDK_API_KEY"];
-    readonly e2b: readonly ["E2B_API_KEY"];
-    readonly railway: readonly ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"];
-    readonly render: readonly ["RENDER_API_KEY", "RENDER_OWNER_ID"];
-    readonly daytona: readonly ["DAYTONA_API_KEY"];
-    readonly modal: readonly ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"];
-    readonly runloop: readonly ["RUNLOOP_API_KEY"];
-    readonly vercel: readonly ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"];
-    readonly cloudflare: readonly ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"];
-    readonly codesandbox: readonly ["CSB_API_KEY"];
-    readonly blaxel: readonly ["BL_API_KEY", "BL_WORKSPACE"];
-    readonly namespace: readonly ["NSC_TOKEN"];
-    readonly hopx: readonly ["HOPX_API_KEY"];
-    readonly beam: readonly ["BEAM_TOKEN", "BEAM_WORKSPACE_ID"];
-    readonly sprites: readonly ["SPRITES_TOKEN"];
-    readonly agentuity: readonly ["AGENTUITY_SDK_KEY"];
-    readonly freestyle: readonly ["FREESTYLE_API_KEY"];
-    readonly upstash: readonly ["UPSTASH_BOX_API_KEY"];
-    readonly 'just-bash': readonly [];
-    readonly 'secure-exec': readonly [];
-};
-
-export { type CallableCompute, type CodeResult$1 as CodeResult, CommandExitError, type CommandResult$1 as CommandResult, type CreateSandboxOptions$1 as CreateSandboxOptions, type ExplicitComputeConfig, type FileEntry, FileWatcher, Sandbox as GatewaySandbox, MessageType, PROVIDER_AUTH, PROVIDER_DASHBOARD_URLS, PROVIDER_ENV_MAP, PROVIDER_ENV_VARS, PROVIDER_HEADERS, PROVIDER_NAMES, PROVIDER_PRIORITY, type ProviderName, type ProviderSandboxInfo, type RunCommandOptions, type Runtime, Sandbox, type SandboxFileSystem, type SandboxInfo$1 as SandboxInfo, type Sandbox$1 as SandboxInterface, type SandboxStatus, type SetupOverlayConfig, type SetupPayload, SignalService, type Snapshot, TRIBUTARY_URL, TerminalInstance, type WebSocketConstructor, autoConfigureCompute, buildProviderHeaders, buildSetupPayload, compute, decodeBinaryMessage, detectProvider, encodeBinaryMessage, encodeSetupPayload, getMissingEnvVars, getProviderConfigFromEnv, getProviderHeaders, isCommandExitError, isGatewayModeEnabled, isProviderAuthComplete, isValidProvider };
+export { type CallableCompute, type CodeResult$1 as CodeResult, CommandExitError, type CommandResult$1 as CommandResult, type CreateSandboxOptions$1 as CreateSandboxOptions, type ExplicitComputeConfig, type FileEntry, FileWatcher, MessageType, type ProviderSandboxInfo, type RunCommandOptions, type Runtime, Sandbox, type SandboxFileSystem, type SandboxInfo$1 as SandboxInfo, type Sandbox$1 as SandboxInterface, type SandboxStatus, type SetupOverlayConfig, type SetupPayload, SignalService, type Snapshot, TerminalInstance, type WebSocketConstructor, buildSetupPayload, compute, decodeBinaryMessage, encodeBinaryMessage, encodeSetupPayload, isCommandExitError };