Update chat_handler.py

chat_handler.py

@@ -1,154 +1,244 @@
 """
-Flare – Chat Handler (state-machine + header session)
+Flare – Chat Handler  (v2)
+==========================
+• /start_session   • /chat
+Intent tespiti, parametre çıkarımı, regex doğrulama, session değişkeni,
+backend API çağrısı ve cevap özetleme.
 """
 
-from __future__ import annotations
-import json, re
-from typing import Dict, List
-from fastapi import APIRouter, HTTPException, Request
+import re
+import json
+import uuid
+import httpx
+import commentjson
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-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()
-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
 
-# --------- endpoints -------
-class SessionStartRequest(BaseModel):
-    project_name:str
-class SessionStartResponse(BaseModel):
-    session_id:str
+from prompt_builder import build_intent_prompt, build_parameter_prompt, log
+
+# ----------------------------------------------------------------------------
+# CONFIG LOAD (service_config.jsonc)
+# ----------------------------------------------------------------------------
+with open("service_config.jsonc", "r", encoding="utf-8") as f:
+    CFG = commentjson.load(f)
+
+PROJECTS = {p["name"]: p for p in CFG["projects"]}
+APIS     = {a["name"]: a for a in CFG["apis"]}
+
+
+# ----------------------------------------------------------------------------
+# SESSION OBJECT
+# ----------------------------------------------------------------------------
+class Session:
+    def __init__(self, project_name: str):
+        self.id = str(uuid.uuid4())
+        self.project = PROJECTS[project_name]
+        self.history: List[Dict[str, str]] = []
+        self.variables: Dict[str, str] = {}       # variable_name -> value
+        self.awaiting: Optional[Dict] = None      # {"intent":..., "missing":[...]}
+        log(f"🆕 Session {self.id} for {project_name}")
+
+
+SESSIONS: Dict[str, Session] = {}
+
 
-@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)
+# ----------------------------------------------------------------------------
+# SPARK LLM WRAPPER  (basit HTTP JSON)
+# ----------------------------------------------------------------------------
+async def spark_generate(prompt: str) -> str:
+    url = CFG["config"]["spark_endpoint"]
+    async with httpx.AsyncClient(timeout=60) as c:
+        r = await c.post(url, json={"prompt": prompt})
+        r.raise_for_status()
+        return r.json()["text"]
+
+
+# ----------------------------------------------------------------------------
+# FASTAPI APP
+# ----------------------------------------------------------------------------
+app = FastAPI()
+
+@app.get("/")
+def health():
+    return {"status": "ok"}
+
+
+# ----------------------------------------------------------------------------
+# SCHEMAS
+# ----------------------------------------------------------------------------
+class StartSessionRequest(BaseModel):
+    project_name: str
 
 class ChatRequest(BaseModel):
-    user_input:str
+    session_id: str
+    user_input: str
+
 class ChatResponse(BaseModel):
-    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)
+    session_id: str
+    answer: str
+
+
+# ----------------------------------------------------------------------------
+# ENDPOINTS
+# ----------------------------------------------------------------------------
+@app.post("/start_session", response_model=ChatResponse)
+async def start_session(req: StartSessionRequest):
+    if req.project_name not in PROJECTS:
+        raise HTTPException(404, "Unknown project")
+    s = Session(req.project_name)
+    SESSIONS[s.id] = s
+    return ChatResponse(session_id=s.id, answer="Nasıl yardımcı olabilirim?")
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat(req: ChatRequest):
+    if req.session_id not in SESSIONS:
+        raise HTTPException(404, "Invalid session")
+
+    s = SESSIONS[req.session_id]
+    user_msg = req.user_input.strip()
+    s.history.append({"role": "user", "content": user_msg})
+
+    # ---------------- Parametre follow-up modunda mı? ----------------
+    if s.awaiting:
+        answer = await _followup_flow(s, user_msg)
+        s.history.append({"role": "assistant", "content": answer})
+        return ChatResponse(session_id=s.id, answer=answer)
+
+    # ---------------- Intent detection ----------------
+    gen_prompt = s.project["versions"][0]["general_prompt"]
+    prompt = build_intent_prompt(gen_prompt, s.history, user_msg)
+    llm_out = await spark_generate(prompt)
+
+    if not llm_out.startswith("#DETECTED_INTENT:"):
+        # Small-talk cevabı
+        s.history.append({"role": "assistant", "content": llm_out})
+        return ChatResponse(session_id=s.id, answer=llm_out)
+
+    intent_name = llm_out.split(":", 1)[1].strip()
+    intent_cfg  = _get_intent_cfg(s.project, intent_name)
+    if not intent_cfg:
+        err = "Üzgünüm, bu konuda yardımcı olamıyorum."
+        s.history.append({"role": "assistant", "content": err})
+        return ChatResponse(session_id=s.id, answer=err)
+
+    answer = await _handle_intent(s, intent_cfg, user_msg)
+    s.history.append({"role": "assistant", "content": answer})
+    return ChatResponse(session_id=s.id, answer=answer)
+
+
+# ----------------------------------------------------------------------------
+# CORE HELPERS
+# ----------------------------------------------------------------------------
+def _get_intent_cfg(project: Dict, name_: str) -> Optional[Dict]:
+    for it in project["versions"][0]["intents"]:
+        if it["name"] == name_:
+            return it
+    return None
+
+def _current_missing(session: Session, intent_cfg: Dict) -> List[str]:
+    return [
+        p["name"]
+        for p in intent_cfg["parameters"]
+        if p["variable_name"] not in session.variables
+    ]
+
+async def _handle_intent(session: Session,
+                         intent_cfg: Dict,
+                         user_msg: str) -> str:
+    missing = _current_missing(session, intent_cfg)
+
+    # --- Parametre extraction denemesi (ilk mesajda) ---
+    if missing:
+        p_prompt = build_parameter_prompt(intent_cfg, missing, user_msg, session.history)
+        llm_out  = await spark_generate(p_prompt)
+
+        if llm_out.startswith("#PARAMETERS:"):
+            ok = _process_param_output(session, intent_cfg, llm_out)
+            if not ok:
+                return ok  # invalid prompt dönebilir
+            missing = _current_missing(session, intent_cfg)
+
+    # --- Hâlâ eksik mi? follow-up sor ---
+    if missing:
+        session.awaiting = {"intent": intent_cfg, "missing": missing}
+        first_caption = next(p for p in intent_cfg["parameters"]
+                             if p["name"] == missing[0])["caption"]
+        return f"{first_caption} nedir?"
+
+    # --- Tüm parametreler hazır → API çağır ---
+    return await _call_api(session, intent_cfg)
+
+async def _followup_flow(session: Session,
+                         user_msg: str) -> str:
+    intent_cfg = session.awaiting["intent"]
+    missing    = session.awaiting["missing"]
+
+    p_prompt = build_parameter_prompt(intent_cfg, missing, user_msg, session.history)
+    llm_out  = await spark_generate(p_prompt)
+
+    if not llm_out.startswith("#PARAMETERS:"):
+        return "Üzgünüm, bilgileri anlayamadım."
+
+    ok = _process_param_output(session, intent_cfg, llm_out)
+    if not ok:
+        return ok
+
+    missing = _current_missing(session, intent_cfg)
+    if missing:
+        session.awaiting["missing"] = missing
+        first_caption = next(p for p in intent_cfg["parameters"]
+                             if p["name"] == missing[0])["caption"]
+        return f"{first_caption} nedir?"
+
+    session.awaiting = None
+    return await _call_api(session, intent_cfg)
+
+def _process_param_output(session: Session,
+                          intent_cfg: Dict,
+                          llm_out: str) -> Optional[str]:
+    try:
+        data = json.loads(llm_out[len("#PARAMETERS:"):])
+    except json.JSONDecodeError:
+        return "Üzgünüm, parametreleri çözemedim."
+
+    for pair in data.get("extracted", []):
+        p_cfg = next(p for p in intent_cfg["parameters"] if p["name"] == pair["name"])
+        if not _validate(p_cfg, pair["value"]):
+            return p_cfg.get("invalid_prompt", "Geçersiz değer.")
+        session.variables[p_cfg["variable_name"]] = pair["value"]
+    return None  # success
+
+def _validate(p_cfg: Dict, value: str) -> bool:
+    pattern = p_cfg.get("validation_regex")
+    return re.match(pattern, value) is not None if pattern else True
+
+async def _call_api(session: Session, intent_cfg: Dict) -> str:
+    api = APIS[intent_cfg["action"]]
+
+    # Simple token
+    token = "testtoken"
+    headers = {k: v.replace("{{token}}", token) for k, v in api["headers"].items()}
+
+    body = json.loads(json.dumps(api["body_template"]))  # deep copy
+    for k, v in body.items():
+        if isinstance(v, str) and v.startswith("{{") and v.endswith("}}"):
+            body[k] = session.variables.get(v[2:-2], "")
+
+    log(f"➡️  {api['name']} {body}")
+    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 as ex:
+        log(f"❌ API error: {ex}")
+        return intent_cfg["fallback_error_prompt"]
+
+    # LLM’ye özetlet
+    summary_prompt = api["response_prompt"].replace(
+        "{{api_response}}", json.dumps(api_json, ensure_ascii=False)
+    )
+    return await spark_generate(summary_prompt)