init

Dockerfile

@@ -14,8 +14,10 @@ COPY . .
 
 # Install Python dependencies
 #RUN pip install --no-cache-dir -e .
+
+pip install git+https://github.com/meta-pytorch/OpenEnv.git
+
 RUN pip install --no-cache-dir -r ./requirements.txt
-RUN pip install --no-cache-dir -e ./openenv
 
 # Expose port
 EXPOSE 8000

openenv/CODE_OF_CONDUCT.md

@@ -1,80 +0,0 @@
-# Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to make participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies within all project spaces, and it also applies when
-an individual is representing the project or its community in public spaces.
-Examples of representing a project or community include using an official
-project e-mail address, posting via an official social media account, or acting
-as an appointed representative at an online or offline event. Representation of
-a project may be further defined and clarified by project maintainers.
-
-This Code of Conduct also applies outside the project spaces when there is a
-reasonable belief that an individual's behavior may have a negative impact on
-the project or its community.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at <opensource-conduct@meta.com>. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq

openenv/CONTRIBUTING.md

@@ -1,39 +0,0 @@
-# Contributing to __________
-We want to make contributing to this project as easy and transparent as
-possible.
-
-## Our Development Process
-... (in particular how this is synced with internal changes to the project)
-
-## Pull Requests
-We actively welcome your pull requests.
-
-1. Fork the repo and create your branch from `main`.
-2. If you've added code that should be tested, add tests.
-3. If you've changed APIs, update the documentation.
-4. Ensure the test suite passes.
-5. Make sure your code lints.
-6. If you haven't already, complete the Contributor License Agreement ("CLA").
-
-## Contributor License Agreement ("CLA")
-In order to accept your pull request, we need you to submit a CLA. You only need
-to do this once to work on any of Meta's open source projects.
-
-Complete your CLA here: <https://code.facebook.com/cla>
-
-## Issues
-We use GitHub issues to track public bugs. Please ensure your description is
-clear and has sufficient instructions to be able to reproduce the issue.
-
-Meta has a [bounty program](https://bugbounty.meta.com/) for the safe
-disclosure of security bugs. In those cases, please go through the process
-outlined on that page and do not file a public issue.
-
-## Coding Style  
-* 2 spaces for indentation rather than tabs
-* 80 character line length
-* ...
-
-## License
-By contributing to __________, you agree that your contributions will be licensed
-under the LICENSE file in the root directory of this source tree.

openenv/LICENSE

@@ -1,28 +0,0 @@
-BSD 3-Clause License
-
-(c) Meta Platforms, Inc. and affiliates.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice,this list
-of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions and the following disclaimer in the documentation
-and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors may
-be used to endorse or promote products derived from this software without specific
-prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
-SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
-BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.

openenv/README.md

@@ -1,299 +0,0 @@
-# <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.
-
-[![PyPI](https://img.shields.io/pypi/v/openenv-core?color=blue)](https://pypi.org/project/openenv-core/)
-[![Discord](https://img.shields.io/badge/Discord-OpenEnv-7289da?style=flat&logo=discord&logoColor=white)](https://discord.gg/YsTYBh6PD9)
-[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/meta-pytorch/OpenEnv/blob/main/examples/OpenEnv_Tutorial.ipynb)
-[![Docs](https://img.shields.io/badge/Docs-Explore-blue?logo=readthedocs&logoColor=white)](https://meta-pytorch.org/OpenEnv/)
-
----
-
-**🚀 Featured Example:** Train LLMs to play BlackJack using [torchforge](https://github.com/meta-pytorch/torchforge) (PyTorch's agentic RL framework): [`examples/grpo_blackjack/`](examples/grpo_blackjack/)
-
-## OpenEnv on partner platforms:
-
-- [Lightning AI Studio](https://lightning.ai/environments?section=featured)
-- [TRL example](https://huggingface.co/docs/trl/main/en/openenv)
-- [Unsloth Google Colab](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/OpenEnv_gpt_oss_(20B)_Reinforcement_Learning_2048_Game.ipynb)
-- [ART example](https://art.openpipe.ai/integrations/openenv-integration)
-- [Oumi example](https://github.com/oumi-ai/oumi/blob/main/notebooks/Oumi%20-%20OpenEnv%20GRPO%20with%20trl.ipynb)
-
-## Overview
-
-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.
-
-The OpenEnv CLI (`openenv`) provides commands to initialize new environments and deploy them to Hugging Face Spaces.
-
-> ⚠️ **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.
-
-### RFCs
-
-Below is a list of active and historical RFCs for OpenEnv. RFCs are proposals for major changes or features. Please review and contribute!
-
-- [RFC 001: Baseline API and Interface Specifications](https://github.com/meta-pytorch/OpenEnv/pull/26)
-
-## Architecture
-
-### Component Overview
-
-```
-┌─────────────────────────────────────────────────────────┐
-│                    Client Application                   │
-│  ┌────────────────┐              ┌──────────────────┐   │
-│  │  EchoEnv       │              │  CodingEnv       │   │
-│  │ (HTTPEnvClient)│              │  (HTTPEnvClient) │   │
-│  └────────┬───────┘              └────────┬─────────┘   │
-└───────────┼───────────────────────────────┼─────────────┘
-            │ HTTP                          │ HTTP
-            │ (reset, step, state)          │
-┌───────────▼───────────────────────────────▼─────────────┐
-│              Docker Containers (Isolated)               │
-│  ┌──────────────────────┐    ┌──────────────────────┐   │
-│  │ FastAPI Server       │    │ FastAPI Server       │   │
-│  │   EchoEnvironment    │    │ PythonCodeActEnv     │   │
-│  │ (Environment base)   │    │ (Environment base)   │   │
-│  └──────────────────────┘    └──────────────────────┘   │
-└────────────────────────────────���────────────────────────┘
-```
-
-### Core Components
-
-#### 1. Web Interface
-
-OpenEnv includes a built-in web interface for interactive environment exploration and debugging. The web interface provides:
-
-- **Two-Pane Layout**: HumanAgent interaction on the left, state observation on the right
-- **Real-time Updates**: WebSocket-based live updates without page refresh
-- **Dynamic Forms**: Automatically generated action forms based on environment Action types
-- **Action History**: Complete log of all actions taken and their results
-
-The web interface is **conditionally enabled** based on environment variables:
-
-- **Local Development**: Disabled by default for lightweight development
-- **Manual Override**: Enable with `ENABLE_WEB_INTERFACE=true`
-
-To use the web interface:
-
-```python
-from core.env_server import create_web_interface_app
-from your_env.models import YourAction, YourObservation
-from your_env.server.your_environment import YourEnvironment
-
-env = YourEnvironment()
-app = create_web_interface_app(env, YourAction, YourObservation)
-```
-
-When enabled, open `http://localhost:8000/web` in your browser to interact with the environment.
-
-#### 2. Environment (Server-Side)
-Base class for implementing environment logic:
-- **`reset()`**: Initialize a new episode, returns initial `Observation`
-- **`step(action)`**: Execute an `Action`, returns resulting `Observation`
-- **`state()`**: Access episode metadata (`State` with episode_id, step_count, etc.)
-
-#### 3. HTTPEnvClient (Client-Side)
-Base class for HTTP communication:
-- Handles HTTP requests to environment server
-- Contains a utility to spin up a docker container locally for the corresponding environment
-- Type-safe action/observation parsing
-
-#### 4. Container Providers
-Manage container deployment:
-- `LocalDockerProvider`: Run containers on local Docker daemon
-- `KubernetesProvider`: Deploy to K8s clusters (future)
-
-#### 5. Models
-Type-safe data structures:
-- `Action`: Base class for environment actions
-- `Observation`: Base class for environment observations
-- `State`: Episode state tracking
-- `StepResult`: Combines observation, reward, done flag
-
-## Project Structure
-
-### For Environment Creators
-
-Use the CLI to quickly scaffold a new environment:
-
-```bash
-openenv init my_env
-```
-
-This creates the following structure:
-
-```
-my_env/
-├── .dockerignore        # Docker build exclusions
-├── __init__.py           # Export YourAction, YourObservation, YourEnv
-├── models.py             # Define Action, Observation, State dataclasses
-├── client.py             # Implement YourEnv(HTTPEnvClient)
-├── README.md             # Document your environment
-├── openenv.yaml          # Environment manifest
-├── pyproject.toml        # Dependencies and package configuration
-├── outputs/              # Runtime outputs (logs, evals) - gitignored
-│   ├── logs/
-│   └── evals/
-└── server/
-    ├── your_environment.py  # Implement YourEnvironment(Environment)
-    ├── app.py               # Create FastAPI app
-    ├── requirements.txt     # Dependencies for Docker (can be generated)
-    └── Dockerfile           # Define container image
-```
-
-#### Dependency Management
-
-OpenEnv uses `pyproject.toml` as the primary dependency specification:
-
-- **Environment-level `pyproject.toml`**: Each environment defines its own dependencies
-- **Root-level `pyproject.toml`**: Contains shared core dependencies (fastapi, pydantic, uvicorn)
-- **Server `requirements.txt`**: Can be auto-generated from `pyproject.toml` for Docker builds
-
-**Development Workflow:**
-
-```bash
-# Install environment in editable mode
-cd my_env
-pip install -e .
-
-# Or using uv (faster)
-uv pip install -e .
-
-# Run server locally without Docker
-uv run server --host 0.0.0.0 --port 8000
-```
-
-**Benefits:**
-- ✅ **Client-side extensions**: Modify client classes locally without repo changes
-- ✅ **Better dependency management**: Clear separation between environments
-- ✅ **Flexible workflows**: Use pip, uv, or Docker for different scenarios
-- ✅ **CI/CD ready**: Automated dependency generation and validation
-
-See [`src/envs/README.md`](src/envs/README.md) for a complete guide on building environments.
-
-### For Environment Users
-
-To use an environment:
-1. Import from `envs.your_env`: `from envs.echo_env import EchoAction, EchoEnv`
-2. Create client: `client = EchoEnv.from_docker_image("echo-env:latest")`
-3. Interact: `client.reset()`, `client.step(action)`, `client.state()`
-4. Cleanup: `client.close()`
-
-See example scripts in `examples/` directory.
-
-## CLI Commands
-
-The OpenEnv CLI provides commands to manage environments:
-
-- **`openenv init <env_name>`** - Initialize a new environment from template
-- **`openenv push [--repo-id <repo>] [--private]`** - Deploy environment to Hugging Face Spaces
-
-### Quick Start
-
-```bash
-# Create a new environment
-openenv init my_game_env
-
-# Deploy to Hugging Face (will prompt for login if needed)
-cd my_game_env
-openenv push
-```
-
-For detailed options: `openenv init --help` and `openenv push --help`.
-
-## Design Principles
-
-1. **Separation of Concerns**: Clear client-server boundaries
-2. **Type Safety**: Strongly-typed actions, observations, and state
-3. **Container Isolation**: Each environment runs in its own container
-4. **Simple APIs**: Minimal, intuitive interfaces
-
-## Quick Start
-
-### Using the Echo Environment(Example)
-
-```python
-from envs.echo_env import EchoAction, EchoEnv
-
-# Automatically start container and connect
-client = EchoEnv.from_docker_image("echo-env:latest")
-
-# Reset the environment
-result = client.reset()
-print(result.observation.echoed_message)  # "Echo environment ready!"
-
-# Send messages
-result = client.step(EchoAction(message="Hello, World!"))
-print(result.observation.echoed_message)  # "Hello, World!"
-print(result.reward)  # 1.3 (based on message length)
-
-# Cleanup
-client.close()  # Stops and removes container
-```
-
-## Requirements
-
-- Python 3.11+
-- Docker Desktop or Docker Engine
-- FastAPI >= 0.104.0
-- Uvicorn >= 0.24.0
-- Requests >= 2.25.0
-- smolagents (for coding environment)
-
-## Supported RL Tools
-The goal of this project is to support a broad set of open and closed tools to help standardize the agentic RL community. If you have a project that supports OpenEnv environments, please put up a PR to add your tool name along with a link to your documentation.
-
-### torchforge
-See GRPO BlackJack training example: [`examples/grpo_blackjack/`](examples/grpo_blackjack/)
-
-### TRL
-See the [TRL example](https://huggingface.co/docs/trl/main/en/openenv) on how to integrate OpenEnv environments with GRPO training.
-
-### Unsloth
-See the 2048 game example based on gpt-oss: [Colab notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/OpenEnv_gpt_oss_(20B)_Reinforcement_Learning_2048_Game.ipynb)
-
-### SkyRL
-See the [SkyRL example](https://skyrl.readthedocs.io/en/latest/examples/openenv.html) on how to train on OpenEnv environments with SkyRL.
-
-### ART
-See the [ART example](https://art.openpipe.ai/integrations/openenv-integration) on how OpenEnv environments can be used to train models with ART.
-
-### Oumi
-See the [Oumi example](https://github.com/oumi-ai/oumi/blob/main/notebooks/Oumi%20-%20OpenEnv%20GRPO%20with%20trl.ipynb) on how OpenEnv environments can be used to train models with Oumi.
-
-## Example Environments
-
-### Echo Environment
-A simple environment that echoes back messages with metadata. Perfect for:
-- Testing the HTTP server infrastructure
-- Learning the framework basics
-- Verifying container deployment
-
-See: [`src/envs/echo_env/README.md`](src/envs/echo_env/README.md)
-
-### Coding Environment
-Executes arbitrary Python code in a sandboxed environment. Features:
-- Safe code execution using smolagents
-- Capture stdout, stderr, and exit codes
-- Persistent execution context within episodes
-- Error handling with detailed messages
-
-See: [`src/envs/coding_env/README.md`](src/envs/coding_env/README.md)
-
-## Community Support & Acknowledgments
-This is an open and community-centric project. If you would like to add your name here, please put up a pull request and tag @jspisak for review. Ty!!
-
-Supporters include: Meta-PyTorch, Hugging Face, [Patronus AI](https://patronus.ai), [Surge AI](https://surgehq.ai), [LastMile AI](https://www.lastmileai.dev), Unsloth AI, Reflection AI, vLLM, SkyRL (UC-Berkeley), LightningAI, Axolotl AI, Stanford Scaling Intelligence Lab, Mithril, [OpenMined](https://openmined.org/), [Fleet AI](https://fleetai.com), [Halluminate](https://halluminate.ai/) ..
-
-And we'd also like to acknowledge the team at Farama Foundation as the OpenEnv API was heavily inspired by the work you all have done on Gymnasium. Cheers!
-
-## License
-
-BSD 3-Clause License (see [LICENSE](./LICENSE) file)

openenv/pyproject.toml

@@ -1,57 +0,0 @@
-[build-system]
-requires = ["setuptools>=45", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "openenv"
-version = "0.1.1"
-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"
-]
-
-[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:",
-]

openenv/scripts/CONVERT.md

@@ -1,491 +0,0 @@
-# Converting Your Environment to OpenEnv Standard
-
-This guide helps you convert an existing `src/envs/<env_name>` environment to a standalone, OpenEnv CLI-compatible environment that can be independently developed, versioned, and deployed.
-
-## Overview
-
-The new OpenEnv standard enables:
-- **Independent repositories**: Each environment can have its own git repo
-- **Standalone deployment**: Use `openenv push` to deploy directly to HuggingFace or Docker registries
-- **Better dependency management**: Use `pyproject.toml` with `uv` for fast, reliable builds
-- **Development flexibility**: Work on environments without the full OpenEnv monorepo
-
-## Prerequisites
-
-- Python 3.10+
-- `uv` package manager ([installation guide](https://github.com/astral-sh/uv))
-- Docker (for building and testing)
-- Git (for version control)
-
-## Quick Start: Automated Conversion
-
-We provide a script to automate most of the conversion process:
-
-```bash
-# From the OpenEnv repository root
-./scripts/convert_env.sh src/envs/my_env /path/to/new/my_env_standalone
-```
-
-> **Note:** The converter requires `python3` on your PATH and works with the default Bash shipped on macOS. When prompted, answer `y` to proceed and leave the optional naming prompts blank to accept the defaults.
-
-This script will:
-1. Copy your environment to a new directory
-2. Convert `requirements.txt` to `pyproject.toml` (if needed)
-3. Add HuggingFace frontmatter to README
-4. Update Dockerfile for standalone builds
-5. Initialize a new git repository
-6. Create necessary configuration files
-7. Rewrite imports so the environment depends on `openenv-core` and installs as a proper Python package
-
-After running the script, jump to [Step 4: Testing Your Conversion](#step-4-testing-your-conversion).
-
-## Manual Conversion Steps
-
-If you prefer to convert manually or need to understand what's happening:
-
-### Step 1: Create New Environment Directory
-
-```bash
-# Create a new directory for your standalone environment
-mkdir -p ~/my_projects/my_env_standalone
-cd ~/my_projects/my_env_standalone
-
-# Copy your existing environment
-cp -r /path/to/OpenEnv/src/envs/my_env/* .
-
-# Initialize git repository
-git init
-git add .
-git commit -m "Initial commit: Convert from OpenEnv monorepo"
-```
-
-### Step 2: Convert Dependencies to pyproject.toml
-
-If your environment uses `server/requirements.txt`, convert it to `pyproject.toml`:
-
-#### Option A: Automated Conversion
-
-```python
-# Run this Python script in your environment directory
-import re
-from pathlib import Path
-
-env_name = Path.cwd().name
-requirements_file = Path("server/requirements.txt")
-
-if requirements_file.exists():
-    # Parse requirements.txt
-    deps = []
-    with open(requirements_file) as f:
-        for line in f:
-            line = line.strip()
-            if line and not line.startswith("#"):
-                deps.append(f'    "{line}",')
-    
-    deps_str = "\n".join(deps)
-    
-    # Create pyproject.toml
-    pyproject_content = f'''[build-system]
-requires = ["setuptools>=45", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "openenv-{env_name}"
-version = "0.1.0"
-description = "{env_name.replace('_', ' ').title()} Environment for OpenEnv"
-requires-python = ">=3.10"
-dependencies = [
-{deps_str}
-    "openenv-core>=0.1.0",
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-cov>=4.0.0",
-    "ipykernel>=6.29.5",
-]
-
-[project.scripts]
-server = "{env_name}.server.app:main"
-
-[tool.setuptools]
-packages = ["{env_name}", "{env_name}.server"]
-package-dir = { "{env_name}" = ".", "{env_name}.server" = "server" }
-
-[tool.setuptools.package-data]
-{env_name} = ["**/*.yaml", "**/*.yml"]
-'''
-    
-    Path("pyproject.toml").write_text(pyproject_content)
-    print(f"✓ Created pyproject.toml from {requirements_file}")
-else:
-    print("No requirements.txt found - pyproject.toml may already exist")
-```
-
-#### Option B: Manual Creation
-
-Create `pyproject.toml` at the environment root:
-
-```toml
-[build-system]
-requires = ["setuptools>=45", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "openenv-my_env"
-version = "0.1.0"
-description = "My Environment for OpenEnv"
-requires-python = ">=3.10"
-dependencies = [
-    "openenv-core>=0.1.0",
-    "fastapi>=0.115.0",
-    "pydantic>=2.0.0",
-    "uvicorn>=0.24.0",
-    "requests>=2.25.0",
-    # Add your environment-specific dependencies here
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-cov>=4.0.0",
-    "ipykernel>=6.29.5",
-]
-
-[project.scripts]
-server = "my_env.server.app:main"
-
-[tool.setuptools]
-packages = ["my_env"]
-
-[tool.setuptools]
-packages = ["{env_name}", "{env_name}.server"]
-package-dir = { "{env_name}" = ".", "{env_name}.server" = "server" }    
-```
-
-**Important**: Replace `my_env` with your actual environment name throughout the file.
-
-### Step 3: Update Files for Standalone Usage
-
-#### 3.1: Add HuggingFace Frontmatter to README.md
-
-Add this YAML frontmatter to the top of your `README.md`:
-
-```markdown
----
-title: My Environment Server
-emoji: 🎮
-colorFrom: '#00C9FF'
-colorTo: '#1B2845'
-sdk: docker
-pinned: false
-app_port: 8000
-base_path: /web
-tags:
-  - openenv
----
-
-# My Environment
-
-[Rest of your README content...]
-```
-
-**Customize**:
-- `title`: Your environment's display name
-- `emoji`: Pick an emoji that represents your environment ([emoji list](https://emojipedia.org/))
-- `colorFrom` / `colorTo`: Gradient colors for HuggingFace card (hex codes)
-
-#### 3.2: Update Dockerfile
-
-Your `server/Dockerfile` needs to support standalone builds. Update it to:
-
-```dockerfile
-# Base image
-FROM python:3.11-slim
-
-# Set working directory
-WORKDIR /app/env
-
-# Install system dependencies (if needed)
-RUN apt-get update && apt-get install -y \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy environment files
-COPY . .
-
-# Install Python dependencies
-RUN pip install --no-cache-dir -e .
-
-# Expose port
-EXPOSE 8000
-
-# Set environment variables
-ENV PYTHONUNBUFFERED=1
-ENV ENABLE_WEB_INTERFACE=true
-
-# Run the server
-CMD ["python", "-m", "uvicorn", "my_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]
-```
-
-**Key changes**:
-- Uses `pip install -e .` to install from `pyproject.toml`
-- Copies entire environment directory
-- Sets `ENABLE_WEB_INTERFACE=true` for HuggingFace deployments
-- Replace `my_env` with your environment name
-
-#### 3.3: Update app.py
-
-Ensure your `server/app.py` has a proper `main()` function:
-
-```python
-# At the end of server/app.py
-def main():
-    """Main entry point for running the server."""
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
-
-if __name__ == "__main__":
-    main()
-```
-
-This enables running with `uv run server`.
-
-#### 3.4: Create uv.lock
-
-Generate a lockfile for reproducible builds:
-
-```bash
-# Install uv if you haven't already
-curl -LsSf https://astral.sh/uv/install.sh | sh
-
-# Generate lockfile
-uv lock
-```
-
-This creates `uv.lock` which pins all dependencies.
-
-#### 3.5: Add .gitignore
-
-Create or update `.gitignore`:
-
-```gitignore
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-
-# Virtual environments
-venv/
-env/
-ENV/
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Environment outputs
-outputs/
-logs/
-*.log
-
-# Testing
-.pytest_cache/
-.coverage
-htmlcov/
-```
-
-### Step 4: Testing Your Conversion
-
-#### 4.1: Install and Test Locally
-
-```bash
-# Install in editable mode
-uv pip install -e .
-
-# Test imports
-python -c "from my_env import MyAction, MyObservation, MyEnv"
-
-# Run server locally
-uv run server
-```
-
-Visit `http://localhost:8000/docs` to see the API documentation.
-
-#### 4.2: Build Docker Image
-
-```bash
-# Build the image
-openenv build
-
-# Or manually:
-docker build -t my_env:latest -f server/Dockerfile .
-
-# Test the container
-docker run -p 8000:8000 my_env:latest
-```
-
-#### 4.3: Validate Structure
-
-Use the OpenEnv CLI to validate your environment:
-
-```bash
-openenv validate
-```
-
-This checks for:
-- Required files (`openenv.yaml`, `pyproject.toml`, etc.)
-- Correct dependency structure
-- Valid server entry point
-- Docker build capability
-
-### Step 5: Deploy Your Environment
-
-#### Deploy to HuggingFace Spaces
-
-```bash
-# Deploy to HuggingFace (with web interface)
-openenv push
-
-# Deploy to specific repo
-openenv push --repo-id myusername/my-env
-
-# Deploy privately
-openenv push --private
-```
-
-#### Deploy to Docker Registry
-
-```bash
-# Build and push to Docker Hub
-openenv push --registry docker.io/myusername
-
-# Push to GitHub Container Registry
-openenv push --registry ghcr.io/myorg
-
-# Push to custom registry
-openenv push --registry myregistry.io/path/to/repo
-```
-
-## Directory Structure After Conversion
-
-Your standalone environment should look like this:
-
-```
-my_env_standalone/
-├── .git/                  # Git repository
-├── .gitignore            # Ignore patterns
-├── README.md             # With HF frontmatter
-├── openenv.yaml          # Environment manifest
-├── pyproject.toml        # Dependencies and metadata
-├── uv.lock              # Locked dependencies
-├── __init__.py          # Module exports
-├── client.py            # Environment client
-├── models.py            # Action/Observation models
-└── server/
-    ├── __init__.py
-    ├── app.py           # FastAPI app (with main())
-    ├── Dockerfile       # Standalone build
-    └── my_env_environment.py  # Core environment logic
-```
-
-## Common Issues and Solutions
-
-### Issue: Import Errors After Installation
-
-**Solution**: Reinstall in editable mode:
-```bash
-uv pip install -e . --force-reinstall
-```
-
-### Issue: Docker Build Fails
-
-**Solutions**:
-1. Ensure `pyproject.toml` has all dependencies
-2. Check Dockerfile COPY commands are correct
-3. Verify base image is accessible
-
-### Issue: `openenv` Commands Not Found
-
-**Solution**: Install openenv-cli:
-```bash
-pip install openenv-cli
-# or
-uv pip install openenv-cli
-```
-
-### Issue: Server Entry Point Not Found
-
-**Solution**: Ensure `pyproject.toml` has correct entry point:
-```toml
-[project.scripts]
-server = "my_env.server.app:main"  # Replace my_env with your name
-```
-
-### Issue: Missing openenv-core Dependency
-
-**Solution**: Add to `pyproject.toml`:
-```toml
-dependencies = [
-    "openenv-core>=0.1.0",
-    # ... other dependencies
-]
-```
-
-For local development, install core from the OpenEnv repo:
-```bash
-pip install -e /path/to/OpenEnv/src/core
-```
-
-## Development Workflow
-
-Once converted, you can work independently:
-
-```bash
-# Clone your standalone repo
-git clone https://github.com/myusername/my_env_standalone
-cd my_env_standalone
-
-# Install dependencies
-uv pip install -e .
-
-# Run locally
-uv run server
-
-# Make changes to client.py, models.py, etc.
-
-# Test changes
-openenv validate
-openenv build
-
-# Deploy updates
-openenv push
-```
-## Automated Script
-
-For full automation, see the `scripts/convert_env.sh` script included in this repository.

openenv/scripts/convert_env.sh

@@ -1,502 +0,0 @@
-#!/bin/bash
-# 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.
-
-set -e  # Exit on error
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Helper functions
-print_info() {
-    echo -e "${BLUE}ℹ${NC} $1"
-}
-
-print_success() {
-    echo -e "${GREEN}✓${NC} $1"
-}
-
-print_warning() {
-    echo -e "${YELLOW}⚠${NC} $1"
-}
-
-print_error() {
-    echo -e "${RED}✗${NC} $1"
-}
-
-print_header() {
-    echo ""
-    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-    echo -e "${BLUE}$1${NC}"
-    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-}
-
-# Usage information
-usage() {
-    cat << EOF
-Usage: $0 <source_env_dir> <target_dir>
-
-Convert an OpenEnv environment from the monorepo to a standalone repository.
-
-Arguments:
-  source_env_dir   Path to existing environment (e.g., src/envs/echo_env)
-  target_dir       Path for new standalone environment (e.g., ~/my_envs/echo_env_standalone)
-
-Example:
-  $0 src/envs/echo_env ~/my_envs/echo_env_standalone
-
-The script will:
-  1. Copy environment files to target directory
-  2. Convert requirements.txt to pyproject.toml
-  3. Add HuggingFace frontmatter to README
-  4. Update Dockerfile for standalone builds
-  5. Initialize git repository
-  6. Generate uv.lock for dependencies
-
-EOF
-    exit 1
-}
-
-# Check arguments
-if [ $# -ne 2 ]; then
-    usage
-fi
-
-SOURCE_DIR="$1"
-TARGET_DIR="$2"
-
-# Validate source directory
-if [ ! -d "$SOURCE_DIR" ]; then
-    print_error "Source directory does not exist: $SOURCE_DIR"
-    exit 1
-fi
-
-# Check if it looks like an OpenEnv environment (either has openenv.yaml or server/ directory)
-if [ ! -f "$SOURCE_DIR/openenv.yaml" ] && [ ! -d "$SOURCE_DIR/server" ]; then
-    print_error "Not an OpenEnv environment (missing openenv.yaml and server/): $SOURCE_DIR"
-    exit 1
-fi
-
-# Warn if it's a legacy environment
-if [ ! -f "$SOURCE_DIR/openenv.yaml" ]; then
-    print_warning "Legacy environment detected (no openenv.yaml) - will create one"
-fi
-
-# Extract environment name from source directory
-ENV_NAME=$(basename "$SOURCE_DIR")
-if [[ "$ENV_NAME" == *"_env" ]]; then
-    BASE_NAME="${ENV_NAME%_env}"
-else
-    BASE_NAME="$ENV_NAME"
-fi
-
-# Convert to class name (capitalize first letter of each word)
-CLASS_NAME=$(echo "$BASE_NAME" | sed -r 's/(^|_)([a-z])/\U\2/g')
-
-print_header "OpenEnv Environment Conversion"
-print_info "Source: $SOURCE_DIR"
-print_info "Target: $TARGET_DIR"
-print_info "Environment: $ENV_NAME"
-print_info "Class Name: $CLASS_NAME"
-
-# Confirm with user
-echo ""
-read -p "Continue with conversion? (y/N): " -n 1 -r
-echo
-if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-    print_info "Conversion cancelled"
-    exit 0
-fi
-
-# Step 1: Copy environment files
-print_header "Step 1: Copying Environment Files"
-
-if [ -d "$TARGET_DIR" ]; then
-    print_warning "Target directory already exists: $TARGET_DIR"
-    read -p "Remove existing directory? (y/N): " -n 1 -r
-    echo
-    if [[ $REPLY =~ ^[Yy]$ ]]; then
-        rm -rf "$TARGET_DIR"
-        print_success "Removed existing directory"
-    else
-        print_error "Cannot proceed with existing directory"
-        exit 1
-    fi
-fi
-
-mkdir -p "$TARGET_DIR"
-cp -r "$SOURCE_DIR"/* "$TARGET_DIR/"
-print_success "Copied environment files to $TARGET_DIR"
-
-cd "$TARGET_DIR"
-
-# Step 1.5: Create openenv.yaml if missing (legacy environments)
-if [ ! -f "openenv.yaml" ]; then
-    print_header "Step 1.5: Creating openenv.yaml"
-    print_info "Legacy environment detected - creating openenv.yaml"
-    
-    cat > openenv.yaml << EOF
-name: ${ENV_NAME}
-version: "0.1.0"
-description: "${BASE_NAME^} environment for OpenEnv"
-action: ${CLASS_NAME}Action
-observation: ${CLASS_NAME}Observation
-EOF
-    
-    print_success "Created openenv.yaml"
-fi
-
-# Step 2: Convert requirements.txt to pyproject.toml
-print_header "Step 2: Setting Up pyproject.toml"
-
-if [ -f "pyproject.toml" ]; then
-    print_success "pyproject.toml already exists"
-else
-    print_info "Creating pyproject.toml"
-    
-    # Collect dependencies from requirements.txt if it exists
-    DEPS=""
-    if [ -f "server/requirements.txt" ]; then
-        print_info "Converting server/requirements.txt to dependencies"
-        while IFS= read -r line; do
-            # Skip empty lines and comments
-            if [[ -n "$line" && ! "$line" =~ ^[[:space:]]*# ]]; then
-                DEPS="${DEPS}    \"${line}\",\n"
-            fi
-        done < "server/requirements.txt"
-    fi
-    
-    # Always add openenv-core
-    DEPS="${DEPS}    \"openenv-core>=0.1.0\","
-    
-    # Create pyproject.toml
-    cat > pyproject.toml << EOF
-[build-system]
-requires = ["setuptools>=45", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "openenv-${ENV_NAME}"
-version = "0.1.0"
-description = "${BASE_NAME^} Environment for OpenEnv"
-requires-python = ">=3.10"
-dependencies = [
-$(echo -e "$DEPS")
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-cov>=4.0.0",
-    "ipykernel>=6.29.5",
-]
-
-[project.scripts]
-server = "${ENV_NAME}.server.app:main"
-
-[tool.setuptools]
-packages = ["${ENV_NAME}"]
-
-[tool.setuptools.package-data]
-${ENV_NAME} = ["**/*.yaml", "**/*.yml"]
-EOF
-    
-    print_success "Created pyproject.toml"
-fi
-
-# Step 3: Add HuggingFace frontmatter to README
-print_header "Step 3: Updating README with HuggingFace Frontmatter"
-
-if [ -f "README.md" ]; then
-    # Check if frontmatter already exists
-    if head -n 1 "README.md" | grep -q "^---$"; then
-        print_success "README.md already has frontmatter"
-    else
-        print_info "Adding HuggingFace frontmatter to README.md"
-        
-        # Create temporary file with frontmatter
-        cat > README.tmp << 'EOF'
----
-title: __TITLE__ Environment Server
-emoji: 🎮
-colorFrom: '#00C9FF'
-colorTo: '#1B2845'
-sdk: docker
-pinned: false
-app_port: 8000
-base_path: /web
-tags:
-  - openenv
----
-
-EOF
-        
-        # Replace placeholder with actual title
-        TITLE="${BASE_NAME^}"
-        sed -i "s/__TITLE__/${TITLE}/g" README.tmp
-        
-        # Append original README content
-        cat "README.md" >> README.tmp
-        mv README.tmp "README.md"
-        
-        print_success "Added HuggingFace frontmatter to README.md"
-    fi
-else
-    print_warning "README.md not found - creating basic one"
-    cat > README.md << EOF
----
-title: ${BASE_NAME^} Environment Server
-emoji: 🎮
-colorFrom: '#00C9FF'
-colorTo: '#1B2845'
-sdk: docker
-pinned: false
-app_port: 8000
-base_path: /web
-tags:
-  - openenv
----
-
-# ${BASE_NAME^} Environment
-
-An OpenEnv environment.
-
-## Quick Start
-
-\`\`\`python
-from ${ENV_NAME} import ${CLASS_NAME}Action, ${CLASS_NAME}Env
-
-# Create environment from Docker image
-env = ${CLASS_NAME}Env.from_docker_image("${ENV_NAME}:latest")
-
-# Reset
-result = env.reset()
-
-# Step
-result = env.step(${CLASS_NAME}Action(...))
-
-# Clean up
-env.close()
-\`\`\`
-
-## Building
-
-\`\`\`bash
-openenv build
-\`\`\`
-
-## Deploying
-
-\`\`\`bash
-openenv push
-\`\`\`
-EOF
-    print_success "Created README.md"
-fi
-
-# Step 4: Update Dockerfile
-print_header "Step 4: Updating Dockerfile for Standalone Builds"
-
-if [ -f "server/Dockerfile" ]; then
-    # Check if Dockerfile already has standalone pattern
-    if grep -q "pip install.*-e \." "server/Dockerfile"; then
-        print_success "Dockerfile already configured for standalone builds"
-    else
-        print_info "Updating Dockerfile for standalone builds"
-        
-        # Create updated Dockerfile
-        cat > server/Dockerfile.new << 'EOF'
-# Base image
-FROM python:3.11-slim
-
-# Set working directory
-WORKDIR /app/env
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy environment files
-COPY . .
-
-# Install Python dependencies
-RUN pip install --no-cache-dir -e .
-
-# Expose port
-EXPOSE 8000
-
-# Set environment variables
-ENV PYTHONUNBUFFERED=1
-ENV ENABLE_WEB_INTERFACE=true
-
-# Run the server
-CMD ["python", "-m", "uvicorn", "__ENV_NAME__.server.app:app", "--host", "0.0.0.0", "--port", "8000"]
-EOF
-        
-        # Replace placeholder
-        sed -i "s/__ENV_NAME__/${ENV_NAME}/g" server/Dockerfile.new
-        
-        # Backup original and replace
-        mv server/Dockerfile server/Dockerfile.backup
-        mv server/Dockerfile.new server/Dockerfile
-        
-        print_success "Updated Dockerfile (backup saved as server/Dockerfile.backup)"
-    fi
-else
-    print_warning "server/Dockerfile not found"
-fi
-
-# Step 5: Ensure app.py has main() function
-print_header "Step 5: Checking server/app.py"
-
-if [ -f "server/app.py" ]; then
-    if grep -q "def main()" "server/app.py"; then
-        print_success "server/app.py has main() function"
-    else
-        print_warning "server/app.py missing main() function - adding it"
-        cat >> server/app.py << 'EOF'
-
-
-def main():
-    """Main entry point for running the server."""
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
-
-
-if __name__ == "__main__":
-    main()
-EOF
-        print_success "Added main() function to server/app.py"
-    fi
-else
-    print_warning "server/app.py not found"
-fi
-
-# Step 6: Create .gitignore
-print_header "Step 6: Creating .gitignore"
-
-cat > .gitignore << 'EOF'
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# Virtual environments
-venv/
-env/
-ENV/
-.venv/
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-.DS_Store
-
-# Testing
-.pytest_cache/
-.coverage
-htmlcov/
-.tox/
-
-# Environment outputs
-outputs/
-logs/
-*.log
-
-# Build artifacts
-*.backup
-EOF
-
-print_success "Created .gitignore"
-
-# Step 7: Initialize git repository
-print_header "Step 7: Initializing Git Repository"
-
-if [ -d ".git" ]; then
-    print_warning "Git repository already initialized"
-else
-    git init
-    git add .
-    git commit -m "Initial commit: Converted from OpenEnv monorepo
-
-Environment: ${ENV_NAME}
-Converted using convert_env.sh script"
-    
-    print_success "Initialized git repository"
-fi
-
-# Step 8: Generate uv.lock (if uv is available)
-print_header "Step 8: Generating Dependency Lock File"
-
-if command -v uv &> /dev/null; then
-    print_info "Generating uv.lock..."
-    if uv lock; then
-        print_success "Generated uv.lock"
-    else
-        print_warning "Failed to generate uv.lock - you may need to fix pyproject.toml dependencies"
-    fi
-else
-    print_warning "uv not found - skipping lock file generation"
-    print_info "Install uv: curl -LsSf https://astral.sh/uv/install.sh | sh"
-fi
-
-# Final summary
-print_header "Conversion Complete!"
-
-echo ""
-print_success "Environment converted successfully!"
-echo ""
-print_info "Next steps:"
-echo ""
-echo "  1. Review the converted files:"
-echo "     cd $TARGET_DIR"
-echo ""
-echo "  2. Install dependencies:"
-echo "     uv pip install -e ."
-echo ""
-echo "  3. Test locally:"
-echo "     uv run server"
-echo ""
-echo "  4. Validate structure:"
-echo "     openenv validate"
-echo ""
-echo "  5. Build Docker image:"
-echo "     openenv build"
-echo ""
-echo "  6. Deploy to HuggingFace:"
-echo "     openenv push"
-echo ""
-echo "  7. Or push to Docker registry:"
-echo "     openenv push --registry docker.io/myusername"
-echo ""
-print_info "For detailed documentation, see CONVERT.md"
-echo ""

openenv/scripts/deploy_to_hf.sh

@@ -1,615 +0,0 @@
-#!/bin/bash
-
-# OpenEnv Hugging Face Deployment Preparation Script
-# This script prepares files for deployment to Hugging Face Spaces
-
-set -euo pipefail
-
-usage() {
-    cat <<'EOF'
-Usage: scripts/deploy_to_hf.sh --env <environment_name> [options]
-
-Required arguments:
-  --env <name>               Environment name under src/envs (e.g. textarena_env)
-
-Optional arguments:
-  --base-sha <sha|tag>       Override openenv-base image reference (defaults to :latest)
-  --hf-namespace <user>      Hugging Face username/organization (defaults to HF_USERNAME or meta-openenv)
-  --staging-dir <path>       Output directory for staging (defaults to hf-staging)
-  --space-suffix <suffix>    Suffix to add to space name (e.g., "-test" for test spaces)
-  --private                   Deploy the space as private (default: public)
-  --dry-run                  Prepare files without pushing to Hugging Face Spaces
-  -h, --help                 Show this help message
-
-Positional compatibility:
-  You can also call the script as:
-    scripts/deploy_to_hf.sh <env_name> [base_image_sha]
-
-Examples:
-  scripts/deploy_to_hf.sh --env textarena_env --hf-namespace my-team
-  scripts/deploy_to_hf.sh echo_env --private --hf-namespace my-org
-EOF
-}
-
-sed_in_place() {
-    local expression="$1"
-    local target_file="$2"
-    if sed --version >/dev/null 2>&1; then
-        sed -i "$expression" "$target_file"
-    else
-        sed -i '' "$expression" "$target_file"
-    fi
-}
-
-SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
-REPO_ROOT=$(cd "$SCRIPT_DIR/.." && pwd)
-cd "$REPO_ROOT"
-
-# Detect if we're running in GitHub Actions
-IS_GITHUB_ACTIONS=false
-if [ -n "${GITHUB_ACTIONS:-}" ]; then
-    IS_GITHUB_ACTIONS=true
-fi
-
-# Check for hf CLI - but allow dry-run mode to work without it
-if ! command -v hf >/dev/null 2>&1; then
-    echo "Warning: huggingface-hub CLI 'hf' not found in PATH." >&2
-    echo "Install the HF CLI: curl -LsSf https://hf.co/cli/install.sh | sh" >&2
-    if [ "${1:-}" != "--dry-run" ] && [ "${2:-}" != "--dry-run" ]; then
-        echo "Error: hf is required for deployment (use --dry-run to skip deployment)" >&2
-        exit 1
-    fi
-fi
-
-ENV_NAME=""
-BASE_IMAGE_SHA=""
-HF_NAMESPACE="${HF_NAMESPACE:-}"  # Initialize from env var if set, otherwise empty
-STAGING_DIR="hf-staging"
-SPACE_SUFFIX=""
-PRIVATE=false
-DRY_RUN=false
-HUB_TAG="openenv"
-
-while [[ $# -gt 0 ]]; do
-    case "$1" in
-        --env)
-            ENV_NAME="$2"
-            shift 2
-            ;;
-        --hub-tag)
-            HUB_TAG="$2"
-            shift 2
-            ;;
-        --base-sha|--base-image-sha)
-            BASE_IMAGE_SHA="$2"
-            shift 2
-            ;;
-        --namespace|--hf-namespace|--hf-user|--hf-username)
-            HF_NAMESPACE="$2"
-            shift 2
-            ;;
-        --staging-dir)
-            STAGING_DIR="$2"
-            shift 2
-            ;;
-        --suffix|--space-suffix)
-            SPACE_SUFFIX="$2"
-            shift 2
-            ;;
-        --private)
-            PRIVATE=true
-            shift
-            ;;
-        --dry-run)
-            DRY_RUN=true
-            shift
-            ;;
-        -h|--help)
-            usage
-            exit 0
-            ;;
-        --)
-            shift
-            break
-            ;;
-        -* )
-            echo "Unknown option: $1" >&2
-            usage
-            exit 1
-            ;;
-        *)
-            if [ -z "$ENV_NAME" ]; then
-                ENV_NAME="$1"
-            elif [ -z "$BASE_IMAGE_SHA" ]; then
-                BASE_IMAGE_SHA="$1"
-            else
-                echo "Unexpected positional argument: $1" >&2
-                usage
-                exit 1
-            fi
-            shift
-            ;;
-    esac
-done
-
-if [ -z "$HUB_TAG" ]; then
-    HUB_TAG="openenv"
-fi
-
-if [ -z "$ENV_NAME" ]; then
-    echo "Error: Environment name is required" >&2
-    usage
-    exit 1
-fi
-
-if [[ "$ENV_NAME" == *","* || "$ENV_NAME" == *" "* ]]; then
-    echo "Error: only one environment can be deployed per invocation (received '$ENV_NAME')." >&2
-    exit 1
-fi
-
-if [ ! -d "src/envs/$ENV_NAME" ]; then
-    echo "Error: Environment '$ENV_NAME' not found under src/envs" >&2
-    exit 1
-fi
-
-# Try to get HF_USERNAME, but handle failures gracefully (especially in CI before auth)
-if command -v hf >/dev/null 2>&1; then
-    HF_USERNAME=$(hf auth whoami 2>/dev/null | head -n1 | tr -d '\n' || echo "")
-fi
-
-if [ -z "$HF_NAMESPACE" ]; then
-    # Check HF_USERNAME (env var or detected from CLI)
-    if [ -n "${HF_USERNAME:-}" ]; then
-        HF_NAMESPACE="${HF_USERNAME}"
-    else
-        HF_NAMESPACE="meta-openenv"
-    fi
-fi
-
-echo "🙋 Using namespace: $HF_NAMESPACE. You can override with --hf-namespace"
-
-# Set base image reference (using GHCR)
-if [ -n "$BASE_IMAGE_SHA" ]; then
-    BASE_IMAGE_REF="ghcr.io/meta-pytorch/openenv-base:$BASE_IMAGE_SHA"
-    echo "Using specific SHA for openenv-base: $BASE_IMAGE_SHA"
-else
-    BASE_IMAGE_REF="ghcr.io/meta-pytorch/openenv-base:latest"
-fi
-
-# Create staging directory
-CURRENT_STAGING_DIR="${STAGING_DIR}/${HF_NAMESPACE}/${ENV_NAME}"
-# Ensure clean staging directory
-rm -rf "$CURRENT_STAGING_DIR"
-mkdir -p "$CURRENT_STAGING_DIR/src/core"
-mkdir -p "$CURRENT_STAGING_DIR/src/envs/$ENV_NAME"
-
-# Copy core files
-cp -R src/core/* "$CURRENT_STAGING_DIR/src/core/"
-
-# Copy environment files
-cp -R src/envs/$ENV_NAME/* "$CURRENT_STAGING_DIR/src/envs/$ENV_NAME/"
-
-echo "📁 Copied core and $ENV_NAME environment files to $CURRENT_STAGING_DIR"
-
-# Create environment-specific multi-stage Dockerfile
-create_environment_dockerfile() {
-    local env_name=$1
-    
-    # Create base Dockerfile
-    cat > "$CURRENT_STAGING_DIR/Dockerfile" << DOCKERFILE_EOF
-# 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.
-
-# Use the specified openenv-base image
-FROM $BASE_IMAGE_REF
-DOCKERFILE_EOF
-
-    # Add environment-specific dependencies
-    case $env_name in
-        "echo_env")
-            # Echo environment needs no additional dependencies
-            ;;
-        "coding_env")
-            cat >> "$CURRENT_STAGING_DIR/Dockerfile" << 'DOCKERFILE_EOF'
-# Install smolagents for code execution
-RUN pip install --no-cache-dir smolagents
-DOCKERFILE_EOF
-            ;;
-        "chat_env")
-            cat >> "$CURRENT_STAGING_DIR/Dockerfile" << 'DOCKERFILE_EOF'
-# Install additional dependencies for ChatEnvironment
-RUN pip install --no-cache-dir torch transformers
-
-# Set up cache directory for Hugging Face models
-RUN mkdir -p /.cache && chmod 777 /.cache
-ENV HF_HOME=/.cache
-ENV TRANSFORMERS_CACHE=/.cache
-
-# Pre-download the GPT-2 model to avoid permission issues during runtime
-RUN python -c "from transformers import GPT2Tokenizer; GPT2Tokenizer.from_pretrained('gpt2')"
-DOCKERFILE_EOF
-            ;;
-        "atari_env")
-            cat >> "$CURRENT_STAGING_DIR/Dockerfile" << 'DOCKERFILE_EOF'
-# Install ALE-specific dependencies
-RUN pip install --no-cache-dir \
-    gymnasium>=0.29.0 \
-    ale-py>=0.8.0 \
-    numpy>=1.24.0
-DOCKERFILE_EOF
-            ;;
-        "textarena_env")
-            cat >> "$CURRENT_STAGING_DIR/Dockerfile" << 'DOCKERFILE_EOF'
-# Install system libraries required by TextArena
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    libgl1 \
-    libglib2.0-0 \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install TextArena and supporting Python packages
-RUN pip install --no-cache-dir \
-    textarena==0.6.1 \
-    nltk==3.9.2
-DOCKERFILE_EOF
-            ;;
-        "openspiel_env")
-            # OpenSpiel requires special C++ build process - replace entire Dockerfile
-            cat > "$CURRENT_STAGING_DIR/Dockerfile" << DOCKERFILE_EOF
-# OpenSpiel environment using pre-built OpenSpiel base image
-ARG OPENSPIEL_BASE_IMAGE=ghcr.io/meta-pytorch/openenv-openspiel-base:sha-e622c7e
-FROM \${OPENSPIEL_BASE_IMAGE}
-
-# Copy OpenEnv core (base image already set WORKDIR=/app)
-WORKDIR /app
-COPY src/core/ /app/src/core/
-
-# Copy OpenSpiel environment
-COPY src/envs/openspiel_env/ /app/src/envs/openspiel_env/
-
-# Extend Python path for OpenEnv (base image set PYTHONPATH=/app/src)
-# We prepend OpenSpiel paths
-ENV PYTHONPATH=/repo:/repo/build/python:/app/src
-
-# OpenSpiel-specific environment variables (can be overridden at runtime)
-ENV OPENSPIEL_GAME=catch
-ENV OPENSPIEL_AGENT_PLAYER=0
-ENV OPENSPIEL_OPPONENT_POLICY=random
-
-# Health check (curl is provided by openenv-base)
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:8000/health || exit 1
-
-# Note: EXPOSE 8000 already set by openenv-base
-
-# Run the FastAPI server (uvicorn installed by openenv-base)
-CMD ["uvicorn", "envs.openspiel_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]
-DOCKERFILE_EOF
-            echo "Created special OpenSpiel Dockerfile with C++ build process"
-            echo "OpenSpiel builds can take 10-15 minutes due to C++ compilation"
-            return  # Skip the common parts since OpenSpiel has its own complete Dockerfile
-            ;;
-    esac
-
-    # Add common parts
-    cat >> "$CURRENT_STAGING_DIR/Dockerfile" << 'DOCKERFILE_EOF'
-
-# Copy only what's needed for this environment
-COPY src/core/ /app/src/core/
-COPY src/envs/ENV_NAME_PLACEHOLDER/ /app/src/envs/ENV_NAME_PLACEHOLDER/
-
-# 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.ENV_NAME_PLACEHOLDER.server.app:app", "--host", "0.0.0.0", "--port", "8000"]
-DOCKERFILE_EOF
-
-    # Replace placeholder with actual environment name
-    sed_in_place "s/ENV_NAME_PLACEHOLDER/$env_name/g" "$CURRENT_STAGING_DIR/Dockerfile"
-}
-
-create_environment_dockerfile "$ENV_NAME"
-
-# Add web interface support
-echo "ENV ENABLE_WEB_INTERFACE=true" >> $CURRENT_STAGING_DIR/Dockerfile
-
-# Create environment-specific README
-create_readme() {
-    local env_name=$1
-    
-    # Capitalize first letter of environment name
-    env_title=$(echo "$env_name" | awk '{print toupper(substr($0,1,1)) substr($0,2)}')
-    
-    # Set environment-specific colors and emoji
-    case $env_name in
-        "atari_env")
-            EMOJI="🕹️"
-            COLOR_FROM="red"
-            COLOR_TO="yellow"
-            ;;
-        "coding_env")
-            EMOJI="💻"
-            COLOR_FROM="blue"
-            COLOR_TO="gray"
-            ;;
-        "openspiel_env")
-            EMOJI="🎮"
-            COLOR_FROM="purple"
-            COLOR_TO="indigo"
-            ;;
-        "echo_env")
-            EMOJI="🔊"
-            COLOR_FROM="blue"
-            COLOR_TO="gray"
-            ;;
-        "chat_env")
-            EMOJI="💬"
-            COLOR_FROM="blue"
-            COLOR_TO="green"
-            ;;
-        "textarena_env")
-            EMOJI="📜"
-            COLOR_FROM="green"
-            COLOR_TO="blue"
-            ;;
-        *)
-            EMOJI="🐳"
-            COLOR_FROM="blue"
-            COLOR_TO="green"
-            ;;
-    esac
-
-    cat > "$CURRENT_STAGING_DIR/README.md" << README_EOF
----
-title: ${env_title} Environment Server
-emoji: ${EMOJI}
-colorFrom: ${COLOR_FROM}
-colorTo: ${COLOR_TO}
-sdk: docker
-pinned: false
-app_port: 8000
-base_path: /web
-tags:
-  - ${HUB_TAG}
----
-
-# ${env_title} Environment Server
-
-FastAPI server for ${env_name} environment powered by Meta's OpenEnv.
-
-## About
-
-This Space provides a containerized environment for ${env_name} interactions.
-Built with FastAPI and OpenEnv framework.
-
-## Web Interface
-
-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
-
-Access the web interface at: \`/web\`
-
-README_EOF
-
-    # Add environment-specific information
-    case $env_name in
-        "echo_env")
-            cat >> "$CURRENT_STAGING_DIR/README.md" << 'README_EOF'
-## Echo Environment
-
-Simple test environment that echoes back messages. Perfect for testing the OpenEnv APIs.
-
-### Usage
-Send a POST request to `/step` with:
-```json
-{
-  "message": "Hello World"
-}
-```
-README_EOF
-            ;;
-        "coding_env")
-            cat >> "$CURRENT_STAGING_DIR/README.md" << 'README_EOF'
-## Coding Environment
-
-Executes Python code in a sandboxed environment with safety checks.
-
-### Usage
-Send a POST request to `/step` with:
-```json
-{
-  "code": "print('Hello World')"
-}
-```
-README_EOF
-            ;;
-        "chat_env")
-            cat >> "$CURRENT_STAGING_DIR/README.md" << 'README_EOF'
-## Chat Environment
-
-Provides a chat-based interface for LLMs with tokenization support.
-
-### Usage
-Send a POST request to `/step` with tokenized input:
-```json
-{
-  "tokens": [1, 2, 3, 4, 5]
-}
-```
-README_EOF
-            ;;
-        "atari_env")
-            cat >> "$CURRENT_STAGING_DIR/README.md" << 'README_EOF'
-## Atari Environment
-
-Provides Atari 2600 games via the Arcade Learning Environment (ALE).
-
-### Usage
-Send a POST request to `/step` with:
-```json
-{
-  "action_id": 0,
-  "game_name": "pong"
-}
-```
-README_EOF
-            ;;
-        "openspiel_env")
-            cat >> "$CURRENT_STAGING_DIR/README.md" << 'README_EOF'
-## OpenSpiel Environment
-
-Provides access to OpenSpiel games for multi-agent reinforcement learning.
-
-### Usage
-Send a POST request to `/step` with:
-```json
-{
-  "action": {
-    "action_id": 1
-  }
-}
-```
-README_EOF
-            ;;
-        "textarena_env")
-            cat >> "$CURRENT_STAGING_DIR/README.md" << 'README_EOF'
-## TextArena Environment
-
-Runs TextArena games such as Wordle, GuessTheNumber, or Chess through a unified HTTP API.
-
-### Usage
-Send a POST request to `/step` with:
-```json
-{
-  "message": "raise shield"
-}
-```
-README_EOF
-            ;;
-        *)
-            cat >> "$CURRENT_STAGING_DIR/README.md" << 'README_EOF'
-
-## API Documentation
-
-Visit `/docs` for interactive API documentation.
-
-## Health Check
-
-The environment provides a health check endpoint at `/health`.
-README_EOF
-            ;;
-    esac
-}
-
-create_readme "$ENV_NAME"
-echo "📝 Created README and web interface support for HF Space"
-
-if $DRY_RUN; then
-    echo "👀 Dry run enabled; skipping Hugging Face upload."
-    exit 0
-fi
-
-echo "🔑 Ensuring Hugging Face authentication..."
-
-# Set up authentication based on environment
-TOKEN_ARGS=()
-if [ "$IS_GITHUB_ACTIONS" = true ]; then
-    if [ -z "${HF_TOKEN:-}" ]; then
-        echo "Error: HF_TOKEN secret is required in GitHub Actions" >&2
-        echo "Please set the HF_TOKEN secret in repository settings" >&2
-        exit 1
-    fi
-    echo "Using HF_TOKEN from GitHub Actions environment"
-    # In CI, pass token directly to commands via --token flag
-    TOKEN_ARGS=(--token "$HF_TOKEN")
-elif [ -n "${HF_TOKEN:-}" ]; then
-    # If HF_TOKEN is set locally, use it
-    echo "Using HF_TOKEN environment variable"
-    TOKEN_ARGS=(--token "$HF_TOKEN")
-else
-    # Interactive mode: check if user is authenticated
-    if ! hf auth whoami >/dev/null 2>&1; then
-        echo "Not authenticated. Please login to Hugging Face..."
-        hf auth login
-        if ! hf auth whoami >/dev/null 2>&1; then
-            echo "Error: Hugging Face authentication failed" >&2
-            exit 1
-        fi
-    fi
-fi
-
-# Verify authentication works (skip in CI if using token directly)
-if [ ${#TOKEN_ARGS[@]} -eq 0 ]; then
-    if ! hf auth whoami >/dev/null 2>&1; then
-        echo "Error: Not authenticated with Hugging Face" >&2
-        echo "Run 'hf auth login' or set HF_TOKEN environment variable" >&2
-        exit 1
-    fi
-    CURRENT_USER=$(hf auth whoami | head -n1 | tr -d '\n')
-    echo "✅ Authenticated as: $CURRENT_USER"
-    if [ "$CURRENT_USER" != "$HF_NAMESPACE" ]; then
-        echo "⚠️  Deploying to namespace '$HF_NAMESPACE' (different from your user '$CURRENT_USER')"
-    fi
-else
-    echo "✅ Token configured for deployment"
-fi
-
-SPACE_REPO="${HF_NAMESPACE}/${ENV_NAME}${SPACE_SUFFIX}"
-
-# Get absolute path to staging directory
-if [ ! -d "$CURRENT_STAGING_DIR" ]; then
-    echo "Error: Staging directory not found: $CURRENT_STAGING_DIR" >&2
-    exit 1
-fi
-CURRENT_STAGING_DIR_ABS=$(cd "$CURRENT_STAGING_DIR" && pwd)
-
-# Determine privacy flag (only add --private if needed, default is public)
-PRIVATE_FLAG=""
-if [ "$PRIVATE" = true ]; then
-    PRIVATE_FLAG="--private"
-fi
-
-echo "Creating space: $SPACE_REPO"
-echo "Command: hf repo create $SPACE_REPO --repo-type space --space-sdk docker --exist-ok $PRIVATE_FLAG ${TOKEN_ARGS[@]+"${TOKEN_ARGS[@]}"}"
-# create the space if it doesn't exist
-# Temporarily disable exit-on-error for this command
-set +e
-CREATE_OUTPUT=$(hf repo create "$SPACE_REPO" --repo-type space --space-sdk docker --exist-ok $PRIVATE_FLAG ${TOKEN_ARGS[@]+"${TOKEN_ARGS[@]}"} 2>&1)
-CREATE_EXIT_CODE=$?
-set -e
-if [ $CREATE_EXIT_CODE -ne 0 ]; then
-    echo "❌ Space creation failed with exit code $CREATE_EXIT_CODE" >&2
-    echo "Error output:" >&2
-    echo "$CREATE_OUTPUT" >&2
-    echo "" >&2
-fi
-
-echo "Uploading files to space: $SPACE_REPO"
-echo "Command: hf upload --repo-type=space $PRIVATE_FLAG ${TOKEN_ARGS[@]+"${TOKEN_ARGS[@]}"} $SPACE_REPO $CURRENT_STAGING_DIR_ABS"
-# upload the staged content (if repo doesn't exist, it will be created with the privacy setting)
-SPACE_UPLOAD_RESULT=$(hf upload --repo-type=space $PRIVATE_FLAG ${TOKEN_ARGS[@]+"${TOKEN_ARGS[@]}"} "$SPACE_REPO" "$CURRENT_STAGING_DIR_ABS" 2>&1)
-UPLOAD_EXIT_CODE=$?
-if [ $UPLOAD_EXIT_CODE -ne 0 ]; then
-    echo "❌ Upload failed with exit code $UPLOAD_EXIT_CODE" >&2
-    echo "Error output:" >&2
-    echo "$SPACE_UPLOAD_RESULT" >&2
-    echo "" >&2
-    echo "  Space: $SPACE_REPO" >&2
-    echo "  Staging dir: $CURRENT_STAGING_DIR_ABS" >&2
-    echo "  Files to upload:" >&2
-    ls -la "$CURRENT_STAGING_DIR_ABS" >&2 || true
-    exit 1
-fi
-# print the URL of the deployed space
-echo "✅ Upload completed for https://huggingface.co/spaces/$SPACE_REPO"
-
-# Cleanup the staging directory after successful deployment
-if [ -d "$CURRENT_STAGING_DIR_ABS" ]; then
-    rm -rf "$CURRENT_STAGING_DIR_ABS"
-fi

openenv/scripts/manage_hf_collection.py

@@ -1,296 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hugging Face Collection Manager for OpenEnv
-
-This script automatically discovers Docker Spaces tagged with 'openenv' on Hugging Face
-and adds them to the Environment Hub collection if they're not already present.
-
-Usage:
-    python scripts/manage_hf_collection.py [--dry-run] [--verbose]
-
-Environment Variables:
-    HF_TOKEN: Required. Your Hugging Face API token with write access to collections.
-"""
-
-import argparse
-import logging
-import os
-import sys
-from typing import Set, List
-from huggingface_hub import HfApi, list_spaces
-from huggingface_hub.utils import HfHubHTTPError
-
-
-# Constants
-COLLECTION_SLUG = "openenv/environment-hub-68f16377abea1ea114fa0743"
-TAG_FILTER = "openenv"
-SPACE_TYPE = "docker"
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    datefmt='%Y-%m-%d %H:%M:%S'
-)
-logger = logging.getLogger(__name__)
-
-
-def setup_api() -> HfApi:
-    """
-    Initialize and authenticate the Hugging Face API client.
-    
-    Returns:
-        HfApi: Authenticated API client
-        
-    Raises:
-        SystemExit: If HF_TOKEN is not set
-    """
-    hf_token = os.environ.get('HF_TOKEN')
-    
-    if not hf_token:
-        logger.error("HF_TOKEN environment variable is not set!")
-        logger.error("Please set it with: export HF_TOKEN=your_token_here")
-        sys.exit(1)
-    
-    logger.info("Authenticating with Hugging Face...")
-    api = HfApi(token=hf_token)
-    
-    try:
-        whoami = api.whoami()
-        logger.info(f"✓ Authenticated as: {whoami['name']}")
-    except Exception as e:
-        logger.error(f"Failed to authenticate with Hugging Face: {e}")
-        sys.exit(1)
-    
-    return api
-
-
-def get_collection_spaces(api: HfApi) -> Set[str]:
-    """
-    Retrieve the list of spaces currently in the Environment Hub collection.
-    
-    Args:
-        api: Authenticated HfApi client
-        
-    Returns:
-        Set of space IDs (in format "owner/space-name")
-    """
-    logger.info(f"Fetching current collection: {COLLECTION_SLUG}")
-    
-    try:
-        collection = api.get_collection(COLLECTION_SLUG)
-        
-        # Extract space IDs from collection items
-        space_ids = set()
-        for item in collection.items:
-            if item.item_type == "space":
-                space_ids.add(item.item_id)
-        
-        logger.info(f"✓ Found {len(space_ids)} spaces in collection")
-        return space_ids
-        
-    except HfHubHTTPError as e:
-        if e.response.status_code == 404:
-            logger.error(f"Collection not found: {COLLECTION_SLUG}")
-            logger.error("Please ensure the collection exists and you have access to it")
-        else:
-            logger.error(f"Error fetching collection: {e}")
-        sys.exit(1)
-    except Exception as e:
-        logger.error(f"Unexpected error fetching collection: {e}")
-        sys.exit(1)
-
-
-def discover_openenv_spaces(api: HfApi) -> List[str]:
-    """
-    Search for all Docker Spaces tagged with 'openenv'.
-    
-    Args:
-        api: Authenticated HfApi client
-        
-    Returns:
-        List of space IDs (in format "owner/space-name")
-    """
-    logger.info(f"Searching for Docker Spaces with tag '{TAG_FILTER}'...")
-    
-    try:
-        # List all spaces with the openenv tag using search parameter
-        spaces = list(list_spaces(
-            search=TAG_FILTER,
-            full=False,
-            sort="trending_score",
-            direction=-1
-        ))
-        
-        # Filter for Docker spaces with the openenv tag
-        # Note: search may return spaces that mention 'openenv' in description too,
-        # so we need to verify the tag is actually present
-        docker_spaces_with_tag = []
-        for space in spaces:
-            # Get full space info to check tags
-            try:
-                space_info = api.space_info(space.id)
-                # Check if it's a Docker space and has the openenv tag
-                if (hasattr(space_info, 'sdk') and space_info.sdk == 'docker' and
-                    hasattr(space_info, 'tags') and TAG_FILTER in space_info.tags and 
-                    space_info.runtime.stage != "RUNTIME_ERROR"):
-                    docker_spaces_with_tag.append(space.id)
-            except Exception as e:
-                logger.warning(f"Could not fetch info for space {space.id}: {e}")
-                continue
-        
-        logger.info(f"✓ Discovered {len(docker_spaces_with_tag)} Docker spaces with tag '{TAG_FILTER}'")
-        
-        return docker_spaces_with_tag
-        
-    except Exception as e:
-        logger.error(f"Error discovering spaces: {e}")
-        sys.exit(1)
-
-
-def add_spaces_to_collection(
-    api: HfApi,
-    space_ids: List[str],
-    dry_run: bool = False
-) -> int:
-    """
-    Add new spaces to the Environment Hub collection.
-    
-    Args:
-        api: Authenticated HfApi client
-        space_ids: List of space IDs to add
-        dry_run: If True, only simulate the addition without making changes
-        
-    Returns:
-        Number of spaces added (or would be added in dry-run mode)
-    """
-    if not space_ids:
-        logger.info("No new spaces to add")
-        return 0
-    
-    added_count = 0
-    failed_count = 0
-    
-    for space_id in space_ids:
-        if dry_run:
-            logger.info(f"[DRY RUN] Would add space: {space_id}")
-            added_count += 1
-        else:
-            try:
-                logger.info(f"Adding space to collection: {space_id}")
-                api.add_collection_item(
-                    collection_slug=COLLECTION_SLUG,
-                    item_id=space_id,
-                    item_type="space"
-                )
-                logger.info(f"✓ Successfully added: {space_id}")
-                added_count += 1
-            except HfHubHTTPError as e:
-                if e.response.status_code == 409:
-                    # Space already in collection (race condition)
-                    logger.warning(f"Space already in collection: {space_id}")
-                else:
-                    logger.error(f"Failed to add {space_id}: {e}")
-                    failed_count += 1
-            except Exception as e:
-                logger.error(f"Unexpected error adding {space_id}: {e}")
-                failed_count += 1
-    
-    if failed_count > 0:
-        logger.warning(f"Failed to add {failed_count} spaces")
-    
-    return added_count
-
-
-def main():
-    """Main execution function."""
-    parser = argparse.ArgumentParser(
-        description="Manage Hugging Face Environment Hub collection for OpenEnv spaces",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Run in dry-run mode to preview changes
-  python scripts/manage_hf_collection.py --dry-run --verbose
-  
-  # Run for real to add spaces to collection
-  python scripts/manage_hf_collection.py
-  
-  # View verbose output
-  python scripts/manage_hf_collection.py --verbose
-
-Environment Variables:
-  HF_TOKEN: Required. Your Hugging Face API token.
-        """
-    )
-    
-    parser.add_argument(
-        '--dry-run',
-        action='store_true',
-        help='Preview changes without modifying the collection'
-    )
-    
-    parser.add_argument(
-        '--verbose',
-        action='store_true',
-        help='Enable verbose logging output'
-    )
-    
-    args = parser.parse_args()
-    
-    # Set logging level
-    if args.verbose:
-        logger.setLevel(logging.DEBUG)
-        logger.debug("Verbose logging enabled")
-    
-    if args.dry_run:
-        logger.info("=" * 60)
-        logger.info("DRY RUN MODE - No changes will be made")
-        logger.info("=" * 60)
-    
-    # Step 1: Setup API
-    api = setup_api()
-    
-    # Step 2: Get current collection spaces
-    current_spaces = get_collection_spaces(api)
-    
-    if args.verbose:
-        logger.debug(f"Current spaces in collection: {sorted(current_spaces)}")
-    
-    # Step 3: Discover all openenv spaces
-    discovered_spaces = discover_openenv_spaces(api)
-    
-    if args.verbose:
-        logger.debug(f"Discovered spaces: {sorted(discovered_spaces)}")
-    
-    # Step 4: Find new spaces not yet in collection
-    new_spaces = [s for s in discovered_spaces if s not in current_spaces]
-    
-    logger.info("=" * 60)
-    logger.info(f"Summary:")
-    logger.info(f"  Total spaces in collection: {len(current_spaces)}")
-    logger.info(f"  Total spaces discovered: {len(discovered_spaces)}")
-    logger.info(f"  New spaces to add: {len(new_spaces)}")
-    logger.info("=" * 60)
-    
-    if new_spaces:
-        logger.info(f"New spaces found:")
-        for space in new_spaces:
-            logger.info(f"  - {space}")
-    
-    # Step 5: Add new spaces to collection
-    added_count = add_spaces_to_collection(api, new_spaces, dry_run=args.dry_run)
-    
-    # Final summary
-    logger.info("=" * 60)
-    if args.dry_run:
-        logger.info(f"[DRY RUN] Would add {added_count} new spaces to collection")
-    else:
-        logger.info(f"✓ Successfully added {added_count} new spaces to collection")
-    logger.info("=" * 60)
-    
-    logger.info(f"Collection URL: https://huggingface.co/collections/{COLLECTION_SLUG}")
-
-
-if __name__ == "__main__":
-    main()
-

openenv/scripts/prepare_hf_deployment.sh

@@ -1,170 +0,0 @@
-#!/bin/bash
-
-# OpenEnv Hugging Face Deployment Preparation Script
-# This script prepares files for deployment to Hugging Face Spaces
-
-set -e
-
-# Cross-platform sed in-place editing
-# BSD sed (macOS) requires -i '', GNU sed (Linux) requires -i
-sed_inplace() {
-    if sed --version >/dev/null 2>&1; then
-        # GNU sed
-        sed -i "$@"
-    else
-        # BSD sed
-        sed -i '' "$@"
-    fi
-}
-
-ENV_NAME="$1"
-BASE_IMAGE_SHA="$2"
-STAGING_DIR="hf-staging"
-
-if [ -z "$ENV_NAME" ]; then
-    echo "Error: Environment name is required"
-    exit 1
-fi
-
-# Validate environment name
-ENV_NAMES="$ENV_NAME"
-
-# Set base image reference (using GHCR)
-if [ -n "$BASE_IMAGE_SHA" ]; then
-    BASE_IMAGE_REF="ghcr.io/meta-pytorch/openenv-base:$BASE_IMAGE_SHA"
-    echo "Using specific SHA for openenv-base: $BASE_IMAGE_SHA"
-else
-    BASE_IMAGE_REF="ghcr.io/meta-pytorch/openenv-base:latest"
-    echo "Using latest tag for openenv-base"
-fi
-
-echo "Preparing $ENV_NAME environment for deployment..."
-
-# Create staging directory
-CURRENT_STAGING_DIR="${STAGING_DIR}_${ENV_NAME}"
-mkdir -p $CURRENT_STAGING_DIR/src/core
-mkdir -p $CURRENT_STAGING_DIR/src/envs/$ENV_NAME
-
-# Copy core files
-cp -r src/core/* $CURRENT_STAGING_DIR/src/core/
-echo "Copied core files"
-
-# Copy environment files
-cp -r src/envs/$ENV_NAME/* $CURRENT_STAGING_DIR/src/envs/$ENV_NAME/
-echo "Copied $ENV_NAME environment files"
-
-# Copy and modify the static Dockerfile from the environment
-create_environment_dockerfile() {
-    local env_name=$1
-    local dockerfile_path="src/envs/$env_name/server/Dockerfile"
-    local prepare_script="src/envs/$env_name/server/prepare_hf.sh"
-
-    if [ ! -f "$dockerfile_path" ]; then
-        echo "Error: Dockerfile not found at $dockerfile_path"
-        exit 1
-    fi
-
-    # Copy the static Dockerfile
-    cp "$dockerfile_path" "$CURRENT_STAGING_DIR/Dockerfile"
-    echo "Copied static Dockerfile from $dockerfile_path"
-
-    # Check if environment has custom HF preparation script
-    if [ -f "$prepare_script" ]; then
-        echo "Found custom HF preparation script, executing..."
-        chmod +x "$prepare_script"
-        "$prepare_script" "$CURRENT_STAGING_DIR/Dockerfile" "$BASE_IMAGE_REF"
-    else
-        # Standard Dockerfile modification: replace ARG BASE_IMAGE with FROM
-        sed_inplace "s|ARG BASE_IMAGE=.*||g" "$CURRENT_STAGING_DIR/Dockerfile"
-        sed_inplace "s|FROM \${BASE_IMAGE}|FROM $BASE_IMAGE_REF|g" "$CURRENT_STAGING_DIR/Dockerfile"
-        echo "Modified Dockerfile with base image: $BASE_IMAGE_REF"
-    fi
-
-    # Add web interface support before the final CMD
-    # Use awk for cross-platform compatibility
-    awk '/^CMD \[/{print "ENV ENABLE_WEB_INTERFACE=true\n"; print; next} 1' "$CURRENT_STAGING_DIR/Dockerfile" > "$CURRENT_STAGING_DIR/Dockerfile.tmp"
-    mv "$CURRENT_STAGING_DIR/Dockerfile.tmp" "$CURRENT_STAGING_DIR/Dockerfile"
-    echo "Enabled web interface"
-}
-
-create_environment_dockerfile $ENV_NAME
-
-# Copy and prepend HF-specific intro to README
-create_readme() {
-    local env_name=$1
-    local readme_source="src/envs/$env_name/README.md"
-
-    if [ ! -f "$readme_source" ]; then
-        echo "Error: README not found at $readme_source"
-        exit 1
-    fi
-
-    # Check if README already has HF front matter
-    if head -n 1 "$readme_source" | grep -q "^---$"; then
-        echo "README has HF front matter, inserting HF deployment section after it"
-
-        # Find the line number of the closing --- (second occurrence)
-        local closing_line=$(grep -n "^---$" "$readme_source" | sed -n '2p' | cut -d: -f1)
-
-        if [ -z "$closing_line" ]; then
-            echo "Error: Could not find closing --- in front matter"
-            exit 1
-        fi
-
-        # Split the README: front matter + rest
-        head -n "$closing_line" "$readme_source" > "$CURRENT_STAGING_DIR/README.md"
-
-        # Add HF-specific deployment info right after front matter
-        cat >> $CURRENT_STAGING_DIR/README.md << 'README_EOF'
-
-## 🚀 Hugging Face Space Deployment
-
-This is a Hugging Face Space deployment of the OpenEnv environment. It includes:
-
-- **Web Interface** at `/web` - Interactive UI for exploring the environment
-- **API Documentation** at `/docs` - Full OpenAPI/Swagger interface
-- **Health Check** at `/health` - Container health monitoring
-
-### Connecting from Code
-
-```python
-from envs.ENV_NAME_PLACEHOLDER import ENV_CLASS_PLACEHOLDER
-
-# Connect to this HF Space
-env = ENV_CLASS_PLACEHOLDER(base_url="https://huggingface.co/spaces/openenv/ENV_NAME_PLACEHOLDER")
-
-# Use the environment
-result = env.reset()
-result = env.step(action)
-```
-
-For full documentation, see the [OpenEnv repository](https://github.com/meta-pytorch/OpenEnv).
-
-README_EOF
-
-        # Append the rest of the original README (skip front matter)
-        tail -n "+$((closing_line + 1))" "$readme_source" >> "$CURRENT_STAGING_DIR/README.md"
-    else
-        echo "Error: README missing HF front matter at $readme_source"
-        echo "Please add YAML front matter to the environment README"
-        exit 1
-    fi
-
-    # Set environment-specific class name
-    case $env_name in
-        "echo_env") ENV_CLASS="EchoEnv" ;;
-        "coding_env") ENV_CLASS="CodingEnv" ;;
-        "chat_env") ENV_CLASS="ChatEnv" ;;
-        "atari_env") ENV_CLASS="AtariEnv" ;;
-        "openspiel_env") ENV_CLASS="OpenSpielEnv" ;;
-        *) ENV_CLASS="Env" ;;
-    esac
-
-    # Replace placeholders (cross-platform)
-    sed_inplace "s/ENV_NAME_PLACEHOLDER/$env_name/g" "$CURRENT_STAGING_DIR/README.md"
-    sed_inplace "s/ENV_CLASS_PLACEHOLDER/$ENV_CLASS/g" "$CURRENT_STAGING_DIR/README.md"
-}
-
-create_readme $ENV_NAME
-echo "Copied and enhanced README for HF Space"
-echo "Completed preparation for $ENV_NAME environment"

openenv/scripts/setup_shared_gitea.sh

@@ -1,83 +0,0 @@
-#!/bin/bash
-# Setup script for shared Gitea instance
-# This script starts Gitea, waits for it to be ready, and creates the admin user
-# Requires: .env file with GITEA_USERNAME and GITEA_PASSWORD
-
-set -e
-
-# Load credentials from .env file
-if [ -f .env ]; then
-    export $(cat .env | grep -E '^(GITEA_USERNAME|GITEA_PASSWORD)=' | xargs)
-else
-    echo "❌ Error: .env file not found"
-    echo "   Please copy .env.example to .env and configure credentials"
-    exit 1
-fi
-
-echo "====================================="
-echo "Setting up shared Gitea instance"
-echo "====================================="
-echo
-
-# Start Gitea with docker-compose
-echo "1. Starting Gitea container..."
-docker-compose -f src/envs/git_env/docker-compose.gitea.yml up -d
-
-# Wait for Gitea to be healthy
-echo "2. Waiting for Gitea to be ready..."
-timeout=60
-elapsed=0
-while [ $elapsed -lt $timeout ]; do
-    if docker exec openenv-gitea curl -sf http://localhost:3000/ > /dev/null 2>&1; then
-        echo "   ✓ Gitea is ready!"
-        break
-    fi
-    echo "   Waiting... (${elapsed}s/${timeout}s)"
-    sleep 2
-    elapsed=$((elapsed + 2))
-done
-
-if [ $elapsed -ge $timeout ]; then
-    echo "   ✗ Timeout waiting for Gitea"
-    exit 1
-fi
-
-# Initialize Gitea (POST to root URL)
-echo "3. Initializing Gitea configuration..."
-docker exec openenv-gitea curl -s -X POST \
-    -H "Content-Type: application/x-www-form-urlencoded" \
-    -d "db_type=sqlite3" \
-    -d "db_path=%2Fdata%2Fgitea%2Fgitea.db" \
-    -d "app_name=Gitea" \
-    -d "repo_root_path=%2Fdata%2Fgit%2Frepositories" \
-    -d "run_user=git" \
-    -d "domain=gitea" \
-    -d "http_port=3000" \
-    -d "app_url=http%3A%2F%2Fgitea%3A3000%2F" \
-    -d "log_root_path=%2Fdata%2Fgitea%2Flog" \
-    -d "offline_mode=on" \
-    http://localhost:3000/ > /dev/null || echo "   (Config may already exist)"
-
-# Create admin user
-echo "4. Creating admin user ($GITEA_USERNAME)..."
-docker exec openenv-gitea su git -c \
-    "gitea admin user create --username $GITEA_USERNAME --password $GITEA_PASSWORD --email ${GITEA_USERNAME}@local.env --admin" \
-    2>&1 | grep -q "already exists" && echo "   ✓ User already exists" || echo "   ✓ User created"
-
-echo
-echo "====================================="
-echo "✓ Gitea setup complete!"
-echo "====================================="
-echo
-echo "Gitea is now available at:"
-echo "  - Web UI: http://localhost:3000"
-echo "  - From containers: http://gitea:3000"
-echo
-echo "Admin credentials are configured from .env file"
-echo
-echo "To stop Gitea:"
-echo "  docker-compose -f src/envs/git_env/docker-compose.gitea.yml down"
-echo
-echo "To remove all data:"
-echo "  docker-compose -f src/envs/git_env/docker-compose.gitea.yml down -v"
-echo

openenv/src/__init__.py

@@ -1,7 +0,0 @@
-# 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."""

openenv/src/core/README.md

@@ -1,180 +0,0 @@
-# <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
-
-- **HTTPEnvClient**: Generic HTTP client for interacting with remote environments
-- **HTTPEnvServer**: FastAPI-based server wrapper for exposing environments over HTTP
-- **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[dev]
-```
-
-## Quick Start
-
-### Creating an Environment Client
-
-```python
-from openenv_core import HTTPEnvClient, StepResult
-from dataclasses import dataclass
-
-@dataclass
-class MyAction:
-    text: str
-
-@dataclass
-class MyObservation:
-    response: str
-
-class MyEnvClient(HTTPEnvClient[MyAction, MyObservation]):
-    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
-
-# Use with Docker
-env = MyEnvClient.from_docker_image("my-env:latest")
-result = env.reset()
-step_result = env.step(MyAction(text="hello"))
-env.close()
-```
-
-### 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
-
-### HTTPEnvClient
-
-Base class for environment clients with these abstract methods:
-
-- `_step_payload(action)`: Convert action to JSON
-- `_parse_result(payload)`: Parse response to StepResult
-- `_parse_state(payload)`: Parse state response
-
-### 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

openenv/src/core/__init__.py

@@ -1,19 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""Core components for agentic environments."""
-
-# Re-export main components from submodules for convenience
-from .env_server import *
-from .client_types import StepResult
-from .http_env_client import HTTPEnvClient
-
-# Note: MCP module doesn't export anything yet
-
-__all__ = [
-    "HTTPEnvClient",
-    "StepResult",
-]

openenv/src/core/client_types.py

@@ -1,22 +0,0 @@
-# Type definitions for EnvTorch
-from dataclasses import dataclass
-from typing import Any, Generic, Optional, TypeVar
-
-# Generic type for observations
-ObsT = TypeVar("ObsT")  # TypeVar for typehinting in IDEs
-
-
-@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

openenv/src/core/containers/__init__.py

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

openenv/src/core/containers/images/Dockerfile

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

openenv/src/core/containers/images/README.md

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

openenv/src/core/containers/runtime/__init__.py

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

openenv/src/core/containers/runtime/providers.py

@@ -1,293 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Container provider abstractions for running environment servers.
-
-This module provides a pluggable architecture for different container providers
-(local Docker, Kubernetes, cloud providers, etc.) to be used with HTTPEnvClient.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Any, Dict, Optional
-
-
-class ContainerProvider(ABC):
-    """
-    Abstract base class for container providers.
-
-    Providers implement this interface to support different container platforms:
-    - LocalDockerProvider: Runs containers on local Docker daemon
-    - KubernetesProvider: Runs containers in Kubernetes cluster
-    - FargateProvider: Runs containers on AWS Fargate
-    - CloudRunProvider: Runs containers on Google Cloud Run
-
-    The provider manages a single container lifecycle and provides the base URL
-    for connecting to it.
-
-    Example:
-        >>> provider = LocalDockerProvider()
-        >>> base_url = provider.start_container("echo-env:latest")
-        >>> print(base_url)  # http://localhost:8000
-        >>> # Use the environment via base_url
-        >>> provider.stop_container()
-    """
-
-    @abstractmethod
-    def start_container(
-        self,
-        image: str,
-        port: Optional[int] = None,
-        env_vars: Optional[Dict[str, str]] = None,
-        **kwargs: Any,
-    ) -> str:
-        """
-        Start a container from the specified image.
-
-        Args:
-            image: Container image name (e.g., "echo-env:latest")
-            port: Port to expose (if None, provider chooses)
-            env_vars: Environment variables to pass to container
-            **kwargs: Provider-specific options
-
-        Returns:
-            Base URL to connect to the container (e.g., "http://localhost:8000")
-
-        Raises:
-            RuntimeError: If container fails to start
-        """
-        pass
-
-    @abstractmethod
-    def stop_container(self) -> None:
-        """
-        Stop and remove the running container.
-
-        This cleans up the container that was started by start_container().
-        """
-        pass
-
-    @abstractmethod
-    def wait_for_ready(self, base_url: str, timeout_s: float = 30.0) -> None:
-        """
-        Wait for the container to be ready to accept requests.
-
-        This typically polls the /health endpoint until it returns 200.
-
-        Args:
-            base_url: Base URL of the container
-            timeout_s: Maximum time to wait
-
-        Raises:
-            TimeoutError: If container doesn't become ready in time
-        """
-        pass
-
-
-class LocalDockerProvider(ContainerProvider):
-    """
-    Container provider for local Docker daemon.
-
-    This provider runs containers on the local machine using Docker.
-    Useful for development and testing.
-
-    Example:
-        >>> provider = LocalDockerProvider()
-        >>> base_url = provider.start_container("echo-env:latest")
-        >>> # Container running on http://localhost:<random-port>
-        >>> provider.stop_container()
-    """
-
-    def __init__(self):
-        """Initialize the local Docker provider."""
-        self._container_id: Optional[str] = None
-        self._container_name: Optional[str] = None
-
-        # Check if Docker is available
-        import subprocess
-
-        try:
-            subprocess.run(
-                ["docker", "version"],
-                check=True,
-                capture_output=True,
-                timeout=5,
-            )
-        except (subprocess.CalledProcessError, FileNotFoundError, subprocess.TimeoutExpired):
-            raise RuntimeError(
-                "Docker is not available. Please install Docker Desktop or Docker Engine."
-            )
-
-    def start_container(
-        self,
-        image: str,
-        port: Optional[int] = None,
-        env_vars: Optional[Dict[str, str]] = None,
-        **kwargs: Any,
-    ) -> str:
-        """
-        Start a Docker container locally.
-
-        Args:
-            image: Docker image name
-            port: Port to expose (if None, finds available port)
-            env_vars: Environment variables for the container
-            **kwargs: Additional Docker run options
-
-        Returns:
-            Base URL to connect to the container
-        """
-        import subprocess
-        import time
-
-        # Find available port if not specified
-        if port is None:
-            port = self._find_available_port()
-
-        # Generate container name
-        self._container_name = self._generate_container_name(image)
-
-        # Build docker run command
-        cmd = [
-            "docker", "run",
-            "-d",  # Detached
-            "--name", self._container_name,
-            "-p", f"{port}:8000",  # Map port
-        ]
-
-        # Add environment variables
-        if env_vars:
-            for key, value in env_vars.items():
-                cmd.extend(["-e", f"{key}={value}"])
-
-        # Add image
-        cmd.append(image)
-
-        # Run container
-        try:
-            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
-            self._container_id = result.stdout.strip()
-        except subprocess.CalledProcessError as e:
-            error_msg = f"Failed to start Docker container.\nCommand: {' '.join(cmd)}\nExit code: {e.returncode}\nStderr: {e.stderr}\nStdout: {e.stdout}"
-            raise RuntimeError(error_msg) from e
-
-        # Wait a moment for container to start
-        time.sleep(1)
-
-        base_url = f"http://localhost:{port}"
-        return base_url
-
-    def stop_container(self) -> None:
-        """
-        Stop and remove the Docker container.
-        """
-        if self._container_id is None:
-            return
-
-        import subprocess
-
-        try:
-            # Stop container
-            subprocess.run(
-                ["docker", "stop", self._container_id],
-                capture_output=True,
-                check=True,
-                timeout=10,
-            )
-
-            # Remove container
-            subprocess.run(
-                ["docker", "rm", self._container_id],
-                capture_output=True,
-                check=True,
-                timeout=10,
-            )
-        except subprocess.CalledProcessError:
-            # Container might already be stopped/removed
-            pass
-        finally:
-            self._container_id = None
-            self._container_name = None
-
-    def wait_for_ready(self, base_url: str, timeout_s: float = 30.0) -> None:
-        """
-        Wait for container to be ready by polling /health endpoint.
-
-        Args:
-            base_url: Base URL of the container
-            timeout_s: Maximum time to wait
-
-        Raises:
-            TimeoutError: If container doesn't become ready
-        """
-        import time
-        import requests
-
-        start_time = time.time()
-        health_url = f"{base_url}/health"
-
-        while time.time() - start_time < timeout_s:
-            try:
-                response = requests.get(health_url, timeout=2.0)
-                if response.status_code == 200:
-                    return
-            except requests.RequestException:
-                pass
-
-            time.sleep(0.5)
-
-        raise TimeoutError(
-            f"Container at {base_url} did not become ready within {timeout_s}s"
-        )
-
-    def _find_available_port(self) -> int:
-        """
-        Find an available port on localhost.
-
-        Returns:
-            An available port number
-        """
-        import socket
-
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            s.bind(("", 0))
-            s.listen(1)
-            port = s.getsockname()[1]
-        return port
-
-    def _generate_container_name(self, image: str) -> str:
-        """
-        Generate a unique container name based on image name and timestamp.
-
-        Args:
-            image: Docker image name
-
-        Returns:
-            A unique container name
-        """
-        import time
-
-        clean_image = image.split("/")[-1].split(":")[0]
-        timestamp = int(time.time() * 1000)
-        return f"{clean_image}-{timestamp}"
-
-
-class KubernetesProvider(ContainerProvider):
-    """
-    Container provider for Kubernetes clusters.
-
-    This provider creates pods in a Kubernetes cluster and exposes them
-    via services or port-forwarding.
-
-    Example:
-        >>> provider = KubernetesProvider(namespace="envtorch-dev")
-        >>> base_url = provider.start_container("echo-env:latest")
-        >>> # Pod running in k8s, accessible via service or port-forward
-        >>> provider.stop_container()
-    """
-    pass

openenv/src/core/containers/test_local_docker_provider.py

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

openenv/src/core/env_server/__init__.py

@@ -1,35 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""Core environment interfaces and types."""
-
-from .base_transforms import CompositeTransform, NullTransform
-from .http_server import HTTPEnvServer, create_app, create_fastapi_app
-from .interfaces import Environment, Message, ModelTokenizer, Transform
-from .types import Action, Observation, State
-from .web_interface import create_web_interface_app, WebInterfaceManager
-
-__all__ = [
-    # Core interfaces
-    "Environment",
-    "Transform",
-    "Message",
-    "ModelTokenizer",
-    # Types
-    "Action",
-    "Observation",
-    "State",
-    # Base transforms
-    "CompositeTransform",
-    "NullTransform",
-    # HTTP Server
-    "HTTPEnvServer",
-    "create_app",
-    "create_fastapi_app",
-    # Web Interface
-    "create_web_interface_app",
-    "WebInterfaceManager",
-]

openenv/src/core/env_server/base_transforms.py

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

openenv/src/core/env_server/http_server.py

@@ -1,257 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-HTTP server wrapper for Environment instances.
-
-This module provides utilities to wrap any Environment subclass and expose it
-over HTTP endpoints that HTTPEnvClient can consume.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import os
-from concurrent.futures import ThreadPoolExecutor
-from dataclasses import asdict
-from typing import Any, Dict, Type
-
-from .interfaces import Environment
-from .types import Action, Observation
-from fastapi import Body, FastAPI
-
-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.
-
-    The server expects:
-    - Action deserialization: Converts JSON dict to Action subclass
-    - Observation serialization: Converts Observation subclass to JSON dict
-
-    Example:
-        >>> from core.env_server import HTTPEnvServer
-        >>> from envs.coding_env.server import CodeExecutionEnvironment
-        >>>
-        >>> env = CodeExecutionEnvironment()
-        >>> server = HTTPEnvServer(env)
-        >>>
-        >>> # Register routes with FastAPI
-        >>> from fastapi import FastAPI
-        >>> app = FastAPI()
-        >>> server.register_routes(app)
-    """
-
-    def __init__(
-        self,
-        env: Environment,
-        action_cls: Type[Action],
-        observation_cls: Type[Observation],
-    ):
-        """
-        Initialize HTTP server wrapper.
-
-        Args:
-            env: The Environment instance to wrap
-            action_cls: The Action subclass this environment expects
-            observation_cls: The Observation subclass this environment returns
-        """
-        self.env = env
-        self.action_cls = action_cls
-        self.observation_cls = observation_cls
-        # Create thread pool for running sync code in async context
-        # This is needed for environments using sync libraries (e.g., Playwright sync API)
-        self._executor = ThreadPoolExecutor(max_workers=1)
-
-    def register_routes(self, app: Any) -> None:
-        """
-        Register HTTP routes on a FastAPI application.
-
-        Args:
-            app: FastAPI application instance
-        """
-
-        if not isinstance(app, FastAPI):
-            raise TypeError("app must be a FastAPI instance")
-
-        @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
-            # Run sync environment code in thread pool to avoid blocking asyncio loop
-            loop = asyncio.get_event_loop()
-            observation = await loop.run_in_executor(self._executor, self.env.reset)
-            return self._serialize_observation(observation)
-
-        @app.post("/step")
-        async def step(request: Dict[str, Any]) -> Dict[str, Any]:
-            """Step endpoint - executes action and returns observation."""
-            # Support both {"action": {...}} and direct action fields
-            action_data = request.get("action", request)
-            # TODO: Handle timeout_s, request_id, episode_id from request if provided
-
-            # Deserialize action
-            action = self._deserialize_action(action_data)
-
-            # Execute step in thread pool to avoid blocking asyncio loop
-            loop = asyncio.get_event_loop()
-            observation = await loop.run_in_executor(
-                self._executor, self.env.step, action
-            )
-
-            # Return serialized observation
-            return self._serialize_observation(observation)
-
-        @app.get("/state")
-        async def get_state() -> Dict[str, Any]:
-            """State endpoint - returns current environment state."""
-            state = self.env.state
-            return asdict(state)
-
-        @app.get("/health")
-        async def health() -> Dict[str, str]:
-            """Health check endpoint."""
-            return {"status": "healthy"}
-
-
-    def _deserialize_action(self, action_data: Dict[str, Any]) -> Action:
-        """
-        Convert JSON dict to Action instance.
-
-        Args:
-            action_data: Dictionary containing action data
-
-        Returns:
-            Action instance
-
-        Note:
-            This is a simple implementation. Subclasses may need to override
-            for more complex deserialization logic.
-        """
-        # 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
-
-    def _serialize_observation(self, observation: Observation) -> Dict[str, Any]:
-        """
-        Convert Observation instance to JSON-compatible dict.
-
-        Args:
-            observation: Observation instance
-
-        Returns:
-            Dictionary compatible with HTTPEnvClient._parse_result()
-
-        The format matches what HTTPEnvClient expects:
-        {
-            "observation": {...},  # Observation fields
-            "reward": float | None,
-            "done": bool,
-        }
-        """
-        obs_dict = asdict(observation)
-
-        # Convert numpy arrays to lists for JSON serialization
-        def _convert_numpy(obj):
-            """Recursively convert numpy arrays to lists."""
-            if hasattr(obj, '__array__'):  # numpy array
-                return obj.tolist()
-            elif isinstance(obj, dict):
-                return {k: _convert_numpy(v) for k, v in obj.items()}
-            elif isinstance(obj, (list, tuple)):
-                return type(obj)(_convert_numpy(item) for item in obj)
-            return obj
-
-        obs_dict = _convert_numpy(obs_dict)
-
-        # 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 in HTTPEnvClient expected format
-        return {
-            "observation": obs_dict,
-            "reward": reward,
-            "done": done,
-        }
-
-def create_app(
-    env: Environment,
-    action_cls: Type[Action],
-    observation_cls: Type[Observation],
-    env_name: Optional[str] = None,
-) -> Any:
-    """
-    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
-        action_cls: The Action subclass this environment expects
-        observation_cls: The Observation subclass this environment returns
-        env_name: Optional environment name for README loading
-        
-    Returns:
-        FastAPI application instance with or without web interface and README integration
-    """
-    # Check if web interface should be enabled
-    # This can be controlled via environment variable or build argument
-    enable_web = (
-        os.getenv("ENABLE_WEB_INTERFACE", "false").lower() in ("true", "1", "yes")
-    )
-
-    if enable_web:
-        # Import web interface only when needed
-        from .web_interface import create_web_interface_app
-        return create_web_interface_app(env, action_cls, observation_cls, env_name)
-    else:
-        # Use standard FastAPI app without web interface
-        return create_fastapi_app(env, action_cls, observation_cls)
-    
-
-def create_fastapi_app(
-    env: Environment,
-    action_cls: Type[Action],
-    observation_cls: Type[Observation],
-) -> Any:
-    """
-    Create a FastAPI application with routes for the given environment.
-
-    Args:
-        env: The Environment instance to serve
-        action_cls: The Action subclass this environment expects
-        observation_cls: The Observation subclass this environment returns
-
-    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
-    """
-    try:
-        from fastapi import FastAPI
-    except ImportError:
-        raise ImportError(
-            "FastAPI is required. Install with: pip install fastapi uvicorn"
-        )
-
-    app = FastAPI(title="Environment HTTP Server")
-    server = HTTPEnvServer(env, action_cls, observation_cls)
-    server.register_routes(app)
-    return app

openenv/src/core/env_server/interfaces.py

@@ -1,118 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-from abc import ABC, abstractmethod
-from typing import Any, Protocol, TypedDict
-
-from .types import Action, Observation, State
-
-
-class Message(TypedDict):
-    """A message in a conversation.
-
-    Compatible with Huggingface chat template format.
-    """
-
-    role: str
-    content: str
-
-
-class ModelTokenizer(Protocol):
-    """Protocol for tokenizers that support chat templates.
-
-    This protocol defines the interface that tokenizers must implement
-    to work with chat-based environments. It's compatible with
-    Huggingface transformers tokenizers.
-    """
-
-    def apply_chat_template(
-        self,
-        conversation: list[Message],
-        tokenize: bool = True,
-        return_tensors: str | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Apply a chat template to format and optionally tokenize a conversation.
-
-        Args:
-            conversation: List of message dictionaries with 'role' and 'content'
-            tokenize: Whether to tokenize the output
-            return_tensors: Format for returned tensors ('pt' for PyTorch)
-            **kwargs: Additional arguments
-
-        Returns:
-            Formatted and optionally tokenized conversation
-        """
-        ...
-
-    def decode(
-        self, token_ids: Any, skip_special_tokens: bool = False, **kwargs: Any
-    ) -> str:
-        """Decode token IDs back to text.
-
-        Args:
-            token_ids: Token IDs to decode
-            skip_special_tokens: Whether to skip special tokens in output
-            **kwargs: Additional arguments
-
-        Returns:
-            Decoded text string
-        """
-        ...
-
-
-class Transform(ABC):
-    """Transform observations to add rewards, metrics, or other modifications.
-
-    Transforms follow the TorchRL pattern where they take an observation
-    and return a (potentially modified) observation. This allows for
-    flexible reward computation and observation augmentation.
-    """
-
-    @abstractmethod
-    def __call__(self, observation: Observation) -> Observation:
-        """Transform an observation.
-
-        Args:
-            observation: The input observation
-
-        Returns:
-            The transformed observation
-        """
-        pass
-
-
-class Environment(ABC):
-    """Base class for all environment servers following Gym/Gymnasium API.
-
-    Args:
-        transform: Optional transform to apply to observations
-    """
-
-    def __init__(self, transform: Transform | None = None):
-        self.transform = transform
-
-    @abstractmethod
-    def reset(self) -> Observation:
-        """Reset the environment and return initial observation."""
-        pass
-
-    @abstractmethod
-    def step(self, action: Action) -> Observation:
-        """Take a step in the environment."""
-        pass
-
-    @property
-    @abstractmethod
-    def state(self) -> State:
-        """Get the current environment state."""
-        pass
-
-    def _apply_transform(self, observation: Observation) -> Observation:
-        """Apply transform if one is provided."""
-        if self.transform is not None:
-            return self.transform(observation)
-        return observation

openenv/src/core/env_server/types.py

@@ -1,57 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Union
-
-
-# Type aliases
-Scalar = Union[int, float, bool]
-
-
-@dataclass(kw_only=True)
-class Action:
-    """Base class for all environment actions."""
-
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-
-@dataclass(kw_only=True)
-class Observation:
-    """Base class for all environment observations."""
-
-    done: bool = False
-    reward: Union[bool, int, float, None] = None
-    metadata: Dict[str, Any] = field(default_factory=dict)
-
-
-@dataclass
-class State:
-    """Base class for environment state."""
-
-    episode_id: Optional[str] = None
-    step_count: int = 0
-
-
-@dataclass
-class CodeExecResult:
-    """Result of code execution containing stdout, stderr, and exit code."""
-
-    stdout: str
-    stderr: str
-    exit_code: int
-
-
-@dataclass
-class EnvironmentMetadata:
-    """Metadata about an environment for documentation and UI purposes."""
-    
-    name: str
-    description: str
-    readme_content: Optional[str] = None
-    version: Optional[str] = None
-    author: Optional[str] = None
-    documentation_url: Optional[str] = None

openenv/src/core/env_server/web_interface.py

@@ -1,1613 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Web interface for OpenEnv environments.
-
-This module provides a web-based interface for interacting with OpenEnv environments,
-including a two-pane layout for HumanAgent interaction and state observation.
-"""
-
-from __future__ import annotations
-
-import json
-import time
-from dataclasses import asdict, dataclass
-from typing import Any, Dict, List, Optional, Type
-from datetime import datetime
-
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request
-from fastapi.responses import HTMLResponse, FileResponse
-from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel
-
-from .interfaces import Environment
-from .types import Action, Observation, State, EnvironmentMetadata
-
-
-def load_environment_metadata(env: Environment, env_name: Optional[str] = None) -> EnvironmentMetadata:
-    """
-    Load environment metadata including README content.
-    
-    Args:
-        env: The environment instance
-        env_name: Optional environment name for README file lookup
-        
-    Returns:
-        EnvironmentMetadata with loaded information
-    """
-    # Try to get metadata from environment if it has a method for it
-    if hasattr(env, 'get_metadata'):
-        return env.get_metadata()
-    
-    # Default metadata
-    metadata = EnvironmentMetadata(
-        name=env_name or env.__class__.__name__,
-        description=f"{env.__class__.__name__} environment",
-        version="1.0.0"
-    )
-    
-    # Try to load README from file system
-    readme_content = _load_readme_from_filesystem(env_name)
-    if readme_content:
-        metadata.readme_content = readme_content
-    
-    return metadata
-
-
-def _load_readme_from_filesystem(env_name: Optional[str]) -> Optional[str]:
-    """
-    Load README content from the filesystem.
-    
-    Tries multiple locations:
-    1. Container filesystem: /app/README.md
-    2. Local development: src/envs/{env_name}/README.md
-    3. Environment variable: ENV_README_PATH
-    """
-    import os
-    from pathlib import Path
-    
-    # Try container filesystem first
-    container_readme = Path("/app/README.md")
-    if container_readme.exists():
-        try:
-            return container_readme.read_text(encoding='utf-8')
-        except Exception:
-            pass
-    
-    # Try environment variable path
-    custom_path = os.environ.get("ENV_README_PATH")
-    if custom_path and Path(custom_path).exists():
-        try:
-            return Path(custom_path).read_text(encoding='utf-8')
-        except Exception:
-            pass
-    
-    # Try local development path
-    if env_name:
-        local_readme = Path(f"src/envs/{env_name}/README.md")
-        if local_readme.exists():
-            try:
-                return local_readme.read_text(encoding='utf-8')
-            except Exception:
-                pass
-    
-    return None
-
-
-@dataclass
-class ActionLog:
-    """Log entry for an action taken."""
-    timestamp: str
-    action: Dict[str, Any]
-    observation: Dict[str, Any]
-    reward: Optional[float]
-    done: bool
-    step_count: int
-
-
-@dataclass
-class EpisodeState:
-    """Current episode state for the web interface."""
-    episode_id: Optional[str]
-    step_count: int
-    current_observation: Optional[Dict[str, Any]]
-    action_logs: List[ActionLog]
-    is_reset: bool = True
-
-
-class WebInterfaceManager:
-    """Manages the web interface for an environment."""
-    
-    def __init__(
-        self,
-        env: Environment,
-        action_cls: Type[Action],
-        observation_cls: Type[Observation],
-        metadata: Optional[EnvironmentMetadata] = None,
-    ):
-        self.env = env
-        self.action_cls = action_cls
-        self.observation_cls = observation_cls
-        self.metadata = metadata or EnvironmentMetadata(
-            name=env.__class__.__name__,
-            description=f"{env.__class__.__name__} environment"
-        )
-        self.episode_state = EpisodeState(
-            episode_id=None,
-            step_count=0,
-            current_observation=None,
-            action_logs=[]
-        )
-        self.connected_clients: List[WebSocket] = []
-    
-    async def connect_websocket(self, websocket: WebSocket):
-        """Connect a new WebSocket client."""
-        await websocket.accept()
-        self.connected_clients.append(websocket)
-        
-        # Send current state to the new client
-        await self._send_state_update()
-    
-    async def disconnect_websocket(self, websocket: WebSocket):
-        """Disconnect a WebSocket client."""
-        if websocket in self.connected_clients:
-            self.connected_clients.remove(websocket)
-    
-    async def _send_state_update(self):
-        """Send current state to all connected clients."""
-        if not self.connected_clients:
-            return
-            
-        state_data = {
-            "type": "state_update",
-            "episode_state": asdict(self.episode_state)
-        }
-        
-        # Send to all connected clients
-        disconnected_clients = []
-        for client in self.connected_clients:
-            try:
-                await client.send_text(json.dumps(state_data))
-            except:
-                disconnected_clients.append(client)
-        
-        # Remove disconnected clients
-        for client in disconnected_clients:
-            self.connected_clients.remove(client)
-    
-    async def reset_environment(self) -> Dict[str, Any]:
-        """Reset the environment and update state."""
-        observation = self.env.reset()
-        state = self.env.state
-        
-        # Update episode state
-        self.episode_state.episode_id = state.episode_id
-        self.episode_state.step_count = 0
-        self.episode_state.current_observation = asdict(observation)
-        self.episode_state.action_logs = []
-        self.episode_state.is_reset = True
-        
-        # Send state update
-        await self._send_state_update()
-        
-        return {
-            "observation": asdict(observation),
-            "reward": observation.reward,
-            "done": observation.done,
-        }
-    
-    async def step_environment(self, action_data: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute a step in the environment and update state."""
-        # Deserialize action
-        action = self._deserialize_action(action_data)
-        
-        # Execute step
-        observation = self.env.step(action)
-        state = self.env.state
-        
-        # Create action log
-        action_log = ActionLog(
-            timestamp=datetime.now().isoformat(),
-            action=asdict(action),
-            observation=asdict(observation),
-            reward=observation.reward,
-            done=observation.done,
-            step_count=state.step_count
-        )
-        
-        # Update episode state
-        self.episode_state.episode_id = state.episode_id
-        self.episode_state.step_count = state.step_count
-        self.episode_state.current_observation = asdict(observation)
-        self.episode_state.action_logs.append(action_log)
-        self.episode_state.is_reset = False
-        
-        # Send state update
-        await self._send_state_update()
-        
-        return {
-            "observation": asdict(observation),
-            "reward": observation.reward,
-            "done": observation.done,
-        }
-    
-    def get_state(self) -> Dict[str, Any]:
-        """Get current environment state."""
-        state = self.env.state
-        return asdict(state)
-    
-    def _deserialize_action(self, action_data: Dict[str, Any]) -> Action:
-        """Convert JSON dict to Action instance."""
-        metadata = action_data.pop("metadata", {})
-        
-        # Handle tensor fields that come from JSON as lists
-        processed_data = {}
-        for key, value in action_data.items():
-            if key == "tokens" and isinstance(value, (list, str)):
-                # Convert list or string to tensor
-                if isinstance(value, str):
-                    # If it's a string, try to parse it as a list of numbers
-                    try:
-                        import json
-                        value = json.loads(value)
-                    except:
-                        # If parsing fails, treat as empty list
-                        value = []
-                if isinstance(value, list):
-                    import torch
-                    processed_data[key] = torch.tensor(value, dtype=torch.long)
-                else:
-                    processed_data[key] = value
-            elif key == "action_id" and isinstance(value, str):
-                # Convert action_id from string to int
-                try:
-                    processed_data[key] = int(value)
-                except ValueError:
-                    # If conversion fails, keep original value
-                    processed_data[key] = value
-            else:
-                processed_data[key] = value
-        
-        action = self.action_cls(**processed_data)
-        action.metadata = metadata
-        return action
-
-
-def create_web_interface_app(
-    env: Environment,
-    action_cls: Type[Action],
-    observation_cls: Type[Observation],
-    env_name: Optional[str] = None,
-) -> FastAPI:
-    """
-    Create a FastAPI application with web interface for the given environment.
-    
-    Args:
-        env: The Environment instance to serve
-        action_cls: The Action subclass this environment expects
-        observation_cls: The Observation subclass this environment returns
-        env_name: Optional environment name for README loading
-        
-    Returns:
-        FastAPI application instance with web interface
-    """
-    from .http_server import create_fastapi_app
-    
-    # Create the base environment app
-    app = create_fastapi_app(env, action_cls, observation_cls)
-    
-    # Load environment metadata
-    metadata = load_environment_metadata(env, env_name)
-    
-    # Create web interface manager
-    web_manager = WebInterfaceManager(env, action_cls, observation_cls, metadata)
-    
-    # Add web interface routes
-    @app.get("/web", response_class=HTMLResponse)
-    async def web_interface():
-        """Serve the web interface."""
-        return get_web_interface_html(action_cls, web_manager.metadata)
-    
-    @app.get("/web/metadata")
-    async def web_metadata():
-        """Get environment metadata."""
-        return asdict(web_manager.metadata)
-    
-    @app.websocket("/ws")
-    async def websocket_endpoint(websocket: WebSocket):
-        """WebSocket endpoint for real-time updates."""
-        await web_manager.connect_websocket(websocket)
-        try:
-            while True:
-                # Keep connection alive
-                await websocket.receive_text()
-        except WebSocketDisconnect:
-            await web_manager.disconnect_websocket(websocket)
-    
-    @app.post("/web/reset")
-    async def web_reset():
-        """Reset endpoint for web interface."""
-        return await web_manager.reset_environment()
-    
-    @app.post("/web/step")
-    async def web_step(request: Dict[str, Any]):
-        """Step endpoint for web interface."""
-        # Check if this is a message-based request (chat environment)
-        if "message" in request:
-            message = request["message"]
-            # Convert message to action using the environment's message_to_action method
-            action = web_manager.env.message_to_action(message)
-            action_data = {"tokens": action.tokens.tolist()}
-        else:
-            action_data = request.get("action", {})
-        
-        return await web_manager.step_environment(action_data)
-    
-    @app.get("/web/state")
-    async def web_state():
-        """State endpoint for web interface."""
-        return web_manager.get_state()
-    
-    return app
-
-
-def get_web_interface_html(action_cls: Type[Action], metadata: Optional[EnvironmentMetadata] = None) -> str:
-    """Generate the HTML for the web interface."""
-    
-    # Check if this is a chat environment by looking for tokens field
-    is_chat_env = False
-    if hasattr(action_cls, '__dataclass_fields__'):
-        for field_name, field_info in action_cls.__dataclass_fields__.items():
-            if field_name == 'tokens' and hasattr(field_info.type, '__name__') and 'Tensor' in field_info.type.__name__:
-                is_chat_env = True
-                break
-    
-    # Get action fields for dynamic form generation with enhanced metadata
-    action_fields = _extract_action_fields(action_cls)
-    
-    return f"""
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>OpenEnv Web Interface</title>
-    <style>
-        * {{
-            margin: 0;
-            padding: 0;
-            box-sizing: border-box;
-        }}
-        
-        body {{
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-            background-color: #f5f5f5;
-            height: 100vh;
-            overflow: hidden;
-        }}
-        
-        .container {{
-            display: flex;
-            height: 100vh;
-        }}
-        
-        .left-pane {{
-            width: 50%;
-            background: white;
-            border-right: 1px solid #e0e0e0;
-            display: flex;
-            flex-direction: column;
-        }}
-        
-        .right-pane {{
-            width: 50%;
-            background: #fafafa;
-            display: flex;
-            flex-direction: column;
-        }}
-        
-        .pane-header {{
-            padding: 20px;
-            border-bottom: 1px solid #e0e0e0;
-            background: #f8f9fa;
-            font-weight: 600;
-            font-size: 16px;
-        }}
-        
-        .pane-content {{
-            flex: 1;
-            padding: 20px;
-            overflow-y: auto;
-        }}
-        
-        .action-form {{
-            background: white;
-            border: 1px solid #e0e0e0;
-            border-radius: 8px;
-            padding: 20px;
-            margin-bottom: 20px;
-        }}
-        
-        .form-group {{
-            margin-bottom: 15px;
-        }}
-        
-        .form-group label {{
-            display: block;
-            margin-bottom: 5px;
-            font-weight: 500;
-            color: #333;
-        }}
-        
-        .form-group input, .form-group textarea {{
-            width: 100%;
-            padding: 8px 12px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
-            font-size: 14px;
-        }}
-        
-        .form-group input:focus, .form-group textarea:focus {{
-            outline: none;
-            border-color: #007bff;
-            box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
-        }}
-        
-        .btn {{
-            background: #007bff;
-            color: white;
-            border: none;
-            padding: 10px 20px;
-            border-radius: 4px;
-            cursor: pointer;
-            font-size: 14px;
-            margin-right: 10px;
-            margin-bottom: 10px;
-        }}
-        
-        .btn:hover {{
-            background: #0056b3;
-        }}
-        
-        .btn:disabled {{
-            background: #6c757d;
-            cursor: not-allowed;
-        }}
-        
-        .btn-secondary {{
-            background: #6c757d;
-        }}
-        
-        .btn-secondary:hover {{
-            background: #545b62;
-        }}
-        
-        .state-display {{
-            background: white;
-            border: 1px solid #e0e0e0;
-            border-radius: 8px;
-            padding: 15px;
-            margin-bottom: 20px;
-        }}
-        
-        .state-item {{
-            margin-bottom: 8px;
-        }}
-        
-        .state-label {{
-            font-weight: 500;
-            color: #666;
-        }}
-        
-        .state-value {{
-            color: #333;
-            font-family: monospace;
-        }}
-        
-        .logs-container {{
-            background: white;
-            border: 1px solid #e0e0e0;
-            border-radius: 8px;
-            padding: 15px;
-            max-height: 400px;
-            overflow-y: auto;
-        }}
-        
-        .log-entry {{
-            border-bottom: 1px solid #f0f0f0;
-            padding: 10px 0;
-        }}
-        
-        .log-entry:last-child {{
-            border-bottom: none;
-        }}
-        
-        .log-timestamp {{
-            font-size: 12px;
-            color: #666;
-            margin-bottom: 5px;
-        }}
-        
-        .log-action {{
-            background: #e3f2fd;
-            padding: 8px;
-            border-radius: 4px;
-            margin-bottom: 5px;
-            font-family: monospace;
-            font-size: 12px;
-        }}
-        
-        .log-observation {{
-            background: #f3e5f5;
-            padding: 8px;
-            border-radius: 4px;
-            font-family: monospace;
-            font-size: 12px;
-        }}
-        
-        .log-reward {{
-            font-weight: 600;
-            color: #28a745;
-        }}
-        
-        .log-done {{
-            font-weight: 600;
-            color: #dc3545;
-        }}
-        
-        .status-indicator {{
-            display: inline-block;
-            width: 8px;
-            height: 8px;
-            border-radius: 50%;
-            margin-right: 8px;
-        }}
-        
-        .status-connected {{
-            background: #28a745;
-        }}
-        
-        .status-disconnected {{
-            background: #dc3545;
-        }}
-        
-        .json-display {{
-            background: #f8f9fa;
-            border: 1px solid #e9ecef;
-            border-radius: 4px;
-            padding: 10px;
-            font-family: monospace;
-            font-size: 12px;
-            white-space: pre-wrap;
-            max-height: 200px;
-            overflow-y: auto;
-        }}
-        
-        /* Chat Interface Styles */
-        .chat-interface {{
-            background: white;
-            border: 1px solid #e0e0e0;
-            border-radius: 8px;
-            padding: 20px;
-            margin-bottom: 20px;
-        }}
-        
-        .chat-messages {{
-            background: #f8f9fa;
-            border: 1px solid #e0e0e0;
-            border-radius: 8px;
-            padding: 15px;
-            margin-bottom: 15px;
-            max-height: 400px;
-            overflow-y: auto;
-        }}
-        
-        .chat-message {{
-            margin-bottom: 15px;
-            padding: 10px;
-            border-radius: 8px;
-        }}
-        
-        .chat-message:last-child {{
-            margin-bottom: 0;
-        }}
-        
-        .chat-message.user {{
-            background: #e3f2fd;
-            margin-left: 20px;
-        }}
-        
-        .chat-message.assistant {{
-            background: #f3e5f5;
-            margin-right: 20px;
-        }}
-        
-        .chat-message.system {{
-            background: #e8f5e8;
-            font-style: italic;
-        }}
-        
-        .message-role {{
-            font-weight: 600;
-            font-size: 12px;
-            color: #666;
-            margin-bottom: 5px;
-        }}
-        
-        .message-content {{
-            font-size: 14px;
-            line-height: 1.4;
-        }}
-        
-        .chat-input-container {{
-            border-top: 1px solid #e0e0e0;
-            padding-top: 15px;
-        }}
-        
-        .role-selector {{
-            margin-bottom: 10px;
-        }}
-        
-        .role-selector label {{
-            font-weight: 500;
-            margin-right: 10px;
-        }}
-        
-        .role-selector select {{
-            padding: 5px 10px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
-        }}
-        
-        .message-input {{
-            display: flex;
-            gap: 10px;
-            align-items: flex-end;
-        }}
-        
-        .message-input textarea {{
-            flex: 1;
-            padding: 10px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
-            resize: vertical;
-            font-family: inherit;
-        }}
-        
-        .message-input textarea:focus {{
-            outline: none;
-            border-color: #007bff;
-            box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
-        }}
-        
-        /* Instructions Section Styles */
-        .instructions-section {{
-            background: white;
-            border: 1px solid #e0e0e0;
-            border-radius: 8px;
-            padding: 20px;
-            margin-bottom: 20px;
-        }}
-        
-        .instructions-header {{
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            margin-bottom: 15px;
-        }}
-        
-        .instructions-title {{
-            font-size: 18px;
-            font-weight: 600;
-            color: #333;
-            margin: 0;
-        }}
-        
-        .instructions-toggle {{
-            background: #f8f9fa;
-            border: 1px solid #dee2e6;
-            border-radius: 4px;
-            padding: 5px 10px;
-            cursor: pointer;
-            font-size: 12px;
-            color: #6c757d;
-        }}
-        
-        .instructions-toggle:hover {{
-            background: #e9ecef;
-        }}
-        
-        .instructions-content {{
-            display: none;
-            max-height: 400px;
-            overflow-y: auto;
-            border-top: 1px solid #e0e0e0;
-            padding-top: 15px;
-        }}
-        
-        .instructions-content.expanded {{
-            display: block;
-        }}
-        
-        .instructions-content h1,
-        .instructions-content h2,
-        .instructions-content h3 {{
-            color: #333;
-            margin-top: 20px;
-            margin-bottom: 10px;
-        }}
-        
-        .instructions-content h1 {{
-            font-size: 24px;
-            border-bottom: 2px solid #007bff;
-            padding-bottom: 10px;
-        }}
-        
-        .instructions-content h2 {{
-            font-size: 20px;
-        }}
-        
-        .instructions-content h3 {{
-            font-size: 16px;
-        }}
-        
-        .instructions-content p {{
-            margin-bottom: 10px;
-            line-height: 1.6;
-        }}
-        
-        .instructions-content code {{
-            background: #f8f9fa;
-            padding: 2px 4px;
-            border-radius: 3px;
-            font-family: monospace;
-            font-size: 14px;
-        }}
-        
-        .instructions-content pre {{
-            background: #f8f9fa;
-            border: 1px solid #e9ecef;
-            border-radius: 4px;
-            padding: 15px;
-            overflow-x: auto;
-            margin: 10px 0;
-        }}
-        
-        .instructions-content pre code {{
-            background: none;
-            padding: 0;
-        }}
-        
-        .instructions-content ul,
-        .instructions-content ol {{
-            margin: 10px 0;
-            padding-left: 20px;
-        }}
-        
-        .instructions-content li {{
-            margin-bottom: 5px;
-        }}
-        
-        .instructions-content table {{
-            border-collapse: collapse;
-            width: 100%;
-            margin: 15px 0;
-        }}
-        
-        .instructions-content th,
-        .instructions-content td {{
-            border: 1px solid #dee2e6;
-            padding: 8px 12px;
-            text-align: left;
-        }}
-        
-        .instructions-content th {{
-            background: #f8f9fa;
-            font-weight: 600;
-        }}
-        
-        /* Enhanced Form Styles */
-        .help-text {{
-            display: block;
-            margin-top: 5px;
-            font-size: 12px;
-            color: #6c757d;
-            font-style: italic;
-        }}
-        
-        .form-group label {{
-            font-weight: 500;
-            color: #333;
-            margin-bottom: 5px;
-        }}
-        
-        .form-group select {{
-            width: 100%;
-            padding: 8px 12px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
-            font-size: 14px;
-            background-color: white;
-        }}
-        
-        .form-group select:focus {{
-            outline: none;
-            border-color: #007bff;
-            box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
-        }}
-        
-        .form-group textarea {{
-            width: 100%;
-            padding: 8px 12px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
-            font-size: 14px;
-            font-family: inherit;
-            resize: vertical;
-        }}
-        
-        .form-group textarea:focus {{
-            outline: none;
-            border-color: #007bff;
-            box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
-        }}
-        
-        .form-group input[type="number"] {{
-            width: 100%;
-            padding: 8px 12px;
-            border: 1px solid #ddd;
-            border-radius: 4px;
-            font-size: 14px;
-        }}
-        
-        .form-group input[type="number"]:focus {{
-            outline: none;
-            border-color: #007bff;
-            box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
-        }}
-        
-        .form-group input[type="text"]:focus {{
-            outline: none;
-            border-color: #007bff;
-            box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);
-        }}
-        
-        .required-indicator {{
-            color: #dc3545;
-            font-weight: bold;
-        }}
-        
-        .form-group .field-description {{
-            font-size: 11px;
-            color: #666;
-            margin-top: 2px;
-            font-style: italic;
-        }}
-    </style>
-</head>
-<body>
-    <div class="container">
-        <!-- Left Pane: HumanAgent Interface -->
-        <div class="left-pane">
-            <div class="pane-header">
-                <span class="status-indicator status-disconnected" id="connection-status"></span>
-                HumanAgent Interface
-            </div>
-            <div class="pane-content">
-                <!-- Instructions Section -->
-                {_generate_instructions_section(metadata)}
-                
-                <!-- Action Form or Chat Interface -->
-                {_generate_action_interface(action_fields, is_chat_env)}
-                
-                <!-- Control Buttons -->
-                <div style="margin-bottom: 20px;">
-                    <button class="btn btn-secondary" id="reset-btn">Reset Environment</button>
-                    <button class="btn btn-secondary" id="state-btn">Get State</button>
-                </div>
-                
-                <!-- Current State Display -->
-                <div class="state-display">
-                    <h3>Current State</h3>
-                    <div id="current-state">
-                        <div class="state-item">
-                            <span class="state-label">Status:</span>
-                            <span class="state-value" id="env-status">Not initialized</span>
-                        </div>
-                        <div class="state-item">
-                            <span class="state-label">Episode ID:</span>
-                            <span class="state-value" id="episode-id">-</span>
-                        </div>
-                        <div class="state-item">
-                            <span class="state-label">Step Count:</span>
-                            <span class="state-value" id="step-count">0</span>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </div>
-        
-        <!-- Right Pane: State Observer -->
-        <div class="right-pane">
-            <div class="pane-header">
-                State Observer
-            </div>
-            <div class="pane-content">
-                <!-- Current Observation -->
-                <div class="state-display">
-                    <h3>Current Observation</h3>
-                    <div id="current-observation" class="json-display">
-                        No observation yet
-                    </div>
-                </div>
-                
-                <!-- Action Logs -->
-                <div class="logs-container">
-                    <h3>Action History</h3>
-                    <div id="action-logs">
-                        No actions taken yet
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <script>
-        class OpenEnvWebInterface {{
-            constructor() {{
-                this.ws = null;
-                this.isConnected = false;
-                this.init();
-            }}
-            
-            init() {{
-                this.connectWebSocket();
-                this.setupEventListeners();
-            }}
-            
-            connectWebSocket() {{
-                const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-                const wsUrl = `${{protocol}}//${{window.location.host}}/ws`;
-                
-                this.ws = new WebSocket(wsUrl);
-                
-                this.ws.onopen = () => {{
-                    this.isConnected = true;
-                    this.updateConnectionStatus(true);
-                    console.log('WebSocket connected');
-                }};
-                
-                this.ws.onmessage = (event) => {{
-                    const data = JSON.parse(event.data);
-                    if (data.type === 'state_update') {{
-                        this.updateUI(data.episode_state);
-                    }}
-                }};
-                
-                this.ws.onclose = () => {{
-                    this.isConnected = false;
-                    this.updateConnectionStatus(false);
-                    console.log('WebSocket disconnected');
-                    // Attempt to reconnect after 3 seconds
-                    setTimeout(() => this.connectWebSocket(), 3000);
-                }};
-                
-                this.ws.onerror = (error) => {{
-                    console.error('WebSocket error:', error);
-                }};
-            }}
-            
-            setupEventListeners() {{
-                // Instructions toggle
-                const instructionsToggle = document.getElementById('instructions-toggle');
-                const instructionsContent = document.getElementById('instructions-content');
-                if (instructionsToggle && instructionsContent) {{
-                    instructionsToggle.addEventListener('click', () => {{
-                        instructionsContent.classList.toggle('expanded');
-                        instructionsToggle.textContent = instructionsContent.classList.contains('expanded') 
-                            ? 'Hide Instructions' : 'Show Instructions';
-                    }});
-                }}
-                
-                // Check if this is a chat environment
-                const isChatEnv = document.getElementById('chat-messages') !== null;
-                
-                if (isChatEnv) {{
-                    // Chat environment event listeners
-                    document.getElementById('send-message-btn').addEventListener('click', () => {{
-                        this.sendMessage();
-                    }});
-                    
-                    // Send message on Enter (but allow Shift+Enter for new lines)
-                    document.getElementById('message-input').addEventListener('keydown', (e) => {{
-                        if (e.key === 'Enter' && !e.shiftKey) {{
-                            e.preventDefault();
-                            this.sendMessage();
-                        }}
-                    }});
-                }} else {{
-                    // Traditional action form submission
-                    const actionForm = document.getElementById('action-form');
-                    if (actionForm) {{
-                        actionForm.addEventListener('submit', (e) => {{
-                            e.preventDefault();
-                            this.submitAction();
-                        }});
-                    }}
-                }}
-                
-                // Reset button
-                document.getElementById('reset-btn').addEventListener('click', () => {{
-                    this.resetEnvironment();
-                }});
-                
-                // State button
-                document.getElementById('state-btn').addEventListener('click', () => {{
-                    this.getState();
-                }});
-            }}
-            
-            async sendMessage() {{
-                const messageInput = document.getElementById('message-input');
-                const roleSelect = document.getElementById('message-role');
-                const message = messageInput.value.trim();
-                const role = roleSelect.value;
-                
-                if (!message) {{
-                    return;
-                }}
-                
-                // Add message to chat display immediately
-                this.addMessageToChat(role, message);
-                
-                // Clear input
-                messageInput.value = '';
-                
-                try {{
-                    // Send message to server to convert to action and step
-                    const response = await fetch('/web/step', {{
-                        method: 'POST',
-                        headers: {{ 'Content-Type': 'application/json' }},
-                        body: JSON.stringify({{ 
-                            message: {{
-                                role: role,
-                                content: message
-                            }}
-                        }})
-                    }});
-                    
-                    if (!response.ok) {{
-                        throw new Error(`HTTP error! status: ${{response.status}}`);
-                    }}
-                    
-                    const result = await response.json();
-                    console.log('Message sent:', result);
-                }} catch (error) {{
-                    console.error('Error sending message:', error);
-                    alert('Error sending message: ' + error.message);
-                }}
-            }}
-            
-            addMessageToChat(role, content) {{
-                const chatMessages = document.getElementById('chat-messages');
-                const messageDiv = document.createElement('div');
-                messageDiv.className = `chat-message ${{role}}`;
-                
-                messageDiv.innerHTML = `
-                    <div class="message-role">${{role.charAt(0).toUpperCase() + role.slice(1)}}</div>
-                    <div class="message-content">${{content}}</div>
-                `;
-                
-                chatMessages.appendChild(messageDiv);
-                chatMessages.scrollTop = chatMessages.scrollHeight;
-            }}
-            
-            async submitAction() {{
-                const formData = new FormData(document.getElementById('action-form'));
-                const action = {{}};
-                
-                // Collect form data
-                for (const [key, value] of formData.entries()) {{
-                    if (value !== '') {{
-                        // Handle tensor fields (tokens) - convert comma-separated string to array
-                        if (key === 'tokens') {{
-                            try {{
-                                action[key] = value.split(',').map(x => parseInt(x.trim())).filter(x => !isNaN(x));
-                            }} catch (e) {{
-                                console.error('Error parsing tokens:', e);
-                                action[key] = [];
-                            }}
-                        }} else {{
-                            action[key] = value;
-                        }}
-                    }}
-                }}
-                
-                try {{
-                    const response = await fetch('/web/step', {{
-                        method: 'POST',
-                        headers: {{ 'Content-Type': 'application/json' }},
-                        body: JSON.stringify({{ action }})
-                    }});
-                    
-                    if (!response.ok) {{
-                        throw new Error(`HTTP error! status: ${{response.status}}`);
-                    }}
-                    
-                    const result = await response.json();
-                    console.log('Step result:', result);
-                }} catch (error) {{
-                    console.error('Error submitting action:', error);
-                    alert('Error submitting action: ' + error.message);
-                }}
-            }}
-            
-            async resetEnvironment() {{
-                try {{
-                    const response = await fetch('/web/reset', {{
-                        method: 'POST',
-                        headers: {{ 'Content-Type': 'application/json' }}
-                    }});
-                    
-                    if (!response.ok) {{
-                        throw new Error(`HTTP error! status: ${{response.status}}`);
-                    }}
-                    
-                    const result = await response.json();
-                    console.log('Reset result:', result);
-                }} catch (error) {{
-                    console.error('Error resetting environment:', error);
-                    alert('Error resetting environment: ' + error.message);
-                }}
-            }}
-            
-            async getState() {{
-                try {{
-                    const response = await fetch('/web/state');
-                    const state = await response.json();
-                    console.log('Current state:', state);
-                    alert('Current state: ' + JSON.stringify(state, null, 2));
-                }} catch (error) {{
-                    console.error('Error getting state:', error);
-                    alert('Error getting state: ' + error.message);
-                }}
-            }}
-            
-            updateConnectionStatus(connected) {{
-                const indicator = document.getElementById('connection-status');
-                if (connected) {{
-                    indicator.className = 'status-indicator status-connected';
-                }} else {{
-                    indicator.className = 'status-indicator status-disconnected';
-                }}
-            }}
-            
-            updateUI(episodeState) {{
-                // Check if this is a chat environment
-                const isChatEnv = document.getElementById('chat-messages') !== null;
-                
-                // Update current state
-                document.getElementById('env-status').textContent = 
-                    episodeState.is_reset ? 'Reset' : 'Running';
-                document.getElementById('episode-id').textContent = 
-                    episodeState.episode_id || '-';
-                document.getElementById('step-count').textContent = 
-                    episodeState.step_count.toString();
-                
-                if (isChatEnv) {{
-                    // Update chat interface
-                    this.updateChatInterface(episodeState);
-                }} else {{
-                    // Update traditional observation display
-                    const observationDiv = document.getElementById('current-observation');
-                    if (episodeState.current_observation) {{
-                        observationDiv.textContent = JSON.stringify(
-                            episodeState.current_observation, null, 2
-                        );
-                    }} else {{
-                        observationDiv.textContent = 'No observation yet';
-                    }}
-                }}
-                
-                // Update action logs
-                const logsDiv = document.getElementById('action-logs');
-                if (episodeState.action_logs.length === 0) {{
-                    logsDiv.innerHTML = 'No actions taken yet';
-                }} else {{
-                    logsDiv.innerHTML = episodeState.action_logs.map(log => `
-                        <div class="log-entry">
-                            <div class="log-timestamp">${{log.timestamp}} (Step ${{log.step_count}})</div>
-                            <div class="log-action">Action: ${{JSON.stringify(log.action, null, 2)}}</div>
-                            <div class="log-observation">Observation: ${{JSON.stringify(log.observation, null, 2)}}</div>
-                            <div>
-                                <span class="log-reward">Reward: ${{log.reward !== null ? log.reward : 'None'}}</span>
-                                ${{log.done ? '<span class="log-done">DONE</span>' : ''}}
-                            </div>
-                        </div>
-                    `).join('');
-                }}
-            }}
-            
-            updateChatInterface(episodeState) {{
-                const chatMessages = document.getElementById('chat-messages');
-                if (!chatMessages) return;
-                
-                // Clear existing messages (except system message)
-                const systemMessage = chatMessages.querySelector('.chat-message.system');
-                chatMessages.innerHTML = '';
-                if (systemMessage) {{
-                    chatMessages.appendChild(systemMessage);
-                }}
-                
-                // Add messages from current observation
-                if (episodeState.current_observation && episodeState.current_observation.messages) {{
-                    episodeState.current_observation.messages.forEach(msg => {{
-                        this.addMessageToChat(msg.role, msg.content);
-                    }});
-                }}
-            }}
-        }}
-        
-        // Initialize the web interface when the page loads
-        document.addEventListener('DOMContentLoaded', () => {{
-            new OpenEnvWebInterface();
-        }});
-    </script>
-</body>
-</html>
-    """.replace('{_generate_action_form_fields(action_fields)}', _generate_action_form_fields(action_fields))
-
-
-def _generate_instructions_section(metadata: Optional[EnvironmentMetadata]) -> str:
-    """Generate the instructions section with environment documentation."""
-    if not metadata or not metadata.readme_content:
-        return ''
-    
-    # Convert markdown to HTML (basic conversion)
-    import re
-    html_content = _markdown_to_html(metadata.readme_content)
-    
-    return f'''
-                <!-- Instructions Section -->
-                <div class="instructions-section">
-                    <div class="instructions-header">
-                        <h3 class="instructions-title">{metadata.name}</h3>
-                        <button class="instructions-toggle" id="instructions-toggle">Show Instructions</button>
-                    </div>
-                    <div class="instructions-content" id="instructions-content">
-                        <div class="instructions-readme">
-                            {html_content}
-                        </div>
-                    </div>
-                </div>
-    '''
-
-
-def _extract_action_fields(action_cls: Type[Action]) -> List[Dict[str, Any]]:
-    """Extract enhanced field metadata from Action class for form generation."""
-    import typing
-    from typing import get_origin, get_args
-    
-    action_fields = []
-    if not hasattr(action_cls, '__dataclass_fields__'):
-        return action_fields
-    
-    for field_name, field_info in action_cls.__dataclass_fields__.items():
-        if field_name == 'metadata':
-            continue
-            
-        field_type = field_info.type
-        field_metadata = _extract_field_metadata(field_name, field_info)
-        
-        # Determine input type based on field type
-        input_type = _determine_input_type(field_type)
-        
-        # Check if field is required
-        is_required = field_info.default is field_info.default_factory
-        
-        action_fields.append({
-            'name': field_name,
-            'type': input_type,
-            'required': is_required,
-            'description': field_metadata.get('description', ''),
-            'default_value': field_metadata.get('default_value'),
-            'choices': field_metadata.get('choices', []),
-            'min_value': field_metadata.get('min_value'),
-            'max_value': field_metadata.get('max_value'),
-            'placeholder': field_metadata.get('placeholder', ''),
-            'help_text': field_metadata.get('help_text', ''),
-        })
-    
-    return action_fields
-
-
-def _extract_field_metadata(field_name: str, field_info) -> Dict[str, Any]:
-    """Extract metadata from dataclass field including docstring and type hints."""
-    import typing
-    from typing import get_origin, get_args, Literal, Union, Optional
-    
-    metadata = {}
-    
-    # Extract description from field docstring or annotation
-    if hasattr(field_info, 'metadata') and field_info.metadata:
-        # Check for custom metadata
-        for meta in field_info.metadata:
-            if isinstance(meta, dict):
-                metadata.update(meta)
-    
-    # Extract type information
-    field_type = field_info.type
-    origin = get_origin(field_type)
-    
-    # Handle Literal types for dropdown choices
-    if origin is Literal:
-        args = get_args(field_type)
-        metadata['choices'] = list(args)
-    
-    # Handle Optional types
-    if origin is Union:
-        args = get_args(field_type)
-        if len(args) == 2 and type(None) in args:
-            # This is Optional[SomeType]
-            non_none_type = args[0] if args[1] is type(None) else args[1]
-            metadata['optional'] = True
-            # Recursively check the non-None type for choices
-            if get_origin(non_none_type) is Literal:
-                metadata['choices'] = list(get_args(non_none_type))
-        else:
-            # Regular Union type
-            metadata['choices'] = [str(arg) for arg in args if arg is not type(None)]
-    
-    # Handle numeric constraints
-    if field_type in (int, float):
-        # Check for common constraint patterns in field name
-        if 'count' in field_name.lower() or 'num' in field_name.lower():
-            metadata['min_value'] = 0
-        if 'id' in field_name.lower():
-            metadata['min_value'] = 0
-    
-    # Generate placeholder text
-    if 'message' in field_name.lower():
-        metadata['placeholder'] = f'Enter {field_name.replace("_", " ")}...'
-    elif 'code' in field_name.lower():
-        metadata['placeholder'] = 'Enter Python code here...'
-    elif 'tokens' in field_name.lower():
-        metadata['placeholder'] = 'Enter comma-separated token IDs (e.g., 1,2,3,4,5)'
-    else:
-        metadata['placeholder'] = f'Enter {field_name.replace("_", " ")}...'
-    
-    # Generate help text based on field name and type
-    if 'action_id' in field_name.lower():
-        metadata['help_text'] = 'The action ID to execute in the environment'
-    elif 'game_name' in field_name.lower():
-        metadata['help_text'] = 'Name of the game or environment'
-    elif 'tokens' in field_name.lower():
-        metadata['help_text'] = 'Token IDs as a comma-separated list of integers'
-    elif 'code' in field_name.lower():
-        metadata['help_text'] = 'Python code to execute in the environment'
-    elif 'message' in field_name.lower():
-        metadata['help_text'] = 'Text message to send'
-    
-    return metadata
-
-
-def _determine_input_type(field_type) -> str:
-    """Determine the appropriate HTML input type for a field type."""
-    import typing
-    from typing import get_origin, get_args, Literal, Union
-    
-    # Handle direct types
-    if field_type == str:
-        return "text"
-    elif field_type == int:
-        return "number"
-    elif field_type == float:
-        return "number"
-    elif field_type == bool:
-        return "checkbox"
-    
-    # Handle complex types
-    origin = get_origin(field_type)
-    
-    if origin is Literal:
-        return "select"
-    elif origin is Union:
-        args = get_args(field_type)
-        if len(args) == 2 and type(None) in args:
-            # Optional type - use the non-None type
-            non_none_type = args[0] if args[1] is type(None) else args[1]
-            return _determine_input_type(non_none_type)
-        elif all(isinstance(arg, str) for arg in args if arg is not type(None)):
-            return "select"
-        else:
-            return "text"
-    elif hasattr(field_type, '__name__') and 'Tensor' in field_type.__name__:
-        return "tensor"
-    else:
-        return "text"
-
-
-def _markdown_to_html(markdown: str) -> str:
-    """Convert basic markdown to HTML for README display."""
-    import html
-    import re
-    
-    # Escape HTML first
-    html_content = html.escape(markdown)
-    
-    # Convert headers
-    html_content = re.sub(r'^# (.*?)$', r'<h1>\1</h1>', html_content, flags=re.MULTILINE)
-    html_content = re.sub(r'^## (.*?)$', r'<h2>\1</h2>', html_content, flags=re.MULTILINE)
-    html_content = re.sub(r'^### (.*?)$', r'<h3>\1</h3>', html_content, flags=re.MULTILINE)
-    
-    # Convert code blocks
-    html_content = re.sub(r'```(.*?)\n(.*?)\n```', r'<pre><code>\2</code></pre>', html_content, flags=re.DOTALL)
-    html_content = re.sub(r'`([^`]+)`', r'<code>\1</code>', html_content)
-    
-    # Convert bold and italic
-    html_content = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', html_content)
-    html_content = re.sub(r'\*(.*?)\*', r'<em>\1</em>', html_content)
-    
-    # Convert lists
-    html_content = re.sub(r'^- (.*?)$', r'<li>\1</li>', html_content, flags=re.MULTILINE)
-    html_content = re.sub(r'(<li>.*</li>)', r'<ul>\1</ul>', html_content, flags=re.DOTALL)
-    
-    # Convert line breaks
-    html_content = html_content.replace('\n', '<br>')
-    
-    return html_content
-
-
-def _generate_action_interface(action_fields: List[Dict[str, Any]], is_chat_env: bool) -> str:
-    """Generate either a chat interface or action form based on environment type."""
-    if is_chat_env:
-        return _generate_chat_interface()
-    else:
-        return _generate_action_form(action_fields)
-
-def _generate_chat_interface() -> str:
-    """Generate a chat-style interface for chat environments."""
-    return '''
-                <!-- Chat Interface -->
-                <div class="chat-interface">
-                    <h3>Chat Interface</h3>
-                    <div class="chat-messages" id="chat-messages">
-                        <div class="chat-message system">
-                            <div class="message-role">System</div>
-                            <div class="message-content">Chat environment ready. Send a message to start the conversation.</div>
-                        </div>
-                    </div>
-                    <div class="chat-input-container">
-                        <div class="role-selector">
-                            <label for="message-role">Role:</label>
-                            <select id="message-role">
-                                <option value="user">User</option>
-                                <option value="assistant">Assistant</option>
-                            </select>
-                        </div>
-                        <div class="message-input">
-                            <textarea id="message-input" placeholder="Type your message here..." rows="3"></textarea>
-                            <button class="btn" id="send-message-btn">Send Message</button>
-                        </div>
-                    </div>
-                </div>
-    '''
-
-def _generate_action_form(action_fields: List[Dict[str, Any]]) -> str:
-    """Generate a traditional action form for non-chat environments."""
-    return f'''
-                <!-- Action Form -->
-                <div class="action-form">
-                    <h3>Take Action</h3>
-                    <form id="action-form">
-                        {_generate_action_form_fields(action_fields)}
-                        <button type="submit" class="btn" id="step-btn">Step</button>
-                    </form>
-                </div>
-    '''
-
-def _generate_action_form_fields(action_fields: List[Dict[str, Any]]) -> str:
-    """Generate HTML form fields for action input with enhanced metadata."""
-    if not action_fields:
-        return '<p>No action fields available</p>'
-    
-    fields_html = []
-    for field in action_fields:
-        field_html = _generate_single_field(field)
-        fields_html.append(field_html)
-    
-    return '\n'.join(fields_html)
-
-
-def _generate_single_field(field: Dict[str, Any]) -> str:
-    """Generate HTML for a single form field with enhanced metadata."""
-    field_name = field['name']
-    field_type = field['type']
-    required = field['required']
-    placeholder = field.get('placeholder', '')
-    help_text = field.get('help_text', '')
-    choices = field.get('choices', [])
-    min_value = field.get('min_value')
-    max_value = field.get('max_value')
-    default_value = field.get('default_value')
-    
-    # Build label with required indicator
-    label_text = field_name.replace('_', ' ').title()
-    if required:
-        label_text += ' <span style="color: red;">*</span>'
-    
-    # Build input attributes
-    input_attrs = []
-    if required:
-        input_attrs.append('required')
-    if placeholder:
-        input_attrs.append(f'placeholder="{placeholder}"')
-    if min_value is not None:
-        input_attrs.append(f'min="{min_value}"')
-    if max_value is not None:
-        input_attrs.append(f'max="{max_value}"')
-    if default_value is not None:
-        input_attrs.append(f'value="{default_value}"')
-    
-    attrs_str = ' '.join(input_attrs)
-    
-    if field_type == 'checkbox':
-        return f'''
-            <div class="form-group">
-                <label>
-                    <input type="checkbox" name="{field_name}" value="true" {attrs_str}>
-                    {label_text}
-                </label>
-                {f'<small class="help-text">{help_text}</small>' if help_text else ''}
-            </div>
-        '''
-    
-    elif field_type == 'select':
-        options_html = []
-        if not required:
-            options_html.append(f'<option value="">-- Select {label_text} --</option>')
-        
-        for choice in choices:
-            selected = 'selected' if str(choice) == str(default_value) else ''
-            options_html.append(f'<option value="{choice}" {selected}>{choice}</option>')
-        
-        return f'''
-            <div class="form-group">
-                <label for="{field_name}">{label_text}:</label>
-                <select name="{field_name}" id="{field_name}" {attrs_str}>
-                    {''.join(options_html)}
-                </select>
-                {f'<small class="help-text">{help_text}</small>' if help_text else ''}
-            </div>
-        '''
-    
-    elif field_type == 'tensor':
-        return f'''
-            <div class="form-group">
-                <label for="{field_name}">{label_text} (comma-separated integers):</label>
-                <input type="text" name="{field_name}" id="{field_name}" {attrs_str}>
-                <small class="help-text">{help_text or 'Enter token IDs as comma-separated integers (e.g., 1,2,3,4,5)'}</small>
-            </div>
-        '''
-    
-    elif field_type == 'text' and ('message' in field_name.lower() or 'code' in field_name.lower()):
-        return f'''
-            <div class="form-group">
-                <label for="{field_name}">{label_text}:</label>
-                <textarea name="{field_name}" id="{field_name}" rows="3" {attrs_str}></textarea>
-                {f'<small class="help-text">{help_text}</small>' if help_text else ''}
-            </div>
-        '''
-    
-    else:
-        return f'''
-            <div class="form-group">
-                <label for="{field_name}">{label_text}:</label>
-                <input type="{field_type}" name="{field_name}" id="{field_name}" {attrs_str}>
-                {f'<small class="help-text">{help_text}</small>' if help_text else ''}
-            </div>
-        '''

openenv/src/core/http_env_client.py

@@ -1,203 +0,0 @@
-"""
-core/runner_env.py
-Minimal HTTP-based environment client.
-- Talks to a single env worker exposing: POST /reset, POST /step
-
-Future hooks (commented below) for:
-- episode_id, seed on reset
-- request_id on step
-- custom headers (auth/trace)
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Any, Dict, Generic, Optional, Type, TYPE_CHECKING, TypeVar
-
-import requests
-
-from .client_types import StepResult
-from .containers.runtime import LocalDockerProvider
-
-if TYPE_CHECKING:
-    from .containers.runtime import ContainerProvider
-
-ActT = TypeVar("ActT")
-ObsT = TypeVar("ObsT")
-EnvClientT = TypeVar("EnvClientT", bound="HTTPEnvClient")
-
-
-class HTTPEnvClient(ABC, Generic[ActT, ObsT]):
-    def __init__(
-        self,
-        base_url: str,
-        request_timeout_s: float = 15.0,
-        default_headers: Optional[Dict[str, str]] = None,
-        provider: Optional["ContainerProvider"] = None,
-    ):
-        self._base = base_url.rstrip("/")
-        self._timeout = float(request_timeout_s)
-        self._http = requests.Session()
-        self._headers = default_headers or {}
-        self._provider = provider
-
-    @classmethod
-    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 locally.
-
-        This is a development utility that:
-        1. Starts a Docker container from the specified image
-        2. Waits for the server to be ready
-        3. Creates and returns a client instance connected to the container
-
-        Note: The container lifecycle management is left to the user or higher-level
-        orchestration. The container will keep running until manually stopped.
-
-        Args:
-            image: Docker image name to run (e.g., "echo-env:latest")
-            provider: Container provider to use (defaults to LocalDockerProvider)
-            **kwargs: Additional arguments to pass to provider.start_container()
-                     (e.g., env_vars, port)
-
-        Returns:
-            An instance of the client class connected to the running container
-
-        Example:
-            >>> from envs.coding_env.client import CodingEnv
-            >>> from envs.coding_env.models import CodeAction
-            >>>
-            >>> # Create environment from image
-            >>> env = CodingEnv.from_docker_image("coding-env:latest")
-            >>>
-            >>> # Create environment with custom env vars
-            >>> env = CodingEnv.from_docker_image(
-            ...     "coding-env:latest",
-            ...     env_vars={"MY_VAR": "value"}
-            ... )
-            >>>
-            >>> # Use the environment
-            >>> result = env.reset()
-            >>> print(result.observation)
-            >>>
-            >>> step_result = env.step(CodeAction(code="print('hello')"))
-            >>> print(step_result.observation.stdout)
-            >>>
-            >>> # Cleanup (optional)
-            >>> env.close()
-        """
-
-        # Use default provider if none provided
-        if provider is None:
-            provider = LocalDockerProvider()
-
-        # 1. Start container with optional kwargs (e.g., env_vars, port)
-        base_url = provider.start_container(image, **kwargs)
-
-        # 2. Wait for server to be ready
-        provider.wait_for_ready(base_url)
-
-        # 3. Create and return client instance with provider reference
-        return cls(base_url=base_url, provider=provider)
-
-    @classmethod
-    def from_hub(cls: Type[EnvClientT], repo_id: str, provider: Optional["ContainerProvider"] = None, **kwargs: Any) -> EnvClientT:
-        """
-        Create an environment client by pulling from a Hugging Face model hub.
-        """
-        
-        if provider is None:
-            provider = LocalDockerProvider()
-        
-        if "tag" in kwargs:
-            tag = kwargs["tag"]
-        else:
-            tag = "latest"
-        
-        base_url = f"registry.hf.space/{repo_id.replace('/', '-')}:{tag}"
-        
-        return cls.from_docker_image(image=base_url, provider=provider)
-
-    @abstractmethod
-    def _step_payload(self, action: ActT) -> dict:
-        """Convert an Action object to the JSON body expected by the env server."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def _parse_result(self, payload: dict) -> StepResult[ObsT]:
-        """Convert a JSON response from the env server to StepResult[ObsT]."""
-        raise NotImplementedError
-
-    @abstractmethod
-    def _parse_state(self, payload: dict) -> Any:
-        """Convert a JSON response from the state endpoint to a State object."""
-        raise NotImplementedError
-
-    # ---------- Environment Server Interface Methods ----------
-    def reset(self) -> StepResult[ObsT]:
-        body: Dict[str, Any] = {}
-        # TODO: later:
-        # body["seed"] = seed
-        # body["episode_id"] = episode_id
-        r = self._http.post(
-            f"{self._base}/reset",
-            json=body,
-            headers=self._headers,
-            timeout=self._timeout,
-        )
-        r.raise_for_status()
-        return self._parse_result(r.json())
-
-    def step(self, action: ActT) -> StepResult[ObsT]:
-        body: Dict[str, Any] = {
-            "action": self._step_payload(action),
-            "timeout_s": int(self._timeout),
-        }
-        # TODO: later:
-        # body["request_id"] = str(uuid.uuid4())
-        # body["episode_id"] = current_episode_id
-        r = self._http.post(
-            f"{self._base}/step",
-            json=body,
-            headers=self._headers,
-            timeout=self._timeout,
-        )
-        r.raise_for_status()
-        return self._parse_result(r.json())
-
-    def state(self) -> Any:
-        """
-        Get the current environment state from the server.
-
-        Returns:
-            State object with environment state information (e.g., episode_id, step_count)
-
-        Example:
-            >>> client = EchoEnv.from_docker_image("echo-env:latest")
-            >>> result = client.reset()
-            >>> state = client.state()
-            >>> print(state.episode_id)
-            >>> print(state.step_count)
-        """
-        r = self._http.get(
-            f"{self._base}/state",
-            headers=self._headers,
-            timeout=self._timeout,
-        )
-        r.raise_for_status()
-        return self._parse_state(r.json())
-
-    def close(self) -> None:
-        """
-        Close the environment and clean up resources.
-
-        If this client was created via from_docker_image(), this will stop
-        and remove the associated container.
-        """
-        if self._provider is not None:
-            self._provider.stop_container()

openenv/src/core/tools/__init__.py

@@ -1,16 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""Core tools for code execution and other utilities."""
-
-from .git_server_client import GitServerClient, RepoInfo
-from .local_python_executor import PyExecutor
-
-__all__ = [
-    "PyExecutor",
-    "GitServerClient",
-    "RepoInfo",
-]

openenv/src/core/tools/git_server_client.py

@@ -1,362 +0,0 @@
-#!/usr/bin/env python3
-"""
-Git Server Client for connecting to external Gitea instance.
-
-This module provides a lightweight client for interacting with a shared
-Gitea service, optimized for task-based isolation where multiple environment
-instances share the same Gitea server but have isolated workspaces.
-"""
-
-import json
-import os
-import shutil
-import subprocess
-import time
-from dataclasses import dataclass
-from pathlib import Path
-from urllib.parse import urlparse
-
-
-@dataclass
-class RepoInfo:
-    """Information about a repository."""
-
-    name: str
-    url: str
-    commit: str
-    clone_url: str
-
-
-class GitServerClient:
-    """
-    Client for connecting to an external Gitea server.
-
-    This client is optimized for task-based isolation where:
-    - Multiple tasks share the same Gitea instance
-    - Each task has its own isolated workspace
-    - Fast reset() via git operations (no server restart)
-    - Repos are pre-migrated to Gitea once
-
-    Args:
-        gitea_url: URL of the Gitea server (e.g., "http://gitea:3000")
-        username: Gitea username for authentication
-        password: Gitea password for authentication
-        workspace_dir: Local workspace directory for cloning repos
-
-    Example:
-        >>> # Connect to shared Gitea (credentials from environment)
-        >>> import os
-        >>> client = GitServerClient(
-        ...     gitea_url=os.getenv("GITEA_URL"),
-        ...     username=os.getenv("GITEA_USERNAME"),
-        ...     password=os.getenv("GITEA_PASSWORD")
-        ... )
-        >>> client.wait_for_ready()
-        >>> # Clone repo to workspace
-        >>> path = client.clone_to_workspace("my-repo", commit="abc123")
-        >>> # Fast reset to base state
-        >>> client.reset_workspace("my-repo", commit="abc123")
-    """
-
-    def __init__(
-        self,
-        gitea_url: str,
-        username: str,
-        password: str,
-        workspace_dir: str = "/workspace",
-    ):
-        """Initialize Git Server Client."""
-        self.gitea_url = gitea_url.rstrip("/")
-        self.username = username
-        self.password = password
-        self.workspace_dir = Path(workspace_dir)
-        self.is_ready = False
-
-        # Parse Gitea URL
-        parsed = urlparse(self.gitea_url)
-        self.domain = parsed.hostname or "localhost"
-        self.port = parsed.port or 3000
-
-        # Ensure workspace exists
-        os.makedirs(self.workspace_dir, exist_ok=True)
-
-        # Configure git credentials
-        self._configure_git()
-
-    def _configure_git(self):
-        """Configure git credentials for automatic authentication."""
-        home_dir = Path.home()
-
-        # Git config
-        git_config = f"""[user]
-    name = {self.username}
-    email = {self.username}@local.env
-[init]
-    defaultBranch = main
-[credential]
-    helper = store
-"""
-        gitconfig_path = home_dir / ".gitconfig"
-        gitconfig_path.write_text(git_config)
-
-        # Git credentials
-        git_credentials = f"http://{self.username}:{self.password}@{self.domain}:{self.port}\n"
-        gitcreds_path = home_dir / ".git-credentials"
-        gitcreds_path.write_text(git_credentials)
-        gitcreds_path.chmod(0o600)
-
-    def wait_for_ready(self, timeout: int = 30) -> bool:
-        """
-        Wait for Gitea server to be ready.
-
-        Args:
-            timeout: Maximum seconds to wait
-
-        Returns:
-            True if server is ready, False otherwise
-        """
-        start_time = time.time()
-        while time.time() - start_time < timeout:
-            try:
-                result = subprocess.run(
-                    ["curl", "-sf", f"{self.gitea_url}/"],
-                    capture_output=True,
-                    timeout=5,
-                )
-                if result.returncode == 0:
-                    self.is_ready = True
-                    return True
-            except subprocess.TimeoutExpired:
-                pass
-            except Exception:
-                pass
-
-            time.sleep(1)
-
-        return False
-
-    def list_repositories(self) -> list[dict[str, str]]:
-        """
-        List all repositories in Gitea.
-
-        Returns:
-            List of repository information dictionaries
-        """
-        if not self.is_ready:
-            raise RuntimeError("Gitea server is not ready")
-
-        result = subprocess.run(
-            [
-                "curl",
-                "-s",
-                f"{self.gitea_url}/api/v1/user/repos",
-                "-u",
-                f"{self.username}:{self.password}",
-            ],
-            capture_output=True,
-            text=True,
-        )
-
-        if result.returncode != 0:
-            return []
-
-        try:
-            repos = json.loads(result.stdout)
-            return [
-                {
-                    "name": repo["name"],
-                    "full_name": repo["full_name"],
-                    "clone_url": repo["clone_url"],
-                    "description": repo.get("description", ""),
-                }
-                for repo in repos
-            ]
-        except (json.JSONDecodeError, KeyError):
-            return []
-
-    def clone_to_workspace(
-        self, repo_name: str, target_dir: str | None = None, commit: str = "main"
-    ) -> str:
-        """
-        Clone a repository to the workspace at a specific commit.
-
-        This creates a fresh clone optimized for task isolation.
-
-        Args:
-            repo_name: Name of repository to clone
-            target_dir: Target directory name (defaults to repo_name)
-            commit: Commit hash or branch to check out
-
-        Returns:
-            Path to cloned repository
-
-        Raises:
-            RuntimeError: If clone fails
-        """
-        if not self.is_ready:
-            raise RuntimeError("Gitea server is not ready")
-
-        target_dir = target_dir or repo_name
-        target_path = self.workspace_dir / target_dir
-
-        # Remove existing directory if present
-        if target_path.exists():
-            shutil.rmtree(target_path)
-
-        clone_url = f"{self.gitea_url}/{self.username}/{repo_name}.git"
-
-        # Clone repository
-        result = subprocess.run(
-            ["git", "clone", clone_url, str(target_path)],
-            capture_output=True,
-            text=True,
-        )
-
-        if result.returncode != 0:
-            raise RuntimeError(f"Clone failed: {result.stderr}")
-
-        # Checkout specific commit
-        if commit != "main":
-            result = subprocess.run(
-                ["git", "checkout", commit],
-                cwd=str(target_path),
-                capture_output=True,
-                text=True,
-            )
-
-            if result.returncode != 0:
-                raise RuntimeError(f"Checkout failed: {result.stderr}")
-
-        return str(target_path)
-
-    def reset_workspace(self, repo_name: str, commit: str = "main") -> bool:
-        """
-        Fast reset of workspace to base state (optimized for task resets).
-
-        This is much faster than re-cloning. It:
-        1. Checks out the target commit
-        2. Resets to that commit (hard)
-        3. Cleans untracked files
-
-        Args:
-            repo_name: Name of repository (directory in workspace)
-            commit: Commit hash or branch to reset to
-
-        Returns:
-            True if reset successful
-
-        Raises:
-            RuntimeError: If reset fails
-        """
-        repo_path = self.workspace_dir / repo_name
-
-        if not repo_path.exists():
-            raise RuntimeError(f"Repository not found in workspace: {repo_name}")
-
-        # Fetch latest (in case commit is new)
-        subprocess.run(
-            ["git", "fetch", "--all"],
-            cwd=str(repo_path),
-            capture_output=True,
-        )
-
-        # Checkout and hard reset to commit
-        result = subprocess.run(
-            ["git", "checkout", commit],
-            cwd=str(repo_path),
-            capture_output=True,
-            text=True,
-        )
-
-        if result.returncode != 0:
-            raise RuntimeError(f"Checkout failed: {result.stderr}")
-
-        result = subprocess.run(
-            ["git", "reset", "--hard", f"origin/{commit}" if commit != "main" else commit],
-            cwd=str(repo_path),
-            capture_output=True,
-            text=True,
-        )
-
-        if result.returncode != 0:
-            # Try without origin/ prefix
-            result = subprocess.run(
-                ["git", "reset", "--hard", commit],
-                cwd=str(repo_path),
-                capture_output=True,
-                text=True,
-            )
-            if result.returncode != 0:
-                raise RuntimeError(f"Reset failed: {result.stderr}")
-
-        # Clean untracked files and directories
-        subprocess.run(
-            ["git", "clean", "-fdx"],
-            cwd=str(repo_path),
-            capture_output=True,
-        )
-
-        return True
-
-    def execute_git_command(
-        self, command: str, working_dir: str = ""
-    ) -> tuple[int, str, str]:
-        """
-        Execute a git command in the workspace.
-
-        Args:
-            command: Git command to execute (without 'git' prefix)
-            working_dir: Working directory relative to workspace
-
-        Returns:
-            Tuple of (exit_code, stdout, stderr)
-        """
-        work_path = (
-            self.workspace_dir / working_dir if working_dir else self.workspace_dir
-        )
-
-        if not work_path.exists():
-            return (1, "", f"Working directory does not exist: {work_path}")
-
-        # Split command safely
-        cmd_parts = ["git"] + command.split()
-
-        result = subprocess.run(
-            cmd_parts,
-            cwd=str(work_path),
-            capture_output=True,
-            text=True,
-        )
-
-        return (result.returncode, result.stdout, result.stderr)
-
-    def get_current_commit(self, repo_name: str) -> str:
-        """
-        Get current commit hash of a workspace repository.
-
-        Args:
-            repo_name: Name of repository in workspace
-
-        Returns:
-            Commit hash
-        """
-        repo_path = self.workspace_dir / repo_name
-
-        if not repo_path.exists():
-            raise RuntimeError(f"Repository not found: {repo_name}")
-
-        result = subprocess.run(
-            ["git", "rev-parse", "HEAD"],
-            cwd=str(repo_path),
-            capture_output=True,
-            text=True,
-        )
-
-        if result.returncode != 0:
-            raise RuntimeError(f"Failed to get commit: {result.stderr}")
-
-        return result.stdout.strip()
-
-    def workspace_exists(self, repo_name: str) -> bool:
-        """Check if a repository exists in workspace."""
-        return (self.workspace_dir / repo_name).exists()

openenv/src/core/tools/local_python_executor.py

@@ -1,152 +0,0 @@
-# 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.
-
-"""Local Python Executor (enhanced).
-
-This module provides a safer wrapper around smolagents.LocalPythonExecutor
-with improved exception handling and a few helpful tools registered with
-the executor to make debugging executed code easier.
-
-Key improvements:
-- Register a few helper utilities via send_tools so user code can use
-  them for reporting (e.g. `format_exc`).
-- More robust extraction of stdout/stderr/exit codes from the executor
-  result object, tolerant to different versions of smolagents.
-- Detailed stderr on unexpected exceptions including full traceback.
-- Structured logging for operational visibility.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import traceback
-from typing import Any
-
-from smolagents import LocalPythonExecutor
-
-from core.env_server.types import CodeExecResult
-
-logger = logging.getLogger(__name__)
-logger.addHandler(logging.NullHandler())
-
-
-class PyExecutor:
-    """Wrapper around smolagents LocalPythonExecutor.
-
-    The wrapper registers a few non-privileged helper tools to the
-    LocalPythonExecutor that can be used by the executed code to
-    format exceptions and to safely stringify results for improved
-    error reporting.
-    """
-
-    def __init__(self, additional_imports: list[str] | None = None):
-        if additional_imports is None:
-            additional_imports = []
-
-        self._executor = LocalPythonExecutor(
-            additional_authorized_imports=additional_imports
-        )
-
-        # Register helpful utilities exposed to the execution environment.
-        # These are intentionally small, read-only helpers.
-        tools = {
-            # Provide a small helper to format the current exception in the
-            # executed context. This is a *string formatting* helper only.
-            "format_exc": traceback.format_exc,
-            # Safe JSON dumps with a fallback for non-serializable objects.
-            "safe_json_dumps": lambda obj: json.dumps(obj, default=lambda o: repr(o)),
-        }
-
-        # `send_tools` is the public API on LocalPythonExecutor to make
-        # helper callables available to the sandboxed runtime. We don't
-        # provide any builtins that could change the environment.
-        try:
-            self._executor.send_tools(tools)
-        except Exception:
-            # If the LocalPythonExecutor implementation doesn't support
-            # send_tools or fails, log and continue — the executor is still usable.
-            logger.debug("LocalPythonExecutor.send_tools failed; continuing without extra tools", exc_info=True)
-
-    def run(self, code: str) -> CodeExecResult:
-        """Execute Python code and return a CodeExecResult.
-
-        This method is intentionally defensive: it attempts to extract
-        meaningful stdout/stderr/exit_code information from a variety of
-        possible return shapes that different versions of smolagents
-        may provide.
-        """
-        try:
-            exec_result = self._executor(code)
-
-            # Default values
-            stdout_parts: list[str] = []
-            stderr_parts: list[str] = []
-            exit_code = 0
-
-            # Extract logs/prints
-            try:
-                logs = getattr(exec_result, "logs", None)
-                if logs:
-                    stdout_parts.append(str(logs))
-            except Exception:
-                logger.debug("Failed to read exec_result.logs", exc_info=True)
-
-            # Extract the result / output value
-            try:
-                if hasattr(exec_result, "output"):
-                    out_val = exec_result.output
-                    # If the output is not None, stringify it in a safe way
-                    if out_val is not None:
-                        # Prefer JSON if possible, otherwise repr
-                        try:
-                            stdout_parts.append(json.dumps(out_val))
-                        except Exception:
-                            stdout_parts.append(repr(out_val))
-            except Exception:
-                logger.debug("Failed to read exec_result.output", exc_info=True)
-
-            # Some runtime implementations may put errors on `error` or `exception`
-            try:
-                err = getattr(exec_result, "error", None)
-                if err:
-                    stderr_parts.append(str(err))
-            except Exception:
-                logger.debug("Failed to read exec_result.error", exc_info=True)
-
-            try:
-                ex = getattr(exec_result, "exception", None)
-                if ex:
-                    stderr_parts.append(str(ex))
-            except Exception:
-                logger.debug("Failed to read exec_result.exception", exc_info=True)
-
-            # Determine exit code if provided
-            try:
-                if hasattr(exec_result, "exit_code"):
-                    exit_code = int(exec_result.exit_code) if exec_result.exit_code is not None else 0
-                elif hasattr(exec_result, "success"):
-                    # Some versions use `success` boolean
-                    exit_code = 0 if exec_result.success else 1
-                else:
-                    # Fallback: if there were any stderr parts, treat as non-zero
-                    exit_code = 1 if stderr_parts else 0
-            except Exception:
-                logger.debug("Failed to determine exec_result exit code", exc_info=True)
-                exit_code = 1 if stderr_parts else 0
-
-            # Compose the final stdout/stderr strings
-            stdout = "\n".join(part for part in stdout_parts if part is not None)
-            stderr = "\n".join(part for part in stderr_parts if part is not None)
-
-            return CodeExecResult(stdout=stdout, stderr=stderr, exit_code=exit_code)
-
-        except Exception as e:
-            # Any unexpected exception from the LocalPythonExecutor is
-            # returned with a full traceback to make debugging easier.
-            tb = traceback.format_exc()
-            logger.exception("LocalPythonExecutor raised an exception during run")
-            return CodeExecResult(stdout="", stderr=tb, exit_code=1)

openenv/src/envs/README.md

@@ -1,382 +0,0 @@
-# Building Your Own Environment
-
-This guide shows you how to create a custom environment using the EnvTorch framework.
-
-## Overview
-
-Creating an environment involves five main steps:
-1. Define your models (Action, Observation, State)
-2. Implement the environment APIs: step, reset, state
-3. Create the FastAPI server
-4. Build a Docker image and push it to a public docker repo for community to access it
-5. Subclass HTTPEnvclient and implement the parsing methods for result and state.
-
-## Step-by-Step Guide
-
-### 1. Define Models
-
-Create your action, observation, and state models using Python dataclasses:
-
-```python
-# models.py
-from dataclasses import dataclass
-from core.env_server import Action, Observation, State
-
-@dataclass
-class MyAction(Action):
-    """Your custom action."""
-    command: str
-    parameters: dict
-
-@dataclass
-class MyObservation(Observation):
-    """Your custom observation."""
-    result: str
-    success: bool
-
-@dataclass
-class MyState(State):
-    """Custom state fields."""
-    custom_field: int = 0
-```
-
-### 2. Implement Environment
-
-Implement the three core methods: `reset()`, `step()`, and `state`:
-
-```python
-# server/my_environment.py
-import uuid
-from core.env_server import Environment
-from ..models import MyAction, MyObservation, MyState
-
-class MyEnvironment(Environment):
-    def __init__(self):
-        super().__init__()
-        self._state = MyState()
-
-    def reset(self) -> MyObservation:
-        self._state = MyState(episode_id=str(uuid.uuid4()))
-        return MyObservation(result="Ready", success=True)
-
-    def step(self, action: MyAction) -> MyObservation:
-        # Implement your logic here
-        self._state.step_count += 1
-        result = self._execute_command(action.command)
-        return MyObservation(result=result, success=True)
-
-    @property
-    def state(self) -> MyState:
-        return self._state
-```
-
-### 3. Create FastAPI Server
-
-Use the `create_fastapi_app` helper to create your HTTP server:
-
-```python
-# server/app.py
-from core.env_server import create_fastapi_app
-from ..models import MyAction, MyObservation
-from .my_environment import MyEnvironment
-
-env = MyEnvironment()
-app = create_fastapi_app(env, MyAction, MyObservation)
-```
-
-### 4. Define Dependencies
-
-**For Python-only dependencies (most common case):**
-
-Create `src/envs/my_env/server/requirements.txt`:
-```txt
-your-package>=1.0.0
-another-package
-```
-
-**For complex setup (optional, only if needed):**
-
-If you need additional setup beyond pip install, create `src/envs/my_env/server/install_deps.sh`:
-```bash
-#!/bin/bash
-set -e
-
-# Install Python dependencies
-pip install --no-cache-dir -r /tmp/requirements.txt
-
-# Additional setup commands (only if needed)
-mkdir -p /some/directory
-# ... other setup steps
-```
-
-### 5. Create Dockerfile
-
-Build your Docker image from the openenv-base. Place this at `src/envs/my_env/server/Dockerfile`:
-
-**Simple case (just requirements.txt):**
-```dockerfile
-# Accept base image as build argument for CI/CD flexibility
-ARG BASE_IMAGE=openenv-base:latest
-FROM ${BASE_IMAGE}
-
-# Install dependencies
-COPY src/envs/my_env/server/requirements.txt /tmp/requirements.txt
-RUN pip install --no-cache-dir -r /tmp/requirements.txt && rm /tmp/requirements.txt
-
-# Copy environment code
-COPY src/core/ /app/src/core/
-COPY src/envs/my_env/ /app/src/envs/my_env/
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:8000/health || exit 1
-
-# Run server
-CMD ["uvicorn", "envs.my_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]
-```
-
-**Complex case (requirements.txt + install_deps.sh):**
-```dockerfile
-ARG BASE_IMAGE=openenv-base:latest
-FROM ${BASE_IMAGE}
-
-# Install dependencies and run setup
-COPY src/envs/my_env/server/requirements.txt /tmp/requirements.txt
-COPY src/envs/my_env/server/install_deps.sh /tmp/install_deps.sh
-RUN chmod +x /tmp/install_deps.sh && \
-    /tmp/install_deps.sh && \
-    rm /tmp/install_deps.sh /tmp/requirements.txt
-
-# Copy environment code
-COPY src/core/ /app/src/core/
-COPY src/envs/my_env/ /app/src/envs/my_env/
-
-# Health check
-HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:8000/health || exit 1
-
-# Run server
-CMD ["uvicorn", "envs.my_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]
-```
-
-### 5. Update GitHub Actions Workflow
-
-**Important**: To enable automatic Docker image builds on GitHub, add your environment to the workflow matrix.
-
-Edit `.github/workflows/docker-build.yml` and add your environment to the matrix:
-
-```yaml
-strategy:
-  matrix:
-    image:
-      - name: echo-env
-        dockerfile: src/envs/echo_env/server/Dockerfile
-      - name: chat-env
-        dockerfile: src/envs/chat_env/server/Dockerfile
-      - name: coding-env
-        dockerfile: src/envs/coding_env/server/Dockerfile
-      - name: my-env  # Add your environment here
-        dockerfile: src/envs/my_env/server/Dockerfile
-```
-
-Once added, every push to `main` will automatically:
-- Build your Docker image
-- Push it to GitHub Container Registry as `ghcr.io/YOUR_USERNAME/openenv-my-env:latest`
-
-### 6. Implement Client
-
-Create a client that extends `HTTPEnvClient`:
-
-```python
-# client.py
-from core.http_env_client import HTTPEnvClient
-from core.types import StepResult
-from .models import MyAction, MyObservation, MyState
-
-class MyEnv(HTTPEnvClient[MyAction, MyObservation]):
-    def _step_payload(self, action: MyAction) -> dict:
-        return {"command": action.command, "parameters": action.parameters}
-
-    def _parse_result(self, payload: dict) -> StepResult[MyObservation]:
-        obs = MyObservation(**payload["observation"])
-        return StepResult(
-            observation=obs,
-            reward=payload.get("reward"),
-            done=payload.get("done", False),
-        )
-
-    def _parse_state(self, payload: dict) -> MyState:
-        return MyState(**payload)
-```
-
-## Building and Using Your Environment
-
-### Build Docker Images
-
-```bash
-# First, build the base image (if not already built)
-docker build -t openenv-base:latest -f src/core/containers/images/Dockerfile .
-
-# Then build your environment image
-docker build -t my-env:latest -f src/envs/my_env/server/Dockerfile .
-```
-
-### Use Your Environment
-
-```python
-from envs.my_env import MyAction, MyEnv
-
-# Create environment from Docker image
-client = MyEnv.from_docker_image("my-env:latest")
-
-# Reset
-result = client.reset()
-print(result.observation.result)  # "Ready"
-
-# Execute actions
-result = client.step(MyAction(command="test", parameters={}))
-print(result.observation.result)
-print(result.observation.success)
-
-# Get state
-state = client.state()
-print(state.episode_id)
-print(state.step_count)
-
-# Cleanup
-client.close()
-```
-
-## Project Structure
-
-Organize your environment following this structure:
-
-```
-src/envs/my_env/
-├── __init__.py           # Export MyAction, MyObservation, MyState, MyEnv
-├── models.py             # Action, Observation, State definitions
-├── client.py             # MyEnv client implementation
-├── README.md             # Environment documentation
-└── server/
-    ├── __init__.py
-    ├── my_environment.py # Environment logic
-    ├── app.py            # FastAPI application
-    └── Dockerfile        # Docker image definition
-```
-
-## Example Environments
-
-Study these examples to see the patterns in action:
-
-### Echo Environment
-Location: `src/envs/echo_env/`
-
-A minimal environment that echoes messages back. Great for:
-- Learning the basics
-- Testing infrastructure
-- Reference implementation
-
-See: [`echo_env/README.md`](echo_env/README.md)
-
-### Coding Environment
-Location: `src/envs/coding_env/`
-
-Executes Python code in a sandboxed environment. Demonstrates:
-- Complex environment logic
-- Error handling
-- External tool integration (smolagents)
-
-See: [`coding_env/README.md`](coding_env/README.md)
-
-## Best Practices
-
-### 1. Type Safety
-Always use typed dataclasses for actions, observations, and state:
-```python
-@dataclass
-class MyAction(Action):
-    command: str  # Use explicit types
-    count: int = 0  # Provide defaults when appropriate
-```
-
-### 2. Error Handling
-Handle errors gracefully in your environment:
-```python
-def step(self, action: MyAction) -> MyObservation:
-    try:
-        result = self._process(action)
-        return MyObservation(result=result, success=True)
-    except Exception as e:
-        return MyObservation(result="", success=False, error=str(e))
-```
-
-### 3. State Management
-Track all relevant episode state:
-```python
-@dataclass
-class MyState(State):
-    # Add custom fields
-    accumulated_reward: float = 0.0
-    last_action: str = ""
-```
-
-### 4. Documentation
-Provide comprehensive README for your environment:
-- Overview and purpose
-- Quick start example
-- Action/Observation specifications
-- Build instructions
-- Usage examples
-
-### 5. Testing
-Test your environment before containerization:
-```python
-# test_my_environment.py
-from envs.my_env.server.my_environment import MyEnvironment
-from envs.my_env.models import MyAction
-
-def test_environment():
-    env = MyEnvironment()
-
-    # Test reset
-    obs = env.reset()
-    assert obs.success
-
-    # Test step
-    action = MyAction(command="test", parameters={})
-    obs = env.step(action)
-    assert obs.success
-
-    # Test state
-    assert env.state.step_count == 1
-```
-
-## Advanced Topics
-
-### Custom Transforms
-Apply transformations to observations:
-
-```python
-from core.env_server import Transform
-
-class MyTransform(Transform):
-    def __call__(self, observation: Observation) -> Observation:
-        # Transform observation
-        return modified_observation
-
-# Use in environment
-env = MyEnvironment(transform=MyTransform())
-```
-
-### Additional Dependencies
-Install environment-specific packages in Dockerfile:
-
-```dockerfile
-FROM openenv-base:latest
-
-# Install specific versions
-RUN pip install --no-cache-dir \
-    numpy==1.24.0 \
-    pandas==2.0.0 \
-    your-custom-package==1.0.0
-```

openenv/src/envs/atari_env/README.md

@@ -1,396 +0,0 @@
----
-title: Atari Environment Server
-emoji: 🕹️
-colorFrom: '#FF6200'
-colorTo: '#D4151B'
-sdk: docker
-pinned: false
-app_port: 8000
-base_path: /web
-tags:
-  - openenv
----
-
-# Atari Environment
-
-Integration of Atari 2600 games with the OpenEnv framework via the Arcade Learning Environment (ALE). ALE provides access to 100+ classic Atari games for RL research.
-
-## Supported Games
-
-ALE supports 100+ Atari 2600 games including:
-
-### Popular Games
-- **Pong** - Classic two-player tennis
-- **Breakout** - Break bricks with a ball
-- **Space Invaders** - Shoot descending aliens
-- **Pac-Man / Ms. Pac-Man** - Navigate mazes and eat pellets
-- **Asteroids** - Destroy asteroids in space
-- **Defender** - Side-scrolling space shooter
-- **Centipede** - Shoot segmented centipede
-- **Donkey Kong** - Jump over barrels to save princess
-- **Frogger** - Cross road and river safely
-- **Q*bert** - Jump on pyramid cubes
-
-And many more! For a complete list, see [ALE documentation](https://ale.farama.org/environments/complete_list/).
-
-## Architecture
-
-```
-┌────────────────────────────────────┐
-│ RL Training Code (Client)          │
-│   AtariEnv.step(action)            │
-└──────────────┬─────────────────────┘
-               │ HTTP
-┌──────────────▼─────────────────────┐
-│ FastAPI Server (Docker)            │
-│   AtariEnvironment                 │
-│     ├─ Wraps ALEInterface          │
-│     ├─ Handles observations        │
-│     └─ Action execution            │
-└────────────────────────────────────┘
-```
-
-## Installation & Usage
-
-### Option 1: Local Development (without Docker)
-
-**Requirements:**
-- Python 3.11+
-- ale-py installed: `pip install ale-py`
-
-```python
-from envs.atari_env import AtariEnv, AtariAction
-
-# Start local server manually
-# python -m envs.atari_env.server.app
-
-# Connect to local server
-env = AtariEnv(base_url="http://localhost:8000")
-
-# Reset environment
-result = env.reset()
-print(f"Screen shape: {result.observation.screen_shape}")
-print(f"Legal actions: {result.observation.legal_actions}")
-print(f"Lives: {result.observation.lives}")
-
-# Take actions
-for _ in range(10):
-    action_id = 2  # UP action
-    result = env.step(AtariAction(action_id=action_id, game_name="pong"))
-    print(f"Reward: {result.reward}, Done: {result.done}")
-    if result.done:
-        break
-
-# Cleanup
-env.close()
-```
-
-### Option 2: Docker (Recommended)
-
-**Build Atari image:**
-
-```bash
-cd OpenEnv
-
-# Build the image
-docker build \
-  -f src/envs/atari_env/server/Dockerfile \
-  -t atari-env:latest \
-  .
-```
-
-**Run specific games:**
-
-```bash
-# Pong (default)
-docker run -p 8000:8000 atari-env:latest
-
-# Breakout
-docker run -p 8000:8000 -e ATARI_GAME=breakout atari-env:latest
-
-# Space Invaders with grayscale observation
-docker run -p 8000:8000 \
-  -e ATARI_GAME=space_invaders \
-  -e ATARI_OBS_TYPE=grayscale \
-  atari-env:latest
-
-# Ms. Pac-Man with full action space
-docker run -p 8000:8000 \
-  -e ATARI_GAME=ms_pacman \
-  -e ATARI_FULL_ACTION_SPACE=true \
-  atari-env:latest
-```
-
-**Use with from_docker_image():**
-
-```python
-from envs.atari_env import AtariEnv, AtariAction
-import numpy as np
-
-# Automatically starts container
-env = AtariEnv.from_docker_image("atari-env:latest")
-
-result = env.reset()
-result = env.step(AtariAction(action_id=2))  # UP
-
-# Reshape screen for visualization
-screen = np.array(result.observation.screen).reshape(result.observation.screen_shape)
-print(f"Screen shape: {screen.shape}")  # (210, 160, 3) for RGB
-
-env.close()  # Stops container
-```
-
-## Observation Types
-
-### 1. RGB (Default)
-- **Shape**: [210, 160, 3]
-- **Description**: Full-color screen observation
-- **Usage**: Most realistic, good for vision-based learning
-
-```python
-docker run -p 8000:8000 -e ATARI_OBS_TYPE=rgb atari-env:latest
-```
-
-### 2. Grayscale
-- **Shape**: [210, 160]
-- **Description**: Grayscale screen observation
-- **Usage**: Reduced dimensionality, faster processing
-
-```python
-docker run -p 8000:8000 -e ATARI_OBS_TYPE=grayscale atari-env:latest
-```
-
-### 3. RAM
-- **Shape**: [128]
-- **Description**: Raw 128-byte Atari 2600 RAM contents
-- **Usage**: Compact representation, useful for specific research
-
-```python
-docker run -p 8000:8000 -e ATARI_OBS_TYPE=ram atari-env:latest
-```
-
-## Action Spaces
-
-### Minimal Action Set (Default)
-Game-specific minimal actions (typically 4-9 actions).
-- Pong: 6 actions (NOOP, FIRE, UP, DOWN, etc.)
-- Breakout: 4 actions (NOOP, FIRE, LEFT, RIGHT)
-
-```python
-docker run -p 8000:8000 -e ATARI_FULL_ACTION_SPACE=false atari-env:latest
-```
-
-### Full Action Set
-All 18 possible Atari 2600 actions:
-0. NOOP
-1. FIRE
-2. UP
-3. RIGHT
-4. LEFT
-5. DOWN
-6. UPRIGHT
-7. UPLEFT
-8. DOWNRIGHT
-9. DOWNLEFT
-10. UPFIRE
-11. RIGHTFIRE
-12. LEFTFIRE
-13. DOWNFIRE
-14. UPRIGHTFIRE
-15. UPLEFTFIRE
-16. DOWNRIGHTFIRE
-17. DOWNLEFTFIRE
-
-```python
-docker run -p 8000:8000 -e ATARI_FULL_ACTION_SPACE=true atari-env:latest
-```
-
-## Configuration
-
-### Environment Variables
-
-- `ATARI_GAME`: Game name (default: "pong")
-- `ATARI_OBS_TYPE`: Observation type - "rgb", "grayscale", "ram" (default: "rgb")
-- `ATARI_FULL_ACTION_SPACE`: Use full action space - "true"/"false" (default: "false")
-- `ATARI_MODE`: Game mode (optional, game-specific)
-- `ATARI_DIFFICULTY`: Game difficulty (optional, game-specific)
-- `ATARI_REPEAT_ACTION_PROB`: Sticky action probability 0.0-1.0 (default: "0.0")
-- `ATARI_FRAMESKIP`: Frames to skip per action (default: "4")
-
-### Example: Breakout with Custom Settings
-
-```bash
-docker run -p 8000:8000 \
-  -e ATARI_GAME=breakout \
-  -e ATARI_OBS_TYPE=grayscale \
-  -e ATARI_FULL_ACTION_SPACE=true \
-  -e ATARI_REPEAT_ACTION_PROB=0.25 \
-  -e ATARI_FRAMESKIP=4 \
-  atari-env:latest
-```
-
-## API Reference
-
-### AtariAction
-
-```python
-@dataclass
-class AtariAction(Action):
-    action_id: int                  # Action index to execute
-    game_name: str = "pong"         # Game name
-    obs_type: str = "rgb"           # Observation type
-    full_action_space: bool = False # Full or minimal action space
-```
-
-### AtariObservation
-
-```python
-@dataclass
-class AtariObservation(Observation):
-    screen: List[int]               # Flattened screen pixels
-    screen_shape: List[int]         # Original screen shape
-    legal_actions: List[int]        # Legal action indices
-    lives: int                      # Lives remaining
-    episode_frame_number: int       # Frame # in episode
-    frame_number: int               # Total frame #
-    done: bool                      # Episode finished
-    reward: Optional[float]         # Reward from last action
-```
-
-### AtariState
-
-```python
-@dataclass
-class AtariState(State):
-    episode_id: str                      # Unique episode ID
-    step_count: int                      # Number of steps
-    game_name: str                       # Game name
-    obs_type: str                        # Observation type
-    full_action_space: bool              # Action space type
-    mode: Optional[int]                  # Game mode
-    difficulty: Optional[int]            # Game difficulty
-    repeat_action_probability: float     # Sticky action prob
-    frameskip: int                       # Frameskip setting
-```
-
-## Example Script
-
-```python
-#!/usr/bin/env python3
-"""Example training loop with Atari environment."""
-
-import numpy as np
-from envs.atari_env import AtariEnv, AtariAction
-
-# Start environment
-env = AtariEnv.from_docker_image("atari-env:latest")
-
-# Training loop
-for episode in range(10):
-    result = env.reset()
-    episode_reward = 0
-    steps = 0
-
-    while not result.done:
-        # Random policy (replace with your RL agent)
-        action_id = np.random.choice(result.observation.legal_actions)
-
-        # Take action
-        result = env.step(AtariAction(action_id=action_id))
-
-        episode_reward += result.reward or 0
-        steps += 1
-
-        # Reshape screen for processing
-        screen = np.array(result.observation.screen).reshape(
-            result.observation.screen_shape
-        )
-
-        # Your RL training code here
-        # ...
-
-    print(f"Episode {episode}: reward={episode_reward:.2f}, steps={steps}")
-
-env.close()
-```
-
-## Testing
-
-### Local Testing
-
-```bash
-# Install dependencies
-pip install ale-py fastapi uvicorn requests
-
-# Start server
-cd /Users/sanyambhutani/OpenEnv/OpenEnv
-export PYTHONPATH=/Users/sanyambhutani/OpenEnv/OpenEnv/src
-python -m envs.atari_env.server.app
-
-# Test from another terminal
-python -c "
-from envs.atari_env import AtariEnv, AtariAction
-env = AtariEnv(base_url='http://localhost:8000')
-result = env.reset()
-print(f'Initial obs: {result.observation.screen_shape}')
-result = env.step(AtariAction(action_id=2))
-print(f'After step: reward={result.reward}, done={result.done}')
-env.close()
-"
-```
-
-### Docker Testing
-
-```bash
-# Build and run
-docker build -f src/envs/atari_env/server/Dockerfile -t atari-env:latest .
-docker run -p 8000:8000 atari-env:latest
-
-# Test in another terminal
-curl http://localhost:8000/health
-curl -X POST http://localhost:8000/reset
-```
-
-## Popular Games and Their Characteristics
-
-| Game | Minimal Actions | Lives | Difficulty | Notes |
-|------|----------------|-------|-----------|-------|
-| Pong | 6 | 1 | Low | Good for learning basics |
-| Breakout | 4 | 5 | Medium | Classic RL benchmark |
-| Space Invaders | 6 | 3 | Medium | Shooting game |
-| Ms. Pac-Man | 9 | 3 | High | Complex navigation |
-| Asteroids | 14 | 3 | Medium | Continuous shooting |
-| Montezuma's Revenge | 18 | 5 | Very High | Exploration challenge |
-| Pitfall | 18 | 1 | High | Platformer |
-| Seaquest | 18 | 3 | High | Submarine rescue |
-
-## Limitations & Notes
-
-- **Frame perfect timing**: Some games require precise timing
-- **Exploration**: Games like Montezuma's Revenge are notoriously difficult
-- **Observation delay**: HTTP adds minimal latency vs local gym
-- **Determinism**: Set `ATARI_REPEAT_ACTION_PROB=0.0` for deterministic behavior
-- **ROMs**: All ROMs are bundled with ale-py package
-
-## References
-
-- [Arcade Learning Environment Paper (2013)](https://jair.org/index.php/jair/article/view/10819)
-- [ALE GitHub](https://github.com/Farama-Foundation/Arcade-Learning-Environment)
-- [ALE Documentation](https://ale.farama.org/)
-- [Gymnasium Atari Environments](https://gymnasium.farama.org/environments/atari/)
-
-## Citation
-
-If you use ALE in your research, please cite:
-
-```bibtex
-@Article{bellemare13arcade,
-    author = {{Bellemare}, M.~G. and {Naddaf}, Y. and {Veness}, J. and {Bowling}, M.},
-    title = {The Arcade Learning Environment: An Evaluation Platform for General Agents},
-    journal = {Journal of Artificial Intelligence Research},
-    year = "2013",
-    month = "jun",
-    volume = "47",
-    pages = "253--279",
-}
-```

openenv/src/envs/atari_env/__init__.py

@@ -1,31 +0,0 @@
-# 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.
-
-"""
-Atari Environment for OpenEnv.
-
-This module provides OpenEnv integration for Atari 2600 games via the
-Arcade Learning Environment (ALE).
-
-Example:
-    >>> from envs.atari_env import AtariEnv, AtariAction
-    >>>
-    >>> # Connect to a running server or start via Docker
-    >>> env = AtariEnv.from_docker_image("atari-env:latest")
-    >>>
-    >>> # Reset and interact
-    >>> result = env.reset()
-    >>> result = env.step(AtariAction(action_id=2))  # UP
-    >>> print(result.reward, result.done)
-    >>>
-    >>> # Cleanup
-    >>> env.close()
-"""
-
-from .client import AtariEnv
-from .models import AtariAction, AtariObservation, AtariState
-
-__all__ = ["AtariEnv", "AtariAction", "AtariObservation", "AtariState"]

openenv/src/envs/atari_env/client.py

@@ -1,119 +0,0 @@
-# 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.
-
-"""
-Atari Environment HTTP Client.
-
-This module provides the client for connecting to an Atari Environment server
-over HTTP.
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, TYPE_CHECKING
-
-from core.client_types import StepResult
-
-from core.http_env_client import HTTPEnvClient
-
-from .models import AtariAction, AtariObservation, AtariState
-
-if TYPE_CHECKING:
-    from core.containers.runtime import ContainerProvider
-
-
-class AtariEnv(HTTPEnvClient[AtariAction, AtariObservation]):
-    """
-    HTTP client for Atari Environment.
-
-    This client connects to an AtariEnvironment HTTP server and provides
-    methods to interact with it: reset(), step(), and state access.
-
-    Example:
-        >>> # Connect to a running server
-        >>> client = AtariEnv(base_url="http://localhost:8000")
-        >>> result = client.reset()
-        >>> print(result.observation.screen_shape)
-        >>>
-        >>> # Take an action
-        >>> result = client.step(AtariAction(action_id=2))  # UP
-        >>> print(result.reward, result.done)
-
-    Example with Docker:
-        >>> # Automatically start container and connect
-        >>> client = AtariEnv.from_docker_image("atari-env:latest")
-        >>> result = client.reset()
-        >>> result = client.step(AtariAction(action_id=0))  # NOOP
-    """
-
-    def _step_payload(self, action: AtariAction) -> Dict[str, Any]:
-        """
-        Convert AtariAction to JSON payload for step request.
-
-        Args:
-            action: AtariAction instance.
-
-        Returns:
-            Dictionary representation suitable for JSON encoding.
-        """
-        return {
-            "action_id": action.action_id,
-            "game_name": action.game_name,
-            "obs_type": action.obs_type,
-            "full_action_space": action.full_action_space,
-        }
-
-    def _parse_result(self, payload: Dict[str, Any]) -> StepResult[AtariObservation]:
-        """
-        Parse server response into StepResult[AtariObservation].
-
-        Args:
-            payload: JSON response from server.
-
-        Returns:
-            StepResult with AtariObservation.
-        """
-        obs_data = payload.get("observation", {})
-
-        observation = AtariObservation(
-            screen=obs_data.get("screen", []),
-            screen_shape=obs_data.get("screen_shape", []),
-            legal_actions=obs_data.get("legal_actions", []),
-            lives=obs_data.get("lives", 0),
-            episode_frame_number=obs_data.get("episode_frame_number", 0),
-            frame_number=obs_data.get("frame_number", 0),
-            done=payload.get("done", False),
-            reward=payload.get("reward"),
-            metadata=obs_data.get("metadata", {}),
-        )
-
-        return StepResult(
-            observation=observation,
-            reward=payload.get("reward"),
-            done=payload.get("done", False),
-        )
-
-    def _parse_state(self, payload: Dict[str, Any]) -> AtariState:
-        """
-        Parse server response into AtariState object.
-
-        Args:
-            payload: JSON response from /state endpoint.
-
-        Returns:
-            AtariState object with environment state information.
-        """
-        return AtariState(
-            episode_id=payload.get("episode_id"),
-            step_count=payload.get("step_count", 0),
-            game_name=payload.get("game_name", "unknown"),
-            obs_type=payload.get("obs_type", "rgb"),
-            full_action_space=payload.get("full_action_space", False),
-            mode=payload.get("mode"),
-            difficulty=payload.get("difficulty"),
-            repeat_action_probability=payload.get("repeat_action_probability", 0.0),
-            frameskip=payload.get("frameskip", 4),
-        )

openenv/src/envs/atari_env/models.py

@@ -1,86 +0,0 @@
-# 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 Atari Environment.
-
-This module defines the Action, Observation, and State types for Atari games
-via the Arcade Learning Environment (ALE).
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Literal, Optional
-
-from core.env_server import Action, Observation, State
-
-
-@dataclass
-class AtariAction(Action):
-    """
-    Action for Atari environments.
-
-    Attributes:
-        action_id: The integer action ID to take (from legal_actions).
-        game_name: Name of the Atari game (e.g., "pong", "breakout", "space_invaders").
-        obs_type: Observation type ("rgb", "grayscale", or "ram").
-        full_action_space: Whether to use full (18 actions) or minimal action space.
-    """
-    action_id: int
-    game_name: str = "pong"
-    obs_type: Literal["rgb", "grayscale", "ram"] = "rgb"
-    full_action_space: bool = False
-
-
-@dataclass
-class AtariObservation(Observation):
-    """
-    Observation from Atari environment.
-
-    This represents what the agent sees after taking an action.
-
-    Attributes:
-        screen: Screen observation as a flattened list of pixels.
-                Shape depends on obs_type:
-                - rgb: [210, 160, 3] flattened
-                - grayscale: [210, 160] flattened
-                - ram: [128] (RAM contents)
-        screen_shape: Original shape of the screen before flattening.
-        legal_actions: List of legal action IDs the agent can take.
-        lives: Number of lives remaining.
-        episode_frame_number: Frame number within current episode.
-        frame_number: Total frame number since environment creation.
-    """
-    screen: List[int]
-    screen_shape: List[int]
-    legal_actions: List[int]
-    lives: int = 0
-    episode_frame_number: int = 0
-    frame_number: int = 0
-
-
-@dataclass
-class AtariState(State):
-    """
-    State for Atari environment.
-
-    Attributes:
-        game_name: Name of the Atari game.
-        obs_type: Observation type ("rgb", "grayscale", or "ram").
-        full_action_space: Whether using full or minimal action space.
-        mode: Game mode (if applicable).
-        difficulty: Game difficulty (if applicable).
-        repeat_action_probability: Probability of repeating previous action (sticky actions).
-        frameskip: Number of frames to skip per action.
-    """
-    game_name: str = "pong"
-    obs_type: Literal["rgb", "grayscale", "ram"] = "rgb"
-    full_action_space: bool = False
-    mode: Optional[int] = None
-    difficulty: Optional[int] = None
-    repeat_action_probability: float = 0.0
-    frameskip: int = 4

openenv/src/envs/atari_env/server/Dockerfile

@@ -1,43 +0,0 @@
-# Dockerfile for Atari Environment
-# This image provides Atari 2600 games via the Arcade Learning Environment (ALE)
-
-# 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 src/envs/atari_env/server/Dockerfile -t atari-env:latest .
-#
-# CI/CD build: docker build --build-arg BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest \
-#              -f src/envs/atari_env/server/Dockerfile -t atari-env:latest .
-ARG BASE_IMAGE=openenv-base:latest
-FROM ${BASE_IMAGE}
-
-# Install dependencies
-COPY src/envs/atari_env/server/requirements.txt /tmp/requirements.txt
-RUN pip install --no-cache-dir -r /tmp/requirements.txt && rm /tmp/requirements.txt
-
-# Copy OpenEnv core (base image already set WORKDIR=/app)
-COPY src/core/ /app/src/core/
-
-# Copy Atari environment code
-COPY src/envs/atari_env/ /app/src/envs/atari_env/
-
-# Copy README for web interface documentation
-COPY src/envs/atari_env/README.md /app/README.md
-
-# Atari-specific environment variables (can be overridden at runtime)
-ENV ATARI_GAME=pong
-ENV ATARI_OBS_TYPE=rgb
-ENV ATARI_FULL_ACTION_SPACE=false
-ENV ATARI_REPEAT_ACTION_PROB=0.0
-ENV ATARI_FRAMESKIP=4
-
-# 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.atari_env.server.app:app", "--host", "0.0.0.0", "--port", "8000"]

openenv/src/envs/atari_env/server/__init__.py

@@ -1,15 +0,0 @@
-# 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.
-
-"""
-Atari Environment Server.
-
-Server-side implementation of Atari environment for OpenEnv.
-"""
-
-from .atari_environment import AtariEnvironment
-
-__all__ = ["AtariEnvironment"]

openenv/src/envs/atari_env/server/app.py

@@ -1,73 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the BSD-style license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-FastAPI application for the Atari Environment.
-
-This module creates an HTTP server that exposes Atari games
-over HTTP endpoints, making them compatible with HTTPEnvClient.
-
-Usage:
-    # Development (with auto-reload):
-    uvicorn envs.atari_env.server.app:app --reload --host 0.0.0.0 --port 8000
-
-    # Production:
-    uvicorn envs.atari_env.server.app:app --host 0.0.0.0 --port 8000 --workers 4
-
-    # Or run directly:
-    python -m envs.atari_env.server.app
-
-Environment variables:
-    ATARI_GAME: Game name to serve (default: "pong")
-    ATARI_OBS_TYPE: Observation type (default: "rgb")
-    ATARI_FULL_ACTION_SPACE: Use full action space (default: "false")
-    ATARI_MODE: Game mode (optional)
-    ATARI_DIFFICULTY: Game difficulty (optional)
-    ATARI_REPEAT_ACTION_PROB: Sticky action probability (default: "0.0")
-    ATARI_FRAMESKIP: Frameskip (default: "4")
-"""
-
-import os
-
-from core.env_server import create_app
-
-from ..models import AtariAction, AtariObservation
-from .atari_environment import AtariEnvironment
-
-# Get configuration from environment variables
-game_name = os.getenv("ATARI_GAME", "pong")
-obs_type = os.getenv("ATARI_OBS_TYPE", "rgb")
-full_action_space = os.getenv("ATARI_FULL_ACTION_SPACE", "false").lower() == "true"
-repeat_action_prob = float(os.getenv("ATARI_REPEAT_ACTION_PROB", "0.0"))
-frameskip = int(os.getenv("ATARI_FRAMESKIP", "4"))
-
-# Optional parameters
-mode = os.getenv("ATARI_MODE")
-difficulty = os.getenv("ATARI_DIFFICULTY")
-
-# Convert to int if specified
-mode = int(mode) if mode is not None else None
-difficulty = int(difficulty) if difficulty is not None else None
-
-# Create the environment instance
-env = AtariEnvironment(
-    game_name=game_name,
-    obs_type=obs_type,
-    full_action_space=full_action_space,
-    mode=mode,
-    difficulty=difficulty,
-    repeat_action_probability=repeat_action_prob,
-    frameskip=frameskip,
-)
-
-# Create the FastAPI app with web interface and README integration
-app = create_app(env, AtariAction, AtariObservation, env_name="atari_env")
-
-
-if __name__ == "__main__":
-    import uvicorn
-
-    uvicorn.run(app, host="0.0.0.0", port=8000)

openenv/src/envs/atari_env/server/atari_environment.py

@@ -1,245 +0,0 @@
-# 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.
-
-"""
-Atari Environment Server Implementation.
-
-This module wraps ALE's ALEInterface and exposes it
-via the OpenEnv Environment interface.
-"""
-
-import uuid
-from typing import Any, Dict, Literal, Optional
-
-from core.env_server import Action, Environment, Observation
-
-from ..models import AtariAction, AtariObservation, AtariState
-
-# Import ALE
-try:
-    from ale_py import ALEInterface, roms
-    import numpy as np
-except ImportError as e:
-    raise ImportError(
-        "ALE (Arcade Learning Environment) is not installed. "
-        "Please install it with: pip install ale-py"
-    ) from e
-
-
-class AtariEnvironment(Environment):
-    """
-    Atari Environment wrapper for OpenEnv.
-
-    This environment wraps Atari 2600 games via the Arcade Learning Environment (ALE)
-    and provides a clean interface for RL training.
-
-    Supported games include: pong, breakout, space_invaders, and 100+ others.
-
-    Args:
-        game_name: Name of the Atari game (e.g., "pong", "breakout").
-        obs_type: Observation type - "rgb", "grayscale", or "ram".
-        full_action_space: Use full action space (18 actions) vs minimal.
-        mode: Game mode (if applicable).
-        difficulty: Game difficulty (if applicable).
-        repeat_action_probability: Sticky action probability (default 0.0).
-        frameskip: Number of frames to skip per action (default 4).
-
-    Example:
-        >>> env = AtariEnvironment("pong")
-        >>> obs = env.reset()
-        >>> print(obs.screen_shape)  # [210, 160, 3]
-        >>> obs = env.step(AtariAction(action_id=2))  # UP
-        >>> print(obs.reward, obs.done)
-    """
-
-    def __init__(
-        self,
-        game_name: str = "pong",
-        obs_type: Literal["rgb", "grayscale", "ram"] = "rgb",
-        full_action_space: bool = False,
-        mode: Optional[int] = None,
-        difficulty: Optional[int] = None,
-        repeat_action_probability: float = 0.0,
-        frameskip: int = 4,
-    ):
-        """Initialize Atari environment."""
-        super().__init__()
-
-        self.game_name = game_name
-        self.obs_type = obs_type
-        self.full_action_space = full_action_space
-        self.mode = mode
-        self.difficulty = difficulty
-        self.repeat_action_probability = repeat_action_probability
-        self.frameskip = frameskip
-
-        # Create ALE interface
-        self.ale = ALEInterface()
-
-        # Configure ALE
-        from ale_py import LoggerMode
-        self.ale.setLoggerMode(LoggerMode.Error)  # Error mode only
-        self.ale.setFloat("repeat_action_probability", repeat_action_probability)
-
-        # Load ROM
-        try:
-            rom_path = roms.get_rom_path(game_name)
-            self.ale.loadROM(rom_path)
-        except Exception as e:
-            raise ValueError(
-                f"Failed to load Atari game '{game_name}': {e}\n"
-                f"Available games can be found via: ale_py.roms.list_roms()"
-            ) from e
-
-        # Set mode and difficulty if specified
-        if mode is not None:
-            self.ale.setMode(mode)
-        if difficulty is not None:
-            self.ale.setDifficulty(difficulty)
-
-        # Get action set
-        if full_action_space:
-            self._action_set = self.ale.getLegalActionSet()
-        else:
-            self._action_set = self.ale.getMinimalActionSet()
-
-        # Get screen dimensions for observation space
-        self.screen_height, self.screen_width = self.ale.getScreenDims()
-        if obs_type == "rgb":
-            self.screen_shape = [self.screen_height, self.screen_width, 3]
-        elif obs_type == "grayscale":
-            self.screen_shape = [self.screen_height, self.screen_width]
-        elif obs_type == "ram":
-            self.screen_shape = [self.ale.getRAMSize()]
-        else:
-            raise ValueError(f"Invalid obs_type: {obs_type}")
-
-        # Initialize state
-        self._state = AtariState(
-            game_name=game_name,
-            obs_type=obs_type,
-            full_action_space=full_action_space,
-            mode=mode,
-            difficulty=difficulty,
-            repeat_action_probability=repeat_action_probability,
-            frameskip=frameskip,
-        )
-
-    def reset(self) -> Observation:
-        """
-        Reset the environment and return initial observation.
-
-        Returns:
-            Initial observation for the agent.
-        """
-        # Reset ALE
-        self.ale.reset_game()
-
-        # Reset state tracking
-        self._state.episode_id = str(uuid.uuid4())
-        self._state.step_count = 0
-
-        # Get initial observation
-        return self._make_observation()
-
-    def step(self, action: Action) -> Observation:
-        """
-        Execute agent's action and return resulting observation.
-
-        Args:
-            action: AtariAction containing the action_id to execute.
-
-        Returns:
-            Observation after action execution.
-
-        Raises:
-            ValueError: If action is not an AtariAction.
-        """
-        if not isinstance(action, AtariAction):
-            raise ValueError(f"Expected AtariAction, got {type(action)}")
-
-        # Validate action_id
-        if action.action_id < 0 or action.action_id >= len(self._action_set):
-            raise ValueError(
-                f"Invalid action_id: {action.action_id}. "
-                f"Valid range: [0, {len(self._action_set) - 1}]"
-            )
-
-        # Get actual ALE action
-        ale_action = self._action_set[action.action_id]
-
-        # Execute action with frameskip
-        total_reward = 0.0
-        for _ in range(self.frameskip):
-            total_reward += self.ale.act(ale_action)
-            if self.ale.game_over():
-                break
-
-        self._state.step_count += 1
-
-        # Get observation
-        obs = self._make_observation()
-        obs.reward = total_reward
-
-        return obs
-
-    @property
-    def state(self) -> AtariState:
-        """Get current environment state."""
-        return self._state
-
-    def _make_observation(self) -> AtariObservation:
-        """
-        Create an AtariObservation from current ALE state.
-
-        Returns:
-            AtariObservation for the agent.
-        """
-        # Get screen observation
-        if self.obs_type == "rgb":
-            screen = self.ale.getScreenRGB()
-        elif self.obs_type == "grayscale":
-            screen = self.ale.getScreenGrayscale()
-        elif self.obs_type == "ram":
-            screen = self.ale.getRAM()
-        else:
-            raise ValueError(f"Invalid obs_type: {self.obs_type}")
-
-        # Flatten screen for JSON serialization
-        # Handle both numpy arrays and lists
-        if hasattr(screen, "flatten"):
-            screen_flat = screen.flatten().tolist()
-        elif hasattr(screen, "tolist"):
-            screen_flat = screen.tolist()
-        else:
-            screen_flat = list(screen)
-
-        # Get game info
-        lives = self.ale.lives()
-        episode_frame_number = self.ale.getEpisodeFrameNumber()
-        frame_number = self.ale.getFrameNumber()
-        done = self.ale.game_over()
-
-        # Create legal actions list (indices into action_set)
-        legal_actions = list(range(len(self._action_set)))
-
-        # Create observation
-        obs = AtariObservation(
-            screen=screen_flat,
-            screen_shape=self.screen_shape,
-            legal_actions=legal_actions,
-            lives=lives,
-            episode_frame_number=episode_frame_number,
-            frame_number=frame_number,
-            done=done,
-            reward=0.0,  # Will be filled in by step()
-            metadata={
-                "game_name": self.game_name,
-                "action_meanings": [str(a) for a in self._action_set],
-            },
-        )
-
-        return obs

openenv/src/envs/atari_env/server/requirements.txt

@@ -1,3 +0,0 @@
-gymnasium>=0.29.0
-ale-py>=0.8.0
-numpy>=1.24.0

openenv/src/envs/atari_env/test_atari_docker.sh

@@ -1,333 +0,0 @@
-#!/bin/bash
-# Comprehensive Docker test for Atari environment
-# Tests: Build, Start, Health, Reset, Step, State, Cleanup
-
-set -e  # Exit on error
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Configuration
-IMAGE_NAME="atari-env"
-IMAGE_TAG="test"
-CONTAINER_NAME="atari-env-test"
-PORT="8765"  # Use non-standard port to avoid conflicts
-HEALTH_RETRIES=30
-HEALTH_DELAY=2
-
-# Cleanup function
-cleanup() {
-    echo -e "\n${BLUE}Cleaning up...${NC}"
-    docker stop ${CONTAINER_NAME} 2>/dev/null || true
-    docker rm ${CONTAINER_NAME} 2>/dev/null || true
-    echo -e "${GREEN}✓${NC} Cleanup complete"
-}
-
-# Set trap to cleanup on exit
-trap cleanup EXIT
-
-# Header
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo "  ATARI ENVIRONMENT DOCKER TEST"
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo ""
-
-# Check prerequisites
-echo -e "${BLUE}Checking prerequisites...${NC}"
-if ! command -v docker &> /dev/null; then
-    echo -e "${RED}✗${NC} Docker is not installed"
-    exit 1
-fi
-echo -e "${GREEN}✓${NC} Docker is installed"
-
-if ! command -v curl &> /dev/null; then
-    echo -e "${RED}✗${NC} curl is not installed"
-    exit 1
-fi
-echo -e "${GREEN}✓${NC} curl is installed"
-
-# Check if we're in the right directory
-if [ ! -f "src/envs/atari_env/server/Dockerfile" ]; then
-    echo -e "${RED}✗${NC} Must run from OpenEnv root directory"
-    exit 1
-fi
-echo -e "${GREEN}✓${NC} In correct directory"
-
-# Step 1: Build Docker image
-echo ""
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${BLUE}STEP 1: Building Docker Image${NC}"
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-echo "Building ${IMAGE_NAME}:${IMAGE_TAG}..."
-if docker build -f src/envs/atari_env/server/Dockerfile -t ${IMAGE_NAME}:${IMAGE_TAG} . 2>&1 | tee /tmp/atari_build.log | tail -n 20; then
-    echo -e "${GREEN}✓${NC} Docker image built successfully"
-else
-    echo -e "${RED}✗${NC} Docker build failed"
-    echo "See /tmp/atari_build.log for full output"
-    exit 1
-fi
-
-# Check image exists
-if docker image inspect ${IMAGE_NAME}:${IMAGE_TAG} &> /dev/null; then
-    IMAGE_SIZE=$(docker image inspect ${IMAGE_NAME}:${IMAGE_TAG} --format='{{.Size}}' | awk '{print $1/1024/1024}')
-    echo -e "${GREEN}✓${NC} Image size: ${IMAGE_SIZE} MB"
-else
-    echo -e "${RED}✗${NC} Image not found after build"
-    exit 1
-fi
-
-# Step 2: Start container
-echo ""
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${BLUE}STEP 2: Starting Container${NC}"
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-# Clean up any existing container
-docker rm -f ${CONTAINER_NAME} 2>/dev/null || true
-
-echo "Starting container on port ${PORT}..."
-docker run -d \
-    --name ${CONTAINER_NAME} \
-    -p ${PORT}:8000 \
-    -e ATARI_GAME=pong \
-    -e ATARI_OBS_TYPE=ram \
-    -e ATARI_FRAMESKIP=4 \
-    ${IMAGE_NAME}:${IMAGE_TAG}
-
-if [ $? -eq 0 ]; then
-    echo -e "${GREEN}✓${NC} Container started: ${CONTAINER_NAME}"
-else
-    echo -e "${RED}✗${NC} Failed to start container"
-    exit 1
-fi
-
-# Wait for container to be running
-sleep 2
-if docker ps | grep -q ${CONTAINER_NAME}; then
-    echo -e "${GREEN}✓${NC} Container is running"
-else
-    echo -e "${RED}✗${NC} Container is not running"
-    docker logs ${CONTAINER_NAME}
-    exit 1
-fi
-
-# Step 3: Wait for health check
-echo ""
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${BLUE}STEP 3: Waiting for Server${NC}"
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-echo "Waiting for server to be ready (timeout: ${HEALTH_RETRIES}s)..."
-for i in $(seq 1 ${HEALTH_RETRIES}); do
-    if curl -s http://localhost:${PORT}/health > /dev/null 2>&1; then
-        echo -e "${GREEN}✓${NC} Server is ready (${i}s)"
-        break
-    fi
-
-    if [ $i -eq ${HEALTH_RETRIES} ]; then
-        echo -e "${RED}✗${NC} Server did not become ready in time"
-        echo "Container logs:"
-        docker logs ${CONTAINER_NAME}
-        exit 1
-    fi
-
-    echo -n "."
-    sleep ${HEALTH_DELAY}
-done
-
-# Step 4: Test health endpoint
-echo ""
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${BLUE}STEP 4: Testing Health Endpoint${NC}"
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-HEALTH_RESPONSE=$(curl -s http://localhost:${PORT}/health)
-echo "Response: ${HEALTH_RESPONSE}"
-
-if echo "${HEALTH_RESPONSE}" | grep -q "healthy"; then
-    echo -e "${GREEN}✓${NC} Health endpoint working"
-else
-    echo -e "${RED}✗${NC} Health endpoint failed"
-    exit 1
-fi
-
-# Step 5: Test reset endpoint
-echo ""
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${BLUE}STEP 5: Testing Reset Endpoint${NC}"
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-RESET_RESPONSE=$(curl -s -X POST http://localhost:${PORT}/reset -H "Content-Type: application/json" -d '{}')
-
-if [ -z "${RESET_RESPONSE}" ]; then
-    echo -e "${RED}✗${NC} Reset endpoint returned empty response"
-    docker logs ${CONTAINER_NAME} | tail -20
-    exit 1
-fi
-
-echo "Response (first 200 chars): ${RESET_RESPONSE:0:200}..."
-
-# Check if response contains expected fields
-if echo "${RESET_RESPONSE}" | grep -q "observation" && \
-   echo "${RESET_RESPONSE}" | grep -q "screen" && \
-   echo "${RESET_RESPONSE}" | grep -q "legal_actions"; then
-    echo -e "${GREEN}✓${NC} Reset endpoint working"
-
-    # Extract some info
-    SCREEN_LEN=$(echo "${RESET_RESPONSE}" | grep -o '"screen":\[[^]]*\]' | wc -c)
-    echo "  Screen data length: ${SCREEN_LEN} chars"
-else
-    echo -e "${RED}✗${NC} Reset response missing required fields"
-    echo "Full response: ${RESET_RESPONSE}"
-    exit 1
-fi
-
-# Step 6: Test step endpoint
-echo ""
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${BLUE}STEP 6: Testing Step Endpoint${NC}"
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-STEP_PAYLOAD='{"action": {"action_id": 0, "game_name": "pong"}}'
-STEP_RESPONSE=$(curl -s -X POST http://localhost:${PORT}/step -H "Content-Type: application/json" -d "${STEP_PAYLOAD}")
-
-if [ -z "${STEP_RESPONSE}" ]; then
-    echo -e "${RED}✗${NC} Step endpoint returned empty response"
-    docker logs ${CONTAINER_NAME} | tail -20
-    exit 1
-fi
-
-echo "Response (first 200 chars): ${STEP_RESPONSE:0:200}..."
-
-# Check if response contains expected fields
-if echo "${STEP_RESPONSE}" | grep -q "observation" && \
-   echo "${STEP_RESPONSE}" | grep -q "reward" && \
-   echo "${STEP_RESPONSE}" | grep -q "done"; then
-    echo -e "${GREEN}✓${NC} Step endpoint working"
-
-    # Extract reward and done
-    REWARD=$(echo "${STEP_RESPONSE}" | grep -o '"reward":[^,}]*' | cut -d: -f2)
-    DONE=$(echo "${STEP_RESPONSE}" | grep -o '"done":[^,}]*' | cut -d: -f2)
-    echo "  Reward: ${REWARD}"
-    echo "  Done: ${DONE}"
-else
-    echo -e "${RED}✗${NC} Step response missing required fields"
-    echo "Full response: ${STEP_RESPONSE}"
-    exit 1
-fi
-
-# Step 7: Test state endpoint
-echo ""
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${BLUE}STEP 7: Testing State Endpoint${NC}"
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-STATE_RESPONSE=$(curl -s http://localhost:${PORT}/state)
-
-if [ -z "${STATE_RESPONSE}" ]; then
-    echo -e "${RED}✗${NC} State endpoint returned empty response"
-    docker logs ${CONTAINER_NAME} | tail -20
-    exit 1
-fi
-
-echo "Response: ${STATE_RESPONSE}"
-
-# Check if response contains expected fields
-if echo "${STATE_RESPONSE}" | grep -q "episode_id" && \
-   echo "${STATE_RESPONSE}" | grep -q "step_count" && \
-   echo "${STATE_RESPONSE}" | grep -q "game_name"; then
-    echo -e "${GREEN}✓${NC} State endpoint working"
-
-    # Extract info
-    GAME_NAME=$(echo "${STATE_RESPONSE}" | grep -o '"game_name":"[^"]*"' | cut -d'"' -f4)
-    STEP_COUNT=$(echo "${STATE_RESPONSE}" | grep -o '"step_count":[^,}]*' | cut -d: -f2)
-    echo "  Game: ${GAME_NAME}"
-    echo "  Steps: ${STEP_COUNT}"
-else
-    echo -e "${RED}✗${NC} State response missing required fields"
-    echo "Full response: ${STATE_RESPONSE}"
-    exit 1
-fi
-
-# Step 8: Test multiple steps
-echo ""
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${BLUE}STEP 8: Testing Multiple Steps${NC}"
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-echo "Taking 10 steps..."
-TOTAL_REWARD=0
-for i in {1..10}; do
-    ACTION_ID=$((RANDOM % 3))  # Random action 0-2
-    STEP_PAYLOAD="{\"action\": {\"action_id\": ${ACTION_ID}, \"game_name\": \"pong\"}}"
-    STEP_RESPONSE=$(curl -s -X POST http://localhost:${PORT}/step -H "Content-Type: application/json" -d "${STEP_PAYLOAD}")
-
-    if ! echo "${STEP_RESPONSE}" | grep -q "observation"; then
-        echo -e "${RED}✗${NC} Step ${i} failed"
-        exit 1
-    fi
-
-    REWARD=$(echo "${STEP_RESPONSE}" | grep -o '"reward":[^,}]*' | cut -d: -f2 | sed 's/null/0/')
-    DONE=$(echo "${STEP_RESPONSE}" | grep -o '"done":[^,}]*' | cut -d: -f2)
-
-    echo "  Step ${i}: action=${ACTION_ID}, reward=${REWARD}, done=${DONE}"
-
-    if [ "${DONE}" = "true" ]; then
-        echo "  Episode completed early at step ${i}"
-        break
-    fi
-done
-
-echo -e "${GREEN}✓${NC} Multiple steps completed successfully"
-
-# Step 9: Check container logs for errors
-echo ""
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-echo -e "${BLUE}STEP 9: Checking Container Logs${NC}"
-echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
-
-LOGS=$(docker logs ${CONTAINER_NAME} 2>&1)
-
-if echo "${LOGS}" | grep -i "error" | grep -v "LoggerMode.Error"; then
-    echo -e "${YELLOW}⚠${NC}  Found errors in logs:"
-    echo "${LOGS}" | grep -i "error" | head -5
-else
-    echo -e "${GREEN}✓${NC} No errors in container logs"
-fi
-
-if echo "${LOGS}" | grep -i "exception"; then
-    echo -e "${RED}✗${NC} Found exceptions in logs:"
-    echo "${LOGS}" | grep -i "exception" | head -5
-    exit 1
-else
-    echo -e "${GREEN}✓${NC} No exceptions in container logs"
-fi
-
-# Final Summary
-echo ""
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo -e "${GREEN}✅ ALL DOCKER TESTS PASSED${NC}"
-echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-echo ""
-echo "Summary:"
-echo "  ✓ Docker image built successfully"
-echo "  ✓ Container started and ran"
-echo "  ✓ Health endpoint working"
-echo "  ✓ Reset endpoint working"
-echo "  ✓ Step endpoint working"
-echo "  ✓ State endpoint working"
-echo "  ✓ Multiple steps working"
-echo "  ✓ No errors or exceptions"
-echo ""
-echo "Image: ${IMAGE_NAME}:${IMAGE_TAG}"
-echo "Container: ${CONTAINER_NAME}"
-echo "Port: ${PORT}"
-echo ""
-echo "To keep container running: docker start ${CONTAINER_NAME}"
-echo "To view logs: docker logs ${CONTAINER_NAME}"
-echo ""

openenv/src/envs/browsergym_env/README.md

@@ -1,554 +0,0 @@
----
-title: BrowserGym Environment Server
-emoji: 🌐
-colorFrom: blue
-colorTo: purple
-sdk: docker
-pinned: false
-app_port: 8000
-base_path: /web
-tags:
-  - openenv
-  - browsergym
-  - web-automation
-  - reinforcement-learning
----
-
-# BrowserGym Environment
-
-BrowserGym is a unified framework for web-based agent tasks that provides access to multiple benchmarks under a single Gymnasium-compatible API. This integration brings the complete training-to-evaluation pipeline for web agents into OpenEnv.
-
-## Why BrowserGym?
-
-BrowserGym provides a complete pipeline for developing web agents: train on simple tasks, then evaluate on realistic websites.
-
-**What are these benchmarks?**
-
-- **MiniWoB++ (Training)**: 100+ synthetic web tasks like "click this button", "fill out this form", "select from dropdown". Each task is a simple webpage with a clear objective. Fast resets, randomized variations, dense rewards. Perfect for learning basic web navigation skills. **No external setup needed** - tasks run in isolated browser sessions.
-
-- **WebArena (Evaluation)**: 812 tasks on real websites (e-commerce, forums, GitLab, Wikipedia). Tasks like "find the cheapest laptop and add to cart" or "create a merge request for bug #123". Multistep, requires reasoning, sparse rewards. Tests if your agent can handle actual websites. **Requires running 7 backend services** (shopping site, GitLab instance, etc.).
-
-- **VisualWebArena**: Similar to WebArena but requires visual understanding - agents need to interpret images, identify UI elements visually, handle multimodal content.
-
-- **WorkArena**: Enterprise software tasks (CRM, project management, business workflows). Tests automation on corporate-style applications.
-
-**The training → evaluation pipeline:**
-1. Train on MiniWoB (simple, controlled, fast iterations)
-2. Evaluate on WebArena (complex, realistic, measures real-world capability)
-
-**Key advantage**: You can start training immediately with MiniWoB. No need to set up infrastructure just to test if your code works.
-
-## Quick Start - Training (MiniWoB)
-
-### No Setup Required! 🎉
-
-```python
-from envs.browsergym_env import BrowserGymEnv, BrowserGymAction
-
-# Create environment for MiniWoB training task
-env = BrowserGymEnv.from_docker_image(
-    "ghcr.io/openenv/browsergym-env:latest",
-    environment={
-        "BROWSERGYM_BENCHMARK": "miniwob",
-        "BROWSERGYM_TASK_NAME": "click-test",  # or "click-button", "click-dialog", etc.
-    }
-)
-
-# Train your agent!
-for episode in range(1000):
-    result = env.reset()
-    print(f"Goal: {result.observation.goal}")
-
-    done = False
-    while not done:
-        # Your agent decides what to do
-        action_str = agent.get_action(result.observation.text)
-        action = BrowserGymAction(action_str=action_str)
-
-        result = env.step(action)
-        done = result.done
-
-        print(f"Reward: {result.reward}")
-
-env.close()
-```
-
-### Available Tasks by Benchmark
-
-#### MiniWoB++ Tasks (Training - 100+ tasks)
-
-MiniWoB tasks are organized by difficulty and type. Here are the main categories:
-
-**Click Tasks** (Basic interaction)
-| Task Name | Description | Difficulty |
-|-----------|-------------|------------|
-| `click-test` | Click a single button | ⭐ Easy |
-| `click-button` | Click button with specific text | ⭐ Easy |
-| `click-button-sequence` | Click buttons in order | ⭐⭐ Medium |
-| `click-checkboxes` | Select specific checkboxes | ⭐⭐ Medium |
-| `click-checkboxes-soft` | Select checkboxes (multiple valid) | ⭐⭐ Medium |
-| `click-checkboxes-large` | Many checkboxes to select from | ⭐⭐ Medium |
-| `click-checkboxes-transfer` | Transfer learning variation | ⭐⭐ Medium |
-| `click-dialog` | Click correct button in dialog | ⭐ Easy |
-| `click-dialog-2` | More complex dialog | ⭐⭐ Medium |
-| `click-link` | Click on a link | ⭐ Easy |
-| `click-option` | Select from dropdown | ⭐⭐ Medium |
-| `click-pie` | Click on pie chart slice | ⭐⭐ Medium |
-| `click-scroll-list` | Click item in scrollable list | ⭐⭐⭐ Hard |
-| `click-shades` | Click on specific color shade | ⭐⭐ Medium |
-| `click-shape` | Click on specific shape | ⭐⭐ Medium |
-| `click-tab` | Switch between tabs | ⭐⭐ Medium |
-| `click-tab-2` | More complex tab switching | ⭐⭐⭐ Hard |
-| `click-widget` | Click on UI widget | ⭐⭐ Medium |
-
-**Text Entry Tasks** (Typing and forms)
-| Task Name | Description | Difficulty |
-|-----------|-------------|------------|
-| `enter-text` | Type text into input field | ⭐ Easy |
-| `enter-text-dynamic` | Dynamic text entry | ⭐⭐ Medium |
-| `enter-text-2` | Multiple text fields | ⭐⭐ Medium |
-| `enter-password` | Fill password field | ⭐ Easy |
-| `enter-date` | Enter a date | ⭐⭐ Medium |
-| `enter-time` | Enter a time | ⭐⭐ Medium |
-| `login-user` | Complete login form | ⭐⭐ Medium |
-| `login-user-popup` | Login via popup | ⭐⭐⭐ Hard |
-
-**Navigation Tasks** (Multi-step interaction)
-| Task Name | Description | Difficulty |
-|-----------|-------------|------------|
-| `navigate-tree` | Navigate through tree structure | ⭐⭐⭐ Hard |
-| `search-engine` | Use search interface | ⭐⭐ Medium |
-| `use-autocomplete` | Interact with autocomplete | ⭐⭐⭐ Hard |
-| `book-flight` | Book a flight (complex form) | ⭐⭐⭐⭐ Very Hard |
-| `choose-date` | Pick date from calendar | ⭐⭐⭐ Hard |
-| `choose-date-easy` | Simplified date picker | ⭐⭐ Medium |
-| `choose-date-medium` | Medium difficulty date picker | ⭐⭐⭐ Hard |
-| `choose-list` | Select from long list | ⭐⭐ Medium |
-
-**Visual/Spatial Tasks** (Requires visual understanding)
-| Task Name | Description | Difficulty |
-|-----------|-------------|------------|
-| `count-sides` | Count sides of shape | ⭐⭐ Medium |
-| `count-shape` | Count specific shapes | ⭐⭐ Medium |
-| `find-word` | Find word in text | ⭐⭐ Medium |
-| `focus-text` | Focus on text element | ⭐ Easy |
-| `focus-text-2` | More complex focus task | ⭐⭐ Medium |
-| `grid-coordinate` | Click grid coordinate | ⭐⭐ Medium |
-| `guess-number` | Guess a number game | ⭐⭐⭐ Hard |
-| `identify-shape` | Identify shape type | ⭐⭐ Medium |
-| `read-table` | Extract info from table | ⭐⭐⭐ Hard |
-| `read-table-2` | More complex table reading | ⭐⭐⭐ Hard |
-
-**Email/Social Tasks** (Realistic scenarios)
-| Task Name | Description | Difficulty |
-|-----------|-------------|------------|
-| `email-inbox` | Manage email inbox | ⭐⭐⭐⭐ Very Hard |
-| `email-inbox-forward` | Forward emails | ⭐⭐⭐⭐ Very Hard |
-| `email-inbox-nl` | Natural language email task | ⭐⭐⭐⭐ Very Hard |
-| `email-inbox-star-reply` | Star and reply to emails | ⭐⭐⭐⭐ Very Hard |
-| `social-media` | Social media interaction | ⭐⭐⭐⭐ Very Hard |
-| `social-media-some` | Partial social media task | ⭐⭐⭐ Hard |
-
-**Total:** 100+ tasks across all categories
-
-**Usage:**
-```python
-# Easy task for quick testing
-env = BrowserGymEnv(environment={"BROWSERGYM_TASK_NAME": "click-test"})
-
-# Medium difficulty for training
-env = BrowserGymEnv(environment={"BROWSERGYM_TASK_NAME": "click-checkboxes"})
-
-# Hard task for evaluation
-env = BrowserGymEnv(environment={"BROWSERGYM_TASK_NAME": "email-inbox"})
-```
-
-#### WebArena Tasks (Evaluation - 812 tasks)
-
-WebArena tasks are organized by website and difficulty. Tasks are numbered 0-811.
-
-**By Website:**
-| Website | Task Count | Description | Example Tasks |
-|---------|------------|-------------|---------------|
-| Shopping | ~200 | E-commerce site | Search products, add to cart, checkout |
-| Shopping Admin | ~150 | Admin panel | Manage products, orders, customers |
-| Reddit | ~150 | Forum/social | Post, comment, search discussions |
-| GitLab | ~200 | Code repository | Create issues, merge requests, review code |
-| Wikipedia | ~100 | Knowledge base | Search, read, extract information |
-| Map | ~12 | Location service | Find places, get directions |
-
-**By Difficulty:**
-| Difficulty | Task Count | Steps Required | Example |
-|------------|------------|----------------|---------|
-| Easy | ~200 | 1-5 steps | "Find the price of product X" |
-| Medium | ~400 | 5-15 steps | "Add cheapest laptop to cart" |
-| Hard | ~212 | 15+ steps | "Create merge request for bug fix" |
-
-**Usage:**
-```python
-# Task 0 (usually easy)
-env = BrowserGymEnv(environment={
-    "BROWSERGYM_BENCHMARK": "webarena",
-    "BROWSERGYM_TASK_NAME": "0",
-    "SHOPPING": "http://your-server:7770",
-    # ... other URLs
-})
-
-# Task 156 (GitLab merge request)
-env = BrowserGymEnv(environment={
-    "BROWSERGYM_BENCHMARK": "webarena",
-    "BROWSERGYM_TASK_NAME": "156",
-    # ... URLs
-})
-```
-
-**Note:** WebArena tasks require the full backend infrastructure. See [WebArena setup guide](https://github.com/web-arena-x/webarena/tree/main/environment_docker).
-
-#### VisualWebArena Tasks (910 tasks)
-
-Similar to WebArena but requires visual understanding. Tasks involve:
-- Image-based reasoning
-- Visual element identification
-- Multimodal interaction (text + images)
-
-#### WorkArena Tasks
-
-Enterprise software automation tasks:
-- CRM operations
-- Project management
-- Business workflows
-
-**Full task lists:**
-- [MiniWoB++ tasks](https://github.com/Farama-Foundation/miniwob-plusplus/tree/master/miniwob/environment)
-- [WebArena tasks](https://github.com/web-arena-x/webarena/blob/main/config_files/)
-- [BrowserGym documentation](https://github.com/ServiceNow/BrowserGym)
-
-## Evaluation (WebArena)
-
-### Prerequisites
-
-WebArena requires setting up backend infrastructure. See the [WebArena documentation](https://github.com/web-arena-x/webarena/tree/main/environment_docker).
-
-### Usage
-
-```python
-from envs.browsergym_env import BrowserGymEnv, BrowserGymAction
-
-# Create environment for WebArena evaluation
-env = BrowserGymEnv.from_docker_image(
-    "ghcr.io/openenv/browsergym-env:latest",
-    environment={
-        "BROWSERGYM_BENCHMARK": "webarena",
-        "BROWSERGYM_TASK_NAME": "0",  # Task ID
-        # WebArena backend URLs (required)
-        "SHOPPING": "http://your-server:7770",
-        "SHOPPING_ADMIN": "http://your-server:7780/admin",
-        "REDDIT": "http://your-server:9999",
-        "GITLAB": "http://your-server:8023",
-        "MAP": "http://your-server:3000",
-        "WIKIPEDIA": "http://your-server:8888/wikipedia_en_all_maxi_2022-05/A/User:The_other_Kiwix_guy/Landing",
-        "HOMEPAGE": "http://your-server:4399",
-    }
-)
-
-# Evaluate your trained agent
-result = env.reset()
-while not result.done:
-    action_str = agent.get_action(result.observation)
-    action = BrowserGymAction(action_str=action_str)
-    result = env.step(action)
-
-print(f"Success: {result.reward}")
-env.close()
-```
-
-## Building the Docker Image
-
-### Prerequisites
-
-1. **Base Image**: Build the OpenEnv base image first:
-
-```bash
-# From the OpenEnv repository root
-docker build -t openenv-base:latest -f src/core/containers/images/Dockerfile .
-```
-
-### Build the BrowserGym Environment
-
-```bash
-# From the OpenEnv repository root
-docker build -t browsergym-env:latest -f src/envs/browsergym_env/server/Dockerfile .
-```
-
-### Run the Server
-
-#### For MiniWoB (Training):
-
-```bash
-docker run -p 8000:8000 \
-  -e BROWSERGYM_BENCHMARK="miniwob" \
-  -e BROWSERGYM_TASK_NAME="click-test" \
-  browsergym-env:latest
-```
-
-#### For WebArena (Evaluation):
-
-```bash
-docker run -p 8000:8000 \
-  -e BROWSERGYM_BENCHMARK="webarena" \
-  -e BROWSERGYM_TASK_NAME="0" \
-  -e SHOPPING="http://your-server:7770" \
-  -e SHOPPING_ADMIN="http://your-server:7780/admin" \
-  -e REDDIT="http://your-server:9999" \
-  -e GITLAB="http://your-server:8023" \
-  -e MAP="http://your-server:3000" \
-  -e WIKIPEDIA="http://your-server:8888/wikipedia_en_all_maxi_2022-05/A/User:The_other_Kiwix_guy/Landing" \
-  -e HOMEPAGE="http://your-server:4399" \
-  browsergym-env:latest
-```
-
-## Environment Details
-
-### Action
-
-Actions in BrowserGym are natural language strings that describe browser operations:
-
-```python
-from envs.browsergym_env import BrowserGymAction
-
-# Click actions
-action = BrowserGymAction(action_str="click('Submit button')")
-action = BrowserGymAction(action_str="click('element_id_123')")
-
-# Type actions
-action = BrowserGymAction(action_str="fill('username', 'john@example.com')")
-action = BrowserGymAction(action_str="fill('password', 'secret123')")
-
-# Navigate actions
-action = BrowserGymAction(action_str="goto('https://example.com')")
-
-# Keyboard actions
-action = BrowserGymAction(action_str="press('Enter')")
-action = BrowserGymAction(action_str="press('Tab')")
-
-# Scroll actions
-action = BrowserGymAction(action_str="scroll('down')")
-```
-
-### Observation
-
-Observations contain multiple modalities:
-
-```python
-result = env.step(action)
-obs = result.observation
-
-# Text observations
-print(obs.text)          # Primary text representation (AXTree or DOM)
-print(obs.axtree_txt)    # Accessibility tree
-print(obs.pruned_html)   # Pruned HTML (interactive elements only)
-
-# Page metadata
-print(obs.url)           # Current URL
-print(obs.goal)          # Task goal/instruction
-
-# Visual (if enabled)
-if obs.screenshot is not None:
-    print(obs.screenshot.shape)  # [height, width, channels]
-
-# Error handling
-if obs.last_action_error:
-    print(f"Action failed: {obs.error}")
-
-# Episode status
-print(obs.done)          # True if episode ended
-print(obs.reward)        # Reward for the step
-
-# Access full BrowserGym data (includes timestamps, etc.)
-print(obs.metadata["browsergym_obs"])  # Full observation dict from BrowserGym
-print(obs.metadata["browsergym_info"]) # Full info dict (timestamps, page state, etc.)
-```
-
-#### Advanced: Accessing Raw BrowserGym Data
-
-For VisualWebArena or custom training, you may need additional data like timestamps or browser state. The full BrowserGym observation and info dicts are preserved in `metadata`:
-
-```python
-result = env.step(action)
-
-# Access timestamps (if available)
-info = result.observation.metadata["browsergym_info"]
-if "timestamp" in info:
-    print(f"Action timestamp: {info['timestamp']}")
-
-# Access additional observation fields
-obs_dict = result.observation.metadata["browsergym_obs"]
-if "dom_object" in obs_dict:
-    dom = obs_dict["dom_object"]
-    # Work with raw DOM object
-
-# Access page performance data
-if "performance" in info:
-    print(f"Page load time: {info['performance']}")
-```
-
-### State
-
-The environment state tracks progress:
-
-```python
-state = env.state()
-
-print(f"Benchmark: {state.benchmark}")     # 'miniwob', 'webarena', etc.
-print(f"Task: {state.task_name}")          # Task name/ID
-print(f"Episode: {state.episode_id}")      # Unique episode ID
-print(f"Steps: {state.step_count}")        # Number of steps taken
-print(f"Total Reward: {state.cum_reward}") # Cumulative reward
-print(f"Goal: {state.goal}")               # Task instruction
-print(f"URL: {state.current_url}")         # Current page URL
-```
-
-## Configuration
-
-Environment variables:
-
-### Common Settings
-- `BROWSERGYM_BENCHMARK`: Benchmark to use (`miniwob`, `webarena`, `visualwebarena`, `workarena`)
-- `BROWSERGYM_TASK_NAME`: Specific task name (optional, will use first available if not set)
-- `BROWSERGYM_HEADLESS`: Run browser in headless mode (default: `true`)
-- `BROWSERGYM_VIEWPORT_WIDTH`: Browser viewport width (default: `1280`)
-- `BROWSERGYM_VIEWPORT_HEIGHT`: Browser viewport height (default: `720`)
-- `BROWSERGYM_TIMEOUT`: Action timeout in milliseconds (default: `10000`)
-
-### WebArena-Specific (only needed for WebArena benchmark)
-- `SHOPPING`: Shopping website URL
-- `SHOPPING_ADMIN`: Shopping admin panel URL
-- `REDDIT`: Reddit-like forum URL
-- `GITLAB`: GitLab instance URL
-- `MAP`: Map service URL
-- `WIKIPEDIA`: Wikipedia instance URL
-- `HOMEPAGE`: Homepage URL
-
-## Supported Benchmarks
-
-### 1. MiniWoB++ (Training) ✅ Recommended for Training
-
-- **100+ tasks** ranging from simple (click buttons) to complex (form filling, navigation)
-- **Fast**: Instant resets, quick episodes
-- **Randomized**: Task variations for generalization
-- **No setup**: Works out-of-the-box
-- **Dense rewards**: Immediate feedback for learning
-
-**Use Case**: Train agents on fundamental web navigation skills
-
-### 2. WebArena (Evaluation) 📊 Benchmark
-
-- **812 realistic tasks** across 6 websites
-- **Complex**: Multi-step reasoning, real web interfaces
-- **Requires setup**: Need to run 7 backend services
-- **Sparse rewards**: Binary success/failure
-- **Evaluation-focused**: Test real-world performance
-
-**Use Case**: Evaluate agents on realistic web tasks
-
-### 3. VisualWebArena (Evaluation) 👁️ Visual Benchmark
-
-- **910 tasks** requiring visual understanding
-- **Multimodal**: Both text and visual observations
-- **Requires setup**: Similar to WebArena
-- **Challenging**: Requires visual reasoning
-
-**Use Case**: Test visual web navigation capabilities
-
-### 4. WorkArena (Evaluation) 💼 Enterprise Benchmark
-
-- **Enterprise tasks**: CRM, project management, etc.
-- **Realistic workflows**: Real enterprise software
-- **Requires setup**: Enterprise software instances
-
-**Use Case**: Evaluate on business automation tasks
-
-## Typical Training Pipeline
-
-```python
-from envs.browsergym_env import BrowserGymEnv, BrowserGymAction
-
-# Stage 1: Train on MiniWoB (simple tasks, fast)
-train_env = BrowserGymEnv.from_docker_image(
-    "browsergym-env:latest",
-    environment={
-        "BROWSERGYM_BENCHMARK": "miniwob",
-        "BROWSERGYM_TASK_NAME": "click-button",
-    }
-)
-
-# Train your agent (RL, imitation learning, etc.)
-agent.train(train_env, num_episodes=10000)
-train_env.close()
-
-# Stage 2: Evaluate on WebArena (complex tasks, realistic)
-eval_env = BrowserGymEnv.from_docker_image(
-    "browsergym-env:latest",
-    environment={
-        "BROWSERGYM_BENCHMARK": "webarena",
-        "BROWSERGYM_TASK_NAME": "0",
-        # ... WebArena URLs
-    }
-)
-
-# Test performance
-success_rate = agent.evaluate(eval_env, num_tasks=812)
-print(f"WebArena Success Rate: {success_rate:.2%}")
-eval_env.close()
-```
-
-## Development & Testing
-
-### Running Tests
-
-```bash
-# From the OpenEnv repository root
-pytest tests/envs/test_browsergym_env.py
-```
-
-### Local Development
-
-```bash
-# Install in development mode
-cd /path/to/OpenEnv
-pip install -e .
-
-# Install BrowserGym
-pip install browsergym browsergym-miniwob browsergym-webarena
-
-# Run the server locally
-cd src/envs/browsergym_env/server
-export BROWSERGYM_BENCHMARK=miniwob
-export BROWSERGYM_TASK_NAME=click-test
-python app.py
-```
-
-## Project Structure
-
-```
-browsergym_env/
-├── __init__.py              # Module exports
-├── models.py                # Action, Observation, State dataclasses
-├── client.py                # HTTPEnvClient implementation
-├── README.md                # This file
-└── server/
-    ├── __init__.py
-    ├── app.py               # FastAPI application
-    ├── browsergym_environment.py  # Environment implementation
-    ├── Dockerfile           # Container specification
-    └── requirements.txt     # Python dependencies
-```
-
-## References
-
-- [BrowserGym GitHub](https://github.com/ServiceNow/BrowserGym)
-- [MiniWoB++ Paper](https://arxiv.org/abs/1802.08802)
-- [WebArena Paper](https://arxiv.org/abs/2307.13854)
-- [WebArena Website](https://webarena.dev/)
-- [VisualWebArena Paper](https://jykoh.com/vwa)
-- [OpenEnv Documentation](https://github.com/meta-pytorch/OpenEnv)

openenv/src/envs/browsergym_env/__init__.py

@@ -1,72 +0,0 @@
-"""BrowserGym Environment for OpenEnv.
-
-BrowserGym is a unified framework for web-based agent tasks that provides
-access to multiple benchmarks under a single Gymnasium-compatible API.
-
-Included Benchmarks:
-- **MiniWoB++**: 100+ simple web tasks for training (no external infrastructure!)
-- **WebArena**: 812 realistic evaluation tasks (requires backend setup)
-- **VisualWebArena**: Visual web navigation tasks
-- **WorkArena**: Enterprise task automation
-
-Key Features:
-- Unified API across all benchmarks
-- Gymnasium-compatible interface
-- Support for multiple observation types (text, visual, DOM)
-- Action spaces for natural language commands
-- Perfect for training (MiniWoB) and evaluation (WebArena)
-
-Training Example (MiniWoB - works immediately):
-    ```python
-    from envs.browsergym_env import BrowserGymEnv, BrowserGymAction
-
-    # Create training environment - no backend setup needed!
-    env = BrowserGymEnv.from_docker_image(
-        "browsergym-env:latest",
-        environment={
-            "BROWSERGYM_BENCHMARK": "miniwob",
-            "BROWSERGYM_TASK_NAME": "click-test",
-        }
-    )
-
-    # Train your agent
-    for episode in range(1000):
-        result = env.reset()
-        while not result.done:
-            action = agent.get_action(result.observation)
-            result = env.step(action)
-
-    env.close()
-    ```
-
-Evaluation Example (WebArena - requires backend):
-    ```python
-    from envs.browsergym_env import BrowserGymEnv, BrowserGymAction
-
-    # Create evaluation environment
-    env = BrowserGymEnv.from_docker_image(
-        "browsergym-env:latest",
-        environment={
-            "BROWSERGYM_BENCHMARK": "webarena",
-            "BROWSERGYM_TASK_NAME": "0",
-            "SHOPPING": "http://your-server:7770",
-            # ... other backend URLs
-        }
-    )
-
-    # Evaluate your trained agent
-    result = env.reset()
-    # ... run evaluation
-    env.close()
-    ```
-"""
-
-from .client import BrowserGymEnv
-from .models import BrowserGymAction, BrowserGymObservation, BrowserGymState
-
-__all__ = [
-    "BrowserGymEnv",
-    "BrowserGymAction",
-    "BrowserGymObservation",
-    "BrowserGymState",
-]

openenv/src/envs/browsergym_env/client.py

@@ -1,123 +0,0 @@
-"""HTTP client for the BrowserGym environment."""
-
-from typing import Any, Dict
-
-from openenv_core.http_env_client import HTTPEnvClient, StepResult
-from browsergym_env.models import (
-    BrowserGymAction,
-    BrowserGymObservation,
-    BrowserGymState,
-)
-
-
-class BrowserGymEnv(HTTPEnvClient[BrowserGymAction, BrowserGymObservation]):
-    """Client for interacting with the BrowserGym environment over HTTP.
-
-    BrowserGym provides unified access to multiple web navigation benchmarks:
-    - MiniWoB++: 100+ training tasks (no external infrastructure needed!)
-    - WebArena: 812 evaluation tasks (requires backend setup)
-    - VisualWebArena: Visual navigation tasks
-    - WorkArena: Enterprise automation tasks
-
-    Example usage for TRAINING (MiniWoB - works out of the box):
-        ```python
-        from envs.browsergym_env import BrowserGymEnv, BrowserGymAction
-
-        # Create environment for MiniWoB training task
-        env = BrowserGymEnv.from_docker_image(
-            "browsergym-env:latest",
-            environment={
-                "BROWSERGYM_BENCHMARK": "miniwob",
-                "BROWSERGYM_TASK_NAME": "click-test",
-            }
-        )
-
-        # Reset and get initial observation
-        result = env.reset()
-        print(f"Task: {result.observation.goal}")
-        print(f"Page: {result.observation.text[:200]}")
-
-        # Take actions
-        action = BrowserGymAction(action_str="click('Submit button')")
-        result = env.step(action)
-        print(f"Reward: {result.reward}")
-        print(f"Done: {result.done}")
-
-        env.close()
-        ```
-
-    Example usage for EVALUATION (WebArena - requires backend):
-        ```python
-        from envs.browsergym_env import BrowserGymEnv, BrowserGymAction
-
-        # Create environment for WebArena evaluation
-        env = BrowserGymEnv.from_docker_image(
-            "browsergym-env:latest",
-            environment={
-                "BROWSERGYM_BENCHMARK": "webarena",
-                "BROWSERGYM_TASK_NAME": "0",  # Task 0
-                # WebArena backend URLs
-                "SHOPPING": "http://your-server:7770",
-                "GITLAB": "http://your-server:8023",
-                # ... other URLs
-            }
-        )
-
-        result = env.reset()
-        # ... interact with environment
-        env.close()
-        ```
-
-    Available benchmarks:
-        - miniwob: MiniWoB++ tasks (training, no setup required)
-        - webarena: WebArena tasks (evaluation, requires backend)
-        - visualwebarena: Visual WebArena tasks (evaluation, requires backend)
-        - workarena: WorkArena tasks (evaluation, requires backend)
-    """
-
-    def _step_payload(self, action: BrowserGymAction) -> Dict[str, Any]:
-        """Convert a BrowserGymAction to the JSON payload for the server."""
-        return {
-            "action_str": action.action_str,
-            "metadata": action.metadata,
-        }
-
-    def _parse_result(
-        self, payload: Dict[str, Any]
-    ) -> StepResult[BrowserGymObservation]:
-        """Parse the server response into a StepResult."""
-        obs_data = payload.get("observation", {})
-
-        observation = BrowserGymObservation(
-            text=obs_data.get("text", ""),
-            url=obs_data.get("url", ""),
-            screenshot=obs_data.get("screenshot"),
-            goal=obs_data.get("goal", ""),
-            axtree_txt=obs_data.get("axtree_txt", ""),
-            pruned_html=obs_data.get("pruned_html", ""),
-            error=obs_data.get("error", ""),
-            last_action_error=obs_data.get("last_action_error", False),
-            done=payload.get("done", False),
-            reward=payload.get("reward"),
-            metadata=obs_data.get("metadata", {}),
-        )
-
-        return StepResult(
-            observation=observation,
-            reward=payload.get("reward"),
-            done=payload.get("done", False),
-        )
-
-    def _parse_state(self, payload: Dict[str, Any]) -> BrowserGymState:
-        """Parse the server state response into a BrowserGymState object."""
-        return BrowserGymState(
-            episode_id=payload.get("episode_id"),
-            step_count=payload.get("step_count", 0),
-            benchmark=payload.get("benchmark", ""),
-            task_name=payload.get("task_name", ""),
-            task_id=payload.get("task_id"),
-            goal=payload.get("goal", ""),
-            current_url=payload.get("current_url", ""),
-            max_steps=payload.get("max_steps"),
-            cum_reward=payload.get("cum_reward", 0.0),
-        )

openenv/src/envs/browsergym_env/models.py

@@ -1,92 +0,0 @@
-"""Data models for the BrowserGym environment.
-
-BrowserGym is a unified framework for web-based agent tasks, combining multiple
-benchmarks including MiniWoB (training), WebArena (evaluation), VisualWebArena,
-and more under a single Gymnasium-compatible API.
-"""
-
-from dataclasses import dataclass
-from typing import List, Optional
-
-from openenv_core.env_server.types import Action, Observation, State
-
-
-@dataclass(kw_only=True)
-class BrowserGymAction(Action):
-    """Action to be executed in the BrowserGym environment.
-
-    BrowserGym supports high-level natural language actions that can be parsed
-    into browser operations.
-
-    Example actions:
-    - "click('Submit button')"
-    - "fill('username', 'john@example.com')"
-    - "goto('https://example.com')"
-    - "scroll(down)"
-    - "send_keys('Enter')"
-    """
-
-    action_str: str
-    """Natural language action string (e.g., "click('Submit')")"""
-
-
-@dataclass(kw_only=True)
-class BrowserGymObservation(Observation):
-    """Observation returned from the BrowserGym environment.
-
-    Contains multiple observation modalities including text (accessibility tree
-    or DOM), visual (screenshot), and page metadata.
-    """
-
-    text: str = ""
-    """Text representation of the page (accessibility tree or DOM)"""
-
-    url: str = ""
-    """Current URL of the page"""
-
-    screenshot: Optional[List[List[List[int]]]] = None
-    """Screenshot as numpy array [height, width, channels] (if visual observation enabled)"""
-
-    goal: str = ""
-    """Task goal/instruction for the current episode"""
-
-    axtree_txt: str = ""
-    """Full accessibility tree as text"""
-
-    pruned_html: str = ""
-    """Pruned HTML content (interactive elements only)"""
-
-    error: str = ""
-    """Error message if action execution failed"""
-
-    last_action_error: bool = False
-    """Whether the last action resulted in an error"""
-
-
-@dataclass
-class BrowserGymState(State):
-    """State of the BrowserGym environment.
-
-    Tracks the current benchmark, task, and progress through an episode.
-    """
-
-    benchmark: str = ""
-    """Benchmark name (e.g., 'miniwob', 'webarena', 'visualwebarena')"""
-
-    task_name: str = ""
-    """Specific task within the benchmark (e.g., 'click-test', 'click-button')"""
-
-    task_id: Optional[str] = None
-    """Task ID for evaluation benchmarks (e.g., WebArena task number)"""
-
-    goal: str = ""
-    """Task goal/instruction"""
-
-    current_url: str = ""
-    """Current URL of the active page"""
-
-    max_steps: Optional[int] = None
-    """Maximum steps allowed for this task"""
-
-    cum_reward: float = 0.0
-    """Cumulative reward for the current episode"""

openenv/src/envs/browsergym_env/openenv.yaml

@@ -1,5 +0,0 @@
-name: browsergym_env
-version: "0.1.0"
-description: "BrowserGym environment for web automation tasks using Playwright"
-action: BrowserGymAction
-observation: BrowserGymObservation

openenv/src/envs/browsergym_env/pyproject.toml

@@ -1,39 +0,0 @@
-[build-system]
-requires = ["setuptools>=45", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "openenv-browsergym_env"
-version = "0.1.0"
-description = "BrowserGym Environment for OpenEnv - Web automation using Playwright"
-requires-python = ">=3.10"
-dependencies = [
-    "openenv-core @ git+https://github.com/meta-pytorch/OpenEnv.git#subdirectory=src/core",
-    "fastapi>=0.104.0",
-    "uvicorn>=0.24.0",
-    "pydantic>=2.0.0",
-    "requests>=2.25.0",
-    "browsergym-core>=0.2.0",
-    "browsergym-miniwob>=0.2.0",
-    "browsergym-webarena>=0.2.0",
-    "gymnasium>=0.29.0",
-    "playwright>=1.40.0",
-    "Pillow>=10.0.0",
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-cov>=4.0.0",
-    "ipykernel>=6.29.5",
-]
-
-[project.scripts]
-server = "browsergym_env.server.app:main"
-
-[tool.setuptools]
-packages = ["browsergym_env", "browsergym_env.server"]
-package-dir = { "browsergym_env" = ".", "browsergym_env.server" = "server" }
-
-[tool.setuptools.package-data]
-browsergym_env = ["**/*.yaml", "**/*.yml", "**/*.md"]