Update main.py

main.py

@@ -19,7 +19,7 @@ from services.kb_creation import (
     get_section_text,
     get_best_steps_section_text,
     get_best_errors_section_text,
-    get_steps_text_by_action,  # NEW
+    get_steps_text_by_action,
 )
 from services.login import router as login_router
 from services.generate_ticket import get_valid_token, create_incident
@@ -94,7 +94,7 @@ GEMINI_URL = (
 )
 
 # -------------------- Helpers --------------------
-NUMBERING_STYLE = os.getenv("NUMBERING_STYLE", "digit").lower()  # 'digit' or 'step'
+NUMBERING_STYLE = os.getenv("NUMBERING_STYLE", "digit").lower()
 
 def _normalize_lines(text: str) -> List[str]:
     raw = (text or "")
@@ -106,47 +106,40 @@ def _normalize_lines(text: str) -> List[str]:
 def _ensure_numbering(text: str) -> str:
     """
     Robust step numbering:
-    - Split by natural delimiters (newline, end-of-sentence, semicolons, arrows, 'then', simple bullets).
-    - Strip any existing list markers (numbers, 'Step N:', bullets).
-    - Return ①..⑳ then 'N)' beyond 20.
+    - Split by natural delimiters (newline, end punctuation, semicolons, arrows, 'then', bullets).
+    - Strip any existing list markers.
+    - Emit circled numerals ①..⑳ then fallback to N).
     """
     t = (text or "").replace("\u2060", "").replace("\u200B", "")
-
-    # 1) Split to segments by common step delimiters
     parts = re.split(
         r"(?:\r?\n|\r|\u2028|\u2029)"      # newlines
-        r"|(?<=[.!?])\s+"                  # sentence end + space
+        r"|(?<=[.!?])\s+"                  # sentence end
         r"|;\s+"                           # semicolons
         r"|(?:\s*→\s*|\s*->\s*)"           # arrows
         r"|(?:\s*\bthen\b\s*)"             # 'then'
-        r"|(?:^\s*[-*•]\s*)",              # simple bullets
+        r"|(?:^\s*[-*•]\s*)",              # bullets
         t,
-        flags=re.IGNORECASE
+        flags=re.IGNORECASE,
     )
-
-    # 2) Clean segments & drop empties
-    cleaned = []
+    cleaned: List[str] = []
     for seg in parts:
         s = (seg or "").strip()
         if not s:
             continue
-        # Remove ANY leading list marker (1) / 2. / Step 3: / -, *, • / circled numerals
         s = re.sub(
             r"^\s*(?:"
-            r"(?:\d+\s*[.)])|"         # 1) or 2.
-            r"(?i:step\s*\d+:?)|"      # Step 3:
-            r"[-*•]|"                  # bullets
-            r"[\u2460-\u2473]"         # circled numerals
+            r"(?:\d+\s*[.)])|"
+            r"(?i:step\s*\d+:?)|"
+            r"[-*•]|"
+            r"[\u2460-\u2473]"              # ①..⑳
             r")\s*",
             "",
-            s
+            s,
         )
         if s:
             cleaned.append(s)
-
     if not cleaned:
         return (text or "").strip()
-
     circled = {
         1:"\u2460",2:"\u2461",3:"\u2462",4:"\u2463",5:"\u2464",
         6:"\u2465",7:"\u2466",8:"\u2467",9:"\u2468",10:"\u2469",
@@ -159,115 +152,6 @@ def _ensure_numbering(text: str) -> str:
         out.append(f"{marker} {s}")
     return "\n".join(out)
 
-def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 4) -> str:
-    q = _normalize_for_match(query)  # lower + punctuation stripped
-    q_terms = [t for t in q.split() if len(t) > 2]
-    if not q_terms:
-        return text or ""
-    kept: List[str] = []
-    for ln in _normalize_lines(text):
-        ln_norm = _normalize_for_match(ln)
-        if any(t in ln_norm for t in q_terms):
-            kept.append(ln)
-        if len(kept) >= max_lines:
-            break
-    return "\n".join(kept).strip() if kept else (text or "").strip()
-
-def _friendly_permission_reply(raw: str) -> str:
-    line = (raw or "").strip()
-    line = re.sub(r"^\s*[\-\*\u2022]\s*", "", line)
-    if not line:
-        return "It looks like you may not have access for this action. Please verify your WMS role/permission with your supervisor or IT."
-    if "verify role access" in line.lower():
-        return "It looks like you may not have access for this action. Please verify your WMS role/permission with your supervisor or IT."
-    if ("permission" in line.lower()) or ("access" in line.lower()) or ("authorization" in line.lower()):
-        return f"It seems to be an access issue: {line}. Please check your role mapping or request access."
-    return line
-
-def _detect_language_hint(msg: str) -> Optional[str]:
-    if re.search(r"[\u0B80-\u0BFF]", msg or ""):
-        return "Tamil"
-    if re.search(r"[\u0900-\u097F]", msg or ""):
-        return "Hindi"
-    return None
-
-def _build_clarifying_message() -> str:
-    # PATCH: more professional message
-    return (
-        "To assist you better, please share a few more details (module/screen and the exact error), "
-        "or I can create 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()
-    short_desc = issue[:100] if issue else (resolved[:100] or "Issue resolved (user confirmation)")
-    long_desc = (
-        f"User reported: \"{issue}\". "
-        f"User confirmation: \"{resolved}\". "
-        f"Tracking record created automatically by NOVA."
-    ).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",
-        "create incident", "create an incident", "raise incident", "raise an incident", "open incident", "open an incident",
-        "log ticket", "log an incident", "generate ticket", "create snow ticket", "raise snow ticket",
-        "raise service now ticket", "create service now ticket", "raise sr", "open sr",
-    ]
-    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"]
-    if not any(k in msg_norm for k in status_keywords):
-        return {}
-    patterns = [r"(?:incident\s*id|incidentid|ticket\s*number|number)\s*[:=]?\s*(inc\d+)", r"(inc\d+)"]
-    for pat in patterns:
-        m = re.search(pat, msg_norm, flags=re.IGNORECASE)
-        if m:
-            val = m.group(1).strip()
-            if val:
-                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",
-        "it's working", "working now", "works now", "fixed", "sorted",
-        "ok now", "fine now", "all good", "all set", "thanks works", "thank you it works", "back to normal",
-    ]
-    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",
-        "didn't work", "doesn't work", "no change", "not fixed", "still failing", "failed again", "broken", "fail",
-    ]
-    return any(p in msg_norm for p in neg_phrases)
-
-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}]}]}
-    try:
-        resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=12, verify=GEMINI_SSL_VERIFY)
-        data = resp.json()
-        text = (
-            data.get("candidates", [{}])[0]
-            .get("content", {})
-            .get("parts", [{}])[0]
-            .get("text", "")
-        )
-        return "true" in (text or "").strip().lower()
-    except Exception:
-        return False
-
-# -------------------- Filters --------------------
 STRICT_OVERLAP = 3
 MAX_SENTENCES_STRICT = 4
 MAX_SENTENCES_CONCISE = 3
@@ -287,7 +171,6 @@ def _normalize_for_match(text: str) -> str:
     return t
 
 def _split_sentences(ctx: str) -> List[str]:
-    # Split on end-of-sentence, newlines, or simple bullets
     raw_sents = re.split(r"(?<=[.!?])\s+|\n+|\-\s+|\*\s+", ctx or "")
     return [s.strip() for s in raw_sents if s and len(s.strip()) > 2]
 
@@ -396,6 +279,14 @@ 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}"
 
+# Optional: language hint (since you use it later)
+def _detect_language_hint(msg: str) -> Optional[str]:
+    if re.search(r"[\u0B80-\u0BFF]", msg or ""):
+        return "Tamil"
+    if re.search(r"[\u0900-\u097F]", msg or ""):
+        return "Hindi"
+    return None
+
 # -------------------- Health --------------------
 @app.get("/")
 async def health_check():
@@ -427,11 +318,58 @@ async def chat_with_ai(input_data: ChatInput):
             }
 
         # Resolution ack (auto incident + mark Resolved)
+        def _is_resolution_ack_heuristic(msg_norm: str) -> bool:
+            phrases = [
+                "it is resolved", "resolved", "issue resolved", "problem resolved",
+                "it's working", "working now", "works now", "fixed", "sorted",
+                "ok now", "fine now", "all good", "all set", "thanks works", "thank you it works", "back to normal",
+            ]
+            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",
+                "didn't work", "doesn't work", "no change", "not fixed", "still failing", "failed again", "broken", "fail",
+            ]
+            return any(p in msg_norm for p in neg_phrases)
+
+        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}]}]}
+            try:
+                resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=12, verify=GEMINI_SSL_VERIFY)
+                data = resp.json()
+                text = (
+                    data.get("candidates", [{}])[0]
+                    .get("content", {})
+                    .get("parts", [{}])[0]
+                    .get("text", "")
+                )
+                return "true" in (text or "").strip().lower()
+            except Exception:
+                return False
+
         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:
+                def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> Tuple[str, str]:
+                    issue = (issue_text or "").strip()
+                    resolved = (resolved_text or "").strip()
+                    short_desc = issue[:100] if issue else (resolved[:100] or "Issue resolved (user confirmation)")
+                    long_desc = (
+                        f'User reported: "{issue}". '
+                        f'User confirmation: "{resolved}". '
+                        "Tracking record created automatically by NOVA."
+                    ).strip()
+                    return short_desc, long_desc
+
                 short_desc, long_desc = _build_tracking_descriptions(input_data.last_issue, input_data.user_message)
                 result = create_incident(short_desc, long_desc)
                 if isinstance(result, dict) and not result.get("error"):
@@ -481,7 +419,15 @@ async def chat_with_ai(input_data: ChatInput):
                     "debug": {"intent": "resolved_ack", "exception": True},
                 }
 
-        # Incident intent
+        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",
+                "create incident", "create an incident", "raise incident", "raise an incident", "open incident", "open an incident",
+                "log ticket", "log an incident", "generate ticket", "create snow ticket", "raise snow ticket",
+                "raise service now ticket", "create service now ticket", "raise sr", "open sr",
+            ]
+            return any(p in msg_norm for p in intent_phrases)
+
         if _is_incident_intent(msg_norm):
             return {
                 "bot_response": (
@@ -501,7 +447,11 @@ async def chat_with_ai(input_data: ChatInput):
             }
 
         # Status intent
-        status_intent = _parse_ticket_status_intent(msg_norm)
+        status_intent = (lambda m: (
+            {"number": re.search(r"(?:incident\s*id|incidentid|ticket\s*number|number)\s*[:=]?\s*(inc\d+)", m, re.IGNORECASE).group(1).upper()} if re.search(r"(?:incident\s*id|incidentid|ticket\s*number|number)\s*[:=]?\s*(inc\d+)", m, re.IGNORECASE) else (
+            {"number": re.search(r"(inc\d+)", m, re.IGNORECASE).group(1).upper()} if re.search(r"(inc\d+)", m, re.IGNORECASE) else {"number": None, "ask_number": True}
+        )
+        ))(msg_norm)
         if status_intent:
             if status_intent.get("ask_number"):
                 return {
@@ -554,21 +504,6 @@ async def chat_with_ai(input_data: ChatInput):
             except Exception as e:
                 raise HTTPException(status_code=500, detail=safe_str(e))
 
-        # Generic opener
-        if len(msg_norm.split()) <= 2 or any(p in msg_norm for p in ("issue", "problem", "help", "support")):
-            return {
-                "bot_response": _build_clarifying_message(),
-                "status": "NO_KB_MATCH",
-                "context_found": False,
-                "ask_resolved": False,
-                "suggest_incident": True,
-                "followup": "You can provide more context, or say 'create ticket' if you'd like me to open one.",
-                "options": [{"type":"yesno","title":"Provide details or create a ticket?"}],
-                "top_hits": [],
-                "sources": [],
-                "debug": {"intent": "generic_issue"},
-            }
-
         # 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", [])
@@ -589,33 +524,37 @@ async def chat_with_ai(input_data: ChatInput):
             items.append({"text": text, "meta": m})
         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 {}
 
+        # Use raw context for steps; filtered context for others
+        if detected_intent == "steps":
+            context = context_raw
+            filt_info = {"mode": "raw", "matched_count": None}
+        else:
+            filtered_text, filt_info = _filter_context_for_query(context_raw, input_data.user_message)
+            context = filtered_text
+
+        context_found = bool((context or "").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
+
         # Force errors intent for permissions
         is_perm_query = any(t in msg_norm for t in PERM_QUERY_TERMS)
         if is_perm_query:
             detected_intent = "errors"
 
         # Prefer full SOP section when we have the best_doc
-        escalation_line = None  # SOP escalation candidate (if found)
+        escalation_line = None
         if best_doc:
             if detected_intent == "steps":
-                # 1) Prefer action-matched steps first (update/reschedule/edit vs create)
                 preferred_actions = kb_results.get("actions", []) or []
                 full_steps = get_steps_text_by_action(best_doc, preferred_actions)
-
-                # 2) If nothing found, fallback BUT FILTER creation-only when user asked update
                 if not full_steps:
                     fallback = get_best_steps_section_text(best_doc)
                     if preferred_actions and ("update" in [a.lower() for a in preferred_actions]):
-                        # Drop lines that look like pure creation verbs when user asked update
                         fallback_lines = [ln.strip() for ln in (fallback or "").splitlines() if ln.strip()]
                         keep = []
                         for ln in fallback_lines:
@@ -625,37 +564,30 @@ async def chat_with_ai(input_data: ChatInput):
                                 and not any(x in low for x in ("update", "modify", "change", "edit", "amend", "reschedule", "re-schedule"))
                             )
                             if is_creation_only:
-                                continue  # skip creation-only line
+                                continue
                             keep.append(ln)
                         fallback = "\n".join(keep).strip()
                     full_steps = fallback if (fallback and fallback.strip()) else full_steps
-
                     if not full_steps:
                         sec = (top_meta or {}).get("section")
                         if sec:
                             full_steps = get_section_text(best_doc, sec)
-
                 if full_steps:
                     context = _ensure_numbering(full_steps)
 
             elif detected_intent == "errors":
                 full_errors = get_best_errors_section_text(best_doc)
                 if full_errors:
-                    # Extract the error lines from the SOP
                     ctx_err = _extract_errors_only(full_errors, max_lines=12)
-                    # If the query mentions permissions, reduce to permission-only lines
                     if is_perm_query:
                         context = _filter_permission_lines(ctx_err, max_lines=6)
                     else:
-                        # Otherwise, keep only the lines relevant to the user's error words
                         context = _filter_error_lines_by_query(ctx_err, input_data.user_message, max_lines=6)
-                    # Try to pick escalation path from the same SOP
                     escalation_line = _extract_escalation_line(full_errors)
                 lines = _normalize_lines(context)
                 if len(lines) == 1:
                     context = _friendly_permission_reply(lines[0])
 
-        # No context for errors → clarifying + ticket option
         if detected_intent == "errors" and not (context or "").strip():
             return {
                 "bot_response": _build_clarifying_message(),
@@ -670,7 +602,6 @@ async def chat_with_ai(input_data: ChatInput):
                 "debug": {"intent": "errors_no_context"},
             }
 
-        # Build LLM prompt (unchanged flow)
         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")
@@ -685,7 +616,7 @@ async def chat_with_ai(input_data: ChatInput):
 ### Output
 Return ONLY the rewritten guidance."""
         headers = {"Content-Type": "application/json"}
-        payload = {"contents": [{"parts": [{"text": enhanced_prompt}]}]}
+        payload = {"contents": [{"parts": [{"text": enhanced_prompt}]}]]}
         bot_text = ""
         http_code = 0
         if use_gemini:
@@ -703,19 +634,16 @@ Return ONLY the rewritten guidance."""
             except Exception:
                 bot_text, http_code = "", 0
 
-        # Deterministic local formatting
         if detected_intent == "steps":
             bot_text = _ensure_numbering(context)
         elif detected_intent == "errors":
             if not bot_text.strip() or http_code == 429:
                 bot_text = context.strip()
-            # Append SOP-specific escalation if available
             if escalation_line:
                 bot_text = (bot_text or "").rstrip() + "\n\n" + escalation_line
         else:
             bot_text = context
 
-        # Status compute
         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"
@@ -734,12 +662,12 @@ Return ONLY the rewritten guidance."""
             "top_hits": [],
             "sources": [],
             "debug": {
-                "used_chunks": len((context or "").split("\n\n---\n\n")) if context else 0,
+                "used_chunks": len((context_raw or "").split("\n\n---\n\n")) if context_raw else 0,
                 "best_distance": best_distance,
                 "best_combined": best_combined,
                 "http_status": http_code,
-                "filter_mode": filt_info.get("mode"),
-                "matched_count": filt_info.get("matched_count"),
+                "filter_mode": filt_info.get("mode") if isinstance(filt_info, dict) else None,
+                "matched_count": filt_info.get("matched_count") if isinstance(filt_info, dict) else None,
                 "user_intent": detected_intent,
                 "best_doc": best_doc,
             },
@@ -749,6 +677,71 @@ Return ONLY the rewritten guidance."""
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
+# -------------------- Incident --------------------
+@app.post("/incident")
+async def raise_incident(input_data: IncidentInput):
+    try:
+        result = create_incident(input_data.short_description, input_data.description)
+        if isinstance(result, dict) and not result.get("error"):
+            inc_number = result.get("number", "<unknown>")
+            sys_id = result.get("sys_id")
+            resolved_note = ""
+            if bool(input_data.mark_resolved) and sys_id not in ("<unknown>", None):
+                ok = _set_incident_resolved(sys_id)
+                resolved_note = " (marked Resolved)" if ok else " (could not mark Resolved; please update manually)"
+            ticket_text = f"Incident created: {inc_number}{resolved_note}" if inc_number else "Incident created."
+            return {
+                "bot_response": f"✅ {ticket_text}",
+                "debug": "Incident created via ServiceNow",
+                "persist": True,
+                "show_assist_card": True,
+                "followup": "Is there anything else I can assist you with?",
+            }
+        else:
+            raise HTTPException(status_code=500, detail=(result or {}).get("error", "Unknown error"))
+    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:
+        token = get_valid_token()
+        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"
+                f"**Status:** {state_label} \n"
+                f"**Issue description:** {short}"
+            ).replace("\n", " \n"),
+            "followup": "Is there anything else I can assist you with?",
+            "show_assist_card": True,
+            "persist": True,
+            "debug": "Incident status fetched",
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=safe_str(e))
+
 def _set_incident_resolved(sys_id: str) -> bool:
     try:
         token = get_valid_token()
@@ -824,106 +817,3 @@ def _set_incident_resolved(sys_id: str) -> bool:
     except Exception as e:
         print(f"[SN PATCH resolve] exception={safe_str(e)}")
         return False
-
-# -------------------- Incident --------------------
-@app.post("/incident")
-async def raise_incident(input_data: IncidentInput):
-    try:
-        result = create_incident(input_data.short_description, input_data.description)
-        if isinstance(result, dict) and not result.get("error"):
-            inc_number = result.get("number", "<unknown>")
-            sys_id = result.get("sys_id")
-            resolved_note = ""
-            if bool(input_data.mark_resolved) and sys_id not in ("<unknown>", None):
-                ok = _set_incident_resolved(sys_id)
-                resolved_note = " (marked Resolved)" if ok else " (could not mark Resolved; please update manually)"
-            ticket_text = f"Incident created: {inc_number}{resolved_note}" if inc_number else "Incident created."
-            return {
-                "bot_response": f"✅ {ticket_text}",
-                "debug": "Incident created via ServiceNow",
-                "persist": True,
-                "show_assist_card": True,
-                "followup": "Is there anything else I can assist you with?",
-            }
-        else:
-            raise HTTPException(status_code=500, detail=(result or {}).get("error", "Unknown error"))
-    except Exception as e:
-        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:
-        prompt = (
-            f"You are helping generate ServiceNow ticket descriptions based on the issue: {input_data.issue}.\n"
-            "Please return the output strictly in JSON format with the following keys:\n"
-            "{\n"
-            ' "ShortDescription": "A concise summary of the issue (max 100 characters)",\n'
-            ' "DetailedDescription": "A detailed explanation of the issue"\n'
-            "}\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)
-        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 {
-                "ShortDescription": ticket_json.get("ShortDescription", "").strip(),
-                "DetailedDescription": ticket_json.get("DetailedDescription", "").strip(),
-            }
-        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:
-        token = get_valid_token()
-        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"
-                f"**Status:** {state_label} \n"
-                f"**Issue description:** {short}"
-            ).replace("\n", " \n"),
-            "followup": "Is there anything else I can assist you with?",
-            "show_assist_card": True,
-            "persist": True,
-            "debug": "Incident status fetched",
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=safe_str(e))