Update main.py

main.py

@@ -43,12 +43,14 @@ GEMINI_URL = (
 )
 os.environ["POSTHOG_DISABLED"] = "true"
 
+
 def safe_str(e: Any) -> str:
     try:
         return builtins.str(e)
     except Exception:
         return "<error stringify failed>"
 
+
 # ---------------------------------------------------------------------
 # App / Lifespan
 # ---------------------------------------------------------------------
@@ -65,6 +67,7 @@ async def lifespan(app: FastAPI):
         print(f"[KB] ingestion failed: {safe_str(e)}")
     yield
 
+
 app = FastAPI(lifespan=lifespan)
 app.include_router(login_router)
 
@@ -89,18 +92,22 @@ class ChatInput(BaseModel):
     prev_status: Optional[str] = None
     last_issue: Optional[str] = None
 
+
 class IncidentInput(BaseModel):
     short_description: str
     description: str
     mark_resolved: Optional[bool] = False
 
+
 class TicketDescInput(BaseModel):
     issue: str
 
+
 class TicketStatusInput(BaseModel):
     sys_id: Optional[str] = None
     number: Optional[str] = None
 
+
 STATE_MAP = {
     "1": "New",
     "2": "In Progress",
@@ -118,37 +125,38 @@ DOMAIN_STATUS_TERMS = (
     "shipment", "order", "load", "trailer", "wave",
     "inventory", "putaway", "receiving", "appointment",
     "dock", "door", "manifest", "pallet", "container",
-    "asn", "grn", "pick", "picking"
+    "asn", "grn", "pick", "picking",
 )
 ERROR_FAMILY_SYNS = {
     "NOT_FOUND": (
         "not found", "missing", "does not exist", "doesn't exist",
         "unavailable", "not available", "cannot find", "no such",
-        "not present", "absent"
+        "not present", "absent",
     ),
     "MISMATCH": (
         "mismatch", "doesn't match", "does not match", "variance",
-        "difference", "discrepancy", "not equal"
+        "difference", "discrepancy", "not equal",
     ),
     "LOCKED": (
         "locked", "status locked", "blocked", "read only", "read-only",
-        "frozen", "freeze"
+        "frozen", "freeze",
     ),
     "PERMISSION": (
         "permission", "permissions", "access denied", "not authorized",
         "not authorised", "insufficient privileges", "no access",
-        "authorization", "authorisation"
+        "authorization", "authorisation",
     ),
     "TIMEOUT": (
         "timeout", "timed out", "network", "connection",
-        "unable to connect", "disconnected", "no network"
+        "unable to connect", "disconnected", "no network",
     ),
     "SYNC": (
         "sync", "synchronization", "synchronisation", "replication",
-        "refresh", "out of sync", "stale", "delay", "lag"
+        "refresh", "out of sync", "stale", "delay", "lag",
     ),
 }
 
+
 def _detect_error_families(msg: str) -> list:
     low = (msg or "").lower()
     low_norm = re.sub(r"[^\w\s]", " ", low)
@@ -159,11 +167,13 @@ def _detect_error_families(msg: str) -> list:
             fams.append(fam)
     return fams
 
+
 def _is_domain_status_context(msg_norm: str) -> bool:
     if "status locked" in msg_norm or "locked status" in msg_norm:
         return True
     return any(term in msg_norm for term in DOMAIN_STATUS_TERMS)
 
+
 def _normalize_lines(text: str) -> List[str]:
     raw = (text or "")
     try:
@@ -171,6 +181,7 @@ def _normalize_lines(text: str) -> List[str]:
     except Exception:
         return [raw.strip()] if raw.strip() else []
 
+
 # ---------------- Action filters for steps (create/update/delete) ----------------
 def _filter_numbered_steps_by_actions(numbered_text: str, wanted: set[str], exclude: set[str]) -> str:
     ACTION_SYNONYMS = {
@@ -179,6 +190,7 @@ def _filter_numbered_steps_by_actions(numbered_text: str, wanted: set[str], excl
         "delete": ("delete", "remove"),
         "navigate": ("navigate", "go to", "open"),
     }
+
     def _has_any(line: str, keys: set[str]) -> bool:
         low = (line or "").lower()
         for k in keys:
@@ -198,6 +210,7 @@ def _filter_numbered_steps_by_actions(numbered_text: str, wanted: set[str], excl
             out_lines.append(ln)
     return "\n".join(out_lines).strip() or (numbered_text or "").strip()
 
+
 # ---------------- Small utilities used by next-step & filtering ----------------
 def _dedupe_lines(text: str) -> str:
     seen, out = set(), []
@@ -208,10 +221,12 @@ def _dedupe_lines(text: str) -> str:
             seen.add(key)
     return "\n".join(out).strip()
 
+
 def _split_sentences(block: str) -> list:
     parts = [t.strip() for t in re.split(r"(?<=[.!?])\s+", block or "") if t.strip()]
     return parts if parts else ([block.strip()] if (block or "").strip() else [])
 
+
 # ------------- Numbering + text normalization used elsewhere ----------
 def _ensure_numbering(text: str) -> str:
     text = re.sub(r"[\u2060\u200B]", "", text or "")
@@ -221,9 +236,10 @@ 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)
-    para_clean = re.sub(r"(?:[\u2460-\u2473]\s+)", "\n\n\n", para_clean)
-    para_clean = re.sub(r"(?i)\bstep\s*\d+\s*:\s*", "\n\n\n", para_clean)
+    # Hard breaks at step boundaries
+    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()]
@@ -232,18 +248,21 @@ def _ensure_numbering(text: str) -> str:
     def strip_prefix_any(s: str) -> str:
         return re.sub(
             r"^\s*(?:"
-            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()
+            r"(?:\d+\s*[.\)])|"
+            r"(?i:step\s*\d+:?)|"
+            r"(?:[-*\u2022])|"
+            r"(?:[\u2460-\u2473])"
+            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"
+        16: "\u246f", 17: "\u2470", 18: "\u2471", 19: "\u2472", 20: "\u2473",
     }
     out = []
     for idx, seg in enumerate(clean_segments, start=1):
@@ -251,6 +270,7 @@ def _ensure_numbering(text: str) -> str:
         out.append(f"{marker} {seg}")
     return "\n".join(out)
 
+
 def _norm_text(s: str) -> str:
     s = (s or "").lower()
     s = re.sub(r"[^\w\s]", " ", s)
@@ -269,32 +289,31 @@ def _norm_text(s: str) -> str:
         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
-        )
+        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:
     """Render a list of steps with circled numbers for visual continuity."""
     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"
+        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)
 
+
 # ---------------- Similarity for anchor-based next steps ----------------
 def _similarity(a: str, b: str) -> float:
     a_norm, b_norm = _norm_text(a), _norm_text(b)
@@ -302,35 +321,50 @@ def _similarity(a: str, b: str) -> float:
     inter = len(ta & tb)
     union = len(ta | tb) or 1
     jacc = inter / union
+
     def _bigrams(tokens: list) -> set:
-        return set([" ".join(tokens[i:i+2]) for i in range(len(tokens)-1)]) if len(tokens) > 1 else set()
+        return set([" ".join(tokens[i:i + 2]) for i in range(len(tokens) - 1)]) if len(tokens) > 1 else set()
+
     ab, bb = _bigrams(a_norm.split()), _bigrams(b_norm.split())
     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)
+    return min(1.0, 0.45 * jacc + 0.30 * big + 0.35 * char)
+
 
 def _extract_anchor_from_query(msg: str) -> dict:
+    """
+    Pull the anchor clause out of the user's sentence and note if a follow-up cue exists.
+    """
     raw = (msg or "").strip()
     low = _norm_text(raw)
     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)
+
     parts = [p.strip() for p in re.split(r"[?.,;:\-\n]+", raw) if p.strip()]
     if not parts:
         return {"anchor": raw, "has_followup": has_followup}
+
     last = parts[-1]
     last_low = _norm_text(last)
     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:
+    """
+    Locate the best-matching line (or sentence inside it) for the user's anchor,
+    then return ONLY subsequent steps. Returns None if no strong anchor is found.
+    """
     steps = _split_sop_into_steps(numbered_text)
     if not steps:
         return None
+
     info = _extract_anchor_from_query(user_message)
     anchor = info.get("anchor", "").strip()
     if not anchor:
@@ -360,8 +394,8 @@ def _anchor_next_steps(user_message: str, numbered_text: str, max_next: int = 8)
         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
+        len_ok = (best_score >= 0.40) and (tok_count >= 3)
+        accept = base_ok or len_ok
     if not accept:
         return None
 
@@ -372,6 +406,7 @@ def _anchor_next_steps(user_message: str, numbered_text: str, max_next: int = 8)
     next_steps = steps[start:end]
     return [ln for ln in _dedupe_lines("\n".join(next_steps)).splitlines() if ln.strip()]
 
+
 # ---------------- Context filtering (neutral/errors rendering) ----------------
 def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str, Any]]:
     STRICT_OVERLAP = 3
@@ -410,18 +445,19 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
     if matched_exact:
         kept = matched_exact[:MAX_SENTENCES_STRICT]
         return _dedupe_lines("\n".join(kept).strip()), {
-            'mode': 'exact', 'matched_count': len(kept), 'all_sentences': len(sentences)
+            '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)
+            '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)
+        'mode': 'concise', 'matched_count': 0, 'all_sentences': len(sentences),
     }
 
+
 def _extract_errors_only(text: str, max_lines: int = 12) -> str:
     kept: List[str] = []
     for ln in _normalize_lines(text):
@@ -431,10 +467,11 @@ def _extract_errors_only(text: str, max_lines: int = 12) -> str:
             break
     return "\n".join(kept).strip() if kept else (text or "").strip()
 
+
 def _filter_permission_lines(text: str, max_lines: int = 6) -> str:
     PERM_SYNONYMS = (
         "permission", "permissions", "access", "authorization", "authorisation",
-        "role", "role mapping", "security profile", "not allowed", "not authorized", "denied", "insufficient"
+        "role", "role mapping", "security profile", "not allowed", "not authorized", "denied", "insufficient",
     )
     kept: List[str] = []
     for ln in _normalize_lines(text):
@@ -445,6 +482,7 @@ def _filter_permission_lines(text: str, max_lines: int = 6) -> str:
             break
     return "\n".join(kept).strip() if kept else (text or "").strip()
 
+
 def _extract_escalation_line(text: str) -> Optional[str]:
     if not text:
         return None
@@ -483,6 +521,7 @@ def _extract_escalation_line(text: str) -> Optional[str]:
     path = re.sub(r"^(?i:escalation\s*path)\s*:\s*", "", path).strip()
     return f"If you want to escalate the issue, follow: {path}"
 
+
 def _detect_language_hint(msg: str) -> Optional[str]:
     if re.search(r"[\u0B80-\u0BFF]", msg or ""):  # Tamil
         return "Tamil"
@@ -490,10 +529,12 @@ def _detect_language_hint(msg: str) -> Optional[str]:
         return "Hindi"
     return None
 
+
 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?")
 
+
 def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> Tuple[str, str]:
     issue = (issue_text or "").strip()
     resolved = (resolved_text or "").strip()
@@ -505,6 +546,7 @@ def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> Tuple[s
     ).strip()
     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",
@@ -514,6 +556,7 @@ def _is_incident_intent(msg_norm: str) -> bool:
     ]
     return any(p in msg_norm for p in intent_phrases)
 
+
 def _parse_ticket_status_intent(msg_norm: str) -> Dict[str, Optional[str]]:
     status_keywords = ["status", "ticket status", "incident status", "check status", "check ticket status", "check incident status"]
     base_has_status = any(k in msg_norm for k in status_keywords)
@@ -525,7 +568,7 @@ def _parse_ticket_status_intent(msg_norm: str) -> Dict[str, Optional[str]]:
         return {}
     patterns = [
         r"(?:incident\s*id|incidentid|ticket\s*number|number)\s*[:=]?\s*(inc\d+)",
-        r"(inc\d+)"
+        r"(inc\d+)",
     ]
     for pat in patterns:
         m = re.search(pat, msg_norm, flags=re.IGNORECASE)
@@ -535,6 +578,7 @@ def _parse_ticket_status_intent(msg_norm: str) -> Dict[str, Optional[str]]:
                 return {"number": val.upper() if val.lower().startswith("inc") else val}
     return {"number": None, "ask_number": True}
 
+
 def _is_resolution_ack_heuristic(msg_norm: str) -> bool:
     phrases = [
         "it is resolved", "resolved", "issue resolved", "problem resolved",
@@ -543,6 +587,7 @@ def _is_resolution_ack_heuristic(msg_norm: str) -> bool:
     ]
     return any(p in msg_norm for p in phrases)
 
+
 def _has_negation_resolved(msg_norm: str) -> bool:
     neg_phrases = [
         "not resolved", "issue not resolved", "still not working", "not working",
@@ -550,6 +595,7 @@ def _has_negation_resolved(msg_norm: str) -> bool:
     ]
     return any(p in msg_norm for p in neg_phrases)
 
+
 def _find_prereq_section_text(best_doc: str) -> str:
     variants = [
         "Pre-Requisites", "Prerequisites", "Pre Requisites", "Pre-Requirements", "Requirements",
@@ -560,6 +606,7 @@ def _find_prereq_section_text(best_doc: str) -> str:
             return txt.strip()
     return ""
 
+
 # ---------------------------------------------------------------------
 # Health
 # ---------------------------------------------------------------------
@@ -567,6 +614,7 @@ def _find_prereq_section_text(best_doc: str) -> str:
 async def health_check():
     return {"status": "ok"}
 
+
 # ---------------------------------------------------------------------
 # Chat
 # ---------------------------------------------------------------------
@@ -758,8 +806,10 @@ async def chat_with_ai(input_data: ChatInput):
         generic_error_signal = any(t in msg_low for t in GENERIC_ERROR_TERMS)
 
         # intent nudge for prereqs
-        PREREQ_TERMS = ("pre req", "pre-requisite", "pre-requisites", "prerequisite",
-                        "prerequisites", "pre requirement", "pre-requirements", "requirements")
+        PREREQ_TERMS = (
+            "pre req", "pre-requisite", "pre-requisites", "prerequisite",
+            "prerequisites", "pre requirement", "pre-requirements", "requirements",
+        )
         if detected_intent == "neutral" and any(t in msg_low for t in PREREQ_TERMS):
             detected_intent = "prereqs"
 
@@ -788,14 +838,12 @@ async def chat_with_ai(input_data: ChatInput):
             "trailer", "shipment", "order", "load", "wave",
             "inventory", "putaway", "receiving", "appointment",
             "dock", "door", "manifest", "pallet", "container",
-            "asn", "grn", "pick", "picking"
+            "asn", "grn", "pick", "picking",
         )
         ACTION_OR_ERROR_TERMS = (
-            "how to", "procedure", "perform",
-            "close", "closing", "open", "navigate", "scan", "confirm", "generate", "update",
-            "receive", "receiving",
-            "error", "issue", "fail", "failed", "not working", "locked", "mismatch",
-            "access", "permission", "status"
+            "how to", "procedure", "perform", "close", "closing", "open", "navigate", "scan",
+            "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()
@@ -810,8 +858,8 @@ async def chat_with_ai(input_data: ChatInput):
         strong_error_signal = len(_detect_error_families(msg_low)) > 0
 
         if (weak_domain_only or (low_context_hit and not combined_ok)) \
-           and not strong_steps_bypass \
-           and not (strong_error_signal or generic_error_signal):
+                and not strong_steps_bypass \
+                and not (strong_error_signal or generic_error_signal):
             return {
                 "bot_response": _build_clarifying_message(),
                 "status": "NO_KB_MATCH",
@@ -853,36 +901,46 @@ async def chat_with_ai(input_data: ChatInput):
             if full_steps:
                 numbered_full = _ensure_numbering(full_steps)
 
-                # action filtering (create/update/delete) – only when user clearly asks
+                # --- Section-aware action filtering (avoid over-trimming "update" sections) ---
                 raw_actions = set((kb_results.get("actions") or []))
                 msg_low2 = (input_data.user_message or "").lower()
+
+                # infer action from user text if extractor missed it
                 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"}
+                    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):
-                   raw_actions = {"update"}
+                    raw_actions = {"update"}
                 elif not raw_actions and ("delete" in msg_low2 or "remove" in msg_low2 or "cancel" in msg_low2 or "void" in msg_low2):
-                   raw_actions = {"delete"}
+                    raw_actions = {"delete"}
+
                 sec_title_low = ((top_meta or {}).get("section") or "").strip().lower()
                 section_is_create = any(k in sec_title_low for k in ("create", "creation"))
                 section_is_update = any(k in sec_title_low for k in ("update", "updation"))
                 section_is_delete = any(k in sec_title_low for k in ("delete", "removal", "cancellation"))
+
                 skip_action_filter = (
                     ("create" in raw_actions and section_is_create) or
                     ("update" in raw_actions and section_is_update) or
                     ("delete" in raw_actions and section_is_delete)
-)
+                )
+
                 wanted, exclude = set(), set()
                 if not skip_action_filter:
-                   if "create" in raw_actions and not ({"update", "delete"} & raw_actions):
-                       wanted, exclude = {"create"}, {"update", "delete"}
-                   elif "update" in raw_actions and not ({"create", "delete"} & raw_actions):
-                       wanted, exclude = {"update"}, {"create", "delete"}
-                   elif "delete" in raw_actions and not ({"create", "update"} & raw_actions):
-                       wanted, exclude = {"delete"}, {"create", "update"}
+                    if "create" in raw_actions and not ({"update", "delete"} & raw_actions):
+                        wanted, exclude = {"create"}, {"update", "delete"}
+                    elif "update" in raw_actions and not ({"create", "delete"} & raw_actions):
+                        wanted, exclude = {"update"}, {"create", "delete"}
+                    elif "delete" in raw_actions and not ({"create", "update"} & raw_actions):
+                        wanted, exclude = {"delete"}, {"create", "update"}
+
                 if (wanted or exclude) and not skip_action_filter:
-    numbered_full = _filter_numbered_steps_by_actions(numbered_full, wanted=wanted, exclude=exclude)
+                    before = numbered_full
+                    numbered_full = _filter_numbered_steps_by_actions(numbered_full, wanted=wanted, exclude=exclude)
+                    # safety: if over-trimmed to <=1 line, revert
+                    if len([ln for ln in numbered_full.splitlines() if ln.strip()]) <= 1:
+                        numbered_full = before
 
-                 # --- NEW: keyword-free anchor-based next-step resolver ---
+                # --- Keyword-free anchor-based next-step resolver ---
                 next_only = _anchor_next_steps(input_data.user_message, numbered_full, max_next=6)
 
                 if next_only is not None:
@@ -933,9 +991,6 @@ async def chat_with_ai(input_data: ChatInput):
             if full_prereqs:
                 context = full_prereqs.strip()
                 context_found = True
-        else:
-            # neutral or other intents: keep filtered context (already set as 'context')
-            pass
 
         # language hint & paraphrase (errors only)
         language_hint = _detect_language_hint(input_data.user_message)
@@ -997,7 +1052,7 @@ Return ONLY the rewritten guidance."""
 
         # non-empty guarantee
         if not (bot_text or "").strip():
-            if context.strip():
+            if (context or "").strip():
                 bot_text = context.strip()
             else:
                 bot_text = (
@@ -1042,6 +1097,7 @@ Return ONLY the rewritten guidance."""
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
+
 # ---------------------------------------------------------------------
 # Ticket description generation
 # ---------------------------------------------------------------------
@@ -1082,6 +1138,7 @@ async def generate_ticket_desc_ep(input_data: TicketDescInput):
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
+
 # ---------------------------------------------------------------------
 # Incident status
 # ---------------------------------------------------------------------
@@ -1124,6 +1181,7 @@ async def incident_status(input_data: TicketStatusInput):
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
+
 # ---------------------------------------------------------------------
 # Incident creation
 # ---------------------------------------------------------------------
@@ -1148,6 +1206,7 @@ Message: {user_message}"""
     except Exception:
         return False
 
+
 def _set_incident_resolved(sys_id: str) -> bool:
     try:
         token = get_valid_token()
@@ -1228,6 +1287,7 @@ def _set_incident_resolved(sys_id: str) -> bool:
         print(f"[SN PATCH resolve] exception={safe_str(e)}")
         return False
 
+
 @app.post("/incident")
 async def raise_incident(input_data: IncidentInput):
     try: