File size: 5,809 Bytes
f3b0a91 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | #!/usr/bin/env python3
"""Scripted multi-step episodes against a running OpenEnv server (WebSocket), recording per-step rewards.
For each (workflow, tier, seed) the script regenerates the same train task locally (the generator is
deterministic in (workflow, tier, seed, TRAIN_MASTER_SEED)) to recover the oracle file writes, then drives the
remote env with a scripted policy:
list_files, read README, run_checks, oracle writes in random order with one broken-indent slip that is
later corrected, route_test, submit (policy "oracle")
same, but only the first half of the writes (policy "half")
public-split oracle-free episode (read, one harmful write, submit) to show outcome-only mode ("public")
The same action list is replayed in-process (alertforge.episode.Episode) and the per-step rewards compared.
PYTHONPATH=openenv python scripts/ws_episode.py --url http://localhost:8000 --out trace.json
"""
from __future__ import annotations
import argparse
import json
import os
import random
import sys
import tempfile
import time
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "..", "src"))
sys.path.insert(0, os.path.join(HERE, "..", "openenv"))
sys.path.insert(0, HERE)
from alertforge import render # noqa: E402
from alertforge.episode import Episode # noqa: E402
from alertforge.solutions import break_indent # noqa: E402
from alertforge_env.client import AlertForgeEnv # noqa: E402
from density_probe import oracle_writes # noqa: E402
TRAIN_MASTER_SEED = 20260928
def actions_for(task_dir: str, policy: str, rng: random.Random) -> list[dict]:
writes = oracle_writes(task_dir)
rng.shuffle(writes)
if policy == "half":
writes = writes[: max(1, len(writes) // 2)]
acts = [{"tool": "list_files"}, {"tool": "read_file", "path": "README.md"}, {"tool": "run_checks"}]
rule_idx = [i for i, (p, _) in enumerate(writes) if p.startswith("rules/")]
slip = rng.choice(rule_idx) if rule_idx else -1
for i, (p, c) in enumerate(writes):
if i == slip:
acts.append({"tool": "write_file", "path": p, "content": break_indent(c)})
acts.append({"tool": "run_checks"})
acts.append({"tool": "write_file", "path": p, "content": c})
acts += [{"tool": "route_test", "labels": {"alertname": "Probe", "severity": "critical"}}, {"tool": "submit"}]
return acts
def run_remote(url: str, reset_kw: dict, acts: list[dict]) -> list[dict]:
trace = []
with AlertForgeEnv(base_url=url, message_timeout_s=600).sync() as env:
r = env.reset(**reset_kw)
task_id = r.observation.get("task_id")
for i, a in enumerate(acts):
t0 = time.time()
s = env.step(a)
trace.append({"i": i + 1, "tool": a["tool"], "path": a.get("path"), "r": s.reward or 0.0,
"ok": s.observation.get("ok"), "done": s.done, "sec": round(time.time() - t0, 2)})
if s.done:
break
return task_id, trace
def run_local(task_dir: str, split: str, tier: str, acts: list[dict]) -> list[float]:
ep = Episode(task_dir, split=split, tier=tier)
out = []
for a in acts:
res = ep.step(a)
out.append(res["reward"])
if res["done"]:
break
ep.close()
return out
def main() -> int:
ap = argparse.ArgumentParser()
ap.add_argument("--url", default="http://localhost:8000")
ap.add_argument("--out", required=True)
ap.add_argument("--seed", type=int, default=7)
ap.add_argument("--public-task", default=os.path.join(HERE, "..", "tasks", "af-009-alert-storm-cleanup-medium-s1"))
a = ap.parse_args()
rng = random.Random(a.seed)
plan = [("slo-onboarding", "easy", 11, "oracle"), ("alert-storm-cleanup", "medium", 12, "oracle"),
("latency-slo", "hard", 13, "oracle"), ("missed-page-postmortem", "medium", 14, "half"),
("team-reorg-migration", "hard", 15, "half")]
episodes = []
tmp = tempfile.mkdtemp(prefix="af-ws-")
for wf, tier, seed, policy in plan:
task_id = f"af-train-{wf}-{tier}-{seed}"
render.build_task(wf, tier, 1000 + seed, tmp, task_id, TRAIN_MASTER_SEED)
tdir = os.path.join(tmp, task_id)
acts = actions_for(tdir, policy, rng)
rid, trace = run_remote(a.url, {"seed": seed, "split": "train", "workflow": wf, "tier": tier}, acts)
local = run_local(tdir, "train", tier, acts)
rem = [t["r"] for t in trace]
episodes.append({"task_id": rid, "local_task_id": task_id, "policy": policy, "tier": tier, "split": "train",
"trace": trace, "sum_r": sum(rem), "local_sum_r": sum(local),
"local_matches_remote": len(local) == len(rem) and all(abs(x - y) < 1e-9 for x, y in zip(local, rem))})
print(f"{rid:48s} {policy:6s} steps={len(rem):3d} nonzero={sum(1 for x in rem if abs(x) > 1e-12):3d} "
f"sum={sum(rem):.6f} local={sum(local):.6f} match={episodes[-1]['local_matches_remote']}", flush=True)
# public split: outcome-only (per-step reward hidden), reward only at submit
pub = os.path.abspath(a.public_task)
idx = sorted(os.listdir(os.path.join(HERE, "..", "tasks"))).index(os.path.basename(pub))
acts = actions_for(pub, "oracle", rng)
rid, trace = run_remote(a.url, {"seed": 0, "split": "public", "index": idx}, acts)
rem = [t["r"] for t in trace]
episodes.append({"task_id": rid, "policy": "oracle", "split": "public", "trace": trace, "sum_r": sum(rem)})
print(f"{rid:48s} public steps={len(rem):3d} nonzero={sum(1 for x in rem if abs(x) > 1e-12):3d} sum={sum(rem):.6f}")
json.dump(episodes, open(a.out, "w"), indent=1)
return 0
if __name__ == "__main__":
sys.exit(main())
|