| """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
|
|
|
