Update chat_handler.py

chat_handler.py

@@ -1,90 +1,69 @@
 """
-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.
+Flare – Chat Handler (router edition)
+=====================================
+app.py → from chat_handler import router
 """
 
-import re
-import json
-import uuid
-import httpx
-import commentjson
+import re, json, uuid, httpx, commentjson
 from datetime import datetime
 from typing import Dict, List, Optional
 
-from fastapi import FastAPI, HTTPException
+from fastapi import APIRouter, HTTPException
 from pydantic import BaseModel
 
 from prompt_builder import build_intent_prompt, build_parameter_prompt, log
 
 # ----------------------------------------------------------------------------
-# CONFIG LOAD (service_config.jsonc)
+# CONFIG
 # ----------------------------------------------------------------------------
-with open("service_config.jsonc", "r", encoding="utf-8") as f:
-    CFG = commentjson.load(f)
-
+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"]}
 
-
 # ----------------------------------------------------------------------------
-# SESSION OBJECT
+# SESSION
 # ----------------------------------------------------------------------------
 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":[...]}
+        self.variables: Dict[str, str] = {}
+        self.awaiting: Optional[Dict] = None
         log(f"🆕 Session {self.id} for {project_name}")
 
-
 SESSIONS: Dict[str, Session] = {}
 
-
 # ----------------------------------------------------------------------------
-# SPARK LLM WRAPPER  (basit HTTP JSON)
+# SPARK
 # ----------------------------------------------------------------------------
 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 = await c.post(CFG["config"]["spark_endpoint"], json={"prompt": prompt})
         r.raise_for_status()
         return r.json()["text"]
 
-
 # ----------------------------------------------------------------------------
-# FASTAPI APP
+# FASTAPI ROUTER
 # ----------------------------------------------------------------------------
-app = FastAPI()
+router = APIRouter()          # <<–– exported to app.py
 
-@app.get("/")
+@router.get("/")
 def health():
     return {"status": "ok"}
 
-
-# ----------------------------------------------------------------------------
-# SCHEMAS
-# ----------------------------------------------------------------------------
+# Schemas
 class StartSessionRequest(BaseModel):
     project_name: str
-
 class ChatRequest(BaseModel):
     session_id: str
     user_input: str
-
 class ChatResponse(BaseModel):
     session_id: str
     answer: str
 
-
-# ----------------------------------------------------------------------------
-# ENDPOINTS
-# ----------------------------------------------------------------------------
-@app.post("/start_session", response_model=ChatResponse)
+# Endpoints
+@router.post("/start_session", response_model=ChatResponse)
 async def start_session(req: StartSessionRequest):
     if req.project_name not in PROJECTS:
         raise HTTPException(404, "Unknown project")
@@ -92,35 +71,33 @@ async def start_session(req: StartSessionRequest):
     SESSIONS[s.id] = s
     return ChatResponse(session_id=s.id, answer="Nasıl yardımcı olabilirim?")
 
-@app.post("/chat", response_model=ChatResponse)
+@router.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ı? ----------------
+    # --- follow-up? ---
     if s.awaiting:
-        answer = await _followup_flow(s, user_msg)
+        answer = await _followup(s, user_msg)
         s.history.append({"role": "assistant", "content": answer})
         return ChatResponse(session_id=s.id, answer=answer)
 
-    # ---------------- Intent detection ----------------
+    # --- intent detect ---
     gen_prompt = s.project["versions"][0]["general_prompt"]
-    prompt = build_intent_prompt(gen_prompt, s.history, user_msg)
-    llm_out = await spark_generate(prompt)
+    intent_prompt = build_intent_prompt(gen_prompt, s.history, user_msg)
+    intent_out = await spark_generate(intent_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)
+    if not intent_out.startswith("#DETECTED_INTENT:"):
+        s.history.append({"role": "assistant", "content": intent_out})
+        return ChatResponse(session_id=s.id, answer=intent_out)
 
-    intent_name = llm_out.split(":", 1)[1].strip()
-    intent_cfg  = _get_intent_cfg(s.project, intent_name)
+    intent_name = intent_out.split(":", 1)[1].strip()
+    intent_cfg  = _find_intent(s.project, intent_name)
     if not intent_cfg:
-        err = "Üzgünüm, bu konuda yardımcı olamıyorum."
+        err = "Üzgünüm, anlayamadım."
         s.history.append({"role": "assistant", "content": err})
         return ChatResponse(session_id=s.id, answer=err)
 
@@ -128,117 +105,82 @@ async def chat(req: ChatRequest):
     s.history.append({"role": "assistant", "content": answer})
     return ChatResponse(session_id=s.id, answer=answer)
 
-
 # ----------------------------------------------------------------------------
-# CORE HELPERS
+# Helper funcs  (değişmedi, sadece router’a ihtiyaç yok)
 # ----------------------------------------------------------------------------
-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
-    ]
+def _find_intent(project, name_):
+    return next((i for i in project["versions"][0]["intents"] if i["name"] == name_), None)
 
-async def _handle_intent(session: Session,
-                         intent_cfg: Dict,
-                         user_msg: str) -> str:
-    missing = _current_missing(session, intent_cfg)
+def _missing(session, intent_cfg):
+    return [p["name"] for p in intent_cfg["parameters"] if p["variable_name"] not in session.variables]
 
-    # --- Parametre extraction denemesi (ilk mesajda) ---
+async def _handle_intent(s, intent_cfg, user_msg):
+    missing = _missing(s, intent_cfg)
     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 ---
+        p_prompt = build_parameter_prompt(intent_cfg, missing, user_msg, s.history)
+        p_out    = await spark_generate(p_prompt)
+        if p_out.startswith("#PARAMETERS:"):
+            if bad := _process_params(s, intent_cfg, p_out):
+                return bad
+            missing = _missing(s, intent_cfg)
     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)
+        s.awaiting = {"intent": intent_cfg, "missing": missing}
+        cap = next(p for p in intent_cfg["parameters"] if p["name"] == missing[0])["caption"]
+        return f"{cap} nedir?"
+    s.awaiting = None
+    return await _call_api(s, intent_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_out      = await spark_generate(p_prompt)
+    if not p_out.startswith("#PARAMETERS:"):
+        return "Üzgünüm, anlayamadım."
+    if bad := _process_params(s, intent_cfg, p_out):
+        return bad
+    missing = _missing(s, 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?"
+        s.awaiting["missing"] = missing
+        cap = next(p for p in intent_cfg["parameters"] if p["name"] == missing[0])["caption"]
+        return f"{cap} nedir?"
+    s.awaiting = None
+    return await _call_api(s, intent_cfg)
 
-    session.awaiting = None
-    return await _call_api(session, intent_cfg)
-
-def _process_param_output(session: Session,
-                          intent_cfg: Dict,
-                          llm_out: str) -> Optional[str]:
+def _process_params(s, intent_cfg, p_out):
     try:
-        data = json.loads(llm_out[len("#PARAMETERS:"):])
+        data = json.loads(p_out[len("#PARAMETERS:"):])
     except json.JSONDecodeError:
-        return "Üzgünüm, parametreleri çözemedim."
-
+        return "Üzgünüm, parametreleri çözemiyorum."
     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"]):
+        if not _valid(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
+        s.variables[p_cfg["variable_name"]] = pair["value"]
+    return None
 
-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
+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(session: Session, intent_cfg: Dict) -> str:
+async def _call_api(s, intent_cfg):
     api = APIS[intent_cfg["action"]]
-
-    # Simple token
-    token = "testtoken"
+    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
+    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] = session.variables.get(v[2:-2], "")
-
-    log(f"➡️  {api['name']} {body}")
+            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 as ex:
-        log(f"❌ API error: {ex}")
+    except Exception:
         return intent_cfg["fallback_error_prompt"]
 
-    # LLM’ye özetlet
-    summary_prompt = api["response_prompt"].replace(
+    summary = api["response_prompt"].replace(
         "{{api_response}}", json.dumps(api_json, ensure_ascii=False)
     )
-    return await spark_generate(summary_prompt)
+    return await spark_generate(summary)