Remove third-party runtimes (daytona, modal, e2b, runloop) from main codebase (#9213)

Co-authored-by: openhands <[email protected]>
Co-authored-by: Engel Nyst <[email protected]>
Co-authored-by: Engel Nyst <[email protected]>

Author: 3 people

config.template.toml

@@ -10,18 +10,7 @@
 # General core configurations
 ##############################################################################
 [core]
-# API key for E2B
-#e2b_api_key = ""
-
-# API key for Modal
-#modal_api_token_id = ""
-#modal_api_token_secret = ""
-
-# API key for Daytona
-#daytona_api_key = ""
-
-# Daytona Target
-#daytona_target = ""
+# API keys and configuration for core services
 
 # Base path for the workspace
 #workspace_base = "./workspace"

dev_config/python/.pre-commit-config.yaml

@@ -3,9 +3,9 @@ repos:
     rev: v5.0.0
     hooks:
       - id: trailing-whitespace
-        exclude: ^(docs/|modules/|python/|openhands-ui/)
+        exclude: ^(docs/|modules/|python/|openhands-ui/|third_party/)
       - id: end-of-file-fixer
-        exclude: ^(docs/|modules/|python/|openhands-ui/)
+        exclude: ^(docs/|modules/|python/|openhands-ui/|third_party/)
       - id: check-yaml
         args: ["--allow-multiple-documents"]
       - id: debug-statements
@@ -28,10 +28,12 @@ repos:
         entry: ruff check --config dev_config/python/ruff.toml
         types_or: [python, pyi, jupyter]
         args: [--fix, --unsafe-fixes]
+        exclude: third_party/
       # Run the formatter.
       - id: ruff-format
         entry: ruff format --config dev_config/python/ruff.toml
         types_or: [python, pyi, jupyter]
+        exclude: third_party/
 
   - repo: https://github.com/pre-commit/mirrors-mypy
     rev: v1.15.0

dev_config/python/mypy.ini

@@ -7,3 +7,5 @@ warn_unreachable = True
 warn_redundant_casts = True
 no_implicit_optional = True
 strict_optional = True
+# Exclude third-party runtime directory from type checking
+exclude = third_party/

dev_config/python/ruff.toml

@@ -1,3 +1,6 @@
+# Exclude third-party runtime directory from linting
+exclude = ["third_party/"]
+
 [lint]
 select = [
     "E",

docs/usage/configuration-options.mdx

@@ -12,22 +12,6 @@ description: This page outlines all available configuration options for OpenHand
 
 The core configuration options are defined in the `[core]` section of the `config.toml` file.
 
-### API Keys
-- `e2b_api_key`
-  - Type: `str`
-  - Default: `""`
-  - Description: API key for E2B
-
-- `modal_api_token_id`
-  - Type: `str`
-  - Default: `""`
-  - Description: API token ID for Modal
-
-- `modal_api_token_secret`
-  - Type: `str`
-  - Default: `""`
-  - Description: API token secret for Modal
-
 ### Workspace
 - `workspace_base` **(Deprecated)**
   - Type: `str`

docs/usage/runtimes/overview.mdx

@@ -9,8 +9,6 @@ commands.
 By default, OpenHands uses a [Docker-based runtime](/usage/runtimes/docker), running on your local computer.
 This means you only have to pay for the LLM you're using, and your code is only ever sent to the LLM.
 
-We also support other runtimes, which are typically managed by third-parties.
-
 Additionally, we provide a [Local Runtime](/usage/runtimes/local) that runs directly on your machine without Docker,
 which can be useful in controlled environments like CI pipelines.
 
@@ -21,6 +19,18 @@ OpenHands supports several different runtime environments:
 - [Docker Runtime](/usage/runtimes/docker) - The default runtime that uses Docker containers for isolation (recommended for most users).
 - [OpenHands Remote Runtime](/usage/runtimes/remote) - Cloud-based runtime for parallel execution (beta).
 - [Local Runtime](/usage/runtimes/local) - Direct execution on your local machine without Docker.
-- And more third-party runtimes:
-  - [Modal Runtime](/usage/runtimes/modal) - Runtime provided by our partners at Modal.
-  - [Daytona Runtime](/usage/runtimes/daytona) - Runtime provided by Daytona.
+
+### Third-Party Runtimes
+
+The following third-party runtimes are available when you install the `third_party_runtimes` extra:
+
+```bash
+pip install openhands-ai[third_party_runtimes]
+```
+
+- [E2B Runtime](/usage/runtimes/e2b) - Open source runtime using E2B sandboxes.
+- [Modal Runtime](/usage/runtimes/modal) - Serverless runtime using Modal infrastructure.
+- [Runloop Runtime](/usage/runtimes/runloop) - Cloud runtime using Runloop infrastructure.
+- [Daytona Runtime](/usage/runtimes/daytona) - Development environment runtime using Daytona.
+
+**Note**: These third-party runtimes are supported by their respective developers, not by the OpenHands team. For issues specific to these runtimes, please refer to their documentation or contact their support teams.

openhands/core/config/openhands_config.py

@@ -46,7 +46,6 @@ class OpenHandsConfig(BaseModel):
         run_as_openhands: Whether to run as openhands.
         max_iterations: Maximum number of iterations allowed.
         max_budget_per_task: Maximum budget per task, agent stops if exceeded.
-        e2b_api_key: E2B API key.
         disable_color: Whether to disable terminal colors. For terminals that don't support color.
         debug: Whether to enable debugging mode.
         file_uploads_max_file_size_mb: Maximum file upload size in MB. `0` means unlimited.
@@ -88,19 +87,14 @@ class OpenHandsConfig(BaseModel):
     run_as_openhands: bool = Field(default=True)
     max_iterations: int = Field(default=OH_MAX_ITERATIONS)
     max_budget_per_task: float | None = Field(default=None)
-    e2b_api_key: SecretStr | None = Field(default=None)
-    modal_api_token_id: SecretStr | None = Field(default=None)
-    modal_api_token_secret: SecretStr | None = Field(default=None)
+
     disable_color: bool = Field(default=False)
     jwt_secret: SecretStr | None = Field(default=None)
     debug: bool = Field(default=False)
     file_uploads_max_file_size_mb: int = Field(default=0)
     file_uploads_restrict_file_types: bool = Field(default=False)
     file_uploads_allowed_extensions: list[str] = Field(default_factory=lambda: ['.*'])
-    runloop_api_key: SecretStr | None = Field(default=None)
-    daytona_api_key: SecretStr | None = Field(default=None)
-    daytona_api_url: str = Field(default='https://app.daytona.io/api')
-    daytona_target: str = Field(default='eu')
+
     cli_multiline_input: bool = Field(default=False)
     conversation_max_age_seconds: int = Field(default=864000)  # 10 days in seconds
     enable_default_condenser: bool = Field(default=True)

openhands/core/logger.py

@@ -261,6 +261,7 @@ def filter(self, record: logging.LogRecord) -> bool:
             'modal_api_token_secret',
             'llm_api_key',
             'sandbox_env_github_token',
+            'runloop_api_key',
             'daytona_api_key',
         ]
 

openhands/runtime/__init__.py

@@ -1,58 +1,113 @@
+import importlib
+
 from openhands.runtime.base import Runtime
 from openhands.runtime.impl.cli.cli_runtime import CLIRuntime
-from openhands.runtime.impl.daytona.daytona_runtime import DaytonaRuntime
 from openhands.runtime.impl.docker.docker_runtime import (
     DockerRuntime,
 )
-from openhands.runtime.impl.e2b.e2b_runtime import E2BRuntime
 from openhands.runtime.impl.kubernetes.kubernetes_runtime import KubernetesRuntime
 from openhands.runtime.impl.local.local_runtime import LocalRuntime
-from openhands.runtime.impl.modal.modal_runtime import ModalRuntime
 from openhands.runtime.impl.remote.remote_runtime import RemoteRuntime
-from openhands.runtime.impl.runloop.runloop_runtime import RunloopRuntime
 from openhands.utils.import_utils import get_impl
 
 # mypy: disable-error-code="type-abstract"
 _DEFAULT_RUNTIME_CLASSES: dict[str, type[Runtime]] = {
     'eventstream': DockerRuntime,
     'docker': DockerRuntime,
-    'e2b': E2BRuntime,
     'remote': RemoteRuntime,
-    'modal': ModalRuntime,
-    'runloop': RunloopRuntime,
     'local': LocalRuntime,
-    'daytona': DaytonaRuntime,
     'kubernetes': KubernetesRuntime,
     'cli': CLIRuntime,
 }
 
+# Try to import third-party runtimes if available
+_THIRD_PARTY_RUNTIME_CLASSES: dict[str, type[Runtime]] = {}
+
+# Dynamically discover and import third-party runtimes
+
+# Check if third_party package exists and discover runtimes
+try:
+    import third_party.runtime.impl
+
+    third_party_base = 'third_party.runtime.impl'
+
+    # List of potential third-party runtime modules to try
+    # These are discovered from the third_party directory structure
+    potential_runtimes = []
+    try:
+        import pkgutil
+
+        for importer, modname, ispkg in pkgutil.iter_modules(
+            third_party.runtime.impl.__path__
+        ):
+            if ispkg:
+                potential_runtimes.append(modname)
+    except Exception:
+        # If discovery fails, no third-party runtimes will be loaded
+        potential_runtimes = []
+
+    # Try to import each discovered runtime
+    for runtime_name in potential_runtimes:
+        try:
+            module_path = f'{third_party_base}.{runtime_name}.{runtime_name}_runtime'
+            module = importlib.import_module(module_path)
+
+            # Try different class name patterns
+            possible_class_names = [
+                f'{runtime_name.upper()}Runtime',  # E2BRuntime
+                f'{runtime_name.capitalize()}Runtime',  # E2bRuntime, DaytonaRuntime, etc.
+            ]
+
+            runtime_class = None
+            for class_name in possible_class_names:
+                try:
+                    runtime_class = getattr(module, class_name)
+                    break
+                except AttributeError:
+                    continue
+
+            if runtime_class:
+                _THIRD_PARTY_RUNTIME_CLASSES[runtime_name] = runtime_class
+
+        except ImportError:
+            pass
+
+except ImportError:
+    # third_party package not available
+    pass
+
+# Combine core and third-party runtimes
+_ALL_RUNTIME_CLASSES = {**_DEFAULT_RUNTIME_CLASSES, **_THIRD_PARTY_RUNTIME_CLASSES}
+
 
 def get_runtime_cls(name: str) -> type[Runtime]:
     """
     If name is one of the predefined runtime names (e.g. 'docker'), return its class.
     Otherwise attempt to resolve name as subclass of Runtime and return it.
     Raise on invalid selections.
     """
-    if name in _DEFAULT_RUNTIME_CLASSES:
-        return _DEFAULT_RUNTIME_CLASSES[name]
+    if name in _ALL_RUNTIME_CLASSES:
+        return _ALL_RUNTIME_CLASSES[name]
     try:
         return get_impl(Runtime, name)
     except Exception as e:
-        known_keys = _DEFAULT_RUNTIME_CLASSES.keys()
+        known_keys = _ALL_RUNTIME_CLASSES.keys()
         raise ValueError(
             f'Runtime {name} not supported, known are: {known_keys}'
         ) from e
 
 
+# Build __all__ list dynamically based on available runtimes
 __all__ = [
     'Runtime',
-    'E2BRuntime',
     'RemoteRuntime',
-    'ModalRuntime',
-    'RunloopRuntime',
     'DockerRuntime',
-    'DaytonaRuntime',
     'KubernetesRuntime',
     'CLIRuntime',
+    'LocalRuntime',
     'get_runtime_cls',
 ]
+
+# Add third-party runtimes to __all__ if they're available
+for runtime_name, runtime_class in _THIRD_PARTY_RUNTIME_CLASSES.items():
+    __all__.append(runtime_class.__name__)

openhands/runtime/base.py

@@ -100,11 +100,10 @@ class Runtime(FileEditRuntimeMixin):
 
     Built-in implementations include:
     - DockerRuntime: Containerized environment using Docker
-    - E2BRuntime: Secure sandbox using E2B
     - RemoteRuntime: Remote execution environment
-    - ModalRuntime: Scalable cloud environment using Modal
     - LocalRuntime: Local execution for development
-    - DaytonaRuntime: Cloud development environment using Daytona
+    - KubernetesRuntime: Kubernetes-based execution environment
+    - CLIRuntime: Command-line interface runtime
 
     Args:
         sid: Session ID that uniquely identifies the current user session

openhands/runtime/impl/__init__.py

@@ -6,22 +6,14 @@
     ActionExecutionClient,
 )
 from openhands.runtime.impl.cli import CLIRuntime
-from openhands.runtime.impl.daytona.daytona_runtime import DaytonaRuntime
 from openhands.runtime.impl.docker.docker_runtime import DockerRuntime
-from openhands.runtime.impl.e2b.e2b_runtime import E2BRuntime
 from openhands.runtime.impl.local.local_runtime import LocalRuntime
-from openhands.runtime.impl.modal.modal_runtime import ModalRuntime
 from openhands.runtime.impl.remote.remote_runtime import RemoteRuntime
-from openhands.runtime.impl.runloop.runloop_runtime import RunloopRuntime
 
 __all__ = [
     'ActionExecutionClient',
     'CLIRuntime',
-    'DaytonaRuntime',
     'DockerRuntime',
-    'E2BRuntime',
     'LocalRuntime',
-    'ModalRuntime',
     'RemoteRuntime',
-    'RunloopRuntime',
 ]