Fix Docker build + rewrite inference.py to follow OpenEnv sample pattern

- Dockerfile: python:3.11-slim -> python:3.12-slim (more reliable registry pull)
- inference.py: Use DataCleanEnv client with from_docker_image() support
- inference.py: Support LOCAL_IMAGE_NAME env var for validator
- inference.py: Use HF router as default API_BASE_URL
- inference.py: Keep [START]/[STEP]/[END] structured output markers

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

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.11-slim
+FROM python:3.12-slim
 
 # Create non-root user (HF Spaces requirement)
 RUN useradd -m -u 1000 user
@@ -7,11 +7,11 @@ ENV HOME=/home/user \
 
 WORKDIR /app
 
-# Install dependencies
+# Copy and install dependencies
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy source
+# Copy source code
 COPY . .
 
 # Install the package

inference.py

@@ -1,13 +1,15 @@
 """
 Inference Script — DataClean Environment
 =========================================
-MANDATORY:
-- Before submitting, ensure the following variables are defined:
-    API_BASE_URL   The API endpoint for the LLM.
+MANDATORY environment variables:
+    API_BASE_URL   The API endpoint for the LLM (default: HF router).
     MODEL_NAME     The model identifier to use for inference.
-    HF_TOKEN       Your Hugging Face / API key.
-- This script must be named `inference.py` and placed in the root directory.
-- Uses OpenAI Client for all LLM calls.
+    HF_TOKEN       Your Hugging Face / API key (no default).
+OPTIONAL:
+    LOCAL_IMAGE_NAME  Docker image to use with from_docker_image().
+    ENV_BASE_URL      Direct URL if environment is already running.
+
+Uses OpenAI Client for all LLM calls.
 """
 
 import json
@@ -17,56 +19,16 @@ import sys
 import textwrap
 import time
 
-import requests
 from openai import OpenAI
 
-
-class _StepResult:
-    def __init__(self, observation: dict, reward: float, done: bool):
-        self.observation = observation
-        self.reward = reward
-        self.done = done
-
-
-class _SimpleClient:
-    """Minimal sync HTTP client for the DataClean environment."""
-
-    def __init__(self, base_url: str):
-        self.base_url = base_url.rstrip("/")
-        self.s = requests.Session()
-
-    def _post(self, path: str, payload: dict) -> dict:
-        """POST with retry on transient errors."""
-        for attempt in range(3):
-            try:
-                r = self.s.post(f"{self.base_url}{path}", json=payload, timeout=60)
-                r.raise_for_status()
-                return r.json()
-            except (requests.ConnectionError, requests.Timeout) as exc:
-                if attempt < 2:
-                    time.sleep(2 ** attempt)
-                    continue
-                raise
-
-    def reset(self, task_name: str = "easy") -> _StepResult:
-        d = self._post("/reset", {"task_name": task_name})
-        return _StepResult(d.get("observation", {}), float(d.get("reward", 0)), bool(d.get("done", False)))
-
-    def step(self, action: dict) -> _StepResult:
-        d = self._post("/step", action)
-        return _StepResult(d.get("observation", {}), float(d.get("reward", 0)), bool(d.get("done", False)))
-
-    def close(self):
-        self.s.close()
-
-
 # ---------------------------------------------------------------------------
 # Configuration
 # ---------------------------------------------------------------------------
-API_BASE_URL = os.getenv("API_BASE_URL", "https://api.groq.com/openai/v1")
+API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/novita/v3/openai")
 API_KEY = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
-MODEL_NAME = os.getenv("MODEL_NAME", "llama-3.3-70b-versatile")
+MODEL_NAME = os.getenv("MODEL_NAME", "meta-llama/llama-3.3-70b-instruct")
 
+LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME", "")
 ENV_BASE_URL = os.getenv("ENV_BASE_URL", "https://glitchghost-dataclean-openenv.hf.space")
 
 MAX_STEPS_PER_TASK = {"easy": 12, "medium": 20, "hard": 30}
@@ -110,12 +72,27 @@ RULES:
 """).strip()
 
 
+# ---------------------------------------------------------------------------
+# Environment client helpers
+# ---------------------------------------------------------------------------
+def _connect_env():
+    """Connect to the DataClean environment using the best available method."""
+    from dataclean_env.client import DataCleanEnv
+
+    # Option 1: Spin up from a local Docker image (validator may set this)
+    if LOCAL_IMAGE_NAME:
+        print(f"  Starting environment from Docker image: {LOCAL_IMAGE_NAME}", flush=True)
+        return DataCleanEnv.from_docker_image(image=LOCAL_IMAGE_NAME)
+
+    # Option 2: Connect to a running instance (HF Space or local)
+    print(f"  Connecting to environment at: {ENV_BASE_URL}", flush=True)
+    return DataCleanEnv(base_url=ENV_BASE_URL)
+
+
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
 ACTION_JSON_RE = re.compile(r"\{[^{}]*\}", re.DOTALL)
-# Also match JSON that may span multiple lines or have nested content
-ACTION_JSON_GREEDY_RE = re.compile(r"\{.*?\}", re.DOTALL)
 
 
 def parse_action(text: str) -> dict:
@@ -133,31 +110,48 @@ def parse_action(text: str) -> dict:
     except (json.JSONDecodeError, ValueError):
         pass
     # Try regex extraction
-    for pattern in [ACTION_JSON_RE, ACTION_JSON_GREEDY_RE]:
-        for m in pattern.finditer(cleaned):
-            try:
-                obj = json.loads(m.group(0))
-                if isinstance(obj, dict) and "action_type" in obj:
-                    return obj
-            except (json.JSONDecodeError, ValueError):
-                continue
+    for m in ACTION_JSON_RE.finditer(cleaned):
+        try:
+            obj = json.loads(m.group(0))
+            if isinstance(obj, dict) and "action_type" in obj:
+                return obj
+        except (json.JSONDecodeError, ValueError):
+            continue
     return {"action_type": "noop"}
 
 
-def build_user_prompt(obs: dict, step_num: int) -> str:
+def build_user_prompt(obs, step_num: int) -> str:
     """Build the user prompt from the observation."""
-    parts = [
-        f"TASK: {obs.get('task_description', '')}",
-        f"DIFFICULTY: {obs.get('difficulty', '')}",
-        f"STEP: {step_num}/{obs.get('max_steps', '?')}",
-        f"CURRENT SCORE: {obs.get('current_score', 0.0)}",
-        "",
-        "CURRENT DATA:",
-        obs.get("data_preview", "(no data)"),
-        "",
-        obs.get("quality_report", ""),
-    ]
-    history = obs.get("action_history", [])
+    # obs can be a DataCleanObservation object or a dict
+    if hasattr(obs, "task_description"):
+        # It's a DataCleanObservation object
+        parts = [
+            f"TASK: {obs.task_description}",
+            f"DIFFICULTY: {obs.difficulty}",
+            f"STEP: {step_num}/{obs.max_steps}",
+            f"CURRENT SCORE: {obs.current_score}",
+            "",
+            "CURRENT DATA:",
+            obs.data_preview or "(no data)",
+            "",
+            obs.quality_report or "",
+        ]
+        history = obs.action_history or []
+    else:
+        # It's a dict
+        parts = [
+            f"TASK: {obs.get('task_description', '')}",
+            f"DIFFICULTY: {obs.get('difficulty', '')}",
+            f"STEP: {step_num}/{obs.get('max_steps', '?')}",
+            f"CURRENT SCORE: {obs.get('current_score', 0.0)}",
+            "",
+            "CURRENT DATA:",
+            obs.get("data_preview", "(no data)"),
+            "",
+            obs.get("quality_report", ""),
+        ]
+        history = obs.get("action_history", [])
+
     if history:
         parts.append("")
         parts.append("RECENT ACTIONS:")
@@ -174,7 +168,7 @@ def build_user_prompt(obs: dict, step_num: int) -> str:
 # ---------------------------------------------------------------------------
 def run_task(
     llm_client: OpenAI,
-    env_client: _SimpleClient,
+    env_client,
     task_name: str,
     max_steps: int,
 ) -> float:
@@ -182,19 +176,12 @@ def run_task(
     # Structured output: START marker (required by validator)
     print(f"[START] task={task_name}", flush=True)
 
-    print(f"\n{'='*60}", flush=True)
-    print(f"  TASK: {task_name.upper()}", flush=True)
-    print(f"{'='*60}", flush=True)
-
     result = env_client.reset(task_name)
     obs = result.observation
-    print(f"  Task: {obs.get('task_description', '')[:80]}...", flush=True)
-    print(f"  Max steps: {max_steps}", flush=True)
 
     step_count = 0
     for step in range(1, max_steps + 1):
         if result.done:
-            print(f"  Episode done at step {step - 1}", flush=True)
             break
 
         user_prompt = build_user_prompt(obs, step)
@@ -203,6 +190,7 @@ def run_task(
             {"role": "user", "content": user_prompt},
         ]
 
+        response_text = '{"action_type": "noop"}'
         for _attempt in range(3):
             try:
                 completion = llm_client.chat.completions.create(
@@ -224,18 +212,22 @@ def run_task(
                 response_text = '{"action_type": "noop"}'
                 break
 
-        action = parse_action(response_text)
-        print(f"  Step {step}: {action.get('action_type', '?')}", end="", flush=True)
-        if action.get("row_index") is not None:
-            print(f" row={action['row_index']}", end="", flush=True)
-        if action.get("column_name"):
-            print(f" col={action['column_name']}", end="", flush=True)
-        if action.get("new_value"):
-            print(f" val={action['new_value']}", end="", flush=True)
-
+        action_dict = parse_action(response_text)
+        print(f"  Step {step}: {action_dict.get('action_type', '?')}", end="", flush=True)
+        if action_dict.get("row_index") is not None:
+            print(f" row={action_dict['row_index']}", end="", flush=True)
+        if action_dict.get("column_name"):
+            print(f" col={action_dict['column_name']}", end="", flush=True)
+        if action_dict.get("new_value"):
+            print(f" val={action_dict['new_value']}", end="", flush=True)
+
+        # Step the environment using the proper client
+        from dataclean_env.models import DataCleanAction
+        action = DataCleanAction(**action_dict)
         result = env_client.step(action)
         obs = result.observation
         step_count = step
+
         print(f"  -> reward={result.reward:.4f} done={result.done}", flush=True)
 
         # Structured output: STEP marker (required by validator)
@@ -247,11 +239,12 @@ def run_task(
     # If agent never submitted, force submit
     if not result.done:
         step_count += 1
-        result = env_client.step({"action_type": "submit"})
+        from dataclean_env.models import DataCleanAction
+        result = env_client.step(DataCleanAction(action_type="submit"))
         print(f"[STEP] step={step_count} reward={result.reward:.4f}", flush=True)
 
     final_score = result.reward
-    print(f"\n  FINAL SCORE ({task_name}): {final_score:.4f}", flush=True)
+    print(f"  FINAL SCORE ({task_name}): {final_score:.4f}", flush=True)
 
     # Structured output: END marker (required by validator)
     print(f"[END] task={task_name} score={final_score:.4f} steps={step_count}", flush=True)
@@ -266,17 +259,13 @@ def main() -> None:
     if not API_KEY:
         print("ERROR: HF_TOKEN or API_KEY environment variable not set", flush=True)
         sys.exit(1)
-    if not MODEL_NAME:
-        print("ERROR: MODEL_NAME environment variable not set", flush=True)
-        sys.exit(1)
 
-    print("DataClean Environment — Baseline Inference", flush=True)
+    print("DataClean Environment - Inference", flush=True)
     print(f"  API: {API_BASE_URL}", flush=True)
     print(f"  Model: {MODEL_NAME}", flush=True)
-    print(f"  Env: {ENV_BASE_URL}", flush=True)
 
     llm_client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-    env_client = _SimpleClient(ENV_BASE_URL)
+    env_client = _connect_env()
 
     scores = {}
     try: