Update app.py

app.py

@@ -1,5 +1,6 @@
 import os
 import io
+import math
 import base64
 import textwrap
 import requests
@@ -7,8 +8,13 @@ import streamlit as st
 from PIL import Image
 from openai import OpenAI
 
+from langchain_openai import ChatOpenAI
+from langchain_core.tools import tool
+from langchain_core.prompts import ChatPromptTemplate
+from langchain.agents import create_tool_calling_agent, AgentExecutor
+
 # =========================
-# CONFIG
+# STREAMLIT + OPENAI CONFIG
 # =========================
 
 st.set_page_config(
@@ -18,25 +24,31 @@ st.set_page_config(
 )
 
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+if not OPENAI_API_KEY:
+    st.warning("Set OPENAI_API_KEY in your Space secrets to enable AI features.")
 client = OpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
 
-VISION_MODEL = "gpt-4.1-mini"     # vision-capable model
-REASONING_MODEL = "gpt-4.1-mini"  # reasoning / agent model
-ASR_MODEL = "whisper-1"           # transcription model
+# OpenAI models
+VISION_MODEL = "gpt-4.1-mini"     # vision-capable
+REASONING_MODEL = "gpt-4.1-mini"  # main agent model
+ASR_MODEL = "whisper-1"           # audio transcription
 
-# Health Canada Drug Product Database API
+# Health Canada Drug Product Database
 DPD_BASE_URL = "https://health-products.canada.ca/api/drug/drugproduct"
 
-# Recalls & Safety Alerts JSON feed (can override with env variable if path changes)
+# Recalls & Safety Alerts (public JSON feed; can override with env)
 RECALLS_FEED_URL = os.getenv(
     "RECALLS_FEED_URL",
     "https://recalls-rappels.canada.ca/static-data/items-en.json"
 )
 
-# CIHI wait-times info (general reference)
+# CIHI wait-times info (context link, not live triage)
 WAIT_TIMES_INFO_URL = "https://www.cihi.ca/en/topics/access-and-wait-times"
 
-# Postal code to province mapping (by first letter)
+# Optional: your own normalized wait-time API
+WAIT_TIMES_API_BASE = os.getenv("WAIT_TIMES_API_BASE", "").rstrip("/")
+
+# Postal prefix -> province map
 POSTAL_PREFIX_TO_PROVINCE = {
     "A": "Newfoundland and Labrador",
     "B": "Nova Scotia",
@@ -58,14 +70,20 @@ POSTAL_PREFIX_TO_PROVINCE = {
     "Y": "Yukon",
 }
 
+USER_AGENT = "carecall-ai-langchain-demo/1.0"
+
 
 # =========================
 # GENERIC HELPERS
 # =========================
 
-def safe_get_json(url, params=None, timeout=6):
+def safe_get_json(url, params=None, method="GET", data=None, timeout=8):
     try:
-        resp = requests.get(url, params=params, timeout=timeout)
+        headers = {"User-Agent": USER_AGENT}
+        if method == "GET":
+            resp = requests.get(url, params=params, headers=headers, timeout=timeout)
+        else:
+            resp = requests.post(url, data=data, headers=headers, timeout=timeout)
         if resp.ok:
             return resp.json()
     except Exception:
@@ -73,7 +91,7 @@ def safe_get_json(url, params=None, timeout=6):
     return None
 
 
-def shorten(text, max_chars=280):
+def shorten(text, max_chars=260):
     if not text:
         return ""
     text = text.strip()
@@ -82,9 +100,16 @@ def shorten(text, max_chars=280):
     return text[: max_chars - 3].rstrip() + "..."
 
 
-# =========================
-# REGION / POSTAL HELPERS
-# =========================
+def haversine_km(lat1, lon1, lat2, lon2):
+    R = 6371.0
+    from math import radians, sin, cos, atan2, sqrt
+    phi1, phi2 = radians(lat1), radians(lat2)
+    dphi = radians(lat2 - lat1)
+    dlambda = radians(lon2 - lon1)
+    a = sin(dphi / 2) ** 2 + cos(phi1) * cos(phi2) * sin(dlambda / 2) ** 2
+    c = 2 * atan2(sqrt(a), sqrt(1 - a))
+    return R * c
+
 
 def infer_province_from_postal(postal_code: str):
     if not postal_code:
@@ -95,108 +120,183 @@ def infer_province_from_postal(postal_code: str):
     return POSTAL_PREFIX_TO_PROVINCE.get(pc[0])
 
 
-def tool_region_context(postal_code: str) -> str:
+def geocode_postal(postal_code: str):
+    if not postal_code:
+        return None
+    q = f"{postal_code}, Canada"
+    url = "https://nominatim.openstreetmap.org/search"
+    try:
+        resp = requests.get(
+            url,
+            params={"q": q, "format": "json", "limit": 1},
+            headers={"User-Agent": USER_AGENT},
+            timeout=8,
+        )
+        if resp.ok:
+            data = resp.json()
+            if data:
+                lat = float(data[0]["lat"])
+                lon = float(data[0]["lon"])
+                return lat, lon
+    except Exception:
+        return None
+    return None
+
+
+# =========================
+# LANGCHAIN TOOLS
+# =========================
+
+@tool
+def get_region_context(postal_code: str) -> str:
+    """
+    Given a Canadian postal code, return high-level provincial context:
+    - inferred province (if possible)
+    - Telehealth / nurse-line style advice
+    - pointer to wait-time info sources (CIHI/provincial).
+    """
     province = infer_province_from_postal(postal_code)
     if not postal_code:
-        return "No postal code provided. Use general Canada-wide guidance."
+        return "No postal code provided. Use general Canada-wide guidance and mention provincial resources."
 
     if not province:
         return (
             f"Postal code '{postal_code}' could not be mapped reliably. "
-            "Provide Canada-wide guidance and advise checking local provincial health websites and Telehealth services."
+            "Use Canada-wide guidance and suggest checking local provincial health ministry and Telehealth services."
         )
 
     telehealth_note = (
-        f"In {province}, advise the user to use the official provincial Telehealth or 811-style nurse advice line "
-        "for real-time clinical advice."
+        f"In {province}, advise the user to use the official provincial Telehealth or 811-style nurse line "
+        "for real-time nurse assessment."
     )
     wait_note = (
-        "For non-urgent issues, they can check provincial or regional health authority websites and CIHI indicators "
-        f"for access/wait-time information. Reference (general): {WAIT_TIMES_INFO_URL}"
+        "For non-urgent issues, they may check provincial/health authority resources and CIHI indicators "
+        f"for access and wait-time context (not real-time). Ref: {WAIT_TIMES_INFO_URL}"
     )
 
     return (
-        f"User postal code: '{postal_code}' mapped to {province}.\n"
+        f"User postal code '{postal_code}' mapped to {province}.\n"
         f"{telehealth_note}\n"
         f"{wait_note}"
     )
 
 
-def tool_find_nearby_clinics_and_waits(postal_code: str) -> str:
+@tool
+def get_nearby_facilities(postal_code: str) -> str:
     """
-    Province-aware pointers to official 'find a clinic' / wait-time resources.
-    Not real-time; we send the user to authoritative tools.
+    Use open map data (OSM/Overpass) to list a few nearby clinics/hospitals/doctors.
+    If WAIT_TIMES_API_BASE is set, also attach estimated wait times when available.
     """
-    province = infer_province_from_postal(postal_code)
-    if not postal_code or not province:
+    coords = geocode_postal(postal_code)
+    if not coords:
         return (
-            "No precise local clinic data. Suggest the user search 'walk-in clinic near me' plus their city, and use "
-            "their provincial health website or health authority finder for verified locations and hours."
+            "Could not geocode postal code. Suggest the user search for walk-in clinics, urgent care, or hospitals "
+            "near them using maps and official provincial tools."
         )
 
-    base = f"For users in {province}, suggest these options to find nearby care and typical waits:\n"
-    province_links = []
-
-    # Very high-level, non-exhaustive hints (you can refine for your production app)
-    if province == "Ontario":
-        province_links.append(
-            "- Use Ontario's official 'Health811' and 'Find a clinic/hospital' tools from Ontario Health."
-        )
-    elif province == "British Columbia":
-        province_links.append(
-            "- Use HealthLink BC (811) and the 'Find Health Services' directory for clinics and urgent care."
-        )
-    elif province == "Alberta":
-        province_links.append(
-            "- Use Alberta Health Services 'Find Healthcare' directory for walk-ins and urgent care clinics."
-        )
-    elif province == "Quebec":
-        province_links.append(
-            "- Use your local CISSS/CIUSSS websites and provincial resources (e.g., Bonjour-santé) for clinic bookings."
-        )
-    elif province == "Manitoba":
-        province_links.append(
-            "- Use Manitoba Health / regional health authority sites to locate walk-in and primary care clinics."
-        )
-    elif province == "Saskatchewan":
-        province_links.append(
-            "- Use Saskatchewan Health Authority tools to find urgent care and clinics."
-        )
-    elif province == "Nova Scotia":
-        province_links.append(
-            "- Use Nova Scotia Health 'Find a Location/Service' for primary care and walk-in options."
-        )
-    elif province == "New Brunswick":
-        province_links.append(
-            "- Use Horizon / Vitalité Health Network resources for clinics and after-hours care."
-        )
-    elif province == "Newfoundland and Labrador":
-        province_links.append(
-            "- Use provincial health authority websites to locate clinics and ERs."
-        )
-    elif province == "Prince Edward Island":
-        province_links.append(
-            "- Use Health PEI resources to find walk-in clinics and primary care."
+    lat, lon = coords
+
+    overpass_url = "https://overpass-api.de/api/interpreter"
+    query = f"""
+    [out:json][timeout:10];
+    (
+      node["amenity"="clinic"](around:7000,{lat},{lon});
+      node["amenity"="hospital"](around:7000,{lat},{lon});
+      node["amenity"="doctors"](around:7000,{lat},{lon});
+      node["amenity"="urgent_care"](around:7000,{lat},{lon});
+    );
+    out center 12;
+    """
+    data = safe_get_json(overpass_url, method="POST", data=query)
+    if not data or "elements" not in data:
+        return (
+            "Nearby facility lookup unavailable from open map data. "
+            "Suggest using map search (e.g., 'walk-in clinic near me') and provincial find-a-clinic tools."
         )
-    else:
-        province_links.append(
-            "- Use your territorial/provincial health authority website and Telehealth for locations and typical waits."
+
+    facilities = []
+    for el in data["elements"]:
+        tags = el.get("tags", {})
+        name = tags.get("name")
+        if not name:
+            continue
+        amenity = tags.get("amenity", "clinic")
+        lat2 = el.get("lat") or (el.get("center") or {}).get("lat")
+        lon2 = el.get("lon") or (el.get("center") or {}).get("lon")
+        if lat2 is None or lon2 is None:
+            continue
+        dist = haversine_km(lat, lon, float(lat2), float(lon2))
+        addr_parts = []
+        for k in ("addr:street", "addr:city"):
+            if tags.get(k):
+                addr_parts.append(tags[k])
+        addr = ", ".join(addr_parts)
+
+        # Default line
+        line = {
+            "name": name,
+            "type": amenity,
+            "distance_km": dist,
+            "address": addr,
+            "wait": None,
+        }
+
+        # Optional: call your own wait-time API
+        if WAIT_TIMES_API_BASE:
+            jt = safe_get_json(
+                f"{WAIT_TIMES_API_BASE}/wait",
+                params={"name": name},
+                timeout=4
+            )
+            if jt and isinstance(jt, dict) and jt.get("estimated_minutes") is not None:
+                line["wait"] = int(jt["estimated_minutes"])
+
+        facilities.append(line)
+
+    facilities = sorted(facilities, key=lambda x: x["distance_km"])[:8]
+    if not facilities:
+        return (
+            "No nearby facilities found in open map data. "
+            "Suggest using maps and provincial health websites to locate clinics and ERs."
         )
 
-    province_links.append(
-        "- For emergencies or red-flag symptoms, emphasize going to the nearest emergency department or calling 911 immediately."
-    )
+    out_lines = ["Nearby health facilities (approximate from open data):"]
+    for f in facilities:
+        s = f"- {f['name']} ({f['type']}, ~{f['distance_km']:.1f} km"
+        if f["address"]:
+            s += f", {f['address']}"
+        if f["wait"] is not None:
+            s += f", est. wait ~{f['wait']} min"
+        s += ")"
+        out_lines.append(s)
+
+    if not WAIT_TIMES_API_BASE:
+        out_lines.append(
+            "Note: No live wait-time API configured; wait times above are not shown. "
+            "You can integrate an official or custom wait-time API via WAIT_TIMES_API_BASE."
+        )
 
-    return base + "\n".join(province_links)
+    return "\n".join(out_lines)
 
 
-# =========================
-# DRUG PRODUCT LOOKUP (DPD)
-# =========================
+@tool
+def get_drug_info(text: str) -> str:
+    """
+    Extracts possible medication/product names from the text and checks Health Canada's DPD.
+    Returns a high-level note; no dosing or personal advice.
+    """
+    if not text:
+        return "No text provided for medication lookup."
 
-def tool_lookup_drug_products(candidates):
+    # naive extraction: capitalized tokens length>3
+    tokens = []
+    for tok in text.split():
+        clean = "".join(ch for ch in tok if ch.isalnum())
+        if len(clean) > 3 and clean[0].isalpha() and clean[0].isupper():
+            tokens.append(clean)
+    candidates = sorted(set(tokens))[:10]
     if not candidates:
-        return "No clear medication/product names detected that require a Drug Product Database lookup."
+        return "No likely medication names detected that require Drug Product Database lookup."
 
     found_lines = []
     for name in candidates[:5]:
@@ -204,36 +304,34 @@ def tool_lookup_drug_products(candidates):
         data = safe_get_json(DPD_BASE_URL, params=params)
         if not data:
             continue
-
-        unique_brands = set()
+        unique = set()
         for item in data[:3]:
             b = item.get("brand_name") or item.get("brandname") or name
             if b:
-                unique_brands.add(b)
-
-        if unique_brands:
+                unique.add(b)
+        if unique:
             found_lines.append(
-                f"- Found Health Canada Drug Product Database entries related to '{name}' "
-                f"(examples: {', '.join(sorted(unique_brands))})."
+                f"- Health Canada DPD has entries related to '{name}' "
+                f"(e.g., {', '.join(sorted(unique))})."
             )
 
     if not found_lines:
         return (
-            "No strong matches found in the Drug Product Database for the detected terms. "
-            "Users should verify drug details directly via the official Health Canada DPD search."
+            "No strong DPD matches found for detected terms. "
+            "Users should confirm medication details directly via the official Health Canada DPD."
         )
 
     found_lines.append(
-        "For definitive product information, they must consult the official Health Canada Drug Product Database."
+        "For definitive information on any medication, refer to the official Health Canada Drug Product Database."
     )
     return "\n".join(found_lines)
 
 
-# =========================
-# RECALLS & SAFETY ALERTS
-# =========================
-
-def tool_get_recent_recalls_snippet():
+@tool
+def get_recalls(_: str) -> str:
+    """
+    Returns a snapshot of recent recalls & safety alerts from the public JSON feed.
+    """
     data = safe_get_json(RECALLS_FEED_URL)
     items = []
 
@@ -244,8 +342,8 @@ def tool_get_recent_recalls_snippet():
 
     if not items:
         return (
-            "Unable to load recent recalls. Direct users to the official Government of Canada "
-            "Recalls and Safety Alerts website for up-to-date information."
+            "Unable to load recent recalls. Refer users to the official Government of Canada "
+            "Recalls and Safety Alerts website for current information."
         )
 
     lines = ["Recent recalls & safety alerts (snapshot):"]
@@ -259,46 +357,30 @@ def tool_get_recent_recalls_snippet():
         date = item.get("date_published") or item.get("date") or ""
         category = item.get("category") or item.get("type") or ""
         lines.append(f"- {shorten(title)} ({category}, {date})")
-
     lines.append(
-        "For details or to check a specific product, direct users to the official Recalls and Safety Alerts portal."
+        "For details or specific products, visit the official Recalls and Safety Alerts portal."
     )
     return "\n".join(lines)
 
 
-# =========================
-# WAIT TIMES AWARENESS (GENERIC)
-# =========================
-
-def tool_get_wait_times_awareness():
+@tool
+def get_wait_times_awareness(_: str) -> str:
+    """
+    Returns general guidance about using official wait-time dashboards (CIHI / provinces).
+    """
     return textwrap.dedent(f"""
-    Use Canadian open-data wait-time indicators conceptually:
-    - CIHI and several provinces publish average wait-time dashboards for ER, surgeries, diagnostics.
-    - These are not real-time triage tools.
+    Use open-data wait-time information conceptually:
+    - CIHI and some provinces publish average wait-time dashboards for ER and procedures.
+    - These are NOT real-time triage tools.
     Guidance:
-    - For mild issues: local clinics/urgent care may be suitable; check provincial wait-time/clinic-finder tools.
-    - For red-flag or severe symptoms: skip online tools and go directly to ER or call 911.
+    - For mild issues: clinic/urgent care may be appropriate; check provincial tools if available.
+    - For red flags or severe symptoms: skip tools and go directly to ER or call 911.
     General reference: {WAIT_TIMES_INFO_URL}
     """).strip()
 
 
 # =========================
-# TERM EXTRACTION
-# =========================
-
-def extract_candidate_terms(text: str):
-    if not text:
-        return []
-    tokens = []
-    for tok in text.split():
-        clean = "".join(ch for ch in tok if ch.isalnum())
-        if len(clean) > 3 and clean[0].isalpha() and clean[0].isupper():
-            tokens.append(clean)
-    return sorted(set(tokens))[:10]
-
-
-# =========================
-# OPENAI CALLS
+# OPENAI: VISION + ASR
 # =========================
 
 def call_vision_summarizer(image_bytes: bytes) -> str:
@@ -309,31 +391,27 @@ def call_vision_summarizer(image_bytes: bytes) -> str:
 
     prompt = (
         "You are a cautious Canadian health-information assistant.\n"
-        "Describe only visible features in neutral terms.\n"
-        "- If skin/toenail etc.: describe colour, texture, dryness, cracks, swelling, but DO NOT name diseases.\n"
-        "- If medication label: read visible drug name/strength if legible.\n"
-        "- If health letter/report: say what type it appears to be, without copying identifiers.\n"
+        "Describe ONLY what is visible in neutral terms.\n"
+        "- For skin/nails: describe colour, dryness, cracks, swelling, etc. Do NOT name diseases.\n"
+        "- For medication labels: read visible drug names/strengths if clear.\n"
+        "- For letters/reports: say what type of document it appears to be; do not copy identifiers.\n"
         "- If unclear: say it is not medically interpretable.\n"
-        "Never diagnose. Never prescribe. 80-100 words max."
+        "Never diagnose or prescribe. Keep to ~80-100 words."
     )
 
     try:
         resp = client.chat.completions.create(
             model=VISION_MODEL,
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": prompt},
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:image/jpeg;base64,{b64}"
-                            },
-                        },
-                    ],
-                }
-            ],
+            messages=[{
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/jpeg;base64,{b64}"},
+                    },
+                ],
+            }],
             temperature=0.2,
         )
         return resp.choices[0].message.content.strip()
@@ -344,12 +422,10 @@ def call_vision_summarizer(image_bytes: bytes) -> str:
 def call_asr(audio_file) -> str:
     if not client or not audio_file:
         return ""
-
     try:
         audio_bytes = audio_file.read()
         bio = io.BytesIO(audio_bytes)
         bio.name = audio_file.name or "voice.wav"
-
         transcript = client.audio.transcriptions.create(
             model=ASR_MODEL,
             file=bio
@@ -362,127 +438,150 @@ def call_asr(audio_file) -> str:
         return f"(Transcription unavailable: {e})"
 
 
-def call_reasoning_agent(
-    user_text: str,
-    voice_text: str,
-    vision_summary: str,
-    dpd_context: str,
-    recalls_context: str,
-    wait_times_context: str,
-    region_context: str,
-    nearby_services_context: str,
-) -> str:
-    if not client:
-        return (
-            "AI backend not configured. With a valid API key, this agent would combine your inputs and "
-            "open-data context into cautious, structured guidance."
-        )
+# =========================
+# LANGCHAIN AGENT
+# =========================
+
+def build_agent():
+    """
+    Constructs a LangChain tool-calling agent that:
+    - reads narrative + vision summary + postal code,
+    - can call tools: get_region_context, get_nearby_facilities, get_drug_info,
+      get_recalls, get_wait_times_awareness,
+    - outputs a structured, safe triage-style answer with:
+      Primary Recommended Pathway, Home Care, Clinic/Telehealth, ER, Resources, Disclaimer.
+    """
+    llm = ChatOpenAI(
+        model=REASONING_MODEL,
+        temperature=0.25,
+        openai_api_key=OPENAI_API_KEY,
+    )
 
-    narrative_parts = []
-    if user_text.strip():
-        narrative_parts.append("Typed description:\n" + user_text.strip())
-    if voice_text.strip():
-        narrative_parts.append("Transcribed voice note:\n" + voice_text.strip())
-    if not narrative_parts:
-        narrative_parts.append("No textual description provided.")
-    narrative = "\n\n".join(narrative_parts)
+    tools = [
+        get_region_context,
+        get_nearby_facilities,
+        get_drug_info,
+        get_recalls,
+        get_wait_times_awareness,
+    ]
 
     system_prompt = """
 You are CareCall AI, an agentic Canadian health information assistant.
 
-HARD RULES:
-- DO NOT give a medical diagnosis.
-- DO NOT prescribe or specify individual dosing.
-- DO NOT guarantee exact real-time wait times or locations.
-- Use ONLY the provided content and tool outputs (vision summary, DPD, recalls, wait-times context, region info, nearby services guide).
-- You MUST classify guidance into a clear, practical structure without pretending to be a doctor.
-
-WHAT YOU SHOULD DO:
-
-1. Identify red-flag indicators (e.g., chest pain, trouble breathing, stroke signs, rapidly spreading infection,
-   severe pain, heavy bleeding, high fever with stiff neck, suicidal thoughts, major trauma).
-   - If any such red flags are present or strongly implied: 
-     PRIMARY PATHWAY = ER/911.
-2. If no red flags and issue seems mild/local (e.g., minor rash, mild toe pain, dry skin, chipped nail, etc.):
-   - You may choose PRIMARY PATHWAY = Home care + possibly pharmacist.
-3. If there is uncertainty, ongoing pain, risk factors (diabetes, immune issues, poor circulation),
-   or symptoms that are not clearly mild:
-   - You may choose PRIMARY PATHWAY = Clinic / family doctor / Telehealth.
-
-ALWAYS:
-
-- Output a section called "Primary Recommended Pathway" with ONE of:
-    * "Home care likely reasonable (monitor closely)"
-    * "Pharmacist / Walk-in clinic / Family doctor recommended"
-    * "Call provincial Telehealth / nurse line for guidance"
-    * "Go to Emergency / Call 911 now"
-- Then:
-    * Give a short explanation for WHY that pathway was chosen.
-    * Provide a "Home Care (if appropriate)" section with 3–6 simple, generic measures
-      (e.g., keep area clean/dry, rest, elevation, cold compress, OTC pain relief as per label, avoid friction),
-      ONLY when not clearly contradicted.
-    * Provide "When to seek clinic/Telehealth" with concrete triggers.
-    * Provide "When this is an emergency" with explicit red-flag bullets.
-    * Mention provincial/nearby resources using the region and nearby-services context.
-    * If medications/recalls context is relevant, remind the user to verify via Health Canada DPD and Recalls portal.
-- Keep total answer under ~350 words.
-- Reiterate that this is informational only, not medical care, and that professionals/Telehealth/ER override all advice.
+You have access to tools to:
+- get_region_context(postal_code)
+- get_nearby_facilities(postal_code)
+- get_drug_info(text)
+- get_recalls(_)
+- get_wait_times_awareness(_)
+
+Follow these rules:
+
+- NEVER provide a medical diagnosis.
+- NEVER prescribe or give dosing.
+- NEVER fabricate real-time wait times.
+- Use tools to ground your answer in Canadian, open, trusted sources.
+- Stay within ~350 words.
+
+PRIMARY PATHWAY LOGIC:
+
+1. If strong red-flag symptoms are present:
+   (chest pain, difficulty breathing, stroke signs, heavy bleeding,
+    major trauma, high fever with stiff neck, severe abdominal pain,
+    rapidly spreading infection with systemic symptoms, suicidal thoughts)
+   => Primary Recommended Pathway: "Go to Emergency / Call 911 now".
+
+2. If NO red flags and description suggests:
+   - localized mild/moderate issue (e.g., minor rash, mild toe pain,
+     discomfort, dryness, irritation, small wound),
+   - no major risk factors clearly stated,
+   => Primary Recommended Pathway: "Home care likely reasonable (monitor closely)",
+      plus pharmacist/clinic as backup if not improving.
+
+3. If symptoms are persistent, unclear, moderate, concerning,
+   or risk factors are present but not clearly ER:
+   => Primary Recommended Pathway:
+      "Pharmacist / Walk-in clinic / Family doctor recommended"
+      OR
+      "Call provincial Telehealth / nurse line for guidance".
+
+OUTPUT FORMAT (exact sections, in this order):
+
+1. **Primary Recommended Pathway**
+   - One bullet with exactly one of:
+     * "Home care likely reasonable (monitor closely)"
+     * "Pharmacist / Walk-in clinic / Family doctor recommended"
+     * "Call provincial Telehealth / nurse line for guidance"
+     * "Go to Emergency / Call 911 now"
+   - One short sentence explaining why.
+
+2. **What this might relate to (general categories)**
+   - 3–5 bullets with broad categories only (irritation, minor trauma,
+     nail/skin infection risk, allergy, medication question, etc.).
+   - Do NOT assert a specific disease name as fact.
+
+3. **Home Care (if appropriate)**
+   - If home care is primary or a safe initial option:
+       3–6 simple measures (gentle cleaning, keep area dry, avoid friction,
+       protective padding, OTC pain relief per label, monitor changes).
+   - If not advised: say that clearly.
+
+4. **When to see a Pharmacist / Clinic / Telehealth**
+   - 3–6 triggers (pain not improving, spreading redness, pus, trouble walking,
+     recurrent issues, underlying conditions like diabetes, confusion about meds).
+
+5. **When this is an Emergency (ER/911)**
+   - 3–8 clear red-flag bullets.
+
+6. **Local & Official Resources**
+   - 2–6 bullets using:
+       get_region_context,
+       get_nearby_facilities,
+       get_wait_times_awareness,
+       and mention Health Canada / PHAC / CIHI / provincial sites.
+
+7. **Important Disclaimer**
+   - 2–4 lines:
+       This is informational only,
+       not medical care,
+       not a substitute for a professional or emergency services.
+
+Use tools whenever they can improve accuracy (especially for region, facilities, recalls, meds).
 """
 
-    user_prompt = f"""
-INPUT CONTEXT
-
-1) User narrative:
-{narrative}
-
-2) Vision summary:
-{vision_summary or "No image or no usable visual details."}
-
-3) Drug Product Database context:
-{dpd_context}
-
-4) Recalls & Safety Alerts context:
-{recalls_context}
-
-5) Wait-time awareness context:
-{wait_times_context}
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", system_prompt),
+            ("human", "{input}"),
+        ]
+    )
 
-6) Region (postal code) context:
-{region_context}
+    agent = create_tool_calling_agent(llm, tools, prompt)
+    executor = AgentExecutor(agent=agent, tools=tools, verbose=False)
+    return executor
 
-7) Nearby services & finder resources:
-{nearby_services_context}
 
-TASK
+def run_agent(narrative: str, vision_summary: str, postal_code: str) -> str:
+    agent = build_agent()
+    # Build a single input string that the agent will use + tools can refine.
+    user_input = f"""
+User narrative:
+{narrative or "(none provided)"}
 
-Using ONLY the above, produce a structured response with these sections:
+Vision summary:
+{vision_summary or "(no image or no usable visual details)"}
 
-1. "Primary Recommended Pathway": one of the four options (see system rules) + 1–2 sentence reasoning.
-2. "What this might relate to (in general terms)": 3–5 bullets of broad categories, no diagnoses.
-3. "Home Care (if appropriate)": 3–6 safe, generic self-care steps OR a note that home care alone is not advised.
-4. "When to see a Pharmacist / Clinic / Telehealth": 3–6 concrete triggers.
-5. "When this is an Emergency (ER/911)": bullet list of red-flag situations.
-6. "Local & Official Resources": 2–5 bullets using the region + nearby-services context and open-data style info.
-7. "Important Disclaimer": 2–4 lines stating this is informational only and not medical care.
+Postal code:
+{postal_code or "(not provided)"}
 
-Be firm and clear but never overconfident.
+Notes:
+- If relevant, consider calling get_drug_info with this combined text.
+- If postal_code is provided, consider get_region_context and get_nearby_facilities.
+- You may call get_recalls and get_wait_times_awareness for additional safety/awareness.
 """
-
-    try:
-        resp = client.chat.completions.create(
-            model=REASONING_MODEL,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": user_prompt},
-            ],
-            temperature=0.35,
-        )
-        return resp.choices[0].message.content.strip()
-    except Exception as e:
-        return (
-            f"(Reasoning agent unavailable: {e})\n\n"
-            "Please contact a licensed provider, Telehealth, or emergency services as appropriate."
-        )
+    result = agent.invoke({"input": user_input})
+    # AgentExecutor returns dict with 'output' key by default
+    return result.get("output", str(result))
 
 
 # =========================
@@ -490,46 +589,45 @@ Be firm and clear but never overconfident.
 # =========================
 
 st.title("CareCall AI (Canada)")
-st.caption("Agentic, vision + voice + postal-aware health info companion. Not a doctor. Not a diagnosis.")
-
-if not OPENAI_API_KEY:
-    st.warning("Set OPENAI_API_KEY in your Space secrets to enable the AI backend.")
+st.caption("LangChain agent • Vision + Voice + Postal-aware • Non-diagnostic health info")
 
 st.markdown(
     """
-**How to use**
-
-1. Enter your **Canadian postal code** (optional but helps tailor guidance).
-2. Upload a **photo** related to your concern (e.g., rash, nail, pill bottle, letter) — optional.
-3. Upload a **voice note** and/or type a **short description**.
-4. Click **Run CareCall Agent** to get:
-   - A clear **primary recommended pathway**,
-   - Safe **home-care tips** when appropriate,
-   - Triggers for **clinic/Telehealth**,
-   - **Emergency red-flag guidance**,
-   - Links to **official & provincial resources**.
+This demo:
+- Lets you upload a **photo** (rash, nail, medication, letter),
+- Add a **voice note** or **typed description**,
+- Optionally enter your **Canadian postal code**,
+- Then an **agentic AI** calls tools (open data, nearby clinics, etc.) and returns:
+
+- A clear **Primary Recommended Pathway** (including home care when safe),
+- Generic **home-care guidance**,
+- **Clinic / Telehealth / ER** triggers,
+- **Nearby facilities** & official resource pointers.
+
+It does **not** diagnose or prescribe.
 """
 )
 
-# 1) Postal code
+if not OPENAI_API_KEY:
+    st.stop()
+
+# Postal code
 st.markdown("### 1. Postal code (optional, Canada only)")
 postal_code = st.text_input(
     "Canadian postal code (e.g., M5V 2T6). Leave blank for general guidance.",
     max_chars=7,
 )
 
-# 2) Image upload
+# Image
 st.markdown("### 2. Upload an image (optional)")
 image_file = st.file_uploader(
     "Upload a photo (JPG/PNG). Avoid highly identifying or explicit content.",
     type=["jpg", "jpeg", "png"],
     accept_multiple_files=False,
 )
-
 image_bytes = None
 if image_file is not None:
     try:
-        # Convert to RGB so we can safely save as JPEG (avoids RGBA error)
         img = Image.open(image_file).convert("RGB")
         st.image(img, caption="Image received", use_container_width=True)
         buf = io.BytesIO()
@@ -539,7 +637,7 @@ if image_file is not None:
         st.warning(f"Could not read that image: {e}")
         image_bytes = None
 
-# 3) Audio upload
+# Audio
 st.markdown("### 3. Add a voice note (optional)")
 audio_file = st.file_uploader(
     "Upload a short voice note (wav/mp3/m4a).",
@@ -547,68 +645,37 @@ audio_file = st.file_uploader(
     accept_multiple_files=False,
 )
 
-# 4) Text description
+# Text
 st.markdown("### 4. Or type a short description")
 user_text = st.text_area(
-    "Describe what’s going on:",
-    placeholder='Example: "Pain and discoloration around big toenail when wearing shoes for 1 week, no fever, no major swelling."',
+    "Describe what's going on:",
+    placeholder='Example: "Big toenail is sore and a bit red for 5 days when wearing tight shoes, no fever, I can walk okay."',
     height=120,
 )
 
-# Run agent
+# Run
 if st.button("Run CareCall Agent"):
-    if not client:
-        st.error("OPENAI_API_KEY is not set. Configure it in your Space settings.")
-    else:
-        with st.spinner("Running vision + voice + open-data tools + reasoning..."):
-
-            # Vision
-            vision_summary = ""
-            if image_bytes:
-                vision_summary = call_vision_summarizer(image_bytes)
-
-            # ASR
-            voice_text = ""
-            if audio_file is not None:
-                voice_text = call_asr(audio_file)
-
-            # Candidate terms for Drug DB
-            combined_for_terms = " ".join(
-                t for t in [user_text or "", voice_text or "", vision_summary or ""] if t
-            )
-            candidates = extract_candidate_terms(combined_for_terms)
-            dpd_context = tool_lookup_drug_products(candidates)
-
-            # Recalls
-            recalls_context = tool_get_recent_recalls_snippet()
-
-            # Wait-time awareness
-            wait_times_context = tool_get_wait_times_awareness()
-
-            # Region context
-            region_context = (
-                tool_region_context(postal_code)
-                if postal_code
-                else "No postal code provided. Use Canada-wide guidance and mention provincial resources generally."
-            )
-
-            # Nearby clinics / wait finder resources
-            nearby_services_context = tool_find_nearby_clinics_and_waits(postal_code) if postal_code else (
-                "No postal code. Suggest searchable options like 'walk-in clinic near me' plus city, "
-                "and provincial clinic/ER finder tools."
-            )
-
-            # Final reasoning
-            final_answer = call_reasoning_agent(
-                user_text=user_text or "",
-                voice_text=voice_text or "",
-                vision_summary=vision_summary,
-                dpd_context=dpd_context,
-                recalls_context=recalls_context,
-                wait_times_context=wait_times_context,
-                region_context=region_context,
-                nearby_services_context=nearby_services_context,
-            )
+    with st.spinner("Running vision + voice + tools + agentic reasoning..."):
+
+        # Vision summary
+        vision_summary = call_vision_summarizer(image_bytes) if image_bytes else ""
+
+        # Transcription
+        voice_text = call_asr(audio_file) if audio_file is not None else ""
+
+        # Combine narrative
+        narrative_parts = []
+        if user_text.strip():
+            narrative_parts.append("Typed: " + user_text.strip())
+        if voice_text.strip():
+            narrative_parts.append("Voice (transcribed): " + voice_text.strip())
+        narrative = "\n".join(narrative_parts)
+
+        response = run_agent(
+            narrative=narrative,
+            vision_summary=vision_summary,
+            postal_code=postal_code or "",
+        )
 
-        st.markdown("### CareCall AI Summary (Informational Only)")
-        st.write(final_answer)
+    st.markdown("### CareCall AI Summary (Informational Only)")
+    st.write(response)