Upload folder using huggingface_hub

Updates/app.py

@@ -0,0 +1,937 @@
+import os
+import re
+import json
+import math
+import time
+import hashlib
+import tempfile
+from dataclasses import dataclass
+from datetime import datetime, date
+from functools import lru_cache
+from typing import Any, Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+import fitz  # PyMuPDF
+import faiss
+from sentence_transformers import SentenceTransformer
+from rapidfuzz import fuzz, process
+
+import gradio as gr
+from openai import OpenAI
+
+# ============================================================
+# Only-Routers (Chat, production-lean)
+# - Fast model by default (no reasoning payload)
+# - One LLM call max per lookup (enrichment only, cached)
+# - No HTTP crawling during normal lookup (links are deterministic)
+# - Timing logs to HF console when DEBUG_TIMING=1
+# ============================================================
+
+# ----------------------------
+# Settings
+# ----------------------------
+TODAY = date(2026, 1, 18)
+
+# Fast default model (override via env)
+OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-5.2").strip()
+
+# Disable LLM at runtime: OPENAI_DISABLE=1
+OPENAI_DISABLE = os.getenv("OPENAI_DISABLE", "0").strip() == "1"
+
+# Timing logs
+DEBUG_TIMING = os.getenv("DEBUG_TIMING", "0").strip() == "1"
+
+# Matching thresholds
+MATCH_OK = 82
+MATCH_AUTOPICK = 95
+MATCH_GAP = 8
+
+# Embeddings
+EMBED_MODEL_NAME = os.getenv("EMBED_MODEL_NAME", "sentence-transformers/all-MiniLM-L6-v2").strip()
+
+# Parsec PDF slicing
+PARSEC_CONTEXT_BEFORE = 900
+PARSEC_CONTEXT_AFTER = 1600
+
+# ----------------------------
+# OpenAI client
+# ----------------------------
+API_KEY = os.getenv("OPENAI_API_KEY", "").strip()
+client = None if (not API_KEY or OPENAI_DISABLE) else OpenAI(api_key=API_KEY)
+
+# ----------------------------
+# Timing helper
+# ----------------------------
+def _tlog(label: str, t0: float) -> None:
+    if DEBUG_TIMING:
+        dt = time.perf_counter() - t0
+        print(f"[TIMER] {label}: {dt:.2f}s")
+
+# ----------------------------
+# JSON-safe helpers
+# ----------------------------
+def _json_load_safe(s: str) -> Dict[str, Any]:
+    try:
+        return json.loads(s)
+    except Exception:
+        return {}
+
+def _json_dump_safe(obj: Any) -> str:
+    try:
+        return json.dumps(obj, ensure_ascii=False)
+    except Exception:
+        return "{}"
+
+# ----------------------------
+# Gradio state helpers (string JSON only)
+# ----------------------------
+def state_load(st_json: str) -> Dict[str, Any]:
+    try:
+        return json.loads(st_json) if isinstance(st_json, str) and st_json else {}
+    except Exception:
+        return {}
+
+def state_dump(st: Dict[str, Any]) -> str:
+    return _json_dump_safe(st or {})
+
+# ----------------------------
+# Normalization
+# ----------------------------
+def norm_text(x: Any) -> str:
+    try:
+        if x is None or (isinstance(x, float) and math.isnan(x)) or pd.isna(x):
+            return ""
+    except Exception:
+        pass
+    s = str(x).strip().lower()
+    s = re.sub(r"[^a-z0-9\s\-\/]", " ", s)
+    s = re.sub(r"\s+", " ", s).strip()
+    return s
+
+def safe_str(x: Any) -> str:
+    if x is None or (isinstance(x, float) and pd.isna(x)) or pd.isna(x):
+        return ""
+    return str(x).strip()
+
+def is_5g_text(s: str) -> bool:
+    t = norm_text(s)
+    return ("5g" in t) or ("nr" in t)
+
+def is_4g_lte_family(row: pd.Series) -> bool:
+    # Treat LTE categories as 4G
+    t = norm_text(row.get("description", "")) + " " + norm_text(row.get("notes", ""))
+    if "5g" in t or "nr" in t:
+        return False
+    if "lte" in t or "4g" in t:
+        return True
+    if re.search(r"\bcat\s*[-]?\s*(m1|m2)\b", t):
+        return True
+    if re.search(r"\bcat\s*[-]?\s*\d{1,2}\b", t):
+        return True
+    if "cat" in t:
+        return True
+    return False
+
+# ----------------------------
+# Lifecycle CSV normalization
+# ----------------------------
+def _normalize_lifecycle_df(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+    lower_cols = {c.lower(): c for c in df.columns}
+
+    def _pick(*names):
+        for n in names:
+            if n.lower() in lower_cols:
+                return lower_cols[n.lower()]
+        return None
+
+    col_map = {}
+
+    sku_col = _pick("sku", "SKU")
+    if sku_col:
+        col_map[sku_col] = "sku"
+
+    mfr_col = _pick("manufacturer", "Manufacturer")
+    if mfr_col:
+        col_map[mfr_col] = "manufacturer"
+
+    dt_col = _pick("device type", "Device Type", "device_type")
+    if dt_col:
+        col_map[dt_col] = "device_type"
+
+    eos_col = _pick("end_of_sale", "end of sale", "End of Sale", "eos")
+    if eos_col:
+        col_map[eos_col] = "end_of_sale"
+
+    eol_col = _pick("end_of_life", "end of life", "End of Life", "eol")
+    if eol_col:
+        col_map[eol_col] = "end_of_life"
+
+    sr_col = _pick("suggested_replacement", "Suggested Replacement")
+    if sr_col:
+        col_map[sr_col] = "suggested_replacement"
+
+    a5_col = _pick("advanced_5g_option", "Advanced 5G Option", "advanced 5g option")
+    if a5_col:
+        col_map[a5_col] = "advanced_5g_option"
+
+    df = df.rename(columns=col_map)
+
+    for req in ["sku", "manufacturer", "device_type", "end_of_sale", "end_of_life", "suggested_replacement", "advanced_5g_option"]:
+        if req not in df.columns:
+            df[req] = ""
+
+    # Compatibility fields used by matching/output
+    if "description" not in df.columns:
+        df["description"] = df["sku"].astype(str)
+    if "notes" not in df.columns:
+        df["notes"] = ""
+    if "region" not in df.columns:
+        df["region"] = ""
+
+    return df
+
+# ----------------------------
+# Maker mapping
+# ----------------------------
+CANON_MAKER = {
+    "CRADLEPOINT": {"cradlepoint", "ericsson", "ericsson enterprise wireless"},
+    "SIERRA": {"sierra", "sierra wireless", "semtech", "airlink"},
+    "FEENEY": {"feeney", "feeney wireless", "inseego"},
+    "DIGI": {"digi", "accelerated", "accelerated concepts"},
+    "CISCO_MERAKI": {"meraki", "cisco meraki"},
+    "CISCO": {"cisco"},
+    "TELTONIKA": {"teltonika"},
+}
+
+def canon_maker_from_text(s: Any) -> str:
+    t = norm_text(s)
+    for canon, terms in CANON_MAKER.items():
+        for term in terms:
+            if term in t:
+                return canon
+    return "UNKNOWN"
+
+# ----------------------------
+# Date parsing
+# ----------------------------
+@dataclass
+class ParsedDate:
+    raw: str
+    kind: str
+    value: Optional[date]
+
+def parse_date_field(x: Any) -> ParsedDate:
+    raw = safe_str(x)
+    if not raw:
+        return ParsedDate(raw="", kind="missing", value=None)
+
+    # MM/DD/YY or M/D/YY
+    if re.fullmatch(r"\d{1,2}/\d{1,2}/\d{2,4}", raw):
+        try:
+            parts = raw.split("/")
+            m = int(parts[0]); d = int(parts[1]); y = int(parts[2])
+            if y < 100:
+                y += 2000
+            dt = date(y, m, d)
+            return ParsedDate(raw=f"{y:04d}-{m:02d}-{d:02d}", kind="full", value=dt)
+        except Exception:
+            return ParsedDate(raw=raw, kind="bad", value=None)
+
+    # YYYY
+    if re.fullmatch(r"\d{4}", raw):
+        y = int(raw)
+        if y == TODAY.year:
+            return ParsedDate(raw=raw, kind="year", value=date(y, 1, 1))
+        if y < TODAY.year:
+            return ParsedDate(raw=raw, kind="year", value=date(y, 1, 1))
+        return ParsedDate(raw=raw, kind="year", value=date(y, 12, 31))
+
+    # YYYY-MM
+    if re.fullmatch(r"\d{4}-\d{2}", raw):
+        try:
+            y, m = raw.split("-")
+            dt = date(int(y), int(m), 1)
+            return ParsedDate(raw=raw, kind="year_month", value=dt)
+        except Exception:
+            return ParsedDate(raw=raw, kind="bad", value=None)
+
+    # YYYY-MM-DD
+    if re.fullmatch(r"\d{4}-\d{2}-\d{2}", raw):
+        try:
+            dt = datetime.strptime(raw, "%Y-%m-%d").date()
+            return ParsedDate(raw=raw, kind="full", value=dt)
+        except Exception:
+            return ParsedDate(raw=raw, kind="bad", value=None)
+
+    return ParsedDate(raw=raw, kind="bad", value=None)
+
+def display_date(pd_: ParsedDate) -> str:
+    if pd_.kind == "missing":
+        return "Not listed"
+    if pd_.kind == "bad":
+        return pd_.raw or "Not listed"
+    return pd_.raw
+
+def status_from_eos_eol(eos: ParsedDate, eol: ParsedDate) -> str:
+    if eos.value is None and eol.value is None:
+        return "Unknown"
+    if eol.value is not None and eol.value <= TODAY:
+        return "End of Life"
+    if eos.value is not None and eos.value <= TODAY:
+        return "End of Sale"
+    return "Active"
+
+def row_to_dates_and_status(row: pd.Series) -> Tuple[str, str, str]:
+    eos = parse_date_field(row.get("end_of_sale"))
+    eol = parse_date_field(row.get("end_of_life"))
+    return display_date(eos), display_date(eol), status_from_eos_eol(eos, eol)
+
+# ----------------------------
+# Files
+# ----------------------------
+EOS_PATH = "routers_eos_eol_by_sku.csv"
+DEC_PATH = "dec2025routers.csv"
+PARSEC_PDF = "ParsecCatalog.pdf"
+
+if not os.path.exists(EOS_PATH):
+    raise FileNotFoundError(f"Missing {EOS_PATH} in repo.")
+if not os.path.exists(DEC_PATH):
+    raise FileNotFoundError(f"Missing {DEC_PATH} in repo.")
+if not os.path.exists(PARSEC_PDF):
+    raise FileNotFoundError(f"Missing {PARSEC_PDF} in repo.")
+
+t0 = time.perf_counter()
+df_eos = pd.read_csv(EOS_PATH).copy()
+df_dec = pd.read_csv(DEC_PATH).copy()
+df_eos = _normalize_lifecycle_df(df_eos)
+
+# Canon columns
+df_eos["_canon_make"] = df_eos["manufacturer"].apply(canon_maker_from_text)
+df_eos["_norm_sku"] = df_eos["sku"].apply(norm_text)
+df_eos["_norm_desc"] = df_eos["description"].apply(norm_text)
+df_eos["_norm_notes"] = df_eos["notes"].apply(norm_text)
+
+df_dec["_canon_make"] = df_dec["Make"].apply(canon_maker_from_text) if "Make" in df_dec.columns else "UNKNOWN"
+df_dec["_norm_model"] = df_dec["Model"].apply(norm_text) if "Model" in df_dec.columns else ""
+df_dec["_is5g"] = df_dec["Modem Type"].apply(lambda x: is_5g_text(str(x))) if "Modem Type" in df_dec.columns else False
+_tlog("load csv", t0)
+
+# ----------------------------
+# Build fuzzy corpus for device matching
+# ----------------------------
+def _label_for_row(i: int) -> str:
+    r = df_eos.iloc[i]
+    return f"{r.get('sku','')} — {r.get('manufacturer','')} — {r.get('description','')}"[:220]
+
+EOS_LABELS = [_label_for_row(i) for i in range(len(df_eos))]
+EOS_CORPUS = []
+for _, r in df_eos.iterrows():
+    EOS_CORPUS.append(" ".join([r.get("_norm_sku",""), r.get("_canon_make",""), r.get("_norm_desc",""), r.get("_norm_notes","")]))
+
+def resolve_device(term: str) -> Dict[str, Any]:
+    q = norm_text(term)
+    if not q:
+        return {"mode": "not_found"}
+
+    exact = df_eos.index[df_eos["_norm_sku"] == q].tolist()
+    if len(exact) == 1:
+        return {"mode":"ok","row_idx": int(exact[0])}
+
+    hits = process.extract(q, EOS_CORPUS, scorer=fuzz.WRatio, limit=6)
+    cands = [(int(idx), int(score), EOS_LABELS[int(idx)]) for _, score, idx in hits]
+
+    if not cands:
+        return {"mode":"not_found"}
+
+    if cands[0][1] >= MATCH_AUTOPICK and (len(cands) == 1 or (cands[0][1] - cands[1][1]) >= MATCH_GAP):
+        return {"mode":"ok","row_idx": cands[0][0]}
+
+    opts = [{"row_idx": cands[0][0], "label": cands[0][2]}]
+    if len(cands) > 1:
+        opts.append({"row_idx": cands[1][0], "label": cands[1][2]})
+    return {"mode":"pick","options": opts}
+
+# ----------------------------
+# Parsec RAG (FAISS)
+# ----------------------------
+t0 = time.perf_counter()
+embedder = SentenceTransformer(EMBED_MODEL_NAME)
+
+def extract_pdf_text_pages(path: str) -> List[str]:
+    doc = fitz.open(path)
+    return [doc[i].get_text("text") for i in range(len(doc))]
+
+def build_parsec_cards(pages: List[str]) -> List[str]:
+    cards = []
+    for p in pages:
+        for m in re.finditer(r"Standard\s+SKU:", p):
+            start = max(0, m.start() - PARSEC_CONTEXT_BEFORE)
+            end = min(len(p), m.start() + PARSEC_CONTEXT_AFTER)
+            c = p[start:end].strip()
+            if len(c) >= 200:
+                cards.append(c)
+    out, seen = [], set()
+    for c in cards:
+        h = hashlib.sha1(c.encode("utf-8")).hexdigest()
+        if h not in seen:
+            seen.add(h); out.append(c)
+    return out
+
+parsec_cards = build_parsec_cards(extract_pdf_text_pages(PARSEC_PDF))
+parsec_emb = embedder.encode(parsec_cards, batch_size=64, show_progress_bar=False, normalize_embeddings=True)
+parsec_emb = np.asarray(parsec_emb, dtype=np.float32)
+parsec_index = faiss.IndexFlatIP(parsec_emb.shape[1])
+parsec_index.add(parsec_emb)
+_tlog("parsec index", t0)
+
+PARSEC_FAMILY_WORDS = {"chinook","labrador","boxer","bloodhound","husky","beagle","mastiff","collie","shepherd","belgian","australian","terrier","pyrenees"}
+
+def _parsec_name_from_card(card_text: str) -> str:
+    low = card_text.lower()
+    for fam in PARSEC_FAMILY_WORDS:
+        if fam in low:
+            return fam.capitalize()
+    return "Parsec antenna"
+
+def _parsec_part_from_card(t: str) -> str:
+    m = re.search(r"Standard\s+SKU:\s*([A-Z0-9]+)", t)
+    return m.group(1).strip() if m else ""
+
+def _parsec_desc_from_card(t: str) -> str:
+    m = re.search(r"Description:\s*(.+?)(?:\n|$)", t, flags=re.IGNORECASE)
+    return re.sub(r"\s+"," ",m.group(1).strip())[:220] if m else ""
+
+def _parsec_connectors_from_card(t: str) -> str:
+    m = re.search(r"Standard\s+Connectors:\s*(.+)", t, flags=re.IGNORECASE)
+    return re.sub(r"\s+"," ",m.group(1).strip())[:80] if m else ""
+
+def parsec_retrieve(query: str, top_k: int = 8) -> List[Dict[str, Any]]:
+    qv = embedder.encode([query], normalize_embeddings=True)
+    qv = np.asarray(qv, dtype=np.float32)
+    scores, ids = parsec_index.search(qv, top_k)
+    out = []
+    for sc, i in zip(scores[0].tolist(), ids[0].tolist()):
+        if 0 <= int(i) < len(parsec_cards):
+            card = parsec_cards[int(i)]
+            out.append({
+                "score": float(sc),
+                "name": _parsec_name_from_card(card),
+                "part_number": _parsec_part_from_card(card),
+                "description": _parsec_desc_from_card(card),
+                "connectors": _parsec_connectors_from_card(card),
+            })
+    return out
+
+def antenna_pick(repl5: str, mode: str, detail: Optional[str]) -> Dict[str, Any]:
+    mimo = "4x4"  # rule: all 5G -> 4x4
+    tech = "5G"
+    if mode == "vehicle":
+        q = f"{repl5} {tech} {mimo} omni vehicle mobile magnetic through-bolt"
+        c = parsec_retrieve(q, top_k=8)
+        best = c[0] if c else {"name":"Parsec antenna","part_number":"","description":"","connectors":""}
+        best.update({"mimo": mimo, "why": "Vehicle omni best match."})
+        return best
+
+    if detail == "directional":
+        q = f"{repl5} {tech} {mimo} directional fixed site"
+        c = parsec_retrieve(q, top_k=8)
+        best = c[0] if c else {"name":"Parsec antenna","part_number":"","description":"","connectors":""}
+        best.update({"mimo": mimo, "why": "Stationary directional best match."})
+        return best
+
+    if detail == "indoor":
+        q = f"{repl5} {tech} {mimo} omni indoor"
+        c = parsec_retrieve(q, top_k=8)
+        best = c[0] if c else {"name":"Parsec antenna","part_number":"","description":"","connectors":""}
+        best.update({"mimo": mimo, "why": "Stationary indoor omni best match."})
+        return best
+
+    q = f"{repl5} {tech} {mimo} omni outdoor pole wall fixed site"
+    c = parsec_retrieve(q, top_k=8)
+    best = c[0] if c else {"name":"Parsec antenna","part_number":"","description":"","connectors":""}
+    best.update({"mimo": mimo, "why": "Stationary outdoor omni best match."})
+    return best
+
+# ----------------------------
+# Replacement selection (lifecycle-first)
+# ----------------------------
+def extract_model_token(text: str) -> str:
+    s = safe_str(text)
+    if not s:
+        return ""
+    parts = [p.strip() for p in s.split("|") if p.strip()]
+    candidates = parts[::-1] if parts else [s]
+    for cand in candidates:
+        u = cand.upper()
+        m = re.search(r"\bRUT[A-Z]?\d{2,4}\b", u)
+        if m:
+            return m.group(0)
+        m = re.search(r"\bRUTM\d{2,3}\b", u)
+        if m:
+            return m.group(0)
+        m = re.search(r"\bIX\d{2}\b", u)
+        if m:
+            return m.group(0)
+        m = re.search(r"\b(R\d{3,4}|E\d{3,4}|S\d{3,4})\b", u)
+        if m:
+            return m.group(0)
+        m = re.search(r"\b[A-Z]{1,6}\d{2,4}[A-Z]?\b", u)
+        if m:
+            return m.group(0)
+    return candidates[0][:60]
+
+def pick_replacements(row: pd.Series, status: str) -> Dict[str, str]:
+    sug = safe_str(row.get("suggested_replacement", ""))
+    adv = safe_str(row.get("advanced_5g_option", ""))
+
+    repl_4g = extract_model_token(sug) if sug else "Not applicable"
+    repl_5g = extract_model_token(adv) if adv else "Not listed"
+
+    # Always provide some 5G answer: if lifecycle missing, pick top 5G from dec (same maker)
+    if repl_5g in {"", "Not listed"}:
+        canon_make = str(row.get("_canon_make","UNKNOWN"))
+        pool = df_dec[(df_dec["_canon_make"] == canon_make) & (df_dec["_is5g"] == True)].copy()
+        repl_5g = str(pool.iloc[0]["Model"]).strip() if not pool.empty else "Not listed"
+
+    return {"repl_4g": repl_4g or "Not applicable", "repl_5g": repl_5g or "Not listed"}
+
+# ----------------------------
+# Features + Fit (dec first, single LLM enrichment call if needed)
+# ----------------------------
+FEATURE_COLS = ["Device", "Modem technology", "WiFi", "Ports", "Antennas", "Ruggedness", "Use case"]
+FIT_COLS = ["Device", "Fit badges", "Ethernet ports", "Battery"]
+
+def _features_from_dec(model: str, canon_make: str) -> Dict[str, str]:
+    if not model or model in {"Not listed", "Not applicable"}:
+        return {k: "Not listed" for k in FEATURE_COLS[1:]}
+    pool = df_dec[df_dec["_canon_make"] == canon_make].copy()
+    if pool.empty:
+        return {k: "Not listed" for k in FEATURE_COLS[1:]}
+    hit = process.extractOne(norm_text(model), pool["_norm_model"].tolist(), scorer=fuzz.WRatio)
+    if not hit or hit[1] < MATCH_OK:
+        return {k: "Not listed" for k in FEATURE_COLS[1:]}
+    r = pool.iloc[int(hit[2])]
+    ports = f"WAN: {r.get('WAN ports and speed','')} | LAN: {r.get('LAN ports and speed','')}".strip()
+    return {
+        "Modem technology": str(r.get("Modem Type","") or "Not listed"),
+        "WiFi": str(r.get("WiFi type","") or "Not listed"),
+        "Ports": ports if ports else "Not listed",
+        "Antennas": str(r.get("Antennas (internal/external/both)","") or "Not listed"),
+        "Ruggedness": str(r.get("Ruggedization","") or "Not listed"),
+        "Use case": str(r.get("Primary use case","") or "Not listed"),
+    }
+
+def _fit_from_dec(model: str, canon_make: str, is5: bool) -> Dict[str, str]:
+    badges = []
+    eth = "Not listed"
+    bat = "Not listed"
+    if is5:
+        badges.append("4x4 MIMO")
+
+    pool = df_dec[df_dec["_canon_make"] == canon_make].copy()
+    if pool.empty or not model or model in {"Not listed", "Not applicable"}:
+        return {"Fit badges": ", ".join(badges) if badges else "Not listed", "Ethernet ports": eth, "Battery": bat}
+
+    hit = process.extractOne(norm_text(model), pool["_norm_model"].tolist(), scorer=fuzz.WRatio)
+    if not hit or hit[1] < MATCH_OK:
+        return {"Fit badges": ", ".join(badges) if badges else "Not listed", "Ethernet ports": eth, "Battery": bat}
+
+    r = pool.iloc[int(hit[2])]
+    use_case = str(r.get("Primary use case","") or "").lower()
+    rugged = str(r.get("Ruggedization","") or "").lower()
+    wifi = str(r.get("WiFi type","") or "").strip().lower()
+    serial = str(r.get("Serial port (yes/no)","") or "").strip().lower()
+    battery = str(r.get("Battery (internal/removable/none/optional)","") or "").strip().lower()
+    notes_blob = " ".join([str(r.get("Special notes","") or ""), str(r.get("summary and use case","") or "")]).lower()
+
+    if any(k in use_case for k in ["vehicle","mobile","fleet","in-vehicle"]) or "vehicle" in rugged:
+        badges.append("Vehicle")
+    else:
+        badges.append("Fixed site")
+
+    if wifi and wifi not in {"none","no","n/a"}:
+        badges.append("Wi‑Fi")
+    if any(k in rugged for k in ["rugged","industrial","ip","harsh"]):
+        badges.append("Rugged")
+    if "dual" in notes_blob and "sim" in notes_blob:
+        badges.append("Dual‑SIM")
+    if serial in {"yes","y","true"}:
+        badges.append("Serial")
+
+    if battery:
+        if "none" in battery:
+            bat = "No"
+        else:
+            bat = "Yes"
+
+    badges_csv = ", ".join(dict.fromkeys(badges)) if badges else "Not listed"
+    return {"Fit badges": badges_csv, "Ethernet ports": eth, "Battery": bat}
+
+# Enrichment cache (one call per (make, repl4, repl5))
+_ENRICH_CACHE: Dict[str, Dict[str, Any]] = {}
+
+def _enrich_key(canon_make: str, repl4: str, repl5: str) -> str:
+    return hashlib.sha1(f"{canon_make}|{repl4}|{repl5}".encode("utf-8")).hexdigest()
+
+def gpt_enrich(repl4: str, repl5: str, canon_make: str, feat4: Dict[str,str], feat5: Dict[str,str], fit4: Dict[str,str], fit5: Dict[str,str]) -> Dict[str, Any]:
+    if client is None:
+        return {"feat4": feat4, "feat5": feat5, "fit4": fit4, "fit5": fit5}
+
+    key = _enrich_key(canon_make, repl4, repl5)
+    if key in _ENRICH_CACHE:
+        return _ENRICH_CACHE[key]
+
+    def miss(d: Dict[str,str]) -> List[str]:
+        out=[]
+        for k,v in d.items():
+            if (not v) or str(v).strip().lower() in {"not listed","nan",""}:
+                out.append(k)
+        return out
+
+    m_feat4 = miss(feat4); m_feat5 = miss(feat5)
+    m_fit4 = miss(fit4); m_fit5 = miss(fit5)
+
+    if not (m_feat4 or m_feat5 or m_fit4 or m_fit5):
+        pack = {"feat4": feat4, "feat5": feat5, "fit4": fit4, "fit5": fit5}
+        _ENRICH_CACHE[key] = pack
+        return pack
+
+    sys = (
+        "You are helping a Verizon rep. Fill missing router feature fields and fit traits. Return strict JSON only. "
+        "Keep values short. "
+        "Fit badges must be chosen from: ['Vehicle','Fixed site','Wi‑Fi','Rugged','Dual‑SIM','4x4 MIMO','High throughput','Serial'] only. "
+        "Rule: if a router is 5G, include '4x4 MIMO'. "
+        "Ethernet ports must be a single integer as a string when possible; else 'Not listed'. "
+        "Battery must be 'Yes', 'No', or 'Not listed'."
+    )
+
+    payload = {
+        "maker_family": canon_make,
+        "models": {"repl4": repl4, "repl5": repl5},
+        "known": {"feat4": feat4, "feat5": feat5, "fit4": fit4, "fit5": fit5},
+        "missing": {"feat4": m_feat4, "feat5": m_feat5, "fit4": m_fit4, "fit5": m_fit5},
+        "output_schema": {
+            "feat4": {k: "string" for k in m_feat4},
+            "feat5": {k: "string" for k in m_feat5},
+            "fit4": {k: "string" for k in m_fit4},
+            "fit5": {k: "string" for k in m_fit5},
+        },
+    }
+
+    t0 = time.perf_counter()
+    resp = client.responses.create(
+        model=OPENAI_MODEL,
+        input=[{"role":"system","content":sys},{"role":"user","content":_json_dump_safe(payload)}],
+        max_output_tokens=420,
+    )
+    _tlog("llm enrich", t0)
+
+    out = _json_load_safe(getattr(resp, "output_text", "") or "")
+
+    def merge(base: Dict[str,str], patch: Any) -> Dict[str,str]:
+        if isinstance(patch, dict):
+            for k,v in patch.items():
+                sv = str(v or "").strip()
+                if sv:
+                    base[k] = sv
+        return base
+
+    feat4x = merge(dict(feat4), out.get("feat4", {}))
+    feat5x = merge(dict(feat5), out.get("feat5", {}))
+    fit4x = merge(dict(fit4), out.get("fit4", {}))
+    fit5x = merge(dict(fit5), out.get("fit5", {}))
+
+    # Enforce 5G 4x4 badge
+    b = str(fit5x.get("Fit badges","") or "")
+    if "4x4 MIMO" not in b:
+        fit5x["Fit badges"] = (b + ", 4x4 MIMO").strip(", ").strip() if b and b != "Not listed" else "4x4 MIMO"
+
+    pack = {"feat4": feat4x, "feat5": feat5x, "fit4": fit4x, "fit5": fit5x}
+    _ENRICH_CACHE[key] = pack
+    return pack
+
+def build_tables(repl4: str, repl5: str, canon_make: str) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    feat4 = _features_from_dec(repl4, canon_make)
+    feat5 = _features_from_dec(repl5, canon_make)
+    fit4 = _fit_from_dec(repl4, canon_make, is5=False)
+    fit5 = _fit_from_dec(repl5, canon_make, is5=True)
+
+    pack = gpt_enrich(repl4, repl5, canon_make, feat4, feat5, fit4, fit5)
+
+    feat_df = pd.DataFrame([
+        {"Device":"4G alternative", **pack["feat4"]},
+        {"Device":"5G replacement", **pack["feat5"]},
+    ], columns=FEATURE_COLS)
+
+    fit_df = pd.DataFrame([
+        {"Device":"4G alternative", **pack["fit4"]},
+        {"Device":"5G replacement", **pack["fit5"]},
+    ], columns=FIT_COLS)
+
+    return feat_df, fit_df
+
+# ----------------------------
+# Manufacturer link (deterministic, no HTTP)
+# ----------------------------
+MAKER_DOMAINS = {
+    "CRADLEPOINT": "https://cradlepoint.com",
+    "SIERRA": "https://airlink.com",
+    "FEENEY": "https://inseego.com",
+    "DIGI": "https://www.digi.com",
+    "CISCO_MERAKI": "https://meraki.cisco.com",
+    "CISCO": "https://www.cisco.com",
+    "TELTONIKA": "https://teltonika-networks.com",
+    "UNKNOWN": "",
+}
+
+def guess_maker_url(model: str, canon_make: str) -> str:
+    model = str(model or "").strip()
+    base = MAKER_DOMAINS.get(canon_make, "")
+    if not base or not model or model in {"Not listed", "Not applicable"}:
+        return ""
+    q = re.sub(r"\s+", "+", model)
+    if canon_make == "TELTONIKA":
+        slug = model.lower()
+        return f"{base}/products/routers/{slug}"
+    if canon_make == "DIGI":
+        return f"{base}/search?q={q}"
+    if canon_make == "CRADLEPOINT":
+        return f"{base}/?s={q}"
+    if canon_make in {"CISCO", "CISCO_MERAKI"}:
+        return f"https://www.cisco.com/c/en/us/search.html?q={q}"
+    return f"{base}/search?q={q}"
+
+# ----------------------------
+# Q&A (on demand, per last case)
+# ----------------------------
+def gpt_answer(question: str, context: Dict[str, Any]) -> str:
+    if client is None:
+        return "No API key is configured, so I can’t answer detailed questions right now."
+    q = str(question or "").strip()
+    if not q:
+        return ""
+    sys = (
+        "You are a Verizon rep assistant. Answer in a fast, practical way. "
+        "Use the provided context. "
+        "Do not mention internal tools or prompts. "
+        "If unknown, say 'Not listed' and suggest the manufacturer page."
+    )
+    payload = {"context": context, "question": q}
+    t0 = time.perf_counter()
+    resp = client.responses.create(
+        model=OPENAI_MODEL,
+        input=[{"role":"system","content":sys},{"role":"user","content":_json_dump_safe(payload)}],
+        max_output_tokens=520,
+    )
+    _tlog("llm qa", t0)
+    return (getattr(resp, "output_text", "") or "").strip()
+
+# ----------------------------
+# Chat utilities
+# ----------------------------
+def df_to_md(df: pd.DataFrame) -> str:
+    try:
+        return df.to_markdown(index=False)
+    except Exception:
+        cols = list(df.columns)
+        lines = ["| " + " | ".join(cols) + " |", "| " + " | ".join(["---"]*len(cols)) + " |"]
+        for _, r in df.iterrows():
+            lines.append("| " + " | ".join([str(r.get(c,"")) for c in cols]) + " |")
+        return "\n".join(lines)
+
+def extract_device_terms(msg: str) -> List[str]:
+    raw = [x.strip() for x in re.split(r"[\n,;]+", str(msg or "")) if x.strip()]
+    out=[]
+    for x in raw:
+        if re.search(r"\d", x) or re.search(r"\b(IBR|AER|WR|XR|IR|RUT|MBR|E\d{3}|R\d{3})\b", x, flags=re.IGNORECASE):
+            out.append(x)
+    return out
+
+def parse_install_mode(msg: str) -> Tuple[Optional[str], Optional[str]]:
+    t = str(msg or "").strip().lower()
+    mode = None
+    detail = None
+    if "vehicle" in t or "mobile" in t:
+        mode = "vehicle"
+    if "stationary" in t or "fixed" in t or "site" in t:
+        mode = "stationary"
+    if "indoor" in t:
+        detail = "indoor"
+    if "outdoor" in t:
+        detail = "outdoor"
+    if "directional" in t:
+        detail = "directional"
+    return mode, detail
+
+def make_case_key(s: str) -> str:
+    s = str(s or "").strip()
+    return re.sub(r"\s+", " ", s)[:80]
+
+# ----------------------------
+# Chat UI (schema-safe)
+# ----------------------------
+with gr.Blocks(title="Only-Routers") as demo:
+    gr.Markdown("## Only-Routers\nChat mode for Verizon reps (multiple devices per message).")
+    state = gr.State("{}")
+
+    chatbot = gr.Chatbot(label="Only-Routers Chat", height=560, type="tuples")
+    msg = gr.Textbox(label="Message", placeholder="Example: RUT240, WR21\nVehicle install", lines=2)
+    send = gr.Button("Send", variant="primary")
+
+    def chat_fn(user_msg, history, st_json):
+        t0 = time.perf_counter()
+        st = state_load(st_json)
+        st.setdefault("cases", {})
+        st.setdefault("last_case_keys", [])
+        st.setdefault("pending", {})
+        st.setdefault("awaiting_questions", False)
+
+        text = (user_msg or "").strip()
+        if not text:
+            return history, state_dump(st)
+
+        # Pending A/B pick
+        if st.get("pending", {}).get("type") == "pick":
+            opts = st["pending"].get("options", [])
+            choice = text.strip().lower()
+            idx = 0 if choice in {"a","1"} else (1 if choice in {"b","2"} else None)
+            if idx is None or idx >= len(opts):
+                history.append((text, "Please reply with **A** or **B**."))
+                return history, state_dump(st)
+
+            chosen_row = int(opts[idx]["row_idx"])
+            life_row = df_eos.iloc[chosen_row]
+            eos, eol, status = row_to_dates_and_status(life_row)
+            repl = pick_replacements(life_row, status)
+            canon_make = str(life_row.get("_canon_make","UNKNOWN"))
+
+            feat_df, fit_df = build_tables(repl["repl_4g"], repl["repl_5g"], canon_make)
+            url4 = guess_maker_url(repl["repl_4g"], canon_make) if repl["repl_4g"] != "Not applicable" else ""
+            url5 = guess_maker_url(repl["repl_5g"], canon_make) if repl["repl_5g"] != "Not listed" else ""
+
+            ck = make_case_key(str(life_row.get("sku","")))
+            st["cases"][ck] = {"row_idx": chosen_row, "repl": repl, "canon_make": canon_make, "status": status, "eos": eos, "eol": eol, "urls": {"4g": url4, "5g": url5}}
+            st["last_case_keys"].append(ck)
+            st["pending"] = {"type":"install_mode", "case_keys":[ck]}
+            st["awaiting_questions"] = True
+
+            bot = []
+            bot.append(f"**{ck}**")
+            bot.append(f"- Status: **{status}** | EOS: **{eos}** | EOL: **{eol}**")
+            bot.append(f"- 4G alternative: **{repl['repl_4g']}**")
+            bot.append(f"- 5G replacement: **{repl['repl_5g']}**")
+            if url4:
+                bot.append(f"- 4G manufacturer page: {url4}")
+            if url5:
+                bot.append(f"- 5G manufacturer page: {url5}")
+            bot.append("\n**Replacement features**\n" + df_to_md(feat_df))
+            bot.append("\n**Verizon fit**\n" + df_to_md(fit_df))
+            bot.append("\nFor antennas: **Vehicle/Mobile** or **Stationary**? If Stationary: **Indoor**, **Outdoor**, or **Directional**.")
+            bot.append("Any questions about the suggested device(s)?")
+
+            history.append((text, "\n".join(bot)))
+            _tlog("chat pick flow", t0)
+            return history, state_dump(st)
+
+        # Pending install-mode
+        if st.get("pending", {}).get("type") == "install_mode":
+            mode, detail = parse_install_mode(text)
+            if mode is None:
+                history.append((text, "Quick one: **Vehicle/Mobile** or **Stationary**? If Stationary: **Indoor**, **Outdoor**, or **Directional**."))
+                return history, state_dump(st)
+
+            updates=[]
+            for ck in st["pending"].get("case_keys", []):
+                case = st["cases"].get(ck, {})
+                repl5 = (case.get("repl", {}) or {}).get("repl_5g","")
+                ant = antenna_pick(repl5, mode=mode, detail=detail)
+                case.setdefault("antennas", {})
+                case["antennas"][f"{mode}:{detail or ''}"] = ant
+                st["cases"][ck] = case
+                updates.append(f"**{ck}** antenna ({mode}{' / '+detail if detail else ''}): {ant.get('name','')} (PN {ant.get('part_number','')})")
+
+            st["pending"] = {}
+            history.append((text, "\n".join(updates)))
+            _tlog("chat antenna flow", t0)
+            return history, state_dump(st)
+
+        # Device lookup
+        device_terms = extract_device_terms(text)
+        if device_terms:
+            bots=[]
+            new_case_keys=[]
+            for term in device_terms:
+                res = resolve_device(term)
+                if res.get("mode") == "pick":
+                    st["pending"] = {"type":"pick", "options": res.get("options", []), "raw": term}
+                    opts = res.get("options", [])
+                    bot = "I found more than one close match. Reply **A** or **B**:\n"
+                    for i,o in enumerate(opts):
+                        bot += f"- **{'A' if i==0 else 'B'}**: {o.get('label','')}\n"
+                    history.append((text, bot.strip()))
+                    _tlog("chat resolve->pick", t0)
+                    return history, state_dump(st)
+
+                if res.get("mode") != "ok":
+                    bots.append(f"**{term}**: not found in lifecycle list. Who makes it (manufacturer) and what's the exact model/SKU?")
+                    continue
+
+                life_row = df_eos.iloc[int(res["row_idx"])]
+                eos, eol, status = row_to_dates_and_status(life_row)
+                repl = pick_replacements(life_row, status)
+                canon_make = str(life_row.get("_canon_make","UNKNOWN"))
+
+                t1 = time.perf_counter()
+                feat_df, fit_df = build_tables(repl["repl_4g"], repl["repl_5g"], canon_make)
+                _tlog("tables", t1)
+
+                url4 = guess_maker_url(repl["repl_4g"], canon_make) if repl["repl_4g"] != "Not applicable" else ""
+                url5 = guess_maker_url(repl["repl_5g"], canon_make) if repl["repl_5g"] != "Not listed" else ""
+
+                ck = make_case_key(str(life_row.get("sku","")) or term)
+                st["cases"][ck] = {"row_idx": int(res["row_idx"]), "repl": repl, "canon_make": canon_make, "status": status, "eos": eos, "eol": eol, "urls": {"4g": url4, "5g": url5}}
+                st["last_case_keys"].append(ck)
+                new_case_keys.append(ck)
+
+                bot=[]
+                bot.append(f"**{ck}**")
+                bot.append(f"- Status: **{status}** | EOS: **{eos}** | EOL: **{eol}**")
+                bot.append(f"- 4G alternative: **{repl['repl_4g']}**")
+                bot.append(f"- 5G replacement: **{repl['repl_5g']}**")
+                if url4:
+                    bot.append(f"- 4G manufacturer page: {url4}")
+                if url5:
+                    bot.append(f"- 5G manufacturer page: {url5}")
+                bot.append("\n**Replacement features**\n" + df_to_md(feat_df))
+                bot.append("\n**Verizon fit**\n" + df_to_md(fit_df))
+                bots.append("\n".join(bot))
+
+            if new_case_keys:
+                st["pending"] = {"type":"install_mode", "case_keys": new_case_keys}
+                bots.append("\nFor antennas: **Vehicle/Mobile** or **Stationary**? If Stationary: **Indoor**, **Outdoor**, or **Directional**.")
+                bots.append("Any questions about the suggested device(s)?")
+                st["awaiting_questions"] = True
+
+            history.append((text, "\n\n---\n\n".join(bots)))
+            _tlog("chat lookup flow", t0)
+            return history, state_dump(st)
+
+        # Q&A about most recent case
+        if not st.get("last_case_keys"):
+            history.append((text, "Tell me the router model/SKU you’re working with (you can paste multiple)."))
+            return history, state_dump(st)
+
+        ck = st["last_case_keys"][-1]
+        case = st["cases"].get(ck, {})
+        ctx = {"case": ck, "replacements": case.get("repl", {}), "urls": case.get("urls", {}), "antennas": case.get("antennas", {})}
+        ans = gpt_answer(text, ctx)
+        history.append((text, ans))
+        _tlog("chat qa flow", t0)
+        return history, state_dump(st)
+
+    send.click(fn=chat_fn, inputs=[msg, chatbot, state], outputs=[chatbot, state], api_name=False)
+
+demo.launch(server_name="0.0.0.0", server_port=int(os.getenv("PORT","7860")), share=False, show_api=False)

app.py

@@ -4,6 +4,7 @@ import json
 import math
 import time
 import hashlib
+import base64
 import tempfile
 from dataclasses import dataclass
 from datetime import datetime, date
@@ -386,6 +387,167 @@ parsec_emb = np.asarray(parsec_emb, dtype=np.float32)
 parsec_index = faiss.IndexFlatIP(parsec_emb.shape[1])
 parsec_index.add(parsec_emb)
 _tlog("parsec index", t0)
+# ----------------------------
+# Antenna photos from ParsecCatalog.pdf (best effort)
+# - Build a map from Standard SKU -> page indices once at startup
+# - Extract the largest image on the matching page and embed as data URI in markdown
+#   (only used when user asks for antenna options)
+# ----------------------------
+PARSEC_PN_TO_PAGES: Dict[str, List[int]] = {}
+
+try:
+    _doc = fitz.open(PARSEC_PDF)
+    for i in range(len(_doc)):
+        t = _doc[i].get_text("text") or ""
+        for m in re.finditer(r"Standard\s+SKU:\s*([A-Z0-9]+)", t):
+            pn = m.group(1).strip().upper()
+            PARSEC_PN_TO_PAGES.setdefault(pn, []).append(i)
+except Exception:
+    PARSEC_PN_TO_PAGES = {}
+
+def _extract_largest_image_data_uri(page_index: int, max_bytes: int = 350_000) -> str:
+    """
+    Extract the largest raster image on a PDF page and return as a data URI (PNG).
+    If the image is too large to embed, return empty string.
+    """
+    try:
+        doc = fitz.open(PARSEC_PDF)
+        page = doc[page_index]
+        imgs = page.get_images(full=True) or []
+        if not imgs:
+            return ""
+
+        best_xref = None
+        best_area = 0
+        for img in imgs:
+            xref = img[0]
+            pix = fitz.Pixmap(doc, xref)
+            area = pix.width * pix.height
+            if area > best_area and pix.width >= 200 and pix.height >= 200:
+                best_area = area
+                best_xref = xref
+            pix = None
+
+        if best_xref is None:
+            return ""
+
+        pix = fitz.Pixmap(doc, best_xref)
+        if pix.n >= 5:  # CMYK
+            pix = fitz.Pixmap(fitz.csRGB, pix)
+
+        png_bytes = pix.tobytes("png")
+        if len(png_bytes) > max_bytes:
+            return ""
+
+        b64 = base64.b64encode(png_bytes).decode("ascii")
+        return f"data:image/png;base64,{b64}"
+    except Exception:
+        return ""
+
+@lru_cache(maxsize=512)
+def antenna_photo_data_uri(part_number: str) -> str:
+    pn = str(part_number or "").strip().upper()
+    if not pn:
+        return ""
+    pages = PARSEC_PN_TO_PAGES.get(pn, [])
+    if not pages:
+        return ""
+    for p in pages[:3]:
+        uri = _extract_largest_image_data_uri(p)
+        if uri:
+            return uri
+    return ""
+
+# ----------------------------
+# Stronger matching (regex normalization + fuzzy)
+# ----------------------------
+def _normalize_query_compact(s: str) -> str:
+    s = str(s or "").strip().upper()
+    return re.sub(r"[^A-Z0-9]", "", s)
+
+def resolve_device_stronger(term: str) -> Dict[str, Any]:
+    raw = str(term or "").strip()
+    if not raw:
+        return {"mode":"not_found"}
+
+    q_compact = _normalize_query_compact(raw)
+    # exact compact SKU match
+    if q_compact:
+        for i, sku in enumerate(df_eos["_norm_sku"].tolist()):
+            if _normalize_query_compact(sku) == q_compact:
+                return {"mode":"ok", "row_idx": i, "confidence":"High"}
+
+    hits = process.extract(raw, EOS_CORPUS, scorer=fuzz.WRatio, limit=6)
+    cands = [(int(idx), int(score), EOS_LABELS[int(idx)]) for _, score, idx in hits]
+    if not cands:
+        return {"mode":"not_found"}
+
+    if cands[0][1] >= MATCH_AUTOPICK and (len(cands)==1 or (cands[0][1]-cands[1][1]) >= MATCH_GAP):
+        return {"mode":"ok", "row_idx": cands[0][0], "confidence":"High"}
+
+    return {"mode":"guess", "row_idx": cands[0][0], "confidence":"Medium", "guess_label": cands[0][2], "raw": raw}
+
+# ----------------------------
+# LLM fallback: identify router + replacements (Verizon equipment only, no pricing)
+# ----------------------------
+def llm_identify_router_and_replacements(raw_text: str) -> Dict[str, Any]:
+    if client is None:
+        return {"found": False, "note": "No API key configured."}
+
+    sys = (
+        "You help Verizon reps identify cellular routers and suggest replacements. "
+        "Keep it to Verizon-sellable equipment families when possible "
+        "(Cradlepoint, Sierra/AirLink, Digi, Cisco/Meraki, Teltonika, Inseego). "
+        "No pricing. Return strict JSON only."
+    )
+    payload = {
+        "user_input": raw_text,
+        "output_schema": {
+            "best_guess_model": "string",
+            "maker_family": "CRADLEPOINT|SIERRA|DIGI|CISCO|CISCO_MERAKI|TELTONIKA|FEENEY|UNKNOWN",
+            "repl_5g": "string",
+            "repl_4g": "string",
+            "confidence": "High|Medium",
+            "note": "string"
+        }
+    }
+    resp = client.responses.create(
+        model=OPENAI_MODEL,
+        input=[{"role":"system","content":sys},{"role":"user","content":_json_dump_safe(payload)}],
+        max_output_tokens=360,
+    )
+    out = _json_load_safe(getattr(resp, "output_text", "") or "")
+    if not isinstance(out, dict) or not out.get("best_guess_model"):
+        return {"found": False, "note": "Could not identify router."}
+    out["found"] = True
+    return out
+
+# ----------------------------
+# Antenna options: Vehicle + Indoor + Outdoor + Directional
+# (all omni except directional)
+# ----------------------------
+def antenna_options_4pack(repl5: str) -> Dict[str, Dict[str, Any]]:
+    # All 5G routers => 4x4
+    veh = antenna_pick(repl5, mode="vehicle", detail=None)
+    ind = antenna_pick(repl5, mode="stationary", detail="indoor")
+    outd = antenna_pick(repl5, mode="stationary", detail="outdoor")
+    direc = antenna_pick(repl5, mode="stationary", detail="directional")
+
+    for a in (veh, ind, outd, direc):
+        a["photo_uri"] = antenna_photo_data_uri(a.get("part_number",""))
+
+    return {"vehicle": veh, "indoor": ind, "outdoor": outd, "directional": direc}
+
+def _fmt_ant(a: Dict[str, Any]) -> str:
+    name = a.get("name","")
+    pn = a.get("part_number","")
+    desc = a.get("description","")
+    conn = a.get("connectors","")
+    s = f"**{name}** (PN {pn}) — {desc}"
+    if conn:
+        s += f" | Conn: {conn}"
+    return s
+
 
 PARSEC_FAMILY_WORDS = {"chinook","labrador","boxer","bloodhound","husky","beagle","mastiff","collie","shepherd","belgian","australian","terrier","pyrenees"}
 
@@ -774,10 +936,11 @@ def make_case_key(s: str) -> str:
 # Chat UI (schema-safe)
 # ----------------------------
 with gr.Blocks(title="Only-Routers") as demo:
-    gr.Markdown("## Only-Routers\nChat mode for Verizon reps (multiple devices per message).")
+    gr.Markdown("## Only-Routers\n\n**Please enter the router models you would like to verify for replacement.**\n\nPaste multiple models/SKUs separated by commas or new lines.")
+
     state = gr.State("{}")
 
-    chatbot = gr.Chatbot(label="Only-Routers Chat", height=560, type="tuples")
+    chatbot = gr.Chatbot(label="Only-Routers Chat", height=600, type="tuples")
     msg = gr.Textbox(label="Message", placeholder="Example: RUT240, WR21\nVehicle install", lines=2)
     send = gr.Button("Send", variant="primary")
 
@@ -787,114 +950,181 @@ with gr.Blocks(title="Only-Routers") as demo:
         st.setdefault("cases", {})
         st.setdefault("last_case_keys", [])
         st.setdefault("pending", {})
-        st.setdefault("awaiting_questions", False)
 
         text = (user_msg or "").strip()
         if not text:
             return history, state_dump(st)
 
-        # Pending A/B pick
-        if st.get("pending", {}).get("type") == "pick":
-            opts = st["pending"].get("options", [])
-            choice = text.strip().lower()
-            idx = 0 if choice in {"a","1"} else (1 if choice in {"b","2"} else None)
-            if idx is None or idx >= len(opts):
-                history.append((text, "Please reply with **A** or **B**."))
+        # ----------------------------
+        # Pending: confirm best guess
+        # ----------------------------
+        if st.get("pending", {}).get("type") == "confirm_guess":
+            pend = st["pending"]
+            raw = pend.get("raw","")
+            row_idx = int(pend.get("row_idx",-1))
+            low = text.lower().strip()
+
+            if low in {"yes","y","yeah","yep","correct","right","ok","okay"}:
+                life_row = df_eos.iloc[row_idx]
+                eos, eol, status = row_to_dates_and_status(life_row)
+                repl = pick_replacements(life_row, status)
+                canon_make = str(life_row.get("_canon_make","UNKNOWN"))
+
+                feat_df, fit_df = build_tables(repl["repl_4g"], repl["repl_5g"], canon_make)
+                url4 = guess_maker_url(repl["repl_4g"], canon_make) if repl["repl_4g"] != "Not applicable" else ""
+                url5 = guess_maker_url(repl["repl_5g"], canon_make) if repl["repl_5g"] != "Not listed" else ""
+
+                ck = make_case_key(str(life_row.get("sku","")) or raw)
+                st["cases"][ck] = {"row_idx": row_idx, "repl": repl, "canon_make": canon_make, "status": status, "eos": eos, "eol": eol, "urls": {"4g": url4, "5g": url5}}
+                st["last_case_keys"].append(ck)
+
+                bot=[]
+                bot.append(f"**{ck}**")
+                bot.append(f"- Status: **{status}** | EOS: **{eos}** | EOL: **{eol}**")
+                bot.append(f"- 4G alternative: **{repl['repl_4g']}**")
+                bot.append(f"- 5G replacement: **{repl['repl_5g']}**")
+                if url4:
+                    bot.append(f"- 4G manufacturer page: {url4}")
+                if url5:
+                    bot.append(f"- 5G manufacturer page: {url5}")
+                bot.append("\n**Replacement features**\n" + df_to_md(feat_df))
+                bot.append("\n**Verizon fit**\n" + df_to_md(fit_df))
+                bot.append("\nWould you like to see the **antenna options** (Vehicle, Indoor, Outdoor, Directional) for this router? Reply **Yes** or **No**.")
+                st["pending"] = {"type":"ask_antennas", "case_keys":[ck]}
+
+                history.append((text, "\n".join(bot)))
+                _tlog("confirm guess", t0)
+                return history, state_dump(st)
+
+            if low in {"no","n","nope","wrong","incorrect"}:
+                st["pending"] = {"type":"await_corrected_model"}
+                history.append((text, "No problem — please reply with the corrected router model/SKU."))
+                return history, state_dump(st)
+
+            # If they pasted corrected model instead of yes/no, fall through as new input
+            st["pending"] = {}
+
+        # ----------------------------
+        # Pending: waiting for corrected model
+        # ----------------------------
+        if st.get("pending", {}).get("type") == "await_corrected_model":
+            st["pending"] = {}  # treat message as a new lookup
+
+        # ----------------------------
+        # Pending: ask antennas yes/no
+        # ----------------------------
+        if st.get("pending", {}).get("type") == "ask_antennas":
+            low = text.lower().strip()
+            want = low in {"yes","y","yeah","yep","sure","ok","okay"}
+            case_keys = st["pending"].get("case_keys", []) or st.get("last_case_keys", [])
+
+            if want:
+                blocks=[]
+                for ck in case_keys:
+                    case = st["cases"].get(ck, {})
+                    repl5 = (case.get("repl", {}) or {}).get("repl_5g","")
+                    if not repl5 or repl5 == "Not listed":
+                        blocks.append(f"**{ck}**: No 5G replacement available to anchor antenna picks.")
+                        continue
+
+                    opts = antenna_options_4pack(repl5)
+                    case["antenna_options"] = opts
+                    st["cases"][ck] = case
+
+                    b=[]
+                    b.append(f"**{ck} — Antenna options (Parsec)**")
+                    b.append(f"- Vehicle (Omni): {_fmt_ant(opts['vehicle'])}")
+                    b.append(f"- Indoor (Omni): {_fmt_ant(opts['indoor'])}")
+                    b.append(f"- Outdoor (Omni): {_fmt_ant(opts['outdoor'])}")
+                    b.append(f"- Directional: {_fmt_ant(opts['directional'])}")
+
+                    # Photos (best effort, may be empty if too large or not found)
+                    for label in ["vehicle","indoor","outdoor","directional"]:
+                        uri = opts[label].get("photo_uri","")
+                        if uri:
+                            b.append(f"\n**{label.capitalize()} photo**\n![]({uri})\n")
+
+                    blocks.append("\n".join(b))
+
+                blocks.append("\nAny questions about the router(s) — including alternatives and comparisons? Ask anything router-related (no pricing).")
+                st["pending"] = {"type":"await_questions"}
+                history.append((text, "\n\n---\n\n".join(blocks)))
+                _tlog("antennas yes", t0)
                 return history, state_dump(st)
 
-            chosen_row = int(opts[idx]["row_idx"])
-            life_row = df_eos.iloc[chosen_row]
-            eos, eol, status = row_to_dates_and_status(life_row)
-            repl = pick_replacements(life_row, status)
-            canon_make = str(life_row.get("_canon_make","UNKNOWN"))
-
-            feat_df, fit_df = build_tables(repl["repl_4g"], repl["repl_5g"], canon_make)
-            url4 = guess_maker_url(repl["repl_4g"], canon_make) if repl["repl_4g"] != "Not applicable" else ""
-            url5 = guess_maker_url(repl["repl_5g"], canon_make) if repl["repl_5g"] != "Not listed" else ""
-
-            ck = make_case_key(str(life_row.get("sku","")))
-            st["cases"][ck] = {"row_idx": chosen_row, "repl": repl, "canon_make": canon_make, "status": status, "eos": eos, "eol": eol, "urls": {"4g": url4, "5g": url5}}
-            st["last_case_keys"].append(ck)
-            st["pending"] = {"type":"install_mode", "case_keys":[ck]}
-            st["awaiting_questions"] = True
-
-            bot = []
-            bot.append(f"**{ck}**")
-            bot.append(f"- Status: **{status}** | EOS: **{eos}** | EOL: **{eol}**")
-            bot.append(f"- 4G alternative: **{repl['repl_4g']}**")
-            bot.append(f"- 5G replacement: **{repl['repl_5g']}**")
-            if url4:
-                bot.append(f"- 4G manufacturer page: {url4}")
-            if url5:
-                bot.append(f"- 5G manufacturer page: {url5}")
-            bot.append("\n**Replacement features**\n" + df_to_md(feat_df))
-            bot.append("\n**Verizon fit**\n" + df_to_md(fit_df))
-            bot.append("\nFor antennas: **Vehicle/Mobile** or **Stationary**? If Stationary: **Indoor**, **Outdoor**, or **Directional**.")
-            bot.append("Any questions about the suggested device(s)?")
-
-            history.append((text, "\n".join(bot)))
-            _tlog("chat pick flow", t0)
+            # No antennas
+            st["pending"] = {"type":"await_questions"}
+            history.append((text, "Got it. Any questions about the router(s) — including alternatives and comparisons? Ask anything router-related (no pricing)."))
             return history, state_dump(st)
 
-        # Pending install-mode
-        if st.get("pending", {}).get("type") == "install_mode":
-            mode, detail = parse_install_mode(text)
-            if mode is None:
-                history.append((text, "Quick one: **Vehicle/Mobile** or **Stationary**? If Stationary: **Indoor**, **Outdoor**, or **Directional**."))
+        # ----------------------------
+        # Pending: questions phase
+        # ----------------------------
+        if st.get("pending", {}).get("type") == "await_questions":
+            if not st.get("last_case_keys"):
+                history.append((text, "Please enter the router models you would like to verify for replacement."))
                 return history, state_dump(st)
 
-            updates=[]
-            for ck in st["pending"].get("case_keys", []):
-                case = st["cases"].get(ck, {})
-                repl5 = (case.get("repl", {}) or {}).get("repl_5g","")
-                ant = antenna_pick(repl5, mode=mode, detail=detail)
-                case.setdefault("antennas", {})
-                case["antennas"][f"{mode}:{detail or ''}"] = ant
-                st["cases"][ck] = case
-                updates.append(f"**{ck}** antenna ({mode}{' / '+detail if detail else ''}): {ant.get('name','')} (PN {ant.get('part_number','')})")
+            # Route to most recent unless message mentions a case key
+            target = st["last_case_keys"][-1]
+            t_low = text.lower()
+            for ck in reversed(st["last_case_keys"]):
+                if ck.lower() in t_low:
+                    target = ck
+                    break
+
+            case = st["cases"].get(target, {})
+            ctx = {
+                "case": target,
+                "status": case.get("status",""),
+                "eos": case.get("eos",""),
+                "eol": case.get("eol",""),
+                "replacements": case.get("repl", {}),
+                "urls": case.get("urls", {}),
+                "antenna_options": case.get("antenna_options", {}),
+            }
+            ans = gpt_answer(text, ctx)
+            history.append((text, ans))
+            _tlog("qa", t0)
+            return history, state_dump(st)
 
-            st["pending"] = {}
-            history.append((text, "\n".join(updates)))
-            _tlog("chat antenna flow", t0)
+        # ----------------------------
+        # Normal device intake
+        # ----------------------------
+        terms = extract_device_terms(text)
+        if not terms:
+            # If not a device list, treat as question about last router if possible
+            if st.get("last_case_keys"):
+                case = st["cases"].get(st["last_case_keys"][-1], {})
+                ctx = {"replacements": case.get("repl", {}), "urls": case.get("urls", {}), "antenna_options": case.get("antenna_options", {})}
+                ans = gpt_answer(text, ctx)
+                history.append((text, ans))
+                return history, state_dump(st)
+
+            history.append((text, "Please enter the router models you would like to verify for replacement."))
             return history, state_dump(st)
 
-        # Device lookup
-        device_terms = extract_device_terms(text)
-        if device_terms:
-            bots=[]
-            new_case_keys=[]
-            for term in device_terms:
-                res = resolve_device(term)
-                if res.get("mode") == "pick":
-                    st["pending"] = {"type":"pick", "options": res.get("options", []), "raw": term}
-                    opts = res.get("options", [])
-                    bot = "I found more than one close match. Reply **A** or **B**:\n"
-                    for i,o in enumerate(opts):
-                        bot += f"- **{'A' if i==0 else 'B'}**: {o.get('label','')}\n"
-                    history.append((text, bot.strip()))
-                    _tlog("chat resolve->pick", t0)
-                    return history, state_dump(st)
-
-                if res.get("mode") != "ok":
-                    bots.append(f"**{term}**: not found in lifecycle list. Who makes it (manufacturer) and what's the exact model/SKU?")
-                    continue
-
-                life_row = df_eos.iloc[int(res["row_idx"])]
+        blocks=[]
+        case_keys=[]
+
+        for term in terms:
+            res = resolve_device_stronger(term)
+
+            if res.get("mode") == "ok":
+                row_idx = int(res["row_idx"])
+                life_row = df_eos.iloc[row_idx]
                 eos, eol, status = row_to_dates_and_status(life_row)
                 repl = pick_replacements(life_row, status)
                 canon_make = str(life_row.get("_canon_make","UNKNOWN"))
 
-                t1 = time.perf_counter()
                 feat_df, fit_df = build_tables(repl["repl_4g"], repl["repl_5g"], canon_make)
-                _tlog("tables", t1)
-
                 url4 = guess_maker_url(repl["repl_4g"], canon_make) if repl["repl_4g"] != "Not applicable" else ""
                 url5 = guess_maker_url(repl["repl_5g"], canon_make) if repl["repl_5g"] != "Not listed" else ""
 
                 ck = make_case_key(str(life_row.get("sku","")) or term)
-                st["cases"][ck] = {"row_idx": int(res["row_idx"]), "repl": repl, "canon_make": canon_make, "status": status, "eos": eos, "eol": eol, "urls": {"4g": url4, "5g": url5}}
+                st["cases"][ck] = {"row_idx": row_idx, "repl": repl, "canon_make": canon_make, "status": status, "eos": eos, "eol": eol, "urls": {"4g": url4, "5g": url5}}
                 st["last_case_keys"].append(ck)
-                new_case_keys.append(ck)
+                case_keys.append(ck)
 
                 bot=[]
                 bot.append(f"**{ck}**")
@@ -907,29 +1137,49 @@ with gr.Blocks(title="Only-Routers") as demo:
                     bot.append(f"- 5G manufacturer page: {url5}")
                 bot.append("\n**Replacement features**\n" + df_to_md(feat_df))
                 bot.append("\n**Verizon fit**\n" + df_to_md(fit_df))
-                bots.append("\n".join(bot))
+                blocks.append("\n".join(bot))
+                continue
 
-            if new_case_keys:
-                st["pending"] = {"type":"install_mode", "case_keys": new_case_keys}
-                bots.append("\nFor antennas: **Vehicle/Mobile** or **Stationary**? If Stationary: **Indoor**, **Outdoor**, or **Directional**.")
-                bots.append("Any questions about the suggested device(s)?")
-                st["awaiting_questions"] = True
+            if res.get("mode") == "guess":
+                st["pending"] = {"type":"confirm_guess", "row_idx": int(res["row_idx"]), "raw": res.get("raw","")}
+                history.append((text, f"I think you mean: **{res.get('guess_label','')}**. Is that correct? Reply **Yes** or **No** (or paste the corrected model)."))
+                return history, state_dump(st)
 
-            history.append((text, "\n\n---\n\n".join(bots)))
-            _tlog("chat lookup flow", t0)
-            return history, state_dump(st)
+            # Not found locally: ask to clarify AND attempt LLM best effort
+            llm = llm_identify_router_and_replacements(term)
+            if llm.get("found"):
+                ck = make_case_key(llm.get("best_guess_model","") or term)
+                repl = {"repl_4g": llm.get("repl_4g","Not applicable") or "Not applicable", "repl_5g": llm.get("repl_5g","Not listed") or "Not listed"}
+                canon_make = llm.get("maker_family","UNKNOWN")
+                url4 = guess_maker_url(repl["repl_4g"], canon_make) if repl["repl_4g"] != "Not applicable" else ""
+                url5 = guess_maker_url(repl["repl_5g"], canon_make) if repl["repl_5g"] != "Not listed" else ""
 
-        # Q&A about most recent case
-        if not st.get("last_case_keys"):
-            history.append((text, "Tell me the router model/SKU you’re working with (you can paste multiple)."))
-            return history, state_dump(st)
+                st["cases"][ck] = {"row_idx": None, "repl": repl, "canon_make": canon_make, "status": "Unknown", "eos": "Not listed", "eol": "Not listed", "urls": {"4g": url4, "5g": url5}, "llm_note": llm.get("note","")}
+                st["last_case_keys"].append(ck)
+                case_keys.append(ck)
+
+                bot=[]
+                bot.append(f"**{ck}** (best effort)")
+                bot.append(f"- Note: {llm.get('note','')}")
+                bot.append(f"- 4G alternative: **{repl['repl_4g']}**")
+                bot.append(f"- 5G replacement: **{repl['repl_5g']}**")
+                if url4:
+                    bot.append(f"- 4G manufacturer page: {url4}")
+                if url5:
+                    bot.append(f"- 5G manufacturer page: {url5}")
+                bot.append("\nIf this is not the correct router, reply with the exact model and manufacturer.")
+                blocks.append("\n".join(bot))
+            else:
+                blocks.append(f"**{term}**: not found. Who makes it (manufacturer) and what's the exact model/SKU?")
+
+        if case_keys:
+            blocks.append("\nWould you like to see the **antenna options** (Vehicle, Indoor, Outdoor, Directional) for each router? Reply **Yes** or **No**.")
+            st["pending"] = {"type":"ask_antennas", "case_keys": case_keys}
+        else:
+            st["pending"] = {"type":"await_questions"}
 
-        ck = st["last_case_keys"][-1]
-        case = st["cases"].get(ck, {})
-        ctx = {"case": ck, "replacements": case.get("repl", {}), "urls": case.get("urls", {}), "antennas": case.get("antennas", {})}
-        ans = gpt_answer(text, ctx)
-        history.append((text, ans))
-        _tlog("chat qa flow", t0)
+        history.append((text, "\n\n---\n\n".join(blocks)))
+        _tlog("lookup", t0)
         return history, state_dump(st)
 
     send.click(fn=chat_fn, inputs=[msg, chatbot, state], outputs=[chatbot, state], api_name=False)

only-routers_ai_poc_hf_chat_prod_v2.ipynb

@@ -0,0 +1,1221 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "74c10174",
+   "metadata": {},
+   "source": [
+    "# Only-Routers Chat (prod v2)\n",
+    "\n",
+    "Implements: greeting prompt, antenna yes/no gate + 4 antenna modes per device + photos (best effort), router Q&A phase, stronger matching with typos, best-guess confirmation (no A/B), LLM fallback on no match.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8c717211",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import re\n",
+    "import json\n",
+    "import math\n",
+    "import time\n",
+    "import hashlib\n",
+    "import base64\n",
+    "import tempfile\n",
+    "from dataclasses import dataclass\n",
+    "from datetime import datetime, date\n",
+    "from functools import lru_cache\n",
+    "from typing import Any, Dict, List, Optional, Tuple\n",
+    "\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "import fitz  # PyMuPDF\n",
+    "import faiss\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "from rapidfuzz import fuzz, process\n",
+    "\n",
+    "import gradio as gr\n",
+    "from openai import OpenAI\n",
+    "\n",
+    "# ============================================================\n",
+    "# Only-Routers (Chat, production-lean)\n",
+    "# - Fast model by default (no reasoning payload)\n",
+    "# - One LLM call max per lookup (enrichment only, cached)\n",
+    "# - No HTTP crawling during normal lookup (links are deterministic)\n",
+    "# - Timing logs to HF console when DEBUG_TIMING=1\n",
+    "# ============================================================\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Settings\n",
+    "# ----------------------------\n",
+    "TODAY = date(2026, 1, 18)\n",
+    "\n",
+    "# Fast default model (override via env)\n",
+    "OPENAI_MODEL = os.getenv(\"OPENAI_MODEL\", \"gpt-5.2\").strip()\n",
+    "\n",
+    "# Disable LLM at runtime: OPENAI_DISABLE=1\n",
+    "OPENAI_DISABLE = os.getenv(\"OPENAI_DISABLE\", \"0\").strip() == \"1\"\n",
+    "\n",
+    "# Timing logs\n",
+    "DEBUG_TIMING = os.getenv(\"DEBUG_TIMING\", \"0\").strip() == \"1\"\n",
+    "\n",
+    "# Matching thresholds\n",
+    "MATCH_OK = 82\n",
+    "MATCH_AUTOPICK = 95\n",
+    "MATCH_GAP = 8\n",
+    "\n",
+    "# Embeddings\n",
+    "EMBED_MODEL_NAME = os.getenv(\"EMBED_MODEL_NAME\", \"sentence-transformers/all-MiniLM-L6-v2\").strip()\n",
+    "\n",
+    "# Parsec PDF slicing\n",
+    "PARSEC_CONTEXT_BEFORE = 900\n",
+    "PARSEC_CONTEXT_AFTER = 1600\n",
+    "\n",
+    "# ----------------------------\n",
+    "# OpenAI client\n",
+    "# ----------------------------\n",
+    "API_KEY = os.getenv(\"OPENAI_API_KEY\", \"\").strip()\n",
+    "client = None if (not API_KEY or OPENAI_DISABLE) else OpenAI(api_key=API_KEY)\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Timing helper\n",
+    "# ----------------------------\n",
+    "def _tlog(label: str, t0: float) -> None:\n",
+    "    if DEBUG_TIMING:\n",
+    "        dt = time.perf_counter() - t0\n",
+    "        print(f\"[TIMER] {label}: {dt:.2f}s\")\n",
+    "\n",
+    "# ----------------------------\n",
+    "# JSON-safe helpers\n",
+    "# ----------------------------\n",
+    "def _json_load_safe(s: str) -> Dict[str, Any]:\n",
+    "    try:\n",
+    "        return json.loads(s)\n",
+    "    except Exception:\n",
+    "        return {}\n",
+    "\n",
+    "def _json_dump_safe(obj: Any) -> str:\n",
+    "    try:\n",
+    "        return json.dumps(obj, ensure_ascii=False)\n",
+    "    except Exception:\n",
+    "        return \"{}\"\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Gradio state helpers (string JSON only)\n",
+    "# ----------------------------\n",
+    "def state_load(st_json: str) -> Dict[str, Any]:\n",
+    "    try:\n",
+    "        return json.loads(st_json) if isinstance(st_json, str) and st_json else {}\n",
+    "    except Exception:\n",
+    "        return {}\n",
+    "\n",
+    "def state_dump(st: Dict[str, Any]) -> str:\n",
+    "    return _json_dump_safe(st or {})\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Normalization\n",
+    "# ----------------------------\n",
+    "def norm_text(x: Any) -> str:\n",
+    "    try:\n",
+    "        if x is None or (isinstance(x, float) and math.isnan(x)) or pd.isna(x):\n",
+    "            return \"\"\n",
+    "    except Exception:\n",
+    "        pass\n",
+    "    s = str(x).strip().lower()\n",
+    "    s = re.sub(r\"[^a-z0-9\\s\\-\\/]\", \" \", s)\n",
+    "    s = re.sub(r\"\\s+\", \" \", s).strip()\n",
+    "    return s\n",
+    "\n",
+    "def safe_str(x: Any) -> str:\n",
+    "    if x is None or (isinstance(x, float) and pd.isna(x)) or pd.isna(x):\n",
+    "        return \"\"\n",
+    "    return str(x).strip()\n",
+    "\n",
+    "def is_5g_text(s: str) -> bool:\n",
+    "    t = norm_text(s)\n",
+    "    return (\"5g\" in t) or (\"nr\" in t)\n",
+    "\n",
+    "def is_4g_lte_family(row: pd.Series) -> bool:\n",
+    "    # Treat LTE categories as 4G\n",
+    "    t = norm_text(row.get(\"description\", \"\")) + \" \" + norm_text(row.get(\"notes\", \"\"))\n",
+    "    if \"5g\" in t or \"nr\" in t:\n",
+    "        return False\n",
+    "    if \"lte\" in t or \"4g\" in t:\n",
+    "        return True\n",
+    "    if re.search(r\"\\bcat\\s*[-]?\\s*(m1|m2)\\b\", t):\n",
+    "        return True\n",
+    "    if re.search(r\"\\bcat\\s*[-]?\\s*\\d{1,2}\\b\", t):\n",
+    "        return True\n",
+    "    if \"cat\" in t:\n",
+    "        return True\n",
+    "    return False\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Lifecycle CSV normalization\n",
+    "# ----------------------------\n",
+    "def _normalize_lifecycle_df(df: pd.DataFrame) -> pd.DataFrame:\n",
+    "    df = df.copy()\n",
+    "    lower_cols = {c.lower(): c for c in df.columns}\n",
+    "\n",
+    "    def _pick(*names):\n",
+    "        for n in names:\n",
+    "            if n.lower() in lower_cols:\n",
+    "                return lower_cols[n.lower()]\n",
+    "        return None\n",
+    "\n",
+    "    col_map = {}\n",
+    "\n",
+    "    sku_col = _pick(\"sku\", \"SKU\")\n",
+    "    if sku_col:\n",
+    "        col_map[sku_col] = \"sku\"\n",
+    "\n",
+    "    mfr_col = _pick(\"manufacturer\", \"Manufacturer\")\n",
+    "    if mfr_col:\n",
+    "        col_map[mfr_col] = \"manufacturer\"\n",
+    "\n",
+    "    dt_col = _pick(\"device type\", \"Device Type\", \"device_type\")\n",
+    "    if dt_col:\n",
+    "        col_map[dt_col] = \"device_type\"\n",
+    "\n",
+    "    eos_col = _pick(\"end_of_sale\", \"end of sale\", \"End of Sale\", \"eos\")\n",
+    "    if eos_col:\n",
+    "        col_map[eos_col] = \"end_of_sale\"\n",
+    "\n",
+    "    eol_col = _pick(\"end_of_life\", \"end of life\", \"End of Life\", \"eol\")\n",
+    "    if eol_col:\n",
+    "        col_map[eol_col] = \"end_of_life\"\n",
+    "\n",
+    "    sr_col = _pick(\"suggested_replacement\", \"Suggested Replacement\")\n",
+    "    if sr_col:\n",
+    "        col_map[sr_col] = \"suggested_replacement\"\n",
+    "\n",
+    "    a5_col = _pick(\"advanced_5g_option\", \"Advanced 5G Option\", \"advanced 5g option\")\n",
+    "    if a5_col:\n",
+    "        col_map[a5_col] = \"advanced_5g_option\"\n",
+    "\n",
+    "    df = df.rename(columns=col_map)\n",
+    "\n",
+    "    for req in [\"sku\", \"manufacturer\", \"device_type\", \"end_of_sale\", \"end_of_life\", \"suggested_replacement\", \"advanced_5g_option\"]:\n",
+    "        if req not in df.columns:\n",
+    "            df[req] = \"\"\n",
+    "\n",
+    "    # Compatibility fields used by matching/output\n",
+    "    if \"description\" not in df.columns:\n",
+    "        df[\"description\"] = df[\"sku\"].astype(str)\n",
+    "    if \"notes\" not in df.columns:\n",
+    "        df[\"notes\"] = \"\"\n",
+    "    if \"region\" not in df.columns:\n",
+    "        df[\"region\"] = \"\"\n",
+    "\n",
+    "    return df\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Maker mapping\n",
+    "# ----------------------------\n",
+    "CANON_MAKER = {\n",
+    "    \"CRADLEPOINT\": {\"cradlepoint\", \"ericsson\", \"ericsson enterprise wireless\"},\n",
+    "    \"SIERRA\": {\"sierra\", \"sierra wireless\", \"semtech\", \"airlink\"},\n",
+    "    \"FEENEY\": {\"feeney\", \"feeney wireless\", \"inseego\"},\n",
+    "    \"DIGI\": {\"digi\", \"accelerated\", \"accelerated concepts\"},\n",
+    "    \"CISCO_MERAKI\": {\"meraki\", \"cisco meraki\"},\n",
+    "    \"CISCO\": {\"cisco\"},\n",
+    "    \"TELTONIKA\": {\"teltonika\"},\n",
+    "}\n",
+    "\n",
+    "def canon_maker_from_text(s: Any) -> str:\n",
+    "    t = norm_text(s)\n",
+    "    for canon, terms in CANON_MAKER.items():\n",
+    "        for term in terms:\n",
+    "            if term in t:\n",
+    "                return canon\n",
+    "    return \"UNKNOWN\"\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Date parsing\n",
+    "# ----------------------------\n",
+    "@dataclass\n",
+    "class ParsedDate:\n",
+    "    raw: str\n",
+    "    kind: str\n",
+    "    value: Optional[date]\n",
+    "\n",
+    "def parse_date_field(x: Any) -> ParsedDate:\n",
+    "    raw = safe_str(x)\n",
+    "    if not raw:\n",
+    "        return ParsedDate(raw=\"\", kind=\"missing\", value=None)\n",
+    "\n",
+    "    # MM/DD/YY or M/D/YY\n",
+    "    if re.fullmatch(r\"\\d{1,2}/\\d{1,2}/\\d{2,4}\", raw):\n",
+    "        try:\n",
+    "            parts = raw.split(\"/\")\n",
+    "            m = int(parts[0]); d = int(parts[1]); y = int(parts[2])\n",
+    "            if y < 100:\n",
+    "                y += 2000\n",
+    "            dt = date(y, m, d)\n",
+    "            return ParsedDate(raw=f\"{y:04d}-{m:02d}-{d:02d}\", kind=\"full\", value=dt)\n",
+    "        except Exception:\n",
+    "            return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\n",
+    "    # YYYY\n",
+    "    if re.fullmatch(r\"\\d{4}\", raw):\n",
+    "        y = int(raw)\n",
+    "        if y == TODAY.year:\n",
+    "            return ParsedDate(raw=raw, kind=\"year\", value=date(y, 1, 1))\n",
+    "        if y < TODAY.year:\n",
+    "            return ParsedDate(raw=raw, kind=\"year\", value=date(y, 1, 1))\n",
+    "        return ParsedDate(raw=raw, kind=\"year\", value=date(y, 12, 31))\n",
+    "\n",
+    "    # YYYY-MM\n",
+    "    if re.fullmatch(r\"\\d{4}-\\d{2}\", raw):\n",
+    "        try:\n",
+    "            y, m = raw.split(\"-\")\n",
+    "            dt = date(int(y), int(m), 1)\n",
+    "            return ParsedDate(raw=raw, kind=\"year_month\", value=dt)\n",
+    "        except Exception:\n",
+    "            return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\n",
+    "    # YYYY-MM-DD\n",
+    "    if re.fullmatch(r\"\\d{4}-\\d{2}-\\d{2}\", raw):\n",
+    "        try:\n",
+    "            dt = datetime.strptime(raw, \"%Y-%m-%d\").date()\n",
+    "            return ParsedDate(raw=raw, kind=\"full\", value=dt)\n",
+    "        except Exception:\n",
+    "            return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\n",
+    "    return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\n",
+    "def display_date(pd_: ParsedDate) -> str:\n",
+    "    if pd_.kind == \"missing\":\n",
+    "        return \"Not listed\"\n",
+    "    if pd_.kind == \"bad\":\n",
+    "        return pd_.raw or \"Not listed\"\n",
+    "    return pd_.raw\n",
+    "\n",
+    "def status_from_eos_eol(eos: ParsedDate, eol: ParsedDate) -> str:\n",
+    "    if eos.value is None and eol.value is None:\n",
+    "        return \"Unknown\"\n",
+    "    if eol.value is not None and eol.value <= TODAY:\n",
+    "        return \"End of Life\"\n",
+    "    if eos.value is not None and eos.value <= TODAY:\n",
+    "        return \"End of Sale\"\n",
+    "    return \"Active\"\n",
+    "\n",
+    "def row_to_dates_and_status(row: pd.Series) -> Tuple[str, str, str]:\n",
+    "    eos = parse_date_field(row.get(\"end_of_sale\"))\n",
+    "    eol = parse_date_field(row.get(\"end_of_life\"))\n",
+    "    return display_date(eos), display_date(eol), status_from_eos_eol(eos, eol)\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Files\n",
+    "# ----------------------------\n",
+    "EOS_PATH = \"routers_eos_eol_by_sku.csv\"\n",
+    "DEC_PATH = \"dec2025routers.csv\"\n",
+    "PARSEC_PDF = \"ParsecCatalog.pdf\"\n",
+    "\n",
+    "if not os.path.exists(EOS_PATH):\n",
+    "    raise FileNotFoundError(f\"Missing {EOS_PATH} in repo.\")\n",
+    "if not os.path.exists(DEC_PATH):\n",
+    "    raise FileNotFoundError(f\"Missing {DEC_PATH} in repo.\")\n",
+    "if not os.path.exists(PARSEC_PDF):\n",
+    "    raise FileNotFoundError(f\"Missing {PARSEC_PDF} in repo.\")\n",
+    "\n",
+    "t0 = time.perf_counter()\n",
+    "df_eos = pd.read_csv(EOS_PATH).copy()\n",
+    "df_dec = pd.read_csv(DEC_PATH).copy()\n",
+    "df_eos = _normalize_lifecycle_df(df_eos)\n",
+    "\n",
+    "# Canon columns\n",
+    "df_eos[\"_canon_make\"] = df_eos[\"manufacturer\"].apply(canon_maker_from_text)\n",
+    "df_eos[\"_norm_sku\"] = df_eos[\"sku\"].apply(norm_text)\n",
+    "df_eos[\"_norm_desc\"] = df_eos[\"description\"].apply(norm_text)\n",
+    "df_eos[\"_norm_notes\"] = df_eos[\"notes\"].apply(norm_text)\n",
+    "\n",
+    "df_dec[\"_canon_make\"] = df_dec[\"Make\"].apply(canon_maker_from_text) if \"Make\" in df_dec.columns else \"UNKNOWN\"\n",
+    "df_dec[\"_norm_model\"] = df_dec[\"Model\"].apply(norm_text) if \"Model\" in df_dec.columns else \"\"\n",
+    "df_dec[\"_is5g\"] = df_dec[\"Modem Type\"].apply(lambda x: is_5g_text(str(x))) if \"Modem Type\" in df_dec.columns else False\n",
+    "_tlog(\"load csv\", t0)\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Build fuzzy corpus for device matching\n",
+    "# ----------------------------\n",
+    "def _label_for_row(i: int) -> str:\n",
+    "    r = df_eos.iloc[i]\n",
+    "    return f\"{r.get('sku','')} — {r.get('manufacturer','')} — {r.get('description','')}\"[:220]\n",
+    "\n",
+    "EOS_LABELS = [_label_for_row(i) for i in range(len(df_eos))]\n",
+    "EOS_CORPUS = []\n",
+    "for _, r in df_eos.iterrows():\n",
+    "    EOS_CORPUS.append(\" \".join([r.get(\"_norm_sku\",\"\"), r.get(\"_canon_make\",\"\"), r.get(\"_norm_desc\",\"\"), r.get(\"_norm_notes\",\"\")]))\n",
+    "\n",
+    "def resolve_device(term: str) -> Dict[str, Any]:\n",
+    "    q = norm_text(term)\n",
+    "    if not q:\n",
+    "        return {\"mode\": \"not_found\"}\n",
+    "\n",
+    "    exact = df_eos.index[df_eos[\"_norm_sku\"] == q].tolist()\n",
+    "    if len(exact) == 1:\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": int(exact[0])}\n",
+    "\n",
+    "    hits = process.extract(q, EOS_CORPUS, scorer=fuzz.WRatio, limit=6)\n",
+    "    cands = [(int(idx), int(score), EOS_LABELS[int(idx)]) for _, score, idx in hits]\n",
+    "\n",
+    "    if not cands:\n",
+    "        return {\"mode\":\"not_found\"}\n",
+    "\n",
+    "    if cands[0][1] >= MATCH_AUTOPICK and (len(cands) == 1 or (cands[0][1] - cands[1][1]) >= MATCH_GAP):\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": cands[0][0]}\n",
+    "\n",
+    "    opts = [{\"row_idx\": cands[0][0], \"label\": cands[0][2]}]\n",
+    "    if len(cands) > 1:\n",
+    "        opts.append({\"row_idx\": cands[1][0], \"label\": cands[1][2]})\n",
+    "    return {\"mode\":\"pick\",\"options\": opts}\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Parsec RAG (FAISS)\n",
+    "# ----------------------------\n",
+    "t0 = time.perf_counter()\n",
+    "embedder = SentenceTransformer(EMBED_MODEL_NAME)\n",
+    "\n",
+    "def extract_pdf_text_pages(path: str) -> List[str]:\n",
+    "    doc = fitz.open(path)\n",
+    "    return [doc[i].get_text(\"text\") for i in range(len(doc))]\n",
+    "\n",
+    "def build_parsec_cards(pages: List[str]) -> List[str]:\n",
+    "    cards = []\n",
+    "    for p in pages:\n",
+    "        for m in re.finditer(r\"Standard\\s+SKU:\", p):\n",
+    "            start = max(0, m.start() - PARSEC_CONTEXT_BEFORE)\n",
+    "            end = min(len(p), m.start() + PARSEC_CONTEXT_AFTER)\n",
+    "            c = p[start:end].strip()\n",
+    "            if len(c) >= 200:\n",
+    "                cards.append(c)\n",
+    "    out, seen = [], set()\n",
+    "    for c in cards:\n",
+    "        h = hashlib.sha1(c.encode(\"utf-8\")).hexdigest()\n",
+    "        if h not in seen:\n",
+    "            seen.add(h); out.append(c)\n",
+    "    return out\n",
+    "\n",
+    "parsec_cards = build_parsec_cards(extract_pdf_text_pages(PARSEC_PDF))\n",
+    "parsec_emb = embedder.encode(parsec_cards, batch_size=64, show_progress_bar=False, normalize_embeddings=True)\n",
+    "parsec_emb = np.asarray(parsec_emb, dtype=np.float32)\n",
+    "parsec_index = faiss.IndexFlatIP(parsec_emb.shape[1])\n",
+    "parsec_index.add(parsec_emb)\n",
+    "_tlog(\"parsec index\", t0)\n",
+    "# ----------------------------\n",
+    "# Antenna photos from ParsecCatalog.pdf (best effort)\n",
+    "# - Build a map from Standard SKU -> page indices once at startup\n",
+    "# - Extract the largest image on the matching page and embed as data URI in markdown\n",
+    "#   (only used when user asks for antenna options)\n",
+    "# ----------------------------\n",
+    "PARSEC_PN_TO_PAGES: Dict[str, List[int]] = {}\n",
+    "\n",
+    "try:\n",
+    "    _doc = fitz.open(PARSEC_PDF)\n",
+    "    for i in range(len(_doc)):\n",
+    "        t = _doc[i].get_text(\"text\") or \"\"\n",
+    "        for m in re.finditer(r\"Standard\\s+SKU:\\s*([A-Z0-9]+)\", t):\n",
+    "            pn = m.group(1).strip().upper()\n",
+    "            PARSEC_PN_TO_PAGES.setdefault(pn, []).append(i)\n",
+    "except Exception:\n",
+    "    PARSEC_PN_TO_PAGES = {}\n",
+    "\n",
+    "def _extract_largest_image_data_uri(page_index: int, max_bytes: int = 350_000) -> str:\n",
+    "    \"\"\"\n",
+    "    Extract the largest raster image on a PDF page and return as a data URI (PNG).\n",
+    "    If the image is too large to embed, return empty string.\n",
+    "    \"\"\"\n",
+    "    try:\n",
+    "        doc = fitz.open(PARSEC_PDF)\n",
+    "        page = doc[page_index]\n",
+    "        imgs = page.get_images(full=True) or []\n",
+    "        if not imgs:\n",
+    "            return \"\"\n",
+    "\n",
+    "        best_xref = None\n",
+    "        best_area = 0\n",
+    "        for img in imgs:\n",
+    "            xref = img[0]\n",
+    "            pix = fitz.Pixmap(doc, xref)\n",
+    "            area = pix.width * pix.height\n",
+    "            if area > best_area and pix.width >= 200 and pix.height >= 200:\n",
+    "                best_area = area\n",
+    "                best_xref = xref\n",
+    "            pix = None\n",
+    "\n",
+    "        if best_xref is None:\n",
+    "            return \"\"\n",
+    "\n",
+    "        pix = fitz.Pixmap(doc, best_xref)\n",
+    "        if pix.n >= 5:  # CMYK\n",
+    "            pix = fitz.Pixmap(fitz.csRGB, pix)\n",
+    "\n",
+    "        png_bytes = pix.tobytes(\"png\")\n",
+    "        if len(png_bytes) > max_bytes:\n",
+    "            return \"\"\n",
+    "\n",
+    "        b64 = base64.b64encode(png_bytes).decode(\"ascii\")\n",
+    "        return f\"data:image/png;base64,{b64}\"\n",
+    "    except Exception:\n",
+    "        return \"\"\n",
+    "\n",
+    "@lru_cache(maxsize=512)\n",
+    "def antenna_photo_data_uri(part_number: str) -> str:\n",
+    "    pn = str(part_number or \"\").strip().upper()\n",
+    "    if not pn:\n",
+    "        return \"\"\n",
+    "    pages = PARSEC_PN_TO_PAGES.get(pn, [])\n",
+    "    if not pages:\n",
+    "        return \"\"\n",
+    "    for p in pages[:3]:\n",
+    "        uri = _extract_largest_image_data_uri(p)\n",
+    "        if uri:\n",
+    "            return uri\n",
+    "    return \"\"\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Stronger matching (regex normalization + fuzzy)\n",
+    "# ----------------------------\n",
+    "def _normalize_query_compact(s: str) -> str:\n",
+    "    s = str(s or \"\").strip().upper()\n",
+    "    return re.sub(r\"[^A-Z0-9]\", \"\", s)\n",
+    "\n",
+    "def resolve_device_stronger(term: str) -> Dict[str, Any]:\n",
+    "    raw = str(term or \"\").strip()\n",
+    "    if not raw:\n",
+    "        return {\"mode\":\"not_found\"}\n",
+    "\n",
+    "    q_compact = _normalize_query_compact(raw)\n",
+    "    # exact compact SKU match\n",
+    "    if q_compact:\n",
+    "        for i, sku in enumerate(df_eos[\"_norm_sku\"].tolist()):\n",
+    "            if _normalize_query_compact(sku) == q_compact:\n",
+    "                return {\"mode\":\"ok\", \"row_idx\": i, \"confidence\":\"High\"}\n",
+    "\n",
+    "    hits = process.extract(raw, EOS_CORPUS, scorer=fuzz.WRatio, limit=6)\n",
+    "    cands = [(int(idx), int(score), EOS_LABELS[int(idx)]) for _, score, idx in hits]\n",
+    "    if not cands:\n",
+    "        return {\"mode\":\"not_found\"}\n",
+    "\n",
+    "    if cands[0][1] >= MATCH_AUTOPICK and (len(cands)==1 or (cands[0][1]-cands[1][1]) >= MATCH_GAP):\n",
+    "        return {\"mode\":\"ok\", \"row_idx\": cands[0][0], \"confidence\":\"High\"}\n",
+    "\n",
+    "    return {\"mode\":\"guess\", \"row_idx\": cands[0][0], \"confidence\":\"Medium\", \"guess_label\": cands[0][2], \"raw\": raw}\n",
+    "\n",
+    "# ----------------------------\n",
+    "# LLM fallback: identify router + replacements (Verizon equipment only, no pricing)\n",
+    "# ----------------------------\n",
+    "def llm_identify_router_and_replacements(raw_text: str) -> Dict[str, Any]:\n",
+    "    if client is None:\n",
+    "        return {\"found\": False, \"note\": \"No API key configured.\"}\n",
+    "\n",
+    "    sys = (\n",
+    "        \"You help Verizon reps identify cellular routers and suggest replacements. \"\n",
+    "        \"Keep it to Verizon-sellable equipment families when possible \"\n",
+    "        \"(Cradlepoint, Sierra/AirLink, Digi, Cisco/Meraki, Teltonika, Inseego). \"\n",
+    "        \"No pricing. Return strict JSON only.\"\n",
+    "    )\n",
+    "    payload = {\n",
+    "        \"user_input\": raw_text,\n",
+    "        \"output_schema\": {\n",
+    "            \"best_guess_model\": \"string\",\n",
+    "            \"maker_family\": \"CRADLEPOINT|SIERRA|DIGI|CISCO|CISCO_MERAKI|TELTONIKA|FEENEY|UNKNOWN\",\n",
+    "            \"repl_5g\": \"string\",\n",
+    "            \"repl_4g\": \"string\",\n",
+    "            \"confidence\": \"High|Medium\",\n",
+    "            \"note\": \"string\"\n",
+    "        }\n",
+    "    }\n",
+    "    resp = client.responses.create(\n",
+    "        model=OPENAI_MODEL,\n",
+    "        input=[{\"role\":\"system\",\"content\":sys},{\"role\":\"user\",\"content\":_json_dump_safe(payload)}],\n",
+    "        max_output_tokens=360,\n",
+    "    )\n",
+    "    out = _json_load_safe(getattr(resp, \"output_text\", \"\") or \"\")\n",
+    "    if not isinstance(out, dict) or not out.get(\"best_guess_model\"):\n",
+    "        return {\"found\": False, \"note\": \"Could not identify router.\"}\n",
+    "    out[\"found\"] = True\n",
+    "    return out\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Antenna options: Vehicle + Indoor + Outdoor + Directional\n",
+    "# (all omni except directional)\n",
+    "# ----------------------------\n",
+    "def antenna_options_4pack(repl5: str) -> Dict[str, Dict[str, Any]]:\n",
+    "    # All 5G routers => 4x4\n",
+    "    veh = antenna_pick(repl5, mode=\"vehicle\", detail=None)\n",
+    "    ind = antenna_pick(repl5, mode=\"stationary\", detail=\"indoor\")\n",
+    "    outd = antenna_pick(repl5, mode=\"stationary\", detail=\"outdoor\")\n",
+    "    direc = antenna_pick(repl5, mode=\"stationary\", detail=\"directional\")\n",
+    "\n",
+    "    for a in (veh, ind, outd, direc):\n",
+    "        a[\"photo_uri\"] = antenna_photo_data_uri(a.get(\"part_number\",\"\"))\n",
+    "\n",
+    "    return {\"vehicle\": veh, \"indoor\": ind, \"outdoor\": outd, \"directional\": direc}\n",
+    "\n",
+    "def _fmt_ant(a: Dict[str, Any]) -> str:\n",
+    "    name = a.get(\"name\",\"\")\n",
+    "    pn = a.get(\"part_number\",\"\")\n",
+    "    desc = a.get(\"description\",\"\")\n",
+    "    conn = a.get(\"connectors\",\"\")\n",
+    "    s = f\"**{name}** (PN {pn}) — {desc}\"\n",
+    "    if conn:\n",
+    "        s += f\" | Conn: {conn}\"\n",
+    "    return s\n",
+    "\n",
+    "\n",
+    "PARSEC_FAMILY_WORDS = {\"chinook\",\"labrador\",\"boxer\",\"bloodhound\",\"husky\",\"beagle\",\"mastiff\",\"collie\",\"shepherd\",\"belgian\",\"australian\",\"terrier\",\"pyrenees\"}\n",
+    "\n",
+    "def _parsec_name_from_card(card_text: str) -> str:\n",
+    "    low = card_text.lower()\n",
+    "    for fam in PARSEC_FAMILY_WORDS:\n",
+    "        if fam in low:\n",
+    "            return fam.capitalize()\n",
+    "    return \"Parsec antenna\"\n",
+    "\n",
+    "def _parsec_part_from_card(t: str) -> str:\n",
+    "    m = re.search(r\"Standard\\s+SKU:\\s*([A-Z0-9]+)\", t)\n",
+    "    return m.group(1).strip() if m else \"\"\n",
+    "\n",
+    "def _parsec_desc_from_card(t: str) -> str:\n",
+    "    m = re.search(r\"Description:\\s*(.+?)(?:\\n|$)\", t, flags=re.IGNORECASE)\n",
+    "    return re.sub(r\"\\s+\",\" \",m.group(1).strip())[:220] if m else \"\"\n",
+    "\n",
+    "def _parsec_connectors_from_card(t: str) -> str:\n",
+    "    m = re.search(r\"Standard\\s+Connectors:\\s*(.+)\", t, flags=re.IGNORECASE)\n",
+    "    return re.sub(r\"\\s+\",\" \",m.group(1).strip())[:80] if m else \"\"\n",
+    "\n",
+    "def parsec_retrieve(query: str, top_k: int = 8) -> List[Dict[str, Any]]:\n",
+    "    qv = embedder.encode([query], normalize_embeddings=True)\n",
+    "    qv = np.asarray(qv, dtype=np.float32)\n",
+    "    scores, ids = parsec_index.search(qv, top_k)\n",
+    "    out = []\n",
+    "    for sc, i in zip(scores[0].tolist(), ids[0].tolist()):\n",
+    "        if 0 <= int(i) < len(parsec_cards):\n",
+    "            card = parsec_cards[int(i)]\n",
+    "            out.append({\n",
+    "                \"score\": float(sc),\n",
+    "                \"name\": _parsec_name_from_card(card),\n",
+    "                \"part_number\": _parsec_part_from_card(card),\n",
+    "                \"description\": _parsec_desc_from_card(card),\n",
+    "                \"connectors\": _parsec_connectors_from_card(card),\n",
+    "            })\n",
+    "    return out\n",
+    "\n",
+    "def antenna_pick(repl5: str, mode: str, detail: Optional[str]) -> Dict[str, Any]:\n",
+    "    mimo = \"4x4\"  # rule: all 5G -> 4x4\n",
+    "    tech = \"5G\"\n",
+    "    if mode == \"vehicle\":\n",
+    "        q = f\"{repl5} {tech} {mimo} omni vehicle mobile magnetic through-bolt\"\n",
+    "        c = parsec_retrieve(q, top_k=8)\n",
+    "        best = c[0] if c else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\",\"connectors\":\"\"}\n",
+    "        best.update({\"mimo\": mimo, \"why\": \"Vehicle omni best match.\"})\n",
+    "        return best\n",
+    "\n",
+    "    if detail == \"directional\":\n",
+    "        q = f\"{repl5} {tech} {mimo} directional fixed site\"\n",
+    "        c = parsec_retrieve(q, top_k=8)\n",
+    "        best = c[0] if c else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\",\"connectors\":\"\"}\n",
+    "        best.update({\"mimo\": mimo, \"why\": \"Stationary directional best match.\"})\n",
+    "        return best\n",
+    "\n",
+    "    if detail == \"indoor\":\n",
+    "        q = f\"{repl5} {tech} {mimo} omni indoor\"\n",
+    "        c = parsec_retrieve(q, top_k=8)\n",
+    "        best = c[0] if c else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\",\"connectors\":\"\"}\n",
+    "        best.update({\"mimo\": mimo, \"why\": \"Stationary indoor omni best match.\"})\n",
+    "        return best\n",
+    "\n",
+    "    q = f\"{repl5} {tech} {mimo} omni outdoor pole wall fixed site\"\n",
+    "    c = parsec_retrieve(q, top_k=8)\n",
+    "    best = c[0] if c else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\",\"connectors\":\"\"}\n",
+    "    best.update({\"mimo\": mimo, \"why\": \"Stationary outdoor omni best match.\"})\n",
+    "    return best\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Replacement selection (lifecycle-first)\n",
+    "# ----------------------------\n",
+    "def extract_model_token(text: str) -> str:\n",
+    "    s = safe_str(text)\n",
+    "    if not s:\n",
+    "        return \"\"\n",
+    "    parts = [p.strip() for p in s.split(\"|\") if p.strip()]\n",
+    "    candidates = parts[::-1] if parts else [s]\n",
+    "    for cand in candidates:\n",
+    "        u = cand.upper()\n",
+    "        m = re.search(r\"\\bRUT[A-Z]?\\d{2,4}\\b\", u)\n",
+    "        if m:\n",
+    "            return m.group(0)\n",
+    "        m = re.search(r\"\\bRUTM\\d{2,3}\\b\", u)\n",
+    "        if m:\n",
+    "            return m.group(0)\n",
+    "        m = re.search(r\"\\bIX\\d{2}\\b\", u)\n",
+    "        if m:\n",
+    "            return m.group(0)\n",
+    "        m = re.search(r\"\\b(R\\d{3,4}|E\\d{3,4}|S\\d{3,4})\\b\", u)\n",
+    "        if m:\n",
+    "            return m.group(0)\n",
+    "        m = re.search(r\"\\b[A-Z]{1,6}\\d{2,4}[A-Z]?\\b\", u)\n",
+    "        if m:\n",
+    "            return m.group(0)\n",
+    "    return candidates[0][:60]\n",
+    "\n",
+    "def pick_replacements(row: pd.Series, status: str) -> Dict[str, str]:\n",
+    "    sug = safe_str(row.get(\"suggested_replacement\", \"\"))\n",
+    "    adv = safe_str(row.get(\"advanced_5g_option\", \"\"))\n",
+    "\n",
+    "    repl_4g = extract_model_token(sug) if sug else \"Not applicable\"\n",
+    "    repl_5g = extract_model_token(adv) if adv else \"Not listed\"\n",
+    "\n",
+    "    # Always provide some 5G answer: if lifecycle missing, pick top 5G from dec (same maker)\n",
+    "    if repl_5g in {\"\", \"Not listed\"}:\n",
+    "        canon_make = str(row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "        pool = df_dec[(df_dec[\"_canon_make\"] == canon_make) & (df_dec[\"_is5g\"] == True)].copy()\n",
+    "        repl_5g = str(pool.iloc[0][\"Model\"]).strip() if not pool.empty else \"Not listed\"\n",
+    "\n",
+    "    return {\"repl_4g\": repl_4g or \"Not applicable\", \"repl_5g\": repl_5g or \"Not listed\"}\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Features + Fit (dec first, single LLM enrichment call if needed)\n",
+    "# ----------------------------\n",
+    "FEATURE_COLS = [\"Device\", \"Modem technology\", \"WiFi\", \"Ports\", \"Antennas\", \"Ruggedness\", \"Use case\"]\n",
+    "FIT_COLS = [\"Device\", \"Fit badges\", \"Ethernet ports\", \"Battery\"]\n",
+    "\n",
+    "def _features_from_dec(model: str, canon_make: str) -> Dict[str, str]:\n",
+    "    if not model or model in {\"Not listed\", \"Not applicable\"}:\n",
+    "        return {k: \"Not listed\" for k in FEATURE_COLS[1:]}\n",
+    "    pool = df_dec[df_dec[\"_canon_make\"] == canon_make].copy()\n",
+    "    if pool.empty:\n",
+    "        return {k: \"Not listed\" for k in FEATURE_COLS[1:]}\n",
+    "    hit = process.extractOne(norm_text(model), pool[\"_norm_model\"].tolist(), scorer=fuzz.WRatio)\n",
+    "    if not hit or hit[1] < MATCH_OK:\n",
+    "        return {k: \"Not listed\" for k in FEATURE_COLS[1:]}\n",
+    "    r = pool.iloc[int(hit[2])]\n",
+    "    ports = f\"WAN: {r.get('WAN ports and speed','')} | LAN: {r.get('LAN ports and speed','')}\".strip()\n",
+    "    return {\n",
+    "        \"Modem technology\": str(r.get(\"Modem Type\",\"\") or \"Not listed\"),\n",
+    "        \"WiFi\": str(r.get(\"WiFi type\",\"\") or \"Not listed\"),\n",
+    "        \"Ports\": ports if ports else \"Not listed\",\n",
+    "        \"Antennas\": str(r.get(\"Antennas (internal/external/both)\",\"\") or \"Not listed\"),\n",
+    "        \"Ruggedness\": str(r.get(\"Ruggedization\",\"\") or \"Not listed\"),\n",
+    "        \"Use case\": str(r.get(\"Primary use case\",\"\") or \"Not listed\"),\n",
+    "    }\n",
+    "\n",
+    "def _fit_from_dec(model: str, canon_make: str, is5: bool) -> Dict[str, str]:\n",
+    "    badges = []\n",
+    "    eth = \"Not listed\"\n",
+    "    bat = \"Not listed\"\n",
+    "    if is5:\n",
+    "        badges.append(\"4x4 MIMO\")\n",
+    "\n",
+    "    pool = df_dec[df_dec[\"_canon_make\"] == canon_make].copy()\n",
+    "    if pool.empty or not model or model in {\"Not listed\", \"Not applicable\"}:\n",
+    "        return {\"Fit badges\": \", \".join(badges) if badges else \"Not listed\", \"Ethernet ports\": eth, \"Battery\": bat}\n",
+    "\n",
+    "    hit = process.extractOne(norm_text(model), pool[\"_norm_model\"].tolist(), scorer=fuzz.WRatio)\n",
+    "    if not hit or hit[1] < MATCH_OK:\n",
+    "        return {\"Fit badges\": \", \".join(badges) if badges else \"Not listed\", \"Ethernet ports\": eth, \"Battery\": bat}\n",
+    "\n",
+    "    r = pool.iloc[int(hit[2])]\n",
+    "    use_case = str(r.get(\"Primary use case\",\"\") or \"\").lower()\n",
+    "    rugged = str(r.get(\"Ruggedization\",\"\") or \"\").lower()\n",
+    "    wifi = str(r.get(\"WiFi type\",\"\") or \"\").strip().lower()\n",
+    "    serial = str(r.get(\"Serial port (yes/no)\",\"\") or \"\").strip().lower()\n",
+    "    battery = str(r.get(\"Battery (internal/removable/none/optional)\",\"\") or \"\").strip().lower()\n",
+    "    notes_blob = \" \".join([str(r.get(\"Special notes\",\"\") or \"\"), str(r.get(\"summary and use case\",\"\") or \"\")]).lower()\n",
+    "\n",
+    "    if any(k in use_case for k in [\"vehicle\",\"mobile\",\"fleet\",\"in-vehicle\"]) or \"vehicle\" in rugged:\n",
+    "        badges.append(\"Vehicle\")\n",
+    "    else:\n",
+    "        badges.append(\"Fixed site\")\n",
+    "\n",
+    "    if wifi and wifi not in {\"none\",\"no\",\"n/a\"}:\n",
+    "        badges.append(\"Wi‑Fi\")\n",
+    "    if any(k in rugged for k in [\"rugged\",\"industrial\",\"ip\",\"harsh\"]):\n",
+    "        badges.append(\"Rugged\")\n",
+    "    if \"dual\" in notes_blob and \"sim\" in notes_blob:\n",
+    "        badges.append(\"Dual‑SIM\")\n",
+    "    if serial in {\"yes\",\"y\",\"true\"}:\n",
+    "        badges.append(\"Serial\")\n",
+    "\n",
+    "    if battery:\n",
+    "        if \"none\" in battery:\n",
+    "            bat = \"No\"\n",
+    "        else:\n",
+    "            bat = \"Yes\"\n",
+    "\n",
+    "    badges_csv = \", \".join(dict.fromkeys(badges)) if badges else \"Not listed\"\n",
+    "    return {\"Fit badges\": badges_csv, \"Ethernet ports\": eth, \"Battery\": bat}\n",
+    "\n",
+    "# Enrichment cache (one call per (make, repl4, repl5))\n",
+    "_ENRICH_CACHE: Dict[str, Dict[str, Any]] = {}\n",
+    "\n",
+    "def _enrich_key(canon_make: str, repl4: str, repl5: str) -> str:\n",
+    "    return hashlib.sha1(f\"{canon_make}|{repl4}|{repl5}\".encode(\"utf-8\")).hexdigest()\n",
+    "\n",
+    "def gpt_enrich(repl4: str, repl5: str, canon_make: str, feat4: Dict[str,str], feat5: Dict[str,str], fit4: Dict[str,str], fit5: Dict[str,str]) -> Dict[str, Any]:\n",
+    "    if client is None:\n",
+    "        return {\"feat4\": feat4, \"feat5\": feat5, \"fit4\": fit4, \"fit5\": fit5}\n",
+    "\n",
+    "    key = _enrich_key(canon_make, repl4, repl5)\n",
+    "    if key in _ENRICH_CACHE:\n",
+    "        return _ENRICH_CACHE[key]\n",
+    "\n",
+    "    def miss(d: Dict[str,str]) -> List[str]:\n",
+    "        out=[]\n",
+    "        for k,v in d.items():\n",
+    "            if (not v) or str(v).strip().lower() in {\"not listed\",\"nan\",\"\"}:\n",
+    "                out.append(k)\n",
+    "        return out\n",
+    "\n",
+    "    m_feat4 = miss(feat4); m_feat5 = miss(feat5)\n",
+    "    m_fit4 = miss(fit4); m_fit5 = miss(fit5)\n",
+    "\n",
+    "    if not (m_feat4 or m_feat5 or m_fit4 or m_fit5):\n",
+    "        pack = {\"feat4\": feat4, \"feat5\": feat5, \"fit4\": fit4, \"fit5\": fit5}\n",
+    "        _ENRICH_CACHE[key] = pack\n",
+    "        return pack\n",
+    "\n",
+    "    sys = (\n",
+    "        \"You are helping a Verizon rep. Fill missing router feature fields and fit traits. Return strict JSON only. \"\n",
+    "        \"Keep values short. \"\n",
+    "        \"Fit badges must be chosen from: ['Vehicle','Fixed site','Wi‑Fi','Rugged','Dual‑SIM','4x4 MIMO','High throughput','Serial'] only. \"\n",
+    "        \"Rule: if a router is 5G, include '4x4 MIMO'. \"\n",
+    "        \"Ethernet ports must be a single integer as a string when possible; else 'Not listed'. \"\n",
+    "        \"Battery must be 'Yes', 'No', or 'Not listed'.\"\n",
+    "    )\n",
+    "\n",
+    "    payload = {\n",
+    "        \"maker_family\": canon_make,\n",
+    "        \"models\": {\"repl4\": repl4, \"repl5\": repl5},\n",
+    "        \"known\": {\"feat4\": feat4, \"feat5\": feat5, \"fit4\": fit4, \"fit5\": fit5},\n",
+    "        \"missing\": {\"feat4\": m_feat4, \"feat5\": m_feat5, \"fit4\": m_fit4, \"fit5\": m_fit5},\n",
+    "        \"output_schema\": {\n",
+    "            \"feat4\": {k: \"string\" for k in m_feat4},\n",
+    "            \"feat5\": {k: \"string\" for k in m_feat5},\n",
+    "            \"fit4\": {k: \"string\" for k in m_fit4},\n",
+    "            \"fit5\": {k: \"string\" for k in m_fit5},\n",
+    "        },\n",
+    "    }\n",
+    "\n",
+    "    t0 = time.perf_counter()\n",
+    "    resp = client.responses.create(\n",
+    "        model=OPENAI_MODEL,\n",
+    "        input=[{\"role\":\"system\",\"content\":sys},{\"role\":\"user\",\"content\":_json_dump_safe(payload)}],\n",
+    "        max_output_tokens=420,\n",
+    "    )\n",
+    "    _tlog(\"llm enrich\", t0)\n",
+    "\n",
+    "    out = _json_load_safe(getattr(resp, \"output_text\", \"\") or \"\")\n",
+    "\n",
+    "    def merge(base: Dict[str,str], patch: Any) -> Dict[str,str]:\n",
+    "        if isinstance(patch, dict):\n",
+    "            for k,v in patch.items():\n",
+    "                sv = str(v or \"\").strip()\n",
+    "                if sv:\n",
+    "                    base[k] = sv\n",
+    "        return base\n",
+    "\n",
+    "    feat4x = merge(dict(feat4), out.get(\"feat4\", {}))\n",
+    "    feat5x = merge(dict(feat5), out.get(\"feat5\", {}))\n",
+    "    fit4x = merge(dict(fit4), out.get(\"fit4\", {}))\n",
+    "    fit5x = merge(dict(fit5), out.get(\"fit5\", {}))\n",
+    "\n",
+    "    # Enforce 5G 4x4 badge\n",
+    "    b = str(fit5x.get(\"Fit badges\",\"\") or \"\")\n",
+    "    if \"4x4 MIMO\" not in b:\n",
+    "        fit5x[\"Fit badges\"] = (b + \", 4x4 MIMO\").strip(\", \").strip() if b and b != \"Not listed\" else \"4x4 MIMO\"\n",
+    "\n",
+    "    pack = {\"feat4\": feat4x, \"feat5\": feat5x, \"fit4\": fit4x, \"fit5\": fit5x}\n",
+    "    _ENRICH_CACHE[key] = pack\n",
+    "    return pack\n",
+    "\n",
+    "def build_tables(repl4: str, repl5: str, canon_make: str) -> Tuple[pd.DataFrame, pd.DataFrame]:\n",
+    "    feat4 = _features_from_dec(repl4, canon_make)\n",
+    "    feat5 = _features_from_dec(repl5, canon_make)\n",
+    "    fit4 = _fit_from_dec(repl4, canon_make, is5=False)\n",
+    "    fit5 = _fit_from_dec(repl5, canon_make, is5=True)\n",
+    "\n",
+    "    pack = gpt_enrich(repl4, repl5, canon_make, feat4, feat5, fit4, fit5)\n",
+    "\n",
+    "    feat_df = pd.DataFrame([\n",
+    "        {\"Device\":\"4G alternative\", **pack[\"feat4\"]},\n",
+    "        {\"Device\":\"5G replacement\", **pack[\"feat5\"]},\n",
+    "    ], columns=FEATURE_COLS)\n",
+    "\n",
+    "    fit_df = pd.DataFrame([\n",
+    "        {\"Device\":\"4G alternative\", **pack[\"fit4\"]},\n",
+    "        {\"Device\":\"5G replacement\", **pack[\"fit5\"]},\n",
+    "    ], columns=FIT_COLS)\n",
+    "\n",
+    "    return feat_df, fit_df\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Manufacturer link (deterministic, no HTTP)\n",
+    "# ----------------------------\n",
+    "MAKER_DOMAINS = {\n",
+    "    \"CRADLEPOINT\": \"https://cradlepoint.com\",\n",
+    "    \"SIERRA\": \"https://airlink.com\",\n",
+    "    \"FEENEY\": \"https://inseego.com\",\n",
+    "    \"DIGI\": \"https://www.digi.com\",\n",
+    "    \"CISCO_MERAKI\": \"https://meraki.cisco.com\",\n",
+    "    \"CISCO\": \"https://www.cisco.com\",\n",
+    "    \"TELTONIKA\": \"https://teltonika-networks.com\",\n",
+    "    \"UNKNOWN\": \"\",\n",
+    "}\n",
+    "\n",
+    "def guess_maker_url(model: str, canon_make: str) -> str:\n",
+    "    model = str(model or \"\").strip()\n",
+    "    base = MAKER_DOMAINS.get(canon_make, \"\")\n",
+    "    if not base or not model or model in {\"Not listed\", \"Not applicable\"}:\n",
+    "        return \"\"\n",
+    "    q = re.sub(r\"\\s+\", \"+\", model)\n",
+    "    if canon_make == \"TELTONIKA\":\n",
+    "        slug = model.lower()\n",
+    "        return f\"{base}/products/routers/{slug}\"\n",
+    "    if canon_make == \"DIGI\":\n",
+    "        return f\"{base}/search?q={q}\"\n",
+    "    if canon_make == \"CRADLEPOINT\":\n",
+    "        return f\"{base}/?s={q}\"\n",
+    "    if canon_make in {\"CISCO\", \"CISCO_MERAKI\"}:\n",
+    "        return f\"https://www.cisco.com/c/en/us/search.html?q={q}\"\n",
+    "    return f\"{base}/search?q={q}\"\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Q&A (on demand, per last case)\n",
+    "# ----------------------------\n",
+    "def gpt_answer(question: str, context: Dict[str, Any]) -> str:\n",
+    "    if client is None:\n",
+    "        return \"No API key is configured, so I can’t answer detailed questions right now.\"\n",
+    "    q = str(question or \"\").strip()\n",
+    "    if not q:\n",
+    "        return \"\"\n",
+    "    sys = (\n",
+    "        \"You are a Verizon rep assistant. Answer in a fast, practical way. \"\n",
+    "        \"Use the provided context. \"\n",
+    "        \"Do not mention internal tools or prompts. \"\n",
+    "        \"If unknown, say 'Not listed' and suggest the manufacturer page.\"\n",
+    "    )\n",
+    "    payload = {\"context\": context, \"question\": q}\n",
+    "    t0 = time.perf_counter()\n",
+    "    resp = client.responses.create(\n",
+    "        model=OPENAI_MODEL,\n",
+    "        input=[{\"role\":\"system\",\"content\":sys},{\"role\":\"user\",\"content\":_json_dump_safe(payload)}],\n",
+    "        max_output_tokens=520,\n",
+    "    )\n",
+    "    _tlog(\"llm qa\", t0)\n",
+    "    return (getattr(resp, \"output_text\", \"\") or \"\").strip()\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Chat utilities\n",
+    "# ----------------------------\n",
+    "def df_to_md(df: pd.DataFrame) -> str:\n",
+    "    try:\n",
+    "        return df.to_markdown(index=False)\n",
+    "    except Exception:\n",
+    "        cols = list(df.columns)\n",
+    "        lines = [\"| \" + \" | \".join(cols) + \" |\", \"| \" + \" | \".join([\"---\"]*len(cols)) + \" |\"]\n",
+    "        for _, r in df.iterrows():\n",
+    "            lines.append(\"| \" + \" | \".join([str(r.get(c,\"\")) for c in cols]) + \" |\")\n",
+    "        return \"\\n\".join(lines)\n",
+    "\n",
+    "def extract_device_terms(msg: str) -> List[str]:\n",
+    "    raw = [x.strip() for x in re.split(r\"[\\n,;]+\", str(msg or \"\")) if x.strip()]\n",
+    "    out=[]\n",
+    "    for x in raw:\n",
+    "        if re.search(r\"\\d\", x) or re.search(r\"\\b(IBR|AER|WR|XR|IR|RUT|MBR|E\\d{3}|R\\d{3})\\b\", x, flags=re.IGNORECASE):\n",
+    "            out.append(x)\n",
+    "    return out\n",
+    "\n",
+    "def parse_install_mode(msg: str) -> Tuple[Optional[str], Optional[str]]:\n",
+    "    t = str(msg or \"\").strip().lower()\n",
+    "    mode = None\n",
+    "    detail = None\n",
+    "    if \"vehicle\" in t or \"mobile\" in t:\n",
+    "        mode = \"vehicle\"\n",
+    "    if \"stationary\" in t or \"fixed\" in t or \"site\" in t:\n",
+    "        mode = \"stationary\"\n",
+    "    if \"indoor\" in t:\n",
+    "        detail = \"indoor\"\n",
+    "    if \"outdoor\" in t:\n",
+    "        detail = \"outdoor\"\n",
+    "    if \"directional\" in t:\n",
+    "        detail = \"directional\"\n",
+    "    return mode, detail\n",
+    "\n",
+    "def make_case_key(s: str) -> str:\n",
+    "    s = str(s or \"\").strip()\n",
+    "    return re.sub(r\"\\s+\", \" \", s)[:80]\n",
+    "\n",
+    "# ----------------------------\n",
+    "# Chat UI (schema-safe)\n",
+    "# ----------------------------\n",
+    "with gr.Blocks(title=\"Only-Routers\") as demo:\n",
+    "    gr.Markdown(\"## Only-Routers\\n\\n**Please enter the router models you would like to verify for replacement.**\\n\\nPaste multiple models/SKUs separated by commas or new lines.\")\n",
+    "\n",
+    "    state = gr.State(\"{}\")\n",
+    "\n",
+    "    chatbot = gr.Chatbot(label=\"Only-Routers Chat\", height=600, type=\"tuples\")\n",
+    "    msg = gr.Textbox(label=\"Message\", placeholder=\"Example: RUT240, WR21\\nVehicle install\", lines=2)\n",
+    "    send = gr.Button(\"Send\", variant=\"primary\")\n",
+    "\n",
+    "    def chat_fn(user_msg, history, st_json):\n",
+    "        t0 = time.perf_counter()\n",
+    "        st = state_load(st_json)\n",
+    "        st.setdefault(\"cases\", {})\n",
+    "        st.setdefault(\"last_case_keys\", [])\n",
+    "        st.setdefault(\"pending\", {})\n",
+    "\n",
+    "        text = (user_msg or \"\").strip()\n",
+    "        if not text:\n",
+    "            return history, state_dump(st)\n",
+    "\n",
+    "        # ----------------------------\n",
+    "        # Pending: confirm best guess\n",
+    "        # ----------------------------\n",
+    "        if st.get(\"pending\", {}).get(\"type\") == \"confirm_guess\":\n",
+    "            pend = st[\"pending\"]\n",
+    "            raw = pend.get(\"raw\",\"\")\n",
+    "            row_idx = int(pend.get(\"row_idx\",-1))\n",
+    "            low = text.lower().strip()\n",
+    "\n",
+    "            if low in {\"yes\",\"y\",\"yeah\",\"yep\",\"correct\",\"right\",\"ok\",\"okay\"}:\n",
+    "                life_row = df_eos.iloc[row_idx]\n",
+    "                eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "                repl = pick_replacements(life_row, status)\n",
+    "                canon_make = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "\n",
+    "                feat_df, fit_df = build_tables(repl[\"repl_4g\"], repl[\"repl_5g\"], canon_make)\n",
+    "                url4 = guess_maker_url(repl[\"repl_4g\"], canon_make) if repl[\"repl_4g\"] != \"Not applicable\" else \"\"\n",
+    "                url5 = guess_maker_url(repl[\"repl_5g\"], canon_make) if repl[\"repl_5g\"] != \"Not listed\" else \"\"\n",
+    "\n",
+    "                ck = make_case_key(str(life_row.get(\"sku\",\"\")) or raw)\n",
+    "                st[\"cases\"][ck] = {\"row_idx\": row_idx, \"repl\": repl, \"canon_make\": canon_make, \"status\": status, \"eos\": eos, \"eol\": eol, \"urls\": {\"4g\": url4, \"5g\": url5}}\n",
+    "                st[\"last_case_keys\"].append(ck)\n",
+    "\n",
+    "                bot=[]\n",
+    "                bot.append(f\"**{ck}**\")\n",
+    "                bot.append(f\"- Status: **{status}** | EOS: **{eos}** | EOL: **{eol}**\")\n",
+    "                bot.append(f\"- 4G alternative: **{repl['repl_4g']}**\")\n",
+    "                bot.append(f\"- 5G replacement: **{repl['repl_5g']}**\")\n",
+    "                if url4:\n",
+    "                    bot.append(f\"- 4G manufacturer page: {url4}\")\n",
+    "                if url5:\n",
+    "                    bot.append(f\"- 5G manufacturer page: {url5}\")\n",
+    "                bot.append(\"\\n**Replacement features**\\n\" + df_to_md(feat_df))\n",
+    "                bot.append(\"\\n**Verizon fit**\\n\" + df_to_md(fit_df))\n",
+    "                bot.append(\"\\nWould you like to see the **antenna options** (Vehicle, Indoor, Outdoor, Directional) for this router? Reply **Yes** or **No**.\")\n",
+    "                st[\"pending\"] = {\"type\":\"ask_antennas\", \"case_keys\":[ck]}\n",
+    "\n",
+    "                history.append((text, \"\\n\".join(bot)))\n",
+    "                _tlog(\"confirm guess\", t0)\n",
+    "                return history, state_dump(st)\n",
+    "\n",
+    "            if low in {\"no\",\"n\",\"nope\",\"wrong\",\"incorrect\"}:\n",
+    "                st[\"pending\"] = {\"type\":\"await_corrected_model\"}\n",
+    "                history.append((text, \"No problem — please reply with the corrected router model/SKU.\"))\n",
+    "                return history, state_dump(st)\n",
+    "\n",
+    "            # If they pasted corrected model instead of yes/no, fall through as new input\n",
+    "            st[\"pending\"] = {}\n",
+    "\n",
+    "        # ----------------------------\n",
+    "        # Pending: waiting for corrected model\n",
+    "        # ----------------------------\n",
+    "        if st.get(\"pending\", {}).get(\"type\") == \"await_corrected_model\":\n",
+    "            st[\"pending\"] = {}  # treat message as a new lookup\n",
+    "\n",
+    "        # ----------------------------\n",
+    "        # Pending: ask antennas yes/no\n",
+    "        # ----------------------------\n",
+    "        if st.get(\"pending\", {}).get(\"type\") == \"ask_antennas\":\n",
+    "            low = text.lower().strip()\n",
+    "            want = low in {\"yes\",\"y\",\"yeah\",\"yep\",\"sure\",\"ok\",\"okay\"}\n",
+    "            case_keys = st[\"pending\"].get(\"case_keys\", []) or st.get(\"last_case_keys\", [])\n",
+    "\n",
+    "            if want:\n",
+    "                blocks=[]\n",
+    "                for ck in case_keys:\n",
+    "                    case = st[\"cases\"].get(ck, {})\n",
+    "                    repl5 = (case.get(\"repl\", {}) or {}).get(\"repl_5g\",\"\")\n",
+    "                    if not repl5 or repl5 == \"Not listed\":\n",
+    "                        blocks.append(f\"**{ck}**: No 5G replacement available to anchor antenna picks.\")\n",
+    "                        continue\n",
+    "\n",
+    "                    opts = antenna_options_4pack(repl5)\n",
+    "                    case[\"antenna_options\"] = opts\n",
+    "                    st[\"cases\"][ck] = case\n",
+    "\n",
+    "                    b=[]\n",
+    "                    b.append(f\"**{ck} — Antenna options (Parsec)**\")\n",
+    "                    b.append(f\"- Vehicle (Omni): {_fmt_ant(opts['vehicle'])}\")\n",
+    "                    b.append(f\"- Indoor (Omni): {_fmt_ant(opts['indoor'])}\")\n",
+    "                    b.append(f\"- Outdoor (Omni): {_fmt_ant(opts['outdoor'])}\")\n",
+    "                    b.append(f\"- Directional: {_fmt_ant(opts['directional'])}\")\n",
+    "\n",
+    "                    # Photos (best effort, may be empty if too large or not found)\n",
+    "                    for label in [\"vehicle\",\"indoor\",\"outdoor\",\"directional\"]:\n",
+    "                        uri = opts[label].get(\"photo_uri\",\"\")\n",
+    "                        if uri:\n",
+    "                            b.append(f\"\\n**{label.capitalize()} photo**\\n![]({uri})\\n\")\n",
+    "\n",
+    "                    blocks.append(\"\\n\".join(b))\n",
+    "\n",
+    "                blocks.append(\"\\nAny questions about the router(s) — including alternatives and comparisons? Ask anything router-related (no pricing).\")\n",
+    "                st[\"pending\"] = {\"type\":\"await_questions\"}\n",
+    "                history.append((text, \"\\n\\n---\\n\\n\".join(blocks)))\n",
+    "                _tlog(\"antennas yes\", t0)\n",
+    "                return history, state_dump(st)\n",
+    "\n",
+    "            # No antennas\n",
+    "            st[\"pending\"] = {\"type\":\"await_questions\"}\n",
+    "            history.append((text, \"Got it. Any questions about the router(s) — including alternatives and comparisons? Ask anything router-related (no pricing).\"))\n",
+    "            return history, state_dump(st)\n",
+    "\n",
+    "        # ----------------------------\n",
+    "        # Pending: questions phase\n",
+    "        # ----------------------------\n",
+    "        if st.get(\"pending\", {}).get(\"type\") == \"await_questions\":\n",
+    "            if not st.get(\"last_case_keys\"):\n",
+    "                history.append((text, \"Please enter the router models you would like to verify for replacement.\"))\n",
+    "                return history, state_dump(st)\n",
+    "\n",
+    "            # Route to most recent unless message mentions a case key\n",
+    "            target = st[\"last_case_keys\"][-1]\n",
+    "            t_low = text.lower()\n",
+    "            for ck in reversed(st[\"last_case_keys\"]):\n",
+    "                if ck.lower() in t_low:\n",
+    "                    target = ck\n",
+    "                    break\n",
+    "\n",
+    "            case = st[\"cases\"].get(target, {})\n",
+    "            ctx = {\n",
+    "                \"case\": target,\n",
+    "                \"status\": case.get(\"status\",\"\"),\n",
+    "                \"eos\": case.get(\"eos\",\"\"),\n",
+    "                \"eol\": case.get(\"eol\",\"\"),\n",
+    "                \"replacements\": case.get(\"repl\", {}),\n",
+    "                \"urls\": case.get(\"urls\", {}),\n",
+    "                \"antenna_options\": case.get(\"antenna_options\", {}),\n",
+    "            }\n",
+    "            ans = gpt_answer(text, ctx)\n",
+    "            history.append((text, ans))\n",
+    "            _tlog(\"qa\", t0)\n",
+    "            return history, state_dump(st)\n",
+    "\n",
+    "        # ----------------------------\n",
+    "        # Normal device intake\n",
+    "        # ----------------------------\n",
+    "        terms = extract_device_terms(text)\n",
+    "        if not terms:\n",
+    "            # If not a device list, treat as question about last router if possible\n",
+    "            if st.get(\"last_case_keys\"):\n",
+    "                case = st[\"cases\"].get(st[\"last_case_keys\"][-1], {})\n",
+    "                ctx = {\"replacements\": case.get(\"repl\", {}), \"urls\": case.get(\"urls\", {}), \"antenna_options\": case.get(\"antenna_options\", {})}\n",
+    "                ans = gpt_answer(text, ctx)\n",
+    "                history.append((text, ans))\n",
+    "                return history, state_dump(st)\n",
+    "\n",
+    "            history.append((text, \"Please enter the router models you would like to verify for replacement.\"))\n",
+    "            return history, state_dump(st)\n",
+    "\n",
+    "        blocks=[]\n",
+    "        case_keys=[]\n",
+    "\n",
+    "        for term in terms:\n",
+    "            res = resolve_device_stronger(term)\n",
+    "\n",
+    "            if res.get(\"mode\") == \"ok\":\n",
+    "                row_idx = int(res[\"row_idx\"])\n",
+    "                life_row = df_eos.iloc[row_idx]\n",
+    "                eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "                repl = pick_replacements(life_row, status)\n",
+    "                canon_make = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "\n",
+    "                feat_df, fit_df = build_tables(repl[\"repl_4g\"], repl[\"repl_5g\"], canon_make)\n",
+    "                url4 = guess_maker_url(repl[\"repl_4g\"], canon_make) if repl[\"repl_4g\"] != \"Not applicable\" else \"\"\n",
+    "                url5 = guess_maker_url(repl[\"repl_5g\"], canon_make) if repl[\"repl_5g\"] != \"Not listed\" else \"\"\n",
+    "\n",
+    "                ck = make_case_key(str(life_row.get(\"sku\",\"\")) or term)\n",
+    "                st[\"cases\"][ck] = {\"row_idx\": row_idx, \"repl\": repl, \"canon_make\": canon_make, \"status\": status, \"eos\": eos, \"eol\": eol, \"urls\": {\"4g\": url4, \"5g\": url5}}\n",
+    "                st[\"last_case_keys\"].append(ck)\n",
+    "                case_keys.append(ck)\n",
+    "\n",
+    "                bot=[]\n",
+    "                bot.append(f\"**{ck}**\")\n",
+    "                bot.append(f\"- Status: **{status}** | EOS: **{eos}** | EOL: **{eol}**\")\n",
+    "                bot.append(f\"- 4G alternative: **{repl['repl_4g']}**\")\n",
+    "                bot.append(f\"- 5G replacement: **{repl['repl_5g']}**\")\n",
+    "                if url4:\n",
+    "                    bot.append(f\"- 4G manufacturer page: {url4}\")\n",
+    "                if url5:\n",
+    "                    bot.append(f\"- 5G manufacturer page: {url5}\")\n",
+    "                bot.append(\"\\n**Replacement features**\\n\" + df_to_md(feat_df))\n",
+    "                bot.append(\"\\n**Verizon fit**\\n\" + df_to_md(fit_df))\n",
+    "                blocks.append(\"\\n\".join(bot))\n",
+    "                continue\n",
+    "\n",
+    "            if res.get(\"mode\") == \"guess\":\n",
+    "                st[\"pending\"] = {\"type\":\"confirm_guess\", \"row_idx\": int(res[\"row_idx\"]), \"raw\": res.get(\"raw\",\"\")}\n",
+    "                history.append((text, f\"I think you mean: **{res.get('guess_label','')}**. Is that correct? Reply **Yes** or **No** (or paste the corrected model).\"))\n",
+    "                return history, state_dump(st)\n",
+    "\n",
+    "            # Not found locally: ask to clarify AND attempt LLM best effort\n",
+    "            llm = llm_identify_router_and_replacements(term)\n",
+    "            if llm.get(\"found\"):\n",
+    "                ck = make_case_key(llm.get(\"best_guess_model\",\"\") or term)\n",
+    "                repl = {\"repl_4g\": llm.get(\"repl_4g\",\"Not applicable\") or \"Not applicable\", \"repl_5g\": llm.get(\"repl_5g\",\"Not listed\") or \"Not listed\"}\n",
+    "                canon_make = llm.get(\"maker_family\",\"UNKNOWN\")\n",
+    "                url4 = guess_maker_url(repl[\"repl_4g\"], canon_make) if repl[\"repl_4g\"] != \"Not applicable\" else \"\"\n",
+    "                url5 = guess_maker_url(repl[\"repl_5g\"], canon_make) if repl[\"repl_5g\"] != \"Not listed\" else \"\"\n",
+    "\n",
+    "                st[\"cases\"][ck] = {\"row_idx\": None, \"repl\": repl, \"canon_make\": canon_make, \"status\": \"Unknown\", \"eos\": \"Not listed\", \"eol\": \"Not listed\", \"urls\": {\"4g\": url4, \"5g\": url5}, \"llm_note\": llm.get(\"note\",\"\")}\n",
+    "                st[\"last_case_keys\"].append(ck)\n",
+    "                case_keys.append(ck)\n",
+    "\n",
+    "                bot=[]\n",
+    "                bot.append(f\"**{ck}** (best effort)\")\n",
+    "                bot.append(f\"- Note: {llm.get('note','')}\")\n",
+    "                bot.append(f\"- 4G alternative: **{repl['repl_4g']}**\")\n",
+    "                bot.append(f\"- 5G replacement: **{repl['repl_5g']}**\")\n",
+    "                if url4:\n",
+    "                    bot.append(f\"- 4G manufacturer page: {url4}\")\n",
+    "                if url5:\n",
+    "                    bot.append(f\"- 5G manufacturer page: {url5}\")\n",
+    "                bot.append(\"\\nIf this is not the correct router, reply with the exact model and manufacturer.\")\n",
+    "                blocks.append(\"\\n\".join(bot))\n",
+    "            else:\n",
+    "                blocks.append(f\"**{term}**: not found. Who makes it (manufacturer) and what's the exact model/SKU?\")\n",
+    "\n",
+    "        if case_keys:\n",
+    "            blocks.append(\"\\nWould you like to see the **antenna options** (Vehicle, Indoor, Outdoor, Directional) for each router? Reply **Yes** or **No**.\")\n",
+    "            st[\"pending\"] = {\"type\":\"ask_antennas\", \"case_keys\": case_keys}\n",
+    "        else:\n",
+    "            st[\"pending\"] = {\"type\":\"await_questions\"}\n",
+    "\n",
+    "        history.append((text, \"\\n\\n---\\n\\n\".join(blocks)))\n",
+    "        _tlog(\"lookup\", t0)\n",
+    "        return history, state_dump(st)\n",
+    "\n",
+    "    send.click(fn=chat_fn, inputs=[msg, chatbot, state], outputs=[chatbot, state], api_name=False)\n",
+    "\n",
+    "demo.launch(server_name=\"0.0.0.0\", server_port=int(os.getenv(\"PORT\",\"7860\")), share=False, show_api=False)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}