Upload folder using huggingface_hub

README.md

@@ -95,6 +95,12 @@ Each step returns:
 - `active_malicious_packages`: malicious packages not yet quarantined
 - `error`: optional action error reason
 
+The `data` field includes evaluator-facing telemetry:
+- `reward_type`: always `training_step_reward`
+- `benchmark_score`: deterministic task score computed from current state
+- `score_breakdown`: component ratios (`quarantine`, `rotate`, `notify`, `contain`)
+- `evaluator_metrics`: audit-friendly counts (invalid actions, fallback use, false positives, deadline status)
+
 ## Reward Design
 
 Dense reward shaping provides trajectory-level signal, not just terminal binary success.
@@ -119,6 +125,35 @@ Episode-end bonuses (on `conclude`/terminal):
 - contained before exfiltration: `+0.10`
 - attacker succeeds: `-0.20`
 
+## Mode and Fallback Architecture
+
+The environment supports explicit execution modes and safe fallbacks:
+
+- `mode=benchmark` (default): deterministic evaluation behavior for leaderboard runs.
+- `mode=training`: same state transitions with evaluator telemetry preserved for training analysis.
+- Unsupported mode values safely fallback to `benchmark`, and `mode_fallback_used=true` is exposed in `state` and `data.evaluator_metrics`.
+
+Command fallback can be enabled for robustness:
+- aliases like `inspect`, `deps`, `dependents`, `rotate` map to canonical commands.
+- fallback usage is counted in `command_fallback_used_count`.
+
+You can set defaults via environment variables:
+- `AGENTIC_SECURITY_LAB_MODE=benchmark|training`
+- `AGENTIC_SECURITY_LAB_COMMAND_FALLBACK=true|false`
+
+Or override at runtime via `POST /reset` body:
+- `mode`
+- `command_fallback_enabled`
+
+## Training Reward vs Benchmark Score
+
+The environment now separates learning signal from benchmark evaluation:
+
+- `reward` (per-step): **training reward** used for RL trajectories.
+- `benchmark_score` (in `observation.data`): deterministic score for evaluator reporting.
+
+This makes it clear that reward shaping drives behavior during episodes, while benchmark score reflects objective completion quality.
+
 ## Grader Definition (Deterministic)
 
 Task-level grading is deterministic and normalized to `[0, 1]` using explicit component completion ratios from final `state`.

inference.py

@@ -20,8 +20,10 @@ from typing import Optional
 
 import httpx
 from openai import OpenAI
-from graders import grade_easy, grade_hard, grade_medium
 
+# ── Configuration ──────────────────────────────────────────────────────────────
+# Defaults match what the hackathon validator injects.
+# HF_TOKEN is set automatically by the validator — do not hardcode it.
 API_BASE_URL = os.getenv("API_BASE_URL", "https://router.huggingface.co/v1")
 MODEL_NAME   = os.getenv("MODEL_NAME",   "Qwen/Qwen2.5-7B-Instruct")
 API_KEY      = os.getenv("HF_TOKEN") or os.getenv("API_KEY") or ""
@@ -30,7 +32,6 @@ ENV_BASE_URL = os.getenv("ENV_BASE_URL", "http://localhost:8000")
 ALL_TASKS = ["easy", "medium", "hard"]
 MAX_STEPS = 30
 BENCHMARK = "agentic-security-lab"
-SCORE_EPS = 1e-6
 
 SYSTEM_PROMPT = textwrap.dedent("""
     You are an expert security engineer responding to a supply-chain incident.
@@ -58,6 +59,8 @@ SYSTEM_PROMPT = textwrap.dedent("""
 """).strip()
 
 
+# ── Logging helpers ────────────────────────────────────────────────────────────
+
 def log_start(task: str, model: str) -> None:
     print(f"[START] task={task} env={BENCHMARK} model={model}", flush=True)
 
@@ -77,11 +80,13 @@ def log_end(success: bool, steps: int, score: float,
     rewards_str = ",".join(f"{r:.2f}" for r in rewards)
     print(
         f"[END] success={str(success).lower()} steps={steps} "
-        f"score={score:.6f} rewards={rewards_str}",
+        f"score={score:.2f} rewards={rewards_str}",
         flush=True,
     )
 
 
+# ── Environment helpers ────────────────────────────────────────────────────────
+
 def env_reset(http: httpx.Client, task_name: str) -> dict:
     r = http.post("/reset", json={"task_name": task_name})
     r.raise_for_status()
@@ -94,11 +99,7 @@ def env_step(http: httpx.Client, command: str, parameters: dict) -> dict:
     return r.json()
 
 
-def env_state(http: httpx.Client) -> dict:
-    r = http.get("/state")
-    r.raise_for_status()
-    return r.json()
-
+# ── Action parsing ─────────────────────────────────────────────────────────────
 
 def parse_action(raw: str) -> tuple:
     text = raw.strip()
@@ -112,6 +113,8 @@ def parse_action(raw: str) -> tuple:
         return "conclude", {}
 
 
+# ── Episode runner ─────────────────────────────────────────────────────────────
+
 def run_task(llm: OpenAI, http: httpx.Client, task_name: str) -> float:
     rewards = []
     step_n  = 0
@@ -130,6 +133,7 @@ def run_task(llm: OpenAI, http: httpx.Client, task_name: str) -> float:
 
         for step_n in range(1, MAX_STEPS + 1):
 
+            # ── LLM call — wrapped so a transient API error doesn't crash ──
             try:
                 resp = llm.chat.completions.create(
                     model       = MODEL_NAME,
@@ -139,12 +143,14 @@ def run_task(llm: OpenAI, http: httpx.Client, task_name: str) -> float:
                 )
                 raw = resp.choices[0].message.content or ""
             except Exception as llm_err:
+                # Treat LLM failure as a no-op conclude to end gracefully
                 raw = '{"command": "conclude", "parameters": {}}'
-                _ = llm_err
+                print(f"[DEBUG] LLM error at step {step_n}: {llm_err}", flush=True)
 
             command, params = parse_action(raw)
             action_str      = json.dumps({"command": command, "parameters": params})
 
+            # ── Environment step ───────────────────────────────────────────
             obs    = env_step(http, command, params)
             reward = float(obs.get("reward", 0.0))
             done   = bool(obs.get("done", False))
@@ -160,27 +166,20 @@ def run_task(llm: OpenAI, http: httpx.Client, task_name: str) -> float:
             if done:
                 break
 
-        final_state = env_state(http)
-        graders = {
-            "easy": grade_easy,
-            "medium": grade_medium,
-            "hard": grade_hard,
-        }
-        score = graders[task_name](final_state)
-        score = max(SCORE_EPS, min(1.0 - SCORE_EPS, score))
-        success = (
-            score >= 1.0 - SCORE_EPS
-            and not bool(final_state.get("attacker_succeeded", False))
-        )
-
-    except Exception:
+        score   = min(1.0, max(0.0, sum(rewards)))
+        success = score > 0.0
+
+    except Exception as exc:
+        # Always emit [END] — even on unexpected failure
         log_end(success=False, steps=step_n, score=0.0, rewards=rewards)
-        return 0.0
+        raise
 
     log_end(success=success, steps=step_n, score=score, rewards=rewards)
     return score
 
 
+# ── Entry point ────────────────────────────────────────────────────────────────
+
 def main() -> None:
     llm  = OpenAI(base_url=API_BASE_URL, api_key=API_KEY)
     http = httpx.Client(base_url=ENV_BASE_URL, timeout=60)
@@ -188,12 +187,17 @@ def main() -> None:
     task_env = os.getenv("TASK_NAME", "")
     tasks    = [task_env] if task_env in ALL_TASKS else ALL_TASKS
 
+    scores = {}
     try:
         for task in tasks:
-            run_task(llm, http, task)
+            scores[task] = run_task(llm, http, task)
     finally:
         http.close()
 
+    print("\n=== Baseline Results ===", flush=True)
+    for task, s in scores.items():
+        print(f"  {task:8s}  score={s:.2f}", flush=True)
+
 
 if __name__ == "__main__":
     main()

models.py

@@ -57,6 +57,10 @@ class AgenticSecurityLabState(BaseModel):
     step_count: int = 0
 
     task_name: str = ""
+    mode: str = "benchmark"
+    mode_fallback_used: bool = False
+    command_fallback_enabled: bool = True
+    command_fallback_used_count: int = 0
 
     packages:   dict[str, Any]       = {}   # name@version -> metadata
     dependents: dict[str, list[str]] = {}   # package      -> consumers
@@ -74,4 +78,8 @@ class AgenticSecurityLabState(BaseModel):
 
     total_reward:       float = 0.0
     incident_contained: bool  = False
-    attacker_succeeded: bool  = False
+    attacker_succeeded: bool  = False
+    invalid_action_count: int = 0
+    duplicate_action_count: int = 0
+    false_positive_quarantines: int = 0
+    critical_rotated_before_deadline: bool = False

server/agentic_security_lab_environment.py

@@ -33,6 +33,14 @@ from models import (
 )
 from scenarios import get_scenario
 
+VALID_MODES = {"benchmark", "training"}
+COMMAND_ALIASES = {
+    "inspect": "inspect_package",
+    "dependents": "check_dependents",
+    "deps": "check_dependents",
+    "rotate": "rotate_secret",
+}
+
 VALID_COMMANDS = {
     "inspect_package",
     "check_dependents",
@@ -47,22 +55,50 @@ VALID_COMMANDS = {
 class AgenticSecurityLabEnvironment:
     """Supply chain incident response RL environment."""
 
-    def __init__(self, task_name: str = "easy"):
+    def __init__(
+        self,
+        task_name: str = "easy",
+        mode: str = "benchmark",
+        command_fallback_enabled: bool = True,
+    ):
         self._task_name = task_name
         self._state     = AgenticSecurityLabState()
         self._scenario: dict[str, Any] = {}
-
-    def reset(self, task_name: str | None = None) -> AgenticSecurityLabObservation:
+        self._requested_mode = mode
+        self._command_fallback_enabled = command_fallback_enabled
+        self._mode_fallback_used = False
+
+    def _resolve_mode(self, mode: str) -> str:
+        if mode in VALID_MODES:
+            self._mode_fallback_used = False
+            return mode
+        self._mode_fallback_used = True
+        return "benchmark"
+
+    def reset(
+        self,
+        task_name: str | None = None,
+        mode: str | None = None,
+        command_fallback_enabled: bool | None = None,
+    ) -> AgenticSecurityLabObservation:
         if task_name:
             self._task_name = task_name
+        if mode is not None:
+            self._requested_mode = mode
+        if command_fallback_enabled is not None:
+            self._command_fallback_enabled = command_fallback_enabled
 
         sc = get_scenario(self._task_name)
         self._scenario = sc
+        resolved_mode = self._resolve_mode(self._requested_mode)
 
         self._state = AgenticSecurityLabState(
             episode_id        = str(uuid.uuid4()),
             step_count        = 0,
             task_name         = self._task_name,
+            mode              = resolved_mode,
+            mode_fallback_used = self._mode_fallback_used,
+            command_fallback_enabled = self._command_fallback_enabled,
             packages          = sc["packages"],
             dependents        = sc["dependents"],
             secrets           = sc["secrets"],
@@ -80,13 +116,22 @@ class AgenticSecurityLabEnvironment:
             result  = (
                 f"[INCIDENT ALERT]  Task: {self._task_name.upper()}\n"
                 f"{sc['description']}\n\n"
+                f"Execution mode   : {resolved_mode}"
+                + (" (fallback from unsupported mode)" if self._mode_fallback_used else "")
+                + "\n"
                 f"Packages in scope : {list(sc['packages'].keys())}\n"
                 f"Exfiltration in   : {sc['exfiltration_step']} steps "
                 f"(budget: {sc['max_steps']} steps total)\n\n"
                 f"Commands available: inspect_package, check_dependents, "
                 f"rotate_secret, quarantine, notify, scan_logs, conclude"
             ),
-            data                     = {"packages_in_scope": list(sc["packages"].keys())},
+            data                     = {
+                "packages_in_scope": list(sc["packages"].keys()),
+                "reward_type": "training_step_reward",
+                "benchmark_score": self._benchmark_score(),
+                "score_breakdown": self._benchmark_score_components(),
+                "evaluator_metrics": self._evaluator_metrics(),
+            },
             incident_summary         = f"Incident open. {len(malicious)} malicious package(s) suspected.",
             steps_remaining          = sc["exfiltration_step"],
             exposed_secrets          = exposed,
@@ -112,10 +157,14 @@ class AgenticSecurityLabEnvironment:
 
         cmd    = action.command.strip().lower()
         params = action.parameters
+        if self._state.command_fallback_enabled and cmd in COMMAND_ALIASES:
+            cmd = COMMAND_ALIASES[cmd]
+            self._state.command_fallback_used_count += 1
 
         if cmd not in VALID_COMMANDS:
             reward = -0.01
             s.total_reward += reward
+            s.invalid_action_count += 1
             return self._build_obs(
                 reward  = reward,
                 success = False,
@@ -200,6 +249,7 @@ class AgenticSecurityLabEnvironment:
         if s.secrets[secret]["rotated"]:
             reward = -0.02
             s.total_reward += reward
+            s.duplicate_action_count += 1
             return self._build_obs(reward, False,
                 f"Secret '{secret}' was already rotated.", steps_left)
 
@@ -208,6 +258,8 @@ class AgenticSecurityLabEnvironment:
         is_critical = s.secrets[secret]["critical"]
         reward = 0.12 if is_critical else 0.06
         s.total_reward += reward
+        if is_critical and s.step_count < s.exfiltration_step:
+            s.critical_rotated_before_deadline = True
 
         return self._build_obs(
             reward  = reward,
@@ -232,12 +284,14 @@ class AgenticSecurityLabEnvironment:
                 error="Package not found")
 
         if pkg in s.quarantined:
+            s.duplicate_action_count += 1
             return self._build_obs(-0.02, False,
                 f"'{pkg}' already quarantined.", steps_left)
 
         if not s.packages[pkg]["malicious"]:
             reward = -0.05
             s.total_reward += reward
+            s.false_positive_quarantines += 1
             return self._build_obs(reward, False,
                 f"⚠  False positive: '{pkg}' is NOT malicious. "
                 f"Unnecessary quarantine harms users.", steps_left)
@@ -270,6 +324,7 @@ class AgenticSecurityLabEnvironment:
                 error="Unknown team")
 
         if team in s.notified_teams:
+            s.duplicate_action_count += 1
             return self._build_obs(0.0, True,
                 f"Team '{team}' already notified.", steps_left)
 
@@ -364,7 +419,13 @@ class AgenticSecurityLabEnvironment:
             done     = done,
             reward   = reward,
             result   = result,
-            data     = data or {},
+            data     = {
+                **(data or {}),
+                "reward_type": "training_step_reward",
+                "benchmark_score": self._benchmark_score(),
+                "score_breakdown": self._benchmark_score_components(),
+                "evaluator_metrics": self._evaluator_metrics(),
+            },
             incident_summary = (
                 f"Step {s.step_count}/{s.max_steps}  |  "
                 f"Quarantined: {len(s.quarantined)}  |  "
@@ -386,6 +447,13 @@ class AgenticSecurityLabEnvironment:
             done     = True,
             reward   = reward,
             result   = result or "Episode ended.",
+            data     = {
+                "reward_type": "training_step_reward",
+                "benchmark_score": self._benchmark_score(),
+                "score_breakdown": self._benchmark_score_components(),
+                "evaluator_metrics": self._evaluator_metrics(),
+                "total_training_reward": s.total_reward,
+            },
             incident_summary = (
                 f"CLOSED  |  Steps: {s.step_count}  |  "
                 f"Total reward: {s.total_reward:.3f}"
@@ -393,4 +461,56 @@ class AgenticSecurityLabEnvironment:
             steps_remaining           = 0,
             exposed_secrets           = [k for k, v in s.secrets.items() if not v["rotated"]],
             active_malicious_packages = [],
-        )
+        )
+
+    def _benchmark_score_components(self) -> dict[str, float]:
+        s = self._state
+        req = self._scenario.get("required_actions", {})
+        q_required = req.get("quarantine", [])
+        r_required = req.get("rotate_secret", [])
+        n_required = req.get("notify", [])
+
+        def ratio(done: list[str], required: list[str]) -> float:
+            if not required:
+                return 1.0
+            return len(set(done) & set(required)) / float(len(required))
+
+        quarantine_ratio = ratio(s.quarantined, q_required)
+        rotate_ratio = ratio(s.rotated_secrets, r_required)
+        notify_ratio = ratio(s.notified_teams, n_required)
+        contain_ratio = 1.0 if not s.attacker_succeeded else 0.0
+        return {
+            "quarantine_ratio": quarantine_ratio,
+            "rotate_ratio": rotate_ratio,
+            "notify_ratio": notify_ratio,
+            "contain_ratio": contain_ratio,
+        }
+
+    def _benchmark_score(self) -> float:
+        c = self._benchmark_score_components()
+        score = (
+            0.35 * c["quarantine_ratio"]
+            + 0.35 * c["rotate_ratio"]
+            + 0.20 * c["notify_ratio"]
+            + 0.10 * c["contain_ratio"]
+        )
+        return max(0.0, min(1.0, round(score, 6)))
+
+    def _evaluator_metrics(self) -> dict[str, Any]:
+        s = self._state
+        return {
+            "task_name": s.task_name,
+            "mode": s.mode,
+            "mode_fallback_used": s.mode_fallback_used,
+            "command_fallback_enabled": s.command_fallback_enabled,
+            "command_fallback_used_count": s.command_fallback_used_count,
+            "invalid_action_count": s.invalid_action_count,
+            "duplicate_action_count": s.duplicate_action_count,
+            "false_positive_quarantines": s.false_positive_quarantines,
+            "critical_rotated_before_deadline": s.critical_rotated_before_deadline,
+            "attacker_succeeded": s.attacker_succeeded,
+            "steps_taken": s.step_count,
+            "steps_budget": s.max_steps,
+            "steps_to_exfiltration": max(0, s.exfiltration_step - s.step_count),
+            "total_training_reward": round(s.total_reward, 6),
+        }

server/app.py

@@ -13,8 +13,14 @@ from models import (
 from server.agentic_security_lab_environment import AgenticSecurityLabEnvironment
 
 TASK_NAME = os.getenv("TASK_NAME", "easy")
+MODE = os.getenv("AGENTIC_SECURITY_LAB_MODE", "benchmark")
+COMMAND_FALLBACK = os.getenv("AGENTIC_SECURITY_LAB_COMMAND_FALLBACK", "true").lower() in {"1", "true", "yes"}
 
-env = AgenticSecurityLabEnvironment(task_name=TASK_NAME)
+env = AgenticSecurityLabEnvironment(
+    task_name=TASK_NAME,
+    mode=MODE,
+    command_fallback_enabled=COMMAND_FALLBACK,
+)
 
 app = FastAPI(
     title="Agentic Security Lab — Supply Chain Incident Response",
@@ -29,6 +35,8 @@ app = FastAPI(
 
 class ResetRequest(BaseModel):
     task_name: str | None = None
+    mode: str | None = None
+    command_fallback_enabled: bool | None = None
 
 
 class StepRequest(BaseModel):
@@ -38,7 +46,11 @@ class StepRequest(BaseModel):
 
 @app.post("/reset", response_model=AgenticSecurityLabObservation)
 def reset(req: ResetRequest = ResetRequest()):
-    return env.reset(task_name=req.task_name)
+    return env.reset(
+        task_name=req.task_name,
+        mode=req.mode,
+        command_fallback_enabled=req.command_fallback_enabled,
+    )
 
 
 @app.post("/step", response_model=AgenticSecurityLabObservation)
@@ -54,7 +66,12 @@ def state():
 
 @app.get("/health")
 def health():
-    return {"status": "ok", "task": env.state.task_name}
+    return {
+        "status": "ok",
+        "task": env.state.task_name,
+        "mode": env.state.mode,
+        "mode_fallback_used": env.state.mode_fallback_used,
+    }
 
 
 @app.get("/")