feat: initial OpenEnv code debugging environment

Implements a complete OpenEnv-compatible environment for the Meta x PyTorch
Hackathon where an AI agent debugs broken Python code across 6 tasks
(easy/medium/hard) with reward = fraction of tests passing (0.0–1.0).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+*.pyo
+.env
+.venv/
+venv/
+*.egg-info/
+dist/
+build/
+.pytest_cache/

README.md

@@ -0,0 +1,101 @@
+# Code Debug OpenEnv
+
+An **OpenEnv-compatible environment** for the Meta x PyTorch Hackathon where an AI agent debugs broken Python code.
+
+## Overview
+
+The agent receives buggy Python code and test descriptions, submits fixes, and is rewarded by the fraction of tests passing (0.0–1.0). The episode ends when all tests pass or the step limit is reached.
+
+## Tasks
+
+| Task | Difficulty | Bug Type |
+|------|-----------|----------|
+| task_001_off_by_one | Easy | Fibonacci returns wrong variable |
+| task_002_wrong_operator | Easy | `<` instead of `>` in find_max |
+| task_003_mutable_default | Medium | Mutable default argument in list builder |
+| task_004_scope_bug | Medium | Closure captures loop variable by reference |
+| task_005_binary_search | Hard | Binary search boundary bugs |
+| task_006_graph_cycle | Hard | DFS cycle detection missing recursion stack |
+
+## API Endpoints
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/health` | Health check |
+| GET | `/tasks` | List all available tasks |
+| POST | `/reset` | Start a new episode |
+| POST | `/step/{episode_id}` | Submit fixed code |
+| GET | `/state/{episode_id}` | Get episode metadata |
+
+## Reward
+
+```
+reward = tests_passed / total_tests  # range: 0.0 – 1.0
+done   = reward == 1.0 OR step_count >= max_steps
+```
+
+## Setup & Run
+
+### Local (development)
+
+```bash
+pip install fastapi uvicorn pydantic httpx openai
+cd Desktop/Meta
+uvicorn code_debug_env.server.app:app --host 0.0.0.0 --port 7860 --reload
+```
+
+### Docker
+
+```bash
+cd Desktop/Meta/code_debug_env
+docker build -t code-debug-env -f server/Dockerfile ..
+docker run -p 7860:7860 code-debug-env
+```
+
+## Inference Script
+
+```bash
+export API_BASE_URL="https://router.huggingface.co/v1"
+export MODEL_NAME="Qwen/Qwen2.5-72B-Instruct"
+export HF_TOKEN="your_token"
+export ENV_URL="http://localhost:7860"  # or HF Space URL
+
+python inference.py
+```
+
+### Expected output format
+
+```
+[START] task=task_001_off_by_one env=http://localhost:7860 model=Qwen/Qwen2.5-72B-Instruct
+[STEP] step=1 action='def fib...' reward=1.00 done=true error=null
+[END] success=true steps=1 score=1.000 rewards=1.00
+```
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `API_BASE_URL` | Yes | LLM API endpoint |
+| `MODEL_NAME` | Yes | Model identifier |
+| `HF_TOKEN` | Yes | Hugging Face / API key |
+| `ENV_URL` | No | OpenEnv server URL (default: http://localhost:7860) |
+
+## Project Structure
+
+```
+code_debug_env/
+├── models.py          # Pydantic models (DebugAction, DebugObservation, DebugState)
+├── client.py          # HTTP client wrapper
+├── openenv.yaml       # Environment manifest
+├── pyproject.toml     # Package metadata
+├── tasks/             # Task definitions (JSON)
+│   ├── easy/
+│   ├── medium/
+│   └── hard/
+└── server/
+    ├── environment.py # Core logic (reset/step/state)
+    ├── executor.py    # Safe subprocess code runner
+    ├── app.py         # FastAPI server
+    └── Dockerfile
+inference.py           # Root-level inference script
+```

code_debug_env/__init__.py

@@ -0,0 +1,4 @@
+from .models import DebugAction, DebugObservation, DebugState, TestResult
+from .client import CodeDebugClient
+
+__all__ = ["DebugAction", "DebugObservation", "DebugState", "TestResult", "CodeDebugClient"]

code_debug_env/client.py

@@ -0,0 +1,61 @@
+"""
+Simple HTTP client for the Code Debug OpenEnv server.
+"""
+
+from typing import Optional
+import httpx
+
+
+class CodeDebugClient:
+    def __init__(self, base_url: str = "http://localhost:7860", timeout: float = 30.0):
+        self.base_url   = base_url.rstrip("/")
+        self._http      = httpx.Client(base_url=self.base_url, timeout=timeout)
+        self.episode_id: Optional[str] = None
+
+    def reset(self, task_id: Optional[str] = None, seed: Optional[int] = None) -> dict:
+        payload: dict = {}
+        if task_id is not None:
+            payload["task_id"] = task_id
+        if seed is not None:
+            payload["seed"] = seed
+        resp = self._http.post("/reset", json=payload)
+        resp.raise_for_status()
+        data = resp.json()
+        self.episode_id = data["episode_id"]
+        return data
+
+    def step(self, code: str) -> dict:
+        if self.episode_id is None:
+            raise RuntimeError("No active episode. Call reset() first.")
+        resp = self._http.post(
+            f"/step/{self.episode_id}",
+            json={"action": {"code": code}},
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def state(self) -> dict:
+        if self.episode_id is None:
+            raise RuntimeError("No active episode. Call reset() first.")
+        resp = self._http.get(f"/state/{self.episode_id}")
+        resp.raise_for_status()
+        return resp.json()
+
+    def list_tasks(self) -> list[dict]:
+        resp = self._http.get("/tasks")
+        resp.raise_for_status()
+        return resp.json()
+
+    def health(self) -> dict:
+        resp = self._http.get("/health")
+        resp.raise_for_status()
+        return resp.json()
+
+    def close(self):
+        self._http.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()

code_debug_env/models.py

@@ -0,0 +1,78 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+from enum import Enum
+
+
+class Difficulty(str, Enum):
+    easy = "easy"
+    medium = "medium"
+    hard = "hard"
+
+
+class DebugAction(BaseModel):
+    """Agent submits fixed code."""
+    code: str = Field(..., description="The corrected Python code")
+
+
+class TestResult(BaseModel):
+    """Result of a single test case execution."""
+    test_name: str
+    passed: bool
+    expected: str = ""
+    actual: str = ""
+    error: str = ""
+
+
+class DebugObservation(BaseModel):
+    """What the agent sees after reset or step."""
+    task_id: str
+    difficulty: Difficulty
+    description: str
+    buggy_code: str
+    test_descriptions: list[str]
+    test_results: list[TestResult] = Field(default_factory=list)
+    stdout: str = ""
+    stderr: str = ""
+    step_count: int = 0
+    max_steps: int = 5
+    reward: float = 0.0
+    done: bool = False
+    total_tests: int = 0
+    tests_passed: int = 0
+
+
+class DebugState(BaseModel):
+    """Episode metadata exposed via /state."""
+    episode_id: str
+    task_id: str
+    difficulty: Difficulty
+    step_count: int = 0
+    max_steps: int = 5
+    last_reward: float = 0.0
+    cumulative_reward: float = 0.0
+    tests_passed: int = 0
+    total_tests: int = 0
+    done: bool = False
+
+
+# --- API request / response models ---
+
+class ResetRequest(BaseModel):
+    task_id: Optional[str] = None
+    seed: Optional[int] = None
+
+
+class ResetResponse(BaseModel):
+    episode_id: str
+    observation: DebugObservation
+
+
+class StepRequest(BaseModel):
+    action: DebugAction
+
+
+class StepResponse(BaseModel):
+    observation: DebugObservation
+    reward: float
+    done: bool
+    info: dict = Field(default_factory=dict)

code_debug_env/openenv.yaml

@@ -0,0 +1,37 @@
+name: code-debug-env
+version: "1.0.0"
+description: "An OpenEnv environment where an AI agent debugs broken Python code. The agent receives buggy code and test descriptions, submits fixes, and is rewarded by the fraction of tests passing (0.0–1.0)."
+type: space
+runtime: fastapi
+app: "code_debug_env.server.app:app"
+port: 7860
+
+tasks:
+  - id: task_001_off_by_one
+    difficulty: easy
+    max_steps: 5
+  - id: task_002_wrong_operator
+    difficulty: easy
+    max_steps: 5
+  - id: task_003_mutable_default
+    difficulty: medium
+    max_steps: 7
+  - id: task_004_scope_bug
+    difficulty: medium
+    max_steps: 7
+  - id: task_005_binary_search
+    difficulty: hard
+    max_steps: 10
+  - id: task_006_graph_cycle
+    difficulty: hard
+    max_steps: 10
+
+reward:
+  type: deterministic
+  range: [0.0, 1.0]
+  formula: "tests_passed / total_tests"
+
+constraints:
+  runtime_limit: "20 minutes"
+  vcpu: 2
+  memory: "8GB"

code_debug_env/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "code-debug-env"
+version = "1.0.0"
+description = "OpenEnv environment for AI-driven Python code debugging"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.109.0",
+    "uvicorn[standard]>=0.27.0",
+    "pydantic>=2.6.1",
+    "httpx>=0.27.0",
+    "openai>=1.0.0",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0.0"]
+
+[project.scripts]
+server = "code_debug_env.server.app:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["code_debug_env*"]

code_debug_env/server/Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*
+
+COPY server/requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+ENV PYTHONPATH=/app
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+
+EXPOSE 7860
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=10s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+CMD ["uvicorn", "code_debug_env.server.app:app", "--host", "0.0.0.0", "--port", "7860"]

code_debug_env/server/__init__.py

@@ -0,0 +1,3 @@
+from .environment import CodeDebugEnvironment
+
+__all__ = ["CodeDebugEnvironment"]

code_debug_env/server/app.py

@@ -0,0 +1,81 @@
+"""
+FastAPI server exposing the OpenEnv-compatible HTTP API.
+Port: 7860 (Hugging Face Spaces default)
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+
+from ..models import (
+    DebugState,
+    ResetRequest,
+    ResetResponse,
+    StepRequest,
+    StepResponse,
+)
+from .environment import CodeDebugEnvironment
+
+app = FastAPI(
+    title="Code Debug OpenEnv",
+    description="An OpenEnv environment where an AI agent debugs broken Python code.",
+    version="1.0.0",
+)
+
+env = CodeDebugEnvironment()
+
+
+# ------------------------------------------------------------------
+# Health & metadata
+# ------------------------------------------------------------------
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "tasks_loaded": len(env.tasks)}
+
+
+@app.get("/tasks")
+async def list_tasks():
+    return env.list_tasks()
+
+
+# ------------------------------------------------------------------
+# OpenEnv core endpoints
+# ------------------------------------------------------------------
+
+@app.post("/reset", response_model=ResetResponse)
+async def reset(req: ResetRequest = None):
+    if req is None:
+        req = ResetRequest()
+    try:
+        result = env.reset(task_id=req.task_id, seed=req.seed)
+        return result
+    except KeyError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+@app.post("/step/{episode_id}", response_model=StepResponse)
+async def step(episode_id: str, req: StepRequest):
+    try:
+        result = env.step(episode_id, req.action.model_dump())
+        return result
+    except KeyError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@app.get("/state/{episode_id}", response_model=DebugState)
+async def state(episode_id: str):
+    try:
+        return env.state(episode_id)
+    except KeyError as e:
+        raise HTTPException(status_code=404, detail=str(e))
+
+
+# ------------------------------------------------------------------
+# Entry point for local dev
+# ------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("code_debug_env.server.app:app", host="0.0.0.0", port=7860, reload=True)

code_debug_env/server/environment.py

@@ -0,0 +1,156 @@
+"""
+Core environment logic: task loading, reset, step, state.
+"""
+
+import json
+import random
+import uuid
+from pathlib import Path
+
+from .executor import run_code_safely
+
+
+class CodeDebugEnvironment:
+    def __init__(self):
+        self.tasks: dict[str, dict] = {}
+        self.episodes: dict[str, dict] = {}
+        self._load_tasks()
+
+    def _load_tasks(self):
+        tasks_dir = Path(__file__).parent.parent / "tasks"
+        for json_file in sorted(tasks_dir.rglob("*.json")):
+            with open(json_file, encoding="utf-8") as f:
+                task = json.load(f)
+                self.tasks[task["task_id"]] = task
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def reset(self, task_id: str | None = None, seed: int | None = None) -> dict:
+        if seed is not None:
+            random.seed(seed)
+
+        if task_id is None:
+            task_id = random.choice(list(self.tasks.keys()))
+
+        if task_id not in self.tasks:
+            raise KeyError(f"Unknown task_id: {task_id!r}")
+
+        task = self.tasks[task_id]
+        episode_id = str(uuid.uuid4())
+
+        self.episodes[episode_id] = {
+            "episode_id": episode_id,
+            "task": task,
+            "step_count": 0,
+            "done": False,
+            "rewards": [],
+            "last_test_results": [],
+        }
+
+        observation = self._initial_observation(task)
+        return {"episode_id": episode_id, "observation": observation}
+
+    def step(self, episode_id: str, action: dict) -> dict:
+        if episode_id not in self.episodes:
+            raise KeyError(f"Unknown episode_id: {episode_id!r}")
+
+        ep = self.episodes[episode_id]
+        if ep["done"]:
+            raise ValueError("Episode is already finished. Call reset() to start a new episode.")
+
+        task = ep["task"]
+        submitted_code = action.get("code", "")
+        ep["step_count"] += 1
+
+        test_results_raw, stdout, stderr = run_code_safely(
+            submitted_code,
+            task["test_code"],
+            timeout=10,
+        )
+
+        tests_passed = sum(1 for t in test_results_raw if t.get("passed", False))
+        total_tests = len(test_results_raw)
+        reward = round(tests_passed / total_tests, 4) if total_tests > 0 else 0.0
+
+        max_steps = task.get("max_steps", 5)
+        done = reward == 1.0 or ep["step_count"] >= max_steps
+
+        ep["done"] = done
+        ep["rewards"].append(reward)
+        ep["last_test_results"] = test_results_raw
+
+        observation = {
+            "task_id": task["task_id"],
+            "difficulty": task["difficulty"],
+            "description": task["description"],
+            "buggy_code": task["buggy_code"],
+            "test_descriptions": task["test_descriptions"],
+            "test_results": test_results_raw,
+            "stdout": stdout,
+            "stderr": stderr,
+            "step_count": ep["step_count"],
+            "max_steps": max_steps,
+            "reward": reward,
+            "done": done,
+            "total_tests": total_tests,
+            "tests_passed": tests_passed,
+        }
+
+        return {"observation": observation, "reward": reward, "done": done, "info": {}}
+
+    def state(self, episode_id: str) -> dict:
+        if episode_id not in self.episodes:
+            raise KeyError(f"Unknown episode_id: {episode_id!r}")
+
+        ep = self.episodes[episode_id]
+        task = ep["task"]
+        last_results = ep.get("last_test_results", [])
+
+        return {
+            "episode_id": episode_id,
+            "task_id": task["task_id"],
+            "difficulty": task["difficulty"],
+            "step_count": ep["step_count"],
+            "max_steps": task.get("max_steps", 5),
+            "last_reward": ep["rewards"][-1] if ep["rewards"] else 0.0,
+            "cumulative_reward": round(sum(ep["rewards"]), 4),
+            "tests_passed": sum(1 for t in last_results if t.get("passed", False)),
+            "total_tests": len(last_results),
+            "done": ep["done"],
+        }
+
+    def list_tasks(self) -> list[dict]:
+        return [
+            {
+                "task_id": t["task_id"],
+                "difficulty": t["difficulty"],
+                "description": t["description"],
+                "max_steps": t.get("max_steps", 5),
+                "total_tests": len(t["test_descriptions"]),
+            }
+            for t in self.tasks.values()
+        ]
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _initial_observation(self, task: dict) -> dict:
+        return {
+            "task_id": task["task_id"],
+            "difficulty": task["difficulty"],
+            "description": task["description"],
+            "buggy_code": task["buggy_code"],
+            "test_descriptions": task["test_descriptions"],
+            "test_results": [],
+            "stdout": "",
+            "stderr": "",
+            "step_count": 0,
+            "max_steps": task.get("max_steps", 5),
+            "reward": 0.0,
+            "done": False,
+            "total_tests": len(task["test_descriptions"]),
+            "tests_passed": 0,
+        }

code_debug_env/server/executor.py

@@ -0,0 +1,117 @@
+"""
+Safe code execution engine.
+
+Runs submitted code in a subprocess with timeout.
+Writes code to a temp directory, generates a test harness,
+and parses JSON results from stdout.
+"""
+
+import json
+import subprocess
+import tempfile
+import textwrap
+from pathlib import Path
+from typing import Tuple
+
+
+def run_code_safely(
+    submitted_code: str,
+    test_code: str,
+    timeout: int = 10,
+) -> Tuple[list[dict], str, str]:
+    """
+    Execute submitted code against test cases in an isolated subprocess.
+
+    Args:
+        submitted_code: The Python code the agent submitted as a fix.
+        test_code: Python snippet that populates a `results` list with test dicts.
+        timeout: Max seconds before killing the subprocess.
+
+    Returns:
+        (test_results, stdout_extra, stderr) where test_results is a list of
+        {"test_name", "passed", "expected", "actual", "error"} dicts.
+    """
+    with tempfile.TemporaryDirectory() as tmpdir:
+        solution_path = Path(tmpdir) / "solution.py"
+        harness_path = Path(tmpdir) / "harness.py"
+
+        # Write the submitted code as a module
+        solution_path.write_text(submitted_code, encoding="utf-8")
+
+        # Build the test harness
+        harness = textwrap.dedent(f"""\
+            import sys, json, traceback
+            sys.path.insert(0, r"{tmpdir}")
+
+            results = []
+
+            # Execute the submitted solution in this namespace
+            try:
+                exec(open(r"{solution_path}", encoding="utf-8").read())
+            except Exception as e:
+                # If the solution itself fails to load, all tests fail
+                print(json.dumps([{{"test_name": "load", "passed": False,
+                       "expected": "code loads", "actual": "",
+                       "error": traceback.format_exc()}}]))
+                sys.exit(0)
+
+            # Run the test code (populates `results`)
+            {textwrap.indent(test_code, "            ").strip()}
+
+            print(json.dumps(results))
+        """)
+
+        harness_path.write_text(harness, encoding="utf-8")
+
+        try:
+            proc = subprocess.run(
+                ["python", str(harness_path)],
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+                cwd=tmpdir,
+            )
+            stdout = proc.stdout.strip()
+            stderr = proc.stderr.strip()
+
+            # Parse test results from last line of stdout (the JSON array)
+            if stdout:
+                # The JSON array should be the last line
+                lines = stdout.split("\n")
+                json_line = lines[-1]
+                extra_output = "\n".join(lines[:-1]) if len(lines) > 1 else ""
+                try:
+                    test_results = json.loads(json_line)
+                    return test_results, extra_output, stderr
+                except json.JSONDecodeError:
+                    return [
+                        {
+                            "test_name": "parse_error",
+                            "passed": False,
+                            "expected": "valid JSON output",
+                            "actual": stdout[:200],
+                            "error": "Could not parse test results from subprocess output",
+                        }
+                    ], "", stderr
+
+            # No stdout at all — likely a crash
+            return [
+                {
+                    "test_name": "execution_error",
+                    "passed": False,
+                    "expected": "code runs",
+                    "actual": "",
+                    "error": stderr[:500] if stderr else "No output produced",
+                }
+            ], "", stderr
+
+        except subprocess.TimeoutExpired:
+            return [
+                {
+                    "test_name": "timeout",
+                    "passed": False,
+                    "expected": f"completes within {timeout}s",
+                    "actual": "timed out",
+                    "error": f"Code execution exceeded {timeout} second timeout",
+                }
+            ], "", "Execution timed out"

code_debug_env/server/requirements.txt

@@ -0,0 +1,5 @@
+fastapi>=0.109.0
+uvicorn[standard]>=0.27.0
+pydantic>=2.6.1
+httpx>=0.27.0
+openai>=1.0.0

code_debug_env/tasks/easy/task_001_off_by_one.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "task_001_off_by_one",
+  "difficulty": "easy",
+  "description": "Fix the bug in the fibonacci function. It should return the nth Fibonacci number (0-indexed: fib(0)=0, fib(1)=1, fib(2)=1, fib(5)=5, fib(10)=55).",
+  "buggy_code": "def fib(n):\n    if n <= 0:\n        return 0\n    if n == 1:\n        return 1\n    a, b = 0, 1\n    for i in range(n - 1):\n        a, b = b, a + b\n    return a\n",
+  "solution": "def fib(n):\n    if n <= 0:\n        return 0\n    if n == 1:\n        return 1\n    a, b = 0, 1\n    for i in range(n - 1):\n        a, b = b, a + b\n    return b\n",
+  "test_descriptions": [
+    "fib(0) should return 0",
+    "fib(1) should return 1",
+    "fib(2) should return 1",
+    "fib(5) should return 5",
+    "fib(10) should return 55"
+  ],
+  "test_code": "test_cases = [(0, 0), (1, 1), (2, 1), (5, 5), (10, 55)]\nfor inp, exp in test_cases:\n    name = f\"fib({inp})=={exp}\"\n    try:\n        actual = fib(inp)\n        results.append({\"test_name\": name, \"passed\": actual == exp, \"expected\": str(exp), \"actual\": str(actual), \"error\": \"\"})\n    except Exception as e:\n        results.append({\"test_name\": name, \"passed\": False, \"expected\": str(exp), \"actual\": \"\", \"error\": str(e)})",
+  "max_steps": 5
+}

code_debug_env/tasks/easy/task_002_wrong_operator.json

@@ -0,0 +1,16 @@
+{
+  "task_id": "task_002_wrong_operator",
+  "difficulty": "easy",
+  "description": "Fix the bug in the find_max function. It should return the maximum value in a list, or None if the list is empty.",
+  "buggy_code": "def find_max(lst):\n    if not lst:\n        return None\n    max_val = lst[0]\n    for item in lst[1:]:\n        if item < max_val:\n            max_val = item\n    return max_val\n",
+  "solution": "def find_max(lst):\n    if not lst:\n        return None\n    max_val = lst[0]\n    for item in lst[1:]:\n        if item > max_val:\n            max_val = item\n    return max_val\n",
+  "test_descriptions": [
+    "find_max([1, 2, 3]) should return 3",
+    "find_max([-1, -5, 0]) should return 0",
+    "find_max([42]) should return 42",
+    "find_max([]) should return None",
+    "find_max([3, 1, 4, 1, 5, 9, 2, 6]) should return 9"
+  ],
+  "test_code": "test_cases = [([1, 2, 3], 3), ([-1, -5, 0], 0), ([42], 42), ([], None), ([3, 1, 4, 1, 5, 9, 2, 6], 9)]\nfor inp, exp in test_cases:\n    name = f\"find_max({inp})=={exp}\"\n    try:\n        actual = find_max(inp)\n        results.append({\"test_name\": name, \"passed\": actual == exp, \"expected\": str(exp), \"actual\": str(actual), \"error\": \"\"})\n    except Exception as e:\n        results.append({\"test_name\": name, \"passed\": False, \"expected\": str(exp), \"actual\": \"\", \"error\": str(e)})",
+  "max_steps": 5
+}

code_debug_env/tasks/hard/task_005_binary_search.json

@@ -0,0 +1,17 @@
+{
+  "task_id": "task_005_binary_search",
+  "difficulty": "hard",
+  "description": "Fix the bugs in binary_search. It should return the index of target in a sorted array, or -1 if not found. There are multiple bugs in the boundary handling and loop condition.",
+  "buggy_code": "def binary_search(arr, target):\n    low, high = 0, len(arr)\n    while low < high:\n        mid = (low + high) // 2\n        if arr[mid] == target:\n            return mid\n        elif arr[mid] < target:\n            low = mid + 1\n        else:\n            high = mid - 1\n    return -1\n",
+  "solution": "def binary_search(arr, target):\n    low, high = 0, len(arr) - 1\n    while low <= high:\n        mid = (low + high) // 2\n        if arr[mid] == target:\n            return mid\n        elif arr[mid] < target:\n            low = mid + 1\n        else:\n            high = mid - 1\n    return -1\n",
+  "test_descriptions": [
+    "binary_search([1, 3, 5, 7, 9], 5) should return 2",
+    "binary_search([1, 3, 5, 7, 9], 1) should return 0 (first element)",
+    "binary_search([1, 3, 5, 7, 9], 9) should return 4 (last element)",
+    "binary_search([1, 3, 5, 7, 9], 4) should return -1 (not found)",
+    "binary_search([42], 42) should return 0 (single element)",
+    "binary_search([], 1) should return -1 (empty array)"
+  ],
+  "test_code": "test_cases = [\n    (([1,3,5,7,9], 5), 2, \"find_middle\"),\n    (([1,3,5,7,9], 1), 0, \"find_first\"),\n    (([1,3,5,7,9], 9), 4, \"find_last\"),\n    (([1,3,5,7,9], 4), -1, \"not_found\"),\n    (([42], 42), 0, \"single_element\"),\n    (([], 1), -1, \"empty_array\")\n]\nfor (arr, target), exp, name in test_cases:\n    try:\n        actual = binary_search(arr, target)\n        results.append({\"test_name\": name, \"passed\": actual == exp, \"expected\": str(exp), \"actual\": str(actual), \"error\": \"\"})\n    except Exception as e:\n        results.append({\"test_name\": name, \"passed\": False, \"expected\": str(exp), \"actual\": \"\", \"error\": str(e)})",
+  "max_steps": 10
+}

code_debug_env/tasks/hard/task_006_graph_cycle.json

@@ -0,0 +1,17 @@
+{
+  "task_id": "task_006_graph_cycle",
+  "difficulty": "hard",
+  "description": "Fix the bug in has_cycle. It should detect if a directed graph (given as an adjacency dict) contains a cycle. The current implementation incorrectly reports cycles in DAGs because it doesn't distinguish between nodes in the current DFS path vs. nodes that have been fully explored.",
+  "buggy_code": "def has_cycle(graph):\n    visited = set()\n\n    def dfs(node):\n        if node in visited:\n            return True\n        visited.add(node)\n        for neighbor in graph.get(node, []):\n            if dfs(neighbor):\n                return True\n        return False\n\n    for node in graph:\n        if node not in visited:\n            if dfs(node):\n                return True\n    return False\n",
+  "solution": "def has_cycle(graph):\n    visited = set()\n    rec_stack = set()\n\n    def dfs(node):\n        visited.add(node)\n        rec_stack.add(node)\n        for neighbor in graph.get(node, []):\n            if neighbor not in visited:\n                if dfs(neighbor):\n                    return True\n            elif neighbor in rec_stack:\n                return True\n        rec_stack.discard(node)\n        return False\n\n    for node in graph:\n        if node not in visited:\n            if dfs(node):\n                return True\n    return False\n",
+  "test_descriptions": [
+    "A simple cycle A->B->C->A should return True",
+    "A DAG A->B->C, A->C should return False",
+    "A self-loop A->A should return True",
+    "An empty graph {} should return False",
+    "A disconnected graph with a cycle in one component should return True",
+    "A diamond DAG A->B, A->C, B->D, C->D should return False"
+  ],
+  "test_code": "test_cases = [\n    ({\"A\": [\"B\"], \"B\": [\"C\"], \"C\": [\"A\"]}, True, \"simple_cycle\"),\n    ({\"A\": [\"B\", \"C\"], \"B\": [\"C\"], \"C\": []}, False, \"dag_no_cycle\"),\n    ({\"A\": [\"A\"]}, True, \"self_loop\"),\n    ({}, False, \"empty_graph\"),\n    ({\"A\": [\"B\"], \"B\": [], \"C\": [\"D\"], \"D\": [\"E\"], \"E\": [\"C\"]}, True, \"disconnected_with_cycle\"),\n    ({\"A\": [\"B\", \"C\"], \"B\": [\"D\"], \"C\": [\"D\"], \"D\": []}, False, \"diamond_dag\")\n]\nfor graph, exp, name in test_cases:\n    try:\n        actual = has_cycle(graph)\n        results.append({\"test_name\": name, \"passed\": actual == exp, \"expected\": str(exp), \"actual\": str(actual), \"error\": \"\"})\n    except Exception as e:\n        results.append({\"test_name\": name, \"passed\": False, \"expected\": str(exp), \"actual\": \"\", \"error\": str(e)})",
+  "max_steps": 10
+}

code_debug_env/tasks/medium/task_003_mutable_default.json

@@ -0,0 +1,15 @@
+{
+  "task_id": "task_003_mutable_default",
+  "difficulty": "medium",
+  "description": "Fix the bug in the add_item and build_shopping_lists functions. build_shopping_lists should return independent lists for each group of items. Currently all lists share the same underlying list due to a mutable default argument.",
+  "buggy_code": "def add_item(item, lst=[]):\n    lst.append(item)\n    return lst\n\n\ndef build_shopping_lists(items_per_list):\n    result = []\n    for items in items_per_list:\n        current_list = add_item(items[0])\n        for item in items[1:]:\n            current_list = add_item(item)\n        result.append(current_list)\n    return result\n",
+  "solution": "def add_item(item, lst=None):\n    if lst is None:\n        lst = []\n    lst.append(item)\n    return lst\n\n\ndef build_shopping_lists(items_per_list):\n    result = []\n    for items in items_per_list:\n        current_list = add_item(items[0])\n        for item in items[1:]:\n            current_list = add_item(item, current_list)\n        result.append(current_list)\n    return result\n",
+  "test_descriptions": [
+    "build_shopping_lists([['a', 'b']]) should return [['a', 'b']]",
+    "build_shopping_lists([['a', 'b'], ['c', 'd']]) should return [['a', 'b'], ['c', 'd']] (independent lists)",
+    "build_shopping_lists([['x']]) should return [['x']]",
+    "Calling build_shopping_lists twice should not carry state between calls"
+  ],
+  "test_code": "try:\n    r1 = build_shopping_lists([['a', 'b']])\n    results.append({\"test_name\": \"single_list\", \"passed\": r1 == [['a', 'b']], \"expected\": \"[['a', 'b']]\", \"actual\": str(r1), \"error\": \"\"})\nexcept Exception as e:\n    results.append({\"test_name\": \"single_list\", \"passed\": False, \"expected\": \"[['a', 'b']]\", \"actual\": \"\", \"error\": str(e)})\n\ntry:\n    r2 = build_shopping_lists([['a', 'b'], ['c', 'd']])\n    results.append({\"test_name\": \"independent_lists\", \"passed\": r2 == [['a', 'b'], ['c', 'd']], \"expected\": \"[['a', 'b'], ['c', 'd']]\", \"actual\": str(r2), \"error\": \"\"})\nexcept Exception as e:\n    results.append({\"test_name\": \"independent_lists\", \"passed\": False, \"expected\": \"[['a', 'b'], ['c', 'd']]\", \"actual\": \"\", \"error\": str(e)})\n\ntry:\n    r3 = build_shopping_lists([['x']])\n    results.append({\"test_name\": \"single_item\", \"passed\": r3 == [['x']], \"expected\": \"[['x']]\", \"actual\": str(r3), \"error\": \"\"})\nexcept Exception as e:\n    results.append({\"test_name\": \"single_item\", \"passed\": False, \"expected\": \"[['x']]\", \"actual\": \"\", \"error\": str(e)})\n\ntry:\n    call1 = build_shopping_lists([['a']])\n    call2 = build_shopping_lists([['b']])\n    results.append({\"test_name\": \"no_state_leak\", \"passed\": call1 == [['a']] and call2 == [['b']], \"expected\": \"[['a']] and [['b']]\", \"actual\": f\"{call1} and {call2}\", \"error\": \"\"})\nexcept Exception as e:\n    results.append({\"test_name\": \"no_state_leak\", \"passed\": False, \"expected\": \"[['a']] and [['b']]\", \"actual\": \"\", \"error\": str(e)})",
+  "max_steps": 7
+}

code_debug_env/tasks/medium/task_004_scope_bug.json

@@ -0,0 +1,15 @@
+{
+  "task_id": "task_004_scope_bug",
+  "difficulty": "medium",
+  "description": "Fix the bug in make_counters. It should return a list of n functions where the i-th function returns i. Currently all returned functions return the same value (n-1) because the closure captures the loop variable by reference.",
+  "buggy_code": "def make_counters(n):\n    counters = []\n    for i in range(n):\n        def counter():\n            return i\n        counters.append(counter)\n    return counters\n",
+  "solution": "def make_counters(n):\n    counters = []\n    for i in range(n):\n        def counter(i=i):\n            return i\n        counters.append(counter)\n    return counters\n",
+  "test_descriptions": [
+    "make_counters(3) should return functions that return 0, 1, 2 respectively",
+    "make_counters(1) should return a single function that returns 0",
+    "make_counters(5)[4]() should return 4",
+    "make_counters(0) should return an empty list"
+  ],
+  "test_code": "try:\n    fns = make_counters(3)\n    vals = [f() for f in fns]\n    results.append({\"test_name\": \"counters_3\", \"passed\": vals == [0, 1, 2], \"expected\": \"[0, 1, 2]\", \"actual\": str(vals), \"error\": \"\"})\nexcept Exception as e:\n    results.append({\"test_name\": \"counters_3\", \"passed\": False, \"expected\": \"[0, 1, 2]\", \"actual\": \"\", \"error\": str(e)})\n\ntry:\n    fns = make_counters(1)\n    vals = [f() for f in fns]\n    results.append({\"test_name\": \"counters_1\", \"passed\": vals == [0], \"expected\": \"[0]\", \"actual\": str(vals), \"error\": \"\"})\nexcept Exception as e:\n    results.append({\"test_name\": \"counters_1\", \"passed\": False, \"expected\": \"[0]\", \"actual\": \"\", \"error\": str(e)})\n\ntry:\n    fns = make_counters(5)\n    val = fns[4]()\n    results.append({\"test_name\": \"counter_5_last\", \"passed\": val == 4, \"expected\": \"4\", \"actual\": str(val), \"error\": \"\"})\nexcept Exception as e:\n    results.append({\"test_name\": \"counter_5_last\", \"passed\": False, \"expected\": \"4\", \"actual\": \"\", \"error\": str(e)})\n\ntry:\n    fns = make_counters(0)\n    results.append({\"test_name\": \"counters_0\", \"passed\": fns == [], \"expected\": \"[]\", \"actual\": str(fns), \"error\": \"\"})\nexcept Exception as e:\n    results.append({\"test_name\": \"counters_0\", \"passed\": False, \"expected\": \"[]\", \"actual\": \"\", \"error\": str(e)})",
+  "max_steps": 7
+}

inference.py

@@ -0,0 +1,233 @@
+"""
+Inference Script — Code Debug OpenEnv
+======================================
+MANDATORY environment variables:
+    API_BASE_URL      The API endpoint for the LLM.
+    MODEL_NAME        The model identifier to use for inference.
+    HF_TOKEN          Your Hugging Face / API key.
+    ENV_URL           URL of the running OpenEnv server (default: http://localhost:7860)
+
+STDOUT FORMAT:
+    [START] task=<task_id> env=<env_url> model=<model_name>
+    [STEP]  step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>
+    [END]   success=<true|false> steps=<n> score=<0.000> rewards=<r1,r2,...>
+"""
+
+import os
+import sys
+import textwrap
+from typing import Optional
+
+import httpx
+from openai import OpenAI
+
+# ------------------------------------------------------------------
+# Configuration
+# ------------------------------------------------------------------
+
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
+MODEL_NAME   = os.getenv("MODEL_NAME", "Qwen/Qwen2.5-72B-Instruct")
+HF_TOKEN     = os.getenv("HF_TOKEN", "")
+ENV_URL      = os.getenv("ENV_URL", "http://localhost:7860")
+
+TEMPERATURE   = 0.2
+MAX_TOKENS    = 2048
+SUCCESS_THRESHOLD = 1.0  # require all tests passing
+
+SYSTEM_PROMPT = textwrap.dedent("""
+    You are an expert Python debugger.
+
+    You will receive:
+    1. A description of the task
+    2. The buggy Python code
+    3. Descriptions of what each test checks
+    4. (From step 2 onwards) Test results showing which tests passed or failed,
+       with actual vs expected values and any error messages
+
+    Your job: return ONLY the corrected Python code with all bugs fixed.
+    Rules:
+    - Output raw Python code only — no markdown fences, no explanations
+    - Include the complete function definition(s), not just the changed lines
+    - Make sure all tests pass
+""").strip()
+
+
+# ------------------------------------------------------------------
+# Logging helpers (strict format per submission spec)
+# ------------------------------------------------------------------
+
+def log_start(task: str, env: str, model: str) -> None:
+    print(f"[START] task={task} env={env} model={model}", flush=True)
+
+
+def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
+    error_val = error if error else "null"
+    done_val  = str(done).lower()
+    safe_action = action.replace("\n", "\\n")[:120]
+    print(
+        f"[STEP] step={step} action={safe_action!r} reward={reward:.2f} done={done_val} error={error_val}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, score: float, rewards: list[float]) -> None:
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(
+        f"[END] success={str(success).lower()} steps={steps} score={score:.3f} rewards={rewards_str}",
+        flush=True,
+    )
+
+
+# ------------------------------------------------------------------
+# Prompt builders
+# ------------------------------------------------------------------
+
+def build_initial_prompt(obs: dict) -> str:
+    lines = [
+        f"## Task\n{obs['description']}",
+        f"\n## Buggy Code\n```python\n{obs['buggy_code']}\n```",
+        "\n## Tests that must pass",
+    ]
+    for desc in obs.get("test_descriptions", []):
+        lines.append(f"- {desc}")
+    return "\n".join(lines)
+
+
+def build_feedback_prompt(obs: dict) -> str:
+    lines = ["## Test Results from your last submission\n"]
+    for tr in obs.get("test_results", []):
+        status = "PASS" if tr["passed"] else "FAIL"
+        lines.append(f"[{status}] {tr['test_name']}")
+        if not tr["passed"]:
+            lines.append(f"       expected : {tr['expected']}")
+            lines.append(f"       actual   : {tr['actual']}")
+            if tr.get("error"):
+                lines.append(f"       error    : {tr['error']}")
+    if obs.get("stderr"):
+        lines.append(f"\n## Stderr\n{obs['stderr'][:500]}")
+    lines.append("\nFix the remaining failures and return the complete corrected code.")
+    return "\n".join(lines)
+
+
+def strip_fences(text: str) -> str:
+    text = text.strip()
+    if text.startswith("```python"):
+        text = text[len("```python"):].strip()
+    elif text.startswith("```"):
+        text = text[3:].strip()
+    if text.endswith("```"):
+        text = text[:-3].strip()
+    return text
+
+
+# ------------------------------------------------------------------
+# Single episode runner
+# ------------------------------------------------------------------
+
+def run_episode(http: httpx.Client, client: OpenAI, task_id: str) -> dict:
+    # Reset
+    reset_resp = http.post("/reset", json={"task_id": task_id})
+    reset_resp.raise_for_status()
+    reset_data  = reset_resp.json()
+    episode_id  = reset_data["episode_id"]
+    obs         = reset_data["observation"]
+    max_steps   = obs.get("max_steps", 5)
+
+    log_start(task=task_id, env=ENV_URL, model=MODEL_NAME)
+
+    messages: list[dict] = [{"role": "system", "content": SYSTEM_PROMPT}]
+    rewards: list[float] = []
+    steps_taken = 0
+    error_msg: Optional[str] = None
+
+    try:
+        for step in range(1, max_steps + 1):
+            # Build user message
+            if step == 1:
+                user_content = build_initial_prompt(obs)
+            else:
+                user_content = build_feedback_prompt(obs)
+
+            messages.append({"role": "user", "content": user_content})
+
+            # LLM call
+            try:
+                completion = client.chat.completions.create(
+                    model=MODEL_NAME,
+                    messages=messages,
+                    temperature=TEMPERATURE,
+                    max_tokens=MAX_TOKENS,
+                )
+                fixed_code = strip_fences(completion.choices[0].message.content or "")
+                messages.append({"role": "assistant", "content": fixed_code})
+            except Exception as exc:
+                error_msg = str(exc)
+                log_step(step=step, action="llm_error", reward=0.0, done=False, error=error_msg)
+                break
+
+            # Step environment
+            step_resp = http.post(
+                f"/step/{episode_id}",
+                json={"action": {"code": fixed_code}},
+            )
+            step_resp.raise_for_status()
+            step_data = step_resp.json()
+            obs       = step_data["observation"]
+            reward    = step_data["reward"]
+            done      = step_data["done"]
+
+            rewards.append(reward)
+            steps_taken = step
+
+            log_step(step=step, action=fixed_code, reward=reward, done=done, error=None)
+
+            if done:
+                break
+
+    except Exception as exc:
+        error_msg = str(exc)
+
+    score   = rewards[-1] if rewards else 0.0
+    success = score >= SUCCESS_THRESHOLD
+    log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+    return {
+        "task_id":    task_id,
+        "episode_id": episode_id,
+        "success":    success,
+        "score":      score,
+        "steps":      steps_taken,
+    }
+
+
+# ------------------------------------------------------------------
+# Main: run all tasks
+# ------------------------------------------------------------------
+
+def main():
+    client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN or "EMPTY")
+    http   = httpx.Client(base_url=ENV_URL, timeout=60.0)
+
+    # Discover available tasks from the server
+    try:
+        tasks_resp = http.get("/tasks")
+        tasks_resp.raise_for_status()
+        all_tasks = [t["task_id"] for t in tasks_resp.json()]
+    except Exception as exc:
+        print(f"[ERROR] Could not fetch task list: {exc}", file=sys.stderr, flush=True)
+        sys.exit(1)
+
+    results = []
+    for task_id in all_tasks:
+        result = run_episode(http, client, task_id)
+        results.append(result)
+
+    # Summary
+    total   = len(results)
+    solved  = sum(1 for r in results if r["success"])
+    avg     = sum(r["score"] for r in results) / total if total else 0.0
+    print(f"\n=== SUMMARY: solved={solved}/{total} avg_score={avg:.3f} ===", flush=True)
+
+
+if __name__ == "__main__":
+    main()