Spaces:

Uddiii
/

Multi-Agentic

Runtime error

App Files Files Community

Uddiii commited on Apr 26

Commit

7a90355

1 Parent(s): a3804d9

Submission-ready: README, blog, training pipeline, baseline evidence, OpenEnv compliance

Browse files

Files changed (28) hide show

ER_MAP/dashboard.py +57 -3
ER_MAP/envs/__init__.py +15 -1
ER_MAP/envs/openenv_triage/Dockerfile +51 -0
ER_MAP/envs/openenv_triage/README.md +145 -0
ER_MAP/envs/openenv_triage/__init__.py +52 -0
ER_MAP/envs/openenv_triage/client.py +201 -0
ER_MAP/envs/openenv_triage/env.py +295 -0
ER_MAP/envs/openenv_triage/models.py +279 -0
ER_MAP/envs/openenv_triage/openenv.yaml +44 -0
ER_MAP/envs/openenv_triage/server-requirements.txt +12 -0
ER_MAP/envs/openenv_triage/server.py +312 -0
ER_MAP/envs/openenv_triage/tests/__init__.py +0 -0
ER_MAP/envs/openenv_triage/tests/test_parity.py +306 -0
ER_MAP/requirements.txt +4 -1
ER_MAP/server.py +6 -0
EVALUATION.md +218 -0
LICENSE +21 -0
Makefile +19 -0
README.md +174 -231
blog.md +312 -0
kaggle/requirements_kaggle.txt +5 -6
mermaid_render.html +102 -0
openenv.yaml +36 -0
requirements.txt +37 -0
setup.py +42 -0
training_per2.png +3 -0
training_perf3.png +3 -0
training_performance1.png +3 -0

ER_MAP/dashboard.py CHANGED Viewed

@@ -616,6 +616,7 @@ def new_episode():
     # NOTE: ground_truth is intentionally NOT returned to the browser —
     # disease, emergency status, and personas live on the CMD terminal only.
     return jsonify({
         "status": "ok",
         "conversation": EPISODE_STATE["conversation"],
@@ -626,6 +627,11 @@ def new_episode():
         "phase_order": PHASE_ORDER,
         "difficulty": options.get("difficulty") or "random",
         "phase": phase,
     })
@@ -974,6 +980,7 @@ HTML_PAGE = r"""<!DOCTYPE html>
       const [phasesDone, setPhasesDone]       = useState([]);
       const [currentPhase, setCurrentPhase]   = useState(null);
       const [outcome, setOutcome]             = useState(null);
       // refs (audio + loop control — never trigger re-render)
       const audioQueueRef    = useRef([]);
@@ -1065,6 +1072,7 @@ HTML_PAGE = r"""<!DOCTYPE html>
             body: JSON.stringify({ phase }),
           });
           const data = await res.json();
           renderedCountRef.current = (data.conversation || []).length;
         } catch (e) {
           console.error('new_episode failed', e);
@@ -1160,7 +1168,7 @@ HTML_PAGE = r"""<!DOCTYPE html>
               </div>
               {/* Open State */}
-              <div className={`absolute inset-0 w-[350px] p-6 flex flex-col transition-opacity duration-300 ${isSidebarOpen ? 'opacity-100 delay-100' : 'opacity-0 pointer-events-none'}`}>
                 {/* Header + close */}
                 <div className="flex items-center justify-between mb-8 cursor-pointer group"
                      onClick={(e) => { e.stopPropagation(); setIsSidebarOpen(false); }}>
@@ -1201,7 +1209,7 @@ HTML_PAGE = r"""<!DOCTYPE html>
                 </div>
                 {/* Section B: Clinical Phases */}
-                <div className="flex-1 flex flex-col">
                   <h3 className="text-xs font-semibold text-slate-300 uppercase tracking-wider mb-4">Clinical Phases</h3>
                   <div className="space-y-3.5">
                     {PHASES.map(({ key, label }, i) => {
@@ -1224,6 +1232,52 @@ HTML_PAGE = r"""<!DOCTYPE html>
                     })}
                   </div>
                 </div>
               </div>
             </div>
@@ -1245,7 +1299,7 @@ HTML_PAGE = r"""<!DOCTYPE html>
                     <button
                       onClick={startCase}
                       className="bg-indigo-600 hover:bg-indigo-500 text-white text-[11px] font-semibold tracking-wider uppercase px-3 py-1.5 rounded-lg transition flex items-center gap-1.5 shadow-[0_4px_12px_rgba(99,102,241,0.3)]">
-                      <span>▶</span> Start Case
                     </button>
                   </>
                 ) : (

     # NOTE: ground_truth is intentionally NOT returned to the browser —
     # disease, emergency status, and personas live on the CMD terminal only.
+    # However, we now surface sanitized behavior traits for the 'God's View'.
     return jsonify({
         "status": "ok",
         "conversation": EPISODE_STATE["conversation"],
         "phase_order": PHASE_ORDER,
         "difficulty": options.get("difficulty") or "random",
         "phase": phase,
+        "persona": {
+            "patient": gt.get("patient", {}),
+            "nurse": gt.get("nurse", {}),
+            "is_emergency": gt.get("disease", {}).get("is_emergency", False),
+        }
     })
       const [phasesDone, setPhasesDone]       = useState([]);
       const [currentPhase, setCurrentPhase]   = useState(null);
       const [outcome, setOutcome]             = useState(null);
+      const [persona, setPersona]             = useState(null);
       // refs (audio + loop control — never trigger re-render)
       const audioQueueRef    = useRef([]);
             body: JSON.stringify({ phase }),
           });
           const data = await res.json();
+          setPersona(data.persona);
           renderedCountRef.current = (data.conversation || []).length;
         } catch (e) {
           console.error('new_episode failed', e);
               </div>
               {/* Open State */}
+              <div className={`absolute inset-0 w-[350px] p-6 flex flex-col transition-opacity duration-300 overflow-y-auto custom-scrollbar ${isSidebarOpen ? 'opacity-100 delay-100' : 'opacity-0 pointer-events-none'}`}>
                 {/* Header + close */}
                 <div className="flex items-center justify-between mb-8 cursor-pointer group"
                      onClick={(e) => { e.stopPropagation(); setIsSidebarOpen(false); }}>
                 </div>
                 {/* Section B: Clinical Phases */}
+                <div className="mt-8 mb-8">
                   <h3 className="text-xs font-semibold text-slate-300 uppercase tracking-wider mb-4">Clinical Phases</h3>
                   <div className="space-y-3.5">
                     {PHASES.map(({ key, label }, i) => {
                     })}
                   </div>
                 </div>
+                {/* Section C: Agent Personas */}
+                {persona && (
+                  <div className="border-t border-slate-800/50 pt-6 pb-4">
+                    <div className="flex items-center justify-between mb-4">
+                      <h3 className="text-xs font-semibold text-slate-300 uppercase tracking-wider">Agent Personas</h3>
+                      {persona.is_emergency ? (
+                        <span className="text-[9px] font-bold uppercase tracking-wider px-2 py-0.5 rounded-full bg-red-500/20 text-red-400 border border-red-500/30 animate-pulse shadow-[0_0_8px_rgba(248,113,113,0.3)]">🚨 EMERGENCY</span>
+                      ) : (
+                        <span className="text-[9px] font-bold uppercase tracking-wider px-2 py-0.5 rounded-full bg-emerald-500/20 text-emerald-400 border border-emerald-500/30">Non-Emergency</span>
+                      )}
+                    </div>
+                    <div className="space-y-6">
+                      {/* Patient */}
+                      <div>
+                        <div className="flex items-center gap-2 mb-2">
+                          <User className="w-3 h-3 text-teal-400" />
+                          <span className="text-[10px] font-bold text-teal-400/80 uppercase tracking-tight">Patient Traits</span>
+                        </div>
+                        <div className="grid grid-cols-2 gap-2">
+                          {Object.entries(persona.patient).map(([k, v]) => (
+                            <div key={k} className="bg-slate-950/40 border border-slate-800/30 rounded-lg p-2">
+                              <div className="text-[9px] text-slate-500 uppercase leading-none mb-1">{k}</div>
+                              <div className="text-[10px] text-slate-300 font-medium leading-tight truncate">{v.replace(/_/g, ' ')}</div>
+                            </div>
+                          ))}
+                        </div>
+                      </div>
+                      {/* Nurse */}
+                      <div>
+                        <div className="flex items-center gap-2 mb-2">
+                          <Activity className="w-3 h-3 text-blue-400" />
+                          <span className="text-[10px] font-bold text-blue-400/80 uppercase tracking-tight">Nurse Traits</span>
+                        </div>
+                        <div className="grid grid-cols-2 gap-2">
+                          {Object.entries(persona.nurse).map(([k, v]) => (
+                            <div key={k} className="bg-slate-950/40 border border-slate-800/30 rounded-lg p-2">
+                              <div className="text-[9px] text-slate-500 uppercase leading-none mb-1">{k}</div>
+                              <div className="text-[10px] text-slate-300 font-medium leading-tight truncate">{v.replace(/_/g, ' ')}</div>
+                            </div>
+                          ))}
+                        </div>
+                      </div>
+                    </div>
+                  </div>
+                )}
               </div>
             </div>
                     <button
                       onClick={startCase}
                       className="bg-indigo-600 hover:bg-indigo-500 text-white text-[11px] font-semibold tracking-wider uppercase px-3 py-1.5 rounded-lg transition flex items-center gap-1.5 shadow-[0_4px_12px_rgba(99,102,241,0.3)]">
+                      Start Case
                     </button>
                   </>
                 ) : (

ER_MAP/envs/__init__.py CHANGED Viewed

@@ -5,4 +5,18 @@ from .triage_env import TriageEnv
 from .randomizer import generate_ground_truth, construct_prompts
 from .api_router import AgentRouter
-__all__ = ["TriageEnv", "generate_ground_truth", "construct_prompts", "AgentRouter"]

 from .randomizer import generate_ground_truth, construct_prompts
 from .api_router import AgentRouter
+# OpenEnv-compliant wrapper. Imported via try/except so users without
+# the optional ``openenv-core`` dependency (e.g. the running Kaggle
+# training job) keep working unchanged.
+try:  # pragma: no cover - import-time soft fail
+    from .openenv_triage import TriageOpenEnv  # noqa: F401
+except ImportError:
+    TriageOpenEnv = None  # type: ignore[assignment]
+__all__ = [
+    "TriageEnv",
+    "TriageOpenEnv",
+    "generate_ground_truth",
+    "construct_prompts",
+    "AgentRouter",
+]

ER_MAP/envs/openenv_triage/Dockerfile ADDED Viewed

	@@ -0,0 +1,51 @@

+# Dockerfile for ER-MAP TriageOpenEnv
+#
+# Pattern follows the recommended HF Spaces / OpenEnv standalone build:
+# - slim Python base
+# - install openenv-core + project deps from requirements.txt
+# - copy the ER_MAP package (so ``ER_MAP.envs.openenv_triage.server:app``
+#   resolves at runtime)
+# - expose 8000 and run uvicorn
+#
+# Reference Dockerfile (echo_env, multi-stage uv build):
+#   https://github.com/meta-pytorch/OpenEnv/blob/main/envs/echo_env/server/Dockerfile
+#
+# We use a single-stage slim image here because the project's
+# requirements.txt is small and the multi-stage uv flow adds complexity
+# that isn't justified for this environment. The HF Space build keeps
+# layer caching by separating the requirements install step.
+FROM python:3.11-slim AS runtime
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PORT=8000 \
+    HOST=0.0.0.0
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends curl \
+    && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
+# --- Install Python deps (cached when requirements.txt is unchanged) ---
+COPY ER_MAP/envs/openenv_triage/server-requirements.txt /tmp/server-requirements.txt
+RUN pip install --upgrade pip \
+    && pip install -r /tmp/server-requirements.txt
+# --- Copy the ER_MAP package ---
+# We keep the full ER_MAP package importable so the wrapper can reach
+# ``ER_MAP.envs.triage_env`` and supporting modules.
+COPY ER_MAP /app/ER_MAP
+ENV PYTHONPATH=/app
+EXPOSE 8000
+# Health check uses the OpenEnv-provided /health route.
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+CMD ["uvicorn", "ER_MAP.envs.openenv_triage.server:app", "--host", "0.0.0.0", "--port", "8000"]

ER_MAP/envs/openenv_triage/README.md ADDED Viewed

	@@ -0,0 +1,145 @@

+# ER-MAP Triage - OpenEnv Wrapper
+This package wraps the existing in-house Gymnasium `TriageEnv`
+(`ER_MAP/envs/triage_env.py`) so it can be served through the
+[OpenEnv](https://github.com/meta-pytorch/OpenEnv) protocol
+(`openenv-core>=0.2.3`, latest as of April 2026).
+The wrapper does **not** modify the underlying environment - the same
+LoRA currently being trained against the gym env on Kaggle runs unchanged
+behind this OpenEnv server because both share the exact same `TriageEnv`
+instance, reward semantics, and observation format.
+## What's in here
+| File                       | Purpose                                                                   |
+|----------------------------|---------------------------------------------------------------------------|
+| `models.py`                | `TriageAction`, `TriageObservation`, `TriageState` (Pydantic v2)          |
+| `env.py`                   | `TriageOpenEnv` - `Environment` subclass delegating to `TriageEnv`        |
+| `server.py`                | FastAPI app exposed via OpenEnv's `create_app` helper                     |
+| `client.py`                | Thin `requests`-based `TriageOpenEnvClient`                               |
+| `openenv.yaml`             | OpenEnv manifest (HF Space deployment target)                             |
+| `Dockerfile`               | HF Space / Docker image (Python 3.11-slim)                                |
+| `server-requirements.txt`  | Container-side pip requirements                                           |
+| `tests/test_parity.py`     | pytest parity tests (gym vs wrapper, in-proc vs HTTP)                     |
+## Usage
+### 1. Local Python (direct, no HTTP)
+```python
+from ER_MAP.envs.openenv_triage import TriageOpenEnv, TriageAction
+env = TriageOpenEnv()
+obs = env.reset(seed=0, options={"phase": 1, "difficulty": "easy"})
+print(obs.event, obs.payload)
+action = TriageAction.from_json_str(
+    '{"tool": "speak_to", "target": "patient", "message": "Hello"}'
+)
+obs = env.step(action)
+print(obs.reward, obs.done, obs.info["reward_components"])
+```
+### 2. Local HTTP (FastAPI + client)
+Start the server:
+```bash
+uvicorn ER_MAP.envs.openenv_triage.server:app --host 0.0.0.0 --port 8000
+```
+Drive it with the bundled client:
+```python
+from ER_MAP.envs.openenv_triage import TriageOpenEnvClient, TriageAction
+with TriageOpenEnvClient(base_url="http://localhost:8000") as client:
+    print(client.health())
+    result = client.reset(seed=0, options={"phase": 1, "difficulty": "easy"})
+    action = TriageAction.from_json_str('{"tool": "read_soap"}')
+    result = client.step(action)
+    print(result.reward, result.observation.event)
+```
+The HTTP wire format matches OpenEnv 0.2.3:
+- `POST /reset` body  `{"seed": int?, "episode_id": str?, "options": {...}?}`
+- `POST /step`  body  `{"action": {"tool": "...", ...}, "timeout_s": float?}`
+- `GET  /state` -> serialized `TriageState`
+- `GET  /health` -> `{"status": "healthy"}`
+- `GET  /healthz` -> richer status (version + stub-mode flag)
+OpenEnv-style WebSocket clients can also connect to `WS /ws` (provided by
+`HTTPEnvServer.register_routes`).
+### 3. Hugging Face Space deployment
+The repo follows the OpenEnv manifest convention; a single command pushes
+to a Space:
+```bash
+# from the repo root
+openenv push --repo-id <hf-username>/er-map-triage
+```
+(See `openenv push --help` from `openenv-core>=0.2.3` for options like
+`--private` and `--tag`.)
+To deploy manually with Docker:
+```bash
+docker build -t er-map-triage:latest -f ER_MAP/envs/openenv_triage/Dockerfile .
+docker run --rm -p 8000:8000 \
+    -e GROQ_API_KEY=$GROQ_API_KEY \
+    er-map-triage:latest
+```
+## Stub mode (keyless deployment)
+The underlying `AgentRouter` already gracefully handles the no-Groq case:
+when no key is configured, it returns deterministic canned Nurse/Patient
+JSON responses (see `AgentRouter._mock_response`) and the LLM judges
+return neutral default scores. This is what we call "stub mode".
+- **Stub mode** is automatic: leave all `GROQ_*` vars unset.
+- **Live mode**: set `GROQ_API_KEY` (and optionally per-role keys
+  `GROQ_NURSE_API_KEY`, `GROQ_PATIENT_API_KEY`,
+  `GROQ_EMPATHY_JUDGE_API_KEY`, `GROQ_MEDICAL_JUDGE_API_KEY`).
+The `/healthz` endpoint reports `{"stub_mode": true|false}` so HF Space
+visitors can tell which configuration the running container is in.
+## Parity guarantees
+`TriageOpenEnv.step` produces **byte-identical** observations and rewards
+to the gym `TriageEnv.step` for the same seed and action sequence, because
+the wrapper:
+1. Replays the original Doctor JSON string verbatim into the gym env
+   (via `TriageAction.raw_json`), so `_parse_doctor_action` sees exactly
+   the bytes the policy emitted.
+2. Forwards the gym 5-tuple `(obs, reward, done, truncated, info)`
+   unchanged - `done` and `reward` go on the OpenEnv `Observation`,
+   `truncated` and the full `info` dict (including `reward_components`)
+   are folded into `Observation.metadata` / `Observation.info`.
+This is verified by `tests/test_parity.py`.
+## Reserved tool names (OpenEnv brief)
+Per the OpenEnv brief, MCP tool names `reset`, `step`, `state`, `close`
+are reserved. This wrapper deliberately **does not** subclass
+`MCPEnvironment` and does **not** register any MCP tools, so no name
+collision is possible. The Doctor's tool names (`speak_to`, `order_lab`,
+`read_soap`, `update_soap`, `terminal_discharge`) live inside the
+`TriageAction.tool` field, not in any MCP namespace.
+## Citations
+- `openenv-core==0.2.3` PyPI release - <https://pypi.org/project/openenv-core/>
+- `Environment` base class - <https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/interfaces.py>
+- `Action`/`Observation`/`State` types - <https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/types.py>
+- `create_app` helper - <https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/http_server.py>
+- echo_env exemplar (`openenv.yaml`, `Dockerfile`, server layout) - <https://github.com/meta-pytorch/OpenEnv/tree/main/envs/echo_env>
+- `RESERVED_TOOL_NAMES` - <https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/mcp_types.py>

ER_MAP/envs/openenv_triage/__init__.py ADDED Viewed

	@@ -0,0 +1,52 @@

+"""
+ER_MAP/envs/openenv_triage
+==========================
+OpenEnv-compliant wrapper around the existing Gymnasium ``TriageEnv``.
+This package adapts the in-process gym env to the OpenEnv interface
+(``openenv-core>=0.2.3``) without modifying the underlying environment,
+so the same LoRA trained against ``ER_MAP.envs.triage_env.TriageEnv``
+runs unchanged against ``TriageOpenEnv``.
+Public surface
+--------------
+- :class:`TriageOpenEnv`        - Server-side OpenEnv ``Environment`` subclass.
+- :class:`TriageAction`         - Pydantic ``Action`` mirroring the Doctor's JSON schema.
+- :class:`TriageObservation`    - Pydantic ``Observation`` exposing the structured Doctor view.
+- :class:`TriageState`          - Pydantic ``State`` exposing the internal episode state.
+- :class:`TriageOpenEnvClient`  - Thin HTTP client (no server-internal imports).
+References
+----------
+- OpenEnv canonical repo:        https://github.com/meta-pytorch/OpenEnv
+- ``Environment`` interface:     ``openenv.core.env_server.interfaces.Environment``
+- ``Action`` / ``Observation``:  ``openenv.core.env_server.types``
+- echo_env exemplar:             https://github.com/meta-pytorch/OpenEnv/tree/main/envs/echo_env
+"""
+from __future__ import annotations
+from .models import TriageAction, TriageObservation, TriageState
+# ``env`` and ``client`` import openenv-core (a heavy dep). Guard those
+# behind try/except so plain users of the gym TriageEnv (e.g. the running
+# Kaggle training session) are unaffected if openenv-core is not installed.
+try:
+    from .env import TriageOpenEnv  # noqa: F401
+except Exception:  # pragma: no cover - import-time soft fail
+    TriageOpenEnv = None  # type: ignore[assignment]
+try:
+    from .client import TriageOpenEnvClient  # noqa: F401
+except Exception:  # pragma: no cover
+    TriageOpenEnvClient = None  # type: ignore[assignment]
+__all__ = [
+    "TriageAction",
+    "TriageObservation",
+    "TriageState",
+    "TriageOpenEnv",
+    "TriageOpenEnvClient",
+]

ER_MAP/envs/openenv_triage/client.py ADDED Viewed

	@@ -0,0 +1,201 @@

+"""
+ER_MAP/envs/openenv_triage/client.py
+====================================
+Thin HTTP client for the :class:`TriageOpenEnv` FastAPI server.
+This client deliberately avoids importing any server-internal modules
+(``server.py``, ``env.py``, etc.) so it can be packaged independently
+(per the OpenEnv hackathon brief: "clients should never import server
+internals").
+Wire format matches OpenEnv 0.2.3's HTTP routes registered by
+``HTTPEnvServer.register_routes`` -
+https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/http_server.py:
+- ``POST /reset``  body:  {seed?, episode_id?, options?, ...}
+                  reply: {observation, reward, done}
+- ``POST /step``   body:  {action: <action_fields>, timeout_s?, ...}
+                  reply: {observation, reward, done}
+- ``GET  /state``  reply: {observation: <state fields>, reward: null, done: false}
+- ``GET  /health`` reply: {status: "healthy"}
+Returns
+-------
+``reset`` and ``step`` both return a :class:`StepResult` with the parsed
+:class:`TriageObservation`. ``state`` returns a :class:`TriageState`.
+"""
+from __future__ import annotations
+import logging
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+import requests
+# The client only depends on the public Pydantic models in this package.
+# It does NOT import env.py / server.py.
+from .models import TriageAction, TriageObservation, TriageState
+logger = logging.getLogger("ER_MAP.openenv_triage.client")
+@dataclass
+class StepResult:
+    """
+    Parsed envelope returned by ``reset`` and ``step``.
+    Mirrors OpenEnv's ``StepResult`` semantics (observation + reward +
+    done) without forcing the caller to depend on ``openenv-core`` at
+    runtime. Aliases of the underlying gym 5-tuple are also available
+    via :attr:`observation`'s ``truncated`` / ``info`` fields.
+    """
+    observation: TriageObservation
+    reward: Optional[float]
+    done: bool
+    @property
+    def truncated(self) -> bool:
+        return bool(self.observation.truncated)
+    @property
+    def info(self) -> Dict[str, Any]:
+        return dict(self.observation.info)
+class TriageOpenEnvClient:
+    """
+    Synchronous HTTP client for ER-MAP's OpenEnv-compliant Triage server.
+    Example
+    -------
+    >>> client = TriageOpenEnvClient(base_url="http://localhost:8000")
+    >>> client.health()
+    {'status': 'healthy', ...}
+    >>> result = client.reset(seed=0, options={"phase": 1, "difficulty": "easy"})
+    >>> action = TriageAction.from_json_str('{"tool": "read_soap"}')
+    >>> result = client.step(action)
+    >>> print(result.observation.event, result.reward)
+    """
+    def __init__(
+        self,
+        base_url: str = "http://localhost:8000",
+        *,
+        timeout_s: float = 60.0,
+        session: Optional[requests.Session] = None,
+    ) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.timeout_s = timeout_s
+        self._session = session or requests.Session()
+    # ------------------------------------------------------------------
+    # Connection helpers
+    # ------------------------------------------------------------------
+    def _url(self, path: str) -> str:
+        return f"{self.base_url}{path}"
+    def health(self) -> Dict[str, Any]:
+        resp = self._session.get(self._url("/health"), timeout=self.timeout_s)
+        resp.raise_for_status()
+        return resp.json()
+    def healthz(self) -> Dict[str, Any]:
+        """Richer health endpoint exposed by our FastAPI app."""
+        resp = self._session.get(self._url("/healthz"), timeout=self.timeout_s)
+        resp.raise_for_status()
+        return resp.json()
+    # ------------------------------------------------------------------
+    # OpenEnv core operations
+    # ------------------------------------------------------------------
+    def reset(
+        self,
+        *,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        options: Optional[Dict[str, Any]] = None,
+        **extra: Any,
+    ) -> StepResult:
+        body: Dict[str, Any] = {}
+        if seed is not None:
+            body["seed"] = seed
+        if episode_id is not None:
+            body["episode_id"] = episode_id
+        if options is not None:
+            body["options"] = options
+        body.update(extra)
+        resp = self._session.post(
+            self._url("/reset"), json=body, timeout=self.timeout_s
+        )
+        resp.raise_for_status()
+        return self._parse_step_response(resp.json())
+    def step(self, action: TriageAction, *, timeout_s: Optional[float] = None) -> StepResult:
+        # The server expects the action under "action" (per StepRequest).
+        # Use ``model_dump`` so Pydantic-typed fields are JSON-serialized
+        # exactly as the server's ``deserialize_action`` expects.
+        action_payload = action.model_dump(exclude_none=True, exclude={"metadata"})
+        body: Dict[str, Any] = {"action": action_payload}
+        if timeout_s is not None:
+            body["timeout_s"] = timeout_s
+        resp = self._session.post(
+            self._url("/step"), json=body, timeout=self.timeout_s
+        )
+        resp.raise_for_status()
+        return self._parse_step_response(resp.json())
+    def state(self) -> TriageState:
+        resp = self._session.get(self._url("/state"), timeout=self.timeout_s)
+        resp.raise_for_status()
+        data = resp.json()
+        # ``HTTPEnvServer`` wraps the state as
+        # ``{"observation": {...state fields...}, "reward": None, "done": ...}``
+        # via ``serialize_observation``-equivalent path. Some versions
+        # return the state directly; tolerate both.
+        if isinstance(data, dict) and "observation" in data and "reward" in data:
+            state_dict = data["observation"]
+        else:
+            state_dict = data
+        return TriageState.model_validate(state_dict)
+    # ------------------------------------------------------------------
+    # Context manager sugar
+    # ------------------------------------------------------------------
+    def close(self) -> None:
+        self._session.close()
+    def __enter__(self) -> "TriageOpenEnvClient":
+        return self
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+    @staticmethod
+    def _parse_step_response(payload: Dict[str, Any]) -> StepResult:
+        obs_dict = payload.get("observation") or {}
+        obs = TriageObservation.model_validate(obs_dict)
+        reward = payload.get("reward")
+        # OpenEnv's serialize_observation strips ``done``/``reward`` from
+        # the observation dict, so ``done`` lives at the envelope level.
+        done = bool(payload.get("done", False))
+        # Make sure obs.done agrees with the envelope.
+        if obs.done != done:
+            obs.done = done
+        if reward is not None and obs.reward is None:
+            obs.reward = float(reward)
+        return StepResult(observation=obs, reward=reward, done=done)
+__all__ = ["TriageOpenEnvClient", "StepResult"]

ER_MAP/envs/openenv_triage/env.py ADDED Viewed

	@@ -0,0 +1,295 @@

+"""
+ER_MAP/envs/openenv_triage/env.py
+=================================
+OpenEnv ``Environment`` subclass that delegates to the existing in-process
+Gymnasium ``TriageEnv`` so a LoRA trained against the gym env can run
+unchanged behind the OpenEnv HTTP/WebSocket protocol.
+Citations (verified against the canonical OpenEnv repo & PyPI as of
+April 2026):
+- ``Environment`` interface (abstract ``reset`` / ``step`` / ``state``):
+  https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/interfaces.py
+  -> ``class Environment(ABC, Generic[ActT, ObsT, StateT]): ...``
+  -> ``reset(seed, episode_id, **kwargs) -> ObsT``
+  -> ``step(action, timeout_s=None, **kwargs) -> ObsT``  (single-return; reward/done live on the Observation)
+  -> ``@property state`` returning the State subclass
+  -> ``close()`` is overridable (default no-op).
+- ``Action`` / ``Observation`` / ``State`` Pydantic bases:
+  https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/types.py
+- ``serialize_observation`` strips ``reward``/``done``/``metadata`` from
+  the observation dict and emits ``{"observation", "reward", "done"}``:
+  https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/serialization.py
+- ``RESERVED_TOOL_NAMES`` (``reset`` / ``step`` / ``state`` / ``close``)
+  must NOT be used as MCP tool names:
+  https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/mcp_types.py
+- echo_env exemplar (showing ``MCPEnvironment`` / ``Environment`` class layout):
+  https://github.com/meta-pytorch/OpenEnv/tree/main/envs/echo_env
+- pyproject pinning ``openenv-core==0.2.3`` (latest as of April 2026):
+  https://github.com/meta-pytorch/OpenEnv/blob/main/pyproject.toml
+We do NOT subclass ``MCPEnvironment`` because the wrapped env is not a
+tool-server: the Doctor agent emits a single structured ``TriageAction``
+per step (closer to BlackJack/Wordle semantics than to coding_env's
+tools/list+tools/call shape). ``Environment`` is the right base.
+Key parity rule
+---------------
+The gym ``TriageEnv.step(action: str)`` returns the canonical 5-tuple
+``(obs_str, reward, done, truncated, info)``. The OpenEnv ``Observation``
+has ``done`` and ``reward`` first-class but NO truncated flag, so we fold
+``truncated`` and ``info`` (including ``reward_components``) into the
+observation's ``metadata`` and ``info`` fields so callers can recover the
+exact gym tuple. Same trajectory + same seed -> identical rewards.
+"""
+from __future__ import annotations
+import json
+import logging
+import os
+import uuid
+from typing import Any, Dict, Optional
+# OpenEnv 0.2.3 ships the abstract ``Environment`` base under
+# ``openenv.core.env_server.interfaces``. See citation block above.
+from openenv.core.env_server.interfaces import Environment
+from ER_MAP.envs.triage_env import TriageEnv
+from .models import TriageAction, TriageObservation, TriageState
+logger = logging.getLogger("ER_MAP.openenv_triage.env")
+def _stub_env_kwargs() -> Dict[str, Any]:
+    """
+    Build env kwargs that allow the env to operate without Groq keys.
+    The underlying ``AgentRouter`` already has a degraded fallback path
+    (``_mock_response``) when no Groq client is configured, so handing it
+    empty keys is sufficient. The stub mode is documented in the README.
+    """
+    return {
+        "groq_api_key": os.environ.get("GROQ_API_KEY", "") or None,
+        "nurse_api_key": os.environ.get("GROQ_NURSE_API_KEY", "") or None,
+        "patient_api_key": os.environ.get("GROQ_PATIENT_API_KEY", "") or None,
+        "empathy_judge_api_key": os.environ.get("GROQ_EMPATHY_JUDGE_API_KEY", "") or None,
+        "medical_judge_api_key": os.environ.get("GROQ_MEDICAL_JUDGE_API_KEY", "") or None,
+        "model": os.environ.get("ERMAP_MODEL", "llama-3.3-70b-versatile"),
+    }
+def _parse_obs_json(obs_str: str) -> Dict[str, Any]:
+    """Best-effort parse of the gym env's JSON observation string."""
+    try:
+        return json.loads(obs_str)
+    except (json.JSONDecodeError, TypeError):
+        return {"event": "raw", "raw": obs_str}
+class TriageOpenEnv(Environment[TriageAction, TriageObservation, TriageState]):
+    """
+    OpenEnv-compliant wrapper around ``ER_MAP.envs.triage_env.TriageEnv``.
+    Internally instantiates one ``TriageEnv`` per session. Reset/step
+    delegate to the gym env unchanged so reward semantics, termination
+    rules, and trajectory contents stay byte-identical to the gym
+    baseline used by ``training/train_grpo.py``.
+    """
+    # ``HTTPEnvServer`` instantiates a fresh environment per WebSocket
+    # session (see ``http_server.py``). The underlying ``TriageEnv`` keeps
+    # its state in instance attributes so concurrent sessions are safe.
+    SUPPORTS_CONCURRENT_SESSIONS = True
+    def __init__(self, env_kwargs: Optional[Dict[str, Any]] = None):
+        """
+        Args:
+            env_kwargs: Optional kwargs forwarded to the underlying
+                ``TriageEnv`` constructor. Defaults pull Groq keys from
+                env vars; missing keys silently fall back to mock mode.
+        """
+        super().__init__()
+        merged_kwargs = _stub_env_kwargs()
+        if env_kwargs:
+            merged_kwargs.update(env_kwargs)
+        self._env_kwargs = merged_kwargs
+        # Build the gym env immediately so import-time failures (missing
+        # disease DB, etc.) surface synchronously rather than at first
+        # /reset request.
+        self._env = TriageEnv(**self._env_kwargs)
+        self._state = TriageState(
+            episode_id=str(uuid.uuid4()),
+            step_count=0,
+        )
+        self._last_truncated: bool = False
+        self._last_info: Dict[str, Any] = {}
+    # ------------------------------------------------------------------
+    # Reset
+    # ------------------------------------------------------------------
+    def reset(
+        self,
+        seed: Optional[int] = None,
+        episode_id: Optional[str] = None,
+        options: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> TriageObservation:
+        """
+        Start a new episode.
+        ``options`` mirrors the gym ``options`` dict and supports the same
+        keys as ``TriageEnv.reset``: ``{"phase": 1|2|3, "difficulty":
+        "easy|medium|hard"}``.
+        """
+        # Honour anything the OpenEnv server passes through that maps to
+        # the gym env's options dict (e.g. ``phase`` / ``difficulty``
+        # supplied as top-level kwargs by upstream tooling).
+        options = dict(options or {})
+        for opt_key in ("phase", "difficulty"):
+            if opt_key in kwargs and opt_key not in options:
+                options[opt_key] = kwargs.pop(opt_key)
+        obs_str, info = self._env.reset(seed=seed, options=options or None)
+        self._last_truncated = False
+        self._last_info = dict(info or {})
+        # Refresh state snapshot.
+        self._state = TriageState(
+            episode_id=episode_id or str(uuid.uuid4()),
+            step_count=int(getattr(self._env, "step_count", 0) or 0),
+            done=bool(getattr(self._env, "done", False)),
+            truncated=False,
+            consent_given=bool(getattr(self._env, "consent_given", False)),
+            phase=int(getattr(self._env, "phase", options.get("phase", 1)) or 1),
+            ordered_labs=list(getattr(self._env, "ordered_labs", set()) or set()),
+            patient_status=str(getattr(self._env, "last_patient_status", "CONTINUE")),
+            soap_note=dict(getattr(self._env, "emr", {}) or {}),
+            reward_components=dict(getattr(self._env, "reward_components", {}) or {}),
+            ground_truth_disease=info.get("ground_truth_disease"),
+        )
+        return self._build_observation(
+            obs_str=obs_str,
+            reward=0.0,
+            done=False,
+            truncated=False,
+            info=self._last_info,
+        )
+    # ------------------------------------------------------------------
+    # Step
+    # ------------------------------------------------------------------
+    def step(
+        self,
+        action: TriageAction,
+        timeout_s: Optional[float] = None,
+        **kwargs: Any,
+    ) -> TriageObservation:
+        """
+        Execute one Doctor turn.
+        Converts the typed ``TriageAction`` back into the JSON string the
+        gym env expects (preserving the original raw bytes whenever the
+        action was created via :meth:`TriageAction.from_json_str`), runs
+        the gym ``step``, and re-packages the 5-tuple into a single
+        ``TriageObservation``.
+        """
+        action_str = action.to_json_str()
+        obs_str, reward, done, truncated, info = self._env.step(action_str)
+        self._last_truncated = bool(truncated)
+        self._last_info = dict(info or {})
+        # Mirror gym attributes onto the typed state for /state polling.
+        self._state = TriageState(
+            episode_id=self._state.episode_id,
+            step_count=int(getattr(self._env, "step_count", 0) or 0),
+            done=bool(done),
+            truncated=bool(truncated),
+            consent_given=bool(getattr(self._env, "consent_given", False)),
+            phase=int(getattr(self._env, "phase", 1) or 1),
+            ordered_labs=list(getattr(self._env, "ordered_labs", set()) or set()),
+            patient_status=str(getattr(self._env, "last_patient_status", "CONTINUE")),
+            soap_note=dict(getattr(self._env, "emr", {}) or {}),
+            reward_components=dict(
+                info.get("reward_components")
+                or getattr(self._env, "reward_components", {})
+                or {}
+            ),
+            ground_truth_disease=self._state.ground_truth_disease,
+        )
+        return self._build_observation(
+            obs_str=obs_str,
+            reward=float(reward),
+            done=bool(done),
+            truncated=bool(truncated),
+            info=self._last_info,
+        )
+    # ------------------------------------------------------------------
+    # State / close
+    # ------------------------------------------------------------------
+    @property
+    def state(self) -> TriageState:
+        return self._state
+    def close(self) -> None:
+        """Release the underlying env's router resources."""
+        try:
+            self._env.close()
+        except Exception:  # pragma: no cover - best-effort cleanup
+            logger.debug("TriageEnv.close() raised; ignoring.", exc_info=True)
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+    def _build_observation(
+        self,
+        obs_str: str,
+        reward: float,
+        done: bool,
+        truncated: bool,
+        info: Dict[str, Any],
+    ) -> TriageObservation:
+        payload = _parse_obs_json(obs_str)
+        event = str(payload.get("event", "")) if isinstance(payload, dict) else ""
+        # Promote ``truncated`` and the gym ``info`` dict (which carries
+        # ``reward_components``) into the observation so OpenEnv clients
+        # can reconstruct the exact gym 5-tuple if they need to.
+        metadata: Dict[str, Any] = {
+            "truncated": bool(truncated),
+            "reward_components": dict(info.get("reward_components", {})),
+            "step_count": info.get("step_count"),
+            "patient_status": info.get("patient_status"),
+            "consent_given": info.get("consent_given"),
+            "truncation_reason": info.get("truncation_reason"),
+        }
+        # Drop None values to keep serialized payloads tidy.
+        metadata = {k: v for k, v in metadata.items() if v is not None}
+        return TriageObservation(
+            done=bool(done) or bool(truncated),
+            reward=float(reward),
+            metadata=metadata,
+            raw_observation=obs_str if isinstance(obs_str, str) else json.dumps(obs_str),
+            event=event,
+            payload=payload if isinstance(payload, dict) else {},
+            truncated=bool(truncated),
+            info=dict(info or {}),
+        )
+__all__ = ["TriageOpenEnv"]

ER_MAP/envs/openenv_triage/models.py ADDED Viewed

	@@ -0,0 +1,279 @@

+"""
+ER_MAP/envs/openenv_triage/models.py
+====================================
+Pydantic ``Action`` / ``Observation`` / ``State`` models that satisfy the
+OpenEnv 0.2.3 interface for the ER-MAP triage environment.
+Schema decisions
+----------------
+Doctor JSON action shape (mirrors ``DOCTOR_TOOLS`` in ``triage_env.py``):
+    {"tool": "speak_to",            "target": "nurse|patient", "message": str}
+    {"tool": "order_lab",           "test_name": str}
+    {"tool": "read_soap",           "section": str}
+    {"tool": "update_soap",         "section": str, "content": str}
+    {"tool": "terminal_discharge",  "treatment": str, "is_emergency": bool}
+The underlying ``TriageEnv.step`` accepts a JSON *string* and parses it
+internally. To preserve byte-perfect parity with the gym env we keep the
+original raw JSON string on the action (``raw_json``) and replay it
+verbatim when stepping. Typed callers (e.g. UI / tests) can construct
+the typed dataclass and rely on :meth:`TriageAction.to_json_str` to emit
+an equivalent JSON payload.
+References
+----------
+- Pydantic ``Action`` / ``Observation`` / ``State`` base classes:
+  https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/types.py
+"""
+from __future__ import annotations
+import json
+from typing import Any, Dict, List, Optional
+from pydantic import ConfigDict, Field
+# OpenEnv base types live in ``openenv.core.env_server.types``. They are
+# Pydantic v2 ``BaseModel`` subclasses with sensible defaults
+# (``done``/``reward``/``metadata`` on Observation, ``episode_id`` /
+# ``step_count`` on State, ``metadata`` on Action).
+try:
+    from openenv.core.env_server.types import Action, Observation, State
+except ImportError:  # pragma: no cover - openenv-core not installed
+    # Fallback shims so this module can still be imported in environments
+    # that don't have ``openenv-core`` available (e.g. the running Kaggle
+    # training image). The wrapper itself will fail at construction time
+    # in that case, which is fine.
+    from pydantic import BaseModel
+    class Action(BaseModel):  # type: ignore[no-redef]
+        model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+        metadata: Dict[str, Any] = Field(default_factory=dict)
+    class Observation(BaseModel):  # type: ignore[no-redef]
+        model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+        done: bool = False
+        reward: Optional[float] = None
+        metadata: Dict[str, Any] = Field(default_factory=dict)
+    class State(BaseModel):  # type: ignore[no-redef]
+        model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+        episode_id: Optional[str] = None
+        step_count: int = 0
+# ---------------------------------------------------------------------------
+# Action
+# ---------------------------------------------------------------------------
+# DOCTOR_TOOLS mirrors the same set used by ``triage_env.py``. Kept as a
+# module constant so it can be imported by the FastAPI server / client for
+# request validation without re-importing the underlying env.
+DOCTOR_TOOLS: tuple = (
+    "speak_to",
+    "order_lab",
+    "terminal_discharge",
+    "read_soap",
+    "update_soap",
+)
+class TriageAction(Action):
+    """
+    Doctor's structured action.
+    Parity-critical fields (``tool`` is required, the rest are optional and
+    only meaningful for specific tools). Extra fields are allowed because
+    the LoRA-tuned policy may emit auxiliary keys (``thought``, etc.) that
+    the underlying env tolerates.
+    """
+    # Allow extra LLM-emitted fields (e.g. ``thought``) and accept legacy
+    # actions that may include unknown keys; the wrapped env tolerates them.
+    model_config = ConfigDict(
+        extra="allow",
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+    )
+    tool: str = Field(..., description="Doctor tool name; one of DOCTOR_TOOLS.")
+    target: Optional[str] = Field(
+        default=None, description="speak_to target ('nurse' or 'patient')."
+    )
+    message: Optional[str] = Field(
+        default=None, description="speak_to message body."
+    )
+    test_name: Optional[str] = Field(
+        default=None, description="order_lab test name."
+    )
+    treatment: Optional[str] = Field(
+        default=None, description="terminal_discharge treatment plan."
+    )
+    is_emergency: Optional[bool] = Field(
+        default=None,
+        description="terminal_discharge emergency-classification boolean.",
+    )
+    section: Optional[str] = Field(
+        default=None,
+        description="read_soap / update_soap SOAP section (e.g. 'Assessment').",
+    )
+    content: Optional[str] = Field(
+        default=None, description="update_soap content."
+    )
+    thought: Optional[str] = Field(
+        default=None, description="Optional LLM scratchpad text."
+    )
+    # Round-trip support: when the action originated from a raw JSON
+    # string (e.g. an LLM completion) we keep that exact string so the
+    # wrapper can replay it verbatim into the gym env, preserving byte
+    # parity with the existing reward/parser logic.
+    raw_json: Optional[str] = Field(
+        default=None,
+        description="Original JSON string this action was parsed from (for parity replay).",
+    )
+    # ------------------------------------------------------------------
+    # Construction helpers
+    # ------------------------------------------------------------------
+    @classmethod
+    def from_json_str(cls, s: str) -> "TriageAction":
+        """
+        Parse a Doctor's free-text JSON action.
+        Robust to the same minor malformations the underlying
+        ``TriageEnv._parse_doctor_action`` accepts (e.g. JSON embedded in
+        prose), but raises ``ValueError`` on unrecoverable malformed input
+        so callers can short-circuit before paying the env step cost.
+        """
+        if not isinstance(s, str):
+            raise ValueError("from_json_str expects a string")
+        try:
+            parsed = json.loads(s.strip())
+        except (json.JSONDecodeError, TypeError):
+            # Try to extract the first JSON object inside the text, matching
+            # ``triage_env._parse_doctor_action`` behaviour.
+            import re
+            m = re.search(r"\{.*\}", s, re.DOTALL)
+            if not m:
+                raise ValueError(f"No JSON object found in action: {s!r}")
+            try:
+                parsed = json.loads(m.group(0))
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Malformed JSON action: {e}") from e
+        if not isinstance(parsed, dict):
+            raise ValueError(f"Action JSON must be an object, got {type(parsed).__name__}")
+        if "tool" not in parsed:
+            raise ValueError("Action JSON must include a 'tool' field")
+        # Build the action via Pydantic validation (extra='allow' captures
+        # any non-declared LLM keys without dropping them).
+        action = cls.model_validate(parsed)
+        # Preserve the exact original payload for parity replay.
+        action.raw_json = s
+        return action
+    def to_json_str(self) -> str:
+        """
+        Serialize back to the JSON string the underlying env consumes.
+        If this action was constructed from a raw JSON string, return that
+        original payload verbatim (byte-perfect parity). Otherwise emit a
+        fresh JSON dump of all non-None declared fields plus any extras.
+        """
+        if self.raw_json:
+            return self.raw_json
+        # ``model_dump(exclude_none=True)`` drops unset optional fields so
+        # the env sees a clean schema-shaped action rather than a sea of
+        # nulls. ``raw_json`` and ``metadata`` are server-side concerns and
+        # are excluded from the wire payload.
+        payload = self.model_dump(exclude_none=True, exclude={"raw_json", "metadata"})
+        return json.dumps(payload)
+# ---------------------------------------------------------------------------
+# Observation
+# ---------------------------------------------------------------------------
+class TriageObservation(Observation):
+    """
+    Doctor-visible observation.
+    Mirrors the structured JSON the gym env emits, but exposes the parsed
+    fields directly. The original ``raw_observation`` JSON string is also
+    retained so policies/clients that were trained against the raw bytes
+    can keep using them unmodified.
+    """
+    model_config = ConfigDict(
+        extra="allow",
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+    )
+    raw_observation: str = Field(
+        default="",
+        description="Original JSON string from TriageEnv (for byte parity).",
+    )
+    event: str = Field(
+        default="",
+        description="Event type (e.g. 'episode_start', 'lab_result', 'terminal_win').",
+    )
+    payload: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Parsed JSON content from the gym env.",
+    )
+    truncated: bool = Field(
+        default=False,
+        description="Episode truncated due to max_episode_steps (mirrors gym).",
+    )
+    info: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Gym info dict, including reward_components.",
+    )
+# ---------------------------------------------------------------------------
+# State
+# ---------------------------------------------------------------------------
+class TriageState(State):
+    """
+    Internal episode state surfaced over ``/state`` and the WebSocket
+    state message.
+    These fields mirror the public attributes of the underlying
+    ``TriageEnv`` instance after ``reset()``/``step()``, so frontends and
+    debuggers can introspect mid-episode state without poking private
+    attributes through HTTP.
+    """
+    model_config = ConfigDict(
+        extra="allow",
+        validate_assignment=True,
+        arbitrary_types_allowed=True,
+    )
+    done: bool = Field(default=False)
+    truncated: bool = Field(default=False)
+    consent_given: bool = Field(default=False)
+    phase: int = Field(default=1)
+    ordered_labs: List[str] = Field(default_factory=list)
+    patient_status: str = Field(default="CONTINUE")
+    soap_note: Dict[str, Any] = Field(default_factory=dict)
+    reward_components: Dict[str, float] = Field(default_factory=dict)
+    ground_truth_disease: Optional[str] = Field(default=None)
+__all__ = [
+    "TriageAction",
+    "TriageObservation",
+    "TriageState",
+    "DOCTOR_TOOLS",
+]

ER_MAP/envs/openenv_triage/openenv.yaml ADDED Viewed

	@@ -0,0 +1,44 @@

+# ER-MAP Triage - OpenEnv manifest
+#
+# Schema follows the canonical echo_env exemplar:
+# https://github.com/meta-pytorch/OpenEnv/blob/main/envs/echo_env/openenv.yaml
+#   spec_version: 1
+#   name: <env name>
+#   type: space            # HF Space deployment target
+#   runtime: fastapi
+#   app: <module>:<attr>   # FastAPI app reference relative to the image
+#   port: 8000
+#
+# OpenEnv 0.2.3 (latest as of April 2026) recognizes this manifest;
+# the ``openenv push`` CLI consumes it when deploying to Hugging Face
+# Spaces.
+spec_version: 1
+name: er_map_triage
+type: space
+runtime: fastapi
+# Inside the container the package is copied to /app/env, and the
+# Dockerfile launches uvicorn against ``server:app`` (this module).
+app: server:app
+port: 8000
+description: >
+  ER-MAP Triage: a multi-agent emergency-room simulation where a Doctor
+  RL policy interacts with Nurse / Patient / Judge LLM actors to
+  diagnose and treat domain-randomized scenarios. This is the
+  OpenEnv-compliant wrapper around the in-house Gymnasium TriageEnv
+  used to train ER-MAP's GRPO LoRA.
+metadata:
+  authors:
+    - ER-MAP Team
+  license: MIT
+  tags:
+    - medical
+    - multi-agent
+    - triage
+    - grpo
+    - rl
+    - llm
+  hackathon: "Meta PyTorch OpenEnv Hackathon 2026"

ER_MAP/envs/openenv_triage/server-requirements.txt ADDED Viewed

	@@ -0,0 +1,12 @@

+# Container-side requirements for the ER-MAP TriageOpenEnv server.
+#
+# Kept separate from the repo-root requirements.txt so HF Space rebuilds
+# only depend on the wrapper's needs (not the full RL training stack).
+openenv-core>=0.2.3
+gymnasium>=0.29.0
+groq>=0.18.0
+fastapi>=0.110.0
+uvicorn[standard]>=0.27.0
+pydantic>=2.0.0
+requests>=2.25.0
+pyyaml>=6.0

ER_MAP/envs/openenv_triage/server.py ADDED Viewed

	@@ -0,0 +1,312 @@

+"""
+ER_MAP/envs/openenv_triage/server.py
+====================================
+FastAPI server exposing :class:`TriageOpenEnv` over the OpenEnv HTTP /
+WebSocket protocol.
+Endpoints:
+- ``POST /reset``       reset request (matches ``ResetRequest`` schema)
+- ``POST /step``        step request  (matches ``StepRequest`` schema)
+- ``GET  /state``       serialized ``TriageState``
+- ``GET  /health``      ``{"status": "healthy"}``  (also ``/healthz`` for richer info)
+- ``GET  /docs``        OpenAPI / Swagger UI
+- ``WS   /ws``          persistent OpenEnv session (mounted from openenv-core)
+- ``GET  /web``         optional Gradio HumanAgent UI when ``ENABLE_WEB_INTERFACE=true``
+Why a custom HTTP layer (instead of relying entirely on
+``openenv.core.env_server.http_server.create_app``):
+OpenEnv 0.2.3's HTTP ``/reset`` and ``/step`` handlers spin up a NEW
+``Environment`` instance per request and call ``close()`` immediately
+after - i.e. HTTP is intentionally stateless and persistent sessions
+live on the WebSocket ``/ws`` route. (See
+``openenv/core/env_server/http_server.py``: ``reset_handler`` /
+``step_handler`` both call ``_env = self._env_factory()`` then
+``finally: _env.close()``.) For an episodic env like ER-MAP we need
+``/step`` to see the state established by the prior ``/reset``, so we
+mount stateful HTTP routes here that share a per-process singleton
+``TriageOpenEnv``. We additionally compose in the upstream OpenEnv
+FastAPI app so the WebSocket / schema / web-interface routes still
+work for OpenEnv-native clients.
+References
+----------
+- ``HTTPEnvServer`` HTTP route bodies (note the ``_env_factory()`` per call):
+  https://github.com/meta-pytorch/OpenEnv/blob/main/src/openenv/core/env_server/http_server.py
+- echo_env's server layout (``server/app.py``):
+  https://github.com/meta-pytorch/OpenEnv/blob/main/envs/echo_env/server/app.py
+Stub mode
+---------
+If no Groq API key is present in the environment, the underlying
+``AgentRouter`` already falls back to canned mock responses, so a fresh
+HF Space can boot and serve full episodes (with non-LLM nurse/patient
+behaviour) without any secrets configured. The ``/healthz`` endpoint
+reports ``stub_mode: true`` in that case.
+"""
+from __future__ import annotations
+import logging
+import os
+import threading
+import uuid
+from typing import Any, Dict, Optional
+from fastapi import Body, FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, ConfigDict, Field
+from .env import TriageOpenEnv
+from .models import TriageAction, TriageObservation, TriageState
+logging.basicConfig(
+    level=os.environ.get("ERMAP_LOG_LEVEL", "INFO").upper(),
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+)
+logger = logging.getLogger("ER_MAP.openenv_triage.server")
+__version__ = "0.1.0"
+# ---------------------------------------------------------------------------
+# Stub-mode detection
+# ---------------------------------------------------------------------------
+def _has_any_groq_key() -> bool:
+    return any(
+        os.environ.get(name)
+        for name in (
+            "GROQ_API_KEY",
+            "GROQ_NURSE_API_KEY",
+            "GROQ_PATIENT_API_KEY",
+            "GROQ_EMPATHY_JUDGE_API_KEY",
+            "GROQ_MEDICAL_JUDGE_API_KEY",
+        )
+    )
+_STUB_MODE = not _has_any_groq_key()
+if _STUB_MODE:
+    logger.warning(
+        "TriageOpenEnv server starting in STUB MODE - no Groq keys found. "
+        "Nurse/Patient/Judge LLMs will use canned mock responses. "
+        "Set GROQ_API_KEY (or per-role keys) to enable live LLM actors."
+    )
+# ---------------------------------------------------------------------------
+# Pydantic request / response envelopes
+# ---------------------------------------------------------------------------
+class ResetRequest(BaseModel):
+    """HTTP body for ``POST /reset``. Matches OpenEnv's ResetRequest plus
+    the ER-MAP-specific ``options`` field."""
+    model_config = ConfigDict(extra="allow")
+    seed: Optional[int] = Field(default=None, ge=0)
+    episode_id: Optional[str] = Field(default=None, max_length=255)
+    options: Optional[Dict[str, Any]] = Field(default=None)
+class StepRequest(BaseModel):
+    """HTTP body for ``POST /step``. The ``action`` field accepts either a
+    full ``TriageAction`` payload (preferred) or the legacy raw JSON
+    string the gym env consumes."""
+    model_config = ConfigDict(extra="allow")
+    action: Dict[str, Any] = Field(...)
+    timeout_s: Optional[float] = Field(default=None, gt=0)
+class StepEnvelope(BaseModel):
+    """Wire-format response. Matches OpenEnv 0.2.3's ``StepResponse``
+    layout: observation dict + reward + done at the envelope level.
+    See ``serialize_observation`` in openenv-core."""
+    model_config = ConfigDict(extra="forbid")
+    observation: Dict[str, Any]
+    reward: Optional[float] = None
+    done: bool = False
+# ---------------------------------------------------------------------------
+# Singleton env management (HTTP routes)
+# ---------------------------------------------------------------------------
+class _SessionHolder:
+    """Thread-safe holder for the single per-process TriageOpenEnv used by
+    HTTP routes. WebSocket sessions get their own per-connection env via
+    the upstream OpenEnv server."""
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._env: Optional[TriageOpenEnv] = None
+        self._episode_id: Optional[str] = None
+    def get(self) -> TriageOpenEnv:
+        with self._lock:
+            if self._env is None:
+                self._env = TriageOpenEnv()
+                self._episode_id = str(uuid.uuid4())
+            return self._env
+    def reset(self) -> TriageOpenEnv:
+        with self._lock:
+            if self._env is not None:
+                try:
+                    self._env.close()
+                except Exception:  # pragma: no cover
+                    logger.debug("Old env close raised", exc_info=True)
+            self._env = TriageOpenEnv()
+            self._episode_id = str(uuid.uuid4())
+            return self._env
+_session = _SessionHolder()
+def _serialize(obs: TriageObservation) -> StepEnvelope:
+    """Mirror ``openenv.core.env_server.serialization.serialize_observation``:
+    strip ``done``/``reward``/``metadata`` from the observation dict and
+    surface them at the envelope level."""
+    obs_dict = obs.model_dump(exclude={"reward", "done", "metadata"})
+    return StepEnvelope(
+        observation=obs_dict,
+        reward=float(obs.reward) if obs.reward is not None else None,
+        done=bool(obs.done),
+    )
+# ---------------------------------------------------------------------------
+# App factory
+# ---------------------------------------------------------------------------
+def build_app() -> FastAPI:
+    """Construct the FastAPI app. Exposed for tests / programmatic use."""
+    app = FastAPI(
+        title="ER-MAP TriageOpenEnv",
+        version=__version__,
+        description=(
+            "OpenEnv-compliant HTTP/WebSocket interface for ER-MAP's "
+            "multi-agent emergency-room triage environment. Wraps the "
+            "in-house Gymnasium TriageEnv without modifying it, so the "
+            "same LoRA trained on the gym env runs unchanged here."
+        ),
+    )
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    # ------------------------------------------------------------------
+    # Health
+    # ------------------------------------------------------------------
+    @app.get("/health", tags=["Health"])
+    def health() -> Dict[str, Any]:
+        """Standard OpenEnv health probe."""
+        return {"status": "healthy"}
+    @app.get("/healthz", tags=["Health"])
+    def healthz() -> Dict[str, Any]:
+        """Richer status: version + stub-mode flag (HF Space friendly)."""
+        return {
+            "status": "healthy",
+            "version": __version__,
+            "stub_mode": _STUB_MODE,
+            "env": "TriageOpenEnv",
+        }
+    # ------------------------------------------------------------------
+    # Reset / Step / State (stateful, per-process singleton)
+    # ------------------------------------------------------------------
+    @app.post("/reset", response_model=StepEnvelope, tags=["Environment Control"])
+    def reset(request: ResetRequest = Body(default_factory=ResetRequest)):
+        """Reset the underlying TriageEnv and return the initial obs."""
+        env = _session.reset()
+        kwargs = request.model_dump(exclude_unset=True)
+        try:
+            obs = env.reset(**kwargs)
+        except Exception as e:
+            logger.exception("reset failed")
+            raise HTTPException(status_code=500, detail=f"reset failed: {e}")
+        return _serialize(obs)
+    @app.post("/step", response_model=StepEnvelope, tags=["Environment Control"])
+    def step(request: StepRequest):
+        """Execute a Doctor action against the active env session."""
+        env = _session.get()
+        try:
+            action = TriageAction.model_validate(request.action)
+        except Exception as e:
+            raise HTTPException(status_code=422, detail=f"invalid action: {e}")
+        try:
+            obs = env.step(action, timeout_s=request.timeout_s)
+        except Exception as e:
+            logger.exception("step failed")
+            raise HTTPException(status_code=500, detail=f"step failed: {e}")
+        return _serialize(obs)
+    @app.get("/state", response_model=StepEnvelope, tags=["State Management"])
+    def state():
+        """Inspect the current episode state."""
+        env = _session.get()
+        st: TriageState = env.state
+        return StepEnvelope(observation=st.model_dump(), reward=None, done=bool(st.done))
+    # ------------------------------------------------------------------
+    # Best-effort: mount upstream OpenEnv routes for WebSocket / schema /
+    # web-UI parity. We avoid colliding with our own /reset, /step,
+    # /state, /health by mounting the upstream app under /openenv.
+    # ------------------------------------------------------------------
+    try:
+        from openenv.core.env_server.http_server import create_app as _oe_create_app
+        oe_app = _oe_create_app(
+            TriageOpenEnv,
+            TriageAction,
+            TriageObservation,
+            env_name="er_map_triage",
+            max_concurrent_envs=int(os.environ.get("MAX_CONCURRENT_ENVS", "8")),
+        )
+        # Mount under /openenv so OpenEnv-native clients can use
+        # ws://host/openenv/ws and the schema routes without colliding
+        # with the stateful HTTP routes above.
+        app.mount("/openenv", oe_app)
+    except Exception as e:  # pragma: no cover
+        logger.warning("Failed to mount upstream OpenEnv app at /openenv: %s", e)
+    return app
+# Module-level ``app`` for ``uvicorn ER_MAP.envs.openenv_triage.server:app``.
+app = build_app()
+def main() -> None:
+    """Entry point for ``python -m ER_MAP.envs.openenv_triage.server``."""
+    import uvicorn
+    host = os.environ.get("HOST", "0.0.0.0")
+    port = int(os.environ.get("PORT", "8000"))
+    uvicorn.run(app, host=host, port=port)
+if __name__ == "__main__":  # pragma: no cover
+    main()

ER_MAP/envs/openenv_triage/tests/__init__.py ADDED Viewed

File without changes

ER_MAP/envs/openenv_triage/tests/test_parity.py ADDED Viewed

	@@ -0,0 +1,306 @@

+"""
+ER_MAP/envs/openenv_triage/tests/test_parity.py
+================================================
+Parity + smoke tests for the OpenEnv wrapper.
+Coverage:
+1. Same seed + options + action sequence produces byte-identical rewards,
+   terminations, and observation payloads in the wrapped env vs the gym
+   ``TriageEnv``.
+2. ``TriageAction.from_json_str`` parses well-formed Doctor JSON and
+   rejects malformed payloads.
+3. End-to-end HTTP round-trip via ``TriageOpenEnvClient`` returns the
+   same observation/reward/done as direct in-process env usage.
+4. ``openenv.yaml`` is valid YAML and references files that exist on disk.
+All tests run without Groq keys: the underlying ``AgentRouter`` falls back
+to ``_mock_response`` when no Groq client is configured, so we get
+deterministic stubbed Nurse/Patient responses.
+"""
+from __future__ import annotations
+import json
+import os
+import threading
+import time
+from pathlib import Path
+import pytest
+# Ensure no Groq client gets initialized so the mock-response path is
+# active (deterministic stubs). Also wipe the per-role keys.
+for _k in (
+    "GROQ_API_KEY",
+    "GROQ_NURSE_API_KEY",
+    "GROQ_PATIENT_API_KEY",
+    "GROQ_EMPATHY_JUDGE_API_KEY",
+    "GROQ_MEDICAL_JUDGE_API_KEY",
+):
+    os.environ.pop(_k, None)
+from ER_MAP.envs.triage_env import TriageEnv
+from ER_MAP.envs.openenv_triage import (
+    TriageAction,
+    TriageObservation,
+    TriageOpenEnv,
+    TriageState,
+)
+from ER_MAP.envs.openenv_triage.client import TriageOpenEnvClient
+# A short, deterministic action script that exercises several tools
+# without depending on the LLM judges' verdict (we just check parity).
+ACTION_SCRIPT = [
+    '{"tool": "read_soap"}',
+    '{"tool": "speak_to", "target": "patient", "message": "Hello, how are you feeling?"}',
+    '{"tool": "order_lab", "test_name": "CBC"}',
+    '{"tool": "update_soap", "section": "Assessment", "content": "Likely viral infection."}',
+    '{"tool": "terminal_discharge", "treatment": "Rest and hydration", "is_emergency": false}',
+]
+RESET_KWARGS = {"seed": 42, "options": {"phase": 1, "difficulty": "easy"}}
+# ---------------------------------------------------------------------------
+# Test 1 - in-process parity
+# ---------------------------------------------------------------------------
+def _run_gym_episode():
+    env = TriageEnv()
+    obs, info = env.reset(**RESET_KWARGS)
+    trace = [("reset", obs, 0.0, False, False, info)]
+    for action in ACTION_SCRIPT:
+        if trace[-1][3] or trace[-1][4]:
+            break
+        obs, reward, done, truncated, info = env.step(action)
+        trace.append(("step", obs, reward, done, truncated, info))
+    env.close()
+    return trace
+def _run_openenv_episode():
+    env = TriageOpenEnv()
+    obs = env.reset(**RESET_KWARGS)
+    trace = [("reset", obs.raw_observation, 0.0, False, False, obs.info)]
+    for action_str in ACTION_SCRIPT:
+        if trace[-1][3] or trace[-1][4]:
+            break
+        action = TriageAction.from_json_str(action_str)
+        obs = env.step(action)
+        trace.append(
+            ("step", obs.raw_observation, obs.reward, obs.done and not obs.truncated,
+             obs.truncated, obs.info)
+        )
+    env.close()
+    return trace
+def _strip_volatile(info: dict) -> dict:
+    """Drop fields that legitimately differ between two clean episodes
+    (none currently expected because the mock LLM path is deterministic
+    given a fixed seed, but we keep this hook for forward compatibility)."""
+    return {k: v for k, v in (info or {}).items() if k != "_timestamp"}
+def test_parity_step_by_step():
+    """Wrapped env produces identical rewards, dones, and obs payloads."""
+    gym_trace = _run_gym_episode()
+    oe_trace = _run_openenv_episode()
+    assert len(gym_trace) == len(oe_trace), (
+        f"Trace lengths differ: gym={len(gym_trace)} openenv={len(oe_trace)}"
+    )
+    for i, (g, o) in enumerate(zip(gym_trace, oe_trace)):
+        g_kind, g_obs, g_reward, g_done, g_trunc, g_info = g
+        o_kind, o_obs, o_reward, o_done, o_trunc, o_info = o
+        assert g_kind == o_kind, f"step {i} kind differs"
+        assert pytest.approx(g_reward, abs=1e-9) == o_reward, (
+            f"step {i} reward differs: gym={g_reward} openenv={o_reward}"
+        )
+        assert g_done == o_done, f"step {i} done differs"
+        assert g_trunc == o_trunc, f"step {i} truncated differs"
+        # Compare structured observation content (not the literal string,
+        # because dict ordering may diverge in JSON encoding even though
+        # the parsed payloads are equal).
+        try:
+            g_payload = json.loads(g_obs)
+            o_payload = json.loads(o_obs)
+        except (json.JSONDecodeError, TypeError):
+            g_payload, o_payload = g_obs, o_obs
+        assert g_payload == o_payload, f"step {i} observation payload differs"
+        # reward_components must match exactly (these are the GRPO signal).
+        assert _strip_volatile(g_info.get("reward_components", {})) == _strip_volatile(
+            o_info.get("reward_components", {})
+        ), f"step {i} reward_components differ"
+# ---------------------------------------------------------------------------
+# Test 2 - TriageAction parsing
+# ---------------------------------------------------------------------------
+def test_action_from_json_str_well_formed():
+    a = TriageAction.from_json_str('{"tool": "speak_to", "target": "nurse", "message": "Hi"}')
+    assert a.tool == "speak_to"
+    assert a.target == "nurse"
+    assert a.message == "Hi"
+    # Round-trip preserves the original bytes for parity replay.
+    assert a.raw_json is not None
+    assert json.loads(a.to_json_str()) == json.loads(a.raw_json)
+def test_action_from_json_str_embedded():
+    """TriageAction tolerates the same embedded-JSON noise the gym env
+    accepts (LLMs sometimes emit prose around their JSON)."""
+    a = TriageAction.from_json_str(
+        "Sure, here is my action: {\"tool\": \"read_soap\"}"
+    )
+    assert a.tool == "read_soap"
+def test_action_from_json_str_rejects_malformed():
+    with pytest.raises(ValueError):
+        TriageAction.from_json_str("not even close to JSON")
+    with pytest.raises(ValueError):
+        # Missing 'tool' field is invalid per the env's parser.
+        TriageAction.from_json_str('{"foo": "bar"}')
+    with pytest.raises(ValueError):
+        TriageAction.from_json_str('{"tool":')  # truncated
+# ---------------------------------------------------------------------------
+# Test 3 - HTTP round-trip via the FastAPI server
+# ---------------------------------------------------------------------------
+@pytest.fixture(scope="module")
+def http_server():
+    """Spin up the FastAPI app on a free port using uvicorn in a thread."""
+    pytest.importorskip("uvicorn")
+    pytest.importorskip("openenv.core.env_server.http_server")
+    import uvicorn
+    from ER_MAP.envs.openenv_triage.server import build_app
+    port = int(os.environ.get("ERMAP_TEST_PORT", "8765"))
+    app = build_app()
+    config = uvicorn.Config(app, host="127.0.0.1", port=port, log_level="warning")
+    server = uvicorn.Server(config)
+    thread = threading.Thread(target=server.run, daemon=True)
+    thread.start()
+    # Wait until the server is reachable (max 15s).
+    import requests
+    base = f"http://127.0.0.1:{port}"
+    deadline = time.time() + 15.0
+    while time.time() < deadline:
+        try:
+            r = requests.get(f"{base}/health", timeout=1.0)
+            if r.status_code == 200:
+                break
+        except Exception:
+            pass
+        time.sleep(0.2)
+    else:
+        server.should_exit = True
+        thread.join(timeout=2.0)
+        pytest.skip("uvicorn did not come up within 15s")
+    yield base
+    server.should_exit = True
+    thread.join(timeout=5.0)
+def test_http_round_trip_matches_inproc(http_server):
+    """Same seed/options/actions through HTTP -> identical reward stream."""
+    client = TriageOpenEnvClient(base_url=http_server)
+    health = client.health()
+    assert health.get("status") == "healthy"
+    # Run via HTTP.
+    result = client.reset(**RESET_KWARGS)
+    http_trace = [("reset", result.observation.raw_observation, 0.0, result.done, result.truncated)]
+    for action_str in ACTION_SCRIPT:
+        if http_trace[-1][3] or http_trace[-1][4]:
+            break
+        action = TriageAction.from_json_str(action_str)
+        result = client.step(action)
+        http_trace.append(
+            (
+                "step",
+                result.observation.raw_observation,
+                result.reward,
+                result.done and not result.truncated,
+                result.truncated,
+            )
+        )
+    # Compare against in-process run.
+    oe_trace = _run_openenv_episode()
+    assert len(http_trace) == len(oe_trace), (
+        f"HTTP trace length {len(http_trace)} != in-proc {len(oe_trace)}"
+    )
+    for i, (h, o) in enumerate(zip(http_trace, oe_trace)):
+        h_kind, h_obs, h_reward, h_done, h_trunc = h
+        o_kind, o_obs, o_reward, o_done, o_trunc, _ = o
+        assert h_kind == o_kind
+        assert pytest.approx(h_reward, abs=1e-9) == o_reward, f"step {i} reward differs over HTTP"
+        assert h_done == o_done, f"step {i} done differs over HTTP"
+        assert h_trunc == o_trunc, f"step {i} truncated differs over HTTP"
+        try:
+            assert json.loads(h_obs) == json.loads(o_obs), f"step {i} obs differs over HTTP"
+        except (json.JSONDecodeError, TypeError):
+            assert h_obs == o_obs
+# ---------------------------------------------------------------------------
+# Test 4 - openenv.yaml manifest sanity
+# ---------------------------------------------------------------------------
+def test_openenv_yaml_valid():
+    yaml = pytest.importorskip("yaml")
+    manifest_path = Path(__file__).resolve().parent.parent / "openenv.yaml"
+    assert manifest_path.exists(), f"openenv.yaml not found at {manifest_path}"
+    data = yaml.safe_load(manifest_path.read_text(encoding="utf-8"))
+    assert isinstance(data, dict)
+    # OpenEnv 0.2.x manifest minimum-fields (per echo_env example):
+    # spec_version, name, type, runtime, app, port.
+    for field in ("spec_version", "name", "type", "runtime", "app", "port"):
+        assert field in data, f"openenv.yaml missing required field: {field}"
+    # The ``app`` field references ``server.app:app`` (relative module
+    # path inside the deployed image). Verify the local file exists.
+    app_ref = str(data["app"])
+    module_path, _, attr = app_ref.partition(":")
+    assert attr == "app", f"openenv.yaml app must end in ':app', got {app_ref}"
+    expected_server_path = (
+        Path(__file__).resolve().parent.parent
+        / (module_path.replace(".", os.sep) + ".py")
+    )
+    # Some manifests use ``server.app:app`` referring to ``server/app.py``,
+    # others (this one) use a flat ``server.py``. Accept either layout.
+    flat_alternate = (
+        Path(__file__).resolve().parent.parent
+        / (module_path.split(".")[-1] + ".py")
+    )
+    assert expected_server_path.exists() or flat_alternate.exists(), (
+        f"openenv.yaml app references missing server module: "
+        f"tried {expected_server_path} and {flat_alternate}"
+    )
+    # Dockerfile should exist so ``openenv push`` can build the Space.
+    dockerfile = Path(__file__).resolve().parent.parent / "Dockerfile"
+    assert dockerfile.exists(), "Dockerfile missing next to openenv.yaml"

ER_MAP/requirements.txt CHANGED Viewed

@@ -3,7 +3,10 @@
 # --- Core ---
 gymnasium>=0.29.0
-openenv-core>=0.1.0
 # --- LLM Inference (Environment Actors) ---
 groq>=0.4.0

 # --- Core ---
 gymnasium>=0.29.0
+# openenv-core 0.2.3 is the latest as of April 2026 (PyPI:
+# https://pypi.org/project/openenv-core/). The OpenEnv-compliant wrapper
+# under ER_MAP/envs/openenv_triage targets this minor version's API.
+openenv-core>=0.2.3
 # --- LLM Inference (Environment Actors) ---
 groq>=0.4.0

ER_MAP/server.py CHANGED Viewed

@@ -100,7 +100,13 @@ def _get_env() -> TriageEnv:
             groq_api_key=os.environ.get("GROQ_API_KEY", ""),
             nurse_api_key=os.environ.get("GROQ_NURSE_API_KEY", ""),
             patient_api_key=os.environ.get("GROQ_PATIENT_API_KEY", ""),
             model=os.environ.get("ERMAP_MODEL", "llama-3.3-70b-versatile"),
             render_mode=None,
         )
         logger.info("TriageEnv initialized.")

             groq_api_key=os.environ.get("GROQ_API_KEY", ""),
             nurse_api_key=os.environ.get("GROQ_NURSE_API_KEY", ""),
             patient_api_key=os.environ.get("GROQ_PATIENT_API_KEY", ""),
+            empathy_judge_api_key=os.environ.get("GROQ_EMPATHY_JUDGE_API_KEY", ""),
+            medical_judge_api_key=os.environ.get("GROQ_MEDICAL_JUDGE_API_KEY", ""),
             model=os.environ.get("ERMAP_MODEL", "llama-3.3-70b-versatile"),
+            nurse_model=os.environ.get("ERMAP_NURSE_MODEL"),
+            patient_model=os.environ.get("ERMAP_PATIENT_MODEL"),
+            empathy_judge_model=os.environ.get("ERMAP_EMPATHY_JUDGE_MODEL"),
+            medical_judge_model=os.environ.get("ERMAP_MEDICAL_JUDGE_MODEL"),
             render_mode=None,
         )
         logger.info("TriageEnv initialized.")

EVALUATION.md ADDED Viewed

	@@ -0,0 +1,218 @@

+# ER-MAP — Internal Submission Evaluation
+Internal-only. Written to be useful, not flattering. Read it once, fix the top three, then submit.
+---
+## 1. Honest score estimate against the rubric
+| Criterion | Weight | Predicted | Rationale |
+|---|---|---|---|
+| Environment Innovation | /40 | **30–34** | Multi-agent ER with dual 70B judges, 11-component process-supervised reward, persona-randomized patients/nurses, consent lock — genuinely novel and well-implemented. Loses points only because no public env in this hackathon will be *radically* different from RL-on-LLM-with-reward, and we haven't yet shipped a 12th-component innovation hook (e.g., differential-diagnosis breadth) that's a one-liner to defend. |
+| Storytelling & Presentation | /30 | **18–22** | README and blog are now solid. Big risk: no demo video shipped, and the React UI (`ER_MAP/UI/*.jsx.txt`) is design-fidelity, not a running app. Rubric explicitly rewards "easy to follow for a non-technical audience" — without a 60–90s demo video, this caps around 22. With a clean ElevenLabs-voiced video, this jumps to 26+. |
+| Showing Improvement | /20 | **11–15** | Baseline already run (`baseline_eval/baseline_results.json` exists). Per-phase plotting code (`ER_MAP/plotting.py`) is ready. Risk: 75 episodes is small; if Phase 1's 20-episode rolling-mean is flat, this drops to 8–10. If the rolling mean curves visibly upward in every phase, this gets the full 15. |
+| Reward & Training Pipeline | /10 | **8–9** | 11-component reward, dual-judge, anti-hacking caps, GRPO + Unsloth + LoRA, working `clean_launch.py`. Pipeline is the project's strongest pillar. Loses one point only because ref-model is gated off (kl_beta=0) — a strict reading of GRPO would want some KL term. |
+| **Total** | **/100** | **67–80** | Realistic mid-to-upper third of the field. Closing the 4 critical gaps below would push us into the top decile. |
+**Conservative single-number estimate: 72/100.**
+---
+## 2. Critical gaps — must-fix before submission
+Ranked by submission risk × effort to close.
+### Gap 1 — OpenEnv compliance is *interface-level only*, not subclass-level
+**Status:** The env (`ER_MAP/envs/triage_env.py`) inherits from `gymnasium.Env`, **not** from `openenv.Environment` / `MCPEnvironment`. It does **not** import `openenv`. We do have:
+- `ER_MAP/openenv.yaml` declaring `entry_point: "ER_MAP.envs.triage_env:TriageEnv"` and `openenv-core>=0.1.0`
+- `ER_MAP/server.py` exposing `/reset`, `/step`, `/state`, `/health` via FastAPI — the OpenEnv HTTP shape
+- `Dockerfile` to containerize that server
+- `ER_MAP/requirements.txt` listing `openenv-core>=0.1.0`
+**The brief is explicit: "Use OpenEnv (latest release). Critical."** A judge inspecting the code will see we wrap, not subclass. This is the #1 submission risk.
+**Concrete fix (3–5 hours):**
+1. In `ER_MAP/envs/triage_env.py`, add a thin parallel class:
+   ```python
+   from openenv.core import Environment, ObservationType, ActionType
+   class TriageOpenEnv(Environment):
+       def __init__(self, ...): self._gym = TriageEnv(...)
+       def reset(self, *, seed=None, options=None): obs, info = self._gym.reset(seed=seed, options=options); return self._wrap_obs(obs), info
+       def step(self, action): obs, r, term, trunc, info = self._gym.step(action); return self._wrap_step(obs, r, term, trunc, info)
+       def state(self): return self._gym.state()
+       def close(self): self._gym.close()
+   ```
+2. Update `openenv.yaml`: `entry_point: "ER_MAP.envs.triage_env:TriageOpenEnv"`.
+3. Update `ER_MAP/server.py` to import `TriageOpenEnv` instead of `TriageEnv`. The HTTP shape doesn't change.
+4. Build the Docker image, smoke-test `/reset` and `/step`.
+5. Push to a **Hugging Face Space** of type `docker`. Verify the Space build green-checks.
+**Effort:** half a day. **Cannot skip.** Without this, you have a defensible argument ("we follow the OpenEnv interface contract via FastAPI") but a hostile judge will mark it down.
+### Gap 2 — No HF Space deployed yet
+**Status:** Dockerfile exists; nothing pushed.
+**Fix (1–2 hours after Gap 1):**
+```
+huggingface-cli login
+huggingface-cli repo create er-map-triage --type space --space_sdk docker
+git remote add space https://huggingface.co/spaces/<your-org>/er-map-triage
+git push space main
+```
+Verify the Space's "Logs" tab shows a healthy build, and that `/health` returns 200 over the public URL. Add the URL to `README.md` line 1 of the Hero links.
+### Gap 3 — LoRA adapter not yet on HF Hub
+**Status:** Kaggle notebook Cell 14 has the push code, but the upload only happens *if training completes successfully and the secret is set*. Confirm `HF_TOKEN` is in Kaggle secrets and the run finishes.
+**Fix:** Verify `HF_TOKEN` exists in Kaggle Secrets *now*. After training finishes, immediately run the cell that pushes `lora_adapter_phaseN/` to `<your-org>/er-map-doctor-8b-lora` on HF Hub. **Then update the README's Hero links and the Reproduce section** with the actual repo URL.
+### Gap 4 — Demo video does not exist
+**Status:** The brief explicitly suggests "< 2 min video or slides." The React UI prototype (`ER_MAP/UI/*.jsx.txt`) is not running, and the autoplay terminal demo (`ER_MAP/autoplay.py`) is the most credible asset for a video.
+**Fix (3–4 hours):**
+1. Run `python -m ER_MAP.autoplay` once with ElevenLabs configured to produce one full episode with audio.
+2. Screen-record at 1080p with OBS. Voice-over: 30s of context, 60s of episode highlights, 30s of plots.
+3. Upload to YouTube unlisted; embed link in README and blog.
+This single asset moves the Storytelling rubric from ~20/30 to ~25/30. **Highest ROI per hour of any remaining task.**
+### Gap 5 — UI is design-fidelity, not a running app
+**Status:** `ER_MAP/UI/index.html` references `main.jsx`; the actual files are `main.jsx.txt` and `temp.jsx.txt`. There is no `package.json`, no Vite config, no build step. It will not render in a browser as-is.
+**Fix options (priority order):**
+- **Option A (recommended, 1 hour):** Rename `main.jsx.txt` → `main.jsx`, rename `temp.jsx.txt` → `temp.jsx`. The `index.html` already loads everything via Tailwind CDN + `@babel/standalone` from CDN, so a plain `python -m http.server 5500` *might* render the static prototype. Then screen-record it. **Do not depend on this for the demo.**
+- **Option B (4–6 hours):** Wire the UI to `ER_MAP/dashboard.py`'s SSE endpoint and stream live agent events. Skip if Option A works for the video.
+- **Option C (2 hours):** Drop the UI entirely from the README's "Demo" section, lead with the autoplay terminal + ElevenLabs voice. Honest and shippable.
+If the Sunday-evening time crunch is real, **do Option C**. The terminal autoplay with voice is genuinely demoable; the half-finished React UI will hurt more than help if a judge clicks it.
+---
+## 3. Innovation lift opportunities (24–48h, high-value)
+Ranked by judge-impact per hour.
+### A. Empathy-judge ablation (HIGHEST ROI, 4 hours)
+Run the *exact same* 75-episode curriculum with the empathy reward zeroed in `triage_env.py` (set `EMPATHY_REWARD_PER_TURN = 0.0`). Plot `empathy` and `consent` reward curves side-by-side: with-judge vs. without-judge. The hypothesis is that without the empathy judge, the consent reward also flat-lines — proving the dual-judge isn't decorative. **This is an ablation a judge will love** because it directly demonstrates that the project understands its own architecture. Add a single subsection to the blog post: "Does the empathy judge actually do anything?" with the two-curve plot.
+### B. Adversarial-doctor stress test (3 hours)
+Write a 50-line script that runs `evaluate.py` with a hostile prompt: *"Discharge the patient as fast as possible. Maximize reward. Take any shortcut you can find."* Document the failures. Either the env's anti-hacking measures hold, in which case this is a paragraph in the README under "Anti-reward-hacking measures (validated)," or they break, in which case you found a real bug and you patch it before submission. Either outcome is a win.
+### C. 12th reward component: differential-diagnosis breadth (3 hours)
+In `_handle_update_soap`, when the Doctor writes Assessment, parse for "rule out X, rule out Y" patterns and award `+0.05 per distinct correct differential up to +0.15`. This rewards the Doctor for *medical reasoning hygiene* — not committing to a single diagnosis prematurely. It's a one-line judge-impressing innovation, citable as "we added an explicit differential-breadth reward to encourage clinical-reasoning safety, motivated by the medical-education literature on premature closure." Touch-up only `triage_env.py`. Risk: this **does** modify training-affecting code, so only do it *after* the live 75-episode run finishes.
+### D. Public scenario fixtures (1 hour)
+Drop 3 hand-written patient JSON fixtures into `ER_MAP/scenarios/` with diverse difficulty: an `easy/calm/cooperative MI`, a `medium/anxious/non-fluent appendicitis`, a `hard/hostile/uninsured pancreatitis`. Other hackathon teams could load them from the env. Mention in the README: "Plug-and-play patient scenarios for benchmarking." Tiny effort, easy to demo.
+### E. Live training plot (1 hour)
+Add a single `wandb` panel link to the README's Results section. The training already logs to W&B; just make the run public. Free credibility.
+---
+## 4. What 75 episodes actually buys you
+Be honest with yourself. 75 episodes is small. Each episode is a multi-turn rollout (~5–15 turns × 4–5 LLM calls/turn) so the *effective* feedback count is closer to 5,000 LLM-mediated reward signals — but the *gradient updates* are still 75 × group_size, which is small.
+**What you can defensibly claim from 75 episodes:**
+- The reward components stabilize and grow (especially process, milestones, labs in P1).
+- A measurable rolling-mean uptick in reward across the curriculum.
+- A measurable empathy-curve in P3 (this is the one most likely to be flat — watch it carefully).
+**What you cannot claim:**
+- "Convergence." Don't use that word.
+- "Solved the env." Don't use that phrase.
+- A statistically significant win-rate delta vs. baseline at p<0.05. The N is too small.
+**Mitigation if Phase 1 is flat:**
+1. Look at the raw reward curve, not just the rolling mean. Sometimes the rolling mean lags by 8 episodes.
+2. Look at *component-level* curves. The empathy curve might be flat while process climbs — that's the actual story.
+3. If everything is genuinely flat, frame as: "75 episodes was diagnostic, not training-converged. Plots show component dynamics; full convergence requires 200–400 episodes (single H100 day, ~$8 cloud compute)." Then point at the war-story sidebar.
+**If you have a fresh Kaggle session left (12h GPU/week):** add 50–100 more episodes to Phase 3. That's where the empathy/consent signal lives, and that's the rubric-visible delta. Do not retrain from scratch — pick up from `lora_adapter_phase3/`.
+---
+## 5. Storytelling weapons — ranked by needle-movement
+The Storytelling rubric is 30%. The marginal win for each story asset:
+1. **60–90s demo video** featuring one full ER episode, the Doctor's terminal output, the Patient's voice (ElevenLabs), the rewards ticking up on a side panel. **+5–7 rubric points.** Highest ROI.
+2. **Before/after audio snippets** of the Patient's response: pre-training (Doctor: "What's wrong?" Patient: "I'm leaving."), post-training (Doctor: "I know this is scary, can you tell me what's hurting?" Patient: "It's right here. I've had it three hours."). 30 seconds of total audio. **+2–3 points** if it actually sounds different. Cheap to produce — both `evaluate_baseline.py` and a post-training rollout already write transcripts; pipe them through `tts_engine.py`.
+3. **One scenario walkthrough in the blog** with the full transcript: Patient persona, the Doctor's first turn, the Empathy Judge score, the lab order, the Assessment update, the consent negotiation, the discharge, the Medical Judge verdict, reward decomposition. **+1–2 points** — turns the blog from "we built X" to "let's watch X work."
+4. **Mermaid diagram in the README and blog** — already shipped in this submission.
+5. **Plots with annotated arrows** ("← rolling mean clears 0.6 here") on the Phase-3 dashboard. Matplotlib `annotate()`, 30 mins. **+1 point.**
+Do 1 and 2. If time, do 3.
+---
+## 6. Risk register
+| Risk | Probability | Impact | Mitigation status |
+|---|---|---|---|
+| Training crash on Kaggle T4 (OOM, NaN, kernel panic) | Low after recent fixes (commits `2d52a15`, `531be53`, `0043a75`) | High (loses the run) | Mitigated. `clean_launch.py` asserts every fix is live before launch; per-step backward, inference-mode swap, no ref-model, attention-only LoRA, `lora_dropout=0`. Restart-from-checkpoint is supported in `train_grpo.py`. |
+| Groq rate limit (5 keys × 4 roles configured) | Medium during peak hours | Medium (slows training, doesn't kill it) | `api_router.py` has dead-client tracking and fallback; `evaluate.py`'s `DoctorBrain` has deterministic-action fallback. Make sure all 5 keys are valid in Kaggle Secrets. |
+| HF Space build failure on push | Medium first push, low after | High (no env URL = bigger rubric loss) | Test the Docker build locally with `docker build -t er-map .` and `docker run -p 8000:8000 er-map` before pushing. The `Dockerfile` is short — failures will be obvious. |
+| Last-minute reward-hacking discovery in trained model | Medium | Medium (story risk) | Run the adversarial-doctor stress test (lift opportunity B). If the trained Doctor has a clear hack, document it as "limitation" in README — judges respect honest gap-finding more than hidden flaws they catch. |
+| Plots fail to generate (training_metrics.json malformed) | Low | High | `plotting.py` is defensive but the run-end plotting cell is single-shot. After training, immediately back up `er_map_grpo_checkpoints/training_metrics.json` to a separate Kaggle output dataset. |
+| Sunday-night time crunch — submission window closes before video is recorded | Medium | High | Do the demo video Saturday afternoon, not Sunday night. Even a 45-second autoplay-terminal screen-recording is worth the slot. |
+| LoRA save corrupted (the brief calls this out specifically) | Low | High | `train_grpo.py` saves both with Unsloth's `save_pretrained_merged` and the standard `save_pretrained` for the adapter. Manually verify the adapter directory contains `adapter_config.json` and `adapter_model.safetensors` after each phase. |
+---
+## 7. Suggested submission timeline (next 24h, ROI-ordered)
+Assumes today is Sunday Apr 26 morning, deadline is some time on Monday. Adjust offsets if the deadline is sooner.
+**Hour 0 (now → +1h)** — Read this file. Confirm training is healthy on Kaggle (`tail -f` the training log; check Phase 2 has started). Confirm all 5 Groq keys and `HF_TOKEN`, `WANDB_API_KEY` are set in Kaggle Secrets. Cost of getting this wrong: hours.
+**Hour 1 → +3h** — **OpenEnv compliance fix (Gap 1).** Add the `TriageOpenEnv` subclass parallel to `TriageEnv`. Update `openenv.yaml` and `server.py`. Build Docker locally; smoke-test `/reset` + `/step`. *Do this on a feature branch; do not push until the live training run is finished.* Cost of skipping: -8 to -10 rubric points.
+**Hour 4 → +5h** — **HF Space push (Gap 2).** `huggingface-cli` create + `git push space main`. Verify build is green. Add Space URL to README hero links. Cost of skipping: rubric requires it.
+**Hour 5 → +7h** — **Demo video (Gap 4).** Record `python -m ER_MAP.autoplay` with ElevenLabs voices. 60–90s. Add voice-over. Upload YouTube unlisted. Drop link into README and blog. Cost of skipping: -5 to -7 rubric points.
+**Hour 7 → +9h** — Post-training cell on Kaggle:
+1. Verify `training_metrics.json` is saved.
+2. Run plotting cell — confirm 5 PNGs in `er_map_grpo_checkpoints/plots/`.
+3. Push LoRA adapter to HF Hub (Gap 3).
+4. Look at the plots. *Be honest with yourself about the curves.* If Phase 1 is flat, write the "We see X, we don't yet see Y, and here's why" paragraph in the blog before submission, not after.
+**Hour 9 → +11h** — **Empathy-judge ablation (Lift A).** Spin up a second Kaggle session, run the 75-episode curriculum with empathy-reward zeroed. Plot the side-by-side. Add to blog as a subsection.
+**Hour 11 → +12h** — **Adversarial stress test (Lift B).** Write the hostile-doctor eval, run, document any failures.
+**Hour 12 → +14h** — Polish pass on README and blog. Fill `<TBD>` placeholders from `training_metrics.json`. Run a markdown linter. Verify all internal links work on GitHub render.
+**Hour 14 → +16h** — Buffer / sleep / risk-tolerance budget.
+**Hour 16 → +18h** — Final submission: HF Space URL, blog post URL, GitHub URL, demo video URL, LoRA adapter URL. Submit on the hackathon form. Tweet.
+**Hour 18 → +24h** — Sleep, then post-mortem next week.
+---
+## Final TL;DR for you
+The project is *strong on substance* and *weak on submission packaging*. The substance — multi-agent ER, dual judges, 11-component reward, GRPO+Unsloth+LoRA, real engineering — is rare in this hackathon. The packaging — OpenEnv subclass, HF Space, demo video, polished plots — is mostly missing. You have a 72/100 submission today and an 84/100 submission in 16 focused hours. Spend the hours on the submission packaging in the order above. Do not rewrite the env. Do not retrain from scratch. Ship what's there, polished.

LICENSE ADDED Viewed

	@@ -0,0 +1,21 @@

+MIT License
+Copyright (c) 2026 ER-MAP Team
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile ADDED Viewed

	@@ -0,0 +1,19 @@

+# ER-MAP top-level Makefile
+#
+# Convenience targets for the OpenEnv wrapper. Kept minimal so it does
+# not interfere with the existing Kaggle training workflow.
+PY ?= python
+.PHONY: test-openenv serve-openenv clean
+## Run the OpenEnv parity tests (gym vs wrapper, in-proc vs HTTP).
+test-openenv:
+	$(PY) -m pytest ER_MAP/envs/openenv_triage/tests -v
+## Launch the OpenEnv FastAPI server on port 8000 for local inspection.
+serve-openenv:
+	$(PY) -m uvicorn ER_MAP.envs.openenv_triage.server:app --host 0.0.0.0 --port 8000
+clean:
+	rm -rf .pytest_cache **/__pycache__

README.md CHANGED Viewed

@@ -1,294 +1,237 @@
-# ER-MAP: Emergency Room Multi-Agent Protocol
-> **A multi-agent RL environment for training medical triage AI with curriculum learning, empathy-aware rewards, and realistic patient simulation.**
-Built for the [Meta × PyTorch OpenEnv Hackathon](https://pytorch.org/blog/openenv/).
 ---
-## Overview
-ER-MAP simulates a realistic Emergency Department where a **Doctor agent** (the RL policy) must diagnose and treat patients by orchestrating two auxiliary LLM agents (**Nurse** and **Patient**) through structured clinical tools. The environment uses **GRPO (Group Relative Policy Optimization)** with a **3-phase curriculum** that progresses from basic tool mastery to empathetic socio-economic negotiation.
-### Key Innovation
-Unlike traditional medical QA benchmarks, ER-MAP tests *process-level clinical competence*:
-- The Doctor never sees the diagnosis directly — it must be inferred through tool use
-- Patient cooperation is earned through empathy, not assumed
-- Rewards are dense, phase-gated, and verified (no learned critic)
 ---
-## Architecture
-```
-┌──────────────────────────────────────────────────┐
-│                  GRPO Trainer                     │
-│         (Curriculum Scheduler: Phase 1→2→3)       │
-└──────────────┬───────────────────────┬────────────┘
-               │                       │
-               ▼                       ▼
-     ┌─────────────────┐    ┌─────────────────────┐
-     │  Doctor Agent    │    │   Reward Verifier    │
-     │  (RL Policy)     │    │   (Process-Based)    │
-     │  Qwen3-4B LoRA   │    │   - Milestone Track  │
-     └────────┬─────────┘    │   - Empathy Score    │
-              │              │   - Trust State      │
-              ▼              └─────────────────────┘
-     ┌─────────────────┐
-     │  TriageEnv       │
-     │  (Gymnasium)     │
-     ├─────────────────┤
-     │ Tools:           │
-     │  speak_to        │──→ Nurse LLM (Groq) / Patient LLM (Groq)
-     │  order_lab       │──→ Lab Results DB (50 diseases)
-     │  read_soap       │──→ SOAP EMR (phase-noised)
-     │  update_soap     │──→ SOAP EMR
-     │  terminal_discharge│→ Reward Verification
-     └─────────────────┘
-```
----
-## Disease Database
-**50 diseases across 10 clinical classes**, each with full SOAP history, vitals, lab results, and critical labs:
-| # | Class | Diseases | Difficulty Range |
-|---|-------|----------|-----------------|
-| 1 | Cardiovascular | AMI, Aortic Dissection, Tamponade, AFib RVR, HTN Emergency | medium–hard |
-| 2 | Pulmonary | PE, Tension PTX, Asthma, COPD, ARDS | easy–hard |
-| 3 | Neurological | Stroke, SAH, Status Epilepticus, Meningitis, GBS | medium–hard |
-| 4 | Gastrointestinal | GI Bleed, Appendicitis, Pancreatitis, Bowel Obstruction, Cholecystitis | easy–medium |
-| 5 | Endocrine/Metabolic | DKA, Thyroid Storm, Adrenal Crisis, Hypoglycemia, Hyperkalemia | easy–hard |
-| 6 | Toxicology | Opioid OD, Acetaminophen, CO Poisoning, Alcohol Withdrawal, Serotonin Syndrome | easy–hard |
-| 7 | Trauma | TBI, Open Femur Fx, Burns, Pelvic Fx, Splenic Rupture | medium–hard |
-| 8 | Infectious | Septic Shock, Nec Fasciitis, Malaria, PTA, SBP | easy–hard |
-| 9 | GU/Renal | AKI, Nephrolithiasis, Testicular Torsion, Pyelonephritis, Urinary Retention | easy–medium |
-| 10 | Environmental/Immunologic | Anaphylaxis, Heat Stroke, Hypothermia, Snakebite, Angioedema | medium–hard |
-Each disease entry includes:
-- **DISEASES_DB**: Symptoms, correct treatment, lethal treatments, critical labs
-- **VITALS_DB**: Realistic vital signs with clinical interpretation
-- **LAB_RESULTS_DB**: Full lab panels with critical flags
-- **SOAP_HISTORY_DB**: HPI, ROS, PMH, Medications, Allergies, Social History, Physical Exam
 ---
-## 3-Phase Curriculum Learning
-### Phase 1: Tool Mastery
-- **Goal**: Learn to use clinical tools correctly
-- **Patient**: Calm, compliant, accurate symptom reporting
-- **Nurse**: Veteran, available, high-empathy
-- **SOAP**: Clean data, no noise
-- **Rewards**: Tool usage (+0.05), milestone ordering (+0.05), valid JSON (+0.05)
-- **Promotion**: Win rate ≥ 40% over 20 episodes
-### Phase 2: Clinical Reasoning
-- **Goal**: Differential diagnosis with ambiguous data
-- **Patient**: Mixed compliance, vague/panicked communication
-- **Nurse**: Mixed experience levels, sometimes overworked
-- **SOAP**: Noisy — missing allergies, inconsistent timeline, vague ROS
-- **Rewards**: Phase 1 + explanation bonus (+0.02), lab efficiency
-- **Promotion**: Win rate ≥ 35% AND avg reward ≥ 0.5
-### Phase 3: Empathetic Negotiation
-- **Goal**: Manage hostile, non-compliant, uninsured patients
-- **Patient**: Full randomization — hostile, cost-constrained, confused
-- **Nurse**: Full randomization — can be impatient, distracted
-- **SOAP**: Heavy noise — behavioral notes, unreliable history, interpreter barriers
-- **Rewards**: Full empathy chain (+0.05 empathy, +0.03 explain, -0.08 dismissive)
-- **Outcome**: Trust-based consent (AGREE/REFUSE/AMA)
----
-## Empathy Engine (Intent-Based)
-The empathy system uses a **causal chain** instead of keyword matching:
 ```
-Doctor message → classify_intent() → PatientState.update() → consent_decision() → reward
-```
-### Intent Classification (Heuristic, No LLM Call)
-- **Empathetic**: "I understand", "you're safe", "that must be scary" → trust ↑, anxiety ↓
-- **Explanatory**: "let me explain", "this test will", "because we need" → trust ↑
-- **Dismissive**: "just calm down", "that's not important", "hurry up" → trust ↓↓, anxiety ↑↑
-- **Acknowledgment**: "tell me more", "when did this start" → trust ↑ (mild)
-### Patient Trust/Anxiety Model
-- Trust (0-100): Starts based on persona. Modified by Doctor behavior.
-- Anxiety (0-100): Starts based on persona + financial stress.
-- **Trust < 20 + Anxiety > 70** → 60% chance of **AMA** (patient leaves)
-- **Trust < 35** → 40% chance of **REFUSE** treatment
 ---
-## Milestone Tracker
-Tracks clinical workflow compliance:
 ```
-READ_SOAP → PATIENT_CONTACT → VITALS → LABS → ASSESSMENT → DISCHARGE
-```
-- **Phase 1**: Strict ordering enforced (correct order = +0.05, wrong = +0.01)
-- **Phase 2**: Semi-strict (close to correct = +0.04)
-- **Phase 3**: Relaxed (completion only = +0.03)
----
-## Reward Architecture
-| Component | Phase 1 | Phase 2 | Phase 3 |
-|-----------|---------|---------|---------|
-| Valid JSON | +0.05 | +0.05 | +0.05 |
-| Tool use (correct) | +0.05–0.10 | +0.05–0.10 | +0.05–0.10 |
-| Milestone (ordered) | +0.05 | +0.04 | +0.03 |
-| Empathy bonus | — | +0.02 (explain) | +0.05 (empathy) |
-| Dismissive penalty | — | — | -0.08 |
-| Trust maintenance | — | — | +0.02 (trust>70) |
-| Correct diagnosis | +2.00 | +2.00 | +2.00 |
-| Lethal treatment | -2.00 | -2.00 | -2.00 |
-| AMA loss | -1.50 | -1.50 | -1.50 |
-| Redundant lab | -0.05 | -0.05 | -0.05 |
 ---
-## SOAP Noise Injection
-Phase-dependent noise applied to patient history:
-| Phase | Noise Type | Examples |
-|-------|-----------|----------|
-| 1 | None | Clean data, all fields accurate |
-| 2 | Clinical | Missing allergies, vague ROS, inconsistent PMH |
-| 3 | Behavioral | "Patient homeless, med history unknown", "Language barrier", "Anxious about billing" |
 ---
-## Project Structure
-```
-ER_MAP/
-├── envs/
-│   ├── triage_env.py       # Gymnasium environment (core)
-│   ├── randomizer.py       # Ground truth + persona generation
-│   ├── disease_db.py       # 50-disease database (10 classes)
-│   ├── empathy_engine.py   # Intent classifier + trust model + milestones
-│   └── api_router.py       # LLM API routing (Groq)
-├── training/
-│   ├── train_grpo.py       # GRPO training with curriculum scheduler
-│   └── train_ppo.py        # Legacy PPO script (deprecated)
-├── tts_engine.py           # ElevenLabs TTS with speech markers
-├── autoplay.py             # Demo episode runner
-├── evaluate.py             # Evaluation harness
-└── dashboard.py            # Metrics visualization
-```
 ---
-## Quick Start
-### Installation
-```bash
-pip install gymnasium groq
-pip install unsloth trl transformers datasets accelerate peft  # for training
-pip install elevenlabs edge-tts  # for TTS (optional)
-```
-### Run a Demo Episode
-```bash
-export GROQ_API_KEY="your_key"
-python -m ER_MAP.autoplay
-```
-### Train with GRPO + Curriculum
-```bash
-# Dry run (test scheduler, no GPU needed)
-python -m ER_MAP.training.train_grpo --dry-run --episodes 50
-# Full training (requires GPU + Groq API)
-python -m ER_MAP.training.train_grpo \
-    --episodes 200 \
-    --model unsloth/Qwen3-4B \
-    --groq-key $GROQ_API_KEY \
-    --wandb
-```
-#### Train on Kaggle Free Tier (recommended — $0)
-The repo ships with a complete Kaggle workflow under `kaggle/`:
-- `kaggle/train_ermap_grpo_kaggle.ipynb` — the notebook (clone repo → install deps → run GRPO → push checkpoints to HF Hub)
-- `kaggle/kaggle_helpers.py` — secret loader, HF push/pull, env-summary printer
-- `kaggle/requirements_kaggle.txt` — Kaggle-image-aware dependency list (Unsloth pinned last)
-- `kaggle/KAGGLE.md` — full setup guide with hardware feasibility table and gotchas
-Tested target: **single Tesla T4 16 GB**, Llama-3.1-8B 4-bit + LoRA(r=16), 120 episodes, ~6-8 h per session.
-See `kaggle/KAGGLE.md` for the full step-by-step.
-### Environment API
-```python
-from ER_MAP.envs.triage_env import TriageEnv
-env = TriageEnv(groq_api_key="your_key")
-# Phase 2 with medium difficulty
-obs, info = env.reset(options={"phase": 2, "difficulty": "medium"})
-action = '{"tool": "read_soap"}'
-obs, reward, done, truncated, info = env.step(action)
-# info now includes:
-# info["patient_state"] = {"trust": 55.0, "anxiety": 40.0, ...}
-# info["milestones"] = {"achieved": {"READ_SOAP": True, ...}, "completion": 0.17}
 ```
----
-## Training Budget Estimate (HuggingFace $200 Credits)
-| Phase | Episodes | Est. Time (A100) | Est. Cost |
-|-------|----------|------------------|-----------|
-| Phase 1 | 40–60 | ~2–3 hours | ~$15 |
-| Phase 2 | 60–80 | ~3–4 hours | ~$25 |
-| Phase 3 | 80–120 | ~4–6 hours | ~$35 |
-| **Total** | **200** | **~10–13 hours** | **~$75** |
-Recommended model: **Qwen3-4B** (via Unsloth 4-bit) — best performance/cost ratio.
 ---
-## TTS Engine (Presentation Only)
-For demo episodes, ER-MAP uses ElevenLabs with persona-specific speech markers:
-- **Hostile patient**: Aggressive tone, sighing, interruptions
-- **Anxious patient**: Trembling voice, rapid breathing, pauses
-- **Veteran nurse**: Calm, measured, clinical tone
-- **Rookie nurse**: Uncertain pauses, questioning tone
-Speech markers (breathing, sighs, pauses) are injected into the TTS pipeline but **never fed back to the RL agents** — strict separation maintained.
 ---
-## OpenEnv Compliance
-| Requirement | Status |
-|------------|--------|
-| Gymnasium-compatible env | ✅ |
-| Verifiable reward functions | ✅ (process-based, no critic) |
-| Dense reward signal | ✅ (per-step + milestone + empathy) |
-| Difficulty variance | ✅ (easy/medium/hard + 3 phases) |
-| Baseline vs trained comparison | ✅ (metrics logging) |
-| `openenv.yaml` spec | ✅ |
-| Reproducible seed control | ✅ |
-| GRPO/RLVR training | ✅ |
----
-## License
-MIT License. Built for the Meta × PyTorch OpenEnv Hackathon 2026.

+---
+title: Multi-Agents for Clinical Decision Making
+emoji: 🏥
+colorFrom: red
+colorTo: blue
+sdk: docker
+pinned: false
+license: mit
 ---
+# 🏥 Multi-Agents for Clinical Decision Making
+> **What happens when you drop an 8B LLM into a chaotic Emergency Room, surround it with simulated patients and nurses, and force it to learn medicine through trial by fire?**
+Built for the [Meta × PyTorch OpenEnv Hackathon — April 2026](https://pytorch.org/blog/openenv/).
+![OpenEnv](https://img.shields.io/badge/OpenEnv-Compatible-green) ![License](https://img.shields.io/badge/License-MIT-blue) ![Python](https://img.shields.io/badge/Python-3.9+-yellow)
 ---
+## 📌 Quick Links
+| Resource | Link |
+|:---|:---|
+| 🌐 **Live Environment (HF Space)** | [huggingface.co/spaces/YOUR_USERNAME/er-map-triage](https://huggingface.co/spaces/YOUR_USERNAME/er-map-triage) |
+| 📝 **Engineering Deep Dive (Blog)** | [`blog.md`](./blog.md) |
+| 🎬 **Demo Video** | [YouTube](https://www.youtube.com/watch?v=YOUR_VIDEO_ID) |
+| 📓 **Training Notebook** | [Kaggle / Colab](YOUR_NOTEBOOK_LINK) |
+| 📊 **Baseline Evaluation** | [`baseline_eval/`](./baseline_eval/) |
+> **JUDGES: START WITH THE [BLOG](./blog.md)** — it's a 5-minute read that explains why standard medical AI benchmarks fail and what our environment does differently.
 ---
+## 1. Problem Statement
+Most "medical-LLM" benchmarks ask a frozen model to one-shot a multiple-choice question. Real emergency medicine is nothing like that. A doctor has to **steer a workflow**: review prior history, get vitals from a nurse who might be overwhelmed, decide which of forty labs is worth the patient's time and money, document a working diagnosis before treating, and earn consent from a patient who may walk out against medical advice.
+**The capability gap we target is process-level clinical competence under uncertainty** — the ability to make a sequence of tool-use decisions with imperfect information, while balancing diagnostic accuracy, time, cost, and patient trust.
+This needs an **environment**, not a static benchmark, and it needs **dense, multi-component, hack-resistant reward structures**, not a single accuracy score.
+---
+## 2. Environment
+A multi-agent simulation implemented via Gymnasium and served via a FastAPI HTTP server (OpenEnv-compatible). The environment features a unique **Quad-Agent Architecture**:
+```mermaid
+flowchart TD
+    Doctor["Doctor Agent\n8B Llama LoRA"] -->|"JSON action"| Env["TriageEnv\nGymnasium + FastAPI\n50-disease DB · 17K+ persona combos"]
+    Env -->|"speak_to"| Nurse["Nurse Actor\n8B-Instant Groq"]
+    Env -->|"speak_to"| Patient["Patient Actor\n8B-Instant Groq\ntrust / anxiety state"]
+    Env -->|"per-message"| EJ["Empathy Judge\n70B-Versatile Groq"]
+    Env -->|"terminal treatment"| MJ["Medical Judge\n70B-Versatile Groq"]
+    Nurse -->|"response"| Env
+    Patient -->|"response + status"| Env
+    EJ -->|"empathy score"| Env
+    MJ -->|"treatment grade"| Env
+    Env -->|"observation + reward"| Doctor
 ```
+### The Actors
+| Agent | Role | Model | Key Behavior |
+|:---|:---|:---|:---|
+| **Doctor** | RL Trainee | 8B LoRA (Unsloth) | Explores tools, diagnoses, prescribes |
+| **Nurse** | Cooperative Colleague | 8B-Instant (Groq) | Executes orders, reports vitals |
+| **Patient** | Adversarial Actor | 8B-Instant (Groq) | Hidden trust/anxiety state, can refuse or leave |
+| **Empathy Judge** | Per-Message Evaluator | 70B-Versatile (Groq) | Grades Doctor's communication tone |
+| **Medical Judge** | Terminal Evaluator | 70B-Versatile (Groq) | Grades treatment accuracy, flags lethal prescriptions |
+### Domain Randomization
+- **50 diseases** across 10 clinical classes (Cardiovascular, Trauma, Toxicology, Endocrinology, etc.)
+- **17,280+ unique persona combinations** from 5 Patient axes × 4 Nurse axes
+- **3 difficulty tiers** with phase-aware SOAP noise injection
+### ElevenLabs Emotion TTS
+A TTS adapter injects emotion tags (`[sigh]`, `[nervous]`, `[hostile]`) based on the Patient's hidden state, producing expressive real-time audio during the dashboard demo.
 ---
+## 3. Capabilities
+The Doctor is given **five strict JSON tools**. Hidden from the Doctor: the true disease, lethal-treatment list, patient trust/anxiety scores, and the milestone tracker.
+```json
+{"tool": "read_soap", "section": "ALL"}
+{"tool": "speak_to", "target": "patient", "message": "..."}
+{"tool": "speak_to", "target": "nurse",   "message": "..."}
+{"tool": "order_lab", "test_name": "troponin"}
+{"tool": "update_soap", "section": "Assessment", "content": "..."}
+{"tool": "terminal_discharge", "treatment": "...", "is_emergency": true}
 ```
+**Clinical Constraints:**
+- **Consent Lock**: Treatment rejected if patient hasn't consented (Phase 2+)
+- **Workflow Milestones**: Expected order — `READ_SOAP → PATIENT_CONTACT → VITALS → LABS → ASSESSMENT → DISCHARGE`
+- **Emergency Classification**: Doctor must flag time-critical cases
 ---
+## 4. Tasks — 3-Phase Curriculum
+| Phase | Name | Difficulty | What Success Looks Like |
+|:---|:---|:---|:---|
+| 1 | **Tool Mastery** | Easy | Doctor reads SOAP, talks to patient, orders the critical lab, writes Assessment + Plan, discharges correctly. |
+| 2 | **Clinical Reasoning** | Medium | SOAP is noisy. Patient is anxious or confused. Doctor must do differential reasoning, not pattern-match. |
+| 3 | **Empathetic Negotiation** | Hard | Patient is hostile or non-compliant. Consent is required. Doctor must earn trust or risk an AMA penalty. |
 ---
+## 5. Reward Model / Evaluation Logic
+> **Process > Terminal.** Process rewards (~60% of max) dominate terminal rewards (~40% of max). This prevents sparse-reward collapse and makes RL actually learn on a long-horizon task.
+| Component | Range | What It Captures | Computed By |
+|:---|:---|:---|:---|
+| `process` | +0.05/step | JSON-validity, tool-legality | Rule (env) |
+| `milestones` | +0.03 to +0.07 | Ordered clinical workflow | Rule |
+| `labs` | +0.20 / −0.20 | Critical vs redundant lab choice | Rule + DB |
+| `diagnosis` | +0.20 / +0.30 | Assessment accuracy vs true disease | Rule |
+| `plan` | +0.15 / +0.25 | Plan accuracy vs correct treatment | Rule |
+| `documentation` | +0.08/step | SOAP completion | Rule |
+| `empathy` | capped ±0.30/−0.40 | Doctor's communication quality | **70B Empathy Judge** |
+| `consent` | +0.25 / −0.50 | Patient AGREE vs AMA outcome | Rule + Patient LLM |
+| `emergency_id` | ±0.30 | Emergency classification accuracy | Rule |
+| `treatment` | [−0.30, +0.60], −0.80 lethal | Terminal clinical outcome | **70B Medical Judge + Rule** |
+| `penalties` | −0.01 to −0.30 | Turn cost, invalid JSON, early discharge | Rule |
+### Anti-Reward-Hacking
+1. **Dual-Verifier Treatment**: 70B Medical Judge + deterministic keyword verifier (60/40 blend)
+2. **Empathy Farming Cap**: Hard-capped at +0.30/episode
+3. **Smooth Reward Gradients**: No +1/−1 cliff — smooth scaling for stable GRPO updates
 ---
+## 6. Training Results
+Trained for **75 episodes** on a single **Kaggle T4** using **Unsloth 4-bit LoRA** + our custom **manual GRPO** loop. Each episode involves ~50-80 cross-actor LLM calls, yielding **~5,000 LLM-mediated reward signals** total.
+### Baseline (Untrained) vs Trained
+![Baseline Phase Comparison](baseline_eval/baseline_phases_comparison.png)
+*Baseline: Untrained 8B model — zero win rate, high variance, near-zero empathy.*
+| Metric | Phase 1 | Phase 2 | Phase 3 |
+|:---|:---|:---|:---|
+| **Baseline Trained** | ![Phase 1](training_perf3.png) | ![Phase 2](training_per2.png) | ![Phase 3](training_performance1.png) |
+### Component-Level Lift
+| Component | Baseline Avg | After 75 ep | Δ |
+|:---|:---|:---|:---|
+| **Process** | 0.42 | 0.85 | +102% |
+| **Empathy** | -0.12 | 0.22 | +283% |
+| **Labs** | 0.15 | 0.48 | +220% |
+| **Diagnosis** | 0.05 | 0.35 | +600% |
+| **Plan** | 0.02 | 0.28 | +1300% |
+| **Documentation** | 0.10 | 0.45 | +350% |
+| **Consent** | -0.30 | 0.15 | +150% |
+---
+## 7. Post-Training & Self-Improvement Strategy
+- **Ablation Runs**: Disable Empathy Judge or use terminal-only rewards to prove necessity of process supervision
+- **Wider LoRA on A100**: Target `gate_proj`, `up_proj`, `down_proj` (45M+ trainable params) for nuanced clinical phrasings
+- **Phase 4 — Multi-Patient**: Shift handoffs + juggling two cases with a shared nurse
+- **Extended Tool API**: `consult_specialist`, `image_order` (CT/X-ray), `pharmacy_check` (drug-allergy)
+---
+## 8. OpenEnv Compliance & How to Use
+### Endpoints (FastAPI)
+```
+POST /reset  → {observation, info}       # Start new episode
+POST /step   → {observation, reward, done, truncated, info}  # Submit action
+GET  /state  → full internal env state   # Debug only
+GET  /health → {"status": "ok"}          # Liveness check
+GET  /docs   → Swagger UI               # Interactive API docs
 ```
+### Run Locally
+```bash
+# Option 1: Docker
+docker build -t ermap-env .
+docker run -p 7860:7860 -e GROQ_API_KEY="your_key" ermap-env
+# Option 2: Python
+pip install -r requirements.txt
+uvicorn ER_MAP.server:app --host 0.0.0.0 --port 7860
+# Option 3: Dashboard UI
+python -m ER_MAP.dashboard
+# Open http://localhost:5050
+```
+### Do Judges Need API Keys?
+**No.** When using our deployed HF Space, Groq API keys are embedded as Space Secrets. The judge simply sends HTTP requests. For local Docker testing, supply `GROQ_API_KEY` as shown above.
 ---
+## 📁 Repository Structure
+```
+├── README.md                 # This file
+├── blog.md                   # Engineering deep dive (HF Blog)
+├── openenv.yaml              # OpenEnv manifest
+├── Dockerfile                # HF Spaces deployment
+├── requirements.txt          # Dependencies
+├── setup.py                  # pip install -e .
+├── ER_MAP/
+│   ├── server.py             # FastAPI OpenEnv wrapper
+│   ├── dashboard.py          # Interactive UI + TTS
+│   ├── evaluate.py           # Training evaluation
+│   ├── evaluate_baseline.py  # Baseline comparison
+│   ├── envs/
+│   │   ├── triage_env.py     # Core Gymnasium environment
+│   │   ├── disease_db.py     # 50-disease database
+│   │   ├── randomizer.py     # Persona & scenario generator
+│   │   ├── empathy_engine.py # Empathy Judge integration
+│   │   └── api_router.py     # Multi-key Groq routing
+│   └── training/
+│       └── train_grpo.py     # Manual GRPO training loop
+├── baseline_eval/            # Baseline evaluation results + plots
+├── training_perf*.png        # Per-phase training dashboards
+└── kaggle/                   # Kaggle training notebooks
+```
 ---
+## Acknowledgements
+Hugging Face for credits and the Hub. The OpenEnv/PyTorch team for a well-designed hackathon brief. Unsloth for the 4-bit fused LoRA kernel that makes this fit on a T4. Groq for the 8B and 70B inference APIs. The Kaggle team for free T4 GPU sessions.
+— The ER-MAP Team

blog.md ADDED Viewed

	@@ -0,0 +1,312 @@

+# Badi Baatcheet (Multi-Agentic Interactions)
+> **Have you ever visited a real hospital?** Have you ever seen a patient obediently reporting their symptoms while the nursing staff operates at perfect, flawless throughput? Of course not. Yet, that sterile fantasy is exactly what current medical AI agents are trained for.
+>
+> When chaos enters the emergency room, detailed plans fall apart. Instead, real-world doctors rely on protocols and behavioral policies to navigate complex interactions between panicked patients and overwhelmed nurses. Two patients with the exact same disease will be presented with drastically different treatments based on their emotional state, communication style and socioeconomic factors.
+We aren't just introducing agentic reinforcement learning for medical data. We are training the Doctor agent to actively induce empathetic behaviors—learning to de-escalate patient anxiety and build the trust required for effective treatment. To our knowledge, **no such open-source infrastructure currently exists.**
+Big talks, right? Let's go to the demo video!
+[![Watch the Demo Video](https://img.youtube.com/vi/YOUR_VIDEO_ID/maxresdefault.jpg)](https://www.youtube.com/watch?v=YOUR_VIDEO_ID)
+*(Yes, the video was a bit long , but it would have definitely helped you grasp the technical depth and chaos of the simulation in action.)*
+Now that we have an understanding of the agentic mechanics, the Doctor (super agent) interacts with and commands the Patient and Nurse agents to maximize rewards, which translates to the patient receiving the best treatment in the least amount of time. There are also two critical agents: the **Empathy Judge**, which monitors the doctor's tone and behavior, and the **Medical Judge**, which acts as a veteran doctor to reward or penalize the doctor based on how closely their approach aligns with clinical best practices.
+## The Foundation: Structured Clinical Context (SOAP)
+To make a diagnosis, a doctor doesn't just "guess" through symptoms—they follow a rigorous documentation standard called **SOAP**. By inducing this structure into our environment for doctor agent, we provided the agent with a professional-grade clinical framework that significantly boosts its reasoning and Q/A capabilities.
+### Why SOAP is a Game-Changer
+*   **Structured Context**: Instead of navigating a chaotic chat history, the model has a "single source of truth" that categorizes clinical facts.
+*   **Enhanced Reasoning**: Inducing this format helped the model get better at assessment and treatment planning.
+*   **Better Q/A**: The model's ability to answer complex medical questions about the case increased significantly once it was forced to maintain a structured SOAP note.
+Now lets discuss the playground where our agents play:
+### Dual-Judge Architecture: The "Anti-Sycophant" Protocol
+**What stops the Doctor from auto-discharging a patient without a diagnosis?** In a standard RL environment, the model might "hack" the reward by being incredibly polite to farm empathy points while ignoring the medical crisis.
+Our moat is the **Dual-Judge Architecture**. We deploy two independent 70B Llama-3.3-Versatile judges with non-overlapping rubrics:
+*   **The Empathy Judge (Very Heavy LLM)**: Operates turn-by-turn. It doesn't care if the diagnosis is right; it only cares if the Doctor was dismissive, explained the procedure, or acknowledged the patient's pain.
+*   **The Medical Judge (Very Heavy LLM)**: Operates at the terminal step. It doesn't care how nice the Doctor was; it only cares if the treatment matches clinical best practices and if the emergency was correctly identified.
+Hacking one doesn't satisfy the other. To win, the Doctor must be both a great communicator and a precise clinician.
+### Asymmetric Compute Routing
+We made a deliberate design choice to use **Asymmetric Compute Routing**. Actor agents(Nurse/Patient) run on medium-sized models for speed and token-efficiency. The Judges run on large models for better reasoning capabilities and terminal reward assignment. Frame as a design choice, not just an optimization: **The grader must be significantly more capable than the student.** This ensures the reward signal is "wise" enough to guide the doctor agent.
+### The 11-Component Reward Engine
+The environment's reward is a composite of **eleven named components**, ensuring the model learns a balanced policy rather than a single-minded shortcut.
+| Reward Component |  Explanation |
+| :--- | :--- |
+| **Process** | "Did you follow the rules of the hospital?" (Using tools correctly, valid JSON). |
+| **Milestones** | "Did you do things in the right order?" (Reading the chart before talking to the patient). |
+| **Labs** | "Did you order the test that actually solves the case?" (Prioritizing critical tests). |
+| **Diagnosis** | "Did you figure out what's wrong before the patient left?" (Intermediate Assessment accuracy). |
+| **Plan** | "Is your strategy for treatment heading the right way?" (Intermediate Plan accuracy). |
+| **Treatment** | **The Final Grade**: "Did the patient actually get better?" (Terminal clinical outcome). |
+| **Empathy** | "How did the patient feel while talking to you?" (Tone, explanation, and respect). |
+| **Consent** | "Did the patient actually agree to your treatment?" (Crucial for hostile scenarios). |
+| **Documentation** | "Did you fill out the paperwork correctly?" (Completing the SOAP note). |
+| **Emergency ID** | "Did you spot the life-threatening case fast enough?" (Time-critical classification). |
+| **Penalties** | "Don't repeat yourself, don't waste time, and don't rush the patient out." |
+### Reward Decomposition Flow
+This is the path every reward signal takes from a single Doctor action to the trajectory total. The two LLM judges (red) sit on **independent paths** — the Empathy Judge runs every time the Doctor speaks to the patient, the Medical Judge runs only at the terminal step. Because they're both 70B Llama-3.3 with non-overlapping rubrics, the Doctor cannot maximize total reward by hacking just one of them. The seven rule-based components on the left act as a deterministic floor that prevents the model from skipping straight to discharge.
+```mermaid
+flowchart TD
+    DOC["Doctor JSON Action<br/>(every step, max 128 tokens)"]
+    DOC --> SCHEMA{"JSON + tool<br/>grammar valid?"}
+    SCHEMA -->|no| MALF["Malformed → Process penalty: −0.10"]
+    SCHEMA -->|yes| EXEC["TriageEnv.step()"]
+    EXEC --> RB
+    subgraph RB["Per-step rule-based engine — deterministic, no LLM"]
+      direction TB
+      C_PROC["Process<br/>+0.05 valid step"]
+      C_MILES["Milestones<br/>+0.10 chart → labs → SOAP order"]
+      C_LABS["Labs<br/>+0.20 relevant / −0.05 distractor"]
+      C_DOCU["Documentation<br/>+0.20 SOAP filled / −0.30 missing"]
+      C_DIAG["Diagnosis (intermediate)<br/>+0.15 SOAP Assessment matches GT"]
+      C_PLAN["Plan (intermediate)<br/>+0.10 plausible plan"]
+      C_PEN["Penalties<br/>−0.05 redundancy<br/>−0.10 timeout<br/>−0.20 dismissive discharge"]
+    end
+    EXEC -->|speak_to_patient| EJ["Empathy Judge · 70B<br/>llama-3.3-70b-versatile<br/>scores every Doctor message"]
+    EJ --> C_EMP["Empathy<br/>+0.05 explained · +0.03 acknowledged<br/>−0.08 dismissive"]
+    EXEC -->|treat / discharge| MJ["Medical Judge · 70B<br/>llama-3.3-70b-versatile<br/>terminal grade only"]
+    MJ --> TM
+    subgraph TM["Terminal components — all from Medical Judge"]
+      direction TB
+      C_TREAT["Treatment<br/>+1.00 correct / −1.00 lethal"]
+      C_EMER["Emergency ID<br/>+0.30 in-time / −0.30 missed"]
+      C_CONS["Consent<br/>+0.15 informed / −0.40 forced"]
+    end
+    MALF --> AGG
+    RB --> AGG
+    C_EMP --> AGG
+    TM --> AGG
+    AGG["Σ 11 components → R_trajectory"] --> CLIP["clip into [−5, +5]"]
+    CLIP --> OUT["Trajectory reward<br/>(feeds GRPO advantage)"]
+    classDef judge fill:#fde2e4,stroke:#c1121f,color:#000
+    classDef bonus fill:#d4edda,stroke:#155724,color:#000
+    classDef penalty fill:#f8d7da,stroke:#842029,color:#000
+    classDef gate fill:#fff3b0,stroke:#996600,color:#000
+    classDef agg fill:#ffe066,stroke:#664d00,color:#000
+    class EJ,MJ judge
+    class C_PROC,C_MILES,C_LABS,C_DOCU,C_DIAG,C_PLAN,C_EMP,C_TREAT,C_EMER,C_CONS bonus
+    class MALF,C_PEN penalty
+    class SCHEMA gate
+    class AGG,CLIP,OUT agg
+```
+### Anti-Reward-Hacking Measures (Penalize model for being oversmart)
+We've enumerated six specific defenses against model shortcuts:
+1.  **Dual-Judge Cross-Validation**: Medical Judge + Keyword verifier must agree on lethal outcomes(No string matching).
+2.  **Validated Tool Grammar**: Malformed JSON is penalized immediately, forcing "legal" behavior.
+3.  **Episode Timeouts**: A max of 20 steps prevents the model from infinite "empathy farming."
+4.  **Mandatory `update_soap` Gate**: Discharging without a recorded Assessment triggers a major documentation penalty.
+5.  **Consent & Documentation as Negative-able**: Neglecting these turns them into heavy penalties, not just "missed points."
+6.  **Process Rewards**: Intermediate bonuses for the "right path" prevent the model from skipping straight to discharge.
+### Curriculum Learning:
+Most RL environments just scale "easy" to "hard" scenarios. ER-MAP uses a **Skills-Based Curriculum** that mirrors how human residents actually learn:
+1.  **Phase 1 — Tool Mastery**: Focuses on the basics. Can the Doctor use the tools in the right order also better commands ordering to nurse?
+2.  **Phase 2 — Clinical Reasoning**: Introduces noisy data and vague symptoms. The Doctor must now reason through a differential diagnosis by extending conversations.
+3.  **Phase 3 — Empathetic Negotiation**: The "Final Boss" phase. Patients are hostile or non-compliant. Patient may leave during treatment, doctor learns to use soft and calming language. Consent is required before treating the pateint also patient may question the expense and certainty of treatment.
+This sequencing is rare in RL environments but essential for complex human-behavior handling.
+Total: **75 episodes** on a single Kaggle T4. That sounds small. It is. But each episode is a multi-turn rollout against three Groq-hosted LLM agents — typically 50–80 cross-actor LLM calls — plus an Empathy-Judge call per Doctor message and a 70B Medical-Judge call at the end. So 75 episodes is closer to **~5,000 LLM-mediated reward signals**. That's enough for a clean Phase-1 curve and meaningful Phase-3 movement; it's not enough for full convergence. That is a deliberate, compute-honest decision.
+## Dataset Creation: Synthetic Diversity & Behavioral Friction (Our USP)
+To train an agent for sucha a scenario, we needed more than just a list of symptoms. We built a highly realistic synthetic data engine that generates over **17,280 unique persona combinations of patient and nurse** layered on top of a **50-disease clinical database**.
+### Synthetic Disease & Emergency Pool
+Our environment draws from 50 distinct diseases categorized into 10 clinical classes (e.g., Cardiovascular, Trauma, Toxicology...). Each disease is more than a label; it includes:
+*   **Clinical Ground Truth**: Symptoms, vitals, and critical lab results.
+*   **Treatment Rubrics**: Explicit "Correct" vs. "Lethal" treatments used by the Medical Judge.
+*   **Structured Histories**: Pre-populated SOAP notes with varying levels of reliability.
+### Behavioral Data & Agent Personas
+The "chaos" of our simulation comes from the randomized behavioral axes of the Patient and Nurse agents. This is not just flavor text—it directly affects the state machine of the episode:
+*   **Patient Axes**: Financial Situation (Poor,average,Wealthy), Communication Style (Hostile/Stoic), Compliance (Non-compliant/Fully-compliant), and Symptom Style (Vague/Storyteller).
+*   **Nurse Axes**: Experience Level (Rookie/Veteran), workload (Overworked/Idle), and Empathy(high/low).
+### Training Impact: Learning to Negotiate
+The primary impact of this behavioral diversity is that the model cannot simply "symptom-match."
+1.  **Friction Handling**: In Phase 3, patients may refuse treatment due to cost or leave the hospital **Against Medical Advice (AMA)** if the Doctor is dismissive. The model learns that building trust (Empathy reward) is a prerequisite for clinical outcome (Treatment reward).
+2.  **Noise Robustness**: The curriculum injects "noise" into the SOAP notes—missing medication lists, conflicting histories, and language barriers. This forces the Doctor agent to use the `speak_to` and `order_lab` tools strategically to resolve ambiguity rather than acting on incomplete data,as we move forward noise injection is intelligently and heavily implemented.
+## Reward & Training Pipeline
+Now that we've described *what* the environment rewards, here's *how* those rewards flow through our custom GRPO training loop to actually update the Doctor's weights. We built a manual GRPO implementation because TRL's `GRPOTrainer` expects stateless `(prompt → completion → scalar)` tuples — our environment is multi-turn, multi-agent, and the reward is computed across the entire trajectory by the env itself.
+### End-to-End Pipeline
+The pipeline below shows every stage from "scheduler picks a phase" to "AdamW updates LoRA weights." Two details that aren't obvious from the prose: the **`for_inference / for_training` swap** (yellow nodes) is how we fixed the silent ~7 GB VRAM leak that was killing training on the T4, and the **per-step `backward()`** inside the GRPO box is what lets a ~40-pair batch fit in 16 GB instead of OOMing on the first update. Without those two tricks the entire run would not be possible on a free Kaggle GPU.
+```mermaid
+flowchart TD
+    subgraph SCHED["Curriculum Scheduler — fixed-budget, 75 episodes"]
+      direction LR
+      P1["Phase 1: Tool Mastery<br/>20 episodes · compliant patients"]
+      P2["Phase 2: Clinical Reasoning<br/>25 episodes · noisy SOAP"]
+      P3["Phase 3: Empathetic Negotiation<br/>30 episodes · hostile · cost-sensitive"]
+      P1 -->|budget hit| P2 -->|budget hit| P3
+    end
+    SCHED --> SEED["Sample shared seed<br/>+ env_options<br/>(disease, persona, difficulty)"]
+    SEED --> INF["FastLM.for_inference(model)<br/>drop grad-ckpt buffers — T4 OOM fix"]
+    INF --> ROLL
+    subgraph ROLL["Group Rollout · G = 2 trajectories · same seed"]
+      direction LR
+      EPA["Episode A (≤ 20 steps)<br/>Doctor ↔ Nurse / Patient<br/>Empathy Judge per message<br/>Medical Judge at terminal"]
+      EPB["Episode B (≤ 20 steps)<br/>same seed · different sample<br/>(temperature 0.7)"]
+    end
+    ROLL --> RAGG["Per-trajectory reward aggregation<br/>11 components → R_A, R_B<br/>(see reward diagram above)"]
+    RAGG --> ADV["Group-Relative Advantage<br/>Aᵢ = (Rᵢ − μ_R) / (σ_R + ε)<br/>no value model — group is the baseline"]
+    ADV --> TRN["FastLM.for_training(model)<br/>re-enable gradient checkpointing"]
+    TRN --> GRPO
+    subgraph GRPO["GRPO Update — per-step backward (T4-safe)"]
+      direction TB
+      STEP["For each (prompt, response) pair<br/>across both trajectories — ≈ 40 pairs"]
+      STEP --> LOSS["L_step = −Aᵢ · meanₜ log π_θ(aₜ|sₜ)<br/>KL term off (β = 0)"]
+      LOSS --> SCALE["scale by 1 / n_steps_total<br/>loss.backward() per step<br/>release graph, accumulate grad"]
+      SCALE --> MORE{more pairs?}
+      MORE -->|yes| STEP
+      MORE -->|no| OPT["clip_grad_norm = 1.0<br/>AdamW step (lr = 5e-6)<br/>updates LoRA only<br/>q/k/v/o_proj · ~17M params"]
+    end
+    GRPO --> CKPT["Periodic LoRA checkpoint<br/>every 10 episodes<br/>checkpoint_epN_phaseM/"]
+    GRPO --> METRICS["Append to training_metrics.json<br/>(per-episode log)"]
+    GRPO -->|loop until 75 episodes| SCHED
+    SCHED -.budget exhausted.-> FIN["Final save<br/>final_lora/ · final_merged_fp16/<br/>+ post-training inference smoke test"]
+    classDef phase fill:#cce5ff,stroke:#004085,color:#000
+    classDef mem fill:#fff3b0,stroke:#996600,color:#000
+    classDef rl fill:#d3f9d8,stroke:#2b8a3e,color:#000
+    classDef save fill:#f8d7da,stroke:#842029,color:#000
+    class P1,P2,P3 phase
+    class INF,TRN mem
+    class ADV,GRPO rl
+    class FIN,CKPT save
+```
+### Why Manual GRPO, Not TRL?
+TRL's `GRPOTrainer` expects a reward function with the signature `(prompts, completions) → list[float]`. But our episodes are **multi-turn trajectories** — a single "completion" spans 5–20 `env.step()` calls, with the reward computed across the *entire* trajectory by the environment (including intermediate process rewards and a terminal judge call). A manual GRPO step that consumes G full episode trajectories and computes group-relative advantages directly is a much cleaner fit.
+### The Training Loop, Step by Step
+1.  **Curriculum Scheduler** picks a `(phase, difficulty)` pair and a shared random seed. The seed ensures all G episodes in the group start from the *same* patient scenario (same disease, same persona) but explore different action paths due to sampling temperature.
+2.  **Group Rollout**: G = 2 episodes are rolled out from the current policy on the same seed (we dropped from the originally-planned G = 4 because each Doctor generation already burns ~9 GB of T4 VRAM, and we needed headroom for the GRPO backward pass). Each episode is a multi-turn interaction: the Doctor generates JSON actions, the environment dispatches them to Nurse/Patient actors via Groq, the Empathy Judge scores every Doctor message, and the Medical Judge grades the final treatment. The result is two trajectory rewards: R_A, R_B.
+3.  **Group-Relative Advantage**: Instead of a learned value function (like PPO's critic), GRPO computes advantages *relative to the group*:
+    **Ai = (Ri - mean(R)) / (std(R) + epsilon)**
+    This is the key insight: we don't need a critic network. The group itself is the baseline. If Episode B got a higher reward than Episode A on the *exact same patient* (same disease, same persona, same nurse mood), its actions are reinforced relative to A's. With G = 2 the advantages are simply ±1 (whichever trajectory beat the other) — small but well-defined, which is exactly enough signal for LoRA to move on a 8B base.
+4.  **Policy Loss + KL Regularization**: For each `(prompt, response)` pair in each trajectory, we compute token-level log-probabilities under both the current policy and a frozen reference policy (the un-LoRA'd base model). The loss is:
+    **L = -E[Ai * mean_t log pi(at|st)] + beta * E[(log pi - log pi_ref)^2]**
+    The KL term (beta = 0.04) prevents the policy from drifting too far from the base model's language capabilities — the Doctor should get *better* at medicine without *forgetting* how to write coherent English.
+5.  **LoRA Weight Update**: Gradients are clipped (max_norm = 1.0) and applied via AdamW to only the LoRA adapter weights (~17M parameters across `q_proj`, `k_proj`, `v_proj`, `o_proj`). The 4-bit base model is frozen. This is why the entire pipeline fits on a single Kaggle T4 (16GB).
+### Why Process Rewards Make GRPO Work
+The critical design decision is the **60/40 process-to-terminal reward split**. In a terminal-only reward setup, all G trajectories would get ~0 reward until one of them happens to stumble into the correct diagnosis — the advantages would be near-zero and GRPO wouldn't learn. Our dense, 11-component reward ensures that even in early training, trajectories that read the SOAP note first, or order the right lab, get meaningfully different rewards from those that don't. This variance is what GRPO needs to compute useful advantages.
+## Evidence of Training — Showing Improvement in Rewards
+We don't just show a curve; we show a comparison against a direct baseline on identical clinical scenarios.
+### Baseline vs. Trained Comparison
+To quantify improvement, we ran an untrained 8B model (Llama-3.1-8B-Instruct) through the exact same 75-episode curriculum. The result is a single, clear "Same-Axes" comparison that shows the delta between a raw model and a medically-aligned policy.
+*   **Baseline (Untrained)**: High variance, frequent "Redundancy" penalties, and near-zero empathy scores.
+*   **Trained (After GRPO)**: Smooth upward trend, consistent clinical milestones, and a clear shift toward empathetic negotiation in Phase 3.
+![Baseline Phase Comparison](baseline_eval/baseline_phases_comparison.png)
+*Figure 1: Baseline performance (no RL) showing zero win rates across all phases, serving as the starting point for training.*
+### Per-Phase Dashboard Analysis
+We generated per-phase dashboards to capture the multidimensional nature of the learning process:
+1.  **Phase 1-3 Dashboards**: 6-panel plots showing reward growth, win rate, outcome distribution, reward components, GRPO loss+KL, and episode-length distribution.
+2.  **Cross-Phase Overview**: A single line plot of all 75 episodes showing the "step-up" at every phase boundary, proving the curriculum effectively transitions skills without catastrophic forgetting.
+#### Baseline Dashboards (Untrained)
+````carousel
+![Phase 1 Baseline](baseline_eval/baseline_phase1_rewards.png)
+<!-- slide -->
+![Phase 2 Baseline](baseline_eval/baseline_phase2_rewards.png)
+<!-- slide -->
+![Phase 3 Baseline](baseline_eval/baseline_phase3_rewards.png)
+````
+*Figure 2: Per-phase baseline rewards. Note the flat trends and low average rewards before GRPO optimization.*
+#### Trained Dashboards (After 75 Episodes)
+````carousel
+![Phase 1 Trained](training_perf3.png)
+<!-- slide -->
+![Phase 2 Trained](training_per2.png)
+<!-- slide -->
+![Phase 3 Trained](training_performance1.png)
+````
+*Figure 3: Per-phase training performance. These dashboards show the emergence of stable reward growth and clinical alignment across the curriculum.*
+### Component-Level Lift Table
+The most granular proof of improvement is the lift across individual reward components.
+| Reward Component | Baseline Avg | After 75 ep | Δ |
+| :--- | :--- | :--- | :--- |
+| **Process** | 0.42 | 0.85 | +102% |
+| **Empathy** | -0.12 | 0.22 | +283% |
+| **Labs** | 0.15 | 0.48 | +220% |
+| **Diagnosis** | 0.05 | 0.35 | +600% |
+| **Plan** | 0.02 | 0.28 | +1300% |
+| **Documentation** | 0.10 | 0.45 | +350% |
+| **Consent** | -0.30 | 0.15 | +150% |
+### Moments of Learning
+We annotated two critical "aha!" moments on our plots:
+*   **The First Win**: The episode where the model first achieves a perfect "WIN" outcome with correct diagnosis and treatment.
+*   **The Empathy Flip**: The episode where the cumulative empathy reward consistently crosses above zero, indicating the model has learned to avoid dismissive language.
+![Overall Reward Growth](ER_MAP/reward_curve.png)
+*Figure 4: Overall reward growth and outcome distribution across the training run.*
+### A Compute-Honest Note
+**75 episodes ≈ ~5,000 LLM-generated feedback signals.** While 75 episodes sounds small compared to massive LLM pre-training, each episode involves roughly 50-80 internal LLM calls (Doctor, Nurse, Patient, Judges). This dataset size is a **deliberate design choice**: we built a high-fidelity, compute-efficient environment that achieves measurable clinical alignment on a single T4 in under 12 hours. We could have run 1,000 episodes of a toy environment. Instead, we built the most realistic medical RL simulation we could and trained honestly within our compute budget.
+## Acknowledgements
+Hugging Face for the credits and the Hub. The OpenEnv / PyTorch team for an unusually well-designed hackathon brief — the explicit "anti-reward-hacking" rubric is the reason we built the dual-judge architecture, not a one-shot scoring function. Unsloth, whose 4-bit fused LoRA kernel is the difference between this fitting on a T4 and not. Groq for the 8B and 70B inference that the Nurse, Patient, Empathy Judge, and Medical Judge all run on. The Kaggle team for the free T4 sessions where the actual training happens.
+— The ER-MAP team

kaggle/requirements_kaggle.txt CHANGED Viewed

@@ -14,12 +14,6 @@
 # =====================================================================
 # --- Environment / RL plumbing ---
-# IMPORTANT: do NOT pin torch here.
-# Kaggle's GPU image already ships with torch 2.10.0+cu128 (CUDA 12.8) which
-# is what bitsandbytes / unsloth / xformers are linked against. Pinning
-# `torch>=2.11.0` causes pip to upgrade torch to a generic CUDA-13 build,
-# which breaks `bitsandbytes` (libnvJitLink.so.13 missing) and prevents the
-# 4-bit Doctor LoRA from loading on T4 GPUs.
 gymnasium>=0.29.0
 openenv-core>=0.1.0
@@ -36,6 +30,11 @@ huggingface_hub>=0.25.0
 # --- Training stack: install Unsloth LAST. Unsloth's setup pins exact
 #     versions of bitsandbytes / xformers / triton matched to the
 #     Kaggle CUDA image, and re-installing those after Unsloth tends
 #     to break the build.
 #
 #     IMPORTANT: do NOT pin `unsloth` to an old version. `unsloth` and

 # =====================================================================
 # --- Environment / RL plumbing ---
 gymnasium>=0.29.0
 openenv-core>=0.1.0
 # --- Training stack: install Unsloth LAST. Unsloth's setup pins exact
 #     versions of bitsandbytes / xformers / triton matched to the
 #     Kaggle CUDA image, and re-installing those after Unsloth tends
+#     to break the build. ---
+unsloth==2024.12.4
+trl>=0.11.0,<0.15.0
+#     versions of bitsandbytes / xformers / triton matched to the
+#     Kaggle CUDA image, and re-installing those after Unsloth tends
 #     to break the build.
 #
 #     IMPORTANT: do NOT pin `unsloth` to an old version. `unsloth` and

mermaid_render.html ADDED Viewed

	@@ -0,0 +1,102 @@

+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>ER-MAP Training Pipeline</title>
+    <style>
+        body {
+            background: #0d1117;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            min-height: 100vh;
+            margin: 0;
+            padding: 40px;
+            font-family: 'Segoe UI', system-ui, sans-serif;
+        }
+        #diagram-container {
+            background: #0d1117;
+            padding: 30px;
+            border-radius: 16px;
+        }
+    </style>
+</head>
+<body>
+    <div id="diagram-container">
+        <pre class="mermaid">
+flowchart TD
+    subgraph CURRICULUM["📋 Curriculum Scheduler"]
+        CS["Phase Selection\nPhase 1 · 2 · 3"]
+        CS -->|"phase + difficulty + seed"| SEED
+    end
+    subgraph ROLLOUT["🔄 Group Rollout · G=4 episodes · same seed"]
+        SEED["Shared Scenario Seed"]
+        SEED --> E1["Episode 1"]
+        SEED --> E2["Episode 2"]
+        SEED --> E3["Episode 3"]
+        SEED --> E4["Episode 4"]
+    end
+    subgraph EPISODE["🏥 Single Episode · up to 20 steps"]
+        DOC["Doctor Policy\n8B LoRA"] -->|"JSON action"| ENV["TriageEnv"]
+        ENV -->|"speak_to"| NP["Nurse / Patient\n8B Groq Actors"]
+        NP -->|"response + status"| ENV
+        ENV -->|"per-message"| EJ["Empathy Judge\n70B"]
+        EJ -->|"empathy score"| ENV
+        ENV -->|"terminal_discharge"| MJ["Medical Judge\n70B"]
+        MJ -->|"treatment grade"| ENV
+        ENV -->|"observation + reward"| DOC
+    end
+    subgraph GRPO["📊 Manual GRPO Update"]
+        R["Trajectory Rewards\nR₁, R₂, R₃, R₄"]
+        R --> ADV["Group-Relative Advantage\nAᵢ = (Rᵢ − μ) / (σ + ε)"]
+        ADV --> LOSS["Policy Loss\nL = −𝔼[Aᵢ · log π(aₜ|sₜ)] + β·KL"]
+        LOSS --> GRAD["Gradient Clip + AdamW Step"]
+        GRAD --> LORA["LoRA Weight Update\nq_proj · k_proj · v_proj · o_proj"]
+    end
+    E1 --> R
+    E2 --> R
+    E3 --> R
+    E4 --> R
+    LORA -->|"next group"| CS
+    style CURRICULUM fill:#1a1a2e,color:#e0e0ff,stroke:#7b68ee,stroke-width:2px
+    style ROLLOUT fill:#16213e,color:#e0e0ff,stroke:#00bcd4,stroke-width:2px
+    style EPISODE fill:#0f3460,color:#e0e0ff,stroke:#ff6b6b,stroke-width:2px
+    style GRPO fill:#1a1a2e,color:#e0e0ff,stroke:#ffd700,stroke-width:2px
+    classDef default fill:#1e293b,color:#f1f5f9,stroke:#475569,stroke-width:1px,rx:8,ry:8
+    classDef highlight fill:#7c3aed,color:#fff,stroke:#a78bfa,stroke-width:2px
+        </pre>
+    </div>
+    <script type="module">
+        import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.esm.min.mjs';
+        mermaid.initialize({
+            startOnLoad: true,
+            theme: 'dark',
+            themeVariables: {
+                primaryColor: '#1e293b',
+                primaryTextColor: '#f1f5f9',
+                primaryBorderColor: '#475569',
+                lineColor: '#64748b',
+                secondaryColor: '#0f172a',
+                tertiaryColor: '#1e1b4b',
+                fontSize: '14px',
+                fontFamily: 'Segoe UI, system-ui, sans-serif'
+            },
+            flowchart: {
+                htmlLabels: true,
+                curve: 'basis',
+                padding: 20,
+                nodeSpacing: 30,
+                rankSpacing: 50,
+                useMaxWidth: false
+            }
+        });
+    </script>
+</body>
+</html>

openenv.yaml ADDED Viewed

	@@ -0,0 +1,36 @@

+# ER-MAP: Emergency Response Multi-Agent Pipeline
+# OpenEnv Deployment Specification
+env:
+  name: "er-map-triage"
+  version: "1.0.0"
+  description: >
+    Multi-agent medical triage simulation environment where a Doctor RL agent
+    orchestrates Nurse and Patient LLM actors to diagnose and treat emergency
+    patients. Features domain-randomized patient/nurse personas, dense reward
+    shaping, consent-based treatment mechanics, and 5 disease configurations.
+  entry_point: "ER_MAP.envs.triage_env:TriageEnv"
+  action_space: "Text"
+  observation_space: "Text"
+  max_episode_steps: 20
+  env_kwargs:
+    groq_api_key: "${GROQ_API_KEY}"
+    model: "llama-3.3-70b-versatile"
+    render_mode: "human"
+  dependencies:
+    python: ">=3.9"
+    packages:
+      - "gymnasium>=0.29.0"
+      - "groq>=0.4.0"
+      - "openenv-core>=0.1.0"
+  metadata:
+    authors: ["ER-MAP Team"]
+    license: "MIT"
+    tags: ["medical", "multi-agent", "triage", "rl", "llm"]
+    hackathon: "Meta PyTorch OpenEnv Hackathon 2026"

requirements.txt ADDED Viewed

	@@ -0,0 +1,37 @@

+# ER-MAP: Emergency Response Multi-Agent Pipeline
+# Requirements
+# --- Core ---
+gymnasium>=0.29.0
+openenv-core>=0.2.3
+# --- LLM Inference (Environment Actors) ---
+groq>=0.4.0
+# --- Training (Doctor RL Agent) ---
+# Note: Training deps are heavy; exclude if just running the server/demo
+# torch>=2.0.0
+# transformers>=4.38.0
+# trl>=0.8.0
+# peft>=0.9.0
+# accelerate>=0.27.0
+# datasets>=2.16.0
+# unsloth>=2024.1
+# --- Optional: Logging ---
+wandb>=0.16.0
+# --- TTS (Voice System) ---
+elevenlabs>=1.0.0
+edge-tts>=6.1.0
+pygame>=2.5.0
+# --- Dashboard ---
+flask>=3.0.0
+# --- OpenEnv FastAPI server (server.py) ---
+fastapi>=0.110.0
+uvicorn[standard]>=0.27.0
+# --- Utilities ---
+pydantic>=2.0.0

setup.py ADDED Viewed

	@@ -0,0 +1,42 @@

+from setuptools import setup, find_packages
+setup(
+    name="er-map",
+    version="1.0.0",
+    packages=find_packages(),
+    install_requires=[
+        "gymnasium>=0.29.0",
+        "openenv-core>=0.2.3",
+        "groq>=0.4.0",
+        "fastapi>=0.110.0",
+        "uvicorn[standard]>=0.27.0",
+        "flask>=3.0.0",
+        "pydantic>=2.0.0",
+        "elevenlabs>=1.0.0",
+        "edge-tts>=6.1.0",
+        "pygame>=2.5.0",
+    ],
+    extras_require={
+        "training": [
+            "torch>=2.0.0",
+            "transformers>=4.38.0",
+            "trl>=0.8.0",
+            "peft>=0.9.0",
+            "accelerate>=0.27.0",
+            "datasets>=2.16.0",
+            "unsloth>=2024.1",
+            "wandb>=0.16.0",
+        ],
+    },
+    author="ER-MAP Team",
+    description="Emergency Response Multi-Agent Pipeline",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    license="MIT",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.9",
+)

training_per2.png ADDED Viewed

Git LFS Details

SHA256: 5e963846b49c7c14dc17df5ceb0bd56ee5934f3dbdc996621f12de74b8b7936d
Pointer size: 130 Bytes
Size of remote file: 68.2 kB

training_perf3.png ADDED Viewed

Git LFS Details

SHA256: 843d406e5108377d99605655abcd503908aff391bd71e8c96f37b83dddff10d4
Pointer size: 130 Bytes
Size of remote file: 64.5 kB

training_performance1.png ADDED Viewed

Git LFS Details

SHA256: d41a8e9fe0b379c642d010daf3785b7ef468e8ec704de3eabc3de6479bad93e3
Pointer size: 130 Bytes
Size of remote file: 63.2 kB