Upload folder using huggingface_hub

Dockerfile

@@ -11,7 +11,7 @@
 # The build script (openenv build) handles context detection and sets appropriate build args.
 
 ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
-FROM ${BASE_IMAGE} AS builder
+FROM ghcr.io/meta-pytorch/openenv-base:latest AS builder
 
 WORKDIR /app
 
@@ -40,22 +40,26 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 
 # Install dependencies using uv sync
 # If uv.lock exists, use it; otherwise resolve on the fly
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh && \
+    install -m 0755 /root/.local/bin/uv /usr/local/bin/uv && \
+    install -m 0755 /root/.local/bin/uvx /usr/local/bin/uvx
+
 RUN --mount=type=cache,target=/root/.cache/uv \
     if [ -f uv.lock ]; then \
-        uv sync --frozen --no-install-project --no-editable; \
+        uv sync --no-install-project --no-editable; \
     else \
         uv sync --no-install-project --no-editable; \
     fi
 
 RUN --mount=type=cache,target=/root/.cache/uv \
     if [ -f uv.lock ]; then \
-        uv sync --frozen --no-editable; \
+        uv sync --no-editable; \
     else \
         uv sync --no-editable; \
     fi
 
 # Final runtime stage
-FROM ${BASE_IMAGE}
+FROM ghcr.io/meta-pytorch/openenv-base:latest
 
 WORKDIR /app
 
@@ -77,5 +81,6 @@ HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
 
 # Run the FastAPI server
 # The module path is constructed to work with the /app/env structure
-ENV ENABLE_WEB_INTERFACE=true
 CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]
+
+ENV ENABLE_WEB_INTERFACE=true

README.md

@@ -1,16 +1,33 @@
 ---
 title: REPL Environment Server
 emoji: 🎮
-colorFrom: yellow
-colorTo: indigo
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
 app_port: 8000
 base_path: /web
 tags:
+  - openenv-0.2.2
   - openenv
 ---
 
+## Hugging Face Space Deployment
+
+This Space is built from OpenEnv environment `repl_env`.
+
+- Space URL: `https://huggingface.co/spaces/openenv/repl`
+- OpenEnv pinned ref: `0.2.2`
+- Hub tag: `openenv`
+
+### Connecting from Code
+
+```python
+from envs.repl_env import Env
+
+env = Env(base_url="https://huggingface.co/spaces/openenv/repl")
+```
+
 # REPL Environment for OpenEnv
 
 A Python REPL environment for training language models on code execution tasks, based on the [Recursive Language Models (RLM)](https://arxiv.org/abs/2512.24601) paradigm.
@@ -99,7 +116,7 @@ from repl_env import REPLEnv
 env = REPLEnv.from_docker_image("repl-env:latest")
 
 # Or from HuggingFace Hub
-env = REPLEnv.from_hub("openenv/repl-env")
+env = REPLEnv.from_hub("openenv/repl")
 ```
 
 ## API Reference
@@ -431,13 +448,15 @@ uv run --project . server
 
 ### Using Docker
 ```bash
+# From the repl_env directory
+cd envs/repl_env
 docker build -t repl-env:latest -f server/Dockerfile .
 docker run -p 8000:8000 repl-env:latest
 ```
 
 ### Testing
 ```bash
-pytest tests/
+pytest tests/envs/test_repl_env.py
 ```
 
 ## References

__init__.py

@@ -40,20 +40,20 @@ References:
     - Alex Zhang Blog: https://alexzhang13.github.io/blog/2025/rlm/
 """
 
-from .models import REPLAction, REPLObservation, REPLState, CodeBlockResult
 from .client import REPLEnv
+from .models import CodeBlockResult, REPLAction, REPLObservation, REPLState
 from .prompts import (
-    # System prompts
-    RLM_SYSTEM_PROMPT,
-    RLM_SYSTEM_PROMPT_QWEN,
-    # Prompt building
-    QueryMetadata,
+    build_initial_prompt,
     build_rlm_system_prompt,
     build_user_prompt,
-    build_initial_prompt,
     # Parsing utilities
     extract_code_blocks,
-    format_observation,
+    format_observations,
+    # Prompt building
+    QueryMetadata,
+    # System prompts
+    RLM_SYSTEM_PROMPT,
+    RLM_SYSTEM_PROMPT_QWEN,
 )
 
 __all__ = [
@@ -74,5 +74,5 @@ __all__ = [
     "build_initial_prompt",
     # Parsing utilities
     "extract_code_blocks",
-    "format_observation",
+    "format_observations",
 ]

client.py

@@ -38,11 +38,12 @@ from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING
 try:
     from openenv.core.client_types import StepResult
     from openenv.core.env_client import EnvClient
-    from .models import REPLAction, REPLObservation, REPLState, CodeBlockResult
+
+    from .models import CodeBlockResult, REPLAction, REPLObservation, REPLState
 except ImportError:
+    from models import CodeBlockResult, REPLAction, REPLObservation, REPLState
     from openenv.core.client_types import StepResult
     from openenv.core.env_client import EnvClient
-    from models import REPLAction, REPLObservation, REPLState, CodeBlockResult
 
 if TYPE_CHECKING:
     from .server.repl_environment import REPLEnvironment
@@ -265,9 +266,7 @@ class REPLEnv:
         Returns:
             StepResult with done=True.
         """
-        return self.step(
-            REPLAction(code="", is_final=True, final_answer=answer)
-        )
+        return self.step(REPLAction(code="", is_final=True, final_answer=answer))
 
     def get_variable(self, name: str) -> StepResult[REPLObservation]:
         """
@@ -315,9 +314,7 @@ class REPLEnv:
             self._remote_client.close()
             self._remote_client = None
 
-    def _wrap_observation(
-        self, obs: REPLObservation
-    ) -> StepResult[REPLObservation]:
+    def _wrap_observation(self, obs: REPLObservation) -> StepResult[REPLObservation]:
         """Wrap a local REPLObservation in a StepResult."""
         return StepResult(
             observation=obs,

envs/repl_env/README.md

@@ -0,0 +1,450 @@
+---
+title: REPL Environment Server
+emoji: 🎮
+colorFrom: yellow
+colorTo: indigo
+sdk: docker
+pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+---
+
+# REPL Environment for OpenEnv
+
+A Python REPL environment for training language models on code execution tasks, based on the [Recursive Language Models (RLM)](https://arxiv.org/abs/2512.24601) paradigm.
+
+## Overview
+
+The RLM paradigm allows language models to:
+- Execute Python code in a sandboxed REPL environment
+- Make recursive calls to themselves or other LMs via `llm_query()` / `llm_query_batched()`
+- Handle near-infinite context by programmatically decomposing and exploring data
+- Terminate with explicit `FINAL(answer)` or `answer = {"content": ..., "ready": True}` signals
+
+## Features
+
+- **Unified API**: Same `REPLEnv` class works for both local and remote execution
+- **Sandboxed Python Execution**: Safe code execution with restricted builtins
+- **Context Loading**: Load large contexts that agents can explore programmatically
+- **Multiple Finalization Patterns**:
+  - Direct call: `FINAL(answer)` - helper function injected into namespace
+  - Print pattern: `print('FINAL(answer)')` or `print('FINAL_VAR(var_name)')`
+  - Prime Intellect style: `answer = {"content": "...", "ready": True}`
+- **Iteration Limits**: Configurable maximum steps per episode
+- **Reward Signals**: Customizable reward functions for RL training
+- **Optional LLM Oracle**: Can enable `llm_query()` and `llm_query_batched()` for recursive calls
+
+## Quick Start
+
+### Local Mode (No Server Required)
+
+```python
+from repl_env import REPLEnv
+
+# Create environment - runs locally by default
+with REPLEnv() as env:
+    result = env.reset(
+        context="This is a large document with lots of text...",
+        task_prompt="Find the word count"
+    )
+
+    # Execute code iteratively
+    result = env.execute("words = context.split()")
+    result = env.execute("count = len(words)")
+    result = env.execute("print(f'FINAL({count})')")
+
+    print(f"Done: {result.done}")
+    print(f"Final Answer: {env.state().final_answer}")
+```
+
+### Remote Server Mode
+
+```python
+from repl_env import REPLEnv
+
+# Connect to a running server - same API!
+with REPLEnv(base_url="https://my-server.hf.space") as env:
+    result = env.reset(context="...", task_prompt="...")
+    result = env.execute("count = len(context)")
+    result = env.execute("print(f'FINAL({count})')")
+```
+
+### Local Mode with LLM Support
+
+```python
+from repl_env import REPLEnv
+
+def my_llm_query(prompt: str) -> str:
+    return your_llm.generate(prompt)
+
+def my_llm_query_batched(prompts: list[str]) -> list[str]:
+    return [my_llm_query(p) for p in prompts]
+
+# Pass LLM functions for recursive calls
+with REPLEnv(llm_query_fn=my_llm_query, llm_batch_fn=my_llm_query_batched) as env:
+    result = env.reset(context=large_document, task_prompt="Summarize this")
+
+    # Now the executed code can use llm_query() and llm_query_batched()!
+    result = env.execute("summary = llm_query('Summarize: ' + context[:1000])")
+```
+
+### From Docker or HuggingFace Hub
+
+```python
+from repl_env import REPLEnv
+
+# Start from Docker image
+env = REPLEnv.from_docker_image("repl-env:latest")
+
+# Or from HuggingFace Hub
+env = REPLEnv.from_hub("openenv/repl-env")
+```
+
+## API Reference
+
+### REPLEnv
+
+```python
+class REPLEnv:
+    def __init__(
+        self,
+        base_url: str | None = None,      # Server URL (None = local mode)
+        *,
+        # Local-only options
+        llm_query_fn: Callable | None = None,    # Function for llm_query()
+        llm_batch_fn: Callable | None = None,    # Function for llm_query_batched()
+        max_output_length: int = 8192,           # Max stdout/stderr chars
+        context_preview_length: int = 500,       # Chars in context preview
+        reward_on_success: float = 1.0,          # Reward on FINAL()
+        reward_on_iteration: float = 0.0,        # Reward per step
+        reward_on_failure: float = -0.1,         # Reward on max iterations
+        reward_on_error: float = -0.05,          # Reward on execution error
+        # Remote-only options
+        connect_timeout_s: float = 10.0,
+        message_timeout_s: float = 60.0,
+    ): ...
+
+    def reset(
+        self,
+        *,
+        context: str = "",              # Text to analyze (as `context` variable)
+        task_prompt: str = "",          # Task description
+        max_iterations: int = 30,       # Max code execution steps
+        seed: int | None = None,        # Random seed
+        episode_id: str | None = None,  # Custom episode ID
+        hf_token: str | None = None,    # HF token for llm_query (remote mode)
+        llm_model: str | None = None,   # Model for llm_query (remote mode)
+    ) -> StepResult[REPLObservation]: ...
+
+    def execute(self, code: str) -> StepResult[REPLObservation]: ...
+    def step(self, action: REPLAction) -> StepResult[REPLObservation]: ...
+    def submit_final_answer(self, answer: str) -> StepResult[REPLObservation]: ...
+    def state(self) -> REPLState: ...
+    def close(self) -> None: ...
+```
+
+### Action Space
+
+```python
+class REPLAction:
+    code: str = ""                    # Python code to execute
+    is_final: bool = False            # Whether this signals the final answer
+    final_answer: str | None = None   # The final answer (if is_final=True)
+```
+
+### Observation Space
+
+```python
+class REPLObservation:
+    result: CodeBlockResult      # Execution result (stdout, stderr, etc.)
+    context_preview: str | None  # First 500 chars of context
+    context_length: int          # Total context length
+    available_variables: list    # Variables in namespace
+    iteration: int               # Current iteration
+    max_iterations: int          # Max iterations
+    done: bool                   # Episode complete?
+    reward: float                # Step reward
+    metadata: dict               # Additional info (final_answer, etc.)
+```
+
+## Finalization Patterns
+
+### Pattern 1: Direct FINAL() call (recommended)
+```python
+result = env.execute("answer = 42")
+result = env.execute("FINAL(answer)")
+# -> done=True, final_answer="42"
+```
+
+### Pattern 2: FINAL() via print
+```python
+result = env.execute("answer = 42")
+result = env.execute("print(f'FINAL({answer})')")
+# -> done=True, final_answer="42"
+```
+
+### Pattern 3: FINAL_VAR() for variable reference
+```python
+result = env.execute("my_result = 'The answer is 42'")
+# Direct call (recommended) - pass variable name as string
+# FINAL_VAR looks up the variable and returns FINAL(value)
+result = env.execute('FINAL_VAR("my_result")')
+# -> done=True, final_answer="The answer is 42"
+
+# Also works via print (for regex detection)
+result = env.execute("print('FINAL_VAR(my_result)')")
+# -> done=True, final_answer="The answer is 42"
+```
+
+### Pattern 4: Prime Intellect style answer dict
+```python
+result = env.execute("answer['content'] = '42'")
+result = env.execute("answer['ready'] = True")
+# -> done=True, final_answer="42"
+```
+
+## Prompts Module
+
+The `prompts` module provides RLM-style prompts and parsing utilities:
+
+```python
+from repl_env.prompts import (
+    # System prompts (from official RLM repo)
+    RLM_SYSTEM_PROMPT,           # Base prompt with llm_query_batched
+    RLM_SYSTEM_PROMPT_QWEN,      # For Qwen models (adds cost warning)
+
+    # Prompt building
+    QueryMetadata,               # Context metadata dataclass
+    build_rlm_system_prompt,     # Build system messages with metadata
+    build_user_prompt,           # Build user prompt for each iteration
+    build_initial_prompt,        # Convenience wrapper for iteration 0
+
+    # Parsing utilities
+    extract_code_blocks,         # Extract code from ```repl``` or ```python``` blocks
+    format_observation,          # Format execution result for LLM
+)
+
+# Example: Build messages using official RLM style
+query_metadata = QueryMetadata(
+    context_lengths=[len(context)],
+    context_total_length=len(context),
+    context_type="str",
+)
+messages = build_rlm_system_prompt(RLM_SYSTEM_PROMPT_QWEN, query_metadata)
+messages.append(build_user_prompt(root_prompt="Count words in the context", iteration=0))
+
+# Extract code from LLM response (supports ```repl``` and ```python```)
+response = "Here's my solution:\n```repl\ncount = len(context.split())\nFINAL(count)\n```"
+code_blocks = extract_code_blocks(response)  # ["count = len(context.split())\nFINAL(count)"]
+```
+
+## Examples
+
+See the `examples/` directory for complete working examples:
+
+- **`examples/repl_with_llm.py`** - Full RLM loop with local Qwen model
+- **`examples/repl_oolong_simple.py`** - RLM on Oolong benchmark with HuggingFace Inference API
+
+Run examples:
+```bash
+# Full RLM example with local model (requires GPU)
+python examples/repl_with_llm.py
+
+# Oolong benchmark with HF Inference API (requires HF_TOKEN)
+python examples/repl_oolong_simple.py
+```
+
+## Model Usage
+
+### Inference Loop
+
+A typical model inference loop where the LLM generates code and the environment executes it:
+
+```python
+from repl_env import REPLEnv
+from repl_env.prompts import RLM_SYSTEM_PROMPT, build_initial_prompt, extract_code_blocks, format_observation
+
+# Works with both local and remote!
+with REPLEnv(base_url="http://localhost:8000") as env:  # or REPLEnv() for local
+    result = env.reset(
+        context="The quick brown fox jumps over the lazy dog. " * 1000,
+        task_prompt="Count how many times 'fox' appears"
+    )
+
+    messages = [
+        {"role": "system", "content": RLM_SYSTEM_PROMPT},
+        {"role": "user", "content": build_initial_prompt(
+            task_prompt="Count how many times 'fox' appears",
+            context_length=result.observation.context_length,
+            context_preview=result.observation.context_preview,
+            variables=result.observation.available_variables,
+        )},
+    ]
+
+    while not result.done:
+        # Get code from LLM
+        response = your_llm.chat(messages)
+        code_blocks = extract_code_blocks(response)
+
+        for code in code_blocks:
+            result = env.execute(code)
+            if result.done:
+                break
+
+        # Update conversation
+        messages.append({"role": "assistant", "content": response})
+        messages.append({"role": "user", "content": format_observation(result.observation)})
+
+    print(f"Final answer: {env.state().final_answer}")
+```
+
+### Recursive LLM Calls (RLM Paradigm)
+
+The key insight of RLM is that models can make recursive calls to themselves or other LLMs from within the code:
+
+```python
+from repl_env import REPLEnv
+
+def llm_query(prompt: str) -> str:
+    """Single LLM call - model can call this from executed code"""
+    return your_llm.generate(prompt)
+
+def llm_query_batched(prompts: list[str]) -> list[str]:
+    """Batch LLM calls for efficiency (parallel in production)"""
+    return [your_llm.generate(p) for p in prompts]
+
+# Create environment with LLM oracle (local mode)
+with REPLEnv(llm_query_fn=llm_query, llm_batch_fn=llm_query_batched) as env:
+    result = env.reset(
+        context=massive_document,  # Could be 100K+ chars
+        task_prompt="Summarize each section and find key themes"
+    )
+
+    # The model can now generate code like this:
+    code = """
+# Split document into sections
+sections = context.split('\\n\\n')
+
+# Use LLM to summarize each section (recursive call!)
+summaries = llm_query_batched([f"Summarize: {s[:1000]}" for s in sections[:10]])
+
+# Combine summaries
+combined = '\\n'.join(summaries)
+
+# Final synthesis using another LLM call
+answer['content'] = llm_query(f"Find key themes in: {combined}")
+answer['ready'] = True
+"""
+
+    result = env.execute(code)
+    print(f"Done: {result.done}, Answer: {env.state().final_answer}")
+```
+
+### RL Training Integration
+
+For RL training, integrate with frameworks like TRL, prime-rl, or verifiers:
+
+```python
+from repl_env import REPLEnv
+
+def collect_trajectory(env, policy, context, task):
+    """Collect a single trajectory for RL training"""
+    result = env.reset(context=context, task_prompt=task)
+
+    trajectory = []
+    total_reward = 0
+
+    while not result.done:
+        # Policy generates code
+        code = policy.generate(result.observation)
+
+        # Step environment
+        next_result = env.execute(code)
+
+        # Store transition
+        trajectory.append({
+            "observation": result.observation,
+            "action": code,
+            "reward": next_result.reward,
+            "next_observation": next_result.observation,
+            "done": next_result.done,
+        })
+
+        total_reward += next_result.reward
+        result = next_result
+
+    return trajectory, total_reward
+
+# Training loop
+with REPLEnv(
+    reward_on_success=1.0,
+    reward_on_iteration=0.0,
+    reward_on_error=-0.05,
+    reward_on_failure=-0.1,
+) as env:
+    for epoch in range(num_epochs):
+        for context, task, ground_truth in dataset:
+            trajectory, reward = collect_trajectory(env, policy, context, task)
+
+            # Verify answer correctness (optional external reward)
+            if trajectory:
+                final_answer = env.state().final_answer
+                if final_answer == ground_truth:
+                    reward += verification_bonus
+
+            # Update policy (use your RL framework - PPO, GRPO, DPO, etc.)
+            policy.update(trajectory, reward)
+```
+
+### Reward Configuration
+
+Configure rewards for different outcomes:
+
+```python
+env = REPLEnv(
+    reward_on_success=1.0,    # When FINAL() is called
+    reward_on_iteration=0.0,  # Per step (can be negative to encourage efficiency)
+    reward_on_error=-0.05,    # When code execution fails
+    reward_on_failure=-0.1,   # When max iterations reached without answer
+)
+```
+
+## Environment Configuration
+
+| Environment Variable | Description | Default |
+|---------------------|-------------|---------|
+| `REPL_CONTEXT` | Initial context to load | "" |
+| `REPL_TASK_PROMPT` | Task description | "" |
+| `REPL_MAX_ITERATIONS` | Max steps per episode | 30 |
+| `HF_TOKEN` | HuggingFace token for llm_query (server fallback) | None |
+| `LLM_MODEL` | Model for llm_query/llm_query_batched | Qwen/Qwen3-Coder-480B-A35B-Instruct |
+
+## Running the Server
+
+### Using UV
+```bash
+cd envs/repl_env
+uv run --project . server
+```
+
+### Using Docker
+```bash
+# From the repl_env directory
+cd envs/repl_env
+docker build -t repl-env:latest -f server/Dockerfile .
+docker run -p 8000:8000 repl-env:latest
+```
+
+### Testing
+```bash
+pytest tests/envs/test_repl_env.py
+```
+
+## References
+
+- [RLM Paper (arXiv:2512.24601)](https://arxiv.org/abs/2512.24601)
+- [RLM Implementation](https://github.com/alexzhang13/rlm)
+- [Alex Zhang's RLM Blog](https://alexzhang13.github.io/blog/2025/rlm/)
+- [Prime Intellect RLM Blog](https://www.primeintellect.ai/blog/rlm)

envs/repl_env/__init__.py

@@ -0,0 +1,78 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+REPL Environment for OpenEnv.
+
+A Python REPL environment for training language models on code execution tasks,
+based on the Recursive Language Models (RLM) paradigm.
+
+This environment allows language models to:
+- Execute Python code in a sandboxed REPL
+- Work with large contexts loaded as variables
+- Finalize answers via FINAL(), FINAL_VAR(), or answer dict pattern
+- Optionally make recursive LLM calls via llm_query() / llm_query_batched()
+
+Example:
+    >>> from repl_env import REPLEnv, REPLAction
+    >>>
+    >>> # Start from Docker
+    >>> env = REPLEnv.from_docker_image("repl-env:latest")
+    >>>
+    >>> # Reset with context
+    >>> result = env.reset(context="Hello World", task_prompt="Count characters")
+    >>>
+    >>> # Execute code
+    >>> result = env.execute("count = len(context)")
+    >>> result = env.execute("print(f'FINAL({count})')")
+    >>>
+    >>> # Check result
+    >>> print(f"Done: {result.done}, Answer: {result.observation.metadata['final_answer']}")
+    >>>
+    >>> env.close()
+
+References:
+    - RLM Paper: https://arxiv.org/abs/2512.24601
+    - Prime Intellect Blog: https://www.primeintellect.ai/blog/rlm
+    - Alex Zhang Blog: https://alexzhang13.github.io/blog/2025/rlm/
+"""
+
+from .client import REPLEnv
+from .models import CodeBlockResult, REPLAction, REPLObservation, REPLState
+from .prompts import (
+    build_initial_prompt,
+    build_rlm_system_prompt,
+    build_user_prompt,
+    # Parsing utilities
+    extract_code_blocks,
+    format_observations,
+    # Prompt building
+    QueryMetadata,
+    # System prompts
+    RLM_SYSTEM_PROMPT,
+    RLM_SYSTEM_PROMPT_QWEN,
+)
+
+__all__ = [
+    # Models
+    "REPLAction",
+    "REPLObservation",
+    "REPLState",
+    "CodeBlockResult",
+    # Client
+    "REPLEnv",
+    # System prompts
+    "RLM_SYSTEM_PROMPT",
+    "RLM_SYSTEM_PROMPT_QWEN",
+    # Prompt building
+    "QueryMetadata",
+    "build_rlm_system_prompt",
+    "build_user_prompt",
+    "build_initial_prompt",
+    # Parsing utilities
+    "extract_code_blocks",
+    "format_observations",
+]

envs/repl_env/client.py

@@ -0,0 +1,466 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+REPL Environment Client.
+
+This module provides a unified client for the REPL Environment that works
+with both remote servers (via WebSocket) and local execution (no server needed).
+
+Examples:
+    # Connect to remote server with your HF token for sub-LLM calls
+    env = REPLEnv(base_url="https://my-server.hf.space")
+    result = env.reset(
+        context="...",
+        task_prompt="...",
+        hf_token=os.environ["HF_TOKEN"],  # Server uses this for llm_query
+    )
+
+    # Run locally (no server)
+    env = REPLEnv()
+
+    # Local with LLM support
+    env = REPLEnv(llm_query_fn=my_llm, llm_batch_fn=my_batch)
+
+    # All use the same interface
+    result = env.execute("x = len(context)")
+    env.close()
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, List, Optional, TYPE_CHECKING
+
+# Support both in-repo and standalone imports
+try:
+    from openenv.core.client_types import StepResult
+    from openenv.core.env_client import EnvClient
+
+    from .models import CodeBlockResult, REPLAction, REPLObservation, REPLState
+except ImportError:
+    from models import CodeBlockResult, REPLAction, REPLObservation, REPLState
+    from openenv.core.client_types import StepResult
+    from openenv.core.env_client import EnvClient
+
+if TYPE_CHECKING:
+    from .server.repl_environment import REPLEnvironment
+
+
+class REPLEnv:
+    """
+    Unified client for the REPL Environment.
+
+    Works with both remote servers and local execution, providing the same
+    interface regardless of where the code runs.
+
+    Examples:
+        >>> # Connect to a running server
+        >>> with REPLEnv(base_url="http://localhost:8000") as env:
+        ...     result = env.reset(context="Hello World", task_prompt="Count chars")
+        ...     result = env.execute("count = len(context)")
+        ...     result = env.execute("print(f'FINAL({count})')")
+        ...     print(result.done)  # True
+
+        >>> # Run locally without a server
+        >>> with REPLEnv() as env:
+        ...     result = env.reset(context="Hello World", task_prompt="Count chars")
+        ...     result = env.execute("count = len(context)")
+        ...     print(result.observation.result.success)  # True
+
+        >>> # Local with LLM support for recursive calls
+        >>> def my_llm(prompt: str) -> str:
+        ...     return "LLM response"
+        >>> with REPLEnv(llm_query_fn=my_llm) as env:
+        ...     result = env.reset(context="...")
+        ...     result = env.execute("response = llm_query('Summarize: ' + context)")
+
+        >>> # From Docker image
+        >>> env = REPLEnv.from_docker_image("repl-env:latest")
+
+        >>> # From HuggingFace Hub
+        >>> env = REPLEnv.from_hub("openenv/repl-env")
+    """
+
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        *,
+        # Local-only options (ignored when base_url is set)
+        llm_query_fn: Optional[Callable[[str], str]] = None,
+        llm_batch_fn: Optional[Callable[[List[str]], List[str]]] = None,
+        max_output_length: int = 8192,
+        context_preview_length: int = 500,
+        reward_on_success: float = 1.0,
+        reward_on_iteration: float = 0.0,
+        reward_on_failure: float = -0.1,
+        reward_on_error: float = -0.05,
+        # Connection options (ignored when running locally)
+        connect_timeout_s: float = 10.0,
+        message_timeout_s: float = 60.0,
+    ):
+        """
+        Initialize REPL environment.
+
+        Args:
+            base_url: Server URL. If None, runs locally without a server.
+            llm_query_fn: Function for llm_query() calls (local mode only).
+            llm_batch_fn: Function for llm_query_batched() calls (local mode only).
+            max_output_length: Max stdout/stderr chars per execution (local only).
+            context_preview_length: Chars to show in context preview (local only).
+            reward_on_success: Reward when final answer submitted (local only).
+            reward_on_iteration: Reward per iteration step (local only).
+            reward_on_failure: Reward when max iterations reached (local only).
+            reward_on_error: Reward when code execution fails (local only).
+            connect_timeout_s: WebSocket connection timeout (remote only).
+            message_timeout_s: Message response timeout (remote only).
+        """
+        self._base_url = base_url
+        self._local_env: Optional[REPLEnvironment] = None
+        self._remote_client: Optional[_RemoteREPLClient] = None
+
+        # Store local-mode options
+        self._llm_query_fn = llm_query_fn
+        self._llm_batch_fn = llm_batch_fn
+        self._max_output_length = max_output_length
+        self._context_preview_length = context_preview_length
+        self._reward_on_success = reward_on_success
+        self._reward_on_iteration = reward_on_iteration
+        self._reward_on_failure = reward_on_failure
+        self._reward_on_error = reward_on_error
+
+        # Store remote-mode options
+        self._connect_timeout_s = connect_timeout_s
+        self._message_timeout_s = message_timeout_s
+
+        # Provider for container/runtime lifecycle (set by factory methods)
+        self._provider = None
+
+    def _ensure_initialized(self) -> None:
+        """Initialize the appropriate backend (local or remote)."""
+        if self._local_env is not None or self._remote_client is not None:
+            return
+
+        if self._base_url is None:
+            # Local mode: create REPLEnvironment directly
+            from .server.repl_environment import REPLEnvironment
+
+            self._local_env = REPLEnvironment(
+                max_output_length=self._max_output_length,
+                context_preview_length=self._context_preview_length,
+                reward_on_success=self._reward_on_success,
+                reward_on_iteration=self._reward_on_iteration,
+                reward_on_failure=self._reward_on_failure,
+                reward_on_error=self._reward_on_error,
+                llm_query_fn=self._llm_query_fn,
+                llm_batch_fn=self._llm_batch_fn,
+            )
+        else:
+            # Remote mode: create WebSocket client
+            self._remote_client = _RemoteREPLClient(
+                base_url=self._base_url,
+                connect_timeout_s=self._connect_timeout_s,
+                message_timeout_s=self._message_timeout_s,
+                provider=self._provider,
+            )
+            self._remote_client.connect()
+
+    def reset(
+        self,
+        *,
+        context: str = "",
+        task_prompt: str = "",
+        max_iterations: int = 30,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        hf_token: Optional[str] = None,
+        llm_model: Optional[str] = None,
+    ) -> StepResult[REPLObservation]:
+        """
+        Reset the environment for a new episode.
+
+        Args:
+            context: Text content to analyze (accessible as `context` variable).
+            task_prompt: Description of the task to solve.
+            max_iterations: Maximum code execution steps before timeout.
+            seed: Optional random seed for reproducibility.
+            episode_id: Optional custom episode identifier.
+            hf_token: Optional HuggingFace token for llm_query/llm_query_batched.
+                      When provided, the server uses this token for sub-LLM calls
+                      instead of its own configured token.
+                      Security: Token is NOT stored in state or logged.
+            llm_model: Optional model name for LLM functions (default: Qwen3-Coder-480B).
+
+        Returns:
+            StepResult with initial observation.
+        """
+        self._ensure_initialized()
+
+        if self._local_env is not None:
+            # Local mode
+            self._local_env.max_iterations = max_iterations
+            obs = self._local_env.reset(
+                seed=seed,
+                episode_id=episode_id,
+                context=context,
+                task_prompt=task_prompt,
+                hf_token=hf_token,
+                llm_model=llm_model,
+            )
+            return self._wrap_observation(obs)
+        else:
+            # Remote mode
+            assert self._remote_client is not None
+            return self._remote_client.reset(
+                context=context,
+                task_prompt=task_prompt,
+                max_iterations=max_iterations,
+                seed=seed,
+                episode_id=episode_id,
+                hf_token=hf_token,
+                llm_model=llm_model,
+            )
+
+    def step(self, action: REPLAction) -> StepResult[REPLObservation]:
+        """
+        Execute a REPL action.
+
+        Args:
+            action: REPLAction containing code to execute.
+
+        Returns:
+            StepResult with execution observation.
+        """
+        self._ensure_initialized()
+
+        if self._local_env is not None:
+            obs = self._local_env.step(action)
+            return self._wrap_observation(obs)
+        else:
+            assert self._remote_client is not None
+            return self._remote_client.step(action)
+
+    def execute(self, code: str) -> StepResult[REPLObservation]:
+        """
+        Execute Python code in the REPL.
+
+        Convenience method that wraps step() with a code-only action.
+
+        Args:
+            code: Python code to execute.
+
+        Returns:
+            StepResult with execution observation.
+        """
+        return self.step(REPLAction(code=code))
+
+    def submit_final_answer(self, answer: str) -> StepResult[REPLObservation]:
+        """
+        Submit a final answer and terminate the episode.
+
+        Args:
+            answer: The final answer string.
+
+        Returns:
+            StepResult with done=True.
+        """
+        return self.step(REPLAction(code="", is_final=True, final_answer=answer))
+
+    def get_variable(self, name: str) -> StepResult[REPLObservation]:
+        """
+        Retrieve and print a variable from the REPL namespace.
+
+        Args:
+            name: Variable name to retrieve.
+
+        Returns:
+            StepResult with variable value in stdout.
+        """
+        return self.execute(f"print(repr({name}))")
+
+    def state(self) -> REPLState:
+        """
+        Get current environment state.
+
+        Returns:
+            REPLState with current environment information.
+        """
+        self._ensure_initialized()
+
+        if self._local_env is not None:
+            return self._local_env.state
+        else:
+            assert self._remote_client is not None
+            return self._remote_client.state()
+
+    def list_variables(self) -> List[str]:
+        """
+        Get list of available variables in the current session.
+
+        Returns:
+            List of variable names.
+        """
+        return self.state().namespace_keys
+
+    def close(self) -> None:
+        """Clean up resources."""
+        if self._local_env is not None:
+            self._local_env.close()
+            self._local_env = None
+
+        if self._remote_client is not None:
+            self._remote_client.close()
+            self._remote_client = None
+
+    def _wrap_observation(self, obs: REPLObservation) -> StepResult[REPLObservation]:
+        """Wrap a local REPLObservation in a StepResult."""
+        return StepResult(
+            observation=obs,
+            reward=obs.reward,
+            done=obs.done,
+        )
+
+    # Context manager support
+
+    def __enter__(self) -> "REPLEnv":
+        """Enter context manager."""
+        self._ensure_initialized()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit context manager."""
+        self.close()
+
+    # Factory methods
+
+    @classmethod
+    def from_docker_image(
+        cls,
+        image: str,
+        **kwargs: Any,
+    ) -> "REPLEnv":
+        """
+        Create a REPL environment by spinning up a Docker container.
+
+        Args:
+            image: Docker image name to run (e.g., "repl-env:latest").
+            **kwargs: Additional arguments passed to container start.
+
+        Returns:
+            Connected REPLEnv instance.
+        """
+        from openenv.core.containers.runtime import LocalDockerProvider
+
+        provider = LocalDockerProvider()
+        base_url = provider.start_container(image, **kwargs)
+        provider.wait_for_ready(base_url)
+
+        env = cls(base_url=base_url)
+        env._provider = provider
+        env._ensure_initialized()
+        return env
+
+    @classmethod
+    def from_hub(
+        cls,
+        repo_id: str,
+        *,
+        use_docker: bool = True,
+        **kwargs: Any,
+    ) -> "REPLEnv":
+        """
+        Create a REPL environment from a HuggingFace Space.
+
+        Args:
+            repo_id: HuggingFace space identifier (e.g., "openenv/repl-env").
+            use_docker: If True, pull from HF registry. If False, run with UV.
+            **kwargs: Additional arguments passed to provider.
+
+        Returns:
+            Connected REPLEnv instance.
+        """
+        if use_docker:
+            from openenv.core.containers.runtime import LocalDockerProvider
+
+            provider = LocalDockerProvider()
+            tag = kwargs.pop("tag", "latest")
+            image = f"registry.hf.space/{repo_id.replace('/', '-')}:{tag}"
+            base_url = provider.start_container(image, **kwargs)
+            provider.wait_for_ready(base_url)
+        else:
+            from openenv.core.containers.runtime import UVProvider
+
+            project_path = kwargs.pop(
+                "project_path", f"git+https://huggingface.co/spaces/{repo_id}"
+            )
+            provider = UVProvider(project_path=project_path, **kwargs)
+            base_url = provider.start()
+            provider.wait_for_ready()
+
+        env = cls(base_url=base_url)
+        env._provider = provider
+        env._ensure_initialized()
+        return env
+
+
+class _RemoteREPLClient(EnvClient[REPLAction, REPLObservation, REPLState]):
+    """
+    Internal WebSocket client for remote REPL connections.
+
+    This is the original EnvClient-based implementation, now used internally
+    by REPLEnv for remote mode.
+    """
+
+    def _step_payload(self, action: REPLAction) -> Dict:
+        """Convert REPLAction to JSON payload for step request."""
+        return {
+            "code": action.code,
+            "is_final": action.is_final,
+            "final_answer": action.final_answer,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[REPLObservation]:
+        """Parse server response into StepResult[REPLObservation]."""
+        obs_data = payload.get("observation", {})
+        result_data = obs_data.get("result", {})
+
+        observation = REPLObservation(
+            result=CodeBlockResult(
+                stdout=result_data.get("stdout", ""),
+                stderr=result_data.get("stderr", ""),
+                locals_snapshot=result_data.get("locals_snapshot", {}),
+                execution_time=result_data.get("execution_time", 0.0),
+                success=result_data.get("success", True),
+                exception=result_data.get("exception"),
+            ),
+            context_preview=obs_data.get("context_preview"),
+            context_length=obs_data.get("context_length", 0),
+            available_variables=obs_data.get("available_variables", []),
+            iteration=obs_data.get("iteration", 0),
+            max_iterations=obs_data.get("max_iterations", 30),
+            done=payload.get("done", False),
+            reward=payload.get("reward"),
+            metadata=obs_data.get("metadata", {}),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> REPLState:
+        """Parse server response into REPLState object."""
+        return REPLState(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+            context=payload.get("context"),
+            task_prompt=payload.get("task_prompt"),
+            iteration=payload.get("iteration", 0),
+            max_iterations=payload.get("max_iterations", 30),
+            namespace_keys=payload.get("namespace_keys", []),
+            final_answer=payload.get("final_answer"),
+            total_execution_time=payload.get("total_execution_time", 0.0),
+        )

envs/repl_env/models.py

@@ -0,0 +1,110 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Data models for the REPL Environment.
+
+The REPL environment provides a Python REPL for training language models
+on code execution tasks, based on the Recursive Language Models (RLM) paradigm.
+
+Supports two finalization patterns:
+1. RLM-style: print('FINAL(answer)') or print('FINAL_VAR(var_name)')
+2. Prime Intellect style: answer = {"content": "...", "ready": True}
+"""
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+# Support both in-repo and standalone imports
+try:
+    from openenv.core.env_server.types import Action, Observation, State
+except ImportError:
+    from openenv.core.env_server.types import Action, Observation, State
+
+
+class REPLAction(Action):
+    """Action containing Python code to execute in the REPL.
+
+    Supports multiple finalization patterns:
+    1. RLM-style: print('FINAL(answer)') or print('FINAL_VAR(var_name)') in code
+    2. Prime Intellect style: answer = {"content": "...", "ready": True} in namespace
+    3. Explicit: Set is_final=True with final_answer
+    """
+
+    code: str = Field(default="", description="Python code to execute")
+    is_final: bool = Field(
+        default=False,
+        description="Whether this action signals the final answer",
+    )
+    final_answer: Optional[str] = Field(
+        default=None, description="Final answer if is_final=True"
+    )
+
+
+class CodeBlockResult(BaseModel):
+    """Result of executing a single code block."""
+
+    stdout: str = Field(default="", description="Standard output from execution")
+    stderr: str = Field(default="", description="Standard error from execution")
+    locals_snapshot: Dict[str, str] = Field(
+        default_factory=dict,
+        description="String representations of new/modified variables",
+    )
+    execution_time: float = Field(
+        default=0.0, ge=0, description="Execution time in seconds"
+    )
+    success: bool = Field(default=True, description="Whether execution succeeded")
+    exception: Optional[str] = Field(
+        default=None, description="Exception message if execution failed"
+    )
+
+
+class REPLObservation(Observation):
+    """Observation returned after code execution in the REPL."""
+
+    result: CodeBlockResult = Field(
+        default_factory=CodeBlockResult, description="Result of code execution"
+    )
+    context_preview: Optional[str] = Field(
+        default=None,
+        description="Preview of the context (first N chars) if context is loaded",
+    )
+    context_length: int = Field(
+        default=0, ge=0, description="Total length of context in characters"
+    )
+    available_variables: List[str] = Field(
+        default_factory=list,
+        description="List of variable names available in the namespace",
+    )
+    iteration: int = Field(default=0, ge=0, description="Current iteration number")
+    max_iterations: int = Field(
+        default=30, ge=1, description="Maximum allowed iterations"
+    )
+
+
+class REPLState(State):
+    """Extended state for REPL environment."""
+
+    context: Optional[str] = Field(
+        default=None, description="The context/problem to work with"
+    )
+    task_prompt: Optional[str] = Field(
+        default=None, description="The task description to solve"
+    )
+    iteration: int = Field(default=0, ge=0, description="Current iteration number")
+    max_iterations: int = Field(
+        default=30, ge=1, description="Max iterations before termination"
+    )
+    namespace_keys: List[str] = Field(
+        default_factory=list, description="Variables currently in namespace"
+    )
+    final_answer: Optional[str] = Field(
+        default=None, description="Final answer if episode is complete"
+    )
+    total_execution_time: float = Field(
+        default=0.0, ge=0, description="Total code execution time in seconds"
+    )

envs/repl_env/openenv.yaml

@@ -0,0 +1,6 @@
+spec_version: 1
+name: repl
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000

envs/repl_env/prompts.py

@@ -0,0 +1,389 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+RLM System Prompts and Parsing Utilities for the REPL Environment.
+
+Based on the official RLM repo: https://github.com/alexzhang13/rlm
+
+Two versions available:
+- RLM_SYSTEM_PROMPT: Base prompt from the repo (with llm_query_batched)
+- RLM_SYSTEM_PROMPT_QWEN: For Qwen3-Coder-480B (adds IMPORTANT cost warning)
+
+Parsing utilities help extract code blocks and format observations.
+"""
+
+import re
+import textwrap
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+# =============================================================================
+# Query Metadata (for context info)
+# =============================================================================
+
+
+@dataclass
+class QueryMetadata:
+    """Metadata about the context for building prompts."""
+
+    context_lengths: List[int]
+    context_total_length: int
+    context_type: str = "str"  # "str" or "List[str]"
+
+
+# =============================================================================
+# System Prompt from Official RLM Repo
+# =============================================================================
+
+RLM_SYSTEM_PROMPT = textwrap.dedent(
+    """You are tasked with answering a query with associated context. You can access, transform, and analyze this context interactively in a REPL environment that can recursively query sub-LLMs, which you are strongly encouraged to use as much as possible. You will be queried iteratively until you provide a final answer.
+
+    The REPL environment is initialized with:
+1. A `context` variable that contains extremely important information about your query. You should check the content of the `context` variable to understand what you are working with. Make sure you look through it sufficiently as you answer your query.
+2. A `llm_query` function that allows you to query an LLM (that can handle around 500K chars) inside your REPL environment.
+3. A `llm_query_batched` function that allows you to query multiple prompts concurrently: `llm_query_batched(prompts: List[str]) -> List[str]`. This is much faster than sequential `llm_query` calls when you have multiple independent queries. Results are returned in the same order as the input prompts.
+4. The ability to use `print()` statements to view the output of your REPL code and continue your reasoning.
+
+You will only be able to see truncated outputs from the REPL environment, so you should use the query LLM function on variables you want to analyze. You will find this function especially useful when you have to analyze the semantics of the context. Use these variables as buffers to build up your final answer.
+Make sure to explicitly look through the entire context in REPL before answering your query. An example strategy is to first look at the context and figure out a chunking strategy, then break up the context into smart chunks, and query an LLM per chunk with a particular question and save the answers to a buffer, then query an LLM with all the buffers to produce your final answer.
+
+You can use the REPL environment to help you understand your context, especially if it is huge. Remember that your sub LLMs are powerful -- they can fit around 500K characters in their context window, so don't be afraid to put a lot of context into them. For example, a viable strategy is to feed 10 documents per sub-LLM query. Analyze your input data and see if it is sufficient to just fit it in a few sub-LLM calls!
+
+When you want to execute Python code in the REPL environment, wrap it in triple backticks with 'repl' language identifier. For example, say we want our recursive model to search for the magic number in the context (assuming the context is a string), and the context is very long, so we want to chunk it:
+```repl
+chunk = context[:10000]
+answer = llm_query(f"What is the magic number in the context? Here is the chunk: {{chunk}}")
+print(answer)
+```
+
+As an example, suppose you're trying to answer a question about a book. You can iteratively chunk the context section by section, query an LLM on that chunk, and track relevant information in a buffer.
+```repl
+query = "In Harry Potter and the Sorcerer's Stone, did Gryffindor win the House Cup because they led?"
+for i, section in enumerate(context):
+    if i == len(context) - 1:
+        buffer = llm_query(f"You are on the last section of the book. So far you know that: {{buffers}}. Gather from this last section to answer {{query}}. Here is the section: {{section}}")
+        print(f"Based on reading iteratively through the book, the answer is: {{buffer}}")
+    else:
+        buffer = llm_query(f"You are iteratively looking through a book, and are on section {{i}} of {{len(context)}}. Gather information to help answer {{query}}. Here is the section: {{section}}")
+        print(f"After section {{i}} of {{len(context)}}, you have tracked: {{buffer}}")
+```
+
+As another example, when the context isn't that long (e.g. >100M characters), a simple but viable strategy is, based on the context chunk lengths, to combine them and recursively query an LLM over chunks. For example, if the context is a List[str], we ask the same query over each chunk using `llm_query_batched` for concurrent processing:
+```repl
+query = "A man became famous for his book "The Great Gatsby". How many jobs did he have?"
+# Suppose our context is ~1M chars, and we want each sub-LLM query to be ~0.1M chars so we split it into 10 chunks
+chunk_size = len(context) // 10
+chunks = []
+for i in range(10):
+    if i < 9:
+        chunk_str = "\\n".join(context[i*chunk_size:(i+1)*chunk_size])
+    else:
+        chunk_str = "\\n".join(context[i*chunk_size:])
+    chunks.append(chunk_str)
+
+# Use batched query for concurrent processing - much faster than sequential calls!
+prompts = [f"Try to answer the following query: {{query}}. Here are the documents:\\n{{chunk}}. Only answer if you are confident in your answer based on the evidence." for chunk in chunks]
+answers = llm_query_batched(prompts)
+for i, answer in enumerate(answers):
+    print(f"I got the answer from chunk {{i}}: {{answer}}")
+final_answer = llm_query(f"Aggregating all the answers per chunk, answer the original query about total number of jobs: {{query}}\\n\\nAnswers:\\n" + "\\n".join(answers))
+```
+
+As a final example, after analyzing the context and realizing its separated by Markdown headers, we can maintain state through buffers by chunking the context by headers, and iteratively querying an LLM over it:
+```repl
+# After finding out the context is separated by Markdown headers, we can chunk, summarize, and answer
+import re
+sections = re.split(r'### (.+)', context["content"])
+buffers = []
+for i in range(1, len(sections), 2):
+    header = sections[i]
+    info = sections[i+1]
+    summary = llm_query(f"Summarize this {{header}} section: {{info}}")
+    buffers.append(f"{{header}}: {{summary}}")
+final_answer = llm_query(f"Based on these summaries, answer the original query: {{query}}\\n\\nSummaries:\\n" + "\\n".join(buffers))
+```
+In the next step, we can return FINAL_VAR("final_answer").
+
+IMPORTANT: When you are done with the iterative process, you MUST provide a final answer using one of the FINAL functions. Do not use these unless you have completed your task. You have two options:
+1. Use FINAL(value) to provide the answer directly, e.g., FINAL(42) or FINAL(my_variable)
+2. Use FINAL_VAR("variable_name") to return a variable by name, e.g., FINAL_VAR("final_answer")
+
+Think step by step carefully, plan, and execute this plan immediately in your response -- do not just say "I will do this" or "I will do that". Output to the REPL environment and recursive LLMs as much as possible. Remember to explicitly answer the original query in your final answer.
+"""
+)
+
+
+# =============================================================================
+# System Prompt for Qwen3-Coder-480B (with IMPORTANT cost warning from paper)
+# Adds cost warning after the "sub LLMs are powerful" paragraph
+# =============================================================================
+
+RLM_SYSTEM_PROMPT_QWEN = textwrap.dedent(
+    """You are tasked with answering a query with associated context. You can access, transform, and analyze this context interactively in a REPL environment that can recursively query sub-LLMs, which you are strongly encouraged to use as much as possible. You will be queried iteratively until you provide a final answer.
+
+The REPL environment is initialized with:
+1. A `context` variable that contains extremely important information about your query. You should check the content of the `context` variable to understand what you are working with. Make sure you look through it sufficiently as you answer your query.
+2. A `llm_query` function that allows you to query an LLM (that can handle around 500K chars) inside your REPL environment.
+3. A `llm_query_batched` function that allows you to query multiple prompts concurrently: `llm_query_batched(prompts: List[str]) -> List[str]`. This is much faster than sequential `llm_query` calls when you have multiple independent queries. Results are returned in the same order as the input prompts.
+4. The ability to use `print()` statements to view the output of your REPL code and continue your reasoning.
+
+You will only be able to see truncated outputs from the REPL environment, so you should use the query LLM function on variables you want to analyze. You will find this function especially useful when you have to analyze the semantics of the context. Use these variables as buffers to build up your final answer.
+Make sure to explicitly look through the entire context in REPL before answering your query. An example strategy is to first look at the context and figure out a chunking strategy, then break up the context into smart chunks, and query an LLM per chunk with a particular question and save the answers to a buffer, then query an LLM with all the buffers to produce your final answer.
+
+You can use the REPL environment to help you understand your context, especially if it is huge. Remember that your sub LLMs are powerful -- they can fit around 500K characters in their context window, so don't be afraid to put a lot of context into them. For example, a viable strategy is to feed 10 documents per sub-LLM query. Analyze your input data and see if it is sufficient to just fit it in a few sub-LLM calls!
+
+IMPORTANT: Be very careful about using 'llm_query' as it incurs high runtime costs. Always batch as much information as reasonably possible into each call (aim for around ~200k characters per call). For example, if you have 1000 lines of information to process, it's much better to split into chunks of 5 and call 'llm_query' on each chunk (200 calls total) rather than making 1000 individual calls. Minimize the number of 'llm_query' calls by batching related information together.
+
+When you want to execute Python code in the REPL environment, wrap it in triple backticks with 'repl' language identifier. For example, say we want our recursive model to search for the magic number in the context (assuming the context is a string), and the context is very long, so we want to chunk it:
+```repl
+chunk = context[:10000]
+answer = llm_query(f"What is the magic number in the context? Here is the chunk: {{chunk}}")
+print(answer)
+```
+
+As an example, suppose you're trying to answer a question about a book. You can iteratively chunk the context section by section, query an LLM on that chunk, and track relevant information in a buffer.
+```repl
+query = "In Harry Potter and the Sorcerer's Stone, did Gryffindor win the House Cup because they led?"
+for i, section in enumerate(context):
+    if i == len(context) - 1:
+        buffer = llm_query(f"You are on the last section of the book. So far you know that: {{buffers}}. Gather from this last section to answer {{query}}. Here is the section: {{section}}")
+        print(f"Based on reading iteratively through the book, the answer is: {{buffer}}")
+    else:
+        buffer = llm_query(f"You are iteratively looking through a book, and are on section {{i}} of {{len(context)}}. Gather information to help answer {{query}}. Here is the section: {{section}}")
+        print(f"After section {{i}} of {{len(context)}}, you have tracked: {{buffer}}")
+```
+
+As another example, when the context isn't that long (e.g. >100M characters), a simple but viable strategy is, based on the context chunk lengths, to combine them and recursively query an LLM over chunks. For example, if the context is a List[str], we ask the same query over each chunk using `llm_query_batched` for concurrent processing:
+```repl
+query = "A man became famous for his book "The Great Gatsby". How many jobs did he have?"
+# Suppose our context is ~1M chars, and we want each sub-LLM query to be ~0.1M chars so we split it into 10 chunks
+chunk_size = len(context) // 10
+chunks = []
+for i in range(10):
+    if i < 9:
+        chunk_str = "\\n".join(context[i*chunk_size:(i+1)*chunk_size])
+    else:
+        chunk_str = "\\n".join(context[i*chunk_size:])
+    chunks.append(chunk_str)
+
+# Use batched query for concurrent processing - much faster than sequential calls!
+prompts = [f"Try to answer the following query: {{query}}. Here are the documents:\\n{{chunk}}. Only answer if you are confident in your answer based on the evidence." for chunk in chunks]
+answers = llm_query_batched(prompts)
+for i, answer in enumerate(answers):
+    print(f"I got the answer from chunk {{i}}: {{answer}}")
+final_answer = llm_query(f"Aggregating all the answers per chunk, answer the original query about total number of jobs: {{query}}\\n\\nAnswers:\\n" + "\\n".join(answers))
+```
+
+As a final example, after analyzing the context and realizing its separated by Markdown headers, we can maintain state through buffers by chunking the context by headers, and iteratively querying an LLM over it:
+```repl
+# After finding out the context is separated by Markdown headers, we can chunk, summarize, and answer
+import re
+sections = re.split(r'### (.+)', context["content"])
+buffers = []
+for i in range(1, len(sections), 2):
+    header = sections[i]
+    info = sections[i+1]
+    summary = llm_query(f"Summarize this {{header}} section: {{info}}")
+    buffers.append(f"{{header}}: {{summary}}")
+final_answer = llm_query(f"Based on these summaries, answer the original query: {{query}}\\n\\nSummaries:\\n" + "\\n".join(buffers))
+```
+In the next step, we can return FINAL_VAR("final_answer").
+
+IMPORTANT: When you are done with the iterative process, you MUST provide a final answer using one of the FINAL functions. Do not use these unless you have completed your task. You have two options:
+1. Use FINAL(value) to provide the answer directly, e.g., FINAL(42) or FINAL(my_variable)
+2. Use FINAL_VAR("variable_name") to return a variable by name, e.g., FINAL_VAR("final_answer")
+
+Think step by step carefully, plan, and execute this plan immediately in your response -- do not just say "I will do this" or "I will do that". Output to the REPL environment and recursive LLMs as much as possible. Remember to explicitly answer the original query in your final answer.
+"""
+)
+
+
+# =============================================================================
+# User Prompt Templates (from official RLM repo)
+# =============================================================================
+
+USER_PROMPT = """Think step-by-step on what to do using the REPL environment (which contains the context) to answer the prompt.\n\nContinue using the REPL environment, which has the `context` variable, and querying sub-LLMs by writing to ```repl``` tags, and determine your answer. Your next action:"""
+
+USER_PROMPT_WITH_ROOT = """Think step-by-step on what to do using the REPL environment (which contains the context) to answer the original prompt: \"{root_prompt}\".\n\nContinue using the REPL environment, which has the `context` variable, and querying sub-LLMs by writing to ```repl``` tags, and determine your answer. Your next action:"""
+
+
+# =============================================================================
+# Prompt Building Functions (from official RLM repo)
+# =============================================================================
+
+
+def build_rlm_system_prompt(
+    system_prompt: str,
+    query_metadata: QueryMetadata,
+) -> List[dict]:
+    """
+    Build the initial system prompt for the REPL environment based on extra prompt metadata.
+
+    Args:
+        system_prompt: The system prompt to use
+        query_metadata: QueryMetadata object containing context metadata
+
+    Returns:
+        List of message dictionaries [system, assistant(metadata)]
+    """
+    context_lengths = query_metadata.context_lengths
+    context_total_length = query_metadata.context_total_length
+    context_type = query_metadata.context_type
+
+    # If there are more than 100 chunks, truncate to the first 100 chunks.
+    if len(context_lengths) > 100:
+        others = len(context_lengths) - 100
+        context_lengths_str = (
+            str(context_lengths[:100]) + "... [" + str(others) + " others]"
+        )
+    else:
+        context_lengths_str = str(context_lengths)
+
+    metadata_prompt = f"Your context is a {context_type} with {context_total_length} total characters, and is broken up into chunks of char lengths: {context_lengths_str}."
+
+    return [
+        {"role": "system", "content": system_prompt},
+        {"role": "assistant", "content": metadata_prompt},
+    ]
+
+
+def build_user_prompt(
+    root_prompt: Optional[str] = None,
+    iteration: int = 0,
+    context_count: int = 1,
+    history_count: int = 0,
+) -> dict:
+    """
+    Build the user prompt for a given iteration.
+
+    Args:
+        root_prompt: The original query/task
+        iteration: Current iteration number (0 = first)
+        context_count: Number of context variables available
+        history_count: Number of prior conversation histories
+
+    Returns:
+        User message dict
+    """
+    if iteration == 0:
+        safeguard = "You have not interacted with the REPL environment or seen your prompt / context yet. Your next action should be to look through and figure out how to answer the prompt, so don't just provide a final answer yet.\n\n"
+        prompt = safeguard + (
+            USER_PROMPT_WITH_ROOT.format(root_prompt=root_prompt)
+            if root_prompt
+            else USER_PROMPT
+        )
+    else:
+        prompt = (
+            "The history before is your previous interactions with the REPL environment. "
+            + (
+                USER_PROMPT_WITH_ROOT.format(root_prompt=root_prompt)
+                if root_prompt
+                else USER_PROMPT
+            )
+        )
+
+    # Inform model about multiple contexts if present
+    if context_count > 1:
+        prompt += f"\n\nNote: You have {context_count} contexts available (context_0 through context_{context_count - 1})."
+
+    # Inform model about prior conversation histories if present
+    if history_count > 0:
+        if history_count == 1:
+            prompt += "\n\nNote: You have 1 prior conversation history available in the `history` variable."
+        else:
+            prompt += f"\n\nNote: You have {history_count} prior conversation histories available (history_0 through history_{history_count - 1})."
+
+    return {"role": "user", "content": prompt}
+
+
+# =============================================================================
+# Convenience Functions (for backward compatibility)
+# =============================================================================
+
+
+def build_initial_prompt(
+    task_prompt: str,
+    context_length: int,
+    context_preview: Optional[str] = None,
+    variables: Optional[List[str]] = None,
+    **kwargs,
+) -> str:
+    """Build the initial user prompt (convenience wrapper).
+
+    Args:
+        task_prompt: The task to accomplish
+        context_length: Total length of the context
+        context_preview: Preview of the context (not used)
+        variables: List of available variable names (not used)
+
+    Returns:
+        Formatted initial prompt string
+    """
+    return build_user_prompt(root_prompt=task_prompt, iteration=0)["content"]
+
+
+# =============================================================================
+# Parsing Utilities
+# =============================================================================
+
+
+def extract_code_blocks(text: str, language: str = "python") -> List[str]:
+    """Extract code blocks from LLM response.
+
+    Supports both ```repl``` (official RLM) and ```python``` style blocks.
+
+    Args:
+        text: The LLM response text
+        language: Language identifier to match (default "python")
+
+    Returns:
+        List of code strings extracted from the response
+    """
+    # Match 'repl' (official) and 'python' (common alternative)
+    patterns = [
+        r"```repl\s*(.*?)```",
+        rf"```{language}\s*(.*?)```",
+    ]
+
+    all_matches = []
+    for pattern in patterns:
+        matches = re.findall(pattern, text, re.DOTALL)
+        all_matches.extend(m.strip() for m in matches if m.strip())
+
+    return all_matches
+
+
+def format_observations(observations) -> str:
+    """Format REPL observations into observation text for the LLM.
+
+    Args:
+        observations: List of REPL observations from env.step()
+
+    Returns:
+        Formatted observation string
+    """
+    formatted = []
+    for i, observation in enumerate(observations, 1):
+        output = (
+            observation.result.stdout.strip()
+            if observation.result.stdout
+            else "(no output)"
+        )
+        if observation.result.success:
+            formatted.append(f"Code block {i} output:\n{output}")
+        else:
+            error = (
+                observation.result.stderr
+                or observation.result.exception
+                or "Unknown error"
+            )
+            formatted.append(
+                f"Code block {i} output:\n{output}\n\nERROR: {error}\n"
+                f"Fix the error in code block {i}. Remember: 'context' is already defined."
+            )
+    return "\n\n".join(formatted)

envs/repl_env/pyproject.toml

@@ -0,0 +1,43 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-repl"
+version = "0.1.0"
+description = "Recursive Language Model REPL Environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv dependencies (required for server functionality)
+    "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git@main",
+    "fastapi>=0.115.0",
+    "pydantic>=2.0.0",
+    "uvicorn>=0.24.0",
+    "requests>=2.31.0",
+    # Environment-specific dependencies
+    "smolagents>=1.22.0,<2",
+    # LLM support via HuggingFace Inference API
+    "huggingface_hub>=0.20.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m repl_env.server.app
+server = "repl_env.server.app:main"
+
+[tool.setuptools]
+# Explicitly list packages - "repl_env" maps to current dir
+packages = ["repl_env", "repl_env.server"]
+package-dir = {"repl_env" = ".", "repl_env.server" = "server"}

envs/repl_env/server/Dockerfile

@@ -0,0 +1,80 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local src/core)
+# - Standalone environments (with openenv from pip)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=repl_env
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv-core is already in the pyproject.toml dependencies
+# For standalone builds, openenv-core will be installed from pip via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+
+# Install git for building from git repos (build-time only)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check using Python (more portable than curl/wget)
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

envs/repl_env/server/__init__.py

@@ -0,0 +1,19 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+REPL Environment Server Components.
+
+This module contains the server-side implementation of the REPL environment.
+"""
+
+from .python_executor import PythonExecutor
+from .repl_environment import REPLEnvironment
+
+__all__ = [
+    "REPLEnvironment",
+    "PythonExecutor",
+]

envs/repl_env/server/app.py

@@ -0,0 +1,92 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the REPL Environment.
+
+This module creates an HTTP server that exposes the REPLEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+The server includes llm_query and llm_query_batched support via HuggingFace Inference API,
+enabling the Recursive Language Model (RLM) paradigm.
+
+LLM Token Configuration:
+    1. Client can pass `hf_token` in reset() - RECOMMENDED
+    2. Server fallback: HF_TOKEN environment variable
+
+LLM functions are created dynamically in REPLEnvironment.reset() based on the
+available token (client or server).
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    uv run --project . server
+
+Environment Variables:
+    HF_TOKEN: Fallback HuggingFace API token (client token takes priority)
+    LLM_MODEL: Model to use for llm_query/llm_query_batched (default: Qwen/Qwen3-Coder-480B-A35B-Instruct)
+"""
+
+import os
+
+# Support both in-repo and standalone imports
+try:
+    # In-repo imports (when running from OpenEnv repository)
+    from openenv.core.env_server.http_server import create_app
+
+    from ..models import REPLAction, REPLObservation
+    from .repl_environment import REPLEnvironment
+except ImportError:
+    from models import REPLAction, REPLObservation
+
+    # Standalone imports (when environment is standalone with openenv from pip)
+    from openenv.core.env_server.http_server import create_app
+    from server.repl_environment import REPLEnvironment
+
+
+# ============== LLM CONFIGURATION ==============
+LLM_MODEL = os.environ.get("LLM_MODEL", "Qwen/Qwen3-Coder-480B-A35B-Instruct")
+HF_TOKEN = os.environ.get("HF_TOKEN", None)
+# ===============================================
+
+# Log LLM configuration
+if HF_TOKEN:
+    print(f"[REPL Server] LLM support ENABLED (server token configured)")
+    print(f"[REPL Server] Default model: {LLM_MODEL}")
+else:
+    print("[REPL Server] No server HF_TOKEN configured")
+    print(
+        "[REPL Server] LLM functions will be enabled if client passes hf_token in reset()"
+    )
+
+# Simple factory - LLM functions are created dynamically in reset() based on token
+env_factory = REPLEnvironment
+
+# Create the app with web interface and README integration
+app = create_app(env_factory, REPLAction, REPLObservation, env_name="repl_env")
+
+
+def main():
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        python -m envs.repl_env.server.app
+        openenv serve repl_env
+    """
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    main()

envs/repl_env/server/python_executor.py

@@ -0,0 +1,339 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Sandboxed Python code executor for the REPL environment.
+
+Uses smolagents.LocalPythonExecutor as the backend for battle-tested sandboxed
+execution, with RLM-specific features on top:
+- Context loading (set_context)
+- Variable access (get_variable, list_variables)
+- Function injection (inject_function for llm_query, llm_query_batched)
+- Output capped at 8,192 characters per turn (configurable)
+- Persistent namespace across code blocks
+"""
+
+import json
+import logging
+import time
+import traceback
+from collections.abc import Callable
+from typing import Any, Dict, List, Optional
+
+from smolagents import LocalPythonExecutor
+
+logger = logging.getLogger(__name__)
+logger.addHandler(logging.NullHandler())
+
+
+class PythonExecutor:
+    """Sandboxed Python code executor with persistent namespace.
+
+    Wraps smolagents.LocalPythonExecutor with RLM-specific features:
+    - Context loading for RLM tasks
+    - Variable tracking for observation
+    - Function injection for llm_query, llm_query_batched
+    - Configurable output length limit (default 8192 chars per Prime Intellect)
+    """
+
+    def __init__(
+        self,
+        max_output_length: int = 8192,
+        allowed_imports: Optional[List[str]] = None,
+    ):
+        """Initialize the executor.
+
+        Args:
+            max_output_length: Maximum characters for stdout/stderr (default 8192)
+            allowed_imports: List of allowed module names for import
+
+        Note:
+            smolagents.LocalPythonExecutor does NOT support wall-clock timeouts.
+            Instead, it limits operations (10M ops) and while iterations (1M).
+        """
+        self.max_output_length = max_output_length
+
+        # Default allowed imports for RLM tasks
+        default_imports = [
+            "re",
+            "json",
+            "math",
+            "random",
+            "collections",
+            "itertools",
+            "functools",
+            "operator",
+            "string",
+            "textwrap",
+            "difflib",
+            "statistics",
+            "decimal",
+            "fractions",
+            "datetime",
+            "copy",
+            "pprint",
+            "typing",
+            "dataclasses",
+            "enum",
+            "bisect",
+            "heapq",
+            "array",
+            "struct",
+            "base64",
+            "hashlib",
+            "hmac",
+            "uuid",
+        ]
+
+        self.allowed_imports = allowed_imports or default_imports
+
+        # Initialize the smolagents executor
+        self._executor = LocalPythonExecutor(
+            additional_authorized_imports=self.allowed_imports
+        )
+
+        # Track variables we've set (for list_variables)
+        self._user_variables: set[str] = set()
+
+        # Track callable functions to register with send_tools
+        self._callable_tools: Dict[str, Callable[..., Any]] = {}
+
+        # Register helper utilities
+        self._register_helpers()
+
+    def _register_helpers(self) -> None:
+        """Register helper functions with the executor."""
+        helpers = {
+            "format_exc": traceback.format_exc,
+            "safe_json_dumps": lambda obj: json.dumps(obj, default=lambda o: repr(o)),
+        }
+        # Register helpers as callable tools
+        for name, func in helpers.items():
+            self.inject_function(name, func)
+
+    def _sync_callable_tools(self) -> None:
+        """Sync callable functions with the executor via send_tools."""
+        if self._callable_tools:
+            try:
+                # Type ignore: smolagents accepts callables despite Tool type hint
+                self._executor.send_tools(self._callable_tools)  # type: ignore[arg-type]
+            except Exception:
+                logger.debug(
+                    "send_tools failed; continuing without extra tools",
+                    exc_info=True,
+                )
+
+    def set_context(self, context: str, variable_name: str = "context") -> None:
+        """Load context into namespace as a variable.
+
+        Args:
+            context: The context string to load
+            variable_name: Name of the variable (default "context")
+        """
+        self.set_variable(variable_name, context)
+
+    def set_variable(self, name: str, value: Any) -> None:
+        """Set a variable in the namespace.
+
+        Args:
+            name: Variable name
+            value: Variable value
+        """
+        # Access the executor's internal state to set variables
+        if hasattr(self._executor, "state"):
+            self._executor.state[name] = value
+        else:
+            # Fallback: store in injected vars for later retrieval
+            self._executor._injected_vars = getattr(
+                self._executor, "_injected_vars", {}
+            )
+            self._executor._injected_vars[name] = value
+
+        self._user_variables.add(name)
+
+    def get_variable(self, name: str) -> Optional[Any]:
+        """Retrieve a variable from namespace.
+
+        Args:
+            name: Variable name
+
+        Returns:
+            The variable value or None if not found
+        """
+        # Try to get from executor's state
+        if hasattr(self._executor, "state"):
+            return self._executor.state.get(name)
+
+        # Fallback to injected vars
+        if hasattr(self._executor, "_injected_vars"):
+            return self._executor._injected_vars.get(name)
+
+        return None
+
+    def list_variables(self) -> List[str]:
+        """List non-private variables in namespace.
+
+        Returns:
+            List of variable names (excluding private and builtins)
+        """
+        variables = set()
+
+        # Get from executor's state
+        if hasattr(self._executor, "state"):
+            for key in self._executor.state:
+                if not key.startswith("_"):
+                    variables.add(key)
+
+        # Include tracked user variables
+        variables.update(self._user_variables)
+
+        return list(variables)
+
+    def execute(self, code: str) -> Dict[str, Any]:
+        """Execute Python code and return results.
+
+        Args:
+            code: Python code to execute
+
+        Returns:
+            Dictionary with stdout, stderr, locals_snapshot, execution_time,
+            success, and exception fields
+        """
+        start_time = time.time()
+        success = True
+        exception_msg = None
+        new_locals: Dict[str, str] = {}
+
+        # Track state before execution
+        pre_state_keys = set()
+        if hasattr(self._executor, "state"):
+            pre_state_keys = set(self._executor.state.keys())
+
+        stdout_parts: list[str] = []
+        stderr_parts: list[str] = []
+
+        try:
+            exec_result = self._executor(code)
+
+            # Extract logs/prints
+            try:
+                logs = getattr(exec_result, "logs", None)
+                if logs:
+                    stdout_parts.append(str(logs))
+            except Exception:
+                logger.debug("Failed to read exec_result.logs", exc_info=True)
+
+            # Extract the result / output value
+            try:
+                if hasattr(exec_result, "output"):
+                    out_val = exec_result.output
+                    if out_val is not None:
+                        try:
+                            stdout_parts.append(json.dumps(out_val))
+                        except Exception:
+                            stdout_parts.append(repr(out_val))
+            except Exception:
+                logger.debug("Failed to read exec_result.output", exc_info=True)
+
+            # Check for errors
+            try:
+                err = getattr(exec_result, "error", None)
+                if err:
+                    stderr_parts.append(str(err))
+                    success = False
+                    exception_msg = str(err)
+            except Exception:
+                logger.debug("Failed to read exec_result.error", exc_info=True)
+
+            try:
+                ex = getattr(exec_result, "exception", None)
+                if ex:
+                    stderr_parts.append(str(ex))
+                    success = False
+                    exception_msg = str(ex)
+            except Exception:
+                logger.debug("Failed to read exec_result.exception", exc_info=True)
+
+            # Determine success from exit_code if available
+            try:
+                if hasattr(exec_result, "exit_code"):
+                    if exec_result.exit_code is not None and exec_result.exit_code != 0:
+                        success = False
+                elif hasattr(exec_result, "success"):
+                    success = bool(exec_result.success)
+            except Exception:
+                logger.debug("Failed to determine exec_result exit code", exc_info=True)
+
+        except Exception as e:
+            success = False
+            exception_msg = f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()}"
+            stderr_parts.append(exception_msg)
+
+        execution_time = time.time() - start_time
+
+        # Capture new/modified variables
+        if hasattr(self._executor, "state"):
+            for key in self._executor.state:
+                if key not in pre_state_keys and not key.startswith("_"):
+                    try:
+                        val = self._executor.state[key]
+                        val_repr = repr(val)
+                        if len(val_repr) > 500:
+                            val_repr = val_repr[:500] + "..."
+                        new_locals[key] = val_repr
+                        self._user_variables.add(key)
+                    except Exception:
+                        new_locals[key] = "<unrepresentable>"
+
+        # Compose stdout/stderr
+        stdout = "\n".join(part for part in stdout_parts if part)
+        stderr = "\n".join(part for part in stderr_parts if part)
+
+        # Truncate output to max_output_length
+        if len(stdout) > self.max_output_length:
+            stdout = (
+                stdout[: self.max_output_length]
+                + f"\n... (truncated, total {len(stdout)} chars)"
+            )
+
+        if len(stderr) > self.max_output_length:
+            stderr = (
+                stderr[: self.max_output_length]
+                + f"\n... (truncated, total {len(stderr)} chars)"
+            )
+
+        return {
+            "stdout": stdout,
+            "stderr": stderr,
+            "locals_snapshot": new_locals,
+            "execution_time": execution_time,
+            "success": success,
+            "exception": exception_msg,
+        }
+
+    def reset(self) -> None:
+        """Reset namespace to initial state."""
+        # Create a new executor instance
+        self._executor = LocalPythonExecutor(
+            additional_authorized_imports=self.allowed_imports
+        )
+        self._user_variables.clear()
+        self._callable_tools.clear()
+        self._register_helpers()
+
+    def inject_function(self, name: str, func: Callable[..., Any]) -> None:
+        """Inject a callable function into the namespace.
+
+        Used for adding llm_query, llm_query_batched, FINAL, etc.
+
+        Args:
+            name: Function name in namespace
+            func: The callable to inject
+        """
+        # Add to callable tools and sync with executor
+        self._callable_tools[name] = func
+        self._user_variables.add(name)
+        self._sync_callable_tools()

envs/repl_env/server/repl_environment.py

@@ -0,0 +1,516 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+REPL Environment Implementation.
+
+A Python REPL environment for training language models on code execution tasks,
+based on the Recursive Language Models (RLM) paradigm.
+
+References:
+- RLM Paper: https://arxiv.org/abs/2512.24601
+- Prime Intellect Blog: https://www.primeintellect.ai/blog/rlm
+- Alex Zhang Blog: https://alexzhang13.github.io/blog/2025/rlm/
+"""
+
+import os
+import re
+from collections.abc import Callable
+from typing import Any, Dict, List, Optional
+from uuid import uuid4
+
+# Support both in-repo and standalone imports
+try:
+    from openenv.core.env_server.interfaces import Environment
+    from openenv.core.env_server.types import EnvironmentMetadata
+except ImportError:
+    from openenv.core.env_server.interfaces import Environment
+    from openenv.core.env_server.types import EnvironmentMetadata
+
+try:
+    from ..models import CodeBlockResult, REPLAction, REPLObservation, REPLState
+except ImportError:
+    from models import CodeBlockResult, REPLAction, REPLObservation, REPLState
+
+try:
+    from .python_executor import PythonExecutor
+except ImportError:
+    from python_executor import PythonExecutor
+
+
+class REPLEnvironment(Environment):
+    """
+    A REPL environment for training language models to use code execution.
+
+    Based on the Recursive Language Models (RLM) paradigm, this environment allows
+    language models to:
+    - Execute Python code in a sandboxed REPL
+    - Work with large contexts loaded as variables
+    - Finalize answers via FINAL(), FINAL_VAR(), or answer dict pattern
+    - Optionally make recursive LLM calls via llm_query() / llm_query_batched()
+
+    Supports two finalization patterns:
+    1. RLM-style: print('FINAL(answer)') or print('FINAL_VAR(var_name)')
+    2. Prime Intellect style: answer = {"content": "...", "ready": True}
+
+    Example:
+        >>> env = REPLEnvironment(context="Hello World", task_prompt="Count chars")
+        >>> obs = env.reset()
+        >>> print(obs.context_preview)  # "Hello World"
+        >>>
+        >>> obs = env.step(REPLAction(code="result = len(context)"))
+        >>> print(obs.result.success)  # True
+        >>> print(obs.available_variables)  # ["context", "result", "answer"]
+        >>>
+        >>> obs = env.step(REPLAction(code="print(f'FINAL({result})')"))
+        >>> print(obs.done)  # True
+        >>> print(obs.metadata["final_answer"])  # "11"
+    """
+
+    SUPPORTS_CONCURRENT_SESSIONS = True
+
+    def __init__(
+        self,
+        context: Optional[str] = None,
+        task_prompt: Optional[str] = None,
+        max_iterations: int = 30,
+        max_output_length: int = 8192,
+        context_preview_length: int = 500,
+        reward_on_success: float = 1.0,
+        reward_on_iteration: float = 0.0,
+        reward_on_failure: float = -0.1,
+        reward_on_error: float = -0.05,
+        llm_query_fn: Optional[Callable[[str], str]] = None,
+        llm_batch_fn: Optional[Callable[[List[str]], List[str]]] = None,
+    ):
+        """Initialize the REPL environment.
+
+        Args:
+            context: Initial context to load (can also be set via REPL_CONTEXT env var)
+            task_prompt: Task description (can also be set via REPL_TASK_PROMPT env var)
+            max_iterations: Maximum steps per episode (default 30, env var REPL_MAX_ITERATIONS)
+            max_output_length: Max chars for stdout/stderr per turn (default 8192)
+            context_preview_length: Chars to show in context preview (default 500)
+            reward_on_success: Reward when final answer is submitted (default 1.0)
+            reward_on_iteration: Reward per iteration step (default 0.0)
+            reward_on_failure: Reward when max iterations reached (default -0.1)
+            reward_on_error: Reward when code execution fails (default -0.05)
+            llm_query_fn: Optional function for llm_query() support
+            llm_batch_fn: Optional function for llm_query_batched() support
+        """
+        self.initial_context = context or os.environ.get("REPL_CONTEXT", "")
+        self.initial_task_prompt = task_prompt or os.environ.get("REPL_TASK_PROMPT", "")
+        self.max_iterations = int(os.environ.get("REPL_MAX_ITERATIONS", max_iterations))
+        self.max_output_length = max_output_length
+        self.context_preview_length = context_preview_length
+
+        # Reward configuration
+        self.reward_on_success = reward_on_success
+        self.reward_on_iteration = reward_on_iteration
+        self.reward_on_failure = reward_on_failure
+        self.reward_on_error = reward_on_error
+
+        # Optional LLM functions for recursive calls
+        self.llm_query_fn = llm_query_fn
+        self.llm_batch_fn = llm_batch_fn
+
+        # State (initialized on reset)
+        self._state: Optional[REPLState] = None
+        self._executor: Optional[PythonExecutor] = None
+
+    def _create_llm_functions(
+        self,
+        hf_token: str,
+        llm_model: Optional[str] = None,
+    ) -> None:
+        """Create LLM functions dynamically using client-provided token.
+
+        This allows clients to use their own HF token instead of the server's.
+
+        Security: The token is used only to initialize the InferenceClient
+        and is NOT stored in state, logged, or persisted anywhere.
+
+        Args:
+            hf_token: HuggingFace API token (not logged or persisted)
+            llm_model: Model to use (default: Qwen/Qwen3-Coder-480B-A35B-Instruct)
+        """
+        from concurrent.futures import as_completed, ThreadPoolExecutor
+
+        try:
+            from huggingface_hub import InferenceClient
+        except ImportError:
+            # huggingface_hub not installed, skip LLM functions
+            return
+
+        model = llm_model or os.environ.get(
+            "LLM_MODEL", "Qwen/Qwen3-Coder-480B-A35B-Instruct"
+        )
+        client = InferenceClient(model=model, token=hf_token)
+
+        def llm_query(prompt: str) -> str:
+            """Query the LLM with a prompt and return the response."""
+            try:
+                messages = [{"role": "user", "content": prompt}]
+                response = client.chat_completion(
+                    messages=messages,
+                    max_tokens=2048,
+                    temperature=0.7,
+                )
+                return response.choices[0].message.content or ""
+            except Exception as e:
+                return f"Error calling LLM: {e}"
+
+        def llm_query_batched(prompts: List[str]) -> List[str]:
+            """Query the LLM with multiple prompts in parallel."""
+            if not prompts:
+                return []
+
+            max_workers = min(len(prompts), 8)
+            results: List[str] = [""] * len(prompts)
+
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                future_to_idx = {
+                    executor.submit(llm_query, prompt): idx
+                    for idx, prompt in enumerate(prompts)
+                }
+                for future in as_completed(future_to_idx):
+                    idx = future_to_idx[future]
+                    try:
+                        results[idx] = future.result()
+                    except Exception as e:
+                        results[idx] = f"Error: {e}"
+
+            return results
+
+        self.llm_query_fn = llm_query
+        self.llm_batch_fn = llm_query_batched
+
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        context: Optional[str] = None,
+        task_prompt: Optional[str] = None,
+        hf_token: Optional[str] = None,
+        llm_model: Optional[str] = None,
+        **kwargs: Any,
+    ) -> REPLObservation:
+        """Reset the environment with optional new context.
+
+        Args:
+            seed: Optional random seed (for reproducibility)
+            episode_id: Optional episode identifier (if not provided, one is generated)
+            context: Context to load (overrides initial_context)
+            task_prompt: Task description (overrides initial_task_prompt)
+            hf_token: Optional HuggingFace token for llm_query/llm_query_batched.
+                      If provided, creates LLM functions using this token.
+                      Security: Token is NOT stored in state or logged.
+            llm_model: Optional model name for LLM functions (default: from env or Qwen3-Coder)
+            **kwargs: Additional reset parameters
+
+        Returns:
+            Initial REPLObservation with environment ready message
+        """
+        effective_context = context or self.initial_context
+        effective_task_prompt = task_prompt or self.initial_task_prompt
+
+        # Create LLM functions if not already provided at init
+        # Priority: client hf_token > server HF_TOKEN env var
+        if not self.llm_query_fn:
+            effective_token = hf_token or os.environ.get("HF_TOKEN")
+            if effective_token:
+                self._create_llm_functions(effective_token, llm_model)
+
+        # Initialize state
+        self._state = REPLState(
+            episode_id=episode_id or str(uuid4()),
+            step_count=0,
+            context=effective_context,
+            task_prompt=effective_task_prompt,
+            iteration=0,
+            max_iterations=self.max_iterations,
+            namespace_keys=[],
+            final_answer=None,
+            total_execution_time=0.0,
+        )
+
+        # Initialize executor
+        self._executor = PythonExecutor(max_output_length=self.max_output_length)
+
+        # Initialize answer dict (Prime Intellect style)
+        self._executor.set_variable("answer", {"content": "", "ready": False})
+
+        # Load context into namespace if provided
+        if effective_context:
+            self._executor.set_context(effective_context)
+
+        # Inject LLM functions if provided
+        # Names: llm_query (single), llm_query_batched (official RLM), llm_batch (alias)
+        if self.llm_query_fn:
+            self._executor.inject_function("llm_query", self.llm_query_fn)
+        if self.llm_batch_fn:
+            self._executor.inject_function(
+                "llm_query_batched", self.llm_batch_fn
+            )  # Official name
+            self._executor.inject_function("llm_batch", self.llm_batch_fn)  # Alias
+
+        # Inject FINAL helper function so both FINAL(x) and print(f'FINAL({x})') work
+        # Returns the FINAL pattern as a string so it appears in stdout for detection
+        def final_helper(value):
+            """Helper that returns FINAL(value) string for detection."""
+            return f"FINAL({value})"
+
+        self._executor.inject_function("FINAL", final_helper)
+
+        # Inject FINAL_VAR helper that looks up variable and returns FINAL(value)
+        # This matches official RLM behavior - strips quotes from var_name and looks up in namespace
+        executor = self._executor  # Capture for closure
+
+        def final_var_helper(var_name: str):
+            """Look up variable by name and return FINAL(value) for detection."""
+            # Strip quotes if present (handles both FINAL_VAR("x") and FINAL_VAR(x))
+            var_name_clean = str(var_name).strip().strip("\"'")
+            # Look up variable in executor namespace
+            value = executor.get_variable(var_name_clean)
+            if value is not None:
+                return f"FINAL({value})"
+            return f"FINAL_VAR({var_name_clean})"  # Fallback for regex detection
+
+        self._executor.inject_function("FINAL_VAR", final_var_helper)
+
+        # Update namespace keys
+        self._state.namespace_keys = self._executor.list_variables()
+
+        # Build initial message
+        message_parts = ["REPL environment initialized."]
+        if effective_context:
+            message_parts.append(
+                f"Context loaded ({len(effective_context)} chars). Use 'context' variable to access it."
+            )
+        if effective_task_prompt:
+            message_parts.append(f"Task: {effective_task_prompt}")
+        message_parts.append(
+            "Use answer['content'] to store your answer, and set answer['ready'] = True when done."
+        )
+
+        return REPLObservation(
+            result=CodeBlockResult(
+                stdout="\n".join(message_parts),
+                stderr="",
+                locals_snapshot={},
+                execution_time=0.0,
+                success=True,
+                exception=None,
+            ),
+            context_preview=(
+                effective_context[: self.context_preview_length]
+                if effective_context
+                else None
+            ),
+            context_length=len(effective_context) if effective_context else 0,
+            available_variables=self._state.namespace_keys,
+            iteration=0,
+            max_iterations=self.max_iterations,
+            done=False,
+            reward=0.0,
+            metadata={
+                "task_prompt": effective_task_prompt,
+                "message": "Environment ready.",
+            },
+        )
+
+    def step(
+        self,
+        action: REPLAction,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> REPLObservation:
+        """Execute code and return observation.
+
+        Args:
+            action: REPLAction containing code to execute
+            timeout_s: Optional timeout in seconds (not currently used)
+            **kwargs: Additional step parameters
+
+        Returns:
+            REPLObservation with execution results
+        """
+        if self._state is None or self._executor is None:
+            raise RuntimeError("Environment not initialized. Call reset() first.")
+
+        self._state.step_count += 1
+        self._state.iteration += 1
+
+        # Check if agent explicitly signals final answer
+        if action.is_final:
+            self._state.final_answer = action.final_answer or ""
+            return self._create_final_observation(
+                success=True,
+                message="Final answer submitted.",
+                reward=self.reward_on_success,
+            )
+
+        # Check iteration limit
+        if self._state.iteration >= self.max_iterations:
+            # Check if there's a partial answer in the answer dict
+            answer_var = self._executor.get_variable("answer")
+            if isinstance(answer_var, dict) and answer_var.get("content"):
+                self._state.final_answer = str(answer_var.get("content", ""))
+            return self._create_final_observation(
+                success=False,
+                message=f"Maximum iterations ({self.max_iterations}) reached.",
+                reward=self.reward_on_failure,
+            )
+
+        # Execute code
+        result = self._executor.execute(action.code)
+        self._state.total_execution_time += result["execution_time"]
+        self._state.namespace_keys = self._executor.list_variables()
+
+        # Calculate reward
+        reward = self.reward_on_iteration
+        if not result["success"]:
+            reward += self.reward_on_error
+
+        # Check for final answer patterns
+        final_answer = self._extract_final_answer(result["stdout"])
+        done = final_answer is not None
+
+        if done:
+            self._state.final_answer = final_answer
+            reward = self.reward_on_success
+
+        return REPLObservation(
+            result=CodeBlockResult(
+                stdout=result["stdout"],
+                stderr=result["stderr"],
+                locals_snapshot=result["locals_snapshot"],
+                execution_time=result["execution_time"],
+                success=result["success"],
+                exception=result["exception"],
+            ),
+            context_preview=(
+                self._state.context[: self.context_preview_length]
+                if self._state.context
+                else None
+            ),
+            context_length=len(self._state.context) if self._state.context else 0,
+            available_variables=self._state.namespace_keys,
+            iteration=self._state.iteration,
+            max_iterations=self.max_iterations,
+            done=done,
+            reward=reward,
+            metadata={
+                "task_prompt": self._state.task_prompt,
+                "final_answer": final_answer,
+                "execution_time": result["execution_time"],
+            },
+        )
+
+    def _extract_final_answer(self, stdout: str) -> Optional[str]:
+        """Extract final answer from output.
+
+        Supports multiple patterns:
+        1. RLM-style: FINAL(answer) in stdout
+        2. RLM-style: FINAL_VAR(variable_name) in stdout
+        3. Prime Intellect style: answer = {"content": "...", "ready": True} in namespace
+
+        Args:
+            stdout: Standard output from code execution
+
+        Returns:
+            Final answer string or None if not found
+        """
+        # Pattern 1: RLM-style FINAL(answer)
+        final_match = re.search(r"FINAL\((.*?)\)", stdout, re.DOTALL)
+        if final_match:
+            return final_match.group(1).strip()
+
+        # Pattern 2: RLM-style FINAL_VAR(variable_name)
+        final_var_match = re.search(r"FINAL_VAR\((\w+)\)", stdout)
+        if final_var_match and self._executor:
+            var_name = final_var_match.group(1)
+            value = self._executor.get_variable(var_name)
+            if value is not None:
+                return str(value)
+
+        # Pattern 3: Prime Intellect style answer dict
+        if self._executor:
+            answer_var = self._executor.get_variable("answer")
+            if isinstance(answer_var, dict):
+                if answer_var.get("ready", False):
+                    return str(answer_var.get("content", ""))
+
+        return None
+
+    def _create_final_observation(
+        self, success: bool, message: str, reward: float
+    ) -> REPLObservation:
+        """Create observation for episode termination.
+
+        Args:
+            success: Whether the episode ended successfully
+            message: Termination message
+            reward: Final reward value
+
+        Returns:
+            Final REPLObservation with done=True
+        """
+        return REPLObservation(
+            result=CodeBlockResult(
+                stdout=message,
+                stderr="",
+                locals_snapshot={},
+                execution_time=0.0,
+                success=success,
+                exception=None,
+            ),
+            context_preview=None,
+            context_length=0,
+            available_variables=[],
+            iteration=self._state.iteration if self._state else 0,
+            max_iterations=self.max_iterations,
+            done=True,
+            reward=reward,
+            metadata={
+                "final_answer": self._state.final_answer if self._state else None,
+                "total_execution_time": (
+                    self._state.total_execution_time if self._state else 0
+                ),
+                "total_iterations": self._state.iteration if self._state else 0,
+            },
+        )
+
+    @property
+    def state(self) -> REPLState:
+        """Get the current environment state.
+
+        Returns:
+            Current REPLState
+
+        Raises:
+            RuntimeError: If environment not initialized
+        """
+        if self._state is None:
+            raise RuntimeError("Environment not initialized. Call reset() first.")
+        return self._state
+
+    def close(self) -> None:
+        """Cleanup resources."""
+        self._executor = None
+        self._state = None
+
+    def get_metadata(self) -> EnvironmentMetadata:
+        """Get environment metadata.
+
+        Returns:
+            EnvironmentMetadata with environment info
+        """
+        return EnvironmentMetadata(
+            name="repl_env",
+            description="Python REPL environment for RLM-style code execution",
+            version="0.1.0",
+        )

models.py

@@ -48,9 +48,7 @@ class REPLAction(Action):
 class CodeBlockResult(BaseModel):
     """Result of executing a single code block."""
 
-    stdout: str = Field(
-        default="", description="Standard output from execution"
-    )
+    stdout: str = Field(default="", description="Standard output from execution")
     stderr: str = Field(default="", description="Standard error from execution")
     locals_snapshot: Dict[str, str] = Field(
         default_factory=dict,
@@ -59,9 +57,7 @@ class CodeBlockResult(BaseModel):
     execution_time: float = Field(
         default=0.0, ge=0, description="Execution time in seconds"
     )
-    success: bool = Field(
-        default=True, description="Whether execution succeeded"
-    )
+    success: bool = Field(default=True, description="Whether execution succeeded")
     exception: Optional[str] = Field(
         default=None, description="Exception message if execution failed"
     )
@@ -84,9 +80,7 @@ class REPLObservation(Observation):
         default_factory=list,
         description="List of variable names available in the namespace",
     )
-    iteration: int = Field(
-        default=0, ge=0, description="Current iteration number"
-    )
+    iteration: int = Field(default=0, ge=0, description="Current iteration number")
     max_iterations: int = Field(
         default=30, ge=1, description="Maximum allowed iterations"
     )
@@ -101,9 +95,7 @@ class REPLState(State):
     task_prompt: Optional[str] = Field(
         default=None, description="The task description to solve"
     )
-    iteration: int = Field(
-        default=0, ge=0, description="Current iteration number"
-    )
+    iteration: int = Field(default=0, ge=0, description="Current iteration number")
     max_iterations: int = Field(
         default=30, ge=1, description="Max iterations before termination"
     )

prompts.py

@@ -358,19 +358,32 @@ def extract_code_blocks(text: str, language: str = "python") -> List[str]:
     return all_matches
 
 
-def format_observation(obs) -> str:
-    """Format a REPLObservation into observation text for the LLM.
+def format_observations(observations) -> str:
+    """Format REPL observations into observation text for the LLM.
 
     Args:
-        obs: The REPLObservation from env.step()
+        observations: List of REPL observations from env.step()
 
     Returns:
         Formatted observation string
     """
-    output = obs.result.stdout.strip() if obs.result.stdout else "(no output)"
-
-    if obs.result.success:
-        return f"Code output:\n{output}"
-    else:
-        error = obs.result.stderr or obs.result.exception or "Unknown error"
-        return f"Code output:\n{output}\n\nERROR: {error}\nFix the error. Remember: 'context' is already defined."
+    formatted = []
+    for i, observation in enumerate(observations, 1):
+        output = (
+            observation.result.stdout.strip()
+            if observation.result.stdout
+            else "(no output)"
+        )
+        if observation.result.success:
+            formatted.append(f"Code block {i} output:\n{output}")
+        else:
+            error = (
+                observation.result.stderr
+                or observation.result.exception
+                or "Unknown error"
+            )
+            formatted.append(
+                f"Code block {i} output:\n{output}\n\nERROR: {error}\n"
+                f"Fix the error in code block {i}. Remember: 'context' is already defined."
+            )
+    return "\n\n".join(formatted)

pyproject.toml

@@ -15,7 +15,7 @@ description = "Recursive Language Model REPL Environment for OpenEnv"
 requires-python = ">=3.10"
 dependencies = [
     # Core OpenEnv dependencies (required for server functionality)
-    "openenv-core @ git+https://github.com/meta-pytorch/OpenEnv.git@v0.2.1",
+    "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git@main",
     "fastapi>=0.115.0",
     "pydantic>=2.0.0",
     "uvicorn>=0.24.0",

server/Dockerfile

@@ -0,0 +1,80 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local src/core)
+# - Standalone environments (with openenv from pip)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=repl_env
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv-core is already in the pyproject.toml dependencies
+# For standalone builds, openenv-core will be installed from pip via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+
+# Install git for building from git repos (build-time only)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check using Python (more portable than curl/wget)
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

server/__init__.py

@@ -10,8 +10,8 @@ REPL Environment Server Components.
 This module contains the server-side implementation of the REPL environment.
 """
 
-from .repl_environment import REPLEnvironment
 from .python_executor import PythonExecutor
+from .repl_environment import REPLEnvironment
 
 __all__ = [
     "REPLEnvironment",

server/app.py

@@ -41,12 +41,14 @@ import os
 try:
     # In-repo imports (when running from OpenEnv repository)
     from openenv.core.env_server.http_server import create_app
+
     from ..models import REPLAction, REPLObservation
     from .repl_environment import REPLEnvironment
 except ImportError:
+    from models import REPLAction, REPLObservation
+
     # Standalone imports (when environment is standalone with openenv from pip)
     from openenv.core.env_server.http_server import create_app
-    from models import REPLAction, REPLObservation
     from server.repl_environment import REPLEnvironment
 
 

server/python_executor.py

@@ -108,9 +108,7 @@ class PythonExecutor:
         """Register helper functions with the executor."""
         helpers = {
             "format_exc": traceback.format_exc,
-            "safe_json_dumps": lambda obj: json.dumps(
-                obj, default=lambda o: repr(o)
-            ),
+            "safe_json_dumps": lambda obj: json.dumps(obj, default=lambda o: repr(o)),
         }
         # Register helpers as callable tools
         for name, func in helpers.items():
@@ -257,30 +255,21 @@ class PythonExecutor:
                     success = False
                     exception_msg = str(ex)
             except Exception:
-                logger.debug(
-                    "Failed to read exec_result.exception", exc_info=True
-                )
+                logger.debug("Failed to read exec_result.exception", exc_info=True)
 
             # Determine success from exit_code if available
             try:
                 if hasattr(exec_result, "exit_code"):
-                    if (
-                        exec_result.exit_code is not None
-                        and exec_result.exit_code != 0
-                    ):
+                    if exec_result.exit_code is not None and exec_result.exit_code != 0:
                         success = False
                 elif hasattr(exec_result, "success"):
                     success = bool(exec_result.success)
             except Exception:
-                logger.debug(
-                    "Failed to determine exec_result exit code", exc_info=True
-                )
+                logger.debug("Failed to determine exec_result exit code", exc_info=True)
 
         except Exception as e:
             success = False
-            exception_msg = (
-                f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()}"
-            )
+            exception_msg = f"{type(e).__name__}: {str(e)}\n{traceback.format_exc()}"
             stderr_parts.append(exception_msg)
 
         execution_time = time.time() - start_time

server/repl_environment.py

@@ -31,9 +31,9 @@ except ImportError:
     from openenv.core.env_server.types import EnvironmentMetadata
 
 try:
-    from ..models import REPLAction, REPLObservation, REPLState, CodeBlockResult
+    from ..models import CodeBlockResult, REPLAction, REPLObservation, REPLState
 except ImportError:
-    from models import REPLAction, REPLObservation, REPLState, CodeBlockResult
+    from models import CodeBlockResult, REPLAction, REPLObservation, REPLState
 
 try:
     from .python_executor import PythonExecutor
@@ -102,12 +102,8 @@ class REPLEnvironment(Environment):
             llm_batch_fn: Optional function for llm_query_batched() support
         """
         self.initial_context = context or os.environ.get("REPL_CONTEXT", "")
-        self.initial_task_prompt = task_prompt or os.environ.get(
-            "REPL_TASK_PROMPT", ""
-        )
-        self.max_iterations = int(
-            os.environ.get("REPL_MAX_ITERATIONS", max_iterations)
-        )
+        self.initial_task_prompt = task_prompt or os.environ.get("REPL_TASK_PROMPT", "")
+        self.max_iterations = int(os.environ.get("REPL_MAX_ITERATIONS", max_iterations))
         self.max_output_length = max_output_length
         self.context_preview_length = context_preview_length
 
@@ -141,7 +137,7 @@ class REPLEnvironment(Environment):
             hf_token: HuggingFace API token (not logged or persisted)
             llm_model: Model to use (default: Qwen/Qwen3-Coder-480B-A35B-Instruct)
         """
-        from concurrent.futures import ThreadPoolExecutor, as_completed
+        from concurrent.futures import as_completed, ThreadPoolExecutor
 
         try:
             from huggingface_hub import InferenceClient
@@ -242,9 +238,7 @@ class REPLEnvironment(Environment):
         )
 
         # Initialize executor
-        self._executor = PythonExecutor(
-            max_output_length=self.max_output_length
-        )
+        self._executor = PythonExecutor(max_output_length=self.max_output_length)
 
         # Initialize answer dict (Prime Intellect style)
         self._executor.set_variable("answer", {"content": "", "ready": False})
@@ -261,9 +255,7 @@ class REPLEnvironment(Environment):
             self._executor.inject_function(
                 "llm_query_batched", self.llm_batch_fn
             )  # Official name
-            self._executor.inject_function(
-                "llm_batch", self.llm_batch_fn
-            )  # Alias
+            self._executor.inject_function("llm_batch", self.llm_batch_fn)  # Alias
 
         # Inject FINAL helper function so both FINAL(x) and print(f'FINAL({x})') work
         # Returns the FINAL pattern as a string so it appears in stdout for detection
@@ -285,9 +277,7 @@ class REPLEnvironment(Environment):
             value = executor.get_variable(var_name_clean)
             if value is not None:
                 return f"FINAL({value})"
-            return (
-                f"FINAL_VAR({var_name_clean})"  # Fallback for regex detection
-            )
+            return f"FINAL_VAR({var_name_clean})"  # Fallback for regex detection
 
         self._executor.inject_function("FINAL_VAR", final_var_helper)
 
@@ -349,9 +339,7 @@ class REPLEnvironment(Environment):
             REPLObservation with execution results
         """
         if self._state is None or self._executor is None:
-            raise RuntimeError(
-                "Environment not initialized. Call reset() first."
-            )
+            raise RuntimeError("Environment not initialized. Call reset() first.")
 
         self._state.step_count += 1
         self._state.iteration += 1
@@ -409,9 +397,7 @@ class REPLEnvironment(Environment):
                 if self._state.context
                 else None
             ),
-            context_length=len(self._state.context)
-            if self._state.context
-            else 0,
+            context_length=len(self._state.context) if self._state.context else 0,
             available_variables=self._state.namespace_keys,
             iteration=self._state.iteration,
             max_iterations=self.max_iterations,
@@ -490,9 +476,7 @@ class REPLEnvironment(Environment):
             done=True,
             reward=reward,
             metadata={
-                "final_answer": self._state.final_answer
-                if self._state
-                else None,
+                "final_answer": self._state.final_answer if self._state else None,
                 "total_execution_time": (
                     self._state.total_execution_time if self._state else 0
                 ),
@@ -511,9 +495,7 @@ class REPLEnvironment(Environment):
             RuntimeError: If environment not initialized
         """
         if self._state is None:
-            raise RuntimeError(
-                "Environment not initialized. Call reset() first."
-            )
+            raise RuntimeError("Environment not initialized. Call reset() first.")
         return self._state
 
     def close(self) -> None:

src/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""EnvTorch: Standardized agentic execution environments."""

src/core/README.md

@@ -0,0 +1,212 @@
+# <img width="35" height="35" alt="image" src="https://github.com/user-attachments/assets/2700a971-e5d6-4036-b03f-2f89c9791609" /> OpenEnv: Agentic Execution Environments
+
+An e2e framework for creating, deploying and using isolated execution environments for agentic RL training, built using Gymnasium style simple APIs. OpenEnv provides a standard for interacting with agentic execution environments via simple Gymnasium style APIs - step(), reset(), state(). Users of agentic execution environments can interact with the environment during RL training loops using these simple APIs.
+
+In addition to making it easier for researchers and RL framework writers, we also provide tools for environment creators making it easier for them to create richer environments and make them available over familiar protocols like HTTP and packaged using canonical technologies like docker. Environment creators can use the OpenEnv framework to create environments that are isolated, secure, and easy to deploy and use.
+
+
+## Overview
+`openenv.core` provides the foundational building blocks for creating and interacting with containerized environments over HTTP. It enables you to build agent environments that can be deployed as Docker containers and accessed via a simple HTTP API.
+
+> ⚠️ **Early Development Warning** OpenEnv is currently in an experimental
+> stage. You should expect bugs, incomplete features, and APIs that may change
+> in future versions. The project welcomes bugfixes, but to make sure things are
+> well coordinated you should discuss any significant change before starting the
+> work. It's recommended that you signal your intention to contribute in the
+> issue tracker, either by filing a new issue or by claiming an existing one.
+
+
+# OpenEnv Core
+
+Core components for OpenEnv - a framework for building HTTP-based agentic environments.
+
+## Features
+
+- **EnvClient**: Async-first client for interacting with remote environments
+- **SyncEnvClient**: Synchronous wrapper via `.sync()` for sync codebases
+- **HTTPEnvServer**: FastAPI-based server wrapper for exposing environments over HTTP/WebSocket
+- **Container Providers**: Pluggable architecture for running containers (Docker, Kubernetes, etc.)
+- **Type System**: Strongly-typed Action/Observation/State interfaces
+- **Web Interface**: Optional web UI for interacting with environments
+
+## Installation
+
+```bash
+pip install "openenv[core]"
+```
+
+For development:
+```bash
+pip install "openenv[core]"
+```
+
+## Quick Start
+
+### Creating an Environment Client
+
+EnvClient is **async by default**. Use `async with` and `await` for all operations:
+
+```python
+import asyncio
+from openenv.core import EnvClient, StepResult
+from dataclasses import dataclass
+from typing import Any
+
+@dataclass
+class MyAction:
+    text: str
+
+@dataclass
+class MyObservation:
+    response: str
+
+class MyEnvClient(EnvClient[MyAction, MyObservation, Any]):
+    def _step_payload(self, action: MyAction) -> dict:
+        return {"text": action.text}
+
+    def _parse_result(self, payload: dict) -> StepResult[MyObservation]:
+        obs_data = payload["observation"]
+        return StepResult(
+            observation=MyObservation(**obs_data),
+            reward=payload.get("reward"),
+            done=payload.get("done", False)
+        )
+
+    def _parse_state(self, payload: dict) -> Any:
+        return payload
+
+# Async usage (recommended)
+async def main():
+    client = await MyEnvClient.from_docker_image("my-env:latest")
+    async with client:
+        result = await client.reset()
+        step_result = await client.step(MyAction(text="hello"))
+
+asyncio.run(main())
+
+# Sync usage (via .sync() wrapper)
+with MyEnvClient(base_url="http://localhost:8000").sync() as client:
+    result = client.reset()
+    step_result = client.step(MyAction(text="hello"))
+```
+
+### Creating an Environment Server
+
+```python
+from openenv.core.env_server import Environment, HTTPEnvServer, create_app
+from dataclasses import dataclass
+
+@dataclass
+class MyAction:
+    text: str
+
+@dataclass
+class MyObservation:
+    response: str
+    reward: float = 0.0
+    done: bool = False
+
+class MyEnvironment(Environment):
+    def reset(self) -> MyObservation:
+        return MyObservation(response="Ready")
+
+    def step(self, action: MyAction) -> MyObservation:
+        return MyObservation(
+            response=f"Echo: {action.text}",
+            reward=1.0,
+            done=False
+        )
+
+# Create FastAPI app
+env = MyEnvironment()
+app = create_app(env, MyAction, MyObservation)
+
+# Run with: uvicorn module:app --host 0.0.0.0 --port 8000
+```
+
+## Container Providers
+
+OpenEnv Core supports multiple container providers:
+
+### Local Docker Provider
+
+```python
+from openenv.core.containers.runtime import LocalDockerProvider
+
+provider = LocalDockerProvider()
+base_url = provider.start_container("my-env:latest")
+provider.wait_for_ready(base_url)
+# Use environment...
+provider.stop_container()
+```
+
+### Kubernetes Provider (Coming Soon)
+
+```python
+from openenv.core.containers.runtime import KubernetesProvider
+
+provider = KubernetesProvider(namespace="envs")
+base_url = provider.start_container("my-env:latest")
+# Use environment...
+provider.stop_container()
+```
+
+
+## API Reference
+
+### EnvClient
+
+Async base class for environment clients. Key methods:
+
+- `async connect()`: Establish WebSocket connection
+- `async reset(**kwargs)`: Reset environment
+- `async step(action)`: Execute action
+- `async state()`: Get current state
+- `async close()`: Close connection and cleanup
+- `sync()`: Return a SyncEnvClient wrapper for synchronous usage
+
+Abstract methods to implement:
+- `_step_payload(action)`: Convert action to JSON
+- `_parse_result(payload)`: Parse response to StepResult
+- `_parse_state(payload)`: Parse state response
+
+### SyncEnvClient
+
+Synchronous wrapper around EnvClient. Use `client.sync()` to get one:
+
+```python
+sync_client = async_client.sync()
+with sync_client:
+    result = sync_client.reset()
+    result = sync_client.step(action)
+```
+
+### HTTPEnvServer
+
+Server wrapper with these methods:
+
+- `register_routes(app)`: Register endpoints on FastAPI app
+- `_deserialize_action(data)`: Convert JSON to Action
+- `_serialize_observation(obs)`: Convert Observation to JSON
+
+### Environment Interface
+
+Base interface for environment implementations:
+
+- `reset()`: Reset environment and return initial observation
+- `step(action)`: Execute action and return observation
+- `state`: Property returning current environment state
+
+## License
+
+This project is licensed under the BSD-3-Clause License - see the LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please see the main OpenEnv repository for contribution guidelines.
+
+## Links
+
+- **Homepage**: https://github.com/meta-pytorch/OpenEnv
+- **Documentation**: https://github.com/meta-pytorch/OpenEnv/blob/main/README.md
+- **Bug Tracker**: https://github.com/meta-pytorch/OpenEnv/issues

src/core/__init__.py

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Core components for agentic environments."""
+
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING
+
+from . import env_server
+from .env_server import *  # noqa: F403
+
+if TYPE_CHECKING:
+    from .env_client import EnvClient
+    from .generic_client import GenericAction, GenericEnvClient
+    from .llm_client import (
+        AnthropicClient,
+        create_llm_client,
+        LLMClient,
+        LLMResponse,
+        OpenAIClient,
+        ToolCall,
+    )
+    from .mcp_client import MCPClientBase, MCPToolClient
+    from .sync_client import SyncEnvClient
+
+__all__ = [
+    "EnvClient",
+    "SyncEnvClient",
+    "GenericEnvClient",
+    "GenericAction",
+    "MCPClientBase",
+    "MCPToolClient",
+    "AnthropicClient",
+    "LLMClient",
+    "LLMResponse",
+    "OpenAIClient",
+    "ToolCall",
+    "create_llm_client",
+] + env_server.__all__  # type: ignore
+
+
+_LAZY_ATTRS = {
+    "EnvClient": (".env_client", "EnvClient"),
+    "SyncEnvClient": (".sync_client", "SyncEnvClient"),
+    "GenericEnvClient": (".generic_client", "GenericEnvClient"),
+    "GenericAction": (".generic_client", "GenericAction"),
+    "MCPClientBase": (".mcp_client", "MCPClientBase"),
+    "MCPToolClient": (".mcp_client", "MCPToolClient"),
+    "AnthropicClient": (".llm_client", "AnthropicClient"),
+    "LLMClient": (".llm_client", "LLMClient"),
+    "LLMResponse": (".llm_client", "LLMResponse"),
+    "OpenAIClient": (".llm_client", "OpenAIClient"),
+    "ToolCall": (".llm_client", "ToolCall"),
+    "create_llm_client": (".llm_client", "create_llm_client"),
+}
+
+
+def __getattr__(name: str):
+    if name in _LAZY_ATTRS:
+        module_path, attr_name = _LAZY_ATTRS[name]
+        module = import_module(module_path, __name__)
+        value = getattr(module, attr_name)
+        globals()[name] = value
+        return value
+
+    try:
+        value = getattr(env_server, name)
+    except AttributeError as exc:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from exc
+
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals().keys()) | set(__all__))

src/core/client_types.py

@@ -0,0 +1,23 @@
+# Type definitions for EnvTorch
+from dataclasses import dataclass
+from typing import Generic, Optional, TypeVar
+
+# Generic type for observations
+ObsT = TypeVar("ObsT")
+StateT = TypeVar("StateT")
+
+
+@dataclass
+class StepResult(Generic[ObsT]):
+    """
+    Represents the result of one environment step.
+
+    Attributes:
+        observation: The environment's observation after the action.
+        reward: Scalar reward for this step (optional).
+        done: Whether the episode is finished.
+    """
+
+    observation: ObsT
+    reward: Optional[float] = None
+    done: bool = False

src/core/containers/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Container management for environment servers."""

src/core/containers/images/Dockerfile

@@ -0,0 +1,64 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+#
+# OpenEnv Base Image
+#
+# This is the standard base image for all OpenEnv environment servers.
+# It includes the minimal dependencies needed to run HTTP environment servers
+# and uv for fast dependency management.
+#
+# Build from repo root: docker build -t openenv-base:latest -f src/openenv/core/containers/images/Dockerfile .
+# Tag:   docker tag openenv-base:latest openenv-base:0.2.0
+#
+
+FROM ghcr.io/astral-sh/uv:0.5.27-python3.11-bookworm-slim AS builder
+
+# Set working directory
+WORKDIR /app
+
+# Copy core pyproject.toml and lockfile for dependency installation
+COPY pyproject.toml uv.lock* ./
+
+# Install core dependencies using uv with cache mount
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv pip install --system -r pyproject.toml
+
+# Final runtime stage
+FROM python:3.11-slim
+
+# Set metadata
+LABEL maintainer="OpenEnv Team"
+LABEL description="Base image for OpenEnv based environment servers with uv"
+LABEL version="0.2.0"
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy uv from builder
+COPY --from=builder /usr/local/bin/uv /usr/local/bin/uvx /usr/local/bin/
+
+# Copy installed Python packages from builder
+COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
+
+# Copy console scripts installed by pip (uvicorn, fastapi, etc.)
+COPY --from=builder /usr/local/bin/uvicorn /usr/local/bin/fastapi /usr/local/bin/
+
+# Set working directory
+WORKDIR /app
+
+# Default environment variables
+ENV PYTHONPATH=/app/src
+ENV PYTHONUNBUFFERED=1
+ENV UV_SYSTEM_PYTHON=1
+
+# Default expose port (can be overridden)
+EXPOSE 8000
+
+# Note: CMD should be specified in child Dockerfiles

src/core/containers/images/README.md

@@ -0,0 +1,92 @@
+# OpenEnv Base Image
+
+Standard base image for all OpenEnv environment servers.
+
+## What's Included
+
+| Layer | Size | Contents |
+|-------|------|----------|
+| python:3.11-slim | 200 MB  | Base Python runtime |
+| + Dependencies   | 100 MB  | FastAPI, uvicorn, requests |
+| **Total**        | **~300 MB** | Ready for environment servers |
+
+## Image Sizes
+
+```
+openenv-base:latest   300 MB  (python + fastapi + uvicorn)
+```
+echo-env:latest        500 MB  (python + fastapi + uvicorn + app)
+coding-env:latest      520 MB  (python + fastapi + uvicorn + app + tools)
+another-env:latest     510 MB  (python + fastapi + uvicorn + app)
+---
+Total: 1.5 GB (with lots of duplication)
+```
+
+### With Base Images (✅ Solution)
+```
+openenv-base:latest    300 MB  (python + fastapi + uvicorn)
+echo-env:latest         50 MB  (app only, uses base)
+coding-env:latest       70 MB  (app + tools, uses base)
+another-env:latest      45 MB  (app only, uses base)
+---
+Total: 465 MB (base shared, minimal duplication)
+```
+
+## Building the Base Image
+
+```bash
+# From project root
+docker build -t openenv-base:latest -f src/openenv/core/containers/images/Dockerfile .
+```
+
+## Usage in Environment Dockerfiles
+
+Each environment Dockerfile should start with:
+
+```dockerfile
+FROM openenv-base:latest
+
+# Copy only environment-specific files
+COPY src/openenv/core/ /app/src/openenv/core/
+COPY envs/my_env/ /app/envs/my_env/
+
+# Run the server
+CMD ["uvicorn", "envs.my_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]
+```
+
+## Base Image Contents
+
+- Python 3.11-slim
+- FastAPI >= 0.104.0
+- Uvicorn >= 0.24.0
+- Requests >= 2.25.0
+- curl (for health checks)
+
+## Example: Building Echo Environment
+
+```bash
+# Step 1: Build base image (do this once)
+docker build -t openenv-base:latest -f src/openenv/core/containers/images/Dockerfile .
+
+# Step 2: Build echo environment (uses base)
+docker build -t echo-env:latest -f envs/echo_env/server/Dockerfile .
+
+# Step 3: Run echo environment
+docker run -p 8000:8000 echo-env:latest
+```
+
+## Updating the Base
+
+When dependencies need updating:
+
+1. Update `src/openenv/core/containers/images/Dockerfile`
+2. Rebuild base image
+3. Rebuild all environment images (they'll use new base)
+
+```bash
+# Update base
+docker build -t openenv-base:latest -f src/openenv/core/containers/images/Dockerfile .
+
+# Rebuild environments (they automatically use new base)
+docker build -t echo-env:latest -f envs/echo_env/server/Dockerfile .
+```

src/core/containers/runtime/__init__.py

@@ -0,0 +1,25 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Container runtime providers."""
+
+from .providers import (
+    ContainerProvider,
+    DockerSwarmProvider,
+    KubernetesProvider,
+    LocalDockerProvider,
+    RuntimeProvider,
+)
+from .uv_provider import UVProvider
+
+__all__ = [
+    "ContainerProvider",
+    "DockerSwarmProvider",
+    "LocalDockerProvider",
+    "KubernetesProvider",
+    "RuntimeProvider",
+    "UVProvider",
+]

src/core/containers/runtime/daytona_provider.py

@@ -0,0 +1,572 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Daytona container provider for running OpenEnv environments in Daytona cloud sandboxes.
+
+Requires the ``daytona`` SDK: ``pip install daytona>=0.10``
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import time
+from typing import Any, Callable, Dict, Optional
+
+import yaml
+
+from .providers import ContainerProvider
+
+
+class DaytonaProvider(ContainerProvider):
+    """
+    Container provider that runs environments in Daytona cloud sandboxes.
+
+    Example:
+        >>> provider = DaytonaProvider(api_key="your-key")
+        >>> image = DaytonaProvider.image_from_dockerfile("envs/echo_env/server/Dockerfile")
+        >>> base_url = provider.start_container(image)
+        >>> provider.wait_for_ready(base_url)
+        >>> provider.stop_container()
+    """
+
+    _dockerfile_registry: Dict[str, Dict[str, Any]] = {}
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        public: bool = False,
+        resources: Optional[Any] = None,
+        auto_stop_interval: int = 15,
+        target: Optional[str] = None,
+        on_snapshot_create_logs: Optional[Callable[[str], None]] = None,
+        cmd: Optional[str] = None,
+        create_timeout: float = 300,
+    ):
+        """
+        Args:
+            api_key: Daytona API key. Falls back to ``DAYTONA_API_KEY`` env var.
+            public: If True, the sandbox preview is publicly accessible.
+            resources: Optional ``daytona.Resources`` instance for CPU/memory.
+            auto_stop_interval: Minutes of inactivity before auto-stop (0 disables).
+            target: Daytona target region (e.g. "us").
+            on_snapshot_create_logs: Callback for snapshot build log lines.
+            cmd: Shell command to start the server inside the sandbox.
+            create_timeout: Seconds to wait for sandbox creation (default 300).
+                Heavy images (e.g. with Playwright/Chromium) may need more.
+        """
+        from daytona import Daytona, DaytonaConfig
+
+        config_kwargs: Dict[str, Any] = {}
+        resolved_key = api_key or os.environ.get("DAYTONA_API_KEY")
+        if resolved_key:
+            config_kwargs["api_key"] = resolved_key
+        if target:
+            config_kwargs["target"] = target
+
+        self._daytona = Daytona(DaytonaConfig(**config_kwargs))
+        self._public = public
+        self._resources = resources
+        self._auto_stop_interval = auto_stop_interval
+        self._on_snapshot_create_logs = on_snapshot_create_logs
+        self._cmd = cmd
+        self._create_timeout = create_timeout
+        self._sandbox: Any = None
+        self._preview_url: Optional[str] = None
+
+    def _discover_server_cmd(self, sandbox: Any, port: int = 8000) -> str:
+        """Discover the server command from ``openenv.yaml`` inside *sandbox*.
+
+        Finds the file, reads the ``app`` field, and constructs a command
+        of the form ``cd <env_root> && python -m uvicorn <app> --host 0.0.0.0 --port <port>``.
+
+        Raises:
+            ValueError: If ``openenv.yaml`` is not found or lacks an ``app`` field.
+        """
+        yaml_path = self._find_openenv_yaml(sandbox)
+        if yaml_path is None:
+            raise ValueError(
+                "Could not find openenv.yaml inside the sandbox. "
+                "Pass an explicit cmd= to DaytonaProvider or start_container()."
+            )
+
+        cat_resp = sandbox.process.exec(f"cat {shlex.quote(yaml_path)}", timeout=10)
+        content = cat_resp.result if hasattr(cat_resp, "result") else str(cat_resp)
+        app = self._parse_app_field(content)
+        if app is None:
+            raise ValueError(
+                f"openenv.yaml at {yaml_path} does not contain an 'app' field. "
+                "Pass an explicit cmd= to DaytonaProvider or start_container()."
+            )
+
+        # The directory containing openenv.yaml is the env root
+        env_root = yaml_path.rsplit("/", 1)[0]
+        return (
+            f"cd {shlex.quote(env_root)} && "
+            f"python -m uvicorn {shlex.quote(app)} --host 0.0.0.0 --port {port}"
+        )
+
+    def _find_openenv_yaml(self, sandbox: Any) -> Optional[str]:
+        """Locate ``openenv.yaml`` inside the sandbox.
+
+        Tries the modern layout path ``/app/env/openenv.yaml`` first,
+        then falls back to a ``find`` command for the old layout.
+        """
+        # Fast path: modern Dockerfile layout
+        resp = sandbox.process.exec(
+            "test -f /app/env/openenv.yaml && echo found", timeout=10
+        )
+        out = resp.result if hasattr(resp, "result") else str(resp)
+        if "found" in (out or ""):
+            return "/app/env/openenv.yaml"
+
+        # Fallback: search for it (redirect stderr so error messages
+        # like "No such file or directory" don't get mistaken for paths).
+        resp = sandbox.process.exec(
+            "find /app -maxdepth 4 -name openenv.yaml -print -quit 2>/dev/null",
+            timeout=10,
+        )
+        path = (resp.result if hasattr(resp, "result") else str(resp) or "").strip()
+        if path and path.startswith("/"):
+            return path
+
+        return None
+
+    @staticmethod
+    def _parse_app_field(yaml_content: str) -> Optional[str]:
+        """Extract the ``app`` value from raw openenv.yaml content.
+
+        Uses PyYAML to handle comments, quotes, and nested keys correctly.
+        """
+        try:
+            data = yaml.safe_load(yaml_content) or {}
+        except Exception:
+            return None
+
+        if not isinstance(data, dict):
+            return None
+
+        value = data.get("app")
+        if isinstance(value, str):
+            value = value.strip()
+            return value if value else None
+        return None
+
+    @staticmethod
+    def _parse_dockerfile_cmd(dockerfile_content: str) -> Optional[str]:
+        """Extract the server command from the last ``CMD`` in a Dockerfile.
+
+        Handles exec form (``CMD ["prog", "arg"]``) and shell form
+        (``CMD prog arg``).  When a Dockerfile has multiple ``CMD``
+        instructions (e.g. multi-stage builds), the last one wins - same
+        semantics as Docker itself.  Lines where ``CMD`` appears inside a
+        comment are ignored.
+
+        Returns:
+            The command as a single string, or ``None`` if no ``CMD`` found.
+        """
+        import re
+
+        last_cmd: Optional[str] = None
+        for line in dockerfile_content.splitlines():
+            stripped = line.strip()
+            # Skip comments
+            if stripped.startswith("#"):
+                continue
+            match = re.match(r"CMD\s+(.+)", stripped, flags=re.IGNORECASE)
+            if match:
+                last_cmd = match.group(1).strip()
+
+        if last_cmd is None:
+            return None
+
+        # Exec form: CMD ["executable", "param1", ...]
+        if last_cmd.startswith("["):
+            try:
+                parts = json.loads(last_cmd)
+                if isinstance(parts, list) and all(isinstance(p, str) for p in parts):
+                    return " ".join(parts)
+            except (json.JSONDecodeError, TypeError):
+                pass
+
+        # Shell form: CMD executable param1 ...
+        return last_cmd if last_cmd else None
+
+    @staticmethod
+    def strip_buildkit_syntax(dockerfile_content: str) -> str:
+        """Remove BuildKit ``--mount=...`` flags from ``RUN`` instructions.
+
+        Handles single-line flags, multi-line continuations, and multiple
+        ``--mount`` flags spread across continuation lines. Only leading
+        ``--mount`` flags are removed (before the actual command starts).
+
+        Daytona's ``Image.from_dockerfile`` does not support BuildKit
+        ``--mount`` syntax.  This helper strips the flags so that standard
+        Dockerfiles (like the ones generated by ``openenv build``) can
+        be used directly.
+        """
+        import re
+
+        def strip_leading_mounts(text: str) -> str:
+            remaining = text
+            while True:
+                match = re.match(r"\s*--mount=\S+\s*", remaining)
+                if not match:
+                    return remaining
+                remaining = remaining[match.end() :]
+
+        lines = dockerfile_content.split("\n")
+        result: list[str] = []
+        in_run = False
+        in_mount_prefix = False
+
+        for line in lines:
+            line_out = line
+            run_start = False
+            if re.match(r"\s*RUN(\s+|$)", line, flags=re.IGNORECASE):
+                in_run = True
+                in_mount_prefix = True
+                run_start = True
+
+            if in_run and in_mount_prefix:
+                original_ends_with_slash = line_out.rstrip().endswith("\\")
+                if run_start:
+                    match = re.match(r"(\s*RUN\s+)(.*)$", line_out, flags=re.IGNORECASE)
+                    if match:
+                        run_prefix, remainder = match.group(1), match.group(2)
+                    else:
+                        run_prefix, remainder = line_out, ""
+                    new_remainder = strip_leading_mounts(remainder)
+                    line_out = run_prefix + new_remainder
+                    content_for_check = new_remainder
+                else:
+                    new_remainder = strip_leading_mounts(line_out)
+                    line_out = new_remainder
+                    content_for_check = new_remainder
+
+                if original_ends_with_slash and not line_out.rstrip().endswith("\\"):
+                    line_out = line_out.rstrip() + " \\"
+
+                if content_for_check.strip() not in ("", "\\"):
+                    in_mount_prefix = False
+
+            if in_run and not line_out.rstrip().endswith("\\"):
+                in_run = False
+                in_mount_prefix = False
+
+            result.append(line_out)
+
+        return "\n".join(result)
+
+    @classmethod
+    def image_from_dockerfile(
+        cls,
+        dockerfile_path: str,
+        context_dir: str | None = None,
+    ) -> str:
+        """Validate a Dockerfile and return a ``dockerfile:`` URI for
+        :meth:`start_container`.
+
+        Eagerly validates the Dockerfile (existence, COPY sources,
+        BuildKit stripping) and stores the processed content in an
+        internal registry.  The actual ``daytona.Image`` is created
+        later inside ``start_container``.
+
+        Args:
+            dockerfile_path: Path to the Dockerfile on disk.
+            context_dir: Build context directory.  Defaults to the
+                Dockerfile's grandparent directory, matching the
+                ``openenv init`` convention where Dockerfiles live in
+                ``<env>/server/Dockerfile`` and the build context is
+                ``<env>/``.  Pass explicitly for non-standard layouts
+                (e.g. ``context_dir="."`` for repo-root contexts).
+
+        Returns:
+            A ``"dockerfile:<abs_path>"`` string to pass to
+            ``start_container``.
+
+        Raises:
+            FileNotFoundError: If *dockerfile_path* does not exist.
+            ValueError: If *context_dir* is given but does not exist,
+                or if COPY sources in the Dockerfile cannot be found
+                under the resolved context directory.
+        """
+        import pathlib
+        import re
+
+        src = pathlib.Path(dockerfile_path).resolve()
+        if not src.is_file():
+            raise FileNotFoundError(f"Dockerfile not found: {dockerfile_path}")
+
+        if context_dir is not None:
+            ctx = pathlib.Path(context_dir)
+            if not ctx.is_dir():
+                raise ValueError(f"context_dir does not exist: {context_dir}")
+        else:
+            # Default: grandparent of the Dockerfile, matching the
+            # openenv init layout (<env>/server/Dockerfile -> <env>/).
+            ctx = src.parent.parent
+
+        content = src.read_text()
+        stripped = cls.strip_buildkit_syntax(content)
+
+        # Validate that COPY sources exist under the context directory.
+        # This catches mismatches early (e.g. a Dockerfile expecting repo
+        # root as context when we defaulted to the env directory).
+        for line in stripped.splitlines():
+            m = re.match(r"^\s*COPY\s+(?!--from=)(\S+)\s+", line, re.IGNORECASE)
+            if not m:
+                continue
+            copy_src = m.group(1)
+            if copy_src.startswith("/"):
+                continue
+            resolved = ctx / copy_src
+            if not resolved.exists() and not any(ctx.glob(copy_src)):
+                raise ValueError(
+                    f"Dockerfile COPY source '{copy_src}' not found "
+                    f"under context_dir '{ctx}'. This Dockerfile may "
+                    f"expect a different build context (e.g. the repo "
+                    f"root). Pass context_dir explicitly."
+                )
+
+        # Parse CMD from the original Dockerfile so start_container can
+        # use it as a fallback when openenv.yaml is unavailable.
+        parsed_cmd = cls._parse_dockerfile_cmd(content)
+
+        cls._dockerfile_registry[str(src)] = {
+            "stripped_content": stripped,
+            "context_dir": str(ctx),
+            "server_cmd": parsed_cmd,
+        }
+
+        return f"dockerfile:{src}"
+
+    def start_container(
+        self,
+        image: str,
+        port: Optional[int] = None,
+        env_vars: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> str:
+        """
+        Create a Daytona sandbox from a Docker image or snapshot.
+
+        Daytona does not execute the image's CMD (known bug — ENTRYPOINT
+        runs, CMD does not).  The server command is resolved in order:
+
+        1. Explicit ``cmd`` passed to the constructor.
+        2. ``cmd`` key in ``**kwargs`` (popped before forwarding).
+        3. Auto-discovered from ``openenv.yaml`` inside the sandbox.
+        4. ``CMD`` parsed from the Dockerfile (when *image* came from
+           ``image_from_dockerfile``).
+
+        Args:
+            image: Docker image name (e.g. ``"echo-env:latest"``),
+                   ``"snapshot:<name>"`` to create from a pre-built snapshot,
+                   or ``"dockerfile:<path>"`` returned by
+                   :meth:`image_from_dockerfile`.
+            port: Must be ``None`` or ``8000``. Daytona exposes port 8000
+                  via its preview proxy; other ports raise ``ValueError``.
+            env_vars: Environment variables forwarded to the sandbox.
+            **kwargs: ``cmd`` (str) to override the server command;
+                remaining kwargs passed through to ``Daytona.create()``.
+
+        Returns:
+            HTTPS preview URL for the sandbox (base_url).
+        """
+        if port is not None and port != 8000:
+            raise ValueError(
+                f"DaytonaProvider only supports port 8000 (got {port}). "
+                "The Daytona preview proxy routes to port 8000 inside the sandbox."
+            )
+
+        # Resolve the server command (may be None; discovery happens after
+        # sandbox creation when we can inspect the filesystem).
+        cmd = kwargs.pop("cmd", None) or self._cmd
+
+        # CMD parsed from Dockerfile (populated for "dockerfile:" images).
+        parsed_cmd: Optional[str] = None
+
+        # Build creation params
+        create_kwargs: Dict[str, Any] = {}
+        if env_vars:
+            create_kwargs["env_vars"] = env_vars
+        if self._public:
+            create_kwargs["public"] = True
+        if self._auto_stop_interval != 15:
+            create_kwargs["auto_stop_interval"] = self._auto_stop_interval
+
+        if image.startswith("snapshot:"):
+            from daytona import CreateSandboxFromSnapshotParams
+
+            snapshot_name = image[len("snapshot:") :]
+            params = CreateSandboxFromSnapshotParams(
+                snapshot=snapshot_name, **create_kwargs
+            )
+        elif image.startswith("dockerfile:"):
+            from daytona import CreateSandboxFromImageParams, Image
+
+            dockerfile_path = image[len("dockerfile:") :]
+            meta = self._dockerfile_registry.get(dockerfile_path)
+            if meta is None:
+                raise ValueError(
+                    f"No registered Dockerfile metadata for {dockerfile_path}. "
+                    "Call DaytonaProvider.image_from_dockerfile() first."
+                )
+
+            parsed_cmd = meta.get("server_cmd")
+
+            # Build the daytona Image from the pre-stripped content.
+            import pathlib
+            import uuid
+
+            ctx = pathlib.Path(meta["context_dir"])
+            tmp_name = f".daytona-{uuid.uuid4().hex[:8]}.dockerfile"
+            tmp_path = ctx / tmp_name
+            try:
+                tmp_path.write_text(meta["stripped_content"])
+                daytona_image = Image.from_dockerfile(str(tmp_path))
+            finally:
+                tmp_path.unlink(missing_ok=True)
+
+            img_kwargs: Dict[str, Any] = {
+                "image": daytona_image,
+                **create_kwargs,
+            }
+            if self._resources is not None:
+                img_kwargs["resources"] = self._resources
+            params = CreateSandboxFromImageParams(**img_kwargs)
+        else:
+            from daytona import CreateSandboxFromImageParams
+
+            img_kwargs = {"image": image, **create_kwargs}
+            if self._resources is not None:
+                img_kwargs["resources"] = self._resources
+            params = CreateSandboxFromImageParams(**img_kwargs)
+
+        # Create sandbox
+        extra: Dict[str, Any] = dict(kwargs)
+        if self._on_snapshot_create_logs is not None:
+            extra["on_snapshot_create_logs"] = self._on_snapshot_create_logs
+
+        self._sandbox = self._daytona.create(
+            params, timeout=self._create_timeout, **extra
+        )
+
+        try:
+            # Discover server command from openenv.yaml if not explicitly set.
+            if cmd is None:
+                try:
+                    cmd = self._discover_server_cmd(self._sandbox)
+                except ValueError:
+                    # Fall back to CMD parsed from Dockerfile (if available).
+                    if parsed_cmd:
+                        cmd = parsed_cmd
+                    else:
+                        raise
+
+            # Wrap in bash -c so compound commands (cd ... && uvicorn ...)
+            # are handled correctly by nohup.  Write PID so we can check
+            # if the process crashed later in wait_for_ready().
+            escaped_cmd = shlex.quote(cmd)
+            self._sandbox.process.exec(
+                f"nohup bash -c {escaped_cmd} > /tmp/openenv-server.log 2>&1 &"
+                " echo $! > /tmp/openenv-server.pid",
+                timeout=10,
+            )
+
+            # Get a signed preview URL for port 8000.  The token is
+            # embedded in the URL itself so no extra headers are needed.
+            signed = self._sandbox.create_signed_preview_url(
+                8000, expires_in_seconds=86400
+            )
+            self._preview_url = signed.url
+        except Exception:
+            self.stop_container()
+            raise
+
+        return self._preview_url
+
+    def refresh_preview_url(self) -> str:
+        """Get a fresh signed preview URL (valid for 24h).
+
+        Daytona signed URLs expire after at most 24 hours.  Call this to
+        get a new one for long-running sessions.  The returned URL points
+        to the same sandbox — clients will need to reconnect using it.
+        """
+        if self._sandbox is None:
+            raise RuntimeError("No active sandbox to refresh URL for.")
+        signed = self._sandbox.create_signed_preview_url(8000, expires_in_seconds=86400)
+        self._preview_url = signed.url
+        return self._preview_url
+
+    def stop_container(self) -> None:
+        """Delete the Daytona sandbox."""
+        if self._sandbox is None:
+            return
+
+        try:
+            self._daytona.delete(self._sandbox)
+        finally:
+            self._sandbox = None
+            self._preview_url = None
+
+    def wait_for_ready(self, base_url: str, timeout_s: float = 120.0) -> None:
+        """
+        Poll the /health endpoint until the sandbox is ready.
+
+        Uses a longer default timeout (120s) than Docker providers because
+        Daytona sandboxes may have cold-start latency.
+
+        Args:
+            base_url: Preview URL returned by ``start_container()``.
+            timeout_s: Maximum seconds to wait.
+
+        Raises:
+            TimeoutError: If the sandbox doesn't become ready in time.
+            RuntimeError: If the server process died (detected via PID check).
+        """
+        import requests
+
+        health_url = f"{base_url}/health"
+
+        deadline = time.time() + timeout_s
+        while time.time() < deadline:
+            try:
+                response = requests.get(health_url, timeout=5.0)
+                if response.status_code == 200:
+                    return
+            except requests.RequestException:
+                pass
+
+            # Early exit: if the server process died, raise immediately
+            # instead of waiting for the full health-check timeout.
+            if self._sandbox is not None:
+                resp = self._sandbox.process.exec(
+                    "kill -0 $(cat /tmp/openenv-server.pid) 2>/dev/null"
+                    " && echo RUNNING || echo DEAD",
+                    timeout=10,
+                )
+                out = resp.result if hasattr(resp, "result") else str(resp)
+                if "DEAD" in (out or ""):
+                    log_resp = self._sandbox.process.exec(
+                        "cat /tmp/openenv-server.log 2>/dev/null", timeout=10
+                    )
+                    log = (
+                        log_resp.result
+                        if hasattr(log_resp, "result")
+                        else str(log_resp)
+                    )
+                    raise RuntimeError(f"Server process died.\nLog:\n{log}")
+
+            time.sleep(1.0)
+
+        raise TimeoutError(
+            f"Daytona sandbox at {base_url} did not become ready within {timeout_s}s"
+        )

src/core/containers/runtime/providers.py

@@ -0,0 +1,669 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Container provider abstractions for running environment servers.
+
+This module provides a pluggable architecture for different container providers
+(local Docker, Kubernetes, cloud providers, etc.) to be used with EnvClient.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional, Sequence
+
+
+class ContainerProvider(ABC):
+    """
+    Abstract base class for container providers.
+
+    Providers implement this interface to support different container platforms:
+    - LocalDockerProvider: Runs containers on local Docker daemon
+    - KubernetesProvider: Runs containers in Kubernetes cluster
+    - FargateProvider: Runs containers on AWS Fargate
+    - CloudRunProvider: Runs containers on Google Cloud Run
+
+    The provider manages a single container lifecycle and provides the base URL
+    for connecting to it.
+
+    Example:
+        >>> provider = LocalDockerProvider()
+        >>> base_url = provider.start_container("echo-env:latest")
+        >>> print(base_url)  # http://localhost:8000
+        >>> # Use the environment via base_url
+        >>> provider.stop_container()
+    """
+
+    @abstractmethod
+    def start_container(
+        self,
+        image: str,
+        port: Optional[int] = None,
+        env_vars: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> str:
+        """
+        Start a container from the specified image.
+
+        Args:
+            image: Container image name (e.g., "echo-env:latest")
+            port: Port to expose (if None, provider chooses)
+            env_vars: Environment variables to pass to container
+            **kwargs: Provider-specific options
+
+        Returns:
+            Base URL to connect to the container (e.g., "http://localhost:8000")
+
+        Raises:
+            RuntimeError: If container fails to start
+        """
+        pass
+
+    @abstractmethod
+    def stop_container(self) -> None:
+        """
+        Stop and remove the running container.
+
+        This cleans up the container that was started by start_container().
+        """
+        pass
+
+    @abstractmethod
+    def wait_for_ready(self, base_url: str, timeout_s: float = 30.0) -> None:
+        """
+        Wait for the container to be ready to accept requests.
+
+        This typically polls the /health endpoint until it returns 200.
+
+        Args:
+            base_url: Base URL of the container
+            timeout_s: Maximum time to wait
+
+        Raises:
+            TimeoutError: If container doesn't become ready in time
+        """
+        pass
+
+
+class LocalDockerProvider(ContainerProvider):
+    """
+    Container provider for local Docker daemon.
+
+    This provider runs containers on the local machine using Docker.
+    Useful for development and testing.
+
+    Example:
+        >>> provider = LocalDockerProvider()
+        >>> base_url = provider.start_container("echo-env:latest")
+        >>> # Container running on http://localhost:<random-port>
+        >>> provider.stop_container()
+    """
+
+    def __init__(self):
+        """Initialize the local Docker provider."""
+        self._container_id: Optional[str] = None
+        self._container_name: Optional[str] = None
+
+        # Check if Docker is available
+        import subprocess
+
+        try:
+            subprocess.run(
+                ["docker", "version"],
+                check=True,
+                capture_output=True,
+                timeout=5,
+            )
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            subprocess.TimeoutExpired,
+        ):
+            raise RuntimeError(
+                "Docker is not available. Please install Docker Desktop or Docker Engine."
+            )
+
+    def start_container(
+        self,
+        image: str,
+        port: Optional[int] = None,
+        env_vars: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> str:
+        """
+        Start a Docker container locally.
+
+        Args:
+            image: Docker image name
+            port: Port to expose (if None, finds available port)
+            env_vars: Environment variables for the container
+            **kwargs: Additional Docker run options
+
+        Returns:
+            Base URL to connect to the container
+        """
+        import subprocess
+        import time
+
+        # Find available port if not specified
+        if port is None:
+            port = self._find_available_port()
+
+        # Generate container name
+        self._container_name = self._generate_container_name(image)
+
+        # Build docker run command
+        cmd = [
+            "docker",
+            "run",
+            "-d",  # Detached
+            "--name",
+            self._container_name,
+            "-p",
+            f"{port}:8000",  # Map port
+        ]
+
+        # Add environment variables
+        if env_vars:
+            for key, value in env_vars.items():
+                cmd.extend(["-e", f"{key}={value}"])
+
+        # Add image
+        cmd.append(image)
+
+        # Run container
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            self._container_id = result.stdout.strip()
+        except subprocess.CalledProcessError as e:
+            error_msg = f"Failed to start Docker container.\nCommand: {' '.join(cmd)}\nExit code: {e.returncode}\nStderr: {e.stderr}\nStdout: {e.stdout}"
+            raise RuntimeError(error_msg) from e
+
+        # Wait a moment for container to start
+        time.sleep(1)
+
+        base_url = f"http://localhost:{port}"
+        return base_url
+
+    def stop_container(self) -> None:
+        """
+        Stop and remove the Docker container.
+        """
+        if self._container_id is None:
+            return
+
+        import subprocess
+
+        try:
+            # Stop container
+            subprocess.run(
+                ["docker", "stop", self._container_id],
+                capture_output=True,
+                check=True,
+                timeout=10,
+            )
+
+            # Remove container
+            subprocess.run(
+                ["docker", "rm", self._container_id],
+                capture_output=True,
+                check=True,
+                timeout=10,
+            )
+        except subprocess.CalledProcessError:
+            # Container might already be stopped/removed
+            pass
+        finally:
+            self._container_id = None
+            self._container_name = None
+
+    def wait_for_ready(self, base_url: str, timeout_s: float = 30.0) -> None:
+        """
+        Wait for container to be ready by polling /health endpoint.
+
+        Args:
+            base_url: Base URL of the container
+            timeout_s: Maximum time to wait
+
+        Raises:
+            TimeoutError: If container doesn't become ready
+        """
+        import time
+
+        import requests
+
+        start_time = time.time()
+        health_url = f"{base_url}/health"
+
+        # Bypass proxy for localhost to avoid proxy issues
+        proxies = {"http": None, "https": None}
+
+        while time.time() - start_time < timeout_s:
+            try:
+                response = requests.get(health_url, timeout=2.0, proxies=proxies)
+                if response.status_code == 200:
+                    return
+            except requests.RequestException:
+                pass
+
+            time.sleep(0.5)
+
+        raise TimeoutError(
+            f"Container at {base_url} did not become ready within {timeout_s}s"
+        )
+
+    def _find_available_port(self) -> int:
+        """
+        Find an available port on localhost.
+
+        Returns:
+            An available port number
+        """
+        import socket
+
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            s.listen(1)
+            port = s.getsockname()[1]
+        return port
+
+    def _generate_container_name(self, image: str) -> str:
+        """
+        Generate a unique container name based on image name and timestamp.
+
+        Args:
+            image: Docker image name
+
+        Returns:
+            A unique container name
+        """
+        import time
+
+        clean_image = image.split("/")[-1].split(":")[0]
+        timestamp = int(time.time() * 1000)
+        return f"{clean_image}-{timestamp}"
+
+
+class DockerSwarmProvider(ContainerProvider):
+    """
+    Container provider that uses Docker Swarm services for local concurrency.
+
+    This provider creates a replicated Swarm service backed by the local Docker
+    engine. The built-in load-balancer fans requests across the replicas,
+    allowing multiple container instances to run concurrently on the developer
+    workstation (mirroring the workflow described in the Docker stack docs).
+    """
+
+    def __init__(
+        self,
+        *,
+        auto_init_swarm: bool = True,
+        overlay_network: Optional[str] = None,
+    ):
+        """
+        Args:
+            auto_init_swarm: Whether to call ``docker swarm init`` when Swarm
+                is not active. Otherwise, user must manually initialize Swarm.
+            overlay_network: Optional overlay network name for the service.
+                When provided, the network is created with
+                ``docker network create --driver overlay --attachable`` if it
+                does not already exist.
+        """
+        self._service_name: Optional[str] = None
+        self._service_id: Optional[str] = None
+        self._published_port: Optional[int] = None
+        self._overlay_network = overlay_network
+        self._auto_init_swarm = auto_init_swarm
+
+        self._ensure_docker_available()
+        self._ensure_swarm_initialized()
+        if self._overlay_network:
+            self._ensure_overlay_network(self._overlay_network)
+
+    def start_container(
+        self,
+        image: str,
+        port: Optional[int] = None,
+        env_vars: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> str:
+        """
+        Start (or scale) a Swarm service for the given image.
+
+        Supported kwargs:
+            replicas (int): Number of container replicas (default: 2).
+            cpu_limit (float | str): CPU limit passed to ``--limit-cpu``.
+            memory_limit (str): Memory limit passed to ``--limit-memory``.
+            constraints (Sequence[str]): Placement constraints.
+            labels (Dict[str, str]): Service labels.
+            command (Sequence[str] | str): Override container command.
+        """
+        import shlex
+        import subprocess
+        import time
+
+        allowed_kwargs = {
+            "replicas",
+            "cpu_limit",
+            "memory_limit",
+            "constraints",
+            "labels",
+            "command",
+        }
+        unknown = set(kwargs) - allowed_kwargs
+        if unknown:
+            raise ValueError(f"Unsupported kwargs for DockerSwarmProvider: {unknown}")
+
+        replicas = int(kwargs.get("replicas", 2))
+        cpu_limit = kwargs.get("cpu_limit")
+        memory_limit = kwargs.get("memory_limit")
+        constraints: Optional[Sequence[str]] = kwargs.get("constraints")
+        labels: Optional[Dict[str, str]] = kwargs.get("labels")
+        command_override = kwargs.get("command")
+
+        if port is None:
+            port = self._find_available_port()
+
+        self._service_name = self._generate_service_name(image)
+        self._published_port = port
+
+        cmd = [
+            "docker",
+            "service",
+            "create",
+            "--detach",
+            "--name",
+            self._service_name,
+            "--replicas",
+            str(max(1, replicas)),
+            "--publish",
+            f"{port}:8000",
+        ]
+
+        if self._overlay_network:
+            cmd.extend(["--network", self._overlay_network])
+
+        if env_vars:
+            for key, value in env_vars.items():
+                cmd.extend(["--env", f"{key}={value}"])
+
+        if cpu_limit is not None:
+            cmd.extend(["--limit-cpu", str(cpu_limit)])
+
+        if memory_limit is not None:
+            cmd.extend(["--limit-memory", str(memory_limit)])
+
+        if constraints:
+            for constraint in constraints:
+                cmd.extend(["--constraint", constraint])
+
+        if labels:
+            for key, value in labels.items():
+                cmd.extend(["--label", f"{key}={value}"])
+
+        cmd.append(image)
+
+        if command_override:
+            if isinstance(command_override, str):
+                cmd.extend(shlex.split(command_override))
+            else:
+                cmd.extend(command_override)
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            self._service_id = result.stdout.strip()
+        except subprocess.CalledProcessError as e:
+            error_msg = (
+                "Failed to start Docker Swarm service.\n"
+                f"Command: {' '.join(cmd)}\n"
+                f"Exit code: {e.returncode}\n"
+                f"Stdout: {e.stdout}\n"
+                f"Stderr: {e.stderr}"
+            )
+            raise RuntimeError(error_msg) from e
+
+        # Give Swarm a brief moment to schedule the tasks.
+        time.sleep(1.0)
+
+        return f"http://localhost:{port}"
+
+    def stop_container(self) -> None:
+        """
+        Remove the Swarm service (and keep the Swarm manager running).
+        """
+        if not self._service_name:
+            return
+
+        import subprocess
+
+        try:
+            subprocess.run(
+                ["docker", "service", "rm", self._service_name],
+                capture_output=True,
+                check=True,
+                timeout=10,
+            )
+        except subprocess.CalledProcessError:
+            # Service may already be gone; ignore.
+            pass
+        finally:
+            self._service_name = None
+            self._service_id = None
+            self._published_port = None
+
+    def wait_for_ready(self, base_url: str, timeout_s: float = 30.0) -> None:
+        """
+        Wait for at least one replica to become healthy by polling /health.
+
+        Note: With Swarm's load balancer, requests round-robin across replicas,
+        so this only verifies that at least one replica is responding. Some
+        replicas may still be starting when this returns.
+        """
+        import time
+
+        import requests
+
+        deadline = time.time() + timeout_s
+        health_url = f"{base_url}/health"
+
+        # Bypass proxy for localhost to avoid proxy issues
+        proxies = {"http": None, "https": None}
+
+        while time.time() < deadline:
+            try:
+                response = requests.get(health_url, timeout=2.0, proxies=proxies)
+                if response.status_code == 200:
+                    return
+            except requests.RequestException:
+                pass
+
+            time.sleep(0.5)
+
+        raise TimeoutError(
+            f"Swarm service at {base_url} did not become ready within {timeout_s}s"
+        )
+
+    def _ensure_docker_available(self) -> None:
+        import subprocess
+
+        try:
+            subprocess.run(
+                ["docker", "version"],
+                check=True,
+                capture_output=True,
+                timeout=5,
+            )
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            subprocess.TimeoutExpired,
+        ) as exc:
+            raise RuntimeError(
+                "Docker is not available. Please install Docker Desktop or Docker Engine."
+            ) from exc
+
+    def _ensure_swarm_initialized(self) -> None:
+        import subprocess
+
+        try:
+            result = subprocess.run(
+                ["docker", "info", "--format", "{{.Swarm.LocalNodeState}}"],
+                capture_output=True,
+                text=True,
+                check=True,
+                timeout=5,
+            )
+            state = result.stdout.strip().lower()
+            if state == "active":
+                return
+        except subprocess.CalledProcessError:
+            state = "unknown"
+
+        if not self._auto_init_swarm:
+            raise RuntimeError(
+                f"Docker Swarm is not active (state={state}). Enable Swarm manually or pass auto_init_swarm=True."
+            )
+
+        try:
+            subprocess.run(
+                ["docker", "swarm", "init"],
+                check=True,
+                capture_output=True,
+                timeout=10,
+            )
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError("Failed to initialize Docker Swarm") from e
+
+    def _ensure_overlay_network(self, network: str) -> None:
+        import subprocess
+
+        inspect = subprocess.run(
+            ["docker", "network", "inspect", network],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if inspect.returncode == 0:
+            return
+
+        try:
+            subprocess.run(
+                [
+                    "docker",
+                    "network",
+                    "create",
+                    "--driver",
+                    "overlay",
+                    "--attachable",
+                    network,
+                ],
+                check=True,
+                capture_output=True,
+                timeout=10,
+            )
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to create overlay network '{network}'") from e
+
+    def _find_available_port(self) -> int:
+        import socket
+
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            s.bind(("", 0))
+            s.listen(1)
+            port = s.getsockname()[1]
+        return port
+
+    def _generate_service_name(self, image: str) -> str:
+        import time
+
+        clean_image = image.split("/")[-1].split(":")[0]
+        timestamp = int(time.time() * 1000)
+        return f"{clean_image}-swarm-{timestamp}"
+
+
+class KubernetesProvider(ContainerProvider):
+    """
+    Container provider for Kubernetes clusters.
+
+    This provider creates pods in a Kubernetes cluster and exposes them
+    via services or port-forwarding.
+
+    Example:
+        >>> provider = KubernetesProvider(namespace="envtorch-dev")
+        >>> base_url = provider.start_container("echo-env:latest")
+        >>> # Pod running in k8s, accessible via service or port-forward
+        >>> provider.stop_container()
+    """
+
+    pass
+
+
+class RuntimeProvider(ABC):
+    """
+    Abstract base class for runtime providers that are not container providers.
+    Providers implement this interface to support different runtime platforms:
+    - UVProvider: Runs environments via `uv run`
+
+    The provider manages a single runtime lifecycle and provides the base URL
+    for connecting to it.
+
+    Example:
+        >>> provider = UVProvider(project_path="/path/to/env")
+        >>> base_url = provider.start()
+        >>> print(base_url)  # http://localhost:8000
+        >>> provider.stop()
+    """
+
+    @abstractmethod
+    def start(
+        self,
+        port: Optional[int] = None,
+        env_vars: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> str:
+        """
+        Start a runtime from the specified image.
+
+        Args:
+            image: Runtime image name
+            port: Port to expose (if None, provider chooses)
+            env_vars: Environment variables for the runtime
+            **kwargs: Additional runtime options
+        """
+
+    @abstractmethod
+    def stop(self) -> None:
+        """
+        Stop the runtime.
+        """
+        pass
+
+    @abstractmethod
+    def wait_for_ready(self, timeout_s: float = 30.0) -> None:
+        """
+        Wait for the runtime to be ready to accept requests.
+        """
+        pass
+
+    def __enter__(self) -> "RuntimeProvider":
+        """
+        Enter the runtime provider.
+        """
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        """
+        Exit the runtime provider.
+        """
+        self.stop()
+        return False

src/core/containers/runtime/uv_provider.py

@@ -0,0 +1,224 @@
+"""Providers for launching ASGI applications via ``uv run``."""
+
+from __future__ import annotations
+
+import os
+import socket
+import subprocess
+import time
+from typing import Dict, Optional
+
+import requests
+
+from .providers import RuntimeProvider
+
+
+def _check_uv_installed() -> None:
+    try:
+        subprocess.check_output(["uv", "--version"])
+    except FileNotFoundError as exc:
+        raise RuntimeError(
+            "`uv` executable not found. Install uv from https://docs.astral.sh and ensure it is on PATH."
+        ) from exc
+
+
+def _find_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("", 0))
+        sock.listen(1)
+        return sock.getsockname()[1]
+
+
+def _create_uv_command(
+    *,
+    host: str,
+    port: int,
+    reload: bool,
+    workers: int,
+    app: str,
+    project_path: str,
+) -> list[str]:
+    command: list[str] = ["uv", "run", "--isolated", "--project", project_path]
+
+    command.append("--")
+    command.extend(
+        [
+            "uvicorn",
+            app,
+            "--host",
+            host,
+            "--port",
+            str(port),
+            "--workers",
+            str(workers),
+        ]
+    )
+
+    if reload:
+        command.append("--reload")
+
+    return command
+
+
+def _poll_health(health_url: str, timeout_s: float) -> None:
+    """Poll a health endpoint until it returns HTTP 200 or times out."""
+
+    deadline = time.time() + timeout_s
+    while time.time() < deadline:
+        try:
+            timeout = max(0.0001, min(deadline - time.time(), 2.0))
+            response = requests.get(health_url, timeout=timeout)
+            if response.status_code == 200:
+                return
+        except requests.RequestException:
+            continue
+
+        time.sleep(0.5)
+
+    raise TimeoutError(f"Server did not become ready within {timeout_s:.1f} seconds")
+
+
+class UVProvider(RuntimeProvider):
+    """
+    RuntimeProvider implementation backed by ``uv run``.
+
+    Args:
+        project_path: Local path to a uv project (passed to ``uv run --project``)
+        app: ASGI application path for uvicorn (defaults to ``server.app:app``)
+        host: Host interface to bind to (defaults to ``0.0.0.0``)
+        reload: Whether to enable uvicorn's reload mode
+        env_vars: Environment variables to pass through to the spawned process
+        context_timeout_s: How long to wait for the environment to become ready
+
+    Example:
+        >>> provider = UVProvider(project_path="/path/to/env")
+        >>> base_url = provider.start()
+        >>> print(base_url)  # http://localhost:8000
+        >>> # Use the environment via base_url
+        >>> provider.stop()
+    """
+
+    def __init__(
+        self,
+        *,
+        project_path: str,
+        app: str = "server.app:app",
+        host: str = "0.0.0.0",
+        reload: bool = False,
+        env_vars: Optional[Dict[str, str]] = None,
+        context_timeout_s: float = 60.0,
+    ):
+        """Initialize the UVProvider."""
+        self.project_path = os.path.abspath(project_path)
+        self.app = app
+        self.host = host
+        self.reload = reload
+        self.env_vars = env_vars
+        self.context_timeout_s = context_timeout_s
+        _check_uv_installed()
+        self._process = None
+        self._base_url = None
+
+    def start(
+        self,
+        port: Optional[int] = None,
+        env_vars: Optional[Dict[str, str]] = None,
+        workers: int = 1,
+        **_: Dict[str, str],
+    ) -> str:
+        """
+        Start the environment via `uv run`.
+
+        Args:
+            port: The port to bind the environment to
+            env_vars: Environment variables to pass to the environment
+            workers: The number of workers to use
+
+        Returns:
+            The base URL of the environment
+
+        Raises:
+            RuntimeError: If the environment is already running
+        """
+        if self._process is not None and self._process.poll() is None:
+            raise RuntimeError("UVProvider is already running")
+
+        bind_port = port or _find_free_port()
+
+        command = _create_uv_command(
+            host=self.host,
+            port=bind_port,
+            reload=self.reload,
+            workers=workers,
+            app=self.app,
+            project_path=self.project_path,
+        )
+
+        env = os.environ.copy()
+
+        if self.env_vars:
+            env.update(self.env_vars)
+        if env_vars:
+            env.update(env_vars)
+
+        try:
+            self._process = subprocess.Popen(command, env=env)
+        except OSError as exc:
+            raise RuntimeError(f"Failed to launch `uv run`: {exc}") from exc
+
+        client_host = "127.0.0.1" if self.host in {"0.0.0.0", "::"} else self.host
+        self._base_url = f"http://{client_host}:{bind_port}"
+        return self._base_url
+
+    def wait_for_ready(self, timeout_s: float = 60.0) -> None:
+        """
+        Wait for the environment to become ready.
+
+        Args:
+            timeout_s: The timeout to wait for the environment to become ready
+
+        Raises:
+            RuntimeError: If the environment is not running
+            TimeoutError: If the environment does not become ready within the timeout
+        """
+        if self._process and self._process.poll() is not None:
+            code = self._process.returncode
+            raise RuntimeError(f"uv process exited prematurely with code {code}")
+
+        _poll_health(f"{self._base_url}/health", timeout_s=timeout_s)
+
+    def stop(self) -> None:
+        """
+        Stop the environment.
+
+        Raises:
+            RuntimeError: If the environment is not running
+        """
+        if self._process is None:
+            return
+
+        if self._process.poll() is None:
+            self._process.terminate()
+            try:
+                self._process.wait(timeout=10.0)
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+                self._process.wait(timeout=5.0)
+
+        self._process = None
+        self._base_url = None
+
+    @property
+    def base_url(self) -> str:
+        """
+        The base URL of the environment.
+
+        Returns:
+            The base URL of the environment
+
+        Raises:
+            RuntimeError: If the environment is not running
+        """
+        if self._base_url is None:
+            raise RuntimeError("UVProvider has not been started")
+        return self._base_url

src/core/containers/test_local_docker_provider.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""
+End-to-end test for LocalDockerProvider.
+
+This script tests the complete flow:
+1. Start a container using LocalDockerProvider
+2. Wait for it to be ready
+3. Make HTTP requests to test the environment
+4. Clean up the container
+"""
+
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+import requests
+from openenv.core.containers.runtime import LocalDockerProvider
+
+
+# TODO: Remove this test or make it a functional test sicne this will be tested in e2e test for echo env
+def test_local_docker_provider():
+    """Test LocalDockerProvider end-to-end."""
+    print("=" * 60)
+    print("LocalDockerProvider End-to-End Test")
+    print("=" * 60)
+    print()
+
+    provider = None
+
+    try:
+        # Step 1: Create provider
+        print("Step 1: Creating LocalDockerProvider...")
+        provider = LocalDockerProvider()
+        print("✓ Provider created\n")
+
+        # Step 2: Start container
+        print("Step 2: Starting echo-env container...")
+        base_url = provider.start_container("echo-env:latest")
+        print(f"✓ Container started at: {base_url}")
+        if provider._container_id:
+            print(f"  Container ID: {provider._container_id[:12]}...")
+        if provider._container_name:
+            print(f"  Container name: {provider._container_name}\n")
+
+        # Step 3: Wait for ready
+        print("Step 3: Waiting for container to be ready...")
+        provider.wait_for_ready(base_url, timeout_s=30.0)
+        print("✓ Container is ready!\n")
+
+        # Step 4: Test health endpoint
+        print("Step 4: Testing /health endpoint...")
+        response = requests.get(f"{base_url}/health")
+        print(f"  Status: {response.status_code}")
+        print(f"  Response: {response.json()}")
+        assert response.status_code == 200
+        assert response.json()["status"] == "healthy"
+        print("✓ Health check passed\n")
+
+        # Step 5: Test reset endpoint
+        print("Step 5: Testing /reset endpoint...")
+        response = requests.post(
+            f"{base_url}/reset",
+            json={},
+            headers={"Content-Type": "application/json"},
+        )
+        print(f"  Status: {response.status_code}")
+        data = response.json()
+        print(f"  Message: {data['observation']['echoed_message']}")
+        print(f"  Reward: {data['reward']}")
+        print(f"  Done: {data['done']}")
+        assert response.status_code == 200
+        assert data["observation"]["echoed_message"] == "Echo environment ready!"
+        print("✓ Reset test passed\n")
+
+        # Step 6: Test step endpoint
+        print("Step 6: Testing /step endpoint...")
+        response = requests.post(
+            f"{base_url}/step",
+            json={"action": {"message": "Hello from LocalDockerProvider!"}},
+            headers={"Content-Type": "application/json"},
+        )
+        print(f"  Status: {response.status_code}")
+        data = response.json()
+        print(f"  Echoed: {data['observation']['echoed_message']}")
+        print(f"  Length: {data['observation']['message_length']}")
+        print(f"  Reward: {data['reward']}")
+        assert response.status_code == 200
+        assert (
+            data["observation"]["echoed_message"] == "Hello from LocalDockerProvider!"
+        )
+        assert data["observation"]["message_length"] == 31
+        print("✓ Step test passed\n")
+
+        # Step 7: Test state endpoint
+        print("Step 7: Testing /state endpoint...")
+        response = requests.get(f"{base_url}/state")
+        print(f"  Status: {response.status_code}")
+        data = response.json()
+        print(f"  Episode ID: {data['episode_id']}")
+        print(f"  Step count: {data['step_count']}")
+        assert response.status_code == 200
+        assert data["step_count"] == 1  # One step from above
+        print("✓ State test passed\n")
+
+        # Step 8: Multiple steps
+        print("Step 8: Testing multiple steps...")
+        for i in range(3):
+            response = requests.post(
+                f"{base_url}/step",
+                json={"action": {"message": f"Message {i + 1}"}},
+                headers={"Content-Type": "application/json"},
+            )
+            assert response.status_code == 200
+            print(f"  Step {i + 1}: ✓")
+
+        # Check state updated
+        response = requests.get(f"{base_url}/state")
+        data = response.json()
+        assert data["step_count"] == 4  # 1 + 3 more steps
+        print(f"  Final step count: {data['step_count']}")
+        print("✓ Multiple steps test passed\n")
+
+        print("=" * 60)
+        print("✓ All tests passed!")
+        print("=" * 60)
+        print()
+
+        return True
+
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+    finally:
+        # Step 9: Cleanup
+        if provider is not None:
+            print("\nStep 9: Cleaning up container...")
+            try:
+                provider.stop_container()
+                print("✓ Container stopped and removed\n")
+            except Exception as e:
+                print(f"⚠️  Cleanup warning: {e}\n")
+
+
+def test_provider_with_custom_port():
+    """Test provider with custom port."""
+    print("=" * 60)
+    print("LocalDockerProvider with Custom Port Test")
+    print("=" * 60)
+    print()
+
+    provider = None
+
+    try:
+        provider = LocalDockerProvider()
+
+        print("Starting container on custom port 8123...")
+        base_url = provider.start_container("echo-env:latest", port=8123)
+        print(f"✓ Started at: {base_url}")
+        assert ":8123" in base_url
+
+        print("Waiting for ready...")
+        provider.wait_for_ready(base_url)
+        print("✓ Ready!")
+
+        print("Testing health...")
+        response = requests.get(f"{base_url}/health")
+        assert response.status_code == 200
+        print("✓ Health check passed")
+
+        print("\n✓ Custom port test passed!\n")
+        return True
+
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        return False
+
+    finally:
+        if provider is not None:
+            provider.stop_container()
+            print("✓ Cleaned up\n")
+
+
+def test_provider_with_env_vars():
+    """Test provider with environment variables."""
+    print("=" * 60)
+    print("LocalDockerProvider with Environment Variables Test")
+    print("=" * 60)
+    print()
+
+    provider = None
+
+    try:
+        provider = LocalDockerProvider()
+
+        print("Starting container with environment variables...")
+        base_url = provider.start_container(
+            "echo-env:latest", env_vars={"DEBUG": "true", "LOG_LEVEL": "info"}
+        )
+        print(f"✓ Started at: {base_url}")
+
+        print("Waiting for ready...")
+        provider.wait_for_ready(base_url)
+        print("✓ Ready!")
+
+        print("Testing health...")
+        response = requests.get(f"{base_url}/health")
+        assert response.status_code == 200
+        print("✓ Health check passed")
+
+        print("\n✓ Environment variables test passed!\n")
+        return True
+
+    except Exception as e:
+        print(f"\n❌ Test failed: {e}")
+        return False
+
+    finally:
+        if provider is not None:
+            provider.stop_container()
+            print("✓ Cleaned up\n")
+
+
+if __name__ == "__main__":
+    print()
+    print("🐳 LocalDockerProvider Test Suite")
+    print()
+
+    results = []
+
+    # Run basic test
+    results.append(("Basic End-to-End", test_local_docker_provider()))
+
+    # Run custom port test
+    results.append(("Custom Port", test_provider_with_custom_port()))
+
+    # Run environment variables test
+    results.append(("Environment Variables", test_provider_with_env_vars()))
+
+    # Summary
+    print("=" * 60)
+    print("Test Summary")
+    print("=" * 60)
+    for name, passed in results:
+        status = "✓ PASSED" if passed else "✗ FAILED"
+        print(f"{name:25} {status}")
+    print("=" * 60)
+
+    all_passed = all(result for _, result in results)
+    if all_passed:
+        print("\n🎉 All tests passed!")
+        exit(0)
+    else:
+        print("\n❌ Some tests failed")
+        exit(1)

src/core/env_client.py

@@ -0,0 +1,484 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Environment client for persistent sessions.
+
+This module provides a WebSocket-based client that maintains a persistent connection
+to an environment server, enabling efficient multi-step interactions without
+the overhead of HTTP request/response cycles.
+
+The client is async by default. For synchronous usage, use the `.sync()` method
+to get a `SyncEnvClient` wrapper.
+
+Example (async):
+    >>> async with GenericEnvClient(base_url="ws://localhost:8000") as env:
+    ...     result = await env.reset()
+    ...     result = await env.step({"code": "print('hello')"})
+
+Example (sync wrapper):
+    >>> env = GenericEnvClient(base_url="ws://localhost:8000").sync()
+    >>> with env:
+    ...     result = env.reset()
+    ...     result = env.step({"code": "print('hello')"})
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Generic, Optional, Type, TYPE_CHECKING, TypeVar
+
+from .client_types import StateT, StepResult
+from .containers.runtime import LocalDockerProvider, UVProvider
+from .utils import convert_to_ws_url
+
+if TYPE_CHECKING:
+    from websockets.asyncio.client import ClientConnection
+
+    from .containers.runtime import ContainerProvider, RuntimeProvider
+    from .sync_client import SyncEnvClient
+
+from websockets.asyncio.client import connect as ws_connect
+
+ActT = TypeVar("ActT")
+ObsT = TypeVar("ObsT")
+EnvClientT = TypeVar("EnvClientT", bound="EnvClient")
+
+
+class EnvClient(ABC, Generic[ActT, ObsT, StateT]):
+    """
+    Async environment client for persistent sessions.
+
+    This client maintains a persistent WebSocket connection to an environment
+    server, enabling efficient multi-step interactions. Each client instance
+    corresponds to a dedicated environment session on the server.
+
+    The client is async by default. For synchronous usage, use the `.sync()`
+    method to get a `SyncEnvClient` wrapper.
+
+    Features:
+    - Lower latency for sequential interactions
+    - Session state is maintained server-side
+    - Better suited for long-running episodes
+    - Async by default for modern Python async/await patterns
+
+    Example (async):
+        >>> from envs.coding_env.client import CodingEnv
+        >>>
+        >>> # Connect to a server using async context manager
+        >>> async with CodingEnv(base_url="ws://localhost:8000") as env:
+        ...     result = await env.reset(seed=42)
+        ...     while not result.done:
+        ...         action = agent.predict(result.observation)
+        ...         result = await env.step(action)
+
+    Example (sync wrapper):
+        >>> env = CodingEnv(base_url="ws://localhost:8000").sync()
+        >>> with env:
+        ...     result = env.reset(seed=42)
+        ...     result = env.step(action)
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        connect_timeout_s: float = 10.0,
+        message_timeout_s: float = 60.0,
+        max_message_size_mb: float = 100.0,
+        provider: Optional["ContainerProvider | RuntimeProvider"] = None,
+        mode: Optional[str] = None,
+    ):
+        """
+        Initialize environment client.
+
+        Args:
+            base_url: Base URL of the environment server (http:// or ws://).
+                     Will be converted to ws:// if http:// is provided.
+            connect_timeout_s: Timeout for establishing WebSocket connection
+            message_timeout_s: Timeout for receiving responses to messages
+            max_message_size_mb: Maximum WebSocket message size in megabytes.
+                                Default 100MB to handle large observations (screenshots, DOM, etc.)
+            provider: Optional container/runtime provider for lifecycle management.
+                     Can be a ContainerProvider (Docker) or RuntimeProvider (UV).
+            mode: Communication mode: 'simulation' for Gym-style API (default) or
+                 'production' for MCP JSON-RPC protocol. Can also be set via the
+                 OPENENV_CLIENT_MODE environment variable. Constructor parameter
+                 takes precedence over environment variable. Case-insensitive.
+        """
+        # Determine mode (constructor > env var > default)
+        if mode is None:
+            mode = os.environ.get("OPENENV_CLIENT_MODE", "simulation")
+
+        # Normalize and validate mode
+        mode = mode.lower()
+        if mode not in ("simulation", "production"):
+            raise ValueError(
+                f"Invalid mode: '{mode}'. Must be 'simulation' or 'production'. "
+                f"Set via constructor parameter or OPENENV_CLIENT_MODE environment variable."
+            )
+
+        # Store mode (use object.__setattr__ to bypass immutability)
+        object.__setattr__(self, "_mode", mode)
+
+        # Convert HTTP URL to WebSocket URL
+        ws_url = convert_to_ws_url(base_url)
+
+        self._ws_url = f"{ws_url}/ws"
+        self._connect_timeout = connect_timeout_s
+        self._message_timeout = message_timeout_s
+        self._max_message_size = int(
+            max_message_size_mb * 1024 * 1024
+        )  # Convert MB to bytes
+        self._provider = provider
+        self._ws: Optional[ClientConnection] = None
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Prevent modification of _mode after initialization."""
+        if name == "_mode" and hasattr(self, "_mode"):
+            raise AttributeError("Cannot modify mode after initialization")
+        super().__setattr__(name, value)
+
+    async def connect(self) -> "EnvClient":
+        """
+        Establish WebSocket connection to the server.
+
+        Returns:
+            self for method chaining
+
+        Raises:
+            ConnectionError: If connection cannot be established
+        """
+        if self._ws is not None:
+            return self
+
+        # Bypass proxy for localhost connections
+        ws_url_lower = self._ws_url.lower()
+        is_localhost = "localhost" in ws_url_lower or "127.0.0.1" in ws_url_lower
+
+        old_no_proxy = os.environ.get("NO_PROXY")
+        if is_localhost:
+            # Set NO_PROXY to bypass proxy for localhost
+            current_no_proxy = old_no_proxy or ""
+            if "localhost" not in current_no_proxy.lower():
+                os.environ["NO_PROXY"] = (
+                    f"{current_no_proxy},localhost,127.0.0.1"
+                    if current_no_proxy
+                    else "localhost,127.0.0.1"
+                )
+
+        try:
+            self._ws = await ws_connect(
+                self._ws_url,
+                open_timeout=self._connect_timeout,
+                max_size=self._max_message_size,
+            )
+        except Exception as e:
+            raise ConnectionError(f"Failed to connect to {self._ws_url}: {e}") from e
+        finally:
+            # Restore original NO_PROXY value
+            if is_localhost:
+                if old_no_proxy is None:
+                    os.environ.pop("NO_PROXY", None)
+                else:
+                    os.environ["NO_PROXY"] = old_no_proxy
+
+        return self
+
+    async def disconnect(self) -> None:
+        """Close the WebSocket connection."""
+        if self._ws is not None:
+            try:
+                # Send close message
+                await self._send({"type": "close"})
+            except Exception:
+                pass  # Best effort
+            try:
+                await self._ws.close()
+            except Exception:
+                pass
+            self._ws = None
+
+    async def _ensure_connected(self) -> None:
+        """Ensure WebSocket connection is established."""
+        if self._ws is None:
+            await self.connect()
+
+    async def _send(self, message: Dict[str, Any]) -> None:
+        """Send a message over the WebSocket."""
+        await self._ensure_connected()
+        assert self._ws is not None
+        await self._ws.send(json.dumps(message))
+
+    async def _receive(self) -> Dict[str, Any]:
+        """Receive and parse a message from the WebSocket."""
+        assert self._ws is not None
+        raw = await asyncio.wait_for(self._ws.recv(), timeout=self._message_timeout)
+        return json.loads(raw)
+
+    async def _send_and_receive(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        """Send a message and wait for response."""
+        await self._send(message)
+        response = await self._receive()
+
+        # Check for error response
+        if response.get("type") == "error":
+            error_data = response.get("data", {})
+            raise RuntimeError(
+                f"Server error: {error_data.get('message', 'Unknown error')} "
+                f"(code: {error_data.get('code', 'UNKNOWN')})"
+            )
+
+        return response
+
+    @classmethod
+    async def from_docker_image(
+        cls: Type[EnvClientT],
+        image: str,
+        provider: Optional["ContainerProvider"] = None,
+        **kwargs: Any,
+    ) -> EnvClientT:
+        """
+        Create an environment client by spinning up a Docker container.
+
+        Args:
+            image: Docker image name to run (e.g., "coding-env:latest")
+            provider: Container provider to use (defaults to LocalDockerProvider)
+            **kwargs: Additional arguments to pass to provider.start_container()
+
+        Returns:
+            Connected client instance
+        """
+        if provider is None:
+            provider = LocalDockerProvider()
+
+        # Start container
+        base_url = provider.start_container(image, **kwargs)
+
+        # Wait for server to be ready
+        provider.wait_for_ready(base_url)
+
+        # Create and connect client
+        client = cls(base_url=base_url, provider=provider)
+        await client.connect()
+
+        return client
+
+    @classmethod
+    async def from_env(
+        cls: Type[EnvClientT],
+        repo_id: str,
+        *,
+        use_docker: bool = True,
+        provider: Optional["ContainerProvider | RuntimeProvider"] = None,
+        **provider_kwargs: Any,
+    ) -> EnvClientT:
+        """
+        Create a client from a Hugging Face Space.
+
+        Args:
+            repo_id: Hugging Face space identifier ``{org}/{space}``.
+            use_docker: When ``True`` (default) pull from the HF registry and
+                launch via :class:`LocalDockerProvider`. When ``False`` run the
+                space locally with :class:`UVProvider`.
+            provider: Optional provider instance to reuse. Must be a
+                :class:`ContainerProvider` when ``use_docker=True`` and a
+                :class:`RuntimeProvider` otherwise.
+            provider_kwargs: Additional keyword arguments forwarded to
+                either the container provider's ``start_container`` (docker)
+                or to the ``UVProvider`` constructor/start (uv). When
+                ``use_docker=False``, the ``project_path`` argument can be
+                used to override the default git URL
+                (``git+https://huggingface.co/spaces/{repo_id}``).
+
+        Returns:
+            Connected client instance
+
+        Examples:
+            >>> # Pull and run from HF Docker registry
+            >>> env = await MyEnv.from_env("openenv/echo-env")
+            >>>
+            >>> # Run locally with UV (clones the space)
+            >>> env = await MyEnv.from_env("openenv/echo-env", use_docker=False)
+            >>>
+            >>> # Run from a local checkout
+            >>> env = await MyEnv.from_env(
+            ...     "openenv/echo-env",
+            ...     use_docker=False,
+            ...     project_path="/path/to/local/checkout"
+            ... )
+        """
+        # Extract start args that apply to both providers
+        start_args = {}
+        for key in ("port", "env_vars", "workers"):
+            if key in provider_kwargs:
+                start_args[key] = provider_kwargs.pop(key)
+
+        if use_docker:
+            # Docker mode: pull from HF registry
+            docker_provider = provider or LocalDockerProvider()
+            tag = provider_kwargs.pop("tag", "latest")
+            image = f"registry.hf.space/{repo_id.replace('/', '-')}:{tag}"
+            base_url = docker_provider.start_container(
+                image, **start_args, **provider_kwargs
+            )
+            docker_provider.wait_for_ready(base_url)
+
+            client = cls(base_url=base_url, provider=docker_provider)
+            await client.connect()
+            return client
+        else:
+            # UV mode: clone and run with uv
+            if provider is None:
+                uv_kwargs = dict(provider_kwargs)
+                project_path = uv_kwargs.pop("project_path", None)
+                if project_path is None:
+                    project_path = f"git+https://huggingface.co/spaces/{repo_id}"
+
+                provider = UVProvider(project_path=project_path, **uv_kwargs)
+            else:
+                if provider_kwargs:
+                    raise ValueError(
+                        "provider_kwargs cannot be used when supplying a provider instance"
+                    )
+
+            base_url = provider.start(**start_args)
+            provider.wait_for_ready()
+
+            client = cls(base_url=base_url, provider=provider)
+            await client.connect()
+            return client
+
+    @abstractmethod
+    def _step_payload(self, action: ActT) -> Dict[str, Any]:
+        """Convert an Action object to the JSON data expected by the env server."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[ObsT]:
+        """Convert a JSON response from the env server to StepResult[ObsT]."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _parse_state(self, payload: Dict[str, Any]) -> StateT:
+        """Convert a JSON response from the state endpoint to a State object."""
+        raise NotImplementedError
+
+    async def reset(self, **kwargs: Any) -> StepResult[ObsT]:
+        """
+        Reset the environment with optional parameters.
+
+        Args:
+            **kwargs: Optional parameters passed to the environment's reset method.
+                     Common parameters include:
+                     - seed: Random seed for reproducibility
+                     - episode_id: Custom episode identifier
+
+        Returns:
+            StepResult containing initial observation
+        """
+        message = {
+            "type": "reset",
+            "data": kwargs,
+        }
+        response = await self._send_and_receive(message)
+        return self._parse_result(response.get("data", {}))
+
+    async def step(self, action: ActT, **kwargs: Any) -> StepResult[ObsT]:
+        """
+        Execute an action in the environment.
+
+        Args:
+            action: The action to execute
+            **kwargs: Optional parameters (currently ignored)
+
+        Returns:
+            StepResult containing observation, reward, and done status
+        """
+        message = {
+            "type": "step",
+            "data": self._step_payload(action),
+        }
+        response = await self._send_and_receive(message)
+        return self._parse_result(response.get("data", {}))
+
+    async def state(self) -> StateT:
+        """
+        Get the current environment state from the server.
+
+        Returns:
+            State object with environment state information
+        """
+        message = {"type": "state"}
+        response = await self._send_and_receive(message)
+        return self._parse_state(response.get("data", {}))
+
+    async def close(self) -> None:
+        """
+        Close the WebSocket connection and clean up resources.
+
+        If this client was created via from_docker_image() or from_env(),
+        this will also stop and remove the associated container/process.
+        """
+        await self.disconnect()
+
+        if self._provider is not None:
+            # Handle both ContainerProvider and RuntimeProvider
+            if hasattr(self._provider, "stop_container"):
+                self._provider.stop_container()
+            elif hasattr(self._provider, "stop"):
+                self._provider.stop()
+
+    async def __aenter__(self) -> "EnvClient":
+        """Enter async context manager, ensuring connection is established."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Exit async context manager, closing connection."""
+        await self.close()
+
+    def __enter__(self) -> "EnvClient":
+        """Sync context manager entry - raises error suggesting async usage."""
+        raise TypeError(
+            "EnvClient is async by default. Use 'async with' instead of 'with', "
+            "or call .sync() to get a synchronous wrapper:\n"
+            "  async with client:  # async usage\n"
+            "  with client.sync():  # sync wrapper"
+        )
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Sync context manager exit - should not be reached."""
+        pass  # pragma: no cover
+
+    def sync(self) -> "SyncEnvClient":
+        """
+        Return a synchronous wrapper around this async client.
+
+        Use this method when you need synchronous access to the environment
+        without async/await syntax. This is useful for:
+        - Integration with synchronous codebases
+        - Interactive/REPL usage
+        - Stopping async from "infecting" the call stack
+
+        Returns:
+            SyncEnvClient wrapper that provides synchronous methods
+
+        Example:
+            >>> # Create async client and get sync wrapper
+            >>> async_client = GenericEnvClient(base_url="http://localhost:8000")
+            >>> sync_client = async_client.sync()
+            >>>
+            >>> # Use synchronous API
+            >>> with sync_client:
+            ...     result = sync_client.reset()
+            ...     result = sync_client.step({"code": "print('hello')"})
+        """
+        from .sync_client import SyncEnvClient
+
+        return SyncEnvClient(self)

src/core/env_server/__init__.py

@@ -0,0 +1,150 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Core environment interfaces and types."""
+
+from .base_transforms import CompositeTransform, NullTransform
+from .exceptions import (
+    ConcurrencyConfigurationError,
+    EnvironmentFactoryError,
+    OpenEnvError,
+    SessionCapacityError,
+    SessionCreationError,
+    SessionNotFoundError,
+)
+from .http_server import create_app, create_fastapi_app, HTTPEnvServer
+from .interfaces import Environment, Message, ModelTokenizer, Transform
+
+try:
+    from .mcp_environment import MCPEnvironment
+except ModuleNotFoundError:
+    MCPEnvironment = None  # type: ignore[assignment]
+
+from .mcp_types import (
+    CallToolAction,
+    CallToolObservation,
+    JsonRpcError,
+    # JSON-RPC types
+    JsonRpcErrorCode,
+    JsonRpcRequest,
+    JsonRpcResponse,
+    ListToolsAction,
+    ListToolsObservation,
+    McpMethod,
+    RESERVED_TOOL_NAMES,
+    Tool,
+    ToolError,
+    ToolErrorType,
+    WSMCPMessage,
+    WSMCPResponse,
+)
+from .route_config import GetEndpointConfig
+from .serialization import (
+    deserialize_action,
+    deserialize_action_with_preprocessing,
+    serialize_observation,
+)
+from .types import (
+    Action,
+    BaseMessage,
+    ConcurrencyConfig,
+    HealthResponse,
+    HealthStatus,
+    Observation,
+    SchemaResponse,
+    ServerCapacityStatus,
+    ServerMode,
+    SessionInfo,
+    State,
+    WSCloseMessage,
+    WSErrorCode,
+    WSErrorResponse,
+    WSIncomingMessage,
+    WSObservationResponse,
+    WSResetMessage,
+    WSStateMessage,
+    WSStateResponse,
+    WSStepMessage,
+)
+
+try:
+    from .web_interface import create_web_interface_app, WebInterfaceManager
+except ModuleNotFoundError:
+    create_web_interface_app = None  # type: ignore[assignment]
+    WebInterfaceManager = None  # type: ignore[assignment]
+
+__all__ = [
+    # Core interfaces
+    "Environment",
+    "Transform",
+    "Message",
+    "ModelTokenizer",
+    # Types
+    "Action",
+    "Observation",
+    "State",
+    "SchemaResponse",
+    "HealthResponse",
+    # Enums
+    "HealthStatus",
+    "ServerMode",
+    "WSErrorCode",
+    # WebSocket message types
+    "BaseMessage",
+    "WSIncomingMessage",
+    "WSResetMessage",
+    "WSStepMessage",
+    "WSStateMessage",
+    "WSCloseMessage",
+    "WSObservationResponse",
+    "WSStateResponse",
+    "WSErrorResponse",
+    # Concurrency types
+    "ConcurrencyConfig",
+    "ServerCapacityStatus",
+    "SessionInfo",
+    # Exceptions
+    "OpenEnvError",
+    "ConcurrencyConfigurationError",
+    "SessionCapacityError",
+    "SessionNotFoundError",
+    "SessionCreationError",
+    "EnvironmentFactoryError",
+    # Base transforms
+    "CompositeTransform",
+    "NullTransform",
+    # HTTP Server
+    "HTTPEnvServer",
+    "create_app",
+    "create_fastapi_app",
+    # Web Interface
+    "create_web_interface_app",
+    "WebInterfaceManager",
+    # Serialization utilities
+    "deserialize_action",
+    "deserialize_action_with_preprocessing",
+    "serialize_observation",
+    # Route configuration
+    "GetEndpointConfig",
+    # MCP types
+    "Tool",
+    "ToolError",
+    "ToolErrorType",
+    "ListToolsAction",
+    "CallToolAction",
+    "ListToolsObservation",
+    "CallToolObservation",
+    "WSMCPMessage",
+    "WSMCPResponse",
+    "RESERVED_TOOL_NAMES",
+    "MCPEnvironment",
+    # JSON-RPC types
+    "JsonRpcErrorCode",
+    "JsonRpcError",
+    "JsonRpcRequest",
+    "JsonRpcResponse",
+    "McpMethod",
+]

src/core/env_server/base_transforms.py

@@ -0,0 +1,29 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Base transform implementations for composing environment-specific transforms."""
+
+from .interfaces import Transform
+from .types import Observation
+
+
+class CompositeTransform(Transform):
+    """Combines multiple transforms into a single transform."""
+
+    def __init__(self, transforms: list[Transform]):
+        self.transforms = transforms
+
+    def __call__(self, observation: Observation) -> Observation:
+        for transform in self.transforms:
+            observation = transform(observation)
+        return observation
+
+
+class NullTransform(Transform):
+    """Default transform that passes through unchanged."""
+
+    def __call__(self, observation: Observation) -> Observation:
+        return observation

src/core/env_server/exceptions.py

@@ -0,0 +1,105 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Custom exceptions for environment server operations."""
+
+from typing import Optional
+
+
+class OpenEnvError(Exception):
+    """Base exception for all OpenEnv errors."""
+
+    pass
+
+
+class ConcurrencyConfigurationError(OpenEnvError):
+    """
+    Raised when an environment is misconfigured for concurrent sessions.
+
+    This error is raised during server startup when max_concurrent_envs > 1
+    is specified for an environment that is not marked as SUPPORTS_CONCURRENT_SESSIONS.
+    """
+
+    def __init__(
+        self,
+        environment_name: str,
+        max_concurrent_envs: int,
+        message: Optional[str] = None,
+    ):
+        self.environment_name = environment_name
+        self.max_concurrent_envs = max_concurrent_envs
+
+        if message is None:
+            message = (
+                f"Environment '{environment_name}' is not marked as SUPPORTS_CONCURRENT_SESSIONS. "
+                f"Cannot run with max_concurrent_envs={max_concurrent_envs}. "
+                f"Either set max_concurrent_envs=1 or ensure the environment "
+                f"properly isolates session state and set SUPPORTS_CONCURRENT_SESSIONS=True."
+            )
+
+        super().__init__(message)
+
+
+class SessionCapacityError(OpenEnvError):
+    """
+    Raised when the server cannot accept new sessions due to capacity limits.
+
+    This error is raised when a new WebSocket connection is attempted but
+    the server has already reached max_concurrent_envs active sessions.
+    """
+
+    def __init__(
+        self,
+        active_sessions: int,
+        max_sessions: int,
+        message: Optional[str] = None,
+    ):
+        self.active_sessions = active_sessions
+        self.max_sessions = max_sessions
+
+        if message is None:
+            message = (
+                f"Server at capacity: {active_sessions}/{max_sessions} sessions active. "
+                f"Cannot accept new connections."
+            )
+
+        super().__init__(message)
+
+
+class SessionNotFoundError(OpenEnvError):
+    """Raised when attempting to access a session that does not exist."""
+
+    def __init__(self, session_id: str, message: Optional[str] = None):
+        self.session_id = session_id
+
+        if message is None:
+            message = f"Session '{session_id}' not found."
+
+        super().__init__(message)
+
+
+class SessionCreationError(OpenEnvError):
+    """Raised when a session cannot be created."""
+
+    def __init__(self, reason: str, message: Optional[str] = None):
+        self.reason = reason
+
+        if message is None:
+            message = f"Failed to create session: {reason}"
+
+        super().__init__(message)
+
+
+class EnvironmentFactoryError(OpenEnvError):
+    """Raised when the environment factory fails to create an instance."""
+
+    def __init__(self, factory_name: str, message: Optional[str] = None):
+        self.factory_name = factory_name
+
+        if message is None:
+            message = f"Environment factory '{factory_name}' failed to create instance."
+
+        super().__init__(message)

src/core/env_server/gradio_theme.py

@@ -0,0 +1,128 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Unified terminal-style theme for OpenEnv Gradio UI (light/dark)."""
+
+from __future__ import annotations
+
+import gradio as gr
+
+_MONO_FONTS = (
+    "JetBrains Mono",
+    "Fira Code",
+    "Cascadia Code",
+    "Consolas",
+    "ui-monospace",
+    "monospace",
+)
+
+_CORE_FONT = (
+    "Lato",
+    "Inter",
+    "Arial",
+    "Helvetica",
+    "sans-serif",
+)
+
+_ZERO_RADIUS = gr.themes.Size(
+    xxs="0px",
+    xs="0px",
+    sm="0px",
+    md="0px",
+    lg="0px",
+    xl="0px",
+    xxl="0px",
+)
+
+_GREEN_HUE = gr.themes.Color(
+    c50="#e6f4ea",
+    c100="#ceead6",
+    c200="#a8dab5",
+    c300="#6fcc8b",
+    c400="#3fb950",
+    c500="#238636",
+    c600="#1a7f37",
+    c700="#116329",
+    c800="#0a4620",
+    c900="#033a16",
+    c950="#04200d",
+)
+
+_NEUTRAL_HUE = gr.themes.Color(
+    c50="#f6f8fa",
+    c100="#eaeef2",
+    c200="#d0d7de",
+    c300="#afb8c1",
+    c400="#8c959f",
+    c500="#6e7781",
+    c600="#57606a",
+    c700="#424a53",
+    c800="#32383f",
+    c900="#24292f",
+    c950="#1b1f24",
+)
+
+OPENENV_GRADIO_THEME = gr.themes.Base(
+    primary_hue=_GREEN_HUE,
+    secondary_hue=_NEUTRAL_HUE,
+    neutral_hue=_NEUTRAL_HUE,
+    font=_CORE_FONT,
+    font_mono=_MONO_FONTS,
+    radius_size=_ZERO_RADIUS,
+).set(
+    body_background_fill="#ffffff",
+    background_fill_primary="#ffffff",
+    background_fill_secondary="#f6f8fa",
+    block_background_fill="#ffffff",
+    block_border_color="#ffffff",
+    block_label_text_color="#57606a",
+    block_title_text_color="#24292f",
+    border_color_primary="#d0d7de",
+    input_background_fill="#ffffff",
+    input_border_color="#d0d7de",
+    button_primary_background_fill="#1a7f37",
+    button_primary_background_fill_hover="#116329",
+    button_primary_text_color="#ffffff",
+    button_secondary_background_fill="#f6f8fa",
+    button_secondary_background_fill_hover="#eaeef2",
+    button_secondary_text_color="#24292f",
+    button_secondary_border_color="#d0d7de",
+    body_background_fill_dark="#0d1117",
+    background_fill_primary_dark="#0d1117",
+    background_fill_secondary_dark="#0d1117",
+    block_background_fill_dark="#0d1117",
+    block_border_color_dark="#0d1117",
+    block_label_text_color_dark="#8b949e",
+    block_title_text_color_dark="#c9d1d9",
+    border_color_primary_dark="#30363d",
+    input_background_fill_dark="#0d1117",
+    input_border_color_dark="#30363d",
+    button_primary_background_fill_dark="#30363d",
+    button_primary_background_fill_hover_dark="#484f58",
+    button_primary_text_color_dark="#c9d1d9",
+    button_secondary_background_fill_dark="#21262d",
+    button_secondary_background_fill_hover_dark="#30363d",
+    button_secondary_text_color_dark="#c9d1d9",
+    button_secondary_border_color_dark="#30363d",
+)
+
+OPENENV_GRADIO_CSS = """
+* { border-radius: 0 !important; }
+.col-left { padding: 16px !important; }
+.col-right { padding: 16px !important; }
+.prose, .markdown-text, .md,
+.prose > *, .markdown-text > * {
+    background: transparent !important;
+    border: none !important;
+    box-shadow: none !important;
+}
+.dark .col-left {
+    border-left-color: rgba(139, 148, 158, 0.4) !important;
+}
+.dark .col-right {
+    border-left-color: rgba(201, 209, 217, 0.3) !important;
+}
+"""

src/core/env_server/gradio_ui.py

@@ -0,0 +1,240 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Gradio-based web UI for OpenEnv environments.
+
+Replaces the legacy HTML/JavaScript interface when ENABLE_WEB_INTERFACE is set.
+Mount at /web via gr.mount_gradio_app() from create_web_interface_app().
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Dict, List, Optional
+
+import gradio as gr
+
+from .types import EnvironmentMetadata
+
+
+def _escape_md(text: str) -> str:
+    """Escape Markdown special characters in user-controlled content."""
+    return re.sub(r"([\\`*_\{\}\[\]()#+\-.!|~>])", r"\\\1", str(text))
+
+
+def _format_observation(data: Dict[str, Any]) -> str:
+    """Format reset/step response for Markdown display."""
+    lines: List[str] = []
+    obs = data.get("observation", {})
+    if isinstance(obs, dict):
+        if obs.get("prompt"):
+            lines.append(f"**Prompt:**\n\n{_escape_md(obs['prompt'])}\n")
+        messages = obs.get("messages", [])
+        if messages:
+            lines.append("**Messages:**\n")
+            for msg in messages:
+                sender = _escape_md(str(msg.get("sender_id", "?")))
+                content = _escape_md(str(msg.get("content", "")))
+                cat = _escape_md(str(msg.get("category", "")))
+                lines.append(f"- `[{cat}]` Player {sender}: {content}")
+            lines.append("")
+    reward = data.get("reward")
+    done = data.get("done")
+    if reward is not None:
+        lines.append(f"**Reward:** `{reward}`")
+    if done is not None:
+        lines.append(f"**Done:** `{done}`")
+    return "\n".join(lines) if lines else "*No observation data*"
+
+
+def _readme_section(metadata: Optional[EnvironmentMetadata]) -> str:
+    """README content for the left panel."""
+    if not metadata or not metadata.readme_content:
+        return "*No README available.*"
+    return metadata.readme_content
+
+
+def get_gradio_display_title(
+    metadata: Optional[EnvironmentMetadata],
+    fallback: str = "OpenEnv Environment",
+) -> str:
+    """Return the title used for the Gradio app (browser tab and Blocks)."""
+    name = metadata.name if metadata else fallback
+    return f"OpenEnv Agentic Environment: {name}"
+
+
+def build_gradio_app(
+    web_manager: Any,
+    action_fields: List[Dict[str, Any]],
+    metadata: Optional[EnvironmentMetadata],
+    is_chat_env: bool,
+    title: str = "OpenEnv Environment",
+    quick_start_md: Optional[str] = None,
+) -> gr.Blocks:
+    """
+    Build a Gradio Blocks app for the OpenEnv web interface.
+
+    Args:
+        web_manager: WebInterfaceManager (reset/step_environment, get_state).
+        action_fields: Field dicts from _extract_action_fields(action_cls).
+        metadata: Environment metadata for README/name.
+        is_chat_env: If True, single message textbox; else form from action_fields.
+        title: App title (overridden by metadata.name when present; see get_gradio_display_title).
+        quick_start_md: Optional Quick Start markdown (class names already replaced).
+
+    Returns:
+        gr.Blocks to mount with gr.mount_gradio_app(app, blocks, path="/web").
+    """
+    readme_content = _readme_section(metadata)
+    display_title = get_gradio_display_title(metadata, fallback=title)
+
+    async def reset_env():
+        try:
+            data = await web_manager.reset_environment()
+            obs_md = _format_observation(data)
+            return (
+                obs_md,
+                json.dumps(data, indent=2),
+                "Environment reset successfully.",
+            )
+        except Exception as e:
+            return ("", "", f"Error: {e}")
+
+    def _step_with_action(action_data: Dict[str, Any]):
+        async def _run():
+            try:
+                data = await web_manager.step_environment(action_data)
+                obs_md = _format_observation(data)
+                return (
+                    obs_md,
+                    json.dumps(data, indent=2),
+                    "Step complete.",
+                )
+            except Exception as e:
+                return ("", "", f"Error: {e}")
+
+        return _run
+
+    async def step_chat(message: str):
+        if not (message or str(message).strip()):
+            return ("", "", "Please enter an action message.")
+        action = {"message": str(message).strip()}
+        return await _step_with_action(action)()
+
+    def get_state_sync():
+        try:
+            data = web_manager.get_state()
+            return json.dumps(data, indent=2)
+        except Exception as e:
+            return f"Error: {e}"
+
+    with gr.Blocks(title=display_title) as demo:
+        with gr.Row():
+            with gr.Column(scale=1, elem_classes="col-left"):
+                if quick_start_md:
+                    with gr.Accordion("Quick Start", open=True):
+                        gr.Markdown(quick_start_md)
+                with gr.Accordion("README", open=False):
+                    gr.Markdown(readme_content)
+
+            with gr.Column(scale=2, elem_classes="col-right"):
+                obs_display = gr.Markdown(
+                    value=("# Playground\n\nClick **Reset** to start a new episode."),
+                )
+                with gr.Group():
+                    if is_chat_env:
+                        action_input = gr.Textbox(
+                            label="Action message",
+                            placeholder="e.g. Enter your message...",
+                        )
+                        step_inputs = [action_input]
+                        step_fn = step_chat
+                    else:
+                        step_inputs = []
+                        for field in action_fields:
+                            name = field["name"]
+                            field_type = field.get("type", "text")
+                            label = name.replace("_", " ").title()
+                            placeholder = field.get("placeholder", "")
+                            if field_type == "checkbox":
+                                inp = gr.Checkbox(label=label)
+                            elif field_type == "number":
+                                inp = gr.Number(label=label)
+                            elif field_type == "select":
+                                choices = field.get("choices") or []
+                                inp = gr.Dropdown(
+                                    choices=choices,
+                                    label=label,
+                                    allow_custom_value=False,
+                                )
+                            elif field_type in ("textarea", "tensor"):
+                                inp = gr.Textbox(
+                                    label=label,
+                                    placeholder=placeholder,
+                                    lines=3,
+                                )
+                            else:
+                                inp = gr.Textbox(
+                                    label=label,
+                                    placeholder=placeholder,
+                                )
+                            step_inputs.append(inp)
+
+                        async def step_form(*values):
+                            if not action_fields:
+                                return await _step_with_action({})()
+                            action_data = {}
+                            for i, field in enumerate(action_fields):
+                                if i >= len(values):
+                                    break
+                                name = field["name"]
+                                val = values[i]
+                                if field.get("type") == "checkbox":
+                                    action_data[name] = bool(val)
+                                elif val is not None and val != "":
+                                    action_data[name] = val
+                            return await _step_with_action(action_data)()
+
+                        step_fn = step_form
+
+                    with gr.Row():
+                        step_btn = gr.Button("Step", variant="primary")
+                        reset_btn = gr.Button("Reset", variant="secondary")
+                        state_btn = gr.Button("Get state", variant="secondary")
+                    with gr.Row():
+                        status = gr.Textbox(
+                            label="Status",
+                            interactive=False,
+                        )
+                    raw_json = gr.Code(
+                        label="Raw JSON response",
+                        language="json",
+                        interactive=False,
+                    )
+
+        reset_btn.click(
+            fn=reset_env,
+            outputs=[obs_display, raw_json, status],
+        )
+        step_btn.click(
+            fn=step_fn,
+            inputs=step_inputs,
+            outputs=[obs_display, raw_json, status],
+        )
+        if is_chat_env:
+            action_input.submit(
+                fn=step_fn,
+                inputs=step_inputs,
+                outputs=[obs_display, raw_json, status],
+            )
+        state_btn.click(
+            fn=get_state_sync,
+            outputs=[raw_json],
+        )
+
+    return demo

src/core/env_server/http_server.py

@@ -0,0 +1,1391 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+HTTP server wrapper for Environment instances.
+
+This module provides utilities to wrap any Environment subclass and expose it
+over HTTP and WebSocket endpoints that EnvClient can consume.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import json
+import os
+import time
+import uuid
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Callable, Dict, Optional, Type
+
+from fastapi import (
+    Body,
+    FastAPI,
+    HTTPException,
+    Request,
+    status,
+    WebSocket,
+    WebSocketDisconnect,
+)
+from pydantic import ValidationError
+
+from .interfaces import Environment
+from .mcp_environment import get_server_tools
+from .mcp_types import (
+    JsonRpcErrorCode,
+    JsonRpcRequest,
+    JsonRpcResponse,
+    McpMethod,
+    WSMCPMessage,
+    WSMCPResponse,
+)
+from .route_config import GetEndpointConfig, register_get_endpoints
+from .serialization import deserialize_action, serialize_observation
+from .types import (
+    Action,
+    ConcurrencyConfig,
+    EnvironmentMetadata,
+    HealthResponse,
+    HealthStatus,
+    Observation,
+    ResetRequest,
+    ResetResponse,
+    SchemaResponse,
+    ServerCapacityStatus,
+    ServerMode,
+    SessionInfo,
+    State,
+    StepRequest,
+    StepResponse,
+    WSCloseMessage,
+    WSErrorCode,
+    WSErrorResponse,
+    WSObservationResponse,
+    WSResetMessage,
+    WSStateMessage,
+    WSStateResponse,
+    WSStepMessage,
+)
+
+
+def _make_json_serializable(obj: Any) -> Any:
+    """
+    Convert an object to a JSON-serializable form.
+
+    Handles Pydantic models, dataclasses, and other common types.
+
+    Args:
+        obj: The object to convert
+
+    Returns:
+        A JSON-serializable representation of the object
+    """
+    if obj is None:
+        return None
+    if isinstance(obj, (str, int, float, bool)):
+        return obj
+    if isinstance(obj, (list, tuple)):
+        return [_make_json_serializable(item) for item in obj]
+    if isinstance(obj, dict):
+        return {k: _make_json_serializable(v) for k, v in obj.items()}
+    if hasattr(obj, "model_dump"):
+        # Pydantic model
+        return obj.model_dump()
+    if hasattr(obj, "__dict__"):
+        # Object with __dict__
+        return {k: _make_json_serializable(v) for k, v in obj.__dict__.items()}
+    # Fallback to string representation
+    return str(obj)
+
+
+from .exceptions import (
+    ConcurrencyConfigurationError,
+    EnvironmentFactoryError,
+    SessionCapacityError,
+)
+
+
+class HTTPEnvServer:
+    """
+    HTTP server wrapper for Environment instances.
+
+    This class wraps an Environment and exposes its reset(), step(), and state
+    methods as HTTP and WebSocket endpoints compatible with EnvClient.
+
+    The server expects:
+    - Action deserialization: Converts JSON dict to Action subclass
+    - Observation serialization: Converts Observation subclass to JSON dict
+
+    Example:
+        >>> from core.env_server import HTTPEnvServer
+        >>> from envs.coding_env.server import CodeExecutionEnvironment
+        >>> from envs.coding_env.models import CodeAction, CodeObservation
+        >>>
+        >>> # Pass environment class (factory pattern)
+        >>> server = HTTPEnvServer(
+        ...     env=CodeExecutionEnvironment,
+        ...     action_cls=CodeAction,
+        ...     observation_cls=CodeObservation,
+        ...     max_concurrent_envs=4,
+        ... )
+        >>>
+        >>> # Register routes with FastAPI
+        >>> from fastapi import FastAPI
+        >>> app = FastAPI()
+        >>> server.register_routes(app)
+    """
+
+    def __init__(
+        self,
+        env: Callable[[], Environment],
+        action_cls: Type[Action],
+        observation_cls: Type[Observation],
+        max_concurrent_envs: Optional[int] = None,
+        concurrency_config: Optional[ConcurrencyConfig] = None,
+    ):
+        """
+        Initialize HTTP server wrapper.
+
+        Args:
+            env: Environment factory (callable) that creates new instances.
+                 Will be called to create a new environment for each WebSocket session.
+            action_cls: The Action subclass this environment expects
+            observation_cls: The Observation subclass this environment returns
+            max_concurrent_envs: Maximum number of concurrent WebSocket sessions.
+                                 Mutually exclusive with concurrency_config.
+            concurrency_config: Optional ConcurrencyConfig for advanced concurrency settings.
+                                Mutually exclusive with max_concurrent_envs.
+
+        Raises:
+            ValueError: If both max_concurrent_envs and concurrency_config are provided.
+            ConcurrencyConfigurationError: If max_concurrent_envs > 1 for an
+                environment that is not marked as SUPPORTS_CONCURRENT_SESSIONS.
+        """
+        # Validate that env is callable
+        if not callable(env):
+            raise TypeError(
+                f"env must be a callable (class or factory function), got {type(env)}. "
+                f"Pass the environment class (e.g., MyEnvironment) not an instance (e.g., MyEnvironment())."
+            )
+
+        self._env_factory: Callable[[], Environment] = env
+
+        # Handle concurrency configuration
+        if max_concurrent_envs is not None and concurrency_config is not None:
+            raise ValueError(
+                "Cannot specify both 'max_concurrent_envs' and 'concurrency_config'. "
+                "Please use only one method to configure concurrency."
+            )
+
+        if concurrency_config is not None:
+            self._concurrency_config = concurrency_config
+        elif max_concurrent_envs is not None:
+            self._concurrency_config = ConcurrencyConfig(
+                max_concurrent_envs=max_concurrent_envs,
+                session_timeout=None,
+            )
+        else:
+            # Default configuration
+            self._concurrency_config = ConcurrencyConfig(
+                max_concurrent_envs=1,
+                session_timeout=None,
+            )
+
+        self._max_concurrent_envs = self._concurrency_config.max_concurrent_envs
+
+        # Validate concurrency configuration
+        self._validate_concurrency_safety()
+
+        self.action_cls = action_cls
+        self.observation_cls = observation_cls
+
+        # Session management for WebSocket connections
+        self._sessions: Dict[str, Environment] = {}
+        self._session_executors: Dict[str, ThreadPoolExecutor] = {}
+        self._session_info: Dict[str, SessionInfo] = {}
+        self._session_lock = asyncio.Lock()
+
+        # Create thread pool for running sync code in async context
+        # This is needed for environments using sync libraries (e.g., Playwright)
+        self._executor = ThreadPoolExecutor(max_workers=32)
+
+    def _validate_concurrency_safety(self) -> None:
+        """
+        Validate that the environment supports the configured concurrency level.
+
+        Raises:
+            ConcurrencyConfigurationError: If max_concurrent_envs > 1 for an
+                environment that is not marked as SUPPORTS_CONCURRENT_SESSIONS.
+        """
+        if self._max_concurrent_envs <= 1:
+            return
+
+        if inspect.isclass(self._env_factory):
+            env_cls = self._env_factory
+        else:
+            _temp_env = self._env_factory()
+            env_cls = type(_temp_env)
+            _temp_env.close()
+            del _temp_env
+
+        if not getattr(env_cls, "SUPPORTS_CONCURRENT_SESSIONS", False):
+            raise ConcurrencyConfigurationError(
+                environment_name=env_cls.__name__,
+                max_concurrent_envs=self._max_concurrent_envs,
+            )
+
+    def get_capacity_status(self) -> ServerCapacityStatus:
+        """
+        Get the current capacity status of the server.
+
+        Returns:
+            ServerCapacityStatus with current session counts and availability.
+        """
+        return ServerCapacityStatus.from_counts(
+            active=len(self._sessions),
+            max_sessions=self._max_concurrent_envs,
+        )
+
+    async def _run_sync_in_thread_pool(
+        self, func: Callable[..., Observation], *args, **kwargs
+    ) -> Observation:
+        """Run a synchronous function in the thread pool executor."""
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(self._executor, lambda: func(*args, **kwargs))
+
+    def _get_valid_kwargs(
+        self,
+        sig: inspect.Signature,
+        kwargs: Dict[str, Any],
+        skip_params: Optional[set[str]] = None,
+    ) -> Dict[str, Any]:
+        """Filter kwargs to only include parameters accepted by the function signature."""
+        if skip_params is None:
+            skip_params = set()
+
+        valid_kwargs = {}
+
+        has_kwargs = any(
+            p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
+        )
+
+        for k, v in kwargs.items():
+            if k in sig.parameters or has_kwargs:
+                if k not in skip_params:
+                    valid_kwargs[k] = v
+
+        return valid_kwargs
+
+    async def _create_session(self) -> tuple[str, Environment]:
+        """
+        Create a new WebSocket session with its own environment instance.
+
+        Returns:
+            Tuple of (session_id, environment)
+
+        Raises:
+            SessionCapacityError: If max concurrent sessions reached
+            EnvironmentFactoryError: If the factory fails to create an environment
+        """
+        async with self._session_lock:
+            if len(self._sessions) >= self._max_concurrent_envs:
+                raise SessionCapacityError(
+                    active_sessions=len(self._sessions),
+                    max_sessions=self._max_concurrent_envs,
+                )
+
+            session_id = str(uuid.uuid4())
+            current_time = time.time()
+
+            # Create executor and reserve slot so capacity is not exceeded while
+            # we create the env outside the lock (avoids blocking other sessions)
+            executor = ThreadPoolExecutor(max_workers=1)
+            self._session_executors[session_id] = executor
+            self._sessions[session_id] = None  # placeholder until env is ready
+
+        try:
+            # Create environment in the executor thread (outside lock)
+            loop = asyncio.get_event_loop()
+            env = await loop.run_in_executor(executor, self._env_factory)
+        except Exception as e:
+            async with self._session_lock:
+                executor.shutdown(wait=False)
+                self._session_executors.pop(session_id, None)
+                self._sessions.pop(session_id, None)
+            factory_name = getattr(
+                self._env_factory, "__name__", str(self._env_factory)
+            )
+            raise EnvironmentFactoryError(factory_name) from e
+
+        async with self._session_lock:
+            self._sessions[session_id] = env
+            self._session_info[session_id] = SessionInfo(
+                session_id=session_id,
+                created_at=current_time,
+                last_activity_at=current_time,
+                step_count=0,
+                environment_type=type(env).__name__,
+            )
+
+        return session_id, env
+
+    async def _destroy_session(self, session_id: str) -> None:
+        """
+        Destroy a WebSocket session and cleanup resources.
+
+        Args:
+            session_id: The session ID to destroy
+        """
+        async with self._session_lock:
+            env = self._sessions.pop(session_id, None)
+            executor = self._session_executors.pop(session_id, None)
+            self._session_info.pop(session_id, None)
+
+        # Run close() in the same executor where the env was created
+        # This is required for thread-sensitive libraries like Playwright/greenlet
+        if env is not None:
+            if executor is not None:
+                try:
+                    loop = asyncio.get_event_loop()
+                    await loop.run_in_executor(executor, env.close)
+                except Exception:
+                    # If executor close fails, try direct close as fallback
+                    try:
+                        env.close()
+                    except Exception:
+                        pass  # Best effort cleanup
+            else:
+                try:
+                    env.close()
+                except Exception:
+                    pass  # Best effort cleanup
+
+        # Shutdown executor after close is done
+        if executor is not None:
+            executor.shutdown(wait=False)
+
+    def _update_session_activity(
+        self, session_id: str, increment_step: bool = False
+    ) -> None:
+        """
+        Update session activity timestamp and optionally increment step count.
+
+        Args:
+            session_id: The session ID to update
+            increment_step: If True, increment the step count
+        """
+        if session_id in self._session_info:
+            self._session_info[session_id].last_activity_at = time.time()
+            if increment_step:
+                self._session_info[session_id].step_count += 1
+
+    def get_session_info(self, session_id: str) -> Optional[SessionInfo]:
+        """
+        Get information about a specific session.
+
+        Args:
+            session_id: The session ID to query
+
+        Returns:
+            SessionInfo if the session exists, None otherwise
+        """
+        return self._session_info.get(session_id)
+
+    async def _run_in_session_executor(
+        self, session_id: str, func: Callable[..., Observation], *args, **kwargs
+    ) -> Observation:
+        """Run a synchronous function in the session's thread pool executor."""
+        executor = self._session_executors.get(session_id, self._executor)
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(executor, lambda: func(*args, **kwargs))
+
+    @property
+    def active_sessions(self) -> int:
+        """Return the number of active WebSocket sessions."""
+        return len(self._sessions)
+
+    @property
+    def max_concurrent_envs(self) -> int:
+        """Return the maximum number of concurrent environments."""
+        return self._max_concurrent_envs
+
+    @property
+    def is_concurrency_safe(self) -> bool:
+        """Return whether the environment is marked as concurrency safe."""
+        import inspect
+
+        if inspect.isclass(self._env_factory):
+            return getattr(self._env_factory, "SUPPORTS_CONCURRENT_SESSIONS", False)
+        else:
+            _temp_env = self._env_factory()
+            result = getattr(_temp_env, "SUPPORTS_CONCURRENT_SESSIONS", False)
+            _temp_env.close()
+            del _temp_env
+            return result
+
+    @property
+    def concurrency_config(self) -> ConcurrencyConfig:
+        """Return the concurrency configuration."""
+        return self._concurrency_config
+
+    def register_routes(
+        self, app: FastAPI, mode: ServerMode | str = ServerMode.SIMULATION
+    ) -> None:
+        """
+        Register HTTP routes on a FastAPI application.
+
+        Args:
+            app: FastAPI application instance
+            mode: Server mode - either SIMULATION or PRODUCTION (or string equivalents).
+                  In production mode, simulation control endpoints (/reset, /step, /state)
+                  are NOT registered. Only safe endpoints (/health, /schema, /metadata, /ws)
+                  are available. Defaults to SIMULATION for backwards compatibility.
+
+        Raises:
+            ValueError: If mode is not a valid ServerMode or string equivalent.
+        """
+        # Convert string to ServerMode enum for backwards compatibility
+        if isinstance(mode, str):
+            try:
+                mode = ServerMode(mode.lower())
+            except ValueError:
+                valid_modes = [m.value for m in ServerMode]
+                raise ValueError(
+                    f"Invalid mode: '{mode}'. Must be one of: {valid_modes}"
+                )
+
+        # Helper function to handle reset endpoint
+        async def reset_handler(
+            request: ResetRequest = Body(default_factory=ResetRequest),
+        ) -> ResetResponse:
+            """Reset endpoint - returns initial observation."""
+            _env = self._env_factory()
+
+            try:
+                kwargs = request.model_dump(exclude_unset=True)
+
+                is_async = _env.reset_async.__func__ is not Environment.reset_async
+
+                if is_async:
+                    sig = inspect.signature(_env.reset_async)
+                else:
+                    sig = inspect.signature(_env.reset)
+                valid_kwargs = self._get_valid_kwargs(sig, kwargs)
+
+                if is_async:
+                    observation = await _env.reset_async(**valid_kwargs)
+                else:
+                    observation = await self._run_sync_in_thread_pool(
+                        _env.reset, **valid_kwargs
+                    )
+                return ResetResponse(**serialize_observation(observation))
+            finally:
+                _env.close()
+
+        # Helper function to handle step endpoint
+        async def step_handler(request: StepRequest) -> StepResponse:
+            """Step endpoint - executes action and returns observation."""
+            action_data = request.action
+
+            try:
+                action = deserialize_action(action_data, self.action_cls)
+            except ValidationError as e:
+                raise HTTPException(
+                    status_code=status.HTTP_422_UNPROCESSABLE_CONTENT, detail=e.errors()
+                )
+
+            _env = self._env_factory()
+
+            try:
+                kwargs = request.model_dump(exclude_unset=True, exclude={"action"})
+
+                is_async = _env.step_async.__func__ is not Environment.step_async
+
+                if is_async:
+                    sig = inspect.signature(_env.step_async)
+                else:
+                    sig = inspect.signature(_env.step)
+                valid_kwargs = self._get_valid_kwargs(
+                    sig, kwargs, skip_params={"action"}
+                )
+
+                if is_async:
+                    observation = await _env.step_async(action, **valid_kwargs)
+                else:
+                    observation = await self._run_sync_in_thread_pool(
+                        _env.step, action, **valid_kwargs
+                    )
+
+                return StepResponse(**serialize_observation(observation))
+            finally:
+                _env.close()
+
+        # Helper function to handle MCP endpoint
+        async def mcp_handler(
+            request: JsonRpcRequest, session_env: Optional[Environment] = None
+        ) -> JsonRpcResponse:
+            """
+            Handle MCP JSON-RPC requests.
+
+            Supports tools/list and tools/call methods in JSON-RPC 2.0 format.
+            """
+            method = request.method
+            request_id = request.id
+
+            # Use provided session environment or create temporary one
+            if session_env is not None:
+                _env = session_env
+                should_close = False
+            else:
+                _env = self._env_factory()
+                should_close = True
+            try:
+                if method == McpMethod.TOOLS_LIST:
+                    # Check if environment is MCP-enabled
+                    if not hasattr(_env, "mcp_client"):
+                        return JsonRpcResponse.error_response(
+                            JsonRpcErrorCode.INTERNAL_ERROR,
+                            "Environment does not support MCP",
+                            request_id=request_id,
+                        )
+
+                    # Use async context manager for MCP client
+                    async with _env.mcp_client:
+                        tools = await _env.mcp_client.list_tools()
+
+                    return JsonRpcResponse.success(
+                        result={
+                            "tools": [
+                                t.model_dump() if hasattr(t, "model_dump") else dict(t)
+                                for t in tools
+                            ]
+                        },
+                        request_id=request_id,
+                    )
+
+                elif method == McpMethod.TOOLS_CALL:
+                    params = request.params
+                    tool_name = params.get("name")
+                    arguments = params.get("arguments", {})
+
+                    if not hasattr(_env, "mcp_client"):
+                        return JsonRpcResponse.error_response(
+                            JsonRpcErrorCode.INTERNAL_ERROR,
+                            "Environment does not support MCP",
+                            request_id=request_id,
+                        )
+
+                    if not tool_name:
+                        return JsonRpcResponse.error_response(
+                            JsonRpcErrorCode.INVALID_REQUEST,
+                            "Missing 'name' in params",
+                            request_id=request_id,
+                        )
+
+                    # Use async context manager for MCP client
+                    async with _env.mcp_client:
+                        result = await _env.mcp_client.call_tool(
+                            name=tool_name, arguments=arguments
+                        )
+
+                    # Ensure result is JSON serializable
+                    serializable_result = _make_json_serializable(result)
+
+                    return JsonRpcResponse.success(
+                        result=serializable_result,
+                        request_id=request_id,
+                    )
+
+                else:
+                    return JsonRpcResponse.error_response(
+                        JsonRpcErrorCode.METHOD_NOT_FOUND,
+                        f"Method not found: {method}",
+                        request_id=request_id,
+                    )
+
+            except Exception as e:
+                return JsonRpcResponse.error_response(
+                    JsonRpcErrorCode.INTERNAL_ERROR,
+                    str(e),
+                    request_id=request_id,
+                )
+            finally:
+                if should_close:
+                    _env.close()
+
+        # Register MCP WebSocket endpoint (available in both production and simulation modes)
+        @app.websocket("/mcp")
+        async def mcp_websocket_endpoint(websocket: WebSocket):
+            """
+            WebSocket endpoint for MCP JSON-RPC requests.
+
+            Each WebSocket connection gets its own environment instance for MCP operations.
+
+            Message Protocol:
+            - Client sends: JSON-RPC 2.0 request (tools/list, tools/call)
+            - Server responds: JSON-RPC 2.0 response (result or error)
+            """
+            await websocket.accept()
+
+            session_id = None
+            session_env = None
+
+            try:
+                # Create session with dedicated environment
+                session_id, session_env = await self._create_session()
+
+                while True:
+                    # Receive message from client
+                    raw_message = await websocket.receive_text()
+
+                    try:
+                        jsonrpc_dict = json.loads(raw_message)
+                        jsonrpc_request = JsonRpcRequest(**jsonrpc_dict)
+                    except json.JSONDecodeError as e:
+                        error_resp = JsonRpcResponse.error_response(
+                            JsonRpcErrorCode.PARSE_ERROR,
+                            f"Parse error: {e}",
+                        )
+                        await websocket.send_text(error_resp.model_dump_json())
+                        continue
+                    except ValidationError as e:
+                        error_resp = JsonRpcResponse.error_response(
+                            JsonRpcErrorCode.INVALID_REQUEST,
+                            f"Invalid request: {e}",
+                        )
+                        await websocket.send_text(error_resp.model_dump_json())
+                        continue
+
+                    try:
+                        # Call mcp_handler with session environment
+                        response = await mcp_handler(
+                            jsonrpc_request, session_env=session_env
+                        )
+                        await websocket.send_text(response.model_dump_json())
+                    except Exception as e:
+                        error_resp = JsonRpcResponse.error_response(
+                            JsonRpcErrorCode.INTERNAL_ERROR,
+                            str(e),
+                            request_id=jsonrpc_request.id,
+                        )
+                        await websocket.send_text(error_resp.model_dump_json())
+
+            except WebSocketDisconnect:
+                pass
+            except SessionCapacityError as e:
+                error_resp = JsonRpcResponse.error_response(
+                    JsonRpcErrorCode.SERVER_ERROR,
+                    str(e),
+                    data={
+                        "active_sessions": e.active_sessions,
+                        "max_sessions": e.max_sessions,
+                    },
+                )
+                await websocket.send_text(error_resp.model_dump_json())
+            except EnvironmentFactoryError as e:
+                error_resp = JsonRpcResponse.error_response(
+                    JsonRpcErrorCode.SERVER_ERROR,
+                    str(e),
+                    data={"factory_name": e.factory_name},
+                )
+                await websocket.send_text(error_resp.model_dump_json())
+            except Exception as e:
+                error_resp = JsonRpcResponse.error_response(
+                    JsonRpcErrorCode.SERVER_ERROR,
+                    str(e),
+                )
+                await websocket.send_text(error_resp.model_dump_json())
+            finally:
+                if session_id:
+                    await self._destroy_session(session_id)
+                try:
+                    await websocket.close()
+                except RuntimeError:
+                    pass
+
+        # Register simulation control routes only in simulation mode
+        if mode == ServerMode.SIMULATION:
+
+            @app.post(
+                "/reset",
+                response_model=ResetResponse,
+                tags=["Environment Control"],
+                summary="Reset the environment",
+                description="""
+Reset the environment to its initial state and return the first observation.
+
+You can optionally provide a seed for reproducibility and an episode_id for tracking.
+                """,
+                responses={
+                    200: {
+                        "description": "Environment reset successfully",
+                        "content": {
+                            "application/json": {
+                                "example": {
+                                    "observation": {"status": "ready", "data": {}},
+                                    "reward": None,
+                                    "done": False,
+                                }
+                            }
+                        },
+                    }
+                },
+            )
+            async def reset(
+                request: ResetRequest = Body(default_factory=ResetRequest),
+            ) -> ResetResponse:
+                return await reset_handler(request)
+
+            @app.post(
+                "/step",
+                response_model=StepResponse,
+                tags=["Environment Control"],
+                summary="Execute an action in the environment",
+                description="""
+Execute an action in the environment and receive the resulting observation.
+
+The action must conform to the environment's action schema, which can be
+retrieved from the `/schema` endpoint. If the action is invalid,
+the endpoint will return HTTP 422 with detailed validation errors.
+
+The response includes:
+- **observation**: The environment's response to the action
+- **reward**: Optional reward signal (float or None)
+- **done**: Boolean indicating if the episode has terminated
+                """,
+                responses={
+                    200: {
+                        "description": "Action executed successfully",
+                        "content": {
+                            "application/json": {
+                                "example": {
+                                    "observation": {"status": "success", "data": {}},
+                                    "reward": 1.0,
+                                    "done": False,
+                                }
+                            }
+                        },
+                    },
+                    422: {
+                        "description": "Validation error - invalid action format or values",
+                        "content": {
+                            "application/json": {
+                                "example": {
+                                    "detail": [
+                                        {
+                                            "type": "string_too_short",
+                                            "loc": ["body", "action", "message"],
+                                            "msg": "String should have at least 1 character",
+                                            "input": "",
+                                        }
+                                    ]
+                                }
+                            }
+                        },
+                    },
+                    500: {
+                        "description": "Internal server error during action execution"
+                    },
+                },
+            )
+            async def step(request: StepRequest) -> StepResponse:
+                return await step_handler(request)
+
+        def get_state_handler() -> State:
+            _env = self._env_factory()
+            try:
+                return _env.state
+            finally:
+                _env.close()
+
+        def get_metadata_handler() -> EnvironmentMetadata:
+            _env = self._env_factory()
+            try:
+                return _env.get_metadata()
+            finally:
+                _env.close()
+
+        # Build list of GET endpoints based on mode
+        get_endpoints = [
+            GetEndpointConfig(
+                path="/metadata",
+                handler=get_metadata_handler,
+                response_model=EnvironmentMetadata,
+                tag="Environment Info",
+                summary="Get environment metadata",
+                description="""
+Get metadata about this environment.
+
+Returns information about the environment including name, description,
+version, author, and documentation links.
+                """,
+            ),
+            GetEndpointConfig(
+                path="/health",
+                handler=lambda: HealthResponse(status=HealthStatus.HEALTHY),
+                response_model=HealthResponse,
+                tag="Health",
+                summary="Health check",
+                description="Check if the environment server is running and healthy.",
+            ),
+        ]
+
+        # Only register /state endpoint in simulation mode
+        if mode == ServerMode.SIMULATION:
+            get_endpoints.insert(
+                0,
+                GetEndpointConfig(
+                    path="/state",
+                    handler=get_state_handler,
+                    response_model=State,
+                    tag="State Management",
+                    summary="Get current environment state",
+                    description="""
+Retrieve the current internal state of the environment.
+
+The structure of the state object is defined by the environment's State model.
+                    """,
+                ),
+            )
+
+        register_get_endpoints(app, get_endpoints)
+
+        # Register combined schema endpoint
+        @app.get(
+            "/schema",
+            response_model=SchemaResponse,
+            tags=["Schema"],
+            summary="Get all JSON schemas",
+            description="""
+Get JSON schemas for actions, observations, and state in a single response.
+
+Returns a combined schema object containing:
+- **action**: JSON schema for actions accepted by this environment
+- **observation**: JSON schema for observations returned by this environment
+- **state**: JSON schema for environment state objects
+
+This is more efficient than calling individual schema endpoints and provides
+all schema information needed to interact with the environment.
+            """,
+            responses={
+                200: {
+                    "description": "Combined schemas retrieved successfully",
+                    "content": {
+                        "application/json": {
+                            "example": {
+                                "action": {
+                                    "type": "object",
+                                    "properties": {"message": {"type": "string"}},
+                                },
+                                "observation": {
+                                    "type": "object",
+                                    "properties": {"response": {"type": "string"}},
+                                },
+                                "state": {
+                                    "type": "object",
+                                    "properties": {"step_count": {"type": "integer"}},
+                                },
+                            }
+                        }
+                    },
+                }
+            },
+        )
+        async def get_schemas() -> SchemaResponse:
+            """Return all schemas in one response."""
+            return SchemaResponse(
+                action=self.action_cls.model_json_schema(),
+                observation=self.observation_cls.model_json_schema(),
+                state=State.model_json_schema(),
+            )
+
+        # Register MCP endpoint for production mode (direct MCP access)
+        @app.post("/mcp")
+        async def mcp_endpoint(request_raw: Request) -> Dict[str, Any]:
+            """
+            MCP JSON-RPC endpoint for production mode.
+
+            Bypasses step() overhead and provides direct access to MCP tools.
+            Supports tools/list and tools/call methods.
+            """
+            # Parse JSON manually to handle parse errors gracefully
+            try:
+                body = await request_raw.body()
+                request_dict = json.loads(body)
+                request = JsonRpcRequest(**request_dict)
+            except json.JSONDecodeError:
+                return JsonRpcResponse.error_response(
+                    JsonRpcErrorCode.PARSE_ERROR
+                ).model_dump()
+            except ValidationError as e:
+                return JsonRpcResponse.error_response(
+                    JsonRpcErrorCode.INVALID_REQUEST,
+                    f"Invalid request: {e}",
+                ).model_dump()
+            except Exception:
+                return JsonRpcResponse.error_response(
+                    JsonRpcErrorCode.PARSE_ERROR
+                ).model_dump()
+
+            method = request.method
+            params = request.params
+            request_id = request.id
+
+            # Create a temporary environment for MCP access
+            _env = self._env_factory()
+
+            try:
+                # Check if environment supports MCP
+                if not hasattr(_env, "mcp_client") and not hasattr(_env, "mcp_server"):
+                    return JsonRpcResponse.error_response(
+                        JsonRpcErrorCode.INTERNAL_ERROR,
+                        "Environment does not support MCP",
+                        request_id=request_id,
+                    ).model_dump()
+
+                if method == McpMethod.TOOLS_LIST:
+                    # List tools from MCP server
+                    if hasattr(_env, "mcp_client") and _env.mcp_client:
+                        async with _env.mcp_client:
+                            tools = await _env.mcp_client.list_tools()
+                        return JsonRpcResponse.success(
+                            result={
+                                "tools": [
+                                    t.model_dump()
+                                    if hasattr(t, "model_dump")
+                                    else dict(t)
+                                    for t in tools
+                                ]
+                            },
+                            request_id=request_id,
+                        ).model_dump()
+                    elif hasattr(_env, "mcp_server") and _env.mcp_server:
+                        # Use server directly
+                        tools = []
+                        for tool_name, tool in get_server_tools(
+                            _env.mcp_server
+                        ).items():
+                            tool_dict = {
+                                "name": tool.name,
+                                "description": tool.description or "",
+                                "inputSchema": tool.parameters or {},
+                            }
+                            tools.append(tool_dict)
+                        return JsonRpcResponse.success(
+                            result={"tools": tools},
+                            request_id=request_id,
+                        ).model_dump()
+                    else:
+                        return JsonRpcResponse.error_response(
+                            JsonRpcErrorCode.INTERNAL_ERROR,
+                            "MCP server not available",
+                            request_id=request_id,
+                        ).model_dump()
+
+                elif method == McpMethod.TOOLS_CALL:
+                    tool_name = params.get("name")
+                    arguments = params.get("arguments", {})
+
+                    if not tool_name:
+                        return JsonRpcResponse.error_response(
+                            JsonRpcErrorCode.INVALID_PARAMS,
+                            "Invalid params - 'name' is required",
+                            request_id=request_id,
+                        ).model_dump()
+
+                    # Call tool via MCP
+                    if hasattr(_env, "mcp_client") and _env.mcp_client:
+                        async with _env.mcp_client:
+                            result = await _env.mcp_client.call_tool(
+                                name=tool_name, arguments=arguments
+                            )
+                    elif hasattr(_env, "mcp_server") and _env.mcp_server:
+                        # Call tool directly on FastMCP server
+                        server_tools = get_server_tools(_env.mcp_server)
+                        if tool_name in server_tools:
+                            tool = server_tools[tool_name]
+                            result = tool.fn(**arguments)
+                        else:
+                            return JsonRpcResponse.error_response(
+                                JsonRpcErrorCode.INVALID_PARAMS,
+                                f"Tool not found: {tool_name}",
+                                request_id=request_id,
+                            ).model_dump()
+                    else:
+                        return JsonRpcResponse.error_response(
+                            JsonRpcErrorCode.INTERNAL_ERROR,
+                            "MCP server not available",
+                            request_id=request_id,
+                        ).model_dump()
+
+                    # Make result JSON serializable
+                    serializable_result = _make_json_serializable(result)
+
+                    return JsonRpcResponse.success(
+                        result=serializable_result,
+                        request_id=request_id,
+                    ).model_dump()
+
+                else:
+                    return JsonRpcResponse.error_response(
+                        JsonRpcErrorCode.METHOD_NOT_FOUND,
+                        f"Method not found: {method}",
+                        request_id=request_id,
+                    ).model_dump()
+
+            except Exception as e:
+                return JsonRpcResponse.error_response(
+                    JsonRpcErrorCode.INTERNAL_ERROR,
+                    str(e),
+                    request_id=request_id,
+                ).model_dump()
+            finally:
+                _env.close()
+
+        # Register WebSocket endpoint for persistent sessions
+        @app.websocket("/ws")
+        async def websocket_endpoint(websocket: WebSocket):
+            """
+            WebSocket endpoint for persistent environment sessions.
+
+            Each WebSocket connection gets its own environment instance.
+
+            Message Protocol:
+            - Client sends: WSResetMessage | WSStepMessage | WSStateMessage | WSCloseMessage
+            - Server responds: WSObservationResponse | WSStateResponse | WSErrorResponse
+            """
+            await websocket.accept()
+
+            session_id = None
+            session_env = None
+
+            try:
+                # Create session with dedicated environment
+                session_id, session_env = await self._create_session()
+
+                while True:
+                    # Receive message from client
+                    raw_message = await websocket.receive_text()
+
+                    try:
+                        message_dict = json.loads(raw_message)
+                    except json.JSONDecodeError as e:
+                        error_resp = WSErrorResponse(
+                            data={
+                                "message": f"Invalid JSON: {e}",
+                                "code": WSErrorCode.INVALID_JSON,
+                            }
+                        )
+                        await websocket.send_text(error_resp.model_dump_json())
+                        continue
+
+                    msg_type = message_dict.get("type", "")
+
+                    try:
+                        match msg_type:
+                            case "reset":
+                                msg = WSResetMessage(**message_dict)
+
+                                is_async = (
+                                    session_env.reset_async.__func__
+                                    is not Environment.reset_async
+                                )
+
+                                if is_async:
+                                    sig = inspect.signature(session_env.reset_async)
+                                    valid_kwargs = self._get_valid_kwargs(sig, msg.data)
+                                    observation = await session_env.reset_async(
+                                        **valid_kwargs
+                                    )
+                                else:
+                                    sig = inspect.signature(session_env.reset)
+                                    valid_kwargs = self._get_valid_kwargs(sig, msg.data)
+                                    observation = await self._run_in_session_executor(
+                                        session_id, session_env.reset, **valid_kwargs
+                                    )
+
+                                self._update_session_activity(session_id)
+
+                                response = WSObservationResponse(
+                                    data=serialize_observation(observation),
+                                )
+
+                            case "step":
+                                msg = WSStepMessage(**message_dict)
+                                action = deserialize_action(msg.data, self.action_cls)
+
+                                is_async = (
+                                    session_env.step_async.__func__
+                                    is not Environment.step_async
+                                )
+
+                                if is_async:
+                                    observation = await session_env.step_async(action)
+                                else:
+                                    observation = await self._run_in_session_executor(
+                                        session_id, session_env.step, action
+                                    )
+
+                                self._update_session_activity(
+                                    session_id, increment_step=True
+                                )
+
+                                response = WSObservationResponse(
+                                    data=serialize_observation(observation)
+                                )
+
+                            case "state":
+                                msg = WSStateMessage(**message_dict)
+                                state = session_env.state
+                                if hasattr(state, "model_dump"):
+                                    state_data = state.model_dump()
+                                else:
+                                    state_data = dict(state) if state else {}
+
+                                response = WSStateResponse(data=state_data)
+
+                            case "close":
+                                msg = WSCloseMessage(**message_dict)
+                                break
+
+                            case "mcp":
+                                msg = WSMCPMessage(**message_dict)
+                                try:
+                                    rpc_request = JsonRpcRequest(**msg.data)
+                                except (ValidationError, Exception) as e:
+                                    rpc_response = JsonRpcResponse.error_response(
+                                        JsonRpcErrorCode.INVALID_REQUEST,
+                                        f"Invalid request: {e}",
+                                    )
+                                else:
+                                    rpc_response = await mcp_handler(
+                                        rpc_request,
+                                        session_env=session_env,
+                                    )
+                                response = WSMCPResponse(data=rpc_response.model_dump())
+
+                            case _:
+                                response = WSErrorResponse(
+                                    data={
+                                        "message": f"Unknown message type: {msg_type}",
+                                        "code": WSErrorCode.UNKNOWN_TYPE,
+                                    }
+                                )
+
+                        await websocket.send_text(response.model_dump_json())
+
+                    except ValidationError as e:
+                        error_resp = WSErrorResponse(
+                            data={
+                                "message": "Invalid message",
+                                "code": WSErrorCode.VALIDATION_ERROR,
+                                "errors": e.errors(),
+                            }
+                        )
+                        await websocket.send_text(error_resp.model_dump_json())
+                    except Exception as e:
+                        error_resp = WSErrorResponse(
+                            data={
+                                "message": str(e),
+                                "code": WSErrorCode.EXECUTION_ERROR,
+                            }
+                        )
+                        await websocket.send_text(error_resp.model_dump_json())
+
+            except WebSocketDisconnect:
+                pass
+            except SessionCapacityError as e:
+                error_resp = WSErrorResponse(
+                    data={
+                        "message": str(e),
+                        "code": WSErrorCode.CAPACITY_REACHED,
+                        "active_sessions": e.active_sessions,
+                        "max_sessions": e.max_sessions,
+                    }
+                )
+                await websocket.send_text(error_resp.model_dump_json())
+            except EnvironmentFactoryError as e:
+                error_resp = WSErrorResponse(
+                    data={
+                        "message": str(e),
+                        "code": WSErrorCode.FACTORY_ERROR,
+                        "factory_name": e.factory_name,
+                    }
+                )
+                await websocket.send_text(error_resp.model_dump_json())
+            except Exception as e:
+                error_resp = WSErrorResponse(
+                    data={"message": str(e), "code": WSErrorCode.SESSION_ERROR}
+                )
+                await websocket.send_text(error_resp.model_dump_json())
+            finally:
+                if session_id:
+                    await self._destroy_session(session_id)
+                try:
+                    await websocket.close()
+                except RuntimeError:
+                    pass
+
+
+def create_app(
+    env: Callable[[], Environment],
+    action_cls: Type[Action],
+    observation_cls: Type[Observation],
+    env_name: Optional[str] = None,
+    max_concurrent_envs: Optional[int] = None,
+    concurrency_config: Optional[ConcurrencyConfig] = None,
+    gradio_builder: Optional[Callable[..., Any]] = None,
+) -> FastAPI:
+    """
+    Create a FastAPI application with or without web interface.
+
+    This function creates a FastAPI app with the web interface enabled by default,
+    including README integration for better user experience.
+
+    Args:
+        env: Environment factory (callable) that creates new instances
+        action_cls: The Action subclass this environment expects
+        observation_cls: The Observation subclass this environment returns
+        env_name: Optional environment name for README loading
+        max_concurrent_envs: Maximum concurrent WebSocket sessions.
+                             Mutually exclusive with concurrency_config.
+        concurrency_config: Optional ConcurrencyConfig for advanced concurrency settings.
+                            Mutually exclusive with max_concurrent_envs.
+        gradio_builder: Optional callable to build a custom Gradio UI at /web.
+            Signature: (web_manager, action_fields, metadata, is_chat_env, title,
+            quick_start_md) -> gr.Blocks. When None, the default Gradio app is used.
+            See docs/customizing-web-ui.md.
+
+    Returns:
+        FastAPI application instance with or without web interface and README integration
+    """
+    # Check if web interface should be enabled
+    # This can be controlled via environment variable or build argument
+    enable_web = os.getenv("ENABLE_WEB_INTERFACE", "false").lower() in (
+        "true",
+        "1",
+        "yes",
+    )
+
+    if enable_web:
+        # Gradio-based web UI (gradio is a core dependency)
+        from .web_interface import create_web_interface_app
+
+        return create_web_interface_app(
+            env,
+            action_cls,
+            observation_cls,
+            env_name,
+            max_concurrent_envs,
+            concurrency_config,
+            gradio_builder=gradio_builder,
+        )
+    else:
+        # Use standard FastAPI app without web interface
+        return create_fastapi_app(
+            env, action_cls, observation_cls, max_concurrent_envs, concurrency_config
+        )
+
+
+def create_fastapi_app(
+    env: Callable[[], Environment],
+    action_cls: Type[Action],
+    observation_cls: Type[Observation],
+    max_concurrent_envs: Optional[int] = None,
+    concurrency_config: Optional[ConcurrencyConfig] = None,
+) -> FastAPI:
+    """
+    Create a FastAPI application with comprehensive documentation.
+
+    Args:
+        env: Environment factory (callable) that creates new instances
+        action_cls: The Action subclass this environment expects
+        observation_cls: The Observation subclass this environment returns
+        max_concurrent_envs: Maximum concurrent WebSocket sessions.
+                             Mutually exclusive with concurrency_config.
+        concurrency_config: Optional ConcurrencyConfig for advanced concurrency settings.
+                            Mutually exclusive with max_concurrent_envs.
+
+    Returns:
+        FastAPI application instance
+    """
+    try:
+        from fastapi import FastAPI
+    except ImportError:
+        raise ImportError(
+            "FastAPI is required. Install with: pip install fastapi uvicorn"
+        )
+
+    app = FastAPI(
+        title="OpenEnv Environment HTTP API",
+        version="1.0.0",
+        description="""
+# OpenEnv Environment HTTP API
+
+HTTP API for interacting with OpenEnv environments through a standardized interface.
+
+## Features
+
+* **Environment Reset**: Initialize or restart episodes
+* **Action Execution**: Send actions and receive observations
+* **State Inspection**: Query current environment state
+* **Schema Access**: Retrieve JSON schemas for actions and observations
+
+## Workflow
+
+1. Call `/reset` to start a new episode and get initial observation
+2. Call `/step` repeatedly with actions to interact with environment
+3. Episode ends when observation returns `done: true`
+4. Call `/state` anytime to inspect current environment state
+
+## Documentation
+
+* **Swagger UI**: Available at `/docs`
+* **ReDoc**: Available at `/redoc`
+* **OpenAPI Schema**: Available at `/openapi.json`
+        """,
+        openapi_tags=[
+            {
+                "name": "Environment Control",
+                "description": "Core operations for environment interaction (reset, step)",
+            },
+            {
+                "name": "State Management",
+                "description": "Operations for inspecting environment state",
+            },
+            {
+                "name": "Environment Info",
+                "description": "Information about the environment",
+            },
+            {
+                "name": "Schema",
+                "description": "JSON Schema endpoints for actions, observations, and state",
+            },
+            {"name": "Health", "description": "Service health and status checks"},
+        ],
+        docs_url="/docs",
+        redoc_url="/redoc",
+        openapi_url="/openapi.json",
+        contact={
+            "name": "OpenEnv Team",
+            "url": "https://github.com/meta-pytorch/OpenEnv",
+        },
+        license_info={
+            "name": "BSD-3-Clause",
+            "url": "https://github.com/meta-pytorch/OpenEnv/blob/main/LICENSE",
+        },
+    )
+
+    server = HTTPEnvServer(
+        env,
+        action_cls,
+        observation_cls,
+        max_concurrent_envs,
+        concurrency_config=concurrency_config,
+    )
+    server.register_routes(app)
+    return app

src/core/env_server/interfaces.py

@@ -0,0 +1,297 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import inspect
+from abc import ABC, abstractmethod
+from typing import Any, Generic, Optional, Protocol, TYPE_CHECKING, TypeVar
+
+from typing_extensions import TypedDict
+
+from .types import Action, EnvironmentMetadata, Observation, State
+
+if TYPE_CHECKING:
+    from openenv.core.rubrics import Rubric
+
+ActT = TypeVar("ActT", bound=Action)
+ObsT = TypeVar("ObsT", bound=Observation)
+StateT = TypeVar("StateT", bound=State)
+
+
+class Message(TypedDict):
+    """A message in a conversation.
+
+    Compatible with Huggingface chat template format.
+    """
+
+    role: str
+    content: str
+
+
+class ModelTokenizer(Protocol):
+    """Protocol for tokenizers that support chat templates.
+
+    This protocol defines the interface that tokenizers must implement
+    to work with chat-based environments. It's compatible with
+    Huggingface transformers tokenizers.
+    """
+
+    def apply_chat_template(
+        self,
+        conversation: list[Message],
+        tokenize: bool = True,
+        return_tensors: str | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Apply a chat template to format and optionally tokenize a conversation.
+
+        Args:
+            conversation: List of message dictionaries with 'role' and 'content'
+            tokenize: Whether to tokenize the output
+            return_tensors: Format for returned tensors ('pt' for PyTorch)
+            **kwargs: Additional arguments
+
+        Returns:
+            Formatted and optionally tokenized conversation
+        """
+        ...
+
+    def decode(
+        self, token_ids: Any, skip_special_tokens: bool = False, **kwargs: Any
+    ) -> str:
+        """Decode token IDs back to text.
+
+        Args:
+            token_ids: Token IDs to decode
+            skip_special_tokens: Whether to skip special tokens in output
+            **kwargs: Additional arguments
+
+        Returns:
+            Decoded text string
+        """
+        ...
+
+
+class Transform(ABC, Generic[ObsT]):
+    """Transform observations to add rewards, metrics, or other modifications.
+
+    Transforms follow the TorchRL pattern where they take an observation
+    and return a (potentially modified) observation. This allows for
+    flexible reward computation and observation augmentation.
+    """
+
+    @abstractmethod
+    def __call__(self, observation: ObsT) -> ObsT:
+        """Transform an observation.
+
+        Args:
+            observation: The input observation
+
+        Returns:
+            The transformed observation
+        """
+        pass
+
+
+class Environment(ABC, Generic[ActT, ObsT, StateT]):
+    """Base class for all environment servers following Gym/Gymnasium API.
+
+    Args:
+        transform: Optional transform to apply to observations
+        rubric: Optional rubric for reward computation. When provided, the
+            rubric's output can be used to set the observation's reward in step().
+
+    Class Attributes:
+        SUPPORTS_CONCURRENT_SESSIONS: Whether this environment supports concurrent sessions.
+            When True, multiple WebSocket connections can each have their own
+            environment instance (up to max_concurrent_envs). When False (default),
+            the environment should only be used with a single session at a time.
+
+            Set this to True in your Environment subclass if:
+            - The environment uses proper session isolation (e.g., unique working dirs)
+            - No shared mutable state exists between instances
+            - External resources (databases, APIs) can handle concurrent access
+
+    Attributes:
+        rubric: Optional rubric for computing rewards. Environments can set this
+            in __init__ and use it in step() to compute observation rewards.
+            Training infrastructure can access it for introspection:
+                for name, r in env.rubric.named_rubrics():
+                    print(f"{name}: {r.last_score}")
+
+    See RFC 004 for rubric design: rfcs/004-rubrics.md
+    """
+
+    # Class-level flag indicating whether this environment supports concurrent sessions
+    SUPPORTS_CONCURRENT_SESSIONS: bool = False
+
+    # Optional rubric for reward computation
+    rubric: Optional["Rubric"]
+
+    def __init__(
+        self,
+        transform: Optional[Transform[ObsT]] = None,
+        rubric: Optional["Rubric"] = None,
+    ):
+        self.transform = transform
+        self.rubric = rubric
+
+    @abstractmethod
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> ObsT:
+        """Reset the environment and return initial observation."""
+        pass
+
+    async def reset_async(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        **kwargs: Any,
+    ) -> ObsT:
+        """Async version of reset. Default implementation calls sync reset.
+
+        Override to provide true async implementation.
+        """
+        return self.reset(seed=seed, episode_id=episode_id, **kwargs)
+
+    @abstractmethod
+    def step(
+        self,
+        action: ActT,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> ObsT:
+        """Take a step in the environment."""
+        pass
+
+    async def step_async(
+        self,
+        action: ActT,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> ObsT:
+        """Async version of step. Default implementation calls sync step.
+
+        Override to provide true async implementation.
+        """
+        return self.step(action, timeout_s=timeout_s, **kwargs)
+
+    @property
+    @abstractmethod
+    def state(self) -> StateT:
+        """Get the current environment state."""
+        pass
+
+    def get_metadata(self) -> EnvironmentMetadata:
+        """
+        Get metadata about this environment.
+
+        Override this method to provide custom metadata for the environment.
+        Default implementation returns basic metadata derived from class name.
+
+        Returns:
+            EnvironmentMetadata with environment information
+        """
+        return EnvironmentMetadata(
+            name=self.__class__.__name__,
+            description=f"{self.__class__.__name__} environment",
+            version="1.0.0",
+        )
+
+    def _apply_transform(self, observation: ObsT) -> ObsT:
+        """Apply transform if one is provided."""
+        if self.transform is not None:
+            return self.transform(observation)
+        return observation
+
+    def _apply_rubric(self, action: ActT, observation: ObsT) -> float:
+        """Apply rubric if one is provided.
+
+        Args:
+            action: The action taken by the agent.
+            observation: The resulting observation.
+
+        Returns:
+            Reward value from the rubric, or 0.0 if no rubric is set.
+
+        Usage in step():
+            def step(self, action: MyAction, ...) -> MyObservation:
+                # ... execute action and create observation ...
+                observation.reward = self._apply_rubric(action, observation)
+                return observation
+        """
+        if self.rubric is not None:
+            return self.rubric(action, observation)
+        return 0.0
+
+    async def _apply_rubric_async(self, action: ActT, observation: ObsT) -> float:
+        """Apply rubric asynchronously if one is provided.
+
+        Args:
+            action: The action taken by the agent.
+            observation: The resulting observation.
+
+        Returns:
+            Reward value from the rubric, or 0.0 if no rubric is set.
+
+        Usage in step_async():
+            async def step_async(self, action: MyAction, ...) -> MyObservation:
+                # ... execute action and create observation ...
+                observation.reward = await self._apply_rubric_async(action, observation)
+                return observation
+        """
+        if self.rubric is not None:
+            result = self.rubric(action, observation)
+            # If rubric returns a coroutine, await it
+            if inspect.iscoroutine(result):
+                return await result
+            return result
+        return 0.0
+
+    def _reset_rubric(self) -> None:
+        """Reset the rubric state if one is provided.
+
+        Call this in reset() to clear any trajectory state in the rubric.
+
+        Usage in reset():
+            def reset(self, ...) -> MyObservation:
+                self._reset_rubric()
+                # ... create initial observation ...
+                return observation
+        """
+        if self.rubric is not None:
+            self.rubric.reset()
+
+    async def _reset_rubric_async(self) -> None:
+        """Reset the rubric state asynchronously if one is provided.
+
+        Call this in reset_async() to clear any trajectory state in the rubric.
+
+        Usage in reset_async():
+            async def reset_async(self, ...) -> MyObservation:
+                await self._reset_rubric_async()
+                # ... create initial observation ...
+                return observation
+        """
+        if self.rubric is not None:
+            # Check if rubric has async reset method
+            if hasattr(self.rubric, "reset_async"):
+                result = self.rubric.reset_async()
+                if inspect.iscoroutine(result):
+                    await result
+            else:
+                self.rubric.reset()
+
+    def close(self) -> None:
+        """Clean up resources used by the environment.
+
+        Override this method to implement custom cleanup logic.
+        Called when the environment is being destroyed or reset.
+        """
+        pass

src/core/env_server/mcp_environment.py

@@ -0,0 +1,624 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+MCP Environment base class for OpenEnv.
+
+This module provides the MCPEnvironment base class that integrates FastMCP servers
+with OpenEnv's Gym-style Environment interface. It handles MCP tool discovery
+and invocation through the step() API, following RFC 003.
+
+Key features:
+- Automatic routing of ListToolsAction and CallToolAction to MCP server
+- Reserved tool name validation (reset, step, state, close are protected)
+- Timeout handling for tool calls
+- Proper error categorization (tool not found, execution errors, timeouts)
+- Mode-aware tool registration (production vs simulation)
+- Code mode support via get_callables() and execute_code()
+
+Usage:
+    from fastmcp import FastMCP
+    from openenv.core.env_server.mcp_environment import MCPEnvironment
+
+    class MyMCPEnv(MCPEnvironment):
+        def __init__(self):
+            mcp = FastMCP("my-server")
+
+            # Register mode-specific tools
+            @self.tool(mode="production")
+            def my_tool(arg: str) -> str:
+                return f"Production: {arg}"
+
+            @self.tool(mode="simulation")
+            def my_tool(arg: str) -> str:
+                return f"Simulation: {arg}"
+
+            super().__init__(mcp)
+
+        def reset(self, seed=None, episode_id=None, **kwargs):
+            # Reset logic here
+            ...
+
+        def _step_impl(self, action):
+            # Handle non-MCP actions
+            ...
+
+        @property
+        def state(self):
+            # Return current state
+            ...
+"""
+
+import asyncio
+import inspect
+from abc import abstractmethod
+from collections import defaultdict
+from typing import Any, Callable, Dict, Optional
+
+from fastmcp import Client
+from fastmcp.client.client import CallToolResult
+from mcp.types import TextContent
+
+from ..utils import run_async_safely
+from .interfaces import Environment
+from .mcp_types import (
+    CallToolAction,
+    CallToolObservation,
+    ListToolsAction,
+    ListToolsObservation,
+    RESERVED_TOOL_NAMES,
+    Tool,
+    ToolError,
+    ToolErrorType,
+)
+from .types import Action, Observation
+
+
+# Default timeout for MCP tool calls in seconds
+MCP_TOOL_CALL_TIMEOUT = 30.0
+
+# Valid modes for tool registration
+VALID_MODES = {"production", "simulation"}
+
+
+def get_server_tools(mcp_server: Any) -> Dict[str, Any]:
+    """
+    Get tools from a FastMCP server, compatible with both 2.x and 3.x.
+
+    Returns:
+        Dictionary mapping tool names to tool objects.
+    """
+    # FastMCP 2.x: get_tools() returns dict {name: Tool}
+    if hasattr(mcp_server, "get_tools"):
+        result = run_async_safely(mcp_server.get_tools())
+        if isinstance(result, dict):
+            return result
+    # FastMCP 3.x: list_tools() returns list of Tool objects
+    if hasattr(mcp_server, "list_tools"):
+        tools_list = run_async_safely(mcp_server.list_tools())
+        return {t.name: t for t in tools_list}
+    return {}
+
+
+class MCPEnvironment(Environment):
+    """
+    Base class for environments that expose tools via MCP (Model Context Protocol).
+
+    MCPEnvironment bridges FastMCP servers with OpenEnv's Gym-style API, allowing
+    agents to discover and invoke MCP tools through the standard step() interface.
+
+    The class automatically handles:
+    - ListToolsAction: Returns available tools from the MCP server
+    - CallToolAction: Invokes a specific tool with arguments
+
+    All other actions are delegated to the abstract _step_impl() method,
+    which subclasses must implement.
+
+    Args:
+        mcp_server: A FastMCP server instance containing tool definitions.
+            The server's tools will be validated against reserved names.
+        transform: Optional transform to apply to observations (inherited from Environment).
+
+    Raises:
+        ValueError: If any tool in the MCP server uses a reserved name
+            (reset, step, state, close).
+
+    Example:
+        >>> from fastmcp import FastMCP
+        >>> mcp = FastMCP("calculator")
+        >>> @mcp.tool()
+        ... def add(a: int, b: int) -> int:
+        ...     return a + b
+        >>> env = MyMCPEnvironment(mcp)
+        >>> obs = env.step(ListToolsAction())
+        >>> obs.tools[0].name
+        'add'
+    """
+
+    def __init__(self, mcp_server: Any, transform: Optional[Any] = None) -> None:
+        """
+        Initialize the MCP environment.
+
+        Args:
+            mcp_server: A FastMCP server instance with tool definitions.
+            transform: Optional transform to apply to observations.
+
+        Raises:
+            ValueError: If any tool uses a reserved name (reset, step, state, close).
+        """
+        super().__init__(transform=transform)
+
+        # Validate tool names before storing
+        self._validate_tool_names(mcp_server)
+
+        self.mcp_server = mcp_server
+        self.mcp_client = Client(mcp_server)
+
+        # Track mode-specific tools: {tool_name: {mode: func}}
+        # mode can be "production", "simulation", or None (available in all modes)
+        self._mode_tools = defaultdict(dict)
+
+        # Track tool schemas for list_tools: {tool_name: {mode: schema}}
+        self._mode_tool_schemas = defaultdict(dict)
+
+    @property
+    def supports_code_mode(self) -> bool:
+        """Check if this environment supports code mode (execute_code)."""
+        return True
+
+    def _get_server_tools(self, mcp_server: Any) -> Dict[str, Any]:
+        """
+        Get tools from a FastMCP server, compatible with both 2.x and 3.x.
+
+        Returns:
+            Dictionary mapping tool names to tool objects.
+        """
+        return get_server_tools(mcp_server)
+
+    def get_callables(self) -> Dict[str, Callable]:
+        """
+        Get callable functions for code mode.
+
+        Returns tool functions as direct Python callables, enabling code mode
+        where agents write Python code that calls tools directly (no JSON-RPC
+        overhead). Mode-specific tools are filtered by the current mode.
+
+        Returns:
+            Dictionary mapping tool names to callables.
+        """
+        callables: Dict[str, Callable] = {}
+        current_mode = getattr(self, "_mode", None)
+
+        # Extract callables from FastMCP server using public API
+        for tool_name, tool in self._get_server_tools(self.mcp_server).items():
+            if hasattr(tool, "fn") and callable(tool.fn):
+                callables[tool_name] = tool.fn
+
+        # Add mode-specific tools available in current mode
+        for tool_name, mode_funcs in self._mode_tools.items():
+            if None in mode_funcs:
+                # Tool available in all modes (already in FastMCP if registered there)
+                if tool_name not in callables:
+                    callables[tool_name] = mode_funcs[None]
+            elif current_mode in mode_funcs:
+                # Tool available in current mode only
+                callables[tool_name] = mode_funcs[current_mode]
+
+        return callables
+
+    def execute_code(self, code: str) -> Observation:
+        """
+        Execute Python code with tools available as callables.
+
+        This enables the CodeAct pattern where agents write Python code
+        that calls tools directly as functions, avoiding JSON-RPC overhead.
+
+        Args:
+            code: Python code to execute. Tools are available as functions
+                in the execution namespace. Set a variable named 'result'
+                to capture the return value.
+
+        Returns:
+            Observation with result in metadata["result"] or error in
+            metadata["error"].
+        """
+        namespace = self.get_callables()
+
+        result_dict: Dict[str, Any] = {}
+        try:
+            exec(code, namespace, result_dict)
+            result = result_dict.get("result")
+            return Observation(done=False, reward=0.0, metadata={"result": result})
+        except SyntaxError as e:
+            return Observation(
+                done=False, reward=0.0, metadata={"error": f"Syntax error: {str(e)}"}
+            )
+        except Exception as e:
+            return Observation(done=False, reward=0.0, metadata={"error": str(e)})
+
+    def _validate_tool_names(self, mcp_server: Any) -> None:
+        """
+        Validate that no tools use reserved names.
+
+        Reserved names (reset, step, state, close) are protected to maintain
+        the dual API boundary between infrastructure and agent APIs.
+
+        Args:
+            mcp_server: The FastMCP server to validate.
+
+        Raises:
+            ValueError: If any tool uses a reserved name.
+        """
+        tools_dict = self._get_server_tools(mcp_server)
+        if tools_dict:
+            tool_names = set(tools_dict.keys())
+            conflicts = tool_names & RESERVED_TOOL_NAMES
+            if conflicts:
+                raise ValueError(
+                    f"MCP tools cannot use reserved names: {sorted(conflicts)}. "
+                    f"Reserved names are: {sorted(RESERVED_TOOL_NAMES)}"
+                )
+
+    def tool(self, mode: Optional[str] = None) -> Callable:
+        """
+        Decorator for registering mode-aware tools.
+
+        Args:
+            mode: Optional mode for the tool ("production" or "simulation").
+                If None, tool is available in all modes.
+
+        Returns:
+            A decorator function for registering tools.
+
+        Raises:
+            ValueError: If mode is not None, "production", or "simulation".
+        """
+        if mode is not None and mode not in VALID_MODES:
+            raise ValueError(
+                f"Invalid mode '{mode}'. Mode must be 'production', 'simulation', or None."
+            )
+
+        def decorator(func: Callable) -> Callable:
+            tool_name = func.__name__
+            # Validate tool name is not reserved
+            if tool_name in RESERVED_TOOL_NAMES:
+                raise ValueError(
+                    f"Tool name '{tool_name}' is reserved and cannot be used. "
+                    f"Reserved names are: {sorted(RESERVED_TOOL_NAMES)}"
+                )
+
+            # If mode is None, register with FastMCP as usual
+            if mode is None:
+                decorated_func = self.mcp_server.tool()(func)
+                self._mode_tools[tool_name][None] = func
+                return decorated_func
+
+            # For mode-specific tools, don't register with FastMCP
+            # Instead, track them ourselves
+            self._mode_tools[tool_name][mode] = func
+
+            # Extract schema information from function signature
+            sig = inspect.signature(func)
+            schema = {
+                "type": "object",
+                "properties": {},
+                "required": [],
+            }
+
+            for param_name, param in sig.parameters.items():
+                # Get type annotation
+                param_type = param.annotation
+                json_type = "string"  # default
+                if param_type in (int, "int"):
+                    json_type = "integer"
+                elif param_type in (float, "float"):
+                    json_type = "number"
+                elif param_type in (bool, "bool"):
+                    json_type = "boolean"
+
+                schema["properties"][param_name] = {"type": json_type}
+
+                # If no default value, it's required
+                if param.default == inspect.Parameter.empty:
+                    schema["required"].append(param_name)
+
+            # Store the schema for this mode-specific tool
+            self._mode_tool_schemas[tool_name][mode] = {
+                "name": tool_name,
+                "description": func.__doc__ or "",
+                "input_schema": schema,
+            }
+
+            return func
+
+        return decorator
+
+    def step(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> Observation:
+        """
+        Execute an action in the environment.
+
+        This method routes MCP-specific actions (ListToolsAction, CallToolAction)
+        to the appropriate handlers, while delegating all other actions to
+        the subclass's _step_impl() method.
+
+        Args:
+            action: The action to execute. Can be:
+                - ListToolsAction: Returns available MCP tools
+                - CallToolAction: Invokes a specific MCP tool
+                - Any other Action: Delegated to _step_impl()
+            timeout_s: Optional timeout in seconds for the action.
+                Defaults to MCP_TOOL_CALL_TIMEOUT (30s) for MCP actions.
+            **kwargs: Additional arguments passed to handlers.
+
+        Returns:
+            Observation appropriate to the action type:
+                - ListToolsObservation for ListToolsAction
+                - CallToolObservation for CallToolAction
+                - Subclass-defined Observation for other actions
+        """
+        if isinstance(action, ListToolsAction):
+            return self._handle_list_tools()
+        elif isinstance(action, CallToolAction):
+            return self._handle_call_tool(action, timeout_s=timeout_s)
+        else:
+            return self._step_impl(action, timeout_s=timeout_s, **kwargs)
+
+    def _handle_list_tools(self) -> ListToolsObservation:
+        """
+        Handle a ListToolsAction by querying the MCP server.
+
+        Returns:
+            ListToolsObservation containing all available tools with their
+            names, descriptions, and input schemas, filtered by current mode.
+        """
+        try:
+            # Get current mode
+            current_mode = getattr(self, "_mode", None)
+
+            # Start with tools from FastMCP server (mode=None tools)
+            tools_result = run_async_safely(self._async_list_tools())
+
+            # Build list of Tool objects
+            tools = []
+
+            # Add FastMCP tools that are not mode-specific
+            for tool in tools_result:
+                if tool.name not in self._mode_tool_schemas:
+                    tools.append(
+                        Tool(
+                            name=tool.name,
+                            description=tool.description or "",
+                            input_schema=tool.inputSchema
+                            if hasattr(tool, "inputSchema")
+                            else {},
+                        )
+                    )
+
+            # Add mode-specific tools available in current mode
+            for tool_name, mode_schemas in self._mode_tool_schemas.items():
+                if None in mode_schemas:
+                    # Tool available in all modes
+                    schema = mode_schemas[None]
+                    tools.append(
+                        Tool(
+                            name=schema["name"],
+                            description=schema["description"],
+                            input_schema=schema["input_schema"],
+                        )
+                    )
+                elif current_mode in mode_schemas:
+                    # Tool available in current mode
+                    schema = mode_schemas[current_mode]
+                    tools.append(
+                        Tool(
+                            name=schema["name"],
+                            description=schema["description"],
+                            input_schema=schema["input_schema"],
+                        )
+                    )
+
+            return ListToolsObservation(tools=tools)
+
+        except Exception as e:
+            # Return an observation with error in metadata
+            return ListToolsObservation(
+                tools=[],
+                metadata={
+                    "error": str(e),
+                    "error_type": "list_tools_failed",
+                },
+            )
+
+    async def _async_list_tools(self) -> list:
+        """
+        Async helper to list tools from the MCP client.
+
+        Returns:
+            List of tool objects from the MCP server.
+        """
+        async with self.mcp_client:
+            return await self.mcp_client.list_tools()
+
+    def _handle_call_tool(
+        self,
+        action: CallToolAction,
+        timeout_s: Optional[float] = None,
+    ) -> CallToolObservation:
+        """
+        Handle a CallToolAction by invoking the specified tool.
+
+        Args:
+            action: The CallToolAction containing tool_name and arguments.
+            timeout_s: Timeout in seconds. Defaults to MCP_TOOL_CALL_TIMEOUT (30s).
+
+        Returns:
+            CallToolObservation with the tool's result or an error.
+        """
+        timeout = timeout_s if timeout_s is not None else MCP_TOOL_CALL_TIMEOUT
+
+        # Check if this is a mode-specific tool
+        tool_name = action.tool_name
+        current_mode = getattr(self, "_mode", None)
+
+        if tool_name in self._mode_tools:
+            mode_info = self._mode_tools[tool_name]
+
+            # Check if tool is available in current mode
+            # Tool is available if:
+            # 1. It has a None mode (available in all modes), OR
+            # 2. It has an implementation for the current mode
+            if None in mode_info:
+                # Use the mode-agnostic version
+                func = mode_info[None]
+            elif current_mode in mode_info:
+                # Use the mode-specific version
+                func = mode_info[current_mode]
+            else:
+                # Tool not available in current mode
+                return CallToolObservation(
+                    tool_name=tool_name,
+                    result=None,
+                    error=ToolError(
+                        error_type=ToolErrorType.TOOL_NOT_FOUND,
+                        message=f"Tool '{tool_name}' not available in {current_mode} mode",
+                    ),
+                )
+
+            # Call the mode-specific function directly
+            try:
+                # Check if function is async and await if necessary
+                if inspect.iscoroutinefunction(func):
+                    result = run_async_safely(func(**action.arguments))
+                else:
+                    result = func(**action.arguments)
+
+                # Wrap result in CallToolResult format to match FastMCP behavior
+                return CallToolObservation(
+                    tool_name=tool_name,
+                    result=CallToolResult(
+                        content=[TextContent(type="text", text=str(result))],
+                        structured_content={"result": result},
+                        meta=None,
+                        data=result,
+                        is_error=False,
+                    ),
+                )
+            except Exception as e:
+                return CallToolObservation(
+                    tool_name=tool_name,
+                    result=None,
+                    error=ToolError(
+                        error_type=ToolErrorType.EXECUTION_ERROR,
+                        message=str(e),
+                    ),
+                )
+
+        # Not a mode-specific tool, use FastMCP
+        try:
+            # Run the async call_tool with timeout
+            # Use run_async_safely to handle both sync and async contexts
+            result = run_async_safely(
+                asyncio.wait_for(
+                    self._async_call_tool(action.tool_name, action.arguments),
+                    timeout=timeout,
+                )
+            )
+
+            return CallToolObservation(
+                tool_name=action.tool_name,
+                result=result,
+            )
+
+        except asyncio.TimeoutError:
+            return CallToolObservation(
+                tool_name=action.tool_name,
+                result=None,
+                error=ToolError(
+                    error_type=ToolErrorType.TIMEOUT,
+                    message=f"Tool '{action.tool_name}' timed out after {timeout} seconds",
+                ),
+            )
+
+        except Exception as e:
+            error_message = str(e)
+
+            # Determine error type based on the exception
+            if (
+                "not found" in error_message.lower()
+                or "unknown tool" in error_message.lower()
+            ):
+                error_type = ToolErrorType.TOOL_NOT_FOUND
+            elif (
+                "invalid" in error_message.lower()
+                or "argument" in error_message.lower()
+            ):
+                error_type = ToolErrorType.INVALID_ARGS
+            else:
+                error_type = ToolErrorType.EXECUTION_ERROR
+
+            return CallToolObservation(
+                tool_name=action.tool_name,
+                result=None,
+                error=ToolError(
+                    error_type=error_type,
+                    message=error_message,
+                ),
+            )
+
+    async def _async_call_tool(self, tool_name: str, arguments: dict) -> Any:
+        """
+        Async helper to call a tool on the MCP server.
+
+        Args:
+            tool_name: Name of the tool to invoke.
+            arguments: Dictionary of arguments to pass to the tool.
+
+        Returns:
+            The result from the tool execution.
+        """
+        async with self.mcp_client:
+            return await self.mcp_client.call_tool(tool_name, arguments)
+
+    @abstractmethod
+    def _step_impl(
+        self,
+        action: Action,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> Observation:
+        """
+        Handle non-MCP actions in the environment.
+
+        Subclasses must implement this method to handle any actions that are
+        not ListToolsAction or CallToolAction. This is where environment-specific
+        action processing should occur.
+
+        Args:
+            action: The action to execute (guaranteed not to be an MCP action).
+            timeout_s: Optional timeout in seconds.
+            **kwargs: Additional arguments.
+
+        Returns:
+            An Observation appropriate for the action.
+        """
+        pass
+
+    def close(self) -> None:
+        """
+        Clean up resources used by the environment.
+
+        This method cleans up the MCP client and any other resources.
+        Subclasses should call super().close() if they override this method.
+        """
+        # The MCP client uses async context manager, so cleanup happens
+        # automatically when the context exits. We just clear references.
+        self.mcp_client = None
+        self.mcp_server = None

src/core/env_server/mcp_types.py

@@ -0,0 +1,321 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+MCP (Model Context Protocol) type definitions for OpenEnv.
+
+This module defines strongly typed models for MCP tool discovery and invocation,
+following RFC 003. These types map MCP's REST-like API (tools/list, tools/call)
+to Gym-style action types.
+
+Key design decisions:
+- Tool discovery (list_tools) does NOT require reset() first
+- Reserved tool names (reset, step, state, close) are prohibited
+- Both step() and WebSocket /mcp paths are supported
+"""
+
+from enum import Enum
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from .types import Action, BaseMessage, Observation
+
+
+# =============================================================================
+# JSON-RPC 2.0 Types
+# =============================================================================
+
+
+class JsonRpcErrorCode(int, Enum):
+    """
+    Standard JSON-RPC 2.0 error codes.
+
+    See: https://www.jsonrpc.org/specification#error_object
+    """
+
+    # Standard JSON-RPC errors
+    PARSE_ERROR = -32700  # Invalid JSON was received
+    INVALID_REQUEST = -32600  # JSON is not a valid Request object
+    METHOD_NOT_FOUND = -32601  # Method does not exist / is not available
+    INVALID_PARAMS = -32602  # Invalid method parameter(s)
+    INTERNAL_ERROR = -32603  # Internal JSON-RPC error
+
+    # Server errors (reserved for implementation-defined errors)
+    SERVER_ERROR = -32000  # Generic server error
+
+
+class McpMethod(str, Enum):
+    """Supported MCP method names."""
+
+    TOOLS_LIST = "tools/list"
+    TOOLS_CALL = "tools/call"
+
+
+class JsonRpcError(BaseModel):
+    """
+    JSON-RPC 2.0 error object.
+
+    See: https://www.jsonrpc.org/specification#error_object
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    code: int = Field(description="Error code indicating the error type")
+    message: str = Field(description="Short description of the error")
+    data: Optional[Any] = Field(
+        default=None, description="Additional error information"
+    )
+
+    @classmethod
+    def from_code(
+        cls, code: JsonRpcErrorCode, message: Optional[str] = None, data: Any = None
+    ) -> "JsonRpcError":
+        """Create an error from a standard error code."""
+        default_messages = {
+            JsonRpcErrorCode.PARSE_ERROR: "Parse error",
+            JsonRpcErrorCode.INVALID_REQUEST: "Invalid Request",
+            JsonRpcErrorCode.METHOD_NOT_FOUND: "Method not found",
+            JsonRpcErrorCode.INVALID_PARAMS: "Invalid params",
+            JsonRpcErrorCode.INTERNAL_ERROR: "Internal error",
+            JsonRpcErrorCode.SERVER_ERROR: "Server error",
+        }
+        return cls(
+            code=code.value,
+            message=message or default_messages.get(code, "Unknown error"),
+            data=data,
+        )
+
+
+class JsonRpcRequest(BaseModel):
+    """
+    JSON-RPC 2.0 request object.
+
+    See: https://www.jsonrpc.org/specification#request_object
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    jsonrpc: Literal["2.0"] = Field(description="JSON-RPC version, must be '2.0'")
+    method: str = Field(description="Name of the method to be invoked")
+    params: Dict[str, Any] = Field(
+        default_factory=dict, description="Parameter values for the method"
+    )
+    id: Optional[Union[str, int]] = Field(
+        default=None, description="Request identifier established by the client"
+    )
+
+
+class JsonRpcResponse(BaseModel):
+    """
+    JSON-RPC 2.0 response object.
+
+    Per JSON-RPC 2.0 spec, a response has either 'result' or 'error', not both.
+    This model excludes None values during serialization to comply with the spec.
+
+    See: https://www.jsonrpc.org/specification#response_object
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    jsonrpc: Literal["2.0"] = Field(default="2.0", description="JSON-RPC version")
+    result: Optional[Any] = Field(
+        default=None, description="Result of the method invocation"
+    )
+    error: Optional[JsonRpcError] = Field(
+        default=None, description="Error object if method invocation failed"
+    )
+    id: Optional[Union[str, int]] = Field(
+        default=None, description="Request identifier from the request"
+    )
+
+    def model_dump(self, **kwargs) -> Dict[str, Any]:
+        """Serialize to dict, excluding result or error when None (JSON-RPC compliance)."""
+        # Always include jsonrpc and id, but only include result OR error
+        data: Dict[str, Any] = {"jsonrpc": self.jsonrpc, "id": self.id}
+        if self.error is not None:
+            data["error"] = (
+                self.error.model_dump()
+                if hasattr(self.error, "model_dump")
+                else self.error
+            )
+        else:
+            # Only include result if there's no error
+            data["result"] = self.result
+        return data
+
+    def model_dump_json(self, **kwargs) -> str:
+        """Serialize to JSON string, excluding result or error when None (JSON-RPC compliance)."""
+        import json
+
+        return json.dumps(self.model_dump())
+
+    @classmethod
+    def success(
+        cls, result: Any, request_id: Optional[Union[str, int]] = None
+    ) -> "JsonRpcResponse":
+        """Create a success response."""
+        return cls(result=result, id=request_id)
+
+    @classmethod
+    def error_response(
+        cls,
+        code: JsonRpcErrorCode,
+        message: Optional[str] = None,
+        data: Any = None,
+        request_id: Optional[Union[str, int]] = None,
+    ) -> "JsonRpcResponse":
+        """Create an error response from a standard error code."""
+        return cls(
+            error=JsonRpcError.from_code(code, message, data),
+            id=request_id,
+        )
+
+
+# =============================================================================
+# MCP Tool Types
+# =============================================================================
+
+
+class Tool(BaseModel):
+    """
+    Strongly typed MCP tool specification.
+
+    Follows the MCP ToolSpec format for tool discovery.
+    See: https://modelcontextprotocol.io/specification/2025-06-18/server/tools
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str = Field(description="Unique identifier for the tool")
+    description: str = Field(
+        description="Human-readable description of what the tool does"
+    )
+    input_schema: Dict[str, Any] = Field(
+        description="JSON Schema for the tool's input parameters"
+    )
+
+
+class ToolErrorType(str, Enum):
+    """Types of errors that can occur during tool execution."""
+
+    EXECUTION_ERROR = "execution_error"  # Tool ran but failed
+    INVALID_ARGS = "invalid_args"  # Invalid arguments provided
+    TRANSPORT_ERROR = "transport_error"  # Communication failure
+    TOOL_NOT_FOUND = "tool_not_found"  # Tool doesn't exist
+    TIMEOUT = "timeout"  # Operation timed out
+
+
+class ToolError(BaseModel):
+    """
+    Structured error for tool execution failures.
+
+    This is used for transport/framework errors, NOT for errors returned
+    by the tool itself (those go in the result field).
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    error_type: ToolErrorType = Field(description="Category of the error")
+    message: str = Field(description="Human-readable error message")
+
+
+# --- MCP Actions ---
+
+
+class ListToolsAction(Action):
+    """
+    Request list of available tools from the environment.
+
+    This action triggers MCP's tools/list operation and returns
+    all available tools with their schemas.
+
+    Note: Does NOT require reset() to be called first.
+    """
+
+    type: Literal["list_tools"] = Field(
+        default="list_tools", description="Action type discriminator"
+    )
+
+
+class CallToolAction(Action):
+    """
+    Call a specific tool via MCP.
+
+    This action triggers MCP's tools/call operation with the
+    specified tool name and arguments.
+    """
+
+    type: Literal["call_tool"] = Field(
+        default="call_tool", description="Action type discriminator"
+    )
+    tool_name: str = Field(description="Name of the tool to call")
+    arguments: Dict[str, Any] = Field(
+        default_factory=dict, description="Arguments to pass to the tool"
+    )
+
+
+# --- MCP Observations ---
+
+
+class ListToolsObservation(Observation):
+    """
+    Response containing available tools.
+
+    Returned when processing a ListToolsAction.
+    """
+
+    tools: List[Tool] = Field(description="List of available tools with their schemas")
+
+
+class CallToolObservation(Observation):
+    """
+    Response from tool execution.
+
+    Contains the tool's result or an error if the call failed.
+    Tool-specific errors (from the tool itself) are included in the result.
+    Transport/framework errors use the error field.
+    """
+
+    tool_name: str = Field(description="Name of the tool that was called")
+    result: Any = Field(
+        default=None, description="Tool-specific result (may include tool errors)"
+    )
+    error: Optional[ToolError] = Field(
+        default=None, description="Transport/framework error if call failed"
+    )
+
+
+# --- WebSocket Message Types for MCP ---
+
+
+class WSMCPMessage(BaseMessage):
+    """
+    WebSocket message for MCP JSON-RPC requests.
+
+    Allows direct MCP access via WebSocket for production inference,
+    bypassing the step() API.
+    """
+
+    type: Literal["mcp"] = Field(default="mcp", description="Message type")
+    data: Dict[str, Any] = Field(description="JSON-RPC payload (method, params, id)")
+
+
+class WSMCPResponse(BaseModel):
+    """
+    WebSocket response for MCP JSON-RPC.
+
+    Contains the JSON-RPC response from the MCP server.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    type: str = Field(default="mcp", description="Response type")
+    data: Dict[str, Any] = Field(description="JSON-RPC response payload")
+
+
+# Reserved tool names that cannot be used (protects dual API boundary)
+RESERVED_TOOL_NAMES = frozenset(["reset", "step", "state", "close"])

src/core/env_server/route_config.py

@@ -0,0 +1,57 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Route configuration utilities for declarative FastAPI route registration.
+
+This module provides utilities to reduce boilerplate in route registration
+by using configuration objects instead of repeated function calls.
+"""
+
+from dataclasses import dataclass
+from typing import Callable, List, Type
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+
+@dataclass
+class GetEndpointConfig:
+    """Configuration for a simple GET endpoint."""
+
+    path: str
+    handler: Callable[[], BaseModel | dict]
+    response_model: Type[BaseModel] | type[dict]
+    tag: str
+    summary: str
+    description: str
+
+
+def register_get_endpoints(app: FastAPI, configs: List[GetEndpointConfig]) -> None:
+    """
+    Register multiple GET endpoints from configuration.
+
+    Args:
+        app: FastAPI application instance
+        configs: List of GET endpoint configurations
+    """
+    for config in configs:
+        # Capture handler in a closure to avoid non-serializable default parameter
+        def make_endpoint(
+            handler: Callable[[], BaseModel | dict],
+        ) -> Callable[[], BaseModel | dict]:
+            async def endpoint() -> BaseModel | dict:
+                return handler()
+
+            return endpoint
+
+        app.get(
+            config.path,
+            response_model=config.response_model,
+            tags=[config.tag],
+            summary=config.summary,
+            description=config.description,
+        )(make_endpoint(config.handler))

src/core/env_server/serialization.py

@@ -0,0 +1,137 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Shared serialization and deserialization utilities for OpenEnv HTTP servers.
+
+This module provides common utilities for converting between JSON dictionaries
+and Pydantic models (Action/Observation) to eliminate code duplication across
+HTTP server and web interface implementations.
+"""
+
+from typing import Any, Dict, Type
+
+from .types import Action, Observation
+
+
+def deserialize_action(action_data: Dict[str, Any], action_cls: Type[Action]) -> Action:
+    """
+    Convert JSON dict to Action instance using Pydantic validation.
+
+    This is a basic deserialization that works for most environments.
+    For special cases (e.g., tensor fields, custom type conversions),
+    use deserialize_action_with_preprocessing().
+
+    Args:
+        action_data: Dictionary containing action data
+        action_cls: The Action subclass to instantiate
+
+    Returns:
+        Action instance
+
+    Raises:
+        ValidationError: If action_data is invalid for the action class
+
+    Note:
+        This uses Pydantic's model_validate() for automatic validation.
+    """
+    return action_cls.model_validate(action_data)
+
+
+def deserialize_action_with_preprocessing(
+    action_data: Dict[str, Any], action_cls: Type[Action]
+) -> Action:
+    """
+    Convert JSON dict to Action instance with preprocessing for special types.
+
+    This version handles common type conversions needed for web interfaces:
+    - Converting lists/strings to tensors for 'tokens' field
+    - Converting string action_id to int
+    - Other custom preprocessing as needed
+
+    Args:
+        action_data: Dictionary containing action data
+        action_cls: The Action subclass to instantiate
+
+    Returns:
+        Action instance
+
+    Raises:
+        ValidationError: If action_data is invalid for the action class
+    """
+    processed_data = {}
+
+    for key, value in action_data.items():
+        if key == "tokens" and isinstance(value, (list, str)):
+            # Convert list or string to tensor
+            if isinstance(value, str):
+                # If it's a string, try to parse it as a list of numbers
+                try:
+                    import json
+
+                    value = json.loads(value)
+                except Exception:
+                    # If parsing fails, treat as empty list
+                    value = []
+            if isinstance(value, list):
+                try:
+                    import torch  # type: ignore
+
+                    processed_data[key] = torch.tensor(value, dtype=torch.long)
+                except ImportError:
+                    # If torch not available, keep as list
+                    processed_data[key] = value
+            else:
+                processed_data[key] = value
+        elif key == "action_id" and isinstance(value, str):
+            # Convert action_id from string to int
+            try:
+                processed_data[key] = int(value)
+            except ValueError:
+                # If conversion fails, keep original value
+                processed_data[key] = value
+        else:
+            processed_data[key] = value
+
+    return action_cls.model_validate(processed_data)
+
+
+def serialize_observation(observation: Observation) -> Dict[str, Any]:
+    """
+    Convert Observation instance to JSON-compatible dict using Pydantic.
+
+    Args:
+        observation: Observation instance
+
+    Returns:
+        Dictionary compatible with EnvClient._parse_result()
+
+    The format matches what EnvClient expects:
+    {
+        "observation": {...},  # Observation fields
+        "reward": float | None,
+        "done": bool,
+    }
+    """
+    # Use Pydantic's model_dump() for serialization
+    obs_dict = observation.model_dump(
+        exclude={
+            "reward",
+            "done",
+            "metadata",
+        }  # Exclude these from observation dict
+    )
+
+    # Extract reward and done directly from the observation
+    reward = observation.reward
+    done = observation.done
+
+    # Return in EnvClient expected format
+    return {
+        "observation": obs_dict,
+        "reward": reward,
+        "done": done,
+    }

src/core/env_server/types.py

@@ -0,0 +1,387 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from enum import Enum
+from typing import Annotated, Any, Dict, Literal, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+
+# Type aliases
+Scalar = Union[int, float, bool]
+
+
+# =============================================================================
+# Enums for Type Safety
+# =============================================================================
+
+
+class ServerMode(str, Enum):
+    """Server operation mode."""
+
+    SIMULATION = "simulation"
+    PRODUCTION = "production"
+
+
+class HealthStatus(str, Enum):
+    """Server health status values."""
+
+    HEALTHY = "healthy"
+    UNHEALTHY = "unhealthy"
+    DEGRADED = "degraded"
+
+
+class WSErrorCode(str, Enum):
+    """WebSocket error codes for structured error handling."""
+
+    INVALID_JSON = "INVALID_JSON"
+    UNKNOWN_TYPE = "UNKNOWN_TYPE"
+    VALIDATION_ERROR = "VALIDATION_ERROR"
+    EXECUTION_ERROR = "EXECUTION_ERROR"
+    CAPACITY_REACHED = "CAPACITY_REACHED"
+    FACTORY_ERROR = "FACTORY_ERROR"
+    SESSION_ERROR = "SESSION_ERROR"
+
+
+# =============================================================================
+# Core Types
+# =============================================================================
+
+
+class Action(BaseModel):
+    """Base class for all environment actions.
+
+    All action subclasses should inherit from this base class.
+    Uses Pydantic for automatic validation and serialization.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",  # Reject unknown fields
+        validate_assignment=True,  # Validate on field assignment
+        arbitrary_types_allowed=True,  # Allow numpy arrays, torch tensors, etc.
+    )
+
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict, description="Additional metadata for the action"
+    )
+
+
+class Observation(BaseModel):
+    """Base class for all environment observations.
+
+    All observation subclasses should inherit from this base class.
+    Uses Pydantic for automatic validation and serialization.
+    """
+
+    model_config = ConfigDict(
+        extra="forbid",
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+    )
+
+    done: bool = Field(default=False, description="Whether the episode has terminated")
+    reward: bool | int | float | None = Field(
+        default=None, description="Reward signal from the last action"
+    )
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict, description="Additional metadata for the observation"
+    )
+
+
+class ResetRequest(BaseModel):
+    """Request model for environment reset."""
+
+    model_config = ConfigDict(
+        extra="allow",  # Allow extra fields for custom reset parameters
+        json_schema_extra={"examples": [{"seed": 42, "episode_id": "episode-001"}, {}]},
+    )
+
+    seed: Optional[int] = Field(
+        default=None, ge=0, description="Random seed for reproducible episodes"
+    )
+    episode_id: Optional[str] = Field(
+        default=None, max_length=255, description="Custom episode identifier"
+    )
+
+
+class ResetResponse(BaseModel):
+    """Response model for environment reset."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    observation: Dict[str, Any] = Field(
+        ..., description="Initial observation from the environment"
+    )
+    reward: Optional[float] = Field(
+        default=None, description="Initial reward (typically None at reset)"
+    )
+    done: bool = Field(
+        default=False, description="Whether episode is already done (typically False)"
+    )
+
+
+class StepRequest(BaseModel):
+    """Request model for environment step."""
+
+    model_config = ConfigDict(
+        extra="allow",  # Allow extra fields for custom step parameters
+        json_schema_extra={
+            "examples": [
+                {"action": {"value": 1}, "timeout_s": 30.0},
+                {"action": {"value": 1}, "render": True, "verbose": False},
+            ]
+        },
+    )
+
+    action: Dict[str, Any] = Field(
+        ...,
+        description="Action to execute, must conform to environment's action schema",
+    )
+    timeout_s: Optional[float] = Field(
+        default=None,
+        gt=0,
+        description="Optional timeout in seconds for action execution",
+    )
+    request_id: Optional[str] = Field(
+        default=None,
+        max_length=255,
+        description="Optional request identifier for tracking",
+    )
+
+
+class StepResponse(BaseModel):
+    """Response model for environment step."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    observation: Dict[str, Any] = Field(
+        ..., description="Observation resulting from the action"
+    )
+    reward: Optional[float] = Field(
+        default=None, description="Reward signal from the action"
+    )
+    done: bool = Field(default=False, description="Whether the episode has terminated")
+
+
+class BaseMessage(BaseModel):
+    """Base class for WebSocket messages with shared configuration."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+        validate_assignment=True,
+    )
+
+
+class State(BaseModel):
+    """Base class for environment state.
+
+    Represents internal environment state, separate from observations.
+    """
+
+    model_config = ConfigDict(
+        extra="allow",  # Allow extra fields for flexibility
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+    )
+
+    episode_id: Optional[str] = Field(
+        default=None, description="Unique identifier for the current episode"
+    )
+    step_count: int = Field(
+        default=0,
+        ge=0,  # Greater than or equal to 0
+        description="Number of steps taken in the current episode",
+    )
+
+
+class CodeExecResult(BaseMessage):
+    """Result of code execution containing stdout, stderr, and exit code."""
+
+    stdout: str = Field(description="Standard output from code execution")
+    stderr: str = Field(description="Standard error from code execution")
+    exit_code: int = Field(description="Exit code from code execution")
+
+
+class EnvironmentMetadata(BaseMessage):
+    """Metadata about an environment for documentation and UI purposes."""
+
+    name: str = Field(description="Name of the environment")
+    description: str = Field(description="Description of what the environment does")
+    readme_content: Optional[str] = Field(
+        default=None, description="Content of the README file for the environment"
+    )
+    version: Optional[str] = Field(
+        default=None, description="Version of the environment"
+    )
+    author: Optional[str] = Field(default=None, description="Author of the environment")
+    documentation_url: Optional[str] = Field(
+        default=None, description="URL to the environment's documentation"
+    )
+
+
+class SchemaResponse(BaseMessage):
+    """Response model for the combined schema endpoint."""
+
+    action: Dict[str, Any] = Field(
+        description="JSON schema for actions accepted by this environment"
+    )
+    observation: Dict[str, Any] = Field(
+        description="JSON schema for observations returned by this environment"
+    )
+    state: Dict[str, Any] = Field(
+        description="JSON schema for environment state objects"
+    )
+
+
+class HealthResponse(BaseMessage):
+    """Response model for health check endpoint."""
+
+    status: HealthStatus = Field(
+        default=HealthStatus.HEALTHY,
+        description="Health status of the environment server",
+    )
+
+
+class WSResetMessage(BaseMessage):
+    """WebSocket message to reset the environment."""
+
+    type: Literal["reset"] = Field(default="reset", description="Message type")
+    data: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Optional reset parameters (seed, episode_id, etc.)",
+    )
+
+
+class WSStepMessage(BaseMessage):
+    """WebSocket message to execute a step."""
+
+    type: Literal["step"] = Field(default="step", description="Message type")
+    data: Dict[str, Any] = Field(
+        ..., description="Action data conforming to environment's action schema"
+    )
+
+
+class WSStateMessage(BaseMessage):
+    """WebSocket message to request current state."""
+
+    type: Literal["state"] = Field(default="state", description="Message type")
+
+
+class WSCloseMessage(BaseMessage):
+    """WebSocket message to close the session."""
+
+    type: Literal["close"] = Field(default="close", description="Message type")
+
+
+# Discriminated union for incoming WebSocket messages
+# Note: WSMCPMessage is defined in mcp_types.py to avoid circular imports
+# The union here covers the core message types; MCP messages are handled separately
+WSIncomingMessage = Annotated[
+    WSResetMessage | WSStepMessage | WSStateMessage | WSCloseMessage,
+    Field(discriminator="type"),
+]
+
+
+class WSObservationResponse(BaseModel):
+    """WebSocket response containing an observation."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["observation"] = Field(
+        default="observation", description="Response type"
+    )
+    data: Dict[str, Any] = Field(description="Observation data")
+
+
+class WSStateResponse(BaseModel):
+    """WebSocket response containing environment state."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["state"] = Field(default="state", description="Response type")
+    data: Dict[str, Any] = Field(description="State data")
+
+
+class WSErrorResponse(BaseModel):
+    """WebSocket response for errors."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["error"] = Field(default="error", description="Response type")
+    data: Dict[str, Any] = Field(description="Error details including message and code")
+
+
+class ConcurrencyConfig(BaseMessage):
+    """Configuration for concurrent environment sessions."""
+
+    max_concurrent_envs: int = Field(
+        default=1,
+        ge=1,
+        description="Maximum number of concurrent WebSocket sessions allowed",
+    )
+    session_timeout: Optional[float] = Field(
+        default=None,
+        gt=0,
+        description="Timeout in seconds for inactive sessions. None means no timeout.",
+    )
+
+
+class ServerCapacityStatus(BaseMessage):
+    """Status of server capacity for concurrent sessions."""
+
+    active_sessions: int = Field(
+        ge=0,
+        description="Number of currently active sessions",
+    )
+    max_sessions: int = Field(
+        ge=1,
+        description="Maximum number of allowed sessions",
+    )
+
+    @model_validator(mode="after")
+    def check_capacity_bounds(self) -> "ServerCapacityStatus":
+        if self.active_sessions > self.max_sessions:
+            raise ValueError(
+                f"active_sessions ({self.active_sessions}) cannot exceed "
+                f"max_sessions ({self.max_sessions})"
+            )
+        return self
+
+    @property
+    def available_slots(self) -> int:
+        """Number of available session slots."""
+        return self.max_sessions - self.active_sessions
+
+    @property
+    def is_at_capacity(self) -> bool:
+        """Whether the server has reached maximum capacity."""
+        return self.available_slots == 0
+
+    @classmethod
+    def from_counts(cls, active: int, max_sessions: int) -> "ServerCapacityStatus":
+        """Create status from active and max session counts."""
+        return cls(
+            active_sessions=active,
+            max_sessions=max_sessions,
+        )
+
+
+class SessionInfo(BaseMessage):
+    """Information about an active session."""
+
+    session_id: str = Field(description="Unique identifier for the session")
+    created_at: float = Field(description="Unix timestamp when the session was created")
+    last_activity_at: float = Field(
+        description="Unix timestamp of the last activity in the session"
+    )
+    step_count: int = Field(
+        default=0,
+        ge=0,
+        description="Number of steps executed in this session",
+    )
+    environment_type: str = Field(
+        description="Environment type for this session (e.g. `CodingEnv`)"
+    )

src/core/env_server/web_interface.py

@@ -0,0 +1,644 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Web interface for OpenEnv environments.
+
+When ENABLE_WEB_INTERFACE is set, the server exposes a Gradio UI at /web for
+reset, step, and state observation. Controlled by the CLI enable_interface
+option (e.g. openenv push --enable-interface) or ENABLE_WEB_INTERFACE env var.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+from typing import Any, Callable, Dict, List, Optional, Type
+
+import gradio as gr
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from pydantic import BaseModel, ConfigDict, Field
+
+from .gradio_theme import OPENENV_GRADIO_CSS, OPENENV_GRADIO_THEME
+from .gradio_ui import build_gradio_app, get_gradio_display_title
+from .interfaces import Environment
+from .serialization import deserialize_action_with_preprocessing, serialize_observation
+from .types import Action, EnvironmentMetadata, Observation, State
+
+# Quick Start markdown template; placeholders match init suffixes (__ENV_NAME__, __ENV_CLASS_NAME__*).
+DEFAULT_QUICK_START_MARKDOWN = """
+### Connect to this environment
+
+Connect from Python using `__ENV_CLASS_NAME__Env`:
+
+```python
+from __ENV_NAME__ import __ENV_CLASS_NAME__Action, __ENV_CLASS_NAME__Env
+
+with __ENV_CLASS_NAME__Env.from_env("<SPACE_ID>") as env:
+    result = await env.step(__ENV_CLASS_NAME__Action(message="..."))
+```
+
+Or connect directly to a running server:
+
+```python
+env = __ENV_CLASS_NAME__Env(base_url="http://localhost:8000")
+```
+
+### Contribute to this environment
+
+Submit improvements via pull request on the Hugging Face Hub.
+
+```bash
+openenv fork <SPACE_ID> --repo-id <your-username>/<your-repo-name>
+```
+
+Then make your changes and submit a pull request:
+
+```bash
+cd <forked-repo>
+openenv push <SPACE_ID> --create-pr
+```
+
+For more information, see the [OpenEnv documentation](https://meta-pytorch.org/OpenEnv/).
+"""
+
+
+def get_quick_start_markdown(
+    metadata: Optional[EnvironmentMetadata],
+    action_cls: Type[Action],
+    observation_cls: Type[Observation],
+) -> str:
+    """
+    Build Quick Start markdown with class names replaced from current env (init-style suffixes).
+
+    Uses the same placeholder names as the init template so that __ENV_CLASS_NAME__Env,
+    __ENV_CLASS_NAME__Action, __ENV_CLASS_NAME__Observation and __ENV_NAME__ are
+    replaced with the actual class/package names.
+    """
+    import os
+
+    # Prefix from action class (e.g. EchoAction -> Echo)
+    action_name = getattr(action_cls, "__name__", "Action")
+    if action_name.endswith("Action"):
+        prefix = action_name[: -len("Action")]
+    else:
+        prefix = action_name.replace("Action", "").strip() or "Env"
+
+    env_client_name = f"{prefix}Env"
+    obs_name = getattr(observation_cls, "__name__", "Observation")
+    pkg_name = (metadata.name if metadata else "env").replace(" ", "_").lower()
+
+    space_id = os.environ.get("SPACE_ID", "<hf-username>/<hf-repo-name>")
+
+    content = DEFAULT_QUICK_START_MARKDOWN
+    content = content.replace("__ENV_CLASS_NAME__Env", env_client_name)
+    content = content.replace("__ENV_CLASS_NAME__Action", action_name)
+    content = content.replace("__ENV_CLASS_NAME__Observation", obs_name)
+    content = content.replace("__ENV_CLASS_NAME__", prefix)
+    content = content.replace("__ENV_NAME__", pkg_name)
+    content = content.replace("<SPACE_ID>", space_id)
+    return content.strip()
+
+
+def load_environment_metadata(
+    env: Environment, env_name: Optional[str] = None
+) -> EnvironmentMetadata:
+    """
+    Load environment metadata including README content.
+
+    Args:
+        env: The environment instance, class, or factory function.
+             - If a class: used as a factory, won't call instance methods
+             - If a function: used as a factory, won't call instance methods
+             - If an instance: may call get_metadata() if available
+        env_name: Optional environment name for README file lookup
+
+    Returns:
+        EnvironmentMetadata with loaded information
+    """
+    import inspect
+
+    # Determine what type of env we received:
+    # 1. A class (used as factory) - e.g., PythonCodeActEnv
+    # 2. A function (factory function) - e.g., create_chat_environment
+    # 3. An actual instance - e.g., SnakeEnvironment()
+    is_class = inspect.isclass(env)
+    is_function = inspect.isfunction(env) or inspect.ismethod(env)
+    is_factory = is_class or is_function
+
+    # Try to get metadata from environment if it's an instance with get_metadata
+    if not is_factory and hasattr(env, "get_metadata"):
+        return env.get_metadata()
+
+    # Determine the class name for default metadata
+    if is_class:
+        # env is the class itself
+        class_name = env.__name__
+    elif is_function:
+        # env is a factory function - use its name or derive from env_name
+        class_name = env_name or env.__name__
+    else:
+        # env is an instance
+        class_name = env.__class__.__name__
+
+    # Default metadata
+    metadata = EnvironmentMetadata(
+        name=env_name or class_name,
+        description=f"{class_name} environment",
+        version="1.0.0",
+    )
+
+    # Try to load README from file system
+    readme_content = _load_readme_from_filesystem(env_name)
+    if readme_content:
+        metadata.readme_content = readme_content
+
+    return metadata
+
+
+def _load_readme_from_filesystem(env_name: Optional[str]) -> Optional[str]:
+    """
+    Load README content from the filesystem.
+
+    Tries multiple locations:
+    1. Container filesystem: /app/README.md
+    2. Local development: src/envs/{env_name}/README.md
+    3. Environment variable: ENV_README_PATH
+    """
+    import os
+    from pathlib import Path
+
+    # Try container filesystem first
+    container_readme = Path("/app/README.md")
+    if container_readme.exists():
+        try:
+            return container_readme.read_text(encoding="utf-8")
+        except Exception:
+            pass
+
+    # Try environment variable path
+    custom_path = os.environ.get("ENV_README_PATH")
+    if custom_path and Path(custom_path).exists():
+        try:
+            return Path(custom_path).read_text(encoding="utf-8")
+        except Exception:
+            pass
+
+    # Try local development path
+    if env_name:
+        local_readme = Path(f"src/envs/{env_name}/README.md")
+        if local_readme.exists():
+            try:
+                return local_readme.read_text(encoding="utf-8")
+            except Exception:
+                pass
+
+    return None
+
+
+class ActionLog(BaseModel):
+    """Log entry for an action taken."""
+
+    model_config = ConfigDict(extra="forbid", validate_assignment=True)
+
+    timestamp: str = Field(description="Timestamp when action was taken")
+    action: Dict[str, Any] = Field(description="Action that was taken")
+    observation: Dict[str, Any] = Field(description="Observation returned from action")
+    reward: Optional[float] = Field(
+        default=None, description="Reward received from action"
+    )
+    done: bool = Field(description="Whether the episode is done after this action")
+    step_count: int = Field(description="Step count when this action was taken")
+
+
+class EpisodeState(BaseModel):
+    """Current episode state for the web interface."""
+
+    model_config = ConfigDict(extra="forbid", validate_assignment=True)
+
+    episode_id: Optional[str] = Field(default=None, description="Current episode ID")
+    step_count: int = Field(description="Current step count in episode")
+    current_observation: Optional[Dict[str, Any]] = Field(
+        default=None, description="Current observation"
+    )
+    action_logs: List[ActionLog] = Field(
+        default_factory=list, description="List of action logs"
+    )
+    is_reset: bool = Field(
+        default=True, description="Whether the episode has been reset"
+    )
+
+
+class WebInterfaceManager:
+    """Manages the web interface for an environment."""
+
+    MAX_ACTION_LOGS = 1000
+
+    def __init__(
+        self,
+        env: Environment,
+        action_cls: Type[Action],
+        observation_cls: Type[Observation],
+        metadata: Optional[EnvironmentMetadata] = None,
+    ):
+        import inspect
+
+        # If env is a class or factory function, instantiate it
+        if inspect.isclass(env) or inspect.isfunction(env):
+            self.env = env()
+        else:
+            self.env = env
+        self.action_cls = action_cls
+        self.observation_cls = observation_cls
+        self.metadata = metadata or EnvironmentMetadata(
+            name=env.__class__.__name__,
+            description=f"{env.__class__.__name__} environment",
+        )
+        self.episode_state = EpisodeState(
+            episode_id=None,
+            step_count=0,
+            current_observation=None,
+            action_logs=[],
+        )
+        self.connected_clients: List[WebSocket] = []
+        # Thread pool for running sync code (e.g., Playwright sync API) in async context
+        self._executor = ThreadPoolExecutor(max_workers=1)
+
+    async def _run_sync_in_thread_pool(self, func, *args, **kwargs):
+        """Run a synchronous function in the thread pool executor.
+
+        This is needed for environments using sync libraries (e.g., Playwright sync API)
+        that cannot be called directly from an async context.
+        """
+        loop = asyncio.get_event_loop()
+        # Use default arguments to capture values at lambda definition time
+        # to avoid closure issues with late binding
+        return await loop.run_in_executor(
+            self._executor, lambda f=func, a=args, kw=kwargs: f(*a, **kw)
+        )
+
+    async def connect_websocket(self, websocket: WebSocket):
+        """Connect a new WebSocket client."""
+        await websocket.accept()
+        self.connected_clients.append(websocket)
+
+        # Send current state to the new client
+        await self._send_state_update()
+
+    async def disconnect_websocket(self, websocket: WebSocket):
+        """Disconnect a WebSocket client."""
+        if websocket in self.connected_clients:
+            self.connected_clients.remove(websocket)
+
+    async def _send_state_update(self):
+        """Send current state to all connected clients."""
+        if not self.connected_clients:
+            return
+
+        state_data = {
+            "type": "state_update",
+            "episode_state": self.episode_state.model_dump(),
+        }
+
+        # Send to all connected clients
+        disconnected_clients = []
+        for client in self.connected_clients:
+            try:
+                await client.send_text(json.dumps(state_data))
+            except Exception:
+                disconnected_clients.append(client)
+
+        # Remove disconnected clients
+        for client in disconnected_clients:
+            self.connected_clients.remove(client)
+
+    async def reset_environment(self) -> Dict[str, Any]:
+        """Reset the environment and update state."""
+        # Run sync reset in thread pool to avoid blocking event loop
+        # and to support environments using sync libraries (e.g., Playwright)
+        observation: Observation = await self._run_sync_in_thread_pool(self.env.reset)
+        state: State = self.env.state
+
+        # Serialize observation once using shared utility
+        serialized = serialize_observation(observation)
+
+        # Update episode state
+        self.episode_state.episode_id = state.episode_id
+        self.episode_state.step_count = 0
+        self.episode_state.current_observation = serialized["observation"]
+        self.episode_state.action_logs = []
+        self.episode_state.is_reset = True
+
+        # Send state update
+        await self._send_state_update()
+
+        return serialized
+
+    async def step_environment(self, action_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Execute a step in the environment and update state."""
+        # Deserialize action with preprocessing for web interface special cases
+        action: Action = deserialize_action_with_preprocessing(
+            action_data, self.action_cls
+        )
+
+        # Run sync step in thread pool to avoid blocking event loop
+        # and to support environments using sync libraries (e.g., Playwright)
+        observation: Observation = await self._run_sync_in_thread_pool(
+            self.env.step, action
+        )
+        state: State = self.env.state
+
+        # Serialize observation once using shared utility
+        serialized = serialize_observation(observation)
+
+        # Create action log
+        action_log = ActionLog(
+            timestamp=datetime.now().isoformat(),
+            action=action.model_dump(exclude={"metadata"}),
+            observation=serialized["observation"],
+            reward=observation.reward,
+            done=observation.done,
+            step_count=state.step_count,
+        )
+
+        # Update episode state
+        self.episode_state.episode_id = state.episode_id
+        self.episode_state.step_count = state.step_count
+        self.episode_state.current_observation = serialized["observation"]
+        self.episode_state.action_logs.append(action_log)
+        if len(self.episode_state.action_logs) > self.MAX_ACTION_LOGS:
+            self.episode_state.action_logs = self.episode_state.action_logs[
+                -self.MAX_ACTION_LOGS :
+            ]
+        self.episode_state.is_reset = False
+
+        # Send state update
+        await self._send_state_update()
+
+        return serialized
+
+    def get_state(self) -> Dict[str, Any]:
+        """Get current environment state."""
+        state: State = self.env.state
+        return state.model_dump()
+
+
+def create_web_interface_app(
+    env: Environment,
+    action_cls: Type[Action],
+    observation_cls: Type[Observation],
+    env_name: Optional[str] = None,
+    max_concurrent_envs: Optional[int] = None,
+    concurrency_config: Optional[Any] = None,
+    gradio_builder: Optional[Callable[..., Any]] = None,
+) -> FastAPI:
+    """
+    Create a FastAPI application with web interface for the given environment.
+
+    Args:
+        env: The Environment instance to serve
+        action_cls: The Action subclass this environment expects
+        observation_cls: The Observation subclass this environment returns
+        env_name: Optional environment name for README loading
+        max_concurrent_envs: Maximum concurrent WebSocket sessions
+        concurrency_config: Optional ConcurrencyConfig for advanced concurrency settings
+        gradio_builder: Optional callable (web_manager, action_fields, metadata,
+            is_chat_env, title, quick_start_md) -> gr.Blocks to use instead of the
+            default Gradio UI. Lets envs replace or customize the /web interface.
+
+    Returns:
+        FastAPI application instance with web interface
+    """
+    from .http_server import create_fastapi_app
+
+    # Create the base environment app
+    app = create_fastapi_app(
+        env, action_cls, observation_cls, max_concurrent_envs, concurrency_config
+    )
+
+    # Load environment metadata
+    metadata = load_environment_metadata(env, env_name)
+
+    # Create web interface manager
+    web_manager = WebInterfaceManager(env, action_cls, observation_cls, metadata)
+
+    # Web API routes first (so they take precedence over Gradio mount at /web)
+    @app.get("/web/metadata")
+    async def web_metadata():
+        """Get environment metadata."""
+        return web_manager.metadata.model_dump()
+
+    @app.websocket("/ws/ui")
+    async def websocket_ui_endpoint(websocket: WebSocket):
+        """WebSocket endpoint for web UI real-time updates.
+
+        Note: Uses /ws/ui to avoid conflict with /ws in http_server.py
+        which is used for concurrent environment sessions.
+        """
+        await web_manager.connect_websocket(websocket)
+        try:
+            while True:
+                # Keep connection alive
+                await websocket.receive_text()
+        except WebSocketDisconnect:
+            await web_manager.disconnect_websocket(websocket)
+
+    @app.post("/web/reset")
+    async def web_reset():
+        """Reset endpoint for web interface."""
+        return await web_manager.reset_environment()
+
+    @app.post("/web/step")
+    async def web_step(request: Dict[str, Any]):
+        """Step endpoint for web interface."""
+        # Check if this is a message-based request (chat environment)
+        if "message" in request:
+            message = request["message"]
+            if hasattr(web_manager.env, "message_to_action"):
+                action = web_manager.env.message_to_action(message)
+                if hasattr(action, "tokens"):
+                    action_data = {"tokens": action.tokens.tolist()}
+                else:
+                    action_data = action.model_dump(exclude={"metadata"})
+            else:
+                action_data = {"message": message}
+        else:
+            action_data = request.get("action", {})
+
+        return await web_manager.step_environment(action_data)
+
+    @app.get("/web/state")
+    async def web_state():
+        """State endpoint for web interface."""
+        return web_manager.get_state()
+
+    action_fields = _extract_action_fields(action_cls)
+    is_chat_env = _is_chat_env(action_cls)
+    quick_start_md = get_quick_start_markdown(metadata, action_cls, observation_cls)
+
+    default_blocks = build_gradio_app(
+        web_manager,
+        action_fields,
+        metadata,
+        is_chat_env,
+        title=metadata.name,
+        quick_start_md=quick_start_md,
+    )
+    if gradio_builder is not None:
+        custom_blocks = gradio_builder(
+            web_manager,
+            action_fields,
+            metadata,
+            is_chat_env,
+            metadata.name,
+            quick_start_md,
+        )
+        if not isinstance(custom_blocks, gr.Blocks):
+            raise TypeError(
+                f"gradio_builder must return a gr.Blocks instance, "
+                f"got {type(custom_blocks).__name__}"
+            )
+        gradio_blocks = gr.TabbedInterface(
+            [default_blocks, custom_blocks],
+            tab_names=["Playground", "Visualization"],
+            title=get_gradio_display_title(metadata),
+        )
+    else:
+        gradio_blocks = default_blocks
+    app = gr.mount_gradio_app(
+        app,
+        gradio_blocks,
+        path="/web",
+        theme=OPENENV_GRADIO_THEME,
+        css=OPENENV_GRADIO_CSS,
+    )
+
+    return app
+
+
+def _is_chat_env(action_cls: Type[Action]) -> bool:
+    """Return True if the action class is a chat-style env (tokens field)."""
+    if hasattr(action_cls, "model_fields"):
+        for field_name, field_info in action_cls.model_fields.items():
+            if (
+                field_name == "tokens"
+                and hasattr(field_info.annotation, "__name__")
+                and "Tensor" in str(field_info.annotation)
+            ):
+                return True
+    return False
+
+
+def _extract_action_fields(action_cls: Type[Action]) -> List[Dict[str, Any]]:
+    """Extract enhanced field metadata from Action class for form generation."""
+    # Use Pydantic's JSON schema generation for robust metadata extraction
+    try:
+        schema = action_cls.model_json_schema()
+    except AttributeError:
+        # Fallback for non-Pydantic v2 models or if something goes wrong
+        return []
+
+    properties = schema.get("properties", {})
+    required_fields = schema.get("required", [])
+
+    action_fields = []
+
+    for field_name, field_info in properties.items():
+        if field_name == "metadata":
+            continue
+
+        # JSON schema "type" can be a string or list/undefined
+        # Determine our internal input type
+        input_type = _determine_input_type_from_schema(field_info, field_name)
+
+        is_required = field_name in required_fields
+
+        action_fields.append(
+            {
+                "name": field_name,
+                "type": input_type,
+                "required": is_required,
+                "description": field_info.get("description", ""),
+                "default_value": field_info.get("default"),
+                "choices": field_info.get("enum"),
+                "min_value": field_info.get("minimum"),
+                "max_value": field_info.get("maximum"),
+                "min_length": field_info.get("minLength"),
+                "max_length": field_info.get("maxLength"),
+                "pattern": field_info.get("pattern"),
+                "placeholder": _generate_placeholder(field_name, field_info),
+                "help_text": _generate_help_text(field_name, field_info),
+            }
+        )
+
+    return action_fields
+
+
+def _determine_input_type_from_schema(
+    field_info: Dict[str, Any], field_name: str
+) -> str:
+    """Determine input type from JSON schema for form generation (Gradio UI)."""
+    schema_type = field_info.get("type")
+
+    # Check for specific tensor field convention
+    if "tokens" in field_name.lower():
+        return "tensor"
+
+    if "enum" in field_info:
+        return "select"
+
+    if schema_type == "boolean":
+        return "checkbox"
+
+    if schema_type == "integer" or schema_type == "number":
+        return "number"
+
+    if schema_type == "string":
+        # Check if it should be a textarea
+        if (
+            field_info.get("maxLength", 0) > 100
+            or "message" in field_name.lower()
+            or "code" in field_name.lower()
+        ):
+            return "textarea"
+        return "text"
+
+    # Default fallback
+    return "text"
+
+
+def _generate_placeholder(field_name: str, field_info: Dict[str, Any]) -> str:
+    """Generate placeholder text."""
+    if "message" in field_name.lower():
+        return f"Enter {field_name.replace('_', ' ')}..."
+    elif "code" in field_name.lower():
+        return "Enter Python code here..."
+    elif "tokens" in field_name.lower():
+        return "Enter comma-separated token IDs (e.g., 1,2,3,4,5)"
+    else:
+        return f"Enter {field_name.replace('_', ' ')}..."
+
+
+def _generate_help_text(field_name: str, field_info: Dict[str, Any]) -> str:
+    """Generate help text."""
+    description = field_info.get("description", "")
+    if description:
+        return description
+
+    if "action_id" in field_name.lower():
+        return "The action ID to execute in environment"
+    elif "game_name" in field_name.lower():
+        return "Name of game or environment"
+    elif "tokens" in field_name.lower():
+        return "Token IDs as a comma-separated list of integers"
+    elif "code" in field_name.lower():
+        return "Python code to execute in environment"
+    elif "message" in field_name.lower():
+        return "Text message to send"
+
+    return ""