Upload folder using huggingface_hub

README.md

@@ -380,3 +380,4 @@ Current deterministic fallback baseline:
 - average: `1.00`
 
 These scores are intentionally reproducible. The fallback policy exists to show that the environment, reward shaping, and graders all work end to end. Model-backed runs can be lower, which is useful for evaluation.
+

inference.py

@@ -24,7 +24,7 @@ from supportdesk_env.tasks import get_task, list_task_ids
 API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
 MODEL_NAME = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
 HF_TOKEN = os.getenv("HF_TOKEN")
-API_KEY = HF_TOKEN
+API_KEY = HF_TOKEN or os.getenv("API_KEY")
 LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
 TASK_NAME = os.getenv("SUPPORTDESK_TASK_ID", "billing_refund_easy")
 BENCHMARK = os.getenv("SUPPORTDESK_BENCHMARK", "supportdesk_env")
@@ -172,10 +172,11 @@ def _log_step(step: int, action_str: str, reward: float, done: bool, error: str
     )
 
 
-def _log_end(success: bool, steps: int, rewards: list[float]) -> None:
+def _log_end(success: bool, steps: int, score: float, rewards: list[float]) -> None:
     reward_text = ",".join(f"{reward:.2f}" for reward in rewards)
     print(
-        f"[END] success={str(success).lower()} steps={steps} rewards={reward_text}",
+        f"[END] success={str(success).lower()} steps={steps} "
+        f"score={score:.3f} rewards={reward_text}",
         flush=True,
     )
 
@@ -268,6 +269,7 @@ async def _run_docker_episode(task_id: str, client: OpenAI | None) -> EpisodeRes
 async def main() -> None:
     client = _build_client()
     success = False
+    final_score = 0.0
     steps_taken = 0
     rewards: list[float] = []
 
@@ -278,11 +280,12 @@ async def main() -> None:
             episode = await _run_docker_episode(TASK_NAME, client)
         else:
             episode = _run_local_episode(TASK_NAME, client)
+        final_score = episode.final_score
         success = episode.final_score >= SUCCESS_SCORE_THRESHOLD
         steps_taken = episode.steps_taken
         rewards = episode.rewards
     finally:
-        _log_end(success=success, steps=steps_taken, rewards=rewards)
+        _log_end(success=success, steps=steps_taken, score=final_score, rewards=rewards)
 
 
 if __name__ == "__main__":

pytest.ini

@@ -1,3 +1,4 @@
 [pytest]
 addopts = -p no:cacheprovider
 testpaths = tests
+pythonpath = .

supportdesk_env/client.py

@@ -30,9 +30,9 @@ class SupportDeskEnv(EnvClient[SupportDeskAction, SupportDeskObservation, Suppor
 
     def _parse_result(self, payload) -> StepResult[SupportDeskObservation]:
         observation = _validate(SupportDeskObservation, payload["observation"])
+        # OpenEnv StepResult only accepts observation/reward/done in this runtime.
         return StepResult(
             observation=observation,
             reward=payload["reward"],
             done=payload["done"],
-            info=payload.get("info", {}),
         )

supportdesk_env/graders.py

@@ -8,6 +8,8 @@ from dataclasses import dataclass
 from supportdesk_env.models import SupportCaseProgress
 from supportdesk_env.tasks import SupportTaskSpec, get_task
 
+STRICT_SCORE_EPSILON = 0.001
+
 
 @dataclass(frozen=True)
 class GradeBreakdown:
@@ -70,8 +72,14 @@ def _reply_penalty(case: SupportCaseProgress, task: SupportTaskSpec) -> float:
     return 0.0 if not any(_normalize(marker) in text for marker in task.forbidden_reply_markers) else 0.5
 
 
+def _strict_open_unit_interval(score: float) -> float:
+    """Keep final task scores strictly within (0, 1) for evaluator compatibility."""
+
+    return min(1.0 - STRICT_SCORE_EPSILON, max(STRICT_SCORE_EPSILON, score))
+
+
 def grade_case(task: SupportTaskSpec, case: SupportCaseProgress) -> GradeBreakdown:
-    """Score a case from 0.0 to 1.0 using deterministic task rules."""
+    """Score a case deterministically with total_score strictly inside (0, 1)."""
 
     queue_score = 1.0 if case.queue == task.gold_queue else 0.0
     priority_score = 1.0 if case.priority == task.gold_priority else 0.0
@@ -112,7 +120,7 @@ def grade_case(task: SupportTaskSpec, case: SupportCaseProgress) -> GradeBreakdo
         milestones.append("resolution_code")
 
     return GradeBreakdown(
-        total_score=round(weighted_total, 4),
+        total_score=round(_strict_open_unit_interval(weighted_total), 4),
         queue_score=queue_score,
         priority_score=priority_score,
         issue_type_score=issue_type_score,

supportdesk_env/server/app.py

@@ -35,6 +35,7 @@ import os
 from typing import Any
 
 import uvicorn
+from fastapi import Body, HTTPException
 
 try:
     from openenv.core.env_server import http_server as openenv_http_server
@@ -103,6 +104,42 @@ def list_tasks() -> dict[str, Any]:
     }
 
 
+@app.get("/episodes/{episode_id}/state", response_model=SupportDeskState)
+def get_episode_state(episode_id: str) -> SupportDeskState:
+    """Optional explicit state helper for robust episode-addressable inspection."""
+
+    try:
+        return SupportDeskEnvironment.state_for_episode(episode_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+
+@app.post("/episodes/{episode_id}/step")
+def step_episode(
+    episode_id: str,
+    payload: dict[str, Any] = Body(...),
+) -> dict[str, Any]:
+    """Optional explicit step helper that does not require sticky request context."""
+
+    action_payload = payload.get("action")
+    if not isinstance(action_payload, dict):
+        raise HTTPException(status_code=422, detail="Request body must include an 'action' object.")
+
+    timeout_s = payload.get("timeout_s")
+    try:
+        action = SupportDeskAction.model_validate(action_payload)
+        env = SupportDeskEnvironment()
+        observation = env.step(action, timeout_s=timeout_s, episode_id=episode_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+    return {
+        "observation": observation.model_dump(),
+        "reward": observation.reward,
+        "done": observation.done,
+    }
+
+
 def main(host: str = "0.0.0.0", port: int = 8000) -> None:
     """
     Entry point for direct execution via uv run or python -m.

supportdesk_env/server/supportdesk_environment.py

@@ -6,6 +6,7 @@ import os
 import threading
 import uuid
 from pathlib import Path
+from typing import ClassVar
 
 from supportdesk_env.graders import grade_case
 from supportdesk_env.models import (
@@ -33,19 +34,11 @@ class SupportDeskEnvironment(
 ):
     """A realistic customer support triage environment with dense rewards."""
 
-    _state_lock = threading.RLock()
-    _shared_task_id: str | None = None
-    _shared_step_count = 0
-    _shared_reward_total = 0.0
-    _shared_done = False
-    _shared_last_feedback = ""
-    _shared_history: list[ActionHistoryEntry] = []
-    _shared_case = SupportCaseProgress()
-    _shared_episode_id: str | None = None
-    _shared_score = 0.0
-    _shared_completed_milestones: list[str] = []
-    _shared_current_sla_minutes_remaining: int | None = None
-    _shared_reset_counter = 0
+    _state_lock: ClassVar[threading.RLock] = threading.RLock()
+    _episode_store: ClassVar[dict[str, SupportDeskState]] = {}
+    _episode_task_ids: ClassVar[dict[str, str]] = {}
+    _latest_episode_id: ClassVar[str | None] = None
+    _shared_reset_counter: ClassVar[int] = 0
 
     def __init__(self, task_id: str | None = None):
         super().__init__()
@@ -65,69 +58,93 @@ class SupportDeskEnvironment(
         initial_grade = grade_case(self.task, self._case)
         self._score = initial_grade.total_score
         self._completed_milestones = list(initial_grade.completed_milestones)
-        self._ensure_shared_state(self.task)
 
     @classmethod
-    def _initialize_shared_state(
-        cls,
-        task: SupportTaskSpec,
-        *,
-        episode_id: str | None = None,
-    ) -> None:
+    def _build_initial_state(cls, task: SupportTaskSpec, episode_id: str) -> SupportDeskState:
         initial_case = SupportCaseProgress()
         initial_grade = grade_case(task, initial_case)
-        cls._shared_task_id = task.task_id
-        cls._shared_step_count = 0
-        cls._shared_reward_total = 0.0
-        cls._shared_done = False
-        cls._shared_last_feedback = (
-            "New case loaded. Review the ticket and policy snippets before acting."
+        return SupportDeskState(
+            episode_id=episode_id,
+            task_id=task.task_id,
+            difficulty=task.difficulty,
+            step_count=0,
+            reward=0.0,
+            done=False,
+            current_score=initial_grade.total_score,
+            max_steps=task.max_steps,
+            case=initial_case,
+            current_sla_minutes_remaining=task.ticket.sla_minutes_remaining,
+            workflow_stage="intake",
+            required_next_actions=["classify"],
+            risk_flags=[],
+            action_history=[],
+            completed_milestones=list(initial_grade.completed_milestones),
+            last_feedback="New case loaded. Review the ticket and policy snippets before acting.",
         )
-        cls._shared_history = []
-        cls._shared_case = initial_case
-        cls._shared_episode_id = episode_id
-        cls._shared_score = initial_grade.total_score
-        cls._shared_completed_milestones = list(initial_grade.completed_milestones)
-        cls._shared_current_sla_minutes_remaining = task.ticket.sla_minutes_remaining
 
     @classmethod
-    def _ensure_shared_state(cls, task: SupportTaskSpec) -> None:
-        with cls._state_lock:
-            if cls._shared_task_id is None:
-                cls._initialize_shared_state(task)
+    def _extract_episode_id(cls, episode_id: str | None = None, **kwargs) -> str | None:
+        if episode_id:
+            return episode_id
+        for key in ("episode_id", "request_id"):
+            value = kwargs.get(key)
+            if isinstance(value, str) and value:
+                return value
+        return None
+
+    def _load_episode(self, episode_id: str | None = None, **kwargs) -> None:
+        resolved_episode_id = self._extract_episode_id(episode_id, **kwargs) or self.__class__._latest_episode_id
+        if not resolved_episode_id:
+            return
+
+        episode_state = self.__class__._episode_store.get(resolved_episode_id)
+        if episode_state is None:
+            raise ValueError(
+                f"Unknown episode_id '{resolved_episode_id}'. Call reset() first or provide a valid episode_id."
+            )
 
-    def _sync_from_shared(self) -> None:
-        task = get_task(self.__class__._shared_task_id or self.task.task_id)
+        task = get_task(self.__class__._episode_task_ids.get(resolved_episode_id, episode_state.task_id))
         self.task = task
-        self._max_steps = task.max_steps
-        self._step_count = self.__class__._shared_step_count
-        self._reward_total = self.__class__._shared_reward_total
-        self._done = self.__class__._shared_done
-        self._last_feedback = self.__class__._shared_last_feedback
-        self._history = [entry.model_copy(deep=True) for entry in self.__class__._shared_history]
-        self._case = self.__class__._shared_case.model_copy(deep=True)
-        self._episode_id = self.__class__._shared_episode_id
-        self._score = self.__class__._shared_score
-        self._completed_milestones = list(self.__class__._shared_completed_milestones)
-        self._current_sla_minutes_remaining = self.__class__._shared_current_sla_minutes_remaining
-
-    def _sync_to_shared(self) -> None:
-        self.__class__._shared_task_id = self.task.task_id
-        self.__class__._shared_step_count = self._step_count
-        self.__class__._shared_reward_total = self._reward_total
-        self.__class__._shared_done = self._done
-        self.__class__._shared_last_feedback = self._last_feedback
-        self.__class__._shared_history = [entry.model_copy(deep=True) for entry in self._history]
-        self.__class__._shared_case = self._case.model_copy(deep=True)
-        self.__class__._shared_episode_id = self._episode_id
-        self.__class__._shared_score = self._score
-        self.__class__._shared_completed_milestones = list(self._completed_milestones)
-        self.__class__._shared_current_sla_minutes_remaining = self._current_sla_minutes_remaining
+        self._max_steps = episode_state.max_steps
+        self._step_count = episode_state.step_count
+        self._reward_total = episode_state.reward
+        self._done = episode_state.done
+        self._last_feedback = episode_state.last_feedback
+        self._history = [entry.model_copy(deep=True) for entry in episode_state.action_history]
+        self._case = episode_state.case.model_copy(deep=True)
+        self._episode_id = resolved_episode_id
+        self._score = episode_state.current_score
+        self._completed_milestones = list(episode_state.completed_milestones)
+        self._current_sla_minutes_remaining = episode_state.current_sla_minutes_remaining
+
+    def _persist_episode(self) -> None:
+        if self._episode_id is None:
+            return
+        self.__class__._episode_store[self._episode_id] = SupportDeskState(
+            episode_id=self._episode_id,
+            task_id=self.task.task_id,
+            difficulty=self.task.difficulty,
+            step_count=self._step_count,
+            reward=round(self._reward_total, 4),
+            done=self._done,
+            current_score=round(self._score, 4),
+            max_steps=self._max_steps,
+            case=self._case.model_copy(deep=True),
+            current_sla_minutes_remaining=self._current_sla_minutes_remaining,
+            workflow_stage=self._workflow_stage(),
+            required_next_actions=self._required_next_actions(),
+            risk_flags=self._risk_flags(),
+            action_history=[entry.model_copy(deep=True) for entry in self._history],
+            completed_milestones=list(self._completed_milestones),
+            last_feedback=self._last_feedback,
+        )
+        self.__class__._episode_task_ids[self._episode_id] = self.task.task_id
+        self.__class__._latest_episode_id = self._episode_id
 
     @property
     def state(self) -> SupportDeskState:
         with self.__class__._state_lock:
-            self._sync_from_shared()
+            self._load_episode()
             return SupportDeskState(
                 episode_id=self._episode_id,
                 task_id=self.task.task_id,
@@ -160,21 +177,23 @@ class SupportDeskEnvironment(
                 self.__class__._shared_reset_counter += 1
                 self.task = get_task(next_task_id)
                 self._max_steps = self.task.max_steps
-            self.__class__._initialize_shared_state(
-                self.task,
-                episode_id=episode_id or f"{self.task.task_id}-{uuid.uuid4().hex[:8]}",
-            )
-            self._sync_from_shared()
+            self._episode_id = episode_id or f"{self.task.task_id}-{uuid.uuid4().hex[:8]}"
+            initial_state = self.__class__._build_initial_state(self.task, self._episode_id)
+            self.__class__._episode_store[self._episode_id] = initial_state
+            self.__class__._episode_task_ids[self._episode_id] = self.task.task_id
+            self.__class__._latest_episode_id = self._episode_id
+            self._load_episode(self._episode_id)
             return self._build_observation(reward=0.0, done=False)
 
     def step(
         self,
         action: SupportDeskAction,
         timeout_s: float | None = None,
+        episode_id: str | None = None,
         **kwargs,
     ) -> SupportDeskObservation:
         with self.__class__._state_lock:
-            self._sync_from_shared()
+            self._load_episode(episode_id, **kwargs)
 
             if self._done:
                 return self._build_observation(
@@ -227,10 +246,18 @@ class SupportDeskEnvironment(
                     reward_delta=reward,
                 )
             )
-            self._sync_to_shared()
+            self._persist_episode()
 
             return self._build_observation(reward=reward, done=self._done)
 
+    @classmethod
+    def state_for_episode(cls, episode_id: str) -> SupportDeskState:
+        with cls._state_lock:
+            state = cls._episode_store.get(episode_id)
+            if state is None:
+                raise ValueError(f"Unknown episode_id '{episode_id}'. Call reset() first.")
+            return state.model_copy(deep=True)
+
     def close(self) -> None:
         """No-op close hook for compatibility with local scripts."""
 

tests/test_supportdesk.py

@@ -66,7 +66,7 @@ def test_perfect_solution_grades_full_score():
     )
 
     breakdown = grade_case(task, env.state.case)
-    assert breakdown.total_score == 1.0
+    assert breakdown.total_score == 0.999
 
 
 def test_max_steps_ends_episode():
@@ -83,7 +83,7 @@ def test_grade_is_bounded_between_zero_and_one():
     env = SupportDeskEnvironment(task_id=task.task_id)
     env.reset()
     breakdown = grade_case(task, env.state.case)
-    assert 0.0 <= breakdown.total_score <= 1.0
+    assert 0.0 < breakdown.total_score < 1.0
 
 
 def test_state_includes_episode_id_after_reset():
@@ -167,3 +167,37 @@ def test_http_reset_step_state_are_session_consistent():
     assert state_payload["case"]["queue"] == "billing_ops"
     assert state_payload["case"]["priority"] == "high"
     assert state_payload["case"]["issue_type"] == "duplicate_charge"
+
+
+@pytest.mark.skipif(TestClient is None, reason="httpx is not installed for FastAPI TestClient")
+def test_http_explicit_episode_helpers_work():
+    from supportdesk_env.server.app import app
+
+    client = TestClient(app)
+
+    episode_id = "explicit-http-episode"
+    reset_response = client.post("/reset", json={"episode_id": episode_id})
+    assert reset_response.status_code == 200
+
+    step_response = client.post(
+        f"/episodes/{episode_id}/step",
+        json={
+            "action": {
+                "operation": "classify",
+                "queue": "billing_ops",
+                "priority": "high",
+                "issue_type": "duplicate_charge",
+            }
+        },
+    )
+    assert step_response.status_code == 200
+
+    state_response = client.get(f"/episodes/{episode_id}/state")
+    assert state_response.status_code == 200
+    state_payload = state_response.json()
+
+    assert state_payload["episode_id"] == episode_id
+    assert state_payload["step_count"] == 1
+    assert state_payload["case"]["queue"] == "billing_ops"
+    assert state_payload["case"]["priority"] == "high"
+    assert state_payload["case"]["issue_type"] == "duplicate_charge"