Update main.py

main.py

@@ -26,15 +26,18 @@ from services.generate_ticket import get_valid_token, create_incident
 VERIFY_SSL = os.getenv("SERVICENOW_SSL_VERIFY", "true").lower() in ("1", "true", "yes")
 GEMINI_SSL_VERIFY = os.getenv("GEMINI_SSL_VERIFY", "true").lower() in ("1", "true", "yes")
 
+
 def safe_str(e: Any) -> str:
     try:
         return builtins.str(e)
     except Exception:
         return "<error stringify failed>"
 
+
 load_dotenv()
 os.environ["POSTHOG_DISABLED"] = "true"
 
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     try:
@@ -48,6 +51,7 @@ async def lifespan(app: FastAPI):
         print(f"[KB] ingestion failed: {safe_str(e)}")
     yield
 
+
 app = FastAPI(lifespan=lifespan)
 app.include_router(login_router)
 
@@ -60,24 +64,28 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# ------------------ Models ------------------
+# ----------------------- Models -----------------------
 class ChatInput(BaseModel):
     user_message: str
     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",
@@ -93,8 +101,10 @@ GEMINI_URL = (
     f"gemini-2.5-flash-lite:generateContent?key={GEMINI_API_KEY}"
 )
 
-# ------------------ Helpers ------------------
+# ----------------------- Helpers -----------------------
 NUMBERING_STYLE = os.getenv("NUMBERING_STYLE", "digit").lower()  # 'digit' or 'step'
+
+
 def _normalize_lines(text: str) -> List[str]:
     raw = (text or "")
     try:
@@ -111,36 +121,25 @@ def _ensure_numbering(text: str) -> str:
     - Uses circled numerals (①..⑳) so the UI won't treat them as ordered lists.
     - Falls back to 'N)' beyond 20 steps.
     """
-
-    # 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*",
+            r"^\s*(?:[\u2060\u200B]*"
+            r"(?:\d+\s*[.)])"
+            r"|(?:step\s*\d+:?)"
+            r"|[-*\u2022]"
+            r"|[\u2460-\u2473]"
+            r")\s*",
             "",
             (s or "").strip(),
-            flags=re.IGNORECASE
+            flags=re.IGNORECASE,
         )
 
-    # 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):
@@ -156,46 +155,33 @@ def _ensure_numbering(text: str) -> str:
     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)
+    para_clean = re.sub(r"(?:((?<=^)|(?<=\s))\d+[.)]\s+)", "\n\n\n", para)
+    para_clean = re.sub(r"(?:((?<=^)|(?<=\s))[\u2460-\u2473]\s+)", "\n\n\n", para_clean)
+    para_clean = re.sub(r"(?i)\bstep\s*\d+\s*:\s*", "\n\n\n", para_clean)
 
-    # 4) Split → segments
-    segments = [seg.strip() for seg in para_clean.split("|||") if seg.strip()]
+    segments = [seg.strip() for seg in para_clean.split("\n\n\n") if seg.strip()]
     if len(segments) < 2:
         tmp = [ln.strip() for ln in para.splitlines() if ln.strip()]
-        segments = tmp if len(tmp) > 1 else [seg.strip() for seg in re.split(r"(?<=[.!?])\s+|;\s+", para) if seg.strip()]
+        segments = tmp if len(tmp) > 1 else [seg.strip() for seg in re.split(r"(?<=[.!?])\s+|\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:"①",2:"②",3:"③",4:"④",5:"⑤",6:"⑥",7:"⑦",8:"⑧",9:"⑨",10:"⑩",
-        11:"⑪",12:"⑫",13:"⑬",14:"⑭",15:"⑮",16:"⑯",17:"��",18:"⑱",19:"⑲",20:"⑳",
+        1:"\u2460",2:"\u2461",3:"\u2462",4:"\u2463",5:"\u2464",6:"\u2465",7:"\u2466",8:"\u2467",9:"\u2468",10:"\u2469",
+        11:"\u246a",12:"\u246b",13:"\u246c",14:"\u246d",15:"\u246e",16:"\u246f",17:"\u2470",18:"\u2471",19:"\u2472",20:"\u2473",
     }
     out: 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 = _normalize_for_match(query)
     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)
@@ -203,12 +189,12 @@ def _filter_error_lines_by_query(text: str, query: str, max_lines: int = 4) -> s
             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)
+    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():
@@ -217,6 +203,7 @@ def _friendly_permission_reply(raw: str) -> str:
         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"
@@ -224,12 +211,14 @@ 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()
@@ -241,6 +230,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",
@@ -250,6 +240,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"]
     if not any(k in msg_norm for k in status_keywords):
@@ -263,6 +254,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",
@@ -271,6 +263,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",
@@ -278,6 +271,7 @@ def _has_negation_resolved(msg_norm: str) -> bool:
     ]
     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
@@ -299,10 +293,12 @@ Message: {user_message}"""
     except Exception:
         return False
 
-# ------------------ Filters ------------------
+
+# ----------------------- Filters -----------------------
 STRICT_OVERLAP = 3
 MAX_SENTENCES_STRICT = 4
 MAX_SENTENCES_CONCISE = 3
+
 PERM_QUERY_TERMS = [
     "permission", "permissions", "access", "access right", "authorization", "authorisation",
     "role", "role access", "security", "security profile", "privilege", "not allowed", "not authorized", "denied",
@@ -312,16 +308,19 @@ PERM_SYNONYMS = (
     "role", "role mapping", "security profile", "not allowed", "not authorized", "denied", "insufficient"
 )
 
+
 def _normalize_for_match(text: str) -> str:
     t = (text or "").lower()
     t = re.sub(r"[^\w\s]", " ", t)
     t = re.sub(r"\s+", " ", t).strip()
     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]]:
     ctx = (context or "").strip()
     if not ctx or not query:
@@ -349,8 +348,10 @@ def _filter_context_for_query(context: str, query: str) -> Tuple[str, Dict[str,
     kept = sentences[:MAX_SENTENCES_CONCISE]
     return "\n".join(kept).strip(), {'mode': 'concise', 'matched_count': 0, 'all_sentences': len(sentences)}
 
+
 NAV_LINE_REGEX = re.compile(r"(navigate\s+to|login|log in|menu|screen)", re.IGNORECASE)
 
+
 def _extract_navigation_only(text: str, max_lines: int = 6) -> str:
     lines = _normalize_lines(text)
     kept: List[str] = []
@@ -361,12 +362,14 @@ def _extract_navigation_only(text: str, max_lines: int = 6) -> str:
             break
     return "\n".join(kept).strip() if kept else (text or "").strip()
 
+
 ERROR_STARTS = (
     "error", "resolution", "fix", "verify", "check",
     "permission", "access", "authorization", "authorisation",
     "role", "role mapping", "security profile", "escalation", "not allowed", "not authorized", "denied"
 )
 
+
 def _extract_errors_only(text: str, max_lines: int = 12) -> str:
     lines = _normalize_lines(text)
     kept: List[str] = []
@@ -378,6 +381,7 @@ 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:
     lines = _normalize_lines(text)
     kept: List[str] = []
@@ -389,6 +393,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]:
     """
     Extract escalation path from SOP text and return a friendly sentence.
@@ -396,19 +401,15 @@ def _extract_escalation_line(text: str) -> Optional[str]:
     """
     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)):
@@ -416,40 +417,68 @@ 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}"
 
-# ------------------ Health ------------------
+
+# ----------------------- NEW: Operation-aware steps filter -----------------------
+UPDATE_TERMS = ("update", "edit", "modify", "change", "reschedule", "adjust", "move", "save")
+CREATE_TERMS = ("create", "add", "new", "book", "schedule", "set up", "make")
+
+
+def _contains_any(s: str, terms: tuple) -> bool:
+    low = (s or "").lower()
+    return any(t in low for t in terms)
+
+
+def _filter_steps_for_operation(text: str, actions: list, max_lines: int = 12) -> str:
+    """
+    Keep only the lines relevant to the requested operation ('update' or 'create').
+    Falls back to the original text if nothing matches (non-breaking).
+    """
+    lines = _normalize_lines(text)
+    if not lines:
+        return text or ""
+    want_update = "update" in (actions or [])
+    want_create = "create" in (actions or [])
+    kept = []
+    for ln in lines:
+        if want_update and not want_create:
+            if _contains_any(ln, UPDATE_TERMS) and not _contains_any(ln, CREATE_TERMS):
+                kept.append(ln)
+        elif want_create and not want_update:
+            if _contains_any(ln, CREATE_TERMS) and not _contains_any(ln, UPDATE_TERMS):
+                kept.append(ln)
+        else:
+            kept.append(ln)
+        if len(kept) >= max_lines:
+            break
+    return "\n".join(kept).strip() or text
+
+
+# ----------------------- Health -----------------------
 @app.get("/")
 async def health_check():
     return {"status": "ok"}
 
-# ------------------ Chat ------------------
+
+# ----------------------- Chat -----------------------
 @app.post("/chat")
 async def chat_with_ai(input_data: ChatInput):
     try:
@@ -478,6 +507,7 @@ async def chat_with_ai(input_data: ChatInput):
         is_llm_resolved = _classify_resolution_llm(input_data.user_message)
         if _has_negation_resolved(msg_norm):
             is_llm_resolved = False
+
         if (not _has_negation_resolved(msg_norm)) and (_is_resolution_ack_heuristic(msg_norm) or is_llm_resolved):
             try:
                 short_desc, long_desc = _build_tracking_descriptions(input_data.last_issue, input_data.user_message)
@@ -642,49 +672,45 @@ async def chat_with_ai(input_data: ChatInput):
         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 {}
 
-        # 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)
+
         if best_doc:
             if detected_intent == "steps":
                 full_steps = get_best_steps_section_text(best_doc)
                 if not full_steps:
                     sec = (top_meta or {}).get("section")
-                    if sec: full_steps = get_section_text(best_doc, sec)
+                    if sec:
+                        full_steps = get_section_text(best_doc, sec)
                 if full_steps:
-                    context = _ensure_numbering(full_steps)
+                    # NEW: restrict to the requested operation before numbering
+                    op_filtered = _filter_steps_for_operation(
+                        full_steps,
+                        kb_results.get("actions", [])
+                    )
+                    context = _ensure_numbering(op_filtered or 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(),
@@ -699,7 +725,6 @@ async def chat_with_ai(input_data: ChatInput):
                 "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")
@@ -715,7 +740,6 @@ async def chat_with_ai(input_data: ChatInput):
 Return ONLY the rewritten guidance."""
         headers = {"Content-Type": "application/json"}
         payload = {"contents": [{"parts": [{"text": enhanced_prompt}]}]}
-
         bot_text = ""
         http_code = 0
         if use_gemini:
@@ -733,29 +757,24 @@ 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
+            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":"Share details or raise a ticket?"}] if status == "PARTIAL" else []
+
         return {
             "bot_response": bot_text,
             "status": status,
@@ -783,6 +802,7 @@ Return ONLY the rewritten guidance."""
     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()
@@ -796,14 +816,12 @@ 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)
@@ -865,7 +883,8 @@ def _set_incident_resolved(sys_id: str) -> bool:
         print(f"[SN PATCH resolve] exception={safe_str(e)}")
         return False
 
-# ------------------ Incident ------------------
+
+# ----------------------- Incident -----------------------
 @app.post("/incident")
 async def raise_incident(input_data: IncidentInput):
     try:
@@ -890,7 +909,8 @@ async def raise_incident(input_data: IncidentInput):
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
-# ------------------ Ticket description generation ------------------
+
+# ----------------------- Ticket description generation -----------------------
 @app.post("/generate_ticket_desc")
 async def generate_ticket_desc_ep(input_data: TicketDescInput):
     try:
@@ -898,8 +918,8 @@ async def generate_ticket_desc_ep(input_data: TicketDescInput):
             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'
+            '  "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."
         )
@@ -928,7 +948,8 @@ async def generate_ticket_desc_ep(input_data: TicketDescInput):
     except Exception as e:
         raise HTTPException(status_code=500, detail=safe_str(e))
 
-# ------------------ Incident status ------------------
+
+# ----------------------- Incident status -----------------------
 @app.post("/incident_status")
 async def incident_status(input_data: TicketStatusInput):
     try:
@@ -937,7 +958,6 @@ async def incident_status(input_data: TicketStatusInput):
         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)