run.py

#!/usr/bin/env python3
"""
OOLONG-synth runner: cheap model wrapped in an RLM vs. an expensive model read
straight through.

    # cheap model, recursive
    python run.py --mode rlm      --model haiku            --context-len 131072 -n 32
    # expensive baselines
    python run.py --mode baseline --model sonnet           --context-len 131072 -n 32
    python run.py --mode baseline --model 'opus[1m]'       --context-len 262144 -n 32

Results append to results/<tag>.jsonl and are resumable: rerunning skips ids
already recorded, provided the run identity (mode/model/context_len) matches.
"""

from __future__ import annotations

import argparse
import json
import os
import sys
import time
import traceback
from concurrent.futures import ProcessPoolExecutor, as_completed
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent / "bench"))

import oolong  # noqa: E402
from rlm_haiku.rlm_repl import RLM_REPL  # noqa: E402
from rlm_haiku.utils.llm import ClaudeCodeClient, QuotaExhausted, Usage  # noqa: E402

RESULTS = Path(__file__).resolve().parent / "results"

MODELS = {
    "haiku": "claude-haiku-4-5-20251001",
    "sonnet": "claude-sonnet-4-6",
    "sonnet[1m]": "claude-sonnet-4-6[1m]",
    "opus": "claude-opus-4-8",
    "opus[1m]": "claude-opus-4-8[1m]",
}


def run_baseline(row: dict, model: str, sub_model: str, max_iters: int, require_repl: bool = False) -> tuple[str, dict]:
    """Official OOLONG protocol: context + question in one shot, no tools."""
    usage = Usage()
    client = ClaudeCodeClient(model=model, usage=usage)
    answer = client.completion([
        {"role": "system", "content": oolong.SYSTEM_PREFIX},
        {"role": "user", "content": row["context_window_text"] + "\n" + row["question"]},
    ])
    return answer, usage.as_dict()


def run_rlm(row: dict, model: str, sub_model: str, max_iters: int, terse: bool = False,
            require_repl: bool = False) -> tuple[str, dict]:
    usage = Usage()
    rlm = RLM_REPL(
        model=model,
        recursive_model=sub_model,
        max_iterations=max_iters,
        usage=usage,
        terse=terse,
        require_repl=require_repl,
    )
    answer = rlm.completion(context=row["context_window_text"], query=row["question"])
    return answer, usage.as_dict()


def run_rlm_terse(row: dict, model: str, sub_model: str, max_iters: int, require_repl: bool = False) -> tuple[str, dict]:
    return run_rlm(row, model, sub_model, max_iters, terse=True, require_repl=require_repl)


RUNNERS = {"baseline": run_baseline, "rlm": run_rlm, "rlm-terse": run_rlm_terse}


def work(args) -> dict:
    """One example, in its own process (the REPL redirects the global stdout)."""
    row, mode, model, sub_model, max_iters, require_repl = args
    started = time.time()
    try:
        answer, usage = RUNNERS[mode](row, model, sub_model, max_iters, require_repl)
        error, quota = None, False
    except QuotaExhausted as e:
        answer, usage, error, quota = "", {}, f"QuotaExhausted: {e}", True
    except Exception:
        answer, usage, error, quota = "", {}, traceback.format_exc(limit=4), False

    scored = oolong.score_response(row, oolong.clean_final(answer)) if answer else {
        "score": 0.0, "attempted_parse": "ERROR", "parse_confidence": "ERROR",
        "gold": row["answer"],
    }
    return {
        "id": int(row["id"]),
        "dataset": row["dataset"],
        "task": row["task"],
        "answer_type": row["answer_type"],
        "question": row["question"],
        **scored,
        "full_answer": answer,
        "error": error,
        "quota": quota,
        "usage": usage,
        "seconds": round(time.time() - started, 1),
    }


def main() -> None:
    p = argparse.ArgumentParser()
    p.add_argument("--mode", choices=RUNNERS, required=True)
    p.add_argument("--model", default="haiku", help="root model (alias or full id)")
    p.add_argument("--sub-model", default=None, help="recursive model; defaults to --model")
    p.add_argument("--context-len", type=int, default=131072)
    p.add_argument("-n", type=int, default=32, help="examples (stratified across the 8 sources)")
    p.add_argument("--seed", type=int, default=0)
    p.add_argument("--workers", type=int, default=4, help="examples in flight")
    p.add_argument("--max-iters", type=int, default=12, help="root LM turns per RLM query")
    p.add_argument("--require-repl", action="store_true", help="reject final answers before any REPL execution")
    p.add_argument("--tag", default=None)
    args = p.parse_args()

    model = MODELS.get(args.model, args.model)
    sub_model = MODELS.get(args.sub_model or args.model, args.sub_model or args.model)
    tag = args.tag or f"{args.mode}_{args.model.replace('[1m]', '1m')}_{args.context_len}"

    df = oolong.load(args.context_len, n=args.n, seed=args.seed)
    rows = df.to_dict("records")

    RESULTS.mkdir(exist_ok=True)
    out = RESULTS / f"{tag}.jsonl"
    meta = {"mode": args.mode, "model": model, "sub_model": sub_model,
            "context_len": args.context_len, "seed": args.seed,
            "require_repl": args.require_repl}
    meta_path = RESULTS / f"{tag}.meta.json"

    # Resume only if this is genuinely the same run; mixing configs fabricates a
    # number no single run ever produced.
    done, total_score, spent = {}, 0.0, 0.0
    if out.exists() and meta_path.exists() and json.loads(meta_path.read_text()) == meta:
        for line in out.read_text().splitlines():
            if line.strip():
                r = json.loads(line)
                done[r["id"]] = r
                total_score += r["score"]
                spent += r.get("usage", {}).get("cost_usd", 0.0)
    elif out.exists():
        sys.exit(f"{out} exists with different settings; delete it or pass --tag")
    meta_path.write_text(json.dumps(meta, indent=2))

    todo = [r for r in rows if int(r["id"]) not in done]
    n_total = len(rows)
    print(f"[{tag}] {model} | {len(todo)} to run, {len(done)} cached, {n_total} total", flush=True)
    if not todo:
        print(f"[{tag}] already complete", flush=True)

    errors, started, n_done, quota_hit = 0, time.time(), len(done), False
    payloads = [(r, args.mode, model, sub_model, args.max_iters, args.require_repl) for r in todo]

    with ProcessPoolExecutor(max_workers=args.workers) as pool, out.open("a") as fh:
        futures = [pool.submit(work, pl) for pl in payloads]
        for fut in as_completed(futures):
            res = fut.result()
            if res["quota"]:
                # Quota is not a wrong answer. Bank nothing, stop everything, and
                # let the operator resume once the window resets.
                quota_hit = True
                for f in futures:
                    f.cancel()
                break
            if res["error"]:
                # Leave failed rows out of the journal so a resume retries them
                # instead of banking a zero that no model actually produced.
                errors += 1
                print(f"[{tag}] ERROR (not journalled): {res['error'].splitlines()[-1][:160]}", flush=True)
                continue

            fh.write(json.dumps(res) + "\n")
            fh.flush()
            os.fsync(fh.fileno())

            n_done += 1
            total_score += res["score"]
            spent += res.get("usage", {}).get("cost_usd", 0.0)
            rate = (time.time() - started) / max(1, n_done - len(done))
            eta = rate * (n_total - n_done) / 60
            print(
                f"[{tag}] errors={errors} {n_done}/{n_total} "
                f"score={total_score / n_done:.3f} ${spent:.2f} eta={eta:.1f}m",
                flush=True,
            )

    if quota_hit:
        print(f"[{tag}] ABORTED: subscription quota exhausted. "
              f"{n_done}/{n_total} banked; rerun the same command after the reset "
              f"to resume.", flush=True)
    if errors:
        print(f"[{tag}] WARNING: {errors} example(s) failed and were NOT scored", flush=True)
    print(
        f"[{tag}] FINAL score={total_score / max(1, n_done):.4f} over {n_done} "
        f"| cost=${spent:.2f} | {(time.time() - started) / 60:.1f}m",
        flush=True,
    )


if __name__ == "__main__":
    main()