| """Per-run metadata for the replay export: model family, invalid-run flags, and the size budget of runs.json. |
| |
| Model family groups the leaderboard: the agent harness by name ("my-agent" -> "My Agent"), except that |
| open-weight models form their own group whatever harness ran them, and scripted policies are "reference". |
| |
| A run is flagged `invalid` (and left out of every leaderboard) when the result says nothing about the model: |
| the provider or the sandbox failed (rate limits, API or network errors, environment or verifier timeouts), the |
| grader crashed, the run's prompt is not the task's current instruction, or the owner listed it in an |
| `--invalid` file. A run that ended on the model's own account (agent timeout, context window, a refusal) stays |
| valid and carries the exception name in `exception`. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| import os |
| import re |
| from pathlib import Path |
|
|
| OPEN_WEIGHTS = re.compile(r"gpt-oss|llama|qwen|deepseek|mistral|mixtral|gemma|glm-|kimi|olmo|nemotron|phi-\d", re.I) |
| INFRA = re.compile(r"RateLimit|UsageLimit|InternalServer|Overloaded|ConnectionClosed|ResponseStalled|UnknownApi|" |
| r"ResourceNotFound|Authentication|ModelNotFound|NetworkConnection|APIConnection|APIError|" |
| r"ServiceUnavailable|SetupTimeout|EnvironmentStart|VerifierTimeout|BuildFailed|Healthcheck|" |
| r"^Timeout$") |
|
|
|
|
| def model_family(agent: str, model: str, source: str) -> str: |
| name = agent.split(": ", 1)[-1] |
| if source != "harbor" or not model or name.startswith(("oracle", "nop")): |
| return "reference" |
| if OPEN_WEIGHTS.search(model): |
| return "open weights" |
| return " ".join(w.capitalize() for w in re.split(r"[-_ ]+", name) if w) or "other" |
|
|
|
|
| def load_invalid(path: str | None) -> list[tuple[str, str]]: |
| """`--invalid` file: one `<substring of the trial path> <reason>` per line, # comments.""" |
| out = [] |
| if path: |
| with open(path) as fh: |
| for line in fh: |
| line = line.split("#", 1)[0].strip() |
| if line: |
| pat, _, reason = line.partition(" ") |
| out.append((pat, reason.strip() or "listed as invalid by the owner")) |
| return out |
|
|
|
|
| def harbor_flags(trial: str, res: dict, listed: list[tuple[str, str]]) -> dict: |
| """{'invalid': reason} and/or {'exception': type} for one Harbor trial (empty when the run is clean).""" |
| out: dict[str, str] = {} |
| exc = (res.get("exception_info") or {}).get("exception_type") |
| if exc: |
| out["exception"] = exc |
| if INFRA.search(exc): |
| out["invalid"] = f"infrastructure error during the run ({exc})" |
| if os.path.isfile(os.path.join(trial, "verifier", "grader_error.json")): |
| out["invalid"] = "the grader crashed on this run" |
| log = os.path.join(trial, "verifier", "checksum.log") |
| if os.path.isfile(log) and os.path.getsize(log) > 0: |
| out["invalid"] = "the verifier's checksum check failed (broken task image)" |
| for pat, reason in listed: |
| if pat in trial: |
| out["invalid"] = reason |
| return out |
|
|
|
|
| def public(run: dict) -> dict: |
| return {k: v for k, v in run.items() if not k.startswith("_")} |
|
|
|
|
| def input_mismatch(task_dir: str, workspace: str, trajectory: str) -> str | None: |
| """Regrading an output cannot repair different inputs seen by the solver. |
| |
| Compare the saved instruction and evidence/policy files that tasks do not ask |
| solvers to edit. Runbooks are mutable task outputs and cannot establish input |
| provenance from the final workspace. A mismatch is excluded from calibration. |
| """ |
| from replay_atif import call_ops, iter_events, load_trajectory |
| from replay_expert import instruction_seen, strip_comments |
| task = Path(task_dir) |
| if not os.path.isfile(trajectory): |
| return "the task instruction cannot be verified: trajectory missing" |
| traj = load_trajectory(trajectory) |
| if instruction_seen(traj, strip_comments((task / "instruction.md").read_text())) is not True: |
| return "the saved instruction differs or cannot be verified; re-run the current task" |
| base = task / "environment" / "workspace" / "monitoring" |
| for path in sorted(base.rglob("*")): |
| if not path.is_file(): |
| continue |
| rel = path.relative_to(base) |
| if str(rel) != "README.md" and rel.parts[0] not in ("docs", "incidents", "slo", "teams", "bin"): |
| continue |
| saved = Path(workspace) / rel |
| if saved.is_file() and saved.read_bytes() != path.read_bytes(): |
| |
| |
| |
| text = path.read_text() |
| edited = False |
| for event in iter_events(traj): |
| if event[0] != "call": |
| continue |
| ops, _ = call_ops(event[2], event[3]) |
| for op in ops: |
| if op[0] == "replace" and op[1] == str(rel) and op[2] and op[2] in text: |
| text = text.replace(op[2], op[3]) if op[4] else text.replace(op[2], op[3], 1) |
| edited = True |
| if edited and text == saved.read_text(): |
| continue |
| if not saved.is_file() or saved.read_bytes() != path.read_bytes(): |
| return f"task evidence differs from the saved workspace ({rel}); re-run the current task" |
| return None |
|
|
|
|
| def fit(data: dict, runs: list[dict], budget: float, render, levels: int) -> int: |
| """Shorten the texts of `runs` (largest first, one level at a time) until runs.json fits `budget` bytes.""" |
| def size() -> int: |
| return len(json.dumps({**data, "runs": [public(r) for r in data["runs"]]}, separators=(",", ":"))) |
|
|
| level = {id(r): 0 for r in runs} |
| total = size() |
| while total > budget: |
| cands = sorted((r for r in runs if level[id(r)] < levels - 1), |
| key=lambda r: -len(json.dumps(r["steps"], separators=(",", ":")))) |
| if not cands: |
| break |
| for r in cands[:max(1, len(cands) // 4)]: |
| level[id(r)] += 1 |
| render(r, level[id(r)]) |
| total = size() |
| return total |
|
|
