Open-source, secure environment with real-world tools for enterprise-grade agents.
Python agentaiai-agentai-agentscode-interpretercopilotdevelopmentdevtoolsgptgpt-4javascriptllmnextjsopenaipythonreactsoftwaretypescript
[skip ci] Release new versions
github-actions[bot]39fc1d71af1a
diff --git a/.changeset/bump-h2-4-4-1.md b/.changeset/bump-h2-4-4-1.mddeleted file mode 100644index 14467311b..000000000--- a/.changeset/bump-h2-4-4-1.md+++ /dev/null@@ -1,5 +0,0 @@-----'@e2b/python-sdk': patch------Raise the `h2` floor to `>=4.4.1` so it can no longer resolve to a version affected by CVE-2026-71554, where a duplicate `Host` header is forwarded to the consuming application and becomes a request smuggling primitive once HTTP/2 is downgraded to HTTP/1.1.diff --git a/.changeset/python-template-alias-encoding.md b/.changeset/python-template-alias-encoding.mddeleted file mode 100644index 25db1a681..000000000--- a/.changeset/python-template-alias-encoding.md+++ /dev/null@@ -1,28 +0,0 @@-----"@e2b/python-sdk": patch------Fix URL encoding of namespaced template names and aliases in the Python SDK.--The endpoints that take a template ID also accept a template name, and names may-be namespaced (e.g. `namespace/name`). The SDK interpolated them into the request-path without encoding, so a call like `Template.exists("namespace/name")` hit-`/templates/aliases/namespace/name` instead of-`/templates/aliases/namespace%2Fname` — the slash split the route rather than-staying inside one path segment. Every method that takes a template ID or name,-an alias, or a snapshot ID in the path — `Template.exists` / `alias_exists`,-`get_tags`, the build/upload/status calls, and `Sandbox.delete_snapshot` (whose-snapshot IDs are `namespace/name:tag`) — now percent-encodes the value, matching-the JavaScript SDK (which already encodes path parameters via-`encodeURIComponent`).--```python-from e2b import Template, Sandbox--# Namespaced templates now resolve correctly-Template.exists("my-team/my-template")-Template.get_tags("my-team/my-template")--# Namespaced snapshots can now be deleted-Sandbox.delete_snapshot("my-team/my-snapshot:default")-```diff --git a/.changeset/sandbox-egress-proxy.md b/.changeset/sandbox-egress-proxy.mddeleted file mode 100644index 8d506b874..000000000--- a/.changeset/sandbox-egress-proxy.md+++ /dev/null@@ -1,98 +0,0 @@-----'e2b': minor-'@e2b/python-sdk': minor------Add `network.egressProxy` / `network["egress_proxy"]` for routing a sandbox's outbound TCP through a SOCKS5 proxy you operate ("bring your own proxy"). Tunneling happens on the host after the `allowOut` / `denyOut` lists are evaluated, so nothing runs inside the sandbox and code running there can neither see the proxy nor route around it. UDP-based traffic — DNS and QUIC/HTTP3 — is not tunneled.--```ts-import { Sandbox } from 'e2b'--const sandbox = await Sandbox.create({- network: {- egressProxy: {- address: 'proxy.example.com:1080',- username: 'proxy-user',- password: 'proxy-password',- },- },-})-```--```python-from e2b import Sandbox--sandbox = Sandbox.create(- network={- "egress_proxy": {- "address": "proxy.example.com:1080",- "username": "proxy-user",- "password": "proxy-password",- },- },-)-```--It combines with the rest of the network configuration — here everything except `api.example.com` is denied, and the traffic that is allowed goes through your proxy:--```ts-await Sandbox.create({- network: {- allowOut: ['api.example.com'],- denyOut: ({ allTraffic }) => [allTraffic],- egressProxy: { address: 'proxy.example.com:1080' },- },-})-```--```python-Sandbox.create(- network={- "allow_out": ["api.example.com"],- "deny_out": lambda ctx: [ctx.all_traffic],- "egress_proxy": {"address": "proxy.example.com:1080"},- },-)-```--`updateNetwork` / `update_network` sets or replaces the proxy on a sandbox that is already running, with no restart. The update replaces the whole configuration instead of merging into it, so an update that leaves the proxy out stops tunneling — repeat it in every update that should keep it.--```ts-// Start tunneling on the running sandbox-await sandbox.updateNetwork({- allowOut: ['api.example.com'],- denyOut: ({ allTraffic }) => [allTraffic],- egressProxy: { address: 'proxy.example.com:1080' },-})--// Stop tunneling: an update without egressProxy clears it-await sandbox.updateNetwork({})-```--```python-# Start tunneling on the running sandbox-sandbox.update_network({- "allow_out": ["api.example.com"],- "deny_out": lambda ctx: [ctx.all_traffic],- "egress_proxy": {"address": "proxy.example.com:1080"},-})--# Stop tunneling: an update without egress_proxy clears it-sandbox.update_network({})-```--`getInfo` / `get_info` reports the proxy the sandbox's egress is currently tunneled through. The password is never returned, so the returned `SandboxEgressProxyInfo` does not have the field at all:--```ts-const info = await sandbox.getInfo()-console.log(info.network?.egressProxy)-// { address: 'proxy.example.com:1080', username: 'proxy-user' }-```--```python-info = sandbox.get_info()-print(info.network["egress_proxy"])-# {'address': 'proxy.example.com:1080', 'username': 'proxy-user'}-```--Egress fails closed: when the proxy is unreachable or does not speak SOCKS5, outbound connections fail rather than falling back to a direct connection. The address is validated server-side when the sandbox is created — a rejected create leaves nothing behind. Available on E2B Cloud and in BYOC deployments; a sandbox that names a proxy on a deployment built from the open source `e2b-dev/infra` repository is rejected as unsupported.diff --git a/packages/js-sdk/CHANGELOG.md b/packages/js-sdk/CHANGELOG.mdindex 8c43c647a..8c1166b0d 100644--- a/packages/js-sdk/CHANGELOG.md+++ b/packages/js-sdk/CHANGELOG.md@@ -1,5 +1,103 @@# e2b+## 2.41.0++### Minor Changes++- 6824cdf: Add `network.egressProxy` / `network["egress_proxy"]` for routing a sandbox's outbound TCP through a SOCKS5 proxy you operate ("bring your own proxy"). Tunneling happens on the host after the `allowOut` / `denyOut` lists are evaluated, so nothing runs inside the sandbox and code running there can neither see the proxy nor route around it. UDP-based traffic — DNS and QUIC/HTTP3 — is not tunneled.++ ```ts+ import { Sandbox } from 'e2b'++ const sandbox = await Sandbox.create({+ network: {+ egressProxy: {+ address: 'proxy.example.com:1080',+ username: 'proxy-user',+ password: 'proxy-password',+ },+ },+ })+ ```++ ```python+ from e2b import Sandbox++ sandbox = Sandbox.create(+ network={+ "egress_proxy": {+ "address": "proxy.example.com:1080",+ "username": "proxy-user",+ "password": "proxy-password",+ },+ },+ )+ ```++ It combines with the rest of the network configuration — here everything except `api.example.com` is denied, and the traffic that is allowed goes through your proxy:++ ```ts+ await Sandbox.create({+ network: {+ allowOut: ['api.example.com'],+ denyOut: ({ allTraffic }) => [allTraffic],+ egressProxy: { address: 'proxy.example.com:1080' },+ },+ })+ ```++ ```python+ Sandbox.create(+ network={+ "allow_out": ["api.example.com"],+ "deny_out": lambda ctx: [ctx.all_traffic],+ "egress_proxy": {"address": "proxy.example.com:1080"},+ },+ )+ ```++ `updateNetwork` / `update_network` sets or replaces the proxy on a sandbox that is already running, with no restart. The update replaces the whole configuration instead of merging into it, so an update that leaves the proxy out stops tunneling — repeat it in every update that should keep it.++ ```ts+ // Start tunneling on the running sandbox+ await sandbox.updateNetwork({+ allowOut: ['api.example.com'],+ denyOut: ({ allTraffic }) => [allTraffic],+ egressProxy: { address: 'proxy.example.com:1080' },+ })++ // Stop tunneling: an update without egressProxy clears it+ await sandbox.updateNetwork({})+ ```++ ```python+ # Start tunneling on the running sandbox+ sandbox.update_network({+ "allow_out": ["api.example.com"],+ "deny_out": lambda ctx: [ctx.all_traffic],+ "egress_proxy": {"address": "proxy.example.com:1080"},+ })++ # Stop tunneling: an update without egress_proxy clears it+ sandbox.update_network({})+ ```++ `getInfo` / `get_info` reports the proxy the sandbox's egress is currently tunneled through. The password is never returned, so the returned `SandboxEgressProxyInfo` does not have the field at all:++ ```ts+ const info = await sandbox.getInfo()+ console.log(info.network?.egressProxy)+ // { address: 'proxy.example.com:1080', username: 'proxy-user' }+ ```++ ```python+ info = sandbox.get_info()+ print(info.network["egress_proxy"])+ # {'address': 'proxy.example.com:1080', 'username': 'proxy-user'}+ ```++ Egress fails closed: when the proxy is unreachable or does not speak SOCKS5, outbound connections fail rather than falling back to a direct connection. The address is validated server-side when the sandbox is created — a rejected create leaves nothing behind. Available on E2B Cloud and in BYOC deployments; a sandbox that names a proxy on a deployment built from the open source `e2b-dev/infra` repository is rejected as unsupported.+## 2.40.0### Minor Changesdiff --git a/packages/js-sdk/package.json b/packages/js-sdk/package.jsonindex 6473c7ee8..b344820b1 100644--- a/packages/js-sdk/package.json+++ b/packages/js-sdk/package.json@@ -1,6 +1,6 @@{"name": "e2b",- "version": "2.40.0",+ "version": "2.41.0","description": "E2B SDK that give agents cloud environments","homepage": "https://e2b.dev","license": "MIT",diff --git a/packages/python-sdk/CHANGELOG.md b/packages/python-sdk/CHANGELOG.mdindex 091bfc804..fe15466fa 100644--- a/packages/python-sdk/CHANGELOG.md+++ b/packages/python-sdk/CHANGELOG.md@@ -1,5 +1,131 @@# @e2b/python-sdk+## 2.41.0++### Minor Changes++- 6824cdf: Add `network.egressProxy` / `network["egress_proxy"]` for routing a sandbox's outbound TCP through a SOCKS5 proxy you operate ("bring your own proxy"). Tunneling happens on the host after the `allowOut` / `denyOut` lists are evaluated, so nothing runs inside the sandbox and code running there can neither see the proxy nor route around it. UDP-based traffic — DNS and QUIC/HTTP3 — is not tunneled.++ ```ts+ import { Sandbox } from 'e2b'++ const sandbox = await Sandbox.create({+ network: {+ egressProxy: {+ address: 'proxy.example.com:1080',+ username: 'proxy-user',+ password: 'proxy-password',+ },+ },+ })+ ```++ ```python+ from e2b import Sandbox++ sandbox = Sandbox.create(+ network={+ "egress_proxy": {+ "address": "proxy.example.com:1080",+ "username": "proxy-user",+ "password": "proxy-password",+ },+ },+ )+ ```++ It combines with the rest of the network configuration — here everything except `api.example.com` is denied, and the traffic that is allowed goes through your proxy:++ ```ts+ await Sandbox.create({+ network: {+ allowOut: ['api.example.com'],+ denyOut: ({ allTraffic }) => [allTraffic],+ egressProxy: { address: 'proxy.example.com:1080' },+ },+ })+ ```++ ```python+ Sandbox.create(+ network={+ "allow_out": ["api.example.com"],+ "deny_out": lambda ctx: [ctx.all_traffic],+ "egress_proxy": {"address": "proxy.example.com:1080"},+ },+ )+ ```++ `updateNetwork` / `update_network` sets or replaces the proxy on a sandbox that is already running, with no restart. The update replaces the whole configuration instead of merging into it, so an update that leaves the proxy out stops tunneling — repeat it in every update that should keep it.++ ```ts+ // Start tunneling on the running sandbox+ await sandbox.updateNetwork({+ allowOut: ['api.example.com'],+ denyOut: ({ allTraffic }) => [allTraffic],+ egressProxy: { address: 'proxy.example.com:1080' },+ })++ // Stop tunneling: an update without egressProxy clears it+ await sandbox.updateNetwork({})+ ```++ ```python+ # Start tunneling on the running sandbox+ sandbox.update_network({+ "allow_out": ["api.example.com"],+ "deny_out": lambda ctx: [ctx.all_traffic],+ "egress_proxy": {"address": "proxy.example.com:1080"},+ })++ # Stop tunneling: an update without egress_proxy clears it+ sandbox.update_network({})+ ```++ `getInfo` / `get_info` reports the proxy the sandbox's egress is currently tunneled through. The password is never returned, so the returned `SandboxEgressProxyInfo` does not have the field at all:++ ```ts+ const info = await sandbox.getInfo()+ console.log(info.network?.egressProxy)+ // { address: 'proxy.example.com:1080', username: 'proxy-user' }+ ```++ ```python+ info = sandbox.get_info()+ print(info.network["egress_proxy"])+ # {'address': 'proxy.example.com:1080', 'username': 'proxy-user'}+ ```++ Egress fails closed: when the proxy is unreachable or does not speak SOCKS5, outbound connections fail rather than falling back to a direct connection. The address is validated server-side when the sandbox is created — a rejected create leaves nothing behind. Available on E2B Cloud and in BYOC deployments; a sandbox that names a proxy on a deployment built from the open source `e2b-dev/infra` repository is rejected as unsupported.++### Patch Changes++- 02ba746: Raise the `h2` floor to `>=4.4.1` so it can no longer resolve to a version affected by CVE-2026-71554, where a duplicate `Host` header is forwarded to the consuming application and becomes a request smuggling primitive once HTTP/2 is downgraded to HTTP/1.1.+- e2eebd5: Fix URL encoding of namespaced template names and aliases in the Python SDK.++ The endpoints that take a template ID also accept a template name, and names may+ be namespaced (e.g. `namespace/name`). The SDK interpolated them into the request+ path without encoding, so a call like `Template.exists("namespace/name")` hit+ `/templates/aliases/namespace/name` instead of+ `/templates/aliases/namespace%2Fname` — the slash split the route rather than+ staying inside one path segment. Every method that takes a template ID or name,+ an alias, or a snapshot ID in the path — `Template.exists` / `alias_exists`,+ `get_tags`, the build/upload/status calls, and `Sandbox.delete_snapshot` (whose+ snapshot IDs are `namespace/name:tag`) — now percent-encodes the value, matching+ the JavaScript SDK (which already encodes path parameters via+ `encodeURIComponent`).++ ```python+ from e2b import Template, Sandbox++ # Namespaced templates now resolve correctly+ Template.exists("my-team/my-template")+ Template.get_tags("my-team/my-template")++ # Namespaced snapshots can now be deleted+ Sandbox.delete_snapshot("my-team/my-snapshot:default")+ ```+## 2.40.0### Minor Changesdiff --git a/packages/python-sdk/package.json b/packages/python-sdk/package.jsonindex b75ee2e9a..f3bf03673 100644--- a/packages/python-sdk/package.json+++ b/packages/python-sdk/package.json@@ -1,7 +1,7 @@{"name": "@e2b/python-sdk","private": true,- "version": "2.40.0",+ "version": "2.41.0","scripts": {"example": "uv run python example.py","test": "uv run pytest -n 4 --verbose -x",diff --git a/packages/python-sdk/pyproject.toml b/packages/python-sdk/pyproject.tomlindex 85fa83a10..0bb4a37fe 100644--- a/packages/python-sdk/pyproject.toml+++ b/packages/python-sdk/pyproject.toml@@ -1,6 +1,6 @@[project]name = "e2b"-version = "2.40.0"+version = "2.41.0"description = "E2B SDK that give agents cloud environments"authors = [{ name = "e2b", email = "[email protected]" }]license = "MIT"diff --git a/packages/python-sdk/uv.lock b/packages/python-sdk/uv.lockindex db18296ea..e4de2a0fa 100644--- a/packages/python-sdk/uv.lock+++ b/packages/python-sdk/uv.lock@@ -183,7 +183,7 @@ wheels = [[[package]]name = "e2b"-version = "2.40.0"+version = "2.41.0"source = { editable = "." }dependencies = [{ name = "attrs" },@@ -281,7 +281,7 @@ name = "exceptiongroup"version = "1.3.1"source = { registry = "https://pypi.org/simple" }dependencies = [- { name = "typing-extensions" },+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },]sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" }wheels = [