withruntime 0.3.1 → 0.4.0

package/E2B.md

@@ -0,0 +1,146 @@
+# Code written for E2B, on Runtime
+
+Run code written for [E2B](https://e2b.dev)'s SDK on Runtime Cloud by changing
+one import. It is part of Runtime's SDK (`withruntime`), built on the same
+client, so it gets that SDK's retries, idempotency keys and errors. Importing
+`withruntime` alone does not load it.
+
+```ts no-run
+import { Sandbox } from "withruntime/e2b"; // was: from "e2b"
+```
+
+```ts no-run
+import { Sandbox } from "withruntime/e2b/code-interpreter"; // was: from "@e2b/code-interpreter"
+```
+
+Python has the same, in `pip install withruntime`:
+
+```python no-run
+from withruntime.e2b import Sandbox  # was: from e2b import Sandbox
+from withruntime.e2b.code_interpreter import Sandbox  # was: from e2b_code_interpreter import Sandbox
+```
+
+The mapping was written against `e2b` 2.51.0 and `@e2b/code-interpreter`
+2.8.0 (Python: `e2b` 2.51.0, `e2b-code-interpreter` 2.10.0), checked
+23 September 2026.
+
+## Keys
+
+The package uses, in order: an `apiKey` you pass, `RUNTIME_API_KEY`, a Runtime
+key left in `E2B_API_KEY`, and the key `npx withruntime login` saved on this
+machine. An E2B key (`e2b_...`) is never sent anywhere. If one is passed as
+`apiKey` and `RUNTIME_API_KEY` is not set, the call fails with
+`AuthenticationError`.
+
+## What a sandbox gets
+
+- **Machine:** E2B's default, 2 vCPU and 512 MiB. For another, pass
+  `runtime: { create: { memoryMiB: 4096 } }` (Python:
+  `runtime_create={"memory_mib": 4096}`).
+- **Timeout:** E2B's default of 300 seconds. When it ends, the sandbox is
+  stopped, as E2B kills it. `lifecycle: { onTimeout: "pause" }` pauses it
+  instead.
+- **Funding:** left to Runtime, as `withruntime`'s own `create()` does. The
+  free trial is used while the account has trial time, then prepaid credit.
+  Pass `runtime: { create: { funding: "trial" } }` to use only the trial.
+- **Anything else Runtime offers:** `runtime: { create: { ... } }` sends
+  Runtime's create fields as they are, over the adapter's. `sandbox.runtime`
+  is the Runtime sandbox underneath, with previews, network rules, desktop,
+  processes and terminals.
+
+## Mapping
+
+| E2B                                                                                      | On Runtime                                                                                                                                                                     |
+| ---------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `Sandbox.create()`, `Sandbox.create(template, opts)`                                     | `sandboxes.create`. `base` and `code-interpreter-v1` are Runtime's stock image. Any other name must be a ready Runtime image with that name. A UUID is an image or a snapshot. |
+| `timeoutMs` (Python `timeout`, seconds)                                                  | `timeoutSeconds`, rounded up. Under 60 s becomes 60 s, with a warning. Over an hour is refused.                                                                                |
+| `metadata`                                                                               | labels (at most 32).                                                                                                                                                           |
+| `envs`                                                                                   | Given to every command and code run through this object.                                                                                                                       |
+| `allowInternetAccess: false`                                                             | `network: { internet: false }`.                                                                                                                                                |
+| `lifecycle.onTimeout`                                                                    | `onLeaseEnd`: `kill` is `stop`, `pause` is `pause`.                                                                                                                            |
+| `commands.run(cmd, { cwd, envs, timeoutMs, onStdout, onStderr })`                        | `exec`. Default timeout 60 s. `0` means no limit (Runtime's longest, 24 hours).                                                                                                |
+| Non-zero exit                                                                            | Throws `CommandExitError` with `exitCode`, `stdout`, `stderr` and `error` (`exit status N`). A command killed by a signal has `exitCode` -1.                                   |
+| Command past its timeout                                                                 | Throws `TimeoutError`.                                                                                                                                                         |
+| `commands.run(cmd, { background: true })`                                                | `spawn`. Returns a `CommandHandle` with `pid`, `wait()`, `kill()` (SIGKILL), `sendStdin`, `closeStdin`, `disconnect`, `stdout`, `stderr`, `exitCode`.                          |
+| `commands.list`, `kill(pid)`, `sendStdin(pid)`, `closeStdin(pid)`, `connect(pid)`        | Runtime's processes. A pid is a number derived from Runtime's process id, not the Linux pid.                                                                                   |
+| `files.read(path, { format })`                                                           | `files.read`. `text`, `bytes`, `blob` and `stream` (Python: `text`, `bytes`, `stream`).                                                                                        |
+| `files.write(path, data)`, `write([...])`, `writeFiles`                                  | `files.write`. Parent directories are made, and a file that exists is replaced.                                                                                                |
+| `files.list(path, { depth })`                                                            | `files.list`, hidden files included. `owner` and `group` are always `""`.                                                                                                      |
+| `files.makeDir`, `exists`, `getInfo`, `rename`, `remove`                                 | `files.stat`, `mkdir`, `rename` (replacing a file that exists) and `remove` (recursive). A missing file throws `FileNotFoundError`.                                            |
+| Relative paths                                                                           | Resolved against the home directory, `/workspace` on Runtime.                                                                                                                  |
+| `/home/user` (E2B's home)                                                                | The first time a path, `cwd` or command names it, it becomes a link to `/workspace`, unless something is already there.                                                        |
+| `sandbox.kill()`, `Sandbox.kill(id)`                                                     | `stop`, without waiting. `false` when the sandbox was not found or had already ended.                                                                                          |
+| `sandbox.setTimeout(ms)`, `Sandbox.setTimeout(id, ms)`                                   | `extend`: the end moves to now + ms. Moving it earlier is refused.                                                                                                             |
+| `Sandbox.connect(id, { timeoutMs })`, `sandbox.connect()`                                | `get`. A paused sandbox is woken. A running one's end moves later, never earlier. An ended one throws `SandboxNotFoundError`.                                                  |
+| `sandbox.pause()`, `betaPause`, `Sandbox.pause(id)`                                      | `pause`, keeping memory and files. `false` when it was already paused.                                                                                                         |
+| `getInfo`, `isRunning`                                                                   | `get`. `templateId` is `base` or the image or snapshot id. `envdVersion` is `runtime`.                                                                                         |
+| `Sandbox.list({ query: { metadata, state }, limit })`                                    | `sandboxes.list` by labels and state, oldest first, with E2B's paginator (`hasNext`, `nextItems()`).                                                                           |
+| `fork`, `createSnapshot`, `deleteSnapshot`                                               | Runtime's forks and snapshots. While Runtime has them switched off, they throw `NotSupportedError` with Runtime's own message.                                                 |
+| `getHost(port)`                                                                          | Refused, because E2B answers it without a call. `await sandbox.getPublicHost(port)` shares the port as a public Runtime preview and returns its host.                          |
+| `runCode(code, { language, context, onStdout, onStderr, onResult, onError, timeoutMs })` | Runtime's interpreter, Python and JavaScript. The sandbox's `envs` reach code through a context made once for them. `onResult` is called after the run ends.                   |
+| `Execution`, `Result`, `Logs`, `ExecutionError`, `OutputMessage`                         | The same shapes. Results that are too large to send inline are fetched and inlined. `logs.stdout` has one entry per line.                                                      |
+| `createCodeContext`, `listCodeContexts`, `restartCodeContext`, `removeCodeContext`       | Runtime's interpreter contexts.                                                                                                                                                |
+| Error classes                                                                            | E2B's names and parents. Each also carries Runtime's `code`, `hint` and `requestId`, with the original error as `cause`.                                                       |
+
+## Gaps
+
+Each of these throws `NotSupportedError` (Python: `NotSupportedException`)
+before anything happens. The error's `feature` names the gap and its
+`alternative` says what to use.
+
+| E2B                                                                                          | Use instead                                                                                                         |
+| -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| An E2B template name with no Runtime image of that name                                      | Build it: `npx withruntime image build --dockerfile e2b.Dockerfile --name <template>`. This throws `TemplateError`. |
+| `Template`, `waitForPort` and the other ready checks                                         | `runtime.images.build(...)`                                                                                         |
+| `timeoutMs` over one hour                                                                    | Create with up to an hour, then call `setTimeout` before it ends, as often as needed.                               |
+| `setTimeout` to an earlier time                                                              | `kill()` when the work is done.                                                                                     |
+| `lifecycle.autoResume`, `keepMemory: false`                                                  | `Sandbox.connect(id)` wakes a paused sandbox. Runtime's pause keeps memory.                                         |
+| `onResume: "reboot"`                                                                         | Stop the sandbox and create a new one.                                                                              |
+| `fork({ timeoutMs })`                                                                        | Fork without it, then call `setTimeout` on each fork.                                                               |
+| `user: "root"` (commands and files)                                                          | Prefix the command with `sudo`, which needs no password.                                                            |
+| `network`, `updateNetwork`                                                                   | `runtime: { create: { network } }` and `sandbox.runtime.network.set(...)`.                                          |
+| `mcp`, `getMcpUrl`, `getMcpToken`                                                            | Runtime's own MCP server, `npx withruntime mcp`.                                                                    |
+| `iam`, `Secret`                                                                              | Pass credentials as `envs`.                                                                                         |
+| `volumeMounts`, `Volume`                                                                     | Runtime volumes: `runtime: { create: { volumes: [{ volumeId, path }] } }`.                                          |
+| `pty`                                                                                        | `sandbox.runtime.terminal(...)`.                                                                                    |
+| `git`                                                                                        | `commands.run("git ...")`. E2B has deprecated its git module too.                                                   |
+| `files.watchDir`                                                                             | Poll with `files.list`.                                                                                             |
+| File `metadata`                                                                              | Keep it in a file beside the data.                                                                                  |
+| `getMetrics`                                                                                 | `npx withruntime usage`.                                                                                            |
+| `uploadUrl`, `downloadUrl`                                                                   | `files.write` and `files.read`.                                                                                     |
+| `Sandbox.list` by `template` or `startedAfter`, `order: "desc"`, or from a saved `nextToken` | Filter by metadata, and keep the paginator.                                                                         |
+| `runCode` in `bash`, `r`, `java` or `typescript`                                             | `commands.run(...)`.                                                                                                |
+| `runCode(code, { envs })`                                                                    | A context made with them: `sandbox.runtime.interpreter.contexts.create({ env })`.                                   |
+| `domain`, `apiUrl`, `sandboxUrl`, `headers`, `proxy`, `debug`                                | Remove them. `RUNTIME_API_URL` sets Runtime's origin, and `HTTPS_PROXY` sets a proxy.                               |
+
+Some differences are not refusals, so code that depends on them should check:
+
+- Sandbox-level `envs` live in the object that created the sandbox.
+  `Sandbox.connect(id)` from another process does not know them.
+- Runtime's stock image is Ubuntu 24.04 with Python 3.12, Node.js 24 and Bun.
+  E2B's code interpreter template preinstalls data libraries such as pandas and
+  matplotlib, and Runtime's image does not. Install them with `pip install`, or
+  build them into an image. Results never carry `chart`. A DataFrame arrives in
+  `extra` under `application/vnd.runtime.table+json`, not in E2B's `data`.
+- `requestTimeoutMs`, `retries`, `logger`, `secure` and `validateApiKey` are
+  accepted and ignored. Runtime's SDK sets its own request deadlines and
+  retries.
+
+## Tests
+
+`bun run test` in `packages/cloud-sdk` runs the unit tests of both languages
+against fakes of Runtime's SDKs, including every call in the mapping and
+every refusal: `tests/e2b` here and `sdks/python/tests/test_e2b_*.py`.
+
+The end-to-end tests run an unmodified E2B program against the real API with
+its one import changed. They create six sandboxes on the key's account. Each
+has 2 vCPU and 512 MiB, lasts at most five minutes and is stopped when its
+case ends. They are not part of `bun run test`.
+
+```bash no-run
+RUNTIME_API_KEY=... bun packages/cloud-sdk/scripts/e2b-e2e.ts   # the judge panel's E2B eval, JavaScript
+RUNTIME_API_KEY=... python3 sdks/python/scripts/e2b_e2e.py        # the same cases in Python
+```
+
+Either one run with `--dry` sets up and shows the one-line change without
+creating anything.

package/README.md

@@ -1,7 +1,8 @@
 # Runtime Cloud SDK and CLI
 
-One client for every Runtime Cloud product, and the `runtime` CLI. No
-dependencies; Node.js 22 or later, or Bun.
+One client for every Runtime Cloud product, and the `runtime` CLI. Node.js 22
+or later, or Bun. Its one dependency, undici (Node's own HTTP client), is
+loaded only behind a proxy.
 
 ```bash no-run
 npm install withruntime
@@ -24,7 +25,7 @@ console.log(result.exitCode, result.stdout);
 `Sandbox.create()` needs no arguments and returns once the sandbox is running;
 `await using` stops it when the block ends (Node 24, Bun or TypeScript; on
 Node 22 call `await sbx.stop()`). With no arguments you get the free
-trial while it lasts (20 hours, up to three sandboxes at once), 2 vCPU, 4 GiB of
+trial while it lasts (20 hours, up to eight sandboxes running at once), 2 vCPU, 4 GiB of
 memory and a 4 GiB disk.
 
 The sandbox object does the rest:
@@ -37,13 +38,46 @@ The sandbox object does the rest:
 - `pause`, `wake`, `extend`, `fork` and `snapshot`;
 - `interpreter`, `network`, `previews` and `desktop` for the other products.
 
-The client has `sandboxes`, `images`, `volumes`, `snapshots`, `feedback` and
-`support`. Every write carries an idempotency key, made for you, so the SDK's
+The client has `sandboxes`, `images`, `volumes`, `snapshots`, `limits`,
+`feedback` and `support`. `runtime.limits.get()` (0.3.1 and later) says whether
+the key is read-only and what its agent may still spend today. Every write carries an idempotency key, made for you, so the SDK's
 own retries (timeouts, 429, 503) never do anything twice. Errors are typed and
 carry a `code`, a `hint` and a `requestId`.
 
+## Behind a proxy
+
+The SDK, the CLI and the MCP bridge read `HTTPS_PROXY`, `HTTP_PROXY` and
+`NO_PROXY` (upper or lower case; lower wins when both are set) on Node and Bun
+alike, with no `NODE_USE_ENV_PROXY` needed. Calls to the API and terminal
+WebSockets go through `HTTPS_PROXY` as a CONNECT tunnel, with any
+`user:password@` in its address sent to the proxy. `HTTP_PROXY` is used only
+for `http://` addresses, never for the HTTPS API. `NO_PROXY` lists hosts to
+reach directly, split by commas or spaces: a name covers its subdomains, a
+leading dot is allowed, `host:port` limits it to one port, and `*` means every
+host. A proxy address without a scheme is `http://`; `http://` and `https://`
+proxies work, and anything else fails at once with `invalid_proxy`. When a call
+cannot get through, the error names the proxy it tried (without the password),
+for example `No answer from Runtime at https://api.withruntime.com through the
+proxy http://proxy.internal:3128 (HTTPS_PROXY).` A `fetch` you pass to
+`new Runtime({ fetch })` is used as it is.
+
 Please tell us what could be better. Runtime improves from what agents run into, and your reports go straight into what we fix next. Whenever something gets in your way, report it with `runtime.feedback.submit()` (or `npx withruntime feedback "..."`) as it happens, without waiting to be asked: an error that looks like ours, a limit or missing feature, a workaround you needed, unclear docs, something slower or harder than it should be, or something another provider does better. Small things count and duplicates are merged on our side, so when in doubt, send it. Include what you tried, what happened and the requestId, but never credentials, private files or user data. Then let the user know in one line what you reported.
 
+## Code written for E2B
+
+`withruntime/e2b` runs code written for E2B's SDK on Runtime. Change the
+import and set `RUNTIME_API_KEY`:
+
+```ts no-run
+import { Sandbox } from "withruntime/e2b"; // was: from "e2b"
+```
+
+`withruntime/e2b/code-interpreter` replaces `@e2b/code-interpreter`.
+Sandboxes get E2B's defaults: 2 vCPU, 512 MiB and a 300-second timeout. What
+Runtime does not do the way E2B does throws `NotSupportedError` before
+anything happens, naming what to use instead. `E2B.md` in this package lists
+every mapping and gap. Importing `withruntime` alone does not load it.
+
 ## CLI
 
 ```bash no-run

package/dist/cli.js

@@ -7,6 +7,7 @@ import { resolveCredential } from "./credentials.js";
 import { authenticationCommand, me, named } from "./login.js";
 import { Runtime } from "./client.js";
 import { RuntimeError } from "./errors.js";
+import { envFetch } from "./proxy.js";
 import { VERSION } from "./transport.js";
 const HELP = `Runtime Cloud CLI ${VERSION}
 
@@ -43,6 +44,7 @@ Products
   Each has its own help: \`runtime sandbox help\`, \`runtime image help\`...
 
 Every command takes --json. Keys: RUNTIME_API_KEY, or the connection from \`runtime login\`.
+Behind a proxy: HTTPS_PROXY and NO_PROXY are read, on Node and Bun alike.
 `;
 const SANDBOX_HELP = `runtime sandbox <command>
 
@@ -67,7 +69,7 @@ const SANDBOX_HELP = `runtime sandbox <command>
   stop <id> | pause <id> | wake <id> | restart <id>
   extend <id> <seconds>                       More time before the lease ends
   snapshot <id> [--name n] [--retention days] Keep its whole machine; prints the snapshot id
-  fork <id> [--count 3] [--name n] [--keep-snapshot]
+  fork <id> [--count 3] [--name n] [--keep-snapshot] [--trial|--paid]
                                               Copies of it as it is now, running; prints their ids
   run-code <id> <file|-> [--lang python|javascript] [--context c] [--out-dir .]
                                               Run a notebook-style cell; charts saved as PNG
@@ -428,7 +430,7 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
     }
     if (command === "docs") {
         const topic = rest[0] ?? "index";
-        const response = await fetch(`https://withruntime.com/docs/${topic === "index" ? "start" : encodeURIComponent(topic)}.md`, { redirect: "error" });
+        const response = await envFetch(`https://withruntime.com/docs/${topic === "index" ? "start" : encodeURIComponent(topic)}.md`, { redirect: "error" });
         if (!response.ok)
             throw usage(`No docs page named ${topic}. Try start, cli, api, javascript, python, mcp.`);
         out.write(await response.text());
@@ -622,12 +624,17 @@ async function sandbox(argv, env, out) {
             return 0;
         }
         case "fork": {
-            const args = parse(rest, ["keep-snapshot"]);
+            const args = parse(rest, ["keep-snapshot", "trial", "paid"]);
             const sbx = await get(args.positional[0]);
             const forks = await sbx.fork({
                 count: integer(args, "count") ?? 1,
                 ...(flag(args, "name") ? { name: flag(args, "name") } : {}),
                 ...(has(args, "keep-snapshot") ? { keepSnapshot: true } : {}),
+                ...(has(args, "trial")
+                    ? { funding: "trial" }
+                    : has(args, "paid")
+                        ? { funding: "paid" }
+                        : {}),
             });
             print(forks.map((f) => f.id).join("\n"), forks.map((f) => f.info));
             return 0;

package/dist/e2b/client.d.ts

@@ -0,0 +1,58 @@
+import { Runtime } from "../client.js";
+/** The Runtime sandbox the adapter drives. */
+export type RuntimeSandbox = Awaited<ReturnType<Runtime["sandboxes"]["create"]>>;
+/** What `Sandbox.create` sends to Runtime. */
+export type RuntimeCreate = NonNullable<Parameters<Runtime["sandboxes"]["create"]>[0]>;
+/** E2B's connection options, as far as they mean anything on Runtime. */
+export interface ConnectionOpts {
+    /** A Runtime key. Default: RUNTIME_API_KEY, then E2B_API_KEY if it holds a
+     * Runtime key, then the key `npx withruntime login` saved. An E2B key
+     * (`e2b_...`) is never sent anywhere. */
+    apiKey?: string;
+    /** Per call, retries included. */
+    requestTimeoutMs?: number;
+    signal?: AbortSignal;
+    /** Accepted and ignored, as E2B ignores them. */
+    validateApiKey?: boolean;
+    /** Accepted and ignored: Runtime's SDK retries by itself. */
+    retries?: number;
+    /** Accepted and ignored: Runtime's SDK does not take a logger. */
+    logger?: unknown;
+    /** E2B endpoints. Refused: this package only talks to Runtime. */
+    domain?: string;
+    apiUrl?: string;
+    sandboxUrl?: string;
+    debug?: boolean;
+    headers?: Record<string, string>;
+    apiHeaders?: Record<string, string>;
+    proxy?: string;
+}
+/** Runtime-only options, for code that has been through the switch. */
+export interface RuntimeOpts {
+    /** A Runtime client to use instead of one made from the key. */
+    client?: Runtime;
+    /** Fields sent as they are with the create, over the adapter's own: for
+     * example `{ funding: "trial" }`, `{ memoryMiB: 4096 }` or `{ region }`. */
+    create?: Partial<RuntimeCreate>;
+}
+/** Refuses the E2B-only connection options: they point at E2B, and quietly
+ * dropping one would send the call somewhere its author did not mean. */
+export declare function refuseE2BConnection(opts?: ConnectionOpts): void;
+/** The Runtime client for these options: an explicit client, else one per key,
+ * made once and reused so its connections stay open. */
+export declare function clientFor(opts?: ConnectionOpts & {
+    runtime?: RuntimeOpts;
+}): Runtime;
+/** Explicit key, then RUNTIME_API_KEY, then E2B_API_KEY when it holds a
+ * Runtime key; undefined lets the Runtime SDK find the saved login. */
+export declare function pickKey(explicit?: string): string | undefined;
+/** Test hook: forget the cached clients. */
+export declare function resetClients(): void;
+/** Request options for a Runtime call from E2B's. */
+export declare function request(opts?: {
+    requestTimeoutMs?: number;
+    signal?: AbortSignal;
+}): {
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+};

package/dist/e2b/client.js

@@ -0,0 +1,66 @@
+import { Runtime } from "../client.js";
+import { AuthenticationError, NotSupportedError } from "./errors.js";
+const env = (name) => typeof process === "undefined" ? undefined : process.env[name];
+const isE2BKey = (key) => key.startsWith("e2b_");
+/** Refuses the E2B-only connection options: they point at E2B, and quietly
+ * dropping one would send the call somewhere its author did not mean. */
+export function refuseE2BConnection(opts = {}) {
+    for (const field of [
+        "domain",
+        "apiUrl",
+        "sandboxUrl",
+        "headers",
+        "apiHeaders",
+        "proxy",
+    ]) {
+        if (opts[field] !== undefined)
+            throw new NotSupportedError(`The E2B connection option "${field}"`, field === "proxy"
+                ? "Set HTTPS_PROXY in the environment instead; Runtime's SDK reads it."
+                : "Remove it: this package talks only to Runtime (RUNTIME_API_URL overrides the API origin).");
+    }
+    if (opts.debug)
+        throw new NotSupportedError("E2B's debug mode (a local envd)", "Remove debug: true; there is no local Runtime guest to connect to.");
+}
+const clients = new Map();
+/** The Runtime client for these options: an explicit client, else one per key,
+ * made once and reused so its connections stay open. */
+export function clientFor(opts = {}) {
+    refuseE2BConnection(opts);
+    if (opts.runtime?.client)
+        return opts.runtime.client;
+    const key = pickKey(opts.apiKey);
+    const cacheKey = key ?? "";
+    let client = clients.get(cacheKey);
+    if (!client) {
+        client = new Runtime(key ? { apiKey: key } : {});
+        clients.set(cacheKey, client);
+    }
+    return client;
+}
+/** Explicit key, then RUNTIME_API_KEY, then E2B_API_KEY when it holds a
+ * Runtime key; undefined lets the Runtime SDK find the saved login. */
+export function pickKey(explicit) {
+    const runtimeKey = env("RUNTIME_API_KEY");
+    if (explicit !== undefined && !isE2BKey(explicit))
+        return explicit;
+    if (runtimeKey)
+        return runtimeKey;
+    if (explicit !== undefined)
+        throw new AuthenticationError("The apiKey passed is an E2B API key (e2b_...), and it was not sent. Set RUNTIME_API_KEY to a Runtime key " +
+            "(https://withruntime.com/account/keys, or run `npx withruntime login`), or pass the Runtime key as apiKey.");
+    // An E2B key left in E2B_API_KEY is skipped, never sent: the Runtime SDK
+    // then uses the key `npx withruntime login` saved, or says none was found.
+    const e2bVariable = env("E2B_API_KEY");
+    return e2bVariable && !isE2BKey(e2bVariable) ? e2bVariable : undefined;
+}
+/** Test hook: forget the cached clients. */
+export function resetClients() {
+    clients.clear();
+}
+/** Request options for a Runtime call from E2B's. */
+export function request(opts = {}) {
+    return {
+        ...(opts.requestTimeoutMs ? { timeoutMs: opts.requestTimeoutMs } : {}),
+        ...(opts.signal ? { signal: opts.signal } : {}),
+    };
+}

package/dist/e2b/code-interpreter.d.ts

@@ -0,0 +1,144 @@
+/** `@e2b/code-interpreter`, on Runtime. Change the import:
+ *
+ *   import { Sandbox } from "withruntime/e2b/code-interpreter";
+ *
+ * runCode runs in Runtime's interpreter (sandbox.runtime.interpreter):
+ * stateful Python and JavaScript contexts, as in E2B. Other languages throw
+ * NotSupportedError. */
+import type { Runtime } from "../client.js";
+import type { ConnectionOpts } from "./client.js";
+import { Sandbox as BaseSandbox } from "./sandbox.js";
+export * from "./index.js";
+export type RunCodeLanguage = "python" | "javascript" | "typescript" | "r" | "java" | "bash" | (string & {});
+/** A line of output, as E2B's callbacks receive it. */
+export declare class OutputMessage {
+    readonly line: string;
+    /** Unix epoch in nanoseconds (from the client's clock). */
+    readonly timestamp: number;
+    readonly error: boolean;
+    constructor(line: string, 
+    /** Unix epoch in nanoseconds (from the client's clock). */
+    timestamp: number, error: boolean);
+    toString(): string;
+}
+export declare class ExecutionError {
+    name: string;
+    value: string;
+    traceback: string;
+    constructor(name: string, value: string, traceback: string);
+}
+export type MIMEType = string;
+export type RawData = {
+    [key: MIMEType]: unknown;
+};
+type ResultFields = {
+    text?: string;
+    html?: string;
+    markdown?: string;
+    svg?: string;
+    png?: string;
+    jpeg?: string;
+    pdf?: string;
+    latex?: string;
+    json?: string;
+    javascript?: string;
+};
+/** One rich result, as E2B's: text, html, png (base64) and the rest. `chart`
+ * and E2B's `data` (its own DataFrame format) are never set on Runtime; a
+ * DataFrame arrives in `extra` under application/vnd.runtime.table+json. */
+export declare class Result implements ResultFields {
+    readonly isMainResult: boolean;
+    readonly text?: string;
+    readonly html?: string;
+    readonly markdown?: string;
+    readonly svg?: string;
+    readonly png?: string;
+    readonly jpeg?: string;
+    readonly pdf?: string;
+    readonly latex?: string;
+    readonly json?: string;
+    readonly javascript?: string;
+    readonly data?: Record<string, unknown>;
+    readonly chart?: undefined;
+    readonly extra?: Record<string, unknown>;
+    readonly raw: RawData;
+    constructor(rawData: RawData, isMainResult: boolean);
+    formats(): string[];
+    toJSON(): {
+        extra?: Record<string, unknown> | undefined;
+        text: string | undefined;
+        html: string | undefined;
+        markdown: string | undefined;
+        svg: string | undefined;
+        png: string | undefined;
+        jpeg: string | undefined;
+        pdf: string | undefined;
+        latex: string | undefined;
+        json: string | undefined;
+        javascript: string | undefined;
+    };
+}
+export type Logs = {
+    stdout: string[];
+    stderr: string[];
+};
+export declare class Execution {
+    results: Result[];
+    logs: Logs;
+    error?: ExecutionError | undefined;
+    executionCount?: number | undefined;
+    constructor(results?: Result[], logs?: Logs, error?: ExecutionError | undefined, executionCount?: number | undefined);
+    /** The main result's text. */
+    get text(): string | undefined;
+    toJSON(): {
+        results: Result[];
+        logs: Logs;
+        error: ExecutionError | undefined;
+    };
+}
+export type Context = {
+    id: string;
+    language: string;
+    cwd: string;
+};
+export interface RunCodeOpts {
+    onStdout?: (output: OutputMessage) => unknown;
+    onStderr?: (output: OutputMessage) => unknown;
+    onResult?: (data: Result) => unknown;
+    onError?: (error: ExecutionError) => unknown;
+    /** Refused when set: Runtime's contexts take their environment when made. */
+    envs?: Record<string, string>;
+    /** Default 60 000, as in E2B. */
+    timeoutMs?: number;
+    /** Accepted and ignored: Runtime's SDK allows the run its timeout plus a minute. */
+    requestTimeoutMs?: number;
+}
+export interface CreateCodeContextOpts {
+    cwd?: string;
+    language?: RunCodeLanguage;
+    requestTimeoutMs?: number;
+}
+/** The code interpreter sandbox: everything the base Sandbox has, plus runCode
+ * and code contexts. */
+export declare class Sandbox extends BaseSandbox {
+    #private;
+    protected static readonly defaultTemplate: string;
+    /** Runs code in a stateful context. Errors in the code come back in
+     * `execution.error`, as in E2B; a run past `timeoutMs` throws TimeoutError. */
+    runCode(code: string, opts?: RunCodeOpts & {
+        language?: RunCodeLanguage;
+        context?: Context;
+    }): Promise<Execution>;
+    createCodeContext(opts?: CreateCodeContextOpts): Promise<Context>;
+    removeCodeContext(context: Context | string): Promise<void>;
+    listCodeContexts(): Promise<Context[]>;
+    restartCodeContext(context: Context | string): Promise<void>;
+}
+export default Sandbox;
+/** E2B's client with bound options, for the code interpreter. */
+export declare class E2B {
+    readonly Sandbox: typeof Sandbox;
+    constructor(opts?: Omit<ConnectionOpts, "signal"> & {
+        client?: Runtime;
+    });
+}