Fix openenv validate: add main(), entry point, openenv-core dep, uv.lock

inference.py

@@ -7,12 +7,19 @@ Required environment variables:
     MODEL_NAME     — model identifier
     HF_TOKEN       — API key
     ENV_URL        — environment server URL (default: http://localhost:8000)
+
+STDOUT FORMAT (OpenEnv spec):
+    [START] task=<task_name> env=<benchmark> model=<model_name>
+    [STEP]  step=<n> action=<action_str> reward=<0.00> done=<true|false> error=<msg|null>
+    [END]   success=<true|false> steps=<n> rewards=<r1,r2,...,rn>
 """
 
 import json
 import os
+import re
 import sys
 import time
+from typing import List, Optional
 import httpx
 from openai import OpenAI
 
@@ -66,19 +73,41 @@ Rules:
 """
 
 
+# ------------------------------------------------------------------
+# OpenEnv stdout logging helpers
+# ------------------------------------------------------------------
+
+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()
+    print(
+        f"[STEP] step={step} action={action} reward={reward:.2f} done={done_val} error={error_val}",
+        flush=True,
+    )
+
+
+def log_end(success: bool, steps: int, rewards: List[float]) -> None:
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    print(f"[END] success={str(success).lower()} steps={steps} rewards={rewards_str}", flush=True)
+
+
 # ------------------------------------------------------------------
 # HTTP helpers
 # ------------------------------------------------------------------
 
 def api_post(path: str, payload: dict = None) -> dict:
-    url = ENV_URL.rstrip("/") + path
+    url  = ENV_URL.rstrip("/") + path
     resp = httpx.post(url, json=payload or {}, timeout=30)
     resp.raise_for_status()
     return resp.json()
 
 
 def api_get(path: str) -> dict:
-    url = ENV_URL.rstrip("/") + path
+    url  = ENV_URL.rstrip("/") + path
     resp = httpx.get(url, timeout=10)
     resp.raise_for_status()
     return resp.json()
@@ -108,58 +137,102 @@ def obs_to_text(obs: dict) -> str:
 
 
 def run_task(task_id: int) -> float:
-    print(f"\n{'='*60}")
-    print(f"  Running Task {task_id}")
-    print(f"{'='*60}")
+    task_name = f"data-cleaning-task{task_id}"
+
+    # Human-readable header (stderr so it doesn't interfere with stdout format)
+    print(f"\n{'='*60}", file=sys.stderr)
+    print(f"  Running Task {task_id}", file=sys.stderr)
+    print(f"{'='*60}", file=sys.stderr)
 
     result  = api_post("/reset", {"task_id": task_id})
     obs     = result["observation"]
     history = []
+    rewards: List[float] = []
+    steps_taken = 0
+    success = False
+
+    log_start(task=task_name, env="data-cleaning-openenv", model=MODEL_NAME)
+
+    try:
+        for step_num in range(1, 50):
+            if obs["done"]:
+                success = obs["current_score"] >= 0.95
+                break
+
+            obs_text = obs_to_text(obs)
+            history.append({"role": "user", "content": obs_text})
+
+            try:
+                response = client.chat.completions.create(
+                    model       = MODEL_NAME,
+                    messages    = [{"role": "system", "content": SYSTEM_PROMPT}] + history,
+                    temperature = 0.0,
+                    max_tokens  = 256,
+                )
+                action_str = response.choices[0].message.content.strip()
+            except Exception as exc:
+                print(f"  Step {step_num}: LLM call failed: {exc}", file=sys.stderr)
+                log_step(step_num, "null", 0.0, True, str(exc))
+                break
 
-    for step_num in range(1, 50):
-        if obs["done"]:
-            break
-
-        obs_text = obs_to_text(obs)
-        history.append({"role": "user", "content": obs_text})
-
-        response = client.chat.completions.create(
-            model    = MODEL_NAME,
-            messages = [{"role": "system", "content": SYSTEM_PROMPT}] + history,
-            temperature = 0.0,
-            max_tokens  = 256,
-        )
-        action_str = response.choices[0].message.content.strip()
-        history.append({"role": "assistant", "content": action_str})
-
-        # Parse action
-        try:
-            action = json.loads(action_str)
-        except json.JSONDecodeError:
-            # Try to extract JSON from markdown code fence
-            import re
-            m = re.search(r"\{.*\}", action_str, re.DOTALL)
-            if m:
-                try:
-                    action = json.loads(m.group())
-                except Exception:
-                    print(f"  Step {step_num}: Could not parse action JSON, skipping.")
-                    break
-            else:
-                print(f"  Step {step_num}: No JSON found in response, skipping.")
+            history.append({"role": "assistant", "content": action_str})
+
+            # Parse action JSON
+            action = None
+            try:
+                action = json.loads(action_str)
+            except json.JSONDecodeError:
+                m = re.search(r"\{.*\}", action_str, re.DOTALL)
+                if m:
+                    try:
+                        action = json.loads(m.group())
+                    except Exception:
+                        pass
+
+            if action is None:
+                print(f"  Step {step_num}: Could not parse action JSON, skipping.", file=sys.stderr)
+                log_step(step_num, action_str, -0.05, False, "json_parse_error")
                 break
 
-        print(f"  Step {step_num:2d} | score={obs['current_score']:.4f} | action={json.dumps(action)}")
+            action_label = json.dumps(action, separators=(",", ":"))
+            print(
+                f"  Step {step_num:2d} | score={obs['current_score']:.4f} | action={action_label}",
+                file=sys.stderr,
+            )
+
+            result      = api_post("/step", action)
+            obs         = result["observation"]
+            step_reward = result["reward"]
+            done        = result["done"]
+            error_msg   = None if obs["message"].startswith("Fill") or step_reward >= 0 else obs["message"]
+
+            print(f"           -> {obs['message']}", file=sys.stderr)
+
+            rewards.append(step_reward)
+            steps_taken = step_num
+
+            log_step(
+                step   = step_num,
+                action = action_label,
+                reward = step_reward,
+                done   = done,
+                error  = error_msg,
+            )
+
+            if done:
+                success = obs["current_score"] >= 0.95
+                break
 
-        result = api_post("/step", action)
-        obs    = result["observation"]
-        print(f"           → {obs['message']}")
+            time.sleep(0.3)
 
-        # Slight delay to stay within rate limits on free-tier endpoints
-        time.sleep(0.3)
+    finally:
+        log_end(success=success, steps=steps_taken, rewards=rewards)
 
     final_score = obs["current_score"]
-    print(f"\n  Task {task_id} final score: {final_score:.4f}  (steps used: {obs['step_count']})")
+    print(
+        f"\n  Task {task_id} final score: {final_score:.4f}  (steps used: {obs['step_count']})",
+        file=sys.stderr,
+    )
     return final_score
 
 
@@ -168,33 +241,33 @@ def run_task(task_id: int) -> float:
 # ------------------------------------------------------------------
 
 def main():
-    print("Data Cleaning OpenEnv — Baseline Inference")
-    print(f"Model : {MODEL_NAME}")
-    print(f"Env   : {ENV_URL}")
+    print("Data Cleaning OpenEnv -- Baseline Inference", file=sys.stderr)
+    print(f"Model : {MODEL_NAME}", file=sys.stderr)
+    print(f"Env   : {ENV_URL}", file=sys.stderr)
 
     # Smoke-test health endpoint
     health = api_get("/health")
     assert health.get("status") == "ok", f"Health check failed: {health}"
-    print("Health check: OK\n")
+    print("Health check: OK\n", file=sys.stderr)
 
     scores = {}
     for task_id in [1, 2, 3]:
         scores[f"task{task_id}"] = run_task(task_id)
 
-    print("\n" + "="*60)
-    print("  BASELINE RESULTS")
-    print("="*60)
+    print("\n" + "="*60, file=sys.stderr)
+    print("  BASELINE RESULTS", file=sys.stderr)
+    print("="*60, file=sys.stderr)
     for k, v in scores.items():
-        print(f"  {k}: {v:.4f}")
+        print(f"  {k}: {v:.4f}", file=sys.stderr)
     avg = sum(scores.values()) / len(scores)
-    print(f"  average: {avg:.4f}")
-    print("="*60)
+    print(f"  average: {avg:.4f}", file=sys.stderr)
+    print("="*60, file=sys.stderr)
 
     # Write scores to file for automated validators
     with open("baseline_scores.json", "w") as f:
         json.dump({"scores": scores, "average": avg}, f, indent=2)
-    print("\nScores written to baseline_scores.json")
+    print("\nScores written to baseline_scores.json", file=sys.stderr)
 
 
 if __name__ == "__main__":
-    main()
+    main()

pyproject.toml

@@ -12,11 +12,15 @@ dependencies = [
     "faker>=18.0.0",
     "openai>=1.0.0",
     "httpx>=0.25.0",
+    "openenv-core>=0.2.0",
 ]
 
+[project.scripts]
+serve = "server.app:main"
+
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
-packages = ["server"]
+packages = ["server"]

requirements.txt

@@ -6,3 +6,4 @@ numpy>=1.24.0
 faker>=18.0.0
 openai>=1.0.0
 httpx>=0.25.0
+openenv-core>=0.2.0

server/app.py

@@ -6,6 +6,7 @@ Endpoints: GET /health, POST /reset, POST /step, POST /state, GET /docs
 from typing import Optional
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
+import uvicorn
 
 from models import DataCleaningAction, DataCleaningObservation, DataCleaningState
 from server.environment import DataCleaningEnvironment
@@ -61,3 +62,15 @@ def step(action: DataCleaningAction):
 @app.post("/state", response_model=DataCleaningState)
 def state():
     return env.state()
+
+
+# ------------------------------------------------------------------
+# Entry point (required by openenv-core and [project.scripts])
+# ------------------------------------------------------------------
+
+def main():
+    uvicorn.run("server.app:app", host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    main()