Update chat_handler.py

chat_handler.py

@@ -1,72 +1,84 @@
 """
-Flare – Chat Handler (header edition)
-====================================
-/start_session -> JSON body döner
-/chat          -> X-Session-ID header + {"user_input": "..."}
+Flare – Chat Handler  (Spark /generate format)
+=============================================
+• X-Session-ID header
+• /generate payload:
+  {project_name, user_input, context, system_prompt}
 """
 
 import re, json, uuid, httpx, commentjson
 from datetime import datetime
 from typing import Dict, List, Optional
 
-from fastapi import APIRouter, HTTPException, Header, Request
+from fastapi import APIRouter, HTTPException, Header
 from pydantic import BaseModel
 
 from prompt_builder import build_intent_prompt, build_parameter_prompt, log
 
-# ----------------------------------------------------------------------------
+# --------------------------------------------------------------------------- #
 # 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"
 
-# ----------------------------------------------------------------------------
+# --------------------------------------------------------------------------- #
 # 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.history: List[Dict[str, str]] = []     # {role, content}
         self.variables: Dict[str, str] = {}
         self.awaiting: Optional[Dict] = None
         log(f"🆕 Session {self.id} for {project_name}")
 
 SESSIONS: Dict[str, Session] = {}
 
-# ----------------------------------------------------------------------------
-# SPARK
-# ----------------------------------------------------------------------------
-async def spark_generate(prompt: str) -> str:
+# --------------------------------------------------------------------------- #
+# Spark client
+# --------------------------------------------------------------------------- #
+async def spark_generate(session: Session,
+                         system_prompt: str,
+                         user_input: str) -> str:
+    """Send request to Spark /generate endpoint"""
+    payload = {
+        "project_name": session.project["name"],
+        "user_input": user_input,
+        "context": session.history[-10:],   # only last 10 turns
+        "system_prompt": system_prompt
+    }
     async with httpx.AsyncClient(timeout=60) as c:
-        r = await c.post(CFG["config"]["spark_endpoint"], json={"prompt": prompt})
+        r = await c.post(SPARK_URL, json=payload)
         r.raise_for_status()
-        return r.json()["text"]
+        # Spark örneğinde cevap key'i "model_answer" olabilir.
+        data = r.json()
+        return data.get("assistant") or data.get("model_answer") or data.get("text", "")
 
-# ----------------------------------------------------------------------------
+# --------------------------------------------------------------------------- #
 # FASTAPI ROUTER
-# ----------------------------------------------------------------------------
+# --------------------------------------------------------------------------- #
 router = APIRouter()
 
 @router.get("/")
 def health():
     return {"status": "ok"}
 
-# Schemas
 class StartSessionRequest(BaseModel):
     project_name: str
 
 class ChatBody(BaseModel):
     user_input: str
-    # session_id optional for legacy
-    session_id: Optional[str] = None
 
 class ChatResponse(BaseModel):
     session_id: str
     answer: str
 
-# Endpoints
+# --------------------------------------------------------------------------- #
+# ENDPOINTS
+# --------------------------------------------------------------------------- #
 @router.post("/start_session", response_model=ChatResponse)
 async def start_session(req: StartSessionRequest):
     if req.project_name not in PROJECTS:
@@ -77,14 +89,11 @@ async def start_session(req: StartSessionRequest):
 
 @router.post("/chat", response_model=ChatResponse)
 async def chat(body: ChatBody,
-               request: Request,
-               x_session_id: Optional[str] = Header(None)):
-    # 1) Session ID alma: header > body
-    sid = x_session_id or body.session_id
-    if not sid or sid not in SESSIONS:
-        raise HTTPException(404, "Invalid or missing session")
-
-    s = SESSIONS[sid]
+               x_session_id: str = Header(...)):
+    if x_session_id not in SESSIONS:
+        raise HTTPException(404, "Invalid session")
+
+    s = SESSIONS[x_session_id]
     user_msg = body.user_input.strip()
     s.history.append({"role": "user", "content": user_msg})
 
@@ -94,10 +103,9 @@ async def chat(body: ChatBody,
         s.history.append({"role": "assistant", "content": answer})
         return ChatResponse(session_id=s.id, answer=answer)
 
-    # ---------------- intent detect
+    # ---------------- intent detection ----------------
     gen_prompt = s.project["versions"][0]["general_prompt"]
-    intent_prompt = build_intent_prompt(gen_prompt, s.history, user_msg)
-    intent_out = await spark_generate(intent_prompt)
+    intent_out = await spark_generate(s, gen_prompt, user_msg)
 
     if not intent_out.startswith("#DETECTED_INTENT:"):
         s.history.append({"role": "assistant", "content": intent_out})
@@ -114,28 +122,31 @@ async def chat(body: ChatBody,
     s.history.append({"role": "assistant", "content": answer})
     return ChatResponse(session_id=s.id, answer=answer)
 
-# ----------------------------------------------------------------------------
-# Helper funcs (aynı)
-# ----------------------------------------------------------------------------
+# --------------------------------------------------------------------------- #
+# Helper functions
+# --------------------------------------------------------------------------- #
 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]
+    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)
     if missing:
         p_prompt = build_parameter_prompt(intent_cfg, missing, user_msg, s.history)
-        out      = await spark_generate(p_prompt)
-        if out.startswith("#PARAMETERS:"):
-            if bad := _process_params(s, intent_cfg, out):
+        p_out    = await spark_generate(s, p_prompt, user_msg)
+        if p_out.startswith("#PARAMETERS:"):
+            if bad := _process_params(s, intent_cfg, p_out):
                 return bad
             missing = _missing(s, intent_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"]
         return f"{cap} nedir?"
+
     s.awaiting = None
     return await _call_api(s, intent_cfg)
 
@@ -143,22 +154,24 @@ 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)
-    out        = await spark_generate(p_prompt)
-    if not out.startswith("#PARAMETERS:"):
+    p_out      = await spark_generate(s, p_prompt, user_msg)
+    if not p_out.startswith("#PARAMETERS:"):
         return "Üzgünüm, anlayamadım."
-    if bad := _process_params(s, intent_cfg, out):
+    if bad := _process_params(s, intent_cfg, p_out):
         return bad
+
     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"]
         return f"{cap} nedir?"
+
     s.awaiting = None
     return await _call_api(s, intent_cfg)
 
-def _process_params(s, intent_cfg, out):
+def _process_params(s, intent_cfg, p_out):
     try:
-        data = json.loads(out[len("#PARAMETERS:"):])
+        data = json.loads(p_out[len("#PARAMETERS:"):])
     except json.JSONDecodeError:
         return "Parametreleri çözemedim."
     for pair in data.get("extracted", []):
@@ -188,7 +201,7 @@ async def _call_api(s, intent_cfg):
     except Exception:
         return intent_cfg["fallback_error_prompt"]
 
-    summary = api["response_prompt"].replace(
+    summary_prompt = api["response_prompt"].replace(
         "{{api_response}}", json.dumps(api_json, ensure_ascii=False)
     )
-    return await spark_generate(summary)
+    return await spark_generate(s, summary_prompt, "")