Open-source, secure environment with real-world tools for enterprise-grade agents.
Python agentaiai-agentai-agentscode-interpretercopilotdevelopmentdevtoolsgptgpt-4javascriptllmnextjsopenaipythonreactsoftwaretypescript
feat(sdk): support structured network rules with per-host transforms (#1286)
Mish Ushakov3786f343364b
diff --git a/.changeset/network-rules-transform.md b/.changeset/network-rules-transform.mdnew file mode 100644index 000000000..1ebb00525--- /dev/null+++ b/.changeset/network-rules-transform.md@@ -0,0 +1,6 @@+---+'e2b': minor+'@e2b/python-sdk': minor+---++Support structured network rules with per-host transformsdiff --git a/packages/js-sdk/src/api/schema.gen.ts b/packages/js-sdk/src/api/schema.gen.tsindex d3c42e3ee..d067e7406 100644--- a/packages/js-sdk/src/api/schema.gen.ts+++ b/packages/js-sdk/src/api/schema.gen.ts@@ -287,6 +287,61 @@ export interface paths {patch?: never;trace?: never;};+ "/sandboxes/{sandboxID}/network": {+ parameters: {+ query?: never;+ header?: never;+ path?: never;+ cookie?: never;+ };+ get?: never;+ /** @description Update the network configuration for a running sandbox. Replaces the current egress rules with the provided configuration. Omitting both fields clears all egress rules. */+ put: {+ parameters: {+ query?: never;+ header?: never;+ path: {+ sandboxID: components["parameters"]["sandboxID"];+ };+ cookie?: never;+ };+ requestBody: {+ content: {+ "application/json": {+ /** @description Allow sandbox to access the internet. When set to false, it behaves the same as specifying denyOut to 0.0.0.0/0 in the network config. */+ allow_internet_access?: boolean;+ /** @description List of allowed destinations for egress traffic. Each entry can be a CIDR block (e.g. "8.8.8.8/32"), a bare IP address (e.g. "8.8.8.8"), or a domain name (e.g. "example.com", "*.example.com"). Allowed entries always take precedence over denied entries. */+ allowOut?: string[];+ /** @description List of denied CIDR blocks or IP addresses for egress traffic. Domain names are not supported for deny rules. */+ denyOut?: string[];+ /** @description Per-domain transform rules. Replaces all existing rules when provided. */+ rules?: {+ [key: string]: components["schemas"]["SandboxNetworkRule"][];+ };+ };+ };+ };+ responses: {+ /** @description Successfully updated the sandbox network configuration */+ 204: {+ headers: {+ [name: string]: unknown;+ };+ content?: never;+ };+ 401: components["responses"]["401"];+ 404: components["responses"]["404"];+ 409: components["responses"]["409"];+ 500: components["responses"]["500"];+ };+ };+ post?: never;+ delete?: never;+ options?: never;+ head?: never;+ patch?: never;+ trace?: never;+ };"/sandboxes/{sandboxID}/pause": {parameters: {query?: never;@@ -2279,17 +2334,32 @@ export interface components {timestampUnix: number;};SandboxNetworkConfig: {- /** @description List of allowed CIDR blocks or IP addresses for egress traffic. Allowed addresses always take precedence over blocked addresses. */+ /** @description List of allowed destinations for egress traffic. Each entry can be a CIDR block (e.g. "8.8.8.8/32"), a bare IP address (e.g. "8.8.8.8"), or a domain name (e.g. "example.com", "*.example.com"). Allowed entries always take precedence over denied entries. */allowOut?: string[];/*** @description Specify if the sandbox URLs should be accessible only with authentication.* @default true*/allowPublicTraffic?: boolean;- /** @description List of denied CIDR blocks or IP addresses for egress traffic */+ /** @description List of denied CIDR blocks or IP addresses for egress traffic. Domain names are not supported for deny rules. */denyOut?: string[];/** @description Specify host mask which will be used for all sandbox requests */maskRequestHost?: string;+ /** @description Per-domain transform rules applied to matching egress HTTP/HTTPS requests. Keys are domains (e.g. "api.example.com", "example.com"). A domain listed here is not automatically allowed - use allowOut to permit the traffic. */+ rules?: {+ [key: string]: components["schemas"]["SandboxNetworkRule"][];+ };+ };+ /** @description Transform rule applied to egress requests matching a domain pattern. */+ SandboxNetworkRule: {+ transform?: components["schemas"]["SandboxNetworkTransform"];+ };+ /** @description Transformations applied to matching egress requests before forwarding. */+ SandboxNetworkTransform: {+ /** @description HTTP headers to inject or override in matching requests. An existing header with the same name is replaced. Values are plain strings; secret resolution happens client-side before sending to the API. */+ headers?: {+ [key: string]: string;+ };};/*** @description Action taken when the sandbox times out.diff --git a/packages/js-sdk/src/index.ts b/packages/js-sdk/src/index.tsindex 3a188e4d8..036d112e4 100644--- a/packages/js-sdk/src/index.ts+++ b/packages/js-sdk/src/index.ts@@ -57,6 +57,13 @@ export type {SandboxListOpts,SandboxPaginator,SandboxNetworkOpts,+ SandboxNetworkInfo,+ SandboxNetworkSelector,+ SandboxNetworkSelectorContext,+ SandboxNetworkRule,+ SandboxNetworkRuleInfo,+ SandboxNetworkRules,+ SandboxNetworkTransform,SandboxLifecycle,SandboxInfoLifecycle,SnapshotInfo,diff --git a/packages/js-sdk/src/sandbox/sandboxApi.ts b/packages/js-sdk/src/sandbox/sandboxApi.tsindex cae217b64..d94d90ca1 100644--- a/packages/js-sdk/src/sandbox/sandboxApi.ts+++ b/packages/js-sdk/src/sandbox/sandboxApi.ts@@ -5,6 +5,7 @@ import {DEFAULT_SANDBOX_TIMEOUT_MS,} from '../connectionConfig'import { compareVersions } from 'compare-versions'+import { ALL_TRAFFIC } from './network'import {InvalidArgumentError,SandboxNotFoundError,@@ -37,23 +38,118 @@ export type GitHubMcpServer = {}}+/**+ * Transform applied to egress requests matching a {@link SandboxNetworkRule}.+ */+export type SandboxNetworkTransform = {+ /**+ * Headers to inject into the outbound request. Values override any headers+ * already present on the request.+ */+ headers?: Record<string, string>+}++/**+ * Per-domain rule applied to egress requests.+ */+export type SandboxNetworkRule = {+ /**+ * Transform applied to requests matching this rule.+ */+ transform?: SandboxNetworkTransform+}++/**+ * Map of host (or CIDR / IP) to ordered list of rules applied to outbound+ * requests for that host. Accepts either a plain object or a `Map`.+ * Registering a host here does not allow egress on its own — the host must+ * also appear in {@link SandboxNetworkOpts.allowOut}.+ */+export type SandboxNetworkRules =+ | Record<string, SandboxNetworkRule[]>+ | Map<string, SandboxNetworkRule[]>++/**+ * Per-domain rule as returned by the sandbox info endpoint. Mirrors+ * {@link SandboxNetworkRule} but with `transform` always materialized to the+ * static {@link SandboxNetworkTransform} shape — no callback variant.+ */+export type SandboxNetworkRuleInfo = {+ transform?: SandboxNetworkTransform+}++/**+ * Context passed to {@link SandboxNetworkOpts.allowOut} and+ * {@link SandboxNetworkOpts.denyOut} when they are defined as functions.+ */+export type SandboxNetworkSelectorContext = {+ /** All traffic sentinel — equivalent to `'0.0.0.0/0'`. */+ allTraffic: string+ /** Rules registered in {@link SandboxNetworkOpts.rules}. */+ rules: Map<string, SandboxNetworkRule[]>+}++/**+ * Egress rule list, either a static array of CIDR blocks / IP addresses /+ * hostnames, or a callback that receives `{ allTraffic, rules }` and returns+ * the same.+ */+export type SandboxNetworkSelector =+ | string[]+ | ((ctx: SandboxNetworkSelectorContext) => string[])+export type SandboxNetworkOpts = {/*** Allow outbound traffic from the sandbox to the specified addresses.* If `allowOut` is not specified, all outbound traffic is allowed.*+ * Accepts either a static array of CIDR blocks, IP addresses, or hostnames,+ * or a callback that receives `{ allTraffic, rules }` and returns the same.+ * `allTraffic` is `'0.0.0.0/0'`; `rules` is a `Map` view of+ * {@link SandboxNetworkOpts.rules}.+ ** Examples:- * - To allow traffic to a specific addresses: `["1.1.1.1", "8.8.8.0/24"]`+ * - Static list: `["1.1.1.1", "8.8.8.0/24"]`+ * - Allow only rule-registered hosts:+ * `({ rules }) => [...rules.keys()]`*/- allowOut?: string[]+ allowOut?: SandboxNetworkSelector/*** Deny outbound traffic from the sandbox to the specified addresses.*+ * Accepts the same shapes as {@link allowOut}.+ ** Examples:- * - To deny traffic to a specific addresses: `["1.1.1.1", "8.8.8.0/24"]`+ * - Static list: `["1.1.1.1", "8.8.8.0/24"]`+ * - Block all egress: `({ allTraffic }) => [allTraffic]`*/- denyOut?: string[]+ denyOut?: SandboxNetworkSelector++ /**+ * Per-domain transform rules applied to matching egress HTTP/HTTPS+ * requests. Keys are domains (e.g. `"api.example.com"`); values are+ * ordered lists of rules.+ *+ * Registering a host here does not allow egress on its own — the host must+ * also appear in {@link allowOut}. Hosts registered here are exposed to the+ * `allowOut`/`denyOut` callbacks via `rules`.+ *+ * @example+ * ```ts+ * await Sandbox.create({+ * network: {+ * allowOut: ({ rules }) => [...rules.keys()],+ * rules: {+ * 'api.openai.com': [+ * { transform: { headers: { Authorization: `Bearer ${token}` } } },+ * ],+ * },+ * },+ * })+ * ```+ */+ rules?: SandboxNetworkRules/*** Specify if the sandbox URLs should be accessible only with authentication.@@ -69,6 +165,19 @@ export type SandboxNetworkOpts = {maskRequestHost?: string}+/**+ * Network configuration as returned by the sandbox info endpoint. Mirrors+ * {@link SandboxNetworkOpts} but with `allowOut`/`denyOut` always materialized+ * to plain string arrays.+ */+export type SandboxNetworkInfo = {+ allowOut?: string[]+ denyOut?: string[]+ rules?: Record<string, SandboxNetworkRuleInfo[]>+ allowPublicTraffic?: boolean+ maskRequestHost?: string+}+export type SandboxLifecycle = {/*** Action to take when sandbox timeout is reached.@@ -360,7 +469,7 @@ export interface SandboxInfo {/*** Sandbox network configuration.*/- network?: SandboxNetworkOpts+ network?: SandboxNetworkInfo/*** Sandbox lifecycle configuration.@@ -413,6 +522,62 @@ export interface SandboxMetrics {diskTotal: number}+function resolveNetworkSelector(+ selector: SandboxNetworkSelector | undefined,+ rules: Map<string, SandboxNetworkRule[]>+): string[] | undefined {+ if (selector === undefined) {+ return undefined+ }++ if (typeof selector === 'function') {+ return selector({ allTraffic: ALL_TRAFFIC, rules })+ }++ return selector+}++function resolveRulesForBody(+ rules: Map<string, SandboxNetworkRule[]>+): Record<string, { transform?: SandboxNetworkTransform }[]> {+ const out: Record<string, { transform?: SandboxNetworkTransform }[]> = {}+ for (const [host, hostRules] of rules) {+ out[host] = hostRules.map((rule) =>+ rule.transform === undefined ? {} : { transform: rule.transform }+ )+ }+ return out+}++function buildNetworkBody(+ network: SandboxNetworkOpts | undefined+): components['schemas']['SandboxNetworkConfig'] | undefined {+ if (!network) {+ return undefined+ }++ const rules =+ network.rules instanceof Map+ ? network.rules+ : new Map(Object.entries(network.rules ?? {}))+ const allowOut = resolveNetworkSelector(network.allowOut, rules)+ const denyOut = resolveNetworkSelector(network.denyOut, rules)++ return {+ ...(allowOut !== undefined ? { allowOut } : {}),+ ...(denyOut !== undefined ? { denyOut } : {}),+ ...(network.rules !== undefined+ ? { rules: resolveRulesForBody(rules) }+ : {}),+ ...(network.allowPublicTraffic !== undefined+ ? { allowPublicTraffic: network.allowPublicTraffic }+ : {}),+ ...(network.maskRequestHost !== undefined+ ? { maskRequestHost: network.maskRequestHost }+ : {}),+ }+}+export class SandboxApi {protected constructor() {}@@ -605,6 +770,7 @@ export class SandboxApi {? {allowOut: res.data.network.allowOut,denyOut: res.data.network.denyOut,+ rules: res.data.network.rules ?? undefined,allowPublicTraffic: res.data.network.allowPublicTraffic,maskRequestHost: res.data.network.maskRequestHost,}@@ -786,7 +952,7 @@ export class SandboxApi {timeout: timeoutToSeconds(timeoutMs),secure: opts?.secure ?? true,allow_internet_access: opts?.allowInternetAccess ?? true,- network: opts?.network,+ network: buildNetworkBody(opts?.network),autoPause: onTimeout === 'pause',autoResume: { enabled: autoResume },}diff --git a/packages/js-sdk/tests/sandbox/network.test.ts b/packages/js-sdk/tests/sandbox/network.test.tsindex b6d2ebe23..7388d9804 100644--- a/packages/js-sdk/tests/sandbox/network.test.ts+++ b/packages/js-sdk/tests/sandbox/network.test.ts@@ -1,13 +1,13 @@import { assert, expect, describe } from 'vitest'-import { CommandExitError, ALL_TRAFFIC } from '../../src'+import { CommandExitError } from '../../src'import { sandboxTest, isDebug } from '../setup.js'describe('allow only 1.1.1.1', () => {sandboxTest.scoped({sandboxOpts: {network: {- denyOut: [ALL_TRAFFIC],+ denyOut: ({ allTraffic }) => [allTraffic],allowOut: ['1.1.1.1'],},},@@ -62,17 +62,17 @@ describe('deny specific IP address', () => {)})-describe('deny all traffic using allTraffic helper', () => {+describe('deny all traffic using allTraffic selector', () => {sandboxTest.scoped({sandboxOpts: {network: {- denyOut: [ALL_TRAFFIC],+ denyOut: ({ allTraffic }) => [allTraffic],},},})sandboxTest.skipIf(isDebug)(- 'deny all traffic using allTraffic helper',+ 'deny all traffic using allTraffic selector',async ({ sandbox }) => {// Test that all traffic is deniedawait expect(@@ -94,7 +94,7 @@ describe('allow takes precedence over deny', () => {sandboxTest.scoped({sandboxOpts: {network: {- denyOut: [ALL_TRAFFIC],+ denyOut: ({ allTraffic }) => [allTraffic],allowOut: ['1.1.1.1', '8.8.8.8'],},},@@ -193,6 +193,49 @@ describe('allowPublicTraffic=true', () => {)})+describe('firewall transform injects headers', () => {+ const injectedHeader = 'X-E2B-Test-Token'+ const injectedValue = 'e2b-transform-value-123'++ sandboxTest.scoped({+ sandboxOpts: {+ network: {+ rules: {+ 'httpbin.e2b.team': [+ {+ transform: {+ headers: {+ [injectedHeader]: injectedValue,+ },+ },+ },+ ],+ },+ },+ },+ })++ sandboxTest.skipIf(isDebug)(+ 'injected header is reflected by httpbin.e2b.team/headers',+ async ({ sandbox }) => {+ const result = await sandbox.commands.run(+ 'curl -sS --max-time 10 https://httpbin.e2b.team/headers'+ )+ assert.equal(result.exitCode, 0)++ const parsed = JSON.parse(result.stdout) as {+ headers: Record<string, string>+ }+ const reflected = parsed.headers[injectedHeader]+ assert.equal(+ reflected,+ injectedValue,+ `expected httpbin to reflect ${injectedHeader}=${injectedValue}, got headers: ${JSON.stringify(parsed.headers)}`+ )+ }+ )+})+describe('maskRequestHost option', () => {sandboxTest.scoped({sandboxOpts: {diff --git a/packages/python-sdk/e2b/__init__.py b/packages/python-sdk/e2b/__init__.pyindex e43f621e4..0b8dc71c9 100644--- a/packages/python-sdk/e2b/__init__.py+++ b/packages/python-sdk/e2b/__init__.py@@ -79,7 +79,14 @@ from .sandbox.sandbox_api import (SandboxInfoLifecycle,SandboxMetrics,SandboxLifecycle,+ SandboxNetworkInfo,SandboxNetworkOpts,+ SandboxNetworkRule,+ SandboxNetworkRuleInfo,+ SandboxNetworkRules,+ SandboxNetworkSelector,+ SandboxNetworkSelectorContext,+ SandboxNetworkTransform,SandboxQuery,SandboxState,SnapshotInfo,@@ -183,6 +190,13 @@ __all__ = ["FileType",# Network"SandboxNetworkOpts",+ "SandboxNetworkInfo",+ "SandboxNetworkSelector",+ "SandboxNetworkSelectorContext",+ "SandboxNetworkRule",+ "SandboxNetworkRuleInfo",+ "SandboxNetworkRules",+ "SandboxNetworkTransform","SandboxLifecycle","ALL_TRAFFIC",# Snapshotdiff --git a/packages/python-sdk/e2b/api/client/api/sandboxes/put_sandboxes_sandbox_id_network.py b/packages/python-sdk/e2b/api/client/api/sandboxes/put_sandboxes_sandbox_id_network.pynew file mode 100644index 000000000..cf6be790d--- /dev/null+++ b/packages/python-sdk/e2b/api/client/api/sandboxes/put_sandboxes_sandbox_id_network.py@@ -0,0 +1,193 @@+from http import HTTPStatus+from typing import Any, Optional, Union, cast++import httpx++from ... import errors+from ...client import AuthenticatedClient, Client+from ...models.error import Error+from ...models.put_sandboxes_sandbox_id_network_body import (+ PutSandboxesSandboxIDNetworkBody,+)+from ...types import Response+++def _get_kwargs(+ sandbox_id: str,+ *,+ body: PutSandboxesSandboxIDNetworkBody,+) -> dict[str, Any]:+ headers: dict[str, Any] = {}++ _kwargs: dict[str, Any] = {+ "method": "put",+ "url": f"/sandboxes/{sandbox_id}/network",+ }++ _kwargs["json"] = body.to_dict()++ headers["Content-Type"] = "application/json"++ _kwargs["headers"] = headers+ return _kwargs+++def _parse_response(+ *, client: Union[AuthenticatedClient, Client], response: httpx.Response+) -> Optional[Union[Any, Error]]:+ if response.status_code == 204:+ response_204 = cast(Any, None)+ return response_204+ if response.status_code == 401:+ response_401 = Error.from_dict(response.json())++ return response_401+ if response.status_code == 404:+ response_404 = Error.from_dict(response.json())++ return response_404+ if response.status_code == 409:+ response_409 = Error.from_dict(response.json())++ return response_409+ if response.status_code == 500:+ response_500 = Error.from_dict(response.json())++ return response_500+ if client.raise_on_unexpected_status:+ raise errors.UnexpectedStatus(response.status_code, response.content)+ else:+ return None+++def _build_response(+ *, client: Union[AuthenticatedClient, Client], response: httpx.Response+) -> Response[Union[Any, Error]]:+ return Response(+ status_code=HTTPStatus(response.status_code),+ content=response.content,+ headers=response.headers,+ parsed=_parse_response(client=client, response=response),+ )+++def sync_detailed(+ sandbox_id: str,+ *,+ client: AuthenticatedClient,+ body: PutSandboxesSandboxIDNetworkBody,+) -> Response[Union[Any, Error]]:+ """Update the network configuration for a running sandbox. Replaces the current egress rules with the+ provided configuration. Omitting both fields clears all egress rules.++ Args:+ sandbox_id (str):+ body (PutSandboxesSandboxIDNetworkBody):++ Raises:+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.+ httpx.TimeoutException: If the request takes longer than Client.timeout.++ Returns:+ Response[Union[Any, Error]]+ """++ kwargs = _get_kwargs(+ sandbox_id=sandbox_id,+ body=body,+ )++ response = client.get_httpx_client().request(+ **kwargs,+ )++ return _build_response(client=client, response=response)+++def sync(+ sandbox_id: str,+ *,+ client: AuthenticatedClient,+ body: PutSandboxesSandboxIDNetworkBody,+) -> Optional[Union[Any, Error]]:+ """Update the network configuration for a running sandbox. Replaces the current egress rules with the+ provided configuration. Omitting both fields clears all egress rules.++ Args:+ sandbox_id (str):+ body (PutSandboxesSandboxIDNetworkBody):++ Raises:+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.+ httpx.TimeoutException: If the request takes longer than Client.timeout.++ Returns:+ Union[Any, Error]+ """++ return sync_detailed(+ sandbox_id=sandbox_id,+ client=client,+ body=body,+ ).parsed+++async def asyncio_detailed(+ sandbox_id: str,+ *,+ client: AuthenticatedClient,+ body: PutSandboxesSandboxIDNetworkBody,+) -> Response[Union[Any, Error]]:+ """Update the network configuration for a running sandbox. Replaces the current egress rules with the+ provided configuration. Omitting both fields clears all egress rules.++ Args:+ sandbox_id (str):+ body (PutSandboxesSandboxIDNetworkBody):++ Raises:+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.+ httpx.TimeoutException: If the request takes longer than Client.timeout.++ Returns:+ Response[Union[Any, Error]]+ """++ kwargs = _get_kwargs(+ sandbox_id=sandbox_id,+ body=body,+ )++ response = await client.get_async_httpx_client().request(**kwargs)++ return _build_response(client=client, response=response)+++async def asyncio(+ sandbox_id: str,+ *,+ client: AuthenticatedClient,+ body: PutSandboxesSandboxIDNetworkBody,+) -> Optional[Union[Any, Error]]:+ """Update the network configuration for a running sandbox. Replaces the current egress rules with the+ provided configuration. Omitting both fields clears all egress rules.++ Args:+ sandbox_id (str):+ body (PutSandboxesSandboxIDNetworkBody):++ Raises:+ errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.+ httpx.TimeoutException: If the request takes longer than Client.timeout.++ Returns:+ Union[Any, Error]+ """++ return (+ await asyncio_detailed(+ sandbox_id=sandbox_id,+ client=client,+ body=body,+ )+ ).parseddiff --git a/packages/python-sdk/e2b/api/client/models/__init__.py b/packages/python-sdk/e2b/api/client/models/__init__.pyindex fb263334f..365bfe9a2 100644--- a/packages/python-sdk/e2b/api/client/models/__init__.py+++ b/packages/python-sdk/e2b/api/client/models/__init__.py@@ -42,6 +42,10 @@ from .post_sandboxes_sandbox_id_snapshots_body import (PostSandboxesSandboxIDSnapshotsBody,)from .post_sandboxes_sandbox_id_timeout_body import PostSandboxesSandboxIDTimeoutBody+from .put_sandboxes_sandbox_id_network_body import PutSandboxesSandboxIDNetworkBody+from .put_sandboxes_sandbox_id_network_body_rules import (+ PutSandboxesSandboxIDNetworkBodyRules,+)from .resumed_sandbox import ResumedSandboxfrom .sandbox import Sandboxfrom .sandbox_auto_resume_config import SandboxAutoResumeConfig@@ -54,6 +58,10 @@ from .sandbox_logs import SandboxLogsfrom .sandbox_logs_v2_response import SandboxLogsV2Responsefrom .sandbox_metric import SandboxMetricfrom .sandbox_network_config import SandboxNetworkConfig+from .sandbox_network_config_rules import SandboxNetworkConfigRules+from .sandbox_network_rule import SandboxNetworkRule+from .sandbox_network_transform import SandboxNetworkTransform+from .sandbox_network_transform_headers import SandboxNetworkTransformHeadersfrom .sandbox_on_timeout import SandboxOnTimeoutfrom .sandbox_state import SandboxStatefrom .sandbox_volume_mount import SandboxVolumeMount@@ -125,6 +133,8 @@ __all__ = ("PostSandboxesSandboxIDRefreshesBody","PostSandboxesSandboxIDSnapshotsBody","PostSandboxesSandboxIDTimeoutBody",+ "PutSandboxesSandboxIDNetworkBody",+ "PutSandboxesSandboxIDNetworkBodyRules","ResumedSandbox","Sandbox","SandboxAutoResumeConfig",@@ -138,6 +148,10 @@ __all__ = ("SandboxLogsV2Response","SandboxMetric","SandboxNetworkConfig",+ "SandboxNetworkConfigRules",+ "SandboxNetworkRule",+ "SandboxNetworkTransform",+ "SandboxNetworkTransformHeaders","SandboxOnTimeout","SandboxState","SandboxVolumeMount",diff --git a/packages/python-sdk/e2b/api/client/models/put_sandboxes_sandbox_id_network_body.py b/packages/python-sdk/e2b/api/client/models/put_sandboxes_sandbox_id_network_body.pynew file mode 100644index 000000000..c37a89368--- /dev/null+++ b/packages/python-sdk/e2b/api/client/models/put_sandboxes_sandbox_id_network_body.py@@ -0,0 +1,112 @@+from collections.abc import Mapping+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast++from attrs import define as _attrs_define+from attrs import field as _attrs_field++from ..types import UNSET, Unset++if TYPE_CHECKING:+ from ..models.put_sandboxes_sandbox_id_network_body_rules import (+ PutSandboxesSandboxIDNetworkBodyRules,+ )+++T = TypeVar("T", bound="PutSandboxesSandboxIDNetworkBody")+++@_attrs_define+class PutSandboxesSandboxIDNetworkBody:+ """+ Attributes:+ allow_out (Union[Unset, list[str]]): List of allowed destinations for egress traffic. Each entry can be a CIDR+ block (e.g. "8.8.8.8/32"), a bare IP address (e.g. "8.8.8.8"), or a domain name (e.g. "example.com",+ "*.example.com"). Allowed entries always take precedence over denied entries.+ allow_internet_access (Union[Unset, bool]): Allow sandbox to access the internet. When set to false, it behaves+ the same as specifying denyOut to 0.0.0.0/0 in the network config.+ deny_out (Union[Unset, list[str]]): List of denied CIDR blocks or IP addresses for egress traffic. Domain names+ are not supported for deny rules.+ rules (Union[Unset, PutSandboxesSandboxIDNetworkBodyRules]): Per-domain transform rules. Replaces all existing+ rules when provided.+ """++ allow_out: Union[Unset, list[str]] = UNSET+ allow_internet_access: Union[Unset, bool] = UNSET+ deny_out: Union[Unset, list[str]] = UNSET+ rules: Union[Unset, "PutSandboxesSandboxIDNetworkBodyRules"] = UNSET+ additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)++ def to_dict(self) -> dict[str, Any]:+ allow_out: Union[Unset, list[str]] = UNSET+ if not isinstance(self.allow_out, Unset):+ allow_out = self.allow_out++ allow_internet_access = self.allow_internet_access++ deny_out: Union[Unset, list[str]] = UNSET+ if not isinstance(self.deny_out, Unset):+ deny_out = self.deny_out++ rules: Union[Unset, dict[str, Any]] = UNSET+ if not isinstance(self.rules, Unset):+ rules = self.rules.to_dict()++ field_dict: dict[str, Any] = {}+ field_dict.update(self.additional_properties)+ field_dict.update({})+ if allow_out is not UNSET:+ field_dict["allowOut"] = allow_out+ if allow_internet_access is not UNSET:+ field_dict["allow_internet_access"] = allow_internet_access+ if deny_out is not UNSET:+ field_dict["denyOut"] = deny_out+ if rules is not UNSET:+ field_dict["rules"] = rules++ return field_dict++ @classmethod+ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:+ from ..models.put_sandboxes_sandbox_id_network_body_rules import (+ PutSandboxesSandboxIDNetworkBodyRules,+ )++ d = dict(src_dict)+ allow_out = cast(list[str], d.pop("allowOut", UNSET))++ allow_internet_access = d.pop("allow_internet_access", UNSET)++ deny_out = cast(list[str], d.pop("denyOut", UNSET))++ _rules = d.pop("rules", UNSET)+ rules: Union[Unset, PutSandboxesSandboxIDNetworkBodyRules]+ if isinstance(_rules, Unset):+ rules = UNSET+ else:+ rules = PutSandboxesSandboxIDNetworkBodyRules.from_dict(_rules)++ put_sandboxes_sandbox_id_network_body = cls(+ allow_out=allow_out,+ allow_internet_access=allow_internet_access,+ deny_out=deny_out,+ rules=rules,+ )++ put_sandboxes_sandbox_id_network_body.additional_properties = d+ return put_sandboxes_sandbox_id_network_body++ @property+ def additional_keys(self) -> list[str]:+ return list(self.additional_properties.keys())++ def __getitem__(self, key: str) -> Any:+ return self.additional_properties[key]++ def __setitem__(self, key: str, value: Any) -> None:+ self.additional_properties[key] = value++ def __delitem__(self, key: str) -> None:+ del self.additional_properties[key]++ def __contains__(self, key: str) -> bool:+ return key in self.additional_propertiesdiff --git a/packages/python-sdk/e2b/api/client/models/put_sandboxes_sandbox_id_network_body_rules.py b/packages/python-sdk/e2b/api/client/models/put_sandboxes_sandbox_id_network_body_rules.pynew file mode 100644index 000000000..1af75b3cb--- /dev/null+++ b/packages/python-sdk/e2b/api/client/models/put_sandboxes_sandbox_id_network_body_rules.py@@ -0,0 +1,71 @@+from collections.abc import Mapping+from typing import TYPE_CHECKING, Any, TypeVar++from attrs import define as _attrs_define+from attrs import field as _attrs_field++if TYPE_CHECKING:+ from ..models.sandbox_network_rule import SandboxNetworkRule+++T = TypeVar("T", bound="PutSandboxesSandboxIDNetworkBodyRules")+++@_attrs_define+class PutSandboxesSandboxIDNetworkBodyRules:+ """Per-domain transform rules. Replaces all existing rules when provided."""++ additional_properties: dict[str, list["SandboxNetworkRule"]] = _attrs_field(+ init=False, factory=dict+ )++ def to_dict(self) -> dict[str, Any]:+ field_dict: dict[str, Any] = {}+ for prop_name, prop in self.additional_properties.items():+ field_dict[prop_name] = []+ for additional_property_item_data in prop:+ additional_property_item = additional_property_item_data.to_dict()+ field_dict[prop_name].append(additional_property_item)++ return field_dict++ @classmethod+ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:+ from ..models.sandbox_network_rule import SandboxNetworkRule++ d = dict(src_dict)+ put_sandboxes_sandbox_id_network_body_rules = cls()++ additional_properties = {}+ for prop_name, prop_dict in d.items():+ additional_property = []+ _additional_property = prop_dict+ for additional_property_item_data in _additional_property:+ additional_property_item = SandboxNetworkRule.from_dict(+ additional_property_item_data+ )++ additional_property.append(additional_property_item)++ additional_properties[prop_name] = additional_property++ put_sandboxes_sandbox_id_network_body_rules.additional_properties = (+ additional_properties+ )+ return put_sandboxes_sandbox_id_network_body_rules++ @property+ def additional_keys(self) -> list[str]:+ return list(self.additional_properties.keys())++ def __getitem__(self, key: str) -> list["SandboxNetworkRule"]:+ return self.additional_properties[key]++ def __setitem__(self, key: str, value: list["SandboxNetworkRule"]) -> None:+ self.additional_properties[key] = value++ def __delitem__(self, key: str) -> None:+ del self.additional_properties[key]++ def __contains__(self, key: str) -> bool:+ return key in self.additional_propertiesdiff --git a/packages/python-sdk/e2b/api/client/models/sandbox_network_config.py b/packages/python-sdk/e2b/api/client/models/sandbox_network_config.pyindex 08284c792..c7a99c127 100644--- a/packages/python-sdk/e2b/api/client/models/sandbox_network_config.py+++ b/packages/python-sdk/e2b/api/client/models/sandbox_network_config.py@@ -1,11 +1,15 @@from collections.abc import Mapping-from typing import Any, TypeVar, Union, cast+from typing import TYPE_CHECKING, Any, TypeVar, Union, castfrom attrs import define as _attrs_definefrom attrs import field as _attrs_fieldfrom ..types import UNSET, Unset+if TYPE_CHECKING:+ from ..models.sandbox_network_config_rules import SandboxNetworkConfigRules++T = TypeVar("T", bound="SandboxNetworkConfig")@@ -13,18 +17,24 @@ T = TypeVar("T", bound="SandboxNetworkConfig")class SandboxNetworkConfig:"""Attributes:- allow_out (Union[Unset, list[str]]): List of allowed CIDR blocks or IP addresses for egress traffic. Allowed- addresses always take precedence over blocked addresses.+ allow_out (Union[Unset, list[str]]): List of allowed destinations for egress traffic. Each entry can be a CIDR+ block (e.g. "8.8.8.8/32"), a bare IP address (e.g. "8.8.8.8"), or a domain name (e.g. "example.com",+ "*.example.com"). Allowed entries always take precedence over denied entries.allow_public_traffic (Union[Unset, bool]): Specify if the sandbox URLs should be accessible only withauthentication. Default: True.- deny_out (Union[Unset, list[str]]): List of denied CIDR blocks or IP addresses for egress traffic+ deny_out (Union[Unset, list[str]]): List of denied CIDR blocks or IP addresses for egress traffic. Domain names+ are not supported for deny rules.mask_request_host (Union[Unset, str]): Specify host mask which will be used for all sandbox requests+ rules (Union[Unset, SandboxNetworkConfigRules]): Per-domain transform rules applied to matching egress+ HTTP/HTTPS requests. Keys are domains (e.g. "api.example.com", "example.com"). A domain listed here is not+ automatically allowed - use allowOut to permit the traffic."""allow_out: Union[Unset, list[str]] = UNSETallow_public_traffic: Union[Unset, bool] = Truedeny_out: Union[Unset, list[str]] = UNSETmask_request_host: Union[Unset, str] = UNSET+ rules: Union[Unset, "SandboxNetworkConfigRules"] = UNSETadditional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)def to_dict(self) -> dict[str, Any]:@@ -40,6 +50,10 @@ class SandboxNetworkConfig:mask_request_host = self.mask_request_host+ rules: Union[Unset, dict[str, Any]] = UNSET+ if not isinstance(self.rules, Unset):+ rules = self.rules.to_dict()+field_dict: dict[str, Any] = {}field_dict.update(self.additional_properties)field_dict.update({})@@ -51,11 +65,15 @@ class SandboxNetworkConfig:field_dict["denyOut"] = deny_outif mask_request_host is not UNSET:field_dict["maskRequestHost"] = mask_request_host+ if rules is not UNSET:+ field_dict["rules"] = rulesreturn field_dict@classmethoddef from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:+ from ..models.sandbox_network_config_rules import SandboxNetworkConfigRules+d = dict(src_dict)allow_out = cast(list[str], d.pop("allowOut", UNSET))@@ -65,11 +83,19 @@ class SandboxNetworkConfig:mask_request_host = d.pop("maskRequestHost", UNSET)+ _rules = d.pop("rules", UNSET)+ rules: Union[Unset, SandboxNetworkConfigRules]+ if isinstance(_rules, Unset):+ rules = UNSET+ else:+ rules = SandboxNetworkConfigRules.from_dict(_rules)+sandbox_network_config = cls(allow_out=allow_out,allow_public_traffic=allow_public_traffic,deny_out=deny_out,mask_request_host=mask_request_host,+ rules=rules,)sandbox_network_config.additional_properties = ddiff --git a/packages/python-sdk/e2b/api/client/models/sandbox_network_config_rules.py b/packages/python-sdk/e2b/api/client/models/sandbox_network_config_rules.pynew file mode 100644index 000000000..aeece3851--- /dev/null+++ b/packages/python-sdk/e2b/api/client/models/sandbox_network_config_rules.py@@ -0,0 +1,72 @@+from collections.abc import Mapping+from typing import TYPE_CHECKING, Any, TypeVar++from attrs import define as _attrs_define+from attrs import field as _attrs_field++if TYPE_CHECKING:+ from ..models.sandbox_network_rule import SandboxNetworkRule+++T = TypeVar("T", bound="SandboxNetworkConfigRules")+++@_attrs_define+class SandboxNetworkConfigRules:+ """Per-domain transform rules applied to matching egress HTTP/HTTPS requests. Keys are domains (e.g. "api.example.com",+ "example.com"). A domain listed here is not automatically allowed - use allowOut to permit the traffic.++ """++ additional_properties: dict[str, list["SandboxNetworkRule"]] = _attrs_field(+ init=False, factory=dict+ )++ def to_dict(self) -> dict[str, Any]:+ field_dict: dict[str, Any] = {}+ for prop_name, prop in self.additional_properties.items():+ field_dict[prop_name] = []+ for additional_property_item_data in prop:+ additional_property_item = additional_property_item_data.to_dict()+ field_dict[prop_name].append(additional_property_item)++ return field_dict++ @classmethod+ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:+ from ..models.sandbox_network_rule import SandboxNetworkRule++ d = dict(src_dict)+ sandbox_network_config_rules = cls()++ additional_properties = {}+ for prop_name, prop_dict in d.items():+ additional_property = []+ _additional_property = prop_dict+ for additional_property_item_data in _additional_property:+ additional_property_item = SandboxNetworkRule.from_dict(+ additional_property_item_data+ )++ additional_property.append(additional_property_item)++ additional_properties[prop_name] = additional_property++ sandbox_network_config_rules.additional_properties = additional_properties+ return sandbox_network_config_rules++ @property+ def additional_keys(self) -> list[str]:+ return list(self.additional_properties.keys())++ def __getitem__(self, key: str) -> list["SandboxNetworkRule"]:+ return self.additional_properties[key]++ def __setitem__(self, key: str, value: list["SandboxNetworkRule"]) -> None:+ self.additional_properties[key] = value++ def __delitem__(self, key: str) -> None:+ del self.additional_properties[key]++ def __contains__(self, key: str) -> bool:+ return key in self.additional_propertiesdiff --git a/packages/python-sdk/e2b/api/client/models/sandbox_network_rule.py b/packages/python-sdk/e2b/api/client/models/sandbox_network_rule.pynew file mode 100644index 000000000..f1d0a306e--- /dev/null+++ b/packages/python-sdk/e2b/api/client/models/sandbox_network_rule.py@@ -0,0 +1,74 @@+from collections.abc import Mapping+from typing import TYPE_CHECKING, Any, TypeVar, Union++from attrs import define as _attrs_define+from attrs import field as _attrs_field++from ..types import UNSET, Unset++if TYPE_CHECKING:+ from ..models.sandbox_network_transform import SandboxNetworkTransform+++T = TypeVar("T", bound="SandboxNetworkRule")+++@_attrs_define+class SandboxNetworkRule:+ """Transform rule applied to egress requests matching a domain pattern.++ Attributes:+ transform (Union[Unset, SandboxNetworkTransform]): Transformations applied to matching egress requests before+ forwarding.+ """++ transform: Union[Unset, "SandboxNetworkTransform"] = UNSET+ additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)++ def to_dict(self) -> dict[str, Any]:+ transform: Union[Unset, dict[str, Any]] = UNSET+ if not isinstance(self.transform, Unset):+ transform = self.transform.to_dict()++ field_dict: dict[str, Any] = {}+ field_dict.update(self.additional_properties)+ field_dict.update({})+ if transform is not UNSET:+ field_dict["transform"] = transform++ return field_dict++ @classmethod+ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:+ from ..models.sandbox_network_transform import SandboxNetworkTransform++ d = dict(src_dict)+ _transform = d.pop("transform", UNSET)+ transform: Union[Unset, SandboxNetworkTransform]+ if isinstance(_transform, Unset):+ transform = UNSET+ else:+ transform = SandboxNetworkTransform.from_dict(_transform)++ sandbox_network_rule = cls(+ transform=transform,+ )++ sandbox_network_rule.additional_properties = d+ return sandbox_network_rule++ @property+ def additional_keys(self) -> list[str]:+ return list(self.additional_properties.keys())++ def __getitem__(self, key: str) -> Any:+ return self.additional_properties[key]++ def __setitem__(self, key: str, value: Any) -> None:+ self.additional_properties[key] = value++ def __delitem__(self, key: str) -> None:+ del self.additional_properties[key]++ def __contains__(self, key: str) -> bool:+ return key in self.additional_propertiesdiff --git a/packages/python-sdk/e2b/api/client/models/sandbox_network_transform.py b/packages/python-sdk/e2b/api/client/models/sandbox_network_transform.pynew file mode 100644index 000000000..d754240c6--- /dev/null+++ b/packages/python-sdk/e2b/api/client/models/sandbox_network_transform.py@@ -0,0 +1,79 @@+from collections.abc import Mapping+from typing import TYPE_CHECKING, Any, TypeVar, Union++from attrs import define as _attrs_define+from attrs import field as _attrs_field++from ..types import UNSET, Unset++if TYPE_CHECKING:+ from ..models.sandbox_network_transform_headers import (+ SandboxNetworkTransformHeaders,+ )+++T = TypeVar("T", bound="SandboxNetworkTransform")+++@_attrs_define+class SandboxNetworkTransform:+ """Transformations applied to matching egress requests before forwarding.++ Attributes:+ headers (Union[Unset, SandboxNetworkTransformHeaders]): HTTP headers to inject or override in matching requests.+ An existing header with the same name is replaced. Values are plain strings; secret resolution happens client-+ side before sending to the API.+ """++ headers: Union[Unset, "SandboxNetworkTransformHeaders"] = UNSET+ additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)++ def to_dict(self) -> dict[str, Any]:+ headers: Union[Unset, dict[str, Any]] = UNSET+ if not isinstance(self.headers, Unset):+ headers = self.headers.to_dict()++ field_dict: dict[str, Any] = {}+ field_dict.update(self.additional_properties)+ field_dict.update({})+ if headers is not UNSET:+ field_dict["headers"] = headers++ return field_dict++ @classmethod+ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:+ from ..models.sandbox_network_transform_headers import (+ SandboxNetworkTransformHeaders,+ )++ d = dict(src_dict)+ _headers = d.pop("headers", UNSET)+ headers: Union[Unset, SandboxNetworkTransformHeaders]+ if isinstance(_headers, Unset):+ headers = UNSET+ else:+ headers = SandboxNetworkTransformHeaders.from_dict(_headers)++ sandbox_network_transform = cls(+ headers=headers,+ )++ sandbox_network_transform.additional_properties = d+ return sandbox_network_transform++ @property+ def additional_keys(self) -> list[str]:+ return list(self.additional_properties.keys())++ def __getitem__(self, key: str) -> Any:+ return self.additional_properties[key]++ def __setitem__(self, key: str, value: Any) -> None:+ self.additional_properties[key] = value++ def __delitem__(self, key: str) -> None:+ del self.additional_properties[key]++ def __contains__(self, key: str) -> bool:+ return key in self.additional_propertiesdiff --git a/packages/python-sdk/e2b/api/client/models/sandbox_network_transform_headers.py b/packages/python-sdk/e2b/api/client/models/sandbox_network_transform_headers.pynew file mode 100644index 000000000..c2d7c1aaa--- /dev/null+++ b/packages/python-sdk/e2b/api/client/models/sandbox_network_transform_headers.py@@ -0,0 +1,47 @@+from collections.abc import Mapping+from typing import Any, TypeVar++from attrs import define as _attrs_define+from attrs import field as _attrs_field++T = TypeVar("T", bound="SandboxNetworkTransformHeaders")+++@_attrs_define+class SandboxNetworkTransformHeaders:+ """HTTP headers to inject or override in matching requests. An existing header with the same name is replaced. Values+ are plain strings; secret resolution happens client-side before sending to the API.++ """++ additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)++ def to_dict(self) -> dict[str, Any]:+ field_dict: dict[str, Any] = {}+ field_dict.update(self.additional_properties)++ return field_dict++ @classmethod+ def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:+ d = dict(src_dict)+ sandbox_network_transform_headers = cls()++ sandbox_network_transform_headers.additional_properties = d+ return sandbox_network_transform_headers++ @property+ def additional_keys(self) -> list[str]:+ return list(self.additional_properties.keys())++ def __getitem__(self, key: str) -> str:+ return self.additional_properties[key]++ def __setitem__(self, key: str, value: str) -> None:+ self.additional_properties[key] = value++ def __delitem__(self, key: str) -> None:+ del self.additional_properties[key]++ def __contains__(self, key: str) -> bool:+ return key in self.additional_propertiesdiff --git a/packages/python-sdk/e2b/sandbox/sandbox_api.py b/packages/python-sdk/e2b/sandbox/sandbox_api.pyindex c3a07afc1..32f9889ff 100644--- a/packages/python-sdk/e2b/sandbox/sandbox_api.py+++ b/packages/python-sdk/e2b/sandbox/sandbox_api.py@@ -1,6 +1,17 @@from dataclasses import dataclass, fieldfrom datetime import datetime-from typing import Any, Dict, List, Literal, Optional, TypedDict, Union, cast+from typing import (+ Any,+ Callable,+ Dict,+ List,+ Literal,+ Mapping,+ Optional,+ TypedDict,+ Union,+ cast,+)from typing_extensions import NotRequired, Unpack@@ -15,9 +26,22 @@ from e2b.api.client.models import (from e2b.api.client.models import (SandboxNetworkConfig as ClientSandboxNetworkConfig,)+from e2b.api.client.models import (+ SandboxNetworkConfigRules,+)+from e2b.api.client.models import (+ SandboxNetworkRule as ClientSandboxNetworkRule,+)+from e2b.api.client.models import (+ SandboxNetworkTransform as ClientSandboxNetworkTransform,+)+from e2b.api.client.models import (+ SandboxNetworkTransformHeaders as ClientSandboxNetworkTransformHeaders,+)from e2b.api.client.types import Unsetfrom e2b.connection_config import ApiParamsfrom e2b.sandbox.mcp import McpServer as BaseMcpServer+from e2b.sandbox.network import ALL_TRAFFICclass GitHubMcpServerConfig(TypedDict):@@ -48,26 +72,112 @@ GitHubMcpServer = Dict[str, Union[GitHubMcpServerConfig, Any]]McpServer = Union[BaseMcpServer, GitHubMcpServer]+class SandboxNetworkTransform(TypedDict):+ """+ Transform applied to egress requests matching a :class:`SandboxNetworkRule`.+ """++ headers: NotRequired[Dict[str, str]]+ """+ Headers to inject into the outbound request. Values override any headers+ already present on the request.+ """+++class SandboxNetworkRule(TypedDict):+ """+ Per-domain rule applied to egress requests.+ """++ transform: NotRequired[SandboxNetworkTransform]+ """+ Transform applied to requests matching this rule.+ """+++SandboxNetworkRules = Dict[str, List[SandboxNetworkRule]]+"""+Map of host (or CIDR / IP) to ordered list of rules applied to outbound+requests for that host. Registering a host here does not allow egress on its+own — the host must also appear in ``SandboxNetworkOpts.allow_out``.+"""+++class SandboxNetworkRuleInfo(TypedDict):+ """+ Per-domain rule as returned by the sandbox info endpoint. Mirrors+ :class:`SandboxNetworkRule` but with ``transform`` always materialized to+ the static :class:`SandboxNetworkTransform` shape — no callable variant.+ """++ transform: NotRequired[SandboxNetworkTransform]+++@dataclass(frozen=True)+class SandboxNetworkSelectorContext:+ """+ Context passed to ``allow_out``/``deny_out`` callables.+ """++ all_traffic: str+ """All traffic sentinel — equivalent to ``"0.0.0.0/0"``."""++ rules: Mapping[str, List[SandboxNetworkRule]]+ """Rules registered in :attr:`SandboxNetworkOpts.rules`."""+++SandboxNetworkSelector = Union[+ List[str],+ Callable[[SandboxNetworkSelectorContext], List[str]],+]+"""+Egress rule list, either a static list of CIDR blocks / IP addresses /+hostnames, or a callable that receives a :class:`SandboxNetworkSelectorContext`+and returns the same.+"""++class SandboxNetworkOpts(TypedDict):"""Sandbox network configuration options."""- allow_out: NotRequired[List[str]]+ allow_out: NotRequired[SandboxNetworkSelector]"""Allow outbound traffic from the sandbox to the specified addresses.- If `allow_out` is not specified, all outbound traffic is allowed.+ If ``allow_out`` is not specified, all outbound traffic is allowed.++ Accepts either a static list of CIDR blocks / IP addresses / hostnames, or+ a callable that receives a :class:`SandboxNetworkSelectorContext` and+ returns the same. ``ctx.all_traffic`` is ``"0.0.0.0/0"``; ``ctx.rules`` is+ a read-only view of :attr:`rules`.Examples:- - To allow traffic to specific addresses: `["1.1.1.1", "8.8.8.0/24"]`+ - Static list: ``["1.1.1.1", "8.8.8.0/24"]``+ - Allow only rule-registered hosts:+ ``lambda ctx: list(ctx.rules.keys())``"""- deny_out: NotRequired[List[str]]+ deny_out: NotRequired[SandboxNetworkSelector]"""Deny outbound traffic from the sandbox to the specified addresses.+ Accepts the same shapes as ``allow_out``.+Examples:- - To deny traffic to specific addresses: `["1.1.1.1", "8.8.8.0/24"]`+ - Static list: ``["1.1.1.1", "8.8.8.0/24"]``+ - Block all egress: ``lambda ctx: [ctx.all_traffic]``+ """++ rules: NotRequired[SandboxNetworkRules]+ """+ Per-domain transform rules applied to matching egress HTTP/HTTPS+ requests. Keys are domains (e.g. ``"api.example.com"``); values are+ ordered lists of :class:`SandboxNetworkRule`.++ Registering a host here does not allow egress on its own — the host must+ also appear in ``allow_out``. Hosts registered here are exposed to the+ ``allow_out``/``deny_out`` callables via ``ctx.rules``."""allow_public_traffic: NotRequired[bool]@@ -86,6 +196,20 @@ class SandboxNetworkOpts(TypedDict):"""+class SandboxNetworkInfo(TypedDict, total=False):+ """+ Network configuration as returned by the sandbox info endpoint.+ Mirrors :class:`SandboxNetworkOpts` but with ``allow_out``/``deny_out``+ always materialized to plain string lists.+ """++ allow_out: List[str]+ deny_out: List[str]+ rules: Dict[str, List[SandboxNetworkRuleInfo]]+ allow_public_traffic: bool+ mask_request_host: str++class SandboxLifecycle(TypedDict):"""Sandbox lifecycle configuration; defines post-timeout behavior and auto-resume settings.@@ -120,18 +244,85 @@ class SandboxInfoLifecycle(TypedDict):"""+def _resolve_network_selector(+ selector: Optional[SandboxNetworkSelector],+ rules: Mapping[str, List[SandboxNetworkRule]],+) -> Optional[List[str]]:+ if selector is None:+ return None++ if callable(selector):+ ctx = SandboxNetworkSelectorContext(all_traffic=ALL_TRAFFIC, rules=rules)+ return list(selector(ctx))++ return list(selector)+++def _build_client_rules(rules: SandboxNetworkRules) -> SandboxNetworkConfigRules:+ client_rules = SandboxNetworkConfigRules()+ for host, host_rules in rules.items():+ converted: List[ClientSandboxNetworkRule] = []+ for rule in host_rules:+ transform = rule.get("transform")+ if transform is None:+ converted.append(ClientSandboxNetworkRule())+ continue++ client_transform = ClientSandboxNetworkTransform()+ headers = transform.get("headers")+ if headers:+ client_headers = ClientSandboxNetworkTransformHeaders()+ client_headers.additional_properties = dict(headers)+ client_transform.headers = client_headers++ converted.append(ClientSandboxNetworkRule(transform=client_transform))+ client_rules.additional_properties[host] = converted++ return client_rules+++def build_network_config(+ network: Optional[SandboxNetworkOpts],+) -> Optional[Dict[str, Any]]:+ """Resolve a :class:`SandboxNetworkOpts` into the dict the API expects."""+ if network is None:+ return None++ rules = network.get("rules") or {}+ allow_out = _resolve_network_selector(network.get("allow_out"), rules)+ deny_out = _resolve_network_selector(network.get("deny_out"), rules)++ body: Dict[str, Any] = {}+ if allow_out is not None:+ body["allow_out"] = allow_out+ if deny_out is not None:+ body["deny_out"] = deny_out+ if "rules" in network and network["rules"] is not None:+ body["rules"] = _build_client_rules(network["rules"])+ if "allow_public_traffic" in network:+ body["allow_public_traffic"] = network["allow_public_traffic"]+ if "mask_request_host" in network:+ body["mask_request_host"] = network["mask_request_host"]++ return body++def from_client_network_config(network: Union[Unset, ClientSandboxNetworkConfig],-) -> Optional[SandboxNetworkOpts]:+) -> Optional[SandboxNetworkInfo]:if isinstance(network, Unset):return None- result: SandboxNetworkOpts = {}+ result: SandboxNetworkInfo = {}if not isinstance(network.allow_out, Unset):result["allow_out"] = list(network.allow_out)if not isinstance(network.deny_out, Unset):result["deny_out"] = list(network.deny_out)+ if not isinstance(network.rules, Unset):+ result["rules"] = cast(+ Dict[str, List[SandboxNetworkRuleInfo]], network.rules.to_dict()+ )if not isinstance(network.allow_public_traffic, Unset):result["allow_public_traffic"] = network.allow_public_trafficif not isinstance(network.mask_request_host, Unset):@@ -184,7 +375,7 @@ class SandboxInfo:"""Envd access token."""allow_internet_access: Optional[bool] = None"""Whether internet access was explicitly enabled or disabled for the sandbox."""- network: Optional[SandboxNetworkOpts] = None+ network: Optional[SandboxNetworkInfo] = None"""Sandbox network configuration."""lifecycle: Optional[SandboxInfoLifecycle] = None"""Sandbox lifecycle configuration."""@@ -198,7 +389,7 @@ class SandboxInfo:envd_access_token: Optional[str] = None,sandbox_domain: Optional[str] = None,allow_internet_access: Optional[bool] = None,- network: Optional[SandboxNetworkOpts] = None,+ network: Optional[SandboxNetworkInfo] = None,lifecycle: Optional[SandboxInfoLifecycle] = None,):return cls(diff --git a/packages/python-sdk/e2b/sandbox_async/main.py b/packages/python-sdk/e2b/sandbox_async/main.pyindex 4aa7a9f6a..11a98923d 100644--- a/packages/python-sdk/e2b/sandbox_async/main.py+++ b/packages/python-sdk/e2b/sandbox_async/main.py@@ -193,7 +193,7 @@ class AsyncSandbox(SandboxApi)::param secure: Envd is secured with access token and cannot be used without it, defaults to `True`.:param allow_internet_access: Allow sandbox to access the internet, defaults to `True`. If set to `False`, it works the same as setting network `deny_out` to `[0.0.0.0/0]`.:param mcp: MCP server to enable in the sandbox- :param network: Sandbox network configuration+ :param network: Sandbox network configuration. ``allow_out``/``deny_out`` may also be a callable receiving a :class:`SandboxNetworkSelectorContext` (``ctx.all_traffic``, ``ctx.rules``) and returning a list of strings. Per-host transform rules are nested under ``network.rules``.:param lifecycle: Sandbox lifecycle configuration — ``on_timeout``: ``"kill"`` (default) or ``"pause"``; ``auto_resume``: ``False`` (default) or ``True`` (only when ``on_timeout="pause"``). Example: ``{"on_timeout": "pause", "auto_resume": True}``:param volume_mounts: Dictionary mapping mount paths to AsyncVolume instances or volume namesdiff --git a/packages/python-sdk/e2b/sandbox_async/sandbox_api.py b/packages/python-sdk/e2b/sandbox_async/sandbox_api.pyindex 78c87feec..55085293a 100644--- a/packages/python-sdk/e2b/sandbox_async/sandbox_api.py+++ b/packages/python-sdk/e2b/sandbox_async/sandbox_api.py@@ -45,6 +45,7 @@ from e2b.sandbox.sandbox_api import (SandboxNetworkOpts,SandboxQuery,SnapshotInfo,+ build_network_config,)from e2b.sandbox_async.paginator import AsyncSandboxPaginator@@ -184,6 +185,7 @@ class SandboxApi(SandboxBase):"auto_resume can only be True when the resolved on_timeout is 'pause'.")+ network_body = build_network_config(network)body = NewSandbox(template_id=template,auto_pause=on_timeout == "pause",@@ -194,7 +196,7 @@ class SandboxApi(SandboxBase):mcp=cast(Any, mcp) or UNSET,secure=secure,allow_internet_access=allow_internet_access,- network=SandboxNetworkConfig(**network) if network else UNSET,+ network=SandboxNetworkConfig(**network_body) if network_body else UNSET,volume_mounts=volume_mounts if volume_mounts else UNSET,)diff --git a/packages/python-sdk/e2b/sandbox_sync/main.py b/packages/python-sdk/e2b/sandbox_sync/main.pyindex 3557f1d14..f00d1b71c 100644--- a/packages/python-sdk/e2b/sandbox_sync/main.py+++ b/packages/python-sdk/e2b/sandbox_sync/main.py@@ -191,7 +191,7 @@ class Sandbox(SandboxApi)::param secure: Envd is secured with access token and cannot be used without it, defaults to `True`.:param allow_internet_access: Allow sandbox to access the internet, defaults to `True`. If set to `False`, it works the same as setting network `deny_out` to `[0.0.0.0/0]`.:param mcp: MCP server to enable in the sandbox- :param network: Sandbox network configuration+ :param network: Sandbox network configuration. ``allow_out``/``deny_out`` may also be a callable receiving a :class:`SandboxNetworkSelectorContext` (``ctx.all_traffic``, ``ctx.rules``) and returning a list of strings. Per-host transform rules are nested under ``network.rules``.:param lifecycle: Sandbox lifecycle configuration — ``on_timeout``: ``"kill"`` (default) or ``"pause"``; ``auto_resume``: ``False`` (default) or ``True`` (only when ``on_timeout="pause"``). Example: ``{"on_timeout": "pause", "auto_resume": True}``:param volume_mounts: Dictionary mapping mount paths to Volume instances or volume namesdiff --git a/packages/python-sdk/e2b/sandbox_sync/sandbox_api.py b/packages/python-sdk/e2b/sandbox_sync/sandbox_api.pyindex c84bae72a..b8b923a22 100644--- a/packages/python-sdk/e2b/sandbox_sync/sandbox_api.py+++ b/packages/python-sdk/e2b/sandbox_sync/sandbox_api.py@@ -37,13 +37,14 @@ from e2b.exceptions import ()from e2b.sandbox.main import SandboxBasefrom e2b.sandbox.sandbox_api import (- SandboxLifecycle,McpServer,SandboxInfo,+ SandboxLifecycle,SandboxMetrics,SandboxNetworkOpts,SandboxQuery,SnapshotInfo,+ build_network_config,)from e2b.sandbox_sync.paginator import SandboxPaginator, get_api_client@@ -183,6 +184,7 @@ class SandboxApi(SandboxBase):"auto_resume can only be True when the resolved on_timeout is 'pause'.")+ network_body = build_network_config(network)body = NewSandbox(template_id=template,auto_pause=on_timeout == "pause",@@ -193,7 +195,7 @@ class SandboxApi(SandboxBase):mcp=cast(Any, mcp) or UNSET,secure=secure,allow_internet_access=allow_internet_access,- network=SandboxNetworkConfig(**network) if network else UNSET,+ network=SandboxNetworkConfig(**network_body) if network_body else UNSET,volume_mounts=volume_mounts if volume_mounts else UNSET,)diff --git a/packages/python-sdk/tests/async/sandbox_async/test_network.py b/packages/python-sdk/tests/async/sandbox_async/test_network.pyindex 8c008371c..92227a421 100644--- a/packages/python-sdk/tests/async/sandbox_async/test_network.py+++ b/packages/python-sdk/tests/async/sandbox_async/test_network.py@@ -1,6 +1,8 @@+import json+import pytest-from e2b import ALL_TRAFFIC, SandboxNetworkOpts+from e2b import SandboxNetworkOptsfrom e2b.sandbox.commands.command_handle import CommandExitException@@ -8,7 +10,9 @@ from e2b.sandbox.commands.command_handle import CommandExitExceptionasync def test_allow_specific_ip_with_deny_all(async_sandbox_factory):"""Test that sandbox with denyOut all and allowOut creates a whitelist."""async_sandbox = await async_sandbox_factory(- network=SandboxNetworkOpts(deny_out=[ALL_TRAFFIC], allow_out=["1.1.1.1"])+ network=SandboxNetworkOpts(+ deny_out=lambda ctx: [ctx.all_traffic], allow_out=["1.1.1.1"]+ ))# Test that allowed IP works@@ -50,9 +54,9 @@ async def test_deny_specific_ip(async_sandbox_factory):@pytest.mark.skip_debug()async def test_deny_all_traffic(async_sandbox_factory):- """Test that sandbox can deny all traffic using all_traffic helper."""+ """Test that sandbox can deny all traffic using the all_traffic selector."""async_sandbox = await async_sandbox_factory(- network=SandboxNetworkOpts(deny_out=[ALL_TRAFFIC]), timeout=30+ network=SandboxNetworkOpts(deny_out=lambda ctx: [ctx.all_traffic]), timeout=30)# Test that all traffic is denied@@ -74,7 +78,7 @@ async def test_allow_takes_precedence_over_deny(async_sandbox_factory):"""Test that allowOut takes precedence over denyOut."""async_sandbox = await async_sandbox_factory(network=SandboxNetworkOpts(- deny_out=[ALL_TRAFFIC], allow_out=["1.1.1.1", "8.8.8.8"]+ deny_out=lambda ctx: [ctx.all_traffic], allow_out=["1.1.1.1", "8.8.8.8"]))@@ -159,6 +163,34 @@ async def test_allow_public_traffic_true(async_sandbox_factory):assert response.status_code == 200[email protected]_debug()+async def test_firewall_transform_injects_headers(async_sandbox_factory):+ """Test that a firewall rule with a transform injects headers into outbound requests."""+ injected_header = "X-E2B-Test-Token"+ injected_value = "e2b-transform-value-123"++ network: SandboxNetworkOpts = {+ "rules": {+ "httpbin.e2b.team": [+ {"transform": {"headers": {injected_header: injected_value}}},+ ],+ },+ }+ async_sandbox = await async_sandbox_factory(network=network)++ result = await async_sandbox.commands.run(+ "curl -sS --max-time 10 https://httpbin.e2b.team/headers"+ )+ assert result.exit_code == 0++ parsed = json.loads(result.stdout)+ reflected = parsed["headers"].get(injected_header)+ assert reflected == injected_value, (+ f"expected httpbin to reflect {injected_header}={injected_value}, "+ f"got headers: {parsed['headers']}"+ )++@pytest.mark.skip_debug()async def test_mask_request_host(async_sandbox_factory):"""Test that mask_request_host modifies the Host header correctly."""diff --git a/packages/python-sdk/tests/sync/sandbox_sync/test_network.py b/packages/python-sdk/tests/sync/sandbox_sync/test_network.pyindex 0cbe32d97..7edfae5c5 100644--- a/packages/python-sdk/tests/sync/sandbox_sync/test_network.py+++ b/packages/python-sdk/tests/sync/sandbox_sync/test_network.py@@ -1,6 +1,8 @@+import json+import pytest-from e2b import ALL_TRAFFIC, SandboxNetworkOpts+from e2b import SandboxNetworkOptsfrom e2b.sandbox.commands.command_handle import CommandExitException@@ -8,7 +10,9 @@ from e2b.sandbox.commands.command_handle import CommandExitExceptiondef test_allow_specific_ip_with_deny_all(sandbox_factory):"""Test that sandbox with denyOut all and allowOut creates a whitelist."""sandbox = sandbox_factory(- network=SandboxNetworkOpts(deny_out=[ALL_TRAFFIC], allow_out=["1.1.1.1"])+ network=SandboxNetworkOpts(+ deny_out=lambda ctx: [ctx.all_traffic], allow_out=["1.1.1.1"]+ ))# Test that allowed IP works@@ -48,9 +52,9 @@ def test_deny_specific_ip(sandbox_factory):@pytest.mark.skip_debug()def test_deny_all_traffic(sandbox_factory):- """Test that sandbox can deny all traffic using all_traffic helper."""+ """Test that sandbox can deny all traffic using the all_traffic selector."""sandbox = sandbox_factory(- network=SandboxNetworkOpts(deny_out=[ALL_TRAFFIC]), timeout=30+ network=SandboxNetworkOpts(deny_out=lambda ctx: [ctx.all_traffic]), timeout=30)# Test that all traffic is denied@@ -72,7 +76,7 @@ def test_allow_takes_precedence_over_deny(sandbox_factory):"""Test that allowOut takes precedence over denyOut."""sandbox = sandbox_factory(network=SandboxNetworkOpts(- deny_out=[ALL_TRAFFIC], allow_out=["1.1.1.1", "8.8.8.8"]+ deny_out=lambda ctx: [ctx.all_traffic], allow_out=["1.1.1.1", "8.8.8.8"]))@@ -157,6 +161,34 @@ def test_allow_public_traffic_true(sandbox_factory):assert response.status_code == 200[email protected]_debug()+def test_firewall_transform_injects_headers(sandbox_factory):+ """Test that a firewall rule with a transform injects headers into outbound requests."""+ injected_header = "X-E2B-Test-Token"+ injected_value = "e2b-transform-value-123"++ network: SandboxNetworkOpts = {+ "rules": {+ "httpbin.e2b.team": [+ {"transform": {"headers": {injected_header: injected_value}}},+ ],+ },+ }+ sandbox = sandbox_factory(network=network)++ result = sandbox.commands.run(+ "curl -sS --max-time 10 https://httpbin.e2b.team/headers"+ )+ assert result.exit_code == 0++ parsed = json.loads(result.stdout)+ reflected = parsed["headers"].get(injected_header)+ assert reflected == injected_value, (+ f"expected httpbin to reflect {injected_header}={injected_value}, "+ f"got headers: {parsed['headers']}"+ )++@pytest.mark.skip_debug()def test_mask_request_host(sandbox_factory):"""Test that mask_request_host modifies the Host header correctly."""diff --git a/spec/openapi.yml b/spec/openapi.ymlindex 87084f64b..464efe67c 100644--- a/spec/openapi.yml+++ b/spec/openapi.yml@@ -271,17 +271,41 @@ components:description: Specify if the sandbox URLs should be accessible only with authentication.allowOut:type: array- description: List of allowed CIDR blocks or IP addresses for egress traffic. Allowed addresses always take precedence over blocked addresses.+ description: List of allowed destinations for egress traffic. Each entry can be a CIDR block (e.g. "8.8.8.8/32"), a bare IP address (e.g. "8.8.8.8"), or a domain name (e.g. "example.com", "*.example.com"). Allowed entries always take precedence over denied entries.items:type: stringdenyOut:type: array- description: List of denied CIDR blocks or IP addresses for egress traffic+ description: List of denied CIDR blocks or IP addresses for egress traffic. Domain names are not supported for deny rules.items:type: stringmaskRequestHost:type: stringdescription: Specify host mask which will be used for all sandbox requests+ rules:+ type: object+ description: Per-domain transform rules applied to matching egress HTTP/HTTPS requests. Keys are domains (e.g. "api.example.com", "example.com"). A domain listed here is not automatically allowed - use allowOut to permit the traffic.+ additionalProperties:+ type: array+ items:+ $ref: '#/components/schemas/SandboxNetworkRule'++ SandboxNetworkRule:+ type: object+ description: Transform rule applied to egress requests matching a domain pattern.+ properties:+ transform:+ $ref: '#/components/schemas/SandboxNetworkTransform'++ SandboxNetworkTransform:+ type: object+ description: Transformations applied to matching egress requests before forwarding.+ properties:+ headers:+ type: object+ description: HTTP headers to inject or override in matching requests. An existing header with the same name is replaced. Values are plain strings; secret resolution happens client-side before sending to the API.+ additionalProperties:+ type: stringSandboxAutoResumeEnabled:type: boolean@@ -1799,8 +1823,8 @@ paths:get:description: Health checkresponses:- '200':- description: Request was successful+ '204':+ description: The service is healthy'401':$ref: '#/components/responses/401'@@ -2360,6 +2384,57 @@ paths:'500':$ref: '#/components/responses/500'+ /sandboxes/{sandboxID}/network:+ put:+ description: Update the network configuration for a running sandbox. Replaces the current egress rules with the provided configuration. Omitting both fields clears all egress rules.+ security:+ - ApiKeyAuth: []+ - Supabase1TokenAuth: []+ Supabase2TeamAuth: []+ tags: [sandboxes]+ requestBody:+ required: true+ content:+ application/json:+ schema:+ type: object+ properties:+ allowOut:+ type: array+ description: List of allowed destinations for egress traffic. Each entry can be a CIDR block (e.g. "8.8.8.8/32"), a bare IP address (e.g. "8.8.8.8"), or a domain name (e.g. "example.com", "*.example.com"). Allowed entries always take precedence over denied entries.+ items:+ type: string+ denyOut:+ type: array+ description: List of denied CIDR blocks or IP addresses for egress traffic. Domain names are not supported for deny rules.+ items:+ type: string+ rules:+ type: object+ description: Per-domain transform rules. Replaces all existing rules when provided.+ additionalProperties:+ type: array+ items:+ $ref: '#/components/schemas/SandboxNetworkRule'+ allow_internet_access:+ type: boolean+ description:+ Allow sandbox to access the internet. When set to false, it behaves the same as specifying denyOut+ to 0.0.0.0/0 in the network config.+ parameters:+ - $ref: '#/components/parameters/sandboxID'+ responses:+ '204':+ description: Successfully updated the sandbox network configuration+ '401':+ $ref: '#/components/responses/401'+ '404':+ $ref: '#/components/responses/404'+ '409':+ $ref: '#/components/responses/409'+ '500':+ $ref: '#/components/responses/500'+/sandboxes/{sandboxID}/refreshes:post:description: Refresh the sandbox extending its time to live