Update chat_handler.py

chat_handler.py

@@ -1,6 +1,6 @@
 """
-Flare – Chat Handler  (regex-intent, small-talk trim, boş-yanıt fallback)
-========================================================================
+Flare – Chat Handler  (v1.3 · robust trimming + param validation)
+=================================================================
 """
 
 import re, json, uuid, sys, httpx, commentjson
@@ -9,255 +9,171 @@ from typing import Dict, List, Optional
 from fastapi import APIRouter, HTTPException, Header
 from pydantic import BaseModel
 from commentjson import JSONLibraryException
-
 from prompt_builder import build_intent_prompt, build_parameter_prompt, log
 
-
-# ─────────────────────────
-# HELPERS
-# ─────────────────────────
-def _trim_smalltalk(raw: str) -> str:
-    """Keep only the very first greeting sentence; cut everything else."""
-    # intent etiketi öncesini al
-    pos_intent = raw.find("#DETECTED_INTENT")
-    if pos_intent != -1:
-        raw = raw[:pos_intent]
-
-    # model kendi prompt'umuzu eklediyse kes
-    pos_sys = raw.find("⚠️")
-    if pos_sys != -1:
-        raw = raw[:pos_sys]
-
-    # ilk 'assistant' bloğundan sonrası at
-    for marker in ["assistant\n\n", "assistant\n", "assistant"]:
-        idx = raw.lower().find(marker)
-        if 0 <= idx <= 2:
-            raw = raw[idx + len(marker):]
-
-    # resmî selam: Hoş geldiniz
+# ─────────────────────────  HELPERS ───────────────────────── #
+def _trim_response(raw: str) -> str:
+    """
+    Remove everything after the first logical assistant block or intent tag.
+    Also strips trailing 'assistant' artifacts and prompt injections.
+    """
+    # Stop at our own rules if model leaked them
+    for stop in ["#DETECTED_INTENT", "⚠️", "\nassistant", "assistant\n", "assistant"]:
+        idx = raw.find(stop)
+        if idx != -1:
+            raw = raw[:idx]
+    # Normalise selamlama
     raw = re.sub(r"Hoş[\s-]?geldin(iz)?", "Hoş geldiniz", raw, flags=re.IGNORECASE)
     return raw.strip()
 
-
-# ---------------------------------------------------------------------- #
-# CONFIG LOAD
-# ---------------------------------------------------------------------- #
-def load_config(path: str = "service_config.jsonc") -> dict:
-    try:
-        with open(path, encoding="utf-8") as f:
-            cfg = commentjson.load(f)
-        log("✅ service_config.jsonc parsed successfully.")
-        return cfg
-    except (JSONLibraryException, FileNotFoundError) as e:
-        log(f"❌ CONFIG ERROR: {e}")
-        sys.exit(1)
-
-CFG = load_config()
+def _safe_intent_parse(raw: str) -> (str, str):
+    """Extract intent name and extra tail."""
+    m = re.search(r"#DETECTED_INTENT:\s*([A-Za-z0-9_-]+)", raw)
+    if not m:
+        return "", raw
+    name = m.group(1)
+    tail = raw[m.end():]
+    return name, tail
+
+# ─────────────────────────  CONFIG ───────────────────────── #
+CFG = commentjson.load(open("service_config.jsonc", encoding="utf-8"))
 PROJECTS = {p["name"]: p for p in CFG["projects"]}
 APIS     = {a["name"]: a for a in CFG["apis"]}
 SPARK_URL = CFG["config"]["spark_endpoint"].rstrip("/") + "/generate"
 ALLOWED_INTENTS = {"flight-booking", "flight-info", "booking-cancel"}
 
-
-# ---------------------------------------------------------------------- #
-# SESSION
-# ---------------------------------------------------------------------- #
+# ─────────────────────────  SESSION ───────────────────────── #
 class Session:
-    def __init__(self, project_name: str):
+    def __init__(self, project: str):
         self.id = str(uuid.uuid4())
-        self.project = PROJECTS[project_name]
+        self.project = PROJECTS[project]
         self.history: List[Dict[str, str]] = []
-        self.variables: Dict[str, str] = {}
+        self.vars: Dict[str, str] = {}
         self.awaiting: Optional[Dict] = None
-        log(f"🆕 Session {self.id} for {project_name}")
+        log(f"🆕 Session {self.id}")
 
 SESSIONS: Dict[str, Session] = {}
 
-
-# ---------------------------------------------------------------------- #
-# SPARK CLIENT
-# ---------------------------------------------------------------------- #
-async def spark_generate(session: Session,
-                         system_prompt: str,
-                         user_input: str) -> str:
+# ─────────────────────────  SPARK ───────────────────────── #
+async def spark_generate(s: Session, prompt: str, user_msg: str) -> str:
     payload = {
-        "project_name": session.project["name"],
-        "user_input": user_input,
-        "context": session.history[-10:],
-        "system_prompt": system_prompt
+        "project_name": s.project["name"],
+        "user_input": user_msg,
+        "context": s.history[-10:],
+        "system_prompt": prompt
     }
     async with httpx.AsyncClient(timeout=60) as c:
-        r = await c.post(SPARK_URL, json=payload)
+        r = await c.post(SPARK_URL + "/generate", json=payload)
         r.raise_for_status()
         d = r.json()
-        raw = (d.get("assistant") or d.get("model_answer") or d.get("text", ""))
-        log(f"🪄 Spark raw: {raw!r}")
-        return raw.strip()
+        raw = (d.get("assistant") or d.get("model_answer") or d.get("text", "")).strip()
+        log(f"🪄 Spark raw: {raw[:120]!r}")
+        return raw
 
-
-# ---------------------------------------------------------------------- #
-# FASTAPI ROUTER
-# ---------------------------------------------------------------------- #
+# ─────────────────────────  FASTAPI ───────────────────────── #
 router = APIRouter()
+@router.get("/")     # health
+def health(): return {"ok": True}
 
-@router.get("/")
-def health():
-    return {"status": "ok"}
-
-class StartSessionRequest(BaseModel):
-    project_name: str
-class ChatBody(BaseModel):
-    user_input: str
-class ChatResponse(BaseModel):
-    session_id: str
-    answer: str
+class Start(BaseModel): project_name: str
+class Body(BaseModel):  user_input: str
+class Resp(BaseModel):  session_id: str; answer: str
 
-
-# ---------------------------------------------------------------------- #
-# ENDPOINTS
-# ---------------------------------------------------------------------- #
-@router.post("/start_session", response_model=ChatResponse)
-async def start_session(req: StartSessionRequest):
+@router.post("/start_session", response_model=Resp)
+async def start_session(req: Start):
     if req.project_name not in PROJECTS:
-        raise HTTPException(404, "Unknown project")
+        raise HTTPException(404, "project")
     s = Session(req.project_name)
     SESSIONS[s.id] = s
-    return ChatResponse(session_id=s.id,
-                        answer="Hoş geldiniz! Size nasıl yardımcı olabilirim?")
+    greet = "Hoş geldiniz! Size nasıl yardımcı olabilirim?"
+    return Resp(session_id=s.id, answer=greet)
 
-@router.post("/chat", response_model=ChatResponse)
-async def chat(body: ChatBody, x_session_id: str = Header(...)):
+@router.post("/chat", response_model=Resp)
+async def chat(body: Body, x_session_id: str = Header(...)):
     if x_session_id not in SESSIONS:
-        raise HTTPException(404, "Invalid session")
-
+        raise HTTPException(404, "session")
     s = SESSIONS[x_session_id]
-    user_msg = body.user_input.strip()
-    s.history.append({"role": "user", "content": user_msg})
+    user = body.user_input.strip()
+    s.history.append({"role": "user", "content": user})
 
-    # follow-up?
+    # ---------- follow-up ----------
     if s.awaiting:
-        answer = await _followup(s, user_msg)
-        s.history.append({"role": "assistant", "content": answer})
-        return ChatResponse(session_id=s.id, answer=answer)
+        ans = await _followup(s, user)
+        s.history.append({"role": "assistant", "content": ans})
+        return Resp(session_id=s.id, answer=ans)
 
-    # intent detect
-    gen_prompt  = s.project["versions"][0]["general_prompt"]
-    intents_cfg = s.project["versions"][0]["intents"]
-    intent_raw  = await spark_generate(
-        s,
-        build_intent_prompt(gen_prompt, s.history, user_msg, intents_cfg),
-        user_msg
-    )
+    # ---------- intent detect ----------
+    p = build_intent_prompt(
+        s.project["versions"][0]["general_prompt"],
+        s.history, user, s.project["versions"][0]["intents"])
+    raw = await spark_generate(s, p, user)
 
-    # boş çıktıyı yakala
-    if intent_raw.strip() == "":
+    if raw == "":
         fallback = "Üzgünüm, mesajınızı anlayamadım. Lütfen tekrar dener misiniz?"
         s.history.append({"role": "assistant", "content": fallback})
-        return ChatResponse(session_id=s.id, answer=fallback)
+        return Resp(session_id=s.id, answer=fallback)
 
-    # küçük selamlaşma yolu
-    if not intent_raw.startswith("#DETECTED_INTENT:"):
-        clean = _trim_smalltalk(intent_raw)
+    # small-talk yolu
+    if not raw.startswith("#DETECTED_INTENT"):
+        clean = _trim_response(raw)
         s.history.append({"role": "assistant", "content": clean})
-        return ChatResponse(session_id=s.id, answer=clean)
-
-    # regex ile intent + extras ayır
-    m = re.search(r"#DETECTED_INTENT:\s*([A-Za-z0-9_-]+)", intent_raw)
-    intent_name = m.group(1) if m else ""
-    extras = intent_raw[m.end():].strip() if m else ""
+        return Resp(session_id=s.id, answer=clean)
 
-    # kısa mesaj guard
-    if len(user_msg.split()) < 3 or intent_name not in ALLOWED_INTENTS:
-        clean = _trim_smalltalk(extras or intent_raw)
+    intent, tail = _safe_intent_parse(raw)
+    if intent not in ALLOWED_INTENTS or len(user.split()) < 3:
+        clean = _trim_response(tail)
         s.history.append({"role": "assistant", "content": clean})
-        return ChatResponse(session_id=s.id, answer=clean)
+        return Resp(session_id=s.id, answer=clean)
 
-    intent_cfg = _find_intent(s.project, intent_name)
-    if not intent_cfg:
+    cfg = _find_intent(s, intent)
+    if not cfg:
         err = "Üzgünüm, anlayamadım."
         s.history.append({"role": "assistant", "content": err})
-        return ChatResponse(session_id=s.id, answer=err)
+        return Resp(session_id=s.id, answer=err)
 
-    answer = await _handle_intent(s, intent_cfg, user_msg)
+    answer = await _handle_intent(s, cfg, user)
     s.history.append({"role": "assistant", "content": answer})
-    return ChatResponse(session_id=s.id, answer=answer)
+    return Resp(session_id=s.id, answer=answer)
 
+# ──────────────────  INTENT / PARAM / API HELPERS  ────────────────── #
+def _find_intent(s, name): return next((i for i in s.project["versions"][0]["intents"] if i["name"] == name), None)
+def _missing(s, cfg):      return [p["name"] for p in cfg["parameters"] if p["variable_name"] not in s.vars]
 
-# ---------------------------------------------------------------------- #
-# HELPER FUNCS  (değişmedi)
-# ---------------------------------------------------------------------- #
-def _find_intent(project, name_):
-    return next((i for i in project["versions"][0]["intents"] if i["name"] == name_), None)
-
-def _missing(s, intent_cfg):
-    return [p["name"] for p in intent_cfg["parameters"] if p["variable_name"] not in s.variables]
-
-async def _handle_intent(s, intent_cfg, user_msg):
-    missing = _missing(s, intent_cfg)
+async def _handle_intent(s, cfg, user):
+    missing = _missing(s, cfg)
     if missing:
-        p_prompt = build_parameter_prompt(intent_cfg, missing, user_msg, s.history)
-        p_raw = await spark_generate(s, p_prompt, user_msg)
-        if p_raw.startswith("#PARAMETERS:") and not _process_params(s, intent_cfg, p_raw):
-            missing = _missing(s, intent_cfg)
+        prmpt = build_parameter_prompt(cfg, missing, user, s.history)
+        raw   = await spark_generate(s, prmpt, user)
+        if raw.startswith("#PARAMETERS:") and not _proc_params(s, cfg, raw):
+            missing = _missing(s, cfg)
 
     if missing:
-        s.awaiting = {"intent": intent_cfg, "missing": missing}
-        cap = next(p for p in intent_cfg["parameters"] if p["name"] == missing[0])["caption"]
+        s.awaiting = {"intent": cfg, "missing": missing}
+        cap = next(p for p in cfg["parameters"] if p["name"] == missing[0])["caption"]
         return f"{cap} nedir?"
-
     s.awaiting = None
-    return await _call_api(s, intent_cfg)
+    return await _call_api(s, cfg)
 
-async def _followup(s, user_msg):
-    intent_cfg = s.awaiting["intent"]
-    missing    = s.awaiting["missing"]
-    p_prompt   = build_parameter_prompt(intent_cfg, missing, user_msg, s.history)
-    p_raw      = await spark_generate(s, p_prompt, user_msg)
-    if not p_raw.startswith("#PARAMETERS:") or _process_params(s, intent_cfg, p_raw):
+async def _followup(s, user):
+    cfg = s.awaiting["intent"]; miss = s.awaiting["missing"]
+    prmpt = build_parameter_prompt(cfg, miss, user, s.history)
+    raw   = await spark_generate(s, prmpt, user)
+    if not raw.startswith("#PARAMETERS:") or _proc_params(s, cfg, raw):
         return "Üzgünüm, anlayamadım."
-    missing = _missing(s, intent_cfg)
-    if missing:
-        s.awaiting["missing"] = missing
-        cap = next(p for p in intent_cfg["parameters"]
-                   if p["name"] == missing[0])["caption"]
+    miss = _missing(s, cfg)
+    if miss:
+        s.awaiting["missing"] = miss
+        cap = next(p for p in cfg["parameters"] if p["name"] == miss[0])["caption"]
         return f"{cap} nedir?"
     s.awaiting = None
-    return await _call_api(s, intent_cfg)
-
-def _process_params(s, intent_cfg, raw):
-    try:
-        data = json.loads(raw[len("#PARAMETERS:"):])
-    except json.JSONDecodeError:
-        return True
-    for pair in data.get("extracted", []):
-        p_cfg = next(p for p in intent_cfg["parameters"] if p["name"] == pair["name"])
-        if not _valid(p_cfg, pair["value"]):
+    return await _call_api(s, cfg)
+
+def _proc_params(s, cfg, raw):
+    try: d = json.loads(raw[len("#PARAMETERS:"):])
+    except: return True
+    for pr in d.get("extracted", []):
+        pcfg = next(p for p in cfg["parameters"] if p["name"] == pr["name"])
+        if not re.fullmatch(pcfg.get("validation_regex", ".*"), pr["value"]):
             return True
-        s.variables[p_cfg["variable_name"]] = pair["value"]
-    return False
-
-def _valid(p_cfg, val):
-    rx = p_cfg.get("validation_regex")
-    return re.match(rx, val) is not None if rx else True
-
-async def _call_api(s, intent_cfg):
-    api = APIS[intent_cfg["action"]]
-    token = "testtoken"
-    headers = {k: v.replace("{{token}}", token) for k, v in api["headers"].items()}
-    body = json.loads(json.dumps(api["body_template"]))
-    for k, v in body.items():
-        if isinstance(v, str) and v.startswith("{{") and v.endswith("}}"):
-            body[k] = s.variables.get(v[2:-2], "")
-    try:
-        async with httpx.AsyncClient(timeout=api["timeout_seconds"]) as c:
-            r = await c.request(api["method"], api["url"], headers=headers, json=body)
-            r.raise_for_status()
-            api_json = r.json()
-    except Exception:
-        return intent_cfg["fallback_error_prompt"]
-
-    sum_prompt = api["response_prompt"].replace("{{api_response}}", json.dumps(api_json, ensure_ascii=False))
-    summary    = await spark_generate(s, sum_prompt, "")
-    if summary.strip() == "":
-        summary = f"İşlem sonucu: {json.dumps(api_json, ensure_ascii=False)}"
-    return summary
+        s.vars[pcfg["variable_name"]] = pr["value"]
+    return Fals