Add V1 env

.dockerignore

@@ -0,0 +1,8 @@
+.git
+.idea
+venv
+__pycache__
+*.pyc
+outputs
+.adapt_tmp
+.pip-tmp

.gitignore

@@ -43,6 +43,8 @@ htmlcov/
 .coverage
 .coverage.*
 .cache
+.adapt_tmp/
+.pip-tmp/
 nosetests.xml
 coverage.xml
 *.cover
@@ -151,7 +153,6 @@ activemq-data/
 .envrc
 .venv
 venv/
-ENV/
 env.bak/
 venv.bak/
 

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY . .
+
+RUN pip install --no-cache-dir -e .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,127 +1,166 @@
-# meta-rl-dsa-solver
+---
+title: ADAPT DSA Tutor OpenEnv
+sdk: docker
+pinned: false
+app_port: 7860
+base_path: /web
+tags:
+  - openenv
+  - reinforcement-learning
+  - code-generation
+---
 
-ADAPT (Adversarial DSA Tutor) is a minimal reinforcement learning environment for DSA code-generation tasks.
+# ADAPT DSA Tutor OpenEnv
 
-The current implementation is V1: direct Python usage, no FastAPI, multiple test cases, hidden tests, subprocess execution, and verifier-based rewards.
+ADAPT, the Adversarial DSA Tutor, is an OpenEnv-compliant RLVR environment for training code-generation agents on small DSA tasks. The agent receives a problem prompt, examples, and visible tests, then submits Python code. The environment runs the code against visible and hidden tests and returns reward, pass-rate metrics, execution status, and feedback.
 
-## Usage
+This repo now focuses on the environment layer only. Verifier work and training scripts are owned separately.
 
-```python
-from env.adapt_env import AdaptEnv
-
-env = AdaptEnv()
-
-obs = env.reset()
-result = env.step("n=int(input())\nprint(n*2)")
-
-reward = result["reward"]
-```
+## Why This Environment
 
-Flow:
+The hackathon asks for OpenEnv environments that can improve LLM behavior through verifiable interaction. ADAPT targets a simple but useful skill loop:
 
 ```text
-model -> generates code -> env.step(code) -> executor runs code -> verifier evaluates -> env returns result
+agent writes code -> environment executes it -> hidden tests and reward signals score it -> trainer improves the agent
 ```
 
-## Files
+The differentiator is curriculum-ready DSA practice: each episode carries a problem id and difficulty tier so training can track per-tier success instead of only aggregate reward.
 
-- `env/adapt_env.py`: reset/step orchestration only
-- `env/executor.py`: subprocess execution with a 2 second timeout
-- `env/test_cases.py`: problem definition plus visible and hidden test cases
+## OpenEnv Interface
 
-## Observation
-
-`reset()` returns:
+The environment uses the latest OpenEnv API shape:
 
-```python
-{
-    "problem": str,
-    "input_format": str,
-    "constraints": str,
-    "examples": list,
-    "visible_tests": list,
-}
-```
+- `AdaptEnvironment(Environment[AdaptAction, AdaptObservation, AdaptState])`
+- `reset()` returns a typed observation.
+- `step(action)` accepts an `AdaptAction` with a Python `code` string.
+- `state` exposes episode id, step count, current problem id, difficulty, and recent metrics.
 
-Hidden tests are kept inside the environment and are not shown in the observation.
+`openenv.yaml` points to:
 
-## Step Result
+```yaml
+app: server.app:app
+port: 7860
+```
 
-`step(code)` returns:
+## Action
 
 ```python
 {
-    "reward": float,
-    "done": bool,
-    "feedback": str,
-    "pass_rate": float,
+    "code": "n = int(input())\nprint(n * 2)"
 }
 ```
 
-## Verifier Requirement
+## Observation
 
-`env.step(code)` calls:
+Reset and step observations include:
 
-```python
-from verifier.verifier import verify
+- problem statement
+- input format
+- constraints
+- examples
+- visible tests
+- problem id
+- difficulty tier
+- feedback
+- pass rate, visible pass rate, and hidden pass rate
+- syntax/runtime/timeout status
+- reward components
 
-reward, metadata = verify(code, test_cases)
-```
+Hidden test inputs and expected outputs are never returned in observations.
 
-The verifier should return:
+## Reward
 
-```python
-(
-    1.0,
-    {
-        "pass_rate": 1.0,
-        "feedback": "All tests passed. Pass rate: 1.00",
-    },
-)
-```
+Reward is clipped to `[0.0, 1.0]` and combines multiple environment-level signals:
+
+- correctness from visible and hidden pass rate
+- syntax validity
+- clean execution
+- output format compliance
+- timeout penalty
+- runtime error penalty
+- static safety rejection for dangerous imports such as `os`, `subprocess`, `socket`, `pathlib`, and `shutil`
 
-If `metadata` does not include `pass_rate` or `feedback`, the environment computes fallback values from executor results.
+If `verifier.verifier.verify(code, test_cases)` exists, the environment can use it as an optional reward augmentation. If the verifier is absent, the environment still works using executor-derived reward.
 
-## Smoke Checks
+## Local Setup
 
-From this directory:
+Use Python `3.10+`.
 
 ```powershell
 cd C:\Users\kaust\PycharmProjects\meta-rl-dsa-solver
+python -m venv .venv
+.\.venv\Scripts\pip install -e .
 ```
 
-Check reset and visible/hidden split:
+For this local machine, the existing checked-out OpenEnv repo can also be used during development:
 
 ```powershell
-python -B -c "from env.adapt_env import AdaptEnv; env=AdaptEnv(); print(env.reset()); print(len(env.visible_tests), len(env.hidden_tests))"
+$env:PYTHONPATH="C:\Users\kaust\PycharmProjects\OpenEnv\src;$PWD"
 ```
 
-Expected split:
+## Smoke Tests
 
-```text
-3 5
+Run the local smoke test:
+
+```powershell
+python test.py
 ```
 
-Check executor directly:
+Check syntax:
 
 ```powershell
-python -B -c "from env.executor import run_code; print(run_code('n=int(input())\nprint(n*2)', '5\n'))"
+python -m py_compile models.py env\adapt_env.py env\executor.py env\test_cases.py server\app.py
 ```
 
-Expected output:
+Start the OpenEnv server:
 
-```python
-{'stdout': '10\n', 'stderr': '', 'exit_code': 0}
+```powershell
+uvicorn server.app:app --host 0.0.0.0 --port 7860
+```
+
+Useful endpoints:
+
+- `GET /health`
+- `GET /schema`
+- `POST /reset`
+- `POST /step`
+- `GET /state`
+
+Example step request:
+
+```powershell
+curl -X POST http://localhost:7860/step -H "Content-Type: application/json" -d "{\"action\":{\"code\":\"n=int(input())\nprint(n*2)\"}}"
 ```
 
-Once `verifier/verifier.py` exists, check the full environment:
+Validate with OpenEnv once dependencies are installed:
 
 ```powershell
-python -B -c "from env.adapt_env import AdaptEnv; env=AdaptEnv(); env.reset(); print(env.step('n=int(input())\nprint(n*2)'))"
+openenv validate .
 ```
 
-Check a wrong answer:
+## Hugging Face Spaces
+
+This repo is Docker Space ready:
 
 ```powershell
-python -B -c "from env.adapt_env import AdaptEnv; env=AdaptEnv(); env.reset(); print(env.step('n=int(input())\nprint(n+2)'))"
+openenv push --repo-id <your-hf-username>/adapt-dsa-tutor
 ```
+
+Before final submission, add:
+
+- live Hugging Face Space link
+- training reward/loss plots from Disha's run
+- before/after code example showing a problem the model failed before training and solved after training
+- mini-blog or short video link
+
+## Current Problem Bank
+
+The environment includes a lightweight curated bank:
+
+- `easy_double`
+- `easy_sum_two`
+- `medium_maximum`
+- `medium_count_even`
+- `hard_reverse_words`
+
+This is intentionally small for submission-minimum stability. Later work can expand it to 30-50 tiered problems without changing the OpenEnv API.

app.py

@@ -0,0 +1,3 @@
+from server.app import app, main
+
+__all__ = ["app", "main"]

client.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from models import AdaptAction
+
+
+class AdaptEnvClient:
+    def __init__(self, base_url: str = "http://localhost:7860") -> None:
+        self.base_url = base_url.rstrip("/")
+        self._client = httpx.Client(base_url=self.base_url, timeout=30.0)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def reset(self, **params: Any) -> dict[str, Any]:
+        response = self._client.post("/reset", json=params)
+        response.raise_for_status()
+        return response.json()
+
+    def step(self, code: str) -> dict[str, Any]:
+        response = self._client.post("/step", json={"action": AdaptAction(code=code).model_dump()})
+        response.raise_for_status()
+        return response.json()
+
+    def state(self) -> dict[str, Any]:
+        response = self._client.get("/state")
+        response.raise_for_status()
+        return response.json()
+
+
+__all__ = ["AdaptEnvClient"]

env/__init__.py

@@ -0,0 +1,3 @@
+from env.adapt_env import AdaptEnvironment
+
+__all__ = ["AdaptEnvironment"]

env/adapt_env.py

@@ -1,104 +1,311 @@
 from __future__ import annotations
 
+import ast
 from typing import Any
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
 
 from env.executor import run_code
-from env.test_cases import VISIBLE_TEST_COUNT, load_problem, load_test_cases
+from env.test_cases import load_problem, split_test_cases
+from models import AdaptAction, AdaptObservation, AdaptState
+
+
+FORBIDDEN_IMPORTS = {"os", "pathlib", "shutil", "socket", "subprocess"}
 
 
-class AdaptEnv:
+class AdaptEnvironment(Environment[AdaptAction, AdaptObservation, AdaptState]):
+    SUPPORTS_CONCURRENT_SESSIONS = True
+
     def __init__(self) -> None:
+        super().__init__()
+        self._state = AdaptState(episode_id=str(uuid4()), step_count=0)
         self.problem: dict[str, Any] = {}
         self.test_cases: list[dict[str, str]] = []
         self.visible_tests: list[dict[str, str]] = []
         self.hidden_tests: list[dict[str, str]] = []
-        self.step_count = 0
+        self.last_results: list[dict[str, Any]] = []
 
-    def reset(self) -> dict:
-        self.problem = self._load_problem()
-        self.test_cases = load_test_cases()
-        self.visible_tests, self.hidden_tests = self._split_test_cases(self.test_cases)
-        self.step_count = 0
-        return self._build_observation()
+    def reset(
+        self,
+        seed: int | None = None,
+        episode_id: str | None = None,
+        problem_id: str | None = None,
+        difficulty: str | None = None,
+        **_: Any,
+    ) -> AdaptObservation:
+        del seed
+        self.problem = load_problem(problem_id=problem_id, difficulty=difficulty)
+        self.test_cases = [dict(test_case) for test_case in self.problem["test_cases"]]
+        self.visible_tests, self.hidden_tests = split_test_cases(self.test_cases)
+        self.last_results = []
+        self._state = AdaptState(
+            episode_id=episode_id or str(uuid4()),
+            step_count=0,
+            problem_id=self.problem["problem_id"],
+            difficulty=self.problem["difficulty"],
+        )
+        return self._build_observation(
+            reward=0.0,
+            done=False,
+            feedback="Submit Python code that reads stdin and prints the required answer.",
+        )
 
-    def step(self, code: str) -> dict:
-        if not self.test_cases:
+    def step(
+        self,
+        action: AdaptAction,
+        timeout_s: float | None = None,
+        **_: Any,
+    ) -> AdaptObservation:
+        del timeout_s
+        if not self.problem:
             self.reset()
 
-        self.step_count += 1
-        run_results = self._run_all_tests(code)
-        reward, metadata = self._verify_code(code)
-        metadata = metadata or {}
+        self._state.step_count += 1
+        syntax_ok, syntax_error = self._check_syntax(action.code)
+        if not syntax_ok:
+            observation = self._build_observation(
+                reward=0.0,
+                done=True,
+                feedback=f"Syntax error: {syntax_error}",
+                syntax_valid=False,
+                execution_status="syntax_error",
+            )
+            self._record_metrics(observation)
+            return observation
 
-        pass_rate = float(metadata.get("pass_rate", self._compute_pass_rate(run_results)))
-        feedback = str(metadata.get("feedback") or self._build_feedback(run_results, pass_rate))
+        safety_ok, safety_error = self._check_safety(action.code)
+        if not safety_ok:
+            observation = self._build_observation(
+                reward=0.0,
+                done=True,
+                feedback=safety_error,
+                syntax_valid=True,
+                execution_status="safety_violation",
+            )
+            self._record_metrics(observation)
+            return observation
 
-        return {
-            "reward": float(reward),
-            "done": True,
-            "feedback": feedback,
-            "pass_rate": pass_rate,
-        }
+        run_results = self._run_all_tests(action.code)
+        self.last_results = run_results
+        metrics = self._score_results(run_results)
+        verifier_reward, verifier_metadata = self._try_verify(action.code)
+        if verifier_reward is not None:
+            metrics["reward"] = max(metrics["reward"], verifier_reward)
+            if verifier_metadata.get("feedback"):
+                metrics["feedback"] = str(verifier_metadata["feedback"])
 
-    def _load_problem(self) -> dict:
-        return load_problem()
+        observation = self._build_observation(
+            reward=metrics["reward"],
+            done=True,
+            feedback=metrics["feedback"],
+            pass_rate=metrics["pass_rate"],
+            visible_pass_rate=metrics["visible_pass_rate"],
+            hidden_pass_rate=metrics["hidden_pass_rate"],
+            syntax_valid=True,
+            execution_status=metrics["execution_status"],
+            timeout_count=metrics["timeout_count"],
+            runtime_error_count=metrics["runtime_error_count"],
+            format_compliance=metrics["format_compliance"],
+            reward_components=metrics["reward_components"],
+        )
+        self._record_metrics(observation)
+        return observation
 
-    def _split_test_cases(
-        self,
-        test_cases: list[dict[str, str]],
-    ) -> tuple[list[dict[str, str]], list[dict[str, str]]]:
-        visible_tests = test_cases[:VISIBLE_TEST_COUNT]
-        hidden_tests = test_cases[VISIBLE_TEST_COUNT:]
-        return visible_tests, hidden_tests
+    @property
+    def state(self) -> AdaptState:
+        return self._state
 
-    def _build_observation(self) -> dict:
-        return {
-            "problem": self.problem["problem"],
-            "input_format": self.problem["input_format"],
-            "constraints": self.problem["constraints"],
-            "examples": self.problem["examples"],
-            "visible_tests": self.visible_tests,
-        }
+    def _build_observation(
+        self,
+        reward: float,
+        done: bool,
+        feedback: str,
+        pass_rate: float = 0.0,
+        visible_pass_rate: float = 0.0,
+        hidden_pass_rate: float = 0.0,
+        syntax_valid: bool = True,
+        execution_status: str = "not_run",
+        timeout_count: int = 0,
+        runtime_error_count: int = 0,
+        format_compliance: float = 0.0,
+        reward_components: dict[str, float] | None = None,
+    ) -> AdaptObservation:
+        return AdaptObservation(
+            problem_id=self.problem["problem_id"],
+            difficulty=self.problem["difficulty"],
+            problem=self.problem["problem"],
+            input_format=self.problem["input_format"],
+            constraints=self.problem["constraints"],
+            examples=self.problem["examples"],
+            visible_tests=self.visible_tests,
+            feedback=feedback,
+            pass_rate=pass_rate,
+            visible_pass_rate=visible_pass_rate,
+            hidden_pass_rate=hidden_pass_rate,
+            syntax_valid=syntax_valid,
+            execution_status=execution_status,
+            timeout_count=timeout_count,
+            runtime_error_count=runtime_error_count,
+            format_compliance=format_compliance,
+            reward_components=reward_components or {},
+            reward=round(max(0.0, min(1.0, reward)), 4),
+            done=done,
+        )
 
     def _run_all_tests(self, code: str) -> list[dict[str, Any]]:
         results = []
-        for test_case in self.test_cases:
+        visible_count = len(self.visible_tests)
+        for index, test_case in enumerate(self.test_cases):
             execution = run_code(code, test_case["input"])
-            actual = execution["stdout"].strip()
+            actual = str(execution["stdout"]).strip()
             expected = test_case["output"].strip()
             results.append(
                 {
-                    "input": test_case["input"],
-                    "expected": expected,
-                    "actual": actual,
-                    "stderr": execution["stderr"].strip(),
-                    "exit_code": execution["exit_code"],
+                    "index": index,
+                    "split": "visible" if index < visible_count else "hidden",
+                    "input": test_case["input"] if index < visible_count else None,
+                    "expected": expected if index < visible_count else None,
+                    "actual": actual if index < visible_count else None,
+                    "stderr": str(execution["stderr"]).strip(),
+                    "exit_code": int(execution["exit_code"]),
+                    "timed_out": bool(execution.get("timed_out", False)),
                     "passed": execution["exit_code"] == 0 and actual == expected,
+                    "format_ok": execution["exit_code"] == 0 and actual != "",
                 }
             )
         return results
 
-    def _verify_code(self, code: str) -> tuple[float, dict[str, Any]]:
-        from verifier.verifier import verify
+    def _score_results(self, run_results: list[dict[str, Any]]) -> dict[str, Any]:
+        total = len(run_results)
+        visible = [result for result in run_results if result["split"] == "visible"]
+        hidden = [result for result in run_results if result["split"] == "hidden"]
+        pass_rate = self._pass_rate(run_results)
+        visible_pass_rate = self._pass_rate(visible)
+        hidden_pass_rate = self._pass_rate(hidden)
+        timeout_count = sum(1 for result in run_results if result["timed_out"])
+        runtime_error_count = sum(
+            1
+            for result in run_results
+            if result["exit_code"] != 0 and not result["timed_out"]
+        )
+        format_compliance = (
+            sum(1 for result in run_results if result["format_ok"]) / total
+            if total
+            else 0.0
+        )
+        timeout_rate = timeout_count / total if total else 0.0
+        runtime_error_rate = runtime_error_count / total if total else 0.0
+        reward_components = {
+            "correctness": 0.8 * pass_rate,
+            "syntax": 0.05,
+            "execution": 0.05 if runtime_error_count == 0 and timeout_count == 0 else 0.0,
+            "format": 0.1 * format_compliance,
+            "timeout_penalty": -0.2 * timeout_rate,
+            "runtime_penalty": -0.1 * runtime_error_rate,
+        }
+        reward = max(0.0, min(1.0, sum(reward_components.values())))
 
-        return verify(code, self.test_cases)
+        if timeout_count:
+            status = "timeout"
+        elif runtime_error_count:
+            status = "runtime_error"
+        else:
+            status = "completed"
 
-    def _compute_pass_rate(self, run_results: list[dict[str, Any]]) -> float:
-        if not run_results:
-            return 0.0
-        passed = sum(1 for result in run_results if result["passed"])
-        return passed / len(run_results)
+        return {
+            "reward": round(reward, 4),
+            "feedback": self._build_feedback(run_results, pass_rate),
+            "pass_rate": round(pass_rate, 4),
+            "visible_pass_rate": round(visible_pass_rate, 4),
+            "hidden_pass_rate": round(hidden_pass_rate, 4),
+            "timeout_count": timeout_count,
+            "runtime_error_count": runtime_error_count,
+            "format_compliance": round(format_compliance, 4),
+            "execution_status": status,
+            "reward_components": {
+                key: round(value, 4) for key, value in reward_components.items()
+            },
+        }
 
     def _build_feedback(self, run_results: list[dict[str, Any]], pass_rate: float) -> str:
         for result in run_results:
+            if result["timed_out"]:
+                label = self._safe_test_label(result)
+                return f"Timed out on {label}."
+
             if result["exit_code"] != 0:
+                label = self._safe_test_label(result)
                 error = result["stderr"] or "runtime error"
-                return f"Runtime error on input {result['input'].strip()}: {error}"
+                return f"Runtime error on {label}: {error}"
 
-            if not result["passed"]:
+            if not result["passed"] and result["split"] == "visible":
                 return (
-                    f"Failed on input {result['input'].strip()}: "
+                    f"Failed on visible input {str(result['input']).strip()}: "
                     f"expected {result['expected']}, got {result['actual']}"
                 )
 
+            if not result["passed"]:
+                return f"Failed on hidden test {result['index'] + 1}."
+
         return f"All tests passed. Pass rate: {pass_rate:.2f}"
+
+    def _record_metrics(self, observation: AdaptObservation) -> None:
+        self._state.last_reward = float(observation.reward or 0.0)
+        self._state.last_pass_rate = observation.pass_rate
+        self._state.last_feedback = observation.feedback
+        self._state.recent_metrics = {
+            "visible_pass_rate": observation.visible_pass_rate,
+            "hidden_pass_rate": observation.hidden_pass_rate,
+            "execution_status": observation.execution_status,
+            "timeout_count": observation.timeout_count,
+            "runtime_error_count": observation.runtime_error_count,
+            "format_compliance": observation.format_compliance,
+            "reward_components": dict(observation.reward_components),
+        }
+
+    def _try_verify(self, code: str) -> tuple[float | None, dict[str, Any]]:
+        try:
+            from verifier.verifier import verify
+        except ImportError:
+            return None, {}
+
+        try:
+            reward, metadata = verify(code, self.test_cases)
+        except Exception as exc:
+            return None, {"feedback": f"Verifier unavailable: {exc}"}
+
+        return float(reward), metadata or {}
+
+    def _check_syntax(self, code: str) -> tuple[bool, str]:
+        try:
+            ast.parse(code)
+        except SyntaxError as exc:
+            return False, str(exc)
+        return True, ""
+
+    def _check_safety(self, code: str) -> tuple[bool, str]:
+        tree = ast.parse(code)
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    root_name = alias.name.split(".", 1)[0]
+                    if root_name in FORBIDDEN_IMPORTS:
+                        return False, f"Forbidden import: {root_name}"
+
+            if isinstance(node, ast.ImportFrom):
+                root_name = (node.module or "").split(".", 1)[0]
+                if root_name in FORBIDDEN_IMPORTS:
+                    return False, f"Forbidden import: {root_name}"
+
+        return True, ""
+
+    def _pass_rate(self, results: list[dict[str, Any]]) -> float:
+        if not results:
+            return 0.0
+        return sum(1 for result in results if result["passed"]) / len(results)
+
+    def _safe_test_label(self, result: dict[str, Any]) -> str:
+        if result["split"] == "visible":
+            return f"visible input {str(result['input']).strip()}"
+        return f"hidden test {result['index'] + 1}"

env/executor.py

@@ -1,22 +1,29 @@
 from __future__ import annotations
 
+import os
+import shutil
 import subprocess
 import sys
-import tempfile
 from pathlib import Path
+from uuid import uuid4
 
 
 TIMEOUT_SECONDS = 2
 
 
 def run_code(code: str, input_data: str) -> dict:
-    with tempfile.TemporaryDirectory() as tmpdir:
+    temp_parent = Path(os.getenv("ADAPT_TMP_DIR", ".adapt_tmp")).resolve()
+    temp_parent.mkdir(parents=True, exist_ok=True)
+    tmpdir = temp_parent / f"run_{uuid4().hex}"
+    tmpdir.mkdir()
+
+    try:
         file_path = Path(tmpdir) / "submission.py"
         file_path.write_text(code, encoding="utf-8")
 
         try:
             result = subprocess.run(
-                [sys.executable, str(file_path)],
+                ["python3", str(file_path)],
                 input=input_data,
                 text=True,
                 capture_output=True,
@@ -27,10 +34,14 @@ def run_code(code: str, input_data: str) -> dict:
                 "stdout": exc.stdout or "",
                 "stderr": "Execution timed out",
                 "exit_code": -1,
+                "timed_out": True,
             }
 
         return {
             "stdout": result.stdout,
             "stderr": result.stderr,
             "exit_code": result.returncode,
+            "timed_out": False,
         }
+    finally:
+        shutil.rmtree(tmpdir, ignore_errors=True)

env/test_cases.py

@@ -1,35 +1,139 @@
 from __future__ import annotations
 
+from typing import Any
 
-PROBLEM = {
-    "problem": "Given an integer n, print n * 2.",
-    "input_format": "A single integer n.",
-    "constraints": "-10^9 <= n <= 10^9",
-    "examples": [
-        {"input": "2\n", "output": "4"},
-        {"input": "5\n", "output": "10"},
-    ],
-}
-
-
-TEST_CASES = [
-    {"input": "2\n", "output": "4"},
-    {"input": "5\n", "output": "10"},
-    {"input": "0\n", "output": "0"},
-    {"input": "1\n", "output": "2"},
-    {"input": "-3\n", "output": "-6"},
-    {"input": "10\n", "output": "20"},
-    {"input": "999999\n", "output": "1999998"},
-    {"input": "-1000000000\n", "output": "-2000000000"},
+
+VISIBLE_TEST_COUNT = 3
+
+
+PROBLEM_BANK: list[dict[str, Any]] = [
+    {
+        "problem_id": "easy_double",
+        "difficulty": "easy",
+        "problem": "Given an integer n, print n * 2.",
+        "input_format": "A single integer n.",
+        "constraints": "-10^9 <= n <= 10^9",
+        "examples": [
+            {"input": "2\n", "output": "4"},
+            {"input": "5\n", "output": "10"},
+        ],
+        "test_cases": [
+            {"input": "2\n", "output": "4"},
+            {"input": "5\n", "output": "10"},
+            {"input": "0\n", "output": "0"},
+            {"input": "1\n", "output": "2"},
+            {"input": "-3\n", "output": "-6"},
+            {"input": "10\n", "output": "20"},
+            {"input": "999999\n", "output": "1999998"},
+            {"input": "-1000000000\n", "output": "-2000000000"},
+        ],
+    },
+    {
+        "problem_id": "easy_sum_two",
+        "difficulty": "easy",
+        "problem": "Given two integers a and b, print their sum.",
+        "input_format": "Two space-separated integers a and b.",
+        "constraints": "-10^9 <= a, b <= 10^9",
+        "examples": [
+            {"input": "2 3\n", "output": "5"},
+            {"input": "-4 7\n", "output": "3"},
+        ],
+        "test_cases": [
+            {"input": "2 3\n", "output": "5"},
+            {"input": "-4 7\n", "output": "3"},
+            {"input": "0 0\n", "output": "0"},
+            {"input": "1000000000 1\n", "output": "1000000001"},
+            {"input": "-8 -9\n", "output": "-17"},
+            {"input": "42 -42\n", "output": "0"},
+        ],
+    },
+    {
+        "problem_id": "medium_maximum",
+        "difficulty": "medium",
+        "problem": "Given n integers, print the maximum value.",
+        "input_format": "First line contains n. Second line contains n space-separated integers.",
+        "constraints": "1 <= n <= 200000; -10^9 <= values <= 10^9",
+        "examples": [
+            {"input": "5\n1 7 3 2 5\n", "output": "7"},
+            {"input": "3\n-5 -2 -9\n", "output": "-2"},
+        ],
+        "test_cases": [
+            {"input": "5\n1 7 3 2 5\n", "output": "7"},
+            {"input": "3\n-5 -2 -9\n", "output": "-2"},
+            {"input": "1\n42\n", "output": "42"},
+            {"input": "6\n0 0 0 0 0 0\n", "output": "0"},
+            {"input": "4\n1000000000 -1 5 999999999\n", "output": "1000000000"},
+            {"input": "7\n-10 -20 -30 -1 -40 -50 -60\n", "output": "-1"},
+        ],
+    },
+    {
+        "problem_id": "medium_count_even",
+        "difficulty": "medium",
+        "problem": "Given n integers, print how many of them are even.",
+        "input_format": "First line contains n. Second line contains n space-separated integers.",
+        "constraints": "1 <= n <= 200000; -10^9 <= values <= 10^9",
+        "examples": [
+            {"input": "5\n1 2 3 4 5\n", "output": "2"},
+            {"input": "4\n2 4 6 8\n", "output": "4"},
+        ],
+        "test_cases": [
+            {"input": "5\n1 2 3 4 5\n", "output": "2"},
+            {"input": "4\n2 4 6 8\n", "output": "4"},
+            {"input": "3\n1 3 5\n", "output": "0"},
+            {"input": "1\n0\n", "output": "1"},
+            {"input": "6\n-2 -3 -4 -5 -6 -7\n", "output": "3"},
+            {"input": "8\n10 11 12 13 14 15 16 17\n", "output": "4"},
+        ],
+    },
+    {
+        "problem_id": "hard_reverse_words",
+        "difficulty": "hard",
+        "problem": "Given a sentence, print its words in reverse order.",
+        "input_format": "A single line containing words separated by one or more spaces.",
+        "constraints": "1 <= sentence length <= 10000",
+        "examples": [
+            {"input": "hello world\n", "output": "world hello"},
+            {"input": "openenv rewards matter\n", "output": "matter rewards openenv"},
+        ],
+        "test_cases": [
+            {"input": "hello world\n", "output": "world hello"},
+            {"input": "openenv rewards matter\n", "output": "matter rewards openenv"},
+            {"input": "single\n", "output": "single"},
+            {"input": "  trim   extra   spaces  \n", "output": "spaces extra trim"},
+            {"input": "a b c d e\n", "output": "e d c b a"},
+            {"input": "adaptive dsa tutor\n", "output": "tutor dsa adaptive"},
+        ],
+    },
 ]
 
 
-VISIBLE_TEST_COUNT = 3
+def load_problem_bank() -> list[dict[str, Any]]:
+    return [_copy_problem(problem) for problem in PROBLEM_BANK]
+
+
+def load_problem(problem_id: str | None = None, difficulty: str | None = None) -> dict[str, Any]:
+    problems = load_problem_bank()
+    if problem_id is not None:
+        for problem in problems:
+            if problem["problem_id"] == problem_id:
+                return problem
+
+    if difficulty is not None:
+        for problem in problems:
+            if problem["difficulty"] == difficulty:
+                return problem
+
+    return problems[0]
 
 
-def load_problem() -> dict:
-    return dict(PROBLEM)
+def split_test_cases(
+    test_cases: list[dict[str, str]],
+) -> tuple[list[dict[str, str]], list[dict[str, str]]]:
+    return test_cases[:VISIBLE_TEST_COUNT], test_cases[VISIBLE_TEST_COUNT:]
 
 
-def load_test_cases() -> list[dict[str, str]]:
-    return [dict(test_case) for test_case in TEST_CASES]
+def _copy_problem(problem: dict[str, Any]) -> dict[str, Any]:
+    copied = dict(problem)
+    copied["examples"] = [dict(example) for example in problem["examples"]]
+    copied["test_cases"] = [dict(test_case) for test_case in problem["test_cases"]]
+    return copied

models.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import Any
+
+from openenv.core.env_server.types import Action, Observation, State
+from pydantic import Field
+
+
+class AdaptAction(Action):
+    code: str = Field(..., min_length=1, description="Python code to execute.")
+
+
+class AdaptObservation(Observation):
+    problem_id: str = Field(default="", description="Current problem identifier.")
+    difficulty: str = Field(default="", description="Current curriculum difficulty tier.")
+    problem: str = Field(default="", description="Problem statement shown to the agent.")
+    input_format: str = Field(default="", description="Expected stdin format.")
+    constraints: str = Field(default="", description="Problem constraints.")
+    examples: list[dict[str, str]] = Field(default_factory=list)
+    visible_tests: list[dict[str, str]] = Field(default_factory=list)
+    feedback: str = Field(default="", description="Human-readable execution feedback.")
+    pass_rate: float = Field(default=0.0, ge=0.0, le=1.0)
+    visible_pass_rate: float = Field(default=0.0, ge=0.0, le=1.0)
+    hidden_pass_rate: float = Field(default=0.0, ge=0.0, le=1.0)
+    syntax_valid: bool = Field(default=True)
+    execution_status: str = Field(default="not_run")
+    timeout_count: int = Field(default=0, ge=0)
+    runtime_error_count: int = Field(default=0, ge=0)
+    format_compliance: float = Field(default=0.0, ge=0.0, le=1.0)
+    reward_components: dict[str, float] = Field(default_factory=dict)
+
+
+class AdaptState(State):
+    problem_id: str = Field(default="")
+    difficulty: str = Field(default="")
+    last_reward: float = Field(default=0.0)
+    last_pass_rate: float = Field(default=0.0, ge=0.0, le=1.0)
+    last_feedback: str = Field(default="")
+    recent_metrics: dict[str, Any] = Field(default_factory=dict)

openenv.yaml

@@ -0,0 +1,35 @@
+spec_version: 1
+name: adapt_dsa_tutor
+type: space
+runtime: fastapi
+app: server.app:app
+port: 7860
+description: "ADAPT: an adversarial DSA tutor environment for RLVR code generation with hidden tests, tiered problems, and anti-hacking reward signals."
+version: "0.2.0"
+
+observation_space:
+  type: dict
+  description: "Problem prompt, examples, visible tests, difficulty metadata, reward, pass rates, execution status, and feedback."
+
+action_space:
+  type: dict
+  description: "AdaptAction with a Python code string submitted for stdin/stdout evaluation."
+
+reward_range: [0.0, 1.0]
+
+tasks:
+  - name: easy_double
+    description: "Easy arithmetic stdin/stdout problem."
+    difficulty: easy
+  - name: easy_sum_two
+    description: "Easy two-integer arithmetic problem."
+    difficulty: easy
+  - name: medium_maximum
+    description: "Medium array scanning problem."
+    difficulty: medium
+  - name: medium_count_even
+    description: "Medium counting problem over a list."
+    difficulty: medium
+  - name: hard_reverse_words
+    description: "Harder string normalization and ordering problem."
+    difficulty: hard

pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "adapt-dsa-tutor"
+version = "0.2.0"
+description = "OpenEnv-compliant adversarial DSA tutor environment for RLVR code generation."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "openenv-core>=0.2.3",
+    "fastapi>=0.104.0",
+    "pydantic>=2.0.0",
+    "uvicorn>=0.24.0",
+    "httpx>=0.28.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+]
+
+[project.scripts]
+server = "server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["env", "server"]
+py-modules = ["app", "client", "models"]

server/__init__.py

@@ -0,0 +1,3 @@
+from server.app import app, main
+
+__all__ = ["app", "main"]

server/app.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as exc:  # pragma: no cover
+    raise ImportError(
+        "openenv-core>=0.2.3 is required. Install with: pip install -e ."
+    ) from exc
+
+from env.adapt_env import AdaptEnvironment
+from models import AdaptAction, AdaptObservation
+
+
+app = create_app(
+    AdaptEnvironment,
+    AdaptAction,
+    AdaptObservation,
+    env_name="adapt_dsa_tutor",
+    max_concurrent_envs=4,
+)
+
+
+def main(host: str = "0.0.0.0", port: int = 7860) -> None:
+    import uvicorn
+
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

server/requirements.txt

@@ -0,0 +1,5 @@
+openenv-core>=0.2.3
+fastapi>=0.104.0
+pydantic>=2.0.0
+uvicorn>=0.24.0
+httpx>=0.28.0

test.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from env.adapt_env import AdaptEnvironment
+from models import AdaptAction, AdaptObservation
+
+
+def assert_hidden_tests_are_not_exposed(payload: dict) -> None:
+    text = str(payload)
+    assert "hidden_tests" not in text
+    assert "-1000000000" not in text
+
+
+def main() -> None:
+    env = AdaptEnvironment()
+    observation = env.reset()
+    assert isinstance(observation, AdaptObservation)
+    assert observation.visible_tests
+    assert observation.problem_id == "easy_double"
+    assert_hidden_tests_are_not_exposed(observation.model_dump())
+
+    correct = env.step(AdaptAction(code="n=int(input())\nprint(n*2)"))
+    print(correct)
+    assert correct.reward == 1.0, correct.model_dump()
+    assert correct.pass_rate == 1.0
+
+    wrong = env.step(AdaptAction(code="n=int(input())\nprint(n+2)"))
+    print(wrong)
+    assert 0.0 <= float(wrong.reward) < 1.0
+    assert wrong.pass_rate < 1.0
+    assert "Failed" in wrong.feedback
+
+    syntax = env.step(AdaptAction(code="def broken(:\n    pass"))
+    print(syntax)
+    assert syntax.reward == 0.0
+    assert syntax.execution_status == "syntax_error"
+
+    timeout = env.step(AdaptAction(code="while True:\n    pass"))
+    print(timeout)
+    assert timeout.timeout_count > 0
+    assert timeout.execution_status == "timeout"
+
+    unsafe = env.step(AdaptAction(code="import os\nprint(os.listdir('.'))"))
+    print(unsafe)
+    assert unsafe.reward == 0.0
+    assert unsafe.execution_status == "safety_violation"
+
+    assert env.state.step_count == 5
+    assert_hidden_tests_are_not_exposed(timeout.model_dump())
+    print("ADAPT OpenEnv smoke tests passed")
+
+
+if __name__ == "__main__":
+    main()