Fix Dockerfile permissions & add application files

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.9-slim
+
+# Install Node.js for frontend build
+RUN apt-get update && apt-get install -y curl && \
+    curl -fsSL https://deb.nodesource.com/setup_18.x | bash - && \
+    apt-get install -y nodejs && \
+    rm -rf /var/lib/apt/lists/*
+
+# Hugging Face Spaces require running as a non-root user with ID 1000
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Copy requirements and install Python deps
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy frontend source and build
+COPY --chown=user frontend/ ./frontend/
+RUN cd frontend && npm install && npm run build
+
+# Copy backend source
+COPY --chown=user backend/ ./backend/
+COPY --chown=user codeblue_context.py .
+
+# Move built frontend to backend static directory
+RUN mv frontend/dist backend/static
+
+# Set environment variables for Hugging Face
+ENV PORT=7860
+ENV HOST=0.0.0.0
+
+EXPOSE 7860
+
+# Run FastAPI server
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,62 @@
----
-title: CodeBlue Context
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-pinned: false
----
+# CodeBlue Context 🚨
+
+**An explainable, 5-agent clinical emergency intelligence system built for the Agent Assemble Hackathon.**
+
+CodeBlue Context is designed to tackle a critical hospital bottleneck: the time doctors waste reading lengthy patient histories during emergencies. Instead of spending 10-15 minutes extracting scattered chart data, CodeBlue compresses a patient's medical context into a structured, structured 10-second summary.
+
+## The 5-Agent Architecture
+
+This system uses a sequential orchestration of 5 Gemini-powered AI agents (using `gemini-2.0-flash`):
+
+1. **Triage Agent**: Determines ESI severity level and identifies time-critical flags.
+2. **Contraindication Guardian**: Cross-references medications and allergies against proposed treatments.
+3. **Lab Interpreter**: Highlights critical abnormalities and their immediate clinical significance.
+4. **Differential Diagnosis Agent**: Formulates the top 3 emergency differentials based strictly on evidence.
+5. **Action Protocol Agent**: Suggests the immediate next steps and patient disposition.
+
+*(A deterministic rules engine acts as a permanent fallback for safety, ensuring an emergency brief is always generated even if the AI is unavailable).*
+
+## Features
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+- **MCP Integration**: Fully exposes an MCP Tool Manifest (`/mcp/tools`) making it compliant with PromptOpinion and other MCP-based systems.
+- **Explainability**: Every AI reasoning step is exposed. It doesn't just give an answer; it shows *why*.
+- **Live Treatment Checker**: Instantly type in a proposed drug (e.g., "morphine") and cross-check it against the patient's entire profile.
+- **Medical-Grade UI**: A highly polished, dark-themed, glass-morphic React dashboard with pulse animations for critical alerts.
+
+## Run Locally
+
+### Requirements
+- Python 3.9+
+- Node.js 18+
+
+### 1. Backend Setup
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+Set your API key in a `.env` file in the root directory:
+```
+gemini_api_key=YOUR_GEMINI_KEY
+```
+Start the backend:
+```bash
+uvicorn backend.main:app --reload
+```
+
+### 2. Frontend Setup
+```bash
+cd frontend
+npm install
+npm run dev
+```
+
+## Hackathon Judging Criteria Met
+
+- **Real-world Usefulness:** Directly addresses emergency chart review bottlenecks.
+- **Safety:** Hard deterministic fallbacks. The system is instructed to *never* hallucinate data.
+- **Explainability:** Features a dedicated panel showing the "reasoning steps" the AI took.
+- **Simplicity:** Drag-and-drop a patient JSON file, click "Generate Snapshot".
+
+---
+*Disclaimer: For demonstration purposes only. Not for actual clinical use.*

backend/__init__.py

@@ -0,0 +1 @@
+

backend/main.py

@@ -0,0 +1,492 @@
+from __future__ import annotations
+import json, os, re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Load .env from project root
+_env_file = Path(__file__).resolve().parent.parent / ".env"
+if _env_file.exists():
+    for _line in _env_file.read_text().splitlines():
+        _line = _line.strip()
+        if _line and not _line.startswith("#") and "=" in _line:
+            _k, _, _v = _line.partition("=")
+            os.environ.setdefault(_k.strip(), _v.strip())
+from datetime import datetime
+
+from fastapi import FastAPI, HTTPException, UploadFile, File, Body
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from codeblue_context import build_emergency_snapshot
+
+import requests as _requests
+
+_KEY = ""
+_env_file2 = Path(__file__).resolve().parent.parent / ".env"
+if _env_file2.exists():
+    for _l in _env_file2.read_text().splitlines():
+        _l = _l.strip()
+        if _l and "=" in _l and not _l.startswith("#"):
+            _k2, _, _v2 = _l.partition("=")
+            if _k2.strip() == "gemini_api_key":
+                _KEY = _v2.strip()
+                break
+if not _KEY:
+    _KEY = os.getenv("gemini_api_key", "") or os.getenv("GEMINI_API_KEY", "")
+
+_GEMINI_URL = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={_KEY}"
+
+BASE_DIR = Path(__file__).resolve().parent
+
+
+def _load_patients() -> List[Dict[str, Any]]:
+    p = BASE_DIR / "sample_patients.json"
+    if not p.exists():
+        return []
+    with p.open() as f:
+        return json.load(f).get("patients", [])
+
+
+PATIENTS: List[Dict[str, Any]] = _load_patients()
+
+app = FastAPI(title="CodeBlue Context API", version="3.0.0",
+              description="5-Agent Emergency Clinical Intelligence System")
+
+app.add_middleware(CORSMiddleware, allow_origins=["*"],
+                   allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
+
+
+# ── Gemini helper ─────────────────────────────────────────────────────────────
+import time
+def _gemini(prompt: str, retries: int = 4) -> Optional[Dict]:
+    if not _KEY:
+        return None
+    payload = {
+        "contents": [{"parts": [{"text": prompt}]}],
+        "generationConfig": {"temperature": 0.1, "maxOutputTokens": 1024}
+    }
+    for attempt in range(retries):
+        try:
+            resp = _requests.post(_GEMINI_URL, json=payload, timeout=20)
+            if resp.status_code == 429 and attempt < retries - 1:
+                time.sleep(2 ** attempt)
+                continue
+            resp.raise_for_status()
+            data = resp.json()
+            text = data["candidates"][0]["content"]["parts"][0]["text"].strip()
+            # Strip code fences if present
+            text = re.sub(r"^```(?:json)?\s*", "", text)
+            text = re.sub(r"\s*```$", "", text)
+            return json.loads(text)
+        except Exception as e:
+            if attempt < retries - 1:
+                time.sleep(2 ** attempt)
+                continue
+            print(f"Gemini error after {retries} attempts: {e}")
+            return None
+
+
+# ── Agent 1: Triage ───────────────────────────────────────────────────────────
+def agent_triage(record: Dict) -> Dict:
+    prompt = f"""You are an emergency triage nurse AI. Analyze ONLY the provided patient data. Do NOT invent facts.
+
+PATIENT DATA:
+{json.dumps(record, indent=2)}
+
+Return ONLY raw JSON (no markdown fences, no explanation):
+{{
+  "severity": 1,
+  "severity_label": "IMMEDIATE",
+  "chief_complaint": "brief one-line presenting issue",
+  "time_critical_flags": ["finding1", "finding2"],
+  "do_not_delay": ["action in first 5 min"],
+  "triage_rationale": "2-3 sentence rationale"
+}}
+Severity scale: 1=IMMEDIATE 2=EMERGENT 3=URGENT 4=LESS URGENT 5=NON-URGENT"""
+    r = _gemini(prompt)
+    if r:
+        return r
+    # Deterministic fallback
+    conditions = record.get("conditions", [])
+    vitals = record.get("vitals", {})
+    spo2 = vitals.get("SpO2") or vitals.get("spo2", 100)
+    hr = vitals.get("heart_rate") or vitals.get("hr", 80)
+    try:
+        spo2 = float(spo2); hr = float(hr)
+    except Exception:
+        spo2 = 100; hr = 80
+    severity = 3
+    if spo2 < 90 or hr > 130 or hr < 45:
+        severity = 1
+    elif spo2 < 93 or hr > 110:
+        severity = 2
+    labels = {1: "IMMEDIATE", 2: "EMERGENT", 3: "URGENT", 4: "LESS URGENT", 5: "NON-URGENT"}
+    return {
+        "severity": severity,
+        "severity_label": labels[severity],
+        "chief_complaint": conditions[0] if conditions else "Emergency presentation",
+        "time_critical_flags": [],
+        "do_not_delay": ["Obtain IV access", "Continuous monitoring"],
+        "triage_rationale": "Triage AI unavailable. Clinical judgment required.",
+    }
+
+
+# ── Agent 2: Contraindication Guardian ───────────────────────────────────────
+def agent_contraindication(record: Dict, proposed_treatment: str = "") -> Dict:
+    treat_line = f"PROPOSED TREATMENT TO CHECK: {proposed_treatment}" if proposed_treatment else "Check all existing medications for interactions."
+    prompt = f"""You are a clinical pharmacist AI specializing in emergency contraindication detection.
+Analyze ONLY the documented data. Never invent facts.
+
+ALLERGIES: {json.dumps(record.get('allergies', []))}
+CURRENT MEDICATIONS: {json.dumps(record.get('medications', []))}
+CONDITIONS: {json.dumps(record.get('conditions', []))}
+LABS: {json.dumps(record.get('labs', []))}
+{treat_line}
+
+Return ONLY raw JSON:
+{{
+  "treatment_verdict": "SAFE",
+  "verdict_reason": "one-line verdict explanation",
+  "allergy_risks": [{{"substance": "", "risk": "", "severity": "HIGH"}}],
+  "drug_interactions": [{{"drug_a": "", "drug_b": "", "interaction": "", "severity": "HIGH"}}],
+  "condition_contraindications": ["condition-based risk"],
+  "safe_alternatives": ["alternative drug or approach"],
+  "monitoring_required": ["monitor SpO2 every 5 min"]
+}}
+treatment_verdict options: SAFE | CAUTION | CONTRAINDICATED | NOT_EVALUATED"""
+    r = _gemini(prompt)
+    if r:
+        return r
+    return {
+        "treatment_verdict": "NOT_EVALUATED",
+        "verdict_reason": "AI agent unavailable. Manual pharmacist review required.",
+        "allergy_risks": [],
+        "drug_interactions": [],
+        "condition_contraindications": [],
+        "safe_alternatives": [],
+        "monitoring_required": [],
+    }
+
+
+# ── Agent 3: Lab Interpreter ──────────────────────────────────────────────────
+def agent_labs(record: Dict) -> Dict:
+    labs = record.get("labs", [])
+    if not labs:
+        return {"critical_labs": [], "abnormal_labs": [], "lab_patterns": [], "immediate_concerns": []}
+    prompt = f"""You are a clinical pathologist AI. Interpret ONLY these labs in emergency context.
+
+LABS: {json.dumps(labs)}
+PATIENT AGE: {record.get('patient', {}).get('age')}
+CONDITIONS: {json.dumps(record.get('conditions', []))}
+
+Return ONLY raw JSON:
+{{
+  "critical_labs": [{{"name": "", "value": "", "significance": "", "immediate_action": ""}}],
+  "abnormal_labs": [{{"name": "", "value": "", "significance": ""}}],
+  "lab_patterns": ["pattern across multiple results"],
+  "immediate_concerns": ["concern requiring action now"]
+}}"""
+    r = _gemini(prompt)
+    if r:
+        return r
+    return {"critical_labs": [], "abnormal_labs": [], "lab_patterns": [], "immediate_concerns": []}
+
+
+# ── Agent 4: Differential Diagnosis ──────────────────────────────────────────
+def agent_differentials(record: Dict) -> Dict:
+    prompt = f"""You are an emergency physician AI. Suggest top differentials based ONLY on documented findings.
+
+VITALS: {json.dumps(record.get('vitals', {}))}
+CONDITIONS: {json.dumps(record.get('conditions', []))}
+CLINICAL NOTES: {json.dumps(record.get('clinical_notes', []))}
+LABS: {json.dumps(record.get('labs', []))}
+HISTORY: {json.dumps(record.get('history', []))}
+
+Return ONLY raw JSON (max 3 differentials):
+{{
+  "differentials": [
+    {{
+      "diagnosis": "",
+      "likelihood": "HIGH",
+      "supporting_evidence": ["evidence from patient data"],
+      "must_rule_out": true
+    }}
+  ],
+  "key_diagnostic_question": "single most important question to resolve uncertainty"
+}}"""
+    r = _gemini(prompt)
+    if r:
+        return r
+    return {"differentials": [], "key_diagnostic_question": "Full clinical assessment required."}
+
+
+# ── Agent 5: Action Protocol ──────────────────────────────────────────────────
+def agent_action_protocol(record: Dict, triage: Dict, contraindication: Dict,
+                          labs: Dict, differentials: Dict) -> Dict:
+    prompt = f"""You are an ED attending physician AI. Generate immediate action protocol for first 30 minutes.
+
+TRIAGE RESULT: {json.dumps(triage)}
+CONTRAINDICATIONS: {json.dumps(contraindication)}
+LAB CONCERNS: {json.dumps(labs)}
+DIFFERENTIALS: {json.dumps(differentials)}
+PATIENT: Age {record.get('patient', {}).get('age')}, {record.get('patient', {}).get('gender')}
+ALLERGIES: {json.dumps(record.get('allergies', []))}
+
+Return ONLY raw JSON:
+{{
+  "immediate_actions": ["Step 1: action", "Step 2: action"],
+  "drugs_to_avoid": [{{"drug": "", "reason": ""}}],
+  "monitoring_parameters": ["parameter every X min"],
+  "escalation_triggers": ["trigger requiring escalation"],
+  "disposition": "ICU"
+}}
+disposition options: ICU | ADMIT | OBSERVE | DISCHARGE | SURGERY_CONSULT | CATH_LAB"""
+    r = _gemini(prompt)
+    if r:
+        return r
+    return {
+        "immediate_actions": ["Obtain IV access", "Continuous monitoring", "Notify attending physician"],
+        "drugs_to_avoid": [],
+        "monitoring_parameters": ["Continuous SpO2", "BP every 5 min"],
+        "escalation_triggers": ["Deteriorating vitals"],
+        "disposition": "ADMIT",
+    }
+
+
+# ── Risk pre-classification (fast, no AI) ─────────────────────────────────────
+def _quick_risk(record: Dict) -> str:
+    vitals = record.get("vitals", {})
+    spo2 = vitals.get("SpO2") or vitals.get("spo2", 100)
+    hr = vitals.get("heart_rate") or vitals.get("hr", 80)
+    try:
+        spo2 = float(spo2); hr = float(hr)
+    except Exception:
+        spo2 = 100; hr = 80
+    for lab in record.get("labs", []):
+        if isinstance(lab, dict) and "critical" in str(lab.get("flag", "")).lower():
+            return "critical"
+    if spo2 < 90 or hr > 130 or hr < 45:
+        return "critical"
+    if spo2 < 94 or hr > 110:
+        return "moderate"
+    if record.get("conditions") or record.get("medications"):
+        return "moderate"
+    return "stable"
+
+
+def _patient_card(record: Dict) -> Dict:
+    p = record.get("patient", {})
+    return {
+        "id": record.get("id"),
+        "display_name": record.get("display_name", record.get("id")),
+        "age": p.get("age"),
+        "gender": p.get("gender"),
+        "risk_level": _quick_risk(record),
+        "conditions": record.get("conditions", [])[:2],
+        "allergy_count": len(record.get("allergies", [])),
+        "med_count": len(record.get("medications", [])),
+    }
+
+
+# ── Routes ────────────────────────────────────────────────────────────────────
+
+@app.get("/health")
+def health():
+    return {
+        "status": "ok", "version": "3.0.0",
+        "patient_count": len(PATIENTS),
+        "gemini_enabled": bool(_KEY),
+        "timestamp": datetime.utcnow().isoformat() + "Z",
+    }
+
+
+@app.get("/patients")
+def list_patients():
+    return {"patients": [_patient_card(p) for p in PATIENTS], "total": len(PATIENTS)}
+
+
+@app.get("/patients/{patient_id}")
+def get_patient(patient_id: str):
+    for p in PATIENTS:
+        if p.get("id") == patient_id:
+            return p
+    raise HTTPException(404, f"Patient '{patient_id}' not found")
+
+
+@app.post("/patients/upload")
+async def upload_patient(file: UploadFile = File(...)):
+    raw = await file.read()
+    try:
+        data = json.loads(raw)
+    except Exception:
+        raise HTTPException(400, "Invalid JSON")
+    records = data if isinstance(data, list) else [data]
+    added = []
+    for rec in records:
+        if not isinstance(rec, dict):
+            continue
+        if not rec.get("id"):
+            rec["id"] = f"UP-{len(PATIENTS)+1:03d}"
+        if not rec.get("display_name"):
+            rec["display_name"] = f"Patient {rec['id']}"
+        PATIENTS.append(rec)
+        added.append(_patient_card(rec))
+    return {"added": added, "total_patients": len(PATIENTS)}
+
+
+# ── CORE: 5-Agent Orchestrator ────────────────────────────────────────────────
+
+@app.get("/orchestrate/{patient_id}")
+@app.post("/orchestrate/{patient_id}")
+def orchestrate(patient_id: str):
+    """
+    Runs all 5 AI agents on the patient record and returns a complete
+    emergency intelligence brief.
+    """
+    record = next((p for p in PATIENTS if p.get("id") == patient_id), None)
+    if not record:
+        raise HTTPException(404, f"Patient '{patient_id}' not found")
+
+    t0 = datetime.utcnow()
+
+    # Deterministic core (always runs, never fails)
+    det_snapshot, det_reasoning, det_risks, det_vitals = build_emergency_snapshot(record)
+
+    # 5 AI Agents (sequential; Gemini free-tier safe)
+    import time
+    
+    triage      = agent_triage(record)
+    time.sleep(2)
+    contra      = agent_contraindication(record)
+    time.sleep(2)
+    labs        = agent_labs(record)
+    time.sleep(2)
+    differentials = agent_differentials(record)
+    time.sleep(2)
+    action      = agent_action_protocol(record, triage, contra, labs, differentials)
+
+    ms = int((datetime.utcnow() - t0).total_seconds() * 1000)
+
+    return {
+        "patient": _patient_card(record),
+        "agents": {
+            "triage": triage,
+            "contraindication": contra,
+            "labs": labs,
+            "differentials": differentials,
+            "action_protocol": action,
+        },
+        "deterministic": {
+            "snapshot": det_snapshot,
+            "risks": det_risks,
+            "vitals": det_vitals,
+            "reasoning_steps": det_reasoning,
+        },
+        "meta": {
+            "processing_ms": ms,
+            "gemini_enabled": bool(_KEY),
+            "generated_at": datetime.utcnow().isoformat() + "Z",
+        },
+    }
+
+
+# ── Treatment Safety Check ────────────────────────────────────────────────────
+
+@app.post("/check-treatment/{patient_id}")
+def check_treatment(patient_id: str, body: Dict[str, Any] = Body(...)):
+    """
+    Instant contraindication check for a proposed treatment.
+    Body: { "treatment": "morphine 4mg IV" }
+    """
+    record = next((p for p in PATIENTS if p.get("id") == patient_id), None)
+    if not record:
+        raise HTTPException(404, f"Patient '{patient_id}' not found")
+    treatment = body.get("treatment", "")
+    if not treatment:
+        raise HTTPException(400, "treatment field required")
+    result = agent_contraindication(record, treatment)
+    return {"patient_id": patient_id, "proposed_treatment": treatment, "result": result}
+
+
+# ── MCP Tool Manifest ─────────────────────────────────────────────────────────
+
+@app.get("/mcp/tools")
+def mcp_tools():
+    return {
+        "tools": [
+            {
+                "name": "list_patients",
+                "description": "List all patients in the CodeBlue system with risk levels.",
+                "inputSchema": {"type": "object", "properties": {}},
+            },
+            {
+                "name": "get_patient_details",
+                "description": "Get full clinical record for a specific patient.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {"patient_id": {"type": "string"}},
+                    "required": ["patient_id"],
+                },
+            },
+            {
+                "name": "generate_emergency_snapshot",
+                "description": (
+                    "Run 5-agent emergency AI analysis: triage, contraindication, "
+                    "lab interpretation, differential diagnosis, and action protocol."
+                ),
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {"patient_id": {"type": "string"}},
+                    "required": ["patient_id"],
+                },
+            },
+            {
+                "name": "check_treatment_safety",
+                "description": "Check if a proposed treatment is safe for a specific patient given their allergies, medications, and conditions.",
+                "inputSchema": {
+                    "type": "object",
+                    "properties": {
+                        "patient_id": {"type": "string"},
+                        "treatment": {"type": "string", "description": "e.g. 'morphine 4mg IV'"},
+                    },
+                    "required": ["patient_id", "treatment"],
+                },
+            },
+        ]
+    }
+
+
+@app.post("/mcp/execute")
+async def mcp_execute(body: Dict[str, Any] = Body(...)):
+    tool = body.get("tool_name") or body.get("name", "")
+    params = body.get("parameters") or body.get("input") or {}
+
+    if tool == "list_patients":
+        return {"result": list_patients()}
+    elif tool == "get_patient_details":
+        pid = params.get("patient_id", "")
+        return {"result": get_patient(pid)}
+    elif tool == "generate_emergency_snapshot":
+        pid = params.get("patient_id", "")
+        return {"result": orchestrate(pid)}
+    elif tool == "check_treatment_safety":
+        pid = params.get("patient_id", "")
+        return {"result": check_treatment(pid, {"treatment": params.get("treatment", "")})}
+    else:
+        raise HTTPException(400, f"Unknown tool: {tool}")
+
+
+# ── Static frontend ───────────────────────────────────────────────────────────
+_static = BASE_DIR / "static"
+_assets = _static / "assets"
+if _assets.exists():
+    app.mount("/assets", StaticFiles(directory=str(_assets)), name="assets")
+
+
+@app.get("/{full_path:path}")
+async def serve_spa(full_path: str):
+    idx = _static / "index.html"
+    if idx.exists():
+        return FileResponse(str(idx))
+    return JSONResponse({"status": "CodeBlue Context API running", "docs": "/docs"})

backend/sample_patients.json

@@ -0,0 +1,303 @@
+{
+  "patients": [
+    {
+      "id": "CB-001",
+      "display_name": "James Harrington",
+      "patient": {
+        "age": 65,
+        "gender": "male",
+        "dob": "1959-03-12"
+      },
+      "allergies": [
+        {
+          "substance": "Penicillin",
+          "severity": "severe",
+          "reaction": "anaphylaxis"
+        },
+        {
+          "substance": "Aspirin",
+          "severity": "moderate",
+          "reaction": "urticaria"
+        }
+      ],
+      "medications": [
+        "Warfarin 5mg daily",
+        "Insulin glargine 20 units nightly",
+        "Metoprolol 50mg twice daily",
+        "Lisinopril 10mg daily"
+      ],
+      "conditions": [
+        "Type 2 Diabetes",
+        "Coronary artery disease",
+        "Hypertension",
+        "Atrial fibrillation"
+      ],
+      "labs": [
+        {
+          "name": "INR",
+          "value": 4.2,
+          "reference_range": { "low": 0.8, "high": 1.2 },
+          "flag": "critical high"
+        },
+        {
+          "name": "Glucose",
+          "value": 58,
+          "unit": "mg/dL",
+          "reference_range": { "low": 70, "high": 140 },
+          "flag": "low"
+        },
+        {
+          "name": "Troponin",
+          "value": 0.08,
+          "unit": "ng/mL",
+          "reference_range": { "low": 0, "high": 0.04 },
+          "flag": "critical high"
+        }
+      ],
+      "vitals": {
+        "heart_rate": 138,
+        "SpO2": 88,
+        "blood_pressure": "188/124",
+        "temperature": 37.2,
+        "respiratory_rate": 22
+      },
+      "history": [
+        "Recent fall at home 3 days ago",
+        "ICU admission last year for cardiac event",
+        "CABG surgery 2019"
+      ],
+      "clinical_notes": [
+        "High-risk emergency profile due to supratherapeutic anticoagulation and unstable vitals. HR: 138, SpO2: 88%, BP: 188/124. Patient presents with chest discomfort and confusion."
+      ]
+    },
+    {
+      "id": "CB-002",
+      "display_name": "Maria Santos",
+      "patient": {
+        "age": 47,
+        "gender": "female",
+        "dob": "1977-08-22"
+      },
+      "allergies": [],
+      "medications": [
+        "Albuterol inhaler PRN",
+        "Montelukast 10mg daily",
+        "Prednisone 20mg short course"
+      ],
+      "conditions": [
+        "Asthma",
+        "Allergic rhinitis"
+      ],
+      "labs": [
+        {
+          "name": "WBC",
+          "value": 12.4,
+          "unit": "K/uL",
+          "reference_range": { "low": 4.5, "high": 11.0 },
+          "flag": "high"
+        }
+      ],
+      "vitals": {
+        "respiratory_rate": 26,
+        "SpO2": 93,
+        "temperature": 38.6,
+        "heart_rate": 108,
+        "blood_pressure": "128/82"
+      },
+      "history": [
+        "Two ER visits for asthma exacerbation this year",
+        "No ICU history"
+      ],
+      "clinical_notes": [
+        "Patient presenting with acute bronchospasm. RR: 26, SpO2: 93%, Temp: 38.6C. Audible wheezing bilaterally. Not responding to initial albuterol."
+      ]
+    },
+    {
+      "id": "CB-003",
+      "display_name": "Robert Chen",
+      "patient": {
+        "age": 72,
+        "gender": "male",
+        "dob": "1952-11-05"
+      },
+      "allergies": [
+        {
+          "substance": "Iodinated contrast",
+          "severity": "moderate",
+          "reaction": "acute kidney injury"
+        }
+      ],
+      "medications": [
+        "Furosemide 40mg daily",
+        "Digoxin 0.125mg daily",
+        "Carvedilol 6.25mg twice daily",
+        "Spironolactone 25mg"
+      ],
+      "conditions": [
+        "Congestive heart failure (EF 25%)",
+        "Chronic kidney disease Stage 3",
+        "Hyperkalemia history"
+      ],
+      "labs": [
+        {
+          "name": "Potassium",
+          "value": 5.9,
+          "unit": "mmol/L",
+          "reference_range": { "low": 3.5, "high": 5.1 },
+          "flag": "high"
+        },
+        {
+          "name": "BNP",
+          "value": 1420,
+          "unit": "pg/mL",
+          "reference_range": { "low": 0, "high": 100 },
+          "flag": "critical high"
+        },
+        {
+          "name": "Creatinine",
+          "value": 2.4,
+          "unit": "mg/dL",
+          "reference_range": { "low": 0.7, "high": 1.3 },
+          "flag": "high"
+        }
+      ],
+      "vitals": {
+        "heart_rate": 58,
+        "blood_pressure": "95/62",
+        "SpO2": 91,
+        "respiratory_rate": 24,
+        "temperature": 36.8
+      },
+      "history": [
+        "Discharged 5 days ago after decompensated heart failure",
+        "3 prior hospitalizations for CHF this year",
+        "Dialysis evaluation pending"
+      ],
+      "clinical_notes": [
+        "Presenting with worsening dyspnea and bilateral lower extremity edema. HR: 58 (bradycardic), BP: 95/62 (hypotensive). Digoxin toxicity must be ruled out given bradycardia + hyperkalemia."
+      ]
+    },
+    {
+      "id": "CB-004",
+      "display_name": "Tyler Brooks",
+      "patient": {
+        "age": 34,
+        "gender": "male",
+        "dob": "1990-06-18"
+      },
+      "allergies": [
+        {
+          "substance": "Codeine",
+          "severity": "moderate",
+          "reaction": "respiratory depression"
+        }
+      ],
+      "medications": [
+        "Oxycodone 10mg PRN",
+        "Cyclobenzaprine 5mg",
+        "Fentanyl patch 25mcg/hr"
+      ],
+      "conditions": [
+        "Chronic back pain",
+        "Post-traumatic stress disorder",
+        "Mild traumatic brain injury"
+      ],
+      "labs": [
+        {
+          "name": "Blood Alcohol",
+          "value": 0.18,
+          "unit": "g/dL",
+          "reference_range": { "low": 0, "high": 0.08 },
+          "flag": "critical high"
+        },
+        {
+          "name": "GCS",
+          "value": 11,
+          "reference_range": { "low": 15, "high": 15 },
+          "flag": "low"
+        }
+      ],
+      "vitals": {
+        "heart_rate": 52,
+        "blood_pressure": "88/54",
+        "SpO2": 89,
+        "respiratory_rate": 8,
+        "temperature": 35.8
+      },
+      "history": [
+        "Motor vehicle accident 2 hours ago",
+        "Known polysubstance use",
+        "Fall from motorcycle at high speed"
+      ],
+      "clinical_notes": [
+        "Trauma patient post-MVA. Multiple opioids on board including fentanyl patch. HR: 52, RR: 8, SpO2: 89%, BP: 88/54 — hemodynamically unstable. GCS 11. Risk of opioid-induced respiratory depression compounding traumatic injury. BAL: 0.18."
+      ]
+    },
+    {
+      "id": "CB-005",
+      "display_name": "Eleanor Voss",
+      "patient": {
+        "age": 81,
+        "gender": "female",
+        "dob": "1943-02-14"
+      },
+      "allergies": [
+        {
+          "substance": "Sulfa drugs",
+          "severity": "severe",
+          "reaction": "Stevens-Johnson syndrome"
+        }
+      ],
+      "medications": [
+        "Metformin 500mg twice daily",
+        "Amlodipine 5mg",
+        "Warfarin 2.5mg",
+        "Donepezil 10mg"
+      ],
+      "conditions": [
+        "Type 2 Diabetes",
+        "Hypertension",
+        "Mild cognitive impairment",
+        "Chronic UTI history"
+      ],
+      "labs": [
+        {
+          "name": "Lactate",
+          "value": 4.8,
+          "unit": "mmol/L",
+          "reference_range": { "low": 0.5, "high": 2.0 },
+          "flag": "critical high"
+        },
+        {
+          "name": "WBC",
+          "value": 18.2,
+          "unit": "K/uL",
+          "reference_range": { "low": 4.5, "high": 11.0 },
+          "flag": "critical high"
+        },
+        {
+          "name": "Procalcitonin",
+          "value": 12.4,
+          "unit": "ng/mL",
+          "reference_range": { "low": 0, "high": 0.25 },
+          "flag": "critical high"
+        }
+      ],
+      "vitals": {
+        "heart_rate": 118,
+        "blood_pressure": "86/48",
+        "SpO2": 92,
+        "respiratory_rate": 28,
+        "temperature": 39.4
+      },
+      "history": [
+        "Lives alone, found by neighbor in altered mental status",
+        "No prior sepsis history",
+        "Refused hospitalization last month for UTI"
+      ],
+      "clinical_notes": [
+        "Elderly patient with septic shock. Temp: 39.4C, HR: 118, BP: 86/48, RR: 28. Lactate 4.8 (critical), WBC 18.2, Procalcitonin 12.4. Suspected urosepsis. Sulfa allergy documented — avoid TMP-SMX. Antibiotic stewardship critical."
+      ]
+    }
+  ]
+}

backend/static/assets/index-BEynGZGH.css

@@ -0,0 +1 @@
+@import"https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800;900&family=JetBrains+Mono:wght@400;500;700&display=swap";:root{--bg-base: #060d1a;--bg-surface: #0d1b2e;--bg-elevated: #112236;--bg-card: #0f1e33;--border-subtle: rgba(255,255,255,.06);--border-default: rgba(255,255,255,.1);--border-accent: rgba(10,132,255,.4);--red-critical: #ff2d55;--red-glow: rgba(255,45,85,.25);--amber-warning: #ff9f0a;--amber-glow: rgba(255,159,10,.2);--green-safe: #30d158;--green-glow: rgba(48,209,88,.2);--blue-accent: #0a84ff;--blue-glow: rgba(10,132,255,.2);--purple-ai: #bf5af2;--text-primary: #f5f5f7;--text-secondary: #8e8e93;--text-tertiary: #48484a;--font-sans: "Inter", system-ui, sans-serif;--font-mono: "JetBrains Mono", monospace}*,*:before,*:after{box-sizing:border-box;margin:0;padding:0}html,body,#root{height:100%;background:var(--bg-base);color:var(--text-primary);font-family:var(--font-sans);font-size:14px;-webkit-font-smoothing:antialiased}::-webkit-scrollbar{width:4px;height:4px}::-webkit-scrollbar-track{background:transparent}::-webkit-scrollbar-thumb{background:var(--border-default);border-radius:99px}@keyframes ekg{0%{stroke-dashoffset:1000}to{stroke-dashoffset:0}}@keyframes pulse-red{0%,to{opacity:1;box-shadow:0 0 0 0 var(--red-glow)}50%{opacity:.8;box-shadow:0 0 0 8px transparent}}@keyframes pulse-amber{0%,to{box-shadow:0 0 0 0 var(--amber-glow)}50%{box-shadow:0 0 0 6px transparent}}@keyframes fade-up{0%{opacity:0;transform:translateY(12px)}to{opacity:1;transform:translateY(0)}}@keyframes fade-in{0%{opacity:0}to{opacity:1}}@keyframes spin{to{transform:rotate(360deg)}}@keyframes glow-blue{0%,to{box-shadow:0 0 12px var(--blue-glow)}50%{box-shadow:0 0 24px var(--blue-glow),0 0 4px var(--blue-accent)}}@keyframes slide-in-right{0%{opacity:0;transform:translate(20px)}to{opacity:1;transform:translate(0)}}@keyframes heartbeat{0%,to{transform:scale(1)}14%{transform:scale(1.15)}28%{transform:scale(1)}42%{transform:scale(1.1)}70%{transform:scale(1)}}.card{background:var(--bg-card);border:1px solid var(--border-subtle);border-radius:12px}.card-elevated{background:var(--bg-elevated);border:1px solid var(--border-default);border-radius:12px}.glass{background:#0d1b2eb3;backdrop-filter:blur(12px);-webkit-backdrop-filter:blur(12px);border:1px solid var(--border-default);border-radius:12px}.badge{display:inline-flex;align-items:center;gap:5px;padding:3px 9px;border-radius:99px;font-size:11px;font-weight:700;letter-spacing:.04em;text-transform:uppercase}.badge-critical{background:#ff2d5526;color:var(--red-critical);border:1px solid rgba(255,45,85,.3);animation:pulse-red 2s infinite}.badge-moderate{background:#ff9f0a1f;color:var(--amber-warning);border:1px solid rgba(255,159,10,.3)}.badge-stable{background:#30d1581a;color:var(--green-safe);border:1px solid rgba(48,209,88,.25)}.badge-unknown{background:#8e8e931a;color:var(--text-secondary);border:1px solid rgba(142,142,147,.2)}.verdict-safe{background:#30d15826;color:var(--green-safe);border:1px solid rgba(48,209,88,.3)}.verdict-caution{background:#ff9f0a26;color:var(--amber-warning);border:1px solid rgba(255,159,10,.3);animation:pulse-amber 2s infinite}.verdict-contraindicated{background:#ff2d5526;color:var(--red-critical);border:1px solid rgba(255,45,85,.4);animation:pulse-red 1.5s infinite}.verdict-not_evaluated{background:#8e8e931a;color:var(--text-secondary);border:1px solid rgba(142,142,147,.2)}.agent-idle{border-color:var(--border-subtle)}.agent-working{border-color:var(--blue-accent);animation:glow-blue 1.2s infinite}.agent-complete{border-color:var(--green-safe);box-shadow:0 0 10px var(--green-glow)}.agent-error{border-color:var(--red-critical)}.btn-primary{display:inline-flex;align-items:center;justify-content:center;gap:8px;padding:10px 20px;border-radius:8px;border:none;cursor:pointer;font-family:var(--font-sans);font-weight:600;font-size:13px;background:var(--blue-accent);color:#fff;transition:opacity .15s,transform .1s}.btn-primary:hover:not(:disabled){opacity:.85;transform:translateY(-1px)}.btn-primary:active{transform:translateY(0)}.btn-primary:disabled{opacity:.35;cursor:not-allowed}.btn-danger{background:linear-gradient(135deg,#c0392b,var(--red-critical));color:#fff;display:inline-flex;align-items:center;justify-content:center;gap:8px;padding:12px 24px;border-radius:8px;border:none;cursor:pointer;font-family:var(--font-sans);font-weight:700;font-size:14px;letter-spacing:.02em;box-shadow:0 4px 20px #ff2d554d;transition:box-shadow .2s,transform .1s;width:100%}.btn-danger:hover:not(:disabled){box-shadow:0 6px 30px #ff2d5580;transform:translateY(-1px)}.btn-danger:disabled{opacity:.3;cursor:not-allowed;transform:none}.btn-ghost{display:inline-flex;align-items:center;gap:6px;padding:8px 14px;border-radius:7px;border:1px solid var(--border-default);background:transparent;color:var(--text-secondary);cursor:pointer;font-family:var(--font-sans);font-size:12px;font-weight:500;transition:border-color .15s,color .15s,background .15s}.btn-ghost:hover{border-color:var(--blue-accent);color:var(--blue-accent);background:var(--blue-glow)}.spinner{width:16px;height:16px;border:2px solid rgba(255,255,255,.2);border-top-color:#fff;border-radius:50%;animation:spin .7s linear infinite}.fade-up{animation:fade-up .35s ease both}.fade-in{animation:fade-in .3s ease both}.slide-in{animation:slide-in-right .35s ease both}.mono{font-family:var(--font-mono)}.input-dark{background:var(--bg-surface);border:1px solid var(--border-default);border-radius:8px;color:var(--text-primary);padding:9px 12px;font-family:var(--font-sans);font-size:13px;width:100%;outline:none;transition:border-color .15s}.input-dark:focus{border-color:var(--blue-accent);box-shadow:0 0 0 3px #0a84ff26}.input-dark::-moz-placeholder{color:var(--text-tertiary)}.input-dark::placeholder{color:var(--text-tertiary)}.divider{height:1px;background:var(--border-subtle)}.welcome-screen{min-height:100vh;display:flex;flex-direction:column;align-items:center;justify-content:center;background:radial-gradient(ellipse at 50% 0%,rgba(10,132,255,.08) 0%,transparent 70%),var(--bg-base);text-align:center;padding:40px 20px}

backend/static/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <title>CodeBlue Context</title>
+    <script type="module" crossorigin src="/assets/index-BPTnkzQ_.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BEynGZGH.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+  </html>

codeblue_context.py

@@ -0,0 +1,467 @@
+import json
+import re
+import sys
+from typing import Any, Dict, List, Optional, Tuple
+
+
+def _to_list(value: Any) -> List[Any]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
+def _first_non_empty(*values: Any) -> str:
+    for value in values:
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return ""
+
+
+def _extract_text(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value.strip()
+    if isinstance(value, (int, float)):
+        return str(value)
+    if isinstance(value, dict):
+        direct = _first_non_empty(
+            value.get("name"),
+            value.get("display"),
+            value.get("text"),
+            value.get("description"),
+            value.get("title"),
+            value.get("condition"),
+            value.get("diagnosis"),
+            value.get("substance"),
+            value.get("allergen"),
+            value.get("medication"),
+            value.get("drug"),
+            value.get("note"),
+        )
+        if direct:
+            return direct
+
+        code = value.get("code")
+        if isinstance(code, dict):
+            code_text = _first_non_empty(code.get("text"), code.get("display"))
+            if code_text:
+                return code_text
+            coding = _to_list(code.get("coding"))
+            for c in coding:
+                if isinstance(c, dict):
+                    coding_text = _first_non_empty(c.get("display"), c.get("code"))
+                    if coding_text:
+                        return coding_text
+        elif isinstance(code, str) and code.strip():
+            return code.strip()
+
+    return ""
+
+
+def _parse_float(value: Any) -> Optional[float]:
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        cleaned = value.strip().replace(",", "")
+        if not cleaned:
+            return None
+        match = re.search(r"-?\d+(\.\d+)?", cleaned)
+        if match:
+            try:
+                return float(match.group(0))
+            except ValueError:
+                return None
+    return None
+
+
+def _extract_reference_range(lab: Dict[str, Any]) -> Tuple[Optional[float], Optional[float]]:
+    rr = lab.get("reference_range")
+    if isinstance(rr, dict):
+        low = _parse_float(rr.get("low"))
+        high = _parse_float(rr.get("high"))
+        return low, high
+    if isinstance(rr, list) and rr:
+        first = rr[0]
+        if isinstance(first, dict):
+            low = _parse_float(first.get("low"))
+            high = _parse_float(first.get("high"))
+            return low, high
+    return None, None
+
+
+def _normalize_vitals(vitals: Any) -> Dict[str, Any]:
+    normalized: Dict[str, Any] = {}
+    if isinstance(vitals, dict):
+        for k, v in vitals.items():
+            normalized[str(k).lower().strip()] = v
+    elif isinstance(vitals, list):
+        for item in vitals:
+            if not isinstance(item, dict):
+                continue
+            key = _extract_text(item.get("name") or item.get("type") or item.get("code"))
+            if not key:
+                continue
+            normalized[key.lower().strip()] = item.get("value")
+    return normalized
+
+
+def _dedupe_keep_order(items: List[str]) -> List[str]:
+    seen = set()
+    result = []
+    for item in items:
+        text = item.strip()
+        if not text:
+            continue
+        if text not in seen:
+            seen.add(text)
+            result.append(text)
+    return result
+
+
+def _has_documented_data(value: Any) -> bool:
+    if value is None:
+        return False
+    if isinstance(value, str):
+        return bool(value.strip())
+    if isinstance(value, (list, tuple, set, dict)):
+        return len(value) > 0
+    return True
+
+
+def _is_placeholder_entry(text: str) -> bool:
+    t = text.strip().lower()
+    return (
+        t == "unknown"
+        or t == "not documented"
+        or t == "none reported"
+        or t.startswith("none identified")
+        or t.startswith("no critical abnormalities identified")
+        or t.startswith("no immediate life-threatening alert identified")
+    )
+
+
+def build_emergency_snapshot(record: Dict[str, Any]) -> Tuple[str, List[Dict[str, str]], List[str], Dict[str, Any]]:
+    if not isinstance(record, dict):
+        record = {}
+
+    reasoning: List[Dict[str, str]] = []
+    def add_reasoning(explanation: str, source_text: str = ""):
+        reasoning.append({"explanation": explanation, "source_text": source_text})
+
+    add_reasoning("Initiating CodeBlue emergency analysis.")
+
+    patient = record.get("patient", {})
+    age = patient.get("age") if isinstance(patient, dict) else None
+    gender = patient.get("gender") if isinstance(patient, dict) else None
+    add_reasoning(f"Extracted patient demographics: Age {age or 'Unknown'}, Gender {gender or 'Unknown'}.")
+
+    raw_allergies = _to_list(record.get("allergies"))
+    raw_medications = _to_list(record.get("medications"))
+    raw_conditions = _to_list(record.get("conditions"))
+    raw_labs = _to_list(record.get("labs"))
+    raw_history = _to_list(record.get("history"))
+    raw_clinical_notes = _to_list(record.get("clinical_notes", record.get("clinical_notes", "")))
+    raw_notes = _to_list(record.get("notes"))
+    raw_vitals = record.get("vitals")
+    vitals = _normalize_vitals(raw_vitals)
+    add_reasoning("Normalized and loaded all available clinical data sources.")
+
+    # Combine all text sources for narrative analysis
+    all_text_sources = [
+        str(item) for item in 
+        raw_allergies + raw_medications + raw_conditions + raw_labs + 
+        raw_history + raw_clinical_notes + raw_notes
+    ]
+    full_narrative = " ".join(all_text_sources).lower()
+
+
+    has_labs_documented = _has_documented_data(record.get("labs"))
+    has_vitals_documented = _has_documented_data(raw_vitals)
+    has_medications_documented = _has_documented_data(record.get("medications"))
+
+    critical_alerts: List[str] = []
+    allergies_out: List[str] = []
+    high_risk_medications: List[str] = []
+    chronic_conditions: List[str] = []
+    recent_abnormalities: List[str] = []
+    emergency_risks: List[str] = []
+    extracted_vitals: Dict[str, Any] = {}
+
+    # Allergies
+    severe_allergy = False
+    for allergy in raw_allergies:
+        allergy_text = _extract_text(allergy)
+        if not allergy_text and isinstance(allergy, dict):
+            allergy_text = _first_non_empty(
+                _extract_text(allergy.get("substance")),
+                _extract_text(allergy.get("allergen")),
+                _extract_text(allergy.get("code")),
+            )
+        if allergy_text:
+            allergies_out.append(allergy_text)
+            add_reasoning(f"Found allergy: {allergy_text}", source_text=allergy_text)
+
+
+    # Conditions
+    conditions = [_extract_text(c) for c in raw_conditions]
+    conditions = [c for c in conditions if c]
+    chronic_keywords = (
+        "diabetes",
+        "hypertension",
+        "heart",
+        "coronary",
+        "copd",
+        "asthma",
+        "ckd",
+        "kidney disease",
+        "renal",
+        "stroke",
+        "epilepsy",
+        "cancer",
+        "chf",
+        "heart failure",
+        "afib",
+        "atrial fibrillation",
+    )
+    for condition in conditions:
+        if any(keyword in condition.lower() for keyword in chronic_keywords):
+            chronic_conditions.append(condition)
+            add_reasoning(f"Identified emergency-relevant chronic condition: {condition}", source_text=condition)
+
+    # Medications
+    meds = [_extract_text(m) for m in raw_medications]
+    meds = [m for m in meds if m]
+
+    anticoagulants = (
+        "warfarin",
+        "heparin",
+        "enoxaparin",
+        "apixaban",
+        "rivaroxaban",
+        "dabigatran",
+        "edoxaban",
+    )
+    opioids = (
+        "morphine",
+        "oxycodone",
+        "hydromorphone",
+        "fentanyl",
+        "codeine",
+        "tramadol",
+        "methadone",
+    )
+    cardiac_meds = (
+        "digoxin",
+        "amiodarone",
+        "metoprolol",
+        "atenolol",
+        "carvedilol",
+        "diltiazem",
+        "verapamil",
+        "nitroglycerin",
+    )
+    has_anticoagulant = False
+    has_insulin = False
+    has_opioid = False
+    has_cardiac_med = False
+
+    for med in meds:
+        med_l = med.lower()
+        if any(name in med_l for name in anticoagulants):
+            has_anticoagulant = True
+            high_risk_medications.append(f"{med} (anticoagulant)")
+            add_reasoning(f"Detected high-risk medication (anticoagulant): {med}", source_text=med)
+        if "insulin" in med_l:
+            has_insulin = True
+            high_risk_medications.append(f"{med} (insulin)")
+            add_reasoning(f"Detected high-risk medication (insulin): {med}", source_text=med)
+        if any(name in med_l for name in opioids):
+            has_opioid = True
+            high_risk_medications.append(f"{med} (opioid)")
+            add_reasoning(f"Detected high-risk medication (opioid): {med}", source_text=med)
+        if any(name in med_l for name in cardiac_meds):
+            has_cardiac_med = True
+            high_risk_medications.append(f"{med} (cardiac medication)")
+            add_reasoning(f"Detected high-risk medication (cardiac): {med}", source_text=med)
+
+    # Labs
+    for lab in raw_labs:
+        if isinstance(lab, str):
+            text = lab.strip()
+            if text:
+                text_l = text.lower()
+                if any(word in text_l for word in ("critical", "abnormal", "high", "low")):
+                    recent_abnormalities.append(text)
+                    if "critical" in text_l:
+                        critical_alerts.append(f"Critical lab finding: {text}.")
+            continue
+
+        if not isinstance(lab, dict):
+            continue
+
+        name = _extract_text(lab.get("name") or lab.get("test") or lab.get("code")) or "Lab result"
+        value_raw = lab.get("value")
+        if value_raw is None and isinstance(lab.get("result"), dict):
+            value_raw = lab["result"].get("value")
+        elif value_raw is None:
+            value_raw = lab.get("result")
+
+        value_num = _parse_float(value_raw)
+        unit = _extract_text(lab.get("unit"))
+        flag = _extract_text(lab.get("flag")).lower()
+        low, high = _extract_reference_range(lab)
+
+        abnormal = False
+        critical = False
+        if flag and any(token in flag for token in ("abnormal", "high", "low", "critical", "panic")):
+            abnormal = True
+        if flag and any(token in flag for token in ("critical", "panic", "severe")):
+            critical = True
+        if value_num is not None:
+            if low is not None and value_num < low:
+                abnormal = True
+            if high is not None and value_num > high:
+                abnormal = True
+
+        if abnormal:
+            value_text = str(value_raw) if value_raw is not None else "reported"
+            detail = f"{name}: {value_text}{(' ' + unit) if unit else ''}"
+            if flag:
+                detail += f" ({flag})"
+            recent_abnormalities.append(detail)
+            add_reasoning(f"Found abnormal lab: {detail}", source_text=str(lab))
+            if critical:
+                critical_alerts.append(f"Critical lab abnormality: {detail}.")
+                add_reasoning(f"Flagged CRITICAL lab: {detail}", source_text=str(lab))
+
+    # Vitals Extraction and Analysis
+    def add_vital_abnormality(label: str, value: Any, is_critical: bool, source: str) -> None:
+        detail = f"{label}: {value}"
+        recent_abnormalities.append(detail)
+        if is_critical:
+            critical_alerts.append(f"Critical vital sign: {detail}.")
+            add_reasoning(f"Flagged CRITICAL vital: {detail}", source_text=source)
+        else:
+            add_reasoning(f"Noted abnormal vital: {detail}", source_text=source)
+
+    # Regex patterns for vitals
+    vital_patterns = {
+        "Blood Pressure": r"bp\s*:?\s*(\d{2,3})\s*/\s*(\d{2,3})",
+        "Heart Rate": r"hr\s*:?\s*(\d{2,3})",
+        "SpO2": r"spo2\s*:?\s*(\d{2,3})%?",
+        "Respiratory Rate": r"rr\s*:?\s*(\d{1,2})",
+        "Temperature": r"temp\s*:?\s*(\d{2}(\.\d)?)",
+    }
+
+    for label, pattern in vital_patterns.items():
+        match = re.search(pattern, full_narrative, re.IGNORECASE)
+        if match:
+            if label == "Blood Pressure":
+                systolic, diastolic = map(int, match.groups())
+                value_str = f"{systolic}/{diastolic}"
+                extracted_vitals[label] = value_str
+                add_reasoning(f"Extracted {label}: {value_str}", source_text=match.group(0))
+                if systolic > 180 or diastolic > 120 or systolic < 90:
+                     add_vital_abnormality(label, value_str, True, match.group(0))
+            else:
+                value = float(match.group(1))
+                extracted_vitals[label] = value
+                add_reasoning(f"Extracted {label}: {value}", source_text=match.group(0))
+                # Add abnormality checks here based on value
+                if label == "Heart Rate" and (value > 130 or value < 40):
+                    add_vital_abnormality(label, f"{value} bpm", True, match.group(0))
+                elif label == "SpO2" and value < 90:
+                    add_vital_abnormality(label, f"{value}%", True, match.group(0))
+
+
+    # History / notes signals
+    narrative_text = " ".join(
+        [_extract_text(item) for item in raw_history + raw_clinical_notes + raw_notes]
+    ).lower()
+
+    if "icu" in narrative_text:
+        critical_alerts.append("ICU history documented.")
+    if "anaphyl" in narrative_text and not severe_allergy:
+        critical_alerts.append("History suggests severe allergic reaction.")
+        severe_allergy = True
+
+    # Emergency risks
+    has_diabetes = any("diabetes" in c.lower() for c in conditions + chronic_conditions)
+    has_cardiac_condition = any(
+        token in c.lower()
+        for c in conditions + chronic_conditions
+        for token in ("heart", "coronary", "chf", "afib", "atrial fibrillation", "myocardial infarction")
+    )
+    trauma_or_fall_risk = any(token in narrative_text for token in ("fall", "trauma", "injury", "post-op", "surgery"))
+
+    if has_anticoagulant:
+        emergency_risks.append("Bleeding Risk (High)")
+        add_reasoning("Synthesized risk: Anticoagulant exposure elevates bleeding risk.")
+    if has_insulin or has_diabetes:
+        emergency_risks.append("Hypoglycemia Risk (Moderate)")
+        add_reasoning("Synthesized risk: Diabetes/insulin factors increase hypoglycemia risk.")
+    if has_opioid:
+        emergency_risks.append("Respiratory Depression Risk (High)")
+        add_reasoning("Synthesized risk: Opioid exposure elevates respiratory depression risk.")
+    if has_cardiac_condition or has_cardiac_med:
+        emergency_risks.append("Cardiac Event Risk (Moderate)")
+        add_reasoning("Synthesized risk: Cardiac history/meds increase risk of cardiac events.")
+    if severe_allergy:
+        emergency_risks.append("Anaphylaxis Risk (High)")
+        add_reasoning("Synthesized risk: Severe allergy history poses high anaphylaxis risk.")
+
+
+    # Final Snapshot Generation
+    final_lines = []
+    if critical_alerts:
+        final_lines.extend(critical_alerts)
+
+    summary_line = f"{age or 'Unknown'}-y/o {gender or 'Unknown'} with history of {', '.join(chronic_conditions[:2]) if chronic_conditions else 'undisclosed conditions'}."
+    final_lines.append(summary_line)
+
+    risk_summary_line = f"Primary risks: {', '.join(emergency_risks[:3]) if emergency_risks else 'none identified'}."
+    final_lines.append(risk_summary_line)
+
+    if not final_lines:
+        final_lines.append("No critical issues identified from available data.")
+
+    add_reasoning("Finalizing emergency snapshot based on synthesized risks and alerts.")
+    final_snapshot = "\n".join(_dedupe_keep_order(final_lines)[:6])
+
+    return final_snapshot, reasoning, emergency_risks, extracted_vitals
+
+
+def main() -> int:
+    raw = ""
+    if len(sys.argv) > 1:
+        path = sys.argv[1]
+        with open(path, "r", encoding="utf-8") as f:
+            raw = f.read()
+    else:
+        raw = sys.stdin.read()
+
+    if not raw.strip():
+        record: Dict[str, Any] = {}
+    else:
+        try:
+            parsed = json.loads(raw)
+            record = parsed if isinstance(parsed, dict) else {}
+        except json.JSONDecodeError:
+            record = {}
+
+    snapshot, reasoning, risks, vitals = build_emergency_snapshot(record)
+    result = {
+        "snapshot": snapshot,
+        "reasoning": reasoning,
+        "risks": risks,
+        "vitals": vitals,
+    }
+    print(json.dumps(result, indent=2, ensure_ascii=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

frontend

@@ -0,0 +1 @@
+Subproject commit 70fcc96cc4551f6093f74a4a7f6c8ee9e75932bf

requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.115.12
+uvicorn==0.34.2
+python-multipart==0.0.9
+google-generativeai==0.8.3