Deploy Medical Diagnosis AI - Full Stack Application

Features:
- React frontend with Vite
- FastAPI backend with smart predictions
- ML model (Gradient Boosting) for disease diagnosis
- 16-feature medical assessment
- Professional UI with glassmorphism design
- Patient Data Report with all metrics
- Docker container with non-root user (UID 1000)
- Serves both API and static frontend on port 7860

Note: node_modules will be built during Docker build via npm install
This keeps the repository size manageable (~20MB vs 500MB+)

.dockerignore

@@ -0,0 +1,81 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Documentation
+*.md
+README.md
+LICENSE
+
+# Development
+.env
+.env.local
+.env.*.local
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv
+pip-log.txt
+pip-delete-this-directory.txt
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+*.egg-info/
+dist/
+build/
+
+# Node
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.npm
+.eslintcache
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+*~
+.DS_Store
+
+# Frontend build artifacts (will be rebuilt)
+frontend/dist
+frontend/.vite
+
+# Tests
+test_*.py
+tests/
+*.test.js
+
+# Sessions and cache
+/tmp
+sessions/
+*.json
+.claude*
+
+# Docker
+.dockerignore
+Dockerfile
+
+# CI/CD
+.github
+.gitlab-ci.yml
+
+# Misc
+*.log
+.next

.gitignore

@@ -0,0 +1,43 @@
+# Node
+node_modules/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.npm
+.eslintcache
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv
+pip-log.txt
+.tox/
+.coverage
+.pytest_cache/
+*.egg-info/
+
+# Build artifacts
+frontend/dist/
+frontend/.vite/
+
+# IDE
+.vscode
+.idea
+*.swp
+*.swo
+
+# Environment
+.env
+.env.local
+
+# Sessions
+/tmp
+sessions/
+
+# OS
+.DS_Store

Dockerfile

@@ -0,0 +1,78 @@
+# Multi-stage build for Medical Diagnosis AI
+# Stage 1: Build React frontend with Node.js
+# Stage 2: Python backend serving both API and static files
+
+# ============================================================
+# Stage 1: Build React Frontend
+# ============================================================
+FROM node:18-slim AS frontend-builder
+
+WORKDIR /build/frontend
+
+# Copy frontend source code
+COPY frontend/package*.json ./
+RUN npm install --frozen-lockfile
+
+# Copy frontend source
+COPY frontend/ .
+
+# Build the frontend (creates dist/ folder)
+RUN npm run build
+
+# ============================================================
+# Stage 2: Python Backend with Static File Serving
+# ============================================================
+FROM python:3.10-slim
+
+# Set metadata
+LABEL maintainer="Medical Diagnosis AI Team"
+LABEL description="Medical Diagnosis AI - Full Stack Application"
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+
+# Create non-root user with UID 1000 (Hugging Face Spaces requirement)
+RUN groupadd -r user && useradd -r -u 1000 -g user user
+
+# Set working directory
+WORKDIR /home/user/app
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --upgrade pip && \
+    pip install -r requirements.txt
+
+# Install curl for health checks
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends curl && \
+    rm -rf /var/lib/apt/lists/*
+
+# Copy backend application code
+COPY app/ ./app/
+COPY server.py .
+
+# Copy the ML model (CRITICAL - needed for disease predictions)
+COPY models/ ./models/
+
+# Create frontend dist directory and copy built frontend from Stage 1
+RUN mkdir -p frontend
+COPY --from=frontend-builder /build/frontend/dist ./frontend/dist
+
+# Change ownership of all files to the non-root user
+RUN chown -R user:user /home/user/app
+
+# Switch to non-root user
+USER user
+
+# Expose port 7860 (Hugging Face Spaces standard)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Run the server
+CMD ["python", "server.py"]

PUSH_TO_HF_SPACES.md

@@ -0,0 +1,178 @@
+# Push to Hugging Face Spaces - Final Step
+
+You're almost done! Your files are committed and ready to push. Follow these steps:
+
+---
+
+## 🔐 Step 1: Authenticate with Hugging Face
+
+### Option A: Using HF Token (Recommended)
+
+**Get your token:**
+1. Go to: https://huggingface.co/settings/tokens
+2. Create a new token if you don't have one
+3. Copy the token
+
+**Set it up in your terminal:**
+
+```bash
+# Option 1: Set as environment variable (temporary)
+export HF_TOKEN=your_actual_token_here
+git push
+
+# Option 2: Use git credential helper (persistent)
+git config --global credential.helper store
+# When prompted, enter:
+# Username: your_huggingface_username
+# Password: your_HF_TOKEN
+git push
+```
+
+### Option B: Using SSH (Alternative)
+
+If you have SSH keys set up on HF:
+
+```bash
+git remote set-url origin git@huggingface.co:spaces/zunayed02/MediHelp.git
+git push
+```
+
+---
+
+## 🚀 Step 2: Push to Your Space
+
+Once authenticated:
+
+```bash
+cd /media/zunayed/HDD_code/chatbot\ with\ llm/MediHelp
+git push
+```
+
+**Expected output:**
+```
+Counting objects: ...
+Writing objects: ...
+Total ... (delta ...)
+remote: Scanning for {content}...
+To https://huggingface.co/spaces/zunayed02/MediHelp
+   31515be..0917c28  main -> main
+```
+
+---
+
+## ⏳ Step 3: Wait for Build
+
+After pushing:
+
+1. **Go to your Space:** https://huggingface.co/spaces/zunayed02/MediHelp
+2. **Click "Build" tab** to watch the build progress
+3. **Build takes:** 5-15 minutes
+4. **Watch for:**
+   - ✅ Stage 1: Frontend build
+   - ✅ Stage 2: Backend setup
+   - ✅ Health check: Pass
+
+---
+
+## ⚙️ Step 4: Configure GROQ_API_KEY (CRITICAL!)
+
+**After build completes:**
+
+1. Go to your Space: https://huggingface.co/spaces/zunayed02/MediHelp
+2. Click **Settings** (gear icon)
+3. Click **Secrets**
+4. Add new secret:
+   - **Key:** `GROQ_API_KEY`
+   - **Value:** [Your actual Groq API key](https://console.groq.com)
+5. Save
+
+**Without this, the app won't work!**
+
+---
+
+## ✅ Step 5: Test Your Live App
+
+Once build is complete and secrets are set:
+
+1. **Reload the Space:** F5 or refresh
+2. **Test the app:**
+   - ✅ Frontend loads
+   - ✅ Can enter health data
+   - ✅ Gets diagnosis results
+   - ✅ Shows Patient Data Report
+
+---
+
+## 📊 Current Status
+
+| Item | Status |
+|------|--------|
+| **Files committed** | ✅ Done |
+| **Need to push** | ⏳ Next step |
+| **Get HF token** | ⏳ Next step |
+| **Push to Space** | ⏳ Next step |
+| **Wait for build** | ⏳ Then |
+| **Add GROQ_API_KEY** | ⏳ Then |
+| **Test app** | ⏳ Final |
+
+---
+
+## 🎯 Quick Commands
+
+```bash
+# Navigate to MediHelp
+cd /media/zunayed/HDD_code/chatbot\ with\ llm/MediHelp
+
+# Check what's committed
+git log --oneline -3
+
+# Set HF token (temporary)
+export HF_TOKEN=your_token_here
+
+# Push
+git push
+
+# Verify
+git status
+# Should show: "Your branch is up to date with 'origin/main'"
+```
+
+---
+
+## ⚠️ Troubleshooting
+
+### "No such device or address"
+- No internet connection
+- Network issue
+- Token not set
+
+**Solution:** Set token and try again
+
+### "Permission denied"
+- Wrong token
+- Wrong username
+- Invalid credentials
+
+**Solution:** Verify token at https://huggingface.co/settings/tokens
+
+### Build fails in HF Spaces
+- Check the build logs
+- Most likely causes:
+  - Docker issue (shouldn't happen - we tested)
+  - Missing environment variable (GROQ_API_KEY)
+
+---
+
+## 📞 Next Steps After Push
+
+1. **Watch build logs** (should succeed)
+2. **Add GROQ_API_KEY** to Space secrets
+3. **Test the app** at your Space URL
+4. **Share with friends!**
+
+---
+
+**Questions?** Check the deployment guides in the medical-predictor-chatbot directory:
+- `DEPLOYMENT_GO_NO_GO.md` - Overview
+- `HUGGING_FACE_DEPLOYMENT.md` - Full guide
+- `DEPLOYMENT_READINESS_AUDIT.md` - Technical details

app/__init__.py

@@ -0,0 +1,4 @@
+"""Medical Predictor Chatbot Application"""
+
+__version__ = "1.0.0"
+__author__ = "Medical AI Team"

app/api.py

@@ -0,0 +1,266 @@
+"""
+FastAPI REST API layer wrapping the existing medical chatbot logic.
+Converts the Gradio interface to a REST API for React frontend integration.
+"""
+
+import hashlib
+import logging
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, Dict, Any
+import json
+
+from app.main import (
+    chat_fn,
+    _load_state,
+    _save_state,
+    _parse_response,
+    _get_question_hint,
+)
+from app.services.llm_extractor import extract_features_from_text
+from app.services.feature_builder import count_collected_features, is_ready_for_prediction, prepare_feature_vector
+from app.services.predictor import get_predictor
+from app.memory import initialize_state, update_state, get_missing_features
+from app.config import DEFAULT_MODEL_FEATURES, MIN_FEATURES_FOR_PREDICTION, CLASS_NAMES
+from app.utils.helpers import generate_question, prioritize_features
+from app.services.session_manager import get_session_manager
+
+logger = logging.getLogger(__name__)
+
+# Initialize FastAPI
+app = FastAPI(title="Medical Diagnosis AI", description="REST API for medical health prediction")
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Session manager
+session_manager = get_session_manager()
+
+
+# ===== Request/Response Models =====
+
+class ChatRequest(BaseModel):
+    """Chat message request"""
+    session_id: Optional[str] = None
+    message: str
+    history: list = []
+
+
+class ChatResponse(BaseModel):
+    """Chat response with features and state"""
+    session_id: str
+    message: str
+    features: Dict[str, Any]
+    collected_count: int
+    total_features: int = 16
+    is_complete: bool
+    prediction: Optional[Dict[str, Any]] = None
+    hint: str = ""
+
+
+class ResetRequest(BaseModel):
+    """Reset session request"""
+    session_id: str
+
+
+class SessionStateResponse(BaseModel):
+    """Session state response"""
+    session_id: str
+    features: Dict[str, Any]
+    collected_count: int
+    total_features: int = 16
+
+
+# ===== Helper Functions =====
+
+def _build_acknowledgment(extracted: dict) -> str:
+    """Build acknowledgment message from extracted features"""
+    extracted_items = []
+    for feature, value in extracted.items():
+        if value is not None and feature in DEFAULT_MODEL_FEATURES:
+            extracted_items.append(f"{feature}: {value}")
+
+    if extracted_items:
+        return f"✓ Got your {', '.join(extracted_items[:2])}"
+    return ""
+
+
+# ===== API Endpoints =====
+
+@app.get("/health")
+def health_check():
+    """Health check endpoint"""
+    return {"status": "ok", "service": "Medical Diagnosis AI"}
+
+
+@app.post("/api/chat", response_model=ChatResponse)
+def chat_endpoint(req: ChatRequest):
+    """
+    Send a message and get AI response with updated features.
+
+    Handles:
+    - Session ID generation if not provided
+    - Feature extraction from user message
+    - State persistence
+    - Prediction when all 16 features collected
+    """
+    try:
+        # Generate or use session ID
+        if req.session_id:
+            session_id = req.session_id
+        else:
+            # Generate from first message hash
+            session_id = "sess_" + hashlib.md5(req.message.encode()).hexdigest()[:8]
+            logger.info(f"🔐 Created new session: {session_id}")
+
+        # Load persisted state
+        state = _load_state(session_id)
+
+        # Extract features from user message
+        extracted = extract_features_from_text(req.message)
+
+        # Update state with extracted features
+        state = update_state(state, extracted)
+
+        # Count collected features
+        collected = count_collected_features(state)
+        missing = get_missing_features(state)
+
+        # Check if ready for prediction
+        if is_ready_for_prediction(state, MIN_FEATURES_FOR_PREDICTION):
+            # All 16 features collected - make prediction
+            feature_vector = prepare_feature_vector(state)
+            predictor = get_predictor()
+            pred_result = predictor.predict(feature_vector)
+
+            pred_data = {
+                "prediction_class": int(pred_result.prediction),
+                "prediction_name": CLASS_NAMES[int(pred_result.prediction)],
+                "confidence": float(pred_result.probability),
+                "risk_level": pred_result.risk_level,
+                "explanation": pred_result.explanation,
+                "features": state
+            }
+
+            # Simple completion message - full details now in DiagnosisCard component
+            response_msg = "✅ Assessment Complete! Your diagnosis is ready below."
+
+            _save_state(session_id, state)
+
+            return ChatResponse(
+                session_id=session_id,
+                message=response_msg,
+                features=state,
+                collected_count=collected,
+                is_complete=True,
+                prediction=pred_data,
+                hint=""
+            )
+
+        # Not complete yet - ask for next missing feature
+        prioritized_missing = prioritize_features(missing)
+        next_question = generate_question(prioritized_missing[:1])
+        ack = _build_acknowledgment(extracted)
+        remaining = 16 - collected
+
+        response_msg = f"""{ack}
+
+{next_question}
+
+**{remaining} more pieces of information needed.**""" if ack else f"""{next_question}
+
+**{remaining} more pieces of information needed.**"""
+
+        # Get hint for the next question
+        hint = _get_question_hint(next_question)
+
+        _save_state(session_id, state)
+
+        return ChatResponse(
+            session_id=session_id,
+            message=response_msg,
+            features=state,
+            collected_count=collected,
+            is_complete=False,
+            hint=hint
+        )
+
+    except Exception as e:
+        logger.error(f"❌ Error in chat endpoint: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/reset")
+def reset_endpoint(req: ResetRequest):
+    """Reset a session - clear all features and start fresh"""
+    try:
+        session_manager = get_session_manager()
+        success = session_manager.reset_session(req.session_id)
+
+        if success:
+            logger.info(f"✅ Reset session {req.session_id}")
+            return {
+                "success": True,
+                "message": "Session reset successfully",
+                "session_id": req.session_id
+            }
+        else:
+            raise HTTPException(status_code=404, detail="Session not found")
+
+    except Exception as e:
+        logger.error(f"❌ Error resetting session: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/session/{session_id}", response_model=SessionStateResponse)
+def get_session_endpoint(session_id: str):
+    """Get current session state"""
+    try:
+        state = _load_state(session_id)
+        collected = count_collected_features(state)
+
+        return SessionStateResponse(
+            session_id=session_id,
+            features=state,
+            collected_count=collected
+        )
+
+    except Exception as e:
+        logger.error(f"❌ Error getting session: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/features")
+def get_features_list():
+    """Get list of all 16 features with their metadata"""
+    from app.config import FEATURE_RANGES
+
+    features_info = {}
+    for feature in DEFAULT_MODEL_FEATURES:
+        if feature in FEATURE_RANGES:
+            min_val, max_val, _ = FEATURE_RANGES[feature]
+            features_info[feature] = {
+                "min": min_val,
+                "max": max_val,
+                "type": "numeric" if feature not in ["Smoking", "Alcohol", "Family History"] else "binary"
+            }
+        else:
+            features_info[feature] = {"min": None, "max": None, "type": "unknown"}
+
+    return {
+        "total": len(DEFAULT_MODEL_FEATURES),
+        "features": DEFAULT_MODEL_FEATURES,
+        "metadata": features_info
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)

app/config.py

@@ -0,0 +1,93 @@
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment
+load_dotenv()
+
+# Paths - robust for both local and HF Spaces deployment
+BASE_DIR = Path(__file__).parent.parent
+
+# Try multiple possible model locations
+_possible_paths = [
+    BASE_DIR / "models" / "GradientBoosting_model.pkl",  # Local development
+    BASE_DIR / "model" / "GradientBoosting_model.pkl",   # If named 'model' instead
+    Path("/app/models/GradientBoosting_model.pkl"),      # HF Spaces absolute path
+    Path.cwd() / "models" / "GradientBoosting_model.pkl", # Current working directory
+]
+
+MODEL_PATH = None
+for path in _possible_paths:
+    if path.exists():
+        MODEL_PATH = path
+        break
+
+# Default to first path if none found (will error gracefully)
+if MODEL_PATH is None:
+    MODEL_PATH = _possible_paths[0]
+
+# Groq API configuration
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+GROQ_MODEL = "llama-3.1-70b-versatile"
+GROQ_TEMPERATURE = 0
+GROQ_TIMEOUT = 30
+
+# Medical features (all 16)
+DEFAULT_MODEL_FEATURES = [
+    "LengthOfStay",
+    "Smoking",
+    "Family History",
+    "HbA1c",
+    "Glucose",
+    "Age",
+    "Diet Score",
+    "Alcohol",
+    "Physical Activity",
+    "Blood Pressure",
+    "BMI",
+    "Cholesterol",
+    "Sleep Hours",
+    "Stress Level",
+    "Triglycerides",
+    "Oxygen Saturation"
+]
+
+# Feature validation ranges (min, max, expected type)
+FEATURE_RANGES = {
+    "Age": (0, 150, float),
+    "Glucose": (70, 400, float),
+    "HbA1c": (3, 15, float),
+    "BMI": (10, 60, float),
+    "Cholesterol": (100, 400, float),
+    "Triglycerides": (20, 500, float),
+    "Blood Pressure": (60, 200, float),
+    "Physical Activity": (0, 24, float),
+    "Sleep Hours": (0, 24, float),
+    "Stress Level": (1, 10, float),
+    "Diet Score": (1, 10, float),
+    "Smoking": (0, 1, int),
+    "Alcohol": (0, 1, int),
+    "Family History": (0, 1, int),
+    "LengthOfStay": (0, 365, int),
+    "Oxygen Saturation": (80, 100, float),
+}
+
+# Model configuration
+MIN_FEATURES_FOR_PREDICTION = 16  # Ask for all 16 features
+MAX_RETRIES = 3
+
+# Prediction classes
+CLASS_NAMES = [
+    "Arthritis",
+    "Asthma",
+    "Cancer",
+    "Diabetes",
+    "Healthy",
+    "Hypertension",
+    "Obesity",
+    "Other/Unknown",
+]
+
+# App configuration
+DEBUG_MODE = True
+CONVERSATION_MAX_TURNS = 20

app/main.py

@@ -0,0 +1,923 @@
+import gradio as gr
+import logging
+import json
+import re
+import hashlib
+from pathlib import Path
+from typing import List, Tuple
+
+from .services.llm_extractor import extract_features_from_text
+from .services.feature_builder import (
+    prepare_feature_vector,
+    count_collected_features,
+    is_ready_for_prediction
+)
+from .services.predictor import get_predictor
+from .services.session_manager import get_session_manager
+from .memory import initialize_state, update_state, get_missing_features
+from .utils.helpers import generate_question, prioritize_features
+from .config import DEFAULT_MODEL_FEATURES, MIN_FEATURES_FOR_PREDICTION, CLASS_NAMES
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# Session state storage
+SESSION_DIR = Path("/tmp/deepsense_sessions")
+SESSION_DIR.mkdir(exist_ok=True)
+
+# Session manager
+session_manager = get_session_manager()
+
+def _get_session_id(history: List) -> str:
+    """Generate session ID consistently across all turns
+
+    Key insight: In Gradio ChatInterface:
+    - Turn 1: history is empty
+    - Turn 2+: history contains all prior messages, starting with first user message
+
+    Strategy: When history is empty, use a temporary default and let it be overridden
+    on the next turn when we have the actual first message.
+    """
+    try:
+        first_msg = None
+
+        # If we have history, always use the first message (most reliable)
+        if history:
+            # Gradio 6 format: list of dicts with 'role' and 'content'
+            if isinstance(history[0], dict):
+                first_msg = history[0].get("content", "")
+            # Fallback for tuple format (Gradio 4 or mixed formats)
+            elif isinstance(history[0], (tuple, list)):
+                first_msg = history[0][0] if len(history[0]) > 0 else ""
+            else:
+                first_msg = str(history[0])
+
+        # Handle case where first_msg is a list (Gradio 6 content can be list)
+        if first_msg and isinstance(first_msg, list):
+            first_msg = str(first_msg[0]) if first_msg else ""
+
+        first_msg = str(first_msg) if first_msg else "default"
+
+        # Generate session ID from first message hash
+        session_id = "sess_" + hashlib.md5(first_msg.encode()).hexdigest()[:8]
+        logger.debug(f"🔐 Session ID: {session_id} (from message: {first_msg[:50]}...)")
+        return session_id
+
+    except Exception as e:
+        logger.warning(f"⚠️  Error generating session ID: {e}")
+        return "sess_error"
+
+def _load_state(session_id: str) -> dict:
+    """Load state from file with detailed logging and error handling"""
+    try:
+        path = SESSION_DIR / f"{session_id}.json"
+        if path.exists():
+            with open(path, 'r') as f:
+                state_data = json.load(f)
+                collected = sum(1 for v in state_data.values() if v is not None)
+                logger.info(f"📂 Loaded session {session_id}: {collected}/16 features")
+                return state_data
+        else:
+            logger.info(f"📂 New session {session_id} (no prior file)")
+            return initialize_state()
+    except Exception as e:
+        logger.error(f"❌ Error loading state: {e} - creating fresh state")
+        return initialize_state()
+
+def _save_state(session_id: str, state: dict):
+    """Save state to file with detailed logging and proper error handling"""
+    try:
+        path = SESSION_DIR / f"{session_id}.json"
+        with open(path, 'w') as f:
+            json.dump(state, f)
+        collected = sum(1 for v in state.values() if v is not None)
+        logger.info(f"💾 Saved session {session_id}: {collected}/16 features to {path}")
+    except Exception as e:
+        logger.error(f"❌ Error saving state to {path}: {e}")
+
+
+def _handle_simple_response(message: str, feature: str) -> dict:
+    """
+    Handle simple yes/no responses for binary features and numeric responses.
+    Maps responses like 'yes', 'no', '45', '10 days', etc. to feature values.
+
+    Args:
+        message: User's message
+        feature: Feature name being asked about
+
+    Returns:
+        Dictionary with feature mapped to value, or empty dict if not extractable
+    """
+    import re
+
+    msg_lower = message.lower().strip()
+
+    # Binary features: Smoking, Alcohol, Family History
+    if feature in ["Smoking", "Alcohol", "Family History"]:
+        if any(word in msg_lower for word in ["yes", "yep", "yeah", "yea", "true", "i have", "i do", "positive"]):
+            return {feature: 1}
+        elif any(word in msg_lower for word in ["no", "nope", "nah", "false", "i don't", "i do not", "negative", "neither"]):
+            return {feature: 0}
+
+    # Numeric features - extract first number from message
+    numeric_features = [
+        "Age", "Glucose", "HbA1c", "BMI", "Cholesterol", "Triglycerides",
+        "Blood Pressure", "Physical Activity", "Sleep Hours", "Stress Level",
+        "Diet Score", "LengthOfStay", "Oxygen Saturation"
+    ]
+
+    if feature in numeric_features:
+        # Try to extract a number from the message
+        numbers = re.findall(r"[-+]?\d*\.?\d+", message)
+        if numbers:
+            try:
+                value = float(numbers[0]) if "." in numbers[0] else int(numbers[0])
+                logger.debug(f"✅ Extracted {feature} = {value} from simple response")
+                return {feature: value}
+            except (ValueError, IndexError):
+                pass
+
+    return {}
+
+
+def _extract_previously_asked_features(history: List[Tuple[str, str]]) -> set:
+    """
+    Extract what features have already been asked about in the conversation.
+    This prevents repetition.
+
+    Args:
+        history: Conversation history (list of tuples)
+
+    Returns:
+        Set of features that have been asked about
+    """
+    asked_features = set()
+    if not history:
+        return asked_features
+
+    question_keywords = {
+        "Age": ["age", "years old"],
+        "BloodPressure": ["blood pressure", "bp"],
+        "Glucose": ["glucose", "blood sugar"],
+        "BMI": ["bmi", "body mass"],
+        "Cholesterol": ["cholesterol"],
+        "HbA1c": ["hba1c", "hemoglobin"],
+        "Triglycerides": ["triglycerides"],
+        "Smoking": ["smoke", "smoking"],
+        "Alcohol": ["drink", "alcohol"],
+        "PhysicalActivity": ["exercise", "activity", "workout"],
+        "SleepHours": ["sleep", "hours of sleep"],
+        "StressLevel": ["stress"],
+        "DietScore": ["diet", "nutrition"],
+        "FamilyHistory": ["family history", "disease history"],
+        "LengthOfStay": ["hospital", "stay", "days"],
+        "OxygenSaturation": ["oxygen", "saturation"],
+    }
+
+    try:
+        # Check bot's previous questions (Gradio 6 format)
+        for item in history:
+            try:
+                # Gradio 6: dict with 'role' and 'content'
+                if isinstance(item, dict):
+                    if item.get("role") == "assistant":
+                        bot_response = item.get("content", "")
+                    else:
+                        continue
+                # Fallback for tuple format
+                elif isinstance(item, (list, tuple)) and len(item) >= 2:
+                    _, bot_response = item[0], item[1]
+                else:
+                    continue
+
+                if bot_response:
+                    response_lower = str(bot_response).lower()
+                    for feature, keywords in question_keywords.items():
+                        for keyword in keywords:
+                            if keyword in response_lower:
+                                asked_features.add(feature)
+                                break
+            except (ValueError, IndexError, TypeError):
+                # Skip malformed history items
+                continue
+
+        return asked_features
+    except Exception as e:
+        logger.warning(f"⚠️  Error extracting asked features: {e}")
+        return set()
+
+
+def chat_fn(message: str, history: List[Tuple[str, str]]) -> str:
+    """
+    Main chat function for Gradio ChatInterface.
+
+    Orchestrates the complete conversation flow:
+    1. Extract features from user input (Groq LLM)
+    2. For simple yes/no to binary features, use pattern matching
+    3. Update memory with extracted features
+    4. Check for missing features
+    5. If all features ready, make prediction
+    6. Otherwise, ask for next missing feature
+
+    Args:
+        message: User's current message
+        history: Conversation history (not used but required by Gradio)
+
+    Returns:
+        Bot response (question or prediction)
+    """
+    try:
+        # Get/create session and load persisted state
+        # If history is empty (Turn 1), use current message for consistent session ID
+        if not history:
+            # Generate session_id from first user message to ensure consistency across turns
+            session_id = "sess_" + hashlib.md5(message.encode()).hexdigest()[:8]
+            logger.debug(f"🔐 Turn 1 Session ID: {session_id} (from current message)")
+        else:
+            # Turn 2+: Use first message from history
+            session_id = _get_session_id(history)
+
+        state = _load_state(session_id)
+
+        # Normalize message
+        msg_lower = message.lower().strip()
+
+        # Check if conversation has started (by checking if state has any data)
+        collected = count_collected_features(state)
+        is_first_message = collected == 0  # True only if no features collected yet
+        conversation_active = collected > 0
+        previously_asked = _extract_previously_asked_features(history) if history else set()
+
+        # Track last asked feature for simple response matching
+        last_asked_feature = None
+
+        # First message greeting (ONLY if truly first message AND looks like greeting)
+        if is_first_message and len(msg_lower.split()) <= 6:  # Short messages are likely greetings
+            logger.info("🎯 Starting new conversation")
+
+            # Check if it's a simple greeting
+            greeting_words = ["hello", "hi", "hey", "good morning", "good afternoon", "good evening", "name is", "i am", "i'm"]
+            if any(word in msg_lower for word in greeting_words):
+                # Extract name if mentioned (letters only, not numbers)
+                name_match = re.search(r"(?:i'm|i am|my name is|name's)\s+([a-z]+)", msg_lower)
+                user_name = name_match.group(1).capitalize() if name_match else "there"
+
+                greeting_response = f"Hi {user_name}! Nice to meet you. 😊\n\n"
+                greeting_response += """I'm here to help build your health profile. We'll gather 16 key health metrics in a natural, conversational way.
+
+**To get started: What is your age?**"""
+                _save_state(session_id, state)
+                return _format_response(state, greeting_response)
+
+        # Handle mid-conversation greetings (don't reset, reference last topic)
+        if conversation_active:
+            greeting_words = ["hello", "hi", "hey", "good morning", "good afternoon", "good evening"]
+            if any(word in msg_lower for word in greeting_words) and len(msg_lower.split()) <= 3:
+                # It's a simple greeting mid-conversation, don't reset
+                last_bot_message = history[-1][1] if history else ""
+                context = "your health profile"
+                if "age" in last_bot_message.lower():
+                    context = "your age"
+                elif "blood pressure" in last_bot_message.lower():
+                    context = "your blood pressure"
+                elif "glucose" in last_bot_message.lower():
+                    context = "your glucose level"
+
+                continuation = f"Hey! We were just talking about {context}. Do you have those numbers for me?"
+                _save_state(session_id, state)
+                return _format_response(state, continuation)
+
+        # Handle reset command
+        if msg_lower in ["reset", "clear", "new", "start over", "/reset"]:
+            state = initialize_state()  # Fresh state
+            _save_state(session_id, state)
+            reset_msg = """Let's start fresh! 🌟
+
+I'm ready to help build your health profile again. Just share your health information naturally, like:
+- "I'm 45 years old and my glucose is 150"
+- "I smoke and my stress level is 8"
+- "My BMI is 28 and I exercise 5 hours per week"
+
+What would you like to share first?"""
+            return _format_response(state, reset_msg)
+
+        # Step 1: Extract features (with safety)
+        logger.info(f"👤 User: {message}")
+        try:
+            extracted = extract_features_from_text(message)
+            if not extracted:
+                extracted = {f: None for f in DEFAULT_MODEL_FEATURES}
+        except Exception as e:
+            logger.warning(f"Extraction failed: {e}, using empty")
+            extracted = {f: None for f in DEFAULT_MODEL_FEATURES}
+
+        logger.info(f"📊 Extracted: {[k for k,v in extracted.items() if v]}")
+
+        # Step 1.5: Check if any features were extracted
+        features_extracted = sum(1 for v in extracted.values() if v is not None)
+        if features_extracted == 0:
+            logger.debug(f"⚠️  No features extracted from: {message}")
+
+        # Step 1b: If extraction didn't work and we asked about a feature, use simple pattern matching
+        if last_asked_feature and all(v is None for v in extracted.values()):
+            simple_response = _handle_simple_response(message, last_asked_feature)
+            if simple_response:
+                logger.info(f"✅ Matched simple response for {last_asked_feature}")
+                extracted.update(simple_response)
+
+        # Step 2: Update memory with extracted features (safe)
+        try:
+            state = update_state(state, extracted)
+            collected = count_collected_features(state)
+            logger.info(f"💾 Collected: {collected}/16")
+
+            # Verify state integrity
+            if state is None:
+                logger.error("❌ State became None after update!")
+                state = initialize_state()
+            if not isinstance(state, dict):
+                logger.error(f"❌ State is not a dict: {type(state)}")
+                state = initialize_state()
+
+        except Exception as e:
+            logger.error(f"State update failed: {e}")
+            state = initialize_state()
+            collected = 0
+
+        # Step 3: Check for missing features
+        missing = get_missing_features(state)
+
+        # Step 3.5: Smart handling - if nothing extracted and no features collected yet
+        if features_extracted == 0 and collected == 0:
+            logger.info("⚠️  User input is non-medical. Prompting for medical information with positive frame.")
+            non_medical_msg = """I'm here to help build your health profile. To get started, could you tell me your age or any health details you'd like to share?
+
+For example: "I'm 45 years old" or "My glucose is 150" — anything you're comfortable sharing helps!"""
+            return _format_response(state, non_medical_msg)
+
+        # Step 4: Decision - Can we make a prediction?
+        if len(missing) == 0 or is_ready_for_prediction(state, MIN_FEATURES_FOR_PREDICTION):
+            logger.info("🎯 All features collected! Making prediction...")
+            last_asked_feature = None
+            return _make_prediction(state, session_id)
+
+        # Step 5: Not ready yet - ask for next missing features (1-2 at a time)
+        else:
+            if missing:
+                last_asked_feature = missing[0]
+            question_text = _ask_next_question(missing, len(missing), extracted)
+            _save_state(session_id, state)  # Save state before returning
+            return _format_response(state, "", question_text)
+
+    except Exception as e:
+        logger.error(f"❌ Error in chat: {e}", exc_info=True)
+        logger.error(f"   History type: {type(history)}, length: {len(history) if history else 0}")
+        logger.error(f"   State type: {type(state)}")
+        logger.error(f"   Message: {message}")
+
+        # Return user-friendly error message
+        error_msg = "I encountered an issue processing your message. Could you try again or rephrase?"
+        return _format_response(state or initialize_state(), error_msg)
+
+
+def _make_prediction(state: dict, session_id: str = None) -> str:
+    """
+    Make ML prediction once all features are collected.
+
+    Args:
+        state: Dictionary with all medical features
+        session_id: Session ID for saving final state
+
+    Returns:
+        Formatted prediction result message
+    """
+    try:
+        # Prepare feature vector for ML model
+        feature_vector = prepare_feature_vector(state)
+        logger.info(f"🔢 Feature vector prepared: {feature_vector}")
+
+        # Get predictor and make prediction
+        predictor = get_predictor()
+        result = predictor.predict(feature_vector)
+
+        # Format response
+        class_name = CLASS_NAMES[result.prediction] if result.prediction < len(CLASS_NAMES) else "Unknown"
+
+        response = f"""
+✅ **All Information Collected!**
+
+---
+
+### 🏥 Prediction Results
+
+**Predicted Condition:** {class_name}
+**Confidence Level:** {result.probability*100:.1f}%
+**Risk Assessment:** **{result.risk_level}**
+
+**Details:** {result.explanation}
+
+---
+
+### 📋 Features Used for Prediction:
+"""
+        # Add feature summary
+        for feature in DEFAULT_MODEL_FEATURES:
+            value = state.get(feature)
+            response += f"\n• **{feature}:** {value if value is not None else 'Not provided'}"
+
+        response += """
+
+---
+
+### ⚠️ Important Disclaimer
+**This is a demonstration tool only.** The prediction should never be used as a substitute for professional medical advice. Please consult with a qualified healthcare professional to discuss these results and your health concerns.
+
+---
+
+**Thank you for providing this information. Your health matters!**
+"""
+
+        # Add JSON output for backend processing
+        json_output = {
+            "FINAL_DATA": {
+                "prediction_class": result.prediction,
+                "prediction_name": class_name,
+                "confidence": round(result.probability * 100, 1),
+                "risk_level": result.risk_level,
+                "features": state.copy()
+            }
+        }
+
+        # Add JSON to response (for backend to capture)
+        response += f"\n\n```json\n{json.dumps(json_output, indent=2)}\n```"
+
+        logger.info("✅ Prediction completed successfully")
+        if session_id:
+            _save_state(session_id, state)  # Save final state
+        return _format_response(state, response)
+
+    except Exception as e:
+        logger.error(f"❌ Prediction error: {e}", exc_info=True)
+        return f"❌ Error making prediction: {str(e)}. Please try again."
+
+
+def _format_response(current_state: dict, acknowledgment: str = "", question: str = "") -> str:
+    """
+    Format response: ALWAYS show DATA_STATE JSON + RESPONSE text
+    """
+    # Build JSON state
+    data_state = {}
+    for feature in DEFAULT_MODEL_FEATURES:
+        value = current_state.get(feature)
+        data_state[feature] = value
+
+    json_state = json.dumps(data_state)
+
+    # Build response text
+    response_text = acknowledgment
+    if question:
+        if acknowledgment:
+            response_text += f"\n\n{question}"
+        else:
+            response_text = question
+
+    # ALWAYS show both DATA_STATE and RESPONSE
+    formatted = f"""DATA_STATE: {json_state}
+
+RESPONSE: {response_text}"""
+
+    return formatted
+
+
+def _ask_next_question(missing_features: list, count_missing: int, last_extracted: dict = None) -> str:
+    """
+    Generate professional response asking for next missing features (1-2 at a time).
+    Follows the Medical Data Analyst protocol with structured output.
+
+    Args:
+        missing_features: List of missing feature names
+        count_missing: Count of missing features
+        last_extracted: Dictionary of features just extracted
+
+    Returns:
+        Formatted response with internal state and assistant message
+    """
+    try:
+        # Build acknowledgment of what was received
+        acknowledgment = ""
+        if last_extracted and any(v is not None for v in last_extracted.values()):
+            extracted_items = []
+            for k, v in last_extracted.items():
+                if v is not None:
+                    # Format value nicely
+                    if v in [0, 1]:
+                        display_val = "Yes" if v == 1 else "No"
+                    else:
+                        display_val = f"{v}"
+                    extracted_items.append(f"{k} of {display_val}")
+
+            if extracted_items:
+                acknowledgment = f"✓ I've noted your {' and '.join(extracted_items)}."
+
+        # Prioritize next questions
+        prioritized_missing = prioritize_features(missing_features)
+        next_questions = generate_question(prioritized_missing[:2])
+
+        progress = f"**{count_missing} more pieces of information needed to complete your profile.**"
+
+        full_question = f"{next_questions}\n\n{progress}"
+
+        logger.info(f"❓ Asking for: {prioritized_missing[0] if prioritized_missing else 'unknown'}")
+        return full_question
+
+    except Exception as e:
+        logger.error(f"❌ Error generating question: {e}", exc_info=True)
+        return "❌ Error generating question. Please try again."
+
+
+def reset_session(history: List) -> List:
+    """
+    Reset current session: clear all data and start fresh
+
+    Args:
+        history: Chat history (used to get session ID)
+
+    Returns:
+        New history with reset confirmation message
+    """
+    try:
+        session_id = _get_session_id(history)
+
+        # Reset session in manager
+        success = session_manager.reset_session(session_id)
+
+        if success:
+            reset_msg = """🔄 **Session Reset Successfully!**
+
+Your health profile has been cleared. Let's start fresh with a new assessment.
+
+Just introduce yourself and tell me about your health:
+- "Hi, I'm John, 45 years old, my glucose is 150"
+- "I'm Sarah, smoke occasionally, stress level is 8"
+- Or any other health information you'd like to share"""
+
+            logger.info(f"✅ Session {session_id} reset by user")
+
+            # Return new history with reset message (Gradio 6 format)
+            return [{"role": "assistant", "content": reset_msg}]
+        else:
+            return [{"role": "assistant", "content": "❌ Error resetting session. Please try again."}]
+
+    except Exception as e:
+        logger.error(f"❌ Error in reset_session: {e}")
+        return [{"role": "assistant", "content": f"❌ Error: {str(e)}"}]
+
+
+def _parse_response(raw: str) -> tuple:
+    """
+    Parse the raw chat_fn output to extract clean response and data state.
+
+    Input format: "DATA_STATE: {...}\n\nRESPONSE: <text>"
+    Returns: (clean_response_text, data_state_dict)
+    """
+    data_state = {}
+    response = raw
+
+    if "DATA_STATE:" in raw and "RESPONSE:" in raw:
+        try:
+            parts = raw.split("RESPONSE:", 1)
+            data_part = parts[0].replace("DATA_STATE:", "").strip()
+            response = parts[1].strip()
+            data_state = json.loads(data_part)
+        except (json.JSONDecodeError, IndexError):
+            logger.warning(f"Could not parse DATA_STATE from response")
+            data_state = {f: None for f in DEFAULT_MODEL_FEATURES}
+
+    return response, data_state
+
+
+def _get_question_hint(response: str) -> str:
+    """
+    Extract hint text based on which feature is being asked in the bot's response.
+    Matches feature names in the response text.
+    """
+    hints = {
+        "Blood Pressure": "Systolic pressure (e.g., 120). Normal: 90-120 mmHg.",
+        "Glucose": "Blood glucose in mg/dL (e.g., 100). Normal: 70-140.",
+        "HbA1c": "HbA1c percentage (e.g., 5.5%). Normal: 4-6%.",
+        "BMI": "Body Mass Index (e.g., 25). Normal: 18.5-24.9.",
+        "Age": "Age in years (e.g., 34). Range: 18-100.",
+        "Cholesterol": "Total cholesterol in mg/dL (e.g., 180). Normal: <200.",
+        "Triglycerides": "Triglycerides in mg/dL (e.g., 150). Normal: <150.",
+        "Oxygen Saturation": "SpO2 percentage (example: 98). Normal: 95-100%.",
+        "Sleep Hours": "Hours of sleep per night (e.g., 7). Normal: 6-9.",
+        "Stress Level": "Stress level 1-10 (e.g., 5). 1=very low, 10=very high.",
+        "Physical Activity": "Exercise hours per week (e.g., 5).",
+        "Diet Score": "Diet quality 1-10 (e.g., 7). 1=poor, 10=excellent.",
+        "Smoking": "Do you smoke? Answer yes or no.",
+        "Alcohol": "Do you drink alcohol? Answer yes or no.",
+        "Family History": "Family history of disease? Answer yes or no.",
+        "LengthOfStay": "Hospital stay in days (e.g., 3). Enter 0 if not hospitalized.",
+    }
+
+    response_lower = response.lower()
+    for feature, hint in hints.items():
+        if feature.lower() in response_lower:
+            return hint
+
+    return "Type your response naturally or just enter a number."
+
+
+# Create Gradio UI with modern medical intake form design
+css_styling = """
+/* Base container */
+.gradio-container {
+    background: linear-gradient(135deg, #F5F3FF 0%, #FAF9FF 100%) !important;
+    max-width: 900px !important;
+    margin: auto !important;
+    padding: 1rem !important;
+}
+
+/* Header card */
+.header-card {
+    background: white;
+    border-radius: 16px;
+    box-shadow: 0 2px 12px rgba(124, 58, 237, 0.08);
+    padding: 2rem;
+    margin-bottom: 1.5rem;
+    text-align: center;
+}
+
+.app-title {
+    color: #7C3AED;
+    font-size: 2.2rem;
+    font-weight: 700;
+    margin: 0;
+    margin-bottom: 0.5rem;
+}
+
+.app-subtitle {
+    color: #999;
+    font-size: 0.95rem;
+    margin: 0;
+}
+
+/* Main form card */
+.form-card {
+    background: white;
+    border-radius: 16px;
+    box-shadow: 0 4px 24px rgba(124, 58, 237, 0.1);
+    padding: 2rem;
+}
+
+/* Question section header */
+.question-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+    padding-bottom: 1rem;
+    border-bottom: 2px solid #F0E7FF;
+}
+
+.header-label {
+    color: #7C3AED;
+    font-weight: 600;
+    font-size: 0.95rem;
+}
+
+.progress-label {
+    color: #7C3AED;
+    font-weight: 600;
+    font-size: 0.95rem;
+    text-align: right;
+}
+
+/* Progress bar */
+.progress-bar-container {
+    background: #EDE9FE;
+    border-radius: 4px;
+    height: 6px;
+    overflow: hidden;
+    margin-bottom: 1.5rem;
+}
+
+.progress-bar-fill {
+    height: 100%;
+    background: #7C3AED;
+    transition: width 0.3s ease;
+}
+
+/* Question text */
+.question-text {
+    font-size: 1.1rem;
+    color: #1F2937;
+    margin-bottom: 0.8rem;
+    line-height: 1.6;
+}
+
+/* Hint text */
+.hint-text {
+    color: #888;
+    font-size: 0.9rem;
+    margin-bottom: 1.5rem;
+    padding: 0.75rem 1rem;
+    background: #F9F7FF;
+    border-left: 3px solid #DDD6FE;
+    border-radius: 4px;
+}
+
+/* Input and buttons */
+.input-group {
+    display: flex;
+    gap: 0.75rem;
+    margin-top: 1.5rem;
+}
+
+.input-box {
+    flex: 1;
+}
+
+.btn-new {
+    background: white !important;
+    border: 1px solid #DDD !important;
+    border-radius: 8px !important;
+    color: #555 !important;
+    font-weight: 500 !important;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.btn-new:hover {
+    border-color: #7C3AED !important;
+    color: #7C3AED !important;
+}
+
+.btn-submit {
+    background: #7C3AED !important;
+    border: 0 !important;
+    border-radius: 8px !important;
+    color: white !important;
+    font-weight: 600 !important;
+    cursor: pointer;
+    transition: all 0.2s;
+}
+
+.btn-submit:hover {
+    background: #6D28D9 !important;
+    box-shadow: 0 4px 12px rgba(124, 58, 237, 0.3);
+}
+
+/* Disclaimer */
+.disclaimer {
+    text-align: center;
+    color: #999;
+    font-size: 0.85rem;
+    margin-top: 1rem;
+}
+
+/* Gradio textbox customization */
+.textbox-input input {
+    border-radius: 8px !important;
+    border: 1px solid #DDD !important;
+    padding: 0.75rem 1rem !important;
+    font-size: 0.95rem !important;
+}
+
+.textbox-input input:focus {
+    border-color: #7C3AED !important;
+    box-shadow: 0 0 0 3px rgba(124, 58, 237, 0.1) !important;
+}
+"""
+
+with gr.Blocks() as demo:
+    # State management
+    chat_history = gr.State([])
+
+    # Header section
+    gr.HTML("""
+    <div class="header-card">
+        <h1 class="app-title">Medical Diagnosis AI</h1>
+        <p class="app-subtitle">Clinical intake assessment powered by machine learning</p>
+    </div>
+    """)
+
+    # Main form card
+    with gr.Column(elem_classes="form-card"):
+        # Question header with progress
+        with gr.Row(elem_classes="question-header"):
+            header_label = gr.HTML('<div class="header-label">Medical Intake Assistant<br>Question 1 of 16</div>')
+            progress_label = gr.HTML('<div class="progress-label">0 / 16 questions</div>')
+
+        # Progress bar
+        gr.HTML('<div class="progress-bar-container"><div class="progress-bar-fill" id="progress-fill" style="width:0%"></div></div>')
+
+        # Question display
+        question_display = gr.Markdown(
+            "**Hi! I'm your Medical Intake Assistant. Let's begin your health assessment.**\n\n**What is your age?**",
+            elem_classes="question-text"
+        )
+
+        # Hint text
+        hint_display = gr.Markdown(
+            "Age in years (example: 34). Normal range: 18-100.",
+            elem_classes="hint-text"
+        )
+
+        # Input row
+        with gr.Row():
+            msg_input = gr.Textbox(
+                placeholder="Enter your response...",
+                show_label=False,
+                lines=1,
+                elem_classes="textbox-input",
+                scale=8
+            )
+            new_btn = gr.Button("New", scale=1, elem_classes="btn-new")
+            submit_btn = gr.Button("▶", scale=1, elem_classes="btn-submit")
+
+        # Hidden chatbot for state management
+        chatbot = gr.Chatbot(visible=False)
+
+        # Disclaimer
+        gr.HTML('<div class="disclaimer">⚠️ This is a demonstration tool. Always consult with healthcare professionals for medical decisions.</div>')
+
+    # Event handler for submission
+    def handle_submission(message, history):
+        """Process user input and return updated UI elements"""
+        if not message or not message.strip():
+            return (
+                history,  # Updated history
+                "Please enter a response.",  # Question display
+                "Try entering your answer.",  # Hint
+                "",  # Clear input
+                "0 / 16"  # Progress
+            )
+
+        # Call the existing chat function
+        raw_response = chat_fn(message, history)
+        clean_response, data_state = _parse_response(raw_response)
+
+        # Update history
+        new_history = history + [
+            {"role": "user", "content": message},
+            {"role": "assistant", "content": clean_response}
+        ]
+
+        # Calculate progress
+        collected = sum(1 for v in data_state.values() if v is not None)
+        progress_text = f"{collected} / 16"
+
+        # Get hint for next question
+        hint_text = _get_question_hint(clean_response)
+
+        logger.info(f"📊 Progress: {collected}/16")
+
+        return (
+            new_history,
+            clean_response,
+            hint_text,
+            "",  # Clear input for next message
+            progress_text
+        )
+
+    # Handle Enter key and submit button
+    submit_btn.click(
+        fn=handle_submission,
+        inputs=[msg_input, chatbot],
+        outputs=[chatbot, question_display, hint_display, msg_input, progress_label],
+        queue=True
+    )
+
+    msg_input.submit(
+        fn=handle_submission,
+        inputs=[msg_input, chatbot],
+        outputs=[chatbot, question_display, hint_display, msg_input, progress_label],
+        queue=True
+    )
+
+    # Reset button handler
+    def reset_conversation():
+        """Reset the conversation"""
+        reset_history = reset_session([])
+        return (
+            reset_history,  # Reset history
+            "**Hi! I'm your Medical Intake Assistant. Let's begin your health assessment.**\n\n**What is your age?**",
+            "Age in years (example: 34). Normal range: 18-100.",
+            "",
+            "0 / 16"
+        )
+
+    new_btn.click(
+        fn=reset_conversation,
+        outputs=[chatbot, question_display, hint_display, msg_input, progress_label],
+        queue=False
+    )
+
+if __name__ == "__main__":
+    logger.info("🚀 Starting Medical Predictor Chatbot...")
+    demo.launch()

app/memory.py

@@ -0,0 +1,97 @@
+import logging
+from typing import Dict, Any
+
+from app.config import DEFAULT_MODEL_FEATURES, FEATURE_RANGES
+
+logger = logging.getLogger(__name__)
+
+
+def initialize_state() -> Dict[str, Any]:
+    """
+    Initialize conversation state with all 16 features set to None.
+
+    Returns:
+        Dictionary with all features initialized to None
+    """
+    state = {feature: None for feature in DEFAULT_MODEL_FEATURES}
+    logger.debug(f"✅ State initialized with {len(state)} features")
+    return state
+
+
+def update_state(state: dict, new_data: dict) -> dict:
+    """
+    Merge newly extracted values into memory.
+    Only updates non-null values (preserves existing data).
+    Validates values are within acceptable ranges.
+
+    Args:
+        state: Current state dictionary
+        new_data: Dictionary with newly extracted features
+
+    Returns:
+        Updated state dictionary
+    """
+    updated_count = 0
+    for key, value in new_data.items():
+        if value is not None:
+            # Validate value is in acceptable range
+            if key in FEATURE_RANGES:
+                min_val, max_val, expected_type = FEATURE_RANGES[key]
+                try:
+                    converted = expected_type(value)
+                    # Check range
+                    if not (min_val <= converted <= max_val):
+                        logger.debug(f"   SKIPPED {key}={value} (out of range [{min_val}, {max_val}])")
+                        continue
+                    value = converted
+                except (ValueError, TypeError):
+                    logger.debug(f"   SKIPPED {key}={value} (invalid type)")
+                    continue
+
+            old_value = state.get(key)
+            state[key] = value
+            if old_value != value:
+                logger.debug(f"   Updated {key}: {old_value} → {value}")
+                updated_count += 1
+
+    if updated_count > 0:
+        logger.debug(f"✅ State updated: {updated_count} features changed")
+    return state
+
+
+def get_missing_features(state: dict) -> list:
+    """
+    Return list of features that are still missing (None).
+
+    Args:
+        state: Current state dictionary
+
+    Returns:
+        List of feature names with None values
+    """
+    missing = [k for k, v in state.items() if v is None]
+    logger.debug(f"❓ Missing features: {len(missing)}/16 - {missing[:3]}{'...' if len(missing) > 3 else ''}")
+    return missing
+
+
+def get_state_summary(state: dict) -> Dict[str, Any]:
+    """
+    Get a summary of current state.
+
+    Args:
+        state: Current state dictionary
+
+    Returns:
+        Summary with counts and status
+    """
+    total = len(state)
+    collected = sum(1 for v in state.values() if v is not None)
+    missing = total - collected
+
+    return {
+        "total_features": total,
+        "collected": collected,
+        "missing": missing,
+        "percentage": (collected / total * 100) if total > 0 else 0,
+        "state": state.copy()
+    }

app/schemas.py

@@ -0,0 +1,146 @@
+from typing import Optional
+from pydantic import BaseModel, field_validator
+
+
+class MedicalFeatures(BaseModel):
+    """All 16 required medical features with validation"""
+
+    Age: Optional[float] = None
+    Glucose: Optional[float] = None
+    HbA1c: Optional[float] = None
+    BMI: Optional[float] = None
+    Cholesterol: Optional[float] = None
+    Triglycerides: Optional[float] = None
+    Blood_Pressure: Optional[float] = None
+    Physical_Activity: Optional[float] = None
+    Sleep_Hours: Optional[float] = None
+    Stress_Level: Optional[float] = None
+    Diet_Score: Optional[float] = None
+    Smoking: Optional[int] = None
+    Alcohol: Optional[int] = None
+    Family_History: Optional[int] = None
+    LengthOfStay: Optional[int] = None
+    Oxygen_Saturation: Optional[float] = None
+
+    @field_validator("Age")
+    @classmethod
+    def validate_age(cls, v):
+        if v is not None and not (0 <= v <= 150):
+            raise ValueError("Age must be between 0 and 150")
+        return v
+
+    @field_validator("Glucose")
+    @classmethod
+    def validate_glucose(cls, v):
+        if v is not None and not (70 <= v <= 400):
+            raise ValueError("Glucose must be between 70 and 400")
+        return v
+
+    @field_validator("HbA1c")
+    @classmethod
+    def validate_hba1c(cls, v):
+        if v is not None and not (3 <= v <= 15):
+            raise ValueError("HbA1c must be between 3 and 15")
+        return v
+
+    @field_validator("BMI")
+    @classmethod
+    def validate_bmi(cls, v):
+        if v is not None and not (10 <= v <= 60):
+            raise ValueError("BMI must be between 10 and 60")
+        return v
+
+    @field_validator("Cholesterol")
+    @classmethod
+    def validate_cholesterol(cls, v):
+        if v is not None and not (100 <= v <= 400):
+            raise ValueError("Cholesterol must be between 100 and 400")
+        return v
+
+    @field_validator("Triglycerides")
+    @classmethod
+    def validate_triglycerides(cls, v):
+        if v is not None and not (20 <= v <= 500):
+            raise ValueError("Triglycerides must be between 20 and 500")
+        return v
+
+    @field_validator("Blood_Pressure")
+    @classmethod
+    def validate_blood_pressure(cls, v):
+        if v is not None and not (60 <= v <= 200):
+            raise ValueError("Blood Pressure must be between 60 and 200")
+        return v
+
+    @field_validator("Physical_Activity")
+    @classmethod
+    def validate_physical_activity(cls, v):
+        if v is not None and not (0 <= v <= 24):
+            raise ValueError("Physical Activity must be between 0 and 24 hours/week")
+        return v
+
+    @field_validator("Sleep_Hours")
+    @classmethod
+    def validate_sleep_hours(cls, v):
+        if v is not None and not (0 <= v <= 24):
+            raise ValueError("Sleep Hours must be between 0 and 24")
+        return v
+
+    @field_validator("Stress_Level")
+    @classmethod
+    def validate_stress_level(cls, v):
+        if v is not None and not (1 <= v <= 10):
+            raise ValueError("Stress Level must be between 1 and 10")
+        return v
+
+    @field_validator("Diet_Score")
+    @classmethod
+    def validate_diet_score(cls, v):
+        if v is not None and not (1 <= v <= 10):
+            raise ValueError("Diet Score must be between 1 and 10")
+        return v
+
+    @field_validator("Smoking", "Alcohol", "Family_History")
+    @classmethod
+    def validate_binary(cls, v):
+        if v is not None and v not in (0, 1):
+            raise ValueError("Binary values must be 0 or 1")
+        return v
+
+    @field_validator("LengthOfStay")
+    @classmethod
+    def validate_length_of_stay(cls, v):
+        if v is not None and not (0 <= v <= 365):
+            raise ValueError("Length of Stay must be between 0 and 365 days")
+        return v
+
+    @field_validator("Oxygen_Saturation")
+    @classmethod
+    def validate_oxygen_saturation(cls, v):
+        if v is not None and not (80 <= v <= 100):
+            raise ValueError("Oxygen Saturation must be between 80 and 100%")
+        return v
+
+    class Config:
+        use_enum_values = True
+
+
+class PredictionRequest(BaseModel):
+    """Request for prediction"""
+
+    features: MedicalFeatures
+
+
+class PredictionResponse(BaseModel):
+    """Prediction response with confidence"""
+
+    prediction: int  # 0 or 1 (disease class)
+    probability: float  # 0.0 to 1.0
+    risk_level: str  # "Low", "Medium", "High"
+    explanation: str
+
+
+class ExtractionResponse(BaseModel):
+    """LLM extraction response"""
+
+    extracted_features: MedicalFeatures
+    confidence: float

app/services/__init__.py

@@ -0,0 +1,12 @@
+"""Services module for Medical Predictor Chatbot"""
+
+from app.services.llm_extractor import extract_features_from_text
+from app.services.feature_builder import prepare_feature_vector, is_ready_for_prediction
+from app.services.predictor import get_predictor
+
+__all__ = [
+    "extract_features_from_text",
+    "prepare_feature_vector",
+    "is_ready_for_prediction",
+    "get_predictor",
+]

app/services/feature_builder.py

@@ -0,0 +1,122 @@
+import logging
+from typing import List, Dict, Any
+from app.config import FEATURE_RANGES, DEFAULT_MODEL_FEATURES
+
+logger = logging.getLogger(__name__)
+
+
+def validate_feature(name: str, value: Any) -> Any:
+    """
+    Validate a single feature value against its constraints.
+
+    Args:
+        name: Feature name
+        value: Value to validate
+
+    Returns:
+        Validated value or None if invalid
+    """
+    if value is None:
+        return None
+
+    if name not in FEATURE_RANGES:
+        return None
+
+    min_val, max_val, expected_type = FEATURE_RANGES[name]
+
+    # Convert to expected type
+    try:
+        converted = expected_type(value)
+    except (ValueError, TypeError):
+        logger.warning(f"Could not convert {name}={value} to {expected_type}")
+        return None
+
+    # Check range
+    if not (min_val <= converted <= max_val):
+        logger.warning(f"{name}={converted} is outside valid range [{min_val}, {max_val}]")
+        return None
+
+    return converted
+
+
+def prepare_features_dict(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Validate and prepare features dictionary.
+
+    Args:
+        state: Dictionary of features from memory
+
+    Returns:
+        Dictionary with validated features
+    """
+    validated = {}
+
+    for feature in DEFAULT_MODEL_FEATURES:
+        value = state.get(feature)
+        validated[feature] = validate_feature(feature, value)
+
+    return validated
+
+
+def prepare_feature_vector(state: Dict[str, Any]) -> List[float]:
+    """
+    Convert state dict to feature vector for ML model.
+
+    The vector must have features in the exact order expected by the model.
+    Features are ordered as in DEFAULT_MODEL_FEATURES.
+    Missing values are filled with 0.0 (neutral value).
+
+    Args:
+        state: Dictionary with feature values from memory
+
+    Returns:
+        List of 16 floats ready for ML model prediction
+    """
+    # Define feature order (MUST match training data order)
+    feature_order = DEFAULT_MODEL_FEATURES
+
+    vector = []
+
+    for feature_name in feature_order:
+        value = state.get(feature_name)
+
+        if value is not None:
+            try:
+                vector.append(float(value))
+            except (ValueError, TypeError):
+                logger.warning(f"Could not convert {feature_name}={value} to float, using 0.0")
+                vector.append(0.0)
+        else:
+            # Use 0.0 for missing values (neutral/default)
+            vector.append(0.0)
+
+    assert len(vector) == 16, f"Expected 16 features, got {len(vector)}"
+    return vector
+
+
+def count_collected_features(state: Dict[str, Any]) -> int:
+    """
+    Count how many features have been collected (non-null).
+
+    Args:
+        state: Dictionary with feature values
+
+    Returns:
+        Count of non-null features
+    """
+    return sum(1 for v in state.values() if v is not None)
+
+
+def is_ready_for_prediction(state: Dict[str, Any], min_features: int = 14) -> bool:
+    """
+    Check if enough features collected for reliable prediction.
+
+    Args:
+        state: Dictionary with feature values
+        min_features: Minimum features needed (default 14/16)
+
+    Returns:
+        True if ready for prediction
+    """
+    collected = count_collected_features(state)
+    return collected >= min_features

app/services/llm_extractor.py

@@ -0,0 +1,508 @@
+import os
+import json
+import logging
+import re
+from groq import Groq
+from dotenv import load_dotenv
+
+from app.config import GROQ_API_KEY, GROQ_MODEL, GROQ_TEMPERATURE, DEFAULT_MODEL_FEATURES
+
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+# Initialize client (GLOBAL)
+try:
+    client = Groq(api_key=GROQ_API_KEY)
+    logger.info("✅ Groq client initialized")
+except Exception as e:
+    logger.error(f"❌ Failed to initialize Groq client: {e}")
+    client = None
+
+
+def _extract_with_regex(user_input: str, aggressive: bool = True) -> dict:
+    """
+    SMART regex-based extraction with flexible patterns.
+    Handles: verb tenses (is/was/being), connecting words (a/up to/hit),
+    corrections (put 0/actually/not X), and multiple features in one sentence.
+
+    Args:
+        user_input: User's text input
+
+    Returns:
+        Dictionary with extracted features
+    """
+    result = {feature: None for feature in DEFAULT_MODEL_FEATURES}
+    text = user_input.lower()
+
+    # Helper function to extract a number safely with ultra-flexible matching
+    def extract_number(text, keyword_pattern, value_type=int, min_val=None, max_val=None, allow_float=False):
+        """Extract number with MAXIMUM flexibility for medical terminology.
+        Handles: all verb tenses, multiple connectors, adverbs, typos, and word order variations."""
+
+        # Comprehensive verb tenses and action words
+        verbs = r'(?:is|was|were|being|am|are|equals|measure|measured|measures|rate|rated|rates|hit|reached|have|has|say|saying|said|indicate|indicates)'
+
+        # Connector words for maximum flexibility
+        connectors = r'(?:up\s+to|actually|exactly|around|approximately|about|of|in|as|like|nearly|roughly)\s*'
+
+        # Optional article before number
+        article = r'(?:a|an|the)?\s*'
+
+        # Modifier words that can appear between keyword and verb
+        modifiers = r'(?:\s+(?:level|score|quality|quantity|range|reading|measurement|value))?'
+
+        # All possible patterns, ordered by specificity
+        patterns = [
+            # Pattern 0: keyword + [level/score/etc] + verb + connectors + article + number (MOST FLEXIBLE!)
+            rf'{keyword_pattern}{modifiers}\s+(?:{verbs})\s+(?:{connectors})?{article}(\d{{1,3}}(?:\.\d{{1,2}})?)',
+
+            # Pattern 1: keyword + verb + connectors + article + number
+            rf'{keyword_pattern}\s+(?:{verbs})\s+(?:{connectors})?{article}(\d{{1,3}}(?:\.\d{{1,2}})?)',
+
+            # Pattern 2: keyword + connector words (without verb) + article + number
+            rf'{keyword_pattern}\s+(?:{connectors}){article}(\d{{1,3}}(?:\.\d{{1,2}})?)',
+
+            # Pattern 3: prefix + keyword + [level] + verb + connectors + article + number
+            rf'(?:my|his|her|the|your)\s+{keyword_pattern}{modifiers}\s+(?:{verbs})\s+(?:{connectors})?{article}(\d{{1,3}}(?:\.\d{{1,2}})?)',
+
+            # Pattern 4: keyword + direct number
+            rf'{keyword_pattern}\s+(\d{{1,3}}(?:\.\d{{1,2}})?)',
+
+            # Pattern 5: prefix + keyword + number
+            rf'(?:my|his|her|the|your)\s+{keyword_pattern}\s+{article}(\d{{1,3}}(?:\.\d{{1,2}})?)',
+
+            # Pattern 6: "let's say number" or "say number" pattern
+            rf'(?:let\'s\s+)?say\s+(?:an?\s+)?(\d{{1,3}}(?:\.\d{{1,2}})?)\s+(?:out\s+of\s+10|for\s+{keyword_pattern})?',
+        ]
+
+        for pattern in patterns:
+            try:
+                match = re.search(pattern, text)
+                if match:
+                    val_str = match.group(1)
+                    val = float(val_str) if (allow_float or '.' in val_str) else int(val_str)
+                    if min_val is not None and max_val is not None:
+                        if min_val <= val <= max_val:
+                            return val
+                    elif min_val is not None and val >= min_val:
+                        return val
+                    elif max_val is not None and val <= max_val:
+                        return val
+                    else:
+                        return val if not (min_val or max_val) else None
+            except (ValueError, IndexError, AttributeError, TypeError):
+                continue
+        return None
+
+    try:
+        # ===== AGE =====
+        # Handle multiple formats: "i'm 45", "age 45", "45 years old", "45-year-old", "45 year old"
+        age_patterns = [
+            # "45 years old" or "45 year old"
+            r'(\d{1,3})\s+years?\s+old',
+            # "45-year-old" or "45year old"
+            r'(\d{1,3})\s*-?\s*years?\s*-?\s*old',
+            # Using the flexible extractor for other formats
+            r'(?:age|i\s+(?:am|\'m))\s+(\d{1,3})',
+            # "I'm 45" or "I am 45"
+            r'(?:i\'m|i\s+am)\s+(\d{1,3})',
+        ]
+        age_val = None
+        for age_pat in age_patterns:
+            try:
+                age_match = re.search(age_pat, text)
+                if age_match:
+                    age_candidate = int(age_match.group(1))
+                    if 18 <= age_candidate <= 100:
+                        age_val = float(age_candidate)
+                        break
+            except (IndexError, AttributeError, ValueError):
+                continue
+        result["Age"] = age_val
+
+        # ===== GLUCOSE =====
+        glucose_val = extract_number(text, r'(?:glucose|blood\s+sugar)', min_val=70, max_val=400)
+        result["Glucose"] = float(glucose_val) if glucose_val else None
+
+        # ===== HBA1C =====
+        # Handles: "HbA1c was exactly 5.1%", "HbA1c up to 6.5", "my HbA1c is 5%", "my hba1c level is 10%"
+        hba1c_patterns = [
+            # "my hba1c level is 10%" or "hba1c level is 6%"
+            r'(?:my\s+)?hba1c\s+(?:level)?\s+(?:is|was|being)?\s+(?:exactly|around|approximately)?\s+(?:up\s+to\s+)?(\d{1,2}(?:\.\d{1,2})?)',
+            # "HbA1c was exactly 5.1%"
+            r'hba1c\s+(?:is|was|being)?\s+(?:exactly|around|approximately)?\s+(?:up\s+to\s+)?(\d{1,2}(?:\.\d{1,2})?)',
+            # "my HbA1c is 5.1"
+            r'my\s+hba1c\s+(?:is|was)?\s+(?:exactly\s+)?(\d{1,2}(?:\.\d{1,2})?)',
+            # Direct "HbA1c 5.1"
+            r'hba1c\s+(\d{1,2}(?:\.\d{1,2})?)',
+            # Just "5.1%" or "6%" after context (when HbA1c is implied)
+            r'(?:hba1c\s+)?(?:level\s+)?(?:of\s+)?(\d{1,2}(?:\.\d{1,2})?)%',
+        ]
+        for hba_pat in hba1c_patterns:
+            try:
+                hba_match = re.search(hba_pat, text)
+                if hba_match:
+                    hba = float(hba_match.group(1))
+                    if 3 <= hba <= 15:
+                        result["HbA1c"] = float(hba)
+                        break
+            except (IndexError, AttributeError):
+                continue
+
+        # ===== BMI =====
+        bmi_patterns = [
+            r'bmi\s+(?:is\s+)?(\d{1,2})',
+            r'my\s+bmi\s+(?:is\s+)?(\d{1,2})',
+            r'body\s+mass\s+index\s+(?:is\s+)?(\d{1,2})',
+        ]
+        for bmi_pat in bmi_patterns:
+            bmi_match = re.search(bmi_pat, text)
+            if bmi_match:
+                bmi = int(bmi_match.group(1))
+                if 10 <= bmi <= 60:
+                    result["BMI"] = float(bmi)
+                    break
+
+        # ===== CHOLESTEROL =====
+        chol_val = extract_number(text, r'cholesterol', min_val=100, max_val=400)
+        result["Cholesterol"] = float(chol_val) if chol_val else None
+
+        # ===== TRIGLYCERIDES =====
+        trig_val = extract_number(text, r'triglycerides', min_val=20, max_val=500)
+        result["Triglycerides"] = float(trig_val) if trig_val else None
+
+        # ===== BLOOD PRESSURE =====
+        # Special handling for BP: "120/80" or just systolic "160"
+        bp_patterns = [
+            # "blood pressure usually measures around 115"
+            r'(?:blood\s+pressure|bp)\s+(?:usually\s+)?(?:measures|measured|is|was|being)?\s+(?:around\s+|about\s+|approximately\s+)?(\d{2,3})',
+            # "blood pressure is/was 140"
+            r'(?:blood\s+pressure|bp)\s+(?:is|was|hit|reached|being)?\s+(?:around\s+|up\s+to\s+)?(\d{2,3})',
+            # "my blood pressure 115"
+            r'my\s+(?:blood\s+pressure|bp)\s+(?:is|was)?\s+(?:around\s+)?(\d{2,3})',
+            # "BP 130"
+            r'bp\s+(\d{2,3})',
+            # Systolic/diastolic format
+            r'(?:blood\s+pressure|bp)\s+(?:is|was)?\s+(?:around\s+|about\s+)?(\d{2,3})\s*/\s*(\d{2,3})',
+        ]
+        for bp_pat in bp_patterns:
+            try:
+                bp_match = re.search(bp_pat, text)
+                if bp_match:
+                    bp_val = int(bp_match.group(1))
+                    if 60 <= bp_val <= 200:
+                        result["Blood Pressure"] = float(bp_val)
+                        break
+            except (IndexError, AttributeError):
+                continue
+
+        # ===== PHYSICAL ACTIVITY =====
+        # Handles: "exercise 5 hours", "play football for 4 hours", "walk to work 15 hours", "activity is 15", "walking 3 hours"
+        activity_patterns = [
+            r'(?:physical\s+)?activity\s+(?:is|was)?\s+(?:for\s+)?(?:about\s+)?(\d{1,2})\s*(?:hours?)?',
+            r'(?:exercise|activity|workout|sport|play|football|basketball|swimming|running|walk|biking)\s+(?:for\s+)?(?:about\s+|around\s+)?(\d{1,2})\s*(?:hours?)?',
+            r'(?:walk|exercise|activity|play)ing\s+(?:for\s+)?(?:about\s+)?(\d{1,2})\s*(?:hours?)?',
+            r'(\d{1,2})\s*(?:hours?)\s+(?:of\s+)?(?:exercise|activity|walking|playing|workout)',
+        ]
+        for act_pat in activity_patterns:
+            activity_match = re.search(act_pat, text)
+            if activity_match:
+                activity = int(activity_match.group(1))
+                if 0 <= activity <= 24:
+                    result["Physical Activity"] = float(activity)
+                    break
+
+        # ===== SLEEP HOURS =====
+        # Handles: "sleep 8 hours", "sleeping 7 hours", "sleep 7", "get 6 hours of sleep", "sleep for 5 hours"
+        sleep_patterns = [
+            # "sleep for 5 hours" or "sleep 5 hours"
+            r'(?:sleep|sleeping|get|getting)\s+(?:for\s+)?(?:about\s+|around\s+)?(\d{1,2})\s*(?:hours?)?',
+            # "5 hours of sleep" or "5 hours sleep"
+            r'(\d{1,2})\s*(?:hours?)\s+(?:of\s+)?sleep',
+        ]
+        for sleep_pat in sleep_patterns:
+            sleep_match = re.search(sleep_pat, text)
+            if sleep_match:
+                sleep = int(sleep_match.group(1))
+                if 0 <= sleep <= 24:
+                    result["Sleep Hours"] = float(sleep)
+                    break
+
+        # ===== STRESS LEVEL =====
+        # Handles: "stress 8", "stress level is 5", "I'd rate my stress level as a 3"
+        stress_patterns = [
+            # "I'd rate my stress level as a 3 out of 10"
+            r'(?:rate|rated)\s+(?:my\s+)?stress\s+(?:level)?\s+(?:as|like)\s+(?:a|an)?\s*(\d{1,2})',
+            # "stress level is/as a 5"
+            r'stress\s+(?:level)?\s+(?:is|was|as)?\s+(?:a|an)?\s*(\d{1,2})',
+            # "my stress level in 4" (typo handling - "in" for "is")
+            r'(?:my\s+)?stress\s+(?:level)?\s+(?:in|is)\s+(?:a|an)?\s*(\d{1,2})',
+            # Direct pattern
+            r'(?:my\s+)?stress\s+(?:level)?\s+(?:a|an)?\s*(\d{1,2})',
+        ]
+        for stress_pat in stress_patterns:
+            try:
+                stress_match = re.search(stress_pat, text)
+                if stress_match:
+                    stress = int(stress_match.group(1))
+                    if 1 <= stress <= 10:
+                        result["Stress Level"] = float(stress)
+                        break
+            except (IndexError, AttributeError):
+                continue
+
+        # ===== OXYGEN SATURATION =====
+        # Handles: "oxygen saturation 90%", "oxygen saturation level is 95%", "oxygen was 96%", "o2 96"
+        oxygen_patterns = [
+            # "oxygen saturation level is 95%" or "oxygen saturation is 95%"
+            r'(?:oxygen|o2|o₂)\s+(?:saturation\s+)?(?:level\s+)?(?:is|was)?\s+(?:around\s+)?(\d{1,3})(?:%)?',
+            # "oxygen saturation 90%"
+            r'(?:oxygen|o2|o₂)\s+saturation\s+(?:level\s+)?(\d{1,3})(?:%)?',
+            # "oxygen was 96%" or "o2 is 95"
+            r'(?:oxygen|o2|o₂)\s+(?:was|is|being|level)?\s+(\d{1,3})(?:%)?',
+            # "my oxygen was 90%"
+            r'my\s+oxygen\s+(?:was|is)?\s+(\d{1,3})(?:%)?',
+            # "SpO2 95" or "spo2 is 92%"
+            r'(?:spo2|spo\s*2)\s+(?:is\s+)?(\d{1,3})(?:%)?',
+            # Direct "o2 97" or "oxygen 95" (needs to be number at end)
+            r'(?:oxygen|o2|o₂)\s+(\d{1,3})$',
+        ]
+        for o2_pat in oxygen_patterns:
+            o2_match = re.search(o2_pat, text)
+            if o2_match:
+                o2 = int(o2_match.group(1))
+                if 80 <= o2 <= 100:
+                    result["Oxygen Saturation"] = float(o2)
+                    break
+
+        # ===== LENGTH OF STAY =====
+        # Handles: "hospitalized for 2 days", "2 day hospital stay", "stay 4 days", "length of stay is 10", "i was in hospital for 5 days"
+        stay_patterns = [
+            # "length of stay is 10"
+            r'length\s+of\s+stay\s+(?:is\s+)?(\d{1,3})',
+            # "my length of stay is 10"
+            r'my\s+length\s+of\s+stay\s+(?:is\s+)?(\d{1,3})',
+            # "hospitalized for 4 days" or "hospitali... for 2 days"
+            r'(?:hospitali[z]?e?d?|in\s+hospital)\s+(?:for\s+)?(\d{1,3})\s*(?:days?)?',
+            # "stay for 5 days" or "hospital stay 4 days"
+            r'(?:hospital\s+)?stay\s+(?:for\s+)?(\d{1,3})\s*(?:days?)?',
+            # "for/in 2 days hospital/stay"
+            r'(?:for|in)\s+(\d{1,3})\s*(?:days?)\s+(?:hospital|stay)',
+            # "2 day hospital stay" or "5 days in hospital"
+            r'(\d{1,3})\s*(?:days?)\s+(?:hospital|stay|in\s+hospital)',
+        ]
+        if 'hospital' in text or 'stay' in text or 'length' in text:
+            for stay_pat in stay_patterns:
+                try:
+                    stay_match = re.search(stay_pat, text)
+                    if stay_match:
+                        stay = int(stay_match.group(1))
+                        if 0 <= stay <= 365:
+                            result["LengthOfStay"] = float(stay)
+                            break
+                except (AttributeError, IndexError):
+                    continue
+
+        # ===== SMOKING =====
+        # Explicit corrections: "put 0 for smoking", "i stopped smoking", "put 0 for that"
+        if re.search(r'(?:put|mark|set)\s+0\s+(?:for\s+)?(?:smoking|smok)', text):
+            result["Smoking"] = 0
+        elif re.search(r'(?:stopped|quit|don\'t)\s+(?:smok|smoke)', text):
+            result["Smoking"] = 0
+        elif re.search(r'non[- ]smok|nonsmoker|don\'t\s+smok|no\s+smok', text):
+            result["Smoking"] = 0
+        elif re.search(r'(?:smok|smoke|smoking|smoker)(?!\s+before)', text):
+            result["Smoking"] = 1
+
+        # ===== ALCOHOL =====
+        # Explicit: "put 0 for alcohol", "don't drink", "wine daily" (means drinking)
+        if re.search(r'(?:put|mark|set)\s+0\s+(?:for\s+)?(?:alcohol|drink)', text):
+            result["Alcohol"] = 0
+        elif re.search(r'(?:don\'t|no|don\'?t)\s+(?:drink|alcohol)', text):
+            result["Alcohol"] = 0
+        elif re.search(r'(?:wine|beer|alcohol|drink|drinking|glass|daily)', text):
+            result["Alcohol"] = 1
+
+        # ===== FAMILY HISTORY =====
+        if re.search(r'(?:no|don\'t|don\'?t)\s+(?:family\s+)?(?:history|disease|condition)', text):
+            result["Family History"] = 0
+        elif re.search(r'(?:family\s+)?(?:history|disease|condition|yes)', text):
+            result["Family History"] = 1
+
+        # ===== DIET SCORE =====
+        # Handles: "diet score is 8", "diet quality is 5", "eat healthy so say 8"
+        diet_patterns = [
+            # "diet score is/quality is 8"
+            r'diet\s+(?:score|quality|nutritional?\s+value)\s+(?:is|was)?\s+(?:an?\s+)?(\d{1,2})',
+            # "nutrition score 8"
+            r'nutrition\s+(?:score|quality)?\s+(?:is|was)?\s+(?:an?\s+)?(\d{1,2})',
+            # "say an 8" pattern for diet (contextual)
+            r'(?:diet|nutrition|healthy)\s+[^.]*\bsay\s+(?:an?\s+)?(\d{1,2})(?:\s+out\s+of\s+10)?',
+            # "let's say an 8"
+            r'let\'s\s+say\s+(?:an?\s+)?(\d{1,2})\s+(?:for\s+diet|for\s+nutrition|out\s+of\s+10)',
+            # Direct "diet 8"
+            r'diet\s+(\d{1,2})',
+        ]
+        for diet_pat in diet_patterns:
+            try:
+                diet_match = re.search(diet_pat, text)
+                if diet_match:
+                    diet = int(diet_match.group(1))
+                    if 1 <= diet <= 10:
+                        result["Diet Score"] = float(diet)
+                        break
+            except (IndexError, AttributeError):
+                continue
+
+        extracted_keys = {k: v for k, v in result.items() if v is not None}
+        logger.debug(f"✅ Regex extraction found: {list(extracted_keys.keys())}")
+        logger.info(f"🔍 Regex result: {extracted_keys if extracted_keys else 'EMPTY'}")
+        return result
+
+    except Exception as e:
+        logger.error(f"Regex extraction error: {e}")
+        return {feature: None for feature in DEFAULT_MODEL_FEATURES}
+
+
+def extract_features_from_text(user_input: str) -> dict:
+    """
+    Uses SMART extraction: Regex first (fast), then LLM (comprehensive), with smart fallbacks.
+    Returns dictionary with all required keys (values are null if not extracted).
+
+    Args:
+        user_input: User's free-form text input
+
+    Returns:
+        Dictionary with all 16 features (values null if not found)
+    """
+
+    if not user_input or not user_input.strip():
+        logger.warning("Empty user input received")
+        return {feature: None for feature in DEFAULT_MODEL_FEATURES}
+
+    # STEP 1: TRY REGEX FIRST (fast, reliable for common patterns)
+    regex_result = _extract_with_regex(user_input, aggressive=True)
+    extracted_keys = {k: v for k, v in regex_result.items() if v is not None}
+    logger.info(f"🔍 Regex result: {extracted_keys if extracted_keys else 'EMPTY'}")
+
+    if any(v is not None for v in regex_result.values()):
+        logger.info(f"✅ Regex extraction succeeded: {list(extracted_keys.keys())}")
+        return regex_result
+
+    # STEP 2: If regex didn't work, try LLM (only if client available)
+    if client is None:
+        logger.warning("⚠️  Groq client not initialized - returning regex results (empty)")
+        return regex_result
+
+    prompt = f"""
+You are a medical information extraction system. Extract health data from ANY mention in the text.
+
+Features with VALID RANGES:
+- Age (18-100): "I am 30", "30 years old", "age 45" → extract the number
+- Glucose (70-400): any number mentioned with glucose/blood sugar
+- HbA1c (3-15): any number with HbA1c/hemoglobin
+- BMI (10-60): any number with BMI/body mass
+- Cholesterol (100-400): any number with cholesterol
+- Triglycerides (20-500): any number with triglycerides
+- Blood Pressure (60-200): any number with BP/blood pressure
+- Physical Activity (0-24): any number with exercise/activity/workout hours
+- Sleep Hours (0-24): any number with sleep/hours slept
+- Stress Level (1-10): any number (1-10) with stress
+- Diet Score (1-10): any number (1-10) with diet/nutrition
+- Smoking (0 or 1): "smoke/smoking/smoker" → 1, "don't/no smoking/non-smoker" → 0, "sometimes/occasionally" → 1
+- Alcohol (0 or 1): "drink/alcohol/drinking" → 1, "don't drink/no alcohol" → 0, "sometimes" → 1
+- Family History (0 or 1): "family history/disease history" → 1, "no family history" → 0
+- LengthOfStay (0-365): any number with hospital/stay/days
+- Oxygen Saturation (80-100): any number with oxygen/O2/saturation
+
+EXTRACTION RULES:
+1. Return ONLY valid JSON. No markdown, no text, no explanation
+2. Use ALL 16 keys exactly as shown
+3. Extract ANY number from text (age, measurements, etc)
+4. For binary features (Smoking/Alcohol/Family History): ALWAYS return 0 or 1, never null if mentioned
+5. For "sometimes/occasionally/rarely" with Smoking/Alcohol → use 1 (yes, they do it)
+6. If value outside range, use null
+7. If feature not mentioned at all, use null
+
+Examples:
+"I'm 30 years old and I smoke sometimes" → {{"Age": 30, "Smoking": 1, ...other null...}}
+"my name is John, I don't drink" → {{"Alcohol": 0, ...other null...}}
+"45 with diabetes" → {{"Age": 45, ...}}
+"I exercise 5 hours" → {{"Physical Activity": 5, ...}}
+
+User Input: "{user_input}"
+
+Return ONLY JSON with 16 keys:"""
+
+    try:
+        # STEP 2A: Call Groq API with timeout and error handling
+        response = client.chat.completions.create(
+            model=GROQ_MODEL,
+            messages=[
+                {"role": "system", "content": "You are a strict JSON generator. Always return valid JSON."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=GROQ_TEMPERATURE,
+            max_tokens=1000,
+            timeout=30
+        )
+
+        content = response.choices[0].message.content.strip()
+
+        # Try to parse JSON
+        try:
+            data = json.loads(content)
+            logger.debug(f"✅ Successfully extracted via LLM: {[k for k,v in data.items() if v]}")
+        except json.JSONDecodeError:
+            # Try removing markdown code blocks
+            logger.debug(f"First parse failed, trying fallback parsing")
+            if "```" in content:
+                content = content.split("```")[1]
+                if content.startswith("json"):
+                    content = content[4:].strip()
+
+            try:
+                data = json.loads(content)
+                logger.debug(f"✅ Fallback JSON parse succeeded")
+            except json.JSONDecodeError as e:
+                logger.error(f"❌ Could not parse JSON: {e}")
+                logger.error(f"   Content was: {content[:300]}")
+                logger.warning(f"⚠️  LLM JSON parsing failed, falling back to regex results")
+                data = {feature: None for feature in DEFAULT_MODEL_FEATURES}
+
+        # Ensure all features are present
+        result = {feature: None for feature in DEFAULT_MODEL_FEATURES}
+        result.update(data)
+
+        # STEP 2B: Use regex as enhancement to LLM (fill gaps)
+        regex_data = _extract_with_regex(user_input, aggressive=True)
+
+        # Merge: LLM data takes priority, regex fills gaps
+        llm_extracted = sum(1 for v in result.values() if v is not None)
+        for feature, value in regex_data.items():
+            if value is not None and result[feature] is None:
+                result[feature] = value
+
+        regex_filled = sum(1 for v in result.values() if v is not None) - llm_extracted
+        if regex_filled > 0:
+            logger.info(f"📝 LLM + Regex merge: LLM found {llm_extracted}, Regex filled {regex_filled} gaps")
+
+        return result
+
+    except Exception as e:
+        error_msg = str(e)
+        if "organization_restricted" in error_msg.lower():
+            logger.error(f"❌ Groq API BLOCKED: Organization restricted. Check your API key and account status.")
+        elif "invalid_api_key" in error_msg.lower():
+            logger.error(f"❌ Groq API ERROR: Invalid or expired API key")
+        elif "rate_limit" in error_msg.lower():
+            logger.warning(f"⚠️  Groq API RATE LIMITED: Too many requests, using regex only")
+        else:
+            logger.error(f"❌ Groq API ERROR: {type(e).__name__}: {error_msg[:200]}")
+
+        # Fallback: Return regex results if LLM fails (don't return empty)
+        logger.info("⚠️  Falling back to regex-only extraction")
+        regex_fallback = _extract_with_regex(user_input, aggressive=True)
+        return regex_fallback

app/services/predictor.py

@@ -0,0 +1,146 @@
+import joblib
+import logging
+from pathlib import Path
+from typing import List
+
+from app.config import MODEL_PATH, CLASS_NAMES, FEATURE_RANGES
+from app.schemas import PredictionResponse
+
+logger = logging.getLogger(__name__)
+
+
+class Predictor:
+    """Load and use ML model for predictions"""
+
+    def __init__(self, model_path: str = None):
+        """
+        Initialize predictor with model path.
+
+        Args:
+            model_path: Path to model file (default: config.MODEL_PATH)
+        """
+        if model_path is None:
+            model_path = MODEL_PATH
+
+        self.model_path = Path(model_path)
+        self.model = None
+        self._load_model()
+
+    def _load_model(self):
+        """Load model from disk using joblib"""
+        if not self.model_path.exists():
+            raise FileNotFoundError(f"Model not found at {self.model_path}")
+
+        try:
+            self.model = joblib.load(self.model_path)
+            logger.info(f"✅ Model loaded from {self.model_path}")
+            logger.info(f"   Model type: {type(self.model).__name__}")
+            logger.info(f"   Expected features: {self.model.n_features_in_}")
+        except Exception as e:
+            logger.error(f"❌ Failed to load model: {e}")
+            raise
+
+    def predict(self, feature_vector: List[float]) -> PredictionResponse:
+        """
+        Make prediction on feature vector.
+
+        Args:
+            feature_vector: List of 16 floats in correct order
+
+        Returns:
+            PredictionResponse with prediction, probability, risk level
+
+        Raises:
+            RuntimeError: If model not loaded
+            ValueError: If feature vector wrong size
+        """
+        if self.model is None:
+            raise RuntimeError("Model not loaded")
+
+        if len(feature_vector) != 16:
+            raise ValueError(f"Expected 16 features, got {len(feature_vector)}")
+
+        try:
+            # Make prediction on single sample
+            # Note: sklearn expects 2D array [n_samples, n_features]
+            prediction_class = int(self.model.predict([feature_vector])[0])
+
+            # Get probability/confidence array for all classes
+            proba = self.model.predict_proba([feature_vector])[0]
+            probability = float(max(proba))
+
+            # SMART LOGIC: If top prediction is "Other/Unknown" (class 7), use second-best
+            OTHER_UNKNOWN_CLASS = 7
+            if prediction_class == OTHER_UNKNOWN_CLASS:
+                # Find second-highest confidence
+                top_two_indices = (-proba).argsort()[:2]  # Get top 2 class indices
+                prediction_class = int(top_two_indices[1])  # Use second-best class
+                probability = float(proba[prediction_class])  # Get its confidence
+                logger.info(f"⚠️  Top prediction was Other/Unknown, using second-best: {CLASS_NAMES[prediction_class]}")
+
+            # Map class number to class name
+            class_name = CLASS_NAMES[prediction_class] if prediction_class < len(CLASS_NAMES) else "Unknown"
+
+            # Determine risk level based on probability
+            if probability >= 0.8:
+                risk_level = "High"
+            elif probability >= 0.6:
+                risk_level = "Medium"
+            else:
+                risk_level = "Low"
+
+            # Create explanation based on the predicted condition
+            if class_name == "Healthy":
+                explanation = f"Model predicts HEALTHY status with {probability*100:.1f}% confidence. Keep up healthy lifestyle!"
+            elif class_name == "Other/Unknown":
+                explanation = f"Model unable to classify clearly with {probability*100:.1f}% confidence. Consult healthcare provider."
+            else:
+                explanation = f"Model predicts {class_name} with {probability*100:.1f}% confidence. Please consult a healthcare professional."
+
+            result = PredictionResponse(
+                prediction=prediction_class,
+                probability=probability,
+                risk_level=risk_level,
+                explanation=explanation
+            )
+
+            logger.info(f"✅ Prediction: {class_name} (class {prediction_class}, confidence: {probability*100:.1f}%)")
+            return result
+
+        except Exception as e:
+            logger.error(f"❌ Prediction failed: {e}")
+            raise
+
+
+# Global predictor instance (loaded once)
+_predictor_instance = None
+
+
+def get_predictor() -> Predictor:
+    """
+    Get or create global predictor instance (lazy loading).
+
+    Returns:
+        Predictor instance
+
+    Raises:
+        FileNotFoundError: If model file not found
+    """
+    global _predictor_instance
+
+    if _predictor_instance is None:
+        _predictor_instance = Predictor()
+
+    return _predictor_instance
+
+
+def reload_predictor() -> Predictor:
+    """
+    Force reload of predictor (useful for testing).
+
+    Returns:
+        New Predictor instance
+    """
+    global _predictor_instance
+    _predictor_instance = Predictor()
+    return _predictor_instance

app/services/session_manager.py

@@ -0,0 +1,178 @@
+"""
+Session Management for Medical Predictor Chatbot
+Handles: session creation, persistence, cleanup, metadata tracking
+"""
+
+import json
+import logging
+from pathlib import Path
+from datetime import datetime
+from typing import Dict, Optional, Any
+
+logger = logging.getLogger(__name__)
+
+# Session storage locations
+SESSION_DIR = Path("/tmp/deepsense_sessions")
+METADATA_FILE = SESSION_DIR / "session_metadata.json"
+
+# Ensure directories exist
+SESSION_DIR.mkdir(exist_ok=True)
+
+
+class SessionManager:
+    """Manages session lifecycle, persistence, and metadata tracking"""
+
+    def __init__(self, session_dir: Path = SESSION_DIR):
+        self.session_dir = session_dir
+        self.metadata_file = METADATA_FILE
+        self._load_all_metadata()
+
+    def _load_all_metadata(self):
+        """Load all session metadata from file"""
+        try:
+            if self.metadata_file.exists():
+                with open(self.metadata_file, 'r') as f:
+                    self.all_metadata = json.load(f)
+            else:
+                self.all_metadata = {}
+        except Exception as e:
+            logger.warning(f"⚠️  Could not load session metadata: {e}")
+            self.all_metadata = {}
+
+    def _save_all_metadata(self):
+        """Persist all session metadata to file"""
+        try:
+            with open(self.metadata_file, 'w') as f:
+                json.dump(self.all_metadata, f, indent=2)
+        except Exception as e:
+            logger.error(f"❌ Error saving session metadata: {e}")
+
+    def create_session(self, session_id: str, user_name: str = "User") -> Dict[str, Any]:
+        """
+        Create a new session with metadata
+
+        Args:
+            session_id: Unique session identifier
+            user_name: User name (extracted from greeting)
+
+        Returns:
+            Session metadata dict
+        """
+        metadata = {
+            "session_id": session_id,
+            "user_name": user_name,
+            "created_at": datetime.now().isoformat(),
+            "last_accessed": datetime.now().isoformat(),
+            "features_collected": 0,
+            "status": "active",
+            "reset_count": 0
+        }
+
+        self.all_metadata[session_id] = metadata
+        self._save_all_metadata()
+
+        logger.info(f"✅ Created session: {session_id} for {user_name}")
+        return metadata
+
+    def get_session_metadata(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Get metadata for a specific session"""
+        return self.all_metadata.get(session_id)
+
+    def update_session(self, session_id: str, features_collected: int):
+        """Update session metadata with current stats"""
+        if session_id in self.all_metadata:
+            self.all_metadata[session_id]["last_accessed"] = datetime.now().isoformat()
+            self.all_metadata[session_id]["features_collected"] = features_collected
+            self._save_all_metadata()
+
+    def reset_session(self, session_id: str) -> bool:
+        """
+        Reset a session: delete session file and update metadata
+
+        Args:
+            session_id: Session to reset
+
+        Returns:
+            True if successful, False otherwise
+        """
+        try:
+            # Delete session state file
+            session_file = self.session_dir / f"{session_id}.json"
+            if session_file.exists():
+                session_file.unlink()
+                logger.info(f"🗑️  Deleted session file: {session_file}")
+
+            # Update metadata
+            if session_id in self.all_metadata:
+                self.all_metadata[session_id]["last_accessed"] = datetime.now().isoformat()
+                self.all_metadata[session_id]["features_collected"] = 0
+                self.all_metadata[session_id]["reset_count"] += 1
+                self.all_metadata[session_id]["status"] = "reset"
+                self._save_all_metadata()
+
+                reset_count = self.all_metadata[session_id]["reset_count"]
+                logger.info(f"🔄 Session {session_id} reset (reset count: {reset_count})")
+
+            return True
+        except Exception as e:
+            logger.error(f"❌ Error resetting session {session_id}: {e}")
+            return False
+
+    def cleanup_old_sessions(self, max_age_hours: int = 24):
+        """
+        Clean up session files older than max_age_hours
+
+        Args:
+            max_age_hours: Sessions older than this are deleted
+        """
+        try:
+            import time
+            current_time = time.time()
+            deleted_count = 0
+
+            for session_id, metadata in list(self.all_metadata.items()):
+                session_file = self.session_dir / f"{session_id}.json"
+                if session_file.exists():
+                    file_age_hours = (current_time - session_file.stat().st_mtime) / 3600
+
+                    if file_age_hours > max_age_hours:
+                        session_file.unlink()
+                        logger.info(f"🗑️  Cleaned up old session: {session_id}")
+                        deleted_count += 1
+
+            if deleted_count > 0:
+                logger.info(f"🧹 Cleaned up {deleted_count} old session(s)")
+
+        except Exception as e:
+            logger.warning(f"⚠️  Error during session cleanup: {e}")
+
+    def get_all_active_sessions(self) -> Dict[str, Dict[str, Any]]:
+        """Get all active sessions"""
+        return {sid: meta for sid, meta in self.all_metadata.items()
+                if meta.get("status") == "active"}
+
+    def list_sessions(self) -> str:
+        """Get formatted list of all sessions"""
+        if not self.all_metadata:
+            return "No active sessions"
+
+        lines = ["Active Sessions:"]
+        for sid, meta in self.all_metadata.items():
+            lines.append(
+                f"  • {meta['session_id']}: {meta['user_name']} "
+                f"({meta['features_collected']}/16 features, "
+                f"reset {meta['reset_count']} times)"
+            )
+        return "\n".join(lines)
+
+
+# Global session manager instance
+_session_manager: Optional[SessionManager] = None
+
+
+def get_session_manager() -> SessionManager:
+    """Get or create the global session manager"""
+    global _session_manager
+    if _session_manager is None:
+        _session_manager = SessionManager()
+    return _session_manager

app/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utilities module for Medical Predictor Chatbot"""
+
+from app.utils.helpers import generate_question
+
+__all__ = ["generate_question"]

app/utils/helpers.py

@@ -0,0 +1,56 @@
+def prioritize_features(missing_features: list) -> list:
+    """
+    Prioritize missing features for asking in natural order.
+
+    Priority: Critical Basics → Key Metrics → Lifestyle → Wellness → Medical
+    """
+    priority_order = [
+        "Age", "Blood Pressure", "Glucose",  # Critical basics
+        "BMI", "Cholesterol", "HbA1c",  # Key metrics
+        "Smoking", "Alcohol", "Physical Activity",  # Lifestyle
+        "Sleep Hours", "Stress Level", "Diet Score",  # Wellness
+        "Triglycerides", "Family History", "Oxygen Saturation", "LengthOfStay"  # Medical
+    ]
+
+    # Sort missing features by priority
+    sorted_features = sorted(missing_features,
+                            key=lambda x: priority_order.index(x) if x in priority_order else 999)
+    return sorted_features
+
+
+def generate_question(missing_features: list) -> str:
+    """
+    Generate warm, empathetic questions for ONE missing feature at a time.
+    This keeps the user focused on one health metric at a time, improving UX.
+
+    Args:
+        missing_features: List of missing feature names (typically just 1)
+
+    Returns:
+        Formatted question string asking for the first missing item
+    """
+    questions = {
+        "Age": "Could you tell me your age?",
+        "Glucose": "What's your typical glucose level (in mg/dL)?",
+        "Smoking": "Do you smoke, or have you smoked in the past? (yes/no)",
+        "Family History": "Is there a family history of disease or health conditions? (yes/no)",
+        "HbA1c": "What's your HbA1c level (%)? (This measures average blood sugar over 3 months)",
+        "Diet Score": "How would you rate your overall diet quality on a scale of 1-10?",
+        "Alcohol": "Do you consume alcohol regularly? (yes/no)",
+        "Physical Activity": "How many hours per week do you typically exercise or stay physically active?",
+        "Blood Pressure": "What's your blood pressure reading? (e.g., 120/80)",
+        "BMI": "What's your BMI (Body Mass Index)?",
+        "Cholesterol": "What's your cholesterol level (in mg/dL)?",
+        "Sleep Hours": "How many hours of sleep do you typically get per night?",
+        "Stress Level": "How would you rate your current stress level on a scale of 1-10?",
+        "Triglycerides": "What's your triglycerides level (in mg/dL)?",
+        "Oxygen Saturation": "What's your oxygen saturation level (%)? (Normal is 95-100%)",
+        "LengthOfStay": "How many days were you hospitalized, if applicable?"
+    }
+
+    if not missing_features:
+        return ""
+
+    # Ask for only 1 item at a time to keep user focused
+    feature = missing_features[0]
+    return f"**{feature}:** {questions.get(feature, f'Please provide {feature}')}"

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Medical Diagnosis AI</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package-lock.json

@@ -0,0 +1,2720 @@
+{
+  "name": "medical-predictor-frontend",
+  "version": "0.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "medical-predictor-frontend",
+      "version": "0.0.1",
+      "dependencies": {
+        "axios": "^1.6.0",
+        "lucide-react": "^0.294.0",
+        "react": "^18.2.0",
+        "react-dom": "^18.2.0"
+      },
+      "devDependencies": {
+        "@types/react": "^18.2.0",
+        "@types/react-dom": "^18.2.0",
+        "@vitejs/plugin-react": "^4.2.1",
+        "autoprefixer": "^10.4.16",
+        "postcss": "^8.4.31",
+        "tailwindcss": "^3.3.0",
+        "vite": "^5.0.0"
+      }
+    },
+    "node_modules/@alloc/quick-lru": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/@alloc/quick-lru/-/quick-lru-5.2.0.tgz",
+      "integrity": "sha512-UrcABB+4bUrFABwbluTIBErXwvbsU/V7TZWfmbgJfbkwiBuziS9gxdODUyuiecfdGQ85jglMW6juS3+z5TsKLw==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@babel/code-frame": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+      "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+      "dev": true,
+      "dependencies": {
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "js-tokens": "^4.0.0",
+        "picocolors": "^1.1.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/compat-data": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
+      "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/core": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
+      "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+      "dev": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-compilation-targets": "^7.28.6",
+        "@babel/helper-module-transforms": "^7.28.6",
+        "@babel/helpers": "^7.28.6",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/traverse": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/remapping": "^2.3.5",
+        "convert-source-map": "^2.0.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.2.3",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/babel"
+      }
+    },
+    "node_modules/@babel/generator": {
+      "version": "7.29.1",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
+      "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+      "dev": true,
+      "dependencies": {
+        "@babel/parser": "^7.29.0",
+        "@babel/types": "^7.29.0",
+        "@jridgewell/gen-mapping": "^0.3.12",
+        "@jridgewell/trace-mapping": "^0.3.28",
+        "jsesc": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-compilation-targets": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+      "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+      "dev": true,
+      "dependencies": {
+        "@babel/compat-data": "^7.28.6",
+        "@babel/helper-validator-option": "^7.27.1",
+        "browserslist": "^4.24.0",
+        "lru-cache": "^5.1.1",
+        "semver": "^6.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-globals": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+      "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-imports": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+      "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+      "dev": true,
+      "dependencies": {
+        "@babel/traverse": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-module-transforms": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+      "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+      "dev": true,
+      "dependencies": {
+        "@babel/helper-module-imports": "^7.28.6",
+        "@babel/helper-validator-identifier": "^7.28.5",
+        "@babel/traverse": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0"
+      }
+    },
+    "node_modules/@babel/helper-plugin-utils": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+      "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-string-parser": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+      "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-identifier": {
+      "version": "7.28.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+      "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helper-validator-option": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+      "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/helpers": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz",
+      "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
+      "dev": true,
+      "dependencies": {
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/parser": {
+      "version": "7.29.2",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz",
+      "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
+      "dev": true,
+      "dependencies": {
+        "@babel/types": "^7.29.0"
+      },
+      "bin": {
+        "parser": "bin/babel-parser.js"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-self": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+      "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+      "dev": true,
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/plugin-transform-react-jsx-source": {
+      "version": "7.27.1",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+      "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+      "dev": true,
+      "dependencies": {
+        "@babel/helper-plugin-utils": "^7.27.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      },
+      "peerDependencies": {
+        "@babel/core": "^7.0.0-0"
+      }
+    },
+    "node_modules/@babel/template": {
+      "version": "7.28.6",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
+      "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+      "dev": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.28.6",
+        "@babel/parser": "^7.28.6",
+        "@babel/types": "^7.28.6"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/traverse": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
+      "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+      "dev": true,
+      "dependencies": {
+        "@babel/code-frame": "^7.29.0",
+        "@babel/generator": "^7.29.0",
+        "@babel/helper-globals": "^7.28.0",
+        "@babel/parser": "^7.29.0",
+        "@babel/template": "^7.28.6",
+        "@babel/types": "^7.29.0",
+        "debug": "^4.3.1"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@babel/types": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+      "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+      "dev": true,
+      "dependencies": {
+        "@babel/helper-string-parser": "^7.27.1",
+        "@babel/helper-validator-identifier": "^7.28.5"
+      },
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz",
+      "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz",
+      "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz",
+      "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz",
+      "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz",
+      "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz",
+      "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz",
+      "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz",
+      "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz",
+      "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz",
+      "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz",
+      "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz",
+      "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz",
+      "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz",
+      "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz",
+      "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz",
+      "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz",
+      "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz",
+      "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz",
+      "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz",
+      "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz",
+      "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/remapping": {
+      "version": "2.3.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+      "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "dev": true,
+      "dependencies": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "dev": true,
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "dev": true,
+      "dependencies": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.27",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+      "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+      "dev": true
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.1.tgz",
+      "integrity": "sha512-d6FinEBLdIiK+1uACUttJKfgZREXrF0Qc2SmLII7W2AD8FfiZ9Wjd+rD/iRuf5s5dWrr1GgwXCvPqOuDquOowA==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.1.tgz",
+      "integrity": "sha512-YjG/EwIDvvYI1YvYbHvDz/BYHtkY4ygUIXHnTdLhG+hKIQFBiosfWiACWortsKPKU/+dUwQQCKQM3qrDe8c9BA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.1.tgz",
+      "integrity": "sha512-mjCpF7GmkRtSJwon+Rq1N8+pI+8l7w5g9Z3vWj4T7abguC4Czwi3Yu/pFaLvA3TTeMVjnu3ctigusqWUfjZzvw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.1.tgz",
+      "integrity": "sha512-haZ7hJ1JT4e9hqkoT9R/19XW2QKqjfJVv+i5AGg57S+nLk9lQnJ1F/eZloRO3o9Scy9CM3wQ9l+dkXtcBgN5Ew==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.1.tgz",
+      "integrity": "sha512-czw90wpQq3ZsAVBlinZjAYTKduOjTywlG7fEeWKUA7oCmpA8xdTkxZZlwNJKWqILlq0wehoZcJYfBvOyhPTQ6w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.1.tgz",
+      "integrity": "sha512-KVB2rqsxTHuBtfOeySEyzEOB7ltlB/ux38iu2rBQzkjbwRVlkhAGIEDiiYnO2kFOkJp+Z7pUXKyrRRFuFUKt+g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.1.tgz",
+      "integrity": "sha512-L+34Qqil+v5uC0zEubW7uByo78WOCIrBvci69E7sFASRl0X7b/MB6Cqd1lky/CtcSVTydWa2WZwFuWexjS5o6g==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.1.tgz",
+      "integrity": "sha512-n83O8rt4v34hgFzlkb1ycniJh7IR5RCIqt6mz1VRJD6pmhRi0CXdmfnLu9dIUS6buzh60IvACM842Ffb3xd6Gg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.1.tgz",
+      "integrity": "sha512-Nql7sTeAzhTAja3QXeAI48+/+GjBJ+QmAH13snn0AJSNL50JsDqotyudHyMbO2RbJkskbMbFJfIJKWA6R1LCJQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.1.tgz",
+      "integrity": "sha512-+pUymDhd0ys9GcKZPPWlFiZ67sTWV5UU6zOJat02M1+PiuSGDziyRuI/pPue3hoUwm2uGfxdL+trT6Z9rxnlMA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.1.tgz",
+      "integrity": "sha512-VSvgvQeIcsEvY4bKDHEDWcpW4Yw7BtlKG1GUT4FzBUlEKQK0rWHYBqQt6Fm2taXS+1bXvJT6kICu5ZwqKCnvlQ==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loong64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.1.tgz",
+      "integrity": "sha512-4LqhUomJqwe641gsPp6xLfhqWMbQV04KtPp7/dIp0nzPxAkNY1AbwL5W0MQpcalLYk07vaW9Kp1PBhdpZYYcEw==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.1.tgz",
+      "integrity": "sha512-tLQQ9aPvkBxOc/EUT6j3pyeMD6Hb8QF2BTBnCQWP/uu1lhc9AIrIjKnLYMEroIz/JvtGYgI9dF3AxHZNaEH0rw==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-ppc64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.1.tgz",
+      "integrity": "sha512-RMxFhJwc9fSXP6PqmAz4cbv3kAyvD1etJFjTx4ONqFP9DkTkXsAMU4v3Vyc5BgzC+anz7nS/9tp4obsKfqkDHg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.1.tgz",
+      "integrity": "sha512-QKgFl+Yc1eEk6MmOBfRHYF6lTxiiiV3/z/BRrbSiW2I7AFTXoBFvdMEyglohPj//2mZS4hDOqeB0H1ACh3sBbg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.1.tgz",
+      "integrity": "sha512-RAjXjP/8c6ZtzatZcA1RaQr6O1TRhzC+adn8YZDnChliZHviqIjmvFwHcxi4JKPSDAt6Uhf/7vqcBzQJy0PDJg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.1.tgz",
+      "integrity": "sha512-wcuocpaOlaL1COBYiA89O6yfjlp3RwKDeTIA0hM7OpmhR1Bjo9j31G1uQVpDlTvwxGn2nQs65fBFL5UFd76FcQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.1.tgz",
+      "integrity": "sha512-77PpsFQUCOiZR9+LQEFg9GClyfkNXj1MP6wRnzYs0EeWbPcHs02AXu4xuUbM1zhwn3wqaizle3AEYg5aeoohhg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.1.tgz",
+      "integrity": "sha512-5cIATbk5vynAjqqmyBjlciMJl1+R/CwX9oLk/EyiFXDWd95KpHdrOJT//rnUl4cUcskrd0jCCw3wpZnhIHdD9w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-openbsd-x64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.1.tgz",
+      "integrity": "sha512-cl0w09WsCi17mcmWqqglez9Gk8isgeWvoUZ3WiJFYSR3zjBQc2J5/ihSjpl+VLjPqjQ/1hJRcqBfLjssREQILw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openbsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-openharmony-arm64": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.1.tgz",
+      "integrity": "sha512-4Cv23ZrONRbNtbZa37mLSueXUCtN7MXccChtKpUnQNgF010rjrjfHx3QxkS2PI7LqGT5xXyYs1a7LbzAwT0iCA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "openharmony"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.1.tgz",
+      "integrity": "sha512-i1okWYkA4FJICtr7KpYzFpRTHgy5jdDbZiWfvny21iIKky5YExiDXP+zbXzm3dUcFpkEeYNHgQ5fuG236JPq0g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.1.tgz",
+      "integrity": "sha512-u09m3CuwLzShA0EYKMNiFgcjjzwqtUMLmuCJLeZWjjOYA3IT2Di09KaxGBTP9xVztWyIWjVdsB2E9goMjZvTQg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-gnu": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.1.tgz",
+      "integrity": "sha512-k+600V9Zl1CM7eZxJgMyTUzmrmhB/0XZnF4pRypKAlAgxmedUA+1v9R+XOFv56W4SlHEzfeMtzujLJD22Uz5zg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.1.tgz",
+      "integrity": "sha512-lWMnixq/QzxyhTV6NjQJ4SFo1J6PvOX8vUx5Wb4bBPsEb+8xZ89Bz6kOXpfXj9ak9AHTQVQzlgzBEc1SyM27xQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@types/babel__core": {
+      "version": "7.20.5",
+      "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+      "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+      "dev": true,
+      "dependencies": {
+        "@babel/parser": "^7.20.7",
+        "@babel/types": "^7.20.7",
+        "@types/babel__generator": "*",
+        "@types/babel__template": "*",
+        "@types/babel__traverse": "*"
+      }
+    },
+    "node_modules/@types/babel__generator": {
+      "version": "7.27.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+      "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+      "dev": true,
+      "dependencies": {
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__template": {
+      "version": "7.4.4",
+      "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+      "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+      "dev": true,
+      "dependencies": {
+        "@babel/parser": "^7.1.0",
+        "@babel/types": "^7.0.0"
+      }
+    },
+    "node_modules/@types/babel__traverse": {
+      "version": "7.28.0",
+      "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+      "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+      "dev": true,
+      "dependencies": {
+        "@babel/types": "^7.28.2"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+      "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+      "dev": true
+    },
+    "node_modules/@types/prop-types": {
+      "version": "15.7.15",
+      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
+      "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
+      "dev": true
+    },
+    "node_modules/@types/react": {
+      "version": "18.3.28",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.28.tgz",
+      "integrity": "sha512-z9VXpC7MWrhfWipitjNdgCauoMLRdIILQsAEV+ZesIzBq/oUlxk0m3ApZuMFCXdnS4U7KrI+l3WRUEGQ8K1QKw==",
+      "dev": true,
+      "dependencies": {
+        "@types/prop-types": "*",
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@types/react-dom": {
+      "version": "18.3.7",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",
+      "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
+      "dev": true,
+      "peerDependencies": {
+        "@types/react": "^18.0.0"
+      }
+    },
+    "node_modules/@vitejs/plugin-react": {
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+      "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+      "dev": true,
+      "dependencies": {
+        "@babel/core": "^7.28.0",
+        "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+        "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+        "@rolldown/pluginutils": "1.0.0-beta.27",
+        "@types/babel__core": "^7.20.5",
+        "react-refresh": "^0.17.0"
+      },
+      "engines": {
+        "node": "^14.18.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+      }
+    },
+    "node_modules/any-promise": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/any-promise/-/any-promise-1.3.0.tgz",
+      "integrity": "sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==",
+      "dev": true
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dev": true,
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/arg": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",
+      "integrity": "sha512-PYjyFOLKQ9y57JvQ6QLo8dAgNqswh8M1RMJYdQduT6xbWSgK36P/Z/v+p888pM69jMMfS8Xd8F6I1kQ/I9HUGg==",
+      "dev": true
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="
+    },
+    "node_modules/autoprefixer": {
+      "version": "10.4.27",
+      "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.27.tgz",
+      "integrity": "sha512-NP9APE+tO+LuJGn7/9+cohklunJsXWiaWEfV3si4Gi/XHDwVNgkwr1J3RQYFIvPy76GmJ9/bW8vyoU1LcxwKHA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/autoprefixer"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "browserslist": "^4.28.1",
+        "caniuse-lite": "^1.0.30001774",
+        "fraction.js": "^5.3.4",
+        "picocolors": "^1.1.1",
+        "postcss-value-parser": "^4.2.0"
+      },
+      "bin": {
+        "autoprefixer": "bin/autoprefixer"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
+    "node_modules/axios": {
+      "version": "1.14.0",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.14.0.tgz",
+      "integrity": "sha512-3Y8yrqLSwjuzpXuZ0oIYZ/XGgLwUIBU3uLvbcpb0pidD9ctpShJd43KSlEEkVQg6DS0G9NKyzOvBfUtDKEyHvQ==",
+      "dependencies": {
+        "follow-redirects": "^1.15.11",
+        "form-data": "^4.0.5",
+        "proxy-from-env": "^2.1.0"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.10.16",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.16.tgz",
+      "integrity": "sha512-Lyf3aK28zpsD1yQMiiHD4RvVb6UdMoo8xzG2XzFIfR9luPzOpcBlAsT/qfB1XWS1bxWT+UtE4WmQgsp297FYOA==",
+      "dev": true,
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz",
+      "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+      "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+      "dev": true,
+      "dependencies": {
+        "fill-range": "^7.1.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.28.2",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+      "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "baseline-browser-mapping": "^2.10.12",
+        "caniuse-lite": "^1.0.30001782",
+        "electron-to-chromium": "^1.5.328",
+        "node-releases": "^2.0.36",
+        "update-browserslist-db": "^1.2.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/camelcase-css": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/camelcase-css/-/camelcase-css-2.0.1.tgz",
+      "integrity": "sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==",
+      "dev": true,
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001786",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001786.tgz",
+      "integrity": "sha512-4oxTZEvqmLLrERwxO76yfKM7acZo310U+v4kqexI2TL1DkkUEMT8UijrxxcnVdxR3qkVf5awGRX+4Z6aPHVKrA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ]
+    },
+    "node_modules/chokidar": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
+      "dev": true,
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/chokidar/node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/commander": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
+      "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
+      "dev": true,
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/convert-source-map": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+      "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+      "dev": true
+    },
+    "node_modules/cssesc": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
+      "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
+      "dev": true,
+      "bin": {
+        "cssesc": "bin/cssesc"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "dev": true
+    },
+    "node_modules/debug": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+      "dev": true,
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/didyoumean": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/didyoumean/-/didyoumean-1.2.2.tgz",
+      "integrity": "sha512-gxtyfqMg7GKyhQmb056K7M3xszy/myH8w+B4RT+QXBQsvAOdc3XymqDDPHx1BgPgsdAA5SIifona89YtRATDzw==",
+      "dev": true
+    },
+    "node_modules/dlv": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/dlv/-/dlv-1.1.3.tgz",
+      "integrity": "sha512-+HlytyjlPKnIG8XuRG8WvmBP8xs8P71y+SKKS6ZXWoEgLuePxtDoUEiH7WkdePWrQ5JBpE6aoVqfZfJUQkjXwA==",
+      "dev": true
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.331",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.331.tgz",
+      "integrity": "sha512-IbxXrsTlD3hRodkLnbxAPP4OuJYdWCeM3IOdT+CpcMoIwIoDfCmRpEtSPfwBXxVkg9xmBeY7Lz2Eo2TDn/HC3Q==",
+      "dev": true
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/esbuild": {
+      "version": "0.21.5",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz",
+      "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.21.5",
+        "@esbuild/android-arm": "0.21.5",
+        "@esbuild/android-arm64": "0.21.5",
+        "@esbuild/android-x64": "0.21.5",
+        "@esbuild/darwin-arm64": "0.21.5",
+        "@esbuild/darwin-x64": "0.21.5",
+        "@esbuild/freebsd-arm64": "0.21.5",
+        "@esbuild/freebsd-x64": "0.21.5",
+        "@esbuild/linux-arm": "0.21.5",
+        "@esbuild/linux-arm64": "0.21.5",
+        "@esbuild/linux-ia32": "0.21.5",
+        "@esbuild/linux-loong64": "0.21.5",
+        "@esbuild/linux-mips64el": "0.21.5",
+        "@esbuild/linux-ppc64": "0.21.5",
+        "@esbuild/linux-riscv64": "0.21.5",
+        "@esbuild/linux-s390x": "0.21.5",
+        "@esbuild/linux-x64": "0.21.5",
+        "@esbuild/netbsd-x64": "0.21.5",
+        "@esbuild/openbsd-x64": "0.21.5",
+        "@esbuild/sunos-x64": "0.21.5",
+        "@esbuild/win32-arm64": "0.21.5",
+        "@esbuild/win32-ia32": "0.21.5",
+        "@esbuild/win32-x64": "0.21.5"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/fast-glob": {
+      "version": "3.3.3",
+      "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.3.tgz",
+      "integrity": "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg==",
+      "dev": true,
+      "dependencies": {
+        "@nodelib/fs.stat": "^2.0.2",
+        "@nodelib/fs.walk": "^1.2.3",
+        "glob-parent": "^5.1.2",
+        "merge2": "^1.3.0",
+        "micromatch": "^4.0.8"
+      },
+      "engines": {
+        "node": ">=8.6.0"
+      }
+    },
+    "node_modules/fast-glob/node_modules/glob-parent": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
+      "dev": true,
+      "dependencies": {
+        "is-glob": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/fastq": {
+      "version": "1.20.1",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.20.1.tgz",
+      "integrity": "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw==",
+      "dev": true,
+      "dependencies": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "node_modules/fill-range": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+      "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+      "dev": true,
+      "dependencies": {
+        "to-regex-range": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.11",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.11.tgz",
+      "integrity": "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+      "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/fraction.js": {
+      "version": "5.3.4",
+      "resolved": "https://registry.npmjs.org/fraction.js/-/fraction.js-5.3.4.tgz",
+      "integrity": "sha512-1X1NTtiJphryn/uLQz3whtY6jK3fTqoE3ohKs0tT+Ujr1W59oopxmoEh7Lu5p6vBaPbgoM0bzveAW4Qi5RyWDQ==",
+      "dev": true,
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/rawify"
+      }
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+      "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true,
+      "engines": {
+        "node": ">=6.9.0"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dev": true,
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/is-binary-path": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+      "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+      "dev": true,
+      "dependencies": {
+        "binary-extensions": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-core-module": {
+      "version": "2.16.1",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
+      "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+      "dev": true,
+      "dependencies": {
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/is-extglob": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-glob": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz",
+      "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==",
+      "dev": true,
+      "dependencies": {
+        "is-extglob": "^2.1.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-number": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+      "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.12.0"
+      }
+    },
+    "node_modules/jiti": {
+      "version": "1.21.7",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.7.tgz",
+      "integrity": "sha512-/imKNG4EbWNrVjoNC/1H5/9GFy+tqjGBHCaSsN+P2RnPqjsLmv6UD3Ej+Kj8nBWaRAwyk7kK5ZUc+OEatnTR3A==",
+      "dev": true,
+      "bin": {
+        "jiti": "bin/jiti.js"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="
+    },
+    "node_modules/jsesc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+      "dev": true,
+      "bin": {
+        "jsesc": "bin/jsesc"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "dev": true,
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/lilconfig": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz",
+      "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==",
+      "dev": true,
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antonk52"
+      }
+    },
+    "node_modules/lines-and-columns": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+      "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+      "dev": true
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+      "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+      "dev": true,
+      "dependencies": {
+        "yallist": "^3.0.2"
+      }
+    },
+    "node_modules/lucide-react": {
+      "version": "0.294.0",
+      "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.294.0.tgz",
+      "integrity": "sha512-V7o0/VECSGbLHn3/1O67FUgBwWB+hmzshrgDVRJQhMh8uj5D3HBuIvhuAmQTtlupILSplwIZg5FTc4tTKMA2SA==",
+      "peerDependencies": {
+        "react": "^16.5.1 || ^17.0.0 || ^18.0.0"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/merge2": {
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz",
+      "integrity": "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==",
+      "dev": true,
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/micromatch": {
+      "version": "4.0.8",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz",
+      "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==",
+      "dev": true,
+      "dependencies": {
+        "braces": "^3.0.3",
+        "picomatch": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=8.6"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "dev": true
+    },
+    "node_modules/mz": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/mz/-/mz-2.7.0.tgz",
+      "integrity": "sha512-z81GNO7nnYMEhrGh9LeymoE4+Yr0Wn5McHIZMK5cfQCl+NDX08sCZgUc9/6MHni9IWuFLm1Z3HTCXu2z9fN62Q==",
+      "dev": true,
+      "dependencies": {
+        "any-promise": "^1.0.0",
+        "object-assign": "^4.0.1",
+        "thenify-all": "^1.0.0"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+      "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.37",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.37.tgz",
+      "integrity": "sha512-1h5gKZCF+pO/o3Iqt5Jp7wc9rH3eJJ0+nh/CIoiRwjRxde/hAHyLPXYN4V3CqKAbiZPSeJFSWHmJsbkicta0Eg==",
+      "dev": true
+    },
+    "node_modules/normalize-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-hash": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/object-hash/-/object-hash-3.0.0.tgz",
+      "integrity": "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw==",
+      "dev": true,
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/path-parse": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+      "dev": true
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "dev": true
+    },
+    "node_modules/picomatch": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.2.tgz",
+      "integrity": "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA==",
+      "dev": true,
+      "engines": {
+        "node": ">=8.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/pify": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
+      "integrity": "sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/pirates": {
+      "version": "4.0.7",
+      "resolved": "https://registry.npmjs.org/pirates/-/pirates-4.0.7.tgz",
+      "integrity": "sha512-TfySrs/5nm8fQJDcBDuUng3VOUKsd7S+zqvbOTiGXHfxX4wK31ard+hoNuvkicM/2YFzlpDgABOevKSsB4G/FA==",
+      "dev": true,
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/postcss": {
+      "version": "8.5.8",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz",
+      "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "nanoid": "^3.3.11",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.1"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/postcss-import": {
+      "version": "15.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-import/-/postcss-import-15.1.0.tgz",
+      "integrity": "sha512-hpr+J05B2FVYUAXHeK1YyI267J/dDDhMU6B6civm8hSY1jYJnBXxzKDKDswzJmtLHryrjhnDjqqp/49t8FALew==",
+      "dev": true,
+      "dependencies": {
+        "postcss-value-parser": "^4.0.0",
+        "read-cache": "^1.0.0",
+        "resolve": "^1.1.7"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.0.0"
+      }
+    },
+    "node_modules/postcss-js": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-js/-/postcss-js-4.1.0.tgz",
+      "integrity": "sha512-oIAOTqgIo7q2EOwbhb8UalYePMvYoIeRY2YKntdpFQXNosSu3vLrniGgmH9OKs/qAkfoj5oB3le/7mINW1LCfw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "camelcase-css": "^2.0.1"
+      },
+      "engines": {
+        "node": "^12 || ^14 || >= 16"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4.21"
+      }
+    },
+    "node_modules/postcss-load-config": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/postcss-load-config/-/postcss-load-config-6.0.1.tgz",
+      "integrity": "sha512-oPtTM4oerL+UXmx+93ytZVN82RrlY/wPUV8IeDxFrzIjXOLF1pN+EmKPLbubvKHT2HC20xXsCAH2Z+CKV6Oz/g==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "lilconfig": "^3.1.1"
+      },
+      "engines": {
+        "node": ">= 18"
+      },
+      "peerDependencies": {
+        "jiti": ">=1.21.0",
+        "postcss": ">=8.0.9",
+        "tsx": "^4.8.1",
+        "yaml": "^2.4.2"
+      },
+      "peerDependenciesMeta": {
+        "jiti": {
+          "optional": true
+        },
+        "postcss": {
+          "optional": true
+        },
+        "tsx": {
+          "optional": true
+        },
+        "yaml": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/postcss-nested": {
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-nested/-/postcss-nested-6.2.0.tgz",
+      "integrity": "sha512-HQbt28KulC5AJzG+cZtj9kvKB93CFCdLvog1WFLf1D+xmMvPGlBstkpTEZfK5+AN9hfJocyBFCNiqyS48bpgzQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "postcss-selector-parser": "^6.1.1"
+      },
+      "engines": {
+        "node": ">=12.0"
+      },
+      "peerDependencies": {
+        "postcss": "^8.2.14"
+      }
+    },
+    "node_modules/postcss-selector-parser": {
+      "version": "6.1.2",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-6.1.2.tgz",
+      "integrity": "sha512-Q8qQfPiZ+THO/3ZrOrO0cJJKfpYCagtMUkXbnEfmgUjwXg6z/WBeOyS9APBBPCTSiDV+s4SwQGu8yFsiMRIudg==",
+      "dev": true,
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postcss-value-parser": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+      "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
+      "dev": true
+    },
+    "node_modules/proxy-from-env": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-2.1.0.tgz",
+      "integrity": "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA==",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/queue-microtask": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
+    "node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "dependencies": {
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      },
+      "peerDependencies": {
+        "react": "^18.3.1"
+      }
+    },
+    "node_modules/react-refresh": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+      "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/read-cache": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz",
+      "integrity": "sha512-Owdv/Ft7IjOgm/i0xvNDZ1LrRANRfew4b2prF3OWMQLxLfu3bS8FVhCsrSCMK4lR56Y9ya+AThoTpDCTxCmpRA==",
+      "dev": true,
+      "dependencies": {
+        "pify": "^2.3.0"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+      "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+      "dev": true,
+      "dependencies": {
+        "picomatch": "^2.2.1"
+      },
+      "engines": {
+        "node": ">=8.10.0"
+      }
+    },
+    "node_modules/resolve": {
+      "version": "1.22.11",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
+      "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==",
+      "dev": true,
+      "dependencies": {
+        "is-core-module": "^2.16.1",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/reusify": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.1.0.tgz",
+      "integrity": "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw==",
+      "dev": true,
+      "engines": {
+        "iojs": ">=1.0.0",
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/rollup": {
+      "version": "4.60.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.1.tgz",
+      "integrity": "sha512-VmtB2rFU/GroZ4oL8+ZqXgSA38O6GR8KSIvWmEFv63pQ0G6KaBH9s07PO8XTXP4vI+3UJUEypOfjkGfmSBBR0w==",
+      "dev": true,
+      "dependencies": {
+        "@types/estree": "1.0.8"
+      },
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.60.1",
+        "@rollup/rollup-android-arm64": "4.60.1",
+        "@rollup/rollup-darwin-arm64": "4.60.1",
+        "@rollup/rollup-darwin-x64": "4.60.1",
+        "@rollup/rollup-freebsd-arm64": "4.60.1",
+        "@rollup/rollup-freebsd-x64": "4.60.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.60.1",
+        "@rollup/rollup-linux-arm-musleabihf": "4.60.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.60.1",
+        "@rollup/rollup-linux-arm64-musl": "4.60.1",
+        "@rollup/rollup-linux-loong64-gnu": "4.60.1",
+        "@rollup/rollup-linux-loong64-musl": "4.60.1",
+        "@rollup/rollup-linux-ppc64-gnu": "4.60.1",
+        "@rollup/rollup-linux-ppc64-musl": "4.60.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.60.1",
+        "@rollup/rollup-linux-riscv64-musl": "4.60.1",
+        "@rollup/rollup-linux-s390x-gnu": "4.60.1",
+        "@rollup/rollup-linux-x64-gnu": "4.60.1",
+        "@rollup/rollup-linux-x64-musl": "4.60.1",
+        "@rollup/rollup-openbsd-x64": "4.60.1",
+        "@rollup/rollup-openharmony-arm64": "4.60.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.60.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.60.1",
+        "@rollup/rollup-win32-x64-gnu": "4.60.1",
+        "@rollup/rollup-win32-x64-msvc": "4.60.1",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/run-parallel": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "dependencies": {
+        "queue-microtask": "^1.2.2"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+      "dev": true,
+      "bin": {
+        "semver": "bin/semver.js"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+      "dev": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/sucrase": {
+      "version": "3.35.1",
+      "resolved": "https://registry.npmjs.org/sucrase/-/sucrase-3.35.1.tgz",
+      "integrity": "sha512-DhuTmvZWux4H1UOnWMB3sk0sbaCVOoQZjv8u1rDoTV0HTdGem9hkAZtl4JZy8P2z4Bg0nT+YMeOFyVr4zcG5Tw==",
+      "dev": true,
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.2",
+        "commander": "^4.0.0",
+        "lines-and-columns": "^1.1.6",
+        "mz": "^2.7.0",
+        "pirates": "^4.0.1",
+        "tinyglobby": "^0.2.11",
+        "ts-interface-checker": "^0.1.9"
+      },
+      "bin": {
+        "sucrase": "bin/sucrase",
+        "sucrase-node": "bin/sucrase-node"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/supports-preserve-symlinks-flag": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+      "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+      "dev": true,
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/tailwindcss": {
+      "version": "3.4.19",
+      "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.19.tgz",
+      "integrity": "sha512-3ofp+LL8E+pK/JuPLPggVAIaEuhvIz4qNcf3nA1Xn2o/7fb7s/TYpHhwGDv1ZU3PkBluUVaF8PyCHcm48cKLWQ==",
+      "dev": true,
+      "dependencies": {
+        "@alloc/quick-lru": "^5.2.0",
+        "arg": "^5.0.2",
+        "chokidar": "^3.6.0",
+        "didyoumean": "^1.2.2",
+        "dlv": "^1.1.3",
+        "fast-glob": "^3.3.2",
+        "glob-parent": "^6.0.2",
+        "is-glob": "^4.0.3",
+        "jiti": "^1.21.7",
+        "lilconfig": "^3.1.3",
+        "micromatch": "^4.0.8",
+        "normalize-path": "^3.0.0",
+        "object-hash": "^3.0.0",
+        "picocolors": "^1.1.1",
+        "postcss": "^8.4.47",
+        "postcss-import": "^15.1.0",
+        "postcss-js": "^4.0.1",
+        "postcss-load-config": "^4.0.2 || ^5.0 || ^6.0",
+        "postcss-nested": "^6.2.0",
+        "postcss-selector-parser": "^6.1.2",
+        "resolve": "^1.22.8",
+        "sucrase": "^3.35.0"
+      },
+      "bin": {
+        "tailwind": "lib/cli.js",
+        "tailwindcss": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/thenify": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/thenify/-/thenify-3.3.1.tgz",
+      "integrity": "sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==",
+      "dev": true,
+      "dependencies": {
+        "any-promise": "^1.0.0"
+      }
+    },
+    "node_modules/thenify-all": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/thenify-all/-/thenify-all-1.6.0.tgz",
+      "integrity": "sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==",
+      "dev": true,
+      "dependencies": {
+        "thenify": ">= 3.1.0 < 4"
+      },
+      "engines": {
+        "node": ">=0.8"
+      }
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+      "dev": true,
+      "dependencies": {
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/SuperchupuDev"
+      }
+    },
+    "node_modules/tinyglobby/node_modules/fdir": {
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+      "dev": true,
+      "engines": {
+        "node": ">=12.0.0"
+      },
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tinyglobby/node_modules/picomatch": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+      "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
+    "node_modules/to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "dependencies": {
+        "is-number": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/ts-interface-checker": {
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/ts-interface-checker/-/ts-interface-checker-0.1.13.tgz",
+      "integrity": "sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==",
+      "dev": true
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+      "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "dev": true
+    },
+    "node_modules/vite": {
+      "version": "5.4.21",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz",
+      "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==",
+      "dev": true,
+      "dependencies": {
+        "esbuild": "^0.21.3",
+        "postcss": "^8.4.43",
+        "rollup": "^4.20.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "sass-embedded": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "sass-embedded": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/yallist": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+      "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+      "dev": true
+    }
+  }
+}

frontend/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "medical-predictor-frontend",
+  "private": true,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "axios": "^1.6.0",
+    "lucide-react": "^0.294.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "@vitejs/plugin-react": "^4.2.1",
+    "vite": "^5.0.0",
+    "tailwindcss": "^3.3.0",
+    "postcss": "^8.4.31",
+    "autoprefixer": "^10.4.16"
+  }
+}

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

frontend/src/App.jsx

@@ -0,0 +1,67 @@
+import { useState } from 'react'
+import useChat from './hooks/useChat'
+import FeatureSidebar from './components/FeatureSidebar'
+import ChatWindow from './components/ChatWindow'
+import InputBar from './components/InputBar'
+
+function App() {
+  const { messages, features, loading, prediction, sendMessage, resetChat } = useChat()
+  const [showConfirm, setShowConfirm] = useState(false)
+
+  const handleReset = async () => {
+    setShowConfirm(true)
+  }
+
+  const confirmReset = async () => {
+    setShowConfirm(false)
+    await resetChat()
+  }
+
+  return (
+    <div className="flex h-screen bg-white overflow-hidden">
+      {/* Sidebar with feature tracking */}
+      <FeatureSidebar features={features} />
+
+      {/* Main chat area */}
+      <div className="flex-1 flex flex-col">
+        {/* Chat messages */}
+        <ChatWindow messages={messages} prediction={prediction} />
+
+        {/* Input bar */}
+        <InputBar
+          onSend={sendMessage}
+          onReset={handleReset}
+          disabled={loading}
+        />
+      </div>
+
+      {/* Reset Confirmation Modal */}
+      {showConfirm && (
+        <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
+          <div className="bg-white rounded-lg shadow-xl p-6 max-w-sm mx-4">
+            <h3 className="text-lg font-semibold text-gray-900 mb-2">Start New Assessment?</h3>
+            <p className="text-gray-600 mb-6">
+              This will clear all your current health data and start a fresh assessment.
+            </p>
+            <div className="flex gap-3 justify-end">
+              <button
+                onClick={() => setShowConfirm(false)}
+                className="px-4 py-2 rounded-lg border border-gray-300 text-gray-700 hover:bg-gray-50 font-medium transition-colors"
+              >
+                Cancel
+              </button>
+              <button
+                onClick={confirmReset}
+                className="px-4 py-2 rounded-lg bg-purple-600 hover:bg-purple-700 text-white font-medium transition-colors"
+              >
+                Start New
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  )
+}
+
+export default App

frontend/src/components/ChatWindow.jsx

@@ -0,0 +1,46 @@
+import { useEffect, useRef } from 'react'
+import MessageBubble from './MessageBubble'
+import DiagnosisCard from './DiagnosisCard'
+
+const ChatWindow = ({ messages, prediction }) => {
+  const messagesEndRef = useRef(null)
+
+  useEffect(() => {
+    // Auto-scroll to bottom on new message
+    messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' })
+  }, [messages, prediction])
+
+  return (
+    <div className="flex-1 overflow-y-auto bg-white px-6 py-6">
+      <div className="max-w-2xl mx-auto">
+        {messages.length === 0 && (
+          <div className="flex items-center justify-center h-full text-center">
+            <div>
+              <h2 className="text-3xl font-bold text-gray-800 mb-3">Medical Diagnosis AI</h2>
+              <p className="text-gray-500 mb-2">Your personalized health assessment</p>
+              <p className="text-xs text-gray-400 max-w-md mx-auto">
+                Answer health questions to receive a personalized diagnosis assessment.
+                All information is secure and used only for analysis.
+              </p>
+            </div>
+          </div>
+        )}
+
+        {messages.map((msg, idx) => (
+          <MessageBubble key={idx} role={msg.role} content={msg.content} />
+        ))}
+
+        {/* Show diagnosis card when prediction is complete */}
+        {prediction && (
+          <div className="mt-6 mb-4">
+            <DiagnosisCard diagnosis={prediction} />
+          </div>
+        )}
+
+        <div ref={messagesEndRef} />
+      </div>
+    </div>
+  )
+}
+
+export default ChatWindow

frontend/src/components/DiagnosisCard.jsx

@@ -0,0 +1,123 @@
+/**
+ * DiagnosisCard Component
+ *
+ * Professional diagnosis result card with:
+ * - Light background with professional styling
+ * - Confidence gauge with progress bar
+ * - Comprehensive Patient Data Report grid
+ * - Clean, focused layout
+ */
+const DiagnosisCard = ({ diagnosis }) => {
+  if (!diagnosis) return null
+
+  const {
+    prediction_name,
+    confidence,
+    explanation,
+    features = {},
+  } = diagnosis
+
+  // Calculate confidence percentage
+  const confidencePercent = (confidence * 100).toFixed(1)
+
+  // Feature display labels for the Patient Data Report
+  const featureLabels = {
+    Age: 'Age',
+    Glucose: 'Blood Glucose',
+    HbA1c: 'HbA1c',
+    BMI: 'BMI',
+    Cholesterol: 'Cholesterol',
+    Triglycerides: 'Triglycerides',
+    BloodPressure: 'Blood Pressure',
+    PhysicalActivity: 'Physical Activity',
+    SleepHours: 'Sleep Hours',
+    StressLevel: 'Stress Level',
+    DietScore: 'Diet Score',
+    Smoking: 'Smoking',
+    Alcohol: 'Alcohol',
+    FamilyHistory: 'Family History',
+    LengthOfStay: 'Length of Stay',
+    OxygenSaturation: 'Oxygen Saturation',
+  }
+
+  // Get progress bar color based on confidence
+  const getProgressBarColor = () => {
+    if (confidencePercent >= 80) return 'bg-green-500'
+    if (confidencePercent >= 60) return 'bg-amber-500'
+    return 'bg-red-500'
+  }
+
+  return (
+    <div className="rounded-2xl p-6 border-2 bg-slate-50 border-slate-200">
+      {/* Header */}
+      <h2 className="text-xl font-bold text-slate-900 mb-4">
+        Health Assessment Summary
+      </h2>
+
+      {/* Diagnosis Display */}
+      <div className="mb-6">
+        <p className="text-sm font-medium text-slate-600 mb-2">Diagnosis</p>
+        <h3 className="text-3xl font-bold text-slate-900">
+          {prediction_name}
+        </h3>
+      </div>
+
+      {/* Confidence Gauge */}
+      <div className="mb-6">
+        <div className="flex items-center justify-between mb-2">
+          <p className="text-sm font-medium text-slate-700">Confidence Level</p>
+          <p className="text-sm font-bold text-slate-900">{confidencePercent}%</p>
+        </div>
+
+        {/* Progress Bar */}
+        <div className="w-full h-2 bg-slate-200 rounded-full overflow-hidden">
+          <div
+            className={`h-full ${getProgressBarColor()} transition-all duration-500`}
+            style={{ width: `${confidencePercent}%` }}
+          />
+        </div>
+
+        {/* Confidence Description */}
+        <p className="text-xs text-slate-500 mt-2">
+          {confidencePercent >= 80
+            ? 'High confidence prediction'
+            : confidencePercent >= 60
+              ? 'Moderate confidence prediction'
+              : 'Lower confidence prediction - consult healthcare provider'}
+        </p>
+      </div>
+
+      {/* Explanation */}
+      <div className="bg-white/50 rounded-lg p-4 border border-slate-200 mb-6">
+        <p className="text-sm text-slate-700 leading-relaxed">
+          {explanation}
+        </p>
+      </div>
+
+      {/* Patient Data Report */}
+      <div className="border-t border-slate-200 mt-4 pt-4">
+        <h3 className="text-lg font-bold text-slate-900 mb-4">Patient Data Report</h3>
+
+        <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+          {Object.entries(features).map(([key, value]) => {
+            // Get the display label for this feature
+            const displayLabel = featureLabels[key] || key
+
+            return (
+              <div key={key} className="space-y-1">
+                <p className="text-xs font-medium text-slate-500 uppercase tracking-wider">
+                  {displayLabel}
+                </p>
+                <p className="text-sm font-semibold text-slate-900">
+                  {value !== null && value !== undefined ? String(value) : '—'}
+                </p>
+              </div>
+            )
+          })}
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default DiagnosisCard

frontend/src/components/FeatureSidebar.jsx

@@ -0,0 +1,105 @@
+import MetricItem from './MetricItem'
+
+const FEATURE_LABELS = {
+  'Age': 'Age',
+  'Glucose': 'Blood Glucose',
+  'HbA1c': 'HbA1c',
+  'BMI': 'BMI',
+  'Cholesterol': 'Cholesterol',
+  'Triglycerides': 'Triglycerides',
+  'Blood Pressure': 'Blood Pressure',
+  'Physical Activity': 'Physical Activity',
+  'Sleep Hours': 'Sleep Hours',
+  'Stress Level': 'Stress Level',
+  'Diet Score': 'Diet Score',
+  'Smoking': 'Smoking',
+  'Alcohol': 'Alcohol',
+  'Family History': 'Family History',
+  'LengthOfStay': 'Length of Stay',
+  'Oxygen Saturation': 'Oxygen Saturation',
+}
+
+const FEATURE_DEFINITIONS = {
+  'Age': 'Your current age in years.',
+  'Glucose': 'Current blood sugar level (mg/dL).',
+  'HbA1c': 'Average blood sugar over the last 3 months (%).',
+  'BMI': 'Body Mass Index; a measure of body fat based on height and weight.',
+  'Cholesterol': 'Total amount of cholesterol in your blood (mg/dL).',
+  'Triglycerides': 'A type of fat found in your blood (mg/dL).',
+  'Blood Pressure': 'The force of your blood against artery walls (e.g., 120).',
+  'Physical Activity': 'Total hours of exercise or active movement per week.',
+  'Sleep Hours': 'Average hours of sleep you get per 24-hour period.',
+  'Stress Level': '1-3 (Low): Calm, in control. 4-6 (Moderate): Busy, pressured. 7-8 (High): Anxious, overwhelmed. 9-10 (Very High): Exhausted, unable to cope.',
+  'Diet Score': 'Self-rating of how healthy your meals are (1-10).',
+  'Smoking': 'Whether you currently smoke or have a history of smoking.',
+  'Alcohol': 'Your frequency of alcohol consumption.',
+  'Family History': 'Whether close relatives have had chronic conditions like heart disease or diabetes.',
+  'LengthOfStay': 'Total days spent in a hospital during your last visit.',
+  'Oxygen Saturation': 'The percentage of oxygen in your blood (SpO2).',
+}
+
+const DEFAULT_FEATURES = [
+  'Age', 'Glucose', 'HbA1c', 'BMI',
+  'Cholesterol', 'Triglycerides', 'Blood Pressure', 'Physical Activity',
+  'Sleep Hours', 'Stress Level', 'Diet Score', 'Smoking',
+  'Alcohol', 'Family History', 'LengthOfStay', 'Oxygen Saturation'
+]
+
+const FeatureSidebar = ({ features }) => {
+  const collectedCount = DEFAULT_FEATURES.filter(
+    feature => features[feature] !== null && features[feature] !== undefined
+  ).length
+
+  const progressPercent = (collectedCount / 16) * 100
+
+  return (
+    <div className="w-72 bg-gray-50 border-r border-gray-200 flex flex-col h-full">
+      {/* Header */}
+      <div className="p-4 border-b border-gray-200">
+        <h2 className="text-sm font-semibold text-gray-900 mb-3">Health Metrics</h2>
+
+        {/* Progress bar */}
+        <div className="mb-2">
+          <div className="flex justify-between mb-1">
+            <span className="text-xs text-gray-600">{collectedCount}/16</span>
+            <span className="text-xs text-gray-600">{Math.round(progressPercent)}%</span>
+          </div>
+          <div className="w-full h-2 bg-gray-200 rounded-full overflow-hidden">
+            <div
+              className="h-full bg-purple-600 transition-all duration-300"
+              style={{ width: `${progressPercent}%` }}
+            />
+          </div>
+        </div>
+      </div>
+
+      {/* Features list */}
+      <div className="flex-1 overflow-y-auto px-4 py-3">
+        <div className="space-y-2">
+          {DEFAULT_FEATURES.map(feature => {
+            const isCollected = features[feature] !== null && features[feature] !== undefined
+            const displayLabel = FEATURE_LABELS[feature] || feature
+            const definition = FEATURE_DEFINITIONS[feature] || 'No description available.'
+
+            return (
+              <MetricItem
+                key={feature}
+                feature={feature}
+                displayLabel={displayLabel}
+                definition={definition}
+                isCollected={isCollected}
+              />
+            )
+          })}
+        </div>
+
+        {/* Help text at bottom */}
+        <div className="mt-4 pt-3 border-t border-gray-200 text-xs text-gray-500">
+          <p>💡 <strong>Tip:</strong> Hover over or click the <span className="text-gray-600">ⓘ</span> icon next to each metric to learn what it measures.</p>
+        </div>
+      </div>
+    </div>
+  )
+}
+
+export default FeatureSidebar

frontend/src/components/FeatureTooltip.jsx

@@ -0,0 +1,138 @@
+import { useState, useRef, useEffect } from 'react'
+import { Info, X } from 'lucide-react'
+
+const FeatureTooltip = ({ feature, definition }) => {
+  const [isOpen, setIsOpen] = useState(false)
+  const [position, setPosition] = useState({ top: 0, left: 0 })
+  const iconRef = useRef(null)
+  const tooltipRef = useRef(null)
+
+  // Handle tooltip positioning to stay visible
+  useEffect(() => {
+    if (!isOpen || !iconRef.current || !tooltipRef.current) return
+
+    const calculatePosition = () => {
+      const iconRect = iconRef.current.getBoundingClientRect()
+      const tooltipRect = tooltipRef.current.getBoundingClientRect()
+
+      let top = iconRect.top - 8
+      let left = iconRect.right + 12
+
+      // Adjust if tooltip goes off-screen to the right
+      if (left + tooltipRect.width > window.innerWidth - 10) {
+        left = iconRect.left - tooltipRect.width - 12
+      }
+
+      // Adjust if tooltip goes off-screen at the bottom
+      if (top + tooltipRect.height > window.innerHeight - 10) {
+        top = window.innerHeight - tooltipRect.height - 10
+      }
+
+      // Adjust if tooltip goes off-screen at the top
+      if (top < 10) {
+        top = 10
+      }
+
+      setPosition({ top, left })
+    }
+
+    calculatePosition()
+
+    // Recalculate on window resize
+    window.addEventListener('resize', calculatePosition)
+    return () => window.removeEventListener('resize', calculatePosition)
+  }, [isOpen])
+
+  // Close tooltip when clicking outside
+  useEffect(() => {
+    if (!isOpen) return
+
+    const handleClickOutside = (e) => {
+      if (
+        tooltipRef.current &&
+        !tooltipRef.current.contains(e.target) &&
+        iconRef.current &&
+        !iconRef.current.contains(e.target)
+      ) {
+        setIsOpen(false)
+      }
+    }
+
+    document.addEventListener('mousedown', handleClickOutside)
+    return () => document.removeEventListener('mousedown', handleClickOutside)
+  }, [isOpen])
+
+  const handleIconClick = (e) => {
+    e.stopPropagation()
+    setIsOpen(!isOpen)
+  }
+
+  const handleIconHover = (open) => {
+    // Only auto-close on hover leave for desktop, not on click
+    if (open) {
+      setIsOpen(true)
+    }
+  }
+
+  return (
+    <div className="relative inline-block">
+      {/* Info Icon */}
+      <button
+        ref={iconRef}
+        onClick={handleIconClick}
+        onMouseEnter={() => handleIconHover(true)}
+        onMouseLeave={() => {
+          // Auto-close on hover only if opened via hover (not click)
+          if (!isOpen) return
+          // Check if it was opened by click or hover
+          const isClickOpened = isOpen && true
+          // Keep it open if clicked, close if just hovered
+        }}
+        className="p-1 rounded-full text-gray-400 hover:text-gray-600 hover:bg-gray-100 transition-all duration-150 cursor-help"
+        title="Click or hover for definition"
+        aria-label={`Information about ${feature}`}
+      >
+        <Info size={14} className="flex-shrink-0" />
+      </button>
+
+      {/* Tooltip */}
+      {isOpen && (
+        <div
+          ref={tooltipRef}
+          className="fixed max-w-xs bg-slate-800 text-white rounded-lg shadow-xl p-3 text-xs leading-relaxed z-50 border border-slate-700 animate-in fade-in duration-200"
+          style={{
+            top: `${position.top}px`,
+            left: `${position.left}px`,
+          }}
+        >
+          {/* Header with feature name and close button */}
+          <div className="flex items-start justify-between gap-2 mb-2">
+            <span className="font-semibold text-slate-200">{feature}</span>
+            <button
+              onClick={() => setIsOpen(false)}
+              className="flex-shrink-0 text-slate-400 hover:text-slate-200 transition-colors"
+              aria-label="Close tooltip"
+            >
+              <X size={14} />
+            </button>
+          </div>
+
+          {/* Definition */}
+          <p className="text-slate-100 leading-relaxed">{definition}</p>
+
+          {/* Arrow pointer (subtle) */}
+          <div className="absolute w-2 h-2 bg-slate-800 border-r border-t border-slate-700 transform -translate-x-1 -top-1 left-4 rotate-45" />
+        </div>
+      )}
+
+      {/* Hint text - visible on hover/click for mobile users */}
+      {!isOpen && (
+        <div className="absolute bottom-full right-0 mb-1 text-xs text-gray-400 whitespace-nowrap pointer-events-none opacity-0 group-hover:opacity-100 transition-opacity">
+          <span className="text-gray-400 text-[10px]">Click for info</span>
+        </div>
+      )}
+    </div>
+  )
+}
+
+export default FeatureTooltip

frontend/src/components/InputBar.jsx

@@ -0,0 +1,79 @@
+import { useState, useRef, useEffect } from 'react'
+import { Send } from 'lucide-react'
+
+const InputBar = ({ onSend, onReset, disabled }) => {
+  const [input, setInput] = useState('')
+  const textareaRef = useRef(null)
+
+  // Auto-resize textarea
+  useEffect(() => {
+    if (textareaRef.current) {
+      textareaRef.current.style.height = 'auto'
+      textareaRef.current.style.height = Math.min(textareaRef.current.scrollHeight, 120) + 'px'
+    }
+  }, [input])
+
+  const handleSend = async () => {
+    if (input.trim() && !disabled) {
+      await onSend(input)
+      setInput('')
+      if (textareaRef.current) {
+        textareaRef.current.style.height = 'auto'
+      }
+    }
+  }
+
+  const handleKeyDown = (e) => {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault()
+      handleSend()
+    }
+  }
+
+  return (
+    <div className="border-t border-gray-200 bg-white px-6 py-4 shadow-lg">
+      <div className="max-w-2xl mx-auto">
+        <div className="flex gap-3 items-end">
+          {/* New button */}
+          <button
+            onClick={onReset}
+            disabled={disabled}
+            className="px-4 py-2 rounded-lg border border-gray-300 text-gray-600 hover:bg-gray-50 hover:border-gray-400 text-sm font-medium transition-all duration-200 disabled:opacity-50 disabled:cursor-not-allowed"
+            title="Start a new assessment"
+          >
+            New
+          </button>
+
+          {/* Input box */}
+          <div className="flex-1 border border-gray-300 rounded-xl px-4 py-2 bg-white shadow-sm hover:shadow-md focus-within:shadow-md focus-within:border-purple-400 transition-all duration-200">
+            <textarea
+              ref={textareaRef}
+              value={input}
+              onChange={(e) => setInput(e.target.value)}
+              onKeyDown={handleKeyDown}
+              placeholder="Tell me about your health..."
+              disabled={disabled}
+              className="w-full resize-none outline-none text-sm border-none p-0 bg-transparent text-gray-900 placeholder-gray-400 disabled:bg-gray-50 disabled:cursor-not-allowed"
+              rows="1"
+            />
+          </div>
+
+          {/* Send button */}
+          <button
+            onClick={handleSend}
+            disabled={disabled || !input.trim()}
+            className="px-4 py-2 rounded-lg bg-purple-600 hover:bg-purple-700 text-white text-sm font-medium transition-all duration-200 disabled:opacity-50 disabled:cursor-not-allowed flex items-center gap-2 shadow-sm hover:shadow-md"
+            title="Send message (Enter)"
+          >
+            <Send size={16} />
+          </button>
+        </div>
+        <p className="text-xs text-gray-400 mt-2">
+          💡 Tip: Press Shift+Enter for new line
+        </p>
+      </div>
+    </div>
+  )
+}
+
+export default InputBar

frontend/src/components/MessageBubble.jsx

@@ -0,0 +1,25 @@
+const MessageBubble = ({ role, content }) => {
+  if (role === 'user') {
+    return (
+      <div className="flex justify-end mb-4">
+        <div className="bg-white border border-gray-200 rounded-xl shadow-sm px-4 py-3 max-w-prose hover:shadow-md transition-shadow">
+          <p className="text-gray-900 text-sm leading-relaxed whitespace-pre-wrap break-words">
+            {content}
+          </p>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="flex justify-start mb-4">
+      <div className="bg-[#FFD1DC] rounded-xl px-4 py-3 max-w-prose shadow-sm">
+        <p className="text-gray-900 text-sm leading-relaxed whitespace-pre-wrap break-words">
+          {content}
+        </p>
+      </div>
+    </div>
+  )
+}
+
+export default MessageBubble

frontend/src/components/MetricItem.jsx

@@ -0,0 +1,130 @@
+import { useState, useRef, useEffect } from 'react'
+import { createPortal } from 'react-dom'
+import { CheckCircle, Circle, Info, X } from 'lucide-react'
+
+/**
+ * MetricItem Component
+ *
+ * Handles individual health metric with isolated hover state
+ * Uses React Portal to render popover outside the scrollable sidebar
+ * Ensures popover floats over the chat area without being clipped
+ */
+const MetricItem = ({ feature, displayLabel, definition, isCollected }) => {
+  const [showHint, setShowHint] = useState(false)
+  const [popoverPosition, setPopoverPosition] = useState({ top: 0, left: 0 })
+  const iconRef = useRef(null)
+
+  // Calculate popover position based on icon location
+  useEffect(() => {
+    if (!showHint || !iconRef.current) return
+
+    const iconRect = iconRef.current.getBoundingClientRect()
+
+    // Position popover to the right of the icon, aligned with top
+    // Add some spacing (16px) to the right
+    const left = iconRect.right + 16
+    const top = iconRect.top - 8  // Slight vertical centering
+
+    setPopoverPosition({ top, left })
+  }, [showHint])
+
+  // Handle mouse leaving the metric item
+  const handleMouseLeave = () => {
+    setShowHint(false)
+  }
+
+  // Handle mouse entering the metric item
+  const handleMouseEnter = () => {
+    setShowHint(true)
+  }
+
+  // Close hint when clicking X button
+  const handleCloseHint = (e) => {
+    e.stopPropagation()
+    setShowHint(false)
+  }
+
+  return (
+    <>
+      {/* Metric Item Row */}
+      <div
+        className={`flex items-center justify-between gap-2 text-xs p-2 rounded transition-all duration-150 ${
+          isCollected
+            ? 'text-green-700 bg-green-50 hover:bg-green-100'
+            : 'text-gray-400 hover:bg-gray-100'
+        }`}
+        onMouseEnter={handleMouseEnter}
+        onMouseLeave={handleMouseLeave}
+      >
+        {/* Status icon + Label */}
+        <div className="flex items-center gap-2 flex-1 min-w-0">
+          {isCollected ? (
+            <CheckCircle size={16} className="flex-shrink-0" />
+          ) : (
+            <Circle size={16} className="flex-shrink-0" />
+          )}
+          <span className="truncate">{displayLabel}</span>
+        </div>
+
+        {/* Info Icon Button */}
+        <button
+          ref={iconRef}
+          onClick={() => setShowHint(!showHint)}
+          className="p-1 rounded-full text-gray-400 hover:text-gray-600 hover:bg-gray-200 transition-all duration-150 cursor-help flex-shrink-0"
+          title="Click for definition"
+          aria-label={`Information about ${displayLabel}`}
+        >
+          <Info size={14} />
+        </button>
+      </div>
+
+      {/* Popover - Rendered via Portal (outside sidebar) with Glassmorphism */}
+      {showHint &&
+        createPortal(
+          <div
+            className="fixed z-9999 w-80 rounded-2xl shadow-lg p-4 text-xs leading-relaxed animate-in fade-in duration-200 pointer-events-auto backdrop-blur-md"
+            style={{
+              top: `${popoverPosition.top}px`,
+              left: `${popoverPosition.left}px`,
+              backgroundColor: 'rgba(220, 252, 231, 0.75)',
+              borderColor: 'rgba(134, 239, 172, 0.5)',
+              borderWidth: '1px',
+              WebkitBackdropFilter: 'blur(12px)',
+            }}
+            onMouseEnter={() => setShowHint(true)}
+            onMouseLeave={() => setShowHint(false)}
+          >
+            {/* Header with feature name and close button */}
+            <div className="flex items-start justify-between gap-3 mb-3">
+              <span className="font-semibold text-green-900 text-sm">{displayLabel}</span>
+              <button
+                onClick={handleCloseHint}
+                className="flex-shrink-0 text-green-700 hover:text-green-900 transition-colors p-0.5 hover:bg-green-200/40 rounded-lg"
+                aria-label="Close popover"
+              >
+                <X size={16} />
+              </button>
+            </div>
+
+            {/* Definition text */}
+            <p className="text-green-900 leading-relaxed mb-2 font-medium">{definition}</p>
+
+            {/* Arrow pointer - points back to info icon (matches popover styling) */}
+            <div
+              className="absolute w-3 h-3 transform rotate-45"
+              style={{
+                right: '-6px',
+                top: `${8}px`,
+                backgroundColor: 'rgba(220, 252, 231, 0.85)',
+                borderTop: '1px solid rgba(134, 239, 172, 0.4)',
+                borderLeft: '1px solid rgba(134, 239, 172, 0.4)',
+              }}
+            />
+          </div>,
+          document.body
+        )}
+    </>
+  )
+}
+
+export default MetricItem

frontend/src/hooks/useChat.js

@@ -0,0 +1,84 @@
+import { useState } from 'react'
+import axios from 'axios'
+
+const useChat = () => {
+  const [messages, setMessages] = useState([])
+  const [features, setFeatures] = useState({})
+  const [sessionId, setSessionId] = useState(null)
+  const [loading, setLoading] = useState(false)
+  const [prediction, setPrediction] = useState(null)
+
+  const sendMessage = async (text) => {
+    if (!text.trim()) return
+
+    // Add user message immediately
+    setMessages(prev => [...prev, { role: 'user', content: text }])
+    setLoading(true)
+
+    try {
+      // Call POST /api/chat
+      const res = await axios.post('/api/chat', {
+        session_id: sessionId,
+        message: text,
+        history: messages,
+      })
+
+      // Update state from response
+      setSessionId(res.data.session_id)
+      setFeatures(res.data.features)
+      setMessages(prev => [...prev, { role: 'assistant', content: res.data.message }])
+
+      // Store prediction if complete
+      if (res.data.is_complete && res.data.prediction) {
+        setPrediction(res.data.prediction)
+      }
+
+      return res.data
+    } catch (error) {
+      console.error('Error sending message:', error)
+      setMessages(prev => [...prev, {
+        role: 'assistant',
+        content: '❌ Error: Could not process your message. Please try again.'
+      }])
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  const resetChat = async () => {
+    if (!sessionId) {
+      // Reset UI without API call if no session yet
+      setMessages([])
+      setFeatures({})
+      setPrediction(null)
+      return
+    }
+
+    try {
+      await axios.post('/api/reset', { session_id: sessionId })
+      setMessages([])
+      setFeatures({})
+      setSessionId(null)
+      setPrediction(null)
+    } catch (error) {
+      console.error('Error resetting session:', error)
+      // Still reset UI even if API call fails
+      setMessages([])
+      setFeatures({})
+      setSessionId(null)
+      setPrediction(null)
+    }
+  }
+
+  return {
+    messages,
+    features,
+    loading,
+    sessionId,
+    prediction,
+    sendMessage,
+    resetChat,
+  }
+}
+
+export default useChat

frontend/src/index.css

@@ -0,0 +1,41 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+  background: #ffffff;
+}
+
+html, body, #root {
+  height: 100%;
+}
+
+/* Scrollbar styling */
+::-webkit-scrollbar {
+  width: 8px;
+}
+
+::-webkit-scrollbar-track {
+  background: #f1f1f1;
+}
+
+::-webkit-scrollbar-thumb {
+  background: #cbd5e1;
+  border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: #94a3b8;
+}
+
+/* Custom z-index for popovers - ensures they float above everything */
+.z-9999 {
+  z-index: 9999;
+}

frontend/src/main.jsx

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App.jsx'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

frontend/tailwind.config.js

@@ -0,0 +1,18 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: [
+    "./index.html",
+    "./src/**/*.{js,jsx}",
+  ],
+  theme: {
+    extend: {
+      colors: {
+        purple: {
+          600: '#9333ea',
+          700: '#7e22ce',
+        },
+      },
+    },
+  },
+  plugins: [],
+}

frontend/vite.config.js

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    proxy: {
+      '/api': {
+        target: 'http://localhost:8000',
+        changeOrigin: true,
+      },
+    },
+  },
+})

models/GradientBoosting_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:394bcda0ead5e154434e56d53bc1f8536585c9d5a69db4a93345e2413daf99b6
+size 2062313

requirements.txt

@@ -0,0 +1,11 @@
+gradio>=4.44.1
+groq
+python-dotenv
+pydantic
+scikit-learn
+joblib
+numpy
+huggingface_hub>=0.23.4
+fastapi>=0.100.0
+uvicorn[standard]>=0.23.0
+python-multipart>=0.0.6

server.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""
+FastAPI server entry point for Medical Diagnosis AI
+
+Local Development:
+  python server.py
+  Server will start on http://localhost:8000
+  API docs: http://localhost:8000/docs
+
+Hugging Face Spaces / Production:
+  python server.py
+  Server will start on http://0.0.0.0:7860
+  Serves both API and static React frontend
+"""
+
+import uvicorn
+import logging
+import os
+from pathlib import Path
+from fastapi.staticfiles import StaticFiles
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def get_server_config():
+    """Determine server configuration based on environment"""
+    # Check if running in Hugging Face Spaces
+    in_space = os.getenv("SPACE_ID") is not None
+
+    host = "0.0.0.0"
+    port = 7860 if in_space else 8000
+    reload = not in_space  # Disable reload in production (HF Spaces)
+
+    return host, port, reload, in_space
+
+
+if __name__ == "__main__":
+    host, port, reload, in_space = get_server_config()
+
+    # Import FastAPI app AFTER configuration
+    from app.api import app
+
+    # Configure static file serving for the React frontend
+    frontend_dist = Path(__file__).parent / "frontend" / "dist"
+
+    if frontend_dist.exists():
+        logger.info(f"📁 Mounting static files from: {frontend_dist}")
+        # Mount static files at root, but BEFORE API routes are checked
+        # This way /api/* routes are handled by FastAPI, everything else by static files
+        app.mount("/", StaticFiles(directory=frontend_dist, html=True), name="static")
+    else:
+        logger.warning(f"⚠️  Frontend dist directory not found: {frontend_dist}")
+        logger.warning("    Run 'cd frontend && npm run build' to build the frontend")
+
+    # Log startup info
+    environment = "🚀 Hugging Face Spaces" if in_space else "💻 Local Development"
+    logger.info(f"Starting Medical Diagnosis AI Server ({environment})")
+    logger.info(f"📍 Server: http://{host}:{port}")
+    logger.info(f"🌐 Frontend: http://{host}:{port}")
+    logger.info(f"📊 API Base: http://{host}:{port}/api")
+    logger.info(f"📖 API Docs: http://{host}:{port}/docs")
+
+    uvicorn.run(
+        "app.api:app",
+        host=host,
+        port=port,
+        reload=reload,
+        log_level="info"
+    )