"""Play Qwen3.8-27B (thinking off) on the proxy tasks with arena-style prompts. Each episode is scored twice from one conversation: - strict: the arena's rule. A reply that is not exactly one JSON object, or an action that fails the task's schema, ends the episode and the task scores its finish_action. - lenient: the conversation continues (first JSON object in the reply is used; schema errors are reported back to the model), to show what the model would reach without format failures. Usage: HF_TOKEN_PATH=... .venv/bin/python -m proxy_eval.run --samples 2 --out reports/proxy/run1 """ import argparse import copy import json import sys import time from concurrent.futures import ThreadPoolExecutor from pathlib import Path from statistics import mean from pydantic import ValidationError sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts")) from calibrate import Model, first_json_object, system_prompt # noqa: E402 from .tasks import FAMILIES # noqa: E402 def classify(reply: str): s = reply.strip() if not s: return None, "empty" try: obj = json.loads(s) return (obj, None) if isinstance(obj, dict) else (None, "not_object") except json.JSONDecodeError: pass if s.startswith("```"): return None, "code_fence" if first_json_object(s) is not None: return None, "json_plus_text" return None, "no_json" def unwrap(action): if isinstance(action, dict) and set(action) == {"action"} and isinstance(action["action"], dict): return action["action"] return action def finish_score(task): """Reward the arena would record if the episode were ended now through finish_action.""" if task.done: return None try: clone = copy.deepcopy(task) except TypeError: # tasks holding a database connection score 0 on an empty finish return 0.0 return clone.step(clone.Action.model_validate(task.finish_action)).reward def play(task, model, completion_budget, context_budget, system_extra=""): schema = task.Action.model_json_schema() messages = [{"role": "system", "content": system_prompt(schema) + system_extra}] obs = task.reset() ep = {"task_id": task.task_id, "family": task.family, "domain": task.domain, "turns": [], "strict": None, "lenient": None, "strict_end": None, "lenient_end": None, "schema_errors": 0} completion_used = 0 first = True def strict_fail(kind): if ep["strict"] is None: ep["strict"], ep["strict_end"] = finish_score(task) or 0.0, kind while True: obs_text = json.dumps(obs) messages.append({"role": "user", "content": obs_text}) if not first: completion_used += len(obs_text) // 3 first = False if completion_used >= completion_budget or sum(len(m["content"]) for m in messages) // 3 >= context_budget: strict_fail("budget") ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, "budget" break reply, used, finish_reason = model.chat(messages) completion_used += used messages.append({"role": "assistant", "content": reply}) ep["turns"].append({"obs": obs_text[:1500], "reply": reply[:1500], "tokens": used}) if finish_reason == "length": strict_fail("truncated") ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, "truncated" break strict_obj, kind = classify(reply) if kind: strict_fail(kind) action = unwrap(strict_obj if strict_obj is not None else first_json_object(reply)) if action is None: ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, kind break if action.get("finish") is True: score = finish_score(task) or 0.0 strict_fail("finish") ep["lenient"], ep["lenient_end"] = score, "finish" break try: parsed = task.Action.model_validate(action) except ValidationError as exc: ep["schema_errors"] += 1 strict_fail("schema_invalid") errors = "; ".join(f"{'.'.join(map(str, e['loc']))}: {e['msg']}" for e in exc.errors()[:3]) obs = {"error": f"Invalid action: {errors}"} if task.steps + ep["schema_errors"] > task.max_steps + 3: ep["lenient"], ep["lenient_end"] = finish_score(task) or 0.0, "schema_invalid" break continue step = task.step(parsed) obs = step.observation if step.done: if ep["strict"] is None: ep["strict"], ep["strict_end"] = step.reward, "done" ep["lenient"], ep["lenient_end"] = step.reward, "done" break ep["n_turns"] = len(ep["turns"]) return ep def main(): parser = argparse.ArgumentParser() parser.add_argument("--model", default="Qwen/Qwen3.8-27B:deepinfra") parser.add_argument("--families", default="", help="comma-separated family prefixes (default: all)") parser.add_argument("--seeds", default="0-4") parser.add_argument("--samples", type=int, default=2) parser.add_argument("--workers", type=int, default=8) parser.add_argument("--temperature", type=float, default=1.0) parser.add_argument("--max-tokens", type=int, default=2048) parser.add_argument("--completion-budget", type=int, default=8192) parser.add_argument("--context-budget", type=int, default=16384) parser.add_argument("--thinking", action="store_true", help="enable the model's thinking mode") parser.add_argument("--system-extra", default="", help="file whose text is appended to the system prompt " "(to imitate a model that has learned a habit)") parser.add_argument("--out", required=True) args = parser.parse_args() extra = "\n\n" + Path(args.system_extra).read_text().strip() if args.system_extra else "" lo, hi = map(int, args.seeds.split("-")) fams = [f for f in FAMILIES if not args.families or any(f.startswith(p) for p in args.families.split(","))] jobs = [(f, s) for f in fams for s in range(lo, hi + 1) for _ in range(args.samples)] model = Model(args.model, args.max_tokens, args.temperature, args.thinking) out = Path(args.out) out.mkdir(parents=True, exist_ok=True) started, results = time.monotonic(), [] def run(job): fam, seed = job return play(FAMILIES[fam](seed), model, args.completion_budget, args.context_budget, extra) with ThreadPoolExecutor(args.workers) as pool, open(out / "episodes.jsonl", "w") as log: for fut in [pool.submit(run, j) for j in jobs]: try: ep = fut.result() except Exception as exc: # infrastructure errors are excluded, not scored print("episode error:", repr(exc)[:300], file=sys.stderr) continue results.append(ep) log.write(json.dumps(ep) + "\n") log.flush() summary = {} for fam in fams: eps = [e for e in results if e["family"] == fam] if not eps: continue ends = {} for e in eps: ends[e["strict_end"]] = ends.get(e["strict_end"], 0) + 1 summary[fam] = {"n": len(eps), "strict": round(mean(e["strict"] for e in eps), 3), "lenient": round(mean(e["lenient"] for e in eps), 3), "strict_ends": ends, "turns": round(mean(e["n_turns"] for e in eps), 1)} report = {"model": args.model, "system_extra": args.system_extra, "temperature": args.temperature, "thinking": args.thinking, "episodes": len(results), "seconds": round(time.monotonic() - started), "usage": model.usage, "families": summary, "overall": {"strict": round(mean(e["strict"] for e in results), 3), "lenient": round(mean(e["lenient"] for e in results), 3)}} (out / "summary.json").write_text(json.dumps(report, indent=2) + "\n") print(f"{'family':24s} {'n':>3s} {'strict':>6s} {'lenient':>7s} strict ends") for fam, s in summary.items(): print(f"{fam:24s} {s['n']:3d} {s['strict']:6.2f} {s['lenient']:7.2f} {s['strict_ends']}") print("overall", report["overall"], "usage", model.usage, "seconds", report["seconds"]) if __name__ == "__main__": main()