computesdk 1.7.0 → 1.7.2

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

@@ -86,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;
@@ -201,6 +201,42 @@ interface TypedSandbox<TProvider extends Provider$1> extends Omit<Sandbox<Extrac
     getInstance(): ExtractProviderSandboxType<TProvider>;
 }
 
+/**
+ * Common options for creating snapshots
+ */
+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
  */
@@ -214,14 +250,42 @@ interface ProviderSandboxManager<TSandbox = any> {
     /** 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<TSandbox = any> {
+interface Provider<TSandbox = any, TTemplate = any, TSnapshot = any> {
     /** Provider name/type */
     readonly name: string;
     /** Sandbox management operations */
     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;
 }
@@ -233,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()
@@ -422,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>;
     };
 }
 /**
@@ -437,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<TSandbox>;
+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 ProviderSandboxTypeMap, 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

@@ -86,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;
@@ -201,6 +201,42 @@ interface TypedSandbox<TProvider extends Provider$1> extends Omit<Sandbox<Extrac
     getInstance(): ExtractProviderSandboxType<TProvider>;
 }
 
+/**
+ * Common options for creating snapshots
+ */
+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
  */
@@ -214,14 +250,42 @@ interface ProviderSandboxManager<TSandbox = any> {
     /** 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<TSandbox = any> {
+interface Provider<TSandbox = any, TTemplate = any, TSnapshot = any> {
     /** Provider name/type */
     readonly name: string;
     /** Sandbox management operations */
     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;
 }
@@ -233,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()
@@ -422,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>;
     };
 }
 /**
@@ -437,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<TSandbox>;
+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 ProviderSandboxTypeMap, 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.js

@@ -43,10 +43,70 @@ function isCommandExitError(error) {
 }
 
 // src/compute.ts
+var import_client = require("@computesdk/client");
+async function authorizeApiKey(apiKey) {
+  try {
+    const response = await fetch("https://preview.computesdk.com/__api/license/authorize", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        key: apiKey,
+        increment_usage: 1
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`License authorization failed: ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.jwt) {
+      throw new Error("No JWT token received from license server");
+    }
+    if (!data.sandbox_url) {
+      throw new Error("No sandbox_url received from license server");
+    }
+    if (!data.preview_url) {
+      throw new Error("No preview_url received from license server");
+    }
+    return {
+      jwt: data.jwt,
+      sandbox_url: data.sandbox_url,
+      preview_url: data.preview_url
+    };
+  } catch (error) {
+    throw new Error(`Failed to authorize API key: ${error}`);
+  }
+}
+async function installComputeInSandbox(sandbox, config) {
+  try {
+    console.log("Installing and starting compute CLI in sandbox...");
+    let authResponse = null;
+    let jwt = config?.jwt;
+    if (config?.apiKey && !jwt) {
+      console.log("Authorizing API key and getting JWT token...");
+      authResponse = await authorizeApiKey(config.apiKey);
+      jwt = authResponse.jwt;
+    }
+    let installCommand = "curl -fsSL https://computesdk.com/install.sh | sh";
+    if (jwt) {
+      installCommand = `curl -fsSL https://computesdk.com/install.sh | sh -s -- --jwt ${jwt}`;
+    }
+    const result = await sandbox.runCommand("sh", ["-c", installCommand]);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to install and start compute CLI: ${result.stderr}`);
+    }
+    console.log("Compute CLI installed and started successfully");
+    return authResponse;
+  } catch (error) {
+    throw new Error(`Failed to install compute CLI in sandbox: ${error}`);
+  }
+}
 var ComputeManager = class {
   constructor() {
     this.config = null;
     this.typedState = { isTyped: false, provider: null };
+    this.computeAuth = {};
     this.sandbox = {
       /**
        * Create a sandbox from a provider (or default provider if configured)
@@ -71,10 +131,20 @@ var ComputeManager = class {
         const provider = params && "provider" in params && params.provider ? params.provider : this.getDefaultProvider();
         const options = params?.options;
         const sandbox = await provider.sandbox.create(options);
+        const authResponse = await installComputeInSandbox(sandbox, this.computeAuth);
+        let finalSandbox = sandbox;
+        if (authResponse) {
+          finalSandbox = new import_client.ComputeClient({
+            sandboxUrl: authResponse.sandbox_url,
+            sandboxId: sandbox.sandboxId,
+            provider: sandbox.provider,
+            token: authResponse.jwt
+          });
+        }
         if (this.typedState.isTyped && (!params || !("provider" in params && params.provider))) {
-          return sandbox;
+          return finalSandbox;
         }
-        return sandbox;
+        return finalSandbox;
       },
       /**
        * Get an existing sandbox by ID from a provider (or default provider if configured)
@@ -134,7 +204,13 @@ var ComputeManager = class {
     const actualProvider = config.defaultProvider || config.provider;
     this.config = {
       provider: actualProvider,
-      defaultProvider: actualProvider
+      defaultProvider: actualProvider,
+      apiKey: config.apiKey,
+      jwt: config.jwt
+    };
+    this.computeAuth = {
+      apiKey: config.apiKey,
+      jwt: config.jwt
     };
     this.typedState = {
       isTyped: true,
@@ -176,12 +252,18 @@ function createCompute(config) {
   const actualProvider = config.defaultProvider || config.provider;
   manager["config"] = {
     provider: actualProvider,
-    defaultProvider: actualProvider
+    defaultProvider: actualProvider,
+    apiKey: config.apiKey,
+    jwt: config.jwt
   };
   manager["typedState"] = {
     isTyped: true,
     provider: actualProvider
   };
+  manager["computeAuth"] = {
+    apiKey: config.apiKey,
+    jwt: config.jwt
+  };
   return {
     setConfig: (cfg) => createCompute(cfg),
     getConfig: () => manager.getConfig(),
@@ -591,7 +673,8 @@ var GeneratedSandboxManager = class {
     this.activeSandboxes = /* @__PURE__ */ new Map();
   }
   async create(options) {
-    const result = await this.methods.create(this.config, options);
+    const optionsWithDefaults = { runtime: "node", ...options };
+    const result = await this.methods.create(this.config, optionsWithDefaults);
     const sandbox = new GeneratedSandbox(
       result.sandbox,
       result.sandboxId,
@@ -651,6 +734,36 @@ var GeneratedSandboxManager = class {
     this.activeSandboxes.delete(sandboxId);
   }
 };
+var GeneratedTemplateManager = class {
+  constructor(config, methods) {
+    this.config = config;
+    this.methods = methods;
+  }
+  async create(options) {
+    return await this.methods.create(this.config, options);
+  }
+  async list(options) {
+    return await this.methods.list(this.config, options);
+  }
+  async delete(templateId) {
+    return await this.methods.delete(this.config, templateId);
+  }
+};
+var GeneratedSnapshotManager = class {
+  constructor(config, methods) {
+    this.config = config;
+    this.methods = methods;
+  }
+  async create(sandboxId, options) {
+    return await this.methods.create(this.config, sandboxId, options);
+  }
+  async list(options) {
+    return await this.methods.list(this.config, options);
+  }
+  async delete(snapshotId) {
+    return await this.methods.delete(this.config, snapshotId);
+  }
+};
 var GeneratedProvider = class {
   // Phantom type for TypeScript inference
   constructor(config, providerConfig) {
@@ -661,6 +774,15 @@ var GeneratedProvider = class {
       providerConfig.methods.sandbox,
       this
     );
+    if (providerConfig.methods.template) {
+      this.template = new GeneratedTemplateManager(config, providerConfig.methods.template);
+    }
+    if (providerConfig.methods.snapshot) {
+      this.snapshot = new GeneratedSnapshotManager(config, providerConfig.methods.snapshot);
+    }
+  }
+  getSupportedRuntimes() {
+    return ["node", "python"];
   }
 };
 function createProvider(providerConfig) {