Update app.py

app.py

@@ -8,16 +8,12 @@ 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.agents import initialize_agent, AgentType
-
 # =========================
-# STREAMLIT + OPENAI CONFIG
+# CONFIG
 # =========================
 
 st.set_page_config(
-    page_title="CareCall AI (Canada) - Agentic Health Info",
+    page_title="CareCall AI (Canada)",
     page_icon="🩺",
     layout="centered"
 )
@@ -27,27 +23,27 @@ 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
 
-# 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
+# Models
+VISION_MODEL = "gpt-4.1-mini"     # image-capable OpenAI model
+REASONING_MODEL = "gpt-4.1-mini"  # reasoning model
+ASR_MODEL = "whisper-1"           # transcription model
 
-# Health Canada Drug Product Database
+# External data sources
 DPD_BASE_URL = "https://health-products.canada.ca/api/drug/drugproduct"
-
-# 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 (context link, not live triage)
 WAIT_TIMES_INFO_URL = "https://www.cihi.ca/en/topics/access-and-wait-times"
 
-# Optional: your own normalized wait-time API
+# Optional: your own official/partner wait time API
 WAIT_TIMES_API_BASE = os.getenv("WAIT_TIMES_API_BASE", "").rstrip("/")
 
-# Postal prefix -> province map
+# Google Custom Search (this is your “Google search”)
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")  # from Google Cloud
+GOOGLE_CSE_ID = os.getenv("GOOGLE_CSE_ID")    # your Custom Search Engine ID (cx)
+
+# Postal code prefix -> province
 POSTAL_PREFIX_TO_PROVINCE = {
     "A": "Newfoundland and Labrador",
     "B": "Nova Scotia",
@@ -69,7 +65,7 @@ POSTAL_PREFIX_TO_PROVINCE = {
     "Y": "Yukon",
 }
 
-USER_AGENT = "carecall-ai-langchain-demo/1.0"
+USER_AGENT = "carecall-ai-googlecse/1.0"
 
 
 # =========================
@@ -93,10 +89,10 @@ def safe_get_json(url, params=None, method="GET", data=None, timeout=8):
 def shorten(text, max_chars=260):
     if not text:
         return ""
-    text = text.strip()
-    if len(text) <= max_chars:
-        return text
-    return text[: max_chars - 3].rstrip() + "..."
+    t = text.strip()
+    if len(t) <= max_chars:
+        return t
+    return t[: max_chars - 3].rstrip() + "..."
 
 
 def haversine_km(lat1, lon1, lat2, lon2):
@@ -143,20 +139,85 @@ def geocode_postal(postal_code: str):
 
 
 # =========================
-# LANGCHAIN TOOLS
+# GOOGLE CUSTOM SEARCH TOOL
 # =========================
 
-@tool
-def get_region_context(postal_code: str) -> str:
+def google_cse_search(query: str, num: int = 5):
+    """
+    Uses Google Custom Search JSON API (CSE) to run queries.
+    This is the ToS-compliant way to 'use Google search'.
+
+    Requires:
+    - GOOGLE_API_KEY
+    - GOOGLE_CSE_ID (cx)
     """
-    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).
+    if not GOOGLE_API_KEY or not GOOGLE_CSE_ID:
+        return None
+
+    url = "https://www.googleapis.com/customsearch/v1"
+    params = {
+        "key": GOOGLE_API_KEY,
+        "cx": GOOGLE_CSE_ID,
+        "q": query,
+        "num": max(1, min(num, 10)),
+    }
+    return safe_get_json(url, params=params)
+
+
+def tool_search_wait_times_google(postal_code: str) -> str:
+    """
+    Use Google Custom Search to find official pages about:
+    - nearby clinics/hospitals,
+    - ER / urgent care wait times or 'current status' pages.
+
+    You should configure your CSE (cx) to prioritize:
+    gov / health authority / hospital domains in Canada.
     """
+    if not postal_code:
+        return "Postal code missing; Google-based search not attempted."
+
+    data = google_cse_search(
+        query=(
+            f"walk-in clinic OR hospital OR emergency room wait times near {postal_code} Canada"
+        ),
+        num=6,
+    )
+
+    if data is None:
+        return (
+            "Google Custom Search is not configured (set GOOGLE_API_KEY and GOOGLE_CSE_ID). "
+            "Rely on OSM + provincial/hospital websites."
+        )
+
+    items = data.get("items", [])
+    if not items:
+        return (
+            "Google Custom Search did not return clear official wait-time pages. "
+            "User should check provincial or hospital websites directly."
+        )
+
+    lines = ["Google search results for clinics / hospitals / wait-time info (review directly):"]
+    for it in items[:6]:
+        title = it.get("title", "Result")
+        link = it.get("link", "")
+        snippet = shorten(it.get("snippet", "") or it.get("htmlSnippet", ""), 180)
+        lines.append(f"- {title} — {link} — {snippet}")
+
+    lines.append(
+        "These links may include official clinic/hospital finders or wait-time dashboards. "
+        "Users should always verify details on the source site."
+    )
+    return "\n".join(lines)
+
+
+# =========================
+# OTHER TOOL-LIKE FUNCTIONS
+# =========================
+
+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 general Canada-wide guidance and mention provincial resources."
+        return "No postal code provided. Use Canada-wide guidance and mention provincial resources."
 
     if not province:
         return (
@@ -165,12 +226,12 @@ def get_region_context(postal_code: str) -> str:
         )
 
     telehealth_note = (
-        f"In {province}, advise the user to use the official provincial Telehealth or 811-style nurse line "
+        f"In {province}, advise use of the official provincial Telehealth or 811-style nurse line "
         "for real-time nurse assessment."
     )
     wait_note = (
-        "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}"
+        "For non-urgent issues, users can check provincial/health authority resources and CIHI indicators "
+        f"for access/wait-time context (not real-time). Ref: {WAIT_TIMES_INFO_URL}"
     )
 
     return (
@@ -180,24 +241,18 @@ def get_region_context(postal_code: str) -> str:
     )
 
 
-@tool
-def get_nearby_facilities(postal_code: str) -> str:
-    """
-    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.
-    """
+def tool_find_nearby_clinics_osm(postal_code: str) -> str:
     coords = geocode_postal(postal_code)
     if not coords:
         return (
-            "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."
+            "Could not geocode the postal code. Suggest searching for walk-in clinics, urgent care, or hospitals "
+            "near the user using maps and official provincial tools."
         )
 
     lat, lon = coords
-
     overpass_url = "https://overpass-api.de/api/interpreter"
     query = f"""
-    [out:json][timeout:10];
+    [out:json][timeout:8];
     (
       node["amenity"="clinic"](around:7000,{lat},{lon});
       node["amenity"="hospital"](around:7000,{lat},{lon});
@@ -206,11 +261,12 @@ def get_nearby_facilities(postal_code: str) -> str:
     );
     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."
+            "Nearby facility lookup via open map data is unavailable. "
+            "Suggest using maps and provincial find-a-clinic tools."
         )
 
     facilities = []
@@ -219,26 +275,22 @@ def get_nearby_facilities(postal_code: str) -> str:
         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)
 
-        line = {
-            "name": name,
-            "type": amenity,
-            "distance_km": dist,
-            "address": addr,
-            "wait": None,
-        }
-
+        wait = None
         if WAIT_TIMES_API_BASE:
             jt = safe_get_json(
                 f"{WAIT_TIMES_API_BASE}/wait",
@@ -246,18 +298,26 @@ def get_nearby_facilities(postal_code: str) -> str:
                 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)
+                wait = int(jt["estimated_minutes"])
+
+        facilities.append(
+            {
+                "name": name,
+                "type": amenity,
+                "distance_km": dist,
+                "address": addr,
+                "wait": wait,
+            }
+        )
 
     facilities = sorted(facilities, key=lambda x: x["distance_km"])[:8]
     if not facilities:
         return (
-            "No nearby facilities found in open map data. "
+            "No nearby facilities found via open map data. "
             "Suggest using maps and provincial health websites to locate clinics and ERs."
         )
 
-    out_lines = ["Nearby health facilities (approximate from open data):"]
+    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"]:
@@ -265,23 +325,18 @@ def get_nearby_facilities(postal_code: str) -> str:
         if f["wait"] is not None:
             s += f", est. wait ~{f['wait']} min"
         s += ")"
-        out_lines.append(s)
+        lines.append(s)
 
     if not WAIT_TIMES_API_BASE:
-        out_lines.append(
-            "Note: No live wait-time API configured; estimated waits are not shown. "
+        lines.append(
+            "Note: No live wait-time API configured; estimated waits (if any) are not shown. "
             "You can integrate an official/custom wait-time API via WAIT_TIMES_API_BASE."
         )
 
-    return "\n".join(out_lines)
+    return "\n".join(lines)
 
 
-@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.
-    """
+def tool_lookup_drug_products(text: str) -> str:
     if not text:
         return "No text provided for medication lookup."
 
@@ -292,9 +347,9 @@ def get_drug_info(text: str) -> str:
             tokens.append(clean)
     candidates = sorted(set(tokens))[:10]
     if not candidates:
-        return "No likely medication names detected that require Drug Product Database lookup."
+        return "No likely medication names detected for Drug Product Database lookup."
 
-    found_lines = []
+    found = []
     for name in candidates[:5]:
         params = {"lang": "en", "type": "json", "brandname": name}
         data = safe_get_json(DPD_BASE_URL, params=params)
@@ -306,28 +361,24 @@ def get_drug_info(text: str) -> str:
             if b:
                 unique.add(b)
         if unique:
-            found_lines.append(
+            found.append(
                 f"- Health Canada DPD has entries related to '{name}' "
                 f"(e.g., {', '.join(sorted(unique))})."
             )
 
-    if not found_lines:
+    if not found:
         return (
-            "No strong DPD matches found for detected terms. "
+            "No strong matches found in the Drug Product Database for detected terms. "
             "Users should confirm medication details directly via the official Health Canada DPD."
         )
 
-    found_lines.append(
-        "For definitive information on any medication, refer to the official Health Canada Drug Product Database."
+    found.append(
+        "For definitive medication information, users must consult the official Health Canada Drug Product Database."
     )
-    return "\n".join(found_lines)
+    return "\n".join(found)
 
 
-@tool
-def get_recalls(_: str) -> str:
-    """
-    Returns a snapshot of recent recalls & safety alerts from the public JSON feed.
-    """
+def tool_get_recent_recalls_snippet() -> str:
     data = safe_get_json(RECALLS_FEED_URL)
     items = []
 
@@ -353,24 +404,21 @@ def get_recalls(_: str) -> str:
         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 specific products, visit the official Recalls and Safety Alerts portal."
     )
     return "\n".join(lines)
 
 
-@tool
-def get_wait_times_awareness(_: str) -> str:
-    """
-    Returns general guidance about using official wait-time dashboards (CIHI / provinces).
-    """
+def tool_get_wait_times_awareness() -> str:
     return textwrap.dedent(f"""
     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.
+    - CIHI and some provinces publish average wait-time dashboards.
+    - These are NOT real-time triage tools or guarantees.
     Guidance:
     - For mild issues: clinic/urgent care may be appropriate; check provincial tools if available.
-    - For red flags or severe symptoms: go directly to ER or call 911.
+    - For red-flag or severe symptoms: go directly to ER or call 911.
     General reference: {WAIT_TIMES_INFO_URL}
     """).strip()
 
@@ -389,8 +437,8 @@ def call_vision_summarizer(image_bytes: bytes) -> str:
         "You are a cautious Canadian health-information assistant.\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"
+        "- For medication labels: mention visible drug names/strengths if legible.\n"
+        "- For letters/reports: say what type of document it appears to be; avoid identifiers.\n"
         "- If unclear: say it is not medically interpretable.\n"
         "Never diagnose or prescribe. Keep to ~80-100 words."
     )
@@ -426,130 +474,117 @@ def call_asr(audio_file) -> str:
             model=ASR_MODEL,
             file=bio
         )
-        text = getattr(transcript, "text", None)
-        if isinstance(text, str):
-            return text.strip()
+        txt = getattr(transcript, "text", None)
+        if isinstance(txt, str):
+            return txt.strip()
         return str(transcript)
     except Exception as e:
         return f"(Transcription unavailable: {e})"
 
 
 # =========================
-# LANGCHAIN AGENT (initialize_agent)
+# REASONING (FINAL ANSWER)
 # =========================
 
-def build_agent():
-    llm = ChatOpenAI(
-        model=REASONING_MODEL,
-        temperature=0.25,
-        openai_api_key=OPENAI_API_KEY,
-    )
-
-    tools = [
-        get_region_context,
-        get_nearby_facilities,
-        get_drug_info,
-        get_recalls,
-        get_wait_times_awareness,
-    ]
-
-    agent = initialize_agent(
-        tools=tools,
-        llm=llm,
-        agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
-        verbose=False,
-        handle_parsing_errors=True,
-    )
-    return agent
-
-
-def run_agent(narrative: str, vision_summary: str, postal_code: str) -> str:
-    agent = build_agent()
+def call_reasoning_agent(
+    narrative: str,
+    vision_summary: str,
+    postal_code: str,
+    dpd_context: str,
+    recalls_context: str,
+    wait_awareness_context: str,
+    region_context: str,
+    nearby_osm_context: str,
+    google_search_context: str,
+) -> str:
+    if not client:
+        return (
+            "AI backend not configured. With a valid API key, this agent would combine your inputs "
+            "into cautious, structured guidance."
+        )
 
-    user_input = f"""
+    system_prompt = """
 You are CareCall AI, an agentic Canadian health information assistant.
 
-You have tools:
-- get_region_context(postal_code)
-- get_nearby_facilities(postal_code)
-- get_drug_info(text)
-- get_recalls(_)
-- get_wait_times_awareness(_)
+You receive:
+- User narrative,
+- Vision summary,
+- Postal code,
+- Drug Product Database context,
+- Recalls & Safety Alerts snapshot,
+- Wait-time awareness notes,
+- Region context (province + Telehealth),
+- OSM-based nearby facilities,
+- Google Custom Search context with official pages.
 
 Rules:
-- NEVER give a diagnosis.
-- NEVER prescribe or give dosing.
-- NEVER fabricate real-time wait times.
-- Stay under about 350 words.
-- Use tools to ground your answer (especially for postal_code, facilities, medications, recalls, wait-time awareness).
-
-PRIMARY PATHWAY LOGIC:
-1. If any strong red-flag symptoms are present (chest pain, trouble breathing, stroke signs,
-   heavy bleeding, major trauma, high fever with stiff neck, severe abdominal pain,
-   rapidly spreading infection with systemic symptoms, suicidal thoughts, etc.):
-   -> Primary Recommended Pathway = "Go to Emergency / Call 911 now".
-2. If NO red flags and the concern is localized, mild/moderate (e.g., minor rash, toe pain,
-   dryness, irritation, chipped/broken nail) and no major risk factors clearly stated:
-   -> Primary Recommended Pathway = "Home care likely reasonable (monitor closely)" + pharmacist/clinic only if not improving.
-3. If symptoms are persistent, unclear, moderate, or risk factors are present (e.g., diabetes, immune issues),
-   but not clearly emergency:
-   -> Primary Recommended Pathway = "Pharmacist / Walk-in clinic / Family doctor recommended"
-      or "Call provincial Telehealth / nurse line for guidance".
-
-CONTEXT:
-- User narrative (typed + transcribed):
-{narrative or "(none provided)"}
+- Do NOT provide a diagnosis.
+- Do NOT prescribe or specify dosing.
+- Do NOT invent real-time wait times or guarantees.
+- Use ONLY the context given (no extra browsing).
+- Keep response under ~350 words.
+- Be clear, neutral, and practical.
 
-- Vision summary:
-{vision_summary or "(no image or no usable visual details)"}
+Primary Pathway Logic:
+(identical as previously described; choose Home vs Clinic vs Telehealth vs ER based on severity and red flags.)
 
-- Postal code:
-{postal_code or "(not provided)"}
+Output sections (in this exact order and headings):
+1. **Primary Recommended Pathway**
+2. **What this might relate to (general categories)**
+3. **Home Care (if appropriate)**
+4. **When to see a Pharmacist / Clinic / Telehealth**
+5. **When this is an Emergency (ER/911)**
+6. **Local & Official Resources**
+7. **Important Disclaimer**
+"""
 
-If useful:
-- Call get_drug_info with the narrative + vision summary text.
-- If postal code is present, call get_region_context and get_nearby_facilities.
-- You may also call get_recalls and get_wait_times_awareness for extra safety/awareness.
+    user_prompt = f"""
+INPUT CONTEXT
 
-OUTPUT (exact sections, in this order):
+User narrative:
+{narrative or "(none provided)"}
 
-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.
+Vision summary:
+{vision_summary or "(no image or no usable visual details)"}
 
-2. **What this might relate to (general categories)**
-   - 3–5 bullets, broad categories only. No firm disease labels.
+Postal code: {postal_code or "(not provided)"}
 
-3. **Home Care (if appropriate)**
-   - If home care is primary or reasonable initial option:
-       3–6 simple steps (cleaning, keep dry, avoid friction, protective padding,
-       OTC pain relief per label, monitor).
-   - Otherwise, say home care alone is not advised.
+Drug Product Database context:
+{dpd_context}
 
-4. **When to see a Pharmacist / Clinic / Telehealth**
-   - 3–6 concrete triggers (worsening pain, spreading redness, pus, difficulty walking,
-     recurring issue, chronic illnesses, medication questions).
+Recalls & Safety Alerts context:
+{recalls_context}
 
-5. **When this is an Emergency (ER/911)**
-   - 3–8 clear red-flag bullets.
+Wait-time awareness (general):
+{wait_awareness_context}
 
-6. **Local & Official Resources**
-   - 2–6 bullets using outputs from region/facility/wait-time tools,
-     and mentioning Health Canada, PHAC, CIHI, and provincial sites.
+Region context:
+{region_context}
 
-7. **Important Disclaimer**
-   - 2–4 lines: informational only, not medical care, not a substitute for professionals or emergency services.
+Nearby facilities (OSM-based):
+{nearby_osm_context}
 
-Now follow this format and use tools as needed.
+Google search context (clinics/hospitals/wait-times):
+{google_search_context}
+
+Now generate the structured response following the system instructions.
 """
 
-    # ZERO_SHOT_REACT_DESCRIPTION agents use .run with a single string
-    result = agent.run(user_input)
-    return result
+    try:
+        resp = client.chat.completions.create(
+            model=REASONING_MODEL,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+            temperature=0.25,
+        )
+        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."
+        )
 
 
 # =========================
@@ -557,43 +592,47 @@ Now follow this format and use tools as needed.
 # =========================
 
 st.title("CareCall AI (Canada)")
-st.caption("LangChain agent • Vision + Voice + Postal-aware • Non-diagnostic health info")
+st.caption("Vision + Voice + Postal + Google CSE • Non-diagnostic agentic helper")
 
 st.markdown(
     """
-This demo:
-- Lets a user upload a **photo**, a **voice note**, and/or a **typed description**.
-- Optionally uses their **Canadian postal code**.
-- An agentic AI then:
-  - analyzes the image safely,
-  - transcribes audio,
-  - calls tools (Health Canada DPD, Recalls, open-map facilities, regional context),
-  - and returns a structured, cautious recommendation:
-    - clear **Primary Recommended Pathway** (home vs clinic vs Telehealth vs ER),
-    - simple **home-care tips** when appropriate,
-    - **when to escalate**, and
-    - **nearby facilities & official resources**.
+This app:
+- Accepts an image, voice note, and/or typed description,
+- (Optionally) uses your **Canadian postal code**,
+- Uses:
+  - OpenAI vision + Whisper,
+  - Health Canada Drug Product DB,
+  - Recalls & Safety Alerts,
+  - CIHI wait-time awareness,
+  - OpenStreetMap for nearby clinics/hospitals,
+  - **Google Custom Search (CSE)** for official pages (if configured),
+- And returns:
+  - a clear **Primary Recommended Pathway** (including *home care likely reasonable* when safe),
+  - simple **home-care steps**,
+  - when to see **pharmacist/clinic/Telehealth**,
+  - when it’s **ER/911**,
+  - local & official resource pointers,
+  - a strong disclaimer.
 """
 )
 
 if not OPENAI_API_KEY:
     st.stop()
 
-# 1) Postal code
+# 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 Canada-wide guidance.",
+    "Canadian postal code (e.g., M5V 2T6). Leave blank for general guidance.",
     max_chars=7,
 )
 
-# 2) Image upload
+# Image upload
 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:
@@ -606,7 +645,7 @@ if image_file is not None:
         st.warning(f"Could not read that image: {e}")
         image_bytes = None
 
-# 3) Audio upload
+# Audio upload
 st.markdown("### 3. Add a voice note (optional)")
 audio_file = st.file_uploader(
     "Upload a short voice note (wav/mp3/m4a).",
@@ -614,7 +653,7 @@ audio_file = st.file_uploader(
     accept_multiple_files=False,
 )
 
-# 4) Text description
+# Text description
 st.markdown("### 4. Or type a short description")
 user_text = st.text_area(
     "Describe what's going on:",
@@ -622,29 +661,63 @@ user_text = st.text_area(
     height=120,
 )
 
-# Run agent
+# Run
 if st.button("Run CareCall Agent"):
-    with st.spinner("Running vision + voice + tools + agentic reasoning..."):
+    with st.spinner("Analyzing inputs and generating guidance..."):
 
         # Vision summary
         vision_summary = call_vision_summarizer(image_bytes) if image_bytes else ""
 
-        # Transcription
+        # Voice transcription
         voice_text = call_asr(audio_file) if audio_file is not None else ""
 
-        # Combine narrative text for tools
-        narrative_parts = []
+        # Combined narrative
+        parts = []
         if user_text.strip():
-            narrative_parts.append("Typed: " + user_text.strip())
+            parts.append("Typed: " + user_text.strip())
         if voice_text.strip():
-            narrative_parts.append("Voice (transcribed): " + voice_text.strip())
-        narrative = "\n".join(narrative_parts)
+            parts.append("Voice (transcribed): " + voice_text.strip())
+        narrative = "\n".join(parts)
+
+        # Tool contexts
+        combined_for_drugs = " ".join(x for x in [narrative, vision_summary] if x)
+        dpd_context = (
+            tool_lookup_drug_products(combined_for_drugs)
+            if combined_for_drugs else "No medication context."
+        )
+
+        recalls_context = tool_get_recent_recalls_snippet()
+        wait_awareness_context = tool_get_wait_times_awareness()
+
+        region_context = (
+            tool_region_context(postal_code)
+            if postal_code
+            else "No postal code provided. Use Canada-wide guidance and mention provincial resources."
+        )
+
+        nearby_osm_context = (
+            tool_find_nearby_clinics_osm(postal_code)
+            if postal_code
+            else "No postal code. Suggest using maps and provincial clinic/ER finder tools."
+        )
+
+        google_search_context = (
+            tool_search_wait_times_google(postal_code)
+            if postal_code
+            else "Postal code missing; Google Custom Search not used."
+        )
 
-        response = run_agent(
+        final_answer = call_reasoning_agent(
             narrative=narrative,
             vision_summary=vision_summary,
             postal_code=postal_code or "",
+            dpd_context=dpd_context,
+            recalls_context=recalls_context,
+            wait_awareness_context=wait_awareness_context,
+            region_context=region_context,
+            nearby_osm_context=nearby_osm_context,
+            google_search_context=google_search_context,
         )
 
     st.markdown("### CareCall AI Summary (Informational Only)")
-    st.write(response)
+    st.write(final_answer)