Upload folder using huggingface_hub

app.py

@@ -1,14 +1,12 @@
-\
 import os
 import re
 import json
 import math
+import glob
 import hashlib
 from dataclasses import dataclass
 from datetime import datetime, date
-from functools import lru_cache
 from typing import Dict, List, Optional, Tuple, Any
-from urllib.parse import quote_plus, urlparse
 
 import numpy as np
 import pandas as pd
@@ -18,49 +16,37 @@ import faiss
 from sentence_transformers import SentenceTransformer
 from rapidfuzz import fuzz, process
 
-import requests
-from bs4 import BeautifulSoup
-
 import gradio as gr
 from openai import OpenAI
 
 
-# ----------------------------
+# ============================
 # Settings
-# ----------------------------
+# ============================
 TODAY = date(2026, 1, 18)
 OPENAI_MODEL = "gpt-5.2"
 OPENAI_REASONING = {"effort": "high"}
 
+MATCH_OK = 80
 EMBED_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+
 PARSEC_CONTEXT_BEFORE = 900
 PARSEC_CONTEXT_AFTER = 1600
 
-HTTP_TIMEOUT = 25
-HTTP_HEADERS = {
-    "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 "
-                  "(KHTML, like Gecko) Chrome/120.0 Safari/537.36"
-}
-RETRY_COUNT = 2
-MATCH_OK = 80
-
 CACHE_DIR = os.path.join(os.getcwd(), ".onlyrouters_cache")
-SPECS_CACHE_DIR = os.path.join(CACHE_DIR, "specs")
-PDF_CACHE_DIR = os.path.join(CACHE_DIR, "pdf")
-os.makedirs(SPECS_CACHE_DIR, exist_ok=True)
-os.makedirs(PDF_CACHE_DIR, exist_ok=True)
+os.makedirs(CACHE_DIR, exist_ok=True)
 
 
-# ----------------------------
-# OpenAI client (Space secret: OPENAI_API_KEY)
-# ----------------------------
+# ============================
+# OpenAI client (HF Space secret: OPENAI_API_KEY)
+# ============================
 API_KEY = os.getenv("OPENAI_API_KEY", "").strip()
 client = OpenAI(api_key=API_KEY) if API_KEY else None
 
 
-# ----------------------------
-# Helpers
-# ----------------------------
+# ============================
+# Small utilities
+# ============================
 def norm_text(s: Any) -> str:
     try:
         if s is None or (isinstance(s, float) and math.isnan(s)) or pd.isna(s):
@@ -72,22 +58,15 @@ def norm_text(s: Any) -> str:
     s = re.sub(r"\s+", " ", s).strip()
     return s
 
+def _safe_str(v: Any) -> str:
+    if v is None or (isinstance(v, float) and pd.isna(v)) or pd.isna(v):
+        return ""
+    return str(v).strip()
+
 def _is_5g(modem_type: Any) -> bool:
     s = norm_text(modem_type)
     return ("5g" in s) or ("nr" in s)
 
-def _req_get(url: str) -> requests.Response:
-    last = None
-    for _ in range(RETRY_COUNT + 1):
-        try:
-            r = requests.get(url, headers=HTTP_HEADERS, timeout=HTTP_TIMEOUT, allow_redirects=True)
-            r.raise_for_status()
-            return r
-        except Exception as e:
-            last = e
-            continue
-    raise last
-
 def _json_load_safe(s: str) -> Dict[str, Any]:
     try:
         return json.loads(s)
@@ -109,9 +88,9 @@ def gpt_json(system: str, payload: Dict[str, Any], max_tokens: int = 700) -> Dic
     return _json_load_safe(getattr(resp, "output_text", "") or "")
 
 
-# ----------------------------
-# Load data files
-# ----------------------------
+# ============================
+# Load data files (must exist in repo)
+# ============================
 EOS_PATH = "routers_eos_eol_by_sku.csv"
 DEC_PATH = "dec2025routers.csv"
 PARSEC_PDF = "ParsecCatalog.pdf"
@@ -126,6 +105,7 @@ if not os.path.exists(PARSEC_PDF):
 df_eos = pd.read_csv(EOS_PATH).copy()
 df_dec = pd.read_csv(DEC_PATH).copy()
 
+# Region filter: keep USA / North America / blank / not specified
 def _region_ok(x: Any) -> bool:
     s = str(x or "").strip().lower()
     if not s:
@@ -145,12 +125,14 @@ def _region_ok(x: Any) -> bool:
 if "region" in df_eos.columns:
     df_eos = df_eos[df_eos["region"].apply(_region_ok)].reset_index(drop=True)
 
+# Optional "Device Type" column
 device_type_col = None
 for c in df_eos.columns:
     if norm_text(c) == "device type":
         device_type_col = c
         break
 
+# Maker mapping
 CANON_MAKER = {
     "CRADLEPOINT": {"cradlepoint", "ericsson", "ericsson enterprise wireless"},
     "SIERRA": {"sierra", "sierra wireless", "semtech", "airlink"},
@@ -177,27 +159,27 @@ def canon_maker_from_text(s: Any) -> str:
                 return canon
     return "UNKNOWN"
 
-def display_maker_for_row(life_row: pd.Series) -> str:
-    canon = str(life_row.get("_canon_make", "UNKNOWN"))
-    if canon != "DIGI":
-        return DISPLAY_MAKER.get(canon, "Unknown")
-    desc = norm_text(life_row.get("description", ""))
-    notes = norm_text(life_row.get("notes", ""))
-    if "accelerated" in desc or "accelerated" in notes:
-        return "Accelerated Concepts (now Digi)"
-    return "Digi"
-
 df_eos["_canon_make"] = df_eos["manufacturer"].apply(canon_maker_from_text) if "manufacturer" in df_eos.columns else "UNKNOWN"
 df_eos["_norm_sku"] = df_eos["sku"].apply(norm_text) if "sku" in df_eos.columns else ""
+df_eos["_norm_desc"] = df_eos["description"].apply(norm_text) if "description" in df_eos.columns else ""
+df_eos["_norm_notes"] = df_eos["notes"].apply(norm_text) if "notes" in df_eos.columns else ""
 
 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(_is_5g) if "Modem Type" in df_dec.columns else False
 
+def display_maker_for_row(life_row: pd.Series) -> str:
+    canon = str(life_row.get("_canon_make","UNKNOWN"))
+    if canon != "DIGI":
+        return DISPLAY_MAKER.get(canon, "Unknown")
+    desc = norm_text(life_row.get("description",""))
+    notes = norm_text(life_row.get("notes",""))
+    return "Accelerated Concepts (now Digi)" if ("accelerated" in desc or "accelerated" in notes) else "Digi"
+
 
-# ----------------------------
+# ============================
 # Date helpers
-# ----------------------------
+# ============================
 @dataclass
 class ParsedDate:
     raw: str
@@ -255,44 +237,12 @@ def row_to_dates_and_status(life_row: pd.Series) -> Tuple[str, str, str]:
     return display_date(eos), display_date(eol), status_from_eos_eol(eos, eol)
 
 
-# ----------------------------
-# Build embeddings + FAISS indices
-# ----------------------------
+# ============================
+# Embeddings + indices
+# ============================
 embedder = SentenceTransformer(EMBED_MODEL_NAME)
 
-# Replacement RAG buckets
-def _router_card(row: pd.Series) -> str:
-    parts = [
-        f"Make: {row.get('Make','')}",
-        f"Model: {row.get('Model','')}",
-        f"Modem Type: {row.get('Modem Type','')}",
-        f"WiFi: {row.get('WiFi type','')}",
-        f"WAN: {row.get('WAN ports and speed','')}",
-        f"LAN: {row.get('LAN ports and speed','')}",
-        f"Antennas: {row.get('Antennas (internal/external/both)','')}",
-        f"Ruggedization: {row.get('Ruggedization','')}",
-        f"Use case: {row.get('Primary use case','')}",
-    ]
-    return "\n".join(parts)[:1400]
-
-df_dec["_card"] = df_dec.apply(_router_card, axis=1)
-
-RAG_REPL: Dict[Tuple[str, bool], Dict[str, Any]] = {}
-dim = None
-for canon in sorted(df_dec["_canon_make"].unique().tolist()):
-    for is5g in [True, False]:
-        subset = df_dec[(df_dec["_canon_make"] == canon) & (df_dec["_is5g"] == is5g)].copy()
-        if subset.empty:
-            continue
-        cards = subset["_card"].tolist()
-        embs = embedder.encode(cards, batch_size=64, show_progress_bar=False, normalize_embeddings=True)
-        embs = np.asarray(embs, dtype=np.float32)
-        dim = embs.shape[1] if dim is None else dim
-        idx = faiss.IndexFlatIP(dim)
-        idx.add(embs)
-        RAG_REPL[(canon, is5g)] = {"index": idx, "rows": subset.index.tolist(), "cards": cards}
-
-# Parsec index
+# Parsec cards around "Standard SKU"
 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))]
@@ -320,9 +270,9 @@ parsec_index = faiss.IndexFlatIP(parsec_emb.shape[1])
 parsec_index.add(parsec_emb)
 
 
-# ----------------------------
-# Device resolution
-# ----------------------------
+# ============================
+# Device resolution (exact SKU -> GPT A/B)
+# ============================
 def _label_for_row(i: int) -> str:
     r = df_eos.iloc[i]
     return f"{r.get('sku','')} — {r.get('manufacturer','')} — {r.get('description','')}"[:220]
@@ -330,7 +280,12 @@ def _label_for_row(i: int) -> str:
 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([norm_text(r.get("sku","")), norm_text(r.get("manufacturer","")), norm_text(r.get("description","")), norm_text(r.get("notes",""))]))
+    EOS_CORPUS.append(" ".join([
+        r.get("_norm_sku",""),
+        r.get("_canon_make",""),
+        r.get("_norm_desc",""),
+        r.get("_norm_notes",""),
+    ]))
 
 def local_candidates(query: str, top_k: int = 6) -> List[Tuple[int,int,str]]:
     q = norm_text(query)
@@ -344,12 +299,17 @@ def gpt_choose_device(user_text: str, candidates: List[Tuple[int,int,str]]) -> D
     payload = {
         "user_input": user_text,
         "candidates": [{"row_idx": i, "score": s, "label": lbl} for (i,s,lbl) in candidates],
+        "rules": [
+            "If one candidate is clearly correct, return mode='ok' with row_idx.",
+            "If two are plausible, return mode='pick' with top 2 options."
+        ],
         "output_schema": {"mode":"ok|pick","row_idx":"int","options":[{"row_idx":"int","label":"string"}]}
     }
-    return gpt_json(sys, payload, max_tokens=260)
+    return gpt_json(sys, payload, max_tokens=300)
 
 def resolve_device(user_text: str) -> Dict[str, Any]:
     q = norm_text(user_text)
+
     exact_idxs = df_eos.index[df_eos["_norm_sku"] == q].tolist()
     if len(exact_idxs) == 1:
         return {"mode":"ok","row_idx": int(exact_idxs[0])}
@@ -360,137 +320,194 @@ def resolve_device(user_text: str) -> Dict[str, Any]:
     cands = local_candidates(user_text, top_k=6)
     if not cands:
         return {"mode":"not_found"}
+
+    if cands[0][1] >= 95 and (len(cands) == 1 or (cands[0][1] - cands[1][1]) >= 8):
+        return {"mode":"ok","row_idx": cands[0][0]}
+
     g = gpt_choose_device(user_text, cands)
     if g.get("mode") == "ok" and isinstance(g.get("row_idx"), int):
         return {"mode":"ok","row_idx": int(g["row_idx"])}
+
     if g.get("mode") == "pick":
         opts = g.get("options", []) or []
         opts2 = [{"row_idx": int(o["row_idx"]), "label": str(o["label"])} for o in opts[:2] if "row_idx" in o]
         if opts2:
             return {"mode":"pick","options": opts2}
-    return {"mode":"pick","options":[{"row_idx":cands[0][0],"label":cands[0][2]},{"row_idx":cands[1][0],"label":cands[1][2]}] if len(cands)>1 else [{"row_idx":cands[0][0],"label":cands[0][2]}]}
+
+    # fallback
+    if len(cands) > 1:
+        return {"mode":"pick","options":[{"row_idx":cands[0][0],"label":cands[0][2]},{"row_idx":cands[1][0],"label":cands[1][2]}]}
+    return {"mode":"pick","options":[{"row_idx":cands[0][0],"label":cands[0][2]}]}
 
 
-# ----------------------------
-# Replacement selection
-# ----------------------------
-def pick_best_5g_fallback(canon_make: str) -> str:
-    pool5 = df_dec[(df_dec["_canon_make"] == canon_make) & (df_dec["_is5g"] == True)].copy()
-    if pool5.empty:
+# ============================
+# Replacements — source of truth is lifecycle CSV (with GPT fallback)
+# ============================
+def _extract_model_token(text: str) -> str:
+    s = _safe_str(text)
+    if not s:
         return ""
-    pool5["_score"] = (
-        pool5["WiFi type"].astype(str).str.len().fillna(0)
-        + pool5["WAN ports and speed"].astype(str).str.len().fillna(0)
-        + pool5["LAN ports and speed"].astype(str).str.len().fillna(0)
-    )
-    pool5 = pool5.sort_values(by="_score", ascending=False)
-    return str(pool5.iloc[0]["Model"]).strip()
+    parts = [p.strip() for p in s.split("|") if p.strip()]
+    candidates = parts[::-1] if parts else [s]
+
+    for cand in candidates:
+        m = re.search(r"\bIX\d{2}\b", cand, flags=re.IGNORECASE)
+        if m:
+            return m.group(0).upper()
+        m = re.search(r"\b(R\d{3,4}|E\d{3,4}|S\d{3,4})\b", cand, flags=re.IGNORECASE)
+        if m:
+            return m.group(0).upper()
+        m = re.search(r"\b[A-Z]{1,5}\d{2,4}[A-Z]?\b", cand.upper())
+        if m:
+            return m.group(0).upper()
+
+    return candidates[0][:60]
+
+def _candidate_5g_models_from_lifecycle(canon_make: str) -> List[str]:
+    pool = df_eos[df_eos["_canon_make"] == canon_make].copy()
+    vals = pool["advanced_5g_option"].tolist() if "advanced_5g_option" in pool.columns else []
+    out, seen = [], set()
+    for v in vals:
+        tok = _extract_model_token(v)
+        if tok and tok.lower() != "nan" and tok not in seen:
+            seen.add(tok); out.append(tok)
+    return out
 
-def likely_4g_only_row(life_row: pd.Series) -> bool:
-    t = norm_text(life_row.get("description","")) + " " + norm_text(life_row.get("notes",""))
-    return ("lte" in t and "5g" not in t) or ("4g" in t and "5g" not in t)
+def _candidate_4g_models_from_lifecycle(canon_make: str) -> List[str]:
+    pool = df_eos[df_eos["_canon_make"] == canon_make].copy()
+    vals = pool["suggested_replacement"].tolist() if "suggested_replacement" in pool.columns else []
+    out, seen = [], set()
+    for v in vals:
+        tok = _extract_model_token(v)
+        if tok and tok.lower() != "nan" and tok not in seen:
+            seen.add(tok); out.append(tok)
+    return out
 
-def likely_5g_row(life_row: pd.Series) -> bool:
-    t = norm_text(life_row.get("description","")) + " " + norm_text(life_row.get("notes",""))
-    return ("5g" in t) or ("nr" in t)
+def _gpt_pick_from_lifecycle_models(old_row: pd.Series, candidates: List[str], need: str) -> str:
+    if client is None or not candidates:
+        return ""
+    sys = "Pick the best replacement model. Choose only from candidates. Return strict JSON only."
+    payload = {
+        "old_device": {
+            "sku": str(old_row.get("sku","")),
+            "description": str(old_row.get("description","")),
+            "manufacturer": str(old_row.get("manufacturer","")),
+            "need": need,
+        },
+        "candidates": candidates[:30],
+        "output_schema": {"choice":"string"}
+    }
+    out = gpt_json(sys, payload, max_tokens=220) or {}
+    choice = str(out.get("choice","") or "").strip()
+    return choice if choice in candidates else ""
 
-def rag_candidates_for_make(canon_make: str, want_5g: bool, query_text: str, k: int = 8) -> List[int]:
-    bucket = RAG_REPL.get((canon_make, want_5g))
-    if not bucket:
-        return []
-    qv = embedder.encode([query_text], normalize_embeddings=True)
-    qv = np.asarray(qv, dtype=np.float32)
-    _, ids = bucket["index"].search(qv, min(k, len(bucket["rows"])))
-    return [bucket["rows"][int(i)] for i in ids[0] if 0 <= int(i) < len(bucket["rows"])]
+def _fallback_5g_from_dec(canon_make: str) -> str:
+    pool5 = df_dec[(df_dec["_canon_make"] == canon_make) & (df_dec["_is5g"] == True)]
+    return str(pool5.iloc[0]["Model"]).strip() if not pool5.empty else ""
 
-def pick_replacements_gpt(life_row: pd.Series, status: str) -> Dict[str, Any]:
+def _device_is_4g(life_row: pd.Series) -> bool:
+    t = norm_text(life_row.get("description","")) + " " + norm_text(life_row.get("notes",""))
+    return (("lte" in t or "4g" in t) and ("5g" not in t and "nr" not in t))
+
+def pick_replacements_lifecycle(life_row: pd.Series, status: str) -> Dict[str, Any]:
     canon = str(life_row.get("_canon_make","UNKNOWN"))
     if canon == "UNKNOWN":
-        return {"repl_4g":"Not applicable","repl_5g":"","why":"","sources":[]}
-
-    adv_val = life_row.get("advanced_5g_option", "")
-    sug_val = life_row.get("suggested_replacement", "")
-    adv_raw = "" if (adv_val is None or pd.isna(adv_val)) else str(adv_val).strip()
-    sug_raw = "" if (sug_val is None or pd.isna(sug_val)) else str(sug_val).strip()
+        return {"repl_4g":"Not applicable","repl_5g":"", "why":"", "sources":[]}
 
-    is_4g_device = likely_4g_only_row(life_row) and (not likely_5g_row(life_row))
+    is_4g_device = _device_is_4g(life_row)
     needs_4g_repl = is_4g_device and (status in {"End of Sale","End of Life"})
     want_5g = is_4g_device or (status in {"End of Sale","End of Life"})
 
-    if not want_5g:
-        return {"repl_4g":"Not applicable","repl_5g":"Not applicable","why":"","sources":[]}
-
-    # forced 5G
-    forced_5g = ""
-    if adv_raw:
-        pool5 = df_dec[(df_dec["_canon_make"]==canon) & (df_dec["_is5g"]==True)]
-        if not pool5.empty:
-            hit = process.extractOne(norm_text(adv_raw), pool5["_norm_model"].tolist(), scorer=fuzz.WRatio)
-            forced_5g = str(pool5.iloc[int(hit[2])]["Model"]).strip() if hit and hit[1] >= MATCH_OK else adv_raw
-        else:
-            forced_5g = adv_raw
-
-    forced_4g = ""
-    if needs_4g_repl and sug_raw:
-        pool4 = df_dec[(df_dec["_canon_make"]==canon) & (df_dec["_is5g"]==False)]
-        if not pool4.empty:
-            hit = process.extractOne(norm_text(sug_raw), pool4["_norm_model"].tolist(), scorer=fuzz.WRatio)
-            forced_4g = str(pool4.iloc[int(hit[2])]["Model"]).strip() if hit and hit[1] >= MATCH_OK else ""
-
-    repl_4g = forced_4g if needs_4g_repl else "Not applicable"
-
-    if forced_5g:
-        if forced_5g.lower() == "nan" or not forced_5g:
-            forced_5g = pick_best_5g_fallback(canon)
-        return {"repl_4g": repl_4g, "repl_5g": forced_5g, "why":"From lifecycle replacement mapping.", "sources":["lifecycle_csv"]}
-
-    # rag + gpt 5g
-    query_text = "\n".join([
-        f"Old device: {life_row.get('sku','')} {life_row.get('manufacturer','')}",
-        str(life_row.get('description','') or ''),
-        str(life_row.get('notes','') or ''),
-        f"Need 5G: {want_5g}",
-        f"Need 4G: {needs_4g_repl}",
-    ])[:2000]
-
-    idx_5g = rag_candidates_for_make(canon, True, query_text, k=8)
-    idx_4g = rag_candidates_for_make(canon, False, query_text, k=8) if needs_4g_repl else []
-
-    def pack(idx: int) -> Dict[str, Any]:
-        r = df_dec.loc[idx]
-        return {"Model": str(r.get("Model","")), "Modem Type": str(r.get("Modem Type","")), "WiFi": str(r.get("WiFi type",""))}
-
-    cand5 = [pack(i) for i in idx_5g[:8] if i in df_dec.index]
-    cand4 = [pack(i) for i in idx_4g[:8] if i in df_dec.index]
-
-    det5 = cand5[0]["Model"] if cand5 else ""
-    if not det5:
-        det5 = pick_best_5g_fallback(canon)
-    det4 = (cand4[0]["Model"] if cand4 else "") if needs_4g_repl else "Not applicable"
-
-    if client is None or not cand5:
-        return {"repl_4g": det4, "repl_5g": det5, "why":"", "sources":["dec_catalog_rag"]}
-
-    sys = "Pick replacements. Choose only from candidates. Return strict JSON only."
-    payload = {
-        "need_4g_replacement": needs_4g_repl,
-        "candidates_5g": cand5,
-        "candidates_4g": cand4,
-        "output_schema": {"repl_4g":"string","repl_5g":"string","why":"string"}
+    repl_4g = "Not applicable"
+    if needs_4g_repl:
+        repl_4g = _extract_model_token(_safe_str(life_row.get("suggested_replacement","")))
+        if not repl_4g:
+            cand4 = _candidate_4g_models_from_lifecycle(canon)
+            repl_4g = _gpt_pick_from_lifecycle_models(life_row, cand4, "4G replacement") or (cand4[0] if cand4 else "")
+        if not repl_4g:
+            repl_4g = "Not applicable"
+
+    repl_5g = "Not applicable"
+    if want_5g:
+        repl_5g = _extract_model_token(_safe_str(life_row.get("advanced_5g_option","")))
+        if not repl_5g:
+            cand5 = _candidate_5g_models_from_lifecycle(canon)
+            repl_5g = _gpt_pick_from_lifecycle_models(life_row, cand5, "5G replacement/upgrade") or (cand5[0] if cand5 else "")
+        if not repl_5g:
+            # last resort: dec catalog
+            repl_5g = _fallback_5g_from_dec(canon)
+
+    if repl_5g.lower() == "nan":
+        repl_5g = ""
+
+    return {
+        "repl_4g": repl_4g,
+        "repl_5g": repl_5g,
+        "why": "Lifecycle replacements (GPT fallback when missing).",
+        "sources": ["lifecycle_csv"] + (["gpt"] if client else []) + (["dec_fallback"] if (want_5g and not _extract_model_token(_safe_str(life_row.get("advanced_5g_option","")))) else []),
     }
-    out = gpt_json(sys, payload, max_tokens=350)
-    repl5 = str(out.get("repl_5g","") or det5).strip()
-    if (not repl5) or (repl5.lower() in {"nan","not applicable"}):
-        repl5 = det5 or pick_best_5g_fallback(canon)
-    repl4 = str(out.get("repl_4g","") or det4).strip()
-    if not needs_4g_repl:
-        repl4 = "Not applicable"
-    return {"repl_4g": repl4, "repl_5g": repl5, "why": str(out.get("why","") or "").strip(), "sources":["dec_catalog_rag","gpt"]}
-
-
-# ----------------------------
-# Antenna picks
-# ----------------------------
+
+
+# ============================
+# Antennas (Parsec-only; family name extraction)
+# ============================
+PARSEC_FAMILY_WORDS = {
+    "chinook","labrador","boxer","bloodhound","husky","beagle","mastiff","collie",
+    "shepherd","belgian","australian","terrier","pyrenees"
+}
+BAD_NAME_MARKERS = {
+    "customization", "standard connectors", "connectors", "features", "benefits",
+    "specifications", "mechanical", "electrical", "mounting", "accessories",
+    "description:", "standard sku"
+}
+
+def _clean_line(s: str) -> str:
+    s = re.sub(r"\s+", " ", str(s or "").strip())
+    if re.fullmatch(r"-[a-z0-9]+", s.lower()):
+        return ""
+    return s
+
+def _is_bad_name_line(line: str) -> bool:
+    low = line.lower()
+    if any(m in low for m in BAD_NAME_MARKERS):
+        return True
+    if re.search(r"\b-[a-z0-9]{1,4}\b", low) and len(low) <= 25:
+        return True
+    return False
+
+def _family_from_line(line: str) -> str:
+    low = line.lower()
+    for fam in PARSEC_FAMILY_WORDS:
+        if fam in low:
+            return fam.capitalize()
+    return ""
+
+def _parsec_name_from_card(card_text: str) -> str:
+    lines = [_clean_line(ln) for ln in str(card_text or "").splitlines()]
+    lines = [ln for ln in lines if ln]
+
+    for ln in lines:
+        if _is_bad_name_line(ln):
+            continue
+        fam = _family_from_line(ln)
+        if fam:
+            return fam
+
+    sku_i = None
+    for i, ln in enumerate(lines):
+        if "standard sku" in ln.lower():
+            sku_i = i
+            break
+    if sku_i is not None:
+        window = lines[max(0, sku_i - 12):sku_i]
+        for ln in reversed(window):
+            if _is_bad_name_line(ln):
+                continue
+            if 3 <= len(ln) <= 40 and re.search(r"[A-Za-z]", ln):
+                return ln.split()[0].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 ""
@@ -499,27 +516,6 @@ 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_name_from_card(t: str) -> str:
-    lines = [ln.strip() for ln in t.splitlines() if ln.strip()]
-    sku_i = None
-    for i, ln in enumerate(lines):
-        if "Standard SKU" in ln:
-            sku_i = i; break
-    window = lines[max(0,(sku_i or 0)-12):(sku_i or 0)]
-    for ln in reversed(window):
-        low = ln.lower()
-        if "description:" in low or "sku" in low or "customization" in low:
-            continue
-        if 3 <= len(ln) <= 90 and re.search(r"[A-Za-z]", ln):
-            return ln
-    for ln in lines[:30]:
-        low = ln.lower()
-        if "description:" in low or "standard sku" in low or "customization" in low:
-            continue
-        if 3 <= len(ln) <= 90 and re.search(r"[A-Za-z]", ln):
-            return ln
-    return "Parsec antenna"
-
 def parsec_retrieve(query: str, top_k: int = 10) -> List[Dict[str, Any]]:
     qv = embedder.encode([query], normalize_embeddings=True)
     qv = np.asarray(qv, dtype=np.float32)
@@ -528,7 +524,13 @@ def parsec_retrieve(query: str, top_k: int = 10) -> List[Dict[str, Any]]:
     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({"name": _parsec_name_from_card(card), "part_number": _parsec_part_from_card(card), "description": _parsec_desc_from_card(card)})
+            out.append({
+                "score": float(sc),
+                "name": _parsec_name_from_card(card),
+                "part_number": _parsec_part_from_card(card),
+                "description": _parsec_desc_from_card(card),
+                "card": card[:1100],
+            })
     return out
 
 def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, Any]:
@@ -537,52 +539,119 @@ def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, An
     cand_stationary = parsec_retrieve(q_stationary, top_k=10)
     cand_vehicle = parsec_retrieve(q_vehicle, top_k=10)
 
-    s = cand_stationary[0] if cand_stationary else {"name":"Parsec antenna","part_number":"","description":""}
-    v = cand_vehicle[0] if cand_vehicle else {"name":"Parsec antenna","part_number":"","description":""}
-    s.update({"mimo": mimo, "why": "Stationary omni best match."})
-    v.update({"mimo": mimo, "why": "Vehicle omni best match."})
-    return {"stationary_omni": s, "vehicle_omni": v, "sources":["parsec_rag"]}
-
+    if client is None:
+        s = cand_stationary[0] if cand_stationary else {"name":"Parsec antenna","part_number":"","description":""}
+        v = cand_vehicle[0] if cand_vehicle else {"name":"Parsec antenna","part_number":"","description":""}
+        s.update({"mimo": mimo, "why": "Stationary omni best match."})
+        v.update({"mimo": mimo, "why": "Vehicle omni best match."})
+        return {"stationary_omni": s, "vehicle_omni": v, "sources":["parsec_rag"]}
 
-# ----------------------------
-# Feature table + output
-# ----------------------------
-FEATURE_ROWS = ["Name","Modem technology","WiFi","Ports","Antennas","Ruggedness","Use case"]
+    sys = "Select Parsec antennas. Choose only from candidates. Return strict JSON only."
+    payload = {
+        "router_model": router_model,
+        "tech": tech,
+        "mimo": mimo,
+        "stationary_candidates": cand_stationary,
+        "vehicle_candidates": cand_vehicle,
+        "rules": [
+            "Return two options: stationary_omni and vehicle_omni.",
+            "Use only candidates. Prefer family names like Labrador/Chinook/Boxer.",
+            "Include name, part_number, description, mimo, why.",
+            "Return JSON only."
+        ],
+        "output_schema": {
+            "stationary_omni": {"name":"string","part_number":"string","description":"string","mimo":"2x2|4x4","why":"string"},
+            "vehicle_omni": {"name":"string","part_number":"string","description":"string","mimo":"2x2|4x4","why":"string"}
+        }
+    }
+    out = gpt_json(sys, payload, max_tokens=650) or {}
+
+    def _fix(x: Dict[str, Any], default_why: str) -> Dict[str, str]:
+        return {
+            "name": str(x.get("name","Parsec antenna") or "Parsec antenna")[:110],
+            "part_number": str(x.get("part_number","") or "")[:40],
+            "description": str(x.get("description","") or "")[:220],
+            "mimo": str(x.get("mimo", mimo) or mimo),
+            "why": str(x.get("why", default_why) or default_why)[:160],
+        }
+
+    s = _fix(out.get("stationary_omni", {}) if isinstance(out, dict) else {}, "Stationary omni best match.")
+    v = _fix(out.get("vehicle_omni", {}) if isinstance(out, dict) else {}, "Vehicle omni best match.")
+    if not s.get("part_number") and cand_stationary:
+        top = cand_stationary[0]
+        s = {"name": top.get("name","Parsec antenna"), "part_number": top.get("part_number",""), "description": top.get("description",""), "mimo": mimo, "why":"Stationary omni best match."}
+    if not v.get("part_number") and cand_vehicle:
+        top = cand_vehicle[0]
+        v = {"name": top.get("name","Parsec antenna"), "part_number": top.get("part_number",""), "description": top.get("description",""), "mimo": mimo, "why":"Vehicle omni best match."}
+    return {"stationary_omni": s, "vehicle_omni": v, "sources":["parsec_rag","gpt"]}
+
+
+# ============================
+# Feature table + GPT fill for missing fields (no more ****; fill missing via GPT)
+# ============================
+FEATURE_COLS = ["Name","Modem technology","WiFi","Ports","Antennas","Ruggedness","Use case"]
 
 def dec_features_by_model(model: str, canon_make: str) -> Dict[str, str]:
     if not model or model == "Not applicable":
-        return {k:"Not listed" for k in FEATURE_ROWS}
+        return {k:"Not listed" for k in FEATURE_COLS}
     pool = df_dec[df_dec["_canon_make"] == canon_make].copy()
     if pool.empty:
-        return {k:"Not listed" for k in FEATURE_ROWS}
+        return {k:"Not listed" for k in FEATURE_COLS}
     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_ROWS}
+        return {k:"Not listed" for k in FEATURE_COLS}
     r = pool.iloc[int(hit[2])]
     ports = f"WAN: {r.get('WAN ports and speed','')} | LAN: {r.get('LAN ports and speed','')}"
     return {
         "Name": str(r.get("Model","")),
         "Modem technology": str(r.get("Modem Type","")),
         "WiFi": str(r.get("WiFi type","")),
-        "Ports": ports.strip(),
+        "Ports": ports,
         "Antennas": str(r.get("Antennas (internal/external/both)","")),
         "Ruggedness": str(r.get("Ruggedization","")),
         "Use case": str(r.get("Primary use case","")),
     }
 
-def current_features_basic(life_row: pd.Series) -> Dict[str, str]:
-    name = str(life_row.get("sku","") or "").strip()
+def gpt_fill_features(device_label: str, feats: Dict[str,str], context: str) -> Dict[str,str]:
+    missing = [k for k,v in feats.items() if (not v) or v.strip().lower() in {"not listed","nan"}]
+    if client is None or not missing:
+        return feats
+    sys = "Fill missing router feature fields. Return strict JSON only."
+    payload = {
+        "device": device_label,
+        "known": feats,
+        "context": context[:2000],
+        "fill_only": missing,
+        "rules": ["Fill only requested fields. Best guess if needed. Return JSON only."],
+        "output_schema": {k:"string" for k in missing}
+    }
+    out = gpt_json(sys, payload, max_tokens=350) or {}
+    for k in missing:
+        v = str(out.get(k,"") or "").strip()
+        if v:
+            feats[k] = v
+    return feats
+
+def current_features_guess(life_row: pd.Series) -> Dict[str,str]:
+    sku = str(life_row.get("sku","") or "").strip()
     desc = str(life_row.get("description","") or "").strip()
-    txt = (desc + " " + str(life_row.get("notes","") or "")).lower()
-    modem = "5G" if ("5g" in txt or "nr" in txt) else ("4G" if "lte" in txt or "4g" in txt else "Not listed")
-    rugged = "Rugged" if "rugged" in txt else "Not listed"
-    return {"Name": name, "Modem technology": modem, "WiFi": "Not listed", "Ports": "Not listed",
-            "Antennas": "Not listed", "Ruggedness": rugged, "Use case": "Not listed"}
+    notes = str(life_row.get("notes","") or "").strip()
+    base = {
+        "Name": sku,
+        "Modem technology": "4G" if _device_is_4g(life_row) else ("5G" if (("5g" in (desc+notes).lower()) or ("nr" in (desc+notes).lower())) else "Not listed"),
+        "WiFi": "Not listed",
+        "Ports": "Not listed",
+        "Antennas": "Not listed",
+        "Ruggedness": "Not listed",
+        "Use case": "Not listed",
+    }
+    return gpt_fill_features("Current device", base, f"{desc}\n{notes}")
 
-def build_features_table(current_feats: Dict[str,str], r4_feats: Dict[str,str], r5_feats: Dict[str,str]) -> str:
+def build_features_table(cur: Dict[str,str], r4: Dict[str,str], r5: Dict[str,str]) -> str:
     cols = ["Device", "Modem technology", "WiFi", "Ports", "Antennas", "Ruggedness", "Use case"]
     header = "| " + " | ".join(cols) + " |"
     sep = "| " + " | ".join(["---"]*len(cols)) + " |"
+
     def row(name: str, feats: Dict[str,str]) -> str:
         return "| " + " | ".join([
             name,
@@ -593,43 +662,65 @@ def build_features_table(current_feats: Dict[str,str], r4_feats: Dict[str,str],
             feats.get("Ruggedness","Not listed"),
             feats.get("Use case","Not listed"),
         ]) + " |"
-    return "\n".join([header, sep, row("Current", current_feats), row("4G replacement", r4_feats), row("5G replacement", r5_feats)])
+
+    return "\n".join([header, sep, row("Current", cur), row("4G replacement", r4), row("5G replacement", r5)])
+
+
+# ============================
+# Output + Gradio UI
+# ============================
+def fmt(v: Any, fallback: str = "Not listed") -> str:
+    s = _safe_str(v)
+    if not s or s.lower() == "nan":
+        return fallback
+    return s
 
 def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl: Dict[str,Any], ant: Dict[str,Any]) -> str:
     canon_make = str(life_row.get("_canon_make","UNKNOWN"))
     current_name = f"{life_row.get('sku','')} — {life_row.get('description','')}".strip(" —")
-    stationary = ant.get("stationary_omni", {})
-    vehicle = ant.get("vehicle_omni", {})
 
-    cur_feats = current_features_basic(life_row)
+    # Antenna
+    st = ant.get("stationary_omni", {})
+    vh = ant.get("vehicle_omni", {})
+
+    # Feature table (fill missing via GPT)
+    cur_feats = current_features_guess(life_row)
     r4_feats = dec_features_by_model(repl.get("repl_4g",""), canon_make)
     r5_feats = dec_features_by_model(repl.get("repl_5g",""), canon_make)
+    if client is not None:
+        r4_feats = gpt_fill_features("4G replacement", r4_feats, "")
+        r5_feats = gpt_fill_features("5G replacement", r5_feats, "")
     table_md = build_features_table(cur_feats, r4_feats, r5_feats)
 
     lines = []
-    lines.append(f"1) Current device: **{current_name}**")
-    lines.append(f"2) Status: **{status}**")
-    lines.append(f"3) End of Sale date: **{eos}**")
-    lines.append(f"4) End of Life date: **{eol}**")
-    lines.append(f"5) 4G recommended replacement: **{repl.get('repl_4g','Not applicable')}**")
-    lines.append(f"6) 5G recommended replacement: **{repl.get('repl_5g','')}**")
-    lines.append("7) Antenna options (Parsec-only):")
-    lines.append(f"   - Stationary (Omni): **{stationary.get('name','')}** (Part #: {stationary.get('part_number','')}) — {stationary.get('description','')} — MIMO: {stationary.get('mimo','')} — {stationary.get('why','')}")
-    lines.append(f"   - Vehicle (Omni): **{vehicle.get('name','')}** (Part #: {vehicle.get('part_number','')}) — {vehicle.get('description','')} — MIMO: {vehicle.get('mimo','')} — {vehicle.get('why','')}")
-    lines.append("8) Recommended features table:")
+    lines.append(f"1. Current device: **{current_name}**")
+    lines.append(f"2. Status: **{status}**")
+    lines.append(f"3. End of Sale date: **{eos}**")
+    lines.append(f"4. End of Life date: **{eol}**")
+    lines.append(f"5. 4G recommended replacement: **{fmt(repl.get('repl_4g'), 'Not applicable')}**")
+    # If 5G is empty, force GPT to pick from lifecycle pool
+    repl5 = fmt(repl.get("repl_5g"), "")
+    if (not repl5) and client is not None:
+        cand5 = _candidate_5g_models_from_lifecycle(str(life_row.get('_canon_make','UNKNOWN')))
+        repl5 = _gpt_pick_from_lifecycle_models(life_row, cand5, "5G replacement/upgrade") or (cand5[0] if cand5 else "")
+    if not repl5:
+        repl5 = "Not listed"
+    lines.append(f"6. 5G recommended replacement: **{repl5}**")
+
+    lines.append("7. Antenna options (Parsec-only):")
+    lines.append(f"   - Stationary (Omni): **{fmt(st.get('name'))}** (Part #: {fmt(st.get('part_number'))}) — {fmt(st.get('description'))} — MIMO: {fmt(st.get('mimo'))} — {fmt(st.get('why'))}")
+    lines.append(f"   - Vehicle (Omni): **{fmt(vh.get('name'))}** (Part #: {fmt(vh.get('part_number'))}) — {fmt(vh.get('description'))} — MIMO: {fmt(vh.get('mimo'))} — {fmt(vh.get('why'))}")
+
+    lines.append("8. Recommended features table:")
     lines.append(table_md)
-    lines.append("\n**Sources (debug):**")
-    srcs = repl.get("sources", [])
-    if isinstance(srcs, list):
-        for s in srcs:
-            lines.append(f"- {s}")
+
+    lines.append("\nSources (debug):")
+    for s in repl.get("sources", []) if isinstance(repl.get("sources"), list) else []:
+        lines.append(f"- {s}")
     lines.append("- ParsecCatalog.pdf (local RAG)")
+    lines.append("- dec2025routers.csv (features + fallback)")
     return "\n".join(lines)
 
-
-# ----------------------------
-# Gradio callbacks
-# ----------------------------
 def run_lookup(user_text: str, st: Dict[str,Any]):
     user_text = str(user_text or "").strip()
     if not user_text:
@@ -640,17 +731,20 @@ def run_lookup(user_text: str, st: Dict[str,Any]):
         opts = res.get("options", [])
         choices = [o["label"] for o in opts]
         st2 = {"mode":"pick","options": opts}
-        return "Did you mean A or B? Pick one, then click **Use selection**.", gr.update(choices=choices, value=None, visible=True), gr.update(visible=True), st2
+        return "Did you mean A or B? Pick one, then click Use selection.", gr.update(choices=choices, value=None, visible=True), gr.update(visible=True), st2
 
     if res.get("mode") != "ok":
         return "Not found.", gr.update(visible=False), gr.update(visible=False), {}
 
     life_row = df_eos.iloc[int(res["row_idx"])]
     eos, eol, status = row_to_dates_and_status(life_row)
-    repl = pick_replacements_gpt(life_row, status)
-    tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") != "Not applicable" else ("4G" if likely_4g_only_row(life_row) else "Unknown")
+
+    repl = pick_replacements_lifecycle(life_row, status)
+
+    tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") != "Not applicable" else ("4G" if _device_is_4g(life_row) else "Unknown")
     mimo_guess = "4x4" if tech == "5G" else "2x2"
     ant = antenna_options_for(router_model=repl.get("repl_5g") or str(life_row.get("sku","")), tech=tech, mimo=mimo_guess)
+
     return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}
 
 def use_selection(selected_label: str, st: Dict[str,Any]):
@@ -669,12 +763,13 @@ def use_selection(selected_label: str, st: Dict[str,Any]):
 
     life_row = df_eos.iloc[int(chosen_row)]
     eos, eol, status = row_to_dates_and_status(life_row)
-    repl = pick_replacements_gpt(life_row, status)
-    tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") != "Not applicable" else ("4G" if likely_4g_only_row(life_row) else "Unknown")
+    repl = pick_replacements_lifecycle(life_row, status)
+
+    tech = "5G" if repl.get("repl_5g") and repl.get("repl_5g") != "Not applicable" else ("4G" if _device_is_4g(life_row) else "Unknown")
     mimo_guess = "4x4" if tech == "5G" else "2x2"
     ant = antenna_options_for(router_model=repl.get("repl_5g") or str(life_row.get("sku","")), tech=tech, mimo=mimo_guess)
-    return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}
 
+    return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}
 
 with gr.Blocks(title="Only-Routers") as demo:
     gr.Markdown("## Only-Routers\nEnter a router SKU/model. If ambiguous, you’ll get A/B choices.")
@@ -690,4 +785,4 @@ with gr.Blocks(title="Only-Routers") as demo:
     check_btn.click(fn=run_lookup, inputs=[user_text, st], outputs=[output_md, pick_dd, use_btn, st])
     use_btn.click(fn=use_selection, inputs=[pick_dd, st], outputs=[output_md, pick_dd, use_btn, st])
 
-demo.launch(share=True, debug=True)
+demo.launch()

only-routers_ai_poc_v4_5.ipynb

@@ -0,0 +1,831 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "762ab53b",
+   "metadata": {},
+   "source": [
+    "# Only-Routers (v4.5)\n",
+    "This notebook mirrors the Space `app.py` logic.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1993260c",
+   "metadata": {},
+   "source": [
+    "## Run\n",
+    "1) Upload the 3 data files and set OPENAI_API_KEY env var (or load key).\n",
+    "2) Run cells top-to-bottom.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "66695eb5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import re\n",
+    "import json\n",
+    "import math\n",
+    "import glob\n",
+    "import hashlib\n",
+    "from dataclasses import dataclass\n",
+    "from datetime import datetime, date\n",
+    "from typing import Dict, List, Optional, Tuple, Any\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",
+    "# ============================\n",
+    "# Settings\n",
+    "# ============================\n",
+    "TODAY = date(2026, 1, 18)\n",
+    "OPENAI_MODEL = \"gpt-5.2\"\n",
+    "OPENAI_REASONING = {\"effort\": \"high\"}\n",
+    "\n",
+    "MATCH_OK = 80\n",
+    "EMBED_MODEL_NAME = \"sentence-transformers/all-MiniLM-L6-v2\"\n",
+    "\n",
+    "PARSEC_CONTEXT_BEFORE = 900\n",
+    "PARSEC_CONTEXT_AFTER = 1600\n",
+    "\n",
+    "CACHE_DIR = os.path.join(os.getcwd(), \".onlyrouters_cache\")\n",
+    "os.makedirs(CACHE_DIR, exist_ok=True)\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# OpenAI client (HF Space secret: OPENAI_API_KEY)\n",
+    "# ============================\n",
+    "API_KEY = os.getenv(\"OPENAI_API_KEY\", \"\").strip()\n",
+    "client = OpenAI(api_key=API_KEY) if API_KEY else None\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Small utilities\n",
+    "# ============================\n",
+    "def norm_text(s: Any) -> str:\n",
+    "    try:\n",
+    "        if s is None or (isinstance(s, float) and math.isnan(s)) or pd.isna(s):\n",
+    "            return \"\"\n",
+    "    except Exception:\n",
+    "        pass\n",
+    "    s = str(s).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(v: Any) -> str:\n",
+    "    if v is None or (isinstance(v, float) and pd.isna(v)) or pd.isna(v):\n",
+    "        return \"\"\n",
+    "    return str(v).strip()\n",
+    "\n",
+    "def _is_5g(modem_type: Any) -> bool:\n",
+    "    s = norm_text(modem_type)\n",
+    "    return (\"5g\" in s) or (\"nr\" in s)\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 gpt_json(system: str, payload: Dict[str, Any], max_tokens: int = 700) -> Dict[str, Any]:\n",
+    "    if client is None:\n",
+    "        return {}\n",
+    "    resp = client.responses.create(\n",
+    "        model=OPENAI_MODEL,\n",
+    "        reasoning=OPENAI_REASONING,\n",
+    "        input=[\n",
+    "            {\"role\": \"system\", \"content\": system},\n",
+    "            {\"role\": \"user\", \"content\": json.dumps(payload)},\n",
+    "        ],\n",
+    "        max_output_tokens=max_tokens,\n",
+    "    )\n",
+    "    return _json_load_safe(getattr(resp, \"output_text\", \"\") or \"\")\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Load data files (must exist in repo)\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",
+    "df_eos = pd.read_csv(EOS_PATH).copy()\n",
+    "df_dec = pd.read_csv(DEC_PATH).copy()\n",
+    "\n",
+    "# Region filter: keep USA / North America / blank / not specified\n",
+    "def _region_ok(x: Any) -> bool:\n",
+    "    s = str(x or \"\").strip().lower()\n",
+    "    if not s:\n",
+    "        return True\n",
+    "    if \"not specified\" in s:\n",
+    "        return True\n",
+    "    if \"north america\" in s:\n",
+    "        return True\n",
+    "    if re.search(r\"\\busa\\b\", s):\n",
+    "        return True\n",
+    "    if re.search(r\"\\bunited\\s+states\\b\", s):\n",
+    "        return True\n",
+    "    if re.search(r\"\\bu\\.?s\\.?\\b\", s):\n",
+    "        return True\n",
+    "    return False\n",
+    "\n",
+    "if \"region\" in df_eos.columns:\n",
+    "    df_eos = df_eos[df_eos[\"region\"].apply(_region_ok)].reset_index(drop=True)\n",
+    "\n",
+    "# Optional \"Device Type\" column\n",
+    "device_type_col = None\n",
+    "for c in df_eos.columns:\n",
+    "    if norm_text(c) == \"device type\":\n",
+    "        device_type_col = c\n",
+    "        break\n",
+    "\n",
+    "# Maker mapping\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",
+    "}\n",
+    "DISPLAY_MAKER = {\n",
+    "    \"CRADLEPOINT\": \"Cradlepoint\",\n",
+    "    \"SIERRA\": \"Sierra Wireless\",\n",
+    "    \"FEENEY\": \"Feeney Wireless\",\n",
+    "    \"DIGI\": \"Digi\",\n",
+    "    \"CISCO_MERAKI\": \"Cisco Meraki\",\n",
+    "    \"CISCO\": \"Cisco\",\n",
+    "    \"UNKNOWN\": \"Unknown\",\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",
+    "df_eos[\"_canon_make\"] = df_eos[\"manufacturer\"].apply(canon_maker_from_text) if \"manufacturer\" in df_eos.columns else \"UNKNOWN\"\n",
+    "df_eos[\"_norm_sku\"] = df_eos[\"sku\"].apply(norm_text) if \"sku\" in df_eos.columns else \"\"\n",
+    "df_eos[\"_norm_desc\"] = df_eos[\"description\"].apply(norm_text) if \"description\" in df_eos.columns else \"\"\n",
+    "df_eos[\"_norm_notes\"] = df_eos[\"notes\"].apply(norm_text) if \"notes\" in df_eos.columns else \"\"\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(_is_5g) if \"Modem Type\" in df_dec.columns else False\n",
+    "\n",
+    "def display_maker_for_row(life_row: pd.Series) -> str:\n",
+    "    canon = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "    if canon != \"DIGI\":\n",
+    "        return DISPLAY_MAKER.get(canon, \"Unknown\")\n",
+    "    desc = norm_text(life_row.get(\"description\",\"\"))\n",
+    "    notes = norm_text(life_row.get(\"notes\",\"\"))\n",
+    "    return \"Accelerated Concepts (now Digi)\" if (\"accelerated\" in desc or \"accelerated\" in notes) else \"Digi\"\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Date helpers\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 = str(x or \"\").strip()\n",
+    "    if not raw:\n",
+    "        return ParsedDate(raw=\"\", kind=\"missing\", value=None)\n",
+    "\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",
+    "    if re.fullmatch(r\"\\d{4}-\\d{2}\", raw):\n",
+    "        try:\n",
+    "            y, m = raw.split(\"-\")\n",
+    "            return ParsedDate(raw=raw, kind=\"year_month\", value=date(int(y), int(m), 1))\n",
+    "        except Exception:\n",
+    "            return ParsedDate(raw=raw, kind=\"bad\", value=None)\n",
+    "\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(parsed: ParsedDate) -> str:\n",
+    "    if parsed.kind == \"missing\":\n",
+    "        return \"Not listed\"\n",
+    "    if parsed.kind == \"bad\":\n",
+    "        return parsed.raw or \"Not listed\"\n",
+    "    return parsed.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(life_row: pd.Series) -> Tuple[str, str, str]:\n",
+    "    eos = parse_date_field(life_row.get(\"end_of_sale\"))\n",
+    "    eol = parse_date_field(life_row.get(\"end_of_life\"))\n",
+    "    return display_date(eos), display_date(eol), status_from_eos_eol(eos, eol)\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Embeddings + indices\n",
+    "# ============================\n",
+    "embedder = SentenceTransformer(EMBED_MODEL_NAME)\n",
+    "\n",
+    "# Parsec cards around \"Standard SKU\"\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",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Device resolution (exact SKU -> GPT A/B)\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([\n",
+    "        r.get(\"_norm_sku\",\"\"),\n",
+    "        r.get(\"_canon_make\",\"\"),\n",
+    "        r.get(\"_norm_desc\",\"\"),\n",
+    "        r.get(\"_norm_notes\",\"\"),\n",
+    "    ]))\n",
+    "\n",
+    "def local_candidates(query: str, top_k: int = 6) -> List[Tuple[int,int,str]]:\n",
+    "    q = norm_text(query)\n",
+    "    hits = process.extract(q, EOS_CORPUS, scorer=fuzz.WRatio, limit=top_k)\n",
+    "    return [(int(idx), int(score), EOS_LABELS[int(idx)]) for _, score, idx in hits]\n",
+    "\n",
+    "def gpt_choose_device(user_text: str, candidates: List[Tuple[int,int,str]]) -> Dict[str, Any]:\n",
+    "    if client is None:\n",
+    "        return {}\n",
+    "    sys = \"Pick which router the user meant. Never invent. Return strict JSON only.\"\n",
+    "    payload = {\n",
+    "        \"user_input\": user_text,\n",
+    "        \"candidates\": [{\"row_idx\": i, \"score\": s, \"label\": lbl} for (i,s,lbl) in candidates],\n",
+    "        \"rules\": [\n",
+    "            \"If one candidate is clearly correct, return mode='ok' with row_idx.\",\n",
+    "            \"If two are plausible, return mode='pick' with top 2 options.\"\n",
+    "        ],\n",
+    "        \"output_schema\": {\"mode\":\"ok|pick\",\"row_idx\":\"int\",\"options\":[{\"row_idx\":\"int\",\"label\":\"string\"}]}\n",
+    "    }\n",
+    "    return gpt_json(sys, payload, max_tokens=300)\n",
+    "\n",
+    "def resolve_device(user_text: str) -> Dict[str, Any]:\n",
+    "    q = norm_text(user_text)\n",
+    "\n",
+    "    exact_idxs = df_eos.index[df_eos[\"_norm_sku\"] == q].tolist()\n",
+    "    if len(exact_idxs) == 1:\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": int(exact_idxs[0])}\n",
+    "    if len(exact_idxs) > 1:\n",
+    "        opts = [{\"row_idx\": int(i), \"label\": EOS_LABELS[int(i)]} for i in exact_idxs[:2]]\n",
+    "        return {\"mode\":\"pick\",\"options\": opts}\n",
+    "\n",
+    "    cands = local_candidates(user_text, top_k=6)\n",
+    "    if not cands:\n",
+    "        return {\"mode\":\"not_found\"}\n",
+    "\n",
+    "    if cands[0][1] >= 95 and (len(cands) == 1 or (cands[0][1] - cands[1][1]) >= 8):\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": cands[0][0]}\n",
+    "\n",
+    "    g = gpt_choose_device(user_text, cands)\n",
+    "    if g.get(\"mode\") == \"ok\" and isinstance(g.get(\"row_idx\"), int):\n",
+    "        return {\"mode\":\"ok\",\"row_idx\": int(g[\"row_idx\"])}\n",
+    "\n",
+    "    if g.get(\"mode\") == \"pick\":\n",
+    "        opts = g.get(\"options\", []) or []\n",
+    "        opts2 = [{\"row_idx\": int(o[\"row_idx\"]), \"label\": str(o[\"label\"])} for o in opts[:2] if \"row_idx\" in o]\n",
+    "        if opts2:\n",
+    "            return {\"mode\":\"pick\",\"options\": opts2}\n",
+    "\n",
+    "    # fallback\n",
+    "    if len(cands) > 1:\n",
+    "        return {\"mode\":\"pick\",\"options\":[{\"row_idx\":cands[0][0],\"label\":cands[0][2]},{\"row_idx\":cands[1][0],\"label\":cands[1][2]}]}\n",
+    "    return {\"mode\":\"pick\",\"options\":[{\"row_idx\":cands[0][0],\"label\":cands[0][2]}]}\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Replacements — source of truth is lifecycle CSV (with GPT fallback)\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",
+    "\n",
+    "    for cand in candidates:\n",
+    "        m = re.search(r\"\\bIX\\d{2}\\b\", cand, flags=re.IGNORECASE)\n",
+    "        if m:\n",
+    "            return m.group(0).upper()\n",
+    "        m = re.search(r\"\\b(R\\d{3,4}|E\\d{3,4}|S\\d{3,4})\\b\", cand, flags=re.IGNORECASE)\n",
+    "        if m:\n",
+    "            return m.group(0).upper()\n",
+    "        m = re.search(r\"\\b[A-Z]{1,5}\\d{2,4}[A-Z]?\\b\", cand.upper())\n",
+    "        if m:\n",
+    "            return m.group(0).upper()\n",
+    "\n",
+    "    return candidates[0][:60]\n",
+    "\n",
+    "def _candidate_5g_models_from_lifecycle(canon_make: str) -> List[str]:\n",
+    "    pool = df_eos[df_eos[\"_canon_make\"] == canon_make].copy()\n",
+    "    vals = pool[\"advanced_5g_option\"].tolist() if \"advanced_5g_option\" in pool.columns else []\n",
+    "    out, seen = [], set()\n",
+    "    for v in vals:\n",
+    "        tok = _extract_model_token(v)\n",
+    "        if tok and tok.lower() != \"nan\" and tok not in seen:\n",
+    "            seen.add(tok); out.append(tok)\n",
+    "    return out\n",
+    "\n",
+    "def _candidate_4g_models_from_lifecycle(canon_make: str) -> List[str]:\n",
+    "    pool = df_eos[df_eos[\"_canon_make\"] == canon_make].copy()\n",
+    "    vals = pool[\"suggested_replacement\"].tolist() if \"suggested_replacement\" in pool.columns else []\n",
+    "    out, seen = [], set()\n",
+    "    for v in vals:\n",
+    "        tok = _extract_model_token(v)\n",
+    "        if tok and tok.lower() != \"nan\" and tok not in seen:\n",
+    "            seen.add(tok); out.append(tok)\n",
+    "    return out\n",
+    "\n",
+    "def _gpt_pick_from_lifecycle_models(old_row: pd.Series, candidates: List[str], need: str) -> str:\n",
+    "    if client is None or not candidates:\n",
+    "        return \"\"\n",
+    "    sys = \"Pick the best replacement model. Choose only from candidates. Return strict JSON only.\"\n",
+    "    payload = {\n",
+    "        \"old_device\": {\n",
+    "            \"sku\": str(old_row.get(\"sku\",\"\")),\n",
+    "            \"description\": str(old_row.get(\"description\",\"\")),\n",
+    "            \"manufacturer\": str(old_row.get(\"manufacturer\",\"\")),\n",
+    "            \"need\": need,\n",
+    "        },\n",
+    "        \"candidates\": candidates[:30],\n",
+    "        \"output_schema\": {\"choice\":\"string\"}\n",
+    "    }\n",
+    "    out = gpt_json(sys, payload, max_tokens=220) or {}\n",
+    "    choice = str(out.get(\"choice\",\"\") or \"\").strip()\n",
+    "    return choice if choice in candidates else \"\"\n",
+    "\n",
+    "def _fallback_5g_from_dec(canon_make: str) -> str:\n",
+    "    pool5 = df_dec[(df_dec[\"_canon_make\"] == canon_make) & (df_dec[\"_is5g\"] == True)]\n",
+    "    return str(pool5.iloc[0][\"Model\"]).strip() if not pool5.empty else \"\"\n",
+    "\n",
+    "def _device_is_4g(life_row: pd.Series) -> bool:\n",
+    "    t = norm_text(life_row.get(\"description\",\"\")) + \" \" + norm_text(life_row.get(\"notes\",\"\"))\n",
+    "    return ((\"lte\" in t or \"4g\" in t) and (\"5g\" not in t and \"nr\" not in t))\n",
+    "\n",
+    "def pick_replacements_lifecycle(life_row: pd.Series, status: str) -> Dict[str, Any]:\n",
+    "    canon = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "    if canon == \"UNKNOWN\":\n",
+    "        return {\"repl_4g\":\"Not applicable\",\"repl_5g\":\"\", \"why\":\"\", \"sources\":[]}\n",
+    "\n",
+    "    is_4g_device = _device_is_4g(life_row)\n",
+    "    needs_4g_repl = is_4g_device and (status in {\"End of Sale\",\"End of Life\"})\n",
+    "    want_5g = is_4g_device or (status in {\"End of Sale\",\"End of Life\"})\n",
+    "\n",
+    "    repl_4g = \"Not applicable\"\n",
+    "    if needs_4g_repl:\n",
+    "        repl_4g = _extract_model_token(_safe_str(life_row.get(\"suggested_replacement\",\"\")))\n",
+    "        if not repl_4g:\n",
+    "            cand4 = _candidate_4g_models_from_lifecycle(canon)\n",
+    "            repl_4g = _gpt_pick_from_lifecycle_models(life_row, cand4, \"4G replacement\") or (cand4[0] if cand4 else \"\")\n",
+    "        if not repl_4g:\n",
+    "            repl_4g = \"Not applicable\"\n",
+    "\n",
+    "    repl_5g = \"Not applicable\"\n",
+    "    if want_5g:\n",
+    "        repl_5g = _extract_model_token(_safe_str(life_row.get(\"advanced_5g_option\",\"\")))\n",
+    "        if not repl_5g:\n",
+    "            cand5 = _candidate_5g_models_from_lifecycle(canon)\n",
+    "            repl_5g = _gpt_pick_from_lifecycle_models(life_row, cand5, \"5G replacement/upgrade\") or (cand5[0] if cand5 else \"\")\n",
+    "        if not repl_5g:\n",
+    "            # last resort: dec catalog\n",
+    "            repl_5g = _fallback_5g_from_dec(canon)\n",
+    "\n",
+    "    if repl_5g.lower() == \"nan\":\n",
+    "        repl_5g = \"\"\n",
+    "\n",
+    "    return {\n",
+    "        \"repl_4g\": repl_4g,\n",
+    "        \"repl_5g\": repl_5g,\n",
+    "        \"why\": \"Lifecycle replacements (GPT fallback when missing).\",\n",
+    "        \"sources\": [\"lifecycle_csv\"] + ([\"gpt\"] if client else []) + ([\"dec_fallback\"] if (want_5g and not _extract_model_token(_safe_str(life_row.get(\"advanced_5g_option\",\"\")))) else []),\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Antennas (Parsec-only; family name extraction)\n",
+    "# ============================\n",
+    "PARSEC_FAMILY_WORDS = {\n",
+    "    \"chinook\",\"labrador\",\"boxer\",\"bloodhound\",\"husky\",\"beagle\",\"mastiff\",\"collie\",\n",
+    "    \"shepherd\",\"belgian\",\"australian\",\"terrier\",\"pyrenees\"\n",
+    "}\n",
+    "BAD_NAME_MARKERS = {\n",
+    "    \"customization\", \"standard connectors\", \"connectors\", \"features\", \"benefits\",\n",
+    "    \"specifications\", \"mechanical\", \"electrical\", \"mounting\", \"accessories\",\n",
+    "    \"description:\", \"standard sku\"\n",
+    "}\n",
+    "\n",
+    "def _clean_line(s: str) -> str:\n",
+    "    s = re.sub(r\"\\s+\", \" \", str(s or \"\").strip())\n",
+    "    if re.fullmatch(r\"-[a-z0-9]+\", s.lower()):\n",
+    "        return \"\"\n",
+    "    return s\n",
+    "\n",
+    "def _is_bad_name_line(line: str) -> bool:\n",
+    "    low = line.lower()\n",
+    "    if any(m in low for m in BAD_NAME_MARKERS):\n",
+    "        return True\n",
+    "    if re.search(r\"\\b-[a-z0-9]{1,4}\\b\", low) and len(low) <= 25:\n",
+    "        return True\n",
+    "    return False\n",
+    "\n",
+    "def _family_from_line(line: str) -> str:\n",
+    "    low = line.lower()\n",
+    "    for fam in PARSEC_FAMILY_WORDS:\n",
+    "        if fam in low:\n",
+    "            return fam.capitalize()\n",
+    "    return \"\"\n",
+    "\n",
+    "def _parsec_name_from_card(card_text: str) -> str:\n",
+    "    lines = [_clean_line(ln) for ln in str(card_text or \"\").splitlines()]\n",
+    "    lines = [ln for ln in lines if ln]\n",
+    "\n",
+    "    for ln in lines:\n",
+    "        if _is_bad_name_line(ln):\n",
+    "            continue\n",
+    "        fam = _family_from_line(ln)\n",
+    "        if fam:\n",
+    "            return fam\n",
+    "\n",
+    "    sku_i = None\n",
+    "    for i, ln in enumerate(lines):\n",
+    "        if \"standard sku\" in ln.lower():\n",
+    "            sku_i = i\n",
+    "            break\n",
+    "    if sku_i is not None:\n",
+    "        window = lines[max(0, sku_i - 12):sku_i]\n",
+    "        for ln in reversed(window):\n",
+    "            if _is_bad_name_line(ln):\n",
+    "                continue\n",
+    "            if 3 <= len(ln) <= 40 and re.search(r\"[A-Za-z]\", ln):\n",
+    "                return ln.split()[0].capitalize()\n",
+    "\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_retrieve(query: str, top_k: int = 10) -> 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",
+    "                \"card\": card[:1100],\n",
+    "            })\n",
+    "    return out\n",
+    "\n",
+    "def antenna_options_for(router_model: str, tech: str, mimo: str) -> Dict[str, Any]:\n",
+    "    q_stationary = f\"{router_model} {tech} {mimo} omni stationary outdoor Parsec\"\n",
+    "    q_vehicle = f\"{router_model} {tech} {mimo} omni vehicle mobile Parsec\"\n",
+    "    cand_stationary = parsec_retrieve(q_stationary, top_k=10)\n",
+    "    cand_vehicle = parsec_retrieve(q_vehicle, top_k=10)\n",
+    "\n",
+    "    if client is None:\n",
+    "        s = cand_stationary[0] if cand_stationary else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\"}\n",
+    "        v = cand_vehicle[0] if cand_vehicle else {\"name\":\"Parsec antenna\",\"part_number\":\"\",\"description\":\"\"}\n",
+    "        s.update({\"mimo\": mimo, \"why\": \"Stationary omni best match.\"})\n",
+    "        v.update({\"mimo\": mimo, \"why\": \"Vehicle omni best match.\"})\n",
+    "        return {\"stationary_omni\": s, \"vehicle_omni\": v, \"sources\":[\"parsec_rag\"]}\n",
+    "\n",
+    "    sys = \"Select Parsec antennas. Choose only from candidates. Return strict JSON only.\"\n",
+    "    payload = {\n",
+    "        \"router_model\": router_model,\n",
+    "        \"tech\": tech,\n",
+    "        \"mimo\": mimo,\n",
+    "        \"stationary_candidates\": cand_stationary,\n",
+    "        \"vehicle_candidates\": cand_vehicle,\n",
+    "        \"rules\": [\n",
+    "            \"Return two options: stationary_omni and vehicle_omni.\",\n",
+    "            \"Use only candidates. Prefer family names like Labrador/Chinook/Boxer.\",\n",
+    "            \"Include name, part_number, description, mimo, why.\",\n",
+    "            \"Return JSON only.\"\n",
+    "        ],\n",
+    "        \"output_schema\": {\n",
+    "            \"stationary_omni\": {\"name\":\"string\",\"part_number\":\"string\",\"description\":\"string\",\"mimo\":\"2x2|4x4\",\"why\":\"string\"},\n",
+    "            \"vehicle_omni\": {\"name\":\"string\",\"part_number\":\"string\",\"description\":\"string\",\"mimo\":\"2x2|4x4\",\"why\":\"string\"}\n",
+    "        }\n",
+    "    }\n",
+    "    out = gpt_json(sys, payload, max_tokens=650) or {}\n",
+    "\n",
+    "    def _fix(x: Dict[str, Any], default_why: str) -> Dict[str, str]:\n",
+    "        return {\n",
+    "            \"name\": str(x.get(\"name\",\"Parsec antenna\") or \"Parsec antenna\")[:110],\n",
+    "            \"part_number\": str(x.get(\"part_number\",\"\") or \"\")[:40],\n",
+    "            \"description\": str(x.get(\"description\",\"\") or \"\")[:220],\n",
+    "            \"mimo\": str(x.get(\"mimo\", mimo) or mimo),\n",
+    "            \"why\": str(x.get(\"why\", default_why) or default_why)[:160],\n",
+    "        }\n",
+    "\n",
+    "    s = _fix(out.get(\"stationary_omni\", {}) if isinstance(out, dict) else {}, \"Stationary omni best match.\")\n",
+    "    v = _fix(out.get(\"vehicle_omni\", {}) if isinstance(out, dict) else {}, \"Vehicle omni best match.\")\n",
+    "    if not s.get(\"part_number\") and cand_stationary:\n",
+    "        top = cand_stationary[0]\n",
+    "        s = {\"name\": top.get(\"name\",\"Parsec antenna\"), \"part_number\": top.get(\"part_number\",\"\"), \"description\": top.get(\"description\",\"\"), \"mimo\": mimo, \"why\":\"Stationary omni best match.\"}\n",
+    "    if not v.get(\"part_number\") and cand_vehicle:\n",
+    "        top = cand_vehicle[0]\n",
+    "        v = {\"name\": top.get(\"name\",\"Parsec antenna\"), \"part_number\": top.get(\"part_number\",\"\"), \"description\": top.get(\"description\",\"\"), \"mimo\": mimo, \"why\":\"Vehicle omni best match.\"}\n",
+    "    return {\"stationary_omni\": s, \"vehicle_omni\": v, \"sources\":[\"parsec_rag\",\"gpt\"]}\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Feature table + GPT fill for missing fields (no more ****; fill missing via GPT)\n",
+    "# ============================\n",
+    "FEATURE_COLS = [\"Name\",\"Modem technology\",\"WiFi\",\"Ports\",\"Antennas\",\"Ruggedness\",\"Use case\"]\n",
+    "\n",
+    "def dec_features_by_model(model: str, canon_make: str) -> Dict[str, str]:\n",
+    "    if not model or model == \"Not applicable\":\n",
+    "        return {k:\"Not listed\" for k in FEATURE_COLS}\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}\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}\n",
+    "    r = pool.iloc[int(hit[2])]\n",
+    "    ports = f\"WAN: {r.get('WAN ports and speed','')} | LAN: {r.get('LAN ports and speed','')}\"\n",
+    "    return {\n",
+    "        \"Name\": str(r.get(\"Model\",\"\")),\n",
+    "        \"Modem technology\": str(r.get(\"Modem Type\",\"\")),\n",
+    "        \"WiFi\": str(r.get(\"WiFi type\",\"\")),\n",
+    "        \"Ports\": ports,\n",
+    "        \"Antennas\": str(r.get(\"Antennas (internal/external/both)\",\"\")),\n",
+    "        \"Ruggedness\": str(r.get(\"Ruggedization\",\"\")),\n",
+    "        \"Use case\": str(r.get(\"Primary use case\",\"\")),\n",
+    "    }\n",
+    "\n",
+    "def gpt_fill_features(device_label: str, feats: Dict[str,str], context: str) -> Dict[str,str]:\n",
+    "    missing = [k for k,v in feats.items() if (not v) or v.strip().lower() in {\"not listed\",\"nan\"}]\n",
+    "    if client is None or not missing:\n",
+    "        return feats\n",
+    "    sys = \"Fill missing router feature fields. Return strict JSON only.\"\n",
+    "    payload = {\n",
+    "        \"device\": device_label,\n",
+    "        \"known\": feats,\n",
+    "        \"context\": context[:2000],\n",
+    "        \"fill_only\": missing,\n",
+    "        \"rules\": [\"Fill only requested fields. Best guess if needed. Return JSON only.\"],\n",
+    "        \"output_schema\": {k:\"string\" for k in missing}\n",
+    "    }\n",
+    "    out = gpt_json(sys, payload, max_tokens=350) or {}\n",
+    "    for k in missing:\n",
+    "        v = str(out.get(k,\"\") or \"\").strip()\n",
+    "        if v:\n",
+    "            feats[k] = v\n",
+    "    return feats\n",
+    "\n",
+    "def current_features_guess(life_row: pd.Series) -> Dict[str,str]:\n",
+    "    sku = str(life_row.get(\"sku\",\"\") or \"\").strip()\n",
+    "    desc = str(life_row.get(\"description\",\"\") or \"\").strip()\n",
+    "    notes = str(life_row.get(\"notes\",\"\") or \"\").strip()\n",
+    "    base = {\n",
+    "        \"Name\": sku,\n",
+    "        \"Modem technology\": \"4G\" if _device_is_4g(life_row) else (\"5G\" if ((\"5g\" in (desc+notes).lower()) or (\"nr\" in (desc+notes).lower())) else \"Not listed\"),\n",
+    "        \"WiFi\": \"Not listed\",\n",
+    "        \"Ports\": \"Not listed\",\n",
+    "        \"Antennas\": \"Not listed\",\n",
+    "        \"Ruggedness\": \"Not listed\",\n",
+    "        \"Use case\": \"Not listed\",\n",
+    "    }\n",
+    "    return gpt_fill_features(\"Current device\", base, f\"{desc}\\n{notes}\")\n",
+    "\n",
+    "def build_features_table(cur: Dict[str,str], r4: Dict[str,str], r5: Dict[str,str]) -> str:\n",
+    "    cols = [\"Device\", \"Modem technology\", \"WiFi\", \"Ports\", \"Antennas\", \"Ruggedness\", \"Use case\"]\n",
+    "    header = \"| \" + \" | \".join(cols) + \" |\"\n",
+    "    sep = \"| \" + \" | \".join([\"---\"]*len(cols)) + \" |\"\n",
+    "\n",
+    "    def row(name: str, feats: Dict[str,str]) -> str:\n",
+    "        return \"| \" + \" | \".join([\n",
+    "            name,\n",
+    "            feats.get(\"Modem technology\",\"Not listed\"),\n",
+    "            feats.get(\"WiFi\",\"Not listed\"),\n",
+    "            feats.get(\"Ports\",\"Not listed\"),\n",
+    "            feats.get(\"Antennas\",\"Not listed\"),\n",
+    "            feats.get(\"Ruggedness\",\"Not listed\"),\n",
+    "            feats.get(\"Use case\",\"Not listed\"),\n",
+    "        ]) + \" |\"\n",
+    "\n",
+    "    return \"\\n\".join([header, sep, row(\"Current\", cur), row(\"4G replacement\", r4), row(\"5G replacement\", r5)])\n",
+    "\n",
+    "\n",
+    "# ============================\n",
+    "# Output + Gradio UI\n",
+    "# ============================\n",
+    "def fmt(v: Any, fallback: str = \"Not listed\") -> str:\n",
+    "    s = _safe_str(v)\n",
+    "    if not s or s.lower() == \"nan\":\n",
+    "        return fallback\n",
+    "    return s\n",
+    "\n",
+    "def assemble_output(life_row: pd.Series, status: str, eos: str, eol: str, repl: Dict[str,Any], ant: Dict[str,Any]) -> str:\n",
+    "    canon_make = str(life_row.get(\"_canon_make\",\"UNKNOWN\"))\n",
+    "    current_name = f\"{life_row.get('sku','')} — {life_row.get('description','')}\".strip(\" —\")\n",
+    "\n",
+    "    # Antenna\n",
+    "    st = ant.get(\"stationary_omni\", {})\n",
+    "    vh = ant.get(\"vehicle_omni\", {})\n",
+    "\n",
+    "    # Feature table (fill missing via GPT)\n",
+    "    cur_feats = current_features_guess(life_row)\n",
+    "    r4_feats = dec_features_by_model(repl.get(\"repl_4g\",\"\"), canon_make)\n",
+    "    r5_feats = dec_features_by_model(repl.get(\"repl_5g\",\"\"), canon_make)\n",
+    "    if client is not None:\n",
+    "        r4_feats = gpt_fill_features(\"4G replacement\", r4_feats, \"\")\n",
+    "        r5_feats = gpt_fill_features(\"5G replacement\", r5_feats, \"\")\n",
+    "    table_md = build_features_table(cur_feats, r4_feats, r5_feats)\n",
+    "\n",
+    "    lines = []\n",
+    "    lines.append(f\"1. Current device: **{current_name}**\")\n",
+    "    lines.append(f\"2. Status: **{status}**\")\n",
+    "    lines.append(f\"3. End of Sale date: **{eos}**\")\n",
+    "    lines.append(f\"4. End of Life date: **{eol}**\")\n",
+    "    lines.append(f\"5. 4G recommended replacement: **{fmt(repl.get('repl_4g'), 'Not applicable')}**\")\n",
+    "    # If 5G is empty, force GPT to pick from lifecycle pool\n",
+    "    repl5 = fmt(repl.get(\"repl_5g\"), \"\")\n",
+    "    if (not repl5) and client is not None:\n",
+    "        cand5 = _candidate_5g_models_from_lifecycle(str(life_row.get('_canon_make','UNKNOWN')))\n",
+    "        repl5 = _gpt_pick_from_lifecycle_models(life_row, cand5, \"5G replacement/upgrade\") or (cand5[0] if cand5 else \"\")\n",
+    "    if not repl5:\n",
+    "        repl5 = \"Not listed\"\n",
+    "    lines.append(f\"6. 5G recommended replacement: **{repl5}**\")\n",
+    "\n",
+    "    lines.append(\"7. Antenna options (Parsec-only):\")\n",
+    "    lines.append(f\"   - Stationary (Omni): **{fmt(st.get('name'))}** (Part #: {fmt(st.get('part_number'))}) — {fmt(st.get('description'))} — MIMO: {fmt(st.get('mimo'))} — {fmt(st.get('why'))}\")\n",
+    "    lines.append(f\"   - Vehicle (Omni): **{fmt(vh.get('name'))}** (Part #: {fmt(vh.get('part_number'))}) — {fmt(vh.get('description'))} — MIMO: {fmt(vh.get('mimo'))} — {fmt(vh.get('why'))}\")\n",
+    "\n",
+    "    lines.append(\"8. Recommended features table:\")\n",
+    "    lines.append(table_md)\n",
+    "\n",
+    "    lines.append(\"\\nSources (debug):\")\n",
+    "    for s in repl.get(\"sources\", []) if isinstance(repl.get(\"sources\"), list) else []:\n",
+    "        lines.append(f\"- {s}\")\n",
+    "    lines.append(\"- ParsecCatalog.pdf (local RAG)\")\n",
+    "    lines.append(\"- dec2025routers.csv (features + fallback)\")\n",
+    "    return \"\\n\".join(lines)\n",
+    "\n",
+    "def run_lookup(user_text: str, st: Dict[str,Any]):\n",
+    "    user_text = str(user_text or \"\").strip()\n",
+    "    if not user_text:\n",
+    "        return \"Enter a router SKU/model.\", gr.update(visible=False), gr.update(visible=False), {}\n",
+    "\n",
+    "    res = resolve_device(user_text)\n",
+    "    if res.get(\"mode\") == \"pick\":\n",
+    "        opts = res.get(\"options\", [])\n",
+    "        choices = [o[\"label\"] for o in opts]\n",
+    "        st2 = {\"mode\":\"pick\",\"options\": opts}\n",
+    "        return \"Did you mean A or B? Pick one, then click Use selection.\", gr.update(choices=choices, value=None, visible=True), gr.update(visible=True), st2\n",
+    "\n",
+    "    if res.get(\"mode\") != \"ok\":\n",
+    "        return \"Not found.\", gr.update(visible=False), gr.update(visible=False), {}\n",
+    "\n",
+    "    life_row = df_eos.iloc[int(res[\"row_idx\"])]\n",
+    "    eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "\n",
+    "    repl = pick_replacements_lifecycle(life_row, status)\n",
+    "\n",
+    "    tech = \"5G\" if repl.get(\"repl_5g\") and repl.get(\"repl_5g\") != \"Not applicable\" else (\"4G\" if _device_is_4g(life_row) else \"Unknown\")\n",
+    "    mimo_guess = \"4x4\" if tech == \"5G\" else \"2x2\"\n",
+    "    ant = antenna_options_for(router_model=repl.get(\"repl_5g\") or str(life_row.get(\"sku\",\"\")), tech=tech, mimo=mimo_guess)\n",
+    "\n",
+    "    return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}\n",
+    "\n",
+    "def use_selection(selected_label: str, st: Dict[str,Any]):\n",
+    "    if not st or st.get(\"mode\") != \"pick\":\n",
+    "        return \"Run a search first.\", gr.update(visible=False), gr.update(visible=False), {}\n",
+    "    if not selected_label:\n",
+    "        return \"Pick A or B first.\", gr.update(visible=True), gr.update(visible=True), st\n",
+    "\n",
+    "    chosen_row = None\n",
+    "    for o in st.get(\"options\", []):\n",
+    "        if o.get(\"label\") == selected_label:\n",
+    "            chosen_row = int(o[\"row_idx\"])\n",
+    "            break\n",
+    "    if chosen_row is None:\n",
+    "        return \"Pick a valid option.\", gr.update(visible=True), gr.update(visible=True), st\n",
+    "\n",
+    "    life_row = df_eos.iloc[int(chosen_row)]\n",
+    "    eos, eol, status = row_to_dates_and_status(life_row)\n",
+    "    repl = pick_replacements_lifecycle(life_row, status)\n",
+    "\n",
+    "    tech = \"5G\" if repl.get(\"repl_5g\") and repl.get(\"repl_5g\") != \"Not applicable\" else (\"4G\" if _device_is_4g(life_row) else \"Unknown\")\n",
+    "    mimo_guess = \"4x4\" if tech == \"5G\" else \"2x2\"\n",
+    "    ant = antenna_options_for(router_model=repl.get(\"repl_5g\") or str(life_row.get(\"sku\",\"\")), tech=tech, mimo=mimo_guess)\n",
+    "\n",
+    "    return assemble_output(life_row, status, eos, eol, repl, ant), gr.update(visible=False), gr.update(visible=False), {}\n",
+    "\n",
+    "with gr.Blocks(title=\"Only-Routers\") as demo:\n",
+    "    gr.Markdown(\"## Only-Routers\\nEnter a router SKU/model. If ambiguous, you’ll get A/B choices.\")\n",
+    "    user_text = gr.Textbox(label=\"Router SKU or model\", placeholder=\"Examples: IBR650B, AER1600, ES450, WR21\", lines=1)\n",
+    "    st = gr.State({})\n",
+    "\n",
+    "    check_btn = gr.Button(\"Check\", variant=\"primary\")\n",
+    "    pick_dd = gr.Dropdown(label=\"Pick A or B\", choices=[], visible=False)\n",
+    "    use_btn = gr.Button(\"Use selection\", visible=False)\n",
+    "\n",
+    "    output_md = gr.Markdown()\n",
+    "\n",
+    "    check_btn.click(fn=run_lookup, inputs=[user_text, st], outputs=[output_md, pick_dd, use_btn, st])\n",
+    "    use_btn.click(fn=use_selection, inputs=[pick_dd, st], outputs=[output_md, pick_dd, use_btn, st])\n",
+    "\n",
+    "demo.launch()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}