Skip to content

armgit / E2B

Public Imported from GitHub
0

Open-source, secure environment with real-world tools for enterprise-grade agents.

[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.md
deleted file mode 100644
index 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.md
deleted file mode 100644
index 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.md
deleted file mode 100644
index 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.md
index 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 Changes
diff --git a/packages/js-sdk/package.json b/packages/js-sdk/package.json
index 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.md
index 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 Changes
diff --git a/packages/python-sdk/package.json b/packages/python-sdk/package.json
index 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.toml
index 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.lock
index 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 = [