withruntime 0.11.1 → 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

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

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,30 +30,54 @@ 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. While it is paused, `isRunning()`
-  is `false` and `getInfo()` says `paused`, so code that reads either as
-  "the sandbox is gone" should not. Pass
+  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 at most 48 connections to the
-  API at once, since one address may hold 64. Each command being run holds
-  one while its output is read, and 8 are kept for other calls, so past 40
-  commands at once from one process the rest wait their turn. Pass your own
-  client with `runtime: { client: new Runtime({ maxConnections }) }` (Python:
+- **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.
@@ -67,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)                                                  | Left out, the sandbox has no time limit: it runs while it works and pauses itself when idle. Given, it is `timeoutSeconds`, rounded up. Under 60 s becomes 60 s, with a warning. Up to 24 hours, as on E2B: a Runtime time limit 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 at its last limit, 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. A sandbox with no time limit has no end to move, and nothing changes.                                                                                                                                                                                                                                                                                                                                                              |
+| `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. |
@@ -98,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
 
@@ -131,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
@@ -161,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,11 +27,12 @@ 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).
-The trial's hours are spent first, then prepaid credit, with nothing to
+The included usage is spent first, then prepaid credit, with nothing to
 choose; `funding` is accepted and ignored.
 
 The sandbox object does the rest:

package/README.src.md

@@ -29,11 +29,12 @@ 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).
-The trial's hours are spent first, then prepaid credit, with nothing to
+The included usage is spent first, then prepaid credit, with nothing to
 choose; `funding` is accepted and ignored.
 
 The sandbox object does the rest:

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=="
           }
         }
       ]

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/sandbox.d.ts

@@ -127,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;

package/dist/blaxel/sandbox.js

@@ -523,8 +523,7 @@ export class SandboxInstance {
     // ---- create, get, list ---------------------------------------------------
     /** 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 async create(sandbox, { createIfNotExist = false } = {}) {
         const config = configOf(sandbox);

package/dist/cli.d.ts

@@ -30,7 +30,7 @@ declare const kit: {
 };
 export type CliKit = typeof kit;
 export declare function run(argv: string[], env?: NodeJS.ProcessEnv, out?: Out): Promise<number>;
-/** `runtime usage` for a person: the balance, the trial and what each kind
+/** `runtime usage` for a person: the balance, the included usage and what each kind
  * of resource was charged, in dollars. --json keeps every figure, and each
  * resource with its rates and CPU time. */
 /** One row per resource, for a spreadsheet: when it ran, how big it was, how

package/dist/cli.js

@@ -36,7 +36,7 @@ Account
                                                The account's audit log (owner or admin keys)
   sso                                          Single sign-on and SCIM directory sync (owner or
                                                admin keys); an owner changes it on the website
-  usage [--csv]                                Balance, trial time and charges; --csv, each resource
+  usage [--csv]                                Balance, included usage and charges; --csv, each resource
   usage export --since <UTC time> --until <UTC time>
                                                Every settlement in the range as CSV; --json, each page
   limits                                       Whether this key is read-only, and its daily spending limit
@@ -695,16 +695,18 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
         const [who, spend] = await Promise.all([rt.me(), rt.usage().catch(() => undefined)]);
         const trialLeft = spend?.trial ? spend.trial.availableMs / 3_600_000 : 0;
         const credit = spend ? BigInt(spend.available) : 0n;
+        // A pilot's sandboxes run on the pilot, before anything else and free.
         const funding = !spend
             ? undefined
             : [
+                ...(spend.pilot ? [pilotFunding(spend.pilot)] : []),
                 ...(trialLeft > 0
                     ? [
-                        `free trial, ${trialLeft.toLocaleString("en-US", { maximumFractionDigits: 1 })} hours left`,
+                        `included usage, ${trialLeft.toLocaleString("en-US", { maximumFractionDigits: 1 })} hours left without credit`,
                     ]
                     : []),
                 ...(credit > 0n ? [`${dollars(credit)} of credit`] : []),
-            ].join("; ") || "no trial time or credit left: runtime billing";
+            ].join("; ") || "no included usage or credit left: runtime billing";
         print(table([
             ["organization", who.orgName ? `${who.orgName} (${who.orgId})` : who.orgId],
             ...(who.role ? [["role", who.role]] : []),
@@ -765,7 +767,10 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
         return 0;
     }
     if (command === "limits") {
-        const l = await (await client(env)).limits.get();
+        const rt = await client(env);
+        // The usage call only adds the pilot's line: a key that cannot read it
+        // still gets its limits.
+        const [l, spend] = await Promise.all([rt.limits.get(), rt.usage().catch(() => undefined)]);
         // As `usage` shows money: $0.0014 of spend read $0.00 until 30 September 2026.
         const usd = (micros) => dollars(micros);
         const access = l.access === "read"
@@ -783,7 +788,13 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
             ],
             ["used, last 24 hours", usd(l.daily.usedMicros)],
             ...(l.daily.remainingMicros === null ? [] : [["left", usd(l.daily.remainingMicros)]]),
-            ...(l.trial ? [["free trial", trialLeft(l.trial)]] : []),
+            ...(l.trial ? [["free time", trialLeft(l.trial)]] : []),
+            ...(spend?.pilot
+                ? [
+                    ["pilot", pilotFunding(spend.pilot)],
+                    ["pilot sandbox hours", pilotLeft(spend.pilot)],
+                ]
+                : []),
         ]), l);
         return 0;
     }
@@ -1029,7 +1040,7 @@ export async function run(argv, env = process.env, out = defaultOut(argv)) {
     }
     throw unknown("command", command, COMMANDS);
 }
-/** `runtime usage` for a person: the balance, the trial and what each kind
+/** `runtime usage` for a person: the balance, the included usage and what each kind
  * of resource was charged, in dollars. --json keeps every figure, and each
  * resource with its rates and CPU time. */
 /** One row per resource, for a spreadsheet: when it ran, how big it was, how
@@ -1083,15 +1094,42 @@ export function usageCsv(u) {
 }
 /** Milliseconds as hours, to a tenth: "8,731.2". */
 const hours = (ms) => (ms / 3_600_000).toLocaleString("en-US", { maximumFractionDigits: 1 });
-/** The free trial's time left, as `runtime usage` and `runtime limits` say it. */
+/** The machine time left without credit, as `runtime usage` and `runtime
+ * limits` say it: this month's included usage, as hours at 2 vCPU and 4 GiB,
+ * or for an account given free hours before 5 October 2026, those hours too. */
 function trialLeft(trial) {
-    return `${hours(trial.availableMs)} of ${hours(trial.totalMs)} hours left`;
+    const renews = trial.renewsAt ? `, renews ${trial.renewsAt.slice(0, 10)}` : "";
+    return trial.totalMs > 0
+        ? `${hours(trial.availableMs)} hours left (${hours(trial.totalMs)} free hours given before 5 October 2026, and the included usage${renews})`
+        : `${hours(trial.availableMs)} hours at 2 vCPU and 4 GiB left this month${renews}`;
+}
+/** This month's included usage, one row per product, as `runtime usage`
+ * says it. */
+function allowanceRows(allowances) {
+    const amount = (n) => n.toLocaleString("en-US", { maximumFractionDigits: 1 });
+    return allowances.map((a) => [
+        `included ${a.pool.replace(/-/g, " ")}`,
+        `${amount(a.left)} of ${amount(a.quantity)} ${a.unit}s left`,
+    ]);
+}
+/** What a pilot gives, as `runtime whoami` and `runtime limits` say it: the
+ * sandboxes it runs free and until when, past which credit does not run
+ * them. */
+function pilotFunding(pilot) {
+    const at = (iso) => `${iso.slice(0, 16).replace("T", " ")} UTC`;
+    return `a pilot: up to ${pilot.sandboxes.toLocaleString("en-US")} sandboxes free, running until ${at(pilot.graceEndsAt)}; credit does not run it; to extend it, write to support`;
 }
 /** A pilot's sandbox hours left, as `runtime usage` says them. */
 function pilotLeft(pilot) {
     const left = `${hours(pilot.leftMs)} of ${pilot.hours.toLocaleString("en-US")} left`;
+    // How long they last at the rate its sandboxes run now (an API before
+    // 0414 does not say how many run).
+    const running = pilot.running ?? 0;
+    const pace = running > 0
+        ? `; at ${running.toLocaleString("en-US")} running, about ${hours(pilot.leftMs / running)} hours`
+        : "";
     return pilot.leftMs > 0
-        ? `${left}; new pilot sandboxes until ${pilot.endsAt.slice(0, 16).replace("T", " ")} UTC`
+        ? `${left}${pace}; new pilot sandboxes until ${pilot.endsAt.slice(0, 16).replace("T", " ")} UTC`
         : "This pilot's sandbox hours are used.";
 }
 function usageSummary(u) {
@@ -1114,7 +1152,9 @@ function usageSummary(u) {
     if (micros(u.expired) > 0n)
         rows.push(["expired or taken back", dollars(micros(u.expired))]);
     if (u.trial)
-        rows.push(["free trial", trialLeft(u.trial)]);
+        rows.push(["free time", trialLeft(u.trial)]);
+    if (u.allowances)
+        rows.push(...allowanceRows(u.allowances));
     if (u.pilot)
         rows.push(["pilot sandbox hours", pilotLeft(u.pilot)]);
     if (u.outbound) {
@@ -1126,7 +1166,15 @@ function usageSummary(u) {
         ]);
     }
     const kinds = new Map();
-    for (const resource of u.resources ?? []) {
+    // Every resource, by kind, from an API that totals them (6 October 2026);
+    // an older one sends only its hundred newest, counted here.
+    for (const k of u.kinds ?? [])
+        kinds.set(k.kind, {
+            count: k.resources,
+            charged: micros(k.chargedMicros),
+            held: micros(k.heldMicros),
+        });
+    for (const resource of u.kinds ? [] : (u.resources ?? [])) {
         const kind = typeof resource.kind === "string" ? resource.kind : "other";
         const entry = kinds.get(kind) ?? { count: 0, charged: 0n, held: 0n };
         entry.count++;
@@ -1305,7 +1353,7 @@ function runningTime(seconds) {
     });
     return `${shown} ${unit}${shown === "1" ? "" : "s"}`;
 }
-/** The sandboxes the free trial paid for, said beside what was priced. */
+/** The sandboxes free usage paid for, said beside what was priced. */
 function trialNote(trial, all, trialSeconds) {
     if (!trial)
         return "";
@@ -1314,7 +1362,7 @@ function trialNote(trial, all, trialSeconds) {
             ? "It"
             : "All of them"
         : `${trial} of them, ${runningTime(trialSeconds)} of that time,`;
-    return ` ${which} ran on the free trial, which charged nothing; Runtime's side prices ${trial === 1 ? "it" : "them"} at the standard rates, what the same work costs on paid credit.`;
+    return ` ${which} ran on free usage, which charged nothing; Runtime's side prices ${trial === 1 ? "it" : "them"} at the standard rates, what the same work costs on paid credit.`;
 }
 async function switching(command, argv, env, out) {
     const args = parse(argv, [], command === "compare" ? ["from", "days"] : ["from"]);
@@ -2808,7 +2856,7 @@ read = readSecret) {
 const JOB_HELP = `runtime job <command>
 
   A job runs a command in a fresh sandbox, once or on a schedule. Each run spends
-  the free trial's hours first, then credit at the sandbox rates.
+  the included usage first, then credit at the sandbox rates.
 
   create <name> (--cron "<min hour day month weekday>" [--timezone Europe/Berlin] | --at <time|now>)
          [--vcpu 2] [--memory 4096] [--disk 4096] [--cpu shared|reserved] [--cpu-floor <thousandths>]
@@ -3254,7 +3302,7 @@ const CREATE_FLAGS = [
     "get-or-create",
 ];
 /** Says on standard error, once for each reason, why a create has not
- * answered yet: it is waiting for a trial slot or room, which can take up to
+ * answered yet: it is waiting for a slot without credit or room, which can take up to
  * two minutes, and silence reads as a hang. */
 function waiting(out) {
     const said = new Set();