Upload app.py

app.py

@@ -0,0 +1,791 @@
+# app.py
+"""
+Streamlit First Aid Assistant
+- Single-file Streamlit app
+- Saves victim records to ./data/victims.json
+- Uses OPENAI_API_KEY (env var) or temporary UI key in session (not persisted)
+- Adjusted for safer defaults and improved UI/UX
+"""
+
+import os
+import json
+import traceback
+from datetime import datetime
+from pathlib import Path
+import streamlit as st
+
+
+# -----------------------
+# Paths / Configuration
+# -----------------------
+APP_DIR = Path.cwd()
+DATA_DIR = APP_DIR / "data"
+DATA_FILE = DATA_DIR / "victims.json"
+NEXT_STEP_FILE = DATA_DIR / "next_step.json"
+STREAMLIT_ROOT_CONFIG = Path("/root/.streamlit/config.toml")
+
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+# -----------------------
+# Simple first-aid content
+# -----------------------
+SNAKEBITE_STEPS = [
+    "Keep the victim calm and still — limit movement.",
+    "Call emergency services immediately.",
+    "Position the affected limb at or slightly below heart level.",
+    "Remove tight clothing or jewelry near the bite area.",
+    "Clean the wound gently with soap and water; do NOT cut or suck the bite.",
+    "Cover with a clean, loose dressing. Monitor breathing and consciousness.",
+]
+
+NORMAL_WOUND_STEPS = [
+    "Wash your hands if possible.",
+    "Apply gentle pressure with a clean cloth to stop bleeding.",
+    "Rinse the wound with clean water (do not use strong antiseptics directly).",
+    "Apply an antiseptic wipe or ointment if available.",
+    "Cover with a sterile dressing or bandage.",
+    "If bleeding continues or wound is deep, seek medical help.",
+]
+
+
+def get_steps(wound_type: str):
+    return SNAKEBITE_STEPS if wound_type == "poisoned" else NORMAL_WOUND_STEPS
+# -----------------------
+# Firebase (Pyrebase4) configuration
+# -----------------------
+import pyrebase
+
+# Lấy config từ secrets.toml
+if "firebase" in st.secrets:
+    fb_cfg = st.secrets["firebase"]
+    firebase_config = {
+        "apiKey": fb_cfg["apiKey"],
+        "authDomain": fb_cfg["authDomain"],
+        "projectId": fb_cfg["projectId"],
+        "storageBucket": fb_cfg["storageBucket"],
+        "messagingSenderId": fb_cfg["messagingSenderId"],
+        "appId": fb_cfg["appId"],
+        "measurementId": fb_cfg["measurementId"],
+        "databaseURL": fb_cfg["databaseURL"]
+    }
+    firebase = pyrebase.initialize_app(firebase_config)
+    db = firebase.database()
+else:
+    st.error("Firebase configuration not found in secrets.toml")
+    db = None
+
+
+# -----------------------
+# Read latest wound data
+# -----------------------
+def get_latest_wound_data():
+    if not db:
+        return None
+    try:
+        data = db.child("data").get().val()
+        if not data:
+            return None
+        # ✅ Nếu data là dict và chứa key "Wound" trực tiếp
+        if "Wound" in data:
+            return data
+        # ✅ Nếu có nhiều bản ghi (record_001, record_002, ...)
+        elif isinstance(data, dict):
+            latest_key = list(data.keys())[-1]
+            return data[latest_key]
+        return data
+    except Exception as e:
+        st.error(f"Error reading Firebase data: {e}")
+        return None
+
+
+# -----------------------
+# Auto-display section
+# -----------------------
+st.set_page_config(page_title="First Aid Assistant (Firebase)", layout="wide")
+st.title("🩺 First Aid Assistant — Firebase Connected")
+
+data = get_latest_wound_data()
+
+if isinstance(data, str):
+    try:
+        # cố gắng parse nếu nó là JSON string
+        data = json.loads(data)
+    except Exception:
+        st.error("⚠️ Firebase returned unexpected string data.")
+        data = None
+
+if data and isinstance(data, dict):
+    st.subheader("📡 Latest record from Firebase")
+    st.json(data)
+
+    wound_type = str(data.get("Wound", "")).strip().lower()
+    st.markdown("---")
+
+    if wound_type == "snakebite":
+        st.subheader("🐍 Detected case: Snakebite")
+        st.markdown("\n".join([f"{i+1}. {s}" for i, s in enumerate(SNAKEBITE_STEPS)]))
+        st.session_state.wound_type = "snakebite"
+        st.session_state.basic_done = True
+
+    elif wound_type in ["normal", "wound"]:
+        st.subheader("🩹 Detected case: Normal wound")
+        st.markdown("\n".join([f"{i+1}. {s}" for i, s in enumerate(NORMAL_WOUND_STEPS)]))
+        st.session_state.wound_type = "normal"
+        st.session_state.basic_done = True
+
+    else:
+        st.warning(f"⚠️ Unknown wound type: {wound_type}")
+else:
+    st.warning("No valid data found in Firebase.")
+
+# -----------------------
+# Refresh Firebase data button
+# -----------------------
+st.markdown("---")
+if st.button("🔄 Refresh Firebase data"):
+    st.toast("Refreshing data from Firebase...", icon="🔁")
+    data = get_latest_wound_data()
+    if data:
+        st.success("✅ Data refreshed successfully!")
+
+        # Cập nhật session state & hướng dẫn theo wound class
+        wound_type = str(data.get("Wound", "")).strip().lower()
+        st.session_state.wound_type = wound_type
+        st.session_state.basic_done = True
+
+        st.subheader("📡 Latest record (refreshed)")
+        st.json(data)
+        st.markdown("---")
+
+        if wound_type == "snakebite":
+            st.subheader("🐍 Detected case: Snakebite")
+            st.markdown("\n".join([f"{i+1}. {s}" for i, s in enumerate(SNAKEBITE_STEPS)]))
+
+        elif wound_type in ["normal", "wound"]:
+            st.subheader("🩹 Detected case: Normal wound")
+            st.markdown("\n".join([f"{i+1}. {s}" for i, s in enumerate(NORMAL_WOUND_STEPS)]))
+
+        else:
+            st.warning(f"⚠️ Unknown wound type: {wound_type}")
+    else:
+        st.warning("No data found in Firebase.")
+
+# -----------------------
+# Data helpers
+# -----------------------
+
+def ensure_datafile():
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    if not DATA_FILE.exists():
+        DATA_FILE.write_text("[]", encoding="utf-8")
+
+
+def save_victim_info(victim: dict):
+    ensure_datafile()
+    try:
+        with DATA_FILE.open("r+", encoding="utf-8") as f:
+            try:
+                data = json.load(f)
+                if not isinstance(data, list):
+                    data = []
+            except Exception:
+                data = []
+            victim_record = {
+                "timestamp": datetime.utcnow().isoformat() + "Z",
+                **victim,
+            }
+            data.append(victim_record)
+            f.seek(0)
+            json.dump(data, f, indent=2)
+            f.truncate()
+        return victim_record
+    except Exception as e:
+        # bubble up a friendly error
+        raise RuntimeError(f"Failed to save victim info: {e}")
+
+
+def write_next_step(wound_type: str):
+    try:
+        DATA_DIR.mkdir(parents=True, exist_ok=True)
+        NEXT_STEP_FILE.write_text(json.dumps({"wound_type": wound_type, "created_at": datetime.utcnow().isoformat() + "Z"}), encoding="utf-8")
+    except Exception:
+        pass
+
+# -----------------------
+# OpenAI integration
+# -----------------------
+DEFAULT_MODEL = os.environ.get("OPENAI_MODEL", "gpt-4o-mini")
+
+# Initialize session state for temporary UI key
+if "ui_api_key" not in st.session_state:
+    st.session_state.ui_api_key = "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"
+
+def get_openai_config_simple():
+    """
+    Returns a small config dict:
+      {
+        "OPENAI_apiKey": <string or None>,
+        "OPENAI_model": <string or None>
+      }
+    Priority: env var -> st.secrets['openai'] -> session UI key
+    """
+    cfg = {
+        "OPENAI_apiKey": os.environ.get("OPENAI_API_KEY"),
+        "OPENAI_model": os.environ.get("OPENAI_MODEL"),
+    }
+
+    # Try reading .streamlit/secrets.toml [openai] table if present
+    try:
+        if hasattr(st, "secrets"):
+            openai_sec = st.secrets.get("openai")
+            if isinstance(openai_sec, dict):
+                cfg["OPENAI_apiKey"] = openai_sec.get("OPENAI_API_KEY") or openai_sec.get("api_key") or cfg["OPENAI_apiKey"]
+                cfg["OPENAI_model"]  = openai_sec.get("OPENAI_MODEL")  or openai_sec.get("model")   or cfg["OPENAI_model"]
+    except Exception:
+        pass
+
+    # fallback to the temporary UI key if nothing else
+    if not cfg["OPENAI_apiKey"]:
+        cfg["OPENAI_apiKey"] = st.session_state.get("ui_api_key")
+
+    return cfg
+
+def get_effective_model():
+    # Prefer env var
+    env_model = os.environ.get("OPENAI_MODEL")
+    if env_model:
+        return env_model
+    
+    # Try Streamlit secrets (handle nested or flat)
+    secret_model = None
+    if hasattr(st, "secrets"):
+        try:
+            # Nested under [openai]
+            secret_model = st.secrets["openai"]["OPENAI_MODEL"]
+        except KeyError:
+            # Flat key
+            secret_model = st.secrets.get("OPENAI_MODEL")
+    
+    # Fallback to default
+    return secret_model or DEFAULT_MODEL
+
+def make_openai_client(api_key):
+    if not api_key:
+        return None, "OpenAI API key not set. Provide OPENAI_API_KEY env var, set in secrets, or paste a temporary key in the UI (not recommended for production)."
+    
+    try:
+        # Prefer modern OpenAI client
+        from openai import OpenAI
+        client = OpenAI(api_key=api_key)
+        return client, None
+    except ImportError:
+        try:
+            # Fallback to legacy openai
+            import openai
+            openai.api_key = api_key
+            # Return the module as 'client' (downstream code must adapt calls)
+            return openai, None
+        except ImportError:
+            return None, "openai package not installed. Add 'openai' to requirements.txt and rebuild/deploy."
+    except Exception as e:
+        return None, f"Failed to create OpenAI client: {str(e)}"
+
+
+def extract_text_from_response(resp):
+    """Robust extraction across SDK shapes. Returns a plain string (possibly empty)."""
+    try:
+        # 1) If response already a string
+        if isinstance(resp, str):
+            return resp.strip()
+
+        # 2) If response has direct 'output_text' (Responses API convenience)
+        if hasattr(resp, "output_text"):
+            try:
+                return str(resp.output_text).strip()
+            except Exception:
+                pass
+        if isinstance(resp, dict) and "output_text" in resp and isinstance(resp["output_text"], str):
+            return resp["output_text"].strip()
+
+        # 3) If response has 'output' list (Responses API): iterate content blocks
+        out = None
+        if hasattr(resp, "output"):
+            out = getattr(resp, "output")
+        elif isinstance(resp, dict) and "output" in resp:
+            out = resp["output"]
+
+        if out:
+            # out is typically a list
+            for item in out:
+                # dict-like
+                if isinstance(item, dict):
+                    # common content shapes: item['content'] -> list with dicts containing 'text'
+                    c = item.get("content") or item.get("text") or item.get("items")
+                    if isinstance(c, str):
+                        return c.strip()
+                    if isinstance(c, list) and c:
+                        # first content block may be dict or string
+                        first = c[0]
+                        if isinstance(first, dict):
+                            # common key names
+                            for k in ("text", "content", "payload", "data"):
+                                if k in first and isinstance(first[k], str):
+                                    return first[k].strip()
+                            # try to stringify the dict
+                            return str(first).strip()
+                        elif isinstance(first, str):
+                            return first.strip()
+                else:
+                    # item may be an object with attributes
+                    # try common attributes
+                    for attr in ("text", "content", "value"):
+                        if hasattr(item, attr):
+                            val = getattr(item, attr)
+                            if isinstance(val, str):
+                                return val.strip()
+                            try:
+                                return str(val).strip()
+                            except Exception:
+                                pass
+
+        # 4) ChatCompletion style: choices -> first -> message -> content
+        if hasattr(resp, "choices") and getattr(resp, "choices", None):
+            first = resp.choices[0]
+            # object-like
+            if hasattr(first, "message") and getattr(first.message, "content", None):
+                return str(first.message.content).strip()
+            if hasattr(first, "text") and getattr(first, "text", None):
+                return str(first.text).strip()
+        if isinstance(resp, dict) and "choices" in resp and isinstance(resp["choices"], list) and resp["choices"]:
+            first = resp["choices"][0]
+            if isinstance(first, dict):
+                msg = first.get("message") or first
+                if isinstance(msg, dict):
+                    c = msg.get("content") or msg.get("text")
+                    if isinstance(c, str):
+                        return c.strip()
+                    # if content is nested structure, stringify
+                    return str(c).strip()
+                # fallback
+                if "text" in first and isinstance(first["text"], str):
+                    return first["text"].strip()
+
+        # 5) If resp looks like a Pydantic model or other object: try to convert to dict then locate text
+        try:
+            # modern pydantic has model_dump()
+            if hasattr(resp, "model_dump"):
+                dd = resp.model_dump()
+                # recursively try to extract
+                return extract_text_from_response(dd)
+            # older pydantic may have dict()
+            if hasattr(resp, "dict"):
+                dd = resp.dict()
+                return extract_text_from_response(dd)
+        except Exception:
+            pass
+
+        # 6) fallback: try common attributes or dict keys, or string conversion
+        for attr in ("text", "content", "message", "output", "response"):
+            if hasattr(resp, attr):
+                try:
+                    return str(getattr(resp, attr)).strip()
+                except Exception:
+                    pass
+        if isinstance(resp, dict):
+            return str(resp).strip()
+
+        return str(resp).strip()
+    except Exception:
+        # absolute fallback
+        try:
+            return str(resp)
+        except Exception:
+            return ""
+
+        
+def normalize_assistant_text(x):
+    """
+    Coerce various SDK response shapes into a plain string safely.
+    - If x is already a str, return it (stripped).
+    - If it has common attributes (text, content), use those.
+    - Otherwise fallback to JSON/string conversion.
+    """
+    try:
+        if x is None:
+            return ""
+        if isinstance(x, str):
+            return x.strip()
+        # common attribute names
+        for attr in ("text", "content", "output_text"):
+            if hasattr(x, attr):
+                val = getattr(x, attr)
+                if isinstance(val, str):
+                    return val.strip()
+                # some attrs can be objects themselves
+                try:
+                    return str(val).strip()
+                except Exception:
+                    pass
+        # dict-like
+        try:
+            if isinstance(x, dict):
+                for k in ("text", "content", "output_text"):
+                    if k in x and isinstance(x[k], str):
+                        return x[k].strip()
+                return json.dumps(x, default=str)[:10000].strip()
+        except Exception:
+            pass
+        # fallback: try string conversion
+        return str(x).strip()
+    except Exception:
+        # last-resort fallback
+        return ""
+
+# --- Robust query function (uses get_openai_config_simple) ---
+def query_openai(system_prompt: str, user_message: str):
+    openai_cfg = get_openai_config_simple()
+    api_key = openai_cfg.get("OPENAI_apiKey")
+    model = openai_cfg.get("OPENAI_model") or DEFAULT_MODEL
+
+    client, err = make_openai_client(api_key)
+    if err:
+        return {"error": err}
+
+    try:
+        # 1) Modern OpenAI client: client.chat.create(...)
+        if hasattr(client, "chat") and hasattr(client.chat, "create"):
+            response = client.chat.create(
+                model=model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_message},
+                ],
+                temperature=0.2,
+                max_tokens=800,
+            )
+            text = extract_text_from_response(response)
+            return {"text": text}
+
+        # 2) Classic openai package ChatCompletion
+        if hasattr(client, "ChatCompletion"):
+            response = client.ChatCompletion.create(
+                model=model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_message},
+                ],
+                temperature=0.2,
+                max_tokens=800,
+            )
+            text = extract_text_from_response(response)
+            return {"text": text}
+
+        # 3) Responses API style: client.responses.create(...)
+        if hasattr(client, "responses") and hasattr(client.responses, "create"):
+            prompt = system_prompt + "\n\n" + user_message
+            response = None
+            # Try a few different kwarg sets because different SDK versions accept different names
+            candidate_kw_sets = [
+                {"model": model, "input": prompt, "max_tokens": 800, "temperature": 0.2},
+                {"model": model, "input": prompt, "max_output_tokens": 800, "temperature": 0.2},
+                {"model": model, "input": prompt, "temperature": 0.2},
+                {"model": model, "input": prompt},
+            ]
+            last_exc = None
+            for kw in candidate_kw_sets:
+                try:
+                    response = client.responses.create(**kw)
+                    break
+                except TypeError as te:
+                    # method doesn't accept some kwarg name(s) — try the next set
+                    last_exc = te
+                    continue
+                except Exception as e:
+                    # other runtime error (quota, auth, etc.) -> propagate as assistant error
+                    return {"error": f"OpenAI responses request failed: {e}"}
+            if response is None:
+                # none of the kwarg sets worked
+                return {"error": f"OpenAI responses client didn't accept tried args. Last error: {last_exc}"}
+            text = extract_text_from_response(response)
+            return {"text": text}
+
+        # 4) Very old shape: Completion.create
+        if hasattr(client, "Completion") and hasattr(client.Completion, "create"):
+            prompt = system_prompt + "\n\n" + user_message
+            response = client.Completion.create(model=model, prompt=prompt, max_tokens=800, temperature=0.2)
+            text = extract_text_from_response(response)
+            return {"text": text}
+
+        return {"error": "OpenAI client present but no compatible chat method found. Consider upgrading the openai package (pip install --upgrade openai)."}
+    except Exception as e:
+        return {"error": f"OpenAI request failed: {e}"}
+
+
+
+def make_system_prompt(wound_type: str, victim_info: dict) -> str:
+    return (
+        f"You are an expert first aid assistant. The victim has wound_type={wound_type}.\n"
+        "- Give clear, actionable, short steps that a non-professional can follow.\n"
+        "- Mention when to call emergency services or go to hospital.\n"
+        f"- Use the victim info below to adjust guidance:\n{json.dumps(victim_info, indent=2)}\n"
+        "Keep language concise. Use numbered short steps when appropriate."
+    )
+
+# -----------------------
+# Config check / helper
+# -----------------------
+DEFAULT_CONFIG_TEXT = """[server]
+headless = true
+port = 8501
+enableCORS = false
+address = "0.0.0.0"
+# disable XSRF to avoid the override warning
+enableXsrfProtection = false
+
+[browser]
+gatherUsageStats = false
+"""
+
+
+def show_and_optionally_reset_config():
+    st.subheader("Streamlit config check")
+    if STREAMLIT_ROOT_CONFIG.exists():
+        st.info(f"Found config at `{STREAMLIT_ROOT_CONFIG}`")
+        try:
+            import toml
+
+            raw = STREAMLIT_ROOT_CONFIG.read_text(encoding="utf-8")
+            toml.loads(raw)  # validate
+            st.success("Config TOML parsed successfully.")
+            st.code(raw, language="toml")
+        except Exception as e:
+            st.error(f"Config parse error: {e}")
+            st.write("Here is a safe replacement you can apply. Click the button to attempt reset.")
+            st.code(DEFAULT_CONFIG_TEXT, language="toml")
+            if st.button("Attempt to reset /root/.streamlit/config.toml (may require root)"):
+                try:
+                    STREAMLIT_ROOT_CONFIG.write_text(DEFAULT_CONFIG_TEXT, encoding="utf-8")
+                    st.success("Wrote default config. You may need to restart Streamlit or the container.")
+                except Exception as write_exc:
+                    st.error(f"Failed to write config: {write_exc}")
+                    st.info("If writing failed due to permissions, run this command on the host:")
+                    cmd = (
+                        "sudo mkdir -p /root/.streamlit && "
+                        "sudo tee /root/.streamlit/config.toml > /dev/null <<'EOF'\n"
+                        + DEFAULT_CONFIG_TEXT
+                        + "EOF\n"
+                    )
+                    st.code(cmd, language="bash")
+    else:
+        st.info(f"No config found at `{STREAMLIT_ROOT_CONFIG}`")
+        if st.button("Create default config at /root/.streamlit/config.toml (may require root)"):
+            try:
+                STREAMLIT_ROOT_CONFIG.parent.mkdir(parents=True, exist_ok=True)
+                STREAMLIT_ROOT_CONFIG.write_text(DEFAULT_CONFIG_TEXT, encoding="utf-8")
+                st.success("Wrote default config. Restart Streamlit if needed.")
+            except Exception as e:
+                st.error(f"Failed to write config: {e}")
+                st.info("If writing failed due to permissions, run this on the host:")
+                cmd = (
+                    "sudo mkdir -p /root/.streamlit && "
+                    "sudo tee /root/.streamlit/config.toml > /dev/null <<'EOF'\n"
+                    + DEFAULT_CONFIG_TEXT
+                    + "EOF\n"
+                )
+                st.code(cmd, language="bash")
+
+# -----------------------
+# Streamlit UI
+# -----------------------
+
+# Function: Save Victim Info to Firebase
+def save_victim_info(victim: dict):
+    """
+    Save a victim record to Firebase Realtime Database using Pyrebase4.
+    Automatically generates a unique record ID.
+    Returns the saved record (dict).
+    """
+    if not db:
+        raise ValueError("Firebase not connected.")
+
+    import time
+
+    # Unique ID for each victim record
+    record_id = f"victim_{int(time.time())}"
+
+    # Ensure wound_type & timestamp fields exist
+    victim_data = victim.copy()
+    victim_data["timestamp"] = time.strftime("%d/%m/%Y %H:%M:%S")
+
+    try:
+        # Save data under "victims/<record_id>"
+        db.child("victims").child(record_id).set(victim_data)
+        return victim_data
+    except Exception as e:
+        raise RuntimeError(f"Failed to save victim info: {e}")
+
+# Advanced section
+if st.session_state.get("basic_done") and st.session_state.get("wound_type"):
+    st.header("Advanced assistance")
+    st.markdown(f"**Wound type:** `{st.session_state.wound_type}`")
+
+    with st.form("victim_form", clear_on_submit=False):
+        st.subheader("Victim information (helps tailor guidance)")
+        name = st.text_input("Victim name (optional)")
+        age = st.text_input("Age (years)", help="Enter an integer or leave blank")
+        weight = st.text_input("Weight (kg)", help="Enter a number or leave blank")
+        height = st.text_input("Height (cm)", help="Enter a number or leave blank")
+        notes = st.text_area("Short notes (allergies, meds, conscious status...)", max_chars=500, height=80)
+
+        col_a, col_b = st.columns([1, 3])
+        with col_a:
+            submit = st.form_submit_button("Save info & get advanced guidance")
+        with col_b:
+            # Use form_submit_button here (not st.button) because we are inside a form
+            emergency_submit = st.form_submit_button("Emergency — Call local services")
+
+        # Both submit buttons return True when they were clicked.
+        if emergency_submit:
+            # Validate numeric fields before saving
+            try:
+                age_v = int(age) if (age and age.strip() != "") else None
+            except Exception:
+                st.error("Age must be an integer (or leave blank).")
+                st.stop()
+            try:
+                weight_v = float(weight) if (weight and weight.strip() != "") else None
+            except Exception:
+                st.error("Weight must be a number (kg) or leave blank.")
+                st.stop()
+            try:
+                height_v = float(height) if (height and height.strip() != "") else None
+            except Exception:
+                st.error("Height must be a number (cm) or leave blank.")
+                st.stop()
+
+            victim = {
+                "name": name or "unknown",
+                "age": age_v,
+                "weight_kg": weight_v,
+                "height_cm": height_v,
+                "notes": notes or "",
+                "wound_type": st.session_state.wound_type,
+                "saved_at": datetime.utcnow().isoformat() + "Z",
+                "emergency": True,
+            }
+
+            try:
+                record = save_victim_info(victim)
+                st.session_state.last_saved_record = record
+                # Emergency: highlight and instruct user to call local services immediately
+                st.error("EMERGENCY recorded. Call local emergency services now.")
+                st.warning("If the victim is unconscious, having trouble breathing, or bleeding heavily, call emergency services immediately.")
+            except Exception as e:
+                st.error(str(e))
+                st.write(traceback.format_exc())
+                st.stop()
+
+        if submit:
+            # Validate numeric fields
+            try:
+                age_v = int(age) if (age and age.strip() != "") else None
+            except Exception:
+                st.error("Age must be an integer (or leave blank).")
+                st.stop()
+            try:
+                weight_v = float(weight) if (weight and weight.strip() != "") else None
+            except Exception:
+                st.error("Weight must be a number (kg) or leave blank.")
+                st.stop()
+            try:
+                height_v = float(height) if (height and height.strip() != "") else None
+            except Exception:
+                st.error("Height must be a number (cm) or leave blank.")
+                st.stop()
+
+            victim = {
+                "name": name or "unknown",
+                "age": age_v,
+                "weight_kg": weight_v,
+                "height_cm": height_v,
+                "notes": notes or "",
+                "wound_type": st.session_state.wound_type,
+                "saved_at": datetime.utcnow().isoformat() + "Z",
+                "emergency": False,
+            }
+
+            try:
+                record = save_victim_info(victim)
+                st.session_state.last_saved_record = record
+                st.success("Victim info saved.")
+            except Exception as e:
+                st.error(str(e))
+                st.write(traceback.format_exc())
+                st.stop()
+
+            # Prepare and call OpenAI for the normal (non-emergency) flow
+            system_prompt = make_system_prompt(st.session_state.wound_type, victim)
+            initial_user_msg = (
+                "The patient has completed the basic steps. Provide the next, in-depth first aid guidance and any monitoring steps. "
+                "Keep guidance concise and list immediate priorities first."
+            )
+            with st.spinner("Contacting assistant..."):
+                resp = query_openai(system_prompt, initial_user_msg)
+            if "error" in resp:
+                st.error(f"Assistant error: {resp['error']}")
+            else:
+                assistant_text = normalize_assistant_text(resp.get("text"))
+                st.session_state.assistant_text = assistant_text
+                st.session_state.chat_history = [
+                    {"role": "assistant", "text": assistant_text}
+                ]
+                st.markdown("**Assistant guidance:**")
+                st.text_area("Assistant", value=assistant_text, height=250, key="assistant_output")
+
+
+    # Chat follow-ups
+    st.subheader("Ask follow-up questions")
+    st.markdown("Ask the assistant further questions related to the victim or care. Keep questions concise.")
+    col_in, col_btn = st.columns([4, 1])
+    with col_in:
+        user_q = st.text_input("Your question", key="chat_input")
+    with col_btn:
+        if st.button("Ask"):
+            if not user_q or user_q.strip() == "":
+                st.warning("Type a question first.")
+            else:
+                victim_info = st.session_state.get("last_saved_record") or {}
+                system_prompt = make_system_prompt(st.session_state.wound_type, victim_info)
+                with st.spinner("Assistant is replying..."):
+                    resp = query_openai(system_prompt, user_q)
+                if "error" in resp:
+                    st.error(f"Assistant error: {resp['error']}")
+                else:
+                    assistant_reply = normalize_assistant_text(resp.get("text"))
+                    history = st.session_state.get("chat_history", [])
+                    history.append({"role": "user", "text": user_q})
+                    history.append({"role": "assistant", "text": assistant_reply})
+                    st.session_state.chat_history = history
+                    st.success("Assistant responded. See conversation below.")
+
+    # Conversation display
+    if st.session_state.get("chat_history"):
+        st.subheader("Conversation log")
+        for turn in st.session_state.chat_history:
+            role = turn.get("role", "assistant")
+            text = turn.get("text", "")
+            if role == "assistant":
+                st.markdown(f"**Assistant:** {text}")
+            else:
+                st.markdown(f"**User:** {text}")
+
+else:
+    st.info("Start by reviewing the quick steps for Snakebite or Normal wound and confirm completion using the checkbox, then click Next → Advanced.")
+
+st.markdown("---")
+st.caption(
+    "🔒 Security: Prefer setting OPENAI_API_KEY as an environment variable or platform secret. "
+    "If you paste a key into the UI it is stored only in session memory and not written to disk."
+)
+
+# END