Update chat_handler.py

chat_handler.py

@@ -1,136 +1,154 @@
 """
-Flare – Chat Handler (start_session & chat)
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Intent → Parametre → API → Humanize akışı
+Flare – Chat Handler (state-machine + header session)
 """
 
 from __future__ import annotations
-
-import json
-from typing import Dict, Optional
-
-from fastapi import APIRouter, HTTPException
+import json, re
+from typing import Dict, List
+from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
-
-from config_provider import ConfigProvider, VersionConfig
-from prompt_builder import build_intent_prompt, build_param_prompt, build_api_humanize_prompt
+from config_provider import ConfigProvider, VersionConfig, IntentConfig, ParameterConfig
+from prompt_builder import (
+    build_detection_prompt, build_param_extract_prompt,
+    build_missing_param_prompt, build_api_humanize_prompt)
+from validation_engine import validate
 from api_executor import call_api
 from session import session_store, Session
 from utils import log
 
-cfg = ConfigProvider.get()
+cfg=ConfigProvider.get()
+router=APIRouter()
 
-router = APIRouter()
+_cancel_words=re.compile(r"\b(vazgeç|iptal|boşver|cancel)\b",re.I)
 
+# -------- helper ----------
+def detect_intent(version: VersionConfig, text: str) -> IntentConfig | None:
+    for it in version.intents:
+        prompt=build_detection_prompt(version.general_prompt,it)
+        if it.name.lower() in text.lower():   #  placeholder: ask_llm(prompt,text,"classification")
+            return it
+    return None
 
-# --------- Body models ----------
+# --------- endpoints -------
 class SessionStartRequest(BaseModel):
-    project_name: str
-
-
+    project_name:str
 class SessionStartResponse(BaseModel):
-    session_id: str
+    session_id:str
 
+@router.post("/start_session",response_model=SessionStartResponse)
+def start_session(body:SessionStartRequest):
+    s=session_store.create_session(body.project_name)
+    return SessionStartResponse(session_id=s.session_id)
 
 class ChatRequest(BaseModel):
-    session_id: str
-    user_input: str
-
-
+    user_input:str
 class ChatResponse(BaseModel):
-    reply: str
-    session: Dict
-
-
-# --------- LLM stub -------------
-def ask_llm(prompt: str, user_input: str = "", mode: str = "text"):
-    log(f"🤖 [LLM-stub] mode={mode} prompt_len={len(prompt)}")
-    if mode == "classification":
-        return ""
-    if mode == "json":
-        return {}
-    return "LLM yanıtı (stub)."
-
-
-# --------- Helpers --------------
-def _get_live_version(project_name: str) -> VersionConfig:
-    proj = next((p for p in cfg.projects if p.name == project_name and p.enabled), None)
-    if proj is None:
-        raise HTTPException(status_code=400, detail="Project not found or disabled")
-    v = max((v for v in proj.versions if v.published), key=lambda x: x.id, default=None)
-    if v is None:
-        raise HTTPException(status_code=400, detail="No published version")
-    return v
-
-
-# --------- Endpoints ------------
-@router.post("/start_session", response_model=SessionStartResponse)
-def start_session(body: SessionStartRequest):
-    session = session_store.create_session(body.project_name)
-    return SessionStartResponse(session_id=session.session_id)
-
-
-@router.post("/chat", response_model=ChatResponse)
-def chat(body: ChatRequest):
-    session: Session | None = session_store.get_session(body.session_id)
-    if session is None:
-        raise HTTPException(status_code=404, detail="Session not found")
-
-    version = _get_live_version(session.project_name)
-    user_input = body.user_input
-    session.add_turn("user", user_input)
-
-    # 1) Intent detection loop
-    intent = None
-    for it in version.intents:
-        prompt = build_intent_prompt(version.general_prompt, it)
-        resp = ask_llm(prompt, user_input, mode="classification")
-        if it.name.lower() in resp.lower():
-            intent = it
-            break
-
-    if intent is None:
-        reply = ask_llm(version.general_prompt, user_input)
-        session.add_turn("assistant", reply)
-        return ChatResponse(reply=reply, session=session.to_dict())
-
-    # 2) Parameter extraction
-    vars_ = session.variables.copy()
-    missing = [p for p in intent.parameters if p.name not in vars_]
-    if missing:
-        prompt = build_param_prompt(version.general_prompt, intent, missing)
-        llm_json = ask_llm(prompt, user_input, mode="json") or {}
-        vars_.update(llm_json)
-
-    still_missing = [p.name for p in intent.parameters if p.required and p.name not in vars_]
-    if still_missing:
-        ask = " ".join(f"{p} değerini söyler misin?" for p in still_missing)
-        reply = ask_llm(version.general_prompt, ask)
-        session.variables = vars_
-        session.awaiting_parameters = still_missing
-        session.add_turn("assistant", reply)
-        return ChatResponse(reply=reply, session=session.to_dict())
-
-    # 3) API call
-    api_cfg = cfg.get_api(intent.action)
-    if api_cfg is None:
-        raise HTTPException(status_code=500, detail="API not configured")
-
-    try:
-        resp = call_api(api_cfg, vars_)
-    except Exception as e:
-        log(f"❌ API error: {e}")
-        reply = intent.fallback_error_prompt or "İşlem sırasında hata oluştu."
-        session.add_turn("assistant", reply)
-        return ChatResponse(reply=reply, session=session.to_dict())
-
-    # 4) Humanize
-    human_prompt = build_api_humanize_prompt(
-        version.general_prompt,
-        api_cfg.response_prompt or "",
-        json.dumps(resp.json(), ensure_ascii=False, indent=2),
-    )
-    reply = ask_llm(human_prompt)
-    session.variables = vars_
-    session.add_turn("assistant", reply)
-    return ChatResponse(reply=reply, session=session.to_dict())
+    reply:str
+    session:Dict
+
+@router.post("/chat",response_model=ChatResponse)
+def chat(req:Request, body:ChatRequest):
+    sid=req.headers.get("X-Session-ID")
+    if not sid: raise HTTPException(400,"X-Session-ID header missing")
+    s=session_store.get_session(sid)
+    if not s: raise HTTPException(404,"Session not found")
+
+    version=_get_live_version(s.project_name)
+    user_text=body.user_input
+    s.add_turn("user",user_text)
+
+    # quick cancel
+    if _cancel_words.search(user_text):
+        s.reset_flow()
+        reply="Elbette, başka bir konuda nasıl yardımcı olabilirim?"
+        s.add_turn("assistant",reply)
+        return ChatResponse(reply=reply,session=s.__dict__)
+
+    # ---- idle state: intent arar
+    if s.state=="idle":
+        intent=detect_intent(version,user_text)
+        if not intent:
+            reply="(LLM-sohbet cevabı)"  # burada ask_llm kullanılacak
+            s.add_turn("assistant",reply)
+            return ChatResponse(reply=reply,session=s.__dict__)
+
+        s.last_intent=intent.name
+        s.state="await_param"
+        s.awaiting_parameters=[p.name for p in intent.parameters]
+        s.variables={}     # yeni intentte öncekileri sıfırla
+
+    # ---- await_param state
+    if s.state=="await_param":
+        intent=next(i for i in version.intents if i.name==s.last_intent)
+        # intent değişti mi?
+        new_int=detect_intent(version,user_text)
+        if new_int and new_int.name!=intent.name:
+            log("🔄 new intent overrides current flow")
+            s.reset_flow()
+            s.last_intent=new_int.name
+            s.state="await_param" if new_int.parameters else "call_api"
+            s.awaiting_parameters=[p.name for p in new_int.parameters]
+            intent=new_int
+
+        # param extraction
+        for p in intent.parameters:
+            if p.name in s.variables: continue
+            if p.name in user_text.lower():    # basit demo extraction
+                val=user_text
+                if not validate(val,p):
+                    reply=p.invalid_prompt or f"{p.caption or p.name} değerini doğrulayamadım."
+                    s.add_turn("assistant",reply)
+                    return ChatResponse(reply=reply,session=s.__dict__)
+                s.variables[p.name]=val
+                s.awaiting_parameters.remove(p.name)
+
+        if s.awaiting_parameters:
+            s.missing_ask_count+=1
+            if s.missing_ask_count>=2:
+                s.reset_flow()
+                reply="Başka bir konuda yardımcı olabilir miyim?"
+                s.add_turn("assistant",reply)
+                return ChatResponse(reply=reply,session=s.__dict__)
+
+            ask=build_missing_param_prompt(s.awaiting_parameters)
+            s.add_turn("assistant",ask)
+            return ChatResponse(reply=ask,session=s.__dict__)
+
+        s.state="call_api"
+
+    # ---- call_api state
+    if s.state=="call_api":
+        intent=next(i for i in version.intents if i.name==s.last_intent)
+        api=cfg.get_api(intent.action)
+        if not api: raise HTTPException(500,"API not found")
+
+        try:
+            resp=call_api(api,s.variables)
+        except Exception as e:
+            log(f"❌ API error {e}")
+            s.reset_flow()
+            reply=intent.fallback_error_prompt or "Hata oluştu."
+            s.add_turn("assistant",reply)
+            return ChatResponse(reply=reply,session=s.__dict__)
+
+        s.api_raw=resp.json()  # debug
+        s.state="humanize"
+
+    # ---- humanize
+    if s.state=="humanize":
+        intent=next(i for i in version.intents if i.name==s.last_intent)
+        api=cfg.get_api(intent.action)
+        human_prompt=build_api_humanize_prompt(
+            version.general_prompt,
+            api.response_prompt or "",
+            json.dumps(s.api_raw,ensure_ascii=False,indent=2)
+        )
+        reply="(LLM-humanize)"   # burada ask_llm kullanılacak
+        s.add_turn("assistant",reply)
+        s.reset_flow()
+        return ChatResponse(reply=reply,session=s.__dict__)
+
+
+def _get_live_version(project_name:str)->VersionConfig:
+    proj=next(p for p in cfg.projects if p.name==project_name and p.enabled)
+    return max((v for v in proj.versions if v.published),key=lambda x:x.id)