fix server entry point

inference.py

@@ -19,6 +19,7 @@ from typing import List, Optional
 import re
 
 import httpx
+
 try:
     from openai import OpenAI
 except Exception:
@@ -34,6 +35,10 @@ MAX_STEPS = 8
 SUCCESS_SCORE_THRESHOLD = 0.5
 
 
+# ---------------------------------------------------------------------------
+# Logging helpers — must match the spec format exactly
+# ---------------------------------------------------------------------------
+
 def log_start(task: str, env: str, model: str) -> None:
     print(f"[START] task={task} env={env} model={model}", flush=True)
 
@@ -47,6 +52,7 @@ def log_step(
 ) -> None:
     err = error if error else "null"
     done_val = str(done).lower()
+    # Collapse newlines so the entire step fits on one line (spec requirement)
     action_clean = action.replace("\n", " ").replace("\r", "").strip()
     print(
         f"[STEP] step={step} action={action_clean} "
@@ -56,7 +62,7 @@ def log_step(
 
 
 def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> None:
-    rewards_str = ",".join(f"{r:.2f}" for r in rewards)
+    rewards_str = ",".join(f"{r:.2f}" for r in rewards) if rewards else ""
     print(
         f"[END] success={str(success).lower()} steps={steps} "
         f"score={score:.3f} rewards={rewards_str}",
@@ -64,6 +70,10 @@ def log_end(success: bool, steps: int, score: float, rewards: List[float]) -> No
     )
 
 
+# ---------------------------------------------------------------------------
+# LLM / heuristic helpers
+# ---------------------------------------------------------------------------
+
 SYSTEM_PROMPT = textwrap.dedent(
     """
     You are an expert SQL debugger.
@@ -94,14 +104,21 @@ SQL_REPLACEMENTS = {
 
 
 def heuristic_correct_sql(query: str) -> str:
+    """Deterministic fallback when the LLM is unavailable."""
     corrected = query
     for broken, fixed in SQL_REPLACEMENTS.items():
-        corrected = re.sub(rf"\b{re.escape(broken)}\b", fixed, corrected, flags=re.IGNORECASE)
+        corrected = re.sub(
+            rf"\b{re.escape(broken)}\b", fixed, corrected, flags=re.IGNORECASE
+        )
     return corrected.strip()
 
 
-def get_model_action(client: Optional["OpenAI"], obs: dict, history: List[str]) -> str:
-    heuristic = heuristic_correct_sql(obs["broken_query"])
+def get_model_action(
+    client: Optional["OpenAI"], obs: dict, history: List[str]
+) -> str:
+    """Return a corrected SQL string. Falls back to heuristic on any failure."""
+    heuristic = heuristic_correct_sql(obs.get("broken_query", ""))
+
     if client is None:
         return heuristic
 
@@ -109,7 +126,7 @@ def get_model_action(client: Optional["OpenAI"], obs: dict, history: List[str])
     user_prompt = textwrap.dedent(
         f"""
         Broken SQL query:
-        {obs["broken_query"]}
+        {obs.get("broken_query", "")}
 
         Schema context: {obs.get("schema_context") or "Not provided"}
         Error hint: {obs.get("error_hint") or "None"}
@@ -141,93 +158,141 @@ def get_model_action(client: Optional["OpenAI"], obs: dict, history: List[str])
         return heuristic
 
 
+# ---------------------------------------------------------------------------
+# Episode runner
+# ---------------------------------------------------------------------------
+
 async def run_task(task_name: str) -> None:
-    client = None
-    if OpenAI is not None and API_KEY not in {"", "dummy"}:
-        try:
-            client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-        except Exception as exc:
-            print(f"[DEBUG] OpenAI client init failed: {exc}", flush=True)
+    """
+    Run one full episode for `task_name`.
 
+    The [END] log line is ALWAYS emitted via the finally block, even if an
+    exception occurs mid-episode or the reset call fails. This is required
+    by the hackathon spec to avoid disqualification.
+    """
+    # Initialise all accumulators BEFORE the try so finally can always read them
     rewards: List[float] = []
     history: List[str] = []
     steps_taken = 0
     score = 0.0
     success = False
 
+    # Build LLM client (best-effort; None means heuristic-only mode)
+    client = None
+    if OpenAI is not None and API_KEY not in {"", "dummy"}:
+        try:
+            client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+        except Exception as exc:
+            print(f"[DEBUG] OpenAI client init failed: {exc}", flush=True)
+
     log_start(task_name, BENCHMARK, MODEL_NAME)
 
-    http = None
+    http: Optional[httpx.AsyncClient] = None
     try:
         http = httpx.AsyncClient(base_url=ENV_URL, timeout=60.0)
 
+        # --- reset ---------------------------------------------------------
+        reset_failed = False
+        obs: dict = {}
         try:
             reset_resp = await http.post("/reset", json={"difficulty": task_name})
             reset_resp.raise_for_status()
             obs = reset_resp.json()
         except Exception as exc:
             print(f"[DEBUG] Reset failed: {exc}", flush=True)
-            return
-
-        for step in range(1, MAX_STEPS + 1):
-            try:
-                action_str = get_model_action(client, obs, history)
-            except Exception as exc:
-                print(f"[DEBUG] Model failed: {exc}", flush=True)
-                action_str = heuristic_correct_sql(obs["broken_query"])
-
-            try:
-                step_resp = await http.post("/step", json={"corrected_query": action_str})
-                step_resp.raise_for_status()
-                result = step_resp.json()
-            except Exception as exc:
-                print(f"[DEBUG] Step failed: {exc}", flush=True)
-                break
-
-            obs = result["observation"]
-            reward = float(result["reward"])
-            done = bool(result["done"])
-            error = result.get("info", {}).get("error")
-
-            rewards.append(reward)
-            steps_taken = step
-            history.append(f"Step {step}: attempt={action_str!r} reward={reward:+.2f}")
-
-            log_step(step, action_str, reward, done, error)
-
-            if done:
-                break
-
-        score = min(max(sum(rewards) / len(rewards) if rewards else 0.0, 0.0), 1.0)
-        success = score >= SUCCESS_SCORE_THRESHOLD
+            # Do NOT return here — fall through to finally so [END] is always logged
+            reset_failed = True
+
+        if not reset_failed:
+            # --- step loop -------------------------------------------------
+            for step in range(1, MAX_STEPS + 1):
+                # Get action (never raises — heuristic is the ultimate fallback)
+                try:
+                    action_str = get_model_action(client, obs, history)
+                except Exception as exc:
+                    print(f"[DEBUG] Model action failed: {exc}", flush=True)
+                    action_str = heuristic_correct_sql(obs.get("broken_query", ""))
+
+                # Submit action to environment
+                try:
+                    step_resp = await http.post(
+                        "/step", json={"corrected_query": action_str}
+                    )
+                    step_resp.raise_for_status()
+                    result = step_resp.json()
+                except Exception as exc:
+                    print(f"[DEBUG] Step {step} request failed: {exc}", flush=True)
+                    # Treat as a 0-reward terminal step so episode ends cleanly
+                    rewards.append(0.0)
+                    steps_taken = step
+                    log_step(step, action_str, 0.0, True, str(exc))
+                    break
+
+                obs = result.get("observation", obs)
+                reward = float(result.get("reward", 0.0))
+                done = bool(result.get("done", False))
+                info = result.get("info")
+                error = info.get("error") if isinstance(info, dict) else None
+
+                rewards.append(reward)
+                steps_taken = step
+                history.append(
+                    f"Step {step}: attempt={action_str!r} reward={reward:+.2f}"
+                )
+
+                log_step(step, action_str, reward, done, error)
+
+                if done:
+                    break
+
+            # Score = average reward across all steps, clamped to [0, 1]
+            if rewards:
+                score = min(max(sum(rewards) / len(rewards), 0.0), 1.0)
+            success = score >= SUCCESS_SCORE_THRESHOLD
 
     except Exception as exc:
-        print(f"[DEBUG] Episode error: {exc}", flush=True)
+        # Catch-all for any unexpected error in the episode body
+        print(f"[DEBUG] Unhandled episode error: {exc}", flush=True)
 
     finally:
+        # Always close the HTTP client
         if http is not None:
             try:
                 await http.aclose()
             except Exception as exc:
                 print(f"[DEBUG] HTTP close error: {exc}", flush=True)
+        # [END] MUST always be emitted — even after reset failure or exception
         log_end(success, steps_taken, score, rewards)
 
 
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
 async def main() -> None:
+    """
+    Run tasks according to SQL_ENV_TASK.
+    If SQL_ENV_TASK is a single valid difficulty, run only that task.
+    Otherwise run all three in sequence so all 3 tasks produce scores.
+    """
     try:
         difficulties = (
-            (TASK_NAME,) if TASK_NAME in {"easy", "medium", "hard"} else ("easy", "medium", "hard")
+            (TASK_NAME,)
+            if TASK_NAME in {"easy", "medium", "hard"}
+            else ("easy", "medium", "hard")
         )
         for difficulty in difficulties:
             await run_task(difficulty)
-            print("", flush=True)
+            print("", flush=True)  # blank line separator between tasks
     except Exception as exc:
-        print(f"[DEBUG] Main error: {exc}", flush=True)
+        print(f"[DEBUG] Main loop error: {exc}", flush=True)
 
 
 if __name__ == "__main__":
     try:
         asyncio.run(main())
+    except KeyboardInterrupt:
+        pass
     except Exception as exc:
         print(f"[DEBUG] Fatal error: {exc}", flush=True)
     finally:

openenv.yaml

@@ -73,4 +73,5 @@ tasks:
 endpoints:
   reset: POST /reset
   step:  POST /step
-  state: POST /state
+  state: GET /state
+  health: GET /health

server/app.py

@@ -0,0 +1,8 @@
+from server import app
+import uvicorn
+
+def main():
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+
+if __name__ == "__main__":
+    main()