File size: 7,805 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 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 | """Multi-turn episode over one task: tool actions on a private workspace copy, per-step shaped reward
from the same grader Harbor uses (§6). Framework-free; the OpenEnv server wraps this class.
Reward modes (AF_REWARD_MODE): parity (default) | shaped | outcome. On the heldout and public splits
the mode is forced to outcome and phi is hidden (H9), so the per-step reward is not a check oracle.
"""
from __future__ import annotations
import json
import os
import shutil
import subprocess
import sys
import tempfile
from .grader.grade import Grader
from .grader.promrun import tool
TOOLS = ("list_files", "read_file", "write_file", "replace_in_file", "run_checks", "route_test", "submit")
BUDGET = {"easy": 40, "medium": 70, "hard": 110}
MAX_WRITE = 1_000_000
STEP_COST, INVALID_COST, COST_CAP = 0.002, 0.01, 0.1
class Episode:
def __init__(self, task_dir: str, split: str = "train", mode: str | None = None, tier: str = "medium"):
self.task_dir = task_dir
self.split = split
mode = mode or os.environ.get("AF_REWARD_MODE", "parity")
self.hidden_split = split in ("heldout", "public")
self.mode = "outcome" if self.hidden_split else mode
with open(os.path.join(task_dir, "tests", "spec.json")) as fh:
self.spec = json.load(fh)
self.grader = Grader(self.spec, os.path.join(task_dir, "tests", "hidden"))
self.root = tempfile.mkdtemp(prefix="af-episode-")
self.ws = os.path.join(self.root, "monitoring")
shutil.copytree(os.path.join(task_dir, "environment", "workspace", "monitoring"), self.ws, symlinks=True)
with open(os.path.join(task_dir, "instruction.md")) as fh:
self.instruction = fh.read().split("-->", 1)[-1].strip()
self.steps_left = BUDGET.get(tier, 70)
self.step_no = 0
self.done = False
self.cost = 0.0
self.phi = self._grade()[0]["progress"]
self.total_reward = 0.0
# ------------------------------------------------------------------ helpers
def _grade(self):
return self.grader.grade(self.ws)
def _path(self, rel: str | None) -> str:
if not rel or rel.startswith("/") or ".." in rel.replace("\\", "/").split("/"):
raise ValueError(f"invalid path: {rel!r}")
p = os.path.realpath(os.path.join(self.ws, rel))
if not p.startswith(os.path.realpath(self.ws) + os.sep):
raise ValueError(f"path escapes the workspace: {rel!r}")
return p
def _run_tool(self, a: dict) -> str:
t = a.get("tool")
if t == "list_files":
out = []
for dp, _, fns in os.walk(self.ws):
for fn in sorted(fns):
out.append(os.path.relpath(os.path.join(dp, fn), self.ws))
return "\n".join(sorted(out))
if t == "read_file":
with open(self._path(a.get("path"))) as fh:
return fh.read()
if t == "write_file":
content = a.get("content")
if content is None or len(content) > MAX_WRITE:
raise ValueError("content missing or larger than 1 MB")
p = self._path(a.get("path"))
os.makedirs(os.path.dirname(p), exist_ok=True)
if os.path.islink(p):
raise ValueError("refusing to write through a symlink")
with open(p, "w") as fh:
fh.write(content)
return f"wrote {a['path']} ({len(content)} bytes)\n" + self._check_file(p)
if t == "replace_in_file":
p = self._path(a.get("path"))
with open(p) as fh:
text = fh.read()
old, new = a.get("old"), a.get("new")
if not old or new is None or text.count(old) != 1:
raise ValueError("`old` must match exactly once")
with open(p, "w") as fh:
fh.write(text.replace(old, new))
return f"edited {a['path']}\n" + self._check_file(p)
if t == "run_checks":
env = {**os.environ, "PATH": os.pathsep.join([os.path.dirname(tool("promtool")),
os.path.dirname(tool("amtool")), os.environ.get("PATH", "")])}
r = subprocess.run([sys.executable, os.path.join(self.ws, "bin", "af-check")], capture_output=True, text=True,
timeout=120, env=env)
return (r.stdout + r.stderr)[-8000:]
if t == "route_test":
labels = a.get("labels") or {}
if not isinstance(labels, dict) or not labels:
raise ValueError("labels must be a non-empty mapping")
args = [f'{k}="{v}"' for k, v in sorted(labels.items())]
r = subprocess.run([tool("amtool"), "config", "routes", "test",
f"--config.file={os.path.join(self.ws, 'alertmanager', 'alertmanager.yml')}", *args],
capture_output=True, text=True, timeout=20)
return (r.stdout + r.stderr).strip()
if t == "submit":
return "submitted"
raise ValueError(f"unknown tool {t!r}; tools: {', '.join(TOOLS)}")
def _check_file(self, p: str) -> str:
if "/rules/" not in p or not p.endswith((".yml", ".yaml")):
return ""
r = subprocess.run([sys.executable, os.path.join(self.ws, "bin", "af-check")], capture_output=True, text=True,
timeout=120, env={**os.environ, "PATH": os.pathsep.join(
[os.path.dirname(tool("promtool")), os.path.dirname(tool("amtool")), os.environ.get("PATH", "")])})
return "\n".join(ln for ln in r.stdout.splitlines() if "rules/" in ln or "FAIL" in ln)[-3000:]
# ------------------------------------------------------------------ API
def step(self, action: dict) -> dict:
"""Never raises (H12): invalid actions return ok=False and keep Φ."""
if self.done:
return {"output": "episode is over", "ok": False, "reward": 0.0, "done": True, "metadata": {}}
self.step_no += 1
self.steps_left -= 1
invalid = 0
try:
output, ok = self._run_tool(action), True
except Exception as e: # noqa: BLE001 - tool errors are observations, not crashes
output, ok, invalid = f"error: {e}", False, 1
done = action.get("tool") == "submit" or self.steps_left <= 0
try:
keys, _ = self._grade()
except Exception: # noqa: BLE001 - grader failure keeps the previous potential
keys = {"progress": self.phi, "reward": 0.0, "outcome": 0.0}
phi_new = keys["progress"]
d_phi = phi_new - self.phi
self.phi = phi_new
if self.mode == "parity":
r = 0.4 * d_phi
elif self.mode == "shaped":
c = min(STEP_COST + INVALID_COST * invalid, max(0.0, COST_CAP - self.cost))
self.cost += c
r = 0.3 * d_phi - c
else:
r = 0.0
if done:
self.done = True
r += keys["reward"] if self.mode == "outcome" else 0.6 * keys["outcome"]
self.total_reward += r
meta = {"invalid": invalid, "step": self.step_no}
if not self.hidden_split:
meta.update(phi=phi_new, delta_phi=d_phi)
if os.environ.get("AF_EXPOSE_COMPONENTS") == "1":
meta["components"] = {k: v for k, v in keys.items() if k.startswith("req_")}
else:
meta["phi"] = None
if done:
meta["outcome"] = keys["outcome"]
meta["harbor_reward"] = keys["reward"]
return {"output": output, "ok": ok, "reward": r, "done": done, "metadata": meta}
def close(self) -> None:
shutil.rmtree(self.root, ignore_errors=True)
|