Upload 8 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+SOP_7_Appointment_Creation.docx filter=lfs diff=lfs merge=lfs -text

SOP_7_Appointment_Creation.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96ffe2e9ec319c3b9575a814b4bade078d1769bbae9de7c16d5810fbf4c5bff6
+size 2129745

main.py

@@ -0,0 +1,806 @@
+
+import os
+import json
+import re
+import requests
+from typing import Optional, Any, Dict
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from dotenv import load_dotenv
+from datetime import datetime
+
+# KB services (Chroma + sentence-transformers + BM25 hybrid)
+from services.kb_creation import (
+    collection,
+    ingest_documents,
+    hybrid_search_knowledge_base,  # new
+)
+
+# Optional routers/utilities you already have
+from services.login import router as login_router  # login API router
+from services.generate_ticket import get_valid_token, create_incident  # ServiceNow helpers
+
+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")
+
+# ---------------------- Env & App bootstrap ----------------------
+load_dotenv()
+os.environ["POSTHOG_DISABLED"] = "true"  # Disable telemetry if present
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    On startup: populate KB if empty.
+    """
+    try:
+        folder_path = os.path.join(os.getcwd(), "documents")
+        if collection.count() == 0:
+            print("🔎 KB empty. Running ingestion...")
+            ingest_documents(folder_path)  # walks /documents & ingests .docx
+        else:
+            print(f"✅ KB already populated with {collection.count()} entries. Skipping ingestion.")
+    except Exception as e:
+        print(f"⚠️ KB ingestion failed: {e}")
+    yield
+
+
+app = FastAPI(lifespan=lifespan)
+app.include_router(login_router)
+
+# CORS (adjust origins as needed)
+origins = [
+    "http://localhost:5173",
+    "http://localhost:5174",
+    "http://localhost:3000",
+]
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ---------------------- Models ----------------------
+class ChatInput(BaseModel):
+    user_message: str
+    prev_status: Optional[str] = None  # "NO_KB_MATCH" | "PARTIAL" | "OK" | 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  # IncidentID (incident number)
+
+
+# ✅ Human‑readable mapping for ServiceNow incident state codes
+STATE_MAP = {
+    "1": "New",
+    "2": "In Progress",
+    "3": "On Hold",
+    "6": "Resolved",
+    "7": "Closed",
+    "8": "Canceled",
+}
+
+# ---------------------- Gemini setup ----------------------
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+GEMINI_URL = (
+    f"https://generativelanguage.googleapis.com/v1beta/models/"
+    f"gemini-2.5-flash-lite:generateContent?key={GEMINI_API_KEY}"
+)
+
+# ---------------------- Helpers: KB context merge + sanitation ----------------------
+def extract_kb_context(kb_results: Optional[Dict[str, Any]], top_chunks: int = 2) -> Dict[str, Any]:
+    """
+    Merge documents + metadatas + distances.
+    If documents are missing but ids exist, fetch via collection.get (rare).
+    Supports hybrid fields: 'combined_scores' in results.
+    """
+    if not kb_results or not isinstance(kb_results, dict):
+        return {"context": "", "sources": [], "top_hits": [], "context_found": False, "best_score": None, "best_combined": None}
+
+    documents = kb_results.get("documents") or []
+    metadatas = kb_results.get("metadatas") or []
+    distances = kb_results.get("distances") or []
+    ids = kb_results.get("ids") or []
+    combined = kb_results.get("combined_scores") or []
+
+    # Fallback fetch by ids if needed
+    if (not documents) and ids:
+        try:
+            fetched = collection.get(ids=ids, include=['documents', 'metadatas'])
+            documents = fetched.get('documents', []) or []
+            metadatas = fetched.get('metadatas', []) or metadatas
+        except Exception:
+            pass
+
+    items = []
+    for i, doc in enumerate(documents):
+        text = doc.strip() if isinstance(doc, str) else ""
+        if not text:
+            continue
+        meta = metadatas[i] if i < len(metadatas) and isinstance(metadatas[i], dict) else {}
+        score = distances[i] if i < len(distances) else None
+        comb = combined[i] if i < len(combined) else None
+        m = dict(meta)
+        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, top_chunks)]
+    context = "\n\n---\n\n".join([s["text"] for s in selected]) if selected else ""
+    sources = [s["meta"] for s in selected]
+
+    # best (lower distance is better, higher combined is better)
+    best_distance = None
+    if distances:
+        try:
+            best_distance = min([d for d in distances if d is not None])
+        except Exception:
+            best_distance = None
+
+    best_combined = None
+    if combined:
+        try:
+            best_combined = max([c for c in combined if c is not None])
+        except Exception:
+            best_combined = None
+
+    return {
+        "context": context,
+        "sources": sources,
+        "top_hits": [],  # hidden in UI
+        "context_found": bool(selected),
+        "best_score": best_distance,
+        "best_combined": best_combined,
+    }
+
+
+def _strip_any_source_lines(text: str) -> str:
+    lines = text.splitlines()
+    kept = []
+    for ln in lines:
+        if re.match(r"^\s*source\s*:", ln, flags=re.IGNORECASE):
+            continue
+        kept.append(ln)
+    return "\n".join(kept).strip()
+
+
+def _build_clarifying_message() -> str:
+    return (
+        "I couldn’t find matching content in the KB yet. To help me narrow it down, please share:\n\n"
+        "• Module/area (e.g., Picking, Receiving, Trailer Close)\n"
+        "• Exact error message text/code (copy-paste)\n"
+        "• IDs involved (Order#, Load ID, Shipment#, Item#)\n"
+        "• Warehouse/site & environment (prod/test)\n"
+        "• When it started and how many users are impacted\n\n"
+        "Reply with these details and I’ll search again."
+    )
+
+# ---------------------- Intent helpers ----------------------
+def _build_tracking_descriptions(issue_text: str, resolved_text: str) -> tuple[str, str]:
+    """
+    Short: first 100 chars of the ORIGINAL issue text (preferred).
+    Long: clear sentence that includes both original issue and resolved ack.
+    """
+    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 _is_feedback_message(msg_norm: str) -> bool:
+    feedback_phrases = [
+        "issue not resolved", "not resolved", "still not working",
+        "same issue", "no change", "didn't work", "doesn't work",
+        "not fixed", "still failing", "failed again",
+    ]
+    return any(p in msg_norm for p in feedback_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 {}  # not a status intent
+
+    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 = (
+        "Classify if the following user message indicates that the issue is resolved or working now.\n"
+        "Return only 'true' or 'false'.\n\n"
+        f"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", "")
+            .strip()
+            .lower()
+        )
+        return "true" in text
+    except Exception:
+        return False
+
+# ---------------------- Health ----------------------
+@app.get("/")
+async def health_check():
+    return {"status": "ok"}
+
+# ---------------------- Chat endpoint ----------------------
+@app.post("/chat")
+async def chat_with_ai(input_data: ChatInput):
+    """
+    Policy:
+    A) If 'resolved/working' detected → auto-create tracking incident, auto-mark Resolved, and ask if further help needed.
+    B) If user intent is 'create ticket' → offer incident form (Yes/No).
+    C) Ticket status intent → if number missing, ask for it; else return status from ServiceNow.
+    D) Feedback-only → ask details (or offer incident on second try) without KB search.
+    E) Otherwise, use HYBRID search; rewrite answer from KB only; ask resolved if 'OK', or refine if 'PARTIAL'.
+    """
+    try:
+        msg_norm = (input_data.user_message or "").lower().strip()
+
+        # --- Handle Yes/No replies from the UI ---
+        if msg_norm in ("yes", "y", "sure", "ok", "okay"):
+            return {
+                "bot_response": (
+                    "Great! Tell me what you’d like to do next — check another ticket, "
+                    "create an incident, or describe your issue."
+                ),
+                "status": "OK",
+                "followup": "You can say: 'create ticket', 'incident status INC0012345', or describe your problem.",
+                "options": [],
+                "debug": {"intent": "continue_conversation"},
+            }
+
+        if msg_norm in ("no", "no thanks", "nope"):
+            return {
+                "bot_response": "Glad I could help! 👋 If you need anything else later, just let me know.",
+                "status": "OK",
+                "end_chat": True,
+                "followup": None,
+                "options": [],
+                "debug": {"intent": "end_conversation"},
+            }
+
+        # --- (A) Resolution acknowledgement
+        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)
+                result = create_incident(short_desc, long_desc)  # ServiceNow helper
+                if isinstance(result, dict) and not result.get("error"):
+                    inc_number = result.get("number", "<unknown>")
+                    sys_id = result.get("sys_id")
+                    # Auto-mark resolved (state=6) if we have sys_id
+                    resolved_note = ""
+                    if sys_id:
+                        ok = _set_incident_resolved(sys_id)
+                        resolved_note = " (marked Resolved)" if ok else " (could not mark Resolved; please update manually)"
+                    return {
+                        "bot_response": f"✅ Incident created: {inc_number}{resolved_note}",
+                        "status": "OK",
+                        "context_found": False,
+                        "ask_resolved": False,
+                        "suggest_incident": False,
+                        "followup": None,
+                        "top_hits": [],
+                        "sources": [],
+                        "auto_incident": True,
+                        "debug": {"intent": "resolved_ack", "auto_created": True},
+                    }
+                else:
+                    err = (result or {}).get("error", "Unknown error")
+                    return {
+                        "bot_response": f"⚠️ I couldn’t create the tracking incident automatically ({err}). Would you like me to try again?",
+                        "status": "PARTIAL",
+                        "context_found": False,
+                        "ask_resolved": False,
+                        "suggest_incident": True,
+                        "followup": "Shall I create a ticket now?",
+                        "top_hits": [],
+                        "sources": [],
+                        "debug": {"intent": "resolved_ack", "auto_created": False, "error": err},
+                    }
+            except Exception as e:
+                return {
+                    "bot_response": f"⚠️ Something went wrong while creating the tracking incident: {str(e)}",
+                    "status": "PARTIAL",
+                    "context_found": False,
+                    "ask_resolved": False,
+                    "suggest_incident": True,
+                    "followup": "Shall I create a ticket now?",
+                    "top_hits": [],
+                    "sources": [],
+                    "debug": {"intent": "resolved_ack", "exception": True},
+                }
+
+        # --- (B) Incident intent
+        if _is_incident_intent(msg_norm):
+            return {
+                "bot_response": "Okay. Shall I create a ServiceNow incident now?",
+                "status": (input_data.prev_status or "PARTIAL"),
+                "context_found": False,
+                "ask_resolved": False,
+                "suggest_incident": True,
+                "followup": "Shall I create a ticket now?",
+                "top_hits": [],
+                "sources": [],
+                "debug": {"intent": "create_ticket"},
+            }
+
+        # --- (C) Ticket status intent
+        status_intent = _parse_ticket_status_intent(msg_norm)
+        if status_intent:
+            if status_intent.get("ask_number"):
+                return {
+                    "bot_response": "Please share the Incident ID (e.g., INC0012345) to check the status.",
+                    "status": "PARTIAL",
+                    "context_found": False,
+                    "ask_resolved": False,
+                    "suggest_incident": False,
+                    "followup": "Provide the Incident ID and I’ll fetch the status.",
+                    "top_hits": [],
+                    "sources": [],
+                    "debug": {"intent": "status_request_missing_id"},
+                }
+            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"}
+                number = status_intent.get("number")
+                url = f"{instance_url}/api/now/table/incident?number={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 {}
+
+                state_code = str(result.get("state", "unknown"))
+                state_label = STATE_MAP.get(state_code, state_code)
+                short = result.get("short_description", "")
+                num = result.get("number", number or "unknown")
+
+                # ✅ Use bold labels + hard line breaks so lines appear separately in Markdown
+                return {
+                    "bot_response": (
+                        f"**Ticket:** {num}  \n"
+                        f"**Status:** {state_label}  \n"
+                        f"**Issue description:** {short}"
+                    ),
+                    "status": "OK",
+                    "show_assist_card": True,   # <— triggers Yes/No card
+                    "context_found": False,
+                    "ask_resolved": False,
+                    "suggest_incident": False,
+                    "followup": "Is there anything else I can assist you with?",
+                    "top_hits": [],
+                    "sources": [],
+                    "debug": {"intent": "status", "http_status": response.status_code},
+                }
+            except Exception as e:
+                raise HTTPException(status_code=500, detail=str(e))
+
+        # --- (D) Feedback-only messages
+        if _is_feedback_message(msg_norm):
+            second_try = (input_data.prev_status or "").upper() == "NO_KB_MATCH"
+            return {
+                "bot_response": (
+                    "Understood. To refine the steps, please share:\n"
+                    "• Exact error text/code\n"
+                    "• IDs (Order#, Load ID, Shipment#)\n"
+                    "• Site & environment (prod/test)\n"
+                    "• When it started and how many users are impacted"
+                    if not second_try else
+                    "It still looks unresolved after clarification.\n\nWould you like me to raise a ServiceNow incident?"
+                ),
+                "status": "NO_KB_MATCH",
+                "context_found": False,
+                "ask_resolved": False,
+                "suggest_incident": bool(second_try),
+                "followup": ("Please reply with the above details." if not second_try else "Shall I create a ticket now?"),
+                "top_hits": [],
+                "sources": [],
+                "debug": {"feedback_only": True, "second_try": second_try},
+            }
+
+        # --- (E) HYBRID KB search & rewrite ---
+        kb_results = hybrid_search_knowledge_base(input_data.user_message, top_k=10, alpha=0.6, beta=0.4)
+        kb_ctx = extract_kb_context(kb_results, top_chunks=2)
+        context = kb_ctx.get("context", "") or ""
+        context_found = bool(kb_ctx.get("context_found", False))
+        best_distance = kb_ctx.get("best_score")  # lower = better
+        best_combined = kb_ctx.get("best_combined")  # higher = better
+
+        # Dynamic gating based on combined score primarily, distance secondarily
+        short_query = len((input_data.user_message or "").split()) <= 4
+        gate_combined_no_kb = 0.22 if short_query else 0.28  # below this → NO_KB
+        gate_combined_ok = 0.60 if short_query else 0.55     # above this → OK
+        gate_distance_no_kb = 2.0                            # if semantic distance is very high, treat carefully
+
+        if (not context_found or not context.strip()) or (
+            (best_combined is None or best_combined < gate_combined_no_kb)
+            and (best_distance is None or best_distance >= gate_distance_no_kb)
+        ):
+            second_try = (input_data.prev_status or "").upper() == "NO_KB_MATCH"
+            clarify_text = (
+                _build_clarifying_message()
+                if not second_try
+                else "I still don’t find a relevant KB match for this scenario even after clarification.\n\n"
+                "Would you like me to raise a ServiceNow incident?"
+            )
+            return {
+                "bot_response": clarify_text,
+                "status": "NO_KB_MATCH",
+                "context_found": False,
+                "ask_resolved": False,
+                "suggest_incident": bool(second_try),
+                "followup": ("Please reply with the above details." if not second_try else "Shall I create a ticket now?"),
+                "top_hits": [],
+                "sources": [],
+                "debug": {"used_chunks": 0, "second_try": second_try, "best_distance": best_distance, "best_combined": best_combined},
+            }
+
+        # We have KB context → LLM rewrite (KB‑only, no Source lines)
+        threshold_ok = gate_combined_ok  # use combined score as the primary signal
+        enhanced_prompt = (
+            "Rewrite the following knowledge base context into clear, actionable steps for the user's question. "
+            "Use ONLY the provided context; do NOT add information that is not present in it. "
+            "If the context is incomplete, say that the answer may be partial. "
+            "Do NOT include any 'Source:' or citation lines in your output.\n\n"
+            f"### Context\n{context}\n\n"
+            f"### Question\n{input_data.user_message}\n\n"
+            "### Output\n"
+            "- Provide numbered steps or concise bullets.\n"
+            "- Mention any prerequisites or validations only if present in the context.\n"
+            "- If context is insufficient, add a one-line note: 'This may be partial based on available KB.'\n"
+        )
+        headers = {"Content-Type": "application/json"}
+        payload = {"contents": [{"parts": [{"text": enhanced_prompt}]}]}
+        try:
+            resp = requests.post(GEMINI_URL, headers=headers, json=payload, timeout=25, verify=VERIFY_SSL)
+            try:
+                result = resp.json()
+            except Exception:
+                result = {}
+        except Exception:
+            resp = type("RespStub", (), {"status_code": 0})()
+            result = {}
+
+        try:
+            bot_text = (
+                result["candidates"][0]["content"]["parts"][0]["text"]
+                if isinstance(result, dict) else ""
+            )
+        except Exception:
+            bot_text = ""
+
+        if not bot_text.strip():
+            bot_text = context
+
+        bot_text = _strip_any_source_lines(bot_text)
+        status = "OK" if (best_combined is not None and best_combined >= threshold_ok) else "PARTIAL"
+        lower = bot_text.lower()
+        if ("partial" in lower) or ("may be partial" in lower) or ("closest" in lower) or ("may not fully" in lower):
+            status = "PARTIAL"
+
+        ask_resolved = (status == "OK")
+        suggest_incident = False
+        followup = ("Does this match your scenario? I can refine the steps." if status == "PARTIAL" else None)
+
+        return {
+            "bot_response": bot_text,
+            "status": status,
+            "context_found": True,
+            "ask_resolved": ask_resolved,
+            "suggest_incident": suggest_incident,
+            "followup": followup,
+            "top_hits": [],
+            "sources": [],
+            "debug": {
+                "used_chunks": len(context.split("\n\n---\n\n")) if context else 0,
+                "best_distance": best_distance,
+                "best_combined": best_combined,
+                "http_status": getattr(resp, "status_code", 0),
+            },
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ---------------------- Incident endpoints ----------------------
+def _set_incident_resolved(sys_id: str) -> bool:
+    """
+    Robust resolver:
+    A) Try default fields (close_code/close_notes/caller_id) with state=6
+    B) If fails, try state="Resolved"
+    C) If still fails, try custom field names from env (e.g., u_resolution_code/u_resolution_notes)
+    Optional: pre-step to In Progress if SERVICENOW_REQUIRE_IN_PROGRESS_FIRST=true
+    Logs a short diagnostic line on failure so we can see the exact reason.
+    """
+    try:
+        # 1) Get an OAuth token the same way you already do for other ServiceNow calls
+        token = get_valid_token()
+        # 2) Read your instance URL from env
+        instance_url = os.getenv("SERVICENOW_INSTANCE_URL")
+        if not instance_url:
+            print("[SN PATCH resolve] missing SERVICENOW_INSTANCE_URL")
+            return False
+
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+        }
+        url = f"{instance_url}/api/now/table/incident/{sys_id}"
+
+        close_code_val = os.getenv("SERVICENOW_CLOSE_CODE", "Solution provided")
+        close_notes_val = os.getenv("SERVICENOW_RESOLUTION_NOTES", "Issue resolved, user confirmed")
+        caller_sysid = os.getenv("SERVICENOW_CALLER_SYSID")
+        resolved_by_sysid = os.getenv("SERVICENOW_RESOLVED_BY_SYSID")  # optional
+        assign_group = os.getenv("SERVICENOW_ASSIGNMENT_GROUP_SYSID")  # optional
+        require_progress = os.getenv("SERVICENOW_REQUIRE_IN_PROGRESS_FIRST", "false").lower() in ("1", "true", "yes")
+
+        # Optional pre-step: set state=2 (In Progress) if your org enforces transitions
+        if require_progress:
+            try:
+                resp1 = requests.patch(url, headers=headers, json={"state": "2"}, verify=VERIFY_SSL, timeout=25)  # <-- use VERIFY_SSL
+                print(f"[SN PATCH progress] status={resp1.status_code} body={resp1.text[:500]}")
+            except Exception as e:
+                print(f"[SN PATCH progress] exception={str(e)}")
+
+        # Helper to clean payload
+        def clean(d: dict) -> dict:
+            return {k: v for k, v in d.items() if v is not None}
+
+        payload_A = clean({
+            "state": "6",  # numeric Resolved
+            "close_code": close_code_val,  # Resolution code (default field name)
+            "close_notes": close_notes_val,  # Resolution notes (default field name)
+            "caller_id": caller_sysid,  # mandatory in your org
+            "resolved_at": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
+            "work_notes": "Auto-resolve set by NOVA.",
+            "resolved_by": resolved_by_sysid,  # optional if BR requires who resolved
+            "assignment_group": assign_group,  # optional if BR requires a group
+        })
+        respA = requests.patch(url, headers=headers, json=payload_A, verify=VERIFY_SSL, timeout=25)
+        if respA.status_code in (200, 204):
+            return True
+        print(f"[SN PATCH resolve A] status={respA.status_code} body={respA.text[:500]}")
+
+        # ---- B) PATCH with state label (some orgs map differently)
+        payload_B = clean({
+            "state": "Resolved",  # label instead of numeric
+            "close_code": close_code_val,
+            "close_notes": close_notes_val,
+            "caller_id": caller_sysid,
+            "resolved_at": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
+            "work_notes": "Auto-resolve set by NOVA.",
+            "resolved_by": resolved_by_sysid,
+            "assignment_group": assign_group,
+        })
+        respB = requests.patch(url, headers=headers, json=payload_B, verify=VERIFY_SSL, timeout=25)
+        if respB.status_code in (200, 204):
+            return True
+        print(f"[SN PATCH resolve B] status={respB.status_code} body={respB.text[:500]}")
+
+        # ---- C) PATCH using custom field names from env
+        # If your dictionary uses, for example, u_resolution_code/u_resolution_notes
+        code_field = os.getenv("SERVICENOW_RESOLUTION_CODE_FIELD", "close_code")
+        notes_field = os.getenv("SERVICENOW_RESOLUTION_NOTES_FIELD", "close_notes")
+        payload_C = clean({
+            "state": "6",
+            code_field: close_code_val,
+            notes_field: close_notes_val,
+            "caller_id": caller_sysid,
+            "resolved_at": datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
+            "work_notes": "Auto-resolve set by NOVA.",
+            "resolved_by": resolved_by_sysid,
+            "assignment_group": assign_group,
+        })
+        respC = requests.patch(url, headers=headers, json=payload_C, verify=VERIFY_SSL, timeout=25)
+        if respC.status_code in (200, 204):
+            return True
+        print(f"[SN PATCH resolve C] status={respC.status_code} body={respC.text[:500]}")
+
+        # If all attempts failed, return False so the chat shows the soft message
+        return False
+    except Exception as e:
+        print(f"[SN PATCH resolve] exception={str(e)}")
+        return False
+
+
+@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}"
+        else:
+            ticket_text = "Incident created."
+
+        # ✅ Do NOT include follow-up question inside bot_response to avoid duplication in UI.
+        #   The front-end will show a Yes/No assist card after this.
+        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?",
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@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["candidates"][0]["content"]["parts"][0]["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=str(e))
+
+
+@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 = 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")
+
+        # �� Bold labels + hard line breaks so ReactMarkdown renders on separate lines
+        return {
+            "bot_response": (
+                f"**Ticket:** {number} \n"
+                f"**Status:** {state_label} \n"
+                f"**Issue description:** {short}"
+            ).replace("\n", "  \n"),  # ensure hard-breaks
+            "followup": "Is there anything else I can assist you with?",
+            "show_assist_card": True,  # <— show Yes/No card from UI after status
+            "persist": True,
+            "debug": "Incident status fetched",
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))