"""Episode runner. Agents: oracle -- executes the answer key's minimal fix (wiring check, NOT a baseline) random -- random walk + random report (floor check) llm -- any OpenAI-compatible chat endpoint; the agent replies with one JSON action per turn, the environment replies with one JSON observation. Usage: python -m oncallval.harness --agent oracle --limit 20 python -m oncallval.harness --agent llm --model gpt-4.1 --base-url https://api.openai.com/v1 """ from __future__ import annotations import argparse import json import os import random import re import urllib.request from .env import Episode from .score import score_episode, summarize, truth_from_spec from .world import stable_hash FENCE = re.compile(r"```(?:json)?\s*(.*?)```", re.DOTALL) def load_jsonl(path): with open(path, encoding="utf-8") as f: return [json.loads(line) for line in f if line.strip()] def extract_action(text: str) -> dict | None: m = FENCE.search(text) if m: text = m.group(1) dec = json.JSONDecoder() for i, ch in enumerate(text): if ch == "{": try: obj, _ = dec.raw_decode(text[i:]) if isinstance(obj, dict) and "action" in obj: return obj except json.JSONDecodeError: continue return None class LLMAgent: def __init__(self, model: str, base_url: str, api_key: str, temperature: float = 0.0): self.model, self.base_url, self.key, self.temperature = model, base_url.rstrip("/"), api_key, temperature self.turns = 0 def chat(self, system: str, messages: list[dict]) -> str: body = json.dumps({"model": self.model, "temperature": self.temperature, "messages": [{"role": "system", "content": system}] + messages}).encode() req = urllib.request.Request( self.base_url + "/chat/completions", data=body, headers={"Content-Type": "application/json", "Authorization": f"Bearer {self.key}"}) with urllib.request.urlopen(req, timeout=180) as r: data = json.loads(r.read()) return data["choices"][0]["message"]["content"] def run(self, ep: Episode, max_turns: int) -> list[dict]: system = ep.system_prompt() messages = [{"role": "user", "content": f"ALERT: {ep.task['alert']}\nBegin. Reply with one JSON action."}] transcript = [] for _ in range(max_turns): text = self.chat(system, messages) action = extract_action(text) if action is None: messages.append({"role": "assistant", "content": text}) messages.append({"role": "user", "content": "Reply with exactly one JSON action object."}) continue obs = ep.step(action) transcript.append({"action": action, "observation": json.loads(obs)}) if ep.done: return transcript messages.append({"role": "assistant", "content": json.dumps(action)}) messages.append({"role": "user", "content": obs}) ep.step({"action": "submit_report", "cause": "unknown:unknown", "fix_summary": "budget exhausted"}) return transcript def oracle_agent(answer: dict): steps = list(answer["actions"]) + [ {"action": "submit_report", "cause": answer["cause"], "fix_summary": "answer key fix"}] def run(ep: Episode, max_turns: int) -> list[dict]: transcript = [] for act in steps: if ep.done: break obs = ep.step(act) transcript.append({"action": act, "observation": json.loads(obs)}) return transcript return run def random_agent(seed: int): rng = random.Random(seed) def run(ep: Episode, max_turns: int) -> list[dict]: transcript = [] svcs = [n for n, s in ep.w["services"].items() if s["kind"] != "external"] submit_at = rng.randint(5, max(6, ep.budget - 2)) for _ in range(max_turns): if ep.done: return transcript if ep.used >= submit_at: act = {"action": "submit_report", "cause": f"bad_deploy:{rng.choice(svcs)}", "fix_summary": "guess"} else: pick = rng.random() svc = rng.choice(svcs) if pick < 0.75: act = {"action": rng.choice(["get_metrics", "get_service", "query_logs"]), "service": svc} if act["action"] == "query_logs": act["limit"] = 20 else: act = rng.choice([ {"action": "restart", "service": svc}, {"action": "rollback", "service": svc}, {"action": "scale", "service": svc, "replicas": rng.randint(2, 10)}, {"action": "set_config", "service": svc, "key": "timeout_ms", "value": 500}, ]) obs = ep.step(act) transcript.append({"action": act, "observation": json.loads(obs)}) return transcript return run def main(): ap = argparse.ArgumentParser() ap.add_argument("--tasks", default="data/tasks.jsonl") ap.add_argument("--answers", default="", help="optional; truth is derived from the task spec if omitted") ap.add_argument("--agent", choices=["oracle", "random", "llm"], required=True) ap.add_argument("--model", default=os.environ.get("ONCALLVAL_MODEL", "gpt-4.1")) ap.add_argument("--base-url", default=os.environ.get("OPENAI_BASE_URL", "https://api.openai.com/v1")) ap.add_argument("--api-key", default=os.environ.get("OPENAI_API_KEY", "")) ap.add_argument("--limit", type=int, default=0, help="run only the first N tasks") ap.add_argument("--out", default="", help="write per-episode results JSONL here") args = ap.parse_args() tasks = load_jsonl(args.tasks) answers = {a["task_id"]: a for a in load_jsonl(args.answers)} if args.answers else {} if args.limit: tasks = tasks[:args.limit] results, transcripts = [], {} for t in tasks: ep = Episode(t) answer = answers.get(t["task_id"]) or truth_from_spec(t) if args.agent == "oracle": if "actions" not in answer: raise SystemExit("oracle agent requires --answers (it replays the answer-key fix)") tr = oracle_agent(answers[t["task_id"]])(ep, ep.budget + 4) elif args.agent == "random": tr = random_agent(stable_hash(t["task_id"]))(ep, ep.budget + 4) else: tr = LLMAgent(args.model, args.base_url, args.api_key).run(ep, ep.budget + 4) r = score_episode(ep, answer) r["difficulty"] = t["difficulty"] r["family"] = t["family"] results.append(r) transcripts[t["task_id"]] = tr summary = summarize(results) print(json.dumps(summary, indent=2)) if args.out: with open(args.out, "w", encoding="utf-8") as f: for r in results: f.write(json.dumps(r, ensure_ascii=False) + "\n") tpath = args.out.replace(".jsonl", ".transcripts.jsonl") with open(tpath, "w", encoding="utf-8") as f: for tid, tr in transcripts.items(): f.write(json.dumps({"task_id": tid, "transcript": tr}, ensure_ascii=False) + "\n") print(f"wrote {args.out} and {tpath}") if __name__ == "__main__": main()