Datasets:
File size: 5,370 Bytes
515c75b | 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 | """Quant Desk environment.
A multi-domain analyst desk: each reset serves one deterministic task drawn
from tasks.jsonl (log forensics, sensor math, invoice reconciliation, graph
counting, CIDR checks, media metadata, and more). The agent answers with a
single `{"answer": "..."}` action and gets up to three attempts per episode;
the episode reward is the best attempt score in [0, 1].
"""
import json
import logging
import threading
from pathlib import Path
from typing import Any, Dict, List, Optional
from uuid import uuid4
from openenv.core.env_server.interfaces import Environment
from openenv.core.env_server.types import Action, Observation
try:
from ..models import QuantDeskAction, QuantDeskObservation, QuantDeskState
from .graders import grade
except ImportError:
from models import QuantDeskAction, QuantDeskObservation, QuantDeskState
from server.graders import grade
logger = logging.getLogger(__name__)
_TASKS_PATH = Path(__file__).resolve().parent.parent / "tasks.jsonl"
MAX_ATTEMPTS = 3
_tasks_lock = threading.Lock()
_TASKS: Optional[List[Dict[str, Any]]] = None
def _load_tasks() -> List[Dict[str, Any]]:
global _TASKS
if _TASKS is None:
with _tasks_lock:
if _TASKS is None:
with open(_TASKS_PATH, encoding="utf-8") as f:
_TASKS = [json.loads(line) for line in f if line.strip()]
return _TASKS
class QuantDeskEnvironment(Environment):
"""Single-answer multi-domain QA environment for OpenEnv Arena."""
SUPPORTS_CONCURRENT_SESSIONS = True
def __init__(self):
super().__init__()
self._tasks = _load_tasks()
self._state = QuantDeskState(episode_id=str(uuid4()))
self._task: Optional[Dict[str, Any]] = None
self._done = False
def _pick_task(self, task_id=None, seed=None, split=None):
pool = [t for t in self._tasks if split is None or t.get("split") == split]
if not pool:
pool = self._tasks
if task_id is not None:
for t in pool:
if t["task_id"] == task_id:
return t
raise ValueError(
f"unknown task_id {task_id!r}; known ids: "
+ ", ".join(sorted(t["task_id"] for t in pool))
)
idx = (seed or 0) % len(pool)
return pool[idx]
def reset(
self,
seed: Optional[int] = None,
episode_id: Optional[str] = None,
task_id: Optional[str] = None,
split: Optional[str] = None,
**kwargs: Any,
) -> QuantDeskObservation:
"""Start an episode on the requested task."""
self._task = self._pick_task(task_id=task_id, seed=seed, split=split)
self._state = QuantDeskState(
episode_id=episode_id or str(uuid4()),
step_count=0,
task_id=self._task["task_id"],
attempts=0,
best_score=0.0,
)
self._done = False
logger.info("reset %s on task %s", self._state.episode_id, self._task["task_id"])
return QuantDeskObservation(
done=False,
reward=0.0,
prompt=self._task["prompt"],
feedback="",
attempts_remaining=MAX_ATTEMPTS,
task_id=self._task["task_id"],
)
def step(
self,
action: Action,
timeout_s: Optional[float] = None,
**kwargs: Any,
) -> QuantDeskObservation:
"""Grade one answer attempt."""
if self._task is None:
self.reset()
self._state.step_count += 1
if self._done:
return QuantDeskObservation(
done=True,
reward=self._state.best_score,
feedback="Episode already finished.",
attempts_remaining=0,
task_id=self._state.task_id,
)
answer = getattr(action, "answer", "")
if not isinstance(answer, str):
answer = json.dumps(answer)
self._state.attempts += 1
score, hint = grade(answer.strip(), self._task)
self._state.best_score = max(self._state.best_score, score)
last = self._state.attempts >= MAX_ATTEMPTS
self._done = score >= 0.999 or last
remaining = 0 if self._done else MAX_ATTEMPTS - self._state.attempts
if score >= 0.999:
feedback = f"Correct on attempt {self._state.attempts}."
else:
feedback = (
f"Attempt {self._state.attempts} of {MAX_ATTEMPTS} "
f"scored {score:.2f}."
)
if hint:
feedback += f" Hint: {hint}."
if not self._done:
feedback += " Try again."
else:
feedback += " No attempts left."
reward = self._state.best_score if self._done else score
return QuantDeskObservation(
done=self._done,
reward=reward,
feedback=feedback,
attempts_remaining=remaining,
task_id=self._state.task_id,
)
@property
def state(self) -> QuantDeskState:
"""Current environment state."""
return self._state
|