Upload folder using huggingface_hub

Dockerfile

@@ -1,35 +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.
-
-# Multi-stage build: First stage builds the base image
-FROM python:3.11-slim as base-builder
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install Python dependencies that all environments need
-RUN pip install --no-cache-dir \
-    fastapi>=0.104.0 \
-    "uvicorn[standard]>=0.24.0" \
-    requests>=2.25.0 \
-    wsproto>=1.0.0
-
-# Set working directory
-WORKDIR /app
-
-# Default environment variables
-ENV PYTHONPATH=/app/src
-ENV PYTHONUNBUFFERED=1
+# Dockerfile for SUMO-RL Environment
+# This image provides traffic signal control via SUMO (Simulation of Urban MObility)
 
-# Second stage: Use the built base image and add environment-specific dependencies
-FROM base-builder
+# Configurable base image - defaults to local build, can be overridden for CI/CD
+# Base image provides: fastapi, uvicorn, requests, curl, PYTHONPATH=/app/src
+#
+# Local build: docker build -t envtorch-base:latest -f src/core/containers/images/Dockerfile .
+#              docker build -f envs/sumo_rl_env/server/Dockerfile -t sumo-rl-env:latest .
+#
+# CI/CD build: docker build --build-arg BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest \
+#              -f envs/sumo_rl_env/server/Dockerfile -t sumo-rl-env:latest .
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ghcr.io/meta-pytorch/openenv-base:latest
 
 # Install SUMO system dependencies
+# SUMO is available in Debian repositories
 RUN apt-get update && apt-get install -y --no-install-recommends \
     sumo \
     sumo-tools \
@@ -39,6 +23,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 ENV SUMO_HOME=/usr/share/sumo
 
 # Install SUMO-RL and Python dependencies
+# sumo-rl includes: gymnasium, pettingzoo, numpy, pandas, sumolib, traci
 RUN pip install --no-cache-dir \
     gymnasium>=0.28 \
     pettingzoo>=1.24.3 \
@@ -48,6 +33,16 @@ RUN pip install --no-cache-dir \
     traci>=1.14.0 \
     sumo-rl>=1.4.5
 
+# Copy OpenEnv core (base image already set WORKDIR=/app)
+COPY src/core/ /app/src/core/
+
+# Copy SUMO-RL environment code (includes nets/)
+COPY envs/sumo_rl_env/ /app/envs/sumo_rl_env/
+
+# Copy example network files to expected location
+# Default: single-intersection (simple 4-way intersection)
+COPY envs/sumo_rl_env/nets/single-intersection/ /app/nets/single-intersection/
+
 # SUMO environment variables (can be overridden at runtime)
 ENV SUMO_NET_FILE=/app/nets/single-intersection/single-intersection.net.xml
 ENV SUMO_ROUTE_FILE=/app/nets/single-intersection/single-intersection.rou.xml
@@ -59,10 +54,8 @@ ENV SUMO_MAX_GREEN=50
 ENV SUMO_REWARD_FN=diff-waiting-time
 ENV SUMO_SEED=42
 
-
-# Copy only what's needed for this environment
-COPY src/core/ /app/src/core/
-COPY src/envs/sumo_rl_env/ /app/src/envs/sumo_rl_env/
+# Expose port
+EXPOSE 8000
 
 # Health check
 HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
@@ -70,4 +63,6 @@ HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
 
 # Run the FastAPI server
 CMD ["uvicorn", "envs.sumo_rl_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]
+ENV PYTHONPATH=/app/src/core:/app/src:${PYTHONPATH}
+
 ENV ENABLE_WEB_INTERFACE=true

README.md

@@ -1,56 +1,357 @@
 ---
-title: Sumo_rl_env Environment Server
-emoji: 🐳
-colorFrom: blue
-colorTo: green
+title: sumo_rl_env Environment
 sdk: docker
-pinned: false
 app_port: 8000
 base_path: /web
+tags:
+  - openenv
+  - openenv-main
 ---
 
-# Sumo_rl_env Environment Server
+# sumo_rl_env Environment
 
-FastAPI server for sumo_rl_env environment powered by Meta's OpenEnv.
+Space URL: `https://huggingface.co/spaces/openenv/sumo_rl_env`
 
-## About
+OpenEnv pinned ref: `main`
 
-This Space provides a containerized environment for sumo_rl_env interactions.
-Built with FastAPI and OpenEnv framework.
+# SUMO-RL Environment
 
-## Web Interface
+Integration of traffic signal control with the OpenEnv framework via SUMO (Simulation of Urban MObility) and SUMO-RL.
 
-This deployment includes an interactive web interface for exploring the environment:
-- **HumanAgent Interface**: Interact with the environment using a web form
-- **State Observer**: Real-time view of environment state and action history
-- **Live Updates**: WebSocket-based real-time updates
+## Overview
 
-Access the web interface at: `/web`
+This environment enables reinforcement learning for **traffic signal control** using SUMO, a microscopic traffic simulation package. Train RL agents to optimize traffic light timing and minimize vehicle delays.
 
-## SUMO Environment
+**Key Features**:
+- **Realistic traffic simulation** via SUMO
+- **Single-agent mode** for single intersection control
+- **Configurable rewards** (waiting time, queue, pressure, speed)
+- **Multiple networks** supported (custom .net.xml and .rou.xml files)
+- **Docker-ready** with pre-bundled example network
 
-Provides traffic signal control via SUMO (Simulation of Urban MObility) for reinforcement learning.
+## Quick Start
 
-### Usage
-Send a POST request to `/step` with:
-```json
-{
-  "action": {
-    "phase_id": 1
-  }
-}
+### Using Docker (Recommended)
+
+```python
+from envs.sumo_rl_env import SumoRLEnv, SumoAction
+
+# Automatically starts container
+env = SumoRLEnv.from_docker_image("sumo-rl-env:latest")
+
+# Reset environment
+result = env.reset()
+print(f"Observation shape: {result.observation.observation_shape}")
+print(f"Available actions: {result.observation.action_mask}")
+
+# Take action (select next green phase)
+result = env.step(SumoAction(phase_id=1))
+print(f"Reward: {result.reward}, Done: {result.done}")
+
+# Get state
+state = env.state()
+print(f"Simulation time: {state.sim_time}")
+print(f"Total vehicles: {state.total_vehicles}")
+print(f"Mean waiting time: {state.mean_waiting_time}")
+
+# Cleanup
+env.close()
+```
+
+### Building the Docker Image
+
+```bash
+cd OpenEnv
+
+# Build base image first (if not already built)
+docker build -t envtorch-base:latest -f src/openenv/core/containers/images/Dockerfile .
+
+# Build SUMO-RL environment
+docker build -f envs/sumo_rl_env/server/Dockerfile -t sumo-rl-env:latest .
+```
+
+### Running with Different Configurations
+
+```bash
+# Default: single-intersection
+docker run -p 8000:8000 sumo-rl-env:latest
+
+# Longer simulation
+docker run -p 8000:8000 \
+  -e SUMO_NUM_SECONDS=50000 \
+  sumo-rl-env:latest
+
+# Different reward function
+docker run -p 8000:8000 \
+  -e SUMO_REWARD_FN=queue \
+  sumo-rl-env:latest
+
+# Custom seed for reproducibility
+docker run -p 8000:8000 \
+  -e SUMO_SEED=123 \
+  sumo-rl-env:latest
+```
+
+## Observation
+
+The observation is a vector containing:
+- **Phase one-hot**: Current active green phase (one-hot encoded)
+- **Min green flag**: Binary indicator if minimum green time has passed
+- **Lane densities**: Number of vehicles / lane capacity for each incoming lane
+- **Lane queues**: Number of queued vehicles / lane capacity for each incoming lane
+
+Observation size varies by network topology (depends on number of phases and lanes).
+
+**Default (single-intersection)**:
+- 4 green phases
+- 8 incoming lanes
+- Observation size: ~21 elements
+
+## Action Space
+
+The action space is discrete and represents selecting the next green phase to activate.
+
+- **Action type**: Discrete
+- **Action range**: `[0, num_green_phases - 1]`
+- **Default (single-intersection)**: 4 actions (one per green phase)
+
+When a phase change is requested, SUMO automatically inserts a yellow phase before switching.
+
+## Rewards
+
+Default reward function is **change in cumulative waiting time**:
+```
+reward = -(total_waiting_time_now - total_waiting_time_previous)
+```
+
+Positive rewards indicate waiting time decreased (good).
+
+### Available Reward Functions
+
+Set via `SUMO_REWARD_FN` environment variable:
+
+- **`diff-waiting-time`** (default): Change in cumulative waiting time
+- **`average-speed`**: Average speed of all vehicles
+- **`queue`**: Negative total queue length
+- **`pressure`**: Pressure metric (incoming - outgoing vehicles)
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `SUMO_NET_FILE` | `/app/nets/single-intersection.net.xml` | Network topology file |
+| `SUMO_ROUTE_FILE` | `/app/nets/single-intersection.rou.xml` | Vehicle routes file |
+| `SUMO_NUM_SECONDS` | `20000` | Simulation duration (seconds) |
+| `SUMO_DELTA_TIME` | `5` | Seconds between agent actions |
+| `SUMO_YELLOW_TIME` | `2` | Yellow phase duration (seconds) |
+| `SUMO_MIN_GREEN` | `5` | Minimum green time (seconds) |
+| `SUMO_MAX_GREEN` | `50` | Maximum green time (seconds) |
+| `SUMO_REWARD_FN` | `diff-waiting-time` | Reward function name |
+| `SUMO_SEED` | `42` | Random seed (use for reproducibility) |
+
+### Using Custom Networks
+
+To use your own SUMO network:
+
+```python
+from envs.sumo_rl_env import SumoRLEnv
+
+env = SumoRLEnv.from_docker_image(
+    "sumo-rl-env:latest",
+    volumes={
+        "/path/to/your/nets": {"bind": "/nets", "mode": "ro"}
+    },
+    environment={
+        "SUMO_NET_FILE": "/nets/my-network.net.xml",
+        "SUMO_ROUTE_FILE": "/nets/my-routes.rou.xml",
+    }
+)
+```
+
+Your network directory should contain:
+- `.net.xml` - Network topology (roads, junctions, traffic lights)
+- `.rou.xml` - Vehicle routes (trip definitions, flow rates)
+
+## API Reference
+
+### SumoAction
+
+```python
+@dataclass
+class SumoAction(Action):
+    phase_id: int  # Green phase to activate (0 to num_phases-1)
+    ts_id: str = "0"  # Traffic signal ID (for multi-agent)
+```
+
+### SumoObservation
+
+```python
+@dataclass
+class SumoObservation(Observation):
+    observation: List[float]  # Observation vector
+    observation_shape: List[int]  # Shape for reshaping
+    action_mask: List[int]  # Valid action indices
+    sim_time: float  # Current simulation time
+    done: bool  # Episode finished
+    reward: Optional[float]  # Reward from last action
+    metadata: Dict  # System metrics
+```
+
+### SumoState
+
+```python
+@dataclass
+class SumoState(State):
+    episode_id: str  # Unique episode ID
+    step_count: int  # Steps taken
+    net_file: str  # Network file path
+    route_file: str  # Route file path
+    sim_time: float  # Current simulation time
+    total_vehicles: int  # Total vehicles in simulation
+    total_waiting_time: float  # Cumulative waiting time
+    mean_waiting_time: float  # Mean waiting time
+    mean_speed: float  # Mean vehicle speed
+    # ... configuration parameters
+```
+
+## Example Training Loop
+
+```python
+from envs.sumo_rl_env import SumoRLEnv, SumoAction
+import numpy as np
+
+# Start environment
+env = SumoRLEnv.from_docker_image("sumo-rl-env:latest")
+
+# Training loop
+for episode in range(10):
+    result = env.reset()
+    episode_reward = 0
+    steps = 0
+
+    while not result.done and steps < 1000:
+        # Random policy (replace with your RL agent)
+        action_id = np.random.choice(result.observation.action_mask)
+
+        # Take action
+        result = env.step(SumoAction(phase_id=int(action_id)))
+
+        episode_reward += result.reward or 0
+        steps += 1
+
+        # Print progress every 100 steps
+        if steps % 100 == 0:
+            state = env.state()
+            print(f"Step {steps}: "
+                  f"reward={result.reward:.2f}, "
+                  f"vehicles={state.total_vehicles}, "
+                  f"waiting={state.mean_waiting_time:.2f}")
+
+    print(f"Episode {episode}: total_reward={episode_reward:.2f}, steps={steps}")
+
+env.close()
+```
+
+## Performance Notes
+
+### Simulation Speed
+
+- **Reset time**: 1-5 seconds (starts new SUMO simulation)
+- **Step time**: ~50-200ms per step (depends on network size)
+- **Episode duration**: Minutes (20,000 sim seconds with delta_time=5 → ~4,000 steps)
+
+### Optimization
+
+For faster simulation:
+1. Reduce `SUMO_NUM_SECONDS` for shorter episodes
+2. Increase `SUMO_DELTA_TIME` for fewer decisions
+3. Use simpler networks with fewer vehicles
+
+## Architecture
+
+```
+┌─────────────────────────────────┐
+│ Client: SumoRLEnv               │
+│  .step(phase_id=1)              │
+└──────────────┬──────────────────┘
+               │ HTTP
+┌──────────────▼──────────────────┐
+│ FastAPI Server (Docker)         │
+│   SumoEnvironment               │
+│     ├─ Wraps sumo_rl           │
+│     ├─ Single-agent mode       │
+│     └─ No GUI                  │
+└──────────────┬──────────────────┘
+               │
+┌──────────────▼──────────────────┐
+│ SUMO Simulator                  │
+│  - Reads .net.xml (network)     │
+│  - Reads .rou.xml (routes)      │
+│  - Simulates traffic flow       │
+│  - Provides observations        │
+└─────────────────────────────────┘
+```
+
+## Bundled Network
+
+The default `single-intersection` network is a simple 4-way intersection with:
+- **4 incoming roads** (North, South, East, West)
+- **4 green phases** (NS straight, NS left, EW straight, EW left)
+- **Vehicle flow**: Continuous stream with varying rates
+
+## Limitations
+
+- **No GUI in Docker**: SUMO GUI requires X server (not available in containers)
+- **Single-agent only**: Multi-agent (multiple intersections) coming in future version
+- **Fixed network per container**: Each container uses one network topology
+- **Memory usage**: ~500MB for small networks, 2-4GB for large city networks
+
+## Troubleshooting
+
+### Container won't start
+```bash
+# Check logs
+docker logs <container-id>
+
+# Verify network files exist
+docker run sumo-rl-env:latest ls -la /app/nets/
+```
+
+### "SUMO_HOME not set" error
+This should be automatic in Docker. If running locally:
+```bash
+export SUMO_HOME=/usr/share/sumo
 ```
 
-### Features
-- **Traffic Simulation**: Realistic traffic flow via SUMO
-- **Signal Control**: Optimize traffic light timing
-- **Multiple Networks**: Support for custom traffic networks
-- **Configurable Rewards**: Waiting time, queue length, pressure metrics
+### Slow performance
+- Reduce simulation duration: `SUMO_NUM_SECONDS=5000`
+- Increase action interval: `SUMO_DELTA_TIME=10`
+- Use smaller networks with fewer vehicles
 
-## API Documentation
+## References
 
-Visit `/docs` for interactive API documentation.
+- [SUMO Documentation](https://sumo.dlr.de/docs/)
+- [SUMO-RL GitHub](https://github.com/LucasAlegre/sumo-rl)
+- [SUMO-RL Paper](https://peerj.com/articles/cs-575/)
+- [RESCO Benchmarks](https://github.com/jault/RESCO)
+
+## Citation
+
+If you use SUMO-RL in your research, please cite:
+
+```bibtex
+@misc{sumorl,
+    author = {Lucas N. Alegre},
+    title = {{SUMO-RL}},
+    year = {2019},
+    publisher = {GitHub},
+    journal = {GitHub repository},
+    howpublished = {\url{https://github.com/LucasAlegre/sumo-rl}},
+}
+```
 
-## Health Check
+## License
 
-The environment provides a health check endpoint at `/health`.
+This integration is licensed under the BSD-style license. SUMO-RL and SUMO have their own licenses.

__init__.py

@@ -0,0 +1,31 @@
+# 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.
+
+"""
+SUMO-RL Environment for OpenEnv.
+
+This module provides OpenEnv integration for traffic signal control using
+SUMO (Simulation of Urban MObility) via the SUMO-RL library.
+
+Example:
+    >>> from envs.sumo_rl_env import SumoRLEnv, SumoAction
+    >>>
+    >>> # Connect to a running server or start via Docker
+    >>> env = SumoRLEnv.from_docker_image("sumo-rl-env:latest")
+    >>>
+    >>> # Reset and interact
+    >>> result = env.reset()
+    >>> result = env.step(SumoAction(phase_id=1))
+    >>> print(result.reward, result.done)
+    >>>
+    >>> # Cleanup
+    >>> env.close()
+"""
+
+from .client import SumoRLEnv
+from .models import SumoAction, SumoObservation, SumoState
+
+__all__ = ["SumoRLEnv", "SumoAction", "SumoObservation", "SumoState"]

client.py

@@ -0,0 +1,144 @@
+# 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.
+
+"""
+Client for SUMO-RL environment.
+
+This module provides a client to interact with the SUMO traffic signal
+control environment via WebSocket for persistent sessions.
+"""
+
+from typing import Any, Dict
+
+from openenv.core.client_types import StepResult
+from openenv.core.env_client import EnvClient
+
+from .models import SumoAction, SumoObservation, SumoState
+
+
+class SumoRLEnv(EnvClient[SumoAction, SumoObservation, SumoState]):
+    """
+    Client for SUMO-RL traffic signal control environment.
+
+    This client maintains a persistent WebSocket connection to a SUMO
+    environment server to control traffic signals using reinforcement learning.
+
+    Example:
+        >>> # Start container and connect
+        >>> env = SumoRLEnv.from_docker_image("sumo-rl-env:latest")
+        >>> try:
+        ...     # Reset environment
+        ...     result = env.reset()
+        ...     print(f"Observation shape: {result.observation.observation_shape}")
+        ...     print(f"Action space: {result.observation.action_mask}")
+        ...
+        ...     # Take action
+        ...     result = env.step(SumoAction(phase_id=1))
+        ...     print(f"Reward: {result.reward}, Done: {result.done}")
+        ...
+        ...     # Get state
+        ...     state = env.state()
+        ...     print(f"Sim time: {state.sim_time}, Total vehicles: {state.total_vehicles}")
+        ... finally:
+        ...     env.close()
+
+    Example with custom network:
+        >>> # Use custom SUMO network via volume mount
+        >>> env = SumoRLEnv.from_docker_image(
+        ...     "sumo-rl-env:latest",
+        ...     port=8000,
+        ...     volumes={
+        ...         "/path/to/my/nets": {"bind": "/nets", "mode": "ro"}
+        ...     },
+        ...     environment={
+        ...         "SUMO_NET_FILE": "/nets/my-network.net.xml",
+        ...         "SUMO_ROUTE_FILE": "/nets/my-routes.rou.xml",
+        ...     }
+        ... )
+
+    Example with configuration:
+        >>> # Adjust simulation parameters
+        >>> env = SumoRLEnv.from_docker_image(
+        ...     "sumo-rl-env:latest",
+        ...     environment={
+        ...         "SUMO_NUM_SECONDS": "10000",
+        ...         "SUMO_DELTA_TIME": "10",
+        ...         "SUMO_REWARD_FN": "queue",
+        ...         "SUMO_SEED": "123",
+        ...     }
+        ... )
+    """
+
+    def _step_payload(self, action: SumoAction) -> Dict[str, Any]:
+        """
+        Convert SumoAction to JSON payload for HTTP request.
+
+        Args:
+            action: SumoAction containing phase_id to execute.
+
+        Returns:
+            Dictionary payload for step endpoint.
+        """
+        return {
+            "phase_id": action.phase_id,
+            "ts_id": action.ts_id,
+        }
+
+    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[SumoObservation]:
+        """
+        Parse step result from HTTP response JSON.
+
+        Args:
+            payload: JSON response from step endpoint.
+
+        Returns:
+            StepResult containing SumoObservation.
+        """
+        obs_data = payload.get("observation", {})
+
+        observation = SumoObservation(
+            observation=obs_data.get("observation", []),
+            observation_shape=obs_data.get("observation_shape", []),
+            action_mask=obs_data.get("action_mask", []),
+            sim_time=obs_data.get("sim_time", 0.0),
+            done=obs_data.get("done", False),
+            reward=obs_data.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[str, Any]) -> SumoState:
+        """
+        Parse state from HTTP response JSON.
+
+        Args:
+            payload: JSON response from state endpoint.
+
+        Returns:
+            SumoState object.
+        """
+        return SumoState(
+            episode_id=payload.get("episode_id", ""),
+            step_count=payload.get("step_count", 0),
+            net_file=payload.get("net_file", ""),
+            route_file=payload.get("route_file", ""),
+            num_seconds=payload.get("num_seconds", 20000),
+            delta_time=payload.get("delta_time", 5),
+            yellow_time=payload.get("yellow_time", 2),
+            min_green=payload.get("min_green", 5),
+            max_green=payload.get("max_green", 50),
+            reward_fn=payload.get("reward_fn", "diff-waiting-time"),
+            sim_time=payload.get("sim_time", 0.0),
+            total_vehicles=payload.get("total_vehicles", 0),
+            total_waiting_time=payload.get("total_waiting_time", 0.0),
+            mean_waiting_time=payload.get("mean_waiting_time", 0.0),
+            mean_speed=payload.get("mean_speed", 0.0),
+        )

envs/sumo_rl_env/README.md

@@ -0,0 +1,341 @@
+# SUMO-RL Environment
+
+Integration of traffic signal control with the OpenEnv framework via SUMO (Simulation of Urban MObility) and SUMO-RL.
+
+## Overview
+
+This environment enables reinforcement learning for **traffic signal control** using SUMO, a microscopic traffic simulation package. Train RL agents to optimize traffic light timing and minimize vehicle delays.
+
+**Key Features**:
+- **Realistic traffic simulation** via SUMO
+- **Single-agent mode** for single intersection control
+- **Configurable rewards** (waiting time, queue, pressure, speed)
+- **Multiple networks** supported (custom .net.xml and .rou.xml files)
+- **Docker-ready** with pre-bundled example network
+
+## Quick Start
+
+### Using Docker (Recommended)
+
+```python
+from envs.sumo_rl_env import SumoRLEnv, SumoAction
+
+# Automatically starts container
+env = SumoRLEnv.from_docker_image("sumo-rl-env:latest")
+
+# Reset environment
+result = env.reset()
+print(f"Observation shape: {result.observation.observation_shape}")
+print(f"Available actions: {result.observation.action_mask}")
+
+# Take action (select next green phase)
+result = env.step(SumoAction(phase_id=1))
+print(f"Reward: {result.reward}, Done: {result.done}")
+
+# Get state
+state = env.state()
+print(f"Simulation time: {state.sim_time}")
+print(f"Total vehicles: {state.total_vehicles}")
+print(f"Mean waiting time: {state.mean_waiting_time}")
+
+# Cleanup
+env.close()
+```
+
+### Building the Docker Image
+
+```bash
+cd OpenEnv
+
+# Build base image first (if not already built)
+docker build -t envtorch-base:latest -f src/openenv/core/containers/images/Dockerfile .
+
+# Build SUMO-RL environment
+docker build -f envs/sumo_rl_env/server/Dockerfile -t sumo-rl-env:latest .
+```
+
+### Running with Different Configurations
+
+```bash
+# Default: single-intersection
+docker run -p 8000:8000 sumo-rl-env:latest
+
+# Longer simulation
+docker run -p 8000:8000 \
+  -e SUMO_NUM_SECONDS=50000 \
+  sumo-rl-env:latest
+
+# Different reward function
+docker run -p 8000:8000 \
+  -e SUMO_REWARD_FN=queue \
+  sumo-rl-env:latest
+
+# Custom seed for reproducibility
+docker run -p 8000:8000 \
+  -e SUMO_SEED=123 \
+  sumo-rl-env:latest
+```
+
+## Observation
+
+The observation is a vector containing:
+- **Phase one-hot**: Current active green phase (one-hot encoded)
+- **Min green flag**: Binary indicator if minimum green time has passed
+- **Lane densities**: Number of vehicles / lane capacity for each incoming lane
+- **Lane queues**: Number of queued vehicles / lane capacity for each incoming lane
+
+Observation size varies by network topology (depends on number of phases and lanes).
+
+**Default (single-intersection)**:
+- 4 green phases
+- 8 incoming lanes
+- Observation size: ~21 elements
+
+## Action Space
+
+The action space is discrete and represents selecting the next green phase to activate.
+
+- **Action type**: Discrete
+- **Action range**: `[0, num_green_phases - 1]`
+- **Default (single-intersection)**: 4 actions (one per green phase)
+
+When a phase change is requested, SUMO automatically inserts a yellow phase before switching.
+
+## Rewards
+
+Default reward function is **change in cumulative waiting time**:
+```
+reward = -(total_waiting_time_now - total_waiting_time_previous)
+```
+
+Positive rewards indicate waiting time decreased (good).
+
+### Available Reward Functions
+
+Set via `SUMO_REWARD_FN` environment variable:
+
+- **`diff-waiting-time`** (default): Change in cumulative waiting time
+- **`average-speed`**: Average speed of all vehicles
+- **`queue`**: Negative total queue length
+- **`pressure`**: Pressure metric (incoming - outgoing vehicles)
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `SUMO_NET_FILE` | `/app/nets/single-intersection.net.xml` | Network topology file |
+| `SUMO_ROUTE_FILE` | `/app/nets/single-intersection.rou.xml` | Vehicle routes file |
+| `SUMO_NUM_SECONDS` | `20000` | Simulation duration (seconds) |
+| `SUMO_DELTA_TIME` | `5` | Seconds between agent actions |
+| `SUMO_YELLOW_TIME` | `2` | Yellow phase duration (seconds) |
+| `SUMO_MIN_GREEN` | `5` | Minimum green time (seconds) |
+| `SUMO_MAX_GREEN` | `50` | Maximum green time (seconds) |
+| `SUMO_REWARD_FN` | `diff-waiting-time` | Reward function name |
+| `SUMO_SEED` | `42` | Random seed (use for reproducibility) |
+
+### Using Custom Networks
+
+To use your own SUMO network:
+
+```python
+from envs.sumo_rl_env import SumoRLEnv
+
+env = SumoRLEnv.from_docker_image(
+    "sumo-rl-env:latest",
+    volumes={
+        "/path/to/your/nets": {"bind": "/nets", "mode": "ro"}
+    },
+    environment={
+        "SUMO_NET_FILE": "/nets/my-network.net.xml",
+        "SUMO_ROUTE_FILE": "/nets/my-routes.rou.xml",
+    }
+)
+```
+
+Your network directory should contain:
+- `.net.xml` - Network topology (roads, junctions, traffic lights)
+- `.rou.xml` - Vehicle routes (trip definitions, flow rates)
+
+## API Reference
+
+### SumoAction
+
+```python
+@dataclass
+class SumoAction(Action):
+    phase_id: int  # Green phase to activate (0 to num_phases-1)
+    ts_id: str = "0"  # Traffic signal ID (for multi-agent)
+```
+
+### SumoObservation
+
+```python
+@dataclass
+class SumoObservation(Observation):
+    observation: List[float]  # Observation vector
+    observation_shape: List[int]  # Shape for reshaping
+    action_mask: List[int]  # Valid action indices
+    sim_time: float  # Current simulation time
+    done: bool  # Episode finished
+    reward: Optional[float]  # Reward from last action
+    metadata: Dict  # System metrics
+```
+
+### SumoState
+
+```python
+@dataclass
+class SumoState(State):
+    episode_id: str  # Unique episode ID
+    step_count: int  # Steps taken
+    net_file: str  # Network file path
+    route_file: str  # Route file path
+    sim_time: float  # Current simulation time
+    total_vehicles: int  # Total vehicles in simulation
+    total_waiting_time: float  # Cumulative waiting time
+    mean_waiting_time: float  # Mean waiting time
+    mean_speed: float  # Mean vehicle speed
+    # ... configuration parameters
+```
+
+## Example Training Loop
+
+```python
+from envs.sumo_rl_env import SumoRLEnv, SumoAction
+import numpy as np
+
+# Start environment
+env = SumoRLEnv.from_docker_image("sumo-rl-env:latest")
+
+# Training loop
+for episode in range(10):
+    result = env.reset()
+    episode_reward = 0
+    steps = 0
+
+    while not result.done and steps < 1000:
+        # Random policy (replace with your RL agent)
+        action_id = np.random.choice(result.observation.action_mask)
+
+        # Take action
+        result = env.step(SumoAction(phase_id=int(action_id)))
+
+        episode_reward += result.reward or 0
+        steps += 1
+
+        # Print progress every 100 steps
+        if steps % 100 == 0:
+            state = env.state()
+            print(f"Step {steps}: "
+                  f"reward={result.reward:.2f}, "
+                  f"vehicles={state.total_vehicles}, "
+                  f"waiting={state.mean_waiting_time:.2f}")
+
+    print(f"Episode {episode}: total_reward={episode_reward:.2f}, steps={steps}")
+
+env.close()
+```
+
+## Performance Notes
+
+### Simulation Speed
+
+- **Reset time**: 1-5 seconds (starts new SUMO simulation)
+- **Step time**: ~50-200ms per step (depends on network size)
+- **Episode duration**: Minutes (20,000 sim seconds with delta_time=5 → ~4,000 steps)
+
+### Optimization
+
+For faster simulation:
+1. Reduce `SUMO_NUM_SECONDS` for shorter episodes
+2. Increase `SUMO_DELTA_TIME` for fewer decisions
+3. Use simpler networks with fewer vehicles
+
+## Architecture
+
+```
+┌─────────────────────────────────┐
+│ Client: SumoRLEnv               │
+│  .step(phase_id=1)              │
+└──────────────┬──────────────────┘
+               │ HTTP
+┌──────────────▼──────────────────┐
+│ FastAPI Server (Docker)         │
+│   SumoEnvironment               │
+│     ├─ Wraps sumo_rl           │
+│     ├─ Single-agent mode       │
+│     └─ No GUI                  │
+└──────────────┬──────────────────┘
+               │
+┌──────────────▼──────────────────┐
+│ SUMO Simulator                  │
+│  - Reads .net.xml (network)     │
+│  - Reads .rou.xml (routes)      │
+│  - Simulates traffic flow       │
+│  - Provides observations        │
+└─────────────────────────────────┘
+```
+
+## Bundled Network
+
+The default `single-intersection` network is a simple 4-way intersection with:
+- **4 incoming roads** (North, South, East, West)
+- **4 green phases** (NS straight, NS left, EW straight, EW left)
+- **Vehicle flow**: Continuous stream with varying rates
+
+## Limitations
+
+- **No GUI in Docker**: SUMO GUI requires X server (not available in containers)
+- **Single-agent only**: Multi-agent (multiple intersections) coming in future version
+- **Fixed network per container**: Each container uses one network topology
+- **Memory usage**: ~500MB for small networks, 2-4GB for large city networks
+
+## Troubleshooting
+
+### Container won't start
+```bash
+# Check logs
+docker logs <container-id>
+
+# Verify network files exist
+docker run sumo-rl-env:latest ls -la /app/nets/
+```
+
+### "SUMO_HOME not set" error
+This should be automatic in Docker. If running locally:
+```bash
+export SUMO_HOME=/usr/share/sumo
+```
+
+### Slow performance
+- Reduce simulation duration: `SUMO_NUM_SECONDS=5000`
+- Increase action interval: `SUMO_DELTA_TIME=10`
+- Use smaller networks with fewer vehicles
+
+## References
+
+- [SUMO Documentation](https://sumo.dlr.de/docs/)
+- [SUMO-RL GitHub](https://github.com/LucasAlegre/sumo-rl)
+- [SUMO-RL Paper](https://peerj.com/articles/cs-575/)
+- [RESCO Benchmarks](https://github.com/jault/RESCO)
+
+## Citation
+
+If you use SUMO-RL in your research, please cite:
+
+```bibtex
+@misc{sumorl,
+    author = {Lucas N. Alegre},
+    title = {{SUMO-RL}},
+    year = {2019},
+    publisher = {GitHub},
+    journal = {GitHub repository},
+    howpublished = {\url{https://github.com/LucasAlegre/sumo-rl}},
+}
+```
+
+## License
+
+This integration is licensed under the BSD-style license. SUMO-RL and SUMO have their own licenses.

envs/sumo_rl_env/__init__.py

@@ -0,0 +1,31 @@
+# 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.
+
+"""
+SUMO-RL Environment for OpenEnv.
+
+This module provides OpenEnv integration for traffic signal control using
+SUMO (Simulation of Urban MObility) via the SUMO-RL library.
+
+Example:
+    >>> from envs.sumo_rl_env import SumoRLEnv, SumoAction
+    >>>
+    >>> # Connect to a running server or start via Docker
+    >>> env = SumoRLEnv.from_docker_image("sumo-rl-env:latest")
+    >>>
+    >>> # Reset and interact
+    >>> result = env.reset()
+    >>> result = env.step(SumoAction(phase_id=1))
+    >>> print(result.reward, result.done)
+    >>>
+    >>> # Cleanup
+    >>> env.close()
+"""
+
+from .client import SumoRLEnv
+from .models import SumoAction, SumoObservation, SumoState
+
+__all__ = ["SumoRLEnv", "SumoAction", "SumoObservation", "SumoState"]

envs/sumo_rl_env/client.py

@@ -0,0 +1,144 @@
+# 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.
+
+"""
+Client for SUMO-RL environment.
+
+This module provides a client to interact with the SUMO traffic signal
+control environment via WebSocket for persistent sessions.
+"""
+
+from typing import Any, Dict
+
+from openenv.core.client_types import StepResult
+from openenv.core.env_client import EnvClient
+
+from .models import SumoAction, SumoObservation, SumoState
+
+
+class SumoRLEnv(EnvClient[SumoAction, SumoObservation, SumoState]):
+    """
+    Client for SUMO-RL traffic signal control environment.
+
+    This client maintains a persistent WebSocket connection to a SUMO
+    environment server to control traffic signals using reinforcement learning.
+
+    Example:
+        >>> # Start container and connect
+        >>> env = SumoRLEnv.from_docker_image("sumo-rl-env:latest")
+        >>> try:
+        ...     # Reset environment
+        ...     result = env.reset()
+        ...     print(f"Observation shape: {result.observation.observation_shape}")
+        ...     print(f"Action space: {result.observation.action_mask}")
+        ...
+        ...     # Take action
+        ...     result = env.step(SumoAction(phase_id=1))
+        ...     print(f"Reward: {result.reward}, Done: {result.done}")
+        ...
+        ...     # Get state
+        ...     state = env.state()
+        ...     print(f"Sim time: {state.sim_time}, Total vehicles: {state.total_vehicles}")
+        ... finally:
+        ...     env.close()
+
+    Example with custom network:
+        >>> # Use custom SUMO network via volume mount
+        >>> env = SumoRLEnv.from_docker_image(
+        ...     "sumo-rl-env:latest",
+        ...     port=8000,
+        ...     volumes={
+        ...         "/path/to/my/nets": {"bind": "/nets", "mode": "ro"}
+        ...     },
+        ...     environment={
+        ...         "SUMO_NET_FILE": "/nets/my-network.net.xml",
+        ...         "SUMO_ROUTE_FILE": "/nets/my-routes.rou.xml",
+        ...     }
+        ... )
+
+    Example with configuration:
+        >>> # Adjust simulation parameters
+        >>> env = SumoRLEnv.from_docker_image(
+        ...     "sumo-rl-env:latest",
+        ...     environment={
+        ...         "SUMO_NUM_SECONDS": "10000",
+        ...         "SUMO_DELTA_TIME": "10",
+        ...         "SUMO_REWARD_FN": "queue",
+        ...         "SUMO_SEED": "123",
+        ...     }
+        ... )
+    """
+
+    def _step_payload(self, action: SumoAction) -> Dict[str, Any]:
+        """
+        Convert SumoAction to JSON payload for HTTP request.
+
+        Args:
+            action: SumoAction containing phase_id to execute.
+
+        Returns:
+            Dictionary payload for step endpoint.
+        """
+        return {
+            "phase_id": action.phase_id,
+            "ts_id": action.ts_id,
+        }
+
+    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[SumoObservation]:
+        """
+        Parse step result from HTTP response JSON.
+
+        Args:
+            payload: JSON response from step endpoint.
+
+        Returns:
+            StepResult containing SumoObservation.
+        """
+        obs_data = payload.get("observation", {})
+
+        observation = SumoObservation(
+            observation=obs_data.get("observation", []),
+            observation_shape=obs_data.get("observation_shape", []),
+            action_mask=obs_data.get("action_mask", []),
+            sim_time=obs_data.get("sim_time", 0.0),
+            done=obs_data.get("done", False),
+            reward=obs_data.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[str, Any]) -> SumoState:
+        """
+        Parse state from HTTP response JSON.
+
+        Args:
+            payload: JSON response from state endpoint.
+
+        Returns:
+            SumoState object.
+        """
+        return SumoState(
+            episode_id=payload.get("episode_id", ""),
+            step_count=payload.get("step_count", 0),
+            net_file=payload.get("net_file", ""),
+            route_file=payload.get("route_file", ""),
+            num_seconds=payload.get("num_seconds", 20000),
+            delta_time=payload.get("delta_time", 5),
+            yellow_time=payload.get("yellow_time", 2),
+            min_green=payload.get("min_green", 5),
+            max_green=payload.get("max_green", 50),
+            reward_fn=payload.get("reward_fn", "diff-waiting-time"),
+            sim_time=payload.get("sim_time", 0.0),
+            total_vehicles=payload.get("total_vehicles", 0),
+            total_waiting_time=payload.get("total_waiting_time", 0.0),
+            mean_waiting_time=payload.get("mean_waiting_time", 0.0),
+            mean_speed=payload.get("mean_speed", 0.0),
+        )

envs/sumo_rl_env/models.py

@@ -0,0 +1,107 @@
+# 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 SUMO-RL Environment.
+
+This module defines the Action, Observation, and State types for traffic
+signal control using SUMO (Simulation of Urban MObility).
+"""
+
+from typing import Dict, List, Optional
+
+from openenv.core.env_server import Action, Observation, State
+from pydantic import Field
+
+
+class SumoAction(Action):
+    """
+    Action for SUMO traffic signal control environment.
+
+    Represents selecting which traffic light phase to activate next.
+
+    Attributes:
+        phase_id: Index of the green phase to activate (0 to num_phases-1)
+        ts_id: Traffic signal ID (for multi-agent support, default "0")
+    """
+
+    phase_id: int
+    ts_id: str = "0"
+
+
+class SumoObservation(Observation):
+    """
+    Observation from SUMO traffic signal environment.
+
+    Contains traffic metrics for decision-making.
+
+    Attributes:
+        observation: Flattened observation vector containing:
+                    - One-hot encoded current phase
+                    - Min green flag (binary)
+                    - Lane densities (normalized)
+                    - Lane queues (normalized)
+        observation_shape: Shape of observation for reshaping
+        action_mask: List of valid action indices
+        sim_time: Current simulation time in seconds
+        done: Whether episode is complete
+        reward: Reward from last action (None on reset)
+        metadata: Additional info (system metrics, etc.)
+    """
+
+    observation: List[float] = Field(default_factory=list)
+    observation_shape: List[int] = Field(default_factory=list)
+    action_mask: List[int] = Field(default_factory=list)
+    sim_time: float = 0.0
+    done: bool = False
+    reward: Optional[float] = None
+    metadata: Dict = Field(default_factory=dict)
+
+
+class SumoState(State):
+    """
+    State of SUMO traffic signal environment.
+
+    Tracks both configuration and runtime state.
+
+    Configuration attributes:
+        net_file: Path to SUMO network file (.net.xml)
+        route_file: Path to SUMO route file (.rou.xml)
+        num_seconds: Total simulation duration in seconds
+        delta_time: Seconds between agent actions
+        yellow_time: Duration of yellow phase in seconds
+        min_green: Minimum green time per phase in seconds
+        max_green: Maximum green time per phase in seconds
+        reward_fn: Name of reward function used
+
+    Runtime attributes:
+        episode_id: Unique episode identifier
+        step_count: Number of steps taken in episode
+        sim_time: Current simulation time in seconds
+        total_vehicles: Total number of vehicles in simulation
+        total_waiting_time: Cumulative waiting time across all vehicles
+    """
+
+    # Episode tracking
+    episode_id: str = ""
+    step_count: int = 0
+
+    # SUMO configuration
+    net_file: str = ""
+    route_file: str = ""
+    num_seconds: int = 20000
+    delta_time: int = 5
+    yellow_time: int = 2
+    min_green: int = 5
+    max_green: int = 50
+    reward_fn: str = "diff-waiting-time"
+
+    # Runtime metrics
+    sim_time: float = 0.0
+    total_vehicles: int = 0
+    total_waiting_time: float = 0.0
+    mean_waiting_time: float = 0.0
+    mean_speed: float = 0.0

envs/sumo_rl_env/nets/single-intersection/single-intersection.edg.xml

@@ -0,0 +1,6 @@
+<edges>
+	<edge from="n" id="n_t" to="t" numLanes="2"/>
+	<edge from="w" id="w_t" to="t" numLanes="2"/>
+	<edge from="t" id="t_s" to="s" numLanes="2"/>
+	<edge from="t" id="t_e" to="e" numLanes="2"/>
+</edges>

envs/sumo_rl_env/nets/single-intersection/single-intersection.net.xml

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- generated on seg 17 dez 2018 17:22:14 -02 by Netedit Version 0.32.0
+<?xml version="1.0" encoding="UTF-8"?>
+
+<configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://sumo.dlr.de/xsd/netconvertConfiguration.xsd">
+
+    <input>
+        <sumo-net-file value="nets/single-intersection/single-intersection.net.xml"/>
+    </input>
+
+    <output>
+        <output-file value="/home/lucas/Documents/sumo-rl/nets/single-intersection/single-intersection2.net.xml"/>
+    </output>
+
+    <processing>
+        <no-turnarounds value="true"/>
+        <offset.disable-normalization value="true"/>
+        <lefthand value="false"/>
+        <junctions.corner-detail value="0"/>
+        <rectangular-lane-cut value="false"/>
+        <walkingareas value="false"/>
+    </processing>
+
+</configuration>
+-->
+
+<net version="0.27" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://sumo.dlr.de/xsd/net_file.xsd">
+
+    <location netOffset="150.00,150.00" convBoundary="0.00,0.00,300.00,300.00" origBoundary="-150.00,-150.00,150.00,150.00" projParameter="!"/>
+
+    <edge id=":t_0" function="internal">
+        <lane id=":t_0_0" index="0" speed="13.90" length="9.50" shape="145.05,151.45 145.05,141.95"/>
+        <lane id=":t_0_1" index="1" speed="13.90" length="9.50" shape="148.35,151.45 148.35,141.95"/>
+    </edge>
+    <edge id=":t_2" function="internal">
+        <lane id=":t_2_0" index="0" speed="13.90" length="9.50" shape="141.95,145.05 151.45,145.05"/>
+        <lane id=":t_2_1" index="1" speed="13.90" length="9.50" shape="141.95,148.35 151.45,148.35"/>
+    </edge>
+
+    <edge id="n_t" from="n" to="t" priority="-1">
+        <lane id="n_t_0" index="0" speed="13.90" length="148.55" shape="145.05,300.00 145.05,151.45"/>
+        <lane id="n_t_1" index="1" speed="13.90" length="148.55" shape="148.35,300.00 148.35,151.45"/>
+    </edge>
+    <edge id="t_e" from="t" to="e" priority="-1">
+        <lane id="t_e_0" index="0" speed="13.90" length="148.55" shape="151.45,145.05 300.00,145.05"/>
+        <lane id="t_e_1" index="1" speed="13.90" length="148.55" shape="151.45,148.35 300.00,148.35"/>
+    </edge>
+    <edge id="t_s" from="t" to="s" priority="-1">
+        <lane id="t_s_0" index="0" speed="13.90" length="141.95" shape="145.05,141.95 145.05,0.00"/>
+        <lane id="t_s_1" index="1" speed="13.90" length="141.95" shape="148.35,141.95 148.35,0.00"/>
+    </edge>
+    <edge id="w_t" from="w" to="t" priority="-1">
+        <lane id="w_t_0" index="0" speed="13.90" length="141.95" shape="0.00,145.05 141.95,145.05"/>
+        <lane id="w_t_1" index="1" speed="13.90" length="141.95" shape="0.00,148.35 141.95,148.35"/>
+    </edge>
+
+    <tlLogic id="t" type="static" programID="0" offset="0">
+        <phase duration="42" state="GGrr"/>
+        <phase duration="2" state="yyrr"/>
+        <phase duration="42" state="rrGG"/>
+        <phase duration="2" state="rryy"/>
+    </tlLogic>
+
+    <junction id="e" type="dead_end" x="300.00" y="150.00" incLanes="t_e_0 t_e_1" intLanes="" shape="300.00,143.45 300.00,149.95"/>
+    <junction id="n" type="dead_end" x="150.00" y="300.00" incLanes="" intLanes="" shape="149.95,300.00 143.45,300.00"/>
+    <junction id="s" type="dead_end" x="150.00" y="0.00" incLanes="t_s_0 t_s_1" intLanes="" shape="143.45,0.00 149.95,0.00"/>
+    <junction id="t" type="traffic_light" x="150.00" y="150.00" incLanes="n_t_0 n_t_1 w_t_0 w_t_1" intLanes=":t_0_0 :t_0_1 :t_2_0 :t_2_1" shape="143.45,151.45 149.95,151.45 151.45,149.95 151.45,143.45 149.95,141.95 143.45,141.95 141.95,143.45 141.95,149.95">
+        <request index="0" response="1100" foes="1100" cont="0"/>
+        <request index="1" response="1100" foes="1100" cont="0"/>
+        <request index="2" response="0000" foes="0011" cont="0"/>
+        <request index="3" response="0000" foes="0011" cont="0"/>
+    </junction>
+    <junction id="w" type="dead_end" x="0.00" y="150.00" incLanes="" intLanes="" shape="0.00,149.95 0.00,143.45"/>
+
+    <connection from="n_t" to="t_s" fromLane="0" toLane="0" via=":t_0_0" tl="t" linkIndex="0" dir="s" state="o"/>
+    <connection from="n_t" to="t_s" fromLane="1" toLane="1" via=":t_0_1" tl="t" linkIndex="1" dir="s" state="o"/>
+    <connection from="w_t" to="t_e" fromLane="0" toLane="0" via=":t_2_0" tl="t" linkIndex="2" dir="s" state="o"/>
+    <connection from="w_t" to="t_e" fromLane="1" toLane="1" via=":t_2_1" tl="t" linkIndex="3" dir="s" state="o"/>
+
+    <connection from=":t_0" to="t_s" fromLane="0" toLane="0" dir="s" state="M"/>
+    <connection from=":t_0" to="t_s" fromLane="1" toLane="1" dir="s" state="M"/>
+    <connection from=":t_2" to="t_e" fromLane="0" toLane="0" dir="s" state="M"/>
+    <connection from=":t_2" to="t_e" fromLane="1" toLane="1" dir="s" state="M"/>
+
+</net>

envs/sumo_rl_env/nets/single-intersection/single-intersection.nod.xml

@@ -0,0 +1,7 @@
+<nodes>
+    <node id="n" x="0.0" y="150.0" type="priority"/>
+    <node id="s" x="0.0" y="-150.0" type="priority"/>
+    <node id="e" x="150.0" y="0.0" type="priority"/>
+    <node id="w" x="-150.0" y="0.0" type="priority"/>
+	<node id="t" x="0.0" y="0.0" type="priority"/>
+</nodes>

envs/sumo_rl_env/nets/single-intersection/single-intersection.rou.xml

@@ -0,0 +1,6 @@
+<routes>
+    <route id="route_ns" edges="n_t t_s"/>
+    <route id="route_we" edges="w_t t_e"/>
+    <flow id="flow_ns" route="route_ns" begin="0" end="100000" probability="0.2" departSpeed="max" departPos="base" departLane="best"/>
+    <flow id="flow_we" route="route_we" begin="0" end="100000" probability="0.5" departSpeed="max" departPos="base" departLane="best"/>
+</routes>

envs/sumo_rl_env/nets/single-intersection/single-intersection.sumocfg

@@ -0,0 +1,10 @@
+<configuration>
+    <input>
+        <net-file value="single-intersection.net.xml"/>
+        <route-files value="single-intersection.rou.xml"/>
+    </input>
+    <time>
+        <begin value="0"/>
+        <end value="100000"/>
+    </time>
+</configuration>

envs/sumo_rl_env/server/Dockerfile

@@ -0,0 +1,65 @@
+# Dockerfile for SUMO-RL Environment
+# This image provides traffic signal control via SUMO (Simulation of Urban MObility)
+
+# Configurable base image - defaults to local build, can be overridden for CI/CD
+# Base image provides: fastapi, uvicorn, requests, curl, PYTHONPATH=/app/src
+#
+# Local build: docker build -t envtorch-base:latest -f src/core/containers/images/Dockerfile .
+#              docker build -f envs/sumo_rl_env/server/Dockerfile -t sumo-rl-env:latest .
+#
+# CI/CD build: docker build --build-arg BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest \
+#              -f envs/sumo_rl_env/server/Dockerfile -t sumo-rl-env:latest .
+ARG BASE_IMAGE=envtorch-base:latest
+FROM ${BASE_IMAGE}
+
+# Install SUMO system dependencies
+# SUMO is available in Debian repositories
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    sumo \
+    sumo-tools \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set SUMO_HOME environment variable
+ENV SUMO_HOME=/usr/share/sumo
+
+# Install SUMO-RL and Python dependencies
+# sumo-rl includes: gymnasium, pettingzoo, numpy, pandas, sumolib, traci
+RUN pip install --no-cache-dir \
+    gymnasium>=0.28 \
+    pettingzoo>=1.24.3 \
+    numpy>=1.24.0 \
+    pandas>=2.0.0 \
+    sumolib>=1.14.0 \
+    traci>=1.14.0 \
+    sumo-rl>=1.4.5
+
+# Copy OpenEnv core (base image already set WORKDIR=/app)
+COPY src/core/ /app/src/core/
+
+# Copy SUMO-RL environment code (includes nets/)
+COPY envs/sumo_rl_env/ /app/envs/sumo_rl_env/
+
+# Copy example network files to expected location
+# Default: single-intersection (simple 4-way intersection)
+COPY envs/sumo_rl_env/nets/single-intersection/ /app/nets/single-intersection/
+
+# SUMO environment variables (can be overridden at runtime)
+ENV SUMO_NET_FILE=/app/nets/single-intersection/single-intersection.net.xml
+ENV SUMO_ROUTE_FILE=/app/nets/single-intersection/single-intersection.rou.xml
+ENV SUMO_NUM_SECONDS=20000
+ENV SUMO_DELTA_TIME=5
+ENV SUMO_YELLOW_TIME=2
+ENV SUMO_MIN_GREEN=5
+ENV SUMO_MAX_GREEN=50
+ENV SUMO_REWARD_FN=diff-waiting-time
+ENV SUMO_SEED=42
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+CMD ["uvicorn", "envs.sumo_rl_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]

envs/sumo_rl_env/server/__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.
+
+"""SUMO-RL environment server package."""

envs/sumo_rl_env/server/app.py

@@ -0,0 +1,53 @@
+# 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 SUMO-RL environment server.
+
+This module creates an HTTP server that exposes traffic signal control
+via the OpenEnv API using SUMO (Simulation of Urban MObility).
+"""
+
+import os
+
+from openenv.core.env_server import create_app
+
+from ..models import SumoAction, SumoObservation
+from .sumo_environment import SumoEnvironment
+
+# Get configuration from environment variables
+net_file = os.getenv("SUMO_NET_FILE", "/app/nets/single-intersection.net.xml")
+route_file = os.getenv("SUMO_ROUTE_FILE", "/app/nets/single-intersection.rou.xml")
+num_seconds = int(os.getenv("SUMO_NUM_SECONDS", "20000"))
+delta_time = int(os.getenv("SUMO_DELTA_TIME", "5"))
+yellow_time = int(os.getenv("SUMO_YELLOW_TIME", "2"))
+min_green = int(os.getenv("SUMO_MIN_GREEN", "5"))
+max_green = int(os.getenv("SUMO_MAX_GREEN", "50"))
+reward_fn = os.getenv("SUMO_REWARD_FN", "diff-waiting-time")
+sumo_seed = int(os.getenv("SUMO_SEED", "42"))
+
+
+# Factory function to create SumoEnvironment instances
+def create_sumo_environment():
+    """Factory function that creates SumoEnvironment with config."""
+    return SumoEnvironment(
+        net_file=net_file,
+        route_file=route_file,
+        num_seconds=num_seconds,
+        delta_time=delta_time,
+        yellow_time=yellow_time,
+        min_green=min_green,
+        max_green=max_green,
+        reward_fn=reward_fn,
+        sumo_seed=sumo_seed,
+    )
+
+
+# Create FastAPI app
+# Pass the factory function instead of an instance for WebSocket session support
+app = create_app(
+    create_sumo_environment, SumoAction, SumoObservation, env_name="sumo_rl_env"
+)

envs/sumo_rl_env/server/sumo_environment.py

@@ -0,0 +1,234 @@
+# 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.
+
+"""
+SUMO-RL Environment Server Implementation.
+
+This module wraps the SUMO-RL SumoEnvironment and exposes it
+via the OpenEnv Environment interface for traffic signal control.
+"""
+
+import os
+import uuid
+from typing import Any, Dict
+
+# Set SUMO_HOME before importing sumo_rl
+os.environ.setdefault("SUMO_HOME", "/usr/share/sumo")
+
+from openenv.core.env_server import Action, Environment, Observation
+
+from ..models import SumoAction, SumoObservation, SumoState
+
+# Import SUMO-RL
+try:
+    from sumo_rl import SumoEnvironment as BaseSumoEnv
+except ImportError as e:
+    raise ImportError(
+        "sumo-rl is not installed. Please install it with: pip install sumo-rl"
+    ) from e
+
+
+class SumoEnvironment(Environment):
+    """
+    SUMO-RL Environment wrapper for OpenEnv.
+
+    This environment wraps the SUMO traffic signal control environment
+    for single-agent reinforcement learning.
+
+    Args:
+        net_file: Path to SUMO network file (.net.xml)
+        route_file: Path to SUMO route file (.rou.xml)
+        num_seconds: Simulation duration in seconds (default: 20000)
+        delta_time: Seconds between agent actions (default: 5)
+        yellow_time: Yellow phase duration in seconds (default: 2)
+        min_green: Minimum green time in seconds (default: 5)
+        max_green: Maximum green time in seconds (default: 50)
+        reward_fn: Reward function name (default: "diff-waiting-time")
+        sumo_seed: Random seed for reproducibility (default: 42)
+
+    Example:
+        >>> env = SumoEnvironment(
+        ...     net_file="/app/nets/single-intersection.net.xml",
+        ...     route_file="/app/nets/single-intersection.rou.xml"
+        ... )
+        >>> obs = env.reset()
+        >>> print(obs.observation_shape)
+        >>> obs = env.step(SumoAction(phase_id=1))
+        >>> print(obs.reward, obs.done)
+    """
+
+    def __init__(
+        self,
+        net_file: str,
+        route_file: str,
+        num_seconds: int = 20000,
+        delta_time: int = 5,
+        yellow_time: int = 2,
+        min_green: int = 5,
+        max_green: int = 50,
+        reward_fn: str = "diff-waiting-time",
+        sumo_seed: int = 42,
+    ):
+        """Initialize SUMO traffic signal environment."""
+        super().__init__()
+
+        # Store configuration
+        self.net_file = net_file
+        self.route_file = route_file
+        self.num_seconds = num_seconds
+        self.delta_time = delta_time
+        self.yellow_time = yellow_time
+        self.min_green = min_green
+        self.max_green = max_green
+        self.reward_fn = reward_fn
+        self.sumo_seed = sumo_seed
+
+        # Create SUMO environment (single-agent mode)
+        # Key settings:
+        # - use_gui=False: No GUI in Docker
+        # - single_agent=True: Returns single obs/reward (not dict)
+        # - sumo_warnings=False: Suppress SUMO warnings
+        # - out_csv_name=None: Don't write CSV files
+        self.env = BaseSumoEnv(
+            net_file=net_file,
+            route_file=route_file,
+            use_gui=False,
+            single_agent=True,
+            num_seconds=num_seconds,
+            delta_time=delta_time,
+            yellow_time=yellow_time,
+            min_green=min_green,
+            max_green=max_green,
+            reward_fn=reward_fn,
+            sumo_seed=sumo_seed,
+            sumo_warnings=False,
+            out_csv_name=None,  # Disable CSV output
+            add_system_info=True,
+            add_per_agent_info=False,
+        )
+
+        # Initialize state
+        self._state = SumoState(
+            net_file=net_file,
+            route_file=route_file,
+            num_seconds=num_seconds,
+            delta_time=delta_time,
+            yellow_time=yellow_time,
+            min_green=min_green,
+            max_green=max_green,
+            reward_fn=reward_fn,
+        )
+
+        self._last_info = {}
+
+    def reset(self) -> Observation:
+        """
+        Reset the environment and return initial observation.
+
+        Returns:
+            Initial SumoObservation for the agent.
+        """
+        # Reset SUMO simulation
+        obs, info = self.env.reset()
+
+        # Update state tracking
+        self._state.episode_id = str(uuid.uuid4())
+        self._state.step_count = 0
+        self._state.sim_time = 0.0
+
+        # Store info for metadata
+        self._last_info = info
+
+        return self._make_observation(obs, reward=None, done=False, info=info)
+
+    def step(self, action: Action) -> Observation:
+        """
+        Execute agent's action and return resulting observation.
+
+        Args:
+            action: SumoAction containing the phase_id to execute.
+
+        Returns:
+            SumoObservation after action execution.
+
+        Raises:
+            ValueError: If action is not a SumoAction.
+        """
+        if not isinstance(action, SumoAction):
+            raise ValueError(f"Expected SumoAction, got {type(action)}")
+
+        # Validate phase_id
+        num_phases = self.env.action_space.n
+        if action.phase_id < 0 or action.phase_id >= num_phases:
+            raise ValueError(
+                f"Invalid phase_id: {action.phase_id}. "
+                f"Valid range: [0, {num_phases - 1}]"
+            )
+
+        # Execute action in SUMO
+        # Returns: (obs, reward, terminated, truncated, info)
+        obs, reward, terminated, truncated, info = self.env.step(action.phase_id)
+        done = terminated or truncated
+
+        # Update state
+        self._state.step_count += 1
+        self._state.sim_time = info.get("step", 0.0)
+        self._state.total_vehicles = info.get("system_total_running", 0)
+        self._state.total_waiting_time = info.get("system_total_waiting_time", 0.0)
+        self._state.mean_waiting_time = info.get("system_mean_waiting_time", 0.0)
+        self._state.mean_speed = info.get("system_mean_speed", 0.0)
+
+        # Store info for metadata
+        self._last_info = info
+
+        return self._make_observation(obs, reward=reward, done=done, info=info)
+
+    @property
+    def state(self) -> SumoState:
+        """Get current environment state."""
+        return self._state
+
+    def _make_observation(
+        self, obs: Any, reward: float, done: bool, info: Dict
+    ) -> SumoObservation:
+        """
+        Create SumoObservation from SUMO environment output.
+
+        Args:
+            obs: Observation array from SUMO environment
+            reward: Reward value (None on reset)
+            done: Whether episode is complete
+            info: Info dictionary from SUMO environment
+
+        Returns:
+            SumoObservation for the agent.
+        """
+        # Convert observation to list
+        if hasattr(obs, "tolist"):
+            obs_list = obs.tolist()
+        else:
+            obs_list = list(obs)
+
+        # Get action mask (all actions valid in SUMO-RL)
+        num_phases = self.env.action_space.n
+        action_mask = list(range(num_phases))
+
+        # Extract system metrics for metadata
+        system_info = {k: v for k, v in info.items() if k.startswith("system_")}
+
+        # Create observation
+        return SumoObservation(
+            observation=obs_list,
+            observation_shape=[len(obs_list)],
+            action_mask=action_mask,
+            sim_time=info.get("step", 0.0),
+            done=done,
+            reward=reward,
+            metadata={
+                "num_green_phases": num_phases,
+                "system_info": system_info,
+            },
+        )

envs/sumo_rl_env/test_sumo_rl.sh

@@ -0,0 +1,220 @@
+#!/bin/bash
+# Complete SUMO-RL Integration Test Script
+# Run this to verify everything works!
+
+set -e  # Exit on error
+
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "🚀 SUMO-RL Environment Test Script"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+
+# Navigate to repo root
+cd /Users/sanyambhutani/GH/OpenEnv
+
+echo "📁 Working directory: $(pwd)"
+echo ""
+
+# Step 1: Check if base image exists
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Step 1: Checking for base image..."
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+if docker images | grep -q "envtorch-base.*latest"; then
+    echo "✅ envtorch-base:latest found"
+else
+    echo "⚠️  envtorch-base:latest not found - building it now..."
+    echo ""
+    docker build -t envtorch-base:latest -f src/core/containers/images/Dockerfile .
+    echo ""
+    echo "✅ Base image built successfully"
+fi
+echo ""
+
+# Step 2: Build SUMO-RL environment
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Step 2: Building SUMO-RL environment image..."
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "⏳ This will take 5-10 minutes (installing SUMO)..."
+echo ""
+
+docker build -f envs/sumo_rl_env/server/Dockerfile -t sumo-rl-env:latest .
+
+echo ""
+echo "✅ SUMO-RL environment built successfully"
+echo ""
+
+# Check image size
+IMAGE_SIZE=$(docker images sumo-rl-env:latest --format "{{.Size}}")
+echo "📦 Image size: $IMAGE_SIZE"
+echo ""
+
+# Step 3: Start container
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Step 3: Starting SUMO-RL container..."
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+# Stop any existing container
+docker stop sumo-rl-test 2>/dev/null || true
+docker rm sumo-rl-test 2>/dev/null || true
+
+# Start new container
+docker run -d -p 8000:8000 --name sumo-rl-test sumo-rl-env:latest
+
+echo "⏳ Waiting for container to start..."
+sleep 5
+
+# Check if container is running
+if docker ps | grep -q sumo-rl-test; then
+    echo "✅ Container is running"
+else
+    echo "❌ Container failed to start!"
+    echo "Logs:"
+    docker logs sumo-rl-test
+    exit 1
+fi
+echo ""
+
+# Step 4: Test health endpoint
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Step 4: Testing health endpoint..."
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+HEALTH_RESPONSE=$(curl -s http://localhost:8000/health)
+echo "Response: $HEALTH_RESPONSE"
+
+if echo "$HEALTH_RESPONSE" | grep -q "healthy"; then
+    echo "✅ Health check passed"
+else
+    echo "❌ Health check failed!"
+    exit 1
+fi
+echo ""
+
+# Step 5: Test reset endpoint
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Step 5: Testing reset endpoint..."
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "⏳ This may take 3-5 seconds (SUMO simulation starting)..."
+
+RESET_RESPONSE=$(curl -s -X POST http://localhost:8000/reset)
+
+if echo "$RESET_RESPONSE" | jq -e '.observation.observation' > /dev/null 2>&1; then
+    echo "✅ Reset successful"
+
+    # Extract observation details
+    OBS_SHAPE=$(echo "$RESET_RESPONSE" | jq '.observation.observation_shape')
+    ACTION_MASK=$(echo "$RESET_RESPONSE" | jq '.observation.action_mask')
+
+    echo "  📊 Observation shape: $OBS_SHAPE"
+    echo "  🎮 Available actions: $ACTION_MASK"
+else
+    echo "❌ Reset failed!"
+    echo "Response: $RESET_RESPONSE"
+    exit 1
+fi
+echo ""
+
+# Step 6: Test step endpoint
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Step 6: Testing step endpoint (taking 5 actions)..."
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+for i in {1..5}; do
+    # Take action (cycle through phases 0-1)
+    PHASE_ID=$((i % 2))
+
+    STEP_RESPONSE=$(curl -s -X POST http://localhost:8000/step \
+        -H "Content-Type: application/json" \
+        -d "{\"action\": {\"phase_id\": $PHASE_ID, \"ts_id\": \"0\"}}")
+
+    if echo "$STEP_RESPONSE" | jq -e '.reward' > /dev/null 2>&1; then
+        REWARD=$(echo "$STEP_RESPONSE" | jq '.reward')
+        DONE=$(echo "$STEP_RESPONSE" | jq '.done')
+        echo "  Step $i: phase=$PHASE_ID, reward=$REWARD, done=$DONE"
+    else
+        echo "❌ Step $i failed!"
+        echo "Response: $STEP_RESPONSE"
+        exit 1
+    fi
+done
+
+echo "✅ All steps successful"
+echo ""
+
+# Step 7: Test state endpoint
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Step 7: Testing state endpoint..."
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+STATE_RESPONSE=$(curl -s http://localhost:8000/state)
+
+if echo "$STATE_RESPONSE" | jq -e '.episode_id' > /dev/null 2>&1; then
+    echo "✅ State endpoint working"
+
+    # Extract state details
+    EPISODE_ID=$(echo "$STATE_RESPONSE" | jq -r '.episode_id')
+    STEP_COUNT=$(echo "$STATE_RESPONSE" | jq '.step_count')
+    SIM_TIME=$(echo "$STATE_RESPONSE" | jq '.sim_time')
+    TOTAL_VEHICLES=$(echo "$STATE_RESPONSE" | jq '.total_vehicles')
+
+    echo "  📝 Episode ID: ${EPISODE_ID:0:8}..."
+    echo "  🔢 Step count: $STEP_COUNT"
+    echo "  ⏱️  Simulation time: $SIM_TIME seconds"
+    echo "  🚗 Total vehicles: $TOTAL_VEHICLES"
+else
+    echo "❌ State endpoint failed!"
+    echo "Response: $STATE_RESPONSE"
+    exit 1
+fi
+echo ""
+
+# Step 8: Check logs for errors
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Step 8: Checking container logs for errors..."
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+LOGS=$(docker logs sumo-rl-test 2>&1)
+
+# Check for Python errors (but ignore LoggerMode.Error which is expected)
+if echo "$LOGS" | grep -i "error\|exception\|traceback" | grep -v "LoggerMode.Error"; then
+    echo "⚠️  Found errors in logs:"
+    echo "$LOGS" | grep -i "error\|exception\|traceback" | grep -v "LoggerMode.Error"
+else
+    echo "✅ No errors found in logs"
+fi
+echo ""
+
+# Step 9: Cleanup
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "Step 9: Cleanup..."
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+echo "🧹 Stopping and removing test container..."
+docker stop sumo-rl-test
+docker rm sumo-rl-test
+
+echo "✅ Cleanup complete"
+echo ""
+
+# Final summary
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "🎉 ALL TESTS PASSED!"
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo ""
+echo "Summary:"
+echo "  ✅ Docker image built successfully ($IMAGE_SIZE)"
+echo "  ✅ Container started and ran"
+echo "  ✅ Health endpoint working"
+echo "  ✅ Reset endpoint working"
+echo "  ✅ Step endpoint working (5 actions executed)"
+echo "  ✅ State endpoint working"
+echo "  ✅ No errors in logs"
+echo ""
+echo "🎯 SUMO-RL integration is working perfectly!"
+echo ""
+echo "Next steps:"
+echo "  1. Test Python client: python examples/sumo_rl_simple.py"
+echo "  2. Push to GitHub to trigger CI/CD"
+echo "  3. Use for RL training!"
+echo ""

models.py

@@ -0,0 +1,107 @@
+# 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 SUMO-RL Environment.
+
+This module defines the Action, Observation, and State types for traffic
+signal control using SUMO (Simulation of Urban MObility).
+"""
+
+from typing import Dict, List, Optional
+
+from openenv.core.env_server import Action, Observation, State
+from pydantic import Field
+
+
+class SumoAction(Action):
+    """
+    Action for SUMO traffic signal control environment.
+
+    Represents selecting which traffic light phase to activate next.
+
+    Attributes:
+        phase_id: Index of the green phase to activate (0 to num_phases-1)
+        ts_id: Traffic signal ID (for multi-agent support, default "0")
+    """
+
+    phase_id: int
+    ts_id: str = "0"
+
+
+class SumoObservation(Observation):
+    """
+    Observation from SUMO traffic signal environment.
+
+    Contains traffic metrics for decision-making.
+
+    Attributes:
+        observation: Flattened observation vector containing:
+                    - One-hot encoded current phase
+                    - Min green flag (binary)
+                    - Lane densities (normalized)
+                    - Lane queues (normalized)
+        observation_shape: Shape of observation for reshaping
+        action_mask: List of valid action indices
+        sim_time: Current simulation time in seconds
+        done: Whether episode is complete
+        reward: Reward from last action (None on reset)
+        metadata: Additional info (system metrics, etc.)
+    """
+
+    observation: List[float] = Field(default_factory=list)
+    observation_shape: List[int] = Field(default_factory=list)
+    action_mask: List[int] = Field(default_factory=list)
+    sim_time: float = 0.0
+    done: bool = False
+    reward: Optional[float] = None
+    metadata: Dict = Field(default_factory=dict)
+
+
+class SumoState(State):
+    """
+    State of SUMO traffic signal environment.
+
+    Tracks both configuration and runtime state.
+
+    Configuration attributes:
+        net_file: Path to SUMO network file (.net.xml)
+        route_file: Path to SUMO route file (.rou.xml)
+        num_seconds: Total simulation duration in seconds
+        delta_time: Seconds between agent actions
+        yellow_time: Duration of yellow phase in seconds
+        min_green: Minimum green time per phase in seconds
+        max_green: Maximum green time per phase in seconds
+        reward_fn: Name of reward function used
+
+    Runtime attributes:
+        episode_id: Unique episode identifier
+        step_count: Number of steps taken in episode
+        sim_time: Current simulation time in seconds
+        total_vehicles: Total number of vehicles in simulation
+        total_waiting_time: Cumulative waiting time across all vehicles
+    """
+
+    # Episode tracking
+    episode_id: str = ""
+    step_count: int = 0
+
+    # SUMO configuration
+    net_file: str = ""
+    route_file: str = ""
+    num_seconds: int = 20000
+    delta_time: int = 5
+    yellow_time: int = 2
+    min_green: int = 5
+    max_green: int = 50
+    reward_fn: str = "diff-waiting-time"
+
+    # Runtime metrics
+    sim_time: float = 0.0
+    total_vehicles: int = 0
+    total_waiting_time: float = 0.0
+    mean_waiting_time: float = 0.0
+    mean_speed: float = 0.0

nets/single-intersection/single-intersection.edg.xml

@@ -0,0 +1,6 @@
+<edges>
+	<edge from="n" id="n_t" to="t" numLanes="2"/>
+	<edge from="w" id="w_t" to="t" numLanes="2"/>
+	<edge from="t" id="t_s" to="s" numLanes="2"/>
+	<edge from="t" id="t_e" to="e" numLanes="2"/>
+</edges>

nets/single-intersection/single-intersection.net.xml

@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!-- generated on seg 17 dez 2018 17:22:14 -02 by Netedit Version 0.32.0
+<?xml version="1.0" encoding="UTF-8"?>
+
+<configuration xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://sumo.dlr.de/xsd/netconvertConfiguration.xsd">
+
+    <input>
+        <sumo-net-file value="nets/single-intersection/single-intersection.net.xml"/>
+    </input>
+
+    <output>
+        <output-file value="/home/lucas/Documents/sumo-rl/nets/single-intersection/single-intersection2.net.xml"/>
+    </output>
+
+    <processing>
+        <no-turnarounds value="true"/>
+        <offset.disable-normalization value="true"/>
+        <lefthand value="false"/>
+        <junctions.corner-detail value="0"/>
+        <rectangular-lane-cut value="false"/>
+        <walkingareas value="false"/>
+    </processing>
+
+</configuration>
+-->
+
+<net version="0.27" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://sumo.dlr.de/xsd/net_file.xsd">
+
+    <location netOffset="150.00,150.00" convBoundary="0.00,0.00,300.00,300.00" origBoundary="-150.00,-150.00,150.00,150.00" projParameter="!"/>
+
+    <edge id=":t_0" function="internal">
+        <lane id=":t_0_0" index="0" speed="13.90" length="9.50" shape="145.05,151.45 145.05,141.95"/>
+        <lane id=":t_0_1" index="1" speed="13.90" length="9.50" shape="148.35,151.45 148.35,141.95"/>
+    </edge>
+    <edge id=":t_2" function="internal">
+        <lane id=":t_2_0" index="0" speed="13.90" length="9.50" shape="141.95,145.05 151.45,145.05"/>
+        <lane id=":t_2_1" index="1" speed="13.90" length="9.50" shape="141.95,148.35 151.45,148.35"/>
+    </edge>
+
+    <edge id="n_t" from="n" to="t" priority="-1">
+        <lane id="n_t_0" index="0" speed="13.90" length="148.55" shape="145.05,300.00 145.05,151.45"/>
+        <lane id="n_t_1" index="1" speed="13.90" length="148.55" shape="148.35,300.00 148.35,151.45"/>
+    </edge>
+    <edge id="t_e" from="t" to="e" priority="-1">
+        <lane id="t_e_0" index="0" speed="13.90" length="148.55" shape="151.45,145.05 300.00,145.05"/>
+        <lane id="t_e_1" index="1" speed="13.90" length="148.55" shape="151.45,148.35 300.00,148.35"/>
+    </edge>
+    <edge id="t_s" from="t" to="s" priority="-1">
+        <lane id="t_s_0" index="0" speed="13.90" length="141.95" shape="145.05,141.95 145.05,0.00"/>
+        <lane id="t_s_1" index="1" speed="13.90" length="141.95" shape="148.35,141.95 148.35,0.00"/>
+    </edge>
+    <edge id="w_t" from="w" to="t" priority="-1">
+        <lane id="w_t_0" index="0" speed="13.90" length="141.95" shape="0.00,145.05 141.95,145.05"/>
+        <lane id="w_t_1" index="1" speed="13.90" length="141.95" shape="0.00,148.35 141.95,148.35"/>
+    </edge>
+
+    <tlLogic id="t" type="static" programID="0" offset="0">
+        <phase duration="42" state="GGrr"/>
+        <phase duration="2" state="yyrr"/>
+        <phase duration="42" state="rrGG"/>
+        <phase duration="2" state="rryy"/>
+    </tlLogic>
+
+    <junction id="e" type="dead_end" x="300.00" y="150.00" incLanes="t_e_0 t_e_1" intLanes="" shape="300.00,143.45 300.00,149.95"/>
+    <junction id="n" type="dead_end" x="150.00" y="300.00" incLanes="" intLanes="" shape="149.95,300.00 143.45,300.00"/>
+    <junction id="s" type="dead_end" x="150.00" y="0.00" incLanes="t_s_0 t_s_1" intLanes="" shape="143.45,0.00 149.95,0.00"/>
+    <junction id="t" type="traffic_light" x="150.00" y="150.00" incLanes="n_t_0 n_t_1 w_t_0 w_t_1" intLanes=":t_0_0 :t_0_1 :t_2_0 :t_2_1" shape="143.45,151.45 149.95,151.45 151.45,149.95 151.45,143.45 149.95,141.95 143.45,141.95 141.95,143.45 141.95,149.95">
+        <request index="0" response="1100" foes="1100" cont="0"/>
+        <request index="1" response="1100" foes="1100" cont="0"/>
+        <request index="2" response="0000" foes="0011" cont="0"/>
+        <request index="3" response="0000" foes="0011" cont="0"/>
+    </junction>
+    <junction id="w" type="dead_end" x="0.00" y="150.00" incLanes="" intLanes="" shape="0.00,149.95 0.00,143.45"/>
+
+    <connection from="n_t" to="t_s" fromLane="0" toLane="0" via=":t_0_0" tl="t" linkIndex="0" dir="s" state="o"/>
+    <connection from="n_t" to="t_s" fromLane="1" toLane="1" via=":t_0_1" tl="t" linkIndex="1" dir="s" state="o"/>
+    <connection from="w_t" to="t_e" fromLane="0" toLane="0" via=":t_2_0" tl="t" linkIndex="2" dir="s" state="o"/>
+    <connection from="w_t" to="t_e" fromLane="1" toLane="1" via=":t_2_1" tl="t" linkIndex="3" dir="s" state="o"/>
+
+    <connection from=":t_0" to="t_s" fromLane="0" toLane="0" dir="s" state="M"/>
+    <connection from=":t_0" to="t_s" fromLane="1" toLane="1" dir="s" state="M"/>
+    <connection from=":t_2" to="t_e" fromLane="0" toLane="0" dir="s" state="M"/>
+    <connection from=":t_2" to="t_e" fromLane="1" toLane="1" dir="s" state="M"/>
+
+</net>

nets/single-intersection/single-intersection.nod.xml

@@ -0,0 +1,7 @@
+<nodes>
+    <node id="n" x="0.0" y="150.0" type="priority"/>
+    <node id="s" x="0.0" y="-150.0" type="priority"/>
+    <node id="e" x="150.0" y="0.0" type="priority"/>
+    <node id="w" x="-150.0" y="0.0" type="priority"/>
+	<node id="t" x="0.0" y="0.0" type="priority"/>
+</nodes>

nets/single-intersection/single-intersection.rou.xml

@@ -0,0 +1,6 @@
+<routes>
+    <route id="route_ns" edges="n_t t_s"/>
+    <route id="route_we" edges="w_t t_e"/>
+    <flow id="flow_ns" route="route_ns" begin="0" end="100000" probability="0.2" departSpeed="max" departPos="base" departLane="best"/>
+    <flow id="flow_we" route="route_we" begin="0" end="100000" probability="0.5" departSpeed="max" departPos="base" departLane="best"/>
+</routes>

nets/single-intersection/single-intersection.sumocfg

@@ -0,0 +1,10 @@
+<configuration>
+    <input>
+        <net-file value="single-intersection.net.xml"/>
+        <route-files value="single-intersection.rou.xml"/>
+    </input>
+    <time>
+        <begin value="0"/>
+        <end value="100000"/>
+    </time>
+</configuration>

pyproject.toml

@@ -0,0 +1,147 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-core"
+version = "0.2.2.dev0"
+description = "A unified framework for reinforcement learning environments"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    # Core shared dependencies - minimal set required for all environments
+    # Heavy dependencies (torch, numpy, smolagents, etc.) should be in
+    # individual environment pyproject.toml files
+    "fastapi>=0.104.0",
+    "pydantic>=2.0.0",
+    "uvicorn>=0.24.0",
+    "requests>=2.25.0",
+    # CLI dependencies
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+    "pyyaml>=6.0",
+    "huggingface_hub>=0.20.0",
+    "openai>=2.7.2",
+    "tomli>=2.3.0",
+    "tomli-w>=1.2.0",
+    "websockets>=15.0.1",
+    # MCP support
+    "fastmcp>=3.0.0",
+    # Web UI dependencies
+    "gradio>=4.0.0",
+]
+
+[project.optional-dependencies]
+core = [
+    "fastapi>=0.104.0",
+    "pydantic>=2.0.0",
+    "uvicorn>=0.24.0",
+    "requests>=2.25.0",
+    "websockets>=15.0.1",
+]
+cli = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+    "pyyaml>=6.0",
+    "huggingface_hub>=0.20.0",
+    "openai>=2.7.2",
+    "tomli>=2.3.0",
+    "tomli-w>=1.2.0",
+]
+docs = [
+    "sphinx==7.2.6",
+    "pytorch-sphinx-theme2",
+    "sphinxcontrib.katex==0.9.10",
+    "docutils>=0.18.1,<0.21",
+    "sphinx-design==0.6.1",
+    "sphinxcontrib-mermaid==1.0.0",
+    "myst-parser",
+    "sphinxext-opengraph",
+    "sphinx-sitemap==2.7.1",
+    "sphinx-gallery>=0.14.0",
+    "matplotlib",
+    "nest-asyncio",
+    "smolagents",
+]
+all = [
+    "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git@main",
+    "openenv-core[cli]",
+]
+daytona = [
+    "daytona>=0.136.0",
+    "pyyaml>=6.0",
+]
+inspect = [
+    "inspect-ai>=0.3.0",
+]
+
+[project.scripts]
+openenv = "openenv.cli.__main__:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+include-package-data = true
+
+[tool.setuptools.package-data]
+"openenv.cli" = ["templates/**/*"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.coverage.run]
+omit = [
+    "openenv/cli/templates/**",
+    "**/templates/**",
+    "openenv/cli/__main__.py",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+markers = [
+    "docker: Tests that require Docker to be running",
+    "network: Tests that require network access (HuggingFace, etc.)",
+    "integration: Integration tests with external resources",
+]
+
+[dependency-groups]
+dev = [
+    "ruff>=0.14.0",
+    "usort>=1.1.0",
+    "pytest>=7.0",
+    "pytest-asyncio>=0.21",
+]
+
+[tool.usort]
+# Disable first_party auto-detection so all non-stdlib imports land in
+# the same "third_party" bucket (the default_category). This matches
+# pyfmt's usort behavior inside arc f, which groups openenv.* and env
+# package imports together without blank-line separators.
+first_party_detection = false
+
+[tool.ruff]
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "W"]
+ignore = [
+    "E402",  # Module level import not at top of file (needed for pytest.importorskip patterns)
+    "E501",  # Line too long (not enforced previously, would require large refactor)
+]
+
+[tool.ruff.lint.per-file-ignores]
+# Context manager variables that are intentionally unused
+"tests/envs/test_websockets.py" = ["F841"]
+"tests/test_cli/test_push.py" = ["F841"]
+# Compatibility shim module
+"src/openenv_core/__init__.py" = ["F401"]

server/Dockerfile

@@ -0,0 +1,65 @@
+# Dockerfile for SUMO-RL Environment
+# This image provides traffic signal control via SUMO (Simulation of Urban MObility)
+
+# Configurable base image - defaults to local build, can be overridden for CI/CD
+# Base image provides: fastapi, uvicorn, requests, curl, PYTHONPATH=/app/src
+#
+# Local build: docker build -t envtorch-base:latest -f src/core/containers/images/Dockerfile .
+#              docker build -f envs/sumo_rl_env/server/Dockerfile -t sumo-rl-env:latest .
+#
+# CI/CD build: docker build --build-arg BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest \
+#              -f envs/sumo_rl_env/server/Dockerfile -t sumo-rl-env:latest .
+ARG BASE_IMAGE=envtorch-base:latest
+FROM ${BASE_IMAGE}
+
+# Install SUMO system dependencies
+# SUMO is available in Debian repositories
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    sumo \
+    sumo-tools \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set SUMO_HOME environment variable
+ENV SUMO_HOME=/usr/share/sumo
+
+# Install SUMO-RL and Python dependencies
+# sumo-rl includes: gymnasium, pettingzoo, numpy, pandas, sumolib, traci
+RUN pip install --no-cache-dir \
+    gymnasium>=0.28 \
+    pettingzoo>=1.24.3 \
+    numpy>=1.24.0 \
+    pandas>=2.0.0 \
+    sumolib>=1.14.0 \
+    traci>=1.14.0 \
+    sumo-rl>=1.4.5
+
+# Copy OpenEnv core (base image already set WORKDIR=/app)
+COPY src/core/ /app/src/core/
+
+# Copy SUMO-RL environment code (includes nets/)
+COPY envs/sumo_rl_env/ /app/envs/sumo_rl_env/
+
+# Copy example network files to expected location
+# Default: single-intersection (simple 4-way intersection)
+COPY envs/sumo_rl_env/nets/single-intersection/ /app/nets/single-intersection/
+
+# SUMO environment variables (can be overridden at runtime)
+ENV SUMO_NET_FILE=/app/nets/single-intersection/single-intersection.net.xml
+ENV SUMO_ROUTE_FILE=/app/nets/single-intersection/single-intersection.rou.xml
+ENV SUMO_NUM_SECONDS=20000
+ENV SUMO_DELTA_TIME=5
+ENV SUMO_YELLOW_TIME=2
+ENV SUMO_MIN_GREEN=5
+ENV SUMO_MAX_GREEN=50
+ENV SUMO_REWARD_FN=diff-waiting-time
+ENV SUMO_SEED=42
+
+# Expose port
+EXPOSE 8000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+CMD ["uvicorn", "envs.sumo_rl_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]

server/__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.
+
+"""SUMO-RL environment server package."""

server/app.py

@@ -0,0 +1,53 @@
+# 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 SUMO-RL environment server.
+
+This module creates an HTTP server that exposes traffic signal control
+via the OpenEnv API using SUMO (Simulation of Urban MObility).
+"""
+
+import os
+
+from openenv.core.env_server import create_app
+
+from ..models import SumoAction, SumoObservation
+from .sumo_environment import SumoEnvironment
+
+# Get configuration from environment variables
+net_file = os.getenv("SUMO_NET_FILE", "/app/nets/single-intersection.net.xml")
+route_file = os.getenv("SUMO_ROUTE_FILE", "/app/nets/single-intersection.rou.xml")
+num_seconds = int(os.getenv("SUMO_NUM_SECONDS", "20000"))
+delta_time = int(os.getenv("SUMO_DELTA_TIME", "5"))
+yellow_time = int(os.getenv("SUMO_YELLOW_TIME", "2"))
+min_green = int(os.getenv("SUMO_MIN_GREEN", "5"))
+max_green = int(os.getenv("SUMO_MAX_GREEN", "50"))
+reward_fn = os.getenv("SUMO_REWARD_FN", "diff-waiting-time")
+sumo_seed = int(os.getenv("SUMO_SEED", "42"))
+
+
+# Factory function to create SumoEnvironment instances
+def create_sumo_environment():
+    """Factory function that creates SumoEnvironment with config."""
+    return SumoEnvironment(
+        net_file=net_file,
+        route_file=route_file,
+        num_seconds=num_seconds,
+        delta_time=delta_time,
+        yellow_time=yellow_time,
+        min_green=min_green,
+        max_green=max_green,
+        reward_fn=reward_fn,
+        sumo_seed=sumo_seed,
+    )
+
+
+# Create FastAPI app
+# Pass the factory function instead of an instance for WebSocket session support
+app = create_app(
+    create_sumo_environment, SumoAction, SumoObservation, env_name="sumo_rl_env"
+)

server/sumo_environment.py

@@ -0,0 +1,234 @@
+# 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.
+
+"""
+SUMO-RL Environment Server Implementation.
+
+This module wraps the SUMO-RL SumoEnvironment and exposes it
+via the OpenEnv Environment interface for traffic signal control.
+"""
+
+import os
+import uuid
+from typing import Any, Dict
+
+# Set SUMO_HOME before importing sumo_rl
+os.environ.setdefault("SUMO_HOME", "/usr/share/sumo")
+
+from openenv.core.env_server import Action, Environment, Observation
+
+from ..models import SumoAction, SumoObservation, SumoState
+
+# Import SUMO-RL
+try:
+    from sumo_rl import SumoEnvironment as BaseSumoEnv
+except ImportError as e:
+    raise ImportError(
+        "sumo-rl is not installed. Please install it with: pip install sumo-rl"
+    ) from e
+
+
+class SumoEnvironment(Environment):
+    """
+    SUMO-RL Environment wrapper for OpenEnv.
+
+    This environment wraps the SUMO traffic signal control environment
+    for single-agent reinforcement learning.
+
+    Args:
+        net_file: Path to SUMO network file (.net.xml)
+        route_file: Path to SUMO route file (.rou.xml)
+        num_seconds: Simulation duration in seconds (default: 20000)
+        delta_time: Seconds between agent actions (default: 5)
+        yellow_time: Yellow phase duration in seconds (default: 2)
+        min_green: Minimum green time in seconds (default: 5)
+        max_green: Maximum green time in seconds (default: 50)
+        reward_fn: Reward function name (default: "diff-waiting-time")
+        sumo_seed: Random seed for reproducibility (default: 42)
+
+    Example:
+        >>> env = SumoEnvironment(
+        ...     net_file="/app/nets/single-intersection.net.xml",
+        ...     route_file="/app/nets/single-intersection.rou.xml"
+        ... )
+        >>> obs = env.reset()
+        >>> print(obs.observation_shape)
+        >>> obs = env.step(SumoAction(phase_id=1))
+        >>> print(obs.reward, obs.done)
+    """
+
+    def __init__(
+        self,
+        net_file: str,
+        route_file: str,
+        num_seconds: int = 20000,
+        delta_time: int = 5,
+        yellow_time: int = 2,
+        min_green: int = 5,
+        max_green: int = 50,
+        reward_fn: str = "diff-waiting-time",
+        sumo_seed: int = 42,
+    ):
+        """Initialize SUMO traffic signal environment."""
+        super().__init__()
+
+        # Store configuration
+        self.net_file = net_file
+        self.route_file = route_file
+        self.num_seconds = num_seconds
+        self.delta_time = delta_time
+        self.yellow_time = yellow_time
+        self.min_green = min_green
+        self.max_green = max_green
+        self.reward_fn = reward_fn
+        self.sumo_seed = sumo_seed
+
+        # Create SUMO environment (single-agent mode)
+        # Key settings:
+        # - use_gui=False: No GUI in Docker
+        # - single_agent=True: Returns single obs/reward (not dict)
+        # - sumo_warnings=False: Suppress SUMO warnings
+        # - out_csv_name=None: Don't write CSV files
+        self.env = BaseSumoEnv(
+            net_file=net_file,
+            route_file=route_file,
+            use_gui=False,
+            single_agent=True,
+            num_seconds=num_seconds,
+            delta_time=delta_time,
+            yellow_time=yellow_time,
+            min_green=min_green,
+            max_green=max_green,
+            reward_fn=reward_fn,
+            sumo_seed=sumo_seed,
+            sumo_warnings=False,
+            out_csv_name=None,  # Disable CSV output
+            add_system_info=True,
+            add_per_agent_info=False,
+        )
+
+        # Initialize state
+        self._state = SumoState(
+            net_file=net_file,
+            route_file=route_file,
+            num_seconds=num_seconds,
+            delta_time=delta_time,
+            yellow_time=yellow_time,
+            min_green=min_green,
+            max_green=max_green,
+            reward_fn=reward_fn,
+        )
+
+        self._last_info = {}
+
+    def reset(self) -> Observation:
+        """
+        Reset the environment and return initial observation.
+
+        Returns:
+            Initial SumoObservation for the agent.
+        """
+        # Reset SUMO simulation
+        obs, info = self.env.reset()
+
+        # Update state tracking
+        self._state.episode_id = str(uuid.uuid4())
+        self._state.step_count = 0
+        self._state.sim_time = 0.0
+
+        # Store info for metadata
+        self._last_info = info
+
+        return self._make_observation(obs, reward=None, done=False, info=info)
+
+    def step(self, action: Action) -> Observation:
+        """
+        Execute agent's action and return resulting observation.
+
+        Args:
+            action: SumoAction containing the phase_id to execute.
+
+        Returns:
+            SumoObservation after action execution.
+
+        Raises:
+            ValueError: If action is not a SumoAction.
+        """
+        if not isinstance(action, SumoAction):
+            raise ValueError(f"Expected SumoAction, got {type(action)}")
+
+        # Validate phase_id
+        num_phases = self.env.action_space.n
+        if action.phase_id < 0 or action.phase_id >= num_phases:
+            raise ValueError(
+                f"Invalid phase_id: {action.phase_id}. "
+                f"Valid range: [0, {num_phases - 1}]"
+            )
+
+        # Execute action in SUMO
+        # Returns: (obs, reward, terminated, truncated, info)
+        obs, reward, terminated, truncated, info = self.env.step(action.phase_id)
+        done = terminated or truncated
+
+        # Update state
+        self._state.step_count += 1
+        self._state.sim_time = info.get("step", 0.0)
+        self._state.total_vehicles = info.get("system_total_running", 0)
+        self._state.total_waiting_time = info.get("system_total_waiting_time", 0.0)
+        self._state.mean_waiting_time = info.get("system_mean_waiting_time", 0.0)
+        self._state.mean_speed = info.get("system_mean_speed", 0.0)
+
+        # Store info for metadata
+        self._last_info = info
+
+        return self._make_observation(obs, reward=reward, done=done, info=info)
+
+    @property
+    def state(self) -> SumoState:
+        """Get current environment state."""
+        return self._state
+
+    def _make_observation(
+        self, obs: Any, reward: float, done: bool, info: Dict
+    ) -> SumoObservation:
+        """
+        Create SumoObservation from SUMO environment output.
+
+        Args:
+            obs: Observation array from SUMO environment
+            reward: Reward value (None on reset)
+            done: Whether episode is complete
+            info: Info dictionary from SUMO environment
+
+        Returns:
+            SumoObservation for the agent.
+        """
+        # Convert observation to list
+        if hasattr(obs, "tolist"):
+            obs_list = obs.tolist()
+        else:
+            obs_list = list(obs)
+
+        # Get action mask (all actions valid in SUMO-RL)
+        num_phases = self.env.action_space.n
+        action_mask = list(range(num_phases))
+
+        # Extract system metrics for metadata
+        system_info = {k: v for k, v in info.items() if k.startswith("system_")}
+
+        # Create observation
+        return SumoObservation(
+            observation=obs_list,
+            observation_shape=[len(obs_list)],
+            action_mask=action_mask,
+            sim_time=info.get("step", 0.0),
+            done=done,
+            reward=reward,
+            metadata={
+                "num_green_phases": num_phases,
+                "system_info": system_info,
+            },
+        )

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

@@ -6,14 +6,76 @@
 
 """Core components for agentic environments."""
 
-# Re-export main components from submodules for convenience
-from .env_server import *
-from .http_env_client import HTTPEnvClient
-from .types import StepResult
+from __future__ import annotations
 
-# Note: MCP module doesn't export anything yet
+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__ = [
-    "HTTPEnvClient",
-    "StepResult",
-]
+    "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

@@ -4,4 +4,4 @@
 # 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."""
+"""Container management for environment servers."""

src/core/containers/images/Dockerfile

@@ -8,30 +8,47 @@
 # 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.
+# It includes the minimal dependencies needed to run HTTP environment servers
+# and uv for fast dependency management.
 #
-# Build: docker build -t openenv-base:latest -f src/core/containers/images/Dockerfile .
-# Tag:   docker tag openenv-base:latest openenv-base:0.1.0
+# 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"
-LABEL version="0.1.0"
+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/*
 
-# Install Python dependencies that all environments need
-RUN pip install --no-cache-dir \
-    fastapi>=0.104.0 \
-    "uvicorn[standard]>=0.24.0" \
-    requests>=2.25.0 \
-    wsproto>=1.0.0
+# 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
@@ -39,6 +56,7 @@ 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

src/core/containers/images/README.md

@@ -36,7 +36,7 @@ Total: 465 MB (base shared, minimal duplication)
 
 ```bash
 # From project root
-docker build -t openenv-base:latest -f src/core/containers/images/Dockerfile .
+docker build -t openenv-base:latest -f src/openenv/core/containers/images/Dockerfile .
 ```
 
 ## Usage in Environment Dockerfiles
@@ -47,8 +47,8 @@ Each environment Dockerfile should start with:
 FROM openenv-base:latest
 
 # Copy only environment-specific files
-COPY src/core/ /app/src/core/
-COPY src/envs/my_env/ /app/src/envs/my_env/
+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"]
@@ -66,10 +66,10 @@ CMD ["uvicorn", "envs.my_env.server.app:app", "--host", "0.0.0.0", "--port", "80
 
 ```bash
 # Step 1: Build base image (do this once)
-docker build -t openenv-base:latest -f src/core/containers/images/Dockerfile .
+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 src/envs/echo_env/server/Dockerfile .
+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
@@ -79,14 +79,14 @@ docker run -p 8000:8000 echo-env:latest
 
 When dependencies need updating:
 
-1. Update `src/core/containers/images/Dockerfile`
+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/core/containers/images/Dockerfile .
+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 src/envs/echo_env/server/Dockerfile .
+docker build -t echo-env:latest -f envs/echo_env/server/Dockerfile .
 ```

src/core/containers/runtime/__init__.py

@@ -6,10 +6,20 @@
 
 """Container runtime providers."""
 
-from .providers import ContainerProvider, KubernetesProvider, LocalDockerProvider
+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

@@ -8,13 +8,13 @@
 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 HTTPEnvClient.
+(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
+from typing import Any, Dict, Optional, Sequence
 
 
 class ContainerProvider(ABC):
@@ -118,7 +118,11 @@ class LocalDockerProvider(ContainerProvider):
                 capture_output=True,
                 timeout=5,
             )
-        except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            subprocess.TimeoutExpired,
+        ):
             raise RuntimeError(
                 "Docker is not available. Please install Docker Desktop or Docker Engine."
             )
@@ -154,10 +158,13 @@ class LocalDockerProvider(ContainerProvider):
 
         # Build docker run command
         cmd = [
-            "docker", "run",
+            "docker",
+            "run",
             "-d",  # Detached
-            "--name", self._container_name,
-            "-p", f"{port}:8000",  # Map port
+            "--name",
+            self._container_name,
+            "-p",
+            f"{port}:8000",  # Map port
         ]
 
         # Add environment variables
@@ -169,8 +176,12 @@ class LocalDockerProvider(ContainerProvider):
         cmd.append(image)
 
         # Run container
-        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-        self._container_id = result.stdout.strip()
+        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)
@@ -222,14 +233,18 @@ class LocalDockerProvider(ContainerProvider):
             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)
+                response = requests.get(health_url, timeout=2.0, proxies=proxies)
                 if response.status_code == 200:
                     return
             except requests.RequestException:
@@ -273,6 +288,308 @@ class LocalDockerProvider(ContainerProvider):
         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.
@@ -286,4 +603,67 @@ class KubernetesProvider(ContainerProvider):
         >>> # 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

@@ -16,8 +16,8 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).parent.parent.parent))
 
 import requests
+from openenv.core.containers.runtime import LocalDockerProvider
 
-from 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():
@@ -87,7 +87,9 @@ def test_local_docker_provider():
         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"]["echoed_message"] == "Hello from LocalDockerProvider!"
+        )
         assert data["observation"]["message_length"] == 31
         print("✓ Step test passed\n")
 
@@ -107,11 +109,11 @@ def test_local_docker_provider():
         for i in range(3):
             response = requests.post(
                 f"{base_url}/step",
-                json={"action": {"message": f"Message {i+1}"}},
+                json={"action": {"message": f"Message {i + 1}"}},
                 headers={"Content-Type": "application/json"},
             )
             assert response.status_code == 200
-            print(f"  Step {i+1}: ✓")
+            print(f"  Step {i + 1}: ✓")
 
         # Check state updated
         response = requests.get(f"{base_url}/state")
@@ -130,6 +132,7 @@ def test_local_docker_provider():
     except Exception as e:
         print(f"\n❌ Test failed: {e}")
         import traceback
+
         traceback.print_exc()
         return False
 
@@ -197,8 +200,7 @@ def test_provider_with_env_vars():
 
         print("Starting container with environment variables...")
         base_url = provider.start_container(
-            "echo-env:latest",
-            env_vars={"DEBUG": "true", "LOG_LEVEL": "info"}
+            "echo-env:latest", env_vars={"DEBUG": "true", "LOG_LEVEL": "info"}
         )
         print(f"✓ Started at: {base_url}")
 

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

@@ -7,10 +7,74 @@
 """Core environment interfaces and types."""
 
 from .base_transforms import CompositeTransform, NullTransform
-from .http_server import HTTPEnvServer, create_app, create_fastapi_app
+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
-from .types import Action, Observation, State
-from .web_interface import create_web_interface_app, WebInterfaceManager
+
+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
@@ -22,6 +86,33 @@ __all__ = [
     "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",
@@ -32,4 +123,28 @@ __all__ = [
     # 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

@@ -26,4 +26,4 @@ class NullTransform(Transform):
     """Default transform that passes through unchanged."""
 
     def __call__(self, observation: Observation) -> Observation:
-        return 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

@@ -8,25 +8,113 @@
 HTTP server wrapper for Environment instances.
 
 This module provides utilities to wrap any Environment subclass and expose it
-over HTTP endpoints that HTTPEnvClient can consume.
+over HTTP and WebSocket endpoints that EnvClient can consume.
 """
 
 from __future__ import annotations
 
+import asyncio
+import inspect
+import json
 import os
-from dataclasses import asdict
-from typing import Any, Dict, Type
+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 .types import Action, Observation
-from fastapi import Body, FastAPI
+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 endpoints compatible with HTTPEnvClient.
+    methods as HTTP and WebSocket endpoints compatible with EnvClient.
 
     The server expects:
     - Action deserialization: Converts JSON dict to Action subclass
@@ -35,9 +123,15 @@ class HTTPEnvServer:
     Example:
         >>> from core.env_server import HTTPEnvServer
         >>> from envs.coding_env.server import CodeExecutionEnvironment
+        >>> from envs.coding_env.models import CodeAction, CodeObservation
         >>>
-        >>> env = CodeExecutionEnvironment()
-        >>> server = HTTPEnvServer(env)
+        >>> # 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
@@ -47,178 +141,1177 @@ class HTTPEnvServer:
 
     def __init__(
         self,
-        env: Environment,
+        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: The Environment instance to wrap
+            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.
         """
-        self.env = env
+        # 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
 
-    def register_routes(self, app: Any) -> None:
+        # 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:
         """
-        Register HTTP routes on a FastAPI application.
+        Validate that the environment supports the configured concurrency level.
 
-        Args:
-            app: FastAPI application instance
+        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 not isinstance(app, FastAPI):
-            raise TypeError("app must be a FastAPI instance")
+        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
 
-        @app.post("/reset")
-        async def reset(request: Dict[str, Any] = Body(default={})) -> Dict[str, Any]:
-            """Reset endpoint - returns initial observation."""
-            # TODO: Handle seed, episode_id from request if provided
-            observation = self.env.reset()
-            return self._serialize_observation(observation)
+        if not getattr(env_cls, "SUPPORTS_CONCURRENT_SESSIONS", False):
+            raise ConcurrencyConfigurationError(
+                environment_name=env_cls.__name__,
+                max_concurrent_envs=self._max_concurrent_envs,
+            )
 
-        @app.post("/step")
-        async def step(request: Dict[str, Any]) -> Dict[str, Any]:
-            """Step endpoint - executes action and returns observation."""
-            action_data = request.get("action", {})
-            # TODO: Handle timeout_s, request_id, episode_id from request if provided
+    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)
 
-            # Deserialize action
-            action = self._deserialize_action(action_data)
+        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,
+                )
 
-            # Execute step
-            observation = self.env.step(action)
+            session_id = str(uuid.uuid4())
+            current_time = time.time()
 
-            # Return serialized observation
-            return self._serialize_observation(observation)
+            # 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
 
-        @app.get("/state")
-        async def get_state() -> Dict[str, Any]:
-            """State endpoint - returns current environment state."""
-            state = self.env.state
-            return asdict(state)
+        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
 
-        @app.get("/health")
-        async def health() -> Dict[str, str]:
-            """Health check endpoint."""
-            return {"status": "healthy"}
+        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
 
-    def _deserialize_action(self, action_data: Dict[str, Any]) -> Action:
+    async def _destroy_session(self, session_id: str) -> None:
         """
-        Convert JSON dict to Action instance.
+        Destroy a WebSocket session and cleanup resources.
 
         Args:
-            action_data: Dictionary containing action data
+            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)
 
-        Returns:
-            Action instance
+        # 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.
 
-        Note:
-            This is a simple implementation. Subclasses may need to override
-            for more complex deserialization logic.
+        Args:
+            session_id: The session ID to update
+            increment_step: If True, increment the step count
         """
-        # Remove metadata if present (it will be set via kw_only field)
-        metadata = action_data.pop("metadata", {})
-        action = self.action_cls(**action_data)
-        action.metadata = metadata
-        return action
+        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 _serialize_observation(self, observation: Observation) -> Dict[str, Any]:
+    def get_session_info(self, session_id: str) -> Optional[SessionInfo]:
         """
-        Convert Observation instance to JSON-compatible dict.
+        Get information about a specific session.
 
         Args:
-            observation: Observation instance
+            session_id: The session ID to query
 
         Returns:
-            Dictionary compatible with HTTPEnvClient._parse_result()
+            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
 
-        The format matches what HTTPEnvClient expects:
-        {
-            "observation": {...},  # Observation fields
-            "reward": float | None,
-            "done": bool,
-        }
+        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:
         """
-        obs_dict = asdict(observation)
+        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)
 
-        # Extract reward and done (these are part of StepResult on client side)
-        reward = obs_dict.pop("reward", None)
-        done = obs_dict.pop("done", False)
-        obs_dict.pop("metadata", None)  # Remove metadata from observation
+                    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
 
-        # Return in HTTPEnvClient expected format
-        return {
-            "observation": obs_dict,
-            "reward": reward,
-            "done": done,
-        }
 
 def create_app(
-    env: Environment,
+    env: Callable[[], Environment],
     action_cls: Type[Action],
     observation_cls: Type[Observation],
     env_name: Optional[str] = None,
-) -> Any:
+    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: The Environment instance to serve
+        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")
+    enable_web = os.getenv("ENABLE_WEB_INTERFACE", "false").lower() in (
+        "true",
+        "1",
+        "yes",
     )
 
     if enable_web:
-        # Import web interface only when needed
+        # 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)
+
+        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)
-    
+        return create_fastapi_app(
+            env, action_cls, observation_cls, max_concurrent_envs, concurrency_config
+        )
+
 
 def create_fastapi_app(
-    env: Environment,
+    env: Callable[[], Environment],
     action_cls: Type[Action],
     observation_cls: Type[Observation],
-) -> Any:
+    max_concurrent_envs: Optional[int] = None,
+    concurrency_config: Optional[ConcurrencyConfig] = None,
+) -> FastAPI:
     """
-    Create a FastAPI application with routes for the given environment.
+    Create a FastAPI application with comprehensive documentation.
 
     Args:
-        env: The Environment instance to serve
+        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 with routes registered
-
-    Example:
-        >>> from envs.coding_env.server import CodeExecutionEnvironment
-        >>> from envs.coding_env.models import CodeAction, CodeObservation
-        >>>
-        >>> env = CodeExecutionEnvironment()
-        >>> app = create_fastapi_app(env, CodeAction, CodeObservation)
-        >>>
-        >>> # Run with: uvicorn module:app --host 0.0.0.0 --port 8000
+        FastAPI application instance
     """
     try:
         from fastapi import FastAPI
@@ -227,7 +1320,72 @@ def create_fastapi_app(
             "FastAPI is required. Install with: pip install fastapi uvicorn"
         )
 
-    app = FastAPI(title="Environment HTTP Server")
-    server = HTTPEnvServer(env, action_cls, observation_cls)
+    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

@@ -4,10 +4,20 @@
 # 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, Protocol, TypedDict
+from typing import Any, Generic, Optional, Protocol, TYPE_CHECKING, TypeVar
 
-from .types import Action, Observation, State
+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):
@@ -64,7 +74,7 @@ class ModelTokenizer(Protocol):
         ...
 
 
-class Transform(ABC):
+class Transform(ABC, Generic[ObsT]):
     """Transform observations to add rewards, metrics, or other modifications.
 
     Transforms follow the TorchRL pattern where they take an observation
@@ -73,7 +83,7 @@ class Transform(ABC):
     """
 
     @abstractmethod
-    def __call__(self, observation: Observation) -> Observation:
+    def __call__(self, observation: ObsT) -> ObsT:
         """Transform an observation.
 
         Args:
@@ -85,34 +95,203 @@ class Transform(ABC):
         pass
 
 
-class Environment(ABC):
+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
     """
 
-    def __init__(self, transform: Transform | None = None):
+    # 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) -> Observation:
+    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: Action) -> Observation:
+    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) -> State:
+    def state(self) -> StateT:
         """Get the current environment state."""
         pass
 
-    def _apply_transform(self, observation: Observation) -> Observation:
+    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