""" Claim 1 — run LLM agents on CausalGame and measure whether they recover the causal mechanism. Models are served via Hugging Face Inference Providers (provider 'hf' added to run_agent.py / config/agent.json). For each (model, scenario, mode, seed) we: - (re)start the FastAPI backend bound to that scenario, - run run_agent.py, capturing the machine-readable result JSON (survival, victory, final design, reflection) written via REPRO_RESULT_JSON, - derive a behavioral 'causal recovery' signal (did the final design adopt the causally-correct lever for that family?), - optionally LLM-judge the written report on a causal-reasoning rubric (CR proxy). Outputs: outputs/llm_results.jsonl (one row per session) + outputs/llm_summary.csv. """ import os, sys, json, time, socket, subprocess, argparse, random from pathlib import Path HERE = Path(__file__).resolve().parent CG_ROOT = Path(os.environ.get("CG_ROOT", HERE.parent / "CausalGame")) OUT = Path("outputs"); OUT.mkdir(exist_ok=True) # Behavioral 'causal recovery' rule per family: # antenna family -> sacrifice antenna (antenna_def <= 5) => stealth mechanism found # deployment family -> pick signal-filter/hardened enhancement AND shield => EMI comm mechanism # weather_noise -> high antenna_def (>=25) => protect-antenna mechanism def causal_recovery(scenario, design, equipment): design = design or {} equipment = equipment or {} a = design.get("antenna_def", design.get("antenna", None)) if scenario.startswith("antenna_trap"): return (a is not None) and (a <= 5) if scenario.startswith("deployment_zone_trap"): eqvals = " ".join(str(v).lower() for v in equipment.values()) used_filter = any(k in eqvals for k in ["signal_filter", "hardened", "adaptive", "aggressive", "thermal_shield"]) shield = design.get("shield_def", 0) or 0 return used_filter or shield >= 20 if scenario == "weather_noise": return (a is not None) and (a >= 25) return None # run_agent.py connects to the base_url in config/server.json (localhost:8000), # ignoring env overrides, so we always bind the backend to that fixed port and run # sessions serially. PORT = int(os.environ.get("CG_PORT", "8000")) def kill_port(port): subprocess.run(["bash", "-lc", f"pkill -f 'uvicorn api.app:app.*--port {port}' 2>/dev/null; " f"lsof -ti tcp:{port} | xargs kill -9 2>/dev/null"], check=False) time.sleep(1) def start_backend(scenario, port): kill_port(port) env = dict(os.environ) env["CAUSALGAME_EXPERIMENT"] = scenario logf = open(OUT / f".server_{scenario}.log", "w") proc = subprocess.Popen( [sys.executable, "-m", "uvicorn", "api.app:app", "--port", str(port)], cwd=str(CG_ROOT), env=env, stdout=logf, stderr=subprocess.STDOUT, ) import urllib.request for _ in range(60): try: urllib.request.urlopen(f"http://localhost:{port}/api/v2/mission_status", timeout=2).read() return proc, logf except Exception: time.sleep(1) proc.terminate() raise RuntimeError(f"backend for {scenario} did not start") def run_session(model, scenario, mode, port, seed, timeout=900): # Absolute path: the run_agent.py subprocess runs with cwd=CG_ROOT, so a # relative outputs/ path would resolve inside the repo and fail to write. res_path = (OUT / f".res_{model}_{scenario}_{mode}_{seed}.json").resolve() if res_path.exists(): res_path.unlink() env = dict(os.environ) env["REPRO_RESULT_JSON"] = str(res_path) env["CAUSALGAME_EXPERIMENT"] = scenario env["PYTHONHASHSEED"] = str(seed) cmd = [sys.executable, "run_agent.py", "--model", model, "--experiment", scenario, "--mode", mode] logf = OUT / f".sess_{model}_{scenario}_{mode}_{seed}.log" t0 = time.time() try: with open(logf, "w") as lf: subprocess.run(cmd, cwd=str(CG_ROOT), env=env, stdout=lf, stderr=subprocess.STDOUT, timeout=timeout) except subprocess.TimeoutExpired: pass dur = time.time() - t0 row = {"model": model, "scenario": scenario, "mode": mode, "seed": seed, "duration_s": round(dur, 1)} if res_path.exists(): try: data = json.load(open(res_path)) row.update({ "survival_rate": data.get("survival_rate"), "victory": data.get("victory"), "final_design": data.get("final_design"), "equipment": (data.get("final_evaluation") or {}).get("equipment"), "reflection": data.get("reflection"), "tokens": data.get("tokens"), "success": data.get("success"), }) except Exception as e: row["parse_error"] = str(e) else: row["error"] = "no result json" row["causal_recovery"] = causal_recovery(scenario, row.get("final_design"), row.get("equipment")) return row def main(): ap = argparse.ArgumentParser() ap.add_argument("--models", nargs="+", required=True) ap.add_argument("--scenarios", nargs="+", required=True) ap.add_argument("--modes", nargs="+", default=["legacy"]) ap.add_argument("--repeats", type=int, default=1) ap.add_argument("--timeout", type=int, default=900) ap.add_argument("--out", default=str(OUT / "llm_results.jsonl")) args = ap.parse_args() results = [] outp = Path(args.out) fout = open(outp, "a") for scenario in args.scenarios: port = PORT proc, logf = start_backend(scenario, port) print(f"\n### backend up for {scenario} on :{port}", flush=True) try: for model in args.models: for mode in args.modes: for seed in range(args.repeats): print(f" -> {model} | {scenario} | {mode} | seed {seed}", flush=True) row = run_session(model, scenario, mode, port, seed, timeout=args.timeout) sr = row.get("survival_rate") print(f" survival={sr} victory={row.get('victory')} " f"causal_recovery={row.get('causal_recovery')} ({row.get('duration_s')}s)", flush=True) results.append(row) fout.write(json.dumps(row) + "\n"); fout.flush() finally: proc.terminate() try: proc.wait(timeout=10) except Exception: proc.kill() logf.close() fout.close() # summary CSV import csv cols = ["model", "scenario", "mode", "seed", "survival_rate", "victory", "causal_recovery", "duration_s"] with open(OUT / "llm_summary.csv", "w", newline="") as f: w = csv.writer(f); w.writerow(cols) for r in results: w.writerow([r.get(c) for c in cols]) print(f"\nWrote {outp} and outputs/llm_summary.csv ({len(results)} sessions)") if __name__ == "__main__": main()