computesdk 1.6.0 → 1.7.1

package/README.md

@@ -19,10 +19,10 @@
 
 ## What is ComputeSDK?
 
-ComputeSDK is a free and open-source toolkit for running other people's code in your applications. Think of it as the "AI SDK for compute" - providing a consistent TypeScript interface whether you're using E2B, Vercel, or Daytona.
+ComputeSDK is a free and open-source toolkit for running other people's code in your applications. Think of it as the "AI SDK for compute" - providing a consistent TypeScript interface whether you're using Blaxel, E2B, Vercel, or Daytona.
 
 **Why ComputeSDK?**
-- 🔄 **Provider-agnostic** - Switch between E2B, Vercel, Daytona and more (coming soon) without code changes
+- 🔄 **Provider-agnostic** - Switch between Blaxel, E2B, Vercel, Daytona and more (coming soon) without code changes
 - 🛡️ **Security-first** - Isolated sandboxes protect your infrastructure
 - ⚡ **Developer experience** - Simple, TypeScript-native API
 - 🌍 **Production-ready** - Used by teams building the next generation of developer tools
@@ -36,7 +36,7 @@ ComputeSDK is a free and open-source toolkit for running other people's code in
 
 ## Features
 
-- 🚀 **Multi-provider support** - E2B, Vercel, Daytona
+- 🚀 **Multi-provider support** - Blaxel, E2B, Vercel, Daytona
 - 📁 **Filesystem operations** - Read, write, create directories across providers
 - 🖥️ **Terminal support** - Interactive PTY terminals (E2B)
 - ⚡ **Command execution** - Run shell commands directly
@@ -53,6 +53,7 @@ ComputeSDK is a free and open-source toolkit for running other people's code in
 npm install computesdk
 
 # Add your preferred provider
+npm install @computesdk/blaxel     # For AI-powered code execution
 npm install @computesdk/e2b        # For data science and Python
 npm install @computesdk/vercel     # For web-scale Node.js/Python  
 npm install @computesdk/daytona    # For development workspaces
@@ -64,7 +65,9 @@ npm install @computesdk/ui         # React hooks and utilities
 Set your environment variables and you're ready to go:
 
 ```bash
-export E2B_API_KEY=your_api_key
+export BLAXEL_API_KEY=your_api_key
+export BLAXEL_WORKSPACE=your_workspace
+# or E2B_API_KEY=your_api_key
 # or VERCEL_TOKEN=your_token
 # or DAYTONA_API_KEY=your_key
 ```
@@ -73,11 +76,14 @@ export E2B_API_KEY=your_api_key
 
 ```typescript
 import { compute } from 'computesdk';
-import { e2b } from '@computesdk/e2b';
+import { blaxel } from '@computesdk/blaxel';
 
 // Set default provider
 compute.setConfig({ 
-  provider: e2b({ apiKey: process.env.E2B_API_KEY }) 
+  provider: blaxel({ 
+    apiKey: process.env.BLAXEL_API_KEY,
+    workspace: process.env.BLAXEL_WORKSPACE
+  }) 
 });
 
 // Create a sandbox
@@ -93,6 +99,40 @@ await compute.sandbox.destroy(sandbox.sandboxId);
 
 ## Provider Setup
 
+### Blaxel - AI-Powered Code Execution
+
+Blaxel provides intelligent code execution with AI assistance:
+
+```bash
+export BLAXEL_API_KEY=your_blaxel_api_key_here
+export BLAXEL_WORKSPACE=your_workspace_here
+```
+
+```typescript
+import { compute } from 'computesdk';
+import { blaxel } from '@computesdk/blaxel';
+
+compute.setConfig({ 
+  provider: blaxel({ 
+    apiKey: process.env.BLAXEL_API_KEY,
+    workspace: process.env.BLAXEL_WORKSPACE
+  }) 
+});
+
+const sandbox = await compute.sandbox.create({});
+
+// Execute code with AI assistance
+const result = await sandbox.runCode(`
+print("Hello from Blaxel!")
+# Your code can leverage AI capabilities
+import json
+data = {"message": "AI-powered execution"}
+print(json.dumps(data, indent=2))
+`);
+
+console.log(result.stdout);
+```
+
 ### E2B - Full Development Environment
 
 E2B provides full filesystem and terminal support:

package/dist/index.d.mts

@@ -7,17 +7,26 @@ interface Provider$1 {
     readonly name: string;
     readonly sandbox: any;
 }
+/**
+ * Type mapping for provider names to their sandbox types
+ * Manually defined for known providers since declaration merging isn't working reliably
+ */
+interface ProviderSandboxTypeMap {
+    e2b: any;
+    vercel: any;
+    daytona: any;
+}
 /**
  * Utility type to extract the native instance type from a provider
- * This enables proper typing for getInstance() calls by looking at the provider's internal types
+ * Uses provider name and manual type inference
  */
-type ExtractSandboxInstanceType<TProvider extends Provider$1> = TProvider extends Provider$1 ? TProvider extends {
-    sandbox: {
-        create(): Promise<infer TSandbox>;
-    };
-} ? (TSandbox extends {
-    getInstance(): infer TInstance;
-} ? TInstance : any) : any : any;
+type ExtractSandboxInstanceType<TProvider extends Provider$1> = TProvider extends {
+    readonly name: 'e2b';
+} ? any : TProvider extends {
+    readonly name: 'vercel';
+} ? any : TProvider extends {
+    readonly name: 'daytona';
+} ? any : any;
 /**
  * Supported runtime environments
  */
@@ -77,7 +86,7 @@ interface SandboxInfo {
  * Options for creating a sandbox
  */
 interface CreateSandboxOptions {
-    /** Runtime environment */
+    /** Runtime environment (defaults to 'node' if not specified) */
     runtime?: Runtime;
     /** Execution timeout in milliseconds */
     timeout?: number;
@@ -149,7 +158,7 @@ declare function isCommandExitError(error: unknown): error is CommandExitError;
 /**
  * Base sandbox interface - what developers interact with
  */
-interface Sandbox {
+interface Sandbox<TSandbox = any> {
     /** Unique identifier for the sandbox */
     readonly sandboxId: string;
     /** Provider that created this sandbox */
@@ -166,9 +175,9 @@ interface Sandbox {
         protocol?: string;
     }): Promise<string>;
     /** Get the provider instance that created this sandbox */
-    getProvider(): Provider$1;
+    getProvider(): Provider<TSandbox>;
     /** Get the native provider sandbox instance with proper typing */
-    getInstance<T = any>(): T;
+    getInstance(): TSandbox;
     /** Kill the sandbox */
     kill(): Promise<void>;
     /** Destroy the sandbox and clean up resources */
@@ -176,38 +185,109 @@ interface Sandbox {
     /** File system operations */
     readonly filesystem: SandboxFileSystem;
 }
+/**
+ * Extract the sandbox type from a provider
+ */
+type ExtractProviderSandboxType<TProvider extends Provider$1> = TProvider extends {
+    readonly __sandboxType: infer TSandbox;
+} ? TSandbox : any;
 /**
  * Typed sandbox interface that preserves the provider's native instance type
  */
-interface TypedSandbox<TProvider extends Provider$1> extends Sandbox {
+interface TypedSandbox<TProvider extends Provider$1> extends Omit<Sandbox<ExtractProviderSandboxType<TProvider>>, 'getProvider'> {
     /** Get the provider instance that created this sandbox with proper typing */
     getProvider(): TProvider;
     /** Get the native provider sandbox instance with proper typing */
-    getInstance(): ExtractSandboxInstanceType<TProvider>;
-    getInstance<T>(): T;
+    getInstance(): ExtractProviderSandboxType<TProvider>;
 }
 
 /**
- * Provider sandbox management interface
+ * Common options for creating snapshots
  */
-interface ProviderSandboxManager {
+interface CreateSnapshotOptions {
+    /** Optional name for the snapshot */
+    name?: string;
+    /** Optional metadata for the snapshot */
+    metadata?: Record<string, string>;
+}
+/**
+ * Common options for listing snapshots
+ */
+interface ListSnapshotsOptions {
+    /** Filter by sandbox ID */
+    sandboxId?: string;
+    /** Limit the number of results */
+    limit?: number;
+}
+/**
+ * Common options for creating templates/blueprints
+ */
+interface CreateTemplateOptions {
+    /** Name of the template */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Optional metadata for the template */
+    metadata?: Record<string, string>;
+}
+/**
+ * Common options for listing templates
+ */
+interface ListTemplatesOptions {
+    /** Limit the number of results */
+    limit?: number;
+}
+/**
+ * Provider sandbox manager interface - handles sandbox lifecycle
+ */
+interface ProviderSandboxManager<TSandbox = any> {
     /** Create a new sandbox */
-    create(options?: CreateSandboxOptions): Promise<Sandbox>;
+    create(options?: CreateSandboxOptions): Promise<Sandbox<TSandbox>>;
     /** Get an existing sandbox by ID */
-    getById(sandboxId: string): Promise<Sandbox | null>;
+    getById(sandboxId: string): Promise<Sandbox<TSandbox> | null>;
     /** List all active sandboxes */
-    list(): Promise<Sandbox[]>;
+    list(): Promise<Sandbox<TSandbox>[]>;
     /** Destroy a sandbox */
     destroy(sandboxId: string): Promise<void>;
 }
+/**
+ * Provider template manager interface - handles template/blueprint lifecycle
+ */
+interface ProviderTemplateManager<TTemplate = any> {
+    /** Create a new template */
+    create(options: CreateTemplateOptions | any): Promise<TTemplate>;
+    /** List all available templates */
+    list(options?: ListTemplatesOptions): Promise<TTemplate[]>;
+    /** Delete a template */
+    delete(templateId: string): Promise<void>;
+}
+/**
+ * Provider snapshot manager interface - handles snapshot lifecycle
+ */
+interface ProviderSnapshotManager<TSnapshot = any> {
+    /** Create a snapshot from a sandbox */
+    create(sandboxId: string, options?: CreateSnapshotOptions): Promise<TSnapshot>;
+    /** List all snapshots */
+    list(options?: ListSnapshotsOptions): Promise<TSnapshot[]>;
+    /** Delete a snapshot */
+    delete(snapshotId: string): Promise<void>;
+}
 /**
  * Provider interface - creates and manages resources
  */
-interface Provider {
+interface Provider<TSandbox = any, TTemplate = any, TSnapshot = any> {
     /** Provider name/type */
     readonly name: string;
     /** Sandbox management operations */
-    readonly sandbox: ProviderSandboxManager;
+    readonly sandbox: ProviderSandboxManager<TSandbox>;
+    /** Optional template management operations */
+    readonly template?: ProviderTemplateManager<TTemplate>;
+    /** Optional snapshot management operations */
+    readonly snapshot?: ProviderSnapshotManager<TSnapshot>;
+    /** Get the list of supported runtime environments */
+    getSupportedRuntimes(): Runtime[];
+    /** Phantom type property for TypeScript inference - not used at runtime */
+    readonly __sandboxType: TSandbox;
 }
 /**
  * Configuration for the compute singleton
@@ -217,6 +297,10 @@ interface ComputeConfig<TProvider extends Provider = Provider> {
     defaultProvider?: TProvider;
     /** @deprecated Use defaultProvider instead. Kept for backwards compatibility */
     provider?: TProvider;
+    /** API key for compute CLI authentication */
+    apiKey?: string;
+    /** JWT token for compute CLI authentication */
+    jwt?: string;
 }
 /**
  * Parameters for compute.sandbox.create()
@@ -285,7 +369,6 @@ interface TypedComputeAPI<TProvider extends Provider> extends Omit<ComputeAPI, '
 declare const compute: ComputeAPI;
 /**
  * Create a compute instance with proper typing
- * This enables proper type inference for getInstance() calls
  *
  * @example
  * ```typescript
@@ -297,7 +380,7 @@ declare const compute: ComputeAPI;
  * });
  *
  * const sandbox = await compute.sandbox.create();
- * const instance = sandbox.getInstance(); // ✅ Properly typed!
+ * const instance = sandbox.getInstance(); // ✅ Properly typed E2B Sandbox!
  * ```
  */
 declare function createCompute<TProvider extends Provider>(config: ComputeConfig<TProvider>): TypedComputeAPI<TProvider>;
@@ -407,13 +490,31 @@ interface SandboxMethods<TSandbox = any, TConfig = any> {
         remove: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, args?: string[]) => Promise<ExecutionResult>) => Promise<void>;
     };
 }
+/**
+ * Template method implementations
+ */
+interface TemplateMethods<TTemplate = any, TConfig = any> {
+    create: (config: TConfig, options: CreateTemplateOptions | any) => Promise<TTemplate>;
+    list: (config: TConfig, options?: ListTemplatesOptions) => Promise<TTemplate[]>;
+    delete: (config: TConfig, templateId: string) => Promise<void>;
+}
+/**
+ * Snapshot method implementations
+ */
+interface SnapshotMethods<TSnapshot = any, TConfig = any> {
+    create: (config: TConfig, sandboxId: string, options?: CreateSnapshotOptions) => Promise<TSnapshot>;
+    list: (config: TConfig, options?: ListSnapshotsOptions) => Promise<TSnapshot[]>;
+    delete: (config: TConfig, snapshotId: string) => Promise<void>;
+}
 /**
  * Provider configuration for createProvider()
  */
-interface ProviderConfig<TSandbox = any, TConfig = any> {
+interface ProviderConfig<TSandbox = any, TConfig = any, TTemplate = any, TSnapshot = any> {
     name: string;
     methods: {
         sandbox: SandboxMethods<TSandbox, TConfig>;
+        template?: TemplateMethods<TTemplate, TConfig>;
+        snapshot?: SnapshotMethods<TSnapshot, TConfig>;
     };
 }
 /**
@@ -422,6 +523,6 @@ interface ProviderConfig<TSandbox = any, TConfig = any> {
  * Auto-generates all boilerplate classes and provides feature detection
  * based on which methods are implemented.
  */
-declare function createProvider<TSandbox, TConfig>(providerConfig: ProviderConfig<TSandbox, TConfig>): (config: TConfig) => Provider;
+declare function createProvider<TSandbox, TConfig = any, TTemplate = any, TSnapshot = any>(providerConfig: ProviderConfig<TSandbox, TConfig, TTemplate, TSnapshot>): (config: TConfig) => Provider<TSandbox, TTemplate, TSnapshot>;
 
-export { CommandExitError, type ComputeAPI, type ComputeConfig, type ComputeRequest, type ComputeResponse, type CreateSandboxOptions, type CreateSandboxParams, type CreateSandboxParamsWithOptionalProvider, type ExecutionResult, type ExtractSandboxInstanceType, type FileEntry, type HandleComputeRequestParams, type Provider, type ProviderConfig, type ProviderSandboxManager, type RunCommandOptions, type Runtime, type Sandbox, type SandboxFileSystem, type SandboxInfo, type SandboxMethods, type SandboxStatus, type TypedComputeAPI, type TypedSandbox, compute, createBackgroundCommand, createCompute, createProvider, handleComputeRequest, isCommandExitError };
+export { CommandExitError, type ComputeAPI, type ComputeConfig, type ComputeRequest, type ComputeResponse, type CreateSandboxOptions, type CreateSandboxParams, type CreateSandboxParamsWithOptionalProvider, type CreateSnapshotOptions, type CreateTemplateOptions, type ExecutionResult, type ExtractSandboxInstanceType, type FileEntry, type HandleComputeRequestParams, type ListSnapshotsOptions, type ListTemplatesOptions, type Provider, type ProviderConfig, type ProviderSandboxManager, type ProviderSandboxTypeMap, type ProviderSnapshotManager, type ProviderTemplateManager, type RunCommandOptions, type Runtime, type Sandbox, type SandboxFileSystem, type SandboxInfo, type SandboxMethods, type SandboxStatus, type SnapshotMethods, type TemplateMethods, type TypedComputeAPI, type TypedSandbox, compute, createBackgroundCommand, createCompute, createProvider, handleComputeRequest, isCommandExitError };

package/dist/index.d.ts

@@ -7,17 +7,26 @@ interface Provider$1 {
     readonly name: string;
     readonly sandbox: any;
 }
+/**
+ * Type mapping for provider names to their sandbox types
+ * Manually defined for known providers since declaration merging isn't working reliably
+ */
+interface ProviderSandboxTypeMap {
+    e2b: any;
+    vercel: any;
+    daytona: any;
+}
 /**
  * Utility type to extract the native instance type from a provider
- * This enables proper typing for getInstance() calls by looking at the provider's internal types
+ * Uses provider name and manual type inference
  */
-type ExtractSandboxInstanceType<TProvider extends Provider$1> = TProvider extends Provider$1 ? TProvider extends {
-    sandbox: {
-        create(): Promise<infer TSandbox>;
-    };
-} ? (TSandbox extends {
-    getInstance(): infer TInstance;
-} ? TInstance : any) : any : any;
+type ExtractSandboxInstanceType<TProvider extends Provider$1> = TProvider extends {
+    readonly name: 'e2b';
+} ? any : TProvider extends {
+    readonly name: 'vercel';
+} ? any : TProvider extends {
+    readonly name: 'daytona';
+} ? any : any;
 /**
  * Supported runtime environments
  */
@@ -77,7 +86,7 @@ interface SandboxInfo {
  * Options for creating a sandbox
  */
 interface CreateSandboxOptions {
-    /** Runtime environment */
+    /** Runtime environment (defaults to 'node' if not specified) */
     runtime?: Runtime;
     /** Execution timeout in milliseconds */
     timeout?: number;
@@ -149,7 +158,7 @@ declare function isCommandExitError(error: unknown): error is CommandExitError;
 /**
  * Base sandbox interface - what developers interact with
  */
-interface Sandbox {
+interface Sandbox<TSandbox = any> {
     /** Unique identifier for the sandbox */
     readonly sandboxId: string;
     /** Provider that created this sandbox */
@@ -166,9 +175,9 @@ interface Sandbox {
         protocol?: string;
     }): Promise<string>;
     /** Get the provider instance that created this sandbox */
-    getProvider(): Provider$1;
+    getProvider(): Provider<TSandbox>;
     /** Get the native provider sandbox instance with proper typing */
-    getInstance<T = any>(): T;
+    getInstance(): TSandbox;
     /** Kill the sandbox */
     kill(): Promise<void>;
     /** Destroy the sandbox and clean up resources */
@@ -176,38 +185,109 @@ interface Sandbox {
     /** File system operations */
     readonly filesystem: SandboxFileSystem;
 }
+/**
+ * Extract the sandbox type from a provider
+ */
+type ExtractProviderSandboxType<TProvider extends Provider$1> = TProvider extends {
+    readonly __sandboxType: infer TSandbox;
+} ? TSandbox : any;
 /**
  * Typed sandbox interface that preserves the provider's native instance type
  */
-interface TypedSandbox<TProvider extends Provider$1> extends Sandbox {
+interface TypedSandbox<TProvider extends Provider$1> extends Omit<Sandbox<ExtractProviderSandboxType<TProvider>>, 'getProvider'> {
     /** Get the provider instance that created this sandbox with proper typing */
     getProvider(): TProvider;
     /** Get the native provider sandbox instance with proper typing */
-    getInstance(): ExtractSandboxInstanceType<TProvider>;
-    getInstance<T>(): T;
+    getInstance(): ExtractProviderSandboxType<TProvider>;
 }
 
 /**
- * Provider sandbox management interface
+ * Common options for creating snapshots
  */
-interface ProviderSandboxManager {
+interface CreateSnapshotOptions {
+    /** Optional name for the snapshot */
+    name?: string;
+    /** Optional metadata for the snapshot */
+    metadata?: Record<string, string>;
+}
+/**
+ * Common options for listing snapshots
+ */
+interface ListSnapshotsOptions {
+    /** Filter by sandbox ID */
+    sandboxId?: string;
+    /** Limit the number of results */
+    limit?: number;
+}
+/**
+ * Common options for creating templates/blueprints
+ */
+interface CreateTemplateOptions {
+    /** Name of the template */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Optional metadata for the template */
+    metadata?: Record<string, string>;
+}
+/**
+ * Common options for listing templates
+ */
+interface ListTemplatesOptions {
+    /** Limit the number of results */
+    limit?: number;
+}
+/**
+ * Provider sandbox manager interface - handles sandbox lifecycle
+ */
+interface ProviderSandboxManager<TSandbox = any> {
     /** Create a new sandbox */
-    create(options?: CreateSandboxOptions): Promise<Sandbox>;
+    create(options?: CreateSandboxOptions): Promise<Sandbox<TSandbox>>;
     /** Get an existing sandbox by ID */
-    getById(sandboxId: string): Promise<Sandbox | null>;
+    getById(sandboxId: string): Promise<Sandbox<TSandbox> | null>;
     /** List all active sandboxes */
-    list(): Promise<Sandbox[]>;
+    list(): Promise<Sandbox<TSandbox>[]>;
     /** Destroy a sandbox */
     destroy(sandboxId: string): Promise<void>;
 }
+/**
+ * Provider template manager interface - handles template/blueprint lifecycle
+ */
+interface ProviderTemplateManager<TTemplate = any> {
+    /** Create a new template */
+    create(options: CreateTemplateOptions | any): Promise<TTemplate>;
+    /** List all available templates */
+    list(options?: ListTemplatesOptions): Promise<TTemplate[]>;
+    /** Delete a template */
+    delete(templateId: string): Promise<void>;
+}
+/**
+ * Provider snapshot manager interface - handles snapshot lifecycle
+ */
+interface ProviderSnapshotManager<TSnapshot = any> {
+    /** Create a snapshot from a sandbox */
+    create(sandboxId: string, options?: CreateSnapshotOptions): Promise<TSnapshot>;
+    /** List all snapshots */
+    list(options?: ListSnapshotsOptions): Promise<TSnapshot[]>;
+    /** Delete a snapshot */
+    delete(snapshotId: string): Promise<void>;
+}
 /**
  * Provider interface - creates and manages resources
  */
-interface Provider {
+interface Provider<TSandbox = any, TTemplate = any, TSnapshot = any> {
     /** Provider name/type */
     readonly name: string;
     /** Sandbox management operations */
-    readonly sandbox: ProviderSandboxManager;
+    readonly sandbox: ProviderSandboxManager<TSandbox>;
+    /** Optional template management operations */
+    readonly template?: ProviderTemplateManager<TTemplate>;
+    /** Optional snapshot management operations */
+    readonly snapshot?: ProviderSnapshotManager<TSnapshot>;
+    /** Get the list of supported runtime environments */
+    getSupportedRuntimes(): Runtime[];
+    /** Phantom type property for TypeScript inference - not used at runtime */
+    readonly __sandboxType: TSandbox;
 }
 /**
  * Configuration for the compute singleton
@@ -217,6 +297,10 @@ interface ComputeConfig<TProvider extends Provider = Provider> {
     defaultProvider?: TProvider;
     /** @deprecated Use defaultProvider instead. Kept for backwards compatibility */
     provider?: TProvider;
+    /** API key for compute CLI authentication */
+    apiKey?: string;
+    /** JWT token for compute CLI authentication */
+    jwt?: string;
 }
 /**
  * Parameters for compute.sandbox.create()
@@ -285,7 +369,6 @@ interface TypedComputeAPI<TProvider extends Provider> extends Omit<ComputeAPI, '
 declare const compute: ComputeAPI;
 /**
  * Create a compute instance with proper typing
- * This enables proper type inference for getInstance() calls
  *
  * @example
  * ```typescript
@@ -297,7 +380,7 @@ declare const compute: ComputeAPI;
  * });
  *
  * const sandbox = await compute.sandbox.create();
- * const instance = sandbox.getInstance(); // ✅ Properly typed!
+ * const instance = sandbox.getInstance(); // ✅ Properly typed E2B Sandbox!
  * ```
  */
 declare function createCompute<TProvider extends Provider>(config: ComputeConfig<TProvider>): TypedComputeAPI<TProvider>;
@@ -407,13 +490,31 @@ interface SandboxMethods<TSandbox = any, TConfig = any> {
         remove: (sandbox: TSandbox, path: string, runCommand: (sandbox: TSandbox, command: string, args?: string[]) => Promise<ExecutionResult>) => Promise<void>;
     };
 }
+/**
+ * Template method implementations
+ */
+interface TemplateMethods<TTemplate = any, TConfig = any> {
+    create: (config: TConfig, options: CreateTemplateOptions | any) => Promise<TTemplate>;
+    list: (config: TConfig, options?: ListTemplatesOptions) => Promise<TTemplate[]>;
+    delete: (config: TConfig, templateId: string) => Promise<void>;
+}
+/**
+ * Snapshot method implementations
+ */
+interface SnapshotMethods<TSnapshot = any, TConfig = any> {
+    create: (config: TConfig, sandboxId: string, options?: CreateSnapshotOptions) => Promise<TSnapshot>;
+    list: (config: TConfig, options?: ListSnapshotsOptions) => Promise<TSnapshot[]>;
+    delete: (config: TConfig, snapshotId: string) => Promise<void>;
+}
 /**
  * Provider configuration for createProvider()
  */
-interface ProviderConfig<TSandbox = any, TConfig = any> {
+interface ProviderConfig<TSandbox = any, TConfig = any, TTemplate = any, TSnapshot = any> {
     name: string;
     methods: {
         sandbox: SandboxMethods<TSandbox, TConfig>;
+        template?: TemplateMethods<TTemplate, TConfig>;
+        snapshot?: SnapshotMethods<TSnapshot, TConfig>;
     };
 }
 /**
@@ -422,6 +523,6 @@ interface ProviderConfig<TSandbox = any, TConfig = any> {
  * Auto-generates all boilerplate classes and provides feature detection
  * based on which methods are implemented.
  */
-declare function createProvider<TSandbox, TConfig>(providerConfig: ProviderConfig<TSandbox, TConfig>): (config: TConfig) => Provider;
+declare function createProvider<TSandbox, TConfig = any, TTemplate = any, TSnapshot = any>(providerConfig: ProviderConfig<TSandbox, TConfig, TTemplate, TSnapshot>): (config: TConfig) => Provider<TSandbox, TTemplate, TSnapshot>;
 
-export { CommandExitError, type ComputeAPI, type ComputeConfig, type ComputeRequest, type ComputeResponse, type CreateSandboxOptions, type CreateSandboxParams, type CreateSandboxParamsWithOptionalProvider, type ExecutionResult, type ExtractSandboxInstanceType, type FileEntry, type HandleComputeRequestParams, type Provider, type ProviderConfig, type ProviderSandboxManager, type RunCommandOptions, type Runtime, type Sandbox, type SandboxFileSystem, type SandboxInfo, type SandboxMethods, type SandboxStatus, type TypedComputeAPI, type TypedSandbox, compute, createBackgroundCommand, createCompute, createProvider, handleComputeRequest, isCommandExitError };
+export { CommandExitError, type ComputeAPI, type ComputeConfig, type ComputeRequest, type ComputeResponse, type CreateSandboxOptions, type CreateSandboxParams, type CreateSandboxParamsWithOptionalProvider, type CreateSnapshotOptions, type CreateTemplateOptions, type ExecutionResult, type ExtractSandboxInstanceType, type FileEntry, type HandleComputeRequestParams, type ListSnapshotsOptions, type ListTemplatesOptions, type Provider, type ProviderConfig, type ProviderSandboxManager, type ProviderSandboxTypeMap, type ProviderSnapshotManager, type ProviderTemplateManager, type RunCommandOptions, type Runtime, type Sandbox, type SandboxFileSystem, type SandboxInfo, type SandboxMethods, type SandboxStatus, type SnapshotMethods, type TemplateMethods, type TypedComputeAPI, type TypedSandbox, compute, createBackgroundCommand, createCompute, createProvider, handleComputeRequest, isCommandExitError };