0.2.1 • Published yesterday

@computesdk/lelantos

Licence

MIT

Version

0.2.1

Deps

Size

86 kB

Vulns

Weekly

Stars

222

Summary Dependency Versions

A unified SDK for running code in remote sandboxes.

What is ComputeSDK?

ComputeSDK provides a consistent TypeScript interface for executing code in remote sandboxes. Whether you're using E2B for data science, Modal for GPU workloads, or Vercel for serverless functions - ComputeSDK provides one unified API.

Perfect for:

AI code execution agents
Data science platforms
Educational coding environments
Testing & CI/CD systems
Developer tools

Quick Start

npm install computesdk @computesdk/e2b

Configure a provider and use the SDK:

import { compute } from 'computesdk';
import { e2b } from '@computesdk/e2b';

compute.setConfig({
  provider: e2b({ apiKey: process.env.E2B_API_KEY }),
});

const sandbox = await compute.sandbox.create();

const result = await sandbox.runCommand('python -c "print(\'Hello World!\')"');
console.log(result.stdout); // "Hello World!"

await sandbox.destroy();

Features

Multi-provider support - E2B, Modal, Daytona, Vercel, and more
Filesystem operations - Read, write, create directories across providers
Command execution - Run shell commands in sandboxes
Terminals - Interactive (PTY) and exec-mode command tracking
Type-safe - Full TypeScript support with comprehensive error handling
Extensible - Easy to add custom providers via @computesdk/provider

Supported Providers

Install provider packages and pass instances into compute.setConfig:

Provider	Environment Variables	Use Cases
E2B	`E2B_API_KEY`	Data science, Python/Node.js, interactive terminals
Modal	`MODAL_TOKEN_ID`, `MODAL_TOKEN_SECRET`	GPU computing, ML inference
Daytona	`DAYTONA_API_KEY`	Development workspaces
Runloop	`RUNLOOP_API_KEY`	Code execution, automation
Vercel	`VERCEL_TOKEN` or `VERCEL_OIDC_TOKEN`	Serverless functions
Cloudflare	`CLOUDFLARE_SANDBOX_URL`, `CLOUDFLARE_SANDBOX_SECRET`	Edge computing
CodeSandbox	`CSB_API_KEY`	Collaborative development
Tensorlake	`TENSORLAKE_API_KEY`	Stateful MicroVM sandboxes
Railway	`RAILWAY_API_TOKEN`, `RAILWAY_ENVIRONMENT_ID`	Ephemeral command execution sandboxes
CreateOS	`CREATEOS_SANDBOX_API_KEY`, `CREATEOS_SANDBOX_BASE_URL`	VM sandboxes with pause/resume/fork snapshots
Lelantos	`LELANTOS_API_KEY`	EU-native Firecracker microVMs, code execution, preview URLs
Tenki	`TENKI_API_KEY` or `TENKI_AUTH_TOKEN`	MicroVM sandboxes with native filesystem and preview URLs
AgentCore	AWS credential chain (`AWS_REGION`, profile, or SSO)	Managed AWS code-execution sandboxes

Configuration

Direct Provider Mode

Pass a provider instance directly to setConfig():

import { compute } from 'computesdk';
import { e2b } from '@computesdk/e2b';

compute.setConfig({
  provider: e2b({ apiKey: process.env.E2B_API_KEY }),
});

const sandbox = await compute.sandbox.create();

Multi-Provider Configuration

Configure multiple providers for resilience and routing:

import { compute } from 'computesdk';
import { e2b } from '@computesdk/e2b';
import { modal } from '@computesdk/modal';

compute.setConfig({
  providers: [
    e2b({ apiKey: process.env.E2B_API_KEY }),
    modal({
      tokenId: process.env.MODAL_TOKEN_ID,
      tokenSecret: process.env.MODAL_TOKEN_SECRET,
    }),
  ],
  providerStrategy: 'priority', // or 'round-robin'
  fallbackOnError: true,
});

// Uses configured strategy
const sandbox = await compute.sandbox.create();

// Force a specific provider for one call
const modalSandbox = await compute.sandbox.create({ provider: 'modal' });

Switching Providers at Runtime

import { compute } from 'computesdk';
import { e2b } from '@computesdk/e2b';
import { modal } from '@computesdk/modal';

// Use E2B for data science
compute.setConfig({
  provider: e2b({ apiKey: process.env.E2B_API_KEY }),
});

const e2bSandbox = await compute.sandbox.create();
await e2bSandbox.runCommand('python -c "import pandas as pd"');
await e2bSandbox.destroy();

// Switch to Modal for GPU workloads
compute.setConfig({
  provider: modal({
    tokenId: process.env.MODAL_TOKEN_ID,
    tokenSecret: process.env.MODAL_TOKEN_SECRET,
  }),
});

const modalSandbox = await compute.sandbox.create();
await modalSandbox.runCommand('python -c "import torch; print(torch.cuda.is_available())"');
await modalSandbox.destroy();

Core API

Sandbox Management

// Create sandbox
const sandbox = await compute.sandbox.create();

// Create with options
const sandbox = await compute.sandbox.create({
  runtime: 'python',
  timeout: 300000,
  metadata: { userId: '123' }
});

// Get existing sandbox
const sandbox = await compute.sandbox.getById('sandbox-id');

// List sandboxes
const sandboxes = await compute.sandbox.list();

// Destroy sandbox
await sandbox.destroy();

Command Execution

// Execute Python code
const result = await sandbox.runCommand('python -c "print(\'Hello\')"');
console.log(result.stdout);
console.log(result.exitCode);

// Run shell commands
const cmd = await sandbox.runCommand('npm install express');
console.log(cmd.stdout);
console.log(cmd.exitCode);

Filesystem Operations

// Write file
await sandbox.filesystem.writeFile('/tmp/hello.py', 'print("Hello")');

// Read file
const content = await sandbox.filesystem.readFile('/tmp/hello.py');

// Create directory
await sandbox.filesystem.mkdir('/tmp/data');

// List directory
const files = await sandbox.filesystem.readdir('/tmp');

// Check if exists
const exists = await sandbox.filesystem.exists('/tmp/hello.py');

// Remove
await sandbox.filesystem.remove('/tmp/hello.py');

Example: Data Science Workflow

import { compute } from 'computesdk';

const sandbox = await compute.sandbox.create({ runtime: 'python' });

// Create project structure
await sandbox.filesystem.mkdir('/analysis');
await sandbox.filesystem.mkdir('/analysis/data');

// Write input data
const csvData = `name,age,city
Alice,25,New York
Bob,30,San Francisco`;

await sandbox.filesystem.writeFile('/analysis/data/people.csv', csvData);

// Write the analysis script
await sandbox.filesystem.writeFile('/analysis/analyze.py', `
import json
import pandas as pd

df = pd.read_csv('/analysis/data/people.csv')
print(f"Average age: {df['age'].mean()}")

results = {'average_age': df['age'].mean()}
with open('/analysis/results.json', 'w') as f:
    json.dump(results, f)
`);

// Run it
const result = await sandbox.runCommand('python /analysis/analyze.py');
console.log(result.stdout);

// Read results
const results = await sandbox.filesystem.readFile('/analysis/results.json');
console.log('Results:', JSON.parse(results));

await sandbox.destroy();

Provider Packages

Install the provider packages you need and pass their instances into compute.setConfig:

npm install @computesdk/e2b        # E2B provider
npm install @computesdk/modal      # Modal provider
npm install @computesdk/daytona    # Daytona provider
npm install @computesdk/vercel     # Vercel provider
npm install @computesdk/tensorlake # Tensorlake provider
npm install @computesdk/railway    # Railway provider
npm install @computesdk/createos-sandbox # CreateOS VM sandbox provider
npm install @computesdk/lelantos   # Lelantos provider
npm install @computesdk/tenki      # Tenki provider
npm install @computesdk/agentcore  # AWS Bedrock AgentCore provider
npm install @computesdk/just-bash  # Local bash sandbox (no auth needed)

You can also use a provider's callable form directly, bypassing compute.setConfig:

import { e2b } from '@computesdk/e2b';

const e2bCompute = e2b({ apiKey: process.env.E2B_API_KEY });
const sandbox = await e2bCompute.sandbox.create();

See individual provider READMEs for details:

@computesdk/e2b - Data science, Python/Node.js, terminals
@computesdk/modal - GPU computing, ML inference
@computesdk/daytona - Development workspaces
@computesdk/vercel - Serverless functions
@computesdk/tensorlake - Stateful MicroVM sandboxes for agentic applications, with snapshot support
@computesdk/railway - Ephemeral command-execution sandboxes on Railway, with shell-based filesystem
@computesdk/createos-sandbox - NodeOps VM sandboxes, with pause/resume/fork snapshots and a native-handle escape hatch
@computesdk/lelantos - EU-native Firecracker microVM sandboxes (E2B-API-compatible), with snapshot/template support
@computesdk/tenki - Tenki Cloud microVM sandboxes with native filesystem and public preview URLs
@computesdk/agentcore - Managed AWS Bedrock AgentCore Code Interpreter sandboxes, authenticated via the standard AWS credential chain
@computesdk/just-bash - Local bash sandbox with virtual filesystem (no auth required)

Building Custom Providers

Want to add support for a new compute provider? See @computesdk/provider for the provider framework:

import { defineProvider } from '@computesdk/provider';

export const myProvider = defineProvider({
  name: 'my-provider',
  defaultMode: 'direct',
  methods: {
    sandbox: {
      create: async (config, options) => {
        // Your implementation
      },
      // ... other methods
    }
  }
});

Documentation

Full Documentation - Complete guides and API reference
Getting Started - Quick setup guide
Providers - Provider-specific documentation

TypeScript Support

Full TypeScript support with comprehensive type definitions:

import type { 
  Sandbox,
  SandboxInfo,
  CodeResult,
  CommandResult,
  CreateSandboxOptions
} from 'computesdk';

Contributing

ComputeSDK is open source and welcomes contributions!

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Community & Support

GitHub Discussions - Ask questions and share ideas
GitHub Issues - Report bugs and request features

License

MIT License - see the LICENSE file for details.

Built with by the ComputeSDK team

computesdk.com

Keywords

computesdk lelantos sandbox code-execution firecracker microvm python javascript cloud compute provider containers