withruntime 0.11.0 → 0.11.2

package/BLAXEL.md

@@ -34,7 +34,7 @@ name, or through `getByExternalId`, use the same Runtime key.
 - **Machine:** Blaxel's default of 4096 MB. vCPUs follow Blaxel's rule of one
   per 2048 MB (at least one, at most 16): 2 for the default, 4 for 8192 MB. A
   trial sandbox has at most 4096 MB (2 vCPUs); `memory: 8192` or more needs
-  prepaid credit, and on the trial is refused with a 400 (`invalid_trial`)
+  prepaid credit, and on the trial is refused with a 400 (`no_credit_size_limit`)
   saying so.
 - **Image:** Blaxel's `base-image`, `py-app`, `ts-app`, `node`,
   `docker-in-sandbox` and `jupyter-server` are Runtime's stock image (Ubuntu
@@ -48,15 +48,14 @@ name, or through `getByExternalId`, use the same Runtime key.
   resumes on the next call. On Runtime it pauses after 60 seconds without a
   call (Runtime's shortest idle pause; Blaxel's is about 15 seconds), keeping
   its memory, files and processes, and wakes by itself on the next command,
-  file call or preview visit. Its lease is Runtime's longest, an hour, and the
-  adapter renews it in the background while the sandbox is in use; when a lease
-  does run out the sandbox pauses rather than ends.
+  file call or preview visit. It has no time limit, so a sandbox in use is
+  never paused on a clock.
 - **How long it is kept:** Blaxel keeps a sandbox until it is deleted or its
   TTL ends. A paused Runtime sandbox is kept 365 days when no TTL, expiry or
   lifecycle is given. With one, it is never deleted before Blaxel would delete
   it, and may be kept longer:
-  - a `ttl`, `expires`, `ttl-max-age` or `date` within the hour is a lease that
-    ends the sandbox at that time, or later if the sandbox paused and woke;
+  - a `ttl`, `expires`, `ttl-max-age` or `date` within the hour is a time limit
+    that ends the sandbox at that time, or later if the sandbox paused and woke;
   - any other deadline, and any `ttl-idle`, keeps a paused sandbox that many
     days, rounded up, counted from each pause; with several, the shortest wins;
   - at most 365 days.
@@ -161,9 +160,9 @@ Some differences are not refusals:
   The old idle pause comes back once no `keepAlive` process runs, when a client
   sees one end (a waited exec, `wait` or `get`), stops or kills one, or calls
   `SandboxInstance.get`. With no such call, the sandbox pauses when it has been
-  idle for that `timeout`. A `keepAlive` process past Runtime's hour-long lease
-  is paused with the sandbox when the lease ends with no call to renew it, and
-  carries on at the next call.
+  idle for that `timeout`. On a sandbox with a time limit, a `keepAlive`
+  process past it is paused with the sandbox when the limit ends with no call
+  to renew it, and carries on at the next call.
 - **A name is not refused while its process runs:** a second process may take a
   running process's name, and `get(name)` answers the newest.
 - **`process.list()` leaves each process's output empty** (Blaxel includes a

package/DAYTONA.md

@@ -17,7 +17,7 @@ from withruntime.daytona import AsyncDaytona  # was: from daytona import AsyncDa
 ```
 
 The mapping was written against `@daytona/sdk` 0.220.0 and `daytona` 0.220.0
-on PyPI, checked 29 September 2026. The exact releases and artifact hashes
+on PyPI, and checked against `@daytona/sdk` 0.222.0 on 5 October 2026. The exact releases and artifact hashes
 are kept in `compatibility-lock.json`.
 
 ## Keys
@@ -38,14 +38,13 @@ package talks only to Runtime.
   kept for Runtime's retention: 30 days on credit, 7 on the trial, or
   `autoDeleteInterval` minutes rounded up to whole days. `delete()` ends it.
   An `ephemeral` sandbox (or `autoDeleteInterval: 0`) ends on `stop()`.
-- **Auto-stop:** Runtime runs a sandbox on a lease of up to an hour. The lease
-  is `autoStopInterval` minutes (default 15), and every call through the
-  adapter moves it on once less than half is left, so a sandbox pauses after
-  that long without calls, as Daytona's does. Past an hour, or `0` (never),
-  the sandbox object also renews the lease each minute while it lives, toward
-  `autoStopInterval` after the last call; once the program ends, the sandbox
-  pauses within an hour. `ttlMinutes` caps the renewals and ends the sandbox at
-  the deadline.
+- **Auto-stop:** `autoStopInterval` minutes (default 15; `0` never) is the
+  sandbox's idle pause: it pauses after that long with nothing happening in
+  it, counted by the sandbox itself, so a long command is never paused for
+  want of calls. It has no time limit. `ttlMinutes` gives it one, and with
+  it Daytona's own rule: the sandbox pauses after `autoStopInterval` minutes
+  without a call through the adapter, each call moving the limit on, and ends
+  at the deadline.
 - **Funding:** left to Runtime, as `withruntime`'s own `create()` does: the free
   trial while the account has trial time, then prepaid credit. Pass
   `withruntime: { create: { funding: "trial" } }` to `new Daytona(...)` or to

package/E2B.md

@@ -20,9 +20,9 @@ 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 checked against `e2b` 2.52.0
-and `@e2b/code-interpreter` 2.8.0 (Python: `e2b` 2.52.0, `e2b-code-interpreter`
-2.10.1) on 2 October 2026. The exact package releases and artifact hashes are kept in
+The mapping was written against `e2b` 2.51.0 and checked against `e2b` 2.52.1
+and `@e2b/code-interpreter` 2.8.0 (Python: `e2b` 2.52.1, `e2b-code-interpreter`
+2.10.1) on 5 October 2026. The exact package releases and artifact hashes are kept in
 `compatibility-lock.json`.
 
 ## Keys
@@ -30,17 +30,55 @@ and `@e2b/code-interpreter` 2.8.0 (Python: `e2b` 2.52.0, `e2b-code-interpreter`
 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`.
+`apiKey`, or left in `E2B_API_KEY`, and `RUNTIME_API_KEY` is not set, the call
+fails with `AuthenticationError` (Python: `AuthenticationException`) saying
+so, rather than fall back to a saved login that may be another account's.
+When `RUNTIME_API_KEY` and `E2B_API_KEY` hold two different Runtime keys, which
+may be two accounts, a warning says so once (`RUNTIME_E2B_TWO_KEYS`; Python: a
+`RuntimeWarning`). A template with no image of its name fails naming the
+account the key belongs to and where the key came from.
 
 ## 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.
+- **Timeout:** kept by Runtime's server, never by a timer in your process,
+  so it holds after the process that made the sandbox exits. A `timeoutMs`
+  you give (Python `timeout`, seconds), up to 24 hours, deletes the sandbox
+  when it runs out, as E2B kills it; so does `lifecycle: { onTimeout: "kill" }`.
+  With no timeout, E2B's default of 300 seconds applies, and when it runs out
+  the sandbox **pauses** instead: nobody asked for it to end, so nothing is
+  lost, and the next call wakes it. E2B deletes it at that point.
+  `lifecycle: { onTimeout: "pause" }` pauses at any timeout.
+- **What a pause keeps, and costs:** memory, files and running processes, for
+  as long as the account has credit, billed as paused storage by the GB a
+  month for what the sandbox alone holds (`pricing.md`, "Paused storage").
+  Sandboxes created with no timeout and never killed pile up as paused
+  storage: call `kill()` when the work is done, or give a `timeoutMs`.
+- **On a pilot account:** the server keeps every sandbox running until you
+  end it, with no idle pause, whatever `timeoutMs` says, and machine size is
+  the pilot's. `kill()` deletes it.
+- **Kill:** `kill()` deletes the sandbox for good, as E2B's does: its disk,
+  memory and shared ports go, and it no longer counts against the account's
+  sandboxes.
+- **Idle pause:** Runtime's default, which E2B does not have. After 60
+  seconds with nothing happening in it (no request, running command, open
+  connection, traffic or CPU use) the sandbox pauses with its memory kept, and
+  the next command or file call wakes it. To code written for E2B it is still
+  running: `isRunning()` is `true`, `getInfo()` says `running` and
+  `list({ query: { state: ["running"] } })` includes it. Pass
+  `runtime: { create: { idlePauseSeconds: 0 } }` (Python:
+  `runtime_create={"idle_pause_seconds": 0}`) to keep it running, as on E2B.
+- **Connections:** one client per key, holding up to 4,096 connections to
+  the API at once, the most Runtime's edge gives an address that has used a
+  valid key. E2B's SDK holds no call back, and neither does this one: a
+  thousand commands at once from one process all run at once. Past an
+  account's room the API answers with a retry, which the client waits out. If
+  calls ever wait for a connection, a warning says so once
+  (`RUNTIME_E2B_QUEUED`). Runtime's own SDK keeps 48; pass your own client
+  with `runtime: { client: new Runtime({ maxConnections }) }` (Python:
+  `client=Runtime(max_connections=...)`).
 - **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.
@@ -53,30 +91,30 @@ machine. An E2B key (`e2b_...`) is never sent anywhere. If one is passed as
 
 | 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. Up to 24 hours, as on E2B: a Runtime lease reaches at most an hour ahead, so while this process runs the adapter extends it every five minutes, never past the end asked for. If the process ends first, the sandbox ends with its last lease, at most an hour later. Over 24 hours throws `InvalidArgumentError`.                                                                                                                                                                                                               |
+| `Sandbox.create()`, `Sandbox.create(template, opts)`                                     | `sandboxes.create`. `base` and `code-interpreter-v1` are Runtime's stock image. Any other name, with its `:tag`, is a Runtime image of that name, resolved by the create itself; E2B's `team/` prefix is dropped, since an account's images are its own. A UUID is an image or a snapshot. A name no image has throws `TemplateError` saying how to build it.                                                                                                                                                                                                                                           |
+| `timeoutMs` (Python `timeout`, seconds)                                                  | `timeoutSeconds`, rounded up, kept by the server, with `onTimeout: "delete"`. Left out, 300 s with `onTimeout: "pause"`. Under 60 s becomes 60 s, with a warning. Up to 24 hours, as on E2B; over throws `InvalidArgumentError`.                                                                                                                                                                                                                                                                                                                                                                        |
 | `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`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `lifecycle.onTimeout`                                                                    | `onTimeout`: `kill` is `delete`, `pause` is `pause`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `commands.run(cmd, { cwd, envs, timeoutMs, onStdout, onStderr })`                        | A native process started by a streamed exec that reads it from the first byte, so Runtime holds a fast writer back rather than drop output: the result is whole, however long. The default command connection deadline is 60 s; `0` disables it. The process lives up to 24 hours, within the sandbox lease.                                                                                                                                                                                                                                                                                            |
 | 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                                                                 | Disconnects with `TimeoutError` (Python: `TimeoutException`) without killing the command; reconnect by pid to keep reading.                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| Command past its timeout                                                                 | Disconnects with `TimeoutError` (Python: `TimeoutException`) without killing the command; reconnect by pid to keep reading. A command whose sandbox is killed under it ends with `TimeoutError` too, saying the sandbox was killed or reached its end of life.                                                                                                                                                                                                                                                                                                                                          |
 | `commands.run(cmd, { background: true })`                                                | `spawn`. Returns a `CommandHandle` with `pid`, `wait()`, `kill()` (SIGKILL), `sendStdin`, `closeStdin`, `disconnect`, `stdout`, `stderr`, `exitCode`. Runtime keeps the last 1 MiB a process printed; anything older that was not read in time is lost, which sets `truncated` and warns. A command with `stdin: true` starts the same way.                                                                                                                                                                                                                                                             |
 | `user` (commands, PTY and files)                                                         | Runs as that Linux user through `sudo -u`; `root` needs nothing more. A user the sandbox lacks throws `InvalidArgumentError` saying how to add one; none is ever created. `user: "user"` is the sandbox's own user. Watching a directory as another user is refused.                                                                                                                                                                                                                                                                                                                                    |
-| `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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `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. `commands.list` shows each command as E2B starts it: `cmd` `/bin/bash`, `args` `["-l", "-c", "<your command>"]` (a PTY: `["-i", "-l"]`), the command cut at 256 characters, `envs` empty.                                                                                                                                                                                                                                                                                                                  |
 | `pty.create`, `connect`, `sendInput`, `resize`, `kill` (Python snake_case)               | Native PTY processes with lossless byte callbacks. A reader timeout or disconnect detaches without killing the process; reconnect resumes reading.                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
 | `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` come from native metadata, with `""` for older guests that omit them.                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| `files.list(path, { depth })`                                                            | `files.list`, hidden files included. `owner` and `group` come from native metadata, with `""` for older guests that omit them. `depth` below one throws `InvalidArgumentError` "depth should be at least one".                                                                                                                                                                                                                                                                                                                                                                                          |
+| `files.makeDir`, `exists`, `getInfo`, `rename`, `remove`                                 | `files.stat`, `mkdir`, `rename` (replacing a file that exists) and `remove` (recursive). A missing file throws `FileNotFoundError`. Entries read as envd gives them: `permissions` begins with the kind's letter (`-rw-r--r--`, `drwxr-xr-x`, `L` for a link), the sandbox user is `user`, and a link's `symlinkTarget` is absolute.                                                                                                                                                                                                                                                                    |
+| Relative paths                                                                           | Resolved against the home directory, `/workspace` on Runtime, and given back under `/home/user`, as E2B gives them: `write("a.txt")` returns `/home/user/a.txt`. A path given in full comes back as given. `pwd` in a command prints `/workspace`.                                                                                                                                                                                                                                                                                                                                                      |
 | `/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, up to 24 hours (past an hour it is carried on as for `timeoutMs`). An earlier end is refused: Runtime cannot end a lease early.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `sandbox.kill()`, `Sandbox.kill(id)`                                                     | `delete`: gone for good. `false` when the sandbox was not found or was already deleted.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `sandbox.setTimeout(ms)`, `Sandbox.setTimeout(id, ms)`                                   | `extend`: the end moves to now + ms, up to 24 hours. An earlier end is refused: Runtime cannot bring a time limit forward. A sandbox with no time limit (a pilot's) has no end to move, and nothing changes.                                                                                                                                                                                                                                                                                                                                                                                            |
 | `Sandbox.connect(id, { timeoutMs })`, `sandbox.connect()`                                | `get`. A paused sandbox is woken. A running one's end moves later, never earlier, up to 24 hours. 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`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `getInfo`, `isRunning`                                                                   | `get`. `templateId` is the template the sandbox was created from, as you named it (kept in the label `e2b-template`, which `metadata` leaves out), or `base`. `envdVersion` is `runtime`. A sandbox Runtime paused for being idle is `running`. `endAt` is when it ends by itself; one that never will (no time limit, as a pilot's) reads 24 hours ahead, the furthest E2B allows.                                                                                                                                                                                                                     |
 | `Sandbox.list({ query: { metadata, state }, limit })`                                    | `sandboxes.list` by labels and state, oldest first, with E2B's paginator (`hasNext`, `nextItems()`, `nextToken`). A `template` or `startedAfter` filter, `order: "desc"` and a saved `nextToken` are applied by the adapter, which reads every match once and pages through them.                                                                                                                                                                                                                                                                                                                       |
 | `fork`, `createSnapshot`, `deleteSnapshot`                                               | Runtime's memory-preserving forks and snapshots; deleting a snapshot removes that saved capture. A fork's `count` is 1 to 20, as E2B checks it.                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `getHost(port)`                                                                          | `<port>-<id>.runtimehost.com` at once, as E2B answers it, and the port is shared as a public Runtime preview beside the caller (the sync Python sandbox shares it before returning). `await sandbox.getPublicHost(port)` returns once the share has landed. On the free trial a shared port is private and a host alone cannot reach it, so both throw `PublicPreviewNotAllowedError` (Python: `PublicPreviewNotAllowedException`, a kind of `NotSupportedError`) at once. Use `(await sandbox.runtime.previews.create(port)).urlWithToken`, or send its token as the `x-runtime-preview-token` header. |
@@ -84,7 +122,7 @@ machine. An E2B key (`e2b_...`) is never sent anywhere. If one is passed as
 | `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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
 | `getMetrics({ start, end })`, `Sandbox.getMetrics(id)`                                   | Runtime's measured CPU and memory, one entry per host reading. `diskUsed` is null: Runtime does not read disk use inside the sandbox.                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| Error classes                                                                            | E2B's names and parents. Each also carries Runtime's `code`, `hint` and `requestId`, with the original error as `cause`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| Error classes and other exports                                                          | Every name `e2b` and the code interpreter export imports, errors with E2B's names and parents. Python also imports each from the module E2B defines it in, so `from e2b.exceptions import TimeoutException` becomes `from withruntime.e2b.exceptions import TimeoutException`, and `WriteEntry` comes from `withruntime.e2b.sandbox.filesystem.filesystem`. Each error also carries Runtime's `code`, `hint` and `requestId`, with the original error as `cause`.                                                                                                                                       |
 
 ## Gaps
 
@@ -117,6 +155,10 @@ returns a handle with `get_new_events()` and `stop()`; asynchronous
 a callback. Stream failures and lost events are reported, never treated as a
 successful empty watch. A positive watch timeout bounds the client subscription and stops its owned watch;
 zero leaves the subscription unlimited. The sandbox lease still applies. Both languages refuse watching network mounts.
+As on envd, a path that is a file is refused with `InvalidArgumentError`
+(Python: `InvalidArgumentException`). Runtime writes a file whole, by a rename
+into place, which its watch sees as a create; a file's create is therefore
+followed by a write event, which E2B code waiting for the write receives.
 
 PTY `timeoutMs` (Python `timeout`, seconds) defaults to sixty seconds, including
 the opening handshake; zero leaves the reader unlimited. Callbacks receive raw
@@ -147,7 +189,7 @@ 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
+has 2 vCPU and 512 MiB, lasts at most five minutes and is deleted when its
 case ends. They are not part of `bun run test`.
 
 ```bash no-run

package/README.md

@@ -27,12 +27,13 @@ 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 (100 free hours, up to eight sandboxes running at once), 2 vCPU, 4 GiB of
+Node 22 call `await sbx.stop()`). With no arguments you get the
+included usage, a 1 GB machine running all month every month with no card (up to
+eight sandboxes running at once without credit), 2 vCPU, 4 GiB of
 memory and a 4 GiB disk. The current default image includes NumPy, pandas and
 matplotlib; see the [sandbox environment](https://withruntime.com/docs/sandbox-environment).
-Omitting `funding` can use prepaid credit after the trial is exhausted. Use
-`Sandbox.create({ funding: "trial" })` for free use only; it never falls back to paid.
+The included usage is spent first, then prepaid credit, with nothing to
+choose; `funding` is accepted and ignored.
 
 The sandbox object does the rest:
 
@@ -45,7 +46,7 @@ The sandbox object does the rest:
   directories with `upload` and `download`;
 - `pause`, `wake`, `extend`, `fork` and `snapshot` (a paused sandbox also wakes
   by itself on the next call), `update` for its name, environment, automatic
-  wake, idle pause and persistence, `keepAlive` to extend its lease while your
+  wake, idle pause and persistence, `keepAlive` to move a time limit on while your
   process runs, `switchImage` to move it to a new image keeping /workspace,
   and `delete` to remove it for good;
 - `interpreter`, `network`, `previews`, `desktop`, `mounts` (your S3, R2 or

package/README.src.md

@@ -29,12 +29,13 @@ 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 ({{trial-hours}} free hours, up to {{trial-sandboxes}} sandboxes running at once), 2 vCPU, 4 GiB of
+Node 22 call `await sbx.stop()`). With no arguments you get the
+included usage, {{included-machine}} every month with no card (up to
+{{trial-sandboxes}} sandboxes running at once without credit), 2 vCPU, 4 GiB of
 memory and a 4 GiB disk. The current default image includes NumPy, pandas and
 matplotlib; see the [sandbox environment](https://withruntime.com/docs/sandbox-environment).
-Omitting `funding` can use prepaid credit after the trial is exhausted. Use
-`Sandbox.create({ funding: "trial" })` for free use only; it never falls back to paid.
+The included usage is spent first, then prepaid credit, with nothing to
+choose; `funding` is accepted and ignored.
 
 The sandbox object does the rest:
 
@@ -47,7 +48,7 @@ The sandbox object does the rest:
   directories with `upload` and `download`;
 - `pause`, `wake`, `extend`, `fork` and `snapshot` (a paused sandbox also wakes
   by itself on the next call), `update` for its name, environment, automatic
-  wake, idle pause and persistence, `keepAlive` to extend its lease while your
+  wake, idle pause and persistence, `keepAlive` to move a time limit on while your
   process runs, `switchImage` to move it to a new image keeping /workspace,
   and `delete` to remove it for good;
 - `interpreter`, `network`, `previews`, `desktop`, `mounts` (your S3, R2 or

package/VERCEL.md

@@ -33,8 +33,9 @@ are ignored.
 
 - **Machine:** Vercel's default, 2 vCPUs with 2048 MiB each.
   `resources: { vcpus }` sets another, with 2048 MiB per vCPU.
-- **Timeout:** Vercel's default of 5 minutes. Runtime's leases run 60 seconds to
-  an hour. A longer `timeout` (Python `execution_time_limit`) starts with an
+- **Timeout:** none unless you pass one: the sandbox runs while it works and
+  pauses itself when idle. A `timeout` is kept as a Runtime time limit, which
+  runs 60 seconds to an hour. A longer `timeout` (Python `execution_time_limit`) starts with an
   hour's lease, and the sandbox object renews it toward the timeout while it
   lives, never past it; once the program ends, the sandbox pauses within an
   hour. `extendTimeout` moves the end later, as often as needed.

package/compatibility-lock.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "checkedAt": "2026-09-29",
+  "checkedAt": "2026-10-05",
   "providers": [
     {
       "id": "e2b",
@@ -9,9 +9,9 @@
         {
           "registry": "npm",
           "name": "e2b",
-          "version": "2.52.0",
+          "version": "2.52.1",
           "artifacts": {
-            "2.52.0": "sha512-TmUZlAvQq8BbguodpA+BBdawR/x5uILMQtHcLkdaLUqevsDjDdh46IYYU8ZRYKsQ4OhWr4xhsFIPSg1kgf+O0w=="
+            "2.52.1": "sha512-qbX0s6qV2gfN4/+NBTIli1hkztfH/1kL4AEAYTaP4wjx7dp2m2wnXcN35iz+8Gug0q4TPN9w4xbdw/TGJr/Bpw=="
           }
         },
         {
@@ -25,10 +25,10 @@
         {
           "registry": "pypi",
           "name": "e2b",
-          "version": "2.52.0",
+          "version": "2.52.1",
           "artifacts": {
-            "e2b-2.52.0-py3-none-any.whl": "sha256-6f4b5084b09986db43e99c7405bae6b14dc56984a69bbb1dc0687f1c71515cfb",
-            "e2b-2.52.0.tar.gz": "sha256-58c0042609513799341d4c1837e2581a4a5e73d3d62c9f1c57495c5e23eedee2"
+            "e2b-2.52.1-py3-none-any.whl": "sha256-708583a37c9b797b0044bd92fa407c21aec65f101f2fd4c4a0ccd842dbe33de1",
+            "e2b-2.52.1.tar.gz": "sha256-3af5c037b971ebc89a1ef0e5ced0e1c9ecbf3d65f2c23df5db7ad9faef8f68fa"
           }
         },
         {
@@ -49,9 +49,9 @@
         {
           "registry": "npm",
           "name": "@daytona/sdk",
-          "version": "0.220.0",
+          "version": "0.222.0",
           "artifacts": {
-            "0.220.0": "sha512-PJio3vbDwRApzlsK6AGO7r4CHJcF9PI5DWuUW2yUnA2MVJSh/jotS0onKBv6boC5F+oboljTibUMxrwVPIrOlQ=="
+            "0.222.0": "sha512-N0hjbprttUcAQE3eBegzRNIhQTzbPOGAuS2LJvl4a6bLp3rjCY1R7G9HbE9STepiBQDAs5B08Vv1rpRTXw9PaA=="
           }
         },
         {
@@ -66,25 +66,25 @@
         {
           "registry": "npm",
           "name": "@daytona/api-client",
-          "version": "0.220.0",
+          "version": "0.222.0",
           "artifacts": {
-            "0.220.0": "sha512-XaMEtiQCaIHc3T7y3HUqx1A5eWSnd+FJvhpSHDwP3Snu9Nnhy4t+K2LHBWgJQn9dGtWXsdOsbB9K0BqpmFJtyA=="
+            "0.222.0": "sha512-KvD+k6LMaqauQBedbMPTZG3UK3oITwmI5onfqbQJOdEG3xD6Occ3dJRphPlXqfF7tdtmDiXv3yrbyyOusqjvdA=="
           }
         },
         {
           "registry": "npm",
           "name": "@daytona/toolbox-api-client",
-          "version": "0.220.0",
+          "version": "0.222.0",
           "artifacts": {
-            "0.220.0": "sha512-Kn94AOxhGQil0XygOOR26SaCkndE4dOtxYS0hLbqrTxcP3H1uq1HGFGSRkHFQNkaR8eL9QwFUPSMqd0Vr3A64A=="
+            "0.222.0": "sha512-crdx4Zoxjtd7sGoURS3Dwd0xEQ+6lW6e+tu45TgUx85BpDAoTEr0z7i13HgXcEfAYMIcj8o70FOlI5JlkEJ5dw=="
           }
         },
         {
           "registry": "npm",
           "name": "@daytona/analytics-api-client",
-          "version": "0.220.0",
+          "version": "0.222.0",
           "artifacts": {
-            "0.220.0": "sha512-3BGYILzjo2aFTJhLd6XBXlNEQBSo9Zr2Nj31OdX9o50fMRVUwVydF6ekIGkPGSLwskz6b6xxg5BSS+f9dbrxCQ=="
+            "0.222.0": "sha512-KNIk2b21pLzKMdKPnz+7cOXE9Qjvlfe9hwfiIdAatxa9jYbwJQTmbxs7BpdDB7I9GtdUionpdskxJWL+rVcWvA=="
           }
         }
       ]
@@ -229,6 +229,34 @@
           "artifacts": {
             "prime_sandboxes-0.4.1-py3-none-any.whl": "sha256-1a1bb96afacc66d690815be82c0b7af180ea141421b7d180b4a0adbada4f38f0",
             "prime_sandboxes-0.4.1.tar.gz": "sha256-53f7577dc9070e3b8e30db360f9e3cce3bcc35f8765b26f24f64dbc3c7763b06"
+          },
+          "latestReview": {
+            "version": "0.4.2",
+            "artifacts": {
+              "prime_sandboxes-0.4.2-py3-none-any.whl": "sha256-ed59f001c7575339d6c903166c5468f783eda0997586ec6476fd8b35f65746f9",
+              "prime_sandboxes-0.4.2.tar.gz": "sha256-4990a724cac0a662fde6e12e7eccfee092a78679cc568653b8ef52008dfa28e4"
+            },
+            "reviewedAt": "2026-10-02",
+            "disposition": "held-for-sdk-qualification",
+            "evidence": {
+              "sourceUrls": [
+                "https://pypi.org/pypi/prime-sandboxes/0.4.2/json",
+                "https://files.pythonhosted.org/packages/3f/4d/a379cdf82d6f06c970bd4f0333c2360c08aba65c809d7492f49aece84c66/prime_sandboxes-0.4.2.tar.gz",
+                "https://files.pythonhosted.org/packages/da/b5/6a9fe6ae1342872c1c0cc45072cc0c58a5fa2783c4c45770e585f2535c8f/prime_sandboxes-0.4.2-py3-none-any.whl",
+                "https://github.com/PrimeIntellect-ai/prime/tree/main/packages/prime-sandboxes"
+              ],
+              "artifactSha256": {
+                "prime_sandboxes-0.4.2-py3-none-any.whl": "ed59f001c7575339d6c903166c5468f783eda0997586ec6476fd8b35f65746f9",
+                "prime_sandboxes-0.4.2.tar.gz": "4990a724cac0a662fde6e12e7eccfee092a78679cc568653b8ef52008dfa28e4"
+              },
+              "changes": [
+                "Source diff of the 0.4.1 and 0.4.2 sdists, downloaded and hashed on the Mac, nothing installed or run: README, __init__, models.py, sandbox.py, one test changed; tests/test_checkpoints.py added.",
+                "Adds filesystem checkpoints: SandboxCheckpoint, CheckpointLookupError and BatchCheckpointResponse models; checkpoint, get_checkpoint, get_checkpoints (batch of up to 100 ids), wait_for_checkpoint and list_checkpoints on the sync and async clients; CreateSandboxRequest takes checkpoint_id with a validate_restore_source check.",
+                "CreateSandboxRequest.docker_image becomes Optional (None when restoring from a checkpoint) and disk_size_gb's default 5.0 becomes None.",
+                "Background job launch: the working_dir prefix is 'cd DIR || exit 1;' instead of 'cd DIR &&', and the launch cwd is / for an absolute working_dir.",
+                "No existing method was removed or renamed. Installed consumer qualification against withruntime/prime is not run; the supported pin stays 0.4.1."
+              ]
+            }
           }
         }
       ]
@@ -252,6 +280,33 @@
           "artifacts": {
             "modal-1.6.0-py3-none-any.whl": "sha256-2f5981ba656570ad96379d29f0ddff876880708c84966024ce130e9e1794fa68",
             "modal-1.6.0.tar.gz": "sha256-c5dd551b5e0a283f3c764476c0a4ebe5bdef1e4a69432fa27e1b1ad8ca5e0817"
+          },
+          "latestReview": {
+            "version": "1.6.1",
+            "artifacts": {
+              "modal-1.6.1-py3-none-any.whl": "sha256-f408ef88563003a83e491a6be09d4221eaa6e038fa4faa2ad8b15b25afe949a4",
+              "modal-1.6.1.tar.gz": "sha256-ff17768f67a65595aa7882e893e6cb78e2e001b3653aa52cfe98d4051d8d9e9e"
+            },
+            "reviewedAt": "2026-10-03",
+            "disposition": "held-for-sdk-qualification",
+            "evidence": {
+              "sourceUrls": [
+                "https://pypi.org/pypi/modal/1.6.1/json",
+                "https://files.pythonhosted.org/packages/65/ba/2b36899ea5633bf101e6ba6f7e95a4da3e4b1f57f52bd0ba8f4cfd12e808/modal-1.6.1.tar.gz",
+                "https://files.pythonhosted.org/packages/d2/3c/6b7d9a15dab9af2833ce674bbc72b5654d4099d5b088f1cc1eda3f8249ca/modal-1.6.1-py3-none-any.whl"
+              ],
+              "artifactSha256": {
+                "modal-1.6.1-py3-none-any.whl": "f408ef88563003a83e491a6be09d4221eaa6e038fa4faa2ad8b15b25afe949a4",
+                "modal-1.6.1.tar.gz": "ff17768f67a65595aa7882e893e6cb78e2e001b3653aa52cfe98d4051d8d9e9e"
+              },
+              "changes": [
+                "Source diff of the 1.6.0 and 1.6.1 sdists, downloaded and hashed on the Mac, nothing installed or run; the 1.6.0 hashes match the pin. No file added or removed; 37 files changed, most in sandbox.py, the CLI and the generated protos.",
+                "Sandbox v2 calls send a per-sandbox token (x-modal-sandbox-token, from the create response) beside the auth token through a new _v2_metadata helper, including command router access.",
+                "Experimental sidecars take include_oidc_identity_token and proxy, refused for GPU sandboxes. Server sessions retry start with an idempotency key for up to 25 minutes; the CLI gains endpoint commands; stats types gain container_total_count; agent detection reads tool variables before AGENT and AI_AGENT.",
+                "Requirements: protobuf below 8.0 instead of 7.0, synchronicity ~=0.12.6 instead of ~=0.12.5. Some iterator return types become AsyncGenerator.",
+                "No public Sandbox, ContainerProcess, Image, App or file method used by withruntime/modal was removed or renamed; that drop-in does not import modal. Installed consumer qualification is not run; the supported pin stays 1.6.0."
+              ]
+            }
           }
         }
       ]

package/dist/api-defaults.d.ts

@@ -2,7 +2,7 @@
 export declare const WAIT_FOR_TIMEOUT_SECONDS = 60;
 /** A streamed exec's command limit when none is given: the API's longest. */
 export declare const STREAMED_EXEC_TIMEOUT_MS = 86400000;
-/** The lease keepAlive keeps ahead of now, and so the most it extends by. */
+/** The time keepAlive keeps ahead of a time limit, and so the most it extends by. */
 export declare const KEEP_ALIVE_MARGIN_SECONDS = 600;
 /** A webhook watch runs until stopped. */
 export declare const WEBHOOK_WATCH_TIMEOUT_MS = 0;

package/dist/api-defaults.js

@@ -7,7 +7,7 @@
 export const WAIT_FOR_TIMEOUT_SECONDS = 60;
 /** A streamed exec's command limit when none is given: the API's longest. */
 export const STREAMED_EXEC_TIMEOUT_MS = 86_400_000;
-/** The lease keepAlive keeps ahead of now, and so the most it extends by. */
+/** The time keepAlive keeps ahead of a time limit, and so the most it extends by. */
 export const KEEP_ALIVE_MARGIN_SECONDS = 600;
 /** A webhook watch runs until stopped. */
 export const WEBHOOK_WATCH_TIMEOUT_MS = 0;

package/dist/blaxel/errors.js

@@ -94,15 +94,15 @@ const BLAXEL_HINTS = {
     cwd_not_found: "Make the directory with sandbox.fs.mkdir(path), or pass an existing workingDir to sandbox.process.exec.",
     sandbox_paused: "Call sandbox.unarchive(), then try again.",
     not_running: "The sandbox is not running: call sandbox.unarchive() if it was archived, or make a new one with SandboxInstance.create if it was deleted.",
-    trial_busy: "The trial's sandboxes are all in use: delete one you no longer need (sandbox.delete()) or archive it (sandbox.archive()), then try again. Moving to paid credit is the account owner's decision.",
-    public_preview_not_allowed: "On the trial, share the port privately: sandbox.previews.create({ metadata: { name }, spec: { port, public: false } }) and a token from preview.tokens.create(expiresAt) on a server supporting absolute preview deadlines. A public preview needs a paid sandbox, which is the account owner's decision.",
+    no_credit_running_limit: "The sandboxes an account without credit runs at once are all in use: delete one you no longer need (sandbox.delete()) or archive it (sandbox.archive()), then try again. Moving to paid credit is the account owner's decision.",
+    public_preview_not_allowed: "Without credit, share the port privately: sandbox.previews.create({ metadata: { name }, spec: { port, public: false } }) and a token from preview.tokens.create(expiresAt) on a server supporting absolute preview deadlines. A public preview needs a paid sandbox, which is the account owner's decision.",
     busy: AGAIN,
     guest_busy: AGAIN,
     rate_limited: AGAIN,
     unauthorized: "Set RUNTIME_API_KEY to a Runtime key (https://withruntime.com/account/keys), or run `npx withruntime login` once. A Blaxel key (BL_API_KEY) is never sent.",
 };
 /** A trial create over the trial's size, in Blaxel's field. */
-const TRIAL_CAP = "A trial sandbox has at most 4096 MB of memory (2 vCPUs); pass memory 4096 or add credit.";
+const TRIAL_CAP = "Without credit, a sandbox has at most 4096 MB of memory (2 vCPUs); pass memory 4096 or add credit.";
 /** A Runtime SDK error as Blaxel's: ResponseError (SandboxGatewayError for a
  * 502, 503 or 504), NotSupportedError for a product Runtime has switched off,
  * CredentialsError when there is no Runtime key. Anything else passes through
@@ -118,7 +118,7 @@ export function translate(error) {
         return new NotSupportedError(error.code.replace(/_unavailable$/, ""), error.hint ?? "", error.message);
     if (error.status < 200 || error.status > 599)
         return error;
-    const trialCap = error.code === "invalid_trial";
+    const trialCap = error.code === "no_credit_size_limit";
     const hint = trialCap ? undefined : (BLAXEL_HINTS[error.code] ?? error.hint);
     const message = [
         trialCap ? TRIAL_CAP : error.message,

package/dist/blaxel/lookup.d.ts

@@ -23,7 +23,8 @@ export declare const STANDBY: {
     idlePauseSeconds: number;
     autoWake: true;
 };
-/** Runtime's longest lease. The adapter renews it while the sandbox is used. */
+/** Runtime's longest time limit. A sandbox made before 0300 has it, and the
+ * adapter renews it while the sandbox is used; one made since has none. */
 export declare const LEASE_SECONDS = 3600;
 /** The live sandbox with this name (or Runtime id): one call. A 404 when
  * there is none, as Blaxel answers. */

package/dist/blaxel/lookup.js

@@ -30,7 +30,8 @@ export const STANDBY = {
     idlePauseSeconds: 60,
     autoWake: true,
 };
-/** Runtime's longest lease. The adapter renews it while the sandbox is used. */
+/** Runtime's longest time limit. A sandbox made before 0300 has it, and the
+ * adapter renews it while the sandbox is used; one made since has none. */
 export const LEASE_SECONDS = 3600;
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 /** The live sandbox with this name (or Runtime id): one call. A 404 when

package/dist/blaxel/sandbox.d.ts

@@ -58,16 +58,18 @@ type Resolved = {
 };
 /** A duration as Blaxel writes it ("30m", "24h", "7d", "1w", "1h30m"). */
 export declare function durationMs(value: string): number;
-/** The lease and the paused retention that honour Blaxel's TTL, expiry and
- * lifecycle: never deleted before Blaxel would delete it. A fixed deadline
- * within the hour is a lease that ends the sandbox; any other deadline keeps
- * a paused sandbox that many days, rounded up; none keeps it 365 days. */
+/** The time limit and the paused retention that honour Blaxel's TTL, expiry
+ * and lifecycle: never deleted before Blaxel would delete it. A fixed
+ * deadline within the hour is a time limit that ends the sandbox; past that
+ * there is none, so it runs while it works and pauses when idle (0300), and
+ * a paused sandbox is kept that many days, rounded up; none keeps it 365
+ * days. */
 export declare function lifetimeOf(asked: {
     ttl?: string | null;
     expires?: Date;
     lifecycle?: SandboxLifecycle | null;
 }): {
-    timeoutSeconds: number;
+    timeoutSeconds?: number;
     onLeaseEnd: "pause" | "stop";
     days: number;
 };
@@ -125,8 +127,7 @@ export declare class SandboxInstance {
     get expiresIn(): number | undefined;
     /** Creates a sandbox and answers once it runs. Blaxel's defaults: the base
      * image (Runtime's stock image) and 4096 MB, with vCPUs at one per 2048 MB.
-     * Funding is left to Runtime: the free trial while the account has trial
-     * time, then prepaid credit. A name another live sandbox holds is refused
+     * Funding is left to Runtime: the included usage first, then prepaid credit. A name another live sandbox holds is refused
      * with a 409, as in Blaxel. */
     static create<T extends typeof SandboxInstance>(this: T, sandbox?: SandboxCreateConfiguration | SandboxModel, { createIfNotExist }?: {
         safe?: boolean;