Added the healthcare agent

examples/voice_agent_webrtc_langgraph/Dockerfile

@@ -55,6 +55,7 @@ WORKDIR /app/examples/voice_agent_webrtc_langgraph
 
 # Dependencies
 RUN uv sync --frozen
+# RUN uv sync
 # Install all agent requirements recursively into the project's virtual environment
 # RUN if [ -d "agents" ]; then \
 #     find agents -type f -name "requirements.txt" -print0 | xargs -0 -I {} uv pip install -r "{}"; \

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

@@ -620,3 +620,244 @@ def authenticate_user(session_id: str, name: Optional[str], dob_yyyy_mm_dd: Opti
     return resp
 
 
+
+# --- Healthcare demo logic (patients, triage, providers, pharmacies) ---
+
+_HC_SESSIONS: Dict[str, Dict[str, Any]] = {}
+_HC_APPOINTMENTS: List[Dict[str, Any]] = []
+_HC_CALL_LOG: List[Dict[str, Any]] = []
+
+
+def _hc_fixtures_dir() -> Path:
+    return Path(__file__).parent / "mock_data"
+
+
+def _hc_load_fixture(name: str) -> Any:
+    # Use a separate cache key namespace to avoid collisions
+    key = f"hc::{name}"
+    if key in _FIXTURE_CACHE:
+        return _FIXTURE_CACHE[key]
+    p = _hc_fixtures_dir() / name
+    with p.open("r", encoding="utf-8") as f:
+        data = json.load(f)
+    _FIXTURE_CACHE[key] = data
+    return data
+
+
+def _hc_get_patient_blob(patient_id: str) -> Dict[str, Any]:
+    data = _hc_load_fixture("patients.json")
+    return dict((data.get("patients") or {}).get(patient_id, {}))
+
+
+def find_patient_by_name(first_name: str, last_name: str) -> Dict[str, Any]:
+    data = _hc_load_fixture("patients.json")
+    patients = data.get("patients", {})
+    fn = (first_name or "").strip().lower()
+    ln = (last_name or "").strip().lower()
+    for pid, blob in patients.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 {"patient_id": pid, "profile": prof}
+    return {}
+
+
+def find_patient_by_full_name(full_name: str) -> Dict[str, Any]:
+    data = _hc_load_fixture("patients.json")
+    patients = data.get("patients", {})
+    target = (full_name or "").strip().lower()
+    for pid, blob in patients.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 {"patient_id": pid, "profile": prof}
+    return {}
+
+
+def get_patient_profile(patient_id: str) -> Dict[str, Any]:
+    blob = _hc_get_patient_blob(patient_id)
+    if not blob:
+        return {}
+    prof = dict(blob.get("profile", {}))
+    return {
+        "profile": prof,
+        "allergies": list(blob.get("allergies", [])),
+        "medications": list(blob.get("medications", [])),
+        "conditions": list(blob.get("conditions", [])),
+        "recent_visits": list(blob.get("recent_visits", [])),
+        "vitals": dict(blob.get("vitals", {})),
+    }
+
+
+def authenticate_patient(session_id: str, patient_id: Optional[str], full_name: Optional[str], dob_yyyy_mm_dd: Optional[str], mrn_last4: Optional[str], secret_answer: Optional[str]) -> Dict[str, Any]:
+    session = _HC_SESSIONS.get(session_id) or {"verified": False, "patient_id": patient_id, "name": full_name}
+    if isinstance(patient_id, str) and patient_id:
+        session["patient_id"] = patient_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"] = _normalize_dob(dob_yyyy_mm_dd) or dob_yyyy_mm_dd
+    if isinstance(mrn_last4, str) and mrn_last4:
+        session["mrn_last4"] = mrn_last4
+    if isinstance(secret_answer, str) and secret_answer:
+        session["secret"] = secret_answer
+
+    ok = False
+    pid = session.get("patient_id")
+    if isinstance(pid, str):
+        prof = get_patient_profile(pid).get("profile", {})
+        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)
+        mrn_ok = str(session.get("mrn_last4") or "") == str(prof.get("mrn_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 (mrn_ok or secret_ok):
+            ok = True
+    session["verified"] = ok
+    _HC_SESSIONS[session_id] = session
+    need: List[str] = []
+    if _normalize_dob(session.get("dob")) is None:
+        need.append("dob")
+    if not session.get("mrn_last4") and not session.get("secret"):
+        need.append("mrn_last4_or_secret")
+    if not session.get("patient_id"):
+        need.append("patient")
+    resp: Dict[str, Any] = {"session_id": session_id, "verified": ok, "needs": need, "profile": {"name": session.get("name")}}
+    try:
+        if isinstance(session.get("patient_id"), str):
+            prof = get_patient_profile(session.get("patient_id")).get("profile", {})
+            if isinstance(prof, dict) and prof.get("secret_question"):
+                resp["question"] = prof.get("secret_question")
+    except Exception:
+        pass
+    return resp
+
+
+def get_preferred_pharmacy(patient_id: str) -> Dict[str, Any]:
+    prof = get_patient_profile(patient_id).get("profile", {})
+    ph_id = prof.get("preferred_pharmacy_id")
+    if not ph_id:
+        return {}
+    data = _hc_load_fixture("pharmacies.json")
+    ph = (data.get("pharmacies") or {}).get(ph_id) or {}
+    return {"pharmacy_id": ph_id, **ph}
+
+
+def list_providers(specialty: Optional[str] = None) -> List[Dict[str, Any]]:
+    data = _hc_load_fixture("providers.json")
+    providers = data.get("providers", {})
+    out: List[Dict[str, Any]] = []
+    for pid, p in providers.items():
+        if specialty and str(p.get("specialty", "")).lower() != specialty.strip().lower():
+            continue
+        out.append({"provider_id": pid, **p})
+    return out
+
+
+def get_provider_slots(provider_id: str, count: int = 3) -> List[str]:
+    data = _hc_load_fixture("providers.json")
+    providers = data.get("providers", {})
+    p = providers.get(provider_id) or {}
+    return list((p.get("next_available") or [])[:count])
+
+
+def schedule_appointment(provider_id: str, slot_iso: str, patient_id: Optional[str]) -> Dict[str, Any]:
+    appt = {
+        "appointment_id": f"A-{uuid.uuid4().hex[:8]}",
+        "provider_id": provider_id,
+        "slot": slot_iso,
+        "patient_id": patient_id,
+        "created_at": datetime.utcnow().isoformat() + "Z",
+        "status": "booked",
+    }
+    _HC_APPOINTMENTS.append(appt)
+    return appt
+
+
+def _patient_age_years(patient_id: Optional[str]) -> Optional[int]:
+    try:
+        if not patient_id:
+            return None
+        prof = get_patient_profile(patient_id).get("profile", {})
+        dob = _normalize_dob(prof.get("dob"))
+        if not dob:
+            return None
+        y, m, d = [int(x) for x in dob.split("-")]
+        today = datetime.utcnow().date()
+        age = today.year - y - ((today.month, today.day) < (m, d))
+        return age
+    except Exception:
+        return None
+
+
+def triage_symptoms(patient_id: Optional[str], symptoms_text: str) -> Dict[str, Any]:
+    txt = (symptoms_text or "").lower()
+    rules = _hc_load_fixture("triage_rules.json").get("rules", [])
+    age = _patient_age_years(patient_id) or 0
+
+    def contains_any(needles: List[str]) -> bool:
+        for n in needles:
+            if n.lower() in txt:
+                return True
+        return False
+
+    chosen: Dict[str, Any] | None = None
+    red_flags_hit: List[str] = []
+
+    for r in rules:
+        matches = r.get("match", [])
+        if matches and not contains_any(matches):
+            continue
+        rflags = r.get("red_flags", [])
+        if rflags:
+            red_flags_hit = [rf for rf in rflags if rf.lower() in txt]
+            if red_flags_hit:
+                chosen = r
+                break
+        crit = r.get("criteria", [])
+        if crit:
+            if "age_over_50" in crit and age > 50:
+                chosen = r
+                break
+        if not r.get("red_flags") and not r.get("criteria"):
+            chosen = r
+            # do not break; prefer a more specific rule if later
+
+    if not chosen and rules:
+        chosen = rules[-1]
+
+    if not chosen:
+        return {"risk": "self_care", "advice": "If symptoms persist or worsen, contact us or seek care.", "red_flags": []}
+
+    return {
+        "risk": chosen.get("escalate", "self_care"),
+        "advice": chosen.get("advice", ""),
+        "red_flags": red_flags_hit,
+        "rule": chosen.get("name", "")
+    }
+
+
+def log_call(session_id: str, patient_id: Optional[str], notes: Optional[str], triage: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    entry = {
+        "log_id": f"L-{uuid.uuid4().hex[:8]}",
+        "session_id": session_id,
+        "patient_id": patient_id,
+        "notes": notes or "",
+        "triage": triage or {},
+        "timestamp": datetime.utcnow().isoformat() + "Z",
+    }
+    _HC_CALL_LOG.append(entry)
+    try:
+        # Also mirror to app.log for visibility
+        logging.getLogger("HealthcareAgent").info("call_log: %s", json.dumps(entry)[:500])
+    except Exception:
+        pass
+    return {"logged": True, "log_id": entry["log_id"]}
+
+

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

@@ -18,90 +18,73 @@ from langchain_core.messages import (
 )
 
 
-# ---- Tools (wire-transfer) ----
+# ---- Tools (healthcare) ----
 
 try:
-    from . import tools as wire_tools  # type: ignore
+    from . import tools as hc_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
+    _spec = _ilu.spec_from_file_location("healthcare_agent_tools", _tools_path)
+    hc_tools = _ilu.module_from_spec(_spec)  # type: ignore
     assert _spec and _spec.loader
-    _spec.loader.exec_module(wire_tools)  # type: ignore
+    _spec.loader.exec_module(hc_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
+find_patient = hc_tools.find_patient
+get_patient_profile_tool = hc_tools.get_patient_profile_tool
+verify_identity = hc_tools.verify_identity
+get_preferred_pharmacy_tool = hc_tools.get_preferred_pharmacy_tool
+list_providers_tool = hc_tools.list_providers_tool
+get_provider_slots_tool = hc_tools.get_provider_slots_tool
+schedule_appointment_tool = hc_tools.schedule_appointment_tool
+triage_symptoms_tool = hc_tools.triage_symptoms_tool
+log_call_tool = hc_tools.log_call_tool
+
+find_customer_by_name = None  # not used
 
 
 """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."
+    "You are a compassionate 24/7 telehealth nurse for existing patients. "
+    "Begin with a warm, concise greeting and ask for the caller's full name. "
+    "IDENTITY IS MANDATORY: Before accessing any records, verify identity using date of birth (any format; you normalize) and EITHER MRN last-4 OR the secret answer. If a secret question is available, read it verbatim and collect the answer. "
+    "NEVER claim the caller is verified unless verification returns verified=true. If not verified, ask ONLY for the next missing field and verify again. "
+    "AFTER VERIFIED: Ask ONE question at a time. Gather chief complaint and symptoms in plain language. Screen for common red flags (severe/worst-ever, head injury, weakness/numbness, vision changes, seizure, stiff neck, high fever). If any red flag is present, clearly advise urgent evaluation. "
+    "Use a calm, empathetic tone and keep responses short (1–2 sentences). "
+    "If no red flags, provide brief self-care guidance (hydration, rest, acetaminophen dose guidance when appropriate) and offer to book a telehealth appointment with available providers. "
+    "Confirm preferred pharmacy for prescriptions if needed. "
+    "Always speak clearly and avoid medical jargon."
 )
 
 
 _MODEL_NAME = os.getenv("REACT_MODEL", os.getenv("CLARIFY_MODEL", "gpt-4o"))
-_LLM = ChatOpenAI(model=_MODEL_NAME, temperature=0.3)
+_OPENAI_BASE_URL = os.getenv("OPENAI_BASE_URL")
+_OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+_LLM = ChatOpenAI(model=_MODEL_NAME, temperature=0.3, base_url=_OPENAI_BASE_URL, api_key=_OPENAI_API_KEY)
 _TOOLS = [
-    list_accounts,
-    get_customer_profile,
-    find_customer,
-    find_account_by_last4,
+    find_patient,
+    get_patient_profile_tool,
     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,
+    triage_symptoms_tool,
+    list_providers_tool,
+    get_provider_slots_tool,
+    schedule_appointment_tool,
+    get_preferred_pharmacy_tool,
+    log_call_tool,
 ]
 _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
+_CURRENT_PATIENT_ID: str | None = None
 
 # ---- Logger ----
-logger = logging.getLogger("WireTransferAgent")
+logger = logging.getLogger("HealthcareAgent")
 if not logger.handlers:
     _stream = logging.StreamHandler()
     _stream.setLevel(logging.INFO)
@@ -116,7 +99,7 @@ if not logger.handlers:
     except Exception:
         pass
 logger.setLevel(logging.INFO)
-_DEBUG = os.getenv("RBC_FEES_DEBUG", "0") not in ("", "0", "false", "False")
+_DEBUG = os.getenv("HC_DEBUG", "0") not in ("", "0", "false", "False")
 
 def _get_thread_id(config: Dict[str, Any] | None, messages: List[BaseMessage]) -> str:
     cfg = config or {}
@@ -256,24 +239,18 @@ 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
+    # Auto-inject session/patient context for identity and profile 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 "patient_id" not in args and _CURRENT_PATIENT_ID:
+            args["patient_id"] = _CURRENT_PATIENT_ID
+    if tool.name in ("get_patient_profile_tool", "get_preferred_pharmacy_tool"):
+        if "patient_id" not in args and _CURRENT_PATIENT_ID:
+            args["patient_id"] = _CURRENT_PATIENT_ID
+    if tool.name == "triage_symptoms_tool":
+        if "patient_id" not in args:
+            args["patient_id"] = _CURRENT_PATIENT_ID
     if _DEBUG:
         try:
             logger.info("call_tool: name=%s args_keys=%s", tool.name, list(args.keys()))
@@ -328,12 +305,12 @@ def agent(messages: List[BaseMessage], previous: List[BaseMessage] | None, confi
     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)
+    # Establish default patient from config (or fallback to pt_jmarshall)
     conf = (config or {}).get("configurable", {}) if isinstance(config, dict) else {}
-    default_customer = conf.get("customer_id") or conf.get("user_email") or "cust_test"
+    default_patient = conf.get("patient_id") or conf.get("user_email") or "pt_jmarshall"
 
-    # Heuristic: infer customer_id from latest human name if provided (e.g., "I am Alice Stone")
-    inferred_customer: str | None = None
+    # Heuristic: infer patient_id from latest human name if provided (e.g., "I am John Marshall")
+    inferred_patient: 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
@@ -343,22 +320,15 @@ def agent(messages: List[BaseMessage], previous: List[BaseMessage] | None, confi
                 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
+            if len(tokens) >= 2 and False:
+                pass
     except Exception:
         pass
 
     # Update module context
-    global _CURRENT_THREAD_ID, _CURRENT_CUSTOMER_ID
+    global _CURRENT_THREAD_ID, _CURRENT_PATIENT_ID
     _CURRENT_THREAD_ID = thread_id
-    _CURRENT_CUSTOMER_ID = inferred_customer or default_customer
+    _CURRENT_PATIENT_ID = inferred_patient or default_patient
 
     llm_response = call_llm(convo).result()
 

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

@@ -1,167 +1,93 @@
 import os
 import sys
 import json
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 from langchain_core.tools import tool
 
-# Robust logic import to avoid crossing into other agent modules during hot reloads
+# Robust logic import isolated to this agent
 try:
-    from . import logic as wt_logic  # type: ignore
+    from . import logic as hc_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
+    _spec = _ilu.spec_from_file_location("healthcare_agent_logic", _logic_path)
+    hc_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
+    _spec.loader.exec_module(hc_logic)  # type: ignore
 
-
-@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))
+find_patient_by_name = hc_logic.find_patient_by_name
+find_patient_by_full_name = hc_logic.find_patient_by_full_name
+get_patient_profile = hc_logic.get_patient_profile
+authenticate_patient = hc_logic.authenticate_patient
+get_preferred_pharmacy = hc_logic.get_preferred_pharmacy
+list_providers = hc_logic.list_providers
+get_provider_slots = hc_logic.get_provider_slots
+schedule_appointment = hc_logic.schedule_appointment
+triage_symptoms = hc_logic.triage_symptoms
+log_call = hc_logic.log_call
 
 
 @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 {}."""
+def find_patient(first_name: str | None = None, last_name: str | None = None, full_name: str | None = None) -> str:
+    """Find a patient_id by name. Prefer full_name; otherwise use first+last. Returns JSON with patient_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 ""))
+        return json.dumps(find_patient_by_full_name(full_name))
+    return json.dumps(find_patient_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({})
+def get_patient_profile_tool(patient_id: str) -> str:
+    """Fetch patient profile, allergies, meds, visits, and vitals. Returns JSON string."""
+    return json.dumps(get_patient_profile(patient_id))
 
 
 @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)
+def verify_identity(session_id: str, patient_id: str | None = None, full_name: str | None = None, dob_yyyy_mm_dd: str | None = None, mrn_last4: str | None = None, secret_answer: str | None = None) -> str:
+    """Verify identity before accessing records. Provide any of: full_name, dob (YYYY-MM-DD or free-form), MRN last-4, secret answer. Returns JSON with verified flag, needed fields, and optional secret question."""
+    res = authenticate_patient(session_id, patient_id, full_name, dob_yyyy_mm_dd, mrn_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))
+def get_preferred_pharmacy_tool(patient_id: str) -> str:
+    """Get the patient's preferred pharmacy details. Returns JSON."""
+    return json.dumps(get_preferred_pharmacy(patient_id))
 
 
 @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))
+def list_providers_tool(specialty: str | None = None) -> str:
+    """List available providers. Optional filter by specialty. Returns JSON array."""
+    return json.dumps(list_providers(specialty))
 
 
 @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))
+def get_provider_slots_tool(provider_id: str, count: int = 3) -> str:
+    """Get upcoming appointment slots for a provider. Returns JSON array of ISO datetimes."""
+    return json.dumps(get_provider_slots(provider_id, count))
 
 
 @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))
+def schedule_appointment_tool(provider_id: str, slot_iso: str, patient_id: str | None = None) -> str:
+    """Schedule an appointment slot with a provider for a patient. Returns JSON with appointment_id."""
+    return json.dumps(schedule_appointment(provider_id, slot_iso, patient_id))
 
 
 @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))
+def triage_symptoms_tool(patient_id: str | None, symptoms_text: str) -> str:
+    """Run symptoms through triage rules. Returns {risk, advice, red_flags, rule}."""
+    return json.dumps(triage_symptoms(patient_id, symptoms_text))
 
 
 @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."""
+def log_call_tool(session_id: str, patient_id: str | None = None, notes: str | None = None, triage_json: str | None = None) -> str:
+    """Log the call details and triage outcome. triage_json is a JSON dict string. Returns {logged, log_id}."""
+    triage: Dict[str, Any] | None
     try:
-        beneficiary = json.loads(beneficiary_json)
+        triage = json.loads(triage_json or "null") if triage_json else None
     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))
+        triage = None
+    return json.dumps(log_call(session_id, patient_id, notes, triage))
 
 

examples/voice_agent_webrtc_langgraph/agents/requirements.txt

@@ -10,4 +10,5 @@ pytz
 docling
 pymongo
 yt_dlp
-requests
+requests
+protobuf==6.31.1