Update app.py

app.py

@@ -26,10 +26,11 @@ if not OPENAI_API_KEY:
 
 client = OpenAI(api_key=OPENAI_API_KEY)
 
-VISION_MODEL = "gpt-4.1-mini"      # image-capable
-REASONING_MODEL = "gpt-4.1-mini"   # reasoning
-ASR_MODEL = "whisper-1"            # transcription
+VISION_MODEL = "gpt-4.1-mini"
+REASONING_MODEL = "gpt-4.1-mini"
+ASR_MODEL = "whisper-1"
 
+# Health Canada & recalls (for safety snippets)
 DPD_BASE_URL = "https://health-products.canada.ca/api/drug/drugproduct"
 RECALLS_FEED_URL = os.getenv(
     "RECALLS_FEED_URL",
@@ -37,13 +38,14 @@ RECALLS_FEED_URL = os.getenv(
 )
 WAIT_TIMES_INFO_URL = "https://www.cihi.ca/en/topics/access-and-wait-times"
 
+# Google Custom Search keys (MUST be set)
 GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
 GOOGLE_CSE_ID = os.getenv("GOOGLE_CSE_ID")
 
-# if you later add your own wait-time microservice:
+# Optional: your own wait-time microservice (not required)
 WAIT_TIMES_API_BASE = os.getenv("WAIT_TIMES_API_BASE", "").rstrip("/")
 
-USER_AGENT = "carecall-ai-google-only/1.0"
+USER_AGENT = "carecall-ai-google-local/1.2"
 
 POSTAL_PREFIX_TO_PROVINCE = {
     "A": "Newfoundland and Labrador",
@@ -67,7 +69,7 @@ POSTAL_PREFIX_TO_PROVINCE = {
 }
 
 # =========================
-# UTILITIES
+# HELPERS
 # =========================
 
 def safe_get_json(url, params=None, method="GET", data=None, timeout=8):
@@ -105,7 +107,6 @@ def infer_province_from_postal(postal_code: str):
 def extract_phone(text: str) -> str:
     if not text:
         return ""
-    # basic North American phone pattern
     m = re.search(r"(\(?\d{3}\)?[\s\-\.]?\d{3}[\s\-\.]?\d{4})", text)
     return m.group(1) if m else ""
 
@@ -113,7 +114,6 @@ def extract_phone(text: str) -> str:
 def extract_hours(text: str) -> str:
     if not text:
         return ""
-    # very rough; just grab a window like "8 AM-2 PM" / "9am–5pm"
     m = re.search(
         r"(\d{1,2}\s?(?:AM|PM|am|pm)\s?[–\-]\s?\d{1,2}\s?(?:AM|PM|am|pm))",
         text
@@ -122,7 +122,7 @@ def extract_hours(text: str) -> str:
 
 
 # =========================
-# POSTAL -> CITY (canadacities.csv)
+# POSTAL -> CITY via canadacities.csv
 # =========================
 
 def load_postal_city_map(path: str = "canadacities.csv"):
@@ -136,14 +136,13 @@ def load_postal_city_map(path: str = "canadacities.csv"):
             header = next(reader, None)
             if not header:
                 return mapping
-
             lower = [h.strip().lower() for h in header]
 
-            def find_col(candidates):
-                for idx, name in enumerate(lower):
-                    for cand in candidates:
-                        if cand in name:
-                            return idx
+            def find_col(cands):
+                for i, name in enumerate(lower):
+                    for c in cands:
+                        if c in name:
+                            return i
                 return None
 
             pc_idx = find_col(["postal", "pcode", "fsa"])
@@ -156,22 +155,22 @@ def load_postal_city_map(path: str = "canadacities.csv"):
             for row in reader:
                 if not row or len(row) <= pc_idx:
                     continue
-                raw_pc = row[pc_idx].strip().upper().replace(" ", "")
-                if not raw_pc:
+                raw = row[pc_idx].strip().upper().replace(" ", "")
+                if not raw:
                     continue
-                prefix = raw_pc[:3]
+                fsa = raw[:3]
                 city = (
                     row[city_idx].strip()
-                    if (city_idx is not None and len(row) > city_idx)
+                    if city_idx is not None and len(row) > city_idx
                     else ""
                 )
                 prov = (
                     row[prov_idx].strip()
-                    if (prov_idx is not None and len(row) > prov_idx)
+                    if prov_idx is not None and len(row) > prov_idx
                     else ""
                 )
-                if prefix and (city or prov):
-                    mapping.setdefault(prefix, (city, prov))
+                if fsa and (city or prov):
+                    mapping.setdefault(fsa, (city, prov))
     except Exception:
         return mapping
 
@@ -207,28 +206,38 @@ def google_cse_search(query: str, num: int = 5):
     return safe_get_json(url, params=params)
 
 
-def facilities_from_cse(items, city_filter=None):
-    """
-    Parse CSE items into structured facilities.
-    Only keep results clearly related to the target city/FSA if city_filter is provided.
-    """
-    facilities = []
-    city_lower = (city_filter or "").lower() if city_filter else None
+def facility_local_score(blob: str, city: str, prov: str, fsa: str, postal: str) -> int:
+    """Heuristic scoring: prioritize truly local results, drop far-away hospitals."""
+    b = blob.lower()
+    score = 0
+    if postal and postal.replace(" ", "").lower() in b.replace(" ", ""):
+        score += 4
+    if fsa and fsa.lower() in b:
+        score += 3
+    if city and city.lower() in b:
+        score += 3
+    if prov and prov.lower() in b:
+        score += 1
+    return score
+
 
-    for it in items:
+def facilities_from_cse(items, city, prov, fsa, postal, min_score=3, max_results=8):
+    facilities = []
+    for it in items or []:
         title = (it.get("title") or "").strip()
         link = (it.get("link") or "").strip()
         snippet = (it.get("snippet") or it.get("htmlSnippet") or "").strip()
-
         if not title:
             continue
 
-        blob = (title + " " + snippet).lower()
-        if city_lower and city_lower not in blob:
-            # Require mention of city name if we know it, to avoid far-away hospitals
+        blob = f"{title} {snippet}"
+        score = facility_local_score(blob, city, prov, fsa, postal)
+
+        # Keep only results that look genuinely local
+        if score < min_score:
             continue
 
-        phone = extract_phone(title + " " + snippet)
+        phone = extract_phone(blob)
         hours = extract_hours(snippet)
         info = shorten(snippet, 200)
 
@@ -237,122 +246,123 @@ def facilities_from_cse(items, city_filter=None):
             "info": info,
             "phone": phone,
             "hours": hours,
-            "url": link
+            "url": link,
+            "score": score,
         })
 
-    return facilities
+    facilities = sorted(facilities, key=lambda x: x["score"], reverse=True)
+    return facilities[:max_results]
 
 
 def tool_list_facilities_google(postal_code: str) -> str:
     """
-    Use ONLY Google Custom Search to list nearby:
-    - Emergency departments / hospitals
-    - Walk-in / urgent care / family practice
-    Based on city inferred from canadacities.csv (if available).
-    Returns markdown listing with name, info/address snippet, phone, hours, url.
+    Pure Google-based facility listing:
+
+    - Detect city/province from canadacities.csv.
+    - Query Google CSE using postal + city + province.
+    - Build two groups:
+        1) Nearby Emergency / Hospital
+        2) Nearby Walk-in / Urgent Care / Family Practice
+    - Only include facilities that pass a locality score threshold to avoid far-away sites.
     """
     if not postal_code:
         return "No postal code provided; cannot list local facilities."
-
     if not GOOGLE_API_KEY or not GOOGLE_CSE_ID:
         return (
             "Google Custom Search is not configured (set GOOGLE_API_KEY and GOOGLE_CSE_ID) "
             "so facility listing is unavailable."
         )
 
-    city, prov = get_city_from_postal(postal_code)
-    pc_clean = postal_code.strip().upper().replace(" ", "")
-    if city:
-        loc = f"{city}, {prov or 'Canada'}"
-        city_filter = city  # require this name in results
-    else:
-        loc = f"{pc_clean} Canada"
-        city_filter = None
-
-    # --- Emergency / hospital search ---
-    er_query = f"emergency department hospital near {loc}"
-    er_data = google_cse_search(er_query, num=8)
-    er_facilities = facilities_from_cse(er_data.get("items", []), city_filter) if er_data else []
-
-    # --- Walk-in / clinic search ---
-    clinic_query = f"walk-in clinic OR urgent care OR family practice near {loc}"
-    clinic_data = google_cse_search(clinic_query, num=8)
-    clinic_facilities = facilities_from_cse(clinic_data.get("items", []), city_filter) if clinic_data else []
+    pc_clean = postal_code.strip().upper()
+    pc_nospace = pc_clean.replace(" ", "")
+    fsa = pc_nospace[:3] if len(pc_nospace) >= 3 else ""
+    city, prov = get_city_from_postal(pc_clean)
+
+    loc_label = f"{city}, {prov}" if city else f"{pc_clean}, Canada"
+
+    # Emergency/hospital search
+    er_query = (
+        f"emergency department OR hospital near {pc_clean} {city or ''} {prov or ''} Canada"
+    )
+    er_data = google_cse_search(er_query, num=10)
+    er_fac = facilities_from_cse(
+        er_data.get("items") if er_data else [],
+        city, prov, fsa, pc_nospace,
+        min_score=3,
+        max_results=6,
+    )
+
+    # Walk-in / clinic search
+    clinic_query = (
+        f"walk-in clinic OR urgent care OR family practice near {pc_clean} {city or ''} {prov or ''} Canada"
+    )
+    clinic_data = google_cse_search(clinic_query, num=10)
+    clinic_fac = facilities_from_cse(
+        clinic_data.get("items") if clinic_data else [],
+        city, prov, fsa, pc_nospace,
+        min_score=3,
+        max_results=10,
+    )
 
     lines = []
 
-    if er_facilities:
-        lines.append(f"Nearby Emergency Departments / Hospitals (via Google CSE around {loc}):")
-        for f in er_facilities[:5]:
-            entry = f"- {f['name']}"
+    if er_fac:
+        lines.append(f"Nearby Emergency Departments / Hospitals (Google CSE around {loc_label}):")
+        for f in er_fac:
+            s = f"- {f['name']}"
             if f["info"]:
-                entry += f" | Info: {f['info']}"
+                s += f" | Info: {f['info']}"
             if f["phone"]:
-                entry += f" | Phone: {f['phone']}"
+                s += f" | Phone: {f['phone']}"
             if f["hours"]:
-                entry += f" | Hours (from listing): {f['hours']}"
+                s += f" | Hours (from listing): {f['hours']}"
             if f["url"]:
-                entry += f" | {f['url']}"
-            lines.append(entry)
-        lines.append("")  # spacer
-
-    if clinic_facilities:
-        lines.append(f"Nearby Walk-in / Urgent Care / Clinic options (via Google CSE around {loc}):")
-        for f in clinic_facilities[:8]:
-            entry = f"- {f['name']}"
+                s += f" | {f['url']}"
+            lines.append(s)
+        lines.append("")
+
+    if clinic_fac:
+        lines.append(f"Nearby Walk-in / Urgent Care / Clinic options (Google CSE around {loc_label}):")
+        for f in clinic_fac:
+            s = f"- {f['name']}"
             if f["info"]:
-                entry += f" | Info: {f['info']}"
+                s += f" | Info: {f['info']}"
             if f["phone"]:
-                entry += f" | Phone: {f['phone']}"
+                s += f" | Phone: {f['phone']}"
             if f["hours"]:
-                entry += f" | Hours (from listing): {f['hours']}"
+                s += f" | Hours (from listing): {f['hours']}"
             if f["url"]:
-                entry += f" | {f['url']}"
-            lines.append(entry)
+                s += f" | {f['url']}"
+            lines.append(s)
 
     if not lines:
         return (
-            f"No strong facility results could be parsed for {loc}. "
-            "Please use official provincial 'find a clinic/ER' tools or maps."
+            f"No strong local facilities parsed for {loc_label}. "
+            "Ask users to use official provincial 'find a clinic/ER' tools or maps with their postal code."
         )
 
     lines.append(
-        "Note: Details (distance, exact hours, availability) can change. "
-        "Users should always confirm on the facility or provincial website."
+        "Note: This list is based on Google Custom Search results filtered by your postal code/city. "
+        "Users must confirm details (distance, hours, availability) on the facility or provincial website."
     )
     return "\n".join(lines)
 
 
 def tool_search_wait_times_google(postal_code: str) -> str:
-    """
-    Supplemental: links about wait-time / access info near user.
-    """
-    if not postal_code:
-        return "No postal code; wait-time links not generated."
-    if not GOOGLE_API_KEY or not GOOGLE_CSE_ID:
-        return (
-            "Google CSE not configured; wait-time links unavailable. "
-            "Use provincial / hospital websites directly."
-        )
-
-    city, prov = get_city_from_postal(postal_code)
+    if not postal_code or not GOOGLE_API_KEY or not GOOGLE_CSE_ID:
+        return ""
     pc_clean = postal_code.strip().upper().replace(" ", "")
-    if city:
-        loc = f"{city}, {prov or 'Canada'}"
-    else:
-        loc = f"{pc_clean} Canada"
+    city, prov = get_city_from_postal(pc_clean)
+    loc = f"{city}, {prov}" if city else f"{pc_clean}, Canada"
 
     data = google_cse_search(
         query=f"emergency department wait times {loc}",
         num=5
     )
     if not data or "items" not in data:
-        return (
-            f"No specific wait-time dashboards found for {loc}. "
-            "Check provincial or hospital websites directly."
-        )
+        return ""
 
-    lines = [f"Wait-time / access info links for {loc} (verify sources):"]
+    lines = [f"Wait-time / access info links near {loc}:"]
     for it in data["items"][:5]:
         title = it.get("title", "Result")
         link = it.get("link", "")
@@ -366,7 +376,7 @@ def tool_hqontario_context(postal_code: str) -> str:
     if province != "Ontario":
         return ""
     return (
-        "For Ontario ED locations and typical wait times near your postal code, use Ontario Health's official tool: "
+        "For Ontario ED locations and typical wait times near your postal code, use Ontario Health's tool: "
         "https://www.hqontario.ca/System-Performance/Time-Spent-in-Emergency-Departments "
         "(select 'Area by Postal Code')."
     )
@@ -375,27 +385,30 @@ def tool_hqontario_context(postal_code: str) -> str:
 def tool_region_context(postal_code: str) -> str:
     province = infer_province_from_postal(postal_code)
     if not postal_code:
-        return "No postal code provided. Use Canada-wide guidance and mention provincial resources."
+        return "No postal code: provide Canada-wide guidance and suggest local provincial resources."
     if not province:
         return (
-            f"Postal code '{postal_code}' could not be mapped reliably. "
-            "Use Canada-wide guidance and suggest checking your provincial health ministry and Telehealth services."
+            f"Postal code '{postal_code}' not mapped cleanly. "
+            "Suggest user check their provincial health ministry and Telehealth services."
         )
-    telehealth_note = (
-        f"In {province}, users can contact the provincial Telehealth/811-style nurse line for real-time advice."
+    tele = (
+        f"In {province}, users can contact the provincial Telehealth/811 nurse line for real-time assessment."
     )
-    wait_note = (
-        "Average wait-time indicators (not real-time) may be available from CIHI and provincial dashboards: "
-        f"{WAIT_TIMES_INFO_URL}"
+    wait = (
+        "CIHI and some provinces publish average wait-time data (not real-time): "
+        f"{WAIT_TIMES_INFO_URL}."
     )
-    return f"User postal code '{postal_code}' mapped to {province}.\n{telehealth_note}\n{wait_note}"
+    return f"Postal code '{postal_code}' mapped to {province}.\n{tele}\n{wait}"
+
 
+# =========================
+# DPD & RECALLS (unchanged, safe)
+# =========================
 
 def tool_lookup_drug_products(text: str) -> str:
     if not text:
         return "No text provided for medication lookup."
 
-    # naive: capitalized tokens as candidate brand names
     tokens = []
     for tok in text.split():
         clean = "".join(ch for ch in tok if ch.isalnum())
@@ -403,7 +416,7 @@ def tool_lookup_drug_products(text: str) -> str:
             tokens.append(clean)
     candidates = sorted(set(tokens))[:10]
     if not candidates:
-        return "No likely medication names detected for Drug Product Database lookup."
+        return "No likely medication names detected for DPD lookup."
 
     found = []
     for name in candidates[:5]:
@@ -411,11 +424,8 @@ def tool_lookup_drug_products(text: str) -> str:
         data = safe_get_json(DPD_BASE_URL, params=params)
         if not data:
             continue
-        uniq = set()
-        for item in data[:3]:
-            b = item.get("brand_name") or item.get("brandname") or name
-            if b:
-                uniq.add(b)
+        uniq = { (it.get("brand_name") or it.get("brandname") or name) for it in data[:3] }
+        uniq = {u for u in uniq if u}
         if uniq:
             found.append(
                 f"- Health Canada DPD has entries related to '{name}' "
@@ -444,7 +454,7 @@ def tool_get_recent_recalls_snippet() -> str:
 
     if not items:
         return (
-            "Unable to load recalls. See the official Government of Canada Recalls and Safety Alerts website."
+            "Unable to load recalls. See the Government of Canada Recalls and Safety Alerts website."
         )
 
     lines = ["Recent recalls & safety alerts (snapshot):"]
@@ -459,22 +469,22 @@ def tool_get_recent_recalls_snippet() -> str:
         category = item.get("category") or item.get("type") or ""
         lines.append(f"- {shorten(title)} ({category}, {date})")
     lines.append(
-        "For full details, visit the official Recalls and Safety Alerts portal."
+        "For details, see the official Recalls and Safety Alerts portal."
     )
     return "\n".join(lines)
 
 
 def tool_get_wait_times_awareness() -> str:
     return textwrap.dedent(f"""
-    Use wait-time information conceptually:
-    - CIHI and some provinces publish average wait-time dashboards (not real-time guarantees).
-    - For severe symptoms or concerning changes, recommend ER/911 regardless of posted averages.
+    Use wait-time information conceptually only:
+    - CIHI/provincial dashboards give average waits (not real-time guarantees).
+    - Severe or red-flag symptoms should go to ER/911 regardless.
     Reference: {WAIT_TIMES_INFO_URL}
     """).strip()
 
 
 # =========================
-# OPENAI HELPERS
+# OPENAI CALLS
 # =========================
 
 def call_vision_summarizer(image_bytes: bytes) -> str:
@@ -483,9 +493,8 @@ def call_vision_summarizer(image_bytes: bytes) -> str:
     b64 = base64.b64encode(image_bytes).decode("utf-8")
     prompt = (
         "You are a cautious Canadian health-information assistant.\n"
-        "Describe ONLY what is visible in neutral terms (e.g., colour, swelling, broken skin).\n"
-        "Do NOT diagnose or prescribe.\n"
-        "Keep to about 80-100 words."
+        "Describe only visible features (colour, swelling, wounds, etc.) in neutral terms.\n"
+        "Do NOT diagnose or prescribe. Keep to 80-100 words."
     )
     try:
         resp = client.chat.completions.create(
@@ -539,71 +548,65 @@ def call_reasoning_agent(
     system_prompt = """
 You are CareCall AI, an agentic Canadian health information assistant.
 
-Inputs provided:
-- User narrative and image summary.
-- Postal code and inferred region.
-- Facilities_context: hospitals / ERs / clinics from Google CSE (already filtered by city/postal).
-- Wait_links_context: links to wait-time or access info.
-- HQOntario_context when applicable.
-- Drug Product Database context.
-- Recalls context.
-- General wait-time awareness context.
+Use ONLY the provided context:
+- narrative, vision_summary, postal_code
+- dpd_context, recalls_context
+- wait_awareness_context
+- region_context
+- facilities_context (local hospitals/ERs/clinics from Google CSE)
+- wait_links_context
+- hqontario_context
 
 Hard rules:
-- DO NOT give a diagnosis.
-- DO NOT prescribe or specify dosing.
-- DO NOT invent real-time wait times.
-- DO NOT invent facility names: you may ONLY list specific hospitals/clinics that appear inside facilities_context,
+- Do NOT give a diagnosis.
+- Do NOT prescribe or state exact medication doses.
+- Do NOT invent real-time wait times.
+- Do NOT invent facilities: you may ONLY name facilities that appear in facilities_context,
   hqontario_context, or wait_links_context.
-- Keep response under ~350 words.
-- Be clear, neutral, and practical.
+- Max ~350 words.
+- Use clear, neutral, practical language.
 
-Decide EXACTLY ONE primary pathway:
+Choose EXACTLY ONE primary pathway:
 A) "Home care likely reasonable (monitor closely)"
 B) "Pharmacist / Walk-in clinic / Family doctor recommended"
 C) "Call provincial Telehealth / nurse line for guidance"
 D) "Go to Emergency / Call 911 now"
 
-Formatting rules:
+Formatting:
 
-1. Start with:
-
-**Primary Recommended Pathway**
-- <one of A/B/C/D> (one short reason)
+1. **Primary Recommended Pathway**
+   - One bullet with A/B/C/D and a one-sentence reason.
 
 2. Conditional sections:
 
-- If A (Home care):
-    Then include, in order:
-      **Home Care**
-      **When to see a Pharmacist / Clinic / Telehealth**
-      **When this is an Emergency (ER/911)**
-      **Local & Official Resources**
-      **Important Disclaimer**
+- If A:
+    **Home Care**
+    **When to see a Pharmacist / Clinic / Telehealth**
+    **When this is an Emergency (ER/911)**
+    **Local & Official Resources**
+    **Important Disclaimer**
 
 - If B or C:
-    Then include:
-      **When to see a Pharmacist / Clinic / Telehealth** (this is the primary plan)
-      **When this is an Emergency (ER/911)**
-      **Local & Official Resources**
-      **Important Disclaimer**
-    Do NOT include a standalone **Home Care** block.
+    **When to see a Pharmacist / Clinic / Telehealth**
+    **When this is an Emergency (ER/911)**
+    **Local & Official Resources**
+    **Important Disclaimer**
+    (No separate Home Care block.)
 
 - If D:
-    Then include ONLY:
-      **When this is an Emergency (ER/911)**
-      **Local & Official Resources**
-      **Important Disclaimer**
-    No Home Care / Walk-in sections.
-
-3. Local & Official Resources:
-- Summarize facilities_context: list some nearby ERs/hospitals and walk-in/urgent care (names, phones, hours/info) as given.
-- Include HQOntario_context when present.
-- Optionally mention key wait_links_context resources.
-- Mention Health Canada / PHAC / Recalls / Drug Product Database generically.
-- If facilities_context is weak, say so and advise using official find-a-clinic/ER tools or maps.
-
-Use only broad, non-diagnostic language (e.g., "possible infection risk", "soft tissue or nail injury").
+    **When this is an Emergency (ER/911)**
+    **Local & Official Resources**
+    **Important Disclaimer**
+    (No Home Care / Walk-in sections.)
+
+In **Local & Official Resources**:
+- Summarize facilities_context (names, phones, hours/info) as nearby options.
+- Include HQOntario_context if present.
+- Optionally summarize wait_links_context.
+- Mention Health Canada / Recalls / DPD generically.
+- If facilities_context is weak, say so and direct user to official find-a-clinic/ER tools or maps.
+
+Use only broad, non-diagnostic descriptions (e.g., "possible infection risk", "soft tissue irritation").
 """
 
     user_prompt = f"""
@@ -662,33 +665,30 @@ Follow the system instructions exactly.
 # =========================
 
 st.title("CareCall AI (Canada)")
-st.caption("Vision + Voice + Postal → Google-based local facilities • One clear pathway (not medical diagnosis)")
+st.caption("Vision + Voice + Postal → Google-local clinics & ERs • ONE clear pathway (informational only)")
 
 st.markdown(
     """
 This tool:
 - Takes an image, voice note, and/or typed description.
-- Uses your **Canadian postal code** to:
-  - infer your city & province (via an internal table),
-  - look up nearby ERs/hospitals and walk-in clinics using **Google Custom Search** only,
-  - (optionally) link to official wait-time dashboards (no fake live waits).
-- Combines this with Canadian public data references and returns **one** clear pathway:
-  home care, clinic/Telehealth, or ER — plus relevant safety guidance.
-
-All outputs are **informational only** and **not a diagnosis**.
+- Uses your **Canadian postal code** and internal city table to:
+  - query Google Custom Search for nearby emergency departments and walk-in/urgent-care clinics,
+  - filter results so only truly local facilities (matching your postal/FSA/city) are listed.
+- Then combines symptom context + public data to suggest **one** primary pathway:
+  home care, clinic/Telehealth, or emergency, with clear safety caveats.
+
+All output is informational and does **not** replace a clinician.
 """
 )
 
-# Postal code
 postal_code = st.text_input(
-    "Canadian postal code (e.g., M5V 2T6).",
+    "Canadian postal code (e.g., L1T 2R2).",
     max_chars=7,
 )
 
-# Image
 st.markdown("### Image (optional)")
 image_file = st.file_uploader(
-    "Upload a photo (JPG/PNG). Avoid highly identifying content.",
+    "Upload a photo (JPG/PNG).",
     type=["jpg", "jpeg", "png"],
     accept_multiple_files=False,
 )
@@ -704,7 +704,6 @@ if image_file is not None:
         st.warning(f"Could not read that image: {e}")
         image_bytes = None
 
-# Audio
 st.markdown("### Voice note (optional)")
 audio_file = st.file_uploader(
     "Upload a short voice note (wav/mp3/m4a).",
@@ -712,17 +711,15 @@ audio_file = st.file_uploader(
     accept_multiple_files=False,
 )
 
-# Text
 st.markdown("### Description")
 user_text = st.text_area(
     "Describe what is happening:",
-    placeholder='Example: "Big toenail is sore for 3 days, a bit red, no fever, I can walk okay but it hurts in shoes."',
     height=120,
+    placeholder='Example: "Big toenail is sore for 3 days, mild redness, no fever, pain 3/10 when walking."'
 )
 
-# Run
 if st.button("Run CareCall Agent"):
-    with st.spinner("Analyzing and building your CareCall summary..."):
+    with st.spinner("Analyzing your inputs and fetching local facilities..."):
 
         vision_summary = call_vision_summarizer(image_bytes) if image_bytes else ""
         voice_text = call_asr(audio_file) if audio_file is not None else ""
@@ -740,14 +737,14 @@ if st.button("Run CareCall Agent"):
         wait_awareness_context = tool_get_wait_times_awareness()
 
         if postal_code.strip():
-            region_context = tool_region_context(postal_code)
             facilities_context = tool_list_facilities_google(postal_code)
+            region_context = tool_region_context(postal_code)
             wait_links_context = tool_search_wait_times_google(postal_code)
             hqontario_context = tool_hqontario_context(postal_code)
         else:
-            region_context = "No postal code provided. Use Canada-wide guidance."
             facilities_context = "No postal code; cannot list local facilities."
-            wait_links_context = "No postal code; no local wait-time links."
+            region_context = "No postal code; use Canada-wide guidance."
+            wait_links_context = ""
             hqontario_context = ""
 
         final_answer = call_reasoning_agent(