Upload folder using huggingface_hub

README.md

@@ -35,7 +35,8 @@ Pharmacovigilance teams are responsible for detecting harmful safety patterns af
 | Episode length | 2-step triage and review workflow |
 | Task count | 3 |
 | Difficulties | Easy, Medium, Hard |
-| Reward range | `0.0` to `1.0` |
+| Step reward range | `-0.25` to `1.0` |
+| Final grader range | strict `(0, 1)` |
 | API | `reset()`, `step()`, `state()` |
 | Server | FastAPI |
 
@@ -114,7 +115,8 @@ triage story.
 | Hard-task reasoning bonus if explanation mentions `drug interaction`, `tacrolimus`, `voriconazole`, `azole`, `calcineurin`, or `level monitoring` | `+0.05` |
 
 Notes:
-- Final reward is clamped to `[0.0, 1.0]`.
+- Step-level rewards may be slightly negative for clearly unsafe or suboptimal actions.
+- Final grader outputs remain deterministic and strictly bounded inside `(0, 1)` for evaluation safety.
 - `suspect_drug` matching is forgiving for the hard task and allows substring matches.
 - The environment is deterministic and reproducible because all tasks and grading logic are hardcoded.
 - Confidence is optional, but calibrated confidence can improve reward while reckless overconfidence is penalized.

env.py

@@ -36,9 +36,9 @@ class Action(BaseModel):
     confidence: Optional[int] = Field(default=None, ge=0, le=100)
 
 
-class Reward(BaseModel):
-    total: float = Field(..., ge=0.0, le=1.0)
-    breakdown: dict
+class Reward(BaseModel):
+    total: float = Field(..., ge=-1.0, le=1.0)
+    breakdown: dict
 
 
 class PharmaVigilanceEnv:
@@ -71,7 +71,7 @@ class PharmaVigilanceEnv:
 
     @staticmethod
     def _clamp_reward(total: float, breakdown: dict) -> Reward:
-        return Reward(total=max(0.0, min(1.0, round(total, 4))), breakdown=breakdown)
+        return Reward(total=max(-0.25, min(1.0, round(total, 4))), breakdown=breakdown)
 
     def _initial_triage_reward(self, action: Action) -> Reward:
         truth = self.current_task.ground_truth

inference.py

@@ -6,19 +6,20 @@ to the environment server, and prints the exact machine-readable lines expected
 by the evaluator.
 """
 
-import argparse
-import json
-import os
-from typing import Iterable, List
-
-import requests
-from openai import OpenAI
-from pydantic import ValidationError
-
-try:
-    from .models import PharmaAction
-except ImportError:
-    from models import PharmaAction
+import argparse
+import json
+import os
+from typing import Any, Iterable, List
+
+import requests
+from pydantic import ValidationError
+
+try:
+    from .graders import TASK_TO_GRADER
+    from .models import PharmaAction
+except ImportError:
+    from graders import TASK_TO_GRADER
+    from models import PharmaAction
 
 
 API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
@@ -85,10 +86,12 @@ def choose_tasks(selection: str) -> Iterable[str]:
     return TASK_SETS[selection]
 
 
-def client() -> OpenAI:
-    if not HF_TOKEN:
-        raise EnvironmentError("HF_TOKEN or API_KEY must be set before running inference.py")
-    return OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+def client() -> Any:
+    if not HF_TOKEN:
+        raise EnvironmentError("HF_TOKEN or API_KEY must be set before running inference.py")
+    from openai import OpenAI
+
+    return OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
 
 
 def fetch_reset(task_name: str) -> dict:
@@ -121,7 +124,7 @@ def prompt_for_case(observation: dict) -> str:
     )
 
 
-def ask_model(llm: OpenAI, observation: dict) -> PharmaAction:
+def ask_model(llm: Any, observation: dict) -> PharmaAction:
     completion = llm.chat.completions.create(
         model=MODEL_NAME,
         messages=[
@@ -144,12 +147,15 @@ def compact_action(action: PharmaAction) -> str:
     return label
 
 
-def final_score(rewards: List[float]) -> float:
-    score = sum(rewards) / len(rewards) if rewards else 0.0
-    return min(max(round(score, 4), 0.01), 0.99)
+def final_score(task_name: str, rewards: List[float]) -> float:
+    grader = TASK_TO_GRADER.get(task_name)
+    if grader is None:
+        score = sum(rewards) / len(rewards) if rewards else 0.0
+        return min(max(round(score, 4), 0.01), 0.99)
+    return float(grader({"rewards": rewards}))
 
 
-def run_one_task(llm: OpenAI, task_name: str) -> None:
+def run_one_task(llm: Any, task_name: str) -> None:
     rewards: List[float] = []
     steps_taken = 0
     score = 0.0
@@ -179,7 +185,7 @@ def run_one_task(llm: OpenAI, task_name: str) -> None:
             steps_taken += 1
             emit_step(steps_taken, action_text, reward, done, None)
 
-        score = final_score(rewards)
+        score = final_score(task_name, rewards)
         success = score >= 0.60
 
     except json.JSONDecodeError:

models.py

@@ -53,6 +53,6 @@ class PharmaAction(Action):
     )
 
 
-class PharmaReward(BaseModel):
-    total: float = Field(..., description="Total reward in the 0.0-1.0 range")
-    breakdown: dict = Field(default_factory=dict, description="Per-component reward breakdown")
+class PharmaReward(BaseModel):
+    total: float = Field(..., description="Step reward total, which may be slightly negative for penalties")
+    breakdown: dict = Field(default_factory=dict, description="Per-component reward breakdown")

openenv.yaml

@@ -69,9 +69,9 @@ observation_space:
       required: false
       description: "Human-readable feedback from the previous action"
 
-reward:
-  min: 0.0
-  max: 1.0
+reward:
+  min: -0.25
+  max: 1.0
   description: >
     Reward is computed over a staged pharmacovigilance decision pipeline:
     classification, causal suspect selection, severity assessment, and
@@ -83,7 +83,9 @@ reward:
     penalty of -0.20 applies when the agent dismisses a true new signal. The
     hard task can earn an additional +0.05 reasoning bonus when the
     explanation explicitly references the interaction mechanism or therapeutic
-    drug monitoring clues.
+    drug monitoring clues. Step-level rewards may dip slightly below zero for
+    clearly unsafe or suboptimal behavior, while final grader scores remain
+    deterministic and normalized for evaluation.
 
 difficulties:
   - easy

tasks.py

@@ -104,9 +104,9 @@ def _reward_from_breakdown(breakdown: dict):
         from .env import Reward
     except ImportError:
         from env import Reward
-
-    total = round(sum(breakdown.values()), 4)
-    return Reward(total=max(0.0, min(1.0, total)), breakdown=breakdown)
+
+    total = round(sum(breakdown.values()), 4)
+    return Reward(total=max(-0.25, min(1.0, total)), breakdown=breakdown)
 
 
 def known_signal_easy_action_grader(action: Any):

tests/test_env.py

@@ -6,15 +6,15 @@ sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 
 from env import Action, PharmaVigilanceEnv
 from tasks import (
-    cluster_signal_medium_action_grader,
-    cluster_signal_medium_grader,
+    cluster_signal_medium_action_grader,
+    cluster_signal_medium_grader,
     confounded_hard_action_grader,
     confounded_hard_grader,
     get_task,
     get_tasks,
-    known_signal_easy_action_grader,
-    known_signal_easy_grader,
-)
+    known_signal_easy_action_grader,
+    known_signal_easy_grader,
+)
 
 
 def test_reset_loads_easy_task():
@@ -179,6 +179,39 @@ def test_final_step_applies_stubborn_penalty_for_repeating_weak_answer():
     assert reward.breakdown["stubborn_penalty"] == -0.05
 
 
+def test_initial_step_can_return_negative_reward_for_unsafe_triage():
+    env = PharmaVigilanceEnv()
+    env.reset("cluster_signal_medium")
+
+    _, reward, done, info = env.step(
+        Action(
+            classification="noise",
+            suspect_drug="Unknown",
+            severity_assessment="mild",
+            recommended_action="dismiss",
+            reasoning="No obvious concern.",
+            confidence=95,
+        )
+    )
+    assert done is False
+    assert info["phase"] == "initial_triage"
+    assert reward.total < 0.0
+
+
+def test_single_step_action_grader_can_return_negative_total():
+    reward = cluster_signal_medium_action_grader(
+        Action(
+            classification="noise",
+            suspect_drug="Unknown",
+            severity_assessment="mild",
+            recommended_action="dismiss",
+            reasoning="Probably unrelated.",
+            confidence=95,
+        )
+    )
+    assert reward.total < 0.0
+
+
 def test_overconfidence_penalty_applies_on_weak_single_step_grading():
     reward = cluster_signal_medium_action_grader(
         Action(
@@ -280,6 +313,16 @@ def test_public_graders_are_strictly_bounded():
     assert confounded_hard_grader({"score": 1.5}) == 0.99
 
 
+def test_inference_final_score_uses_public_task_grader():
+    pytest.importorskip("openenv")
+    from inference import final_score
+
+    rewards = [0.4, 1.0]
+    assert final_score("known_signal_easy", rewards) == known_signal_easy_grader({"rewards": rewards})
+    assert final_score("cluster_signal_medium", rewards) == cluster_signal_medium_grader({"rewards": rewards})
+    assert final_score("confounded_hard", rewards) == confounded_hard_grader({"rewards": rewards})
+
+
 def test_http_reset_then_step_roundtrip():
     pytest.importorskip("openenv")
     from fastapi.testclient import TestClient