Update main.py

main.py

@@ -1,4 +1,3 @@
-
 import os
 import json
 import re
@@ -19,7 +18,6 @@ from services.kb_creation import (
     get_section_text,
     get_best_steps_section_text,
     get_best_errors_section_text,
-    get_steps_text_by_action,
 )
 from services.login import router as login_router
 from services.generate_ticket import get_valid_token, create_incident
@@ -51,6 +49,7 @@ async def lifespan(app: FastAPI):
 
 app = FastAPI(lifespan=lifespan)
 app.include_router(login_router)
+
 origins = ["https://chatbotnova-chatbot-frontend.hf.space"]
 app.add_middleware(
     CORSMiddleware,
@@ -60,7 +59,7 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# -------------------- Models --------------------
+# ------------------ Models ------------------
 class ChatInput(BaseModel):
     user_message: str
     prev_status: Optional[str] = None
@@ -93,9 +92,8 @@ GEMINI_URL = (
     f"gemini-2.5-flash-lite:generateContent?key={GEMINI_API_KEY}"
 )
 
-# -------------------- Helpers --------------------
-NUMBERING_STYLE = os.getenv("NUMBERING_STYLE", "digit").lower()
-
+# ------------------ Helpers ------------------
+NUMBERING_STYLE = os.getenv("NUMBERING_STYLE", "digit").lower()  # 'digit' or 'step'
 def _normalize_lines(text: str) -> List[str]:
     raw = (text or "")
     try:
@@ -103,55 +101,204 @@ def _normalize_lines(text: str) -> List[str]:
     except Exception:
         return [raw.strip()] if raw.strip() else []
 
+
 def _ensure_numbering(text: str) -> str:
     """
-    Robust step numbering:
-    - Split by natural delimiters (newline, end punctuation, semicolons, arrows, 'then', bullets).
-    - Strip any existing list markers.
-    - Emit circled numerals ①..⑳ then fallback to N).
+    Render numbered steps robustly:
+    - Handles single-paragraph SOP content that already contains inline markers.
+    - Strips ANY leading marker per segment (classic, bullets, and circled numerals).
+    - Uses circled numerals (①..⑳) so the UI won't treat them as ordered lists.
+    - Falls back to 'N)' beyond 20 steps.
     """
-    t = (text or "").replace("\u2060", "").replace("\u200B", "")
-    parts = re.split(
-        r"(?:\r?\n|\r|\u2028|\u2029)"      # newlines
-        r"|(?<=[.!?])\s+"                  # sentence end
-        r"|;\s+"                           # semicolons
-        r"|(?:\s*→\s*|\s*->\s*)"           # arrows
-        r"|(?:\s*\bthen\b\s*)"             # 'then'
-        r"|(?:^\s*[-*•]\s*)",              # bullets
-        t,
-        flags=re.IGNORECASE,
-    )
-    cleaned: List[str] = []
-    for seg in parts:
-        s = (seg or "").strip()
-        if not s:
-            continue
-        s = re.sub(
-            r"^\s*(?:"
-            r"(?:\d+\s*[.)])|"
-            r"(?i:step\s*\d+:?)|"
-            r"[-*•]|"
-            r"[\u2460-\u2473]"              # ①..⑳
-            r")\s*",
+
+    # 0) Strip hidden chars that can break regexes
+    text = re.sub(r"[\u2060\u200B]", "", text or "")
+
+    # --- Helpers ---
+    def strip_prefix_any(s: str) -> str:
+        """
+        Remove *any* leading list marker:
+          - classic: '1)', '2.', 'Step 3:', bullets '- * •'
+          - circled numerals: ①..⑳ (U+2460..U+2473)
+          - optional hidden chars before them
+        """
+        return re.sub(
+            r"^\s*(?:[\u2060\u200B]*"                # optional zero-width prefix
+            r"(?:\d+\s*[.)]"                         # '1)' '2.' '3 )'
+            r"|(?:step\s*\d+:?)"                     # 'Step 3:' (case-insensitive handled below)
+            r"|[\-\*\u2022]"                         # bullets '-', '*', '•'
+            r"|[\u2460-\u2473]"                      # circled numerals ①..⑳
+            r"))\s*",
             "",
-            s,
+            (s or "").strip(),
+            flags=re.IGNORECASE
         )
-        if s:
-            cleaned.append(s)
-    if not cleaned:
-        return (text or "").strip()
+
+    # 1) Normalize lines
+    lines = [ln.strip() for ln in (text or "").splitlines() if ln and ln.strip()]
+    if not lines:
+        return text or ""
+
+    # 2) Merge dangling numeric-only lines with following text
+    merged: List[str] = []
+    i = 0
+    while i < len(lines):
+        ln = lines[i]
+        if re.fullmatch(r"\d+[.)]?|[\u2460-\u2473]", ln) and (i + 1) < len(lines):
+            merged.append(lines[i + 1].strip())
+            i += 2
+        else:
+            merged.append(ln)
+            i += 1
+
+    para = " ".join(merged).strip()
+    if not para:
+        return ""
+
+    # 3) Neutralize inline markers to a hard delimiter '|||'
+    #    - classic numbers: ' 2) ', ' 3. '
+    #    - circled numerals: ' ② ' etc.
+    para_clean = re.sub(r"(?:(?<=^)|(?<=\s))\d+[.)]\s+", "|||", para)
+    para_clean = re.sub(r"(?:(?<=^)|(?<=\s))[\u2460-\u2473]\s+", "|||", para_clean)
+    para_clean = re.sub(r"(?i)\bstep\s*\d+\s*:\s*", "|||", para_clean)
+
+    # 4) Split → segments
+    segments = [seg.strip() for seg in para_clean.split("|||") 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+|;\s+", para) if seg.strip()]
+
+    # 5) Strip ANY leading marker from each segment (including circled ones)
+    segments = [strip_prefix_any(seg) for seg in segments if seg.strip()]
+
+    # 6) Numbering: circled numerals for 1..20; then 'N)' style
     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",
+        1:"①",2:"②",3:"③",4:"④",5:"⑤",6:"⑥",7:"⑦",8:"⑧",9:"⑨",10:"⑩",
+        11:"⑪",12:"⑫",13:"⑬",14:"⑭",15:"⑮",16:"⑯",17:"⑰",18:"⑱",19:"⑲",20:"⑳",
     }
-    out = []
-    for i, s in enumerate(cleaned, 1):
-        marker = circled.get(i, f"{i})")
-        out.append(f"{marker} {s}")
+    out: List[str] = []
+    for idx, seg in enumerate(segments, start=1):
+        marker = circled.get(idx, f"{idx})")
+        out.append(f"{marker} {seg}")
+
     return "\n".join(out)
 
+
+
+def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 4) -> str:
+    """
+    Keep only error lines that contain key tokens from the user's query.
+    E.g., for 'putaway error', keep lines containing 'putaway' / 'error'.
+    """
+    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:
+    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()
+    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
@@ -171,7 +318,7 @@ def _normalize_for_match(text: str) -> str:
     return t
 
 def _split_sentences(ctx: str) -> List[str]:
-    raw_sents = re.split(r"(?<=[.!?])\s+|\n+|\-\s+|\*\s+", ctx or "")
+    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]
 
 def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str, Any]]:
@@ -242,17 +389,25 @@ def _filter_permission_lines(text: str, max_lines: int = 6) -> str:
     return "\n".join(kept).strip() if kept else (text or "").strip()
 
 def _extract_escalation_line(text: str) -> Optional[str]:
+    """
+    Extract escalation path from SOP text and return a friendly sentence.
+    Prefers the line after 'Escalation Path:' or any arrow chain (-> or →).
+    """
     if not text:
         return None
+
     lines = _normalize_lines(text)
     if not lines:
         return None
+
+    # Locate an escalation heading
     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 = []
     if start_idx is not None:
         for j in range(start_idx, min(len(lines), start_idx + 6)):
@@ -260,39 +415,40 @@ def _extract_escalation_line(text: str) -> Optional[str]:
                 break
             block.append(lines[j].strip())
     else:
+        # Look for any arrows if heading not found
         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:
             path = arrow_lines[0]
+
     if not path:
         m2 = re.search(r"(operator.*?administrator|operator.*)", text_block, flags=re.IGNORECASE)
         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}"
 
-# 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
+    return f"If you want to escalate the issue, follow: {path}"
 
-# -------------------- Health --------------------
+# ------------------ Health ------------------
 @app.get("/")
 async def health_check():
     return {"status": "ok"}
 
-# -------------------- Chat --------------------
+# ------------------ Chat ------------------
 @app.post("/chat")
 async def chat_with_ai(input_data: ChatInput):
     try:
@@ -318,58 +474,11 @@ 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"):
@@ -419,15 +528,7 @@ Message: {user_message}"""
                     "debug": {"intent": "resolved_ack", "exception": True},
                 }
 
-        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)
-
+        # Incident intent
         if _is_incident_intent(msg_norm):
             return {
                 "bot_response": (
@@ -447,11 +548,7 @@ Message: {user_message}"""
             }
 
         # Status intent
-        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)
+        status_intent = _parse_ticket_status_intent(msg_norm)
         if status_intent:
             if status_intent.get("ask_number"):
                 return {
@@ -504,12 +601,28 @@ Message: {user_message}"""
             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": "Share more details or say 'create ticket'.",
+                "options": [{"type":"yesno","title":"Share details or raise 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", [])
         metadatas = kb_results.get("metadatas", [])
         distances = kb_results.get("distances", [])
         combined = kb_results.get("combined_scores", [])
+
         items: List[Dict[str, Any]] = []
         for i, doc in enumerate(documents):
             text = doc.strip() if isinstance(doc, str) else ""
@@ -522,72 +635,55 @@ Message: {user_message}"""
             if score is not None: m["distance"] = score
             if comb is not None: m["combined"] = comb
             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
+        escalation_line = None  # SOP escalation candidate (if found)
         if best_doc:
             if detected_intent == "steps":
-                preferred_actions = kb_results.get("actions", []) or []
-                full_steps = get_steps_text_by_action(best_doc, preferred_actions)
+                full_steps = get_best_steps_section_text(best_doc)
                 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]):
-                        fallback_lines = [ln.strip() for ln in (fallback or "").splitlines() if ln.strip()]
-                        keep = []
-                        for ln in fallback_lines:
-                            low = ln.lower()
-                            is_creation_only = (
-                                ("create" in low or "creation" in low or " add " in low or " new " in low or " book " in low or " schedule " in low)
-                                and not any(x in low for x in ("update", "modify", "change", "edit", "amend", "reschedule", "re-schedule"))
-                            )
-                            if is_creation_only:
-                                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)
+                    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(),
@@ -595,13 +691,14 @@ Message: {user_message}"""
                 "context_found": False,
                 "ask_resolved": False,
                 "suggest_incident": True,
-                "followup": "Share more details (module/screen/error), or say 'create ticket'.",
-                "options": [{"type":"yesno","title":"Provide details or create a ticket?"}],
+                "followup": "Share more details or say 'create ticket'.",
+                "options": [{"type":"yesno","title":"Share details or raise a ticket?"}],
                 "top_hits": [],
                 "sources": [],
                 "debug": {"intent": "errors_no_context"},
             }
 
+        # Build LLM prompt
         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")
@@ -617,6 +714,7 @@ Message: {user_message}"""
 Return ONLY the rewritten guidance."""
         headers = {"Content-Type": "application/json"}
         payload = {"contents": [{"parts": [{"text": enhanced_prompt}]}]}
+
         bot_text = ""
         http_code = 0
         if use_gemini:
@@ -634,23 +732,29 @@ 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:
+                # Fallback to SOP-derived filtered context (no generic)
                 bot_text = context.strip()
+
+            # Append SOP-specific escalation if available; otherwise NO escalation
             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"
         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":"Provide details or create a ticket?"}] if status == "PARTIAL" else []
+
+        options = [{"type":"yesno","title":"Share details or raise a ticket?"}] if status == "PARTIAL" else []
         return {
             "bot_response": bot_text,
             "status": status,
@@ -662,86 +766,22 @@ Return ONLY the rewritten guidance."""
             "top_hits": [],
             "sources": [],
             "debug": {
-                "used_chunks": len((context_raw or "").split("\n\n---\n\n")) if context_raw else 0,
+                "used_chunks": len((context or "").split("\n\n---\n\n")) if context else 0,
                 "best_distance": best_distance,
                 "best_combined": best_combined,
                 "http_status": http_code,
-                "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,
+                "filter_mode": filt_info.get("mode"),
+                "matched_count": filt_info.get("matched_count"),
                 "user_intent": detected_intent,
                 "best_doc": best_doc,
             },
         }
+
     except HTTPException:
         raise
     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()
@@ -755,20 +795,24 @@ def _set_incident_resolved(sys_id: str) -> bool:
             "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)
                 print(f"[SN PATCH progress] status={resp1.status_code} body={resp1.text[:500]}")
             except Exception as e:
                 print(f"[SN PATCH progress] exception={safe_str(e)}")
+
         def clean(d: dict) -> dict:
             return {k: v for k, v in d.items() if v is not None}
+
         payload_A = clean({
             "state": "6",
             "close_code": close_code_val,
@@ -783,6 +827,7 @@ def _set_incident_resolved(sys_id: str) -> bool:
         if respA.status_code in (200, 204):
             return True
         print(f"[SN PATCH resolve A] status={respA.status_code} body={respA.text[:500]}")
+
         payload_B = clean({
             "state": "Resolved",
             "close_code": close_code_val,
@@ -797,6 +842,7 @@ def _set_incident_resolved(sys_id: str) -> bool:
         if respB.status_code in (200, 204):
             return True
         print(f"[SN PATCH resolve B] status={respB.status_code} body={respB.text[:500]}")
+
         code_field = os.getenv("SERVICENOW_RESOLUTION_CODE_FIELD", "close_code")
         notes_field = os.getenv("SERVICENOW_RESOLUTION_NOTES_FIELD", "close_notes")
         payload_C = clean({
@@ -817,3 +863,109 @@ 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))