Update app.py

app.py

@@ -1,274 +1,542 @@
-import os, io, base64, json, time, random
-from typing import Optional, Dict, Any, List, Tuple
-from urllib.parse import quote_plus
-
-from fastapi import FastAPI, Request, BackgroundTasks
-from fastapi.responses import PlainTextResponse
-import httpx
-from bs4 import BeautifulSoup
+import os
+import io
+import base64
+import textwrap
+import requests
+import streamlit as st
 from PIL import Image
+from openai import OpenAI
 
-from twilio.rest import Client as TwilioClient
+# =========================
+# CONFIG
+# =========================
 
-# OpenAI
-from openai import OpenAI
-oai_client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-
-# LangChain minimal (structured output)
-from langchain_openai import ChatOpenAI
-from langchain_core.pydantic_v1 import BaseModel, Field
-from langchain_core.prompts import ChatPromptTemplate
-
-# Search tools
-from duckduckgo_search import DDGS
-try:
-    from tavily import TavilyClient
-    _HAS_TAVILY = True
-except Exception:
-    _HAS_TAVILY = False
-
-app = FastAPI(title="SAVE SMS Webhook (Async Reply)")
-
-# ---------- Twilio client ----------
-TW_SID = os.getenv("TWILIO_ACCOUNT_SID", "")
-TW_TOKEN = os.getenv("TWILIO_AUTH_TOKEN", "")
-TW_FROM = os.getenv("TWILIO_FROM", "")  # e.g., +12175898085
-_twilio_ok = bool(TW_SID and TW_TOKEN and TW_FROM)
-twilio_client = TwilioClient(TW_SID, TW_TOKEN) if _twilio_ok else None
-
-# ---------- shared helpers ----------
-lc_llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
-
-MERCHANT_DOMAINS = (
-    "walmart.ca","realcanadiansuperstore.ca","amazon.ca","metro.ca",
-    "nofrills.ca","freshco.com","well.ca","costco.ca","iga.net","londondrugs.com"
+st.set_page_config(
+    page_title="CareCall AI (Canada) - Agentic Health Info",
+    page_icon="🩺",
+    layout="centered"
 )
 
-class Offer(BaseModel):
-    merchant: str = Field(...)
-    title: str = Field(...)
-    price: float = Field(...)
-    url: str = Field(...)
-
-extract_prompt = ChatPromptTemplate.from_messages([
-    ("system","Extract one best CAD offer for the queried item from the page text. "
-              "Return JSON: merchant,title,price(float),url. If none, return empty with price 0."),
-    ("human","Query: {query}\nURL: {url}\n--- PAGE TEXT ---\n{text}\n--- END ---")
-])
-chain_extract = extract_prompt | lc_llm.with_structured_output(Offer)
-
-def img_or_pdf_to_image_bytes(data: bytes, filename: str) -> bytes:
-    name = (filename or "").lower()
-    if name.endswith((".jpg",".jpeg",".png",".webp")):
-        img = Image.open(io.BytesIO(data)).convert("RGB")
-        buf = io.BytesIO(); img.save(buf, format="JPEG", quality=90); return buf.getvalue()
-    if name.endswith(".pdf"):
-        try:
-            img = Image.open(io.BytesIO(data)).convert("RGB")
-            buf = io.BytesIO(); img.save(buf, format="JPEG", quality=90); return buf.getvalue()
-        except Exception:
-            return data
-    return data
-
-def b64_data_uri(data: bytes, mime: str) -> str:
-    return f"data:{mime};base64," + base64.b64encode(data).decode("utf-8")
-
-def call_openai_vision_for_receipt(image_bytes: bytes) -> Dict[str, Any]:
-    is_pdf = image_bytes[0:4] == b"%PDF"
-    mime = "application/pdf" if is_pdf else "image/jpeg"
-    system = ("You are a strict, no-chitchat receipt parser for Canadian grocery receipts. "
-              "Return ONLY JSON; prices in CAD.")
-    user_prompt = """
-{ "store":{"name":"string","address":"string|null","date":"YYYY-MM-DD|null"},
-  "items":[{"name":"string","size":"string|null","qty":1,"unit_price":0.00,"line_total":0.00}],
-  "subtotal":0.00,"tax":0.00,"total":0.00 }
-Rules: shopper-friendly names; qty>=1; unit_price before tax; line_total=qty*unit_price; use null if missing.
-Return ONLY JSON.
-"""
-    resp = oai_client.chat.completions.create(
-        model="gpt-4o-mini", temperature=0,
-        messages=[{"role":"system","content":system},
-                  {"role":"user","content":[
-                      {"type":"text","text":user_prompt},
-                      {"type":"image_url","image_url":{"url":b64_data_uri(image_bytes,mime)}}
-                  ]}]
-    )
-    s = resp.choices[0].message.content.strip()
-    if s.startswith("```"):
-        s = s.split("```",2)[1]
-        if s.lower().startswith("json"): s = s.split("\n",1)[1]
-    return json.loads(s)
-
-def _fallback_store_search_urls(q: str, k: int = 5) -> List[str]:
-    qenc = quote_plus(q)
-    urls = [
-        f"https://www.walmart.ca/search?q={qenc}",
-        f"https://www.realcanadiansuperstore.ca/search?search-bar={qenc}",
-        f"https://www.amazon.ca/s?k={qenc}",
-        f"https://www.metro.ca/en/online-grocery/search?filter.query={qenc}",
-        f"https://www.nofrills.ca/search?search-bar={qenc}",
-        f"https://www.freshco.com/en/search?search-bar={qenc}",
-        f"https://well.ca/searchresult.html?keyword={qenc}",
-        f"https://www.costco.ca/CatalogSearch?dept=All&keyword={qenc}",
-        f"https://www.iga.net/en/search?search={qenc}",
-        f"https://www.londondrugs.com/search?searchTerm={qenc}",
-    ]
-    return urls[:k]
-
-def _search_web(query: str, k: int = 5) -> List[str]:
-    urls: List[str] = []
-    if _HAS_TAVILY and os.getenv("TAVILY_API_KEY"):
-        try:
-            tv = TavilyClient(os.getenv("TAVILY_API_KEY"))
-            res = tv.search(query=f"{query} price", search_depth="basic", max_results=k,
-                            include_domains=list(MERCHANT_DOMAINS))
-            for r in res.get("results", []):
-                if r.get("url"): urls.append(r["url"])
-        except Exception: pass
-    if not urls:
-        try:
-            with DDGS() as ddgs:
-                q = f"{query} price"
-                for attempt in range(3):
-                    for r in ddgs.text(q, region="ca-en", max_results=k):
-                        u = r.get("href") or r.get("url")
-                        if u: urls.append(u)
-                    if urls: break
-                    time.sleep(0.6*(2**attempt)+random.random()*0.3)
-        except Exception: urls=[]
-    urls = [u for u in urls if any(dom in u for dom in MERCHANT_DOMAINS)]
-    if not urls: urls = _fallback_store_search_urls(query, k=k)
-    seen, out = set(), []
-    for u in urls:
-        if u not in seen: out.append(u); seen.add(u)
-    return out[:k]
-
-def _fetch_text(url: str, timeout=15) -> str:
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+if not OPENAI_API_KEY:
+    st.error("Missing OPENAI_API_KEY. Please set it in your Space secrets.")
+client = OpenAI(api_key=OPENAI_API_KEY) if OPENAI_API_KEY else None
+
+# Models
+VISION_MODEL = "gpt-4.1-mini"     # vision-capable
+REASONING_MODEL = "gpt-4.1-mini"  # reasoning / agent
+ASR_MODEL = "whisper-1"           # transcription
+
+# Health Canada Drug Product Database API (public)
+DPD_BASE_URL = "https://health-products.canada.ca/api/drug/drugproduct"
+
+# Recalls & Safety Alerts JSON feed (configurable; keep overridable)
+RECALLS_FEED_URL = os.getenv(
+    "RECALLS_FEED_URL",
+    "https://recalls-rappels.canada.ca/static-data/items-en.json"
+)
+
+# CIHI wait-times info (general reference, 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)
+POSTAL_PREFIX_TO_PROVINCE = {
+    "A": "Newfoundland and Labrador",
+    "B": "Nova Scotia",
+    "C": "Prince Edward Island",
+    "E": "New Brunswick",
+    "G": "Quebec",
+    "H": "Quebec",
+    "J": "Quebec",
+    "K": "Ontario",
+    "L": "Ontario",
+    "M": "Ontario",
+    "N": "Ontario",
+    "P": "Ontario",
+    "R": "Manitoba",
+    "S": "Saskatchewan",
+    "T": "Alberta",
+    "V": "British Columbia",
+    "X": "Northwest Territories / Nunavut",
+    "Y": "Yukon"
+}
+
+
+# =========================
+# HELPERS
+# =========================
+
+def safe_get_json(url, params=None, timeout=6):
     try:
-        headers = {"User-Agent":"Mozilla/5.0 (compatible; PriceAgent/1.0)"}
-        with httpx.Client(follow_redirects=True, timeout=timeout) as client:
-            r = client.get(url, headers=headers)
-        soup = BeautifulSoup(r.text,"html.parser")
-        for t in soup(["script","style","noscript"]): t.decompose()
-        return " ".join(soup.get_text(separator=" ").split())[:12000]
-    except Exception: return ""
-
-def langchain_price_lookup(item_name: str) -> Optional[Dict[str, Any]]:
-    urls = _search_web(item_name, k=5)
-    best: Optional[Offer] = None
-    for u in urls:
-        text = _fetch_text(u)
-        if not text: continue
-        try:
-            offer: Offer = chain_extract.invoke({"query": item_name, "url": u, "text": text})
-        except Exception:
+        resp = requests.get(url, params=params, timeout=timeout)
+        if resp.ok:
+            return resp.json()
+    except Exception:
+        return None
+    return None
+
+
+def shorten(text, max_chars=400):
+    if not text:
+        return ""
+    text = text.strip()
+    if len(text) <= max_chars:
+        return text
+    return text[: max_chars - 3].rstrip() + "..."
+
+
+# =========================
+# REGION CONTEXT (POSTAL CODE)
+# =========================
+
+def infer_province_from_postal(postal_code: str):
+    """
+    Very simple FSA-based province inference using the first character.
+    """
+    if not postal_code:
+        return None
+    pc = postal_code.strip().upper().replace(" ", "")
+    if not pc:
+        return None
+    first = pc[0]
+    return POSTAL_PREFIX_TO_PROVINCE.get(first)
+
+
+def tool_region_context(postal_code: str) -> str:
+    """
+    Build region-aware context for the agent:
+    - Province guess (if possible)
+    - Telehealth-style guidance
+    - Where to check local wait times / services
+    """
+    province = infer_province_from_postal(postal_code)
+    if not postal_code:
+        base = "No postal code provided. Provide general Canada-wide guidance."
+        return base
+
+    if not province:
+        return (
+            f"Postal code '{postal_code}' could not be confidently mapped. "
+            "Provide generic Canada-wide guidance and suggest checking local provincial health websites."
+        )
+
+    # Generic, safe phrasing without hard-coding all numbers:
+    telehealth_note = (
+        f"In {province}, guide the user to their official provincial Telehealth or 811-style nurse advice line "
+        "and ministry of health website for region-specific instructions."
+    )
+
+    wait_note = (
+        "Advise the user that approximate wait-time and access information may be available via their "
+        "provincial or regional health authority website, and through CIHI's access and wait-times resources. "
+        f"Reference (non-exclusively): {WAIT_TIMES_INFO_URL}"
+    )
+
+    return (
+        f"User-provided postal code: '{postal_code}' mapped to: {province}.\n"
+        f"{telehealth_note}\n"
+        f"{wait_note}"
+    )
+
+
+# =========================
+# TOOL: DRUG PRODUCT LOOKUP (DPD)
+# =========================
+
+def tool_lookup_drug_products(candidates):
+    if not candidates:
+        return "No clear medication names detected that require a drug database lookup."
+
+    found_lines = []
+    for name in candidates[:5]:
+        params = {
+            "lang": "en",
+            "type": "json",
+            "brandname": name
+        }
+        data = safe_get_json(DPD_BASE_URL, params=params)
+        if not data:
             continue
-        if not offer or not offer.price or offer.price <= 0: continue
-        if best is None or offer.price < best.price: best = offer
-    if not best: return None
-    return {"title": best.title or item_name, "price": float(best.price),
-            "source": best.merchant or "Other store", "link": best.url or urls[0]}
-
-def normalize_query(item: Dict[str, Any]) -> str:
-    base = item.get("name") or ""; size = item.get("size") or ""
-    q = f"{base} {size}".strip()
-    return " ".join([t for t in q.split() if len(t) > 1])
-
-def research_prices(items: List[Dict[str, Any]], max_items=6) -> List[Dict[str, Any]]:
-    out=[]
-    for it in items[:max_items]:
-        name = normalize_query(it)
-        if not name: continue
-        unit = it.get("unit_price")
-        offer = langchain_price_lookup(name)
-        if not offer: continue
-        cheaper = isinstance(unit,(int,float)) and offer["price"] < float(unit)-0.005
-        out.append({"item_name":it.get("name"),"receipt_unit_price":unit,
-                    "found_price":offer["price"],"found_store":offer["source"],
-                    "found_title":offer["title"],"found_link":offer["link"],
-                    "is_cheaper":cheaper})
-        time.sleep(0.25)
-    return out
-
-def compute_savings(receipt: Dict[str, Any], found: List[Dict[str, Any]]) -> Tuple[float,List[Dict[str, Any]]]:
-    cheaper=[f for f in found if f.get("is_cheaper")]
-    s=0.0
-    for f in cheaper:
-        try: s += float(f["receipt_unit_price"]) - float(f["found_price"])
-        except Exception: pass
-    return round(s,2), cheaper
-
-def format_five_lines(receipt: Dict[str, Any], savings: float, cheaper_list: List[Dict[str, Any]]) -> str:
-    store = (receipt.get("store") or {}).get("name") or "your store"
-    total_val = receipt.get("total") or receipt.get("subtotal")
-    total_txt = "N/A"
-    try: total_txt = f"${float(str(total_val).replace('$','').strip()):.2f}"
-    except Exception: pass
-    lines = [
-        f"Receipt read: {store}, total {total_txt}.",
-        f"I found potential savings of ${savings:.2f} by checking other stores.",
-    ]
-    if cheaper_list:
-        bullets=[]
-        for f in cheaper_list[:3]:
-            item=f.get("item_name") or "Item"; shop=f.get("found_store") or "other store"
-            price=float(f.get("found_price") or 0.0)
-            bullets.append(f"{item} @ {shop} for ${price:.2f}")
-        lines.append("Cheaper picks: " + "; ".join(bullets) + ".")
-    else:
-        lines.append("No clearly cheaper matches found right now for your items.")
-    lines.append("Reply 'DEALS' anytime to get weekly picks tailored to your receipts.")
-    return "\n".join(lines[:5])
-
-# ---------- background job ----------
-def process_and_reply(media_url: str, to_number: str):
-    if not _twilio_ok:
-        return
+
+        unique_brands = 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:
+            found_lines.append(
+                f"- Found Health Canada Drug Product Database entries related to '{name}' "
+                f"(examples: {', '.join(sorted(unique_brands))})."
+            )
+
+    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."
+        )
+
+    found_lines.append(
+        "For definitive product information, ingredients, status, and monographs, "
+        "users must consult the official Health Canada Drug Product Database."
+    )
+    return "\n".join(found_lines)
+
+
+# =========================
+# TOOL: RECALLS & SAFETY ALERTS
+# =========================
+
+def tool_get_recent_recalls_snippet():
+    data = safe_get_json(RECALLS_FEED_URL)
+    if not data or not isinstance(data, list):
+        return (
+            "Unable to fetch recent recalls. Direct users to the official Government of Canada "
+            "Recalls and Safety Alerts website for up-to-date information."
+        )
+
+    items = data[:5]
+    lines = ["Recent recalls and safety alerts (high-level snapshot):"]
+    for item in items:
+        title = (
+            item.get("title")
+            or item.get("english_title")
+            or "Recall / Alert"
+        )
+        date = item.get("date_published") or item.get("date") or ""
+        category = item.get("category") or item.get("type") or ""
+        lines.append(f"- {shorten(title, 90)} ({category}, {date})")
+    lines.append(
+        "For full details or to check a specific product, direct users to the official Recalls and Safety Alerts portal."
+    )
+    return "\n".join(lines)
+
+
+# =========================
+# TOOL: WAIT TIMES AWARENESS (GENERIC)
+# =========================
+
+def tool_get_wait_times_awareness():
+    return textwrap.dedent(f"""
+    Use open Canadian data conceptually:
+    - CIHI and several provinces publish indicators and dashboards for emergency room, surgery, and diagnostic wait times.
+    - These are averages and not real-time triage.
+    Guidance:
+    - For non-urgent issues: consider checking local clinic or urgent care centre information online.
+    - For urgent symptoms: do not spend time checking wait-time tools; go to the nearest ER or call 911.
+    Reference (general): {WAIT_TIMES_INFO_URL}
+    """).strip()
+
+
+# =========================
+# TOOL: CANDIDATE 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: VISION, ASR, AGENT
+# =========================
+
+def call_vision_summarizer(image_bytes: bytes) -> str:
+    if not client or not image_bytes:
+        return ""
+
+    b64 = base64.b64encode(image_bytes).decode("utf-8")
+    prompt = (
+        "You are a cautious Canadian health-information assistant.\n"
+        "Look at the image and ONLY describe observable details in neutral terms.\n"
+        "- If it's a skin issue: describe general appearance (location/size/colour/pattern). Do NOT name diseases.\n"
+        "- If it's a pill bottle or box: note visible drug name/strength/marks if legible.\n"
+        "- If it's a health letter/report: state the type (e.g., appointment letter, lab report) without exposing identifiers.\n"
+        "- If it's irrelevant or unclear: say it is not medically interpretable.\n"
+        "Never diagnose. Never prescribe. Keep within ~80-100 words."
+    )
+
     try:
-        with httpx.Client(follow_redirects=True, timeout=20) as client:
-            r = client.get(media_url); r.raise_for_status()
-            content = r.content
-        img_bytes = img_or_pdf_to_image_bytes(content, "mms.jpg")
-        receipt = call_openai_vision_for_receipt(img_bytes)
-        items = receipt.get("items") or []
-        if not items:
-            msg = "I couldn't read items. Send a clearer photo."
-        else:
-            found = research_prices(items)
-            savings, cheaper = compute_savings(receipt, found)
-            msg = format_five_lines(receipt, savings, cheaper)
-            msg = "\n".join(msg.split("\n")[:5])[:1400]
+        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}"
+                            },
+                        },
+                    ],
+                }
+            ],
+            temperature=0.2,
+        )
+        return resp.choices[0].message.content.strip()
     except Exception as e:
-        msg = f"Processing error: {e}"
+        return f"(Vision analysis unavailable: {e})"
+
+
+def call_asr(audio_file) -> str:
+    if not client or not audio_file:
+        return ""
 
-    # outbound SMS
     try:
-        twilio_client.messages.create(to=to_number, from_=TW_FROM, body=msg)
-    except Exception:
-        pass
-
-# ---------- HTTP routes ----------
-@app.get("/sms")
-async def sms_health():
-    return PlainTextResponse("SMS webhook is up (POST only).", media_type="text/plain")
-
-@app.post("/sms")
-async def sms_webhook(request: Request, background_tasks: BackgroundTasks):
-    form = dict(await request.form())
-    from_number = form.get("From", "")
-    num_media = int(form.get("NumMedia","0") or "0")
-    media_url = form.get("MediaUrl0") if num_media > 0 else None
-
-    # quick acknowledgement to beat 15s timeout
-    if not media_url:
-        ack = "<Response><Message>Please MMS a clear photo of your grocery receipt to analyze savings.</Message></Response>"
-        return PlainTextResponse(ack, media_type="application/xml")
-
-    # run heavy work in background, then send outbound SMS
-    if _twilio_ok and from_number:
-        background_tasks.add_task(process_and_reply, media_url, from_number)
-        reply = "<Response><Message>Got it—processing your receipt now. You’ll get a follow-up text shortly.</Message></Response>"
+        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
+        )
+        text = getattr(transcript, "text", None)
+        if isinstance(text, str):
+            return text.strip()
+        return str(transcript)
+    except Exception as e:
+        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,
+) -> 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, non-diagnostic guidance."
+        )
+
+    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)
+
+    system_prompt = """
+You are CareCall AI, an agentic Canadian health information assistant.
+
+Rules:
+- You DO NOT diagnose.
+- You DO NOT prescribe or give specific dosing.
+- You DO NOT claim exact real-time wait times.
+- You MAY:
+  - Summarize concerns neutrally.
+  - Map them to broad, possible categories (e.g., irritation, infection, allergy, medication question, admin/letter).
+  - Use the provided Drug Database context, Recalls context, wait-time awareness, and region context
+    to make the guidance safer and more relevant.
+  - Suggest next steps:
+      * Self-care for clearly mild issues,
+      * Pharmacist / family doctor / walk-in clinic,
+      * Provincial Telehealth / 811-style nurse line,
+      * ER / 911 if red-flag symptoms are present.
+- Red flags (e.g., chest pain, difficulty breathing, signs of stroke, heavy bleeding, suicidal thoughts,
+  severe abdominal pain, high fever with stiff neck, major trauma, rapidly worsening symptoms)
+  -> clearly recommend ER/911.
+- Always mention that official sources include:
+  Health Canada, Public Health Agency of Canada, CIHI, and the user's provincial health services.
+- Max 350 words. Clear, calm, practical.
+"""
+
+    user_prompt = f"""
+INPUT TO THE AGENT
+
+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}
+
+6) Region (postal-code-based) context:
+{region_context}
+
+TASK
+
+Using ONLY the above information:
+
+1. Briefly summarize what the user seems worried about (neutral; no diagnosis).
+2. Describe, in broad terms, what categories of issues it could relate to, without asserting a specific disease.
+3. Provide clear next-step options in bullet form, aligned with Canadian context and (if available) their province:
+   - When self-care might be reasonable.
+   - When to talk to a pharmacist, family doctor, or walk-in clinic.
+   - When to call their provincial Telehealth / nurse line.
+   - When to bypass everything and go to ER / call 911.
+4. If any medication/recall hints appear, remind them to confirm via Health Canada resources and follow professional advice.
+5. End with a concise disclaimer that this is informational only and not medical care.
+"""
+
+    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."
+        )
+
+
+# =========================
+# STREAMLIT UI
+# =========================
+
+st.title("CareCall AI (Canada)")
+st.caption("Agentic, vision + voice + postal-aware health info companion. Not a doctor. Not a diagnosis.")
+
+st.markdown(
+    """
+This demo:
+- Accepts a photo (rash, pill label, letter, etc.).
+- Accepts a voice note and/or typed description.
+- Optionally uses your **postal code** to tailor guidance to your province.
+- Uses:
+  - OpenAI vision (for safe visual summary),
+  - Whisper (for transcription),
+  - Canadian open-data style tools (Drug Product Database, recalls, wait-time context),
+  - A reasoning agent with strict safety rules.
+"""
+)
+
+# Postal code
+st.markdown("### 1. Postal code (optional, Canada only)")
+postal_code = st.text_input(
+    "Enter your Canadian postal code (e.g., M5V 2T6). Leave blank if you prefer not to share.",
+    max_chars=7
+)
+
+# Image upload
+st.markdown("### 2. Upload an image (optional)")
+image_file = st.file_uploader(
+    "Upload a photo (JPG/PNG). Avoid sharing highly identifying or explicit content.",
+    type=["jpg", "jpeg", "png"],
+    accept_multiple_files=False,
+)
+
+image_bytes = None
+if image_file is not None:
+    try:
+        img = Image.open(image_file)
+        st.image(img, caption="Image received", use_column_width=True)
+        buf = io.BytesIO()
+        img.save(buf, format="JPEG")
+        image_bytes = buf.getvalue()
+    except Exception as e:
+        st.warning(f"Could not read that image: {e}")
+        image_bytes = None
+
+# Audio upload
+st.markdown("### 3. Add a voice note (optional)")
+audio_file = st.file_uploader(
+    "Upload a short voice note (wav/mp3/m4a).",
+    type=["wav", "mp3", "m4a"],
+    accept_multiple_files=False,
+)
+
+# Text description
+user_text = st.text_area(
+    "Or type a short description:",
+    placeholder='Example: "Red itchy patch on forearm for 3 days, mild burning, no fever, using a new soap."',
+    height=120,
+)
+
+# Run agent
+if st.button("Run CareCall Agent"):
+    if not client:
+        st.error("OPENAI_API_KEY is not set. Configure it in your Space settings.")
     else:
-        reply = "<Response><Message>Got the image—backend SMS sending is misconfigured. Set TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_FROM.</Message></Response>"
+        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)
+
+            # Candidates for DPD lookup
+            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()
 
-    return PlainTextResponse(reply, media_type="application/xml")
+            # Wait-time awareness
+            wait_times_context = tool_get_wait_times_awareness()
+
+            # Region context from postal
+            region_context = tool_region_context(postal_code) if postal_code else (
+                "No postal code provided. Use Canada-wide guidance and suggest provincial resources."
+            )
+
+            # 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,
+            )
+
+        st.markdown("### CareCall AI Summary (Informational Only)")
+        st.write(final_answer)
+
+        st.markdown(
+            """
+---
+Critical Safety Notice
+
+- This tool does not provide medical diagnoses, prescriptions, or emergency triage.
+- It may be incomplete or incorrect and must not replace a doctor, nurse, pharmacist,
+  Telehealth service, or emergency care.
+- If you have severe or worsening symptoms (such as chest pain, difficulty breathing,
+  signs of stroke, heavy bleeding, suicidal thoughts, major injury, high fever with stiff neck),
+  call 911 or go to the nearest emergency department immediately.
+- For dependable information, consult:
+  Health Canada, the Public Health Agency of Canada, CIHI, and your provincial/territorial health services.
+"""
+        )