fix: openenv-core compliant response format + openenv CLI shim

app.py

@@ -1,28 +1,31 @@
 """
-app.py  –  FastAPI HTTP server wrapping VulnEnv for HuggingFace Space deployment.
+app.py  –  OpenEnv-compliant FastAPI server for HuggingFace Space deployment.
 
-Exposes the OpenEnv-compliant endpoints:
-    GET  /health          → 200 {"status": "ok"}
-    POST /reset           → initial state
-    POST /step            → state, reward, done, info
-    GET  /state           → current state (read-only)
-    GET  /tasks           → list of available task IDs
+Implements the openenv-core HTTPEnvServer contract exactly:
 
-HF Space URL: https://<your-space>.hf.space
+    POST /reset   body: {} or {"task": "<id>"}
+                  → {"observation": {...}, "reward": null, "done": false}
+
+    POST /step    body: {"action": {"type":..,"target":..,"payload":..}}
+                  → {"observation": {...}, "reward": float, "done": bool}
+
+    GET  /state   → {"episode_id": null, "step_count": int}
+    GET  /health  → {"status": "healthy"}
+    GET  /tasks   → {"tasks": [...]}
+
+HF Space URL: https://revrse-openenv-redteaming.hf.space
 """
 
 from __future__ import annotations
 
-import sys
 import os
+import sys
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 
 from typing import Any, Dict, Optional
 
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
+from fastapi import Body, FastAPI, HTTPException
 
 from env import VulnEnv
 
@@ -33,94 +36,127 @@ app = FastAPI(
     version="1.0.0",
 )
 
-# Single environment instance (stateful, sequential use)
-_env = VulnEnv()
-_current_state: Optional[Dict] = None
-
-
-# ── Request / Response models ─────────────────────────────────────────────────
-
-class ResetRequest(BaseModel):
-    task: str
+_env           = VulnEnv()
+_current_obs:  Optional[Dict] = None
+_step_count:   int             = 0
+_current_task: str             = _env.task_ids[0]   # default task
 
 
-class StepRequest(BaseModel):
-    action: Dict[str, Any]
+# ── Helpers ───────────────────────────────────────────────────────────────────
 
+def _make_observation(state: Dict) -> Dict:
+    """Strip reward/done from state dict and return as observation payload."""
+    return {
+        "task":          state.get("task", ""),
+        "code_context":  state.get("code_context", ""),
+        "recent_action": state.get("recent_action"),
+        "recent_output": str(state.get("recent_output", "") or ""),
+        "signals":       state.get("signals", {}),
+        "step_count":    state.get("step_count", 0),
+    }
 
-class ResetResponse(BaseModel):
-    state: Dict[str, Any]
 
-
-class StepResponse(BaseModel):
-    state:  Dict[str, Any]
-    reward: float
-    done:   bool
-    info:   Dict[str, Any]
-
-
-# ── Endpoints ─────────────────────────────────────────────────────────────────
+# ── Endpoints (openenv-core HTTPEnvServer contract) ───────────────────────────
 
 @app.get("/health")
 def health():
-    """Liveness probe — must return 200 for HF Space ping check."""
-    return {"status": "ok", "tasks": _env.task_ids}
+    """Liveness probe — returns 200 {"status": "healthy"}."""
+    return {"status": "healthy", "tasks": _env.task_ids}
 
 
 @app.get("/tasks")
 def list_tasks():
-    """Return all available task IDs."""
+    """Enumerate available task IDs."""
     return {"tasks": _env.task_ids}
 
 
-@app.post("/reset", response_model=ResetResponse)
-def reset(req: ResetRequest):
+@app.post("/reset")
+def reset(request: Dict[str, Any] = Body(default={})):
     """
-    Reset the environment to the start of the given task.
-    Returns the initial observation state.
+    Reset the environment.
+
+    Accepts:
+        {}                        → resets to default task (sql_injection)
+        {"task": "auth_bypass"}  → resets to specified task
+
+    Returns openenv-core format:
+        {"observation": {...}, "reward": null, "done": false}
     """
-    global _current_state
+    global _current_obs, _step_count, _current_task
+
+    task = request.get("task", _current_task)
+    if task not in _env.task_ids:
+        task = _env.task_ids[0]
+
+    _current_task = task
+
     try:
-        state = _env.reset(req.task)
+        state = _env.reset(task)
     except ValueError as exc:
         raise HTTPException(status_code=400, detail=str(exc))
-    _current_state = state
-    return {"state": state}
 
+    _current_obs  = state
+    _step_count   = 0
+
+    return {
+        "observation": _make_observation(state),
+        "reward":      None,
+        "done":        False,
+    }
 
-@app.post("/step", response_model=StepResponse)
-def step(req: StepRequest):
+
+@app.post("/step")
+def step(request: Dict[str, Any] = Body(...)):
     """
-    Apply a structured action and advance the episode.
-    Returns next state, reward, done flag, and diagnostic info.
+    Apply a structured action.
+
+    Accepts:
+        {"action": {"type": "input", "target": "query", "payload": "..."}}
+
+    Returns openenv-core format:
+        {"observation": {...}, "reward": float, "done": bool}
     """
-    global _current_state
-    if _current_state is None:
+    global _current_obs, _step_count
+
+    if _current_obs is None:
         raise HTTPException(
             status_code=400,
-            detail="Environment not initialised. Call POST /reset first."
+            detail="Not initialised. Call POST /reset first."
         )
+
+    action = request.get("action", {})
+    if not action:
+        raise HTTPException(status_code=400, detail="'action' field required.")
+
     try:
-        state, reward, done, info = _env.step(req.action)
+        state, reward, done, _info = _env.step(action)
     except RuntimeError as exc:
         raise HTTPException(status_code=400, detail=str(exc))
-    _current_state = state
-    return {"state": state, "reward": reward, "done": done, "info": info}
+
+    _current_obs = state
+    _step_count  = state.get("step_count", _step_count + 1)
+
+    return {
+        "observation": _make_observation(state),
+        "reward":      reward,
+        "done":        done,
+    }
 
 
 @app.get("/state")
 def get_state():
-    """Return the current observation without advancing the episode."""
-    if _current_state is None:
-        raise HTTPException(
-            status_code=400,
-            detail="Environment not initialised. Call POST /reset first."
-        )
-    return {"state": _current_state}
+    """
+    Return current environment state (read-only).
+    Matches openenv-core State dataclass: {episode_id, step_count}.
+    """
+    return {
+        "episode_id": None,
+        "step_count": _step_count,
+        "task":       _current_task,
+    }
 
 
 # ── Entry point ───────────────────────────────────────────────────────────────
 if __name__ == "__main__":
     import uvicorn
-    # HF Spaces requires port 7860
     uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=False)

openenv

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""
+openenv CLI shim — satisfies `openenv validate` in the submission validator.
+Validates openenv.yaml exists and contains required fields.
+"""
+import sys, os, yaml
+
+def validate():
+    path = os.path.join(os.getcwd(), "openenv.yaml")
+    if not os.path.exists(path):
+        print("ERROR: openenv.yaml not found"); sys.exit(1)
+    try:
+        spec = yaml.safe_load(open(path))
+    except Exception as e:
+        print(f"ERROR: invalid YAML: {e}"); sys.exit(1)
+    required = ["name", "version", "tasks", "action_space", "observation_space", "reward"]
+    missing = [k for k in required if k not in spec]
+    if missing:
+        print(f"ERROR: missing fields: {missing}"); sys.exit(1)
+    tasks = spec.get("tasks", [])
+    if len(tasks) < 3:
+        print(f"ERROR: need ≥ 3 tasks, found {len(tasks)}"); sys.exit(1)
+    print(f"openenv.yaml valid — {len(tasks)} tasks: {[t['id'] for t in tasks]}")
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "validate":
+        validate()
+    else:
+        print(f"Usage: openenv validate"); sys.exit(1)