Update app.py

app.py

@@ -1,21 +1,20 @@
-# app.py — Biomedical Device Troubleshooting Assistant
-# Education-only · Manual (PDF/TXT) upload & search · Guardrails · Agentic planner (optional)
-# Deps: chainlit==1.0.200, python-dotenv==1.0.1, openai==1.35.13, pypdf>=4.2.0
+# app.py — Biomedical Device Troubleshooting Assistant (Education-only, Agentic)
+# Minimal deps: chainlit==1.0.200, python-dotenv==1.0.1, openai==1.35.13
+# .env: GEMINI_API_KEY=... (preferred) OR OPENAI_API_KEY=...
 
-import os, io, re, json
-from typing import Any, Callable, Dict, List, Optional
+import os, re, json
 from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional
 
 import chainlit as cl
 from dotenv import load_dotenv
 from openai import AsyncOpenAI as _SDKAsyncOpenAI
-from pypdf import PdfReader
 
 # =========================
-# Minimal "agents" shim (no external package needed)
+# Small “agents” shim
 # =========================
-def set_tracing_disabled(disabled: bool = True):
-    return disabled
+def set_tracing_disabled(_: bool = True):  # placeholder (no-op)
+    return True
 
 def function_tool(func: Callable):
     func._is_tool = True
@@ -26,10 +25,10 @@ class AsyncOpenAI:
         kwargs = {"api_key": api_key}
         if base_url:
             kwargs["base_url"] = base_url
-        self._client = _SDKAsyncOpenAI(**kwargs)
+        self._c = _SDKAsyncOpenAI(**kwargs)
     @property
     def client(self):
-        return self._client
+        return self._c
 
 class OpenAIChatCompletionsModel:
     def __init__(self, model: str, openai_client: AsyncOpenAI):
@@ -42,11 +41,16 @@ class Agent:
     instructions: str
     model: OpenAIChatCompletionsModel
     tools: Optional[List[Callable]] = field(default_factory=list)
-
-    def tool_specs(self) -> List[Dict[str, Any]]:
-        specs = []
-        for t in (self.tools or []):
-            if getattr(t, "_is_tool", False):
+    _tool_specs: Optional[List[Dict[str, Any]]] = field(default=None, init=False)
+
+    def tool_specs(self) -> Optional[List[Dict[str, Any]]]:
+        if not self.tools:
+            return None
+        if self._tool_specs is None:
+            specs: List[Dict[str, Any]] = []
+            for t in self.tools:
+                if not getattr(t, "_is_tool", False):
+                    continue
                 argnames = list(t.__code__.co_varnames[:t.__code__.co_argcount])
                 specs.append({
                     "type": "function",
@@ -60,39 +64,39 @@ class Agent:
                         },
                     },
                 })
-        return specs
+            self._tool_specs = specs
+        return self._tool_specs
 
 class Runner:
     @staticmethod
-    async def run(agent: Agent, user_input: str, context: Optional[Dict[str, Any]] = None):
+    async def run(agent: Agent, user_input: str, context: Optional[Dict[str, Any]] = None, turns: int = 5):
         msgs = [
             {"role": "system", "content": agent.instructions},
             {"role": "user", "content": user_input},
         ]
-        tools = agent.tool_specs()
+        tool_specs = agent.tool_specs()
         tool_map = {t.__name__: t for t in (agent.tools or []) if getattr(t, "_is_tool", False)}
 
-        # small Plan→Act→Observe budget
-        for _ in range(6):
+        for _ in range(max(1, min(8, turns))):
             resp = await agent.model.client.chat.completions.create(
                 model=agent.model.model,
                 messages=msgs,
-                tools=tools or None,
-                tool_choice="auto" if tools else None,
+                tools=tool_specs or None,
+                tool_choice="auto" if tool_specs else None,
             )
             msg = resp.choices[0].message
             msgs.append({"role": "assistant", "content": msg.content or "", "tool_calls": msg.tool_calls})
 
             if msg.tool_calls:
+                # Plan→Act→Observe
                 for call in msg.tool_calls:
                     fn_name = call.function.name
                     args = json.loads(call.function.arguments or "{}")
                     result = {"error": f"Unknown tool: {fn_name}"}
-                    if fn_name in tool_map:
-                        try:
-                            result = tool_map[fn_name](**args)
-                        except Exception as e:
-                            result = {"error": str(e)}
+                    tool = tool_map.get(fn_name)
+                    if tool:
+                        try: result = tool(**args)
+                        except Exception as e: result = {"error": str(e)}
                     msgs.append({
                         "role": "tool",
                         "tool_call_id": call.id,
@@ -114,150 +118,79 @@ class Runner:
         return out
 
 # =========================
-# Provider setup (Gemini or OpenAI)
+# Model setup (Gemini via OpenAI-compatible OR OpenAI)
 # =========================
-load_dotenv()
-GEMINI_API_KEY = os.getenv("Gem")
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-
-if GEMINI_API_KEY:
-    API_KEY = GEMINI_API_KEY
-    BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai/"
-    MODEL_ID = "gemini-2.5-flash"
-elif OPENAI_API_KEY:
-    API_KEY = OPENAI_API_KEY
-    BASE_URL = None
-    MODEL_ID = "gpt-4o-mini"
-else:
-    raise RuntimeError("Missing GEMINI_API_KEY or OPENAI_API_KEY in environment.")
-
+def setup_model() -> OpenAIChatCompletionsModel:
+    load_dotenv()
+    gem = os.getenv("Gem")
+    oai = os.getenv("OPENAI_API_KEY")
+    if gem:
+        client = AsyncOpenAI(api_key=gem, base_url="https://generativelanguage.googleapis.com/v1beta/openai/")
+        return OpenAIChatCompletionsModel("gemini-2.5-flash", client)
+    if oai:
+        client = AsyncOpenAI(api_key=oai)
+        return OpenAIChatCompletionsModel("gpt-4o-mini", client)
+    raise RuntimeError("Add GEMINI_API_KEY or OPENAI_API_KEY to your .env")
+
+llm_model = setup_model()
 set_tracing_disabled(True)
-ext_client = AsyncOpenAI(api_key=API_KEY, base_url=BASE_URL)
-llm_model = OpenAIChatCompletionsModel(model=MODEL_ID, openai_client=ext_client)
 
 # =========================
-# Guardrails (topic & safety)
+# Guardrails (fast & local)
 # =========================
-ALLOWED_COMMANDS = ("/help", "/policy", "/manual", "/clear", "/hits", "/agent", "/simple")
-
-TOPIC_KEYWORDS = [
-    "biomedical","biomed","device","equipment","oem","service manual",
-    "troubleshoot","fault","error","alarm","probe","sensor","lead","cable",
-    "battery","power","calibration","qc","verification","analyzer","self-test",
-    "ventilator","defibrillator","infusion","pump","ecg","oximeter","nibp",
-    "monitor","ultrasound","anesthesia","syringe","suction","spirometer","glucometer"
-]
-
-RE_FORBIDDEN_CLINICAL = re.compile(r"\b(diagnos(e|is|tic)|prescrib|medicat|treat(ment|ing)?|dose|drug|therapy)\b", re.I)
-RE_INVASIVE_REPAIR    = re.compile(r"\b(open(ing)?\s+(device|casing|cover)|solder|reflow|board[- ]level|replace\s+(capacitor|ic))\b", re.I)
-RE_ALARM_BYPASS       = re.compile(r"\b(bypass|disable|silence)\s+(alarm|alert|safety|interlock)\b", re.I)
-RE_FIRMWARE_TAMPER    = re.compile(r"\b(firmware|bootloader|root|jailbreak|unlock\s+(service|engineer)\s*mode|password\s*override|backdoor)\b", re.I)
-RE_EMAIL = re.compile(r"[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}", re.I)
-RE_PHONE = re.compile(r"(?:\+\d{1,3}[-\s.]*)?(?:\(?\d{3,4}\)?[-\s.]*)?\d{3}[-\s.]?\d{4}")
-RE_IDHINT = re.compile(r"\b(CNIC|MRN|passport|nid|national\s*id|social\s*security|aadhaar)\b", re.I)
+COMMANDS = ("/help", "/policy", "/agent", "/simple", "/tools")
+
+TOPIC_TOKENS = tuple("""
+biomedical biomed device equipment oem troubleshoot fault error alarm probe sensor lead cable battery power calibration qc
+verification analyzer self-test ventilator defibrillator infusion pump ecg oximeter nibp monitor ultrasound anesthesia syringe
+suction spirometer glucometer flow pressure temperature module waveform leak occlusion charger display keypad
+""".split())
+
+RE_FORBIDDEN = {
+    "clinical_advice": re.compile(r"\b(diagnos(e|is|tic)|prescrib|medicat|treat(ment|ing)?|dose|drug|therapy)\b", re.I),
+    "invasive_repair": re.compile(r"\b(open(ing)?\s+(device|casing|cover)|solder|reflow|board[- ]level|replace\s+(capacitor|ic))\b", re.I),
+    "alarm_bypass":   re.compile(r"\b(bypass|disable|silence)\s+(alarm|alert|safety|interlock)\b", re.I),
+    "firmware":       re.compile(r"\b(firmware|bootloader|root|jailbreak|unlock\s+(service|engineer)\s*mode|password\s*override|backdoor)\b", re.I),
+}
+RE_PHI = {
+    "email": re.compile(r"[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}", re.I),
+    "phone": re.compile(r"(?:\+\d{1,3}[-\s.]*)?(?:\(?\d{3,4}\)?[-\s.]*)?\d{3}[-\s.]?\d{4}"),
+    "id":    re.compile(r"\b(CNIC|MRN|passport|nid|national\s*id|social\s*security|aadhaar)\b", re.I),
+}
 
 def on_topic(text: str) -> bool:
     low = (text or "").lower().strip()
-    if not low:
-        return False
-    if any(low.startswith(cmd) for cmd in ALLOWED_COMMANDS):
-        return True
-    return any(k in low for k in TOPIC_KEYWORDS)
+    return bool(low) and (low.startswith(COMMANDS) or any(t in low for t in TOPIC_TOKENS))
 
-def local_guard(text: str) -> List[str]:
+def guard_issues(text: str) -> List[str]:
     low = (text or "").lower()
-    issues = []
-    if RE_FORBIDDEN_CLINICAL.search(low): issues.append("clinical_advice")
-    if RE_INVASIVE_REPAIR.search(low):    issues.append("invasive_repair")
-    if RE_ALARM_BYPASS.search(low):       issues.append("alarm_bypass")
-    if RE_FIRMWARE_TAMPER.search(low):    issues.append("firmware_tamper")
-    if RE_EMAIL.search(text) or RE_PHONE.search(text) or RE_IDHINT.search(text):
-        issues.append("phi_share_or_collect")
+    issues = [k for k, rx in RE_FORBIDDEN.items() if rx.search(low)]
+    if any(rx.search(text) for rx in RE_PHI.values()):
+        issues.append("phi")
     return issues
 
 # =========================
-# Manual handling & search (robust PDF detection)
-# =========================
-def extract_pdf_pages(data: bytes):
-    pages = []
-    reader = PdfReader(io.BytesIO(data))
-    for i, pg in enumerate(reader.pages, start=1):
-        try:
-            txt = pg.extract_text() or ""
-        except Exception:
-            txt = ""
-        pages.append({"page": i, "text": txt})
-    return pages
-
-def extract_txt_pages(data: bytes, chunk_chars: int = 1600):
-    try: txt = data.decode("utf-8", errors="ignore")
-    except Exception: txt = ""
-    chunks = [{"page": i+1, "text": txt[i:i+chunk_chars]} for i in range(0, len(txt), chunk_chars)]
-    return chunks or [{"page": 1, "text": ""}]
-
-def _is_pdf(file_obj, data: bytes) -> bool:
-    # Chainlit may expose .type or nothing; avoid relying on .mime
-    name = getattr(file_obj, "name", "") or getattr(file_obj, "filename", "")
-    typ  = getattr(file_obj, "type", "") or ""
-    return (
-        name.lower().endswith(".pdf")
-        or typ == "application/pdf"
-        or (isinstance(data, (bytes, bytearray)) and data[:5] == b"%PDF-")
-    )
-
-def manual_hits(pages, query: str, topk: int = 3):
-    if not pages: return []
-    terms = [w for w in re.findall(r"\w+", (query or "").lower()) if len(w) > 2]
-    scored = []
-    for p in pages:
-        low = (p.get("text") or "").lower()
-        score = sum(low.count(t) for t in terms)
-        if score > 0: scored.append((score, p))
-    scored.sort(key=lambda x: x[0], reverse=True)
-    hits = [p for _, p in scored[:topk]] or pages[:1]
-    def excerpt(text: str, window: int = 420):
-        t = text or ""
-        low = t.lower()
-        idxs = [low.find(tk) for tk in terms if tk in low]
-        start = max(0, min([i for i in idxs if i >= 0], default=0) - window)
-        end = min(len(t), start + 2*window)
-        snippet = re.sub(r"\s+", " ", t[start:end]).strip()
-        snippet = RE_EMAIL.sub("[REDACTED_EMAIL]", snippet)
-        snippet = RE_PHONE.sub("[REDACTED_PHONE]", snippet)
-        snippet = RE_IDHINT.sub("[ID]", snippet)
-        return snippet
-    return [f"[p.{h['page']}] {excerpt(h.get('text',''))}" for h in hits]
-
-# =========================
-# Tools the agent can call
+# Education-only tools
 # =========================
-def _current_manual_pages():
-    m = cl.user_session.get("manual")
-    return (m or {}).get("pages", [])
-
-@function_tool
-def search_manual(query: str, topk: str = "3") -> dict:
-    """Search the uploaded manual (PDF/TXT) for the query. Returns {'hits': [snippets...]}. If no manual, hits=[]"""
-    pages = _current_manual_pages()
-    k = int(topk) if str(topk).isdigit() else 3
-    hits = manual_hits(pages, query, topk=k) if pages else []
-    return {"hits": hits}
+def _bullets(items: List[str]) -> str:
+    return "\n".join(f"- {x}" for x in (items or [])) or "-"
 
 @function_tool
 def quick_reference(device_and_symptom: str) -> dict:
     """
-    Deterministic education-only bullets based on free-text device description.
+    Generic, non-invasive reference for troubleshooting.
     """
-    d = (device_and_symptom or "").lower()
-    life_critical = any(k in d for k in ["ventilator","defibrillator","infusion pump"])
+    s = (device_and_symptom or "").lower()
+    life = any(k in s for k in ["ventilator", "defibrillator", "infusion pump"])
     return {
         "safety": [
-            "If attached to a patient, ensure backup/alternative monitoring before checks.",
-            "No invasive service; do not open casing; follow OEM and facility policy.",
-            "Do not bypass or silence alarms beyond OEM instructions."
-        ] + (["Life-support device: remove from service and use backup if malfunction suspected."] if life_critical else []),
+            "If attached to a patient, ensure backup monitoring before checks.",
+            "Do not open the casing; follow OEM & facility policy.",
+            "Do not bypass or silence alarms beyond OEM instructions.",
+            *(["Life-support device: remove from service and use backup if malfunction suspected."] if life else [])
+        ],
         "common_faults": [
-            "Power/battery supply issues or loose connections.",
+            "Power/battery issues or loose connections.",
             "Damaged/incorrect accessories (leads, probes, tubing).",
             "Configuration/profile mismatch for the clinical setup.",
             "Environmental interference (EMI), filters/clogs, or mechanical obstruction."
@@ -265,67 +198,189 @@ def quick_reference(device_and_symptom: str) -> dict:
         "quick_checks": [
             "Note model/serial/firmware and any error codes.",
             "Verify power source/battery; try another outlet; reseat user-removable battery.",
-            "Inspect and reseat accessories; swap with a known-good if available.",
-            "Confirm settings match procedure; restore defaults if safe.",
-            "Run device self-test if available and review OEM quick-reference."
+            "Inspect & reseat accessories; swap with a known-good.",
+            "Confirm settings; restore defaults if safe.",
+            "Run device self-test and review OEM quick-reference."
         ],
         "qc": [
-            "Verify against a reference/simulator where applicable (ECG, SpO2, NIBP, flow, etc.).",
-            "Confirm scheduled electrical safety tests per policy.",
-            "Document results and compare with historical QC."
+            "Verify against a reference/simulator where applicable (ECG, SpO₂, NIBP, flow).",
+            "Perform electrical safety tests per policy.",
+            "Document & compare with prior QC."
         ],
         "escalate": [
             "Any failed self-test or QC/safety test.",
-            "Persistent faults after basic checks or physical damage/liquid ingress.",
-            "Life-critical pathway: remove from service immediately and escalate to Biomed/OEM."
-        ]
+            "Persistent faults after basic checks or visible damage/liquid ingress.",
+            "Life-critical pathway: remove from service and escalate to Biomed/OEM."
+        ],
     }
 
 @function_tool
 def safety_policy() -> dict:
-    """Return a concise policy block enforced by the assistant."""
+    """Concise policy enforced by the assistant."""
     return {"policy": [
         "Education-only troubleshooting; no clinical advice.",
-        "No invasive repairs, no alarm bypass, no firmware tampering.",
+        "No invasive repairs; no alarm bypass; no firmware tampering.",
         "No collecting/sharing personal identifiers.",
-        "OEM manuals and local policy take precedence."
+        "OEM manuals & local policy take precedence."
     ]}
 
 @function_tool
 def record_step(note: str) -> dict:
-    """Append an action/observation to the agent trace shown to the user."""
+    """Append an action/observation to an agent trace (shown to user)."""
     trace: List[str] = cl.user_session.get("agent_trace") or []
-    clean = re.sub(r"\s+", " ", (note or "")).strip()
+    clean = " ".join((note or "").split())
     if clean:
         trace.append(clean[:500])
         cl.user_session.set("agent_trace", trace)
     return {"ok": True, "len": len(trace)}
 
+@function_tool
+def error_code_lookup(model: str, code: str) -> dict:
+    """
+    Friendly generic notes for common codes (extendable).
+    """
+    key = f"{(model or '').strip().lower()}::{(code or '').strip().lower()}"
+    KB = {
+        "generic::e01": {"meaning": "General startup/self-test failure.",
+                         "notes": ["Safe power-cycle (off-patient). Check mains/battery, connections. Re-run self-test. Escalate if persistent."]},
+        "generic::occlusion": {"meaning": "Flow obstruction detected.",
+                               "notes": ["Check clamps/kinks/filters. Reload set per OEM. Do not bypass alarms."]},
+        "monitor::leads_off": {"meaning": "ECG leads not detected / poor contact.",
+                               "notes": ["Verify placement & skin prep. Swap known-good leads. Route away from mains/EMI."]},
+    }
+    data = KB.get(key) or KB.get(f"generic::{(code or '').strip().lower()}")
+    if not data:
+        return {"found": False, "message": "No local entry. Use OEM quick-ref.", "examples": list(KB.keys())}
+    return {"found": True, "model": model, "code": code, "meaning": data["meaning"], "education_notes": data["notes"]}
+
+@function_tool
+def acronym_expand(term: str) -> dict:
+    """Explain common biomed/acquisition acronyms (study aid)."""
+    t = (term or "").strip().lower()
+    MAP = {
+        "ecg": "Electrocardiogram.",
+        "nibp": "Non-Invasive Blood Pressure.",
+        "spo2": "Peripheral oxygen saturation (pulse oximetry).",
+        "peep": "Positive End-Expiratory Pressure (ventilation).",
+        "fio2": "Fraction of inspired oxygen.",
+        "vt": "Tidal Volume.",
+        "hu": "Hounsfield Units (CT).",
+        "snr": "Signal-to-Noise Ratio.",
+        "tr": "Repetition Time (MRI).",
+        "te": "Echo Time (MRI).",
+        "flair": "Fluid-Attenuated Inversion Recovery (MRI).",
+        "adc": "Apparent Diffusion Coefficient (MRI).",
+    }
+    return {"term": term, "meaning": MAP.get(t, "Not in the quick list. Use OEM/teaching refs.")}
+
+@function_tool
+def unit_convert(value: str, from_unit: str, to_unit: str) -> dict:
+    """
+    Limited, safe conversions used in QC:
+    mmHg↔kPa (1 kPa = 7.50062 mmHg) | L/min↔mL/s (1 L/min = 16.6667 mL/s) | mV↔µV (1 mV = 1000 µV)
+    """
+    def f(x): return float(str(x).strip())
+    v = f(value); fu = (from_unit or "").lower(); tu = (to_unit or "").lower()
+    if fu == "mmhg" and tu == "kpa":  return {"ok": True, "result": v/7.50062}
+    if fu == "kpa"  and tu == "mmhg": return {"ok": True, "result": v*7.50062}
+    if fu in ["l/min","lpm"] and tu in ["ml/s","mlps"]: return {"ok": True, "result": v*1000/60}
+    if fu in ["ml/s","mlps"] and tu in ["l/min","lpm"]: return {"ok": True, "result": v*60/1000}
+    if fu == "mv" and tu in ["µv","uv"]: return {"ok": True, "result": v*1000}
+    if fu in ["µv","uv"] and tu == "mv": return {"ok": True, "result": v/1000}
+    return {"ok": False, "error": "Unsupported units. Try mmHg↔kPa, L/min↔mL/s, mV↔µV."}
+
+@function_tool
+def triage_priority(device_and_symptom: str) -> dict:
+    """Heuristic priority: life-critical / high / standard (education-only)."""
+    s = (device_and_symptom or "").lower()
+    life = any(k in s for k in ["ventilator","defibrillator","infusion pump"])
+    high = any(k in s for k in ["alarm","occlusion","no output","no reading","self-test fail","charging issue"])
+    return {"priority": "life-critical" if life else ("high" if high else "standard"),
+            "explain": "Heuristic only. Follow local escalation policy."}
+
+@function_tool
+def simulator_baselines(device: str) -> dict:
+    """Educational simulator targets (generic, not OEM-specific)."""
+    d = (device or "").lower()
+    bank = {
+        "ecg": ["1 mV @ 10 mm/mV (paper 25 mm/s).", "Check lead-fault detection & baseline stability."],
+        "nibp": ["Phantom ~120/80 mmHg within policy tolerance.", "Leak test & overpressure safety."],
+        "spo2": ["Simulator steps e.g., 97%, 90%, 85% (device-dependent).", "Verify pleth and probe integrity."],
+        "ventilator": ["Tidal volume/flow with analyzer; verify alarms.", "Circuit leak test; filters per policy."],
+    }
+    for k, v in bank.items():
+        if k in d: return {"device": device, "baselines": v}
+    return {"device": device, "baselines": ["Use appropriate reference/simulator.", "Document vs prior QC; check alarm trips."]}
+
+@function_tool
+def env_checklist(_: str) -> dict:
+    """Environment/power/EMI checklist for safe troubleshooting."""
+    return {"checks": [
+        "Verify mains outlet & ground; power indicator on.",
+        "Avoid extension cords; try a known-good outlet.",
+        "Route signal cables away from mains/transformers.",
+        "Eliminate strong RF/EMI sources nearby.",
+        "Check filters/vents; ambient temp/humidity within spec."
+    ]}
+
+@function_tool
+def accessory_checklist(_: str) -> dict:
+    """Generic accessory fit/damage/compatibility checklist."""
+    return {"checks": [
+        "Inspect connectors for bent pins/corrosion; ensure tight seating.",
+        "Check cables/tubing for cuts/kinks; confirm model compatibility.",
+        "Swap to a known-good accessory.",
+        "Respect single-use vs reusable policy."
+    ]}
+
+@function_tool
+def build_qc_template(device: str) -> dict:
+    """Markdown QC template students can copy into notes/CMMS (education-only)."""
+    d = (device or "Device").strip()
+    md = f"""### QC/Verification — {d}
+- Date / Tech:
+- Model / Serial / FW:
+- Visual Inspection: (✔/✖) Notes:
+- Electrical Safety: (✔/✖) Leakage / Ground:
+- Functional Checks:
+  - Reference/Simulator values → Measured:
+  - Alarms exercised →
+- Accessories (list & status):
+- Final Assessment: Pass / Conditional / Fail
+- Next Steps / Escalation:
+"""
+    return {"markdown": md}
+
 # =========================
-# Agentic planner & simple fallback
+# Agentic planner + simple fallback
 # =========================
 PLANNER_INSTRUCTIONS = (
-    "You are an agentic biomedical device troubleshooting planner for clinical engineers.\n"
-    "STRICT SCOPE: Education-only. Do NOT give clinical advice, do NOT instruct invasive repairs, do NOT bypass alarms, "
-    "do NOT suggest firmware tampering. Respect policy.\n\n"
+    "You are an **agentic biomedical device troubleshooting planner** for clinical engineers.\n"
+    "SCOPE (strict): education-only. No clinical advice. No invasive repairs. No alarm bypass. No firmware tampering. No PHI.\n"
     "Loop up to 3 times:\n"
-    "- PLAN: Decide what you need (e.g., search_manual for error keywords, or quick_reference).\n"
-    "- ACT: Call a tool (search_manual, quick_reference, safety_policy, record_step).\n"
-    "- OBSERVE: Read tool result. Summarize via record_step.\n"
-    "Then produce a final plan with exactly these sections:\n"
+    "- PLAN what you need (e.g., quick_reference, safety_policy, acronym_expand, error_code_lookup, unit_convert, triage_priority,\n"
+    "  simulator_baselines, env_checklist, accessory_checklist, build_qc_template).\n"
+    "- ACT by calling a tool.\n"
+    "- OBSERVE and add a short summary via record_step.\n\n"
+    "Finally output exactly these sections:\n"
     "1) Safety First\n"
     "2) Likely Causes (ranked)\n"
     "3) Step-by-Step Checks (non-invasive; no alarm bypass)\n"
     "4) QC/Calibration\n"
     "5) Escalate When\n"
-    "End with a one-line summary. If life-critical & patient-connected is implied, start with: "
+    "End with a one-line summary. If life-critical & patient-connected is implied, start with:\n"
     "REMOVE FROM SERVICE & USE BACKUP — then proceed off-patient.\n"
 )
+
 planner_agent = Agent(
     name="Agentic Planner",
     instructions=PLANNER_INSTRUCTIONS,
     model=llm_model,
-    tools=[search_manual, quick_reference, safety_policy, record_step],
+    tools=[
+        quick_reference, safety_policy, record_step, error_code_lookup, acronym_expand,
+        unit_convert, triage_priority, simulator_baselines, env_checklist,
+        accessory_checklist, build_qc_template
+    ],
 )
 
 SIMPLE_SYSTEM = (
@@ -333,13 +388,11 @@ SIMPLE_SYSTEM = (
     "Output sections: Safety First; Likely Causes; Step-by-Step Checks; QC/Calibration; Escalate When; one-line summary."
 )
 
-async def simple_llm_plan(user_desc: str, manual_excerpts: str = "") -> str:
-    user_block = f"Device & symptom:\n{user_desc.strip()}"
-    if manual_excerpts:
-        user_block += f"\n\nManual excerpts:\n{manual_excerpts.strip()}"
-    resp = await ext_client.client.chat.completions.create(
-        model=MODEL_ID,
-        messages=[{"role":"system","content":SIMPLE_SYSTEM},{"role":"user","content":user_block}],
+async def simple_plan(user_desc: str) -> str:
+    resp = await llm_model.client.chat.completions.create(
+        model=llm_model.model,
+        messages=[{"role": "system", "content": SIMPLE_SYSTEM},
+                  {"role": "user", "content": f"Device & symptom:\n{user_desc.strip()}"}],
     )
     return resp.choices[0].message.content or ""
 
@@ -348,38 +401,50 @@ async def simple_llm_plan(user_desc: str, manual_excerpts: str = "") -> str:
 # =========================
 WELCOME = (
     "🛠️ **Biomedical Device Troubleshooting Assistant** (Agentic)\n"
-    "Education-only. No diagnosis, no invasive service, no alarm bypass. OEM manual & policy rule the day.\n\n"
+    "Education-only. No diagnosis, no invasive service, no alarm bypass. OEM & policy rule the day.\n\n"
     "Type your **device & symptom** (e.g., “Infusion pump occlusion alarm”).\n"
-    "Commands: **/manual** upload PDF/TXT, **/hits** show manual matches, **/clear** remove manual,\n"
-    "**/agent** agentic mode (default), **/simple** single-pass mode, **/policy** view rules."
+    "Commands: **/agent** agentic (default) · **/simple** single-pass · **/policy** rules · **/tools** list tools · **/help**"
 )
 POLICY = (
     "🛡️ **Safety & Scope Policy**\n"
-    "- Scope: biomedical **device troubleshooting** (education-only).\n"
+    "- Scope: biomedical device troubleshooting (education-only).\n"
     "- No clinical advice (diagnosis/treatment/dosing/medications).\n"
-    "- No invasive repairs (opening casing, soldering, board-level).\n"
-    "- No alarm bypass or firmware tampering.\n"
-    "- No collecting/sharing personal identifiers.\n"
+    "- No invasive repairs; no alarm bypass; no firmware tampering.\n"
+    "- No collecting/sharing personal identifiers (PHI).\n"
     "- OEM manuals & local policy take priority."
 )
 REFUSAL = (
-    "🚫 I can’t help with diagnosis/treatment, invasive repair, alarm bypass, firmware hacks, or collecting personal data.\n"
-    "I can guide **safe, non-invasive troubleshooting** and educational QC steps."
+    "🚫 I can’t help with diagnosis/treatment, invasive repair, alarm bypass, firmware hacks, or handling personal identifiers.\n"
+    "I can guide safe, non-invasive troubleshooting and educational QC steps."
+)
+
+TOOLS_LIST = (
+    "🔧 **Available Tools**\n"
+    "- quick_reference(text)\n"
+    "- safety_policy()\n"
+    "- record_step(note)\n"
+    "- error_code_lookup(model, code)\n"
+    "- acronym_expand(term)\n"
+    "- unit_convert(value, from_unit, to_unit)\n"
+    "- triage_priority(text)\n"
+    "- simulator_baselines(device)\n"
+    "- env_checklist(context)\n"
+    "- accessory_checklist(device)\n"
+    "- build_qc_template(device)\n"
 )
 
 # =========================
 # Chainlit flow
 # =========================
 @cl.on_chat_start
-async def start():
-    cl.user_session.set("manual", None)
-    cl.user_session.set("agent_mode", "agent")   # 'agent' | 'simple'
+async def on_start():
+    cl.user_session.set("mode", "agent")       # 'agent' | 'simple'
     cl.user_session.set("agent_trace", [])
     await cl.Message(content=WELCOME).send()
 
 @cl.on_message
-async def main(message: cl.Message):
-    text = (message.content or "").strip()
+async def on_message(msg: cl.Message):
+    text = (msg.content or "").strip()
     low = text.lower()
 
     # Commands
@@ -387,109 +452,54 @@ async def main(message: cl.Message):
         await cl.Message(content=WELCOME).send(); return
     if low.startswith("/policy"):
         await cl.Message(content=POLICY).send(); return
+    if low.startswith("/tools"):
+        await cl.Message(content=TOOLS_LIST).send(); return
     if low.startswith("/agent"):
-        cl.user_session.set("agent_mode", "agent")
-        await cl.Message(content="✅ Agentic mode enabled (planner will Plan→Act→Observe).").send(); return
+        cl.user_session.set("mode", "agent")
+        await cl.Message(content="✅ Agentic mode enabled.").send(); return
     if low.startswith("/simple"):
-        cl.user_session.set("agent_mode", "simple")
-        await cl.Message(content="✅ Simple mode enabled (single LLM pass).").send(); return
-
-    if low.startswith("/manual"):
-        files = await cl.AskFileMessage(
-            content="Upload the **service manual** (PDF or TXT). Max ~20 MB.",
-            accept=["application/pdf", "text/plain"],  # UI hint only
-            max_files=1, max_size_mb=20, timeout=240
-        ).send()
-        if not files:
-            await cl.Message(content="No file received.").send(); return
-
-        f = files[0]
-        data = getattr(f, "content", None)
-        if data is None and getattr(f, "path", None):
-            with open(f.path, "rb") as fh:
-                data = fh.read()
-        if not data:
-            await cl.Message(content="Received file but got empty content. Please re-upload.").send(); return
+        cl.user_session.set("mode", "simple")
+        await cl.Message(content="✅ Simple mode enabled.").send(); return
 
-        try:
-            if _is_pdf(f, data):
-                pages = extract_pdf_pages(data)
-            else:
-                pages = extract_txt_pages(data)
-        except Exception as e:
-            await cl.Message(content=f"Couldn't read the manual: {e}").send(); return
-
-        cl.user_session.set("manual", {"name": getattr(f, "name", "manual"), "pages": pages})
-        await cl.Message(content=f"✅ Manual indexed: **{getattr(f, 'name', 'manual')}** — {len(pages)} page-chunks.").send()
-        return
-
-    if low.startswith("/clear"):
-        cl.user_session.set("manual", None)
-        await cl.Message(content="Manual cleared.").send()
-        return
-
-    if low.startswith("/hits"):
-        m = cl.user_session.get("manual")
-        if not m or not m.get("pages"):
-            await cl.Message(content="No manual attached. Use **/manual** to upload one.").send(); return
-        query = text.replace("/hits", "").strip() or "device fault error alarm"
-        hits = manual_hits(m["pages"], query, topk=3) or ["No obvious matches — try different wording."]
-        await cl.Message(content="### 🔎 Manual Matches\n" + "\n\n".join(hits)).send()
-        return
-
-    # Topic & safety guard
+    # Guardrails
     if not on_topic(text):
         await cl.Message(
             content="I only support **biomedical device troubleshooting**. "
-                    "Describe the device & symptom (e.g., “ECG noisy baseline”), or upload a manual with **/manual**."
-        ).send()
-        return
-    issues = local_guard(text)
-    if issues:
-        await cl.Message(content=REFUSAL + "\n\n" + POLICY).send()
-        return
+                    "Describe the device & symptom (e.g., “ECG noisy baseline”)."
+        ).send(); return
 
-    # Manual context (for simple fallback)
-    manual = cl.user_session.get("manual")
-    manual_name = manual.get("name") if manual else None
-    excerpts = ""
-    if manual and manual.get("pages"):
-        excerpts = "\n".join(manual_hits(manual["pages"], text, topk=3))
+    issues = guard_issues(text)
+    if issues:
+        await cl.Message(content=REFUSAL + "\n\n" + POLICY).send(); return
 
-    mode = cl.user_session.get("agent_mode") or "agent"
+    mode = cl.user_session.get("mode") or "agent"
     trace_before = len(cl.user_session.get("agent_trace") or [])
 
     if mode == "agent":
         try:
-            # Agentic planner will call tools (search_manual/quick_reference/record_step) itself
-            result = await Runner.run(planner_agent, text)
+            result = await Runner.run(planner_agent, text, turns=5)
             answer = result.final_output or "I couldn’t generate a plan."
         except Exception as e:
-            await cl.Message(content=f"⚠️ Planner failed: {e}\nFalling back to simple mode.").send()
-            answer = await simple_llm_plan(text, excerpts)
+            await cl.Message(content=f"⚠️ Planner error: {e}\nFalling back to simple mode.").send()
+            answer = await simple_plan(text)
     else:
-        answer = await simple_llm_plan(text, excerpts)
+        answer = await simple_plan(text)
 
-    # Agent trace (new steps only)
+    # Agent trace (new steps)
     trace = cl.user_session.get("agent_trace") or []
     new_trace = trace[trace_before:]
-    trace_md = ""
-    if new_trace:
-        trace_md = "### 🧭 Agent Trace (summary)\n" + "\n".join(f"- {t}" for t in new_trace) + "\n\n"
+    trace_md = "### 🧭 Agent Trace (summary)\n" + "\n".join(f"- {t}" for t in new_trace) + "\n\n" if new_trace else ""
 
-    # Deterministic quick reference
+    # Deterministic quick reference (always helpful)
     qref = quick_reference(text)
-    def bullets(arr: List[str]): return "\n".join(f"- {x}" for x in (arr or [])) or "-"
-
     quick_md = (
         f"### 📘 Quick Reference\n"
-        f"**Safety**\n{bullets(qref.get('safety'))}\n\n"
-        f"**Common Faults**\n{bullets(qref.get('common_faults'))}\n\n"
-        f"**Quick Checks**\n{bullets(qref.get('quick_checks'))}\n\n"
-        f"**QC / Calibration**\n{bullets(qref.get('qc'))}\n\n"
-        f"**Escalate If**\n{bullets(qref.get('escalate'))}\n\n"
-        f"> ⚠️ Education-only. Refer to OEM manual & policy. No invasive service.\n"
+        f"**Safety**\n{_bullets(qref.get('safety'))}\n\n"
+        f"**Common Faults**\n{_bullets(qref.get('common_faults'))}\n\n"
+        f"**Quick Checks**\n{_bullets(qref.get('quick_checks'))}\n\n"
+        f"**QC / Calibration**\n{_bullets(qref.get('qc'))}\n\n"
+        f"**Escalate If**\n{_bullets(qref.get('escalate'))}\n\n"
+        f"> ⚠️ Education-only. Follow OEM & local policy.\n"
     )
 
-    prefix = f"📄 Using manual: **{manual_name}**\n\n" if manual_name else ""
-    await cl.Message(content=f"{trace_md}{quick_md}\n---\n{prefix}{answer}").send()
+    await cl.Message(content=f"{trace_md}{quick_md}\n---\n{answer}").send()