@rivet-dev/agentos-sandbox 0.0.0-main.2f99c77 → 0.0.0-main.5ac5a14

package/dist/bindings.d.ts

@@ -0,0 +1,2 @@
+export type { AgentOsSandboxClientOptions as SandboxBindingsOptions } from "@rivet-dev/agentos-core";
+export { createSandboxBindings } from "@rivet-dev/agentos-core";

package/dist/bindings.js

@@ -0,0 +1 @@
+export { createSandboxBindings } from "@rivet-dev/agentos-core";

package/dist/cloudflare.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOsSandboxProvider } from "@rivet-dev/agentos-core";
+import type { CloudflareProviderOptions, CloudflareSandboxClient } from "sandbox-agent/cloudflare";
+export type { CloudflareProviderOptions, CloudflareSandboxClient };
+/** Start a Cloudflare sandbox for each AgentOS VM. */
+export declare function cloudflare(options: CloudflareProviderOptions): AgentOsSandboxProvider;

package/dist/cloudflare.js

@@ -0,0 +1,6 @@
+import { cloudflare as sandboxAgentCloudflare } from "sandbox-agent/cloudflare";
+import { sandboxAgentProvider } from "./provider.js";
+/** Start a Cloudflare sandbox for each AgentOS VM. */
+export function cloudflare(options) {
+    return sandboxAgentProvider(sandboxAgentCloudflare(options));
+}

package/dist/computesdk.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOsSandboxProvider } from "@rivet-dev/agentos-core";
+import type { ComputeSdkProviderOptions } from "sandbox-agent/computesdk";
+export type { ComputeSdkProviderOptions };
+/** Start a ComputeSDK sandbox for each AgentOS VM. */
+export declare function computesdk(options?: ComputeSdkProviderOptions): AgentOsSandboxProvider;

package/dist/computesdk.js

@@ -0,0 +1,6 @@
+import { computesdk as sandboxAgentComputeSdk } from "sandbox-agent/computesdk";
+import { sandboxAgentProvider } from "./provider.js";
+/** Start a ComputeSDK sandbox for each AgentOS VM. */
+export function computesdk(options) {
+    return sandboxAgentProvider(sandboxAgentComputeSdk(options));
+}

package/dist/daytona.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOsSandboxProvider } from "@rivet-dev/agentos-core";
+import type { DaytonaProviderOptions } from "sandbox-agent/daytona";
+export type { DaytonaProviderOptions };
+/** Start a Daytona sandbox for each AgentOS VM. */
+export declare function daytona(options?: DaytonaProviderOptions): AgentOsSandboxProvider;

package/dist/daytona.js

@@ -0,0 +1,6 @@
+import { daytona as sandboxAgentDaytona } from "sandbox-agent/daytona";
+import { sandboxAgentProvider } from "./provider.js";
+/** Start a Daytona sandbox for each AgentOS VM. */
+export function daytona(options) {
+    return sandboxAgentProvider(sandboxAgentDaytona(options));
+}

package/dist/docker.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOsSandboxProvider } from "@rivet-dev/agentos-core";
+import type { DockerProviderOptions } from "sandbox-agent/docker";
+export type { DockerProviderOptions };
+/** Start a local Docker sandbox for each AgentOS VM. */
+export declare function docker(options?: DockerProviderOptions): AgentOsSandboxProvider;

package/dist/docker.js

@@ -0,0 +1,6 @@
+import { docker as sandboxAgentDocker } from "sandbox-agent/docker";
+import { sandboxAgentProvider } from "./provider.js";
+/** Start a local Docker sandbox for each AgentOS VM. */
+export function docker(options) {
+    return sandboxAgentProvider(sandboxAgentDocker(options));
+}

package/dist/e2b.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOsSandboxProvider } from "@rivet-dev/agentos-core";
+import type { E2BProviderOptions } from "sandbox-agent/e2b";
+export type { E2BProviderOptions };
+/** Start an E2B sandbox for each AgentOS VM. */
+export declare function e2b(options?: E2BProviderOptions): AgentOsSandboxProvider;

package/dist/e2b.js

@@ -0,0 +1,6 @@
+import { e2b as sandboxAgentE2b } from "sandbox-agent/e2b";
+import { sandboxAgentProvider } from "./provider.js";
+/** Start an E2B sandbox for each AgentOS VM. */
+export function e2b(options) {
+    return sandboxAgentProvider(sandboxAgentE2b(options));
+}

package/dist/index.d.ts

@@ -1,4 +1,9 @@
+export type { AgentOsSandboxClient as SandboxClient, AgentOsSandboxClientOptions as SandboxClientOptions, AgentOsSandboxInput as SandboxInput, AgentOsSandboxOptions as SandboxOptions, AgentOsSandboxProvider as SandboxProvider, AgentOsSandboxProviderOptions as SandboxProviderOptions, } from "@rivet-dev/agentos-core";
+export type { SandboxBindingsOptions } from "./bindings.js";
+export { createSandboxBindings } from "./bindings.js";
+export type { DockerProviderOptions } from "./docker.js";
+export { docker } from "./docker.js";
 export type { SandboxFsOptions, SandboxMountPluginConfig, } from "./mount.js";
 export { createSandboxFs } from "./mount.js";
-export type { SandboxToolkitOptions } from "./toolkit.js";
-export { createSandboxToolkit } from "./toolkit.js";
+export type { SandboxAgentProviderOptions } from "./provider.js";
+export { sandboxAgentProvider } from "./provider.js";

package/dist/index.js

@@ -1,2 +1,4 @@
+export { createSandboxBindings } from "./bindings.js";
+export { docker } from "./docker.js";
 export { createSandboxFs } from "./mount.js";
-export { createSandboxToolkit } from "./toolkit.js";
+export { sandboxAgentProvider } from "./provider.js";

package/dist/local.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOsSandboxProvider } from "@rivet-dev/agentos-core";
+import type { LocalProviderOptions } from "sandbox-agent/local";
+export type { LocalProviderOptions };
+/** Start a local Sandbox Agent process for each AgentOS VM. */
+export declare function local(options?: LocalProviderOptions): AgentOsSandboxProvider;

package/dist/local.js

@@ -0,0 +1,6 @@
+import { local as sandboxAgentLocal } from "sandbox-agent/local";
+import { sandboxAgentProvider } from "./provider.js";
+/** Start a local Sandbox Agent process for each AgentOS VM. */
+export function local(options) {
+    return sandboxAgentProvider(sandboxAgentLocal(options));
+}

package/dist/modal.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOsSandboxProvider } from "@rivet-dev/agentos-core";
+import type { ModalProviderOptions } from "sandbox-agent/modal";
+export type { ModalProviderOptions };
+/** Start a Modal sandbox for each AgentOS VM. */
+export declare function modal(options?: ModalProviderOptions): AgentOsSandboxProvider;

package/dist/modal.js

@@ -0,0 +1,6 @@
+import { modal as sandboxAgentModal } from "sandbox-agent/modal";
+import { sandboxAgentProvider } from "./provider.js";
+/** Start a Modal sandbox for each AgentOS VM. */
+export function modal(options) {
+    return sandboxAgentProvider(sandboxAgentModal(options));
+}

package/dist/mount.d.ts

@@ -1,27 +1,2 @@
-import type { MountConfigJsonObject, NativeMountPluginDescriptor } from "@rivet-dev/agentos-runtime-core/descriptors";
-import type { SandboxAgent } from "sandbox-agent";
-export interface SandboxFsOptions {
-    /** A connected SandboxAgent client instance. */
-    client: SandboxAgent;
-    /** Base path to scope all operations under. Defaults to "/". */
-    basePath?: string;
-    /** Per-request timeout for sandbox-agent HTTP calls. */
-    timeoutMs?: number;
-    /** Maximum file size allowed for buffered pread/truncate fallbacks. */
-    maxFullReadBytes?: number;
-}
-export type SandboxMountPluginConfig = MountConfigJsonObject & {
-    baseUrl: string;
-    token?: string;
-    headers?: Record<string, string>;
-    basePath?: string;
-    timeoutMs?: number;
-    maxFullReadBytes?: number;
-};
-/**
- * Create a declarative sandbox-agent mount plugin descriptor.
- *
- * This keeps the legacy helper name while routing first-party sandbox mounts
- * through the native `sandbox_agent` plugin instead of a JS VFS backend.
- */
-export declare function createSandboxFs(options: SandboxFsOptions): NativeMountPluginDescriptor<SandboxMountPluginConfig>;
+export type { AgentOsSandboxClientOptions as SandboxFsOptions, SandboxMountPluginConfig, } from "@rivet-dev/agentos-core";
+export { createSandboxFs } from "@rivet-dev/agentos-core";

package/dist/mount.js

@@ -1,45 +1 @@
-function normalizeHeaders(headers) {
-    if (!headers) {
-        return undefined;
-    }
-    if (headers instanceof Headers) {
-        return Object.fromEntries(headers.entries());
-    }
-    if (Array.isArray(headers)) {
-        return Object.fromEntries(headers);
-    }
-    return Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)]));
-}
-function getSerializableClientConfig(client) {
-    const serializable = client;
-    const baseUrl = serializable.baseUrl?.trim().replace(/\/+$/, "");
-    if (!baseUrl) {
-        throw new Error("SandboxAgent client does not expose a serializable baseUrl; connect with a standard sandbox-agent client instance");
-    }
-    return {
-        baseUrl,
-        ...(serializable.token ? { token: serializable.token } : {}),
-        ...(serializable.defaultHeaders
-            ? { headers: normalizeHeaders(serializable.defaultHeaders) }
-            : {}),
-    };
-}
-/**
- * Create a declarative sandbox-agent mount plugin descriptor.
- *
- * This keeps the legacy helper name while routing first-party sandbox mounts
- * through the native `sandbox_agent` plugin instead of a JS VFS backend.
- */
-export function createSandboxFs(options) {
-    return {
-        id: "sandbox_agent",
-        config: {
-            ...getSerializableClientConfig(options.client),
-            ...(options.basePath ? { basePath: options.basePath } : {}),
-            ...(options.timeoutMs != null ? { timeoutMs: options.timeoutMs } : {}),
-            ...(options.maxFullReadBytes != null
-                ? { maxFullReadBytes: options.maxFullReadBytes }
-                : {}),
-        },
-    };
-}
+export { createSandboxFs } from "@rivet-dev/agentos-core";

package/dist/provider.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOsSandboxProvider } from "@rivet-dev/agentos-core";
+import { type SandboxProvider as SandboxAgentBackend, type SandboxAgentStartOptions } from "sandbox-agent";
+export type SandboxAgentProviderOptions = Omit<SandboxAgentStartOptions, "sandbox" | "sandboxId">;
+/** Adapt any sandbox-agent backend into a per-VM AgentOS sandbox provider. */
+export declare function sandboxAgentProvider(backend: SandboxAgentBackend, options?: SandboxAgentProviderOptions): AgentOsSandboxProvider;

package/dist/provider.js

@@ -0,0 +1,18 @@
+import { SandboxAgent, } from "sandbox-agent";
+/** Adapt any sandbox-agent backend into a per-VM AgentOS sandbox provider. */
+export function sandboxAgentProvider(backend, options = {}) {
+    return {
+        async start() {
+            const client = await SandboxAgent.start({ ...options, sandbox: backend });
+            return new Proxy(client, {
+                get(target, property) {
+                    if (property === "dispose") {
+                        return target.destroySandbox.bind(target);
+                    }
+                    const value = Reflect.get(target, property, target);
+                    return typeof value === "function" ? value.bind(target) : value;
+                },
+            });
+        },
+    };
+}

package/dist/sprites.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOsSandboxProvider } from "@rivet-dev/agentos-core";
+import type { SpritesClientOverrides, SpritesCreateOverrides, SpritesProviderOptions } from "sandbox-agent/sprites";
+export type { SpritesClientOverrides, SpritesCreateOverrides, SpritesProviderOptions, };
+/** Start a Fly.io Sprite for each AgentOS VM. */
+export declare function sprites(options?: SpritesProviderOptions): AgentOsSandboxProvider;

package/dist/sprites.js

@@ -0,0 +1,6 @@
+import { sprites as sandboxAgentSprites } from "sandbox-agent/sprites";
+import { sandboxAgentProvider } from "./provider.js";
+/** Start a Fly.io Sprite for each AgentOS VM. */
+export function sprites(options) {
+    return sandboxAgentProvider(sandboxAgentSprites(options));
+}

package/dist/vercel.d.ts

@@ -0,0 +1,5 @@
+import type { AgentOsSandboxProvider } from "@rivet-dev/agentos-core";
+import type { VercelProviderOptions } from "sandbox-agent/vercel";
+export type { VercelProviderOptions };
+/** Start a Vercel Sandbox for each AgentOS VM. */
+export declare function vercel(options?: VercelProviderOptions): AgentOsSandboxProvider;

package/dist/vercel.js

@@ -0,0 +1,6 @@
+import { vercel as sandboxAgentVercel } from "sandbox-agent/vercel";
+import { sandboxAgentProvider } from "./provider.js";
+/** Start a Vercel Sandbox for each AgentOS VM. */
+export function vercel(options) {
+    return sandboxAgentProvider(sandboxAgentVercel(options));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rivet-dev/agentos-sandbox",
-	"version": "0.0.0-main.2f99c77",
+	"version": "0.0.0-main.5ac5a14",
 	"type": "module",
 	"license": "Apache-2.0",
 	"main": "./dist/index.js",
@@ -13,6 +13,51 @@
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
+		},
+		"./local": {
+			"types": "./dist/local.d.ts",
+			"import": "./dist/local.js",
+			"default": "./dist/local.js"
+		},
+		"./e2b": {
+			"types": "./dist/e2b.d.ts",
+			"import": "./dist/e2b.js",
+			"default": "./dist/e2b.js"
+		},
+		"./daytona": {
+			"types": "./dist/daytona.d.ts",
+			"import": "./dist/daytona.js",
+			"default": "./dist/daytona.js"
+		},
+		"./docker": {
+			"types": "./dist/docker.d.ts",
+			"import": "./dist/docker.js",
+			"default": "./dist/docker.js"
+		},
+		"./vercel": {
+			"types": "./dist/vercel.d.ts",
+			"import": "./dist/vercel.js",
+			"default": "./dist/vercel.js"
+		},
+		"./cloudflare": {
+			"types": "./dist/cloudflare.d.ts",
+			"import": "./dist/cloudflare.js",
+			"default": "./dist/cloudflare.js"
+		},
+		"./modal": {
+			"types": "./dist/modal.d.ts",
+			"import": "./dist/modal.js",
+			"default": "./dist/modal.js"
+		},
+		"./computesdk": {
+			"types": "./dist/computesdk.d.ts",
+			"import": "./dist/computesdk.js",
+			"default": "./dist/computesdk.js"
+		},
+		"./sprites": {
+			"types": "./dist/sprites.d.ts",
+			"import": "./dist/sprites.js",
+			"default": "./dist/sprites.js"
 		}
 	},
 	"scripts": {
@@ -21,15 +66,20 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@rivet-dev/agentos-core": "0.0.0-main.2f99c77",
-		"@rivet-dev/agentos-runtime-core": "0.0.0-main.2f99c77",
-		"sandbox-agent": "^0.4.2",
-		"zod": "^4.1.11"
+		"@rivet-dev/agentos-core": "0.0.0-main.5ac5a14",
+		"dockerode": "^4.0.9",
+		"get-port": "^7.1.0",
+		"sandbox-agent": "^0.4.2"
 	},
 	"devDependencies": {
-		"@agentos-software/common": "0.0.0-main.2f99c77",
+		"@agentos-software/common": "0.0.0-main.5ac5a14",
 		"@types/node": "^22.10.2",
 		"typescript": "^5.7.2",
 		"vitest": "^2.1.8"
+	},
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/rivet-dev/agentos.git",
+		"directory": "packages/agentos-sandbox"
 	}
 }

package/dist/toolkit.d.ts

@@ -1,14 +0,0 @@
-/**
- * Sandbox toolkit exposing process management and command execution
- * as host tools for agents running inside an agentOS VM.
- */
-import type { ToolKit } from "@rivet-dev/agentos-core";
-import type { SandboxAgent } from "sandbox-agent";
-export interface SandboxToolkitOptions {
-    /** A connected SandboxAgent client instance. */
-    client: SandboxAgent;
-}
-/**
- * Create a ToolKit that exposes sandbox process management operations.
- */
-export declare function createSandboxToolkit(options: SandboxToolkitOptions): ToolKit;

package/dist/toolkit.js

@@ -1,191 +0,0 @@
-/**
- * Sandbox toolkit exposing process management and command execution
- * as host tools for agents running inside an agentOS VM.
- */
-import { z } from "zod";
-/** Host tool type alias for convenience. */
-function hostTool(def) {
-    return def;
-}
-/**
- * Create a ToolKit that exposes sandbox process management operations.
- */
-export function createSandboxToolkit(options) {
-    const { client } = options;
-    return {
-        name: "sandbox",
-        description: "Execute commands and manage processes in a remote sandbox environment.",
-        tools: {
-            "run-command": hostTool({
-                description: "Run a command synchronously in the sandbox and return its stdout, stderr, and exit code.",
-                inputSchema: z.object({
-                    command: z
-                        .string()
-                        .describe("The command to execute (e.g. 'ls', 'python3')."),
-                    args: z
-                        .array(z.string())
-                        .optional()
-                        .describe("Arguments to pass to the command."),
-                    cwd: z
-                        .string()
-                        .optional()
-                        .describe("Working directory for the command."),
-                    env: z
-                        .record(z.string(), z.string())
-                        .optional()
-                        .describe("Additional environment variables."),
-                    timeoutMs: z
-                        .number()
-                        .optional()
-                        .describe("Maximum execution time in milliseconds."),
-                }),
-                timeout: 120_000,
-                execute: async (input) => {
-                    const result = await client.runProcess({
-                        command: input.command,
-                        args: input.args,
-                        cwd: input.cwd,
-                        env: input.env,
-                        timeoutMs: input.timeoutMs,
-                    });
-                    return {
-                        stdout: result.stdout,
-                        stderr: result.stderr,
-                        exitCode: result.exitCode,
-                        timedOut: result.timedOut,
-                        durationMs: result.durationMs,
-                    };
-                },
-            }),
-            "create-process": hostTool({
-                description: "Start a long-running background process in the sandbox. Returns a process ID for later management.",
-                inputSchema: z.object({
-                    command: z.string().describe("The command to execute."),
-                    args: z
-                        .array(z.string())
-                        .optional()
-                        .describe("Arguments to pass to the command."),
-                    cwd: z
-                        .string()
-                        .optional()
-                        .describe("Working directory for the process."),
-                    env: z
-                        .record(z.string(), z.string())
-                        .optional()
-                        .describe("Additional environment variables."),
-                }),
-                execute: async (input) => {
-                    const proc = await client.createProcess({
-                        command: input.command,
-                        args: input.args,
-                        cwd: input.cwd,
-                        env: input.env,
-                    });
-                    return {
-                        id: proc.id,
-                        command: proc.command,
-                        args: proc.args,
-                        status: proc.status,
-                        pid: proc.pid,
-                    };
-                },
-            }),
-            "list-processes": hostTool({
-                description: "List all processes running in the sandbox.",
-                inputSchema: z.object({}),
-                execute: async () => {
-                    const result = await client.listProcesses();
-                    return {
-                        processes: result.processes.map((p) => ({
-                            id: p.id,
-                            command: p.command,
-                            args: p.args,
-                            status: p.status,
-                            exitCode: p.exitCode,
-                            pid: p.pid,
-                        })),
-                    };
-                },
-            }),
-            "stop-process": hostTool({
-                description: "Gracefully stop a running process in the sandbox.",
-                inputSchema: z.object({
-                    id: z.string().describe("The process ID to stop."),
-                }),
-                execute: async (input) => {
-                    const proc = await client.stopProcess(input.id);
-                    return {
-                        id: proc.id,
-                        status: proc.status,
-                        exitCode: proc.exitCode,
-                    };
-                },
-            }),
-            "kill-process": hostTool({
-                description: "Forcefully kill a running process in the sandbox.",
-                inputSchema: z.object({
-                    id: z.string().describe("The process ID to kill."),
-                }),
-                execute: async (input) => {
-                    const proc = await client.killProcess(input.id);
-                    return {
-                        id: proc.id,
-                        status: proc.status,
-                        exitCode: proc.exitCode,
-                    };
-                },
-            }),
-            "get-process-logs": hostTool({
-                description: "Get stdout/stderr logs from a sandbox process.",
-                inputSchema: z.object({
-                    id: z.string().describe("The process ID."),
-                    stream: z
-                        .enum(["stdout", "stderr", "combined"])
-                        .optional()
-                        .describe("Which output stream to read. Defaults to combined."),
-                    tail: z
-                        .number()
-                        .optional()
-                        .describe("Only return the last N log entries."),
-                }),
-                execute: async (input) => {
-                    const result = await client.getProcessLogs(input.id, {
-                        stream: input.stream,
-                        tail: input.tail,
-                    });
-                    return {
-                        logs: result.entries.map((e) => {
-                            // The sandbox-agent SDK returns log data as base64. Decode it
-                            // so callers receive plain text.
-                            let text = e.data;
-                            if (e.encoding === "base64") {
-                                text = Buffer.from(e.data, "base64").toString("utf-8");
-                            }
-                            return {
-                                data: text,
-                                stream: e.stream,
-                                timestampMs: e.timestampMs,
-                            };
-                        }),
-                    };
-                },
-            }),
-            "send-input": hostTool({
-                description: "Send text input to an interactive sandbox process via stdin.",
-                inputSchema: z.object({
-                    id: z.string().describe("The process ID."),
-                    data: z.string().describe("The text to send to the process stdin."),
-                }),
-                execute: async (input) => {
-                    // Encode the text as base64 for the sandbox-agent API.
-                    const encoded = Buffer.from(input.data, "utf-8").toString("base64");
-                    await client.sendProcessInput(input.id, {
-                        data: encoded,
-                        encoding: "base64",
-                    });
-                    return { sent: true };
-                },
-            }),
-        },
-    };
-}