e2b

Minor Changes

• 5c0f6eb: Remove SDK-side defaults from API request payloads so the API defaults apply when options are omitted. Sandbox create/fork/connect no longer preset a 5-minute timeout, fork no longer presets count: 1, create no longer presets allow_internet_access, pause no longer presets keeping memory, and template builds no longer preset CPU/memory. Explicitly provided values are still sent unchanged.

  Sandbox create and connect now use the v2 API endpoints (POST /v2/sandboxes, POST /v2/sandboxes/{id}/connect), which default timeout to 5 minutes and always secure envd access. The secure option on Sandbox.create is deprecated: every sandbox is secured, so the option is still accepted but ignored.

Patch Changes

• 5c0f6eb: Remove client-side validation of the fork count argument. The API validates the requested fork count and rejects invalid values.

Minor Changes

• 5b015ad: Removed the V1 template build operations and schemas from the generated API clients. The API no longer serves them (runtime 87968fc1e1fa); control planes carrying that change answer 410 Gone. Template builds go through the Template SDK.

  Visible removal, classified minor: the JS paths namespace loses POST /templates, POST /templates/{templateID}, POST /templates/{templateID}/builds/{buildID} and POST /v2/templates, and components['schemas'] loses TemplateLegacy, TemplateBuildRequest and TemplateBuildRequestV2; the Python e2b.api.client.models package loses TemplateLegacy, TemplateBuildRequest and TemplateBuildRequestV2, and e2b.api.client.api.templates loses the post_templates, post_templates_template_id, post_templates_template_id_builds_build_id and post_v2_templates modules. No SDK method accepted or returned them; code that imported these names directly must drop the import.

  The regenerated clients also pick up a documented 429 on most operations, a 409 on template create (v3), the upload-request headers on the build file-upload link, minLength: 1 on the v2 build source fields, and a deprecation marker on the always-empty logs field of the build status.

Patch Changes

• 956e3ab: Apply the request headers the API returns with a template layer-file upload link. Azure Blob Storage requires x-ms-blob-type on the upload request, which its signed URL cannot carry, so COPY instructions failed on Azure-backed clusters. GCS- and S3-backed clusters return no headers and are unaffected.
• e1fbe86: Bump @connectrpc/connect and @connectrpc/connect-web to 2.2.0 (fixes Http2SessionManager.verify() hanging when the connection closes mid-verification and stops delivering stream messages after cancellation).
• 80496c0: Fix uploads of non-native ReadableStreams in the browser silently sending the text [object ReadableStream] instead of the data. Buffering a stream drained it with new Response(stream), which accepts any async iterable on Node (an undici extension) but only its own stream class in a browser, stringifying anything else. Streams are now drained through the reader, which every implementation supports.
• 80496c0: Report a sandbox killed mid-request as an actionable TimeoutError in the browser. When the connection to a sandbox drops mid-request the SDK probes the sandbox's health to tell a killed sandbox apart from a transient network blip, but the probe only ran for connection-dropped wordings it recognized, and the browser's (network error) was missing — so killing a sandbox while a command was running surfaced a generic SandboxError: [unknown] network error instead of TimeoutError: ... The sandbox was killed or reached its end of life while the request was in flight.
• e1fbe86: Bump undici to 7.29.1 and the optional undici8 fallback to 8.10.2 to pick up the September 2026 security fixes.

Patch Changes

• 90e3fc5: Reject invalid Sandbox.create lifecycle options and Sandbox.connect onResume values before requiring an API key, matching the Python SDK.
• 5e418dc: Document that onResume / on_resume needs a control plane that knows the option: an older self-hosted or BYOC control plane drops the memory field and restores memory while reporting success, instead of rejecting the request.
• 9136603: Retry control-plane HTTP requests up to three times after 429 responses using the server's delta-seconds Retry-After delay. Retries can be configured or disabled with retries, and stop when waiting would exhaust the request timeout. Envd requests, including filesystem operations, and volume-content requests are not retried.

Minor Changes

• f842aa8: Expose a configurable minimum free-disk target with minFreeDiskMb in JavaScript, min_free_disk_mb in Python, and --min-free-disk-mb in template create. Omission uses the team default, while explicit zero requests no minimum growth. Growth is best effort and never shrinks an existing filesystem.

Minor Changes

• 08efa36: Add httpsPorts (JS) / https_ports (Python) to the sandbox network config. Ports listed there have their public URLs proxied to the sandbox over HTTPS — use it when the service listening on the port serves TLS itself. This is not TLS passthrough: traffic is still terminated at the E2B proxy and re-encrypted on the hop to the sandbox, and the backend certificate is not verified, so self-signed certificates work. The configured ports are also returned in the sandbox info network config.
• 6b759bf: Add ServiceBusyError (JavaScript) / ServiceBusyException (Python) for HTTP 503 responses: the API refused the operation because the service or the node running the sandbox is temporarily busy, the sandbox is unchanged, and the call can be retried. A refused pause() is the first case. The base SandboxError / SandboxException also carries the HTTP status as statusCode / status_code when the error came from an API response, so callers can branch on the status without parsing the message. Like AuthenticationError / AuthenticationException, the new class does not subclass the sandbox base error: it is raised for every 503 whatever the operation, so catch it explicitly.

Patch Changes

• 58c81f1: onTimeout / on_timeout and onResume / on_resume now raise InvalidArgumentError / InvalidArgumentException for a value outside their two literals, instead of silently resolving it to the other one. Both are resolved into a boolean before the request is built, so the value never reaches the API and a typo cannot be rejected server-side: on_timeout="Pause" previously resolved to kill and deleted the sandbox and its snapshot at timeout, and on_resume="Reboot" previously restored the memory the caller asked to skip. A nullish value still means "not configured" and leaves the choice to the API.

Patch Changes

• 6146cd0: Improve reliability for high-concurrency sandbox workloads by spreading envd traffic across four HTTP/2 connection pools. Set E2B_ENVD_POOL_SHARDS before importing the SDK to adjust the pool count.

Minor Changes

• 9d1c90d: Remove client-side API key format validation. The SDK no longer checks that the API key matches the e2b_ hex format — only that a key is present. The validateApiKey/validate_api_key option is deprecated and has no effect, and the E2B_VALIDATE_API_KEY environment variable is no longer read. The server remains the source of truth for key validity.

Patch Changes

• 67c06e0: Point the two Code Interpreter README links at code-interpreting/analyze-data-with-ai instead of the code-interpreting section index. The index has no landing page and 307s to that article, dropping the query string on the way, so the UTM parameters were lost before the reader arrived. Linking at the resolved path keeps them.

• 8943d6f: Update runtime dependencies: tar 7.5.22 and @bufbuild/protobuf 2.14.0 in the JS SDK, statuses 2.0.2, async-listen 3.1.0 and yup 1.7.1 in the CLI. No behavior change.

• 182b498: Point the README documentation links at docs.e2b.dev instead of e2b.dev/docs. The docs site moved to its own subdomain and has no /docs path prefix there, so e2b.dev/docs serves a 308 to docs.e2b.dev/ and e2b.dev/docs/code-interpreting maps to docs.e2b.dev/code-interpreting. The UTM parameters are unchanged and survived the redirect, so this removes a redirect hop rather than fixing broken attribution.

• b802997: Fix two network.egressProxy / network["egress_proxy"] cases an untyped caller reaches.

  The JS SDK had no shape guard: buildEgressProxyBody rebuilds the body from the known fields, so an address that was missing or not a string vanished and the caller got an API error about a config they never wrote ({"egressProxy":{}}). It now raises InvalidArgumentError naming the option, the way the Python SDK already did:

  // InvalidArgumentError: network egressProxy must be an object with a string
  // 'address' (e.g. 'proxy.example.com:1080').
  await Sandbox.create({
    network: { egressProxy: 'proxy.example.com:1080' as never },
  })

  A null / None username or password is now treated as absent instead of being serialized as a JSON null the API rejects — reading a credential out of an unset environment variable is how a caller lands there, and it means the proxy takes no credentials:

  await Sandbox.create({
    network: {
      egressProxy: {
        address: 'proxy.example.com:1080',
        // Unset in the environment; the proxy takes no credentials.
        username: process.env.PROXY_USER,
      },
    },
  })

  Sandbox.create(
      network={
          "egress_proxy": {
              "address": "proxy.example.com:1080",
              "username": os.environ.get("PROXY_USER"),
          },
      },
  )

Patch Changes

• b17b726: Stop the shared retrying transports from mirroring streamed request bodies in
  memory. pyqwest's retry middleware keeps a non-bytes body replayable by
  copying it as it is sent, so a streamed files.write of a file-like object or
  volume.write_file grew a full in-RAM mirror and peak memory scaled with file
  size. The transports now declare pyqwest's RetryMode.UNBUFFERED: a streamed
  body is replayed only while nothing has been read from it, which is all the
  SDK's connect-only retry policy needs — a ConnectionError is raised only
  before the request was written. Connect retries are unchanged, and bytes
  bodies (unary RPC payloads, in-memory writes) were already replayable without
  a copy.

Minor Changes

• 8787dfe: Add sorting and new filters to Sandbox.list. The order option ('asc' / 'desc', default 'desc') sorts sandboxes by start time across the whole paginated dataset, and the query now supports startedAfter / started_after (inclusive lower bound on start time) and template (exact template ID or alias) filters, all applied server-side before pagination. The CLI e2b sandbox list command exposes these via --order, --started-after, and --template.

Minor Changes

• 5759f17: Add an E2B client that binds a connection config once and exposes the resource surfaces off it, so a single process can talk to several API keys, domains or deployments. The classes it exposes are per-client subclasses of the real Sandbox/Volume/Template/Secret classes, so they behave exactly like the top-level ones — per-call options still win over the client's options, which win over the environment variables. The named top-level exports are unchanged and keep reading the environment.

  Nothing existing changes: Template is now the TemplateBase class made callable as a factory, so Template(...), the statics and instanceof keep working, and the default export is still Sandbox.

  import { E2B } from 'e2b'
  
  const { Sandbox, Volume, Template, Secret } = new E2B({
    apiKey: 'e2b_***',
    domain: 'e2b.dev',
  })
  
  const sandbox = await Sandbox.create()
  const volume = await Volume.create('my-volume')
  const exists = await Template.exists('my-template')
  await Template.build(Template().fromPythonImage('3'), 'my-env')
  await Secret.create('openai-api-key', 'sk-***')

  from e2b import E2B
  
  client = E2B(api_key="e2b_***", domain="e2b.dev")
  Sandbox, Volume, Template = client.Sandbox, client.Volume, client.Template
  Secret = client.Secret
  
  sandbox = Sandbox.create()
  volume = Volume.create("my-volume")
  exists = Template.exists("my-template")
  secret = Secret.create("openai-api-key", "sk-***")
  
  # Async variants are exposed too.
  AsyncSandbox = client.AsyncSandbox
  async_sandbox = await AsyncSandbox.create()

Minor Changes

• f89f8c3: Add Secrets Management to the SDK. The Secret class (and AsyncSecret in Python) now manages E2B secrets: create and update store secret values (write-only — no read surface returns them), getInfo / get_info and the paginated list read metadata, exists and destroy are idempotent existence and lifecycle helpers, and fill formats the ${e2b.secrets.name} placeholder that the runtime resolves to the secret's current value.

Patch Changes

• 61503f7: Report iam.tokens.toJSON, .then, .toString and .valueOf as unregistered workload tokens in a network transform callback. These four names were exempt from the unknown-token guard because the runtime reads them off any object it serializes, awaits or coerces, so referencing one as a token name used to serialize Bearer undefined or a built-in's source text into the rule. Such a value carries no placeholder for the egress proxy to resolve, so it was forwarded verbatim and the destination answered 401 on a garbage credential, with no error from E2B. They now throw InvalidArgumentError like any other unregistered name — on use rather than on the read, so serializing, awaiting and coercing the map itself keep working. The Python SDK was not affected.

  import { Sandbox, Secret } from 'e2b'
  
  await Sandbox.create({
    iam: {
      tokens: {
        aws: Secret.iamToken({
          audience: 'sts.amazonaws.com',
          tokenType: 'JWT-SVID',
        }),
      },
    },
    network: {
      rules: {
        'api.example.com': [
          {
            // InvalidArgumentError: Network transform references iam token
            // 'then', which is not registered. Registered tokens: 'aws'.
            transform: ({ iam }) => ({
              headers: { Authorization: `Bearer ${iam.tokens.then}` },
            }),
          },
        ],
      },
    },
  })

• d79c6cd: Remove the unused stackTrace constructor parameter from error classes that never have a caller stack trace attached (TimeoutError, NotEnoughSpaceError, NotFoundError, FileNotFoundError, SandboxNotFoundError, GitUpstreamError, VolumeNotFoundError, VolumePathNotFoundError).

• 2be6c12: Internal refactor: the template API operations resolve their connection config through a class-level hook, so a TemplateBase subclass can carry bound connection options. No behavior change — Template / AsyncTemplate keep reading config from per-call options and environment variables. In the Python SDK the terminal template operations (build, build_in_background, get_build_status, exists, alias_exists, assign_tags, remove_tags, get_tags) became classmethods, with signatures unchanged for callers.

• 05aa03c: Add typed not-found errors for volumes: VolumeNotFoundError / VolumeNotFoundException (thrown when a volume is not found) and VolumePathNotFoundError / VolumePathNotFoundException (thrown when a path inside a volume is not found). All subclass the existing NotFoundError / NotFoundException, so existing catches keep working.

Patch Changes

• 0d507cd: Restore the http2 parameter on get_transport and get_envd_transport, which the pyqwest migration dropped in 2.38.0. http2=False again returns a transport pinned to HTTP/1.1, on its own connection pool.

Minor Changes

• 07eb9be: Allow a network rule's transform to be a callback, so a workload identity token from the iam option can be injected into egress requests without the SDK ever seeing its value. The callback receives placeholder strings that the egress proxy resolves per request — iam.tokens.aws is ${e2b.identity.tokens.aws} on the wire — and referencing a token that is not registered in iam.tokens fails with InvalidArgumentError / InvalidArgumentException instead of silently sending a placeholder no token will ever replace.

  updateNetwork / update_network accepts the same callbacks, but its payload carries no iam config, so token names cannot be checked there and every name resolves to its placeholder.

  Token names are validated where they are registered and again before they are interpolated: a name cannot be empty or contain {, } or control characters, since the proxy reads a placeholder up to its first } and a brace in the name would resolve a different token than the one referenced.

  import { Sandbox, Secret } from 'e2b'
  
  const sandbox = await Sandbox.create({
    iam: {
      tokens: {
        aws: Secret.iamToken({
          audience: 'sts.amazonaws.com',
          tokenType: 'JWT-SVID',
        }),
      },
    },
    network: {
      allowOut: ({ rules }) => [...rules.keys()],
      rules: {
        'api.internal.example.com': [
          {
            transform: ({ iam }) => ({
              headers: { Authorization: `Bearer ${iam.tokens.aws}` },
            }),
          },
        ],
      },
    },
  })
  

  from e2b import Sandbox, Secret
  
  sandbox = Sandbox.create(
      iam={
          "tokens": {
              "aws": Secret.iam_token(audience="sts.amazonaws.com", token_type="JWT-SVID"),
          },
      },
      network={
          "allow_out": lambda ctx: list(ctx.rules.keys()),
          "rules": {
              "api.internal.example.com": [
                  {
                      "transform": lambda ctx: {
                          "headers": {"Authorization": f"Bearer {ctx.iam.tokens['aws']}"},
                      },
                  },
              ],
          },
      },
  )
  

• 64b25bb: Add the iam option to Sandbox.create for configuring sandbox workload identity, and a Secret class with an iamToken / iam_token method for defining the workload tokens. Passing a non-empty tokens map (name → { audience, tokenType }) enables workload identity for the sandbox:

  import { Sandbox, Secret } from 'e2b'
  
  const sandbox = await Sandbox.create({
    iam: {
      tokens: {
        aws: Secret.iamToken({
          audience: 'sts.amazonaws.com',
          tokenType: 'JWT-SVID',
        }),
      },
    },
  })
  

  from e2b import Sandbox, Secret
  
  sandbox = Sandbox.create(
      iam={
          "tokens": {
              "aws": Secret.iam_token(audience="sts.amazonaws.com", token_type="JWT-SVID"),
          },
      },
  )
  

  Plain { audience, tokenType } objects ({"audience": ..., "token_type": ...} dicts in Python) are accepted as token values too.

Minor Changes

• b048369: Move the envd HTTP API client (sandbox file transfers, health checks) onto pyqwest via its httpx-compatible transport adapter. envd RPC already runs on pyqwest through connectrpc, so all sandbox traffic now shares one HTTP stack built from the same transport pieces (with separate connection pools per use).

  The per-thread (sync) and per-loop (async) envd httpx clients are gone: the pyqwest transports are thread-safe and loop-independent, so a single client per module serves all threads and event loops.

  Timeout semantics through the adapter:

  • Streamed downloads (files.read(format="stream")): a request_timeout set explicitly for the call is the deadline for the whole transfer — by default the transfer is unbounded in total, as before. A stalled stream is reclaimed by a 60-second idle read timeout that resets on every chunk. stream_idle_timeout keeps working on the async client (applied per read); the sync client cannot interrupt a blocking read, so it relies on the transport-wide idle bound and now ignores the parameter.
  • Uploads: a buffered upload is bounded by request_timeout as a whole-request deadline, and a streamed (file-like) upload carries no client-side timeout (a stalled one is bounded server-side by envd's idle read timeout) — both matching the JS SDK.
  • Non-streamed reads (files.read() as text or bytes) and buffered uploads are bounded by request_timeout for the whole transfer (default 60 seconds), where the previous transport bounded each socket operation and left total duration unbounded. Reading or writing a file too large to transfer inside the deadline now raises httpx.ReadTimeout — pass a larger request_timeout (or 0 to disable), or use format="stream"/file-like data, for large transfers.

  E2B_MAX_CONNECTIONS is no longer read: it configured httpx's global connection cap, and the last transport that took one is gone (reqwest has no counterpart — it does not cap concurrent connections). E2B_KEEPALIVE_EXPIRY and E2B_MAX_KEEPALIVE_CONNECTIONS keep tuning the pools.

• a874ced: Move the REST API client (sandbox lifecycle, listing, templates, volumes control plane) onto pyqwest (Rust reqwest/hyper) via its httpx-compatible transport adapter, replacing the httpx-native HTTPTransport/AsyncHTTPTransport. The generated httpx client API is unchanged — only the transport underneath is swapped — so logging event hooks, headers, and redirect handling (follow_redirects, response.history) behave as before.

  One timeout semantics change: through the adapter, request_timeout is a deadline for the whole API call, where the previous transports applied it to each phase (connect, read, write) separately — a slow request could exceed it in total. For the REST API's small JSON exchanges this tightening is what request_timeout reads as promising; 0 still disables it.

  Because pyqwest transports are thread-safe and loop-independent (I/O runs on a Rust runtime), the API connection pool is now shared process-wide per proxy, instead of one pool per thread (sync) or per event loop (async), and ApiClient no longer maintains per-thread/per-loop httpx client caches — a single httpx client serves all threads and event loops. Connection-establishment failures are retried with backoff (E2B_CONNECTION_RETRIES, default 3), matching the connect-only retries of the previous transports. Timeouts keep raising httpx.ReadTimeout (an httpx.TimeoutException), as before, whether they fire while waiting for the response head or while reading the response body, and connection, network, and protocol failures keep raising their httpx counterparts (httpx.ConnectError, httpx.ReadError, httpx.RemoteProtocolError).

  proxy for API calls takes a URL string (e.g. proxy="http://user:pass@localhost:8030", scheme http, https, socks5, or socks5h), an httpx.URL, or an httpx.Proxy — including its credentials (sent as Proxy-Authorization) and any headers configured for the proxy. The one httpx.Proxy option pyqwest cannot express, a per-proxy ssl_context, raises InvalidArgumentException rather than being silently dropped.

  Low-level HTTP logs stay available: where enabling the httpcore logger used to show connection-level detail, pyqwest logs one line per request on the pyqwest.access logger and request lifecycle records on pyqwest, both at DEBUG and off unless enabled:

  import logging
  
  logging.basicConfig()
  logging.getLogger("pyqwest.access").setLevel(logging.DEBUG)
  # DEBUG pyqwest.access - HTTP Request: POST https://api.e2b.app/sandboxes "HTTP/2 201 Created"
  

  The SDK's own logger option is unchanged and independent of these.

  envd traffic is not affected: RPC (commands, PTY, filesystem watch) already runs on pyqwest via connectrpc, and the envd HTTP API (file transfers, health checks) keeps its httpx transports.

• b3a7c9f: Move template build-context uploads (to S3 presigned URLs) onto pyqwest via its httpx-compatible transport adapter. Content-Length framing for the streamed archive body is preserved (S3 rejects chunked transfer encoding), and redirects stay with the httpx client instead of being followed inside the transport. The 1-hour upload timeout now bounds the entire upload rather than each socket operation, and verify_ssl=False on the client is no longer honored for uploads (pyqwest has no insecure-TLS option).

• 458c2c4: Move the volume content client (Volume/AsyncVolume file operations) onto pyqwest via its httpx-compatible transport adapter, the same stack the REST API client uses. The connection pool is shared process-wide per proxy instead of one pool per thread (sync) or per event loop (async), and connection-establishment failures are retried with backoff (E2B_CONNECTION_RETRIES, default 3), as before.

  For streamed volume reads (Volume.read_file(format="stream")), a stalled stream is by default bounded by a transport-wide idle read timeout of 60 seconds that resets on every chunk (still surfaced as httpx.ReadTimeout; matches the JS SDK's default stream idle timeout). AsyncVolume.read_file keeps honoring an explicit stream_idle_timeout per read (including 0 to disable); the sync client ignores it — it cannot interrupt a blocking read. Passing request_timeout to a streamed read now bounds the whole transfer rather than individual socket operations.

  The same whole-transfer semantics apply to non-streamed operations: read_file(format="text"/"bytes") and uploads are bounded by request_timeout as a total deadline (default 1 hour for file content operations), where the previous transports bounded each socket operation and left total duration unbounded. Pass a larger request_timeout (or 0 to disable) for very large transfers on slow links.

Patch Changes

• cab27aa: Kill newly created sandboxes when MCP gateway startup fails. The failure now surfaces as SandboxError (JS) / SandboxException (Python) with a Failed to start MCP gateway: <stderr> message instead of a bare command exit error.

Patch Changes

• 88f41f3: Align ANSI stripping of template build log messages across both SDKs. The Python SDK's strip_ansi_escape_codes now ports the JS SDK's stripAnsi regex: OSC sequences (hyperlinks, window titles) are matched non-greedily up to the first string terminator — including sequences spanning newlines — and CSI sequences are stripped without requiring a terminator. Both implementations additionally strip the remaining ECMA-48 string controls (DCS/Sixel, SOS, PM, APC) through their string terminator so control payloads no longer leak into cleaned logs.
• 998e560: Relax the Python SDK's wcmatch requirement from >=10.1,<11 to >=10.1,<12 so e2b can be installed alongside packages that already require wcmatch>=11 (for example deepagents>=0.7.0), which previously failed to resolve. The SDK only calls glob.glob() with GLOBSTAR | DOTMATCH for template context matching; wcmatch 11.0's single breaking change affects translate() callers using extended-glob capture groups, so it is a no-op here. The template glob test suite passes against 10.1, 10.2.1 and 11.0.

Minor Changes

• 2821fb0: Route volume content requests to a team's custom (BYOC) cluster. When a team is connected to a custom cluster, the volume create and get endpoints now return that cluster's domain, and the SDK uses it as the destination for volume content requests instead of the default api.<E2B_DOMAIN> host. Teams on the default cluster are unaffected and keep their configured domain.

Minor Changes

• 1504fbc: Add fromFedoraImage, fromAlpineImage, and fromArchImage base-image helpers to the Template builder (from_fedora_image, from_alpine_image, from_arch_image in the Python SDK), alongside the existing fromUbuntuImage/fromDebianImage/etc. Templates can now start from Fedora, Alpine, and Arch base images (the orchestrator identifies the distro from /etc/os-release). Fedora and Alpine default to pinned tags (fedora:44, alpine:3.24) so builds stay reproducible; Arch defaults to latest because it is a rolling release and provisioning runs pacman -Syu regardless.

Patch Changes

• 6733f36: Align the Python SDK's from_fedora_image and from_alpine_image defaults with the JS SDK: fedora:44 and alpine:3.24, replacing fedora:42 (end-of-life, so its repositories leave the normal mirror network and provisioning can fail) and alpine:3.22. Callers that omit the variant now get the same base image in both SDKs, and both tags are the ones the orchestrator's distro build tests cover. Also corrects the JS TemplateFromImage type docs, which still named the old defaults.
• 45d2679: Regenerate e2b/sandbox/mcp.py with datamodel-code-generator 0.64.0: the MCP server option types now use builtin generics (list[str], dict[str, Any]) and are closed TypedDicts, mirroring the spec's additionalProperties: false. Raises the typing-extensions floor to >=4.10.0, the first release accepting PEP 728's closed.
• ee0ad25: Update snapshot docstrings to use project terminology instead of team (e.g. "my-project/my-snapshot", project slug)

Minor Changes

• 00253c3: Migrate the sandbox RPC layer (commands, PTY, filesystem watch) from the vendored e2b_connect client to the official Connect RPC client for Python (connectrpc), whose HTTP transport is pyqwest (Rust reqwest/hyper), and switch the envd protobuf messages from Google's protobuf runtime to Buf's protobuf-py.

  Closing a command or watch stream early now sends RST_STREAM to the server, so abandoned streams no longer leak on the shared HTTP/2 connection, and peer resets surface as typed errors instead of ambiguous EOFs. The REST API and file upload/download keep using httpx.

  Notes:

  • The SDK no longer depends on the protobuf package, removing a common source of dependency conflicts with other libraries that pin it.
  • The e2b_connect module is no longer shipped with the package. Code that imported it directly should use connectrpc (ConnectError, Code) instead; SDK exception types (SandboxException, TimeoutException, ...) are unchanged.
  • The generated e2b.envd.*.*_pb2 modules were replaced by protobuf-py equivalents (e2b.envd.process.process_pb, e2b.envd.filesystem.filesystem_pb) with a different message API.
  • Connection retries for sandbox RPC calls (E2B_CONNECTION_RETRIES, default 3) now retry only failures establishing the connection — before the request could have reached envd — with exponential backoff. Unary RPCs are no longer replayed when the connection drops mid-request, which could re-execute a delivered call (e.g. re-send process input); such drops surface as errors immediately, the way they always did for streaming calls.
  • The proxy option applies to sandbox RPC calls the same way it does to the REST API and file transfer requests. URL strings, httpx.URL, and httpx.Proxy values keep working (credentials in the URL or in httpx.Proxy(auth=...)); httpx.Proxy custom headers and ssl_context are not supported for RPC calls and raise InvalidArgumentException.
  • CommandResult.error (and CommandHandle.error) is now None when a command finishes without an error, matching the declared Optional[str] type and the JS SDK's error?: string. It used to be "" on success — code comparing result.error == "" or treating it as always-str should check for None/falsiness instead.
  • For async streaming calls (commands.run/connect, PTY, files.watch_dir), request_timeout now bounds opening the stream — the wait until envd confirms with a start event, matching the JS SDK's requestTimeoutMs — and raises TimeoutException when exceeded. The running stream is bounded by the command/watch timeout (as before). In the sync SDK there is no way to interrupt the blocking wait, so request_timeout is not applied to opening the stream — both stream setup and the running stream are bounded by timeout (unlimited when 0).
  • E2B_MAX_CONNECTIONS no longer applies to sandbox RPC traffic: the new transport bounds only idle connections per host (E2B_KEEPALIVE_EXPIRY, E2B_MAX_KEEPALIVE_CONNECTIONS), not the total number of open connections. It still applies to the REST API and file transfers.

• 4fcf7cb: Add FileType.SYMLINK to the sandbox filesystem types. Newer envd versions report symlinks with a dedicated FILE_TYPE_SYMLINK entry type; previously the SDKs treated it as unknown, so files.list() silently omitted symlink entries and getInfo()/get_info() returned an undefined/None type for them. Symlinks now surface as FileType.SYMLINK ('symlink') with symlinkTarget/symlink_target populated, in JS and both sync and async Python.

Patch Changes

• 3f46d56: Select template build-step stack-trace frames by SDK boundary instead of fixed depth. The caller's frame is now the first one whose file lies outside the SDK package, so traces stay correct when transpilers inject extra frames (e.g. TS class-field initializers) or runtimes elide delegating frames (e.g. Bun's tail-call elision). The suppress/override stack-trace collection machinery this made redundant (runInNewStackTraceContext, runInStackTraceOverrideContext and their Python equivalents) is removed.
• 4fcf7cb: Regenerate API clients from the latest specs, which are now synced with Copybara from their source-of-truth repositories (e2b-dev/infra@e2255f0 for the REST and envd specs, belt for the volume-content spec) instead of being copied by hand. Picks up the latest spec changes: named SandboxTimeoutRequest/SandboxSnapshotRequest/SandboxRefreshRequest request schemas, SandboxNetworkConfig and SandboxIam workload-identity models, the FILE_TYPE_SYMLINK filesystem entry type, and deprecation of access-token auth in favor of API keys. Anything the upstream specs mark x-not-implemented: true (currently the SOCKS5 egress-proxy config) is excluded from the generated clients. Generated Python client models now list fields in spec order instead of alphabetical order (the tag filtering moved from a custom script to Redocly CLI); construct them with keyword arguments if you don't already

Minor Changes

• 95e4dc2: Add sandbox.fork() / Sandbox.fork(sandbox_id) (and the AsyncSandbox equivalents) for forking a running sandbox. The sandbox is checkpointed in place (briefly paused, snapshotted with its full memory state, and resumed — its ID and expiration stay untouched) and count new sandboxes are created from that snapshot. Each fork succeeds or fails independently: the returned list contains one entry per requested fork, either a running sandbox instance or an exception. Per-fork error codes map to the same exception classes as other API errors (e.g. 429 to RateLimitException).

  sandbox = Sandbox.create()
  
  fork1, fork2 = sandbox.fork(count=2, timeout=60)
  if isinstance(fork1, Sandbox):
      fork1.commands.run('echo "hello from fork"')
  

Minor Changes

• 2c77fc0: Add a name filter to Sandbox.listSnapshots() / Sandbox.list_snapshots().

  The filter accepts a snapshot name or ID, optionally tag-qualified (e.g. "my-snapshot", "my-team/my-snapshot" or "my-snapshot:v1"). Unknown names return an empty list rather than an error. It can be combined with the existing sandboxId / sandbox_id filter (results must match both).

  // JS/TS
  const paginator = Sandbox.listSnapshots({ name: 'my-snapshot' })
  const snapshots = await paginator.nextItems()
  

  # Python (sync)
  paginator = Sandbox.list_snapshots(name="my-snapshot")
  snapshots = paginator.next_items()
  
  # Python (async)
  paginator = AsyncSandbox.list_snapshots(name="my-snapshot")
  snapshots = await paginator.next_items()
  

Patch Changes

• 7474d90: Fix inverted no_install_recommends docstring on TemplateBuilder.apt_install(). The docstring described the parameter as "Whether to install recommended packages", but the code passes apt-get's --no-install-recommends flag when the argument is True, which skips recommended packages, the opposite of what the docs claimed. The docstring now describes the real behavior. No behavior change.

• 99e536f: fix(python-sdk): stop leaking per-call proxy connection pools in volume content clients

  The volume content clients passed both proxy and the shared cached transport to httpx, so with a proxy configured every volume operation mounted a fresh, never-closed proxy transport. The proxy is already part of the cached transport, so the client-level proxy argument is now dropped. Volume transports also gained connect-level retries, matching the other transports.

Minor Changes

• 09e12b3: Replace the per-call integration connection option with a set-once, process-wide ConnectionConfig.setIntegration() (JS) / ConnectionConfig.set_integration() (Python). Integrations wrapping the SDK call it once at startup and every request is attributed via the User-Agent header — no more threading the option through individual SDK calls. The method is internal and hidden from docs. The integration option on ConnectionConfigOpts (JS) and the integration keyword argument on ConnectionConfig (Python) are removed; ConnectionConfigOpts remains as a deprecated alias of ConnectionOpts. In both SDKs, an explicitly provided User-Agent header now always takes precedence over the SDK-built one, while SDK-built values are recomputed whenever a config is rebuilt so they always reflect the current integration.

Minor Changes

• 2b7dd17: Add a gzip option to the template copy layer to control whether copied files are gzipped before upload.

  Gzip is enabled by default (matching the previous behavior). Pass gzip: false (gzip=False in Python) to upload an uncompressed tar archive instead — useful when copying already-compressed files where gzipping adds CPU cost without shrinking the payload.

  // JS/TS
  template.copy('model.bin', '/app/', { gzip: false })
  

  # Python
  template.copy('model.bin', '/app/', gzip=False)
  

Patch Changes

• bb45f18: Introduce a generic, reusable paginator base class and migrate the sandbox and snapshot list paginators onto it. The base owns the shared cursor-based pagination state (hasNext/has_next, nextToken/next_token, and reading the x-next-token header) while each concrete paginator implements nextItems/next_items to fetch its own page, so future list endpoints can add pagination by subclassing it without reimplementing the bookkeeping. No public API changes.

• f160f08: Keep integration user-agent attribution on ConnectionConfig instead of exposing it through sandbox, template, volume, or per-call API option types.

• 8b8a224: feat(python-sdk): add a logger option for request/debug logging

  You can now pass a standard library logging.Logger to Sandbox.create / AsyncSandbox.create (and the static Sandbox.connect(sandbox_id, ...)) to route that sandbox's request/response logs to your own logger. The logger is stored on the sandbox and propagates to all of its later operations — including control-plane calls such as kill, pause, set_timeout, and get_info. Matching the JavaScript SDK, logger is a construction-time option and is not a per-request parameter that those methods accept from the caller. The stdlib logging.Logger is used directly as the adapter instead of a custom interface.

  The logger is wired into the API client, the envd client, and the RPC (ConnectRPC) path. Mirroring the JS SDK: requests log at INFO, successful API and unary RPC responses at INFO, streamed RPC messages at DEBUG, and failed API responses (status >= 400) at ERROR. When no logger is supplied, the SDK emits no request/response logging at all (also matching the JS SDK).

  Volume content operations continue to accept logger per call via VolumeApiParams, matching the JS Volume API.

  import logging
  from e2b import Sandbox
  
  logging.basicConfig(level=logging.DEBUG)
  logger = logging.getLogger("my-app.e2b")
  
  sbx = Sandbox.create(logger=logger)
  sbx.commands.run("echo hello")  # request/response logged via `logger`
  

• a6b1cf4: fix(python-sdk): strip colon-separated SGR escape codes in build logs

  strip_ansi_escape_codes now strips CSI parameters that use colons as well as semicolons, matching the JavaScript SDK's stripAnsi. Modern terminals emit colon-separated SGR sequences (e.g. 256-color \x1b[38:5:82m, truecolor \x1b[38:2::r:g:bm, and curly underlines \x1b[4:3m), which previously leaked literal escape garbage into template build log messages on the Python side.

• c385566: Correct Sandbox.list() documentation across both SDKs: it returns a paginator (SandboxPaginator / AsyncSandboxPaginator), not a list, and by default the server returns sandboxes in both running and paused states. The docstrings now describe the return type accurately and show how to iterate pages via paginator.next_items() / await paginator.nextItems() while paginator.has_next / paginator.hasNext is true. No behavior change.

• bb16968: Template builds: the build-context tar archive is now spooled to a temporary file and streamed from disk during upload instead of being held in memory (JS and Python, sync and async), while keeping the explicit Content-Length required by S3 presigned URLs. Temp-file cleanup is now best-effort, so a cleanup failure after the upload no longer masks a successful upload as an error (nor overwrites the real upload error on failure). The Python SDK now uploads the archive with a 1-hour default timeout (overridable via request_timeout) instead of the 60s general API timeout, matching the JS SDK and preventing large uploads from timing out.

Minor Changes

• 7e7e951: Add an object form to the sandbox lifecycle.onTimeout (on_timeout in Python) that controls the snapshot kind taken when a sandbox auto-pauses on timeout, via keepMemory (keep_memory).

  onTimeout now accepts either the existing bare action ('pause' / 'kill') or the object form. The object form is a discriminated union on action: keepMemory is only accepted alongside action: 'pause' — pairing it with action: 'kill' is a compile-time type error (and is rejected at runtime for untyped callers). When keepMemory is false, a timeout auto-pause drops the in-memory state and persists only the filesystem (a filesystem-only snapshot); resuming such a sandbox cold-boots (reboots) it from disk, losing running processes and open connections. Defaults to true (full memory snapshot). It cannot be combined with auto-resume: auto-resume wakes a paused sandbox on inbound traffic by restoring its memory snapshot in place, and a filesystem-only snapshot has no memory to restore (resuming cold-boots it), so it must be resumed explicitly. The bare string form is unchanged.

  # Python
  sbx = Sandbox.create(
      lifecycle={"on_timeout": {"action": "pause", "keep_memory": False}}
  )
  

  // JS/TS
  const sbx = await Sandbox.create({
    lifecycle: { onTimeout: { action: 'pause', keepMemory: false } },
  })
  

• cb5a387: Add a keepMemory (keep_memory in Python) option to pause for filesystem-only snapshots.

  When keepMemory is false, pausing drops the in-memory state and captures only the filesystem (no memory snapshot); resuming such a snapshot cold-boots (reboots) the sandbox from disk, losing running processes and open connections. Defaults to true (full memory snapshot), so existing callers are unaffected.

  # Python
  sbx.pause(keep_memory=False)          # filesystem-only snapshot
  

  // JS/TS
  await sandbox.pause({ keepMemory: false }) // filesystem-only snapshot
  

Patch Changes

• de0c401: Fix three filesystem watch handle bugs:
  • JS: WatchHandle now awaits async onEvent/onExit callbacks. A rejecting async onEvent is routed to onExit and stops the watch instead of becoming an unhandled promise rejection that can crash Node, and async callbacks get backpressure/ordering — matching CommandHandle.
  • Python (sync): WatchHandle.get_new_events() and stop() now send a request timeout (default 60s, overridable via request_timeout) so a stalled call can't hang the thread forever, and include the authentication header so the polling/stop calls aren't sent unauthenticated on older envd.
  • Python (async): AsyncWatchHandle now invokes on_exit when the stream ends cleanly (with None) and when stop() is called, in addition to on error — matching the JS SDK.

Patch Changes

• 2a98cce: Fix CommandHandle (sync and async) recording the command result after yielding the flushed end-event chunks. The decoders are now flushed and the CommandResult is recorded before the trailing chunks are yielded, so a consumer that stops iterating on the first flushed chunk still observes the exit code.
• 21af1f8: Avoid quadratic-time stdout/stderr accumulation in command handles by buffering decoded chunks in a list and joining on read instead of repeatedly concatenating onto an instance attribute.

Patch Changes

• 60feee3: Stream uploads instead of buffering streaming input entirely in memory:

  • Sandbox.files.write() / write_files(): ReadableStream data (JS, outside the browser) and file-like objects (Python) are streamed to the sandbox, including when gzip is enabled (compression now happens chunk by chunk). useOctetStream/use_octet_stream now defaults to auto-detect — octet-stream is used when any entry is streamable (so streamed uploads aren't silently buffered) and multipart/form-data otherwise; browsers always use multipart/form-data. A streamed upload is bounded by a per-chunk timeout on the wire (Python's per-write httpx timeout, default the request timeout); a stalled upload that this can't observe is bounded server-side. On Python's AsyncSandbox, the blocking file reads and gzip compression of a streamed upload now run in a worker thread so a large upload doesn't stall the event loop.
  • Sandbox.files.read(format="stream"): the request timeout now bounds only the initial handshake instead of killing the stream while it's being consumed. The body is bounded by a per-chunk idle timeout on the wire (streamIdleTimeoutMs in JS, stream_idle_timeout in Python, default the request timeout — 60s — 0/None to disable): it aborts only when the server stops sending mid-stream, and a slow or paused consumer never trips it (a held-but-unread stream is reclaimed server-side). Use signal (JS) to cancel an in-flight stream. A dropped connection during the stream handshake now surfaces the same typed, health-checked error as non-stream reads. The stream holds a pooled connection until it is consumed to the end, cancelled/closed, errors, or the idle timeout fires — consume it fully, use the context manager, or close it.
  • Python Sandbox.files.read(format="stream"): the response body is now streamed from the sandbox instead of being downloaded into memory before iteration (sync and async).
  • JS Sandbox.files.read() with blob or stream format now returns an empty Blob/ReadableStream for empty files instead of "".

• 8171a03: Fix Python SDK header precedence so a custom Authorization passed via api_headers is no longer overwritten by the deprecated access_token. The deprecated access token is now applied before api_headers, matching the JS SDK where a custom Authorization wins.

• c1415f3: Stream volume file uploads and downloads instead of buffering in memory:

  • Volume.writeFile() / Volume.write_file(): ReadableStream data (JS, outside the browser) and file-like objects (Python) are now streamed to the API in chunks.
  • Volume.readFile(format="stream") / read_file(format="stream"): the request timeout now bounds only the initial handshake instead of killing the stream while it's being consumed (Python disables the read timeout; JS bounds the handshake and supports signal to cancel an in-flight stream). A dropped connection during the stream handshake now surfaces the same typed, health-checked error as non-stream reads.

Patch Changes

• 726ced6: Fix duplicate logo on NPM/PyPI by switching to <picture> element.

Patch Changes

• f3e7f33: Tidy up SDK authentication and deprecate the access token in ConnectionConfig.

  • Deprecated the accessToken (JS) / access_token (Python) option on ConnectionConfig. It still works exactly as before — when set (or via E2B_ACCESS_TOKEN), the Authorization: Bearer header is still sent — but you should pass custom auth through apiHeaders instead, e.g. new ConnectionConfig({ apiHeaders: { Authorization: 'Bearer <token>' } }).
  • The SDK now raises a clear error when no API key is supplied, pointing to the API Keys tab (https://e2b.dev/dashboard?tab=keys). In JS this is controlled by a requireApiKey option (default true) so callers that authenticate differently — like the CLI hitting /teams with an access token — can opt out; in Python the API key is always required.
  • Removed the unused access-token toggle from the API clients: requireAccessToken (JS) and require_access_token (Python). No caller ever set it to a non-default value, so behavior is unchanged.
  • The CLI now passes the access token to the /teams endpoint through apiHeaders instead of the deprecated option.
  • Decoupled the sandbox-scoped envd access token from ConnectionConfig: EnvdApiClient now owns its own accessToken field and sets the X-Access-Token header itself.

• 0a5d524: Update package logos with theme-aware dark/light variants for GitHub.

Patch Changes

• 706c553: Template SDK fixes:

  • Match the exact listening port in wait_for_port (via ss's sport filter) so e.g. port 80 no longer matches 8080.
  • Shell-quote the URL, filename, and process name in wait_for_url, wait_for_file, and wait_for_process.
  • Shell-quote paths and arguments in remove, rename, make_dir, make_symlink, git_clone (URL/branch/path), and the devcontainer helpers so values with spaces or shell metacharacters work correctly.
  • Keep fetching build logs after a terminal build status is returned so the tail of the logs (beyond the 100-entries-per-call API limit) is no longer dropped.
  • Collect one stack trace per COPY instruction so failed-step stack traces stay aligned after copy() with multiple sources or copy_items().

• 432c091: Add integration attribution options that append integration metadata to the SDK User-Agent.

Patch Changes

• 1d5259c: Fix a batch of connection-handling bugs in the JS and Python SDKs:
  • Python: HTTP transport caches now key on the configured proxy, so clients created with different (or no) proxy settings no longer silently reuse a transport built for the first proxy seen.
  • Python: request_timeout is now applied to control-plane (E2B API) requests; previously the underlying httpx client was built with no timeout at all.
  • Python: the server-stream parser no longer stalls (or drops the final envelope) when the remaining payload of an envelope is shorter than the 5-byte envelope header.
  • JS + Python: passing debug: false explicitly now overrides the E2B_DEBUG=true environment variable instead of being ignored.
  • JS: the RPC logger no longer crashes requests with a TypeError when a response contains protobuf int64 (bigint) fields; they are now logged as strings.

Minor Changes

• e873ee9: Add an allowNetworkMounts/allow_network_mounts option to filesystem directory watching. When enabled, paths on network filesystem mounts (NFS, CIFS, SMB, FUSE) can be watched — they are rejected by default because events on network mounts may be unreliable or not delivered at all. Requires envd 0.6.4 or later; watching with this option against an older sandbox raises a template error.

Patch Changes

• 32880d6: Key per-event-loop async HTTP transport and client caches by the loop object (held weakly) instead of id(loop). CPython can reuse the id of a closed loop almost immediately, so sequential event loops (for example repeated asyncio.run(...) calls) could inherit a transport or client bound to a previous, closed loop. Cache entries are now also released automatically when their loop is garbage collected.

• 0b0c728: Fix several issues in the volume content API client:

  • AsyncVolume HTTP transports are now cached per event loop (and per proxy) instead of a process-wide singleton, and sync transports are cached per thread.
  • Volume metadata operations (list, make_dir, get_info, update_metadata, remove) now respect request_timeout (60s by default) instead of running with httpx timeouts disabled.
  • Volume content auth no longer falls back to the E2B_ACCESS_TOKEN environment variable; it requires the volume token, matching the JS SDK.
  • VolumeConnectionConfig no longer mutates the caller's headers dict.

• 1328d9f: Retry connection establishment on the HTTP/2 transports used for the E2B API and envd clients (3 retries by default, configurable via the E2B_CONNECTION_RETRIES environment variable).

Patch Changes

• 554dc88: Create Python SDK sync HTTP clients from the calling thread, including sandbox envd clients and API clients used by template uploads.
• 82d6e32: Use dedicated HTTP/1.1 clients for Python template file uploads to signed storage URLs.

Patch Changes

• 08012ee: feat: add sendStdin/send_stdin and closeStdin/close_stdin to CommandHandle

  You can now send and close stdin directly on a background command handle instead of going through sandbox.commands with the command's PID.

• ca18220: Use components['schemas'][...] instead of verbose paths[...] traversal for OpenAPI-generated type references.

Minor Changes

• 073661a: Add API-only custom header options for the JavaScript and Python SDKs.

Patch Changes

• e7a82ea: Remove unused internal code: wait helper (js-sdk), asSandboxTemplate/asHeadline/selectOption/basicDockerfile (cli), and format_execution_timeout_error (python-sdk). No public API changes.
• 5b2bb94: Return a dedicated rate limit error for HTTP 429 responses from the envd API. Previously these were surfaced as a generic sandbox error, unlike the main API client which already raised RateLimitError (JS) / RateLimitException (Python). Rate limit errors are now consistent across all SDK request paths.

Patch Changes

• 4e16cff: Fix proxy not being applied to volume content requests. Volume.create/Volume.connect now store the proxy on the returned instance, so instance methods (list, readFile, writeFile, makeDir, getInfo, updateMetadata, remove, …) route through it without having to pass proxy on every call. A per-call proxy still takes precedence.

Minor Changes

• d86368a: Align the sync and async Python SDK implementations: consistent parameter ordering (_create, Commands._start), matching docstrings, keyword arguments in Filesystem.write, and a consistent bare Exception for the internal "Body of the request is None" guard (matching the volume client).

  Sandbox.pause() / AsyncSandbox.pause() (and beta_pause) now return a bool — True if the sandbox got paused, False if it was already paused — matching the JS SDK. Previously the instance method returned None and the class-method form returned the sandbox ID.

Patch Changes

• 08012ee: feat: add sendStdin/send_stdin and closeStdin/close_stdin to CommandHandle

  You can now send and close stdin directly on a background command handle instead of going through sandbox.commands with the command's PID.

• 7296b2c: fix(python-sdk): stop sending E2b-Sandbox-Id/E2b-Sandbox-Port headers on the control-plane connect request

  Sandbox.connect was attaching the envd data-plane headers (E2b-Sandbox-Id, E2b-Sandbox-Port) to the POST /sandboxes/{id}/connect API call. These headers belong only on data-plane (filesystem/commands/pty) requests, matching the JS SDK behavior.

• f2550fa: Mark the Python SDK as typed (PEP 561). Added py.typed markers to the e2b and e2b_connect packages so type checkers like mypy and Pyright honor the inline annotations on Sandbox, AsyncSandbox, and other public APIs instead of treating imports as Any.

• 6c04e31: Use thread-local sync HTTP transports to avoid sharing HTTP/2 connection state across Python threads.

Minor Changes

• 18a10afa: chore(js): add max concurrency limits

Patch Changes

• 4b9cc04: Use the stable sandbox host for envd requests on supported E2B domains and give envd traffic a separate HTTP transport cache from API traffic. Sync envd transports are cached per thread to avoid sharing a single HTTP/2 connection across threaded sync workloads.

Minor Changes

• 3786f34: Support structured network rules with per-host transforms
• c485bf5: Add Sandbox.updateNetwork / update_network to replace a running sandbox's egress configuration (allow / deny lists, per-host rules, internet access toggle).
• 3ea4ef5: use stable sandbox.e2b.app for h2 efficiency

Patch Changes

• ba315c0: Add signal: AbortSignal option to Template.build, Template.buildInBackground, Template.getBuildStatus, Template.exists, Template.aliasExists, Template.assignTags, Template.removeTags, and Template.getTags. When the signal is aborted, the underlying request (and, for Template.build, the status polling loop) is cancelled and the returned promise rejects with an AbortError.

Minor Changes

• 3786f34: Support structured network rules with per-host transforms
• c485bf5: Add Sandbox.updateNetwork / update_network to replace a running sandbox's egress configuration (allow / deny lists, per-host rules, internet access toggle).

Patch Changes

• a9bb287: fix(python-sdk): close gRPC streams on AsyncWatchHandle.stop() and AsyncCommandHandle.disconnect()

  stop() / disconnect() previously only cancelled the consumer task and left the underlying server-streaming RPC open (the await self._events.aclose() was commented out as a Python 3.8 workaround). On long-lived sandboxes this leaked file descriptors and eventually produced Code.internal: error creating watcher: too many open files. Python 3.8 is no longer supported (pyproject.toml pins ^3.10), so the workaround is removed and the streams are now closed explicitly.

• 8640378: Make http2 parameter optional

Minor Changes

• d21b936: - Fix lifecycle and autopause precedence
  • Deprecate auto_pause/autoPause; use lifecycle={"on_timeout": "pause"} instead. A DeprecationWarning (Python) / console.warn (JS) is now emitted when the flag is set
  • Breaking validation change: passing auto_resume=true while the resolved on_timeout is "kill" now raises InvalidArgumentException (Python) / InvalidArgumentError (JS)

Minor Changes

• e10958d: support for api h2

Patch Changes

• eaf452a: add optional name parameter to createSnapshot and return snapshot names

Minor Changes

• 2ac5de2: Add signal: AbortSignal option to JS SDK methods to support cancelling in-flight requests. The signal can be passed to Sandbox.create, Sandbox.connect, sandbox.commands.run, sandbox.files.*, volume methods, and other request options. When the signal is aborted, the underlying fetch is aborted and the returned promise rejects with an AbortError.

  SandboxPaginator.nextItems and SnapshotPaginator.nextItems now accept a SandboxApiOpts argument (including signal) — when provided, the per-call options override the connection options the paginator was constructed with for that single request.

  Same change in the Python SDK: SandboxPaginator.next_items / SnapshotPaginator.next_items (sync and async) now accept **opts: ApiParams (e.g. api_key, domain, headers, request_timeout); when provided, the per-call options override the ones the paginator was constructed with.

Patch Changes

• 55e9e0e: resolve Dependabot security alerts: bump vulnerable transitive npm deps via pnpm overrides (postcss, vite, lodash, brace-expansion, picomatch, yaml, @tootallnate/once, smol-toml, flatted, minimatch) and python dev deps in poetry.lock (pytest, pytest-asyncio, python-dotenv, pygments, requests, black)

Patch Changes

• 2c995d4: added opt-in useOctetStream / use_octet_stream option to sandbox file write; default is now multipart/form-data regardless of envd version

Patch Changes

• eaf452a: add optional name parameter to createSnapshot and return snapshot names

Minor Changes

• cf35f61: switch to application/octet-stream for file uploads
• 1cc385a: Edit README

Patch Changes

• ef46004: Increase default timeout for volume file uploads to 1 hour

Minor Changes

• 6d7e72e: added volumes support to the SDKs

Minor Changes

• f7f1f29: Update SDK READMEs

Minor Changes

• f7f1f29: Update SDK READMEs

Minor Changes

• 7c8d298: adds network configs and lifecycle handling to info responses

Patch Changes

• 1c55083: Fix missing instance config propagation in Sandbox pause/connect and add regression tests for config forwarding + overrides.

Patch Changes

• 710fae6: request_timeout applies to connect/pool/write

Patch Changes

• 16c86d1: Support multiple asyncio loops

Patch Changes

• 5417dd4: Rebuild the CLI so the bundled tar picks up 7.5.19+, fixing the node-tar denial-of-service vulnerabilities (the CLI bundles the SDK and its dependencies into dist/index.js)
• Updated dependencies [3f46d56]
• Updated dependencies [1ae3f92]
• Updated dependencies [9ee4414]
• Updated dependencies [5e141a7]
• Updated dependencies [4fcf7cb]
• Updated dependencies [5417dd4]
• Updated dependencies [4fcf7cb]
  • e2b@2.36.0