feat: add E2B sandbox support

Add a new E2BREPL environment that runs Python code in E2B sandboxes,
following the same HTTP broker pattern as ModalREPL and PrimeREPL.

Changes:
- Add rlm/environments/e2b_repl.py with E2BREPL class
- Add examples/e2b_repl_example.py demonstrating usage
- Register "e2b" environment in environments/__init__.py
- Add "e2b" to EnvironmentType in core/types.py
- Add e2b optional dependency to pyproject.toml

Key implementation details:
- Uses e2b-code-interpreter SDK with Sandbox.create() API
- Runs Flask broker on port 8889 (8888 is used by E2B's Jupyter)
- Uses sandbox.get_host(port) for public URL access
- Supports llm_query(), llm_query_batched(), FINAL_VAR()

Author: alt-glitch

examples/e2b_repl_example.py

@@ -0,0 +1,107 @@
+"""
+Example usage of E2B REPL with code execution and LLM queries.
+
+Run with: python -m examples.e2b_repl_example
+
+Requires E2B API key set in environment:
+    export E2B_API_KEY=your_api_key
+"""
+
+from rlm.clients.base_lm import BaseLM
+from rlm.core.lm_handler import LMHandler
+from rlm.core.types import ModelUsageSummary, UsageSummary
+from rlm.environments.e2b_repl import E2BREPL
+
+
+class MockLM(BaseLM):
+    """Simple mock LM that echoes prompts."""
+
+    def __init__(self):
+        super().__init__(model_name="mock-model")
+
+    def completion(self, prompt):
+        return f"Mock response to: {prompt[:50]}"
+
+    async def acompletion(self, prompt):
+        return self.completion(prompt)
+
+    def get_usage_summary(self):
+        return UsageSummary(
+            model_usage_summaries={
+                "mock-model": ModelUsageSummary(
+                    total_calls=1, total_input_tokens=10, total_output_tokens=10
+                )
+            }
+        )
+
+    def get_last_usage(self):
+        return self.get_usage_summary()
+
+
+def main():
+    print("=" * 60)
+    print("E2B REPL Example")
+    print("=" * 60)
+
+    # Example 1: Basic code execution
+    print("\n[1] Basic code execution (no LLM handler)")
+    print("-" * 40)
+
+    with E2BREPL(timeout=300) as repl:
+        print(f"E2B sandbox created, ID: {repl.sandbox_id}")
+
+        result = repl.execute_code("x = 1 + 2")
+        print("Executed: x = 1 + 2")
+        print(f"Locals: {result.locals}")
+
+        result = repl.execute_code("print(x * 2)")
+        print("Executed: print(x * 2)")
+        print(f"Stdout: {result.stdout.strip()}")
+
+        result = repl.execute_code("answer = 42")
+        result = repl.execute_code('print(FINAL_VAR("answer"))')
+        print(f"FINAL_VAR('answer'): {result.stdout.strip()}")
+
+    # Example 2: With LLM handler
+    print("\n[2] Code execution with LLM handler")
+    print("-" * 40)
+
+    mock_client = MockLM()
+
+    with LMHandler(client=mock_client) as handler:
+        print(f"LM Handler started at {handler.address}")
+
+        with E2BREPL(
+            timeout=300,
+            lm_handler_address=handler.address,
+        ) as repl:
+            print(f"E2B sandbox created, ID: {repl.sandbox_id}")
+            print(f"Broker URL: {repl.broker_url}")
+
+            # Single LLM query
+            result = repl.execute_code('response = llm_query("What is 2+2?")')
+            print("Executed: response = llm_query('What is 2+2?')")
+            print(f"Stderr: {result.stderr or '(none)'}")
+
+            result = repl.execute_code("print(response)")
+            print(f"Response: {result.stdout.strip()}")
+
+            # Batched LLM query
+            result = repl.execute_code(
+                'responses = llm_query_batched(["Question 1", "Question 2", "Question 3"])'
+            )
+            print("\nExecuted: responses = llm_query_batched([...])")
+
+            result = repl.execute_code("print(f'Got {len(responses)} responses')")
+            print(f"Result: {result.stdout.strip()}")
+
+            result = repl.execute_code("print(responses[0])")
+            print(f"First response: {result.stdout.strip()}")
+
+    print("\n" + "=" * 60)
+    print("Done!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -20,6 +20,7 @@ dependencies = [
 
 [project.optional-dependencies]
 modal = ["modal>=0.73.0", "dill>=0.3.7"]
+e2b = ["e2b-code-interpreter>=0.0.11", "dill>=0.3.7"]
 
 [build-system]
 requires = ["setuptools>=61.0"]

rlm/core/types.py

@@ -5,7 +5,7 @@
 ClientBackend = Literal[
     "openai", "portkey", "openrouter", "vllm", "litellm", "anthropic", "azure_openai", "gemini"
 ]
-EnvironmentType = Literal["local", "prime", "modal"]
+EnvironmentType = Literal["local", "docker", "modal", "prime", "e2b"]
 
 
 def _serialize_value(value: Any) -> Any:

rlm/environments/__init__.py

@@ -5,12 +5,12 @@
 
 
 def get_environment(
-    environment: Literal["local", "modal", "docker"],
+    environment: Literal["local", "modal", "docker", "e2b"],
     environment_kwargs: dict[str, Any],
 ) -> BaseEnv:
     """
     Routes a specific environment and the args (as a dict) to the appropriate environment if supported.
-    Currently supported environments: ['local', 'modal', 'docker']
+    Currently supported environments: ['local', 'modal', 'docker', 'e2b']
     """
     if environment == "local":
         return LocalREPL(**environment_kwargs)
@@ -22,7 +22,11 @@ def get_environment(
         from rlm.environments.docker_repl import DockerREPL
 
         return DockerREPL(**environment_kwargs)
+    elif environment == "e2b":
+        from rlm.environments.e2b_repl import E2BREPL
+
+        return E2BREPL(**environment_kwargs)
     else:
         raise ValueError(
-            f"Unknown environment: {environment}. Supported: ['local', 'modal', 'docker']"
+            f"Unknown environment: {environment}. Supported: ['local', 'modal', 'docker', 'e2b']"
         )