π OpenHands: AI-Driven Development
feat(runtime): upgrade E2B runtime to v2.0 with full implementation (#10832)
Ruilin Zhou9960d11d0813
diff --git a/openhands/runtime/base.py b/openhands/runtime/base.pyindex 3a377d11b0..3e5018aa39 100644--- a/openhands/runtime/base.py+++ b/openhands/runtime/base.py@@ -863,7 +863,7 @@ fi# If the instructions file is not found in the workspace root, try to load it from the repo rootself.log('debug',- f'.openhands_instructions not present, trying to load from repository {microagents_dir=}',+ f'.openhands_instructions not present, trying to load from repository microagents_dir={microagents_dir}',)obs = self.read(FileReadAction(path=str(repo_root / '.openhands_instructions'))diff --git a/poetry.lock b/poetry.lockindex 376e5c7598..f050c92058 100644--- a/poetry.lock+++ b/poetry.lock@@ -1,4 +1,4 @@-# This file is automatically @generated by Poetry 2.1.3 and should not be changed by hand.+# This file is automatically @generated by Poetry 2.1.4 and should not be changed by hand.[[package]]name = "aiofiles"@@ -2257,15 +2257,15 @@ files = [[[package]]name = "e2b"-version = "1.7.0"+version = "2.0.0"description = "E2B SDK that give agents cloud environments"optional = truepython-versions = "<4.0,>=3.9"groups = ["main"]markers = "extra == \"third-party-runtimes\""files = [- {file = "e2b-1.7.0-py3-none-any.whl", hash = "sha256:6bd3d935249fcf5684494a97178d4d58446b4ed4018ac09087e4000046e82aab"},- {file = "e2b-1.7.0.tar.gz", hash = "sha256:7783408c2cdf7aee9b088d31759364f2b13b21100cc4e132ba36fd84cfc72e31"},+ {file = "e2b-2.0.0-py3-none-any.whl", hash = "sha256:a6621b905cb2a883a9c520736ae98343a6184fc90c29b4f2f079d720294a0df0"},+ {file = "e2b-2.0.0.tar.gz", hash = "sha256:4d033d937b0a09b8428e73233321a913cbaef8e7299fc731579c656e9d53a144"},][package.dependencies]@@ -2273,10 +2273,28 @@ attrs = ">=23.2.0"httpcore = ">=1.0.5,<2.0.0"httpx = ">=0.27.0,<1.0.0"packaging = ">=24.1"-protobuf = ">=5.29.4,<6.0.0"+protobuf = ">=4.21.0"python-dateutil = ">=2.8.2"typing-extensions = ">=4.1.0"+[[package]]+name = "e2b-code-interpreter"+version = "2.0.0"+description = "E2B Code Interpreter - Stateful code execution"+optional = true+python-versions = "<4.0,>=3.9"+groups = ["main"]+markers = "extra == \"third-party-runtimes\""+files = [+ {file = "e2b_code_interpreter-2.0.0-py3-none-any.whl", hash = "sha256:273642d4dd78f09327fb1553fe4f7ddcf17892b78f98236e038d29985e42dca5"},+ {file = "e2b_code_interpreter-2.0.0.tar.gz", hash = "sha256:19136916be8de60bfd0a678742501d1d0335442bb6e86405c7dd6f98059b73c4"},+]++[package.dependencies]+attrs = ">=21.3.0"+e2b = ">=2.0.0,<3.0.0"+httpx = ">=0.20.0,<1.0.0"+[[package]]name = "english-words"version = "2.0.1"@@ -11845,9 +11863,9 @@ cffi = {version = ">=1.11", markers = "platform_python_implementation == \"PyPy\cffi = ["cffi (>=1.11)"][extras]-third-party-runtimes = ["daytona", "e2b", "modal", "runloop-api-client"]+third-party-runtimes = ["daytona", "e2b-code-interpreter", "modal", "runloop-api-client"][metadata]lock-version = "2.1"python-versions = "^3.12,<3.14"-content-hash = "a0ae2cee596dde71f89c06e9669efda58ee8f8f019fad3dbe9df068005c32904"+content-hash = "5135db5c5c744f7b2aab0ccb6921343d2268d8ef950e024ddc3bce25c597140a"diff --git a/pyproject.toml b/pyproject.tomlindex 80a9286c04..008ebd05e9 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -96,14 +96,14 @@ memory-profiler = "^0.61.0"jupyter_kernel_gateway = "*"# Third-party runtime dependencies (optional)-e2b = { version = ">=1.0.5,<1.8.0", optional = true }modal = { version = ">=0.66.26,<1.2.0", optional = true }runloop-api-client = { version = "0.50.0", optional = true }daytona = { version = "0.24.2", optional = true }httpx-aiohttp = "^0.1.8"+e2b-code-interpreter = { version = "^2.0.0", optional = true }[tool.poetry.extras]-third_party_runtimes = [ "e2b", "modal", "runloop-api-client", "daytona" ]+third_party_runtimes = [ "e2b-code-interpreter", "modal", "runloop-api-client", "daytona" ][tool.poetry.group.dev]optional = truediff --git a/third_party/runtime/impl/e2b/e2b_runtime.py b/third_party/runtime/impl/e2b/e2b_runtime.pyindex bd43219da1..92ec319edf 100644--- a/third_party/runtime/impl/e2b/e2b_runtime.py+++ b/third_party/runtime/impl/e2b/e2b_runtime.py@@ -1,32 +1,50 @@+import osfrom typing import Callablefrom openhands.core.config import OpenHandsConfig+from openhands.core.logger import openhands_logger as loggerfrom openhands.events.action import (+ BrowseURLAction,+ BrowseInteractiveAction,+ CmdRunAction,+ FileEditAction,FileReadAction,FileWriteAction,+ IPythonRunCellAction,)from openhands.events.observation import (+ BrowserOutputObservation,+ CmdOutputObservation,ErrorObservation,+ FileEditObservation,FileReadObservation,FileWriteObservation,+ IPythonRunCellObservation,Observation,)from openhands.events.stream import EventStreamfrom openhands.integrations.provider import PROVIDER_TOKEN_TYPE+from openhands.llm.llm_registry import LLMRegistryfrom openhands.runtime.impl.action_execution.action_execution_client import (ActionExecutionClient,)-from third_party.runtime.impl.e2b.filestore import E2BFileStore-from third_party.runtime.impl.e2b.sandbox import E2BSandboxfrom openhands.runtime.plugins import PluginRequirement+from openhands.runtime.runtime_status import RuntimeStatusfrom openhands.runtime.utils.files import insert_lines, read_lines+from openhands.utils.async_utils import call_sync_from_async+from third_party.runtime.impl.e2b.filestore import E2BFileStore+from third_party.runtime.impl.e2b.sandbox import E2BBox, E2BSandboxclass E2BRuntime(ActionExecutionClient):+ # Class-level cache for sandbox IDs+ _sandbox_id_cache: dict[str, str] = {}+def __init__(self,config: OpenHandsConfig,event_stream: EventStream,+ llm_registry: LLMRegistry,sid: str = "default",plugins: list[PluginRequirement] | None = None,env_vars: dict[str, str] | None = None,@@ -37,42 +55,348 @@ class E2BRuntime(ActionExecutionClient):git_provider_tokens: PROVIDER_TOKEN_TYPE | None = None,sandbox: E2BSandbox | None = None,):+ if config.workspace_base is not None:+ logger.warning(+ "Setting workspace_base is not supported in the E2B runtime. "+ "E2B provides its own isolated filesystem."+ )+super().__init__(- config,- event_stream,- sid,- plugins,- env_vars,- status_callback,- attach_to_existing,- headless_mode,- user_id,- git_provider_tokens,+ config=config,+ event_stream=event_stream,+ llm_registry=llm_registry,+ sid=sid,+ plugins=plugins,+ env_vars=env_vars,+ status_callback=status_callback,+ attach_to_existing=attach_to_existing,+ headless_mode=headless_mode,+ user_id=user_id,+ git_provider_tokens=git_provider_tokens,)- if sandbox is None:- self.sandbox = E2BSandbox(config.sandbox)- if not isinstance(self.sandbox, E2BSandbox):- raise ValueError("E2BRuntime requires an E2BSandbox")- self.file_store = E2BFileStore(self.sandbox.filesystem)+ self.sandbox = sandbox+ self.file_store = None+ self.api_url = None+ self._action_server_port = 8000+ self._runtime_initialized = False++ @property+ def action_execution_server_url(self) -> str:+ """Return the URL of the action execution server."""+ if not self.api_url:+ raise RuntimeError("E2B runtime not connected. Call connect() first.")+ return self.api_url++ async def connect(self) -> None:+ """Initialize E2B sandbox and start action execution server."""+ self.set_runtime_status(RuntimeStatus.STARTING_RUNTIME)++ try:+ if self.attach_to_existing and self.sandbox is None:+ try:+ cached_sandbox_id = self.__class__._sandbox_id_cache.get(self.sid)++ if cached_sandbox_id:+ try:+ self.sandbox = E2BBox(self.config.sandbox, sandbox_id=cached_sandbox_id)+ logger.info(f"Successfully attached to existing E2B sandbox: {cached_sandbox_id}")+ except Exception as e:+ logger.warning(f"Failed to connect to cached sandbox {cached_sandbox_id}: {e}")+ del self.__class__._sandbox_id_cache[self.sid]+ self.sandbox = None++ except Exception as e:+ logger.warning(f"Failed to attach to existing sandbox: {e}. Will create a new one.")++ # Create E2B sandbox if not provided+ if self.sandbox is None:+ try:+ self.sandbox = E2BSandbox(self.config.sandbox)+ sandbox_id = self.sandbox.sandbox.sandbox_id+ logger.info(f"E2B sandbox created with ID: {sandbox_id}")++ self.__class__._sandbox_id_cache[self.sid] = sandbox_id+ except Exception as e:+ logger.error(f"Failed to create E2B sandbox: {e}")+ raise++ if not isinstance(self.sandbox, (E2BSandbox, E2BBox)):+ raise ValueError("E2BRuntime requires an E2BSandbox or E2BBox")++ self.file_store = E2BFileStore(self.sandbox.filesystem)++ # E2B doesn't use action execution server - set dummy URL+ self.api_url = "direct://e2b-sandbox"++ workspace_dir = self.config.workspace_mount_path_in_sandbox+ if workspace_dir:+ try:+ exit_code, output = self.sandbox.execute(f"sudo mkdir -p {workspace_dir}")+ if exit_code == 0:+ self.sandbox.execute(f"sudo chmod 777 {workspace_dir}")+ logger.info(f"Created workspace directory: {workspace_dir}")+ else:+ logger.warning(f"Failed to create workspace directory: {output}")+ except Exception as e:+ logger.warning(f"Failed to create workspace directory: {e}")++ await call_sync_from_async(self.setup_initial_env)++ self._runtime_initialized = True+ self.set_runtime_status(RuntimeStatus.READY)+ logger.info("E2B runtime connected successfully")++ except Exception as e:+ logger.error(f"Failed to connect E2B runtime: {e}")+ self.set_runtime_status(RuntimeStatus.FAILED)+ raise++ async def close(self) -> None:+ """Close the E2B runtime."""+ if self._runtime_closed:+ return++ self._runtime_closed = True++ if self.sandbox:+ try:++ if not self.attach_to_existing:+ self.sandbox.close()+ if self.sid in self.__class__._sandbox_id_cache:+ del self.__class__._sandbox_id_cache[self.sid]+ logger.info("E2B sandbox closed and removed from cache")+ else:+ logger.info("E2B runtime connection closed, sandbox kept running for reuse")++ except Exception as e:+ logger.error(f"Error closing E2B sandbox: {e}")++ parent_close = super().close()+ if parent_close is not None:+ await parent_close++ def run(self, action: CmdRunAction) -> Observation:+ """Execute command using E2B's native execute method."""+ if self.sandbox is None:+ return ErrorObservation("E2B sandbox not initialized")++ try:+ timeout = action.timeout if action.timeout else self.config.sandbox.timeout+ exit_code, output = self.sandbox.execute(action.command, timeout=timeout)+ return CmdOutputObservation(+ content=output,+ command=action.command,+ exit_code=exit_code+ )+ except Exception as e:+ return ErrorObservation(f"Failed to execute command: {e}")++ def run_ipython(self, action: IPythonRunCellAction) -> Observation:+ """Execute IPython code using E2B's code interpreter."""+ if self.sandbox is None:+ return ErrorObservation("E2B sandbox not initialized")++ try:+ result = self.sandbox.sandbox.run_code(action.code)++ outputs = []+ if hasattr(result, 'results') and result.results:+ for r in result.results:+ if hasattr(r, 'text') and r.text:+ outputs.append(r.text)+ elif hasattr(r, 'html') and r.html:+ outputs.append(r.html)+ elif hasattr(r, 'png') and r.png:+ outputs.append(f"[Image data: {len(r.png)} bytes]")++ if hasattr(result, 'error') and result.error:+ return ErrorObservation(f"IPython error: {result.error}")++ return IPythonRunCellObservation(+ content='\n'.join(outputs) if outputs else '',+ code=action.code+ )+ except Exception as e:+ return ErrorObservation(f"Failed to execute IPython code: {e}")def read(self, action: FileReadAction) -> Observation:- content = self.file_store.read(action.path)- lines = read_lines(content.split("\n"), action.start, action.end)- code_view = "".join(lines)- return FileReadObservation(code_view, path=action.path)+ if self.file_store is None:+ return ErrorObservation("E2B file store not initialized. Call connect() first.")++ try:+ content = self.file_store.read(action.path)+ lines = read_lines(content.split("\n"), action.start, action.end)+ code_view = "".join(lines)+ return FileReadObservation(code_view, path=action.path)+ except Exception as e:+ return ErrorObservation(f"Failed to read file: {e}")def write(self, action: FileWriteAction) -> Observation:- if action.start == 0 and action.end == -1:- self.file_store.write(action.path, action.content)- return FileWriteObservation(content="", path=action.path)- files = self.file_store.list(action.path)- if action.path in files:- all_lines = self.file_store.read(action.path).split("\n")- new_file = insert_lines(- action.content.split("\n"), all_lines, action.start, action.end+ if self.file_store is None:+ return ErrorObservation("E2B file store not initialized. Call connect() first.")++ try:+ if action.start == 0 and action.end == -1:+ self.file_store.write(action.path, action.content)+ return FileWriteObservation(content="", path=action.path)++ files = self.file_store.list(action.path)+ if action.path in files:+ all_lines = self.file_store.read(action.path).split("\n")+ new_file = insert_lines(+ action.content.split("\n"), all_lines, action.start, action.end+ )+ self.file_store.write(action.path, "".join(new_file))+ return FileWriteObservation("", path=action.path)+ else:+ # Create a new file+ self.file_store.write(action.path, action.content)+ return FileWriteObservation(content="", path=action.path)+ except Exception as e:+ return ErrorObservation(f"Failed to write file: {e}")++ def edit(self, action: FileEditAction) -> Observation:+ """Edit a file using E2B's file system."""+ if self.file_store is None:+ return ErrorObservation("E2B file store not initialized. Call connect() first.")++ try:+ if action.path in self.file_store.list(action.path):+ content = self.file_store.read(action.path)+ else:+ return ErrorObservation(f"File {action.path} not found")++ lines = content.split('\n')+ if action.start < 0 or action.end > len(lines):+ return ErrorObservation(f"Invalid line range: {action.start}-{action.end}")++ new_lines = lines[:action.start] + action.content.split('\n') + lines[action.end:]+ new_content = '\n'.join(new_lines)++ self.file_store.write(action.path, new_content)++ return FileEditObservation(+ content='',+ path=action.path,+ old_content='\n'.join(lines[action.start:action.end]),+ start=action.start,+ end=action.end)- self.file_store.write(action.path, "".join(new_file))- return FileWriteObservation("", path=action.path)- else:- # FIXME: we should create a new file here- return ErrorObservation(f"File not found: {action.path}")+ except Exception as e:+ return ErrorObservation(f"Failed to edit file: {e}")++ def browse(self, action: BrowseURLAction) -> Observation:+ """Browse a URL using E2B's browser capabilities."""+ if self.sandbox is None:+ return ErrorObservation("E2B sandbox not initialized")++ try:+ exit_code, output = self.sandbox.execute(f"curl -s -L '{action.url}'")+ if exit_code != 0:+ exit_code, output = self.sandbox.execute(f"wget -qO- '{action.url}'")++ if exit_code != 0:+ return ErrorObservation(f"Failed to fetch URL: {output}")++ return BrowserOutputObservation(+ content=output,+ url=action.url,+ screenshot=None,+ error=None if exit_code == 0 else output+ )+ except Exception as e:+ return ErrorObservation(f"Failed to browse URL: {e}")++ def browse_interactive(self, action: BrowseInteractiveAction) -> Observation:+ """Interactive browsing is not supported in E2B."""+ return ErrorObservation(+ "Interactive browsing is not supported in E2B runtime. "+ "Use browse() for simple URL fetching or consider using a different runtime."+ )++ def list_files(self, path: str | None = None) -> list[str]:+ """List files in the sandbox."""+ if self.sandbox is None:+ logger.warning("Cannot list files: E2B sandbox not initialized")+ return []++ if path is None:+ path = self.config.workspace_mount_path_in_sandbox or '/workspace'++ try:+ exit_code, output = self.sandbox.execute(f"find {path} -maxdepth 1 -type f -o -type d")+ if exit_code == 0:+ files = [line.strip() for line in output.strip().split('\n') if line.strip()]+ return [f.replace(path + '/', '') if f.startswith(path + '/') else f for f in files]+ else:+ logger.warning(f"Failed to list files in {path}: {output}")+ return []+ except Exception as e:+ logger.warning(f"Error listing files: {e}")+ return []++ def add_env_vars(self, env_vars: dict[str, str]) -> None:+ """Add environment variables to the E2B sandbox."""+ if self.sandbox is None:+ logger.warning("Cannot add env vars: E2B sandbox not initialized")+ return++ if not hasattr(self, '_env_vars'):+ self._env_vars = {}+ self._env_vars.update(env_vars)++ for key, value in env_vars.items():+ try:+ escaped_value = value.replace("'", "'\"'\"'")+ cmd = f"export {key}='{escaped_value}'"+ self.sandbox.execute(cmd)+ logger.debug(f"Set env var: {key}")+ except Exception as e:+ logger.warning(f"Failed to set env var {key}: {e}")++ def get_working_directory(self) -> str:+ """Get the current working directory."""+ if self.sandbox is None:+ return self.config.workspace_mount_path_in_sandbox or '/workspace'+ try:+ exit_code, output = self.sandbox.execute("pwd")+ if exit_code == 0:+ return output.strip()+ except Exception:+ pass+ return self.config.workspace_mount_path_in_sandbox or '/workspace'++ def get_mcp_config(self, extra_stdio_servers: list | None = None) -> dict:+ """Get MCP configuration for E2B runtime."""+ return {+ 'stdio_servers': extra_stdio_servers or []+ }++ def check_if_alive(self) -> None:+ """Check if the E2B sandbox is alive."""+ if self.sandbox is None:+ raise RuntimeError("E2B sandbox not initialized")+ return++ def copy_to(self, host_src: str, sandbox_dest: str, recursive: bool = False) -> None:+ """Copy files to the E2B sandbox."""+ if self.sandbox is None:+ raise RuntimeError("E2B sandbox not initialized")+ self.sandbox.copy_to(host_src, sandbox_dest, recursive)++ def get_vscode_token(self) -> str:+ """E2B doesn't support VSCode integration."""+ return ""++ @classmethod+ def setup(cls, config: OpenHandsConfig, headless_mode: bool = False) -> None:+ """Set up the E2B runtime environment."""+ logger.info("E2B runtime setup called")+ pass++ @classmethod+ def teardown(cls, config: OpenHandsConfig) -> None:+ """Tear down the E2B runtime environment."""+ logger.info("E2B runtime teardown called")+ passdiff --git a/third_party/runtime/impl/e2b/sandbox.py b/third_party/runtime/impl/e2b/sandbox.pyindex 842dfeb091..ff5cbdbe07 100644--- a/third_party/runtime/impl/e2b/sandbox.py+++ b/third_party/runtime/impl/e2b/sandbox.py@@ -3,7 +3,7 @@ import osimport tarfilefrom glob import glob-from e2b import Sandbox as E2BSandbox+from e2b_code_interpreter import Sandboxfrom e2b.exceptions import TimeoutExceptionfrom openhands.core.config import SandboxConfig@@ -19,7 +19,7 @@ class E2BBox:def __init__(self,config: SandboxConfig,- template: str = "openhands",+ sandbox_id: str | None = None,):self.config = copy.deepcopy(config)self.initialize_plugins: bool = config.initialize_plugins@@ -30,20 +30,41 @@ class E2BBox:raise ValueError("E2B_API_KEY environment variable is required for E2B runtime")++ # Read custom E2B domain if provided+ e2b_domain = os.getenv("E2B_DOMAIN")+ if e2b_domain:+ logger.info(f'Using custom E2B domain: {e2b_domain}')- self.sandbox = E2BSandbox(- api_key=e2b_api_key,- template=template,- # It's possible to stream stdout and stderr from sandbox and from each process- on_stderr=lambda x: logger.debug(f"E2B sandbox stderr: {x}"),- on_stdout=lambda x: logger.debug(f"E2B sandbox stdout: {x}"),- cwd=self._cwd, # Default workdir inside sandbox- )- logger.debug(f'Started E2B sandbox with ID "{self.sandbox.id}"')+ # E2B v2 requires using create() method or connect to existing+ try:+ # Configure E2B client with custom domain if provided+ create_kwargs = {}+ connect_kwargs = {}++ if e2b_domain:+ # Set up custom domain configuration+ # Note: This depends on E2B SDK version and may need adjustment+ os.environ['E2B_API_URL'] = f'https://{e2b_domain}'+ logger.info(f'Set E2B_API_URL to https://{e2b_domain}')++ if sandbox_id:+ # Connect to existing sandbox+ self.sandbox = Sandbox.connect(sandbox_id, **connect_kwargs)+ logger.info(f'Connected to existing E2B sandbox with ID "{sandbox_id}"')+ else:+ # Create new sandbox (e2b-code-interpreter doesn't need template)+ self.sandbox = Sandbox.create(**create_kwargs)+ sandbox_id = self.sandbox.sandbox_id+ logger.info(f'Created E2B sandbox with ID "{sandbox_id}"')+ except Exception as e:+ logger.error(f"Failed to create/connect E2B sandbox: {e}")+ raise@propertydef filesystem(self):- return self.sandbox.filesystem+ # E2B v2 uses 'files' instead of 'filesystem'+ return getattr(self.sandbox, 'files', None) or getattr(self.sandbox, 'filesystem', None)def _archive(self, host_src: str, recursive: bool = False):if recursive:@@ -70,21 +91,23 @@ class E2BBox:def execute(self, cmd: str, timeout: int | None = None) -> tuple[int, str]:timeout = timeout if timeout is not None else self.config.timeout- process = self.sandbox.process.start(cmd, env_vars=self._env)++ # E2B code-interpreter uses commands.run()try:- process_output = process.wait(timeout=timeout)+ result = self.sandbox.commands.run(cmd)+ output = ""+ if hasattr(result, 'stdout') and result.stdout:+ output += result.stdout+ if hasattr(result, 'stderr') and result.stderr:+ output += result.stderr+ exit_code = getattr(result, 'exit_code', 0) or 0+ return exit_code, outputexcept TimeoutException:- logger.debug("Command timed out, killing process...")- process.kill()+ logger.debug("Command timed out")return -1, f'Command: "{cmd}" timed out'-- logs = [m.line for m in process_output.messages]- logs_str = "\n".join(logs)- if process.exit_code is None:- return -1, logs_str-- assert process_output.exit_code is not None- return process_output.exit_code, logs_str+ except Exception as e:+ logger.error(f"Command execution failed: {e}")+ return -1, str(e)def copy_to(self, host_src: str, sandbox_dest: str, recursive: bool = False):"""Copies a local file or directory to the sandbox."""@@ -98,24 +121,28 @@ class E2BBox:uploaded_path = self.sandbox.upload_file(tar_file)# Check if sandbox_dest exists. If not, create it.- process = self.sandbox.process.start_and_wait(f"test -d {sandbox_dest}")- if process.exit_code != 0:- self.sandbox.filesystem.make_dir(sandbox_dest)+ exit_code, _ = self.execute(f"test -d {sandbox_dest}")+ if exit_code != 0:+ self.execute(f"mkdir -p {sandbox_dest}")# Extract the archive into the destination and delete the archive- process = self.sandbox.process.start_and_wait(+ exit_code, output = self.execute(f"sudo tar -xf {uploaded_path} -C {sandbox_dest} && sudo rm {uploaded_path}")- if process.exit_code != 0:+ if exit_code != 0:raise Exception(- f"Failed to extract {uploaded_path} to {sandbox_dest}: {process.stderr}"+ f"Failed to extract {uploaded_path} to {sandbox_dest}: {output}")# Delete the local archiveos.remove(tar_filename)def close(self):- self.sandbox.close()+ # E2B v2 uses kill() instead of close()+ if hasattr(self.sandbox, 'kill'):+ self.sandbox.kill()+ elif hasattr(self.sandbox, 'close'):+ self.sandbox.close()def get_working_directory(self):return self.sandbox.cwd