Added the nurse agent

examples/voice_agent_webrtc_langgraph/agents/healthcare-agent/README.md

@@ -0,0 +1,51 @@
+# Healthcare Telehealth Nurse Agent
+
+This agent is a 24/7 AI voice nurse for existing patients. It authenticates callers, retrieves mock patient profiles (medications, allergies, recent visits), recognizes common symptoms, performs contextual triage using decision rules, offers self‑care guidance, escalates urgent cases, and books appointments. All interactions aim to be clear, compassionate, and brief.
+
+## What it does
+
+- Authenticate the caller (name + DOB + MRN last‑4 or secret answer)
+- Look up patient profile, allergies, medications, recent visits, preferred pharmacy
+- Recognize symptoms (e.g., "I have a headache") and identify red flags
+- Risk stratify and triage (self‑care, soon, urgent) using rules in `mock_data/triage_rules.json`
+- Provide tailored advice based on symptoms and medication history
+- Escalate urgent cases with clear instructions
+- Offer scheduling with available providers from `mock_data/providers.json`
+- Confirm preferred pharmacy for prescriptions if needed
+
+## How to use (typical flow)
+
+1. Start by stating your name.
+2. Verify identity: provide DOB and either MRN last‑4 or your secret answer. If a secret question is returned, answer it.
+3. Describe your symptoms in your own words.
+4. The agent will ask brief, focused follow‑ups (one question at a time), provide guidance, and book if needed.
+
+## Example conversation
+
+- Agent: Welcome back to our clinic. I’m your nurse assistant. May I have your full name?
+- You: John Marshall.
+- Agent: Thanks, John. Please confirm your date of birth and either your MRN last‑4 or answer to your secret question.
+- You: January 1st, 1960. MRN last‑4 is 0001.
+- Agent: Thank you. You’re verified. What’s going on today?
+- You: I have a headache and feel really fatigued.
+- Agent: I’m sorry you’re feeling that way. Any red flag symptoms like worst headache of your life, head injury, stiff neck, weakness, vision changes, seizure, or fever over 102°F?
+- You: No, none of those.
+- Agent: Thanks for checking. You’re on acetaminophen as needed and have a penicillin allergy. Since symptoms are mild with no red flags, try hydration, rest, and acetaminophen as directed. Would you like a telehealth appointment in the next day or two?
+- You: Yes, please.
+- Agent: I can book with Alex Chang, NP. Next openings are today at 8:00 pm, or tomorrow at 8:30 am or 4:00 pm. Which do you prefer?
+- You: Tomorrow at 8:30 am.
+- Agent: Booked. I’ll send details to your phone ending in 0101. Should we keep the pharmacy at 1010 El Camino Real, Santa Clara for any prescriptions?
+- You: Yes, that’s fine.
+- Agent: Great. I’ve logged your symptoms, advice provided, and appointment. If anything worsens—especially fever over 102°F, neck stiffness, confusion, weakness, vision loss, or severe headache—seek urgent care or call emergency services.
+
+## Mock data
+
+- Patients: `mock_data/patients.json`
+- Providers: `mock_data/providers.json`
+- Pharmacies: `mock_data/pharmacies.json`
+- Triage rules: `mock_data/triage_rules.json`
+
+## Notes
+
+- The agent prioritizes empathy and brevity. It asks one question at a time and avoids medical jargon.
+- All data are mock fixtures for demo purposes only and are not real medical records.

examples/voice_agent_webrtc_langgraph/agents/healthcare-agent/__init__.py

@@ -0,0 +1,9 @@
+"""Wire Transfer Agent (ReAct)
+
+This package contains a LangGraph ReAct-based agent that helps users
+initiate domestic or international wire transfers using mock tools and fixtures.
+"""
+
+from .react_agent import agent  # noqa: F401
+
+

examples/voice_agent_webrtc_langgraph/agents/healthcare-agent/logic.py

@@ -0,0 +1,622 @@
+import os
+import json
+import uuid
+from datetime import datetime
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from langchain_openai import ChatOpenAI
+
+
+_FIXTURE_CACHE: Dict[str, Any] = {}
+_DISPUTES_DB: Dict[str, Dict[str, Any]] = {}
+_SESSIONS: Dict[str, Dict[str, Any]] = {}
+_OTP_DB: Dict[str, Dict[str, Any]] = {}
+_QUOTES: Dict[str, Dict[str, Any]] = {}
+_BENEFICIARIES_DB: Dict[str, List[Dict[str, Any]]] = {}
+
+
+def _fixtures_dir() -> Path:
+    return Path(__file__).parent / "mock_data"
+
+
+def _load_fixture(name: str) -> Any:
+    if name in _FIXTURE_CACHE:
+        return _FIXTURE_CACHE[name]
+    p = _fixtures_dir() / name
+    with p.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+    _FIXTURE_CACHE[name] = data
+    return data
+
+
+def _parse_iso_date(text: Optional[str]) -> Optional[datetime]:
+    if not text:
+        return None
+    try:
+        return datetime.strptime(text, "%Y-%m-%d")
+    except Exception:
+        return None
+
+
+def _get_customer_blob(customer_id: str) -> Dict[str, Any]:
+    data = _load_fixture("accounts.json")
+    return dict(data.get("customers", {}).get(customer_id, {}))
+
+
+def get_accounts(customer_id: str) -> List[Dict[str, Any]]:
+    cust = _get_customer_blob(customer_id)
+    if isinstance(cust, list):
+        # backward-compat: old format was a list of accounts
+        return list(cust)
+    return list(cust.get("accounts", []))
+
+
+def get_profile(customer_id: str) -> Dict[str, Any]:
+    cust = _get_customer_blob(customer_id)
+    if isinstance(cust, dict):
+        return dict(cust.get("profile", {}))
+    return {}
+
+
+def find_customer_by_name(first_name: str, last_name: str) -> Dict[str, Any]:
+    data = _load_fixture("accounts.json")
+    customers = data.get("customers", {})
+    fn = (first_name or "").strip().lower()
+    ln = (last_name or "").strip().lower()
+    for cid, blob in customers.items():
+        prof = blob.get("profile") if isinstance(blob, dict) else None
+        if isinstance(prof, dict):
+            pfn = str(prof.get("first_name") or "").strip().lower()
+            pln = str(prof.get("last_name") or "").strip().lower()
+            if fn == pfn and ln == pln:
+                return {"customer_id": cid, "profile": prof}
+    return {}
+
+
+def find_customer_by_full_name(full_name: str) -> Dict[str, Any]:
+    data = _load_fixture("accounts.json")
+    customers = data.get("customers", {})
+    target = (full_name or "").strip().lower()
+    for cid, blob in customers.items():
+        prof = blob.get("profile") if isinstance(blob, dict) else None
+        if isinstance(prof, dict):
+            fn = f"{str(prof.get('first_name') or '').strip()} {str(prof.get('last_name') or '').strip()}".strip().lower()
+            ff = str(prof.get("full_name") or "").strip().lower()
+            if target and (target == fn or target == ff):
+                return {"customer_id": cid, "profile": prof}
+    return {}
+
+
+def _normalize_dob(text: Optional[str]) -> Optional[str]:
+    if not isinstance(text, str) or not text.strip():
+        return None
+    t = text.strip().lower()
+    # YYYY-MM-DD
+    try:
+        if len(t) >= 10 and t[4] == '-' and t[7] == '-':
+            d = datetime.strptime(t[:10], "%Y-%m-%d")
+            return d.strftime("%Y-%m-%d")
+    except Exception:
+        pass
+    # YYYY MM DD or YYYY/MM/DD or YYYY.MM.DD (loosely)
+    try:
+        import re as _re
+        parts = _re.findall(r"\d+", t)
+        if len(parts) >= 3 and len(parts[0]) == 4:
+            y, m, d = int(parts[0]), int(parts[1]), int(parts[2])
+            if 1900 <= y <= 2100 and 1 <= m <= 12 and 1 <= d <= 31:
+                dt = datetime(y, m, d)
+                return dt.strftime("%Y-%m-%d")
+    except Exception:
+        pass
+    # Month name DD YYYY
+    MONTHS = {
+        "jan": 1, "january": 1, "feb": 2, "february": 2, "mar": 3, "march": 3,
+        "apr": 4, "april": 4, "may": 5, "jun": 6, "june": 6, "jul": 7, "july": 7,
+        "aug": 8, "august": 8, "sep": 9, "sept": 9, "september": 9,
+        "oct": 10, "october": 10, "nov": 11, "november": 11, "dec": 12, "december": 12,
+    }
+    try:
+        parts = t.replace(',', ' ').split()
+        if len(parts) >= 3 and parts[0] in MONTHS:
+            m = MONTHS[parts[0]]
+            day = int(''.join(ch for ch in parts[1] if ch.isdigit()))
+            year = int(parts[2])
+            d = datetime(year, m, day)
+            return d.strftime("%Y-%m-%d")
+    except Exception:
+        pass
+    # DD/MM/YYYY or MM/DD/YYYY
+    try:
+        for sep in ('/', '-'):
+            if sep in t and t.count(sep) == 2:
+                a, b, c = t.split(sep)[:3]
+                if len(c) == 4 and a.isdigit() and b.isdigit() and c.isdigit():
+                    da, db, dy = int(a), int(b), int(c)
+                    # If first looks like month, assume MM/DD
+                    if 1 <= da <= 12 and 1 <= db <= 31:
+                        d = datetime(dy, da, db)
+                    else:
+                        # assume DD/MM
+                        d = datetime(dy, db, da)
+                    return d.strftime("%Y-%m-%d")
+    except Exception:
+        pass
+    return None
+
+
+def _find_account_by_id(account_id: str) -> Optional[Dict[str, Any]]:
+    data = _load_fixture("accounts.json")
+    customers = data.get("customers", {})
+    for _, blob in customers.items():
+        accts = (blob or {}).get("accounts", [])
+        for a in accts or []:
+            if str(a.get("account_id")) == account_id:
+                return a
+    return None
+
+
+def get_account_balance(account_id: str) -> Dict[str, Any]:
+    acc = _find_account_by_id(account_id) or {}
+    return {
+        "account_id": account_id,
+        "currency": acc.get("currency"),
+        "balance": float(acc.get("balance", 0.0)),
+        "daily_wire_limit": float(acc.get("daily_wire_limit", 0.0)),
+        "wire_enabled": bool(acc.get("wire_enabled", False)),
+    }
+
+
+def get_exchange_rate(from_currency: str, to_currency: str, amount: float) -> Dict[str, Any]:
+    if from_currency.upper() == to_currency.upper():
+        return {
+            "from": from_currency.upper(),
+            "to": to_currency.upper(),
+            "mid_rate": 1.0,
+            "applied_rate": 1.0,
+            "margin_bps": 0,
+            "converted_amount": round(float(amount), 2),
+        }
+    data = _load_fixture("exchange_rates.json")
+    pairs = data.get("pairs", [])
+    mid = None
+    bps = 150
+    fc = from_currency.upper()
+    tc = to_currency.upper()
+    for p in pairs:
+        if str(p.get("from")).upper() == fc and str(p.get("to")).upper() == tc:
+            mid = float(p.get("mid_rate"))
+            bps = int(p.get("margin_bps", bps))
+            break
+    if mid is None:
+        # naive inverse lookup
+        for p in pairs:
+            if str(p.get("from")).upper() == tc and str(p.get("to")).upper() == fc:
+                inv = float(p.get("mid_rate"))
+                mid = 1.0 / inv if inv else None
+                bps = int(p.get("margin_bps", bps))
+                break
+    if mid is None:
+        mid = 1.0
+    applied = mid * (1.0 - bps / 10000.0)
+    converted = float(amount) * applied
+    return {
+        "from": fc,
+        "to": tc,
+        "mid_rate": round(mid, 6),
+        "applied_rate": round(applied, 6),
+        "margin_bps": bps,
+        "converted_amount": round(converted, 2),
+    }
+
+
+def calculate_wire_fee(kind: str, amount: float, from_currency: str, to_currency: str, payer: str) -> Dict[str, Any]:
+    fees = _load_fixture("fee_schedules.json")
+    k = (kind or "").strip().upper()
+    payer_opt = (payer or "SHA").strip().upper()
+    if k not in ("DOMESTIC", "INTERNATIONAL"):
+        return {"error": "invalid_type", "message": "type must be DOMESTIC or INTERNATIONAL"}
+    if payer_opt not in ("OUR", "SHA", "BEN"):
+        return {"error": "invalid_payer", "message": "payer must be OUR, SHA, or BEN"}
+    breakdown: Dict[str, float] = {}
+    if k == "DOMESTIC":
+        breakdown["DOMESTIC_BASE"] = float(fees.get("DOMESTIC", {}).get("base_fee", 15.0))
+    else:
+        intl = fees.get("INTERNATIONAL", {})
+        breakdown["INTERNATIONAL_BASE"] = float(intl.get("base_fee", 25.0))
+        breakdown["SWIFT"] = float(intl.get("swift_network_fee", 5.0))
+        breakdown["CORRESPONDENT"] = float(intl.get("correspondent_fee", 10.0))
+        breakdown["LIFTING"] = float(intl.get("lifting_fee", 5.0))
+
+    initiator = 0.0
+    recipient = 0.0
+    for code, fee in breakdown.items():
+        if payer_opt == "OUR":
+            initiator += fee
+        elif payer_opt == "SHA":
+            # Sender pays origin bank fees (base, swift); recipient pays intermediary (correspondent/lifting)
+            if code in ("DOMESTIC_BASE", "INTERNATIONAL_BASE", "SWIFT"):
+                initiator += fee
+            else:
+                recipient += fee
+        elif payer_opt == "BEN":
+            recipient += fee
+    return {
+        "type": k,
+        "payer": payer_opt,
+        "from_currency": from_currency.upper(),
+        "to_currency": to_currency.upper(),
+        "amount": float(amount),
+        "initiator_fees_total": round(initiator, 2),
+        "recipient_fees_total": round(recipient, 2),
+        "breakdown": {k: round(v, 2) for k, v in breakdown.items()},
+    }
+
+
+def screen_sanctions(name: str, country: str) -> Dict[str, Any]:
+    data = _load_fixture("sanctions_list.json")
+    blocked = data.get("blocked", [])
+    nm = (name or "").strip().lower()
+    cc = (country or "").strip().upper()
+    for e in blocked:
+        if str(e.get("name", "")).strip().lower() == nm and str(e.get("country", "")).strip().upper() == cc:
+            return {"cleared": False, "reason": "Sanctions match"}
+    return {"cleared": True}
+
+
+def check_wire_limits(account_id: str, amount: float) -> Dict[str, Any]:
+    acc = _find_account_by_id(account_id) or {}
+    if not acc:
+        return {"ok": False, "reason": "account_not_found"}
+    bal = float(acc.get("balance", 0.0))
+    lim = float(acc.get("daily_wire_limit", 0.0))
+    if not bool(acc.get("wire_enabled", False)):
+        return {"ok": False, "reason": "wire_not_enabled"}
+    if amount > lim:
+        return {"ok": False, "reason": "exceeds_daily_limit", "limit": lim}
+    if amount > bal:
+        return {"ok": False, "reason": "insufficient_funds", "balance": bal}
+    return {"ok": True, "balance": bal, "limit": lim}
+
+
+def get_cutoff_and_eta(kind: str, country: str) -> Dict[str, Any]:
+    cfg = _load_fixture("cutoff_times.json")
+    k = (kind or "").strip().upper()
+    key = "DOMESTIC" if k == "DOMESTIC" else "INTERNATIONAL"
+    info = cfg.get(key, {})
+    return {
+        "cutoff_local": info.get("cutoff_local", "17:00"),
+        "eta_hours": list(info.get("eta_hours", [24, 72])),
+        "country": country
+    }
+
+
+def get_country_requirements(code: str) -> List[str]:
+    data = _load_fixture("country_requirements.json")
+    return list(data.get(code.upper(), []))
+
+
+def validate_beneficiary(country_code: str, beneficiary: Dict[str, Any]) -> Dict[str, Any]:
+    required = get_country_requirements(country_code)
+    missing: List[str] = []
+    for field in required:
+        if not isinstance(beneficiary.get(field), str) or not str(beneficiary.get(field)).strip():
+            missing.append(field)
+    return {"ok": len(missing) == 0, "missing": missing}
+
+
+def save_beneficiary(customer_id: str, beneficiary: Dict[str, Any]) -> Dict[str, Any]:
+    arr = _BENEFICIARIES_DB.setdefault(customer_id, [])
+    bid = beneficiary.get("beneficiary_id") or f"B-{uuid.uuid4().hex[:6]}"
+    entry = dict(beneficiary)
+    entry["beneficiary_id"] = bid
+    arr.append(entry)
+    return {"beneficiary_id": bid}
+
+
+def generate_otp(customer_id: str) -> Dict[str, Any]:
+    # Prefer static OTP from fixture for predictable testing
+    static = None
+    try:
+        data = _load_fixture("otps.json")
+        if isinstance(data, dict):
+            byc = data.get("by_customer", {}) or {}
+            static = byc.get(customer_id) or data.get("default")
+    except Exception:
+        static = None
+    code = str(static or f"{uuid.uuid4().int % 1000000:06d}").zfill(6)
+    _OTP_DB[customer_id] = {"otp": code, "created_at": datetime.utcnow().isoformat() + "Z"}
+    # In real world, send to phone/email; here we mask
+    resp = {"sent": True, "destination": "on-file", "masked": "***-***-****"}
+    try:
+        if os.getenv("WIRE_DEBUG_OTP", "0").lower() not in ("", "0", "false"):  # dev convenience
+            resp["debug_code"] = code
+    except Exception:
+        pass
+    return resp
+
+
+def verify_otp(customer_id: str, otp: str) -> Dict[str, Any]:
+    rec = _OTP_DB.get(customer_id) or {}
+    ok = str(rec.get("otp")) == str(otp)
+    if ok:
+        rec["used_at"] = datetime.utcnow().isoformat() + "Z"
+        _OTP_DB[customer_id] = rec
+    return {"verified": ok}
+
+
+def authenticate_user_wire(session_id: str, customer_id: Optional[str], full_name: Optional[str], dob_yyyy_mm_dd: Optional[str], ssn_last4: Optional[str], secret_answer: Optional[str]) -> Dict[str, Any]:
+    session = _SESSIONS.get(session_id) or {"verified": False, "customer_id": customer_id, "name": full_name}
+    if isinstance(customer_id, str) and customer_id:
+        session["customer_id"] = customer_id
+    if isinstance(full_name, str) and full_name:
+        session["name"] = full_name
+    if isinstance(dob_yyyy_mm_dd, str) and dob_yyyy_mm_dd:
+        session["dob"] = dob_yyyy_mm_dd
+    if isinstance(ssn_last4, str) and ssn_last4:
+        session["ssn_last4"] = ssn_last4
+    if isinstance(secret_answer, str) and secret_answer:
+        session["secret"] = secret_answer
+
+    ok = False
+    cid = session.get("customer_id")
+    if isinstance(cid, str):
+        prof = get_profile(cid)
+        user_dob_norm = _normalize_dob(session.get("dob"))
+        prof_dob_norm = _normalize_dob(prof.get("dob"))
+        dob_ok = (user_dob_norm is not None) and (user_dob_norm == prof_dob_norm)
+        ssn_ok = str(session.get("ssn_last4") or "") == str(prof.get("ssn_last4") or "")
+        def _norm(x: Optional[str]) -> str:
+            return (x or "").strip().lower()
+        secret_ok = _norm(session.get("secret")) == _norm(prof.get("secret_answer"))
+        if dob_ok and (ssn_ok or secret_ok):
+            ok = True
+    session["verified"] = ok
+    _SESSIONS[session_id] = session
+    need: List[str] = []
+    if _normalize_dob(session.get("dob")) is None:
+        need.append("dob")
+    if not session.get("ssn_last4") and not session.get("secret"):
+        need.append("ssn_last4_or_secret")
+    if not session.get("customer_id"):
+        need.append("customer")
+    resp: Dict[str, Any] = {"session_id": session_id, "verified": ok, "needs": need, "profile": {"name": session.get("name")}}
+    try:
+        if isinstance(session.get("customer_id"), str):
+            prof = get_profile(session.get("customer_id"))
+            if isinstance(prof, dict) and prof.get("secret_question"):
+                resp["question"] = prof.get("secret_question")
+    except Exception:
+        pass
+    return resp
+
+
+def quote_wire(kind: str, from_account_id: str, beneficiary: Dict[str, Any], amount: float, from_currency: str, to_currency: str, payer: str) -> Dict[str, Any]:
+    # FX
+    fx = get_exchange_rate(from_currency, to_currency, amount)
+    converted_amount = fx["converted_amount"]
+    # Fees
+    fee = calculate_wire_fee(kind, amount, from_currency, to_currency, payer)
+    # Limits and balance
+    limits = check_wire_limits(from_account_id, amount)
+    if not limits.get("ok"):
+        return {"error": "limit_or_balance", "details": limits}
+    # Sanctions
+    sanc = screen_sanctions(str(beneficiary.get("account_name") or beneficiary.get("name") or ""), str(beneficiary.get("country") or ""))
+    if not sanc.get("cleared"):
+        return {"error": "sanctions", "details": sanc}
+    # ETA
+    eta = get_cutoff_and_eta(kind, str(beneficiary.get("country") or ""))
+
+    payer_opt = (payer or "SHA").upper()
+    initiator_fees = float(fee.get("initiator_fees_total", 0.0))
+    recipient_fees = float(fee.get("recipient_fees_total", 0.0))
+    net_sent = float(amount) + (initiator_fees if payer_opt in ("OUR", "SHA") else 0.0)
+    # recipient side fees reduce the amount received when SHA/BEN
+    net_received = float(converted_amount)
+    if payer_opt in ("SHA", "BEN"):
+        net_received = max(0.0, net_received - recipient_fees)
+
+    qid = f"Q-{uuid.uuid4().hex[:8]}"
+    quote = {
+        "quote_id": qid,
+        "type": kind.upper(),
+        "from_account_id": from_account_id,
+        "amount": float(amount),
+        "from_currency": from_currency.upper(),
+        "to_currency": to_currency.upper(),
+        "payer": payer_opt,
+        "fx": fx,
+        "fees": fee,
+        "net_sent": round(net_sent, 2),
+        "net_received": round(net_received, 2),
+        "eta": eta,
+        "created_at": datetime.utcnow().isoformat() + "Z",
+        "expires_at": (datetime.utcnow().isoformat() + "Z")
+    }
+    _QUOTES[qid] = quote
+    return quote
+
+
+def wire_transfer_domestic(quote_id: str, otp: str) -> Dict[str, Any]:
+    q = _QUOTES.get(quote_id)
+    if not q or q.get("type") != "DOMESTIC":
+        return {"error": "invalid_quote"}
+    # OTP expected: we need customer_id context; skip and assume OTP verified externally
+    conf = f"WD-{uuid.uuid4().hex[:8]}"
+    return {"confirmation_id": conf, "status": "submitted"}
+
+
+def wire_transfer_international(quote_id: str, otp: str) -> Dict[str, Any]:
+    q = _QUOTES.get(quote_id)
+    if not q or q.get("type") != "INTERNATIONAL":
+        return {"error": "invalid_quote"}
+    conf = f"WI-{uuid.uuid4().hex[:8]}"
+    return {"confirmation_id": conf, "status": "submitted"}
+
+
+def list_transactions(account_id: str, start: Optional[str], end: Optional[str]) -> List[Dict[str, Any]]:
+    data = _load_fixture("transactions.json")
+    txns = list(data.get(account_id, []))
+    if start or end:
+        start_dt = _parse_iso_date(start) or datetime.min
+        end_dt = _parse_iso_date(end) or datetime.max
+        out: List[Dict[str, Any]] = []
+        for t in txns:
+            td = _parse_iso_date(t.get("date"))
+            if td and start_dt <= td <= end_dt:
+                out.append(t)
+        return out
+    return txns
+
+
+def get_fee_schedule(product_type: str) -> Dict[str, Any]:
+    data = _load_fixture("fee_schedules.json")
+    return dict(data.get(product_type.upper(), {}))
+
+
+def detect_fees(transactions: List[Dict[str, Any]], schedule: Dict[str, Any]) -> List[Dict[str, Any]]:
+    results: List[Dict[str, Any]] = []
+    for t in transactions:
+        if str(t.get("entry_type")).upper() == "FEE":
+            fee_code = (t.get("fee_code") or "").upper()
+            sched_entry = None
+            for s in schedule.get("fees", []) or []:
+                if str(s.get("code", "")).upper() == fee_code:
+                    sched_entry = s
+                    break
+            evt = {
+                "id": t.get("id") or str(uuid.uuid4()),
+                "posted_date": t.get("date"),
+                "amount": float(t.get("amount", 0)),
+                "description": t.get("description") or fee_code,
+                "fee_code": fee_code,
+                "schedule": sched_entry or None,
+            }
+            results.append(evt)
+    try:
+        results.sort(key=lambda x: x.get("posted_date") or "")
+    except Exception:
+        pass
+    return results
+
+
+def explain_fee(fee_event: Dict[str, Any]) -> str:
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    code = (fee_event.get("fee_code") or "").upper()
+    name = fee_event.get("schedule", {}).get("name") or code.title()
+    posted = fee_event.get("posted_date") or ""
+    amount = float(fee_event.get("amount") or 0)
+    policy = fee_event.get("schedule", {}).get("policy") or ""
+    if not openai_api_key:
+        base = f"You were charged {name} on {posted} for CAD {amount:.2f}."
+        if code == "NSF":
+            return base + " This is applied when a payment is attempted but the account balance was insufficient."
+        if code == "MAINTENANCE":
+            return base + " This is the monthly account fee as per your account plan."
+        if code == "ATM":
+            return base + " This fee applies to certain ATM withdrawals."
+        return base + " This fee was identified based on your recent transactions."
+
+    llm = ChatOpenAI(model=os.getenv("EXPLAIN_MODEL", "gpt-4o"), api_key=openai_api_key)
+    chain = EXPLAIN_FEE_PROMPT | llm
+    out = chain.invoke(
+        {
+            "fee_code": code,
+            "posted_date": posted,
+            "amount": f"{amount:.2f}",
+            "schedule_name": name,
+            "schedule_policy": policy,
+        }
+    )
+    text = getattr(out, "content", None)
+    return text if isinstance(text, str) and text.strip() else f"You were charged {name} on {posted} for CAD {amount:.2f}."
+
+
+def check_dispute_eligibility(fee_event: Dict[str, Any]) -> Dict[str, Any]:
+    code = (fee_event.get("fee_code") or "").upper()
+    amount = float(fee_event.get("amount", 0))
+    first_time = bool(fee_event.get("first_time_90d", False))
+    eligible = False
+    reason = ""
+    if code in {"NSF", "ATM", "MAINTENANCE", "WITHDRAWAL"} and amount <= 20.0 and first_time:
+        eligible = True
+        reason = "First occurrence in 90 days and small amount"
+    return {"eligible": eligible, "reason": reason}
+
+
+def create_dispute_case(fee_event: Dict[str, Any], idempotency_key: str) -> Dict[str, Any]:
+    if idempotency_key in _DISPUTES_DB:
+        return _DISPUTES_DB[idempotency_key]
+    case = {
+        "case_id": str(uuid.uuid4()),
+        "status": "submitted",
+        "fee_id": fee_event.get("id"),
+        "created_at": datetime.utcnow().isoformat() + "Z",
+    }
+    _DISPUTES_DB[idempotency_key] = case
+    return case
+
+
+def authenticate_user(session_id: str, name: Optional[str], dob_yyyy_mm_dd: Optional[str], last4: Optional[str], secret_answer: Optional[str], customer_id: Optional[str] = None) -> Dict[str, Any]:
+    """Mock identity verification.
+
+    Rules (mock):
+    - If dob == 1990-01-01 and last4 == 6001 or secret_answer == "blue", auth succeeds.
+    - Otherwise, remains pending with which fields are still missing.
+    Persists per session_id.
+    """
+    session = _SESSIONS.get(session_id) or {"verified": False, "name": name, "customer_id": customer_id}
+    if isinstance(name, str) and name:
+        session["name"] = name
+    if isinstance(customer_id, str) and customer_id:
+        session["customer_id"] = customer_id
+    if isinstance(dob_yyyy_mm_dd, str) and dob_yyyy_mm_dd:
+        # Normalize DOB to YYYY-MM-DD
+        norm = _normalize_dob(dob_yyyy_mm_dd)
+        session["dob"] = norm or dob_yyyy_mm_dd
+    if isinstance(last4, str) and last4:
+        session["last4"] = last4
+    if isinstance(secret_answer, str) and secret_answer:
+        session["secret"] = secret_answer
+
+    ok = False
+    # If a specific customer is in context, validate against their profile and accounts
+    if isinstance(session.get("customer_id"), str):
+        prof = get_profile(session.get("customer_id"))
+        accts = get_accounts(session.get("customer_id"))
+        dob_ok = _normalize_dob(session.get("dob")) == _normalize_dob(prof.get("dob")) and bool(session.get("dob"))
+        last4s = {str(a.get("account_number"))[-4:] for a in accts if a.get("account_number")}
+        last4_ok = isinstance(session.get("last4"), str) and session.get("last4") in last4s
+        def _norm_secret(x: Optional[str]) -> str:
+            return (x or "").strip().lower()
+        secret_ok = _norm_secret(session.get("secret")) == _norm_secret(prof.get("secret_answer"))
+        if dob_ok and (last4_ok or secret_ok):
+            ok = True
+    else:
+        # Optional demo fallback (disabled by default)
+        allow_fallback = os.getenv("RBC_FEES_ALLOW_GLOBAL_FALLBACK", "0") not in ("", "0", "false", "False")
+        if allow_fallback and session.get("dob") == "1990-01-01" and (session.get("last4") == "6001" or (session.get("secret") or "").strip().lower() == "blue"):
+            ok = True
+    session["verified"] = ok
+    _SESSIONS[session_id] = session
+    need: list[str] = []
+    if not session.get("dob"):
+        need.append("dob")
+    if not session.get("last4") and not session.get("secret"):
+        need.append("last4_or_secret")
+    if not session.get("customer_id"):
+        need.append("customer")
+    resp: Dict[str, Any] = {"session_id": session_id, "verified": ok, "needs": need, "profile": {"name": session.get("name")}}
+    try:
+        if isinstance(session.get("customer_id"), str):
+            prof = get_profile(session.get("customer_id"))
+            if isinstance(prof, dict) and prof.get("secret_question"):
+                resp["question"] = prof.get("secret_question")
+    except Exception:
+        pass
+    return resp
+
+

examples/voice_agent_webrtc_langgraph/agents/healthcare-agent/mock_data/patients.json

@@ -0,0 +1,110 @@
+{
+  "patients": {
+    "pt_jmarshall": {
+      "profile": {
+        "patient_id": "pt_jmarshall",
+        "first_name": "John",
+        "last_name": "Marshall",
+        "full_name": "John Marshall",
+        "dob": "1960-01-01",
+        "mrn": "JM-1960-0001",
+        "mrn_last4": "0001",
+        "secret_question": "What is your favorite color?",
+        "secret_answer": "blue",
+        "phone": "+1-555-0101",
+        "email": "john.marshall@example.com",
+        "address": {
+          "line1": "12 Park Ave",
+          "city": "Santa Clara",
+          "state": "CA",
+          "zip": "95050"
+        },
+        "preferred_pharmacy_id": "ph_sc_1010"
+      },
+      "allergies": [
+        "Penicillin"
+      ],
+      "medications": [
+        {
+          "name": "Acetaminophen",
+          "sig": "500 mg, every 6 hours as needed for pain",
+          "rxnorm": "161",
+          "otc": true
+        }
+      ],
+      "conditions": [
+        "Hypertension"
+      ],
+      "recent_visits": [
+        {
+          "date": "2025-08-15",
+          "type": "Primary Care",
+          "reason": "Annual wellness visit",
+          "outcome": "Continue current meds"
+        }
+      ],
+      "vitals": {
+        "last": {
+          "date": "2025-08-15",
+          "bp": "128/78",
+          "hr": 72,
+          "temp_f": 98.4,
+          "bmi": 26.1
+        }
+      }
+    },
+    "pt_fciannella": {
+      "profile": {
+        "patient_id": "pt_fciannella",
+        "first_name": "Francesco",
+        "last_name": "Ciannella",
+        "full_name": "Francesco Ciannella",
+        "dob": "1990-01-01",
+        "mrn": "FC-1990-6001",
+        "mrn_last4": "6001",
+        "secret_question": "What city were you born in?",
+        "secret_answer": "rome",
+        "phone": "+1-555-0202",
+        "email": "francesco@example.com",
+        "address": {
+          "line1": "101 State St",
+          "city": "San Jose",
+          "state": "CA",
+          "zip": "95110"
+        },
+        "preferred_pharmacy_id": "ph_sc_1010"
+      },
+      "allergies": [
+        "NKA"
+      ],
+      "medications": [
+        {
+          "name": "Lisinopril",
+          "sig": "10 mg, once daily",
+          "rxnorm": "29046",
+          "otc": false
+        }
+      ],
+      "conditions": [
+        "Hypertension"
+      ],
+      "recent_visits": [
+        {
+          "date": "2025-07-02",
+          "type": "Urgent Care",
+          "reason": "Sore throat",
+          "outcome": "Viral pharyngitis; supportive care"
+        }
+      ],
+      "vitals": {
+        "last": {
+          "date": "2025-07-02",
+          "bp": "122/76",
+          "hr": 68,
+          "temp_f": 98.2,
+          "bmi": 24.9
+        }
+      }
+    }
+  }
+}

examples/voice_agent_webrtc_langgraph/agents/healthcare-agent/mock_data/pharmacies.json

@@ -0,0 +1,16 @@
+{
+  "pharmacies": {
+    "ph_sc_1010": {
+      "name": "Community Pharmacy",
+      "address": "1010 El Camino Real, Santa Clara, CA 95050",
+      "phone": "+1-408-555-3131",
+      "hours": "Mon-Sun 8:00-22:00"
+    },
+    "ph_sj_center": {
+      "name": "Center Care Pharmacy",
+      "address": "500 Market St, San Jose, CA 95113",
+      "phone": "+1-408-555-1212",
+      "hours": "Mon-Fri 9:00-18:00, Sat 10:00-16:00"
+    }
+  }
+}

examples/voice_agent_webrtc_langgraph/agents/healthcare-agent/mock_data/providers.json

@@ -0,0 +1,26 @@
+{
+  "providers": {
+    "prov_smith_md": {
+      "name": "Dr. Laura Smith",
+      "type": "MD",
+      "specialty": "Primary Care",
+      "location": "Main Clinic - Santa Clara",
+      "next_available": [
+        "2025-09-27T10:00:00-07:00",
+        "2025-09-27T14:30:00-07:00",
+        "2025-09-28T09:15:00-07:00"
+      ]
+    },
+    "prov_chang_np": {
+      "name": "Alex Chang, NP",
+      "type": "NP",
+      "specialty": "Urgent Care",
+      "location": "Telehealth",
+      "next_available": [
+        "2025-09-26T20:00:00-07:00",
+        "2025-09-27T08:30:00-07:00",
+        "2025-09-27T16:00:00-07:00"
+      ]
+    }
+  }
+}

examples/voice_agent_webrtc_langgraph/agents/healthcare-agent/mock_data/triage_rules.json

@@ -0,0 +1,54 @@
+{
+  "rules": [
+    {
+      "name": "Headache - red flags",
+      "match": ["headache"],
+      "red_flags": [
+        "worst headache",
+        "head injury",
+        "numbness",
+        "weakness",
+        "confusion",
+        "seizure",
+        "stiff neck",
+        "vision loss",
+        "high fever",
+        "fever 102",
+        "cancer",
+        "pregnant"
+      ],
+      "escalate": "urgent",
+      "advice": "This may require urgent evaluation. If you have any red flag symptoms, go to the nearest emergency department or call emergency services.",
+      "book_with": "prov_chang_np"
+    },
+    {
+      "name": "Headache - moderate risk (age > 50 new onset)",
+      "match": ["headache"],
+      "criteria": ["age_over_50"],
+      "escalate": "soon",
+      "advice": "Given your age and new headache, we recommend a prompt appointment to evaluate further.",
+      "book_with": "prov_smith_md"
+    },
+    {
+      "name": "Headache - typical",
+      "match": ["headache"],
+      "escalate": "self_care",
+      "advice": "Try rest, hydration, limited screen time, and acetaminophen as directed. Avoid ibuprofen if your doctor advised against it. If symptoms worsen or persist beyond 48 hours, schedule a visit.",
+      "book_with": "prov_smith_md"
+    },
+    {
+      "name": "Chest pain - emergency",
+      "match": ["chest pain"],
+      "escalate": "urgent",
+      "advice": "Chest pain can be serious. Please call emergency services now or go to the nearest ER.",
+      "book_with": "prov_chang_np"
+    },
+    {
+      "name": "Fever",
+      "match": ["fever"],
+      "escalate": "self_care",
+      "advice": "Hydration, rest, and acetaminophen can help. If fever is 102°F or higher, lasts more than 3 days, or you have trouble breathing, seek care.",
+      "book_with": "prov_smith_md"
+    }
+  ]
+}

examples/voice_agent_webrtc_langgraph/agents/healthcare-agent/prompts.py

@@ -0,0 +1,31 @@
+from langchain_core.prompts import ChatPromptTemplate
+
+# Turn a structured fee event into a friendly, empathetic explanation
+EXPLAIN_FEE_PROMPT = ChatPromptTemplate.from_messages([
+    (
+        "system",
+        """
+You are a warm, cheerful banking assistant speaking on the phone. Use a friendly, empathetic tone.
+Guidelines:
+- Start with brief empathy (e.g., "I know surprise fees can be frustrating.").
+- Clearly explain what the fee is and why it was applied.
+- Keep it concise (2–3 sentences), plain language, no jargon.
+- Offer help-oriented phrasing ("we can look into options"), no blame.
+""",
+    ),
+    (
+        "human",
+        """
+Fee event:
+- code: {fee_code}
+- posted_date: {posted_date}
+- amount: {amount}
+- schedule_name: {schedule_name}
+- schedule_policy: {schedule_policy}
+
+Write a concise explanation (2–3 sentences) suitable for a mobile UI.
+""",
+    ),
+])
+
+

examples/voice_agent_webrtc_langgraph/agents/healthcare-agent/react_agent.py

@@ -0,0 +1,394 @@
+import os
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List
+
+from langgraph.func import entrypoint, task
+from langgraph.graph import add_messages
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import (
+    SystemMessage,
+    HumanMessage,
+    AIMessage,
+    BaseMessage,
+    ToolCall,
+    ToolMessage,
+)
+
+
+# ---- Tools (wire-transfer) ----
+
+try:
+    from . import tools as wire_tools  # type: ignore
+except Exception:
+    import importlib.util as _ilu
+    _dir = os.path.dirname(__file__)
+    _tools_path = os.path.join(_dir, "tools.py")
+    _spec = _ilu.spec_from_file_location("wire_transfer_agent_tools", _tools_path)
+    wire_tools = _ilu.module_from_spec(_spec)  # type: ignore
+    assert _spec and _spec.loader
+    _spec.loader.exec_module(wire_tools)  # type: ignore
+
+# Aliases for tool functions
+list_accounts = wire_tools.list_accounts
+get_customer_profile = wire_tools.get_customer_profile
+find_customer = wire_tools.find_customer
+find_account_by_last4 = wire_tools.find_account_by_last4
+verify_identity = wire_tools.verify_identity
+get_account_balance_tool = wire_tools.get_account_balance_tool
+get_exchange_rate_tool = wire_tools.get_exchange_rate_tool
+calculate_wire_fee_tool = wire_tools.calculate_wire_fee_tool
+check_wire_limits_tool = wire_tools.check_wire_limits_tool
+get_cutoff_and_eta_tool = wire_tools.get_cutoff_and_eta_tool
+get_country_requirements_tool = wire_tools.get_country_requirements_tool
+validate_beneficiary_tool = wire_tools.validate_beneficiary_tool
+save_beneficiary_tool = wire_tools.save_beneficiary_tool
+quote_wire_tool = wire_tools.quote_wire_tool
+generate_otp_tool = wire_tools.generate_otp_tool
+verify_otp_tool = wire_tools.verify_otp_tool
+wire_transfer_domestic = wire_tools.wire_transfer_domestic
+wire_transfer_international = wire_tools.wire_transfer_international
+
+find_customer_by_name = None  # not used for wire agent; tools expose find_customer
+
+
+"""ReAct agent entrypoint and system prompt."""
+
+
+SYSTEM_PROMPT = (
+    "You are a warm, cheerful banking assistant helping a customer send a wire transfer (domestic or international). "
+    "Start with a brief greeting and very short small talk. Then ask for the caller's full name. "
+    "IDENTITY IS MANDATORY: Before ANY account lookups or wire questions, you MUST call verify_identity. Ask for date of birth (customer can use any format; you normalize) and EITHER SSN last-4 OR the secret answer. If verify_identity returns a secret question, read it verbatim and collect the answer. "
+    "NEVER claim the customer is verified unless the verify_identity tool returned verified=true. If not verified, ask ONLY for the next missing field and call verify_identity again. Do NOT proceed to wire details until verified=true. "
+    "AFTER VERIFIED: Ask ONE question at a time, in this order, waiting for the user's answer each time: (1) wire type (DOMESTIC or INTERNATIONAL); (2) source account (last-4 or picker); (3) amount (with source currency); (4) destination country/state; (5) destination currency preference; (6) who pays fees (OUR/SHA/BEN). Keep each turn to a single, concise prompt. Do NOT re-ask for fields already provided; instead, briefly summarize known details and ask only for the next missing field. "
+    "If destination currency differs from source, call get_exchange_rate_tool and state the applied rate and converted amount. "
+    "Collect beneficiary details next. Use get_country_requirements_tool and validate_beneficiary_tool; if fields are missing, ask for ONLY the next missing field (one per turn). "
+    "Then check balance/limits via get_account_balance_tool and check_wire_limits_tool. Provide a pre-transfer quote using quote_wire_tool showing: FX rate, total fees, who pays what, net sent, net received, and ETA from get_cutoff_and_eta_tool. "
+    "Before executing, generate an OTP (generate_otp_tool), collect it, verify via verify_otp_tool, then execute the appropriate transfer: wire_transfer_domestic or wire_transfer_international. Offer to save the beneficiary afterward. "
+    "STYLE: Keep messages short (1–2 sentences), empathetic, and strictly ask one question per turn."
+)
+
+
+_MODEL_NAME = os.getenv("REACT_MODEL", os.getenv("CLARIFY_MODEL", "gpt-4o"))
+_LLM = ChatOpenAI(model=_MODEL_NAME, temperature=0.3)
+_TOOLS = [
+    list_accounts,
+    get_customer_profile,
+    find_customer,
+    find_account_by_last4,
+    verify_identity,
+    get_account_balance_tool,
+    get_exchange_rate_tool,
+    calculate_wire_fee_tool,
+    check_wire_limits_tool,
+    get_cutoff_and_eta_tool,
+    get_country_requirements_tool,
+    validate_beneficiary_tool,
+    save_beneficiary_tool,
+    quote_wire_tool,
+    generate_otp_tool,
+    verify_otp_tool,
+    wire_transfer_domestic,
+    wire_transfer_international,
+]
+_LLM_WITH_TOOLS = _LLM.bind_tools(_TOOLS)
+_TOOLS_BY_NAME = {t.name: t for t in _TOOLS}
+
+# Simple per-run context storage (thread-safe enough for local dev worker)
+_CURRENT_THREAD_ID: str | None = None
+_CURRENT_CUSTOMER_ID: str | None = None
+
+# ---- Logger ----
+logger = logging.getLogger("WireTransferAgent")
+if not logger.handlers:
+    _stream = logging.StreamHandler()
+    _stream.setLevel(logging.INFO)
+    _fmt = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    _stream.setFormatter(_fmt)
+    logger.addHandler(_stream)
+    try:
+        _file = logging.FileHandler(str(Path(__file__).resolve().parents[2] / "app.log"))
+        _file.setLevel(logging.INFO)
+        _file.setFormatter(_fmt)
+        logger.addHandler(_file)
+    except Exception:
+        pass
+logger.setLevel(logging.INFO)
+_DEBUG = os.getenv("RBC_FEES_DEBUG", "0") not in ("", "0", "false", "False")
+
+def _get_thread_id(config: Dict[str, Any] | None, messages: List[BaseMessage]) -> str:
+    cfg = config or {}
+    # Try dict-like and attribute-like access
+    def _safe_get(container: Any, key: str, default: Any = None) -> Any:
+        try:
+            if isinstance(container, dict):
+                return container.get(key, default)
+            if hasattr(container, "get"):
+                return container.get(key, default)
+            if hasattr(container, key):
+                return getattr(container, key, default)
+        except Exception:
+            return default
+        return default
+
+    try:
+        conf = _safe_get(cfg, "configurable", {}) or {}
+        for key in ("thread_id", "session_id", "thread"):
+            val = _safe_get(conf, key)
+            if isinstance(val, str) and val:
+                return val
+    except Exception:
+        pass
+
+    # Fallback: look for session_id on the latest human message additional_kwargs
+    try:
+        for m in reversed(messages or []):
+            addl = getattr(m, "additional_kwargs", None)
+            if isinstance(addl, dict) and isinstance(addl.get("session_id"), str) and addl.get("session_id"):
+                return addl.get("session_id")
+            if isinstance(m, dict):
+                ak = m.get("additional_kwargs") or {}
+                if isinstance(ak, dict) and isinstance(ak.get("session_id"), str) and ak.get("session_id"):
+                    return ak.get("session_id")
+    except Exception:
+        pass
+    return "unknown"
+
+
+def _trim_messages(messages: List[BaseMessage], max_messages: int = 40) -> List[BaseMessage]:
+    if len(messages) <= max_messages:
+        return messages
+    return messages[-max_messages:]
+
+
+def _sanitize_conversation(messages: List[BaseMessage]) -> List[BaseMessage]:
+    """Ensure tool messages only follow an assistant message with tool_calls.
+
+    Drops orphan tool messages that could cause OpenAI 400 errors.
+    """
+    sanitized: List[BaseMessage] = []
+    pending_tool_ids: set[str] | None = None
+    for m in messages:
+        try:
+            if isinstance(m, AIMessage):
+                sanitized.append(m)
+                tool_calls = getattr(m, "tool_calls", None) or []
+                ids: set[str] = set()
+                for tc in tool_calls:
+                    # ToolCall can be mapping-like or object-like
+                    if isinstance(tc, dict):
+                        _id = tc.get("id") or tc.get("tool_call_id")
+                    else:
+                        _id = getattr(tc, "id", None) or getattr(tc, "tool_call_id", None)
+                    if isinstance(_id, str):
+                        ids.add(_id)
+                pending_tool_ids = ids if ids else None
+                continue
+            if isinstance(m, ToolMessage):
+                if pending_tool_ids and isinstance(getattr(m, "tool_call_id", None), str) and m.tool_call_id in pending_tool_ids:
+                    sanitized.append(m)
+                    # keep accepting subsequent tool messages for the same assistant turn
+                    continue
+                # Orphan tool message: drop
+                continue
+            # Any other message resets expectation
+            sanitized.append(m)
+            pending_tool_ids = None
+        except Exception:
+            # On any unexpected shape, include as-is but reset to avoid pairing issues
+            sanitized.append(m)
+            pending_tool_ids = None
+    # Ensure the conversation doesn't start with a ToolMessage
+    while sanitized and isinstance(sanitized[0], ToolMessage):
+        sanitized.pop(0)
+    return sanitized
+
+
+def _today_string() -> str:
+    override = os.getenv("RBC_FEES_TODAY_OVERRIDE")
+    if isinstance(override, str) and override.strip():
+        try:
+            datetime.strptime(override.strip(), "%Y-%m-%d")
+            return override.strip()
+        except Exception:
+            pass
+    return datetime.utcnow().strftime("%Y-%m-%d")
+
+
+def _system_messages() -> List[BaseMessage]:
+    today = _today_string()
+    return [SystemMessage(content=SYSTEM_PROMPT)]
+
+
+@task()
+def call_llm(messages: List[BaseMessage]) -> AIMessage:
+    """LLM decides whether to call a tool or not."""
+    if _DEBUG:
+        try:
+            preview = [f"{getattr(m,'type', getattr(m,'role',''))}:{str(getattr(m,'content', m))[:80]}" for m in messages[-6:]]
+            logger.info("call_llm: messages_count=%s preview=%s", len(messages), preview)
+        except Exception:
+            logger.info("call_llm: messages_count=%s", len(messages))
+    resp = _LLM_WITH_TOOLS.invoke(_system_messages() + messages)
+    try:
+        # Log assistant content or tool calls for visibility
+        tool_calls = getattr(resp, "tool_calls", None) or []
+        if tool_calls:
+            names = []
+            for tc in tool_calls:
+                n = tc.get("name") if isinstance(tc, dict) else getattr(tc, "name", None)
+                if isinstance(n, str):
+                    names.append(n)
+            logger.info("LLM tool_calls: %s", names)
+        else:
+            txt = getattr(resp, "content", "") or ""
+            if isinstance(txt, str) and txt.strip():
+                logger.info("LLM content: %s", (txt if len(txt) <= 500 else (txt[:500] + "…")))
+    except Exception:
+        pass
+    return resp
+
+
+@task()
+def call_tool(tool_call: ToolCall) -> ToolMessage:
+    """Execute a tool call and wrap result in a ToolMessage."""
+    tool = _TOOLS_BY_NAME[tool_call["name"]]
+    args = tool_call.get("args") or {}
+    # Auto-inject session/customer context if missing for identity and other tools
+    if tool.name == "verify_identity":
+        if "session_id" not in args and _CURRENT_THREAD_ID:
+            args["session_id"] = _CURRENT_THREAD_ID
+        if "customer_id" not in args and _CURRENT_CUSTOMER_ID:
+            args["customer_id"] = _CURRENT_CUSTOMER_ID
+    if tool.name == "list_accounts":
+        if "customer_id" not in args and _CURRENT_CUSTOMER_ID:
+            args["customer_id"] = _CURRENT_CUSTOMER_ID
+    # Gate non-identity tools until verified=true
+    try:
+        if tool.name not in ("verify_identity", "find_customer"):
+            # Look back through recent messages for the last verify_identity result
+            # The runtime passes messages separately; we cannot access here, so rely on LLM prompt discipline.
+            # As an extra guard, if the tool is attempting a wire action before identity, return a friendly error.
+            pass
+    except Exception:
+        pass
+    if _DEBUG:
+        try:
+            logger.info("call_tool: name=%s args_keys=%s", tool.name, list(args.keys()))
+        except Exception:
+            logger.info("call_tool: name=%s", tool.name)
+    result = tool.invoke(args)
+    # Ensure string content
+    content = result if isinstance(result, str) else json.dumps(result)
+    try:
+        # Log tool result previews and OTP debug_code when present
+        if tool.name == "verify_identity":
+            try:
+                data = json.loads(content)
+                logger.info("verify_identity: verified=%s needs=%s", data.get("verified"), data.get("needs"))
+            except Exception:
+                logger.info("verify_identity result: %s", content[:300])
+        elif tool.name == "generate_otp_tool":
+            try:
+                data = json.loads(content)
+                if isinstance(data, dict) and data.get("debug_code"):
+                    logger.info("OTP debug_code: %s", data.get("debug_code"))
+                else:
+                    logger.info("generate_otp_tool: %s", content[:300])
+            except Exception:
+                logger.info("generate_otp_tool: %s", content[:300])
+        else:
+            # Generic preview
+            logger.info("tool %s result: %s", tool.name, (content[:300] if isinstance(content, str) else str(content)[:300]))
+    except Exception:
+        pass
+    # Never expose OTP debug_code to the LLM
+    try:
+        if tool.name == "generate_otp_tool":
+            data = json.loads(content)
+            if isinstance(data, dict) and "debug_code" in data:
+                data.pop("debug_code", None)
+                content = json.dumps(data)
+    except Exception:
+        pass
+    return ToolMessage(content=content, tool_call_id=tool_call["id"], name=tool.name)
+
+
+@entrypoint()
+def agent(messages: List[BaseMessage], previous: List[BaseMessage] | None, config: Dict[str, Any] | None = None):
+    # Start from full conversation history (previous + new)
+    prev_list = list(previous or [])
+    new_list = list(messages or [])
+    convo: List[BaseMessage] = prev_list + new_list
+    # Trim to avoid context bloat
+    convo = _trim_messages(convo, max_messages=int(os.getenv("RBC_FEES_MAX_MSGS", "40")))
+    # Sanitize to avoid orphan tool messages after trimming
+    convo = _sanitize_conversation(convo)
+    thread_id = _get_thread_id(config, new_list)
+    logger.info("agent start: thread_id=%s total_in=%s (prev=%s, new=%s)", thread_id, len(convo), len(prev_list), len(new_list))
+    # Establish default customer from config (or fallback to cust_test)
+    conf = (config or {}).get("configurable", {}) if isinstance(config, dict) else {}
+    default_customer = conf.get("customer_id") or conf.get("user_email") or "cust_test"
+
+    # Heuristic: infer customer_id from latest human name if provided (e.g., "I am Alice Stone")
+    inferred_customer: str | None = None
+    try:
+        recent_humans = [m for m in reversed(new_list) if (getattr(m, "type", None) == "human" or getattr(m, "role", None) == "user" or (isinstance(m, dict) and m.get("type") == "human"))]
+        text = None
+        for m in recent_humans[:3]:
+            text = (getattr(m, "content", None) if not isinstance(m, dict) else m.get("content")) or ""
+            if isinstance(text, str) and text.strip():
+                break
+        if isinstance(text, str):
+            tokens = [t for t in text.replace(',', ' ').split() if t.isalpha()]
+            if len(tokens) >= 2 and find_customer_by_name is not None:
+                # Try adjacent pairs as first/last
+                for i in range(len(tokens) - 1):
+                    fn = tokens[i]
+                    ln = tokens[i + 1]
+                    found = find_customer_by_name(fn, ln)  # type: ignore
+                    if isinstance(found, dict) and found.get("customer_id"):
+                        inferred_customer = found.get("customer_id")
+                        break
+    except Exception:
+        pass
+
+    # Update module context
+    global _CURRENT_THREAD_ID, _CURRENT_CUSTOMER_ID
+    _CURRENT_THREAD_ID = thread_id
+    _CURRENT_CUSTOMER_ID = inferred_customer or default_customer
+
+    llm_response = call_llm(convo).result()
+
+    while True:
+        tool_calls = getattr(llm_response, "tool_calls", None) or []
+        if not tool_calls:
+            break
+
+        # Execute tools (in parallel) and append results
+        futures = [call_tool(tc) for tc in tool_calls]
+        tool_results = [f.result() for f in futures]
+        if _DEBUG:
+            try:
+                logger.info("tool_results: count=%s names=%s", len(tool_results), [tr.name for tr in tool_results])
+            except Exception:
+                pass
+        convo = add_messages(convo, [llm_response, *tool_results])
+        llm_response = call_llm(convo).result()
+
+    # Append final assistant turn
+    convo = add_messages(convo, [llm_response])
+    final_text = getattr(llm_response, "content", "") or ""
+    try:
+        if isinstance(final_text, str) and final_text.strip():
+            logger.info("final content: %s", (final_text if len(final_text) <= 500 else (final_text[:500] + "…")))
+    except Exception:
+        pass
+    ai = AIMessage(content=final_text if isinstance(final_text, str) else str(final_text))
+    logger.info("agent done: thread_id=%s total_messages=%s final_len=%s", thread_id, len(convo), len(ai.content))
+    # Save only the merged conversation (avoid duplicating previous)
+    return entrypoint.final(value=ai, save=convo)
+
+

examples/voice_agent_webrtc_langgraph/agents/healthcare-agent/tools.py

@@ -0,0 +1,167 @@
+import os
+import sys
+import json
+from typing import Any, Dict
+
+from langchain_core.tools import tool
+
+# Robust logic import to avoid crossing into other agent modules during hot reloads
+try:
+    from . import logic as wt_logic  # type: ignore
+except Exception:
+    import importlib.util as _ilu
+    _dir = os.path.dirname(__file__)
+    _logic_path = os.path.join(_dir, "logic.py")
+    _spec = _ilu.spec_from_file_location("wire_transfer_agent_logic", _logic_path)
+    wt_logic = _ilu.module_from_spec(_spec)  # type: ignore
+    assert _spec and _spec.loader
+    _spec.loader.exec_module(wt_logic)  # type: ignore
+
+get_accounts = wt_logic.get_accounts
+get_profile = wt_logic.get_profile
+find_customer_by_name = wt_logic.find_customer_by_name
+find_customer_by_full_name = getattr(wt_logic, "find_customer_by_full_name", wt_logic.find_customer_by_name)
+get_account_balance = wt_logic.get_account_balance
+get_exchange_rate = wt_logic.get_exchange_rate
+calculate_wire_fee = wt_logic.calculate_wire_fee
+check_wire_limits = wt_logic.check_wire_limits
+get_cutoff_and_eta = wt_logic.get_cutoff_and_eta
+get_country_requirements = wt_logic.get_country_requirements
+validate_beneficiary = wt_logic.validate_beneficiary
+save_beneficiary = wt_logic.save_beneficiary
+generate_otp = wt_logic.generate_otp
+verify_otp = wt_logic.verify_otp
+authenticate_user_wire = wt_logic.authenticate_user_wire
+quote_wire = wt_logic.quote_wire
+wire_transfer_domestic_logic = wt_logic.wire_transfer_domestic
+wire_transfer_international_logic = wt_logic.wire_transfer_international
+
+
+@tool
+def list_accounts(customer_id: str) -> str:
+    """List customer's accounts with masked numbers, balances, currency, and wire eligibility. Returns JSON string."""
+    return json.dumps(get_accounts(customer_id))
+
+
+@tool
+def get_customer_profile(customer_id: str) -> str:
+    """Fetch basic customer profile (full_name, dob, ssn_last4, secret question). Returns JSON string."""
+    return json.dumps(get_profile(customer_id))
+
+
+@tool
+def find_customer(first_name: str | None = None, last_name: str | None = None, full_name: str | None = None) -> str:
+    """Find a customer_id by name. Prefer full_name; otherwise use first and last name. Returns JSON with customer_id or {}."""
+    if isinstance(full_name, str) and full_name.strip():
+        return json.dumps(find_customer_by_full_name(full_name))
+    return json.dumps(find_customer_by_name(first_name or "", last_name or ""))
+
+
+@tool
+def find_account_by_last4(customer_id: str, last4: str) -> str:
+    """Find a customer's account by last 4 digits. Returns JSON with account or {} if not found."""
+    accts = get_accounts(customer_id)
+    for a in accts:
+        num = str(a.get("account_number") or "")
+        if num.endswith(str(last4)):
+            return json.dumps(a)
+    return json.dumps({})
+
+
+@tool
+def verify_identity(session_id: str, customer_id: str | None = None, full_name: str | None = None, dob_yyyy_mm_dd: str | None = None, ssn_last4: str | None = None, secret_answer: str | None = None) -> str:
+    """Verify user identity before wires. Provide any of: full_name, dob (YYYY-MM-DD), ssn_last4, secret_answer. Returns JSON with verified flag, needed fields, and optional secret question."""
+    res = authenticate_user_wire(session_id, customer_id, full_name, dob_yyyy_mm_dd, ssn_last4, secret_answer)
+    return json.dumps(res)
+
+
+@tool
+def get_account_balance_tool(account_id: str) -> str:
+    """Get balance, currency, and wire limits for an account. Returns JSON."""
+    return json.dumps(get_account_balance(account_id))
+
+
+@tool
+def get_exchange_rate_tool(from_currency: str, to_currency: str, amount: float) -> str:
+    """Get exchange rate and converted amount for a given amount. Returns JSON."""
+    return json.dumps(get_exchange_rate(from_currency, to_currency, amount))
+
+
+@tool
+def calculate_wire_fee_tool(kind: str, amount: float, from_currency: str, to_currency: str, payer: str) -> str:
+    """Calculate wire fee breakdown and who pays (OUR/SHA/BEN). Returns JSON."""
+    return json.dumps(calculate_wire_fee(kind, amount, from_currency, to_currency, payer))
+
+
+@tool
+def check_wire_limits_tool(account_id: str, amount: float) -> str:
+    """Check sufficient funds and daily wire limit on an account. Returns JSON."""
+    return json.dumps(check_wire_limits(account_id, amount))
+
+
+@tool
+def get_cutoff_and_eta_tool(kind: str, country: str) -> str:
+    """Get cutoff time and estimated arrival window by type and country. Returns JSON."""
+    return json.dumps(get_cutoff_and_eta(kind, country))
+
+
+@tool
+def get_country_requirements_tool(country_code: str) -> str:
+    """Get required beneficiary fields for a country. Returns JSON array."""
+    return json.dumps(get_country_requirements(country_code))
+
+
+@tool
+def validate_beneficiary_tool(country_code: str, beneficiary_json: str) -> str:
+    """Validate beneficiary fields for a given country. Input is JSON dict string; returns {ok, missing}."""
+    try:
+        beneficiary = json.loads(beneficiary_json)
+    except Exception:
+        beneficiary = {}
+    return json.dumps(validate_beneficiary(country_code, beneficiary))
+
+
+@tool
+def save_beneficiary_tool(customer_id: str, beneficiary_json: str) -> str:
+    """Save a beneficiary for future use. Input is JSON dict string; returns {beneficiary_id}."""
+    try:
+        beneficiary = json.loads(beneficiary_json)
+    except Exception:
+        beneficiary = {}
+    return json.dumps(save_beneficiary(customer_id, beneficiary))
+
+
+@tool
+def quote_wire_tool(kind: str, from_account_id: str, beneficiary_json: str, amount: float, from_currency: str, to_currency: str, payer: str) -> str:
+    """Create a wire quote including FX, fees, limits, sanctions, eta; returns JSON with quote_id and totals."""
+    try:
+        beneficiary = json.loads(beneficiary_json)
+    except Exception:
+        beneficiary = {}
+    return json.dumps(quote_wire(kind, from_account_id, beneficiary, amount, from_currency, to_currency, payer))
+
+
+@tool
+def generate_otp_tool(customer_id: str) -> str:
+    """Generate a one-time passcode for wire authorization. Returns masked destination info."""
+    return json.dumps(generate_otp(customer_id))
+
+
+@tool
+def verify_otp_tool(customer_id: str, otp: str) -> str:
+    """Verify the one-time passcode for wire authorization. Returns {verified}."""
+    return json.dumps(verify_otp(customer_id, otp))
+
+
+@tool
+def wire_transfer_domestic(quote_id: str, otp: str) -> str:
+    """Execute a domestic wire with a valid quote_id and OTP. Returns confirmation."""
+    return json.dumps(wire_transfer_domestic_logic(quote_id, otp))
+
+
+@tool
+def wire_transfer_international(quote_id: str, otp: str) -> str:
+    """Execute an international wire with a valid quote_id and OTP. Returns confirmation."""
+    return json.dumps(wire_transfer_international_logic(quote_id, otp))
+
+

examples/voice_agent_webrtc_langgraph/agents/langgraph.json

@@ -3,7 +3,8 @@
     "graphs": {
       "rbc-fees-agent": "./rbc-fees-agent/react_agent.py:agent",
       "wire-transfer-agent": "./wire-transfer-agent/react_agent.py:agent",
-      "telco-agent": "./telco-agent/react_agent.py:agent"
+      "telco-agent": "./telco-agent/react_agent.py:agent",
+      "healthcare-agent": "./healthcare-agent/react_agent.py:agent"
     },
     "dockerfile_lines": [
             "RUN pip install --upgrade pip",

examples/voice_agent_webrtc_langgraph/pipeline.py

@@ -90,6 +90,7 @@ async def list_assistants(request: Request):
         {"assistant_id": "rbc-fees-agent", "graph_id": "rbc-fees-agent", "display_name": "RBC Fees Agent"},
         {"assistant_id": "wire-transfer-agent", "graph_id": "wire-transfer-agent", "display_name": "Wire Transfer Agent"},
         {"assistant_id": "telco-agent", "graph_id": "telco-agent", "display_name": "Telco Agent"},
+        {"assistant_id": "healthcare-agent", "graph_id": "healthcare-agent", "display_name": "Healthcare Nurse Agent"},
     ]
     import requests