Live-smoke fixes: tool-call wire 400, episode resilience, real PNG minimap

Three real bugs caught by the first OpenRouter run (qwen3.6):
1. 400 on turn 2: assistant tool_calls were replayed with
function.arguments as a dict; OpenAI/OpenRouter require a JSON
string. _wire_messages now coerces it (history keeps the dict for
readable playback; pure — input not mutated). Error text widened
200→800 chars for debuggability.
2. A fatal provider error aborted the whole sweep + lost the report.
evaluate now wraps each episode: non-Budget exception ⇒ outcome
'error', journalled, run continues and still finalizes; Budget
still stops intentionally.
3. Minimap was delegated to the training renderer which needs a
terrain_png the bench engine never emits ⇒ 'cannot identify image
file' ⇒ model silently ran TEXT-ONLY. New openra_bench/minimap.py
renders a valid colour PNG from the ASCII fog grid + unit cells (no
external dep); agent uses it.
+ objective wording: {not:{own_units_gte:1}} now reads 'your whole
force is destroyed' instead of a double negative.

tests: test_minimap.py (4, incl PIL re-open + agent attach),
test_resilience.py +2 (wire-args, episode error continues). 30+
touched-module tests green.

openra_bench/agent.py

@@ -378,18 +378,9 @@ def _render_minimap_b64(render_state: dict) -> str | None:
     """Best-effort minimap PNG. Returns None (text-only fallback) when
     terrain isn't resolvable — vision degrades gracefully in Phase 0."""
     try:
-        from openra_rl_training.training.minimap_renderer import render_minimap
-
-        return render_minimap(
-            terrain_png=render_state.get("terrain_png"),  # None in Phase 0 -> None
-            map_width=render_state.get("map_width", 64),
-            map_height=render_state.get("map_height", 64),
-            bounds_x=render_state.get("bounds_x", 0),
-            bounds_y=render_state.get("bounds_y", 0),
-            own_units=render_state.get("units_summary", []) or [],
-            enemy_units=render_state.get("enemy_summary", []) or [],
-            ascii_minimap=render_state.get("minimap", ""),
-        )
+        from .minimap import render_png_b64
+
+        return render_png_b64(render_state)
     except Exception as e:  # noqa: BLE001 — vision is optional
         logger.debug("minimap render skipped: %s", e)
         return None

openra_bench/game_knowledge.py

@@ -196,7 +196,19 @@ def _describe(node: Any, join: str = " AND ") -> str:
     if "any_of" in node:
         return "(" + " OR ".join(_describe(c) for c in node["any_of"]) + ")"
     if "not" in node:
-        return "NOT (" + _describe(node["not"]) + ")"
+        inner = node["not"]
+        inner_d = inner if isinstance(inner, dict) else dict(
+            getattr(inner, "__pydantic_extra__", {}) or {}
+        )
+        # Common fail form {not: {own_units_gte: N}} reads far clearer
+        # as a plain loss statement than a double negative.
+        if set(inner_d) == {"own_units_gte"}:
+            n = inner_d["own_units_gte"]
+            return (
+                "your whole force is destroyed" if int(n) <= 1
+                else f"fewer than {n} of your units remain"
+            )
+        return "NOT (" + _describe(inner) + ")"
     return join.join(_leaf_phrase(k, v) for k, v in node.items())
 
 

openra_bench/minimap.py

@@ -0,0 +1,81 @@
+"""Self-contained minimap PNG (no training-repo / terrain_png dep).
+
+The bench engine emits an ASCII fog grid (`#`=unknown, `.`=explored)
+plus unit/building cell lists — enough to draw a real, legible colour
+minimap the model can actually see. Pure; returns base64 PNG, or None
+if Pillow is missing or there's nothing to draw (graceful text-only
+fallback).
+"""
+
+from __future__ import annotations
+
+import base64
+import io
+import logging
+
+logger = logging.getLogger(__name__)
+
+CELL = 6  # px per map cell (≈768×240 for a 128×40 map — legible)
+
+# (R,G,B)
+_BG_UNKNOWN = (18, 18, 22)      # '#'  fog / never seen
+_BG_EXPLORED = (70, 74, 82)     # '.'  revealed terrain
+_OWN = (60, 200, 90)            # your units
+_OWN_BLD = (60, 130, 230)       # your buildings
+_ENEMY = (225, 60, 55)          # enemy units
+_ENEMY_BLD = (240, 160, 40)     # enemy buildings
+
+
+def _draw_cell(px, w: int, h: int, cx: int, cy: int, rgb, r: int = 1) -> None:
+    for yy in range(max(0, cy - r), min(h, cy + r + 1)):
+        for xx in range(max(0, cx - r), min(w, cx + r + 1)):
+            for sy in range(CELL):
+                for sx in range(CELL):
+                    px[xx * CELL + sx, yy * CELL + sy] = rgb
+
+
+def render_png_b64(render_state: dict) -> str | None:
+    try:
+        from PIL import Image
+    except Exception:  # noqa: BLE001 — vision optional
+        return None
+
+    ascii_mm = render_state.get("minimap") or ""
+    rows = [r for r in ascii_mm.split("\n") if r]
+    if not rows:
+        return None
+    h = len(rows)
+    w = max(len(r) for r in rows)
+    if w == 0 or w * h > 200_000:  # sanity cap
+        return None
+
+    img = Image.new("RGB", (w * CELL, h * CELL), _BG_UNKNOWN)
+    px = img.load()
+    for y, row in enumerate(rows):
+        for x, ch in enumerate(row):
+            if ch != "#":  # explored / visible
+                for sy in range(CELL):
+                    for sx in range(CELL):
+                        px[x * CELL + sx, y * CELL + sy] = _BG_EXPLORED
+
+    def _plot(items, rgb_unit, rgb_bld):
+        for it in items or []:
+            if not isinstance(it, dict):
+                continue
+            cx, cy = int(it.get("cell_x", 0)), int(it.get("cell_y", 0))
+            if 0 <= cx < w and 0 <= cy < h:
+                is_b = bool(it.get("is_building"))
+                _draw_cell(px, w, h, cx, cy, rgb_bld if is_b else rgb_unit,
+                           r=1 if is_b else 0)
+
+    _plot(render_state.get("units_summary"), _OWN, _OWN_BLD)
+    _plot(render_state.get("own_buildings"), _OWN_BLD, _OWN_BLD)
+    _plot(render_state.get("enemy_summary"), _ENEMY, _ENEMY_BLD)
+
+    try:
+        buf = io.BytesIO()
+        img.save(buf, format="PNG")
+        return base64.b64encode(buf.getvalue()).decode("ascii")
+    except Exception as e:  # noqa: BLE001
+        logger.debug("minimap encode failed: %s", e)
+        return None

openra_bench/providers.py

@@ -144,7 +144,7 @@ class OpenAICompatibleProvider(ChatProvider):
             transient = self._policy.is_transient_status(resp.status_code)
             cls = RuntimeError if transient else FatalProviderError
             exc = cls(
-                f"{resp.status_code} from provider: {resp.text[:200]}"
+                f"{resp.status_code} from provider: {resp.text[:800]}"
             )
             exc.transient = transient  # type: ignore[attr-defined]
             exc.retry_after = retry_after  # type: ignore[attr-defined]
@@ -190,11 +190,28 @@ class OpenAICompatibleProvider(ChatProvider):
 
     @staticmethod
     def _wire_messages(messages: list[dict]) -> list[dict]:
-        """Pure: project each message onto OpenAI-legal keys only."""
-        return [
-            {k: v for k, v in m.items() if k in OpenAICompatibleProvider._WIRE_KEYS}
-            for m in messages
-        ]
+        """Pure: project each message onto OpenAI-legal keys only, and
+        coerce `tool_calls[].function.arguments` to a JSON **string**
+        (the wire spec requires a string; history keeps the dict for
+        readable playback). Pure — inputs are not mutated."""
+        out: list[dict] = []
+        for m in messages:
+            wm = {
+                k: v for k, v in m.items()
+                if k in OpenAICompatibleProvider._WIRE_KEYS
+            }
+            tcs = wm.get("tool_calls")
+            if tcs:
+                fixed = []
+                for tc in tcs:
+                    fn = dict(tc.get("function", {}))
+                    args = fn.get("arguments", {})
+                    if not isinstance(args, str):
+                        fn["arguments"] = json.dumps(args)
+                    fixed.append({**tc, "function": fn})
+                wm["tool_calls"] = fixed
+            out.append(wm)
+        return out
 
     @staticmethod
     def _reply_from_data(data: dict) -> ChatReply:

openra_bench/run_eval.py

@@ -295,18 +295,48 @@ def evaluate(
                 pass
 
     try:
+        def _safe_run(task: tuple) -> dict:
+            # One bad episode (fatal provider 400, engine crash, …) must
+            # not abort a multi-hour sweep or lose the report — record
+            # it as outcome="error" and continue. Budget is the only
+            # signal that intentionally stops the whole run.
+            compiled, cell, split, seed = task
+            try:
+                return _run_one(task)
+            except BudgetExceeded:
+                raise
+            except Exception as e:  # noqa: BLE001
+                msg = f"{type(e).__name__}: {e}"
+                return {
+                    "cell": cell,
+                    "capability": compiled.meta.capability,
+                    "split": split,
+                    "seed": seed,
+                    "outcome": "error",
+                    "composite": 0.0,
+                    "perception": 0.0,
+                    "reasoning": 0.0,
+                    "action": 0.0,
+                    "weakest_link": "n/a",
+                    "objective_progress": 0.0,
+                    "reward_vector": {},
+                    "turns": 0,
+                    "notes": [msg[:500]],
+                    "_sc": None,
+                }
+
         if concurrency > 1 and len(tasks) > 1:
             from concurrent.futures import ThreadPoolExecutor
 
             with ThreadPoolExecutor(max_workers=concurrency) as ex:
-                futs = {ex.submit(_run_one, t): t for t in tasks}
+                futs = {ex.submit(_safe_run, t): t for t in tasks}
                 from concurrent.futures import as_completed
 
                 for fu in as_completed(futs):
                     _record(fu.result())
         else:
             for t in tasks:
-                _record(_run_one(t))
+                _record(_safe_run(t))
     except BudgetExceeded as e:
         truncated = True
         skipped.append(f"BUDGET STOP: {e}")

tests/test_minimap.py

@@ -0,0 +1,79 @@
+"""Bench-native minimap PNG: must produce a *valid* image (the live
+smoke caught the old training-repo path emitting bytes PIL couldn't
+open, so the model silently ran text-only)."""
+
+from __future__ import annotations
+
+import base64
+import io
+
+import pytest
+
+from openra_bench.minimap import render_png_b64
+
+PIL = pytest.importorskip("PIL")
+from PIL import Image  # noqa: E402
+
+
+def _grid(w, h, explored_cols=0):
+    return "\n".join(
+        "".join("." if x < explored_cols else "#" for x in range(w))
+        for _ in range(h)
+    )
+
+
+def test_renders_a_valid_png_pil_can_reopen():
+    rs = {
+        "minimap": _grid(128, 40, explored_cols=20),
+        "units_summary": [{"cell_x": 6, "cell_y": 8}],
+        "enemy_summary": [
+            {"cell_x": 34, "cell_y": 22, "is_building": False},
+            {"cell_x": 40, "cell_y": 5, "is_building": True},
+        ],
+    }
+    b64 = render_png_b64(rs)
+    assert isinstance(b64, str) and b64
+    im = Image.open(io.BytesIO(base64.b64decode(b64)))  # must NOT raise
+    im.verify()
+    assert im.format == "PNG"
+    assert im.size == (128 * 6, 40 * 6)
+
+
+def test_unit_and_fog_pixels_are_distinct():
+    rs = {
+        "minimap": _grid(20, 10, explored_cols=0),  # all fog
+        "units_summary": [{"cell_x": 5, "cell_y": 5}],
+    }
+    im = Image.open(
+        io.BytesIO(base64.b64decode(render_png_b64(rs)))
+    ).convert("RGB")
+    own = im.getpixel((5 * 6 + 3, 5 * 6 + 3))      # on the unit
+    fog = im.getpixel((0, 0))                       # fog corner
+    assert own != fog
+    assert own[1] > own[0] and own[1] > own[2]      # green-ish own unit
+
+
+def test_graceful_none_when_nothing_to_draw():
+    assert render_png_b64({"minimap": ""}) is None
+    assert render_png_b64({}) is None
+
+
+def test_agent_attaches_image_when_vision_on():
+    from openra_bench.agent import ModelAgent
+    from openra_bench.providers import ProviderConfig
+
+    a = ModelAgent(ProviderConfig(vision=True), allowed_tools=["observe"],
+                   provider=type("P", (), {"complete": lambda *a, **k: None})())
+    msg = a._user_message({
+        "minimap": _grid(16, 8, 4),
+        "units_summary": [{"id": "1001", "cell_x": 1, "cell_y": 1}],
+        "enemy_summary": [],
+    })
+    assert isinstance(msg["content"], list)
+    kinds = [p["type"] for p in msg["content"]]
+    assert "image_url" in kinds and "text" in kinds
+    url = next(p["image_url"]["url"] for p in msg["content"]
+              if p["type"] == "image_url")
+    assert url.startswith("data:image/png;base64,")
+    # the attached payload is itself a valid PNG
+    Image.open(io.BytesIO(base64.b64decode(url.split(",", 1)[1]))).verify()

tests/test_resilience.py

@@ -166,3 +166,55 @@ def test_evaluate_journal_resume_is_lossless(tmp_path):
     assert b["resumed"] == 2 and b["overall"]["n"] == 2
     assert len(jp.read_text().splitlines()) == 2  # nothing re-appended
     assert "cost" in b and "truncated" in b
+
+
+# ── wire: tool_call arguments must be a JSON string (OpenRouter 400) ────────
+
+
+def test_wire_messages_serializes_tool_call_arguments():
+    from openra_bench.providers import OpenAICompatibleProvider as P
+
+    hist = [
+        {"role": "system", "content": "s"},
+        {"role": "assistant", "content": "", "reasoning": "drop me",
+         "tool_calls": [{"id": "c0", "type": "function",
+                         "function": {"name": "move_units",
+                                      "arguments": {"unit_ids": [1],
+                                                    "target_x": 5}}}]},
+        {"role": "tool", "tool_call_id": "c0", "content": "ok"},
+    ]
+    wire = P._wire_messages(hist)
+    args = wire[1]["tool_calls"][0]["function"]["arguments"]
+    assert isinstance(args, str)            # JSON string, not dict
+    assert json.loads(args) == {"unit_ids": [1], "target_x": 5}
+    assert "reasoning" not in wire[1]       # playback-only key stripped
+    # pure: original history untouched (still a dict for playback)
+    assert isinstance(
+        hist[1]["tool_calls"][0]["function"]["arguments"], dict
+    )
+    # already-string args are left alone
+    hist[1]["tool_calls"][0]["function"]["arguments"] = '{"a":1}'
+    assert P._wire_messages(hist)[1]["tool_calls"][0]["function"][
+        "arguments"
+    ] == '{"a":1}'
+
+
+def test_evaluate_continues_past_a_failing_episode(tmp_path):
+    pytest.importorskip("openra_train")
+    from openra_bench.run_eval import evaluate
+
+    PACK = Path("openra_bench/scenarios/packs/perception-frontier-reading.yaml")
+
+    def boom_factory(_compiled):
+        def agent_fn(_rs, _Command):
+            raise RuntimeError("simulated fatal provider 400")
+        return agent_fn
+
+    out = evaluate([PACK], ["easy"], [1, 2], agent_factory=boom_factory,
+                   journal_path=tmp_path / "j.jsonl")
+    eps = out["episodes"]
+    assert len(eps) == 2
+    assert all(e["outcome"] == "error" for e in eps)   # recorded, not raised
+    assert "overall" in out                            # report still produced
+    # journal captured them so --resume won't re-run the errored ones
+    assert len((tmp_path / "j.jsonl").read_text().splitlines()) == 2