File size: 5,060 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 | """OpenEnv Environment for 3amBench / AlertForge.
reset(seed, split="train"|"heldout"|"public", index=None, workflow=None, tier=None)
- public: one of the released Harbor tasks (AF_DATASET_DIR/tasks, sorted), chosen by `index` or seed
- train: a fresh task generated in-process from (workflow, tier, seed); unlimited instances
- heldout: like train, but with the server-side secret master seed AF_HELDOUT_SEED
step(action) → tool output + per-step reward from the same grader Harbor uses (alertforge.episode).
"""
from __future__ import annotations
import os
import random
import shutil
import tempfile
from typing import Any, Optional
from uuid import uuid4
from openenv.core.env_server.interfaces import Environment
from alertforge.cli import TIERS, WORKFLOWS
from alertforge.episode import Episode
from alertforge_env.models import AlertForgeAction, AlertForgeObservation, AlertForgeState
DATASET_DIR = os.environ.get("AF_DATASET_DIR", os.path.join(os.path.dirname(__file__), "..", "..", ".."))
TRAIN_MASTER_SEED = 20260928
_PUBLIC_CACHE: list[str] | None = None
def public_tasks() -> list[str]:
"""Sorted released task dirs (cached at module level; OpenEnv routes use throwaway instances)."""
global _PUBLIC_CACHE
if _PUBLIC_CACHE is None:
root = os.path.join(os.path.abspath(DATASET_DIR), "tasks")
_PUBLIC_CACHE = sorted(os.path.join(root, d) for d in os.listdir(root)) if os.path.isdir(root) else []
return _PUBLIC_CACHE
class AlertForgeEnvironment(Environment[AlertForgeAction, AlertForgeObservation, AlertForgeState]):
SUPPORTS_CONCURRENT_SESSIONS = True
def __init__(self) -> None:
super().__init__()
self._ep: Episode | None = None
self._tmp: str | None = None
self._state = AlertForgeState()
def reset(self, seed: Optional[int] = None, episode_id: Optional[str] = None, split: str = "train",
index: Optional[int] = None, workflow: Optional[str] = None, tier: Optional[str] = None,
**kwargs: Any) -> AlertForgeObservation:
self.close()
rng = random.Random(seed)
if split == "public":
tasks = public_tasks()
if not tasks:
return AlertForgeObservation(output="no public tasks found (set AF_DATASET_DIR)", ok=False, done=True)
task_dir = tasks[(index if index is not None else rng.randrange(len(tasks))) % len(tasks)]
task_id = os.path.basename(task_dir)
tier = next((t for t in TIERS if f"-{t}-" in task_id), "medium")
wf = next((w for w in WORKFLOWS if w in task_id), "")
else:
if split == "heldout" and not os.environ.get("AF_HELDOUT_SEED"):
return AlertForgeObservation(output="heldout split needs AF_HELDOUT_SEED on the server", ok=False, done=True)
master = int(os.environ["AF_HELDOUT_SEED"]) if split == "heldout" else TRAIN_MASTER_SEED
wf = workflow if workflow in WORKFLOWS else rng.choice(WORKFLOWS)
tier = tier if tier in TIERS else rng.choice(TIERS)
task_seed = seed if seed is not None else rng.randrange(10**9)
from alertforge import render
self._tmp = tempfile.mkdtemp(prefix="af-env-task-")
task_id = f"af-{split}-{wf}-{tier}-{task_seed}"
render.build_task(wf, tier, 1000 + task_seed, self._tmp, task_id, master)
task_dir = os.path.join(self._tmp, task_id)
self._ep = Episode(task_dir, split=split, tier=tier)
self._state = AlertForgeState(episode_id=episode_id or str(uuid4()), step_count=0, task_id=task_id,
tier=tier, workflow=wf, split=split)
return AlertForgeObservation(output="", ok=True, step=0, steps_left=self._ep.steps_left, task_id=task_id,
instruction=self._ep.instruction, reward=0.0, done=False,
metadata={"reward_mode": self._ep.mode})
def step(self, action: AlertForgeAction, timeout_s: Optional[float] = None, **kwargs: Any) -> AlertForgeObservation:
if self._ep is None:
return AlertForgeObservation(output="call reset() first", ok=False, done=True, reward=0.0)
res = self._ep.step(action.model_dump(exclude={"metadata"}, exclude_none=True))
self._state.step_count += 1
self._state.submitted = self._state.submitted or action.tool == "submit"
return AlertForgeObservation(output=res["output"], ok=res["ok"], step=self._ep.step_no,
steps_left=self._ep.steps_left, task_id=self._state.task_id,
reward=res["reward"], done=res["done"], metadata=res["metadata"])
@property
def state(self) -> AlertForgeState:
return self._state
def close(self) -> None:
if self._ep is not None:
self._ep.close()
self._ep = None
if self._tmp:
shutil.rmtree(self._tmp, ignore_errors=True)
self._tmp = None
|