sbox-sdk 0.0.2

package/dist/ai-sdk/index.js

@@ -0,0 +1,80 @@
+/**
+ * `sbox-sdk/ai-sdk` — Vercel AI SDK adapter. Projects the provider-neutral
+ * sandbox tool registry into the AI SDK's `tool()` shape, keyed by tool name so
+ * the result drops straight into `generateText({ tools })` / `streamText`.
+ *
+ * Approval: stable `ai` v5 has no `needsApproval` field on a tool, so the
+ * `SandboxPolicy` is enforced inside `execute` — `"deny"` short-circuits with a
+ * message the model reads, and `"ask"` awaits `policy.onApprovalRequest` when
+ * one is configured (otherwise it proceeds; HITL is opt-in). For AI SDK v7,
+ * `toolApproval()` builds the call-site approval map instead.
+ *
+ * Peer dependency: `ai` (optional).
+ */
+import { tool } from "ai";
+import { decide, enforcePolicy } from "../agent-tools/policy.js";
+import { createSandboxTools } from "../agent-tools/registry.js";
+function resolve(source, opts) {
+    return Array.isArray(source)
+        ? { specs: source }
+        : { sandbox: source, specs: createSandboxTools(source, opts) };
+}
+/**
+ * Build AI SDK tools from a live sandbox (capability-gated) or a pre-built
+ * `ToolSpec[]`. Hand the result to `generateText({ tools })`.
+ */
+export function toAISDKTools(source, opts = {}) {
+    const { specs, sandbox } = resolve(source, opts);
+    const { policy } = opts;
+    const tools = {};
+    for (const spec of specs) {
+        tools[spec.name] = tool({
+            description: spec.description,
+            execute: async (input, options) => {
+                const ctx = { sandbox, signal: options.abortSignal };
+                const denied = await enforcePolicy(spec, input, ctx, policy);
+                if (denied !== null) {
+                    return denied;
+                }
+                const result = await spec.execute(input, ctx);
+                return result.text;
+            },
+            inputSchema: spec.inputSchema,
+        });
+    }
+    return tools;
+}
+/**
+ * The Vercel AI SDK framework adapter for the `ai()` plugin:
+ *
+ * ```ts
+ * import { ai } from "sbox-sdk/ai";
+ * import { aiSdk } from "sbox-sdk/ai-sdk";
+ *
+ * const client = createSandboxClient({ provider: e2b(), plugins: [ai({ framework: aiSdk() })] });
+ * const sandbox = await client.create();
+ * await generateText({ model, prompt, tools: sandbox.tools });
+ * ```
+ */
+export function aiSdk() {
+    return {
+        build: (sandbox, opts) => toAISDKTools(sandbox, opts),
+        name: "ai-sdk",
+    };
+}
+/**
+ * AI SDK v7 forward-compat: build the call-site `toolApproval` map
+ * (`generateText({ tools, toolApproval })`) from the same policy. Each entry
+ * returns `"user-approval"` when the policy says "ask", else `undefined`.
+ */
+export function toolApproval(source, opts = {}) {
+    const { specs, sandbox } = resolve(source, opts);
+    const { policy } = opts;
+    const map = {};
+    for (const spec of specs) {
+        map[spec.name] = async (input) => decide(spec, input, { sandbox }, policy) === "ask"
+            ? "user-approval"
+            : undefined;
+    }
+    return map;
+}

package/dist/anthropic/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * `sbox-sdk/anthropic` — Anthropic (Claude) adapter. Projects the
+ * provider-neutral sandbox tool registry into the SDK's `betaZodTool()` shape.
+ *
+ * The returned `BetaRunnableTool[]` serves BOTH Claude tool-use paths, because a
+ * `BetaRunnableTool` IS a tool definition (`BetaToolUnion`) plus a `run`/`parse`:
+ *   • auto-loop  — `anthropic.beta.messages.toolRunner({ tools })`
+ *   • manual loop — `anthropic.beta.messages.create({ tools })`, then on a
+ *     `tool_use` block: `tool.run(tool.parse(block.input))` -> `tool_result`.
+ *
+ * Approval: Claude has no native HITL, so the shared `enforcePolicy` runs inside
+ * `run` — `"deny"` short-circuits and `"ask"` awaits `policy.onApprovalRequest`
+ * (when configured); both return a message Claude reads.
+ *
+ * Peer dependency: `@anthropic-ai/sdk` (optional).
+ */
+import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
+import type { FrameworkAdapter, ToolSetOptions, ToolSpec } from "../agent-tools/types.js";
+import type { Sandbox } from "../internal/types.js";
+export type AnthropicToolOptions = ToolSetOptions;
+/** Array of runnable Claude tools (also valid tool definitions for create()). */
+export type AnthropicToolSet = ReturnType<typeof betaZodTool>[];
+/**
+ * Build Claude tools from a live sandbox (capability-gated) or a pre-built
+ * `ToolSpec[]`. Pass the result to `anthropic.beta.messages.toolRunner({ tools })`
+ * or `anthropic.beta.messages.create({ tools })`.
+ */
+export declare function toAnthropicTools(source: Sandbox | ToolSpec[], opts?: AnthropicToolOptions): AnthropicToolSet;
+/**
+ * The Anthropic (Claude) framework adapter for the `ai()` plugin:
+ *
+ * ```ts
+ * import { ai } from "sbox-sdk/ai";
+ * import { anthropic } from "sbox-sdk/anthropic";
+ *
+ * const client = createSandboxClient({ provider: e2b(), plugins: [ai({ framework: anthropic() })] });
+ * const sandbox = await client.create();
+ * const msg = await claude.beta.messages.toolRunner({ model, messages, tools: sandbox.tools });
+ * ```
+ */
+export declare function anthropic(): FrameworkAdapter<AnthropicToolSet>;
+//# sourceMappingURL=index.d.ts.map

package/dist/anthropic/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/anthropic/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAIjE,OAAO,KAAK,EACV,gBAAgB,EAEhB,cAAc,EACd,QAAQ,EACT,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAEpD,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC;AAElD,iFAAiF;AACjF,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,EAAE,CAAC;AAahE;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,OAAO,GAAG,QAAQ,EAAE,EAC5B,IAAI,GAAE,oBAAyB,GAC9B,gBAAgB,CAkBlB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,IAAI,gBAAgB,CAAC,gBAAgB,CAAC,CAK9D"}

package/dist/anthropic/index.js

@@ -0,0 +1,64 @@
+/**
+ * `sbox-sdk/anthropic` — Anthropic (Claude) adapter. Projects the
+ * provider-neutral sandbox tool registry into the SDK's `betaZodTool()` shape.
+ *
+ * The returned `BetaRunnableTool[]` serves BOTH Claude tool-use paths, because a
+ * `BetaRunnableTool` IS a tool definition (`BetaToolUnion`) plus a `run`/`parse`:
+ *   • auto-loop  — `anthropic.beta.messages.toolRunner({ tools })`
+ *   • manual loop — `anthropic.beta.messages.create({ tools })`, then on a
+ *     `tool_use` block: `tool.run(tool.parse(block.input))` -> `tool_result`.
+ *
+ * Approval: Claude has no native HITL, so the shared `enforcePolicy` runs inside
+ * `run` — `"deny"` short-circuits and `"ask"` awaits `policy.onApprovalRequest`
+ * (when configured); both return a message Claude reads.
+ *
+ * Peer dependency: `@anthropic-ai/sdk` (optional).
+ */
+import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
+import { enforcePolicy } from "../agent-tools/policy.js";
+import { createSandboxTools } from "../agent-tools/registry.js";
+function resolve(source, opts) {
+    return Array.isArray(source)
+        ? { specs: source }
+        : { sandbox: source, specs: createSandboxTools(source, opts) };
+}
+/**
+ * Build Claude tools from a live sandbox (capability-gated) or a pre-built
+ * `ToolSpec[]`. Pass the result to `anthropic.beta.messages.toolRunner({ tools })`
+ * or `anthropic.beta.messages.create({ tools })`.
+ */
+export function toAnthropicTools(source, opts = {}) {
+    const { specs, sandbox } = resolve(source, opts);
+    const { policy } = opts;
+    return specs.map((spec) => betaZodTool({
+        description: spec.description,
+        inputSchema: spec.inputSchema,
+        name: spec.name,
+        run: async (args) => {
+            const ctx = { sandbox };
+            const denied = await enforcePolicy(spec, args, ctx, policy);
+            if (denied !== null) {
+                return denied;
+            }
+            return (await spec.execute(args, ctx)).text;
+        },
+    }));
+}
+/**
+ * The Anthropic (Claude) framework adapter for the `ai()` plugin:
+ *
+ * ```ts
+ * import { ai } from "sbox-sdk/ai";
+ * import { anthropic } from "sbox-sdk/anthropic";
+ *
+ * const client = createSandboxClient({ provider: e2b(), plugins: [ai({ framework: anthropic() })] });
+ * const sandbox = await client.create();
+ * const msg = await claude.beta.messages.toolRunner({ model, messages, tools: sandbox.tools });
+ * ```
+ */
+export function anthropic() {
+    return {
+        build: (sandbox, opts) => toAnthropicTools(sandbox, opts),
+        name: "anthropic",
+    };
+}

package/dist/aws-lambda/index.d.ts

@@ -0,0 +1,87 @@
+import type { SandboxProvider } from "../adapter/index.js";
+export interface AwsLambdaOptions {
+    /** ARN of the MicroVM image to run (default for create when spec.template is unset). */
+    imageIdentifier?: string;
+    region?: string;
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    /** Runner port inside the MicroVM (default 8080). */
+    port?: number;
+    /** Base path your runner serves under (default ""). */
+    runnerBasePath?: string;
+    /** Auth-token lifetime in minutes (default 30). */
+    tokenTtlMinutes?: number;
+    /** Max running+suspended lifetime in seconds (1–28800). */
+    maximumDurationInSeconds?: number;
+    executionRoleArn?: string;
+    ingressNetworkConnectors?: string[];
+    egressNetworkConnectors?: string[];
+    /** Override the control-plane client endpoint (testing/localstack). */
+    endpoint?: string;
+    /** Injectable fetch for the data plane (testing); defaults to globalThis.fetch. */
+    fetch?: typeof fetch;
+}
+interface MicrovmRef {
+    microvmId: string;
+    endpoint: string;
+}
+export declare const AWS_LAMBDA_CAPS: {
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "native";
+    readonly privatePreview: "native";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "native";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "unsupported";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+};
+export type AwsLambdaCaps = typeof AWS_LAMBDA_CAPS;
+export declare const awsLambda: (opts: AwsLambdaOptions) => SandboxProvider<{
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "native";
+    readonly privatePreview: "native";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "native";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "unsupported";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+}, MicrovmRef>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/aws-lambda/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/aws-lambda/index.ts"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EASV,eAAe,EAGhB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,gBAAgB;IAC/B,wFAAwF;IACxF,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE;QACZ,WAAW,EAAE,MAAM,CAAC;QACpB,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,qDAAqD;IACrD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,uDAAuD;IACvD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,mDAAmD;IACnD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,2DAA2D;IAC3D,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAClC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;IACpC,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;IACnC,uEAAuE;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mFAAmF;IACnF,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;CACtB;AAED,UAAU,UAAU;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BM,CAAC;AAEnC,MAAM,MAAM,aAAa,GAAG,OAAO,eAAe,CAAC;AA8DnD,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;cA0PpB,CAAC"}

package/dist/aws-lambda/index.js

@@ -0,0 +1,290 @@
+/**
+ * `sbox-sdk/aws-lambda` — adapter for AWS Lambda MicroVMs (Firecracker-based
+ * serverless sandboxes, GA June 2026).
+ *
+ * Two planes:
+ *  - CONTROL plane via `@aws-sdk/client-lambda-microvms`: RunMicrovm (launch from
+ *    a pre-built image ARN) -> {microvmId, endpoint}; CreateMicrovmAuthToken (JWE);
+ *    Suspend/Resume (preserve memory+disk up to 8h); Terminate; ListMicrovms.
+ *  - DATA plane via fetch to the microVM's dedicated HTTPS endpoint, with headers
+ *    `X-aws-proxy-auth` (token) and `X-aws-proxy-port`. AWS does NOT provide a
+ *    built-in exec/fs API — your image must run an HTTP "runner". This adapter
+ *    speaks a tiny runner protocol (see ./runner): POST /sbox/exec, /sbox/fs/read,
+ *    /sbox/fs/write. Bake the reference runner into your MicroVM image.
+ *
+ * `pause()` = Suspend (memory preserved); `destroy()` = Terminate. `stop()` is
+ * unsupported (there is no keep-compute-but-release state in between). Requires
+ * the optional peer dependency `@aws-sdk/client-lambda-microvms`.
+ */
+import { AsyncQueue, base64ToBytes, bytesToBase64, defineProvider, SandboxError, } from "../adapter/index.js";
+export const AWS_LAMBDA_CAPS = {
+    background: "unsupported",
+    codeInterpreter: "unsupported",
+    egressControl: "unsupported",
+    exposePort: "native",
+    filesUpload: "native",
+    filesWatch: "unsupported",
+    fork: "unsupported",
+    gpu: "unsupported",
+    killProcess: "unsupported",
+    list: "native",
+    metrics: "unsupported",
+    pause: "native",
+    privatePreview: "native",
+    proxiedFetch: "unsupported",
+    pty: "unsupported",
+    region: "native",
+    secretsVault: "unsupported",
+    setTimeout: "unsupported",
+    snapshot: "unsupported",
+    ssh: "unsupported",
+    statefulKernel: "unsupported",
+    stdin: "unsupported",
+    stop: "unsupported",
+    streaming: "emulated",
+    volumes: "unsupported",
+};
+const AWS_LAMBDA_FLAGS = {
+    exitCodeNative: true,
+    perCommandEnvCwd: true, // the runner applies cwd/env per /sbox/exec request
+    preservesDiskOnStop: false,
+    preservesMemoryOnPause: true, // Suspend preserves memory + disk
+    previewModel: "tunnel",
+};
+let cached = null;
+async function loadAws() {
+    if (!cached) {
+        cached =
+            (await import("@aws-sdk/client-lambda-microvms"));
+    }
+    return cached;
+}
+function mapStatus(s) {
+    if (s === 404) {
+        return "NotFound";
+    }
+    if (s === 401 || s === 403) {
+        return "Unauthorized";
+    }
+    if (s === 429) {
+        return "QuotaExceeded";
+    }
+    if (s === 408) {
+        return "Timeout";
+    }
+    return "Provider";
+}
+function mapState(state) {
+    switch ((state ?? "").toUpperCase()) {
+        case "RUNNING": {
+            return "running";
+        }
+        case "SUSPENDED": {
+            return "paused";
+        }
+        case "PENDING":
+        case "STARTING": {
+            return "creating";
+        }
+        case "TERMINATED": {
+            return "destroyed";
+        }
+        default: {
+            return "unknown";
+        }
+    }
+}
+export const awsLambda = defineProvider((opts) => {
+    const port = opts.port ?? 8080;
+    const runnerBase = opts.runnerBasePath ?? "";
+    const fetchImpl = opts.fetch ?? globalThis.fetch;
+    let clientP = null;
+    const getClient = async () => {
+        if (!clientP) {
+            clientP = loadAws().then((mod) => new mod.LambdaMicrovmsClient({
+                region: opts.region,
+                credentials: opts.credentials,
+                endpoint: opts.endpoint,
+            }));
+        }
+        return clientP;
+    };
+    const mintToken = async (microvmId) => {
+        const mod = await loadAws();
+        const client = await getClient();
+        const res = await client.send(new mod.CreateMicrovmAuthTokenCommand({
+            microvmIdentifier: microvmId,
+            expirationInMinutes: opts.tokenTtlMinutes ?? 30,
+            allowedPorts: [{ allPorts: {} }],
+        }));
+        const authToken = res.authToken;
+        return authToken?.["X-aws-proxy-auth"] ?? "";
+    };
+    const makeHandle = (ref, initialToken) => {
+        let token = initialToken;
+        const dp = async (path, body) => {
+            const call = () => fetchImpl(`https://${ref.endpoint}${runnerBase}${path}`, {
+                method: "POST",
+                headers: {
+                    "x-aws-proxy-auth": token,
+                    "x-aws-proxy-port": String(port),
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify(body),
+            });
+            let res = await call();
+            if (res.status === 401) {
+                token = await mintToken(ref.microvmId); // token expired -> refresh once
+                res = await call();
+            }
+            if (res.status === 404) {
+                throw new SandboxError("NotFound", `${path} -> 404`, {
+                    provider: "aws-lambda",
+                    status: 404,
+                });
+            }
+            if (!res.ok) {
+                const text = await res.text().catch(() => "");
+                throw new SandboxError(mapStatus(res.status), `aws-lambda ${path} -> ${res.status} ${text}`, {
+                    provider: "aws-lambda",
+                    status: res.status,
+                    retryable: res.status === 429 || res.status >= 500,
+                });
+            }
+            return (await res.json());
+        };
+        const ctl = async (Command, input) => {
+            const mod = (await loadAws());
+            const client = await getClient();
+            return client.send(new mod[Command](input));
+        };
+        return {
+            id: ref.microvmId,
+            raw: ref,
+            getInfo() {
+                return {
+                    id: ref.microvmId,
+                    state: "running",
+                    provider: "aws-lambda",
+                    metadata: {},
+                    raw: ref,
+                };
+            },
+            async destroy() {
+                await ctl("TerminateMicrovmCommand", {
+                    microvmIdentifier: ref.microvmId,
+                });
+            },
+            async pause() {
+                await ctl("SuspendMicrovmCommand", {
+                    microvmIdentifier: ref.microvmId,
+                });
+            },
+            async resume() {
+                await ctl("ResumeMicrovmCommand", { microvmIdentifier: ref.microvmId });
+            },
+            exec(cmd, options) {
+                const queue = new AsyncQueue();
+                void dp("/sbox/exec", {
+                    cmd,
+                    cwd: options.cwd,
+                    env: options.env,
+                    timeoutMs: options.timeoutMs,
+                })
+                    .then((r) => {
+                    if (r.stdout) {
+                        queue.push({ type: "stdout", data: r.stdout });
+                    }
+                    if (r.stderr) {
+                        queue.push({ type: "stderr", data: r.stderr });
+                    }
+                    queue.push({ type: "exit", exitCode: r.exitCode ?? 0 });
+                    queue.close();
+                })
+                    .catch((error) => queue.fail(error instanceof SandboxError
+                    ? error
+                    : SandboxError.wrap(error, "aws-lambda")));
+                return {
+                    pid: Promise.resolve(""),
+                    async kill() {
+                        /* buffered runner exec; no kill handle */
+                    },
+                    [Symbol.asyncIterator]: () => queue.iterator(),
+                };
+            },
+            async readFile(path) {
+                const r = await dp("/sbox/fs/read", {
+                    path,
+                });
+                return base64ToBytes(r.contentBase64);
+            },
+            async writeFile(path, data) {
+                await dp("/sbox/fs/write", {
+                    path,
+                    contentBase64: bytesToBase64(data),
+                });
+            },
+            exposePort(p) {
+                // Single endpoint + port routing via the X-aws-proxy-port header; the JWE
+                // token authorizes access. Consumers send both headers.
+                return { url: `https://${ref.endpoint}`, port: p, token };
+            },
+        };
+    };
+    const provider = {
+        name: "aws-lambda",
+        capabilities: AWS_LAMBDA_CAPS,
+        flags: AWS_LAMBDA_FLAGS,
+        async create(spec) {
+            const image = spec.template ?? opts.imageIdentifier;
+            if (!image) {
+                throw new SandboxError("Validation", "aws-lambda requires an image ARN (spec.template or imageIdentifier option)", { provider: "aws-lambda" });
+            }
+            const mod = await loadAws();
+            const client = await getClient();
+            const run = await client.send(new mod.RunMicrovmCommand({
+                imageIdentifier: image,
+                executionRoleArn: opts.executionRoleArn,
+                maximumDurationInSeconds: opts.maximumDurationInSeconds ??
+                    (spec.ttlMs ? Math.ceil(spec.ttlMs / 1000) : undefined),
+                ingressNetworkConnectors: opts.ingressNetworkConnectors,
+                egressNetworkConnectors: opts.egressNetworkConnectors,
+                runHookPayload: spec.env
+                    ? JSON.stringify({ env: spec.env })
+                    : undefined,
+            }));
+            const ref = {
+                microvmId: run.microvmId,
+                endpoint: run.endpoint,
+            };
+            return makeHandle(ref, await mintToken(ref.microvmId));
+        },
+        async connect(id) {
+            const mod = await loadAws();
+            const client = await getClient();
+            const got = await client.send(new mod.GetMicrovmCommand({ microvmIdentifier: id }));
+            const ref = {
+                microvmId: id,
+                endpoint: got.endpoint,
+            };
+            return makeHandle(ref, await mintToken(id));
+        },
+        async *list() {
+            const mod = await loadAws();
+            const client = await getClient();
+            const res = await client.send(new mod.ListMicrovmsCommand({}));
+            const items = (res.microvms ?? res.items ?? []);
+            for (const m of items) {
+                const id = m.microvmId ?? m.id ?? "";
+                yield {
+                    id,
+                    state: mapState(m.state),
+                    provider: "aws-lambda",
+                    metadata: {},
+                    raw: m,
+                };
+            }
+        },
+    };
+    return provider;
+});

package/dist/beam/index.d.ts

@@ -0,0 +1,92 @@
+import type { SandboxProvider } from "../adapter/index.js";
+export interface BeamOptions {
+    /** Beam API token (falls back to the SDK's standard environment). */
+    token?: string;
+    /** Beam workspace id (falls back to the SDK's standard environment). */
+    workspaceId?: string;
+    /** Default base image when a spec omits `template`. */
+    image?: string;
+    /** Default vCPUs for new sandboxes. */
+    cpu?: number;
+    /** Default memory (e.g. "1Gi") for new sandboxes. */
+    memory?: string;
+}
+export declare const BEAM_CAPS: {
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "native";
+    readonly gpu: "native";
+    readonly killProcess: "unsupported";
+    readonly list: "unsupported";
+    readonly metrics: "unsupported";
+    readonly pause: "unsupported";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "native";
+    readonly snapshot: "native";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+};
+export type BeamCaps = typeof BEAM_CAPS;
+interface BeamStream {
+    read?(): Promise<string | Uint8Array | null>;
+    [Symbol.asyncIterator]?(): AsyncIterator<string | Uint8Array>;
+}
+interface BeamProcess {
+    pid?: number;
+    stdout?: BeamStream | string;
+    stderr?: BeamStream | string;
+    wait(): Promise<number>;
+    kill(): Promise<void>;
+}
+interface BeamInstance {
+    exec(command: string | string[], opts?: {
+        cwd?: string;
+        env?: Record<string, string>;
+    }): Promise<BeamProcess>;
+    exposePort(port: number): Promise<string>;
+    snapshot(): Promise<string>;
+    updateTtl(ttl: number): Promise<void>;
+    terminate(): Promise<boolean>;
+    sandboxId(): string;
+}
+export declare const beam: (opts: BeamOptions) => SandboxProvider<{
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "native";
+    readonly gpu: "native";
+    readonly killProcess: "unsupported";
+    readonly list: "unsupported";
+    readonly metrics: "unsupported";
+    readonly pause: "unsupported";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "native";
+    readonly snapshot: "native";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+}, BeamInstance>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/beam/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/beam/index.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EASV,eAAe,EAGhB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BY,CAAC;AAEnC,MAAM,MAAM,QAAQ,GAAG,OAAO,SAAS,CAAC;AAWxC,UAAU,UAAU;IAClB,IAAI,CAAC,IAAI,OAAO,CAAC,MAAM,GAAG,UAAU,GAAG,IAAI,CAAC,CAAC;IAC7C,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC,IAAI,aAAa,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC;CAC/D;AACD,UAAU,WAAW;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IAC7B,MAAM,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IAC7B,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACxB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AACD,UAAU,YAAY;IACpB,IAAI,CACF,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,EAC1B,IAAI,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,GACpD,OAAO,CAAC,WAAW,CAAC,CAAC;IACxB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC5B,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtC,SAAS,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9B,SAAS,IAAI,MAAM,CAAC;CACrB;AAoDD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;gBAyKhB,CAAC"}