Initial lightweight hackathon submission

.dockerignore

@@ -0,0 +1,13 @@
+.git
+.venv
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.DS_Store
+.idea/
+.vscode/
+*.log

.gitignore

@@ -0,0 +1,9 @@
+node_modules/
+.next/
+backend/.venv/
+venv/
+__pycache__/
+*.pyc
+*.log
+.env
+.DS_Store

Dockerfile

@@ -0,0 +1,45 @@
+# ── Base image (lightweight, CPU-only) ────────────────────────────────────────
+FROM python:3.11-slim
+
+# ── Metadata ──────────────────────────────────────────────────────────────────
+LABEL maintainer="MediRoute Team" \
+      env_id="mediroute-openenv-v1" \
+      version="1.0.0" \
+      description="Medical Triage and Hospital Routing OpenEnv Environment" \
+      org.opencontainers.image.title="MediRoute OpenEnv" \
+      org.opencontainers.image.licenses="MIT"
+
+# ── System dependencies ───────────────────────────────────────────────────────
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── Python runtime defaults ───────────────────────────────────────────────────
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+# ── Working directory ─────────────────────────────────────────────────────────
+WORKDIR /app
+
+# ── Install Python dependencies first (cache-friendly layer) ──────────────────
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+# ── Copy application source safely ────────────────────────────────────────────
+# Copying the full project avoids file-not-found build breaks and is HF-Spaces-friendly.
+COPY . .
+
+# ── Non-root user for security ────────────────────────────────────────────────
+RUN adduser --disabled-password --gecos "" appuser
+USER appuser
+
+# ── Environment variable defaults (override at runtime) ───────────────────────
+ENV OPENAI_API_KEY="EMPTY" \
+    API_BASE_URL="https://api.openai.com/v1" \
+    MODEL_NAME="gpt-4o-mini" \
+    HF_TOKEN=""
+
+# ── Default command: run baseline inference across all tasks ──────────────────
+# LLM agent can be enabled by passing: --agent llm and setting API env vars.
+CMD ["python", "-u", "inference.py", "--difficulty", "all", "--agent", "rules"]

README.md

@@ -0,0 +1,232 @@
+# MediRoute OpenEnv
+
+**MediRoute OpenEnv** is a deterministic **healthcare triage + hospital routing** simulation environment designed for evaluating agent decision-making under realistic clinical constraints.
+
+It models the end-to-end flow a real triage system must handle:
+- interpret symptoms + vitals/labs
+- assign severity (non-emergency → critical)
+- route to the right specialist
+- pick an appropriate nearby facility
+- decide between **appointment vs ambulance escalation**
+
+This environment is intentionally small, fully deterministic, and strongly typed so it can be used in hackathon evaluation pipelines and reproduced exactly.
+
+---
+
+## Why this matters (motivation + utility)
+
+Healthcare triage is a high-stakes planning problem with:
+- **multi-step reasoning** (severity → specialist → facility → action)
+- **safety-critical escalation** (ambulance dispatch vs harmful delays)
+- **real-world constraints** (limited specialists, nearby hospitals, and incomplete info)
+
+MediRoute is useful for agent evaluation because it tests:
+- **trajectory quality** (progressive reward shaping across steps)
+- **loop avoidance** (duplicate actions and stalling are penalized)
+- **robustness** (invalid actions are handled safely and deterministically)
+- **policy compliance** (terminal actions and episode boundaries are enforced)
+
+---
+
+## Environment overview
+
+- **Environment class**: `MediRouteEnv` in `environment.py`
+- **Spec**: `openenv.yaml`
+- **Typed interface**: `models.py` (Pydantic `Observation`, `Action`, `StepResult`)
+- **Tasks**: `tasks.py` (`easy`, `medium`, `hard`)
+- **Deterministic graders**: `graders.py` (`grade_step`, `grade_episode`)
+
+OpenEnv interface methods:
+- `reset(difficulty: str) -> Observation`
+- `step(action: Action) -> StepResult` where `StepResult` contains:
+  - `observation` (updated `Observation`)
+  - `reward` (incremental step reward)
+  - `done` (episode termination flag)
+  - `info` (diagnostics incl. totals and termination reason)
+- `state() -> Observation` (read-only snapshot)
+
+---
+
+## Tasks (real-world healthcare cases)
+
+The tasks represent increasing clinical risk and decision complexity.
+
+### Easy — mild illness (primary care)
+- **Scenario**: fever + sore throat with positive strep test
+- **Goal**: classify **low** severity, route to **General Physician**, choose an appropriate clinic, then close with appointment/guidance
+- **Clinical realism**: routine outpatient triage with lab confirmation
+
+### Medium — suspected acute coronary syndrome
+- **Scenario**: crushing chest pain, hypertension, ECG ST-elevation, elevated troponin
+- **Goal**: classify **high** severity, route to **Cardiologist**, select a cardiac-capable hospital, then close appropriately
+- **Clinical realism**: time-sensitive cardiology routing
+
+### Hard — critical collapse (life-threatening)
+- **Scenario**: unresponsive patient with cyanosis and SpO₂ crash
+- **Goal**: classify **critical** severity and **dispatch ambulance** (terminal action), avoiding unsafe appointment flows
+- **Clinical realism**: emergency escalation with irreversible harm from delay
+
+---
+
+## Action space
+
+Defined in `models.py` (`VALID_ACTION_TYPES`) and mirrored in `openenv.yaml`:
+
+- `analyze_symptoms` — classify severity (target: `low|moderate|high|critical`)
+- `request_more_info` — ask for missing details (target optional)
+- `recommend_specialist` — choose specialist (target: a specialist name)
+- `select_hospital` — choose facility (target: a hospital name)
+- `book_appointment` — close non-emergencies (target optional)
+- `call_ambulance` — escalate emergencies (target optional)
+- `provide_temp_guidance` — short-term guidance (target optional)
+
+---
+
+## Observation space
+
+`Observation` fields (see `models.py` and `openenv.yaml`):
+- `symptoms: str`
+- `lab_report_summary: dict`
+- `severity_score: float` in `[0.0, 1.0]` (updated when severity is analyzed)
+- `location: str`
+- `nearby_hospitals: list[str]`
+- `available_specialists: list[str]`
+- `previous_actions: list[str]` (canonical `"<action_type>:<target>"`)
+
+---
+
+## Reward shaping (non-binary, trajectory-based)
+
+Reward is **shaped across the trajectory** (not a single binary outcome):
+- partial credit for intermediate correct decisions (severity, specialist, hospital)
+- penalties for unsafe or unproductive behavior (wrong routing, duplicates, stalling)
+- episode total is clamped to `[0.0, 1.0]` for consistent scoring
+
+Implementation:
+- per-step reward: `graders.grade_step(task, action, previous_actions)`
+- episode summary: `graders.grade_episode(...)`
+- total reward clamped + tracked in `environment.py`
+
+---
+
+## Setup
+
+### Local (Python)
+
+```bash
+cd meta
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+---
+
+## Run the environment
+
+### Interactive REPL (manual testing)
+
+```bash
+cd meta
+python app.py --difficulty easy
+```
+
+### Baseline inference (LLM agent)
+
+Environment variables:
+- `OPENAI_API_KEY` (or `HF_TOKEN` for gated HF models)
+- `API_BASE_URL` (defaults to OpenAI; can be any OpenAI-compatible server)
+- `MODEL_NAME` (defaults to `gpt-4o-mini`)
+
+```bash
+cd meta
+export OPENAI_API_KEY="..."
+export API_BASE_URL="https://api.openai.com/v1"
+export MODEL_NAME="gpt-4o-mini"
+python inference.py --difficulty all --agent llm
+```
+
+### Baseline inference (deterministic rules agent)
+
+This baseline runs **without any network calls** and is fully reproducible.
+
+```bash
+cd meta
+python inference.py --difficulty all --agent rules
+```
+
+---
+
+## Expected baseline scores
+
+Because the environment and grader are deterministic:
+- **Rules baseline** (`--agent rules`) is expected to score **1.0000** on `easy`, `medium`, and `hard`.
+- **LLM baseline** (`--agent llm`) depends on the chosen model/endpoint, but should typically pass all tasks with a capable instruction-following model.
+
+---
+
+## Docker (build + run)
+
+### Build
+
+```bash
+cd meta
+docker build -t mediroute-openenv:latest .
+```
+
+### Run (rules baseline, no API required)
+
+```bash
+docker run --rm mediroute-openenv:latest python -u inference.py --difficulty all --agent rules
+```
+
+### Run (LLM baseline)
+
+```bash
+docker run --rm \
+  -e OPENAI_API_KEY="..." \
+  -e API_BASE_URL="https://api.openai.com/v1" \
+  -e MODEL_NAME="gpt-4o-mini" \
+  mediroute-openenv:latest python -u inference.py --difficulty all --agent llm
+```
+
+---
+
+## Hugging Face Spaces (CPU) deployment notes
+
+MediRoute is HF-Spaces-friendly because it is **CPU-only** and can run fully offline using the rules baseline.
+
+Recommended Space setup:
+- **SDK**: Docker (or Python, but Docker is easiest)
+- **Hardware**: CPU basic
+- **Entrypoint**: keep the default `CMD` (runs all tasks), or override to rules mode
+
+If using Docker Spaces:
+- add secrets as needed (`OPENAI_API_KEY` / `HF_TOKEN`)
+- optionally set `MODEL_NAME` and `API_BASE_URL` for your endpoint
+
+To default the Space to offline evaluation:
+- configure it to run: `python -u inference.py --difficulty all --agent rules`
+
+---
+
+## Novelty (why this is different)
+
+Compared to common OpenEnv tasks (email triage, scheduling, simple classification), MediRoute is novel because it combines:
+- **safety-critical escalation** (ambulance dispatch logic, harmful appointment decisions)
+- **severity inference → downstream routing** (specialist + hospital choice depends on severity)
+- **trajectory shaping** that rewards incremental clinical reasoning and penalizes loops
+- **healthcare-specific realism** (vitals/labs, STEMI-like signals, SpO₂ collapse)
+
+---
+
+## Repo map
+
+- `environment.py` — OpenEnv environment implementation (`reset/step/state`)
+- `models.py` — Pydantic models (`Observation`, `Action`, `StepResult`)
+- `tasks.py` — deterministic tasks (`easy|medium|hard`)
+- `graders.py` — deterministic reward shaping and episode grading
+- `inference.py` — baseline inference runner (`--agent llm|rules`)
+- `app.py` — manual interactive REPL
+- `openenv.yaml` — OpenEnv specification
+

app.py

@@ -0,0 +1,104 @@
+"""
+app.py — Interactive entrypoint for MediRoute OpenEnv.
+
+Run this script for a quick interactive session with the environment:
+    python app.py --difficulty easy
+    python app.py --difficulty medium
+    python app.py --difficulty hard
+
+The script drives a simple REPL loop so you can manually test the environment
+without running the full AI inference pipeline.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from environment import MediRouteEnv
+from models import Action
+from tasks import list_tasks
+
+
+def print_obs(obs) -> None:
+    sep = "─" * 60
+    print(sep)
+    print(f"  📍 Location       : {obs.location}")
+    print(f"  🤒 Symptoms       : {obs.symptoms}")
+    print(f"  🔬 Labs           : {json.dumps(obs.lab_report_summary, indent=4)}")
+    print(f"  ⚡ Severity score : {obs.severity_score:.2f}")
+    print(f"  🏥 Hospitals      : {obs.nearby_hospitals}")
+    print(f"  👨‍⚕️ Specialists    : {obs.available_specialists}")
+    print(f"  📋 Past actions   : {obs.previous_actions or '(none)'}")
+    print(sep)
+
+
+def repl(difficulty: str) -> None:
+    env = MediRouteEnv()
+    obs = env.reset(difficulty=difficulty)
+
+    print(f"\n🏥  MediRoute OpenEnv — difficulty: {difficulty.upper()}")
+    print_obs(obs)
+
+    valid_types = [
+        "analyze_symptoms",
+        "request_more_info",
+        "recommend_specialist",
+        "select_hospital",
+        "book_appointment",
+        "call_ambulance",
+        "provide_temp_guidance",
+    ]
+    print("Valid action types:", ", ".join(valid_types))
+    print("Type  'quit' to exit.\n")
+
+    while True:
+        raw = input("action_type [target]: ").strip()
+        if raw.lower() in {"quit", "exit", "q"}:
+            break
+
+        parts = raw.split(maxsplit=1)
+        action_type = parts[0]
+        target = parts[1] if len(parts) > 1 else None
+
+        action = Action(action_type=action_type, target=target)
+        result = env.step(action)
+
+        reward_sign = "+" if result.reward >= 0 else ""
+        print(f"\n  Reward : {reward_sign}{result.reward:.2f}")
+        print(f"  Done   : {result.done}")
+        print(f"  Total  : {result.info.get('total_reward', 0):.2f}")
+
+        if result.done:
+            summary = result.info.get("episode_summary", {})
+            print("\n🎯  Episode complete!")
+            print(json.dumps(summary, indent=4))
+            break
+        else:
+            print_obs(result.observation)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="MediRoute OpenEnv interactive REPL")
+    parser.add_argument(
+        "--difficulty",
+        choices=["easy", "medium", "hard"],
+        default="easy",
+        help="Task difficulty level (default: easy)",
+    )
+    parser.add_argument("--list-tasks", action="store_true", help="List available tasks and exit")
+
+    args = parser.parse_args()
+
+    if args.list_tasks:
+        print("\nAvailable Tasks:\n")
+        for diff, desc in list_tasks().items():
+            print(f"  [{diff.upper():6}]  {desc}")
+        sys.exit(0)
+
+    repl(args.difficulty)
+
+
+if __name__ == "__main__":
+    main()

environment.py

@@ -0,0 +1,237 @@
+"""
+environment.py — Core MediRoute OpenEnv environment.
+
+This module implements the standard OpenEnv interface:
+    env.reset(difficulty) → Observation
+    env.step(action)      → StepResult
+    env.state()           → Observation
+
+The environment is fully deterministic given the same task; no randomness.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional, Tuple
+
+from graders import grade_episode, grade_step
+from models import Action, Observation, StepResult
+from tasks import get_task
+
+
+@dataclass(frozen=True)
+class DoneReason:
+    code: str
+    message: str
+
+
+class MediRouteEnv:
+    """
+    Medical Triage and Hospital Routing simulation environment.
+
+    Follows the OpenEnv specification:
+      ┌──────────────────────────────────────────────────────────┐
+      │  reset(difficulty)  →  Observation                       │
+      │  step(action)       →  StepResult(obs, reward, done, info)│
+      │  state()            →  Observation (read-only snapshot)  │
+      └──────────────────────────────────────────────────────────┘
+    """
+
+    # Class-level metadata (used by openenv.yaml / registry)
+    ENV_ID: str = "mediroute-openenv-v1"
+    VERSION: str = "1.0.0"
+
+    def __init__(self) -> None:
+        self._task: Dict[str, Any] = {}
+        self._obs: Observation | None = None
+        self._total_reward: float = 0.0
+        self._done: bool = False
+        self._step_count: int = 0
+        self._done_reason: Optional[DoneReason] = None
+
+    # ─────────────────────────────────────────────
+    #  OpenEnv Interface
+    # ─────────────────────────────────────────────
+
+    def reset(self, difficulty: str = "easy") -> Observation:
+        """
+        Initialise (or re-initialise) the environment for a new episode.
+
+        Args:
+            difficulty: One of 'easy', 'medium', 'hard'.
+
+        Returns:
+            The initial Observation the agent should act upon.
+        """
+        self._task = get_task(difficulty)
+        self._total_reward = 0.0
+        self._done = False
+        self._done_reason = None
+        self._step_count = 0
+
+        self._obs = Observation(
+            symptoms=self._task["symptoms"],
+            lab_report_summary=self._task["lab_report_summary"],
+            severity_score=self._task["severity_score"],
+            location=self._task["location"],
+            nearby_hospitals=self._task["nearby_hospitals"],
+            available_specialists=self._task["available_specialists"],
+            previous_actions=[],
+        )
+        return self._obs
+
+    def step(self, action: Action) -> StepResult:
+        """
+        Advance the environment by one action.
+
+        Args:
+            action: A typed Action submitted by the agent.
+
+        Returns:
+            StepResult with updated observation, step reward, done flag, and info.
+        """
+        if self._obs is None:
+            raise RuntimeError("Environment not initialised. Call reset() first.")
+
+        if self._done:
+            return StepResult(
+                observation=self._obs,
+                reward=0.0,
+                done=True,
+                info={
+                    "warning": "Episode is already done; no further steps are accepted.",
+                    "total_reward": self._total_reward,
+                    "done_reason": (self._done_reason.code if self._done_reason else "done"),
+                },
+            )
+
+        # ── Validate action type ───────────────────────────────────────────────
+        if not action.validate_action_type():
+            return StepResult(
+                observation=self._obs,
+                reward=-0.10,
+                done=False,
+                info={
+                    "error": f"Unknown action_type '{action.action_type}'.",
+                    "total_reward": self._total_reward,
+                },
+            )
+
+        # ── Basic action schema validation (deterministic, non-throwing) ───────
+        invalid_reason, target_norm = self._validate_action_semantics(action)
+        if invalid_reason:
+            # Do not mutate state for invalid semantic actions; keep episode running.
+            return StepResult(
+                observation=self._obs,
+                reward=-0.10,
+                done=False,
+                info={
+                    "error": invalid_reason,
+                    "total_reward": self._total_reward,
+                },
+            )
+
+        # ── Compute incremental reward ────────────────────────────────────────
+        raw_reward = grade_step(
+            task=self._task,
+            action=action,
+            previous_actions=self._obs.previous_actions,
+        )
+
+        # ── Accumulate and clamp total reward to [0, 1] ───────────────────────
+        new_total = max(0.0, min(1.0, self._total_reward + raw_reward))
+        incremental_reward = new_total - self._total_reward
+        self._total_reward = new_total
+
+        # ── Update observation: record action, update severity_score ──────────
+        self._obs.previous_actions.append(action.as_key())
+        self._step_count += 1
+
+        # Reflect severity classification if agent analysed symptoms
+        if action.action_type == "analyze_symptoms" and target_norm:
+            severity_map = {"low": 0.2, "moderate": 0.5, "high": 0.75, "critical": 0.95}
+            # If an unknown target somehow slips through, do not overwrite severity.
+            if target_norm in severity_map:
+                self._obs.severity_score = severity_map[target_norm]
+
+        # ── Determine if episode terminates ───────────────────────────────────
+        terminal_actions = self._task.get("terminal_actions", {"book_appointment", "call_ambulance"})
+        max_steps = self._task.get("max_steps", 8)
+
+        if action.action_type in terminal_actions:
+            self._done = True
+            self._done_reason = DoneReason(
+                code="terminal_action",
+                message=f"Episode ended by terminal action: {action.action_type}.",
+            )
+        elif self._step_count >= max_steps:
+            self._done = True
+            self._done_reason = DoneReason(
+                code="max_steps",
+                message=f"Episode ended after reaching max_steps={max_steps}.",
+            )
+
+        # ── Build info payload ────────────────────────────────────────────────
+        info: Dict[str, Any] = {
+            "step": self._step_count,
+            "raw_step_reward": raw_reward,
+            "total_reward": self._total_reward,
+            "done": self._done,
+            "done_reason": (self._done_reason.code if self._done_reason else None),
+        }
+
+        if self._done:
+            info["episode_summary"] = grade_episode(
+                task=self._task,
+                all_actions=self._obs.previous_actions,
+                final_total_reward=self._total_reward,
+            )
+
+        return StepResult(
+            observation=self._obs,
+            reward=incremental_reward,
+            done=self._done,
+            info=info,
+        )
+
+    def state(self) -> Observation:
+        """Return the current observation without advancing the environment."""
+        if self._obs is None:
+            raise RuntimeError("Environment not initialised. Call reset() first.")
+        return self._obs
+
+    # ─────────────────────────────────────────────
+    #  Validation helpers
+    # ─────────────────────────────────────────────
+
+    def _validate_action_semantics(self, action: Action) -> Tuple[Optional[str], Optional[str]]:
+        """
+        Validate action semantics in a deterministic, non-throwing way.
+
+        Returns:
+            (error_message_or_none, normalized_target_or_none)
+        """
+        action_type = action.action_type
+        target = (action.target or "").strip()
+        target_norm = target.lower() if target else None
+
+        # Target requirements
+        if action_type == "analyze_symptoms":
+            if not target_norm:
+                return "analyze_symptoms requires a target severity: low|moderate|high|critical.", None
+            if target_norm not in {"low", "moderate", "high", "critical"}:
+                return "Invalid severity target for analyze_symptoms (use low|moderate|high|critical).", None
+            return None, target_norm
+
+        if action_type in {"recommend_specialist", "select_hospital"} and not target:
+            return f"{action_type} requires a non-empty target.", None
+
+        # Loop prevention / stalling guardrails (lightweight, deterministic)
+        # Excessive 'request_more_info' stalls the episode without progress.
+        if action_type == "request_more_info":
+            recent = self._obs.previous_actions[-3:] if self._obs else []
+            if sum(1 for a in recent if a.startswith("request_more_info:")) >= 2:
+                # Not invalid, but strongly discouraged: let grader penalize via duplicates/negative.
+                return None, target_norm
+
+        return None, target_norm

graders.py

@@ -0,0 +1,162 @@
+"""
+graders.py — Reward shaping logic for MediRoute OpenEnv.
+
+Each action is evaluated against the ground-truth task expectations.
+Rewards are incremental per-step values; the environment accumulates and
+clamps the episode total to [0.0, 1.0].
+
+Reward table
+─────────────────────────────────────────────────────────────────
+ Correct severity classification (analyze_symptoms)   +0.30
+ Correct specialist recommendation                    +0.30
+ Correct hospital selection                           +0.20
+ Successful appointment booking (non-emergency)       +0.20
+ Correct emergency escalation (call_ambulance)        +0.50
+ Wrong department / specialist                        -0.20
+ Unnecessary loop / duplicate action                  -0.30
+ Calling ambulance on non-emergency                   -0.30
+ Booking appointment in emergency case                -0.30
+─────────────────────────────────────────────────────────────────
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from models import Action
+
+
+# ─────────────────────────────────────────────
+#  Internal helpers
+# ─────────────────────────────────────────────
+
+def _is_duplicate(action: Action, previous_actions: List[str]) -> bool:
+    return action.as_key() in previous_actions
+
+
+# ─────────────────────────────────────────────
+#  Public API
+# ─────────────────────────────────────────────
+
+def grade_step(
+    task: Dict[str, Any],
+    action: Action,
+    previous_actions: List[str],
+) -> float:
+    """
+    Compute the incremental reward for a single action taken in *task*.
+
+    Args:
+        task:             The full task dict as returned by tasks.get_task().
+        action:           The Action the agent wants to execute.
+        previous_actions: Actions already taken this episode (as 'type:target' strings).
+
+    Returns:
+        A float reward value (can be negative; clamping is done in the environment).
+    """
+
+    # ── Duplicate penalty ────────────────────────────────────────────────────
+    if _is_duplicate(action, previous_actions):
+        return -0.30
+
+    action_type = action.action_type
+    target = (action.target or "").strip()
+
+    # ── analyze_symptoms ─────────────────────────────────────────────────────
+    if action_type == "analyze_symptoms":
+        if target.lower() == task["expected_severity"].lower():
+            return 0.30
+        else:
+            return -0.10   # Incorrect severity assessment
+
+    # ── request_more_info ────────────────────────────────────────────────────
+    elif action_type == "request_more_info":
+        # Neutral in most cases; mild reward only if no prior analysis done
+        analyzed = any(a.startswith("analyze_symptoms") for a in previous_actions)
+        return 0.05 if not analyzed else -0.05
+
+    # ── recommend_specialist ─────────────────────────────────────────────────
+    elif action_type == "recommend_specialist":
+        if target == task["expected_specialist"]:
+            return 0.30
+        else:
+            return -0.20   # Wrong department
+
+    # ── select_hospital ──────────────────────────────────────────────────────
+    elif action_type == "select_hospital":
+        if target == task["expected_hospital"]:
+            return 0.20
+        elif target in task["nearby_hospitals"]:
+            return 0.05    # Nearby but not optimal
+        else:
+            return -0.10   # Unknown / unreachable hospital
+
+    # ── book_appointment ─────────────────────────────────────────────────────
+    elif action_type == "book_appointment":
+        if task["requires_ambulance"]:
+            # Trying to book appointment in a life-threatening emergency is wrong
+            return -0.30
+        return 0.20
+
+    # ── call_ambulance ──���────────────────────────────────────────────────────
+    elif action_type == "call_ambulance":
+        if task["requires_ambulance"]:
+            return 0.50    # Correct emergency escalation
+        else:
+            return -0.30   # Unnecessary ambulance dispatch
+
+    # ── provide_temp_guidance ─────────────────────────────────────────────────
+    elif action_type == "provide_temp_guidance":
+        # Acceptable as a closing action for non-emergencies
+        if not task["requires_ambulance"]:
+            return 0.10
+        else:
+            return -0.10   # Not enough for a critical patient
+
+    # ── Unknown action ────────────────────────────────────────────────────────
+    return -0.10
+
+
+def grade_episode(
+    task: Dict[str, Any],
+    all_actions: List[str],
+    final_total_reward: float,
+) -> Dict[str, Any]:
+    """
+    Produce a final episode summary / score report.
+
+    Args:
+        task:               Task dict.
+        all_actions:        Full list of action keys taken during the episode.
+        final_total_reward: Accumulated clamped reward from the environment.
+
+    Returns:
+        A dict with score, pass/fail, and diagnostic breakdown.
+    """
+    score = round(final_total_reward, 4)
+    passed = score >= 0.5
+
+    breakdown = {
+        "severity_classified": any(
+            a.startswith(f"analyze_symptoms:{task['expected_severity']}")
+            for a in all_actions
+        ),
+        "correct_specialist": any(
+            a.startswith(f"recommend_specialist:{task['expected_specialist']}")
+            for a in all_actions
+        ),
+        "correct_hospital": any(
+            a.startswith(f"select_hospital:{task['expected_hospital']}")
+            for a in all_actions
+        ),
+        "ambulance_called": any(a.startswith("call_ambulance") for a in all_actions),
+        "appointment_booked": any(a.startswith("book_appointment") for a in all_actions),
+    }
+
+    return {
+        "score": score,
+        "passed": passed,
+        "difficulty": task["difficulty"],
+        "total_steps": len(all_actions),
+        "breakdown": breakdown,
+    }

inference.py

@@ -0,0 +1,326 @@
+"""
+inference.py — Baseline AI agent for MediRoute OpenEnv.
+
+Connects to any OpenAI-compatible endpoint (including Hugging Face TGI,
+vLLM, or the official OpenAI API) and runs the agent across all three
+difficulty tasks, printing structured logs.
+
+Environment variables (set before running):
+    OPENAI_API_KEY   – API key (use 'EMPTY' for local / HF endpoints)
+    API_BASE_URL     – Base URL, e.g. https://api-inference.huggingface.co/v1
+    MODEL_NAME       – Model identifier, e.g. mistralai/Mistral-7B-Instruct-v0.3
+    HF_TOKEN         – (Optional) Hugging Face token for gated models
+
+Usage:
+    python inference.py
+    python inference.py --difficulty easy
+    python inference.py --difficulty all
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import time
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+# OpenAI SDK is only required for the LLM agent mode.
+if TYPE_CHECKING:
+    from openai import OpenAI  # pragma: no cover
+else:
+    OpenAI = Any  # type: ignore[misc,assignment]
+
+from environment import MediRouteEnv
+from models import Action, VALID_ACTION_TYPES
+
+# ─────────────────────────────────────────────
+#  Configuration from environment variables
+# ─────────────────────────────────────────────
+
+API_KEY: str = os.getenv("OPENAI_API_KEY", "EMPTY")
+API_BASE_URL: str = os.getenv("API_BASE_URL", "https://api.openai.com/v1")
+MODEL_NAME: str = os.getenv("MODEL_NAME", "gpt-4o-mini")
+HF_TOKEN: str = os.getenv("HF_TOKEN", "")
+
+# If HF_TOKEN is set, prefer it as the API key for HF endpoints
+if HF_TOKEN and API_KEY == "EMPTY":
+    API_KEY = HF_TOKEN
+
+MAX_STEPS_PER_EPISODE: int = 8
+ALL_DIFFICULTIES: List[str] = ["easy", "medium", "hard"]
+
+
+# ─────────────────────────────────────────────
+#  Prompt engineering
+# ─────────────────────────────────────────────
+
+SYSTEM_PROMPT = """You are MediRoute, an AI medical triage and routing agent.
+Your goal is to help patients by:
+1. Analysing their symptoms and lab reports to determine severity.
+2. Recommending the correct medical specialist.
+3. Selecting the best nearby hospital.
+4. Booking appointments or dispatching ambulances as appropriate.
+
+You must respond with a single JSON object containing exactly two keys:
+  "action_type" : one of [analyze_symptoms, request_more_info, recommend_specialist,
+                           select_hospital, book_appointment, call_ambulance,
+                           provide_temp_guidance]
+  "target"      : a string value relevant to the action, or null
+
+Severity levels for analyze_symptoms: low | moderate | high | critical
+
+Rules:
+- For life-threatening emergencies (SpO₂ < 85 %, unconscious, etc.) → call_ambulance.
+- Do NOT book an appointment in a critical emergency.
+- Pick the FIRST hospital in the nearby_hospitals list as the best option.
+- Stop after taking a terminal action (book_appointment or call_ambulance).
+- Never repeat the same action twice.
+"""
+
+
+def build_user_message(obs, step: int) -> str:
+    return f"""Step {step} — Patient Status:
+
+Symptoms       : {obs.symptoms}
+Lab Results    : {json.dumps(obs.lab_report_summary, indent=2)}
+Severity Score : {obs.severity_score:.2f}
+Location       : {obs.location}
+Nearby Hospitals (in order of proximity/quality):
+  {chr(10).join(f'  {i+1}. {h}' for i, h in enumerate(obs.nearby_hospitals))}
+Available Specialists:
+  {chr(10).join(f'  - {s}' for s in obs.available_specialists)}
+Actions already taken: {obs.previous_actions or '(none)'}
+
+What is your next action? Respond ONLY with valid JSON.
+"""
+
+
+# ─────────────────────────────────────────────
+#  Agent loop
+# ─────────────────────────────────────────────
+
+def parse_action(response_text: str) -> Optional[Action]:
+    """Extract a valid Action from the model's raw JSON response."""
+    text = response_text.strip()
+
+    # Strip markdown code fences if present
+    if text.startswith("```"):
+        lines = text.splitlines()
+        text = "\n".join(lines[1:-1] if lines and lines[-1].strip() == "```" else lines[1:])
+
+    # Extract the first JSON object defensively (models sometimes add extra prose).
+    m = re.search(r"\{[\s\S]*\}", text)
+    if m:
+        text = m.group(0)
+
+    try:
+        data = json.loads(text)
+    except (json.JSONDecodeError, ValueError) as exc:
+        # Keep logs compatible with strict parsers: no free-form prefixes.
+        print(f"[STEP] event=parse_error detail={str(exc)[:120]!r}")
+        return None
+
+    action_type = str(data.get("action_type", "request_more_info")).strip()
+    target = data.get("target")
+    if action_type not in VALID_ACTION_TYPES:
+        return Action(action_type="request_more_info", target=None)
+    if target is not None and not isinstance(target, str):
+        # Keep schema strict: targets are strings or null.
+        target = str(target)
+    return Action(action_type=action_type, target=target)
+
+
+def rules_agent(obs) -> Action:
+    """
+    Deterministic baseline policy.
+    Designed to be fully offline and reproducible for judge evaluation.
+    """
+    labs = obs.lab_report_summary or {}
+    symptoms = (obs.symptoms or "").lower()
+
+    # 1) Emergency detection / severity inference
+    spo2_raw = str(labs.get("spo2", "")).lower()
+    gcs_raw = str(labs.get("consciousness", "")).lower()
+    emergency_signals = any(
+        s in spo2_raw for s in ["78", "79", "80", "81", "82", "83", "84"]
+    ) or ("unresponsive" in gcs_raw) or ("cyanotic" in symptoms) or ("collapse" in symptoms)
+
+    if not any(a.startswith("analyze_symptoms:") for a in obs.previous_actions):
+        if emergency_signals:
+            return Action(action_type="analyze_symptoms", target="critical")
+        # STEMI-ish signals
+        ecg = str(labs.get("ecg_finding", "")).lower()
+        troponin = str(labs.get("troponin_i", "")).lower()
+        if "st-segment elevation" in ecg or "elevated" in troponin:
+            return Action(action_type="analyze_symptoms", target="high")
+        # Default outpatient
+        return Action(action_type="analyze_symptoms", target="low")
+
+    # 2) Route to specialist
+    if not any(a.startswith("recommend_specialist:") for a in obs.previous_actions):
+        if emergency_signals:
+            return Action(action_type="recommend_specialist", target="Emergency Doctor")
+        # Cardiology cues
+        ecg = str(labs.get("ecg_finding", "")).lower()
+        troponin = str(labs.get("troponin_i", "")).lower()
+        if "st-segment elevation" in ecg or "elevated" in troponin:
+            return Action(action_type="recommend_specialist", target="Cardiologist")
+        return Action(action_type="recommend_specialist", target="General Physician")
+
+    # 3) Choose hospital (prefer first listed)
+    if not any(a.startswith("select_hospital:") for a in obs.previous_actions):
+        best = obs.nearby_hospitals[0] if obs.nearby_hospitals else "General Hospital"
+        return Action(action_type="select_hospital", target=best)
+
+    # 4) Close episode
+    if emergency_signals:
+        return Action(action_type="call_ambulance", target=None)
+    return Action(action_type="book_appointment", target=None)
+
+
+def run_episode(client: Optional[OpenAI], difficulty: str, agent: str) -> Dict[str, Any]:
+    """Run a complete episode for the given difficulty and return the summary."""
+    env = MediRouteEnv()
+    obs = env.reset(difficulty=difficulty)
+    conversation: List[Dict[str, str]] = []
+    step = 0
+    episode_start = time.time()
+
+    print(f"[START] difficulty={difficulty.upper()} agent={agent} symptoms={obs.symptoms!r}")
+
+    while step < MAX_STEPS_PER_EPISODE:
+        step += 1
+        if agent == "rules":
+            action = rules_agent(obs)
+        else:
+            user_msg = build_user_message(obs, step)
+            conversation.append({"role": "user", "content": user_msg})
+
+            # ── Call the model ────────────────────────────────────────────────
+            assistant_text = ""
+            for attempt in range(2):
+                try:
+                    if client is None:
+                        raise RuntimeError("OpenAI client not initialized.")
+                    response = client.chat.completions.create(
+                        model=MODEL_NAME,
+                        messages=[{"role": "system", "content": SYSTEM_PROMPT}] + conversation,
+                        temperature=0.0,   # deterministic (to the extent the backend supports it)
+                        max_tokens=256,
+                    )
+                    assistant_text = response.choices[0].message.content or ""
+                except Exception as exc:
+                    print(f"[STEP] step={step} event=llm_error detail={str(exc)[:160]!r}")
+                    assistant_text = ""
+                    break
+
+                action = parse_action(assistant_text)
+                if action is not None:
+                    break
+
+                # One corrective retry: ask for strict JSON only.
+                conversation.append({"role": "assistant", "content": assistant_text})
+                conversation.append(
+                    {
+                        "role": "user",
+                        "content": "Your last response was invalid. Respond with ONLY a JSON object with keys action_type and target.",
+                    }
+                )
+
+            if assistant_text:
+                conversation.append({"role": "assistant", "content": assistant_text})
+
+            if action is None:
+                action = Action(action_type="request_more_info", target=None)
+
+        # ── Step environment ──────────────────────────────────────────────────
+        result = env.step(action)
+
+        reward_sign = "+" if result.reward >= 0 else ""
+        print(
+            f"[STEP {step}] action={action.action_type}  "
+            f"target={action.target!r}  "
+            f"reward={reward_sign}{result.reward:.2f}  "
+            f"total={result.info.get('total_reward', 0):.2f}  "
+            f"done={result.done}"
+        )
+
+        obs = result.observation
+
+        if result.done:
+            break
+
+    elapsed = time.time() - episode_start
+    summary = env.state().previous_actions  # all actions taken
+
+    final_info = result.info if step > 0 else {}
+    episode_summary = final_info.get("episode_summary", {})
+    total_reward = final_info.get("total_reward", 0.0)
+
+    print(f"[END] difficulty={difficulty.upper()} agent={agent}  "
+          f"score={total_reward:.4f}  "
+          f"passed={episode_summary.get('passed', False)}  "
+          f"steps={step}  "
+          f"elapsed={elapsed:.1f}s "
+          f"breakdown={json.dumps(episode_summary.get('breakdown', {}))}")
+
+    return {
+        "difficulty": difficulty,
+        "score": total_reward,
+        "passed": episode_summary.get("passed", False),
+        "steps": step,
+        "elapsed_seconds": round(elapsed, 2),
+        "breakdown": episode_summary.get("breakdown", {}),
+    }
+
+
+# ─────────────────────────────────────────────
+#  Main
+# ─────────────────────────────────────────────
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="MediRoute OpenEnv — Baseline Inference")
+    parser.add_argument(
+        "--difficulty",
+        choices=["easy", "medium", "hard", "all"],
+        default="all",
+        help="Which task(s) to run (default: all)",
+    )
+    parser.add_argument(
+        "--agent",
+        choices=["llm", "rules"],
+        default="llm",
+        help="Agent policy: llm (OpenAI-compatible) or rules (offline deterministic baseline).",
+    )
+    args = parser.parse_args()
+
+    # Keep output machine-parseable: rely on [START]/[STEP]/[END] markers.
+
+    client: Optional[OpenAI] = None
+    if args.agent == "llm":
+        try:
+            from openai import OpenAI as OpenAIClient  # type: ignore
+        except ImportError:
+            print("[ERROR] openai package not found. Install it or run with: --agent rules")
+            sys.exit(1)
+        client = OpenAIClient(api_key=API_KEY, base_url=API_BASE_URL)
+
+    difficulties = ALL_DIFFICULTIES if args.difficulty == "all" else [args.difficulty]
+    results = []
+
+    for diff in difficulties:
+        result = run_episode(client, diff, agent=args.agent)
+        results.append(result)
+
+    # ── Final leaderboard ─────────────────────────────────────────────────────
+    avg_score = sum(r["score"] for r in results) / len(results)
+
+    # Emit one final [END] summary line for strict log parsers.
+    print(f"[END] summary average_score={avg_score:.4f} results={json.dumps(results)}")
+
+
+if __name__ == "__main__":
+    main()

lifeline-ai/.gitignore

@@ -0,0 +1,41 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts

lifeline-ai/AGENTS.md

@@ -0,0 +1,5 @@
+<!-- BEGIN:nextjs-agent-rules -->
+# This is NOT the Next.js you know
+
+This version has breaking changes — APIs, conventions, and file structure may all differ from your training data. Read the relevant guide in `node_modules/next/dist/docs/` before writing any code. Heed deprecation notices.
+<!-- END:nextjs-agent-rules -->

lifeline-ai/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

lifeline-ai/README.md

@@ -0,0 +1,129 @@
+# LifeLine AI (Phase 2 MVP)
+
+**LifeLine AI** is a production-style full-stack healthcare emergency assistance demo:
+- symptom intake + report upload
+- AI-assisted triage (possible/likely wording; not a diagnosis)
+- nearby hospital finder (cards + demo map pins)
+- appointment booking flow + confirmation modal
+- a visually prominent **SOS button** (ambulance dispatch simulation with ETA + tracking code)
+
+This folder is the Phase 2 MVP website built after the MediRoute OpenEnv simulation.
+
+---
+
+## What We Built
+
+- **OpenEnv environment** from Phase 1 (`MediRouteEnv`) with deterministic grading.
+- **3 graded tasks** (easy / medium / hard) for healthcare routing and escalation.
+- **PyTorch clinical reasoning layer** in `backend/app/hf_torch.py`.
+- **Hugging Face transformer inference** for symptom-to-department and urgency scoring.
+- **Hospital ranking engine** (best rated / closest / fastest route) with realistic cards.
+- **Emergency SOS workflow** with dispatch simulation, live ETA, and status progression.
+
+---
+
+## Tech stack
+
+- **Frontend**: Next.js (App Router) + React + TypeScript + Tailwind CSS
+- **Backend**: FastAPI + Pydantic
+- **AI**:
+  - Hugging Face Transformers pipeline (`facebook/bart-large-mnli`) via **PyTorch**
+  - OpenAI-compatible fallback path
+  - deterministic heuristic fallback for offline demos
+- **Data**: mock hospital dataset (`backend/data/hospitals.json`)
+
+---
+
+## Run locally (recommended)
+
+### 1) Backend API
+
+```bash
+cd lifeline-ai/backend
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+./run.sh
+```
+
+Backend runs at `http://localhost:8000`.
+
+Optional (LLM mode):
+
+```bash
+export OPENAI_API_KEY="..."
+export API_BASE_URL="https://api.openai.com/v1"
+export MODEL_NAME="gpt-4o-mini"
+```
+
+If `OPENAI_API_KEY` is **not** set, the backend uses **deterministic demo triage**.
+
+### 2) Frontend web app
+
+In a second terminal:
+
+```bash
+cd lifeline-ai
+npm install
+npm run dev
+```
+
+Open `http://localhost:3000`.
+
+---
+
+## Demo flow
+
+1. On the landing page (`/`), use a demo preset (cardiac / fever / collapse) or type symptoms manually.
+2. Submit → results page (`/results`) with:
+   - possible condition
+   - urgency level
+   - recommended department
+   - temporary precautions
+   - recommended next step
+3. Explore hospitals (`/hospitals`) with sorting:
+   - best rated
+   - closest
+   - fastest route
+   + a demo map with pins
+4. Book an appointment (`/book`) and view a confirmation modal.
+5. Hit the **SOS** button (bottom-right) anytime for ambulance dispatch simulation.
+
+---
+
+## Configuration
+
+Frontend:
+- `NEXT_PUBLIC_API_BASE` (default `http://localhost:8000`)
+
+Backend:
+- `USE_HF_LOCAL` (default `1`, enables local Hugging Face + PyTorch inference path)
+- `OPENAI_API_KEY` (enables LLM mode)
+- `API_BASE_URL` (OpenAI-compatible base URL)
+- `MODEL_NAME` (model id)
+
+---
+
+## Sponsor-aligned architecture
+
+- `backend/app/hf_torch.py`:
+  - loads a Hugging Face transformer pipeline with `framework="pt"`
+  - performs symptom classification into department labels
+  - performs urgency scoring into low/medium/high/emergency
+  - returns confidence score and model metadata for UI display
+- `backend/app/ai.py`:
+  - first tries Hugging Face + PyTorch path
+  - falls back to OpenAI-compatible model
+  - then deterministic heuristic fallback
+- `src/app/results/page.tsx`:
+  - displays provider/model/confidence as a visible judge-facing proof point
+  - includes live confidence progress UI while inference is running
+
+---
+
+## Sponsor-friendly pitch lines
+
+- **Hugging Face**: "We run transformer-based triage classification using a Hugging Face pipeline to map symptom narratives into urgency and department recommendations."
+- **PyTorch**: "Our inference path is explicitly PyTorch-backed (`framework='pt'`), giving us transparent, production-style model loading and confidence scoring."
+- **Why this matters**: "This combines interpretable clinical routing with real-time emergency UX, making AI assistance actionable in under two minutes during a crisis demo."
+

lifeline-ai/backend/app/ai.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import os
+import re
+from typing import Optional
+
+import httpx
+
+from .hf_torch import classify_with_hf_pytorch
+from .models import AnalyzeRequest, AnalyzeResponse
+
+# Optional local embedding resources (cached)
+_emb_model = None
+_emb_documents = None
+_emb_doc_embeddings = None
+
+DISCLAIMER = (
+    "This is an AI-assisted triage suggestion, not a medical diagnosis. "
+    "If symptoms are severe or worsening, seek in-person medical care immediately."
+)
+
+
+def _heuristic_triage(req: AnalyzeRequest) -> AnalyzeResponse:
+    s = req.symptoms.lower()
+
+    emergency_signals = any(
+        kw in s
+        for kw in [
+            "unresponsive",
+            "faint",
+            "collapsed",
+            "blue lips",
+            "cyanotic",
+            "severe bleeding",
+            "cannot breathe",
+            "no breathing",
+            "seizure",
+        ]
+    )
+    cardiac_signals = any(
+        kw in s
+        for kw in [
+            "chest pain",
+            "shortness of breath",
+            "pain radiating",
+            "left arm",
+            "tightness",
+            "pressure in chest",
+        ]
+    )
+    infection_signals = any(kw in s for kw in ["fever", "sore throat", "cough", "chills"])
+
+    if emergency_signals:
+        return AnalyzeResponse(
+            possible_condition="Possible emergency event (airway/breathing/circulation concern)",
+            urgency="emergency",
+            recommended_department="Emergency",
+            temporary_precautions=[
+                "Call local emergency services immediately.",
+                "If trained, start basic life support and keep the airway open.",
+                "Do not give food or drink if the person is unconscious.",
+            ],
+            recommended_next_step="Use SOS to request an ambulance now. Go to the nearest emergency-capable hospital.",
+            disclaimer=DISCLAIMER,
+            confidence_note="Heuristic demo mode (offline).",
+            confidence_score=0.72,
+            model_provider="heuristic",
+            model_name="rules-v1",
+        )
+
+    if cardiac_signals:
+        return AnalyzeResponse(
+            possible_condition="Possible cardiac concern",
+            urgency="high",
+            recommended_department="Cardiology",
+            temporary_precautions=[
+                "Stop exertion and sit upright.",
+                "If symptoms worsen, do not drive yourself—use ambulance support.",
+                "If prescribed by a clinician previously, follow your emergency plan.",
+            ],
+            recommended_next_step="Visit the nearest hospital within 30 minutes; prefer a cardiac-capable center.",
+            disclaimer=DISCLAIMER,
+            confidence_note="Heuristic demo mode (offline).",
+            confidence_score=0.76,
+            model_provider="heuristic",
+            model_name="rules-v1",
+        )
+
+    if infection_signals:
+        return AnalyzeResponse(
+            possible_condition="Possible infection / flu-like illness",
+            urgency="medium",
+            recommended_department="General Medicine",
+            temporary_precautions=[
+                "Hydrate and rest.",
+                "Monitor temperature and breathing.",
+                "Seek urgent care if severe shortness of breath, confusion, or persistent high fever occurs.",
+            ],
+            recommended_next_step="Book an appointment with a general physician within 24–48 hours.",
+            disclaimer=DISCLAIMER,
+            confidence_note="Heuristic demo mode (offline).",
+            confidence_score=0.68,
+            model_provider="heuristic",
+            model_name="rules-v1",
+        )
+
+    return AnalyzeResponse(
+        possible_condition="Possible non-specific concern",
+        urgency="low",
+        recommended_department="General Medicine",
+        temporary_precautions=[
+            "Monitor symptoms and avoid triggers.",
+            "Write down symptom timeline and any medications taken.",
+        ],
+        recommended_next_step="If symptoms persist, book a routine appointment.",
+        disclaimer=DISCLAIMER,
+        confidence_note="Heuristic demo mode (offline).",
+        confidence_score=0.55,
+        model_provider="heuristic",
+        model_name="rules-v1",
+    )
+
+
+def _hf_pytorch_triage(req: AnalyzeRequest) -> Optional[AnalyzeResponse]:
+    """
+    Sponsor-facing inference path:
+    Uses a Hugging Face transformer pipeline running on PyTorch.
+    Returns None on any runtime/dependency issue to preserve resilient fallback.
+    """
+    try:
+        pred = classify_with_hf_pytorch(req.symptoms)
+    except Exception:
+        return None
+
+    dept = pred.department
+    urgency = pred.urgency
+
+    if urgency == "emergency":
+        possible = "Possible life-threatening emergency"
+        next_step = "Use SOS now and proceed to the nearest emergency-capable hospital."
+        precautions = [
+            "Call emergency services immediately.",
+            "Keep the patient still and monitor breathing.",
+            "Do not delay for non-essential procedures.",
+        ]
+    elif urgency == "high":
+        possible = "Possible acute clinical concern requiring urgent care"
+        next_step = "Visit a hospital within 30 minutes; prioritize facilities with critical care support."
+        precautions = [
+            "Avoid physical exertion.",
+            "Keep communication available and avoid driving alone if worsening.",
+            "Prepare prior records/medication list for triage.",
+        ]
+    elif urgency == "medium":
+        possible = "Possible moderate clinical issue"
+        next_step = "Book an appointment soon and monitor changes over the next 24 hours."
+        precautions = [
+            "Hydrate and rest.",
+            "Track symptom progression.",
+            "Escalate to urgent care if worsening rapidly.",
+        ]
+    else:
+        possible = "Possible mild clinical issue"
+        next_step = "Monitor symptoms and schedule a routine consultation if persistent."
+        precautions = [
+            "Continue observation and rest.",
+            "Record onset, triggers, and duration of symptoms.",
+        ]
+
+    return AnalyzeResponse(
+        possible_condition=possible,
+        urgency=urgency,  # type: ignore[arg-type]
+        recommended_department=dept,
+        temporary_precautions=precautions,
+        recommended_next_step=next_step,
+        disclaimer=DISCLAIMER,
+        confidence_note=f"Hugging Face transformer inference via PyTorch ({pred.model_name}).",
+        confidence_score=pred.confidence,
+        model_provider=pred.provider,
+        model_name=pred.model_name,
+    )
+
+
+def _local_embeddings_triage(req: AnalyzeRequest) -> Optional[AnalyzeResponse]:
+    """
+    Use a local sentence-transformers model to find the closest matching
+    condition from a small medical dataset (`medical_data.json`) located
+    at the repository root (meta/medical_data.json). This is a best-effort
+    offline fallback and returns None on any error to preserve existing
+    fallback behavior.
+    """
+    global _emb_model, _emb_documents, _emb_doc_embeddings
+    try:
+        from sentence_transformers import SentenceTransformer, util
+        import json
+        import os
+    except Exception:
+        return None
+
+    try:
+        # Lazy-load model and document embeddings to avoid repeated expensive work
+        if _emb_model is None:
+            model_name = os.getenv("EMBEDDING_MODEL", "sentence-transformers/embeddinggemma-300m-medical")
+            _emb_model = SentenceTransformer(model_name)
+
+        if _emb_documents is None or _emb_doc_embeddings is None:
+            # medical_data.json is located at repo root
+            repo_root = os.path.normpath(os.path.join(os.path.dirname(__file__), "..", "..", ".."))
+            data_path = os.path.join(repo_root, "medical_data.json")
+            if not os.path.exists(data_path):
+                return None
+            with open(data_path, "r") as fh:
+                medical_data = json.load(fh)
+
+            # Build searchable text in the same format as test.py
+            documents = [
+                f"{item['condition']}. Symptoms: {item['symptoms']}. Causes: {item['causes']}. Precautions: {item['precautions']}. Doctor advice: {item['see_doctor']}"
+                for item in medical_data
+            ]
+
+            if not documents:
+                return None
+
+            _emb_documents = medical_data
+            _emb_doc_embeddings = _emb_model.encode(documents, convert_to_tensor=True)
+    except Exception:
+        return None
+
+    try:
+        # Encode query and compute similarity
+        query_embedding = _emb_model.encode(req.symptoms, convert_to_tensor=True)
+        scores = util.cos_sim(query_embedding, _emb_doc_embeddings)[0]
+        best_idx = int(scores.argmax().item())
+        best_score = float(scores[best_idx].item())
+        best_match = _emb_documents[best_idx]
+    except Exception:
+        return None
+
+    # Build a conservative AnalyzeResponse from the matched document
+    possible = best_match.get("condition", "Possible concern")
+    precautions = best_match.get("precautions", []) or []
+    next_step = best_match.get("see_doctor", "Follow up with a clinician if concerned.")
+
+    return AnalyzeResponse(
+        possible_condition=str(possible),
+        urgency=str(best_match.get("urgency", "low")),
+        recommended_department=str(best_match.get("department", "General Medicine")),
+        temporary_precautions=[str(x) for x in precautions][:6],
+        recommended_next_step=str(next_step),
+        disclaimer=DISCLAIMER,
+        confidence_note="Local embeddings-based match",
+        confidence_score=min(max(best_score, 0.0), 1.0),
+        model_provider="local-embeddings",
+        model_name=os.getenv("EMBEDDING_MODEL", "sentence-transformers/embeddinggemma-300m-medical"),
+    )
+
+
+async def analyze(req: AnalyzeRequest) -> AnalyzeResponse:
+    """
+    AI abstraction layer:
+    - If LLM env vars are set, call an OpenAI-compatible endpoint.
+    - Otherwise fall back to deterministic heuristic triage (demo mode).
+    """
+    # 1) Hugging Face + PyTorch local pipeline (preferred sponsor path)
+    if os.getenv("USE_HF_LOCAL", "1").strip() not in {"0", "false", "False"}:
+        hf_result = _hf_pytorch_triage(req)
+        if hf_result is not None:
+            return hf_result
+
+    api_key = os.getenv("OPENAI_API_KEY", "").strip()
+    base_url = os.getenv("API_BASE_URL", "https://api.openai.com/v1").strip()
+    model = os.getenv("MODEL_NAME", "gpt-4o-mini").strip()
+
+    if not api_key:
+        # Try a local embeddings-based match before falling back to heuristics.
+        if os.getenv("USE_LOCAL_EMBEDDINGS", "1").strip() not in {"0", "false", "False"}:
+            emb = _local_embeddings_triage(req)
+            if emb is not None:
+                return emb
+
+        return _heuristic_triage(req)
+
+    system = (
+        "You are LifeLine AI, a healthcare triage assistant. "
+        "You must not provide a diagnosis. Use 'possible'/'likely' wording. "
+        "Return STRICT JSON with keys: possible_condition, urgency, recommended_department, "
+        "temporary_precautions (array of strings), recommended_next_step, confidence_note. "
+        "Urgency must be one of: low, medium, high, emergency."
+    )
+    user = (
+        f"Symptoms: {req.symptoms}\n"
+        f"Location: {req.location}\n"
+        f"Uploaded files: {req.uploaded_files}\n"
+        "Respond with JSON only."
+    )
+
+    payload = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": system},
+            {"role": "user", "content": user},
+        ],
+        "temperature": 0.0,
+        "max_tokens": 300,
+    }
+
+    url = base_url.rstrip("/") + "/chat/completions"
+    headers = {"Authorization": f"Bearer {api_key}"}
+
+    async with httpx.AsyncClient(timeout=25.0) as client:
+        r = await client.post(url, json=payload, headers=headers)
+        r.raise_for_status()
+        data = r.json()
+        text = (data["choices"][0]["message"]["content"] or "").strip()
+
+    # Extract JSON object defensively
+    m = re.search(r"\{[\s\S]*\}", text)
+    if not m:
+        return _heuristic_triage(req)
+    import json
+
+    try:
+        obj = json.loads(m.group(0))
+    except Exception:
+        return _heuristic_triage(req)
+
+    urgency = obj.get("urgency", "medium")
+    if urgency not in {"low", "medium", "high", "emergency"}:
+        urgency = "medium"
+
+    tp = obj.get("temporary_precautions", [])
+    if not isinstance(tp, list):
+        tp = [str(tp)]
+
+    return AnalyzeResponse(
+        possible_condition=str(obj.get("possible_condition", "Possible concern")),
+        urgency=urgency,  # type: ignore[arg-type]
+        recommended_department=str(obj.get("recommended_department", "General Medicine")),
+        temporary_precautions=[str(x) for x in tp][:6],
+        recommended_next_step=str(obj.get("recommended_next_step", "Consider in-person care if symptoms worsen.")),
+        disclaimer=DISCLAIMER,
+        confidence_note=str(obj.get("confidence_note", "LLM mode")),
+        confidence_score=float(obj.get("confidence_score", 0.7)),
+        model_provider="openai-compatible",
+        model_name=model,
+    )
+

lifeline-ai/backend/app/hf_torch.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import List
+
+
+@dataclass
+class HFResult:
+    department: str
+    urgency: str
+    confidence: float
+    provider: str
+    model_name: str
+    framework: str
+
+
+DEPARTMENT_LABELS: List[str] = [
+    "Cardiology",
+    "Emergency",
+    "General Medicine",
+    "Pulmonology",
+    "Neurology",
+]
+
+URGENCY_LABELS: List[str] = ["low", "medium", "high", "emergency"]
+
+
+@lru_cache(maxsize=1)
+def _load_zero_shot_pipeline():
+    """
+    Load Hugging Face transformer pipeline on PyTorch backend.
+    This is intentionally isolated so fallback mode still works if deps are absent.
+    """
+    from transformers import pipeline
+
+    # framework='pt' makes the PyTorch path explicit for judges/sponsors.
+    return pipeline(
+        task="zero-shot-classification",
+        model="facebook/bart-large-mnli",
+        framework="pt",
+    )
+
+
+def classify_with_hf_pytorch(symptoms: str) -> HFResult:
+    pipe = _load_zero_shot_pipeline()
+
+    dep_pred = pipe(symptoms, candidate_labels=DEPARTMENT_LABELS, multi_label=False)
+    urg_pred = pipe(symptoms, candidate_labels=URGENCY_LABELS, multi_label=False)
+
+    dep_label = str(dep_pred["labels"][0])
+    dep_score = float(dep_pred["scores"][0])
+    urg_label = str(urg_pred["labels"][0]).lower()
+    urg_score = float(urg_pred["scores"][0])
+
+    # Conservative combined confidence
+    confidence = max(0.0, min(1.0, (dep_score * 0.55) + (urg_score * 0.45)))
+
+    return HFResult(
+        department=dep_label,
+        urgency=urg_label if urg_label in URGENCY_LABELS else "medium",
+        confidence=confidence,
+        provider="huggingface",
+        model_name="facebook/bart-large-mnli",
+        framework="pytorch",
+    )
+

lifeline-ai/backend/app/main.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from typing import List, Literal, Optional
+import os
+import httpx
+
+from fastapi import FastAPI, File, Form, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+
+from .ai import analyze as ai_analyze
+from .models import (
+    AnalyzeRequest,
+    AnalyzeResponse,
+    AppointmentCreateRequest,
+    AppointmentCreateResponse,
+    HospitalsResponse,
+    SosRequest,
+    SosResponse,
+)
+from .store import DB, compute_demo_eta_seconds, generate_sos_tracking_code, sort_hospitals, hospitals_for_location
+
+
+app = FastAPI(title="LifeLine AI API", version="1.0.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=False,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/health")
+def health() -> dict:
+    return {"status": "ok"}
+
+
+@app.post("/upload")
+async def upload_files(files: List[UploadFile] = File(default=[])) -> dict:
+    """
+    Demo-safe upload endpoint:
+    - accepts PDFs/images/prescriptions
+    - does not persist to disk by default (to keep MVP simple)
+    - returns filenames so the analyze endpoint can reference them
+    """
+    names = []
+    for f in files:
+        # Read a small amount to validate stream; don't store.
+        _ = await f.read(1024)
+        names.append(f.filename or "upload")
+    return {"uploaded_files": names}
+
+
+@app.post("/analyze", response_model=AnalyzeResponse)
+async def analyze(symptoms: str = Form(...), location: str = Form(...), uploaded_files: str = Form("[]")) -> AnalyzeResponse:
+    """
+    Triage analysis endpoint.
+    Uses an AI abstraction layer:
+    - LLM mode if env vars set (OPENAI_API_KEY + optional API_BASE_URL/MODEL_NAME)
+    - otherwise deterministic heuristic mode for instant demos
+    """
+    import json
+
+    try:
+        files = json.loads(uploaded_files)
+        if not isinstance(files, list):
+            files = []
+    except Exception:
+        files = []
+
+    req = AnalyzeRequest(symptoms=symptoms, location=location, uploaded_files=[str(x) for x in files][:10])
+    return await ai_analyze(req)
+
+
+@app.get("/hospitals", response_model=HospitalsResponse)
+def hospitals(
+    location: str,
+    sort: Literal["best_rated", "closest", "fastest_route"] = "closest",
+    lat: Optional[float] = None,
+    lng: Optional[float] = None,
+) -> HospitalsResponse:
+    # If client provides coordinates, adjust distances/etas based on that location
+    if lat is not None and lng is not None:
+        hs = sort_hospitals(hospitals_for_location(DB.hospitals, lat, lng), sort)
+    else:
+        hs = sort_hospitals(DB.hospitals, sort)
+    return HospitalsResponse(location=location, sort=sort, hospitals=hs)
+
+
+@app.post("/appointments", response_model=AppointmentCreateResponse)
+def create_appointment(req: AppointmentCreateRequest) -> AppointmentCreateResponse:
+    appt = DB.create_appointment(req)
+    return AppointmentCreateResponse(appointment=appt)
+
+
+@app.get("/appointments")
+def list_appointments() -> dict:
+    return {"appointments": [a.model_dump() for a in DB.list_appointments()]}
+
+
+@app.post("/sos", response_model=SosResponse)
+def sos(req: SosRequest) -> SosResponse:
+    # Always pick the closest hospital for SOS demo.
+    hs = sort_hospitals(DB.hospitals, "fastest_route")
+    nearest = hs[0]
+    eta_seconds = compute_demo_eta_seconds(nearest)
+    return SosResponse(
+        nearest_hospital=nearest,
+        eta_seconds=eta_seconds,
+        tracking_code=generate_sos_tracking_code(),
+        message="Ambulance dispatched. Stay calm—help is on the way.",
+        meta={"location": req.location, "symptoms": req.symptoms or ""},
+    )
+
+
+@app.get("/reverse-geocode")
+def reverse_geocode(lat: float, lng: float) -> dict:
+    """
+    Server-side reverse geocoding endpoint.
+    Uses provider configured by GEOCODER_PROVIDER (default: nominatim).
+    Returns JSON: { display_name, lat, lng } or raises HTTPException on error.
+    """
+    provider = os.getenv("GEOCODER_PROVIDER", "nominatim")
+    try:
+        if provider == "nominatim":
+            url = f"https://nominatim.openstreetmap.org/reverse?format=jsonv2&lat={lat}&lon={lng}"
+            headers = {"User-Agent": "LifeLineAI-Demo/1.0"}
+            r = httpx.get(url, headers=headers, timeout=10.0)
+            r.raise_for_status()
+            data = r.json()
+            return {"display_name": data.get("display_name", ""), "lat": lat, "lng": lng}
+        else:
+            # Unsupported provider configured
+            from fastapi import HTTPException
+
+            raise HTTPException(status_code=501, detail=f"Geocoder provider '{provider}' not implemented")
+    except Exception as e:
+        from fastapi import HTTPException
+
+        raise HTTPException(status_code=502, detail=f"Reverse geocode failed: {e}")
+

lifeline-ai/backend/app/models.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import BaseModel, Field
+
+
+UrgencyLevel = Literal["low", "medium", "high", "emergency"]
+
+
+class AnalyzeRequest(BaseModel):
+    symptoms: str = Field(..., min_length=3, max_length=4000)
+    location: str = Field(..., min_length=2, max_length=200)
+    # Filenames only; actual file bytes are uploaded separately.
+    uploaded_files: List[str] = Field(default_factory=list)
+
+
+class AnalyzeResponse(BaseModel):
+    possible_condition: str
+    urgency: UrgencyLevel
+    recommended_department: str
+    temporary_precautions: List[str]
+    recommended_next_step: str
+    disclaimer: str
+    confidence_note: str
+    confidence_score: float = Field(..., ge=0.0, le=1.0)
+    model_provider: str = "heuristic"
+    model_name: str = "rule-based"
+
+
+class Hospital(BaseModel):
+    id: str
+    name: str
+    distance_km: float = Field(..., ge=0.0)
+    eta_minutes: int = Field(..., ge=1, le=180)
+    rating: float = Field(..., ge=0.0, le=5.0)
+    specialties: List[str] = Field(default_factory=list)
+    availability: Literal["open", "limited", "busy"] = "open"
+    address: str
+    phone: str
+    lat: float
+    lng: float
+
+
+class HospitalsResponse(BaseModel):
+    location: str
+    sort: Literal["best_rated", "closest", "fastest_route"] = "closest"
+    hospitals: List[Hospital]
+
+
+class AppointmentCreateRequest(BaseModel):
+    hospital_id: str
+    department: str
+    doctor: str
+    time_slot: str
+    patient_name: str = Field(..., min_length=2, max_length=120)
+    patient_phone: str = Field(..., min_length=6, max_length=40)
+
+
+class Appointment(BaseModel):
+    id: str
+    hospital_id: str
+    hospital_name: str
+    department: str
+    doctor: str
+    time_slot: str
+    patient_name: str
+    patient_phone: str
+    status: Literal["confirmed", "cancelled"] = "confirmed"
+    created_at_iso: str
+
+
+class AppointmentCreateResponse(BaseModel):
+    appointment: Appointment
+
+
+class SosRequest(BaseModel):
+    location: str
+    symptoms: Optional[str] = None
+
+
+class SosResponse(BaseModel):
+    status: Literal["ambulance_dispatched"] = "ambulance_dispatched"
+    nearest_hospital: Hospital
+    eta_seconds: int = Field(..., ge=30, le=3600)
+    tracking_code: str
+    message: str
+    meta: Dict[str, Any] = Field(default_factory=dict)
+

lifeline-ai/backend/app/store.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import json
+import os
+import time
+import uuid
+from datetime import datetime, timezone
+from typing import Dict, List, Literal, Optional
+
+from .models import Appointment, AppointmentCreateRequest, Hospital
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def load_hospitals() -> List[Hospital]:
+    base = os.path.dirname(os.path.dirname(__file__))
+    path = os.path.join(base, "data", "hospitals.json")
+    with open(path, "r", encoding="utf-8") as f:
+        raw = json.load(f)
+    return [Hospital(**h) for h in raw]
+
+
+def sort_hospitals(hospitals: List[Hospital], sort: Literal["best_rated", "closest", "fastest_route"]) -> List[Hospital]:
+    if sort == "best_rated":
+        return sorted(hospitals, key=lambda h: (-h.rating, h.eta_minutes, h.distance_km))
+    if sort == "fastest_route":
+        return sorted(hospitals, key=lambda h: (h.eta_minutes, h.distance_km, -h.rating))
+    return sorted(hospitals, key=lambda h: (h.distance_km, h.eta_minutes, -h.rating))
+
+
+def _haversine_km(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """Return the great-circle distance between two points in kilometers."""
+    from math import radians, sin, cos, asin, sqrt
+
+    lat1, lon1, lat2, lon2 = map(radians, (lat1, lon1, lat2, lon2))
+    dlat = lat2 - lat1
+    dlon = lon2 - lon1
+    a = sin(dlat / 2) ** 2 + cos(lat1) * cos(lat2) * sin(dlon / 2) ** 2
+    c = 2 * asin(sqrt(a))
+    return 6371.0 * c
+
+
+def hospitals_for_location(hospitals: List[Hospital], lat: float, lng: float) -> List[Hospital]:
+    """
+    Return a new list of Hospital objects with distance_km and eta_minutes adjusted
+    according to the provided lat/lng (user location). This is used for demo proximity
+    sorting when the client provides coordinates.
+    """
+    new: List[Hospital] = []
+    for h in hospitals:
+        dist = _haversine_km(lat, lng, h.lat, h.lng)
+        # Estimate ETA: assume average driving speed ~40 km/h -> minutes = dist/40*60 = dist*1.5
+        eta = max(3, int(round(dist * 1.5)))
+        # Create a shallow copy with updated fields
+        nh = Hospital(**{**h.model_dump(), "distance_km": round(dist, 2), "eta_minutes": eta})
+        new.append(nh)
+    return new
+
+
+class InMemoryDB:
+    def __init__(self) -> None:
+        self._appointments: Dict[str, Appointment] = {}
+        self._hospitals = load_hospitals()
+
+    @property
+    def hospitals(self) -> List[Hospital]:
+        return self._hospitals
+
+    def get_hospital(self, hospital_id: str) -> Optional[Hospital]:
+        for h in self._hospitals:
+            if h.id == hospital_id:
+                return h
+        return None
+
+    def create_appointment(self, req: AppointmentCreateRequest) -> Appointment:
+        hosp = self.get_hospital(req.hospital_id)
+        hospital_name = hosp.name if hosp else "Unknown Hospital"
+        appt = Appointment(
+            id="appt_" + uuid.uuid4().hex[:12],
+            hospital_id=req.hospital_id,
+            hospital_name=hospital_name,
+            department=req.department,
+            doctor=req.doctor,
+            time_slot=req.time_slot,
+            patient_name=req.patient_name,
+            patient_phone=req.patient_phone,
+            status="confirmed",
+            created_at_iso=_now_iso(),
+        )
+        self._appointments[appt.id] = appt
+        return appt
+
+    def list_appointments(self) -> List[Appointment]:
+        return sorted(self._appointments.values(), key=lambda a: a.created_at_iso, reverse=True)
+
+
+DB = InMemoryDB()
+
+
+def generate_sos_tracking_code() -> str:
+    return "SOS-" + uuid.uuid4().hex[:8].upper()
+
+
+def compute_demo_eta_seconds(hospital: Hospital) -> int:
+    # Convert minutes to seconds with a small deterministic variation.
+    jitter = int((hospital.distance_km * 7) % 20)
+    return max(60, hospital.eta_minutes * 60 + jitter)
+

lifeline-ai/backend/data/hospitals.json

@@ -0,0 +1,68 @@
+[
+  {
+    "id": "hosp_city_clinic",
+    "name": "City Clinic",
+    "distance_km": 2.4,
+    "eta_minutes": 9,
+    "rating": 4.6,
+    "specialties": ["General Medicine", "ENT", "Pediatrics"],
+    "availability": "open",
+    "address": "12 Market St, Downtown",
+    "phone": "+1-555-0101",
+    "lat": 12.9721,
+    "lng": 77.5933
+  },
+  {
+    "id": "hosp_downtown_med",
+    "name": "Downtown Medical Center",
+    "distance_km": 3.1,
+    "eta_minutes": 11,
+    "rating": 4.2,
+    "specialties": ["General Medicine", "Diagnostics", "Orthopedics"],
+    "availability": "limited",
+    "address": "88 River Rd, Downtown",
+    "phone": "+1-555-0102",
+    "lat": 12.9699,
+    "lng": 77.5965
+  },
+  {
+    "id": "hosp_westside_heart",
+    "name": "Westside Heart Center",
+    "distance_km": 6.8,
+    "eta_minutes": 18,
+    "rating": 4.8,
+    "specialties": ["Cardiology", "Cath Lab", "ICU"],
+    "availability": "busy",
+    "address": "5 Sunset Ave, Westside",
+    "phone": "+1-555-0201",
+    "lat": 12.9657,
+    "lng": 77.5852
+  },
+  {
+    "id": "hosp_general",
+    "name": "General Hospital",
+    "distance_km": 5.5,
+    "eta_minutes": 16,
+    "rating": 4.1,
+    "specialties": ["Emergency", "General Surgery", "Internal Medicine"],
+    "availability": "open",
+    "address": "200 Main Blvd, Central",
+    "phone": "+1-555-0301",
+    "lat": 12.9764,
+    "lng": 77.6009
+  },
+  {
+    "id": "hosp_northside_icu",
+    "name": "Northside Hospital (ICU)",
+    "distance_km": 7.9,
+    "eta_minutes": 20,
+    "rating": 4.7,
+    "specialties": ["Emergency", "ICU", "Pulmonology"],
+    "availability": "busy",
+    "address": "77 North Ring Rd, Northside",
+    "phone": "+1-555-0401",
+    "lat": 12.9894,
+    "lng": 77.5801
+  }
+]
+

lifeline-ai/backend/requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.110.0
+uvicorn[standard]>=0.27.0
+pydantic>=2.0.0
+python-multipart>=0.0.9
+httpx>=0.26.0
+transformers>=4.40.0
+torch>=2.2.0
+sentence-transformers>=2.2.2

lifeline-ai/backend/run.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+uvicorn app.main:app --host 0.0.0.0 --port "${PORT:-8000}" --reload
+

lifeline-ai/eslint.config.mjs

@@ -0,0 +1,18 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;

lifeline-ai/next.config.ts

@@ -0,0 +1,7 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;

lifeline-ai/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "lifeline-ai",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "next": "16.2.2",
+    "react": "19.2.4",
+    "react-dom": "19.2.4"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.2.2",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  }
+}

lifeline-ai/postcss.config.mjs

@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;

lifeline-ai/src/app/book/page.tsx

@@ -0,0 +1,267 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import { Button, Card, Container, Pill, TopNav } from "@/components/ui";
+import { Appointment, createAppointment, getHospitals, Hospital } from "@/lib/api";
+import { SOSButton } from "@/components/SOSButton";
+
+const DOCTORS: Record<string, string[]> = {
+  Cardiology: ["Dr. Meera Iyer", "Dr. Rahul Menon", "Dr. Sana Patel"],
+  Emergency: ["Dr. Arjun Rao", "Dr. Kavya Nair"],
+  "General Medicine": ["Dr. Neha Singh", "Dr. Vikram Das"],
+  ENT: ["Dr. Ananya Shah"],
+};
+
+function timeSlots() {
+  return [
+    "Today 10:30 AM",
+    "Today 12:00 PM",
+    "Today 4:30 PM",
+    "Tomorrow 9:30 AM",
+    "Tomorrow 2:00 PM",
+  ];
+}
+
+export default function BookPage() {
+  const [location, setLocation] = useState("Downtown");
+  const [hospitals, setHospitals] = useState<Hospital[]>([]);
+  const [hospitalId, setHospitalId] = useState<string>("");
+  const [department, setDepartment] = useState<string>("General Medicine");
+  const [doctor, setDoctor] = useState<string>("");
+  const [timeSlot, setTimeSlot] = useState<string>(timeSlots()[0]);
+  const [patientName, setPatientName] = useState<string>("");
+  const [patientPhone, setPatientPhone] = useState<string>("");
+  const [busy, setBusy] = useState(false);
+  const [confirmation, setConfirmation] = useState<Appointment | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    getHospitals(location, "closest").then((r) => {
+      if (cancelled) return;
+      setHospitals(r.hospitals);
+      setHospitalId((prev) => prev || r.hospitals[0]?.id || "");
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [location]);
+
+  useEffect(() => {
+    const list = DOCTORS[department] ?? ["Dr. Available Clinician"];
+    setDoctor(list[0]);
+  }, [department]);
+
+  const selectedHospital = useMemo(() => hospitals.find((h) => h.id === hospitalId) ?? null, [hospitals, hospitalId]);
+  const departments = useMemo(() => Object.keys(DOCTORS), []);
+  const doctors = useMemo(() => DOCTORS[department] ?? [], [department]);
+
+  const canBook =
+    hospitalId &&
+    department &&
+    doctor &&
+    timeSlot &&
+    patientName.trim().length >= 2 &&
+    patientPhone.trim().length >= 6 &&
+    !busy;
+
+  async function book() {
+    if (!canBook) return;
+    setBusy(true);
+    try {
+      const res = await createAppointment({
+        hospital_id: hospitalId,
+        department,
+        doctor,
+        time_slot: timeSlot,
+        patient_name: patientName.trim(),
+        patient_phone: patientPhone.trim(),
+      });
+      setConfirmation(res.appointment);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  return (
+    <div className="min-h-full bg-gradient-to-b from-white to-slate-50">
+      <TopNav />
+      <main className="py-10 sm:py-14">
+        <Container>
+          <div>
+            <Pill className="bg-blue-50 text-blue-700">Appointment booking</Pill>
+            <h1 className="mt-3 text-3xl font-extrabold tracking-tight text-slate-900">Book a visit</h1>
+            <p className="mt-2 text-slate-600">Select hospital, department, doctor, and a time slot. Demo uses mock availability.</p>
+          </div>
+
+          <div className="mt-8 grid gap-6 lg:grid-cols-3">
+            <div className="lg:col-span-2 space-y-6">
+              <Card>
+                <div className="grid gap-4 sm:grid-cols-2">
+                  <div>
+                    <div className="text-sm font-semibold text-slate-900">Location</div>
+                    <input
+                      value={location}
+                      onChange={(e) => setLocation(e.target.value)}
+                      className="mt-2 w-full rounded-2xl border border-slate-200 bg-white px-4 py-3 text-sm outline-none focus:border-blue-400 focus:ring-2 focus:ring-blue-100"
+                    />
+                    <div className="mt-2 text-xs text-slate-500">Tip: try Downtown / Westside / Northside</div>
+                  </div>
+                  <div>
+                    <div className="text-sm font-semibold text-slate-900">Hospital</div>
+                    <select
+                      value={hospitalId}
+                      onChange={(e) => setHospitalId(e.target.value)}
+                      className="mt-2 w-full rounded-2xl border border-slate-200 bg-white px-4 py-3 text-sm outline-none focus:border-blue-400 focus:ring-2 focus:ring-blue-100"
+                    >
+                      {hospitals.map((h) => (
+                        <option key={h.id} value={h.id}>
+                          {h.name} • {h.eta_minutes} min
+                        </option>
+                      ))}
+                    </select>
+                    {selectedHospital && (
+                      <div className="mt-2 text-xs text-slate-500">{selectedHospital.address}</div>
+                    )}
+                  </div>
+
+                  <div>
+                    <div className="text-sm font-semibold text-slate-900">Department</div>
+                    <select
+                      value={department}
+                      onChange={(e) => setDepartment(e.target.value)}
+                      className="mt-2 w-full rounded-2xl border border-slate-200 bg-white px-4 py-3 text-sm outline-none focus:border-blue-400 focus:ring-2 focus:ring-blue-100"
+                    >
+                      {departments.map((d) => (
+                        <option key={d} value={d}>
+                          {d}
+                        </option>
+                      ))}
+                    </select>
+                  </div>
+                  <div>
+                    <div className="text-sm font-semibold text-slate-900">Doctor</div>
+                    <select
+                      value={doctor}
+                      onChange={(e) => setDoctor(e.target.value)}
+                      className="mt-2 w-full rounded-2xl border border-slate-200 bg-white px-4 py-3 text-sm outline-none focus:border-blue-400 focus:ring-2 focus:ring-blue-100"
+                    >
+                      {doctors.map((d) => (
+                        <option key={d} value={d}>
+                          {d}
+                        </option>
+                      ))}
+                    </select>
+                    <div className="mt-2 text-xs font-semibold text-emerald-700">Specialist verified</div>
+                  </div>
+
+                  <div className="sm:col-span-2">
+                    <div className="text-sm font-semibold text-slate-900">Time slot</div>
+                    <div className="mt-2 flex flex-wrap gap-2">
+                      {timeSlots().map((t) => (
+                        <button
+                          key={t}
+                          onClick={() => setTimeSlot(t)}
+                          className={`rounded-xl border px-3 py-2 text-sm font-semibold ${
+                            timeSlot === t
+                              ? "border-blue-200 bg-blue-600 text-white"
+                              : "border-slate-200 bg-white text-slate-800 hover:bg-slate-50"
+                          }`}
+                        >
+                          {t}
+                        </button>
+                      ))}
+                    </div>
+                  </div>
+                </div>
+              </Card>
+
+              <Card>
+                <div className="text-sm font-semibold text-slate-900">Patient details</div>
+                <div className="mt-4 grid gap-4 sm:grid-cols-2">
+                  <div>
+                    <div className="text-xs font-semibold text-slate-600">Full name</div>
+                    <input
+                      value={patientName}
+                      onChange={(e) => setPatientName(e.target.value)}
+                      className="mt-2 w-full rounded-2xl border border-slate-200 bg-white px-4 py-3 text-sm outline-none focus:border-blue-400 focus:ring-2 focus:ring-blue-100"
+                      placeholder="Your name"
+                    />
+                  </div>
+                  <div>
+                    <div className="text-xs font-semibold text-slate-600">Phone</div>
+                    <input
+                      value={patientPhone}
+                      onChange={(e) => setPatientPhone(e.target.value)}
+                      className="mt-2 w-full rounded-2xl border border-slate-200 bg-white px-4 py-3 text-sm outline-none focus:border-blue-400 focus:ring-2 focus:ring-blue-100"
+                      placeholder="+1 555 0123"
+                    />
+                  </div>
+                </div>
+                <div className="mt-5 flex justify-end">
+                  <Button onClick={book} disabled={!canBook}>
+                    {busy ? "Booking..." : "Confirm appointment"}
+                  </Button>
+                </div>
+              </Card>
+            </div>
+
+            <div className="space-y-6">
+              <Card>
+                <div className="text-sm font-semibold text-slate-900">Reminder</div>
+                <p className="mt-2 text-sm text-slate-600">
+                  If symptoms are severe (chest pain, breathing trouble, unresponsive), use SOS instead of booking.
+                </p>
+                <div className="mt-4">
+                  <Button variant="danger" onClick={() => window.scrollTo({ top: 0, behavior: "smooth" })}>
+                    Emergency guidance
+                  </Button>
+                </div>
+              </Card>
+            </div>
+          </div>
+        </Container>
+      </main>
+
+      {confirmation && (
+        <div className="fixed inset-0 z-50 grid place-items-end bg-slate-900/50 p-4 sm:place-items-center">
+          <div className="w-full max-w-md animate-fade-up">
+            <Card>
+              <div className="flex items-start justify-between gap-3">
+                <div>
+                  <div className="text-lg font-extrabold text-slate-900">Appointment confirmed</div>
+                  <div className="mt-1 text-sm text-slate-600">Confirmation ID: {confirmation.id}</div>
+                </div>
+                <button
+                  className="rounded-xl px-3 py-2 text-sm font-semibold text-slate-600 hover:bg-slate-50"
+                  onClick={() => setConfirmation(null)}
+                >
+                  Close
+                </button>
+              </div>
+              <div className="mt-5 space-y-2 text-sm text-slate-800">
+                <div>
+                  <span className="font-semibold">Hospital:</span> {confirmation.hospital_name}
+                </div>
+                <div>
+                  <span className="font-semibold">Department:</span> {confirmation.department}
+                </div>
+                <div>
+                  <span className="font-semibold">Doctor:</span> {confirmation.doctor}
+                </div>
+                <div>
+                  <span className="font-semibold">Time:</span> {confirmation.time_slot}
+                </div>
+              </div>
+              <div className="mt-6 flex justify-end">
+                <Button onClick={() => setConfirmation(null)}>Done</Button>
+              </div>
+            </Card>
+          </div>
+        </div>
+      )}
+
+      <SOSButton />
+    </div>
+  );
+}
+

lifeline-ai/src/app/globals.css

@@ -0,0 +1,88 @@
+@import "tailwindcss";
+
+:root {
+  --background: #ffffff;
+  --foreground: #0f172a; /* slate-900 */
+}
+
+@theme inline {
+  --color-background: var(--background);
+  --color-foreground: var(--foreground);
+  --font-sans: var(--font-geist-sans);
+  --font-mono: var(--font-geist-mono);
+}
+
+/* Dark mode disabled to ensure consistent visibility */
+/* @media (prefers-color-scheme: dark) {
+  :root {
+    --background: #020617;
+    --foreground: #e2e8f0;
+  }
+} */
+
+/* Body background and color are set explicitly in layout.tsx */
+/* to ensure consistent light mode appearance */
+
+::selection {
+  background: rgba(59, 130, 246, 0.25);
+}
+
+@keyframes fadeUp {
+  from {
+    opacity: 0;
+    transform: translateY(8px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes pulseSoft {
+  0%,
+  100% {
+    transform: scale(1);
+    box-shadow: 0 0 0 0 rgba(239, 68, 68, 0.35);
+  }
+  50% {
+    transform: scale(1.03);
+    box-shadow: 0 0 0 10px rgba(239, 68, 68, 0.08);
+  }
+}
+
+@keyframes bounceSoft {
+  0%,
+  100% {
+    transform: translateY(0);
+  }
+  50% {
+    transform: translateY(-4px);
+  }
+}
+
+@keyframes shimmer {
+  0% {
+    background-position: -200% 0;
+  }
+  100% {
+    background-position: 200% 0;
+  }
+}
+
+.animate-fade-up {
+  animation: fadeUp 380ms ease-out both;
+}
+
+.animate-pulse-soft {
+  animation: pulseSoft 2s ease-in-out infinite;
+}
+
+.animate-bounce-soft {
+  animation: bounceSoft 1.6s ease-in-out infinite;
+}
+
+.loading-shimmer {
+  background: linear-gradient(90deg, #eef2ff 25%, #f8fafc 37%, #eef2ff 63%);
+  background-size: 300% 100%;
+  animation: shimmer 1.2s linear infinite;
+}

lifeline-ai/src/app/hospitals/page.tsx

@@ -0,0 +1,220 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import { useSearchParams } from "next/navigation";
+import { getHospitals, Hospital } from "@/lib/api";
+import { Button, Card, Container, Pill, TopNav } from "@/components/ui";
+import { SOSButton } from "@/components/SOSButton";
+
+function Stars({ rating }: { rating: number }) {
+  const full = Math.round(rating);
+  return (
+    <div className="flex items-center gap-1">
+      {Array.from({ length: 5 }).map((_, i) => (
+        <span key={i} className={i < full ? "text-amber-500" : "text-slate-200"}>
+          ★
+        </span>
+      ))}
+      <span className="ml-2 text-xs font-semibold text-slate-600">{rating.toFixed(1)}</span>
+    </div>
+  );
+}
+
+function AvailabilityPill({ v }: { v: Hospital["availability"] }) {
+  if (v === "busy") return <Pill className="bg-orange-500 text-white">Busy</Pill>;
+  if (v === "limited") return <Pill className="bg-blue-600 text-white">Limited</Pill>;
+  return <Pill className="bg-emerald-600 text-white">Open</Pill>;
+}
+
+export default function HospitalsPage() {
+  const sp = useSearchParams();
+  const initialLocation = sp.get("location") || "Downtown";
+
+  const [location, setLocation] = useState(initialLocation);
+  const [sort, setSort] = useState<"best_rated" | "closest" | "fastest_route">("closest");
+  const [hospitals, setHospitals] = useState<Hospital[]>([]);
+  const [geo, setGeo] = useState<{ lat: number; lng: number } | null>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    getHospitals(location, sort, geo?.lat ?? null, geo?.lng ?? null)
+      .then((r) => {
+        if (cancelled) return;
+        setHospitals(r.hospitals);
+      })
+      .catch(() => {
+        if (cancelled) return;
+        setHospitals([]);
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [location, sort, geo]);
+
+  function enableGeolocation() {
+    if (!navigator.geolocation) return;
+    navigator.geolocation.getCurrentPosition((p) => {
+      const lat = p.coords.latitude;
+      const lng = p.coords.longitude;
+      setGeo({ lat, lng });
+      // Update textual location for visibility
+      setLocation(`${lat.toFixed(4)},${lng.toFixed(4)}`);
+      // Immediately fetch hospitals for this location
+      getHospitals(`${lat.toFixed(4)},${lng.toFixed(4)}`, sort, lat, lng).then((r) => setHospitals(r.hospitals)).catch(() => {});
+    });
+  }
+
+  const bounds = useMemo(() => {
+    if (!hospitals.length) return null;
+    const lats = hospitals.map((h) => h.lat);
+    const lngs = hospitals.map((h) => h.lng);
+    const minLat = Math.min(...lats);
+    const maxLat = Math.max(...lats);
+    const minLng = Math.min(...lngs);
+    const maxLng = Math.max(...lngs);
+    return { minLat, maxLat, minLng, maxLng };
+  }, [hospitals]);
+
+  return (
+    <div className="min-h-full bg-gradient-to-b from-white to-slate-50">
+      <TopNav />
+      <main className="py-10 sm:py-14">
+        <Container>
+          <div className="flex flex-col gap-4 sm:flex-row sm:items-end sm:justify-between">
+            <div>
+              <Pill className="bg-blue-50 text-blue-700">Nearby hospital finder</Pill>
+              <h1 className="mt-3 text-3xl font-extrabold tracking-tight text-slate-900">Hospitals near you</h1>
+              <p className="mt-2 text-slate-600">
+                Compare <span className="font-semibold">best rated</span>, <span className="font-semibold">closest</span>, or{" "}
+                <span className="font-semibold">fastest route</span>.
+              </p>
+            </div>
+            <div className="grid gap-3 sm:grid-cols-2">
+              <div>
+                <div className="text-xs font-semibold text-slate-600">Location</div>
+                <input
+                  value={location}
+                  onChange={(e) => setLocation(e.target.value)}
+                  aria-label="Location"
+                  className="mt-2 w-full rounded-2xl border border-slate-200 bg-white px-4 py-3 text-sm outline-none focus:border-blue-400 focus:ring-2 focus:ring-blue-100"
+                />
+              </div>
+              <div>
+                <div className="text-xs font-semibold text-slate-600">Sort</div>
+                <div className="mt-2 flex gap-2">
+                  <Button variant={sort === "best_rated" ? "primary" : "secondary"} onClick={() => setSort("best_rated")}>
+                    Best rated
+                  </Button>
+                  <Button variant={sort === "closest" ? "primary" : "secondary"} onClick={() => setSort("closest")}>
+                    Closest
+                  </Button>
+                  <Button variant={sort === "fastest_route" ? "primary" : "secondary"} onClick={() => setSort("fastest_route")}>
+                    Fastest
+                  </Button>
+                </div>
+              </div>
+            </div>
+            <div className="sm:ml-auto">
+              <Button variant="secondary" onClick={enableGeolocation}>
+                Use my location
+              </Button>
+            </div>
+          </div>
+
+          <div className="mt-8 grid gap-6 lg:grid-cols-3">
+            <div className="lg:col-span-2 space-y-4">
+              {!hospitals.length && <div className="text-sm text-slate-600">Loading hospitals…</div>}
+              {hospitals.map((h) => {
+                const erWait = Math.max(8, Math.round(h.eta_minutes * 1.2 + (5 - h.rating) * 4));
+                const doctorMins = Math.max(6, Math.round(h.eta_minutes * 0.65));
+                const beds = h.availability === "open" ? "Beds: 12 available" : h.availability === "limited" ? "Beds: 4 available" : "Beds: 1 available";
+                return (
+                <Card key={h.id}>
+                  <div className="flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between group">
+                    <div className="space-y-2">
+                      <div className="flex items-center gap-2">
+                        <div className="text-lg font-extrabold text-slate-900">{h.name}</div>
+                        <AvailabilityPill v={h.availability} />
+                        <Pill className="bg-emerald-100 text-emerald-800">Verified hospital</Pill>
+                      </div>
+                      <Stars rating={h.rating} />
+                      <div className="text-sm text-slate-600">{h.address}</div>
+                      <div className="flex flex-wrap gap-2 text-xs">
+                        <Pill className="bg-blue-50 text-blue-700">Doctor available in {doctorMins} mins</Pill>
+                        <Pill className="bg-slate-100 text-slate-700">ER wait {erWait} mins</Pill>
+                        <Pill className="bg-violet-100 text-violet-700">{beds}</Pill>
+                      </div>
+                      <div className="flex flex-wrap gap-2">
+                        {h.specialties.slice(0, 5).map((s) => (
+                          <Pill key={s} className="bg-slate-100 text-slate-700">
+                            {s} • verified specialist
+                          </Pill>
+                        ))}
+                      </div>
+                    </div>
+                    <div className="grid gap-2 rounded-2xl border border-slate-200 bg-slate-50 p-4 transition group-hover:-translate-y-0.5">
+                      <div className="text-xs font-semibold text-slate-600">Distance</div>
+                      <div className="text-sm font-extrabold text-slate-900">{h.distance_km.toFixed(1)} km</div>
+                      <div className="text-xs font-semibold text-slate-600">ETA</div>
+                      <div className="text-sm font-extrabold text-slate-900">{h.eta_minutes} min</div>
+                      {geo && (
+                        <a
+                          className="text-xs font-semibold text-blue-700 hover:underline"
+                          target="_blank"
+                          rel="noreferrer"
+                          href={`https://www.google.com/maps/dir/?api=1&origin=${geo.lat},${geo.lng}&destination=${h.lat},${h.lng}&travelmode=driving`}
+                        >
+                          Open live route
+                        </a>
+                      )}
+                      <a className="text-xs font-semibold text-blue-700 hover:underline" href={`tel:${h.phone}`}>
+                        Call {h.phone}
+                      </a>
+                    </div>
+                  </div>
+                </Card>
+              )})}
+            </div>
+
+            <div className="space-y-6">
+              <Card>
+                <div className="text-sm font-semibold text-slate-900">Map (demo)</div>
+                <p className="mt-2 text-sm text-slate-600">
+                  Demo map pins. In production, replace with Google Maps / Mapbox. Pins are plotted from mock hospital coordinates.
+                </p>
+                <div className="mt-4 overflow-hidden rounded-2xl border border-slate-200 bg-slate-50">
+                  <div className="relative h-[280px] w-full">
+                    <div className="absolute inset-0 bg-[radial-gradient(circle_at_30%_20%,rgba(59,130,246,0.18),transparent_35%),radial-gradient(circle_at_70%_70%,rgba(16,185,129,0.18),transparent_40%)]" />
+                    <div className="absolute inset-0 p-4">
+                      {bounds && hospitals.map((h) => {
+                        const x = ((h.lng - bounds.minLng) / (bounds.maxLng - bounds.minLng || 1)) * 100;
+                        const y = (1 - (h.lat - bounds.minLat) / (bounds.maxLat - bounds.minLat || 1)) * 100;
+                        return (
+                          <div
+                            key={h.id}
+                            className="absolute -translate-x-1/2 -translate-y-1/2"
+                            style={{ left: `${x}%`, top: `${y}%` }}
+                            title={h.name}
+                          >
+                            <div className="grid h-9 w-9 place-items-center rounded-full bg-blue-600 text-white shadow-md">
+                              +
+                            </div>
+                          </div>
+                        );
+                      })}
+                      <div className="absolute bottom-3 left-3 rounded-xl bg-white/90 px-3 py-2 text-xs font-semibold text-slate-700 shadow-sm">
+                        {sort === "best_rated" ? "Best rated" : sort === "fastest_route" ? "Fastest route" : "Closest"}
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              </Card>
+            </div>
+          </div>
+        </Container>
+      </main>
+      <SOSButton />
+    </div>
+  );
+}
+

lifeline-ai/src/app/layout.tsx

@@ -0,0 +1,35 @@
+import type { Metadata } from "next";
+import { Geist, Geist_Mono } from "next/font/google";
+import "./globals.css";
+
+const geistSans = Geist({
+  variable: "--font-geist-sans",
+  subsets: ["latin"],
+});
+
+const geistMono = Geist_Mono({
+  variable: "--font-geist-mono",
+  subsets: ["latin"],
+});
+
+export const metadata: Metadata = {
+  title: "LifeLine AI",
+  description: "Emergency assistance: triage, hospitals, booking, SOS.",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html
+      lang="en"
+      className={`${geistSans.variable} ${geistMono.variable} h-full antialiased`}
+    >
+      <body className="min-h-full flex flex-col bg-white text-slate-900">
+        {children}
+      </body>
+    </html>
+  );
+}

lifeline-ai/src/app/not-found.tsx

@@ -0,0 +1,25 @@
+import Link from "next/link";
+import { Container, TopNav } from "@/components/ui";
+
+export default function NotFound() {
+  return (
+    <div className="min-h-full bg-gradient-to-b from-white to-slate-50">
+      <TopNav />
+      <main className="py-16">
+        <Container>
+          <div className="rounded-2xl border border-slate-200 bg-white p-8 text-center shadow-sm">
+            <div className="text-2xl font-extrabold text-slate-900">Page not found</div>
+            <p className="mt-2 text-slate-600">Return to symptom input to continue the demo.</p>
+            <Link
+              href="/"
+              className="mt-6 inline-flex rounded-xl bg-blue-600 px-4 py-2.5 text-sm font-semibold text-white hover:bg-blue-700"
+            >
+              Go home
+            </Link>
+          </div>
+        </Container>
+      </main>
+    </div>
+  );
+}
+

lifeline-ai/src/app/page.tsx

@@ -0,0 +1,213 @@
+"use client";
+
+import { useMemo, useState, useEffect } from "react";
+import { useRouter } from "next/navigation";
+import { Button, Card, Container, Pill, TopNav } from "@/components/ui";
+import { uploadFiles } from "@/lib/api";
+import { DEMO_CASES } from "@/lib/demo";
+
+export default function Home() {
+  const router = useRouter();
+  const [symptoms, setSymptoms] = useState("");
+  const [location, setLocation] = useState("");
+  const [coords, setCoords] = useState<{ lat: number; lng: number } | null>(null);
+  const [toast, setToast] = useState<{ msg: string; kind: "info" | "error" } | null>(null);
+  const [files, setFiles] = useState<File[]>([]);
+  const [busy, setBusy] = useState(false);
+  const canSubmit = symptoms.trim().length >= 3 && location.trim().length >= 2 && !busy;
+
+  const fileNote = useMemo(() => {
+    if (files.length === 0) return "Upload optional reports (PDF/images/prescriptions).";
+    return `${files.length} file(s) selected. We'll attach filenames to your analysis.`;
+  }, [files.length]);
+
+  async function onSubmit() {
+    if (!canSubmit) return;
+    setBusy(true);
+    try {
+      let uploaded_files: string[] = [];
+      if (files.length) {
+        const up = await uploadFiles(files);
+        uploaded_files = up.uploaded_files ?? [];
+      }
+      const payload = { symptoms: symptoms.trim(), location: location.trim(), uploaded_files };
+      sessionStorage.setItem("lifeline:last_intake", JSON.stringify(payload));
+      router.push("/results");
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  function enableGeolocation() {
+    if (!navigator.geolocation) return;
+    navigator.geolocation.getCurrentPosition(
+      (p) => {
+        const lat = p.coords.latitude;
+        const lng = p.coords.longitude;
+        // store coords and show a quick toast while we reverse-geocode
+        setCoords({ lat, lng });
+        setToast({ msg: "Location detected — resolving address…", kind: "info" });
+        reverseGeocodeAndSet(lat, lng);
+      },
+      (err) => {
+        console.warn("geolocation error", err);
+        setToast({ msg: "Could not get your location (permission denied or error).", kind: "error" });
+      },
+      { enableHighAccuracy: true, timeout: 8000 }
+    );
+  }
+
+  useEffect(() => {
+    // Auto-detect on page load (try to get permission silently)
+    // Delay slightly to avoid immediate permission prompt in some browsers
+    const t = setTimeout(() => {
+      try {
+        enableGeolocation();
+      } catch (e) {
+        // ignore
+      }
+    }, 600);
+    return () => clearTimeout(t);
+  }, []);
+
+  async function reverseGeocodeAndSet(lat: number, lng: number) {
+    try {
+  const apiBase = process.env.NEXT_PUBLIC_API_BASE ?? "";
+  const url = `${apiBase}/reverse-geocode?lat=${encodeURIComponent(lat)}&lng=${encodeURIComponent(lng)}`;
+      const res = await fetch(url);
+      if (!res.ok) throw new Error("geocode failed");
+      const j = await res.json();
+      const name = j.display_name || `${lat.toFixed(4)},${lng.toFixed(4)}`;
+      setLocation(name);
+      setToast({ msg: `Detected location: ${name}`, kind: "info" });
+      // clear toast after a short delay
+      setTimeout(() => setToast(null), 4500);
+    } catch (e) {
+      setLocation(`${lat.toFixed(4)},${lng.toFixed(4)}`);
+      setToast({ msg: "Detected coordinates but failed to resolve address.", kind: "error" });
+      setTimeout(() => setToast(null), 4500);
+    }
+  }
+
+  function fillDemo(id: string) {
+    const c = DEMO_CASES.find((d) => d.id === id);
+    if (!c) return;
+    setSymptoms(c.symptoms);
+    setLocation(c.location);
+  }
+
+  return (
+    <div className="min-h-full bg-gradient-to-b from-white to-slate-50">
+      <TopNav />
+      {/* Simple toast */}
+      {toast && (
+        <div className={`fixed left-1/2 top-20 -translate-x-1/2 z-50 rounded-xl px-4 py-3 shadow-md ${
+          toast.kind === "error" ? "bg-red-600 text-white" : "bg-blue-600 text-white"
+        }`} role="status">
+          {toast.msg}
+        </div>
+      )}
+      <main className="py-10 sm:py-14">
+        <Container>
+          <div className="grid gap-8 lg:grid-cols-2 lg:items-start">
+            <div className="space-y-5">
+              <Pill className="bg-blue-50 text-blue-700">Not a diagnosis • Demo-ready triage</Pill>
+              <h1 className="text-3xl font-extrabold tracking-tight text-slate-900 sm:text-4xl">
+                Get urgent guidance and the best next step—fast.
+              </h1>
+              <p className="text-slate-600 leading-7">
+                LifeLine AI helps you understand symptom urgency, find nearby hospitals, book an appointment, or request
+                emergency help. It always uses <span className="font-semibold">possible / likely</span> wording—never a final diagnosis.
+              </p>
+
+              <div className="grid gap-3 sm:grid-cols-3">
+                {DEMO_CASES.map((d) => (
+                  <button
+                    key={d.id}
+                    onClick={() => fillDemo(d.id)}
+                    className="rounded-2xl border border-slate-200 bg-white p-4 text-left shadow-sm transition hover:-translate-y-0.5 hover:border-blue-200 hover:shadow-md"
+                  >
+                    <div className="text-sm font-semibold text-slate-900">{d.title}</div>
+                    <div className="mt-1 text-xs text-slate-500">Autofill demo</div>
+                  </button>
+                ))}
+              </div>
+            </div>
+
+            <Card>
+              <div className="space-y-4">
+                <div>
+                  <div className="text-sm font-semibold text-slate-900">Describe symptoms</div>
+                  <textarea
+                    value={symptoms}
+                    onChange={(e) => setSymptoms(e.target.value)}
+                    placeholder="I have chest pain and shortness of breath"
+                    className="mt-2 min-h-[120px] w-full resize-none rounded-2xl border border-slate-200 bg-white px-4 py-3 text-sm outline-none focus:border-blue-400 focus:ring-2 focus:ring-blue-100"
+                  />
+                </div>
+
+                <div className="grid gap-3 sm:grid-cols-2">
+                  <div>
+                    <div className="text-sm font-semibold text-slate-900">Location</div>
+                      <div className="mt-2 flex items-center gap-2">
+                        <input
+                          value={location}
+                          onChange={(e) => setLocation(e.target.value)}
+                          placeholder="Downtown / Westside / Northside"
+                          className="flex-1 rounded-2xl border border-slate-200 bg-white px-4 py-3 text-sm outline-none focus:border-blue-400 focus:ring-2 focus:ring-blue-100"
+                        />
+                        <Button variant="secondary" onClick={enableGeolocation}>
+                          Use my location
+                        </Button>
+                      </div>
+                      {coords && (
+                        <div className="mt-2 flex items-center gap-2">
+                          <div className="rounded-lg bg-slate-50 px-3 py-2 text-sm text-slate-700">
+                            <div className="font-semibold">Detected</div>
+                            <div className="text-xs">{location}</div>
+                            <div className="text-xs text-slate-500">{coords.lat.toFixed(4)}, {coords.lng.toFixed(4)}</div>
+                          </div>
+                          <Button variant="secondary" onClick={() => { setCoords(null); setLocation(""); }}>
+                            Clear
+                          </Button>
+                        </div>
+                      )}
+                  </div>
+                  <div>
+                    <div className="text-sm font-semibold text-slate-900">Upload reports (optional)</div>
+                    <input
+                      type="file"
+                      multiple
+                      accept="application/pdf,image/*"
+                      aria-label="Upload reports"
+                      onChange={(e) => setFiles(Array.from(e.target.files ?? []))}
+                      className="mt-2 block w-full text-sm file:mr-3 file:rounded-xl file:border-0 file:bg-slate-100 file:px-3 file:py-2 file:text-slate-900 hover:file:bg-slate-200"
+                    />
+                    <div className="mt-2 text-xs text-slate-500">{fileNote}</div>
+                    <div className="mt-1 text-[11px] font-semibold text-emerald-700">Secure upload indicator: encrypted in transit (demo)</div>
+                  </div>
+                </div>
+
+                <div className="rounded-2xl border border-blue-100 bg-blue-50 p-4 text-sm text-blue-900">
+                  <div className="font-semibold">Safety note</div>
+                  <div className="mt-1 text-blue-800/90">
+                    If you suspect a life-threatening emergency, use the SOS button for immediate ambulance dispatch simulation.
+                  </div>
+                </div>
+
+                <div className="flex items-center justify-between gap-3">
+                  <div className="text-xs text-slate-500">
+                    By continuing, you agree this is informational only.
+                  </div>
+                  <Button onClick={onSubmit} disabled={!canSubmit}>
+                    {busy ? "Analyzing..." : "Submit"}
+                  </Button>
+                </div>
+              </div>
+            </Card>
+          </div>
+        </Container>
+      </main>
+    </div>
+  );
+}

lifeline-ai/src/app/results/page.tsx

@@ -0,0 +1,206 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import Link from "next/link";
+import { analyze, AnalyzeResult } from "@/lib/api";
+import { urgencyMeta } from "@/lib/demo";
+import { Button, Card, Container, Pill, TopNav } from "@/components/ui";
+import { SOSButton } from "@/components/SOSButton";
+
+type Intake = { symptoms: string; location: string; uploaded_files: string[] };
+
+export default function ResultsPage() {
+  const [intake] = useState<Intake | null>(() => {
+    if (typeof window === "undefined") return null;
+    try {
+      const raw = sessionStorage.getItem("lifeline:last_intake");
+      return raw ? (JSON.parse(raw) as Intake) : null;
+    } catch {
+      return null;
+    }
+  });
+  const [result, setResult] = useState<AnalyzeResult | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [liveConfidence, setLiveConfidence] = useState(0.25);
+
+  useEffect(() => {
+    if (!intake) return;
+    let cancelled = false;
+    analyze(intake)
+      .then((r) => {
+        if (cancelled) return;
+        setResult(r);
+      })
+      .catch((e) => {
+        if (cancelled) return;
+        setError(e?.message ?? "Failed to analyze");
+      })
+      .finally(() => {
+        if (cancelled) return;
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [intake]);
+
+  useEffect(() => {
+    if (result || error) return;
+    const t = window.setInterval(() => {
+      setLiveConfidence((v) => Math.min(0.94, v + 0.03));
+    }, 350);
+    return () => window.clearInterval(t);
+  }, [result, error]);
+
+  const meta = useMemo(() => {
+    if (!result) return null;
+    return urgencyMeta(result.urgency);
+  }, [result]);
+
+  return (
+    <div className="min-h-full bg-gradient-to-b from-white to-slate-50">
+      <TopNav />
+      <main className="py-10 sm:py-14">
+        <Container>
+          <div className="flex items-start justify-between gap-4">
+            <div>
+              <Pill className="bg-slate-100 text-slate-800">AI-assisted triage • Not a diagnosis</Pill>
+              <h1 className="mt-3 text-3xl font-extrabold tracking-tight text-slate-900">Your results</h1>
+              <p className="mt-2 max-w-2xl text-slate-600">
+                We provide <span className="font-semibold">possible / likely</span> guidance only. If you feel unsafe, use SOS.
+              </p>
+            </div>
+            <Link
+              href="/"
+              className="rounded-xl border border-slate-200 bg-white px-4 py-2 text-sm font-semibold text-slate-700 hover:bg-slate-50"
+            >
+              New check
+            </Link>
+          </div>
+
+          <div className="mt-8 grid gap-6 lg:grid-cols-3">
+            <div className="lg:col-span-2 space-y-6">
+              <Card>
+                <div className="text-sm font-semibold text-slate-900">Your input</div>
+                <div className="mt-3 grid gap-3 sm:grid-cols-2">
+                  <div className="rounded-2xl border border-slate-200 bg-slate-50 p-4">
+                    <div className="text-xs font-semibold text-slate-600">Symptoms</div>
+                    <div className="mt-1 text-sm text-slate-900">{intake?.symptoms || "—"}</div>
+                  </div>
+                  <div className="rounded-2xl border border-slate-200 bg-slate-50 p-4">
+                    <div className="text-xs font-semibold text-slate-600">Location</div>
+                    <div className="mt-1 text-sm text-slate-900">{intake?.location || "—"}</div>
+                    <div className="mt-2 text-xs text-slate-500">
+                      Attachments: {intake?.uploaded_files?.length ? intake.uploaded_files.join(", ") : "none"}
+                    </div>
+                  </div>
+                </div>
+              </Card>
+
+              <Card>
+                <div className="flex items-start justify-between gap-4">
+                  <div>
+                    <div className="text-sm font-semibold text-slate-900">AI analysis</div>
+                    <div className="mt-1 text-xs text-slate-500">
+                      {result?.confidence_note ?? "Running live model inference..."} • Always verify with a clinician
+                    </div>
+                  </div>
+                  {meta && <Pill className={`${meta.pill} ${result?.urgency === "emergency" ? "animate-pulse-soft" : ""}`}>{meta.label} urgency</Pill>}
+                </div>
+
+                {!result && !error && intake && (
+                  <div className="mt-5 space-y-2">
+                    <div className="loading-shimmer h-4 w-40 rounded-lg" />
+                    <div className="loading-shimmer h-4 w-full rounded-lg" />
+                    <div className="loading-shimmer h-4 w-5/6 rounded-lg" />
+                    <div className="pt-2">
+                      <div className="mb-1 flex items-center justify-between text-[11px] font-semibold text-blue-700">
+                        <span>Live confidence update</span>
+                        <span>{Math.round(liveConfidence * 100)}%</span>
+                      </div>
+                      <div className="h-2 w-full rounded-full bg-blue-100">
+                        <div className="h-2 rounded-full bg-blue-600 transition-all duration-300" style={{ width: `${Math.round(liveConfidence * 100)}%` }} />
+                      </div>
+                    </div>
+                  </div>
+                )}
+                {error && <div className="mt-5 text-sm text-red-700">{error}</div>}
+
+                {result && (
+                  <div className="mt-5 grid gap-4 sm:grid-cols-2 animate-fade-up">
+                    <div className="rounded-2xl border border-slate-200 p-4">
+                      <div className="text-xs font-semibold text-slate-600">Possible condition</div>
+                      <div className="mt-1 text-base font-bold text-slate-900">{result.possible_condition}</div>
+                    </div>
+                    <div className="rounded-2xl border border-slate-200 p-4">
+                      <div className="text-xs font-semibold text-slate-600">Recommended department</div>
+                      <div className="mt-1 text-base font-bold text-slate-900">{result.recommended_department}</div>
+                    </div>
+                    <div className="rounded-2xl border border-blue-200 bg-blue-50 p-4 sm:col-span-2">
+                      <div className="text-xs font-semibold text-blue-700">Model inference</div>
+                      <div className="mt-1 text-sm text-blue-900">
+                        Powered by <span className="font-bold">{result.model_provider}</span> model <span className="font-bold">{result.model_name}</span>
+                        {" "}with confidence <span className="font-bold">{Math.round(result.confidence_score * 100)}%</span>.
+                      </div>
+                    </div>
+                    <div className="rounded-2xl border border-slate-200 p-4 sm:col-span-2">
+                      <div className="text-xs font-semibold text-slate-600">Recommended next step</div>
+                      <div className="mt-1 text-sm text-slate-900">{result.recommended_next_step}</div>
+                    </div>
+                    <div className="rounded-2xl border border-slate-200 p-4 sm:col-span-2">
+                      <div className="text-xs font-semibold text-slate-600">Temporary precautions</div>
+                      <ul className="mt-2 list-disc space-y-1 pl-5 text-sm text-slate-900">
+                        {result.temporary_precautions.map((p, i) => (
+                          <li key={i}>{p}</li>
+                        ))}
+                      </ul>
+                    </div>
+                    <div className="rounded-2xl border border-amber-200 bg-amber-50 p-4 sm:col-span-2">
+                      <div className="text-xs font-semibold text-amber-900">Disclaimer</div>
+                      <div className="mt-1 text-xs text-amber-900/90">{result.disclaimer}</div>
+                    </div>
+                  </div>
+                )}
+              </Card>
+            </div>
+
+            <div className="space-y-6">
+              <Card>
+                <div className="text-sm font-semibold text-slate-900">Next actions</div>
+                <div className="mt-4 grid gap-3">
+                  <Link
+                    href={`/hospitals?location=${encodeURIComponent(intake?.location ?? "")}`}
+                    className="rounded-2xl border border-slate-200 bg-white p-4 hover:bg-slate-50"
+                  >
+                    <div className="text-sm font-bold text-slate-900">Find nearby hospitals</div>
+                    <div className="mt-1 text-xs text-slate-500">Compare best-rated, closest, fastest route</div>
+                  </Link>
+                  <Link
+                    href="/book"
+                    className="rounded-2xl border border-slate-200 bg-white p-4 hover:bg-slate-50"
+                  >
+                    <div className="text-sm font-bold text-slate-900">Book an appointment</div>
+                    <div className="mt-1 text-xs text-slate-500">Choose doctor + time slot</div>
+                  </Link>
+                </div>
+              </Card>
+
+              <Card>
+                <div className="text-sm font-semibold text-slate-900">If this feels urgent</div>
+                <p className="mt-2 text-sm text-slate-600">
+                  Use the SOS button to simulate ambulance dispatch with ETA and nearest hospital.
+                </p>
+                <div className="mt-4">
+                  <Button variant="danger" onClick={() => window.scrollTo({ top: 0, behavior: "smooth" })}>
+                    Safety reminder
+                  </Button>
+                </div>
+              </Card>
+            </div>
+          </div>
+        </Container>
+      </main>
+      <SOSButton />
+    </div>
+  );
+}
+

lifeline-ai/src/components/SOSButton.tsx

@@ -0,0 +1,142 @@
+"use client";
+
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Button, Card, Pill } from "@/components/ui";
+import { sos } from "@/lib/api";
+
+function formatEta(seconds: number) {
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  return `${m}:${String(s).padStart(2, "0")}`;
+}
+
+export function SOSButton() {
+  const [open, setOpen] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [status, setStatus] = useState<"idle" | "dispatched">("idle");
+  const [eta, setEta] = useState<number>(0);
+  const [tracking, setTracking] = useState<string>("");
+  const [hospitalName, setHospitalName] = useState<string>("");
+  const [statusTick, setStatusTick] = useState(0);
+  const timerRef = useRef<number | null>(null);
+
+  const last = useMemo(() => {
+    if (typeof window === "undefined") return null;
+    try {
+      const raw = sessionStorage.getItem("lifeline:last_intake");
+      return raw ? (JSON.parse(raw) as { location?: string; symptoms?: string }) : null;
+    } catch {
+      return null;
+    }
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      if (timerRef.current) window.clearInterval(timerRef.current);
+    };
+  }, []);
+
+  async function requestSOS() {
+    setBusy(true);
+    try {
+      const location = last?.location || "Downtown";
+      const symptoms = last?.symptoms || undefined;
+      const res = await sos(location, symptoms);
+      setStatus("dispatched");
+      setEta(res.eta_seconds);
+      setTracking(res.tracking_code);
+      setHospitalName(res.nearest_hospital.name);
+      if (timerRef.current) window.clearInterval(timerRef.current);
+      timerRef.current = window.setInterval(() => {
+        setEta((t) => (t > 0 ? t - 1 : 0));
+        setStatusTick((v) => v + 1);
+      }, 1000);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  const progress = status === "dispatched" ? Math.max(0, Math.min(100, 100 - Math.floor((eta / 900) * 100))) : 0;
+  const dispatchMsg =
+    statusTick % 6 < 2
+      ? "Nearest ICU notified"
+      : statusTick % 6 < 4
+        ? "Ambulance en route"
+        : "Paramedic team preparing arrival";
+
+  return (
+    <>
+      <button
+        aria-label="Emergency SOS"
+        onClick={() => setOpen(true)}
+        className="animate-bounce-soft fixed bottom-5 right-5 z-50 flex h-16 w-16 items-center justify-center rounded-full bg-red-600 text-white shadow-lg shadow-red-600/30 ring-1 ring-red-200 hover:bg-red-700 active:scale-[0.98] focus:outline-none focus:ring-4 focus:ring-red-200"
+      >
+        <span className="text-sm font-extrabold tracking-wide">SOS</span>
+      </button>
+
+      {open && (
+        <div className="fixed inset-0 z-50 grid place-items-end bg-slate-950/70 p-4 sm:place-items-center">
+          <div className="w-full max-w-md animate-fade-up">
+            <Card>
+              <div className="flex items-start justify-between gap-3">
+                <div>
+                  <div className="text-lg font-extrabold text-slate-900">Emergency SOS</div>
+                  <div className="mt-1 text-sm text-slate-600">
+                    This is a demo simulation of ambulance dispatch. If this is real, call your local emergency number.
+                  </div>
+                </div>
+                <button
+                  className="rounded-xl px-3 py-2 text-sm font-semibold text-slate-600 hover:bg-slate-50"
+                  onClick={() => setOpen(false)}
+                >
+                  Close
+                </button>
+              </div>
+
+              <div className="mt-5 space-y-3">
+                {status === "idle" ? (
+                  <>
+                    <div className="rounded-2xl border border-red-100 bg-red-50 p-4 text-sm text-red-900">
+                      <div className="font-semibold">When to use SOS</div>
+                      <ul className="mt-2 list-disc pl-5 text-red-800/90 space-y-1">
+                        <li>Severe chest pain, trouble breathing</li>
+                        <li>Unresponsive / seizure / severe bleeding</li>
+                        <li>Blue lips or sudden collapse</li>
+                      </ul>
+                    </div>
+                    <Button variant="danger" onClick={requestSOS} disabled={busy}>
+                      {busy ? "Dispatching..." : "Request Ambulance"}
+                    </Button>
+                  </>
+                ) : (
+                  <div className="rounded-2xl border border-emerald-100 bg-emerald-50 p-4">
+                    <div className="flex items-center justify-between gap-3">
+                      <Pill className="animate-pulse-soft bg-emerald-600 text-white">Ambulance dispatched</Pill>
+                      <div className="text-xs font-semibold text-emerald-900">Tracking: {tracking}</div>
+                    </div>
+                    <div className="mt-3 text-sm text-emerald-900">
+                      Nearest hospital: <span className="font-semibold">{hospitalName}</span>
+                    </div>
+                    <div className="mt-2 text-sm text-emerald-900">
+                      ETA: <span className="font-extrabold tabular-nums">{formatEta(eta)}</span>
+                    </div>
+                    <div className="mt-3 rounded-xl border border-emerald-200 bg-white/60 p-2">
+                      <div className="h-2 w-full rounded-full bg-emerald-100">
+                        <div className="h-2 rounded-full bg-emerald-600 transition-all duration-700" style={{ width: `${progress}%` }} />
+                      </div>
+                      <div className="mt-1 text-[11px] font-semibold text-emerald-800">{dispatchMsg}</div>
+                    </div>
+                    <div className="mt-3 text-xs text-emerald-800/90">
+                      Stay calm. If safe, unlock the door and keep phone volume on.
+                    </div>
+                  </div>
+                )}
+              </div>
+            </Card>
+          </div>
+        </div>
+      )}
+    </>
+  );
+}
+

lifeline-ai/src/components/ui.tsx

@@ -0,0 +1,79 @@
+import Link from "next/link";
+import { ReactNode } from "react";
+
+export function Container({ children }: { children: ReactNode }) {
+  return <div className="mx-auto w-full max-w-6xl px-4 sm:px-6 lg:px-8">{children}</div>;
+}
+
+export function Card({ children }: { children: ReactNode }) {
+  return (
+    <div className="rounded-3xl border border-slate-200/90 bg-white shadow-[0_8px_30px_rgba(2,6,23,0.06)] transition hover:shadow-[0_12px_36px_rgba(2,6,23,0.09)]">
+      <div className="p-5 sm:p-6 md:p-7">{children}</div>
+    </div>
+  );
+}
+
+export function Button({
+  children,
+  onClick,
+  type = "button",
+  variant = "primary",
+  disabled,
+}: {
+  children: ReactNode;
+  onClick?: () => void;
+  type?: "button" | "submit";
+  variant?: "primary" | "secondary" | "danger";
+  disabled?: boolean;
+}) {
+  const base =
+    "inline-flex min-h-11 items-center justify-center gap-2 rounded-2xl px-4 py-2.5 text-sm font-semibold transition-all duration-200 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 disabled:opacity-60 disabled:cursor-not-allowed";
+  const styles =
+    variant === "danger"
+      ? "bg-red-600 text-white shadow-md shadow-red-600/25 hover:-translate-y-0.5 hover:bg-red-700"
+      : variant === "secondary"
+        ? "bg-white text-slate-900 border border-slate-200 hover:-translate-y-0.5 hover:bg-slate-50"
+        : "bg-blue-600 text-white shadow-md shadow-blue-600/20 hover:-translate-y-0.5 hover:bg-blue-700";
+  return (
+    <button type={type} onClick={onClick} disabled={disabled} className={`${base} ${styles}`}>
+      {children}
+    </button>
+  );
+}
+
+export function Pill({ children, className = "" }: { children: ReactNode; className?: string }) {
+  return (
+    <span className={`inline-flex items-center rounded-full px-3 py-1 text-xs font-semibold ${className}`}>
+      {children}
+    </span>
+  );
+}
+
+export function TopNav() {
+  return (
+    <header className="sticky top-0 z-30 border-b border-slate-200/70 bg-white/85 backdrop-blur">
+      <Container>
+        <div className="flex h-16 items-center justify-between">
+          <Link href="/" className="flex items-center gap-2">
+            <div className="grid h-10 w-10 place-items-center rounded-2xl bg-gradient-to-br from-blue-500 to-blue-700 text-white font-black shadow-md shadow-blue-600/25">
+              LL
+            </div>
+            <div className="leading-tight">
+              <div className="text-sm font-extrabold tracking-tight text-slate-900">LifeLine AI</div>
+              <div className="text-xs text-slate-500">Emergency assistance MVP</div>
+            </div>
+          </Link>
+          <nav className="flex items-center gap-2 text-sm">
+            <Link className="rounded-lg px-3 py-2 text-slate-600 hover:bg-slate-50 hover:text-slate-900" href="/hospitals">
+              Hospitals
+            </Link>
+            <Link className="rounded-lg px-3 py-2 text-slate-600 hover:bg-slate-50 hover:text-slate-900" href="/book">
+              Book
+            </Link>
+          </nav>
+        </div>
+      </Container>
+    </header>
+  );
+}
+

lifeline-ai/src/lib/api.ts

@@ -0,0 +1,127 @@
+export type Urgency = "low" | "medium" | "high" | "emergency";
+
+export type AnalyzeResult = {
+  possible_condition: string;
+  urgency: Urgency;
+  recommended_department: string;
+  temporary_precautions: string[];
+  recommended_next_step: string;
+  disclaimer: string;
+  confidence_note: string;
+  confidence_score: number;
+  model_provider: string;
+  model_name: string;
+};
+
+export type Hospital = {
+  id: string;
+  name: string;
+  distance_km: number;
+  eta_minutes: number;
+  rating: number;
+  specialties: string[];
+  availability: "open" | "limited" | "busy";
+  address: string;
+  phone: string;
+  lat: number;
+  lng: number;
+};
+
+export type HospitalsResponse = {
+  location: string;
+  sort: "best_rated" | "closest" | "fastest_route";
+  hospitals: Hospital[];
+};
+
+export type AppointmentRequest = {
+  hospital_id: string;
+  department: string;
+  doctor: string;
+  time_slot: string;
+  patient_name: string;
+  patient_phone: string;
+};
+
+export type Appointment = {
+  id: string;
+  hospital_id: string;
+  hospital_name: string;
+  department: string;
+  doctor: string;
+  time_slot: string;
+  patient_name: string;
+  patient_phone: string;
+  status: "confirmed" | "cancelled";
+  created_at_iso: string;
+};
+
+export type SosResponse = {
+  status: "ambulance_dispatched";
+  nearest_hospital: Hospital;
+  eta_seconds: number;
+  tracking_code: string;
+  message: string;
+};
+
+const API_BASE = process.env.NEXT_PUBLIC_API_BASE ?? "http://localhost:8000";
+
+export async function uploadFiles(files: File[]) {
+  const fd = new FormData();
+  for (const f of files) fd.append("files", f);
+  const res = await fetch(`${API_BASE}/upload`, { method: "POST", body: fd });
+  if (!res.ok) throw new Error(`Upload failed (${res.status})`);
+  return (await res.json()) as { uploaded_files: string[] };
+}
+
+export async function analyze(payload: {
+  symptoms: string;
+  location: string;
+  uploaded_files: string[];
+}) {
+  const fd = new FormData();
+  fd.set("symptoms", payload.symptoms);
+  fd.set("location", payload.location);
+  fd.set("uploaded_files", JSON.stringify(payload.uploaded_files ?? []));
+  const res = await fetch(`${API_BASE}/analyze`, { method: "POST", body: fd });
+  if (!res.ok) throw new Error(`Analyze failed (${res.status})`);
+  return (await res.json()) as AnalyzeResult;
+}
+
+export async function getHospitals(
+  location: string,
+  sort: HospitalsResponse["sort"],
+  lat?: number | null,
+  lng?: number | null
+) {
+  const url = new URL(`${API_BASE}/hospitals`);
+  url.searchParams.set("location", location);
+  url.searchParams.set("sort", sort);
+  if (typeof lat === "number" && typeof lng === "number") {
+    url.searchParams.set("lat", String(lat));
+    url.searchParams.set("lng", String(lng));
+  }
+  const res = await fetch(url.toString());
+  if (!res.ok) throw new Error(`Hospitals failed (${res.status})`);
+  return (await res.json()) as HospitalsResponse;
+}
+
+export async function createAppointment(req: AppointmentRequest) {
+  const res = await fetch(`${API_BASE}/appointments`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(req),
+  });
+  if (!res.ok) throw new Error(`Appointment failed (${res.status})`);
+  return (await res.json()) as { appointment: Appointment };
+}
+
+export async function sos(location: string, symptoms?: string) {
+  const res = await fetch(`${API_BASE}/sos`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ location, symptoms }),
+  });
+  if (!res.ok) throw new Error(`SOS failed (${res.status})`);
+  return (await res.json()) as SosResponse;
+}
+

lifeline-ai/src/lib/demo.ts

@@ -0,0 +1,34 @@
+export const DEMO_CASES = [
+  {
+    id: "demo_cardiac",
+    title: "Emergency cardiac case",
+    symptoms: "I have chest pain and shortness of breath. The pain is radiating to my left arm.",
+    location: "Westside",
+  },
+  {
+    id: "demo_fever",
+    title: "Fever & sore throat",
+    symptoms: "I have fever and sore throat for the last 2 days.",
+    location: "Downtown",
+  },
+  {
+    id: "demo_collapse",
+    title: "Unresponsive collapse",
+    symptoms: "Person collapsed and is unresponsive. Blue lips and very slow breathing.",
+    location: "Northside",
+  },
+] as const;
+
+export function urgencyMeta(urgency: "low" | "medium" | "high" | "emergency") {
+  switch (urgency) {
+    case "emergency":
+      return { label: "Emergency", pill: "bg-red-600 text-white", border: "border-red-200" };
+    case "high":
+      return { label: "High", pill: "bg-orange-500 text-white", border: "border-orange-200" };
+    case "medium":
+      return { label: "Medium", pill: "bg-blue-600 text-white", border: "border-blue-200" };
+    default:
+      return { label: "Low", pill: "bg-emerald-600 text-white", border: "border-emerald-200" };
+  }
+}
+

lifeline-ai/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}

medical_data.json

@@ -0,0 +1,359 @@
+[
+  {
+    "condition": "Common Cold",
+    "symptoms": "sneezing, runny nose, cough, sore throat, mild fever, congestion",
+    "causes": "Usually caused by viral infections affecting the upper respiratory tract.",
+    "precautions": "Drink warm fluids, rest well, maintain hygiene, and avoid cold exposure.",
+    "see_doctor": "Consult a doctor if symptoms last more than a week or breathing becomes difficult."
+  },
+  {
+    "condition": "Flu",
+    "symptoms": "fever, cough, fatigue, body pain, chills, headache, weakness",
+    "causes": "Caused by the influenza virus and spreads through respiratory droplets.",
+    "precautions": "Take rest, stay hydrated, isolate if contagious, and monitor temperature.",
+    "see_doctor": "See a doctor if fever is very high, weakness is severe, or symptoms worsen."
+  },
+  {
+    "condition": "Pneumonia",
+    "symptoms": "fever, cough, chest pain, shortness of breath, fatigue, chills",
+    "causes": "Caused by bacterial, viral, or fungal infection in the lungs.",
+    "precautions": "Rest, drink fluids, avoid smoking, and monitor breathing closely.",
+    "see_doctor": "Seek immediate medical help if breathing difficulty or chest pain is severe."
+  },
+  {
+    "condition": "Asthma",
+    "symptoms": "wheezing, shortness of breath, chest tightness, cough, difficulty breathing",
+    "causes": "Triggered by allergens, dust, smoke, exercise, or respiratory infections.",
+    "precautions": "Avoid triggers, keep inhaler nearby, and avoid dusty or smoky environments.",
+    "see_doctor": "Seek urgent care if breathing becomes difficult or inhaler does not help."
+  },
+  {
+    "condition": "Bronchitis",
+    "symptoms": "cough, mucus, fatigue, chest discomfort, mild fever, sore throat",
+    "causes": "Usually caused by viral infections or irritation of the airways.",
+    "precautions": "Rest, stay hydrated, avoid smoking, and use steam inhalation if needed.",
+    "see_doctor": "Consult a doctor if cough persists for more than 3 weeks or breathing worsens."
+  },
+  {
+    "condition": "COVID-19",
+    "symptoms": "fever, cough, fatigue, loss of smell, sore throat, body pain, shortness of breath",
+    "causes": "Caused by the SARS-CoV-2 virus and spreads through droplets or close contact.",
+    "precautions": "Isolate, hydrate, monitor oxygen levels if possible, and rest well.",
+    "see_doctor": "Seek medical care if breathing difficulty, chest pain, or low oxygen occurs."
+  },
+  {
+    "condition": "Tuberculosis",
+    "symptoms": "persistent cough, weight loss, night sweats, fever, chest pain, fatigue",
+    "causes": "Caused by Mycobacterium tuberculosis infection, mainly affecting the lungs.",
+    "precautions": "Seek early treatment, avoid spreading infection, and follow medical therapy strictly.",
+    "see_doctor": "See a doctor if cough lasts more than 2 weeks or blood appears in sputum."
+  },
+  {
+    "condition": "Sinusitis",
+    "symptoms": "headache, facial pain, nasal congestion, fever, runny nose, pressure around eyes",
+    "causes": "Usually caused by infection or inflammation of the sinus cavities.",
+    "precautions": "Steam inhalation, hydration, rest, and nasal saline rinses may help.",
+    "see_doctor": "Consult a doctor if symptoms are severe or last more than 10 days."
+  },
+  {
+    "condition": "Migraine",
+    "symptoms": "headache, nausea, vomiting, sensitivity to light, sensitivity to sound, dizziness",
+    "causes": "Can be triggered by stress, lack of sleep, hormonal changes, or certain foods.",
+    "precautions": "Rest in a dark quiet room, stay hydrated, and avoid known triggers.",
+    "see_doctor": "Seek medical help if headache is sudden, severe, or different from usual migraines."
+  },
+  {
+    "condition": "Tension Headache",
+    "symptoms": "headache, pressure around head, neck pain, stress, mild dizziness",
+    "causes": "Often caused by stress, poor posture, eye strain, or muscle tension.",
+    "precautions": "Rest, hydration, posture correction, and stress reduction can help.",
+    "see_doctor": "See a doctor if headaches become frequent or severe."
+  },
+  {
+    "condition": "Hypertension",
+    "symptoms": "headache, dizziness, blurred vision, nosebleeds, chest discomfort",
+    "causes": "Can result from genetics, stress, obesity, high salt intake, or underlying disease.",
+    "precautions": "Reduce salt, exercise, manage stress, and monitor blood pressure regularly.",
+    "see_doctor": "Consult a doctor if blood pressure is consistently high or symptoms worsen."
+  },
+  {
+    "condition": "Hypotension",
+    "symptoms": "dizziness, fainting, weakness, blurred vision, nausea",
+    "causes": "May be caused by dehydration, blood loss, heart problems, or low blood sugar.",
+    "precautions": "Drink fluids, avoid sudden standing, and eat balanced meals.",
+    "see_doctor": "See a doctor if fainting, confusion, or repeated dizziness occurs."
+  },
+  {
+    "condition": "Diabetes",
+    "symptoms": "frequent urination, increased thirst, fatigue, blurred vision, weight loss, hunger",
+    "causes": "Caused by high blood sugar levels due to insulin-related problems.",
+    "precautions": "Control sugar intake, exercise, stay hydrated, and monitor glucose levels.",
+    "see_doctor": "Consult a doctor if symptoms are persistent or sugar levels are abnormal."
+  },
+  {
+    "condition": "Hypoglycemia",
+    "symptoms": "sweating, shaking, hunger, dizziness, weakness, confusion, rapid heartbeat",
+    "causes": "Caused by low blood sugar, often due to skipping meals or diabetes medication.",
+    "precautions": "Take glucose or sugary food immediately and monitor symptoms.",
+    "see_doctor": "Seek urgent help if confusion, unconsciousness, or seizures occur."
+  },
+  {
+    "condition": "Anemia",
+    "symptoms": "fatigue, weakness, pale skin, dizziness, shortness of breath, headache",
+    "causes": "Often caused by iron deficiency, blood loss, or low red blood cell production.",
+    "precautions": "Eat iron-rich foods, stay hydrated, and follow prescribed supplements.",
+    "see_doctor": "Consult a doctor if fatigue is severe or symptoms persist."
+  },
+  {
+    "condition": "Dehydration",
+    "symptoms": "dry mouth, dizziness, fatigue, dark urine, thirst, headache",
+    "causes": "Caused by excessive fluid loss through sweating, vomiting, diarrhea, or poor intake.",
+    "precautions": "Drink oral fluids, rest, and avoid excessive heat exposure.",
+    "see_doctor": "Seek care if confusion, very low urine output, or severe weakness occurs."
+  },
+  {
+    "condition": "Gastroenteritis",
+    "symptoms": "diarrhea, vomiting, stomach pain, nausea, fever, dehydration",
+    "causes": "Usually caused by viral or bacterial infection of the digestive tract.",
+    "precautions": "Drink ORS, eat light foods, rest, and maintain hygiene.",
+    "see_doctor": "See a doctor if there is blood in stool, severe dehydration, or persistent vomiting."
+  },
+  {
+    "condition": "Food Poisoning",
+    "symptoms": "vomiting, diarrhea, stomach cramps, nausea, fever, weakness",
+    "causes": "Caused by contaminated food or drink containing bacteria, viruses, or toxins.",
+    "precautions": "Hydrate well, avoid heavy foods, and rest.",
+    "see_doctor": "Seek medical help if symptoms are severe, prolonged, or involve dehydration."
+  },
+  {
+    "condition": "Acidity",
+    "symptoms": "burning chest pain, stomach discomfort, bloating, sour taste, nausea",
+    "causes": "Often caused by excess stomach acid, spicy foods, stress, or irregular eating habits.",
+    "precautions": "Avoid spicy/oily foods, eat smaller meals, and avoid lying down after eating.",
+    "see_doctor": "Consult a doctor if symptoms are frequent or severe."
+  },
+  {
+    "condition": "Gastritis",
+    "symptoms": "stomach pain, nausea, bloating, vomiting, burning sensation, loss of appetite",
+    "causes": "Caused by irritation or inflammation of the stomach lining.",
+    "precautions": "Avoid alcohol, spicy foods, and take prescribed medication if advised.",
+    "see_doctor": "See a doctor if vomiting blood, black stools, or severe pain occurs."
+  },
+  {
+    "condition": "Appendicitis",
+    "symptoms": "lower right abdominal pain, nausea, vomiting, fever, loss of appetite",
+    "causes": "Caused by inflammation of the appendix, often due to blockage or infection.",
+    "precautions": "Avoid eating or drinking and seek urgent medical evaluation.",
+    "see_doctor": "Go to the emergency room immediately if appendicitis is suspected."
+  },
+  {
+    "condition": "Urinary Tract Infection",
+    "symptoms": "burning urination, frequent urination, lower abdominal pain, fever, cloudy urine",
+    "causes": "Usually caused by bacterial infection in the urinary tract.",
+    "precautions": "Drink plenty of water, maintain hygiene, and do not hold urine.",
+    "see_doctor": "Consult a doctor if fever, back pain, or worsening symptoms occur."
+  },
+  {
+    "condition": "Kidney Stones",
+    "symptoms": "severe side pain, blood in urine, nausea, vomiting, painful urination",
+    "causes": "Caused by mineral and salt deposits forming in the kidneys.",
+    "precautions": "Drink lots of water and avoid dehydration.",
+    "see_doctor": "Seek urgent medical help if pain is severe or urine is blocked."
+  },
+  {
+    "condition": "Menstrual Cramps",
+    "symptoms": "lower abdominal pain, back pain, nausea, fatigue, mood changes",
+    "causes": "Caused by uterine muscle contractions during menstruation.",
+    "precautions": "Rest, warm compress, hydration, and light movement may help.",
+    "see_doctor": "Consult a doctor if pain is unusually severe or disrupts daily life."
+  },
+  {
+    "condition": "PCOS",
+    "symptoms": "irregular periods, acne, weight gain, excess hair growth, hair thinning",
+    "causes": "A hormonal disorder affecting ovulation and metabolism.",
+    "precautions": "Maintain healthy diet, exercise, and follow medical advice.",
+    "see_doctor": "Consult a gynecologist if symptoms persist or worsen."
+  },
+  {
+    "condition": "Pregnancy Nausea",
+    "symptoms": "nausea, vomiting, fatigue, missed period, dizziness",
+    "causes": "Usually caused by hormonal changes during early pregnancy.",
+    "precautions": "Eat small frequent meals, stay hydrated, and rest well.",
+    "see_doctor": "See a doctor if vomiting is severe or dehydration occurs."
+  },
+  {
+    "condition": "Allergic Rhinitis",
+    "symptoms": "sneezing, itchy nose, runny nose, watery eyes, congestion",
+    "causes": "Triggered by allergens such as pollen, dust, mold, or pet dander.",
+    "precautions": "Avoid allergens, keep surroundings clean, and use prescribed allergy medication.",
+    "see_doctor": "Consult a doctor if symptoms are frequent or severe."
+  },
+  {
+    "condition": "Skin Allergy",
+    "symptoms": "itching, rash, redness, swelling, hives",
+    "causes": "Can be triggered by foods, medicines, insect bites, or contact irritants.",
+    "precautions": "Avoid suspected triggers, keep skin cool, and avoid scratching.",
+    "see_doctor": "Seek medical help if swelling affects breathing or rash becomes severe."
+  },
+  {
+    "condition": "Fungal Infection",
+    "symptoms": "itching, skin rash, redness, scaling, irritation",
+    "causes": "Caused by fungal growth on the skin, often in warm or moist areas.",
+    "precautions": "Keep skin dry, maintain hygiene, and avoid sharing towels or clothes.",
+    "see_doctor": "Consult a doctor if rash spreads or does not improve."
+  },
+  {
+    "condition": "Eczema",
+    "symptoms": "itching, dry skin, rash, redness, skin irritation",
+    "causes": "Linked to skin barrier problems, allergies, and inflammation.",
+    "precautions": "Moisturize regularly, avoid irritants, and keep skin hydrated.",
+    "see_doctor": "See a doctor if rash is severe, infected, or persistent."
+  },
+  {
+    "condition": "Psoriasis",
+    "symptoms": "red patches, scaling, itching, dry skin, joint discomfort",
+    "causes": "An immune-related skin condition causing rapid skin cell buildup.",
+    "precautions": "Moisturize skin, avoid triggers, and follow prescribed treatment.",
+    "see_doctor": "Consult a dermatologist if symptoms worsen or affect daily life."
+  },
+  {
+    "condition": "Conjunctivitis",
+    "symptoms": "red eyes, itching eyes, watery eyes, discharge, irritation",
+    "causes": "Can be caused by viral, bacterial, or allergic inflammation of the eye.",
+    "precautions": "Avoid touching eyes, maintain hygiene, and do not share towels.",
+    "see_doctor": "See a doctor if pain, blurred vision, or severe redness occurs."
+  },
+  {
+    "condition": "Ear Infection",
+    "symptoms": "ear pain, fever, hearing difficulty, discharge, irritability",
+    "causes": "Usually caused by bacterial or viral infection in the ear.",
+    "precautions": "Avoid inserting objects in ear and follow treatment advice.",
+    "see_doctor": "Consult a doctor if fever, discharge, or severe pain occurs."
+  },
+  {
+    "condition": "Throat Infection",
+    "symptoms": "sore throat, fever, difficulty swallowing, swollen glands, cough",
+    "causes": "Can be caused by viral or bacterial infection.",
+    "precautions": "Warm fluids, rest, and avoid cold foods or irritants.",
+    "see_doctor": "See a doctor if swallowing becomes difficult or fever persists."
+  },
+  {
+    "condition": "Tonsillitis",
+    "symptoms": "sore throat, fever, swollen tonsils, bad breath, difficulty swallowing",
+    "causes": "Caused by viral or bacterial infection of the tonsils.",
+    "precautions": "Warm fluids, rest, and maintain hydration.",
+    "see_doctor": "Consult a doctor if symptoms are severe or recurrent."
+  },
+  {
+    "condition": "Dengue",
+    "symptoms": "high fever, headache, body pain, rash, nausea, weakness",
+    "causes": "Caused by dengue virus transmitted by mosquito bites.",
+    "precautions": "Stay hydrated, rest, avoid mosquito exposure, and monitor symptoms.",
+    "see_doctor": "Seek immediate care if bleeding, severe weakness, or abdominal pain occurs."
+  },
+  {
+    "condition": "Malaria",
+    "symptoms": "fever, chills, sweating, headache, vomiting, body pain",
+    "causes": "Caused by Plasmodium parasites transmitted through mosquito bites.",
+    "precautions": "Use mosquito protection, rest, and seek early treatment.",
+    "see_doctor": "Consult a doctor immediately if malaria is suspected."
+  },
+  {
+    "condition": "Typhoid",
+    "symptoms": "fever, stomach pain, weakness, headache, diarrhea, constipation",
+    "causes": "Caused by Salmonella typhi infection, often through contaminated food or water.",
+    "precautions": "Drink safe water, eat hygienic food, and rest well.",
+    "see_doctor": "See a doctor if persistent fever or severe weakness occurs."
+  },
+  {
+    "condition": "Hepatitis",
+    "symptoms": "yellow eyes, yellow skin, fatigue, nausea, abdominal pain, dark urine",
+    "causes": "Caused by liver inflammation due to viruses, alcohol, or other liver injury.",
+    "precautions": "Avoid alcohol, rest, hydrate, and seek medical evaluation.",
+    "see_doctor": "Consult a doctor immediately if jaundice appears."
+  },
+  {
+    "condition": "Jaundice",
+    "symptoms": "yellow eyes, yellow skin, fatigue, dark urine, abdominal discomfort",
+    "causes": "Often linked to liver disease, bile duct problems, or excess bilirubin.",
+    "precautions": "Avoid alcohol and seek medical evaluation promptly.",
+    "see_doctor": "See a doctor as soon as jaundice is noticed."
+  },
+  {
+    "condition": "Heart Attack",
+    "symptoms": "chest pain, sweating, shortness of breath, nausea, left arm pain, dizziness",
+    "causes": "Caused by blocked blood flow to the heart muscle.",
+    "precautions": "This is a medical emergency. Rest and seek emergency help immediately.",
+    "see_doctor": "Call emergency services immediately if heart attack symptoms are present."
+  },
+  {
+    "condition": "Angina",
+    "symptoms": "chest pain, chest pressure, shortness of breath, fatigue, arm discomfort",
+    "causes": "Caused by reduced blood flow to the heart muscle.",
+    "precautions": "Avoid exertion and seek medical evaluation.",
+    "see_doctor": "Consult a doctor urgently if chest pain is recurrent or worsening."
+  },
+  {
+    "condition": "Stroke",
+    "symptoms": "sudden weakness, facial droop, slurred speech, confusion, dizziness, headache",
+    "causes": "Caused by interrupted blood flow or bleeding in the brain.",
+    "precautions": "This is a medical emergency and needs immediate hospital care.",
+    "see_doctor": "Call emergency services immediately if stroke symptoms appear."
+  },
+  {
+    "condition": "Epilepsy",
+    "symptoms": "seizures, loss of consciousness, staring spells, confusion, jerking movements",
+    "causes": "Caused by abnormal electrical activity in the brain.",
+    "precautions": "Ensure safety during seizures and avoid dangerous environments.",
+    "see_doctor": "Seek medical evaluation for any seizure episode."
+  },
+  {
+    "condition": "Anxiety Disorder",
+    "symptoms": "restlessness, rapid heartbeat, sweating, fear, chest tightness, overthinking",
+    "causes": "Can be related to stress, mental health factors, or life events.",
+    "precautions": "Practice breathing exercises, sleep well, and reduce stress triggers.",
+    "see_doctor": "Consult a doctor or mental health professional if symptoms interfere with daily life."
+  },
+  {
+    "condition": "Depression",
+    "symptoms": "sadness, fatigue, sleep problems, loss of interest, low mood, appetite changes",
+    "causes": "Can result from biological, psychological, and social factors.",
+    "precautions": "Seek support, maintain routine, sleep well, and avoid isolation.",
+    "see_doctor": "Consult a professional if symptoms persist or affect daily functioning."
+  },
+  {
+    "condition": "Insomnia",
+    "symptoms": "difficulty sleeping, fatigue, irritability, poor concentration, headache",
+    "causes": "Often caused by stress, anxiety, poor sleep habits, or health conditions.",
+    "precautions": "Maintain a sleep routine, reduce screen time, and avoid caffeine late in the day.",
+    "see_doctor": "See a doctor if sleep problems are frequent or severe."
+  },
+  {
+    "condition": "Obesity",
+    "symptoms": "weight gain, fatigue, joint pain, shortness of breath, snoring",
+    "causes": "Can result from excess calorie intake, low activity, hormonal issues, or genetics.",
+    "precautions": "Follow a balanced diet, regular exercise, and healthy sleep habits.",
+    "see_doctor": "Consult a doctor for persistent weight-related health concerns."
+  },
+  {
+    "condition": "Arthritis",
+    "symptoms": "joint pain, stiffness, swelling, reduced movement, inflammation",
+    "causes": "Can be due to wear and tear, autoimmune disease, or joint inflammation.",
+    "precautions": "Gentle exercise, weight management, and medical treatment can help.",
+    "see_doctor": "Consult a doctor if pain or swelling persists."
+  },
+  {
+    "condition": "Back Pain",
+    "symptoms": "lower back pain, stiffness, muscle tightness, reduced movement",
+    "causes": "Can result from muscle strain, poor posture, injury, or spinal problems.",
+    "precautions": "Maintain posture, avoid heavy lifting, and use proper back support.",
+    "see_doctor": "See a doctor if pain is severe, persistent, or causes weakness."
+  },
+  {
+    "condition": "Sprain",
+    "symptoms": "joint pain, swelling, bruising, difficulty moving, tenderness",
+    "causes": "Caused by overstretching or tearing of ligaments.",
+    "precautions": "Rest, ice, compression, and elevation can help.",
+    "see_doctor": "Consult a doctor if swelling or pain is severe or walking is difficult."
+  }
+]

models.py

@@ -0,0 +1,113 @@
+"""
+models.py — Typed Pydantic models for the MediRoute OpenEnv environment.
+
+These models define the complete interface contract for the AI agent:
+ - Observation: what the agent perceives at each step
+ - Action:       what the agent can do
+ - StepResult:  what the environment returns after each action
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+# ─────────────────────────────────────────────
+#  Observation
+# ─────────────────────────────────────────────
+class Observation(BaseModel):
+    """Everything the agent can see about the current patient and environment."""
+
+    symptoms: str = Field(
+        ..., description="Free-text description of the patient's chief complaints."
+    )
+    lab_report_summary: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Key lab / vital results (e.g. {'bp': '160/100', 'spo2': '98%'}).",
+    )
+    severity_score: float = Field(
+        0.0,
+        ge=0.0,
+        le=1.0,
+        description="Numeric severity 0 (trivial) → 1 (life-threatening). "
+        "Starts at 0; updated by the environment after analysis.",
+    )
+    location: str = Field(..., description="Patient's current geographic area/district.")
+    nearby_hospitals: List[str] = Field(
+        default_factory=list,
+        description="Ordered list of hospitals reachable from the patient's location.",
+    )
+    available_specialists: List[str] = Field(
+        default_factory=list,
+        description="Specialists currently on-call or available for consultation.",
+    )
+    previous_actions: List[str] = Field(
+        default_factory=list,
+        description="Ordered list of actions already taken in this episode "
+        "(format: '<action_type>:<target>').",
+    )
+
+    class Config:
+        validate_assignment = True
+
+
+# ─────────────────────────────────────────────
+#  Action
+# ─────────────────────────────────────────────
+VALID_ACTION_TYPES = {
+    "analyze_symptoms",
+    "request_more_info",
+    "recommend_specialist",
+    "select_hospital",
+    "book_appointment",
+    "call_ambulance",
+    "provide_temp_guidance",
+}
+
+
+class Action(BaseModel):
+    """A single action the agent submits to the environment."""
+
+    action_type: str = Field(
+        ...,
+        description=(
+            "One of: analyze_symptoms | request_more_info | recommend_specialist | "
+            "select_hospital | book_appointment | call_ambulance | provide_temp_guidance"
+        ),
+    )
+    target: Optional[str] = Field(
+        None,
+        description=(
+            "Contextual target of the action, e.g. severity level, specialist name, "
+            "hospital name, or None for actions that don't require a target."
+        ),
+    )
+
+    def validate_action_type(self) -> bool:
+        return self.action_type in VALID_ACTION_TYPES
+
+    def as_key(self) -> str:
+        """Canonical string representation used for deduplication."""
+        return f"{self.action_type}:{self.target}"
+
+
+# ─────────────────────────────────────────────
+#  StepResult  (returned by env.step())
+# ─────────────────────────────────────────────
+class StepResult(BaseModel):
+    """The structured return value from MediRouteEnv.step()."""
+
+    observation: Observation = Field(..., description="Updated environment observation.")
+    reward: float = Field(
+        ...,
+        description="Incremental reward earned by this single action (can be negative).",
+    )
+    done: bool = Field(
+        ..., description="Whether the episode has terminated after this action."
+    )
+    info: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Diagnostic extras: total_reward, raw_step_reward, error messages.",
+    )

openenv.yaml

@@ -0,0 +1,107 @@
+# MediRoute OpenEnv configuration
+# Compatible with the OpenEnv specification
+
+env_id: mediroute-openenv-v1
+version: "1.0.0"
+name: "MediRoute OpenEnv"
+description: >
+  A medical triage and hospital routing simulation environment where an AI agent
+  analyses patient symptoms and lab results, determines severity, recommends the
+  correct specialist, selects the best nearby hospital, books appointments, and
+  escalates emergencies with ambulance dispatch.
+
+author: "MediRoute Team"
+license: MIT
+
+# ── Environment entry-point ────────────────────────────────────────────────
+entrypoint:
+  module: environment
+  class: MediRouteEnv
+
+# ── Task definitions ───────────────────────────────────────────────────────
+tasks:
+  - id: easy
+    difficulty: easy
+    description: "Mild illness — fever and sore throat. Classify low severity, recommend GP, book appointment."
+    max_steps: 6
+    passing_score: 0.5
+
+  - id: medium
+    difficulty: medium
+    description: "Cardiology case — chest pain, high BP, ECG abnormality. Recommend cardiologist, select cardiac hospital."
+    max_steps: 8
+    passing_score: 0.6
+
+  - id: hard
+    difficulty: hard
+    description: "Life-threatening emergency — severe chest pain, SpO₂ crash, unresponsive. Dispatch ambulance immediately."
+    max_steps: 6
+    passing_score: 0.5
+
+# ── Action space ───────────────────────────────────────────────────────────
+action_space:
+  type: discrete
+  actions:
+    - analyze_symptoms
+    - request_more_info
+    - recommend_specialist
+    - select_hospital
+    - book_appointment
+    - call_ambulance
+    - provide_temp_guidance
+
+# ── Observation space ──────────────────────────────────────────────────────
+observation_space:
+  symptoms:
+    type: string
+    description: "Free-text patient complaints"
+  lab_report_summary:
+    type: object
+    description: "Key lab / vital results"
+  severity_score:
+    type: float
+    range: [0.0, 1.0]
+    description: "Numeric severity score"
+  location:
+    type: string
+    description: "Patient geographic area"
+  nearby_hospitals:
+    type: list[string]
+    description: "Candidate hospitals sorted by proximity/quality"
+  available_specialists:
+    type: list[string]
+    description: "On-call specialists"
+  previous_actions:
+    type: list[string]
+    description: "Action history for this episode"
+
+# ── Reward structure ───────────────────────────────────────────────────────
+reward:
+  range: [0.0, 1.0]
+  components:
+    correct_severity_classification: +0.30
+    correct_specialist_recommendation: +0.30
+    correct_hospital_selection: +0.20
+    successful_appointment_booking: +0.20
+    correct_emergency_escalation: +0.50
+    wrong_department: -0.20
+    duplicate_action: -0.30
+    unnecessary_ambulance: -0.30
+    ambulance_missed_in_emergency: -0.30
+
+# ── Inference configuration ────────────────────────────────────────────────
+inference:
+  script: inference.py
+  env_vars:
+    - OPENAI_API_KEY
+    - API_BASE_URL
+    - MODEL_NAME
+    - HF_TOKEN
+  max_runtime_minutes: 20
+  supports_hf_spaces: true
+
+# ── Runtime constraints ────────────────────────────────────────────────────
+runtime:
+  cpu_only: true
+  max_ram_gb: 8
+  max_vcpu: 2

requirements.txt

@@ -0,0 +1,2 @@
+pydantic>=2.0.0
+openai>=1.10.0

tasks.py

@@ -0,0 +1,140 @@
+"""
+tasks.py — Deterministic task definitions for MediRoute OpenEnv.
+
+Each task is a fully specified medical scenario with:
+  - Initial state (symptoms, labs, location, nearby hospitals, specialists)
+  - Ground-truth expectations used by the grader
+  - Difficulty metadata
+
+Tasks are purely data; no side-effects happen here.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+# ─────────────────────────────────────────────
+#  Task Registry
+# ─────────────────────────────────────────────
+
+TASKS: Dict[str, Dict[str, Any]] = {
+    # ── EASY ──────────────────────────────────────────────────────────────────
+    "easy": {
+        "difficulty": "easy",
+        "description": "Mild illness — fever and sore throat.",
+        "symptoms": "Patient reports fever (101.5 °F) and sore throat for 2 days.",
+        "lab_report_summary": {
+            "temperature_f": 101.5,
+            "strep_rapid_test": "positive",
+            "wbc": "11,200 / µL (mildly elevated)",
+        },
+        # Initial severity — agent must classify this
+        "severity_score": 0.0,
+        "location": "Downtown",
+        "nearby_hospitals": [
+            "City Clinic",
+            "Downtown Medical Center",
+            "Northside Hospital",
+        ],
+        "available_specialists": [
+            "General Physician",
+            "ENT Specialist",
+            "Cardiologist",
+            "Emergency Doctor",
+        ],
+        # Ground-truth answers for graders
+        "expected_severity": "low",
+        "expected_specialist": "General Physician",
+        "expected_hospital": "City Clinic",
+        "requires_ambulance": False,
+        "terminal_actions": {"book_appointment", "provide_temp_guidance"},
+        "max_steps": 6,
+    },
+
+    # ── MEDIUM ────────────────────────────────────────────────────────────────
+    "medium": {
+        "difficulty": "medium",
+        "description": "Cardiology case — chest pain, high BP, ECG abnormality.",
+        "symptoms": (
+            "55-year-old male with crushing chest pain radiating to left arm, "
+            "persistent for 30 minutes. Hypertension history."
+        ),
+        "lab_report_summary": {
+            "blood_pressure": "165/105 mmHg",
+            "ecg_finding": "ST-segment elevation in leads II, III, aVF",
+            "troponin_i": "0.9 ng/mL (elevated)",
+            "heart_rate": "102 bpm",
+        },
+        "severity_score": 0.0,
+        "location": "Westside",
+        "nearby_hospitals": [
+            "Westside Heart Center",
+            "General Hospital",
+            "City Clinic",
+        ],
+        "available_specialists": [
+            "Cardiologist",
+            "General Physician",
+            "Emergency Doctor",
+            "ENT Specialist",
+        ],
+        "expected_severity": "high",
+        "expected_specialist": "Cardiologist",
+        "expected_hospital": "Westside Heart Center",
+        "requires_ambulance": False,
+        "terminal_actions": {"book_appointment", "provide_temp_guidance"},
+        "max_steps": 8,
+    },
+
+    # ── HARD ──────────────────────────────────────────────────────────────────
+    "hard": {
+        "difficulty": "hard",
+        "description": "Life-threatening emergency — severe chest pain, SpO₂ crash, unresponsive.",
+        "symptoms": (
+            "Elderly female found unresponsive. Bystander reports sudden "
+            "severe chest pain followed by collapse. Lips cyanotic."
+        ),
+        "lab_report_summary": {
+            "spo2": "78 % (critical)",
+            "pulse": "thready / barely palpable",
+            "consciousness": "GCS 3 — unresponsive",
+            "respiratory_rate": "6 breaths/min",
+        },
+        "severity_score": 0.0,
+        "location": "Northside",
+        "nearby_hospitals": [
+            "Northside Hospital (ICU)",
+            "General Hospital",
+            "Westside Heart Center",
+        ],
+        "available_specialists": [
+            "Emergency Doctor",
+            "Cardiologist",
+            "General Physician",
+        ],
+        "expected_severity": "critical",
+        "expected_specialist": "Emergency Doctor",
+        "expected_hospital": "Northside Hospital (ICU)",
+        "requires_ambulance": True,
+        "terminal_actions": {"call_ambulance", "book_appointment", "provide_temp_guidance"},
+        "max_steps": 6,
+    },
+}
+
+
+def get_task(difficulty: str) -> Dict[str, Any]:
+    """Return a defensive copy of the task definition for the given difficulty."""
+    key = difficulty.lower().strip()
+    if key not in TASKS:
+        raise ValueError(
+            f"Unknown difficulty '{difficulty}'. "
+            f"Available options: {sorted(TASKS.keys())}"
+        )
+    # Deep copy primitive fields; lists/dicts are re-created automatically
+    import copy
+    return copy.deepcopy(TASKS[key])
+
+
+def list_tasks() -> Dict[str, str]:
+    """Return a {difficulty: description} summary for logging / display."""
+    return {k: v["description"] for k, v in TASKS.items()}

test.py

@@ -0,0 +1,42 @@
+import json
+from sentence_transformers import SentenceTransformer, util
+
+print("Loading medical model...")
+model = SentenceTransformer("sentence-transformers/embeddinggemma-300m-medical")
+print("Model loaded!\n")
+
+# Load dataset
+with open("medical_data.json", "r") as f:
+    medical_data = json.load(f)
+
+# Build searchable text
+documents = [
+    f"{item['condition']}. Symptoms: {item['symptoms']}. Causes: {item['causes']}. Precautions: {item['precautions']}. Doctor advice: {item['see_doctor']}"
+    for item in medical_data
+]
+
+# Encode disease database
+doc_embeddings = model.encode(documents, convert_to_tensor=True)
+
+# Input
+user_input = input("Enter patient symptoms: ").strip().lower()
+
+# Encode user symptoms
+query_embedding = model.encode(user_input, convert_to_tensor=True)
+
+# Find best match
+scores = util.cos_sim(query_embedding, doc_embeddings)[0]
+best_match_idx = scores.argmax().item()
+best_match = medical_data[best_match_idx]
+
+# Output
+print("\n==============================")
+print("      LIFELINE AI REPORT      ")
+print("==============================\n")
+print(f"Entered Symptoms   : {user_input}")
+print(f"Possible Condition : {best_match['condition']}")
+print(f"Causes             : {best_match['causes']}")
+print(f"Precautions        : {best_match['precautions']}")
+print(f"When to See Doctor : {best_match['see_doctor']}")
+print(f"Confidence Score   : {scores[best_match_idx]:.4f}")
+print("\n⚠️ Disclaimer: This is an AI-assisted suggestion, not a final medical diagnosis.")