| """Readable narratives: what a run actually did, in order, on one page. |
| |
| The numeric features say how much; this says what. Each narrative keeps only |
| the load-bearing moments -- the plan it wrote down, every training and |
| evaluation job, every error and the move that followed it, and the summary it |
| signed off with -- so a run that took ten hours and 180 tool calls can be read |
| in a minute and compared against another. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| import os |
| import re |
| import textwrap |
|
|
| from .parse import Run, ToolCall |
| from .taxonomy import classify_action |
|
|
| MILESTONE_ACTIONS = {"train", "generate", "eval_official", "eval_custom", "data_prep"} |
| SCORE_RES = [ |
| re.compile(r"(?<![\w_])accuracy\s{2,}([01]?\.\d+)"), |
| re.compile(r"(?<![\w_])[\"']accuracy[\"']\s*:\s*([01]?\.\d+)"), |
| ] |
|
|
|
|
| def _hhmm(t: float) -> str: |
| return f"{int(t // 3600):d}:{int(t % 3600) // 60:02d}" |
|
|
|
|
| def _one_line(s: str, n: int = 150) -> str: |
| s = re.sub(r"\s+", " ", (s or "").strip()) |
| return s[:n] + ("…" if len(s) > n else "") |
|
|
|
|
| def _scores_in(text: str) -> list[str]: |
| return [m for pat in SCORE_RES for m in pat.findall(text or "")] |
|
|
|
|
| def _error_kind(tc: ToolCall) -> str | None: |
| """Name the failure in a tool result, if there is one. |
| |
| `is_error` alone is too narrow: a training script that dies with a |
| traceback still exits through a normal tool result, and that is exactly |
| the kind of failure we want to watch the agent recover from. |
| """ |
| t = tc.result_text or "" |
| if "CUDA out of memory" in t or "OutOfMemoryError" in t: |
| return "CUDA OOM" |
| if re.search(r"^Traceback \(most recent call last\)", t, re.M): |
| last = [ln for ln in t.strip().splitlines() if ln.strip()][-1:] |
| return f"exception: {_one_line(last[0], 90)}" if last else "exception" |
| if "ModuleNotFoundError" in t or "ImportError" in t: |
| return "missing package" |
| if "EAI_AGAIN" in t or "Temporary failure in name resolution" in t: |
| return "network blocked (offline sandbox)" |
| if "No space left on device" in t: |
| return "disk full" |
| if tc.is_error: |
| return f"tool error: {_one_line(t, 90)}" |
| return None |
|
|
|
|
| def narrative(run: Run) -> str: |
| out: list[str] = [] |
| out.append(f"# {run.run_id}") |
| out.append("") |
| out.append(f"- task: **{run.task}**, base model: **{run.base_model}**") |
| out.append(f"- harness accuracy: **{run.accuracy}**") |
| out.append(f"- wall clock: {_hhmm(run.wall_s)}, tool calls: {len(run.tool_calls)}") |
| if run.result: |
| out.append( |
| f"- terminal: {run.result.get('terminal_reason')} " |
| f"(api_error={run.result.get('api_error_status')}), " |
| f"cost ${run.result.get('total_cost_usd', 0):.2f}" |
| ) |
| out.append("") |
|
|
| |
| todos = [tc for tc in run.tool_calls if tc.name in ("TaskCreate", "TaskUpdate")] |
| if todos: |
| out.append("## Plan as first written") |
| seen = 0 |
| for tc in todos: |
| desc = tc.inp.get("description") or tc.inp.get("prompt") or json.dumps(tc.inp)[:200] |
| out.append(f"- {_one_line(desc, 120)}") |
| seen += 1 |
| if seen >= 12: |
| break |
| out.append("") |
|
|
| first_text = next( |
| ( |
| c.get("text", "") |
| for ev in run.events |
| if ev.kind == "assistant" |
| for c in (ev.raw.get("message", {}).get("content") or []) |
| if isinstance(c, dict) and c.get("type") == "text" and len(c.get("text", "")) > 80 |
| ), |
| "", |
| ) |
| if first_text: |
| out.append("## First stated intent") |
| out.append(textwrap.indent(_one_line(first_text, 700), "> ")) |
| out.append("") |
|
|
| out.append("## Milestones") |
| out.append("") |
| out.append("| t | action | what | scores seen |") |
| out.append("|---|---|---|---|") |
| for tc in run.tool_calls: |
| act = classify_action(tc) |
| if act not in MILESTONE_ACTIONS: |
| continue |
| payload = tc.command or tc.inp.get("file_path", "") |
| scores = _scores_in(tc.result_text) |
| out.append( |
| f"| {_hhmm(tc.t_rel)} | {act} | `{_one_line(payload, 110)}` | " |
| f"{', '.join(scores[:4]) if scores else ''} |" |
| ) |
| out.append("") |
|
|
| out.append("## Failures and what happened next") |
| out.append("") |
| n = 0 |
| for i, tc in enumerate(run.tool_calls): |
| kind = _error_kind(tc) |
| if not kind: |
| continue |
| n += 1 |
| nxt = run.tool_calls[i + 1] if i + 1 < len(run.tool_calls) else None |
| follow = _one_line(nxt.text_payload, 140) if nxt else "(end of run)" |
| out.append(f"- **{_hhmm(tc.t_rel)} {kind}**") |
| out.append(f" - was running: `{_one_line(tc.text_payload, 120)}`") |
| out.append(f" - next move: `{follow}`") |
| if n >= 25: |
| out.append(f"- … and more (showing first 25)") |
| break |
| if n == 0: |
| out.append("_none detected_") |
| out.append("") |
|
|
| if run.final_message: |
| out.append("## Final summary the agent wrote") |
| out.append("") |
| out.append(run.final_message) |
| out.append("") |
| return "\n".join(out) |
|
|
|
|
| def write_all(runs: list[Run], out_dir: str) -> None: |
| os.makedirs(out_dir, exist_ok=True) |
| for r in runs: |
| with open(os.path.join(out_dir, f"{r.run_id}.md"), "w") as fh: |
| fh.write(narrative(r)) |
| print(f" wrote {len(runs)} narratives to {out_dir}") |
|
|
