Bulletproof _safe_score for all bad inputs (None, NaN, strings, bool)

log_step and log_end now route every reward/score through _safe_score
which handles: None, NaN, inf, empty string, non-numeric string, bool,
negative, >1. All map to the closed range [0.05, 0.95] — strictly in (0, 1).

Also added catch-alls in run_episode and main() so if the env or LLM
client crashes at any point, every task still emits a valid
[START]/[STEP]/[END] block with score in (0, 1).

inference.py

@@ -82,25 +82,58 @@ SYSTEM_PROMPT = textwrap.dedent("""
 
 # ── Logging ───────────────────────────────────────────────────────────────────
 
+# Hard bounds: every score/reward we ever emit is clamped to this closed range.
+# 0.05 margin guarantees that :.2f and :.3f formatting never produces
+# "0.00", "0.000", "1.00", or "1.000" (all of which parse as exactly 0.0 / 1.0).
+_MIN_SCORE = 0.05
+_MAX_SCORE = 0.95
+
+
+def _safe_score(x) -> float:
+    """Coerce anything (None, NaN, str, bool, int, float) to a float strictly in (0, 1)."""
+    try:
+        if x is None:
+            return _MIN_SCORE
+        if isinstance(x, bool):
+            return _MAX_SCORE if x else _MIN_SCORE
+        v = float(x)
+        if v != v:  # NaN
+            return _MIN_SCORE
+        if v == float("inf"):
+            return _MAX_SCORE
+        if v == float("-inf"):
+            return _MIN_SCORE
+    except (TypeError, ValueError):
+        return _MIN_SCORE
+    return max(_MIN_SCORE, min(_MAX_SCORE, v))
+
+
 def log_start(task: str, model: str) -> None:
     print(f"[START] task={task} env={BENCHMARK} model={model}", flush=True)
 
 
-def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str]) -> None:
-    error_val = error.replace("\n", " ").strip() if error else "null"
-    done_val = str(done).lower()
+def log_step(step: int, action: str, reward, done: bool, error: Optional[str]) -> None:
+    r = _safe_score(reward)
+    error_val = (error or "null")
+    if hasattr(error_val, "replace"):
+        error_val = error_val.replace("\n", " ").strip() or "null"
+    done_val = str(bool(done)).lower()
     print(
-        f"[STEP] step={step} action={action} reward={reward:.2f} "
+        f"[STEP] step={int(step)} action={action or 'noop'} reward={r:.2f} "
         f"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)
+def log_end(success: bool, steps: int, score, rewards: List) -> None:
+    s = _safe_score(score)
+    safe_rewards = [_safe_score(r) for r in (rewards or [])]
+    if not safe_rewards:
+        safe_rewards = [_MIN_SCORE]
+    rewards_str = ",".join(f"{r:.2f}" for r in safe_rewards)
     print(
-        f"[END] success={str(success).lower()} steps={steps} "
-        f"score={score:.3f} rewards={rewards_str}",
+        f"[END] success={str(bool(success)).lower()} steps={int(steps)} "
+        f"score={s:.3f} rewards={rewards_str}",
         flush=True,
     )
 
@@ -152,16 +185,6 @@ def pick_action(
 
 # ── Single-episode runner ─────────────────────────────────────────────────────
 
-_SCORE_EPS = 0.05  # strict (0, 1) with generous margin for :.2f/:.3f rounding
-
-
-def _clamp_score(x: float) -> float:
-    """Clamp to strictly (0, 1). Uses 0.05 margin so :.2f/:.3f formatting stays safe."""
-    if x != x:  # NaN
-        return 0.5
-    return max(_SCORE_EPS, min(1.0 - _SCORE_EPS, x))
-
-
 async def run_episode(
     env: SQLAgentEnv,
     client: OpenAI,
@@ -172,7 +195,7 @@ async def run_episode(
 
     rewards: List[float] = []
     steps_taken = 0
-    score = _SCORE_EPS
+    score = _MIN_SCORE
     success = False
     last_error: Optional[str] = None
 
@@ -180,28 +203,30 @@ async def run_episode(
         try:
             obs = env.reset(task_id)
         except Exception as exc:
-            log_step(step=1, action="reset", reward=_SCORE_EPS, done=True, error=str(exc))
-            rewards.append(_SCORE_EPS)
+            log_step(step=1, action="reset", reward=_MIN_SCORE, done=True, error=str(exc))
+            rewards.append(_MIN_SCORE)
             steps_taken = 1
             return
 
         for step in range(1, MAX_STEPS + 1):
-            action_name = pick_action(client, obs, step)
+            try:
+                action_name = pick_action(client, obs, step)
+            except Exception:
+                action_name = "generate"
             action = Action(repair_action=action_name)
 
             try:
                 obs, reward_info = await env.step(action)
             except Exception as exc:
-                log_step(step=step, action=action_name, reward=_SCORE_EPS, done=True, error=str(exc))
-                rewards.append(_SCORE_EPS)
+                log_step(step=step, action=action_name, reward=_MIN_SCORE, done=True, error=str(exc))
+                rewards.append(_MIN_SCORE)
                 steps_taken = step
                 break
 
-            raw_reward = reward_info.value if reward_info.value is not None else _SCORE_EPS
-            reward = _clamp_score(raw_reward)
-            done = reward_info.done
-            last_error = obs.error_message
-            success = reward_info.success
+            reward = _safe_score(getattr(reward_info, "value", None))
+            done = bool(getattr(reward_info, "done", False))
+            last_error = getattr(obs, "error_message", None)
+            success = bool(getattr(reward_info, "success", False))
 
             rewards.append(reward)
             steps_taken = step
@@ -218,16 +243,19 @@ async def run_episode(
                 break
 
         denom = max(len(rewards), 1)
-        avg = sum(rewards) / denom if rewards else _SCORE_EPS
-        score = _clamp_score(avg)
+        avg = sum(rewards) / denom if rewards else _MIN_SCORE
+        score = _safe_score(avg)
 
+    except Exception as exc:
+        # Catch-all so we always emit a valid [END] line
+        log_step(step=steps_taken or 1, action="error", reward=_MIN_SCORE, done=True, error=str(exc))
+        if not rewards:
+            rewards.append(_MIN_SCORE)
+        score = _MIN_SCORE
     finally:
-        # Final safety net: score and every reward must be strictly in (0, 1)
-        score = _clamp_score(score)
-        rewards = [_clamp_score(r) for r in rewards]
         log_end(
             success=success,
-            steps=steps_taken,
+            steps=max(int(steps_taken), 1),
             score=score,
             rewards=rewards,
         )
@@ -236,12 +264,25 @@ async def run_episode(
 # ── Main ──────────────────────────────────────────────────────────────────────
 
 async def main() -> None:
-    client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
-    env = SQLAgentEnv()
+    try:
+        client = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
+        env = SQLAgentEnv()
+    except Exception as exc:
+        # Environment couldn't init — still emit a valid [START]/[STEP]/[END] per task
+        for task_id in TASKS:
+            log_start(task=task_id, model=MODEL_NAME)
+            log_step(step=1, action="init_error", reward=_MIN_SCORE, done=True, error=str(exc))
+            log_end(success=False, steps=1, score=_MIN_SCORE, rewards=[_MIN_SCORE])
+            print("", flush=True)
+        return
 
     for task_id in TASKS:
-        await run_episode(env, client, task_id)
-        # Small gap between tasks for readability
+        try:
+            await run_episode(env, client, task_id)
+        except Exception as exc:
+            # run_episode already has its own catch-all, but guard against anything leaking
+            log_end(success=False, steps=1, score=_MIN_SCORE, rewards=[_MIN_SCORE])
+            print(f"[DEBUG] run_episode({task_id}) crashed: {exc}", flush=True)
         print("", flush=True)