Update main.py

main.py

@@ -23,7 +23,6 @@ from public_api.public_api_location import get_location_status
 from public_api.utils import flatten_json, extract_fields
 from public_api.field_mapping import TOOL_REGISTRY, ALL_TOOLS
 
-
 # KB services
 from services.kb_creation import (
     collection,
@@ -39,23 +38,51 @@ from services.kb_creation import (
 from services.login import router as login_router
 from services.generate_ticket import get_valid_token, create_incident
 
-# ---------------------------------------------------------------------
-# Environment
-# ---------------------------------------------------------------------
+
+# =============================================================================
+# Environment / Gemini config
+# =============================================================================
 load_dotenv()
+
 VERIFY_SSL = os.getenv("SERVICENOW_SSL_VERIFY", "true").lower() in ("1", "true", "yes")
 GEMINI_SSL_VERIFY = os.getenv("GEMINI_SSL_VERIFY", "true").lower() in ("1", "true", "yes")
 GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+# ✔ Use header-based auth (safer than embedding the key in the URL)
+#    You can switch model id if needed (e.g., "gemini-2.5-flash-lite"), but
+#    standard "flash" is generally stronger with function-calling.
 GEMINI_URL = (
     "https://generativelanguage.googleapis.com/v1beta/models/"
-    f"gemini-2.5-flash-lite:generateContent?key={GEMINI_API_KEY}"
+    "gemini-2.5-flash:generateContent"
 )
+
 os.environ["POSTHOG_DISABLED"] = "true"
 
 # --- API WMS session cache ---
 _WMS_SESSION_DATA = None
 _WMS_WAREHOUSE_ID = None
 
+
+def _gemini_post(payload: dict, timeout: int = 25):
+    """
+    Central helper to call Gemini with proper headers and SSL behavior.
+    """
+    if not GEMINI_API_KEY:
+        # Return an object mimicking requests.Response for graceful handling
+        return type(
+            "Resp",
+            (),
+            {
+                "status_code": 401,
+                "json": lambda: {"error": {"message": "Missing GEMINI_API_KEY"}},
+                "text": "Missing GEMINI_API_KEY",
+                "raise_for_status": lambda: None,
+            },
+        )()
+    headers = {"Content-Type": "application/json", "x-goog-api-key": GEMINI_API_KEY}
+    return requests.post(GEMINI_URL, headers=headers, json=payload, timeout=timeout, verify=GEMINI_SSL_VERIFY)
+
+
 def _ensure_wms_session() -> bool:
     """Login once to WMS and cache session_data + default warehouse."""
     global _WMS_SESSION_DATA, _WMS_WAREHOUSE_ID
@@ -71,9 +98,10 @@ def _ensure_wms_session() -> bool:
         print("[WMS] login failed:", e)
     return False
 
-# ---------------------------------------------------------------------
-# Minimal server-side cache (used to populate short description if frontend didn’t pass last_issue)
-# ---------------------------------------------------------------------
+
+# =============================================================================
+# Minimal server-side cache (used to populate short description later)
+# =============================================================================
 LAST_ISSUE_HINT: str = ""
 
 
@@ -84,9 +112,9 @@ def safe_str(e: Any) -> str:
         return "<error stringify failed>"
 
 
-# ---------------------------------------------------------------------
+# =============================================================================
 # App / Lifespan
-# ---------------------------------------------------------------------
+# =============================================================================
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     try:
@@ -106,7 +134,7 @@ app.include_router(login_router)
 
 # CORS
 origins = [
-    "https://chatbotnova-chatbot-frontend.hf.space",
+    "https://chatbotnova-chatbot-frontend.hf.space",  # HF frontend Space URL
     # "http://localhost:5173",  # local dev if needed
 ]
 app.add_middleware(
@@ -117,9 +145,9 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# ---------------------------------------------------------------------
+# =============================================================================
 # Models
-# ---------------------------------------------------------------------
+# =============================================================================
 class ChatInput(BaseModel):
     user_message: str
     prev_status: Optional[str] = None
@@ -150,9 +178,9 @@ STATE_MAP = {
     "8": "Canceled",
 }
 
-# ---------------------------------------------------------------------
+# =============================================================================
 # Generic helpers (shared)
-# ---------------------------------------------------------------------
+# =============================================================================
 NUMBERING_STYLE = os.getenv("NUMBERING_STYLE", "digit").lower()  # 'digit' or 'step'
 DOMAIN_STATUS_TERMS = (
     "shipment", "order", "load", "trailer", "wave",
@@ -160,6 +188,7 @@ DOMAIN_STATUS_TERMS = (
     "dock", "door", "manifest", "pallet", "container",
     "asn", "grn", "pick", "picking",
 )
+
 ERROR_FAMILY_SYNS = {
     "NOT_FOUND": (
         "not found", "missing", "does not exist", "doesn't exist",
@@ -190,38 +219,29 @@ ERROR_FAMILY_SYNS = {
 }
 
 
-
-
 def _try_wms_tool(user_text: str) -> dict | None:
     """
     Uses Gemini function calling + TOOL_REGISTRY to decide if a WMS tool should be called.
     Returns YOUR existing response dict shape. If no tool match or any error -> returns None.
     """
-
     # Guards
     if not GEMINI_API_KEY:
         return None
     if not _ensure_wms_session():
         return None
 
-    headers = {"Content-Type": "application/json", "x-goog-api-key": GEMINI_API_KEY}
+    # Prepare default warehouse from cached session
+    session_data = _WMS_SESSION_DATA
+    default_wh = session_data.get("user_warehouse_id") if session_data else None
+
     payload = {
-        "contents": [{"role": "user","parts": [{"text": user_text}]}],
-        "tools": [{"functionDeclarations": ALL_TOOLS}],
-        "toolConfig": {                            # REST field name
-        "functionCallingConfig": { "mode": "ANY" }
-        }
+        "contents": [{"role": "user", "parts": [{"text": user_text}]}],
+        "tools": [{"functionDeclarations": ALL_TOOLS}],  # from public_api.field_mapping
+        "toolConfig": {"functionCallingConfig": {"mode": "ANY"}},  # nudge function calling
     }
 
     try:
-        resp = requests.post(
-            GEMINI_URL,
-            headers=headers,
-            json=payload,
-            timeout=25,
-            verify=GEMINI_SSL_VERIFY
-        )
-        # Raise if HTTP not 2xx so we handle cleanly
+        resp = _gemini_post(payload, timeout=25)
         resp.raise_for_status()
         data = resp.json()
 
@@ -229,12 +249,9 @@ def _try_wms_tool(user_text: str) -> dict | None:
         if not candidates:
             return None
 
-        # Defensive extraction of the first part
         content = candidates[0].get("content", {})
         parts = content.get("parts", [])
         part = parts[0] if parts else {}
-
-        # Gemini returns a function call in part["functionCall"] when a tool is selected
         fn_call = part.get("functionCall")
         if not fn_call or "name" not in fn_call:
             return None
@@ -244,21 +261,19 @@ def _try_wms_tool(user_text: str) -> dict | None:
 
         cfg = TOOL_REGISTRY.get(tool_name)
         if not cfg:
-            # Tool not registered → bail
             return None
 
-        # -------- Resolve warehouse --------
+        # Resolve warehouse override, else use session default
         wh = (
             args.pop("warehouse_id", None)
             or args.pop("warehouseId", None)
             or args.pop("wh_id", None)
-            or _WMS_WAREHOUSE_ID
+            or default_wh
         )
 
-        # -------- Invoke the tool callable correctly --------
+        # Get callable
         tool_fn = cfg.get("function")
         if not callable(tool_fn):
-            # Misconfigured registry
             return {
                 "bot_response": f"⚠️ Tool '{tool_name}' is not callable. Check TOOL_REGISTRY['{tool_name}']['function'].",
                 "status": "PARTIAL",
@@ -272,15 +287,20 @@ def _try_wms_tool(user_text: str) -> dict | None:
                 "source": "ERROR",
             }
 
-        # Holds & Location use kwargs (e.g., lodnum/subnum/dtlnum OR stoloc);
-        # Item uses single ID parameter (e.g., item_id) plus warehouse.
-        if tool_name in ("get_inventory_holds", "get_location_status"):
-            # Pass warehouse as kwarg if present; rest comes from args
-            call_kwargs = {"warehouse_id": wh} if wh is not None else {}
-            call_kwargs.update(args)
-            raw = tool_fn(**call_kwargs)
+        # ---- Correct invocation according to your real function signatures ----
+        # get_inventory_holds(session_data, warehouse_id, **kwargs)
+        # get_location_status(session_data, warehouse_id, stoloc)
+        # get_item(session_data, warehouse_id, item_number, **kwargs)
+        if tool_name == "get_inventory_holds":
+            call_kwargs = {**args}  # lodnum / subnum / dtlnum
+            raw = tool_fn(session_data, wh, **call_kwargs)
+
+        elif tool_name == "get_location_status":
+            stoloc = args.get("stoloc")
+            raw = tool_fn(session_data, wh, stoloc)
+
         else:
-            id_param = cfg.get("id_param")
+            id_param = cfg.get("id_param")  # "item_number"
             target = args.get(id_param)
             if id_param and target is None:
                 return {
@@ -295,19 +315,10 @@ def _try_wms_tool(user_text: str) -> dict | None:
                     "debug": {"intent": "wms_missing_id_param", "tool": tool_name},
                     "source": "CLIENT",
                 }
+            extra_kwargs = {k: v for k, v in args.items() if k != id_param}
+            raw = tool_fn(session_data, wh, target, **extra_kwargs)
 
-            call_kwargs = {"warehouse_id": wh} if wh is not None else {}
-            # Include the ID param, plus any other Gemini-parsed args
-            if id_param:
-                call_kwargs[id_param] = target
-            # Keep other non-ID args (filters, etc.)
-            for k, v in args.items():
-                if k != id_param:
-                    call_kwargs[k] = v
-
-            raw = tool_fn(**call_kwargs)
-
-        # -------- Error handling from tool layer --------
+        # ---- Tool-layer error handling ----
         if isinstance(raw, dict) and raw.get("error"):
             return {
                 "bot_response": f"⚠️ {raw['error']}",
@@ -322,7 +333,7 @@ def _try_wms_tool(user_text: str) -> dict | None:
                 "source": "ERROR",
             }
 
-        # -------- Extract data list (default key = 'data') --------
+        # ---- Extract rows from response ----
         response_key = cfg.get("response_key", "data")
         data_list = (raw.get(response_key, []) if isinstance(raw, dict) else []) or []
         if not data_list:
@@ -339,24 +350,20 @@ def _try_wms_tool(user_text: str) -> dict | None:
                 "source": "LIVE_API",
             }
 
-        # -------- TABLE: Holds / Location --------
+        # ---- Table rendering (holds + location) ----
         if tool_name in ("get_inventory_holds", "get_location_status"):
-            rows_for_text = []
-            total_qty = 0
-
+            rows_for_text, total_qty = [], 0
             for item in data_list:
                 flat = flatten_json(item)
                 row = extract_fields(flat, cfg["mapping"], cfg.get("formatters", {}))
                 rows_for_text.append("• " + "; ".join(f"{k}: {v}" for k, v in row.items()))
 
             if tool_name == "get_inventory_holds":
-                # Only holds have quantity in most schemas
                 def _to_int(x):
                     try:
                         return int(x or 0)
                     except Exception:
                         return 0
-
                 total_qty = sum(_to_int(it.get("untqty", 0)) for it in data_list)
                 msg = f"Found {len(rows_for_text)} hold records (Total Qty: {total_qty}).\n" + "\n".join(rows_for_text[:10])
             else:
@@ -379,9 +386,8 @@ def _try_wms_tool(user_text: str) -> dict | None:
                 "show_export": True if tool_name == "get_inventory_holds" else False,
             }
 
-        # -------- ITEM: summary + single-row table --------
+        # ---- Item summary + one-row table ----
         flat = flatten_json(data_list[0])
-
         requested = args.get("fields", [])
         if requested:
             filtered_map = {k: v for k, v in cfg["mapping"].items() if k in requested or k == "Item"}
@@ -412,7 +418,6 @@ def _try_wms_tool(user_text: str) -> dict | None:
         }
 
     except requests.HTTPError as e:
-        # Surface Gemini API issues more clearly
         return {
             "bot_response": f"Gemini API error: {e}",
             "status": "PARTIAL",
@@ -429,6 +434,7 @@ def _try_wms_tool(user_text: str) -> dict | None:
         print("[WMS] tool call error:", e)
         return None
 
+
 def _detect_error_families(msg: str) -> list:
     low = (msg or "").lower()
     low_norm = re.sub(r"[^\w\s]", " ", low)
@@ -493,7 +499,7 @@ def _dedupe_lines(text: str) -> str:
 
 
 def _split_sentences(block: str) -> list:
-    parts = [t.strip() for t in re.split(r"(?<=[.!?])\s+", block or "") if t.strip()]
+    parts = [t.strip() for t in re.split(r"(?<=\w[.!?])\s+", block or "") if t.strip()]
     return parts if parts else ([block.strip()] if (block or "").strip() else [])
 
 
@@ -505,33 +511,31 @@ def _ensure_numbering(text: str) -> str:
     para = " ".join(lines).strip()
     if not para:
         return ""
-    para_clean = re.sub(r"(?:\b\d+\s*[.\)])\s+", "\n\n\n", para)          # 1. / 1)
-    para_clean = re.sub(r"(?:[\u2460-\u2473]\s+)", "\n\n\n", para_clean)  # circled digits
-    para_clean = re.sub(r"(?i)\bstep\s*\d+\s*:\s*", "\n\n\n", para_clean) # Step 1:
+
+    # Remove existing numbering/bullets to rebuild consistently
+    para_clean = re.sub(r"(?:\b\d+\s*[\.\)])\s+", "\n\n\n", para)                # 1. / 1)
+    para_clean = re.sub(r"(?:[\u2460-\u2473]\s+)", "\n\n\n", para_clean)         # circled digits
+    para_clean = re.sub(r"(?i)\bstep\s*\d+\s*:?\s*", "\n\n\n", para_clean)       # Step 1:
+
     segments = [seg.strip() for seg in para_clean.split("\n\n\n") if seg.strip()]
     if len(segments) < 2:
         tmp = [ln.strip() for ln in para.splitlines() if ln.strip()]
-        segments = tmp if len(tmp) > 1 else [seg.strip() for seg in re.split(r"(?<=[.!?])\s+", para) if seg.strip()]
+        segments = tmp if len(tmp) > 1 else [seg.strip() for seg in re.split(r"(?<=\w[.!?])\s+", para) if seg.strip()]
 
     def strip_prefix_any(s: str) -> str:
         return re.sub(
             r"^\s*(?:"
-            r"(?:\d+\s*[.\)])|"
-            r"(?i:step\s*\d+:?)|"
-            r"(?:[-*\u2022])|"
-            r"(?:[\u2460-\u2473])"
+            r"(?:\d+\s*[\.\)])|"             # 1. / 1)
+            r"(?i:step\s*\d+:?)|"            # Step 1:
+            r"(?:[-*\u2022])|"               # bullets
+            r"(?:[\u2460-\u2473])"           # circled digits
             r")\s*",
             "",
             (s or "").strip(),
         )
 
     clean_segments = [strip_prefix_any(seg) for seg in segments if seg.strip()]
-    circled = {
-        1: "\u2460", 2: "\u2461", 3: "\u2462", 4: "\u2463", 5: "\u2464",
-        6: "\u2465", 7: "\u2466", 8: "\u2467", 9: "\u2468", 10: "\u2469",
-        11: "\u246a", 12: "\u246b", 13: "\u246c", 14: "\u246d", 15: "\u246e",
-        16: "\u246f", 17: "\u2470", 18: "\u2471", 19: "\u2472", 20: "\u2473",
-    }
+    circled = {i: chr(9311 + i) for i in range(1, 21)}  # \u2460.. \u2473
     out = []
     for idx, seg in enumerate(clean_segments, start=1):
         marker = circled.get(idx, f"{idx})")
@@ -539,49 +543,13 @@ def _ensure_numbering(text: str) -> str:
     return "\n".join(out)
 
 
-def _norm_text(s: str) -> str:
-    s = (s or "").lower()
-    s = re.sub(r"[^\w\s]", " ", s)
-    s = re.sub(r"\s+", " ", s).strip()
-    if not s:
+def _similarity(a: str, b: str) -> float:
+    def _norm_text(s: str) -> str:
+        s = (s or "").lower()
+        s = re.sub(r"[^\w\s]", " ", s)
+        s = re.sub(r"\s+", " ", s).strip()
         return s
-    toks = s.split()
-    stemmed = []
-    for t in toks:
-        if len(t) > 3 and t.endswith("s"):
-            t = t[:-1]
-        if len(t) > 4 and t.endswith("ed"):
-            t = t[:-2]
-        if len(t) > 5 and t.endswith("ing"):
-            t = t[:-3]
-        stemmed.append(t)
-    return " ".join(stemmed).strip()
-
-
-def _split_sop_into_steps(numbered_text: str) -> list:
-    lines = [ln.strip() for ln in (numbered_text or "").splitlines() if ln.strip()]
-    steps = []
-    for ln in lines:
-        cleaned = re.sub(r"^\s*(?:[\u2460-\u2473]|\d+[.)]|[-*•])\s*", "", ln)
-        if cleaned:
-            steps.append(cleaned)
-    return steps
-
-
-def _format_steps_as_numbered(steps: list) -> str:
-    circled = {
-        1: "\u2460", 2: "\u2461", 3: "\u2462", 4: "\u2463", 5: "\u2464",
-        6: "\u2465", 7: "\u2466", 8: "\u2467", 9: "\u2468", 10: "\u2469",
-        11: "\u246a", 12: "\u246b", 13: "\u246c", 14: "\u246d", 15: "\u246e",
-        16: "\u246f", 17: "\u2470", 18: "\u2471", 19: "\u2472", 20: "\u2473",
-    }
-    out = []
-    for i, s in enumerate(steps, start=1):
-        out.append(f"{circled.get(i, str(i))} {s}")
-    return "\n".join(out)
-
 
-def _similarity(a: str, b: str) -> float:
     a_norm, b_norm = _norm_text(a), _norm_text(b)
     ta, tb = set(a_norm.split()), set(b_norm.split())
     inter = len(ta & tb)
@@ -595,13 +563,15 @@ def _similarity(a: str, b: str) -> float:
     big_inter = len(ab & bb)
     big_union = len(ab | bb) or 1
     big = big_inter / big_union
+
     char = SequenceMatcher(None, a_norm, b_norm).ratio()
     return min(1.0, 0.45 * jacc + 0.30 * big + 0.35 * char)
 
 
 def _extract_anchor_from_query(msg: str) -> dict:
     raw = (msg or "").strip()
-    low = _norm_text(raw)
+    low = re.sub(r"[^\w\s]", " ", raw.lower()).strip()
+
     FOLLOWUP_CUES = ("what next", "what is next", "what to do", "then", "after that", "next")
     has_followup = any(cue in low for cue in FOLLOWUP_CUES)
 
@@ -610,17 +580,16 @@ def _extract_anchor_from_query(msg: str) -> dict:
         return {"anchor": raw, "has_followup": has_followup}
 
     last = parts[-1]
-    last_low = _norm_text(last)
+    last_low = re.sub(r"[^\w\s]", " ", last.lower()).strip()
     if any(cue in last_low for cue in FOLLOWUP_CUES) and len(parts) >= 2:
         anchor = parts[-2]
     else:
         anchor = parts[-1] if len(parts) > 1 else parts[0]
-
     return {"anchor": anchor.strip(), "has_followup": has_followup}
 
 
 def _anchor_next_steps(user_message: str, numbered_text: str, max_next: int = 8) -> list | None:
-    steps = _split_sop_into_steps(numbered_text)
+    steps = [ln.strip() for ln in (numbered_text or "").splitlines() if ln.strip()]
     if not steps:
         return None
 
@@ -628,9 +597,8 @@ def _anchor_next_steps(user_message: str, numbered_text: str, max_next: int = 8)
     anchor = info.get("anchor", "").strip()
     if not anchor:
         return None
-    anchor_norm = _norm_text(anchor)
-    has_followup = bool(info.get("has_followup"))
 
+    has_followup = bool(info.get("has_followup"))
     candidates = []
     for idx, step_line in enumerate(steps):
         s_full = _similarity(anchor, step_line)
@@ -638,23 +606,24 @@ def _anchor_next_steps(user_message: str, numbered_text: str, max_next: int = 8)
         scores = [s_full]
         for s in _split_sentences(step_line):
             scores.append(_similarity(anchor, s))
-            a_flat = re.sub(r"\W+", "", anchor_norm)
-            s_flat = re.sub(r"\W+", "", _norm_text(s))
-            if a_flat and (a_flat in s_flat or s_flat in a_flat):
-                literal_hit = True
+        a_flat = re.sub(r"\W+", "", re.sub(r"[^\w\s]", " ", anchor.lower()))
+        s_flat = re.sub(r"\W+", "", re.sub(r"[^\w\s]", " ", s.lower()))
+        if a_flat and (a_flat in s_flat or s_flat in a_flat):
+            literal_hit = True
         score = max(scores)
         candidates.append((idx, score, literal_hit))
 
     candidates.sort(key=lambda t: (t[1], t[0]), reverse=True)
     best_idx, best_score, best_literal = candidates[0]
 
-    tok_count = len([t for t in anchor_norm.split() if len(t) > 1])
+    tok_count = len([t for t in re.sub(r"[^\w\s]", " ", anchor.lower()).split() if len(t) > 1])
     if best_literal:
         accept = True
     else:
         base_ok = best_score >= (0.55 if not has_followup else 0.50)
         len_ok = (best_score >= 0.40) and (tok_count >= 3)
         accept = base_ok or len_ok
+
     if not accept:
         return None
 
@@ -678,12 +647,13 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
         return t
 
     def _split_sents(ctx: str) -> List[str]:
-        raw_sents = re.split(r"(?<=[.!?])\s+", ctx or "")
+        raw_sents = re.split(r"(?<=\w[.!?])\s+", ctx or "")
         return [s.strip() for s in raw_sents if s and len(s.strip()) > 2]
 
     ctx = (context or "").strip()
     if not ctx or not query:
         return ctx, {'mode': 'concise', 'matched_count': 0, 'all_sentences': 0}
+
     q_norm = _norm(query)
     q_terms = [t for t in q_norm.split() if len(t) > 2]
     if not q_terms:
@@ -693,7 +663,7 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
     matched_exact, matched_any = [], []
     for s in sentences:
         s_norm = _norm(s)
-        is_bullet = bool(re.match(r"^[\-\*]\s*", s))
+        is_bullet = bool(re.match(r"^[-*\u2022]\s*", s))
         overlap = sum(1 for t in q_terms if t in s_norm) + (1 if is_bullet else 0)
         if overlap >= STRICT_OVERLAP:
             matched_exact.append(s)
@@ -705,11 +675,13 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
         return _dedupe_lines("\n".join(kept).strip()), {
             'mode': 'exact', 'matched_count': len(kept), 'all_sentences': len(sentences),
         }
+
     if matched_any:
         kept = matched_any[:MAX_SENTENCES_CONCISE]
         return _dedupe_lines("\n".join(kept).strip()), {
             'mode': 'concise', 'matched_count': len(kept), 'all_sentences': len(sentences),
         }
+
     kept = sentences[:MAX_SENTENCES_CONCISE]
     return _dedupe_lines("\n".join(kept).strip()), {
         'mode': 'concise', 'matched_count': 0, 'all_sentences': len(sentences),
@@ -719,7 +691,7 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
 def _extract_errors_only(text: str, max_lines: int = 12) -> str:
     kept: List[str] = []
     for ln in _normalize_lines(text):
-        if re.match(r"^\s*[\-\*\u2022]\s*", ln) or (":" in ln):
+        if re.match(r"^\s*[-*\u2022]\s*", ln) or (":" in ln):
             kept.append(ln)
         if len(kept) >= max_lines:
             break
@@ -747,12 +719,14 @@ def _extract_escalation_line(text: str) -> Optional[str]:
     lines = _normalize_lines(text)
     if not lines:
         return None
+
     start_idx = None
     for i, ln in enumerate(lines):
         low = ln.lower()
         if "escalation" in low or "escalation path" in low or "escalate" in low:
             start_idx = i
             break
+
     block: List[str] = []
     if start_idx is not None:
         for j in range(start_idx, min(len(lines), start_idx + 6)):
@@ -763,9 +737,11 @@ def _extract_escalation_line(text: str) -> Optional[str]:
         block = [ln.strip() for ln in lines if ("->" in ln or "→" in ln)]
     if not block:
         return None
+
     text_block = " ".join(block)
     m = re.search(r"escalation[^:]*:\s*(.+)", text_block, flags=re.IGNORECASE)
     path = m.group(1).strip() if m else None
+
     if not path:
         arrow_lines = [ln for ln in block if ("->" in ln or "→" in ln)]
         if arrow_lines:
@@ -775,6 +751,7 @@ def _extract_escalation_line(text: str) -> Optional[str]:
         path = m2.group(1).strip() if m2 else None
     if not path:
         return None
+
     path = path.replace("->", "→").strip()
     path = re.sub(r"^(?i:escalation\s*path)\s*:\s*", "", path).strip()
     return f"If you want to escalate the issue, follow: {path}"
@@ -789,9 +766,10 @@ def _detect_language_hint(msg: str) -> Optional[str]:
 
 
 def _build_clarifying_message() -> str:
-    return ("It seems the issue isn’t resolved yet. Would you like to share a few details so I can check further, "
-            "or should I raise a ServiceNow ticket for you?")
-
+    return (
+        "It seems the issue isn’t resolved yet. Would you like to share a few details so I can check further, "
+        "or should I raise a ServiceNow ticket for you?"
+    )
 
 
 def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> Tuple[str, str]:
@@ -804,16 +782,14 @@ def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> Tuple[s
     issue = (issue_text or "").strip()
     resolved = (resolved_text or "").strip()
 
-    # Detect if it's a process/SOP query (heuristic)
+    # Detect process/SOP query
     is_process_query = bool(re.search(r"\b(how to|steps|procedure|process)\b", issue.lower()))
 
-    # Avoid "Process Steps – Process Steps" duplication
     if is_process_query:
-        # Remove any leading 'process steps' words from issue to avoid duplication
+        # Avoid "Process Steps – Process Steps" duplication
         cleaned_issue = re.sub(r"^\s*(process\s*steps\s*[-–:]?\s*)", "", issue, flags=re.IGNORECASE).strip()
         short_desc = f"Process Steps – {cleaned_issue or issue}"[:100]
     else:
-        # Error or other query: use the issue as-is
         short_desc = issue[:100]
 
     long_desc = (
@@ -824,6 +800,7 @@ def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> Tuple[s
 
     return short_desc, long_desc
 
+
 def _is_incident_intent(msg_norm: str) -> bool:
     intent_phrases = [
         "create ticket", "create a ticket", "raise ticket", "raise a ticket", "open ticket", "open a ticket",
@@ -843,6 +820,7 @@ def _parse_ticket_status_intent(msg_norm: str) -> Dict[str, Optional[str]]:
     )
     if (not base_has_status) or (base_has_status and not has_ticket_marker and _is_domain_status_context(msg_norm)):
         return {}
+
     patterns = [
         r"(?:incident\s*id|incidentid|ticket\s*number|number)\s*[:=]?\s*(inc\d+)",
         r"(inc\d+)",
@@ -884,21 +862,22 @@ def _find_prereq_section_text(best_doc: str) -> str:
     return ""
 
 
-# ---------------------------------------------------------------------
+# =============================================================================
 # Health
-# ---------------------------------------------------------------------
+# =============================================================================
 @app.get("/")
 async def health_check():
     return {"status": "ok"}
 
 
-# ---------------------------------------------------------------------
+# =============================================================================
 # Chat
-# ---------------------------------------------------------------------
+# =============================================================================
 @app.post("/chat")
 async def chat_with_ai(input_data: ChatInput):
-    global LAST_ISSUE_HINT  # <-- ensure global declared before any assignment/use
+    global LAST_ISSUE_HINT  # ensure global declared before any assignment/use
     assist_followup: Optional[str] = None
+
     try:
         msg_norm = (input_data.user_message or "").lower().strip()
 
@@ -911,6 +890,7 @@ async def chat_with_ai(input_data: ChatInput):
                 "options": [],
                 "debug": {"intent": "continue_conversation"},
             }
+
         if msg_norm in ("no", "no thanks", "nope"):
             return {
                 "bot_response": "No problem. Do you need assistance with any other issue?",
@@ -925,6 +905,7 @@ async def chat_with_ai(input_data: ChatInput):
         is_llm_resolved = _classify_resolution_llm(input_data.user_message)
         if _has_negation_resolved(msg_norm):
             is_llm_resolved = False
+
         if (not _has_negation_resolved(msg_norm)) and (_is_resolution_ack_heuristic(msg_norm) or is_llm_resolved):
             try:
                 # Prefer cached issue hint if frontend didn't pass last_issue
@@ -1015,6 +996,7 @@ async def chat_with_ai(input_data: ChatInput):
                     "sources": [],
                     "debug": {"intent": "status_request_missing_id"},
                 }
+
             try:
                 token = get_valid_token()
                 instance_url = os.getenv("SERVICENOW_INSTANCE_URL")
@@ -1049,14 +1031,13 @@ async def chat_with_ai(input_data: ChatInput):
                 }
             except Exception as e:
                 raise HTTPException(status_code=500, detail=safe_str(e))
-                
-        # --- Try WMS API tools before KB search ---
+
+        # --- Try WMS API tools BEFORE KB search ---
         res = _try_wms_tool(input_data.user_message)
         if res is not None:
-           return res
-
+            return res
 
-        # ------------------ Hybrid KB search ------------------
+        # ---------------- Hybrid KB search ----------------
         kb_results = hybrid_search_knowledge_base(input_data.user_message, top_k=10, alpha=0.6, beta=0.4)
         documents = kb_results.get("documents", [])
         metadatas = kb_results.get("metadatas", [])
@@ -1080,16 +1061,17 @@ async def chat_with_ai(input_data: ChatInput):
 
         selected = items[:max(1, 2)]
         context_raw = "\n\n---\n\n".join([s["text"] for s in selected]) if selected else ""
+
         filtered_text, filt_info = _filter_context_for_query(context_raw, input_data.user_message)
         context = filtered_text
         context_found = bool(context.strip())
 
         best_distance = (min([d for d in distances if d is not None], default=None) if distances else None)
         best_combined = (max([c for c in combined if c is not None], default=None) if combined else None)
-
         detected_intent = kb_results.get("user_intent", "neutral")
         best_doc = kb_results.get("best_doc")
         top_meta = (metadatas or [{}])[0] if metadatas else {}
+
         msg_low = (input_data.user_message or "").lower()
         GENERIC_ERROR_TERMS = ("error", "issue", "problem", "not working", "failed", "failure")
         generic_error_signal = any(t in msg_low for t in GENERIC_ERROR_TERMS)
@@ -1113,12 +1095,12 @@ async def chat_with_ai(input_data: ChatInput):
             detected_intent = "errors"
 
         # heading-aware prereq nudge
-        sec_title = ((top_meta or {}).get("section") or "").strip().lower()
+        sec_title = (top_meta or {}).get("section", "") or ""
+        sec_title_low = sec_title.strip().lower()
         PREREQ_HEADINGS = ("pre-requisites", "prerequisites", "pre requisites", "pre-requirements", "requirements")
-        if detected_intent == "neutral" and any(h in sec_title for h in PREREQ_HEADINGS):
+        if detected_intent == "neutral" and any(h in sec_title_low for h in PREREQ_HEADINGS):
             detected_intent = "prereqs"
 
-        # gating
         def _contains_any(s: str, keywords: tuple) -> bool:
             low = (s or "").lower()
             return any(k in low for k in keywords)
@@ -1134,13 +1116,16 @@ async def chat_with_ai(input_data: ChatInput):
             "confirm", "generate", "update", "receive", "receiving", "error", "issue", "fail", "failed",
             "not working", "locked", "mismatch", "access", "permission", "status",
         )
+
         matched_count = int(filt_info.get("matched_count") or 0)
         filter_mode = (filt_info.get("mode") or "").lower()
         has_any_action_or_error = _contains_any(msg_low, ACTION_OR_ERROR_TERMS)
         mentions_domain = _contains_any(msg_low, DOMAIN_TERMS)
+
         short_query = len((input_data.user_message or "").split()) <= 4
         gate_combined_ok = 0.60 if short_query else 0.55
         combined_ok = (best_combined is not None and best_combined >= gate_combined_ok)
+
         weak_domain_only = (mentions_domain and not has_any_action_or_error)
         low_context_hit = (matched_count < 2 and filter_mode in ("concise", "exact"))
         strong_steps_bypass = True
@@ -1172,7 +1157,7 @@ async def chat_with_ai(input_data: ChatInput):
                 },
             }
 
-        # ---------- Build SOP context ----------
+        # Build SOP/Errors/Prereqs context
         escalation_line: Optional[str] = None
         full_errors: Optional[str] = None
         next_step_applied = False
@@ -1186,13 +1171,11 @@ async def chat_with_ai(input_data: ChatInput):
                 full_steps = get_section_text(best_doc, sec)
             else:
                 full_steps = get_best_steps_section_text(best_doc)
-
             if full_steps:
                 numbered_full = _ensure_numbering(full_steps)
 
                 raw_actions = set((kb_results.get("actions") or []))
                 msg_low2 = (input_data.user_message or "").lower()
-
                 if not raw_actions and ("creation" in msg_low2 or "create" in msg_low2 or "set up" in msg_low2 or "setup" in msg_low2):
                     raw_actions = {"create"}
                 elif not raw_actions and ("update" in msg_low2 or "modify" in msg_low2 or "edit" in msg_low2 or "change" in msg_low2):
@@ -1227,7 +1210,6 @@ async def chat_with_ai(input_data: ChatInput):
                         numbered_full = before
 
                 next_only = _anchor_next_steps(input_data.user_message, numbered_full, max_next=6)
-
                 if next_only is not None:
                     if len(next_only) == 0:
                         context = "You are at the final step of this SOP. No further steps."
@@ -1235,8 +1217,7 @@ async def chat_with_ai(input_data: ChatInput):
                         next_step_info = {"count": 0}
                         context_preformatted = True
                     else:
-                        context = _format_steps_as_numbered(next_only)
-                        context = _dedupe_lines(context)
+                        context = _dedupe_lines(_ensure_numbering("\n".join(next_only)))
                         next_step_applied = True
                         next_step_info = {"count": len(next_only)}
                         context_preformatted = True
@@ -1256,10 +1237,9 @@ async def chat_with_ai(input_data: ChatInput):
                     flags=re.IGNORECASE,
                 ))
             )
-
             if said_not_resolved:
                 return {
-                    "bot_response": "Select an option below.",  # concise helper; avoids duplicate long sentence/dot
+                    "bot_response": "Select an option below.",
                     "status": "OK",
                     "context_found": False,
                     "ask_resolved": False,
@@ -1270,26 +1250,18 @@ async def chat_with_ai(input_data: ChatInput):
                     "top_hits": [],
                     "sources": [],
                     "debug": {
-                       "intent": "errors_not_resolved",
-                       "best_doc": best_doc,
+                        "intent": "errors_not_resolved",
+                        "best_doc": best_doc,
                     },
                 }
 
             full_errors = get_best_errors_section_text(best_doc)
             if full_errors:
                 ctx_err = _extract_errors_only(full_errors, max_lines=30)
-
                 if is_perm_query:
                     context = _filter_permission_lines(ctx_err, max_lines=6)
                 else:
-                    DOMAIN_TERMS = (
-                        "trailer", "shipment", "order", "load", "wave",
-                        "inventory", "putaway", "receiving", "appointment",
-                        "dock", "door", "manifest", "pallet", "container",
-                        "asn", "grn", "pick", "picking",
-                    )
                     mentions_domain_local = any(t in msg_low for t in DOMAIN_TERMS)
-
                     is_specific_error = (len(_detect_error_families(msg_low)) > 0) or mentions_domain_local
                     if is_specific_error:
                         context = _filter_context_for_query(ctx_err, input_data.user_message)[0]
@@ -1297,14 +1269,14 @@ async def chat_with_ai(input_data: ChatInput):
                             all_lines = _normalize_lines(ctx_err)
                             error_bullets = [
                                 ln for ln in all_lines
-                                if re.match(r"^\s*[\-\*\u2022]\s*", ln) or (":" in ln)
+                                if re.match(r"^\s*[-*\u2022]\s*", ln) or (":" in ln)
                             ]
                             context = "\n".join(error_bullets[:6]).strip()
                     else:
                         all_lines = _normalize_lines(ctx_err)
                         error_bullets = [
                             ln for ln in all_lines
-                            if re.match(r"^\s*[\-\*\u2022]\s*", ln) or (":" in ln)
+                            if re.match(r"^\s*[-*\u2022]\s*", ln) or (":" in ln)
                         ]
                         context = "\n".join(error_bullets[:6]).strip()
 
@@ -1321,8 +1293,7 @@ async def chat_with_ai(input_data: ChatInput):
                             numbered_steps = _ensure_numbering(steps_src)
                             next_only = _anchor_next_steps(input_data.user_message, numbered_steps, max_next=6)
                             if next_only is not None and len(next_only) > 0:
-                                context = _format_steps_as_numbered(next_only)
-                                context = _dedupe_lines(context)
+                                context = _dedupe_lines(_ensure_numbering("\n".join(next_only)))
                                 context_preformatted = True
                                 next_step_applied = True
                                 next_step_info = {"count": len(next_only), "source": "errors_domain_override"}
@@ -1336,10 +1307,11 @@ async def chat_with_ai(input_data: ChatInput):
                 context = full_prereqs.strip()
                 context_found = True
 
-        # language hint & paraphrase (errors only)
+        # language hint & paraphrase (errors only when not overridden)
         language_hint = _detect_language_hint(input_data.user_message)
         lang_line = f"Respond in {language_hint}." if language_hint else "Respond in a clear, polite tone."
         use_gemini = (detected_intent == "errors") and not steps_override_applied
+
         enhanced_prompt = f"""You are a helpful support assistant. Rewrite the provided context ONLY into clear, user-friendly guidance.
 - Do not add any information that is not present in the context.
 - If the content is an error/access/permission note, paraphrase it into a helpful sentence users can understand.
@@ -1350,14 +1322,13 @@ async def chat_with_ai(input_data: ChatInput):
 {input_data.user_message}
 ### Output
 Return ONLY the rewritten guidance."""
-        headers = {"Content-Type": "application/json"}
-        payload = {"contents": [{"parts": [{"text": enhanced_prompt}]}]}
         bot_text = ""
         http_code = 0
 
         if use_gemini and GEMINI_API_KEY:
             try:
-                resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=25, verify=GEMINI_SSL_VERIFY)
+                payload = {"contents": [{"role": "user", "parts": [{"text": enhanced_prompt}]}]}
+                resp = _gemini_post(payload, timeout=25)
                 http_code = getattr(resp, "status_code", 0)
                 try:
                     result = resp.json()
@@ -1372,10 +1343,7 @@ Return ONLY the rewritten guidance."""
 
         # deterministic local formatting
         if detected_intent == "steps":
-            if context_preformatted:
-                bot_text = context
-            else:
-                bot_text = _ensure_numbering(context)
+            bot_text = context if context_preformatted else _ensure_numbering(context)
         elif detected_intent == "errors":
             if not (bot_text or "").strip() or http_code == 429:
                 bot_text = context.strip()
@@ -1407,41 +1375,35 @@ Return ONLY the rewritten guidance."""
         short_query = len((input_data.user_message or "").split()) <= 4
         gate_combined_ok = 0.60 if short_query else 0.55
         status = "OK" if (best_combined is not None and best_combined >= gate_combined_ok) else "PARTIAL"
+
         lower = (bot_text or "").lower()
         if ("partial" in lower) or ("may be partial" in lower) or ("closest" in lower) or ("may not fully" in lower):
             status = "PARTIAL"
 
         options = [{"type": "yesno", "title": "Share details or raise a ticket?"}] if status == "PARTIAL" else []
 
-        # ----- Cache last issue hint (used if user later says "issue resolved thanks")
-        # ----- Cache last issue hint (used if user later says "issue resolved thanks")
+        # --- Cache last issue hint (used if user later says "issue resolved thanks")
         try:
-    # Always prefer the user's query as the base
-           base_query = (input_data.user_message or "").strip()
-           if detected_intent == "steps":
-        # For process/SOP: cache the user query — not the heading "Process Steps"
-              LAST_ISSUE_HINT = base_query[:100]
-           elif detected_intent == "errors":
-        # For errors: build "<user query> — <first error line shown>"
-              shown_lines = [ln.strip() for ln in (bot_text or "").splitlines() if ln.strip()]
-
-        # Pick the first bullet/colon line that is NOT escalation
-              top_error_line = ""
-              for ln in shown_lines:
-                  if re.match(r"^\s*[\-\*\u2022]\s*", ln) or (":" in ln):
-                     low = ln.lower()
-                     if "escalation" in low:
-                         continue  # skip escalation sentences
-                     top_error_line = ln
-                     break
-# Strip any trailing escalation phrase from the chosen line (safety)
-              if top_error_line:
-                 top_error_line = re.split(r"\bif you want to escalate\b", top_error_line, flags=re.IGNORECASE)[0].strip()
-              if top_error_line:
-                 LAST_ISSUE_HINT = f"{base_query} — {top_error_line}"
-              else:
-                 LAST_ISSUE_HINT = base_query
-              LAST_ISSUE_HINT = LAST_ISSUE_HINT[:100]    
+            base_query = (input_data.user_message or "").strip()
+            if detected_intent == "steps":
+                LAST_ISSUE_HINT = base_query[:100]
+            elif detected_intent == "errors":
+                shown_lines = [ln.strip() for ln in (bot_text or "").splitlines() if ln.strip()]
+                top_error_line = ""
+                for ln in shown_lines:
+                    if re.match(r"^\s*[-*\u2022]\s*", ln) or (":" in ln):
+                        low = ln.lower()
+                        if "escalation" in low:
+                            continue  # skip escalation sentences
+                        top_error_line = ln
+                        break
+                if top_error_line:
+                    top_error_line = re.split(r"\bif you want to escalate\b", top_error_line, flags=re.IGNORECASE)[0].strip()
+                if top_error_line:
+                    LAST_ISSUE_HINT = f"{base_query} — {top_error_line}"
+                else:
+                    LAST_ISSUE_HINT = base_query
+                LAST_ISSUE_HINT = LAST_ISSUE_HINT[:100]
         except Exception:
             pass
 
@@ -1474,9 +1436,9 @@ Return ONLY the rewritten guidance."""
         raise HTTPException(status_code=500, detail=safe_str(e))
 
 
-# ---------------------------------------------------------------------
+# =============================================================================
 # Ticket description generation
-# ---------------------------------------------------------------------
+# =============================================================================
 @app.post("/generate_ticket_desc")
 async def generate_ticket_desc_ep(input_data: TicketDescInput):
     try:
@@ -1489,20 +1451,23 @@ async def generate_ticket_desc_ep(input_data: TicketDescInput):
             "}\n"
             "Do not include any extra text, comments, or explanations outside the JSON."
         )
-        headers = {"Content-Type": "application/json"}
-        payload = {"contents": [{"parts": [{"text": prompt}]}]}
-        resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=25, verify=GEMINI_SSL_VERIFY)
+        payload = {"contents": [{"role": "user", "parts": [{"text": prompt}]}]}
+        resp = _gemini_post(payload, timeout=25)
+
         try:
             data = resp.json()
         except Exception:
             return {"ShortDescription": "", "DetailedDescription": "", "error": "Gemini returned non-JSON"}
+
         try:
             text = data.get("candidates", [{}])[0].get("content", {}).get("parts", [{}])[0].get("text", "").strip()
         except Exception:
             return {"ShortDescription": "", "DetailedDescription": "", "error": "Gemini parsing failed"}
+
         if text.startswith("```"):
             lines = [ln for ln in text.splitlines() if not ln.strip().startswith("```")]
             text = "\n".join(lines).strip()
+
         try:
             ticket_json = json.loads(text)
             return {
@@ -1511,13 +1476,14 @@ async def generate_ticket_desc_ep(input_data: TicketDescInput):
             }
         except Exception:
             return {"ShortDescription": "", "DetailedDescription": "", "error": "Invalid JSON returned"}
+
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
 
-# ---------------------------------------------------------------------
+# =============================================================================
 # Incident status
-# ---------------------------------------------------------------------
+# =============================================================================
 @app.post("/incident_status")
 async def incident_status(input_data: TicketStatusInput):
     try:
@@ -1525,24 +1491,30 @@ async def incident_status(input_data: TicketStatusInput):
         instance_url = os.getenv("SERVICENOW_INSTANCE_URL")
         if not instance_url:
             raise HTTPException(status_code=500, detail="SERVICENOW_INSTANCE_URL missing")
+
         headers = {"Authorization": f"Bearer {token}", "Accept": "application/json"}
+
         if input_data.sys_id:
             url = f"{instance_url}/api/now/table/incident/{input_data.sys_id}"
             response = requests.get(url, headers=headers, verify=VERIFY_SSL, timeout=25)
             data = response.json()
             result = data.get("result", {}) if response.status_code == 200 else {}
+
         elif input_data.number:
             url = f"{instance_url}/api/now/table/incident?number={input_data.number}"
             response = requests.get(url, headers=headers, verify=VERIFY_SSL, timeout=25)
             data = response.json()
             lst = data.get("result", [])
             result = (lst or [{}])[0] if response.status_code == 200 else {}
+
         else:
             raise HTTPException(status_code=400, detail="Provide IncidentID (number) or sys_id")
+
         state_code = builtins.str(result.get("state", "unknown"))
         state_label = STATE_MAP.get(state_code, state_code)
         short = result.get("short_description", "")
         number = result.get("number", input_data.number or "unknown")
+
         return {
             "bot_response": (
                 f"**Ticket:** {number} \n"
@@ -1554,23 +1526,23 @@ async def incident_status(input_data: TicketStatusInput):
             "persist": True,
             "debug": "Incident status fetched",
         }
+
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
 
-# ---------------------------------------------------------------------
+# =============================================================================
 # Incident creation
-# ---------------------------------------------------------------------
+# =============================================================================
 def _classify_resolution_llm(user_message: str) -> bool:
     if not GEMINI_API_KEY:
         return False
     prompt = f"""Classify if the following user message indicates that the issue is resolved or working now.
 Return only 'true' or 'false'.
 Message: {user_message}"""
-    headers = {"Content-Type": "application/json"}
-    payload = {"contents": [{"parts": [{"text": prompt}]}]}
+    payload = {"contents": [{"role": "user", "parts": [{"text": prompt}]}]}
     try:
-        resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=12, verify=GEMINI_SSL_VERIFY)
+        resp = _gemini_post(payload, timeout=12)
         data = resp.json()
         text = (
             data.get("candidates", [{}])[0]
@@ -1590,18 +1562,21 @@ def _set_incident_resolved(sys_id: str) -> bool:
         if not instance_url:
             print("[SN PATCH resolve] missing SERVICENOW_INSTANCE_URL")
             return False
+
         headers = {
             "Authorization": f"Bearer {token}",
             "Accept": "application/json",
             "Content-Type": "application/json",
         }
         url = f"{instance_url}/api/now/table/incident/{sys_id}"
+
         close_code_val = os.getenv("SERVICENOW_CLOSE_CODE", "Solution provided")
         close_notes_val = os.getenv("SERVICENOW_RESOLUTION_NOTES", "Issue resolved, user confirmed")
         caller_sysid = os.getenv("SERVICENOW_CALLER_SYSID")
         resolved_by_sysid = os.getenv("SERVICENOW_RESOLVED_BY_SYSID")
         assign_group = os.getenv("SERVICENOW_ASSIGNMENT_GROUP_SYSID")
         require_progress = os.getenv("SERVICENOW_REQUIRE_IN_PROGRESS_FIRST", "false").lower() in ("1", "true", "yes")
+
         if require_progress:
             try:
                 resp1 = requests.patch(url, headers=headers, json={"state": "2"}, verify=VERIFY_SSL, timeout=25)
@@ -1612,6 +1587,7 @@ def _set_incident_resolved(sys_id: str) -> bool:
         def clean(d: dict) -> dict:
             return {k: v for k, v in d.items() if v is not None}
 
+        # Attempt A: numeric state
         payload_A = clean({
             "state": "6",
             "close_code": close_code_val,
@@ -1627,6 +1603,7 @@ def _set_incident_resolved(sys_id: str) -> bool:
             return True
         print(f"[SN PATCH resolve A] status={respA.status_code} body={respA.text[:500]}")
 
+        # Attempt B: string state (some instances prefer labels)
         payload_B = clean({
             "state": "Resolved",
             "close_code": close_code_val,
@@ -1642,6 +1619,7 @@ def _set_incident_resolved(sys_id: str) -> bool:
             return True
         print(f"[SN PATCH resolve B] status={respB.status_code} body={respB.text[:500]}")
 
+        # Attempt C: configurable field names
         code_field = os.getenv("SERVICENOW_RESOLUTION_CODE_FIELD", "close_code")
         notes_field = os.getenv("SERVICENOW_RESOLUTION_NOTES_FIELD", "close_notes")
         payload_C = clean({
@@ -1658,7 +1636,9 @@ def _set_incident_resolved(sys_id: str) -> bool:
         if respC.status_code in (200, 204):
             return True
         print(f"[SN PATCH resolve C] status={respC.status_code} body={respC.text[:500]}")
+
         return False
+
     except Exception as e:
         print(f"[SN PATCH resolve] exception={safe_str(e)}")
         return False