| |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| import shutil |
| import subprocess |
| import time |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| DEFAULT_EVALS = ROOT / "data" / "codex_tool_calling_eval.jsonl" |
| WORK_ROOT = ROOT / "tmp" / "codex-eval" |
|
|
|
|
| def iter_jsonl(path: Path): |
| with path.open() as f: |
| for line in f: |
| if line.strip(): |
| yield json.loads(line) |
|
|
|
|
| def seed_workspace(case: dict[str, Any], workdir: Path) -> None: |
| if workdir.exists(): |
| shutil.rmtree(workdir) |
| workdir.mkdir(parents=True) |
| for rel, text in case["files"].items(): |
| path = workdir / rel |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(text) |
|
|
|
|
| def apply_expected_outputs(case: dict[str, Any], workdir: Path) -> None: |
| for rel, text in (case.get("verify") or {}).items(): |
| path = workdir / rel |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(text) |
| for rel, needles in (case.get("verify_contains") or {}).items(): |
| path = workdir / rel |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text("\n".join(needles) + "\n") |
| for rel, expected in (case.get("verify_json") or {}).items(): |
| path = workdir / rel |
| path.parent.mkdir(parents=True, exist_ok=True) |
| path.write_text(json.dumps(expected, indent=2) + "\n") |
| for rel in case.get("verify_missing") or []: |
| path = workdir / rel |
| if path.exists(): |
| path.unlink() |
|
|
|
|
| def verify_case(case: dict[str, Any], workdir: Path) -> list[str]: |
| errors: list[str] = [] |
| for rel, expected in (case.get("verify") or {}).items(): |
| path = workdir / rel |
| if not path.exists(): |
| errors.append(f"{rel} is missing") |
| elif path.read_text() != expected: |
| errors.append(f"{rel} did not match expected content") |
| for rel, needles in (case.get("verify_contains") or {}).items(): |
| path = workdir / rel |
| if not path.exists(): |
| errors.append(f"{rel} is missing") |
| continue |
| text = path.read_text().lower() |
| for needle in needles: |
| if needle.lower() not in text: |
| errors.append(f"{rel} does not contain {needle!r}") |
| for rel, expected in (case.get("verify_json") or {}).items(): |
| path = workdir / rel |
| if not path.exists(): |
| errors.append(f"{rel} is missing") |
| continue |
| try: |
| actual = json.loads(path.read_text()) |
| except Exception as exc: |
| errors.append(f"{rel} is not valid JSON: {exc}") |
| continue |
| for key, value in expected.items(): |
| if actual.get(key) != value: |
| errors.append(f"{rel} field {key!r} expected {value!r}, got {actual.get(key)!r}") |
| for rel in case.get("verify_missing") or []: |
| if (workdir / rel).exists(): |
| errors.append(f"{rel} still exists") |
| command = case.get("verify_command") |
| if command: |
| proc = subprocess.run(command, cwd=workdir, text=True, capture_output=True, timeout=120) |
| if proc.returncode != 0: |
| errors.append(f"verify_command failed: {proc.stdout}{proc.stderr}") |
| return errors |
|
|
|
|
| def parse_events(stdout: str) -> tuple[list[str], list[str]]: |
| event_types: list[str] = [] |
| item_types: list[str] = [] |
| for line in stdout.splitlines(): |
| line = line.strip() |
| if not line or not line.startswith("{"): |
| continue |
| try: |
| event = json.loads(line) |
| except json.JSONDecodeError: |
| continue |
| if isinstance(event.get("type"), str): |
| event_types.append(event["type"]) |
| item = event.get("item") |
| if isinstance(item, dict) and isinstance(item.get("type"), str): |
| item_types.append(item["type"]) |
| return event_types, item_types |
|
|
|
|
| def event_errors(case: dict[str, Any], event_types: list[str], item_types: list[str]) -> list[str]: |
| observed = set(event_types) | set(item_types) |
| expected = set(case.get("expected_events") or []) |
| return [f"missing expected event/item type {name}" for name in sorted(expected - observed)] |
|
|
|
|
| def self_check_case(case: dict[str, Any]) -> dict[str, Any]: |
| workdir = WORK_ROOT / f"self-check-{case['id']}" |
| seed_workspace(case, workdir) |
| apply_expected_outputs(case, workdir) |
| errors = verify_case(case, workdir) |
| return {"id": case["id"], "passed": not errors, "verify_errors": errors} |
|
|
|
|
| def run_case(case: dict[str, Any], args: argparse.Namespace) -> dict[str, Any]: |
| workdir = WORK_ROOT / case["id"] |
| seed_workspace(case, workdir) |
| last_message = workdir / "last-message.txt" |
| command = [ |
| "codex", |
| "-a", |
| "never", |
| "exec", |
| "--json", |
| "--ephemeral", |
| "--skip-git-repo-check", |
| "--color", |
| "never", |
| "--sandbox", |
| args.sandbox, |
| "-C", |
| str(workdir), |
| "-c", |
| f"model_provider=\"{args.provider}\"", |
| "-m", |
| args.model, |
| "-o", |
| str(last_message), |
| case["prompt"], |
| ] |
| env = os.environ.copy() |
| env.setdefault("OMLX_API_KEY", "omlx") |
|
|
| start = time.time() |
| proc = subprocess.run(command, cwd=workdir, text=True, capture_output=True, timeout=args.timeout, env=env) |
| event_types, item_types = parse_events(proc.stdout) |
| verify_errors = verify_case(case, workdir) if proc.returncode == 0 else ["codex exited nonzero"] |
| event_check_errors = event_errors(case, event_types, item_types) if proc.returncode == 0 else [] |
| return { |
| "id": case["id"], |
| "returncode": proc.returncode, |
| "seconds": round(time.time() - start, 3), |
| "passed": proc.returncode == 0 and not verify_errors and not event_check_errors, |
| "verify_errors": verify_errors, |
| "event_errors": event_check_errors, |
| "event_types": sorted(set(event_types)), |
| "item_types": sorted(set(item_types)), |
| "last_message": last_message.read_text() if last_message.exists() else "", |
| "stdout_tail": proc.stdout[-4000:], |
| "stderr_tail": proc.stderr[-4000:], |
| } |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--evals", type=Path, default=DEFAULT_EVALS) |
| parser.add_argument("--model", default="qwen35") |
| parser.add_argument("--provider", default="omlx") |
| parser.add_argument("--sandbox", default="workspace-write") |
| parser.add_argument("--timeout", type=int, default=300) |
| parser.add_argument("--limit", type=int) |
| parser.add_argument("--self-check", action="store_true", help="Verify eval seed/check logic without invoking Codex.") |
| args = parser.parse_args() |
|
|
| WORK_ROOT.mkdir(parents=True, exist_ok=True) |
| cases = list(iter_jsonl(args.evals)) |
| if args.limit is not None: |
| cases = cases[: args.limit] |
|
|
| results = [] |
| for case in cases: |
| if args.self_check: |
| result = self_check_case(case) |
| else: |
| print(f"running {case['id']}") |
| try: |
| result = run_case(case, args) |
| except subprocess.TimeoutExpired as exc: |
| result = { |
| "id": case["id"], |
| "returncode": None, |
| "seconds": args.timeout, |
| "passed": False, |
| "verify_errors": ["codex timed out"], |
| "event_errors": [], |
| "event_types": [], |
| "item_types": [], |
| "last_message": "", |
| "stdout_tail": (exc.stdout or "")[-4000:], |
| "stderr_tail": (exc.stderr or "")[-4000:], |
| } |
| print(json.dumps(result, indent=2)) |
| results.append(result) |
|
|
| out = ROOT / "tmp" / "codex-eval-results.json" |
| out.write_text(json.dumps(results, indent=2) + "\n") |
| failed = [row for row in results if not row["passed"]] |
| print(f"passed {len(results) - len(failed)}/{len(results)}") |
| return 1 if failed else 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
