Upload folder using huggingface_hub

Dockerfile

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

README.md

@@ -1,10 +1,255 @@
 ---
-title: Compressionenv
-emoji: 😻
-colorFrom: blue
-colorTo: yellow
+title: Compressionenv Environment Server
+emoji: 🎾
+colorFrom: purple
+colorTo: blue
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Compressionenv Environment
+
+A simple test environment that echoes back messages. Perfect for testing the env APIs as well as demonstrating environment usage patterns.
+
+## Quick Start
+
+The simplest way to use the Compressionenv environment is through the `CompressionenvEnv` class:
+
+```python
+from compressionenv import CompressionenvAction, CompressionenvEnv
+
+try:
+    # Create environment from Docker image
+    compressionenvenv = CompressionenvEnv.from_docker_image("compressionenv-env:latest")
+
+    # Reset
+    result = compressionenvenv.reset()
+    print(f"Reset: {result.observation.echoed_message}")
+
+    # Send multiple messages
+    messages = ["Hello, World!", "Testing echo", "Final message"]
+
+    for msg in messages:
+        result = compressionenvenv.step(CompressionenvAction(message=msg))
+        print(f"Sent: '{msg}'")
+        print(f"  → Echoed: '{result.observation.echoed_message}'")
+        print(f"  → Length: {result.observation.message_length}")
+        print(f"  → Reward: {result.reward}")
+
+finally:
+    # Always clean up
+    compressionenvenv.close()
+```
+
+That's it! The `CompressionenvEnv.from_docker_image()` method handles:
+- Starting the Docker container
+- Waiting for the server to be ready
+- Connecting to the environment
+- Container cleanup when you call `close()`
+
+## Building the Docker Image
+
+Before using the environment, you need to build the Docker image:
+
+```bash
+# From project root
+docker build -t compressionenv-env:latest -f server/Dockerfile .
+```
+
+## Deploying to Hugging Face Spaces
+
+You can easily deploy your OpenEnv environment to Hugging Face Spaces using the `openenv push` command:
+
+```bash
+# From the environment directory (where openenv.yaml is located)
+openenv push
+
+# Or specify options
+openenv push --namespace my-org --private
+```
+
+The `openenv push` command will:
+1. Validate that the directory is an OpenEnv environment (checks for `openenv.yaml`)
+2. Prepare a custom build for Hugging Face Docker space (enables web interface)
+3. Upload to Hugging Face (ensuring you're logged in)
+
+### Prerequisites
+
+- Authenticate with Hugging Face: The command will prompt for login if not already authenticated
+
+### Options
+
+- `--directory`, `-d`: Directory containing the OpenEnv environment (defaults to current directory)
+- `--repo-id`, `-r`: Repository ID in format 'username/repo-name' (defaults to 'username/env-name' from openenv.yaml)
+- `--base-image`, `-b`: Base Docker image to use (overrides Dockerfile FROM)
+- `--private`: Deploy the space as private (default: public)
+
+### Examples
+
+```bash
+# Push to your personal namespace (defaults to username/env-name from openenv.yaml)
+openenv push
+
+# Push to a specific repository
+openenv push --repo-id my-org/my-env
+
+# Push with a custom base image
+openenv push --base-image ghcr.io/meta-pytorch/openenv-base:latest
+
+# Push as a private space
+openenv push --private
+
+# Combine options
+openenv push --repo-id my-org/my-env --base-image custom-base:latest --private
+```
+
+After deployment, your space will be available at:
+`https://huggingface.co/spaces/<repo-id>`
+
+The deployed space 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
+- **WebSocket** at `/ws` - Persistent session endpoint for low-latency interactions
+
+## Environment Details
+
+### Action
+**CompressionenvAction**: Contains a single field
+- `message` (str) - The message to echo back
+
+### Observation
+**CompressionenvObservation**: Contains the echo response and metadata
+- `echoed_message` (str) - The message echoed back
+- `message_length` (int) - Length of the message
+- `reward` (float) - Reward based on message length (length × 0.1)
+- `done` (bool) - Always False for echo environment
+- `metadata` (dict) - Additional info like step count
+
+### Reward
+The reward is calculated as: `message_length × 0.1`
+- "Hi" → reward: 0.2
+- "Hello, World!" → reward: 1.3
+- Empty message → reward: 0.0
+
+## Advanced Usage
+
+### Connecting to an Existing Server
+
+If you already have a Compressionenv environment server running, you can connect directly:
+
+```python
+from compressionenv import CompressionenvEnv
+
+# Connect to existing server
+compressionenvenv = CompressionenvEnv(base_url="<ENV_HTTP_URL_HERE>")
+
+# Use as normal
+result = compressionenvenv.reset()
+result = compressionenvenv.step(CompressionenvAction(message="Hello!"))
+```
+
+Note: When connecting to an existing server, `compressionenvenv.close()` will NOT stop the server.
+
+### Using the Context Manager
+
+The client supports context manager usage for automatic connection management:
+
+```python
+from compressionenv import CompressionenvAction, CompressionenvEnv
+
+# Connect with context manager (auto-connects and closes)
+with CompressionenvEnv(base_url="http://localhost:8000") as env:
+    result = env.reset()
+    print(f"Reset: {result.observation.echoed_message}")
+    # Multiple steps with low latency
+    for msg in ["Hello", "World", "!"]:
+        result = env.step(CompressionenvAction(message=msg))
+        print(f"Echoed: {result.observation.echoed_message}")
+```
+
+The client uses WebSocket connections for:
+- **Lower latency**: No HTTP connection overhead per request
+- **Persistent session**: Server maintains your environment state
+- **Efficient for episodes**: Better for many sequential steps
+
+### Concurrent WebSocket Sessions
+
+The server supports multiple concurrent WebSocket connections. To enable this,
+modify `server/app.py` to use factory mode:
+
+```python
+# In server/app.py - use factory mode for concurrent sessions
+app = create_app(
+    CompressionenvEnvironment,  # Pass class, not instance
+    CompressionenvAction,
+    CompressionenvObservation,
+    max_concurrent_envs=4,  # Allow 4 concurrent sessions
+)
+```
+
+Then multiple clients can connect simultaneously:
+
+```python
+from compressionenv import CompressionenvAction, CompressionenvEnv
+from concurrent.futures import ThreadPoolExecutor
+
+def run_episode(client_id: int):
+    with CompressionenvEnv(base_url="http://localhost:8000") as env:
+        result = env.reset()
+        for i in range(10):
+            result = env.step(CompressionenvAction(message=f"Client {client_id}, step {i}"))
+        return client_id, result.observation.message_length
+
+# Run 4 episodes concurrently
+with ThreadPoolExecutor(max_workers=4) as executor:
+    results = list(executor.map(run_episode, range(4)))
+```
+
+## Development & Testing
+
+### Direct Environment Testing
+
+Test the environment logic directly without starting the HTTP server:
+
+```bash
+# From the server directory
+python3 server/compressionenv_environment.py
+```
+
+This verifies that:
+- Environment resets correctly
+- Step executes actions properly
+- State tracking works
+- Rewards are calculated correctly
+
+### Running Locally
+
+Run the server locally for development:
+
+```bash
+uvicorn server.app:app --reload
+```
+
+## Project Structure
+
+```
+compressionenv/
+├── .dockerignore         # Docker build exclusions
+├── __init__.py            # Module exports
+├── README.md              # This file
+├── openenv.yaml           # OpenEnv manifest
+├── pyproject.toml         # Project metadata and dependencies
+├── uv.lock                # Locked dependencies (generated)
+├── client.py              # CompressionenvEnv client
+├── models.py              # Action and Observation models
+└── server/
+    ├── __init__.py        # Server module exports
+    ├── compressionenv_environment.py  # Core environment logic
+    ├── app.py             # FastAPI application (HTTP + WebSocket endpoints)
+    └── Dockerfile         # Container image definition
+```

__init__.py

@@ -0,0 +1,16 @@
+# 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.
+
+"""Compressionenv Environment."""
+
+from .client import CompressionenvEnv
+from .models import CompressionenvAction, CompressionenvObservation
+
+__all__ = [
+    "CompressionenvAction",
+    "CompressionenvObservation",
+    "CompressionenvEnv",
+]

client.py

@@ -0,0 +1,99 @@
+# 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.
+
+"""Compressionenv Environment Client."""
+
+from typing import Dict
+
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+from openenv.core import EnvClient
+
+from .models import CompressionenvAction, CompressionenvObservation
+
+
+class CompressionenvEnv(
+    EnvClient[CompressionenvAction, CompressionenvObservation]
+):
+    """
+    Client for the Compressionenv Environment.
+
+    This client maintains a persistent WebSocket connection to the environment server,
+    enabling efficient multi-step interactions with lower latency.
+    Each client instance has its own dedicated environment session on the server.
+
+    Example:
+        >>> # Connect to a running server
+        >>> with CompressionenvEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.echoed_message)
+        ...
+        ...     result = client.step(CompressionenvAction(message="Hello!"))
+        ...     print(result.observation.echoed_message)
+
+    Example with Docker:
+        >>> # Automatically start container and connect
+        >>> client = CompressionenvEnv.from_docker_image("compressionenv-env:latest")
+        >>> try:
+        ...     result = client.reset()
+        ...     result = client.step(CompressionenvAction(message="Test"))
+        ... finally:
+        ...     client.close()
+    """
+
+    def _step_payload(self, action: CompressionenvAction) -> Dict:
+        """
+        Convert CompressionenvAction to JSON payload for step message.
+
+        Args:
+            action: CompressionenvAction instance
+
+        Returns:
+            Dictionary representation suitable for JSON encoding
+        """
+        return {
+            "message": action.message,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[CompressionenvObservation]:
+        """
+        Parse server response into StepResult[CompressionenvObservation].
+
+        Args:
+            payload: JSON response data from server
+
+        Returns:
+            StepResult with CompressionenvObservation
+        """
+        obs_data = payload.get("observation", {})
+        observation = CompressionenvObservation(
+            echoed_message=obs_data.get("echoed_message", ""),
+            message_length=obs_data.get("message_length", 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) -> State:
+        """
+        Parse server response into State object.
+
+        Args:
+            payload: JSON response from state request
+
+        Returns:
+            State object with episode_id and step_count
+        """
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

models.py

@@ -0,0 +1,100 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Data models for the Compressionenv Environment.
+
+The compressionenv environment gives the agent a Paul Graham essay and asks it to
+propose compression + decompression algorithms (as Python code).
+"""
+
+from typing import Any, Dict, Optional
+
+from pydantic import Field
+
+from openenv.core.env_server.types import Action, Observation
+
+
+class CompressionenvAction(Action):
+    """
+    Agent-provided compression/decompression algorithms.
+
+    The environment expects `compression_code` and `decompression_code` to define:
+
+    - compress(text: str) -> bytes
+    - decompress(data: bytes) -> str
+    """
+
+    compression_code: str = Field(
+        ...,
+        description="Python code defining compress(text: str) -> bytes",
+        min_length=1,
+    )
+    decompression_code: str = Field(
+        ...,
+        description="Python code defining decompress(data: bytes) -> str",
+        min_length=1,
+    )
+    algo_name: str = Field(
+        default="agent_algo",
+        description="Optional name/label for this algorithm variant",
+    )
+
+
+class CompressionenvObservation(Observation):
+    """Observation from the Compressionenv environment."""
+
+    essay_id: str = Field(..., description="Selected essay slug/id for this episode")
+    essay_text: str = Field(
+        ...,
+        description="Full essay text for the agent to compress",
+    )
+
+    valid: bool = Field(
+        default=False,
+        description="Whether the submitted algorithms successfully round-tripped",
+    )
+    error: Optional[str] = Field(
+        default=None,
+        description="Error message if the algorithms failed validation/execution",
+    )
+
+    compressed_size_bytes: Optional[int] = Field(
+        default=None,
+        description="Size of compressed bytes produced by the agent algorithm",
+        ge=0,
+    )
+    avg_prev_compressed_size_bytes: Optional[float] = Field(
+        default=None,
+        description="Average compressed size over previous successful steps for this essay",
+        ge=0,
+    )
+    improved_over_avg: Optional[bool] = Field(
+        default=None,
+        description="True if current compressed size < avg of previous sizes",
+    )
+
+    baselines_size_bytes: Dict[str, int] = Field(
+        default_factory=dict,
+        description="Baseline compressor sizes for this essay (zlib/bz2/lzma)",
+    )
+    best_baseline_size_bytes: Optional[int] = Field(
+        default=None,
+        description="Best (smallest) baseline size in bytes",
+        ge=0,
+    )
+    beat_any_baseline: Optional[bool] = Field(
+        default=None,
+        description="True if current compressed size is smaller than at least one baseline",
+    )
+    beat_best_baseline: Optional[bool] = Field(
+        default=None,
+        description="True if current compressed size is smaller than the best baseline",
+    )
+
+    reward: float = Field(default=0.0, description="Reward for this step")
+    done: bool = Field(default=False, description="Whether episode is done")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Extra info")

openenv.yaml

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

pyproject.toml

@@ -0,0 +1,45 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-compressionenv"
+version = "0.1.0"
+description = "Compressionenv environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]>=0.2.0",
+    # Environment-specific dependencies
+    # Add all dependencies needed for your environment here
+    # Examples:
+    # "numpy>=1.19.0",
+    # "torch>=2.0.0",
+    # "gymnasium>=0.29.0",
+    # "openspiel>=1.0.0",
+    # "smolagents>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m compressionenv.server.app
+server = "compressionenv.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["compressionenv", "compressionenv.server"]
+package-dir = { "compressionenv" = ".", "compressionenv.server" = "server" }

server/__init__.py

@@ -0,0 +1,11 @@
+# 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.
+
+"""Compressionenv environment server components."""
+
+from .compressionenv_environment import CompressionenvEnvironment
+
+__all__ = ["CompressionenvEnvironment"]

server/app.py

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Compressionenv Environment.
+
+This module creates an HTTP server that exposes the CompressionenvEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+# Import from local models.py (PYTHONPATH includes /app/env in Docker)
+from models import CompressionenvAction, CompressionenvObservation
+from .compressionenv_environment import CompressionenvEnvironment
+
+
+# Create the app with web interface and README integration
+app = create_app(
+    CompressionenvEnvironment,
+    CompressionenvAction,
+    CompressionenvObservation,
+    env_name="compressionenv",
+    max_concurrent_envs=1,  # increase this number to allow more concurrent WebSocket sessions
+)
+
+
+def main(host: str = "0.0.0.0", port: int = 8000):
+    """
+    Entry point for direct execution via uv run or python -m.
+
+    This function enables running the server without Docker:
+        uv run --project . server
+        uv run --project . server --port 8001
+        python -m compressionenv.server.app
+
+    Args:
+        host: Host address to bind to (default: "0.0.0.0")
+        port: Port number to listen on (default: 8000)
+
+    For production deployments, consider using uvicorn directly with
+    multiple workers:
+        uvicorn compressionenv.server.app:app --workers 4
+    """
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    main(port=args.port)

server/compressionenv_environment.py

@@ -0,0 +1,315 @@
+# 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.
+
+"""
+Compressionenv Environment Implementation.
+
+Environment where the agent proposes compression/decompression algorithms for a
+Paul Graham essay. The environment validates round-trip correctness and scores
+compressed size relative to the agent's prior attempts and baseline compressors.
+"""
+
+import base64
+import json
+import os
+import random
+import subprocess
+import sys
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from uuid import uuid4
+
+import bz2
+import lzma
+import zlib
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+from models import CompressionenvAction, CompressionenvObservation
+
+
+@dataclass(frozen=True)
+class _Essay:
+    essay_id: str
+    text: str
+
+
+class CompressionenvEnvironment(Environment):
+    """
+    Compression algorithm search environment.
+
+    - On `reset()`, selects a PG essay (from `../essays/*.txt`) and returns it.
+    - On `step()`, executes agent-provided Python code defining:
+        compress(text: str) -> bytes
+        decompress(data: bytes) -> str
+      Validates that decompress(compress(essay)) == essay.
+
+    Rewards (per spec):
+    - If algorithms fail or don't round-trip: -1 reward.
+    - If compressed size is lower than average of previous successful sizes for
+      this essay in the episode: +1 reward.
+    - Compare against baselines (zlib, bz2, lzma):
+        - If agent achieves smaller size than at least one baseline: +10 reward.
+        - If agent achieves smaller size than the best baseline: +20 reward.
+    """
+
+    # Enable concurrent WebSocket sessions.
+    # Set to True if your environment isolates state between instances.
+    # When True, multiple WebSocket clients can connect simultaneously, each
+    # getting their own environment instance (when using factory mode in app.py).
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self):
+        """Initialize the compressionenv environment."""
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._essay: _Essay | None = None
+        self._successful_sizes: list[int] = []
+        self._baselines: dict[str, int] = {}
+
+    def reset(self) -> CompressionenvObservation:
+        """
+        Reset the environment.
+
+        Returns:
+            CompressionenvObservation containing a selected essay
+        """
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+        self._essay = self._pick_essay()
+        self._successful_sizes = []
+        self._baselines = self._compute_baselines(self._essay.text)
+
+        return CompressionenvObservation(
+            essay_id=self._essay.essay_id,
+            essay_text=self._essay.text,
+            valid=True,
+            error=None,
+            compressed_size_bytes=None,
+            avg_prev_compressed_size_bytes=None,
+            improved_over_avg=None,
+            baselines_size_bytes=self._baselines,
+            best_baseline_size_bytes=min(self._baselines.values()) if self._baselines else None,
+            beat_any_baseline=None,
+            beat_best_baseline=None,
+            done=False,
+            reward=0.0,
+            metadata={
+                "episode_id": self._state.episode_id,
+                "step_count": self._state.step_count,
+                "num_baselines": len(self._baselines),
+            },
+        )
+
+    def step(self, action: CompressionenvAction) -> CompressionenvObservation:  # type: ignore[override]
+        """
+        Execute a step: run agent algorithms, validate, score compression size.
+        """
+        if self._essay is None:
+            # Defensive: ensure reset called.
+            self._essay = self._pick_essay()
+            self._baselines = self._compute_baselines(self._essay.text)
+            self._successful_sizes = []
+
+        self._state.step_count += 1
+
+        essay_text = self._essay.text
+        baselines = self._baselines
+        best_baseline = min(baselines.values()) if baselines else None
+
+        reward = 0.0
+        error: str | None = None
+        valid = False
+        compressed_size: int | None = None
+        improved_over_avg: bool | None = None
+        beat_any_baseline: bool | None = None
+        beat_best_baseline: bool | None = None
+        avg_prev: float | None = None
+
+        try:
+            compressed_bytes = self._run_agent_codec(
+                essay_text=essay_text,
+                compression_code=action.compression_code,
+                decompression_code=action.decompression_code,
+            )
+            compressed_size = len(compressed_bytes)
+            valid = True
+        except Exception as e:
+            error = str(e)
+            reward = -1.0
+
+        if valid and compressed_size is not None:
+            if self._successful_sizes:
+                avg_prev = sum(self._successful_sizes) / len(self._successful_sizes)
+                improved_over_avg = compressed_size < avg_prev
+                if improved_over_avg:
+                    reward += 1.0
+            else:
+                avg_prev = None
+                improved_over_avg = None
+
+            self._successful_sizes.append(compressed_size)
+
+            if baselines:
+                beat_any_baseline = any(compressed_size < s for s in baselines.values())
+                beat_best_baseline = best_baseline is not None and compressed_size < best_baseline
+                if beat_best_baseline:
+                    reward += 20.0
+                elif beat_any_baseline:
+                    reward += 10.0
+
+        return CompressionenvObservation(
+            essay_id=self._essay.essay_id,
+            essay_text=essay_text,
+            valid=valid,
+            error=error,
+            compressed_size_bytes=compressed_size,
+            avg_prev_compressed_size_bytes=avg_prev,
+            improved_over_avg=improved_over_avg,
+            baselines_size_bytes=baselines,
+            best_baseline_size_bytes=best_baseline,
+            beat_any_baseline=beat_any_baseline,
+            beat_best_baseline=beat_best_baseline,
+            done=False,
+            reward=reward,
+            metadata={
+                "episode_id": self._state.episode_id,
+                "step_count": self._state.step_count,
+                "algo_name": action.algo_name,
+                "num_successful_attempts": len(self._successful_sizes),
+            },
+        )
+
+    @property
+    def state(self) -> State:
+        """
+        Get the current environment **state**.
+
+        In RL terms, the State is a (Markov) description of the underlying
+        environment that is at least as informative as any single Observation.
+        Here we include all information needed to reconstruct what any call to
+        `reset()` or `step()` would expose in an observation for this episode.
+
+        Returns:
+            Current State with core fields plus extra environment details.
+        """
+        # State allows extra fields, so we enrich it to be a superset of any
+        # single observation: from this State, an agent could derive the latest
+        # observation for the current episode.
+        if self._essay is not None:
+            self._state.essay_id = self._essay.essay_id  # type: ignore[attr-defined]
+            self._state.essay_text = self._essay.text  # type: ignore[attr-defined]
+            self._state.baselines_size_bytes = self._baselines  # type: ignore[attr-defined]
+            self._state.num_successful_attempts = len(self._successful_sizes)  # type: ignore[attr-defined]
+            if self._successful_sizes:
+                self._state.best_compressed_size_bytes = min(self._successful_sizes)  # type: ignore[attr-defined]
+                self._state.last_compressed_size_bytes = self._successful_sizes[-1]  # type: ignore[attr-defined]
+            if self._baselines:
+                self._state.best_baseline_size_bytes = min(self._baselines.values())  # type: ignore[attr-defined]
+        return self._state
+
+    def _pick_essay(self) -> _Essay:
+        # Expected layout:
+        #   compression-openenv/
+        #     essays/
+        #     compressionenv/
+        #       server/
+        #         compressionenv_environment.py  (this file)
+        essays_dir = Path(__file__).resolve().parents[2] / "essays"
+        if not essays_dir.exists():
+            # Try repo-level essays directory (if running from different cwd/layout).
+            essays_dir = Path(os.getcwd()).resolve() / "essays"
+        paths = sorted(essays_dir.glob("*.txt"))
+        if not paths:
+            raise FileNotFoundError(
+                f"No essays found in {essays_dir}. Expected PG essay .txt files."
+            )
+        path = random.choice(paths)
+        essay_id = path.stem
+        text = path.read_text(encoding="utf-8")
+        return _Essay(essay_id=essay_id, text=text)
+
+    def _compute_baselines(self, text: str) -> dict[str, int]:
+        data = text.encode("utf-8")
+        # Deterministic settings.
+        baselines: dict[str, bytes] = {
+            "zlib": zlib.compress(data, level=9),
+            "bz2": bz2.compress(data, compresslevel=9),
+            "lzma": lzma.compress(data, preset=9),
+        }
+        return {k: len(v) for k, v in baselines.items()}
+
+    def _run_agent_codec(
+        self,
+        essay_text: str,
+        compression_code: str,
+        decompression_code: str,
+    ) -> bytes:
+        """
+        Execute agent code in a subprocess and return compressed bytes.
+
+        Security note: this is not a hardened sandbox. It's a best-effort isolation
+        to avoid contaminating the server process, with a timeout.
+        """
+        runner = r"""
+import base64
+import json
+import sys
+
+payload = json.loads(sys.stdin.read())
+essay_text = payload["essay_text"]
+compression_code = payload["compression_code"]
+decompression_code = payload["decompression_code"]
+
+ns = {}
+exec(compression_code, ns, ns)
+exec(decompression_code, ns, ns)
+
+compress = ns.get("compress")
+decompress = ns.get("decompress")
+if compress is None or decompress is None:
+    raise RuntimeError("Expected functions compress(text: str)->bytes and decompress(data: bytes)->str")
+
+compressed = compress(essay_text)
+if not isinstance(compressed, (bytes, bytearray)):
+    raise RuntimeError(f"compress() must return bytes, got {type(compressed)}")
+compressed = bytes(compressed)
+
+round_trip = decompress(compressed)
+if not isinstance(round_trip, str):
+    raise RuntimeError(f"decompress() must return str, got {type(round_trip)}")
+if round_trip != essay_text:
+    raise RuntimeError("Round-trip failed: decompress(compress(essay)) != essay")
+
+sys.stdout.write(base64.b64encode(compressed).decode("ascii"))
+"""
+        payload = {
+            "essay_text": essay_text,
+            "compression_code": compression_code,
+            "decompression_code": decompression_code,
+        }
+        with tempfile.TemporaryDirectory() as td:
+            proc = subprocess.run(
+                [sys.executable, "-c", runner],
+                input=json.dumps(payload).encode("utf-8"),
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                cwd=td,
+                timeout=3.0,
+                env={
+                    "PYTHONIOENCODING": "utf-8",
+                    "PYTHONUTF8": "1",
+                    "PYTHONDONTWRITEBYTECODE": "1",
+                },
+            )
+        if proc.returncode != 0:
+            stderr = proc.stderr.decode("utf-8", errors="replace").strip()
+            raise RuntimeError(stderr or f"Agent codec subprocess failed with code {proc.returncode}")
+        out = proc.stdout.decode("utf-8", errors="replace").strip()
+        try:
+            return base64.b64decode(out.encode("ascii"), validate=True)
+        except Exception as e:
+            raise RuntimeError(f"Failed to decode compressed output: {e}") from e

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+

spec.md

@@ -0,0 +1 @@
+create an environment where agent is given a pg essay text and it comes up with a compression and decompression algorithms for it. the environment runs the algorithm on essay and gives +1 reward to agent if curent step's compressed text size is lower than avg of all compression sizes achieved so far in previous steps for that essay. it also runs compressions and decompression on the essay to verify that compression and decompression algorithms work correctly, if they don't then it's -1 reward. it also runs state of the art eg zip, bzip etc top text compressions on the essay and checks the size. if agent achieves smaller size than any of them it's +10 and if it achieves smallest size than it's +20 reward.