Update chat_handler.py

chat_handler.py

@@ -1,40 +1,28 @@
 """
-Flare – Chat Handler  (v1.7 · parameter parsing düzeltmesi)
+Flare – Chat Handler (Refactored with LLM Factory)
 ==========================================
 """
 
-import os
-import re, json, sys, httpx
+import re, json, sys, httpx, os
 from datetime import datetime
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Any
 from fastapi import APIRouter, HTTPException, Header
 from pydantic import BaseModel
 import requests
 
-from prompt_builder import build_intent_prompt, build_parameter_prompt, build_smart_parameter_question_prompt, extract_params_from_question
+from prompt_builder import build_intent_prompt, build_parameter_prompt
 from utils import log
 from api_executor import call_api as execute_api  
+from config_provider import ConfigProvider
 from validation_engine import validate
 from session import session_store, Session
-from llm_interface import LLMInterface, SparkLLM, GPT4oLLM
-from config_provider import ConfigProvider
-from llm_factory import LLMFactory
-
-# ─────────────────────────  CONFIG ───────────────────────── #
-# Global config reference
-cfg = None
 
-def get_config():
-    """Always get fresh config"""
-    global cfg
-    cfg = ConfigProvider.get()
-    return cfg
-
-# Initialize on module load
-cfg = get_config()
+# Initialize router
+router = APIRouter()
 
-# Global LLM instance
-llm_provider: Optional[LLMInterface] = None
+# ─────────────────────────  GLOBAL VARS ───────────────────────── #
+cfg = ConfigProvider.get()
+llm_provider = None
 
 # ─────────────────────────  HELPERS ───────────────────────── #
 def _trim_response(raw: str) -> str:
@@ -67,480 +55,82 @@ def _safe_intent_parse(raw: str) -> tuple[str, str]:
 
 # ─────────────────────────  LLM SETUP ───────────────────────── #
 def setup_llm_provider():
-    """Initialize LLM provider based on config"""
+    """Initialize LLM provider using factory pattern"""
     global llm_provider
     
     try:
+        from llm_factory import LLMFactory
         llm_provider = LLMFactory.create_provider()
         log("✅ LLM provider initialized successfully")
     except Exception as e:
         log(f"❌ Failed to initialize LLM provider: {e}")
         raise
 
-# ─────────────────────────  SPARK/LLM CALL ───────────────────────── #
+# ─────────────────────────  LLM GENERATION ───────────────────────── #
 async def llm_generate(s: Session, prompt: str, user_msg: str) -> str:
     """Call LLM provider with proper error handling"""
+    global llm_provider
+    
+    if llm_provider is None:
+        setup_llm_provider()
+    
     try:
-        # Get conversation context
-        context = [
-            {"role": msg["role"], "content": msg["content"]} 
-            for msg in s.chat_history[-10:]  # Last 10 messages
-        ]
-        
-        # Generate response
-        raw_response = await llm_provider.generate(
-            system_prompt=prompt,
-            user_input=user_msg,
-            context=context
-        )
-        
-        log(f"📥 LLM response length: {len(raw_response)}")
-        return raw_response
-        
-    except httpx.TimeoutException:
-        log("⏱️ LLM timeout - returning fallback")
-        return "İsteğiniz zaman aşımına uğradı. Lütfen tekrar deneyin."
-    except Exception as e:
-        log(f"❌ LLM error: {str(e)}")
-        return "Bir hata oluştu. Lütfen daha sonra tekrar deneyin."
-
-# ─────────────────────────  ALLOWED INTENTS ───────────────────────── #
-ALLOWED_INTENTS = {"flight-booking", "flight-info", "booking-cancel"}
-
-# ─────────────────────────  FASTAPI ───────────────────────── #
-router = APIRouter()
-
-@router.get("/")
-def health(): 
-    return {"status": "ok", "sessions": len(session_store._sessions)}
-
-class StartRequest(BaseModel): 
-    project_name: str
-
-class ChatRequest(BaseModel):  
-    user_input: str
-
-class ChatResponse(BaseModel):  
-    session_id: str
-    answer: str
-
-@router.post("/start_session", response_model=ChatResponse)
-async def start_session(req: StartRequest):
-    """Create new session"""
-    try:
-        # Validate project exists
-        project = next((p for p in cfg.projects if p.name == req.project_name and p.enabled), None)
-        if not project:
-            raise HTTPException(404, f"Project '{req.project_name}' not found or disabled")
-        
-        # Find published version
-        version = next((v for v in project.versions if v.published), None)
-        if not version:
-            raise HTTPException(404, f"No published version for project '{req.project_name}'")
-        
-        # Create session with version config
-        session = session_store.create_session(req.project_name, version)
-        greeting = "Hoş geldiniz! Size nasıl yardımcı olabilirim?"
-        session.add_turn("assistant", greeting)
-        
-        return ChatResponse(session_id=session.session_id, answer=greeting)
-        
-    except Exception as e:
-        log(f"❌ Error creating session: {e}")
-        raise HTTPException(500, str(e))
-
-@router.post("/chat", response_model=ChatResponse)
-async def chat(body: ChatRequest, x_session_id: str = Header(...)):
-    """Process chat message"""
-    try:
-        # Get session
-        session = session_store.get_session(x_session_id)
-        if not session:
-            raise HTTPException(404, "Session not found")
-        
-        user_input = body.user_input.strip()
-        if not user_input:
-            raise HTTPException(400, "Empty message")
-            
-        log(f"💬 User input: {user_input}")
-        log(f"📊 Session state: {session.state}, last_intent: {session.last_intent}")
-        log(f"📊 Session version: {session.version_number}")
-        
-        session.add_turn("user", user_input)
-        
         # Get version config from session
-        version = session.get_version_config()
+        version = s.get_version_config()
         if not version:
-            raise HTTPException(500, "Version configuration lost")
-
-        # Handle based on state
-        if session.state == "await_param":
-            log(f"🔄 Handling parameter followup for missing: {session.awaiting_parameters}")
-            answer = await _handle_parameter_followup(session, user_input)
-        else:
-            log("🆕 Handling new message")
-            answer = await _handle_new_message(session, user_input)
+            # Fallback: get from project config
+            project = next((p for p in cfg.projects if p.name == s.project_name), None)
+            if not project:
+                raise ValueError(f"Project not found: {s.project_name}")
+            version = next((v for v in project.versions if v.published), None)
+            if not version:
+                raise ValueError("No published version found")
         
-        session.add_turn("assistant", answer)
-        return ChatResponse(session_id=session.session_id, answer=answer)
+        log(f"🚀 Calling LLM for session {s.session_id[:8]}...")
+        log(f"📋 Prompt preview (first 200 chars): {prompt[:200]}...")
         
-    except HTTPException:
-        raise
-    except Exception as e:
-        log(f"❌ Chat error: {e}")
-        session.reset_flow()
-        error_msg = "Bir hata oluştu. Lütfen tekrar deneyin."
-        session.add_turn("assistant", error_msg)
-        return ChatResponse(session_id=x_session_id, answer=error_msg)
-
-# ─────────────────────────  MESSAGE HANDLERS ───────────────────────── #
-async def _handle_new_message(session: Session, user_input: str) -> str:
-    """Handle new message (not parameter followup)"""
-    
-    # Get version config from session
-    version = session.get_version_config()
-    if not version:
-        log("❌ Version config not found")
-        return "Bir hata oluştu. Lütfen tekrar deneyin."
-    
-    # Build intent detection prompt
-    prompt = build_intent_prompt(
-        version.general_prompt,
-        session.chat_history,
-        user_input,
-        version.intents
-    )
-    
-    # Get LLM response
-    raw = await spark_generate(session, prompt, user_input)
-    
-    # Empty response fallback
-    if not raw:
-        log("⚠️ Empty response from LLM")
-        return "Üzgünüm, mesajınızı anlayamadım. Lütfen tekrar dener misiniz?"
-    
-    # Check for intent
-    if not raw.startswith("#DETECTED_INTENT"):
-        # Small talk response
-        log("💬 No intent detected, returning small talk")
-        return _trim_response(raw)
-    
-    # Parse intent
-    intent_name, tail = _safe_intent_parse(raw)
-    
-    # Validate intent
-    if intent_name not in ALLOWED_INTENTS:
-        log(f"⚠️ Invalid intent: {intent_name}")
-        return _trim_response(tail) if tail else "Size nasıl yardımcı olabilirim?"
-    
-    # Short message guard (less than 3 words usually means incomplete request)
-    if len(user_input.split()) < 3 and intent_name != "flight-info":
-        log(f"⚠️ Message too short ({len(user_input.split())} words) for intent {intent_name}")
-        return _trim_response(tail) if tail else "Lütfen talebinizi biraz daha detaylandırır mısınız?"
-    
-    # Find intent config
-    intent_config = next((i for i in version.intents if i.name == intent_name), None)
-    if not intent_config:
-        log(f"❌ Intent config not found for: {intent_name}")
-        return "Üzgünüm, bu işlemi gerçekleştiremiyorum."
-    
-    # Set intent in session
-    session.last_intent = intent_name
-    log(f"✅ Intent set: {intent_name}")
-    
-    # Log intent parameters
-    log(f"📋 Intent parameters: {[p.name for p in intent_config.parameters]}")
-    
-    # Extract parameters
-    return await _extract_parameters(session, intent_config, user_input)
-
-async def _handle_parameter_followup(session: Session, user_input: str) -> str:
-    """Handle parameter collection followup"""
-    if not session.last_intent:
-        log("⚠️ No last intent in session")
-        session.reset_flow()
-        return "Üzgünüm, hangi işlem için bilgi istediğimi unuttum. Baştan başlayalım."
-
-    # Get version config from session
-    version = session.get_version_config()
-    if not version:
-        log("❌ Version config not found")
-        session.reset_flow()
-        return "Bir hata oluştu. Lütfen tekrar deneyin."    
-    
-    # Get intent config
-    intent_config = next((i for i in version.intents if i.name == session.last_intent), None)
-    if not intent_config:
-        log(f"❌ Intent config not found for: {session.last_intent}")
-        session.reset_flow()
-        return "Bir hata oluştu. Lütfen tekrar deneyin."
-    
-    # Smart parameter collection
-    if cfg.global_config.parameter_collection_config.smart_grouping:
-        return await _handle_smart_parameter_collection(session, intent_config, user_input)
-    else:
-        return await _handle_simple_parameter_collection(session, intent_config, user_input)
-
-async def _handle_simple_parameter_collection(session: Session, intent_config, user_input: str) -> str:
-    """Original simple parameter collection logic"""
-    # Try to extract missing parameters
-    missing = session.awaiting_parameters
-    log(f"🔍 Trying to extract missing params: {missing}")
-    
-    prompt = build_parameter_prompt(intent_config, missing, user_input, session.chat_history, intent_config.locale)
-    raw = await spark_generate(session, prompt, user_input)
-    
-    # Try parsing with or without #PARAMETERS: prefix
-    success = _process_parameters(session, intent_config, raw)
-    
-    if not success:
-        # Increment miss count
-        session.missing_ask_count += 1
-        log(f"⚠️ No parameters extracted, miss count: {session.missing_ask_count}")
+        # Call the configured LLM provider
+        raw = await llm_provider.generate(
+            user_input=user_msg,
+            system_prompt=prompt,
+            context=s.chat_history[-10:] if s.chat_history else []
+        )
         
-        if session.missing_ask_count >= 3:
-            session.reset_flow()
-            return "Üzgünüm, istediğiniz bilgileri anlayamadım. Başka bir konuda yardımcı olabilir miyim?"
-        return "Üzgünüm, anlayamadım. Lütfen tekrar söyler misiniz?"
-    
-    # Check if we have all required parameters
-    missing = _get_missing_parameters(session, intent_config)
-    log(f"📊 Still missing params: {missing}")
-    
-    if missing:
-        session.awaiting_parameters = missing
-        param = next(p for p in intent_config.parameters if p.name == missing[0])
-        return f"{param.caption} bilgisini alabilir miyim?"
-    
-    # All parameters collected, call API
-    log("✅ All parameters collected, calling API")
-    session.state = "call_api"
-    return await _execute_api_call(session, intent_config)
-
-async def _handle_smart_parameter_collection(session: Session, intent_config, user_input: str) -> str:
-    """Smart parameter collection with grouping and retry logic"""
-    
-    # Try to extract missing parameters
-    missing = session.awaiting_parameters
-    log(f"🔍 Trying to extract missing params: {missing}")
-    
-    prompt = build_parameter_prompt(intent_config, missing, user_input, session.chat_history, intent_config.locale)
-    raw = await spark_generate(session, prompt, user_input)
-    
-    # Try parsing with or without #PARAMETERS: prefix
-    success = _process_parameters(session, intent_config, raw)
-    
-    # Hangi parametreler hala eksik?
-    still_missing = _get_missing_parameters(session, intent_config)
-    
-    # Sorulan ama cevaplanmayan parametreleri belirle
-    asked_but_not_answered = []
-    for param in session.awaiting_parameters:
-        if param in still_missing:
-            asked_but_not_answered.append(param)
-    
-    # Cevaplanmayanları session'a kaydet
-    if asked_but_not_answered:
-        session.mark_parameters_unanswered(asked_but_not_answered)
-        log(f"❓ Parameters not answered: {asked_but_not_answered}")
-    
-    # Cevaplananları işaretle
-    for param in session.awaiting_parameters:
-        if param not in still_missing:
-            session.mark_parameter_answered(param)
-            log(f"✅ Parameter answered: {param}")
-    
-    if still_missing:
-        # Maksimum deneme kontrolü
-        if session.missing_ask_count >= 3:
-            session.reset_flow()
-            return "Üzgünüm, istediğiniz bilgileri anlayamadım. Başka bir konuda yardımcı olabilir miyim?"
+        log(f"🪄 LLM raw response: {raw[:100]}...")
+        return raw
         
-        # Smart parameter question oluştur
-        return await _generate_smart_parameter_question(session, intent_config, still_missing)
-    
-    # Tüm parametreler toplandı
-    log("✅ All parameters collected, calling API")
-    session.state = "call_api"
-    return await _execute_api_call(session, intent_config)
-
-async def _generate_smart_parameter_question(session: Session, intent_config, missing_params: List[str]) -> str:
-    """Generate smart parameter collection question"""
-    
-    # Kaç parametre soracağımızı belirle
-    max_params = cfg.global_config.parameter_collection_config.max_params_per_question
-    
-    # Öncelik sırasına göre parametreleri seç
-    params_to_ask = []
-    
-    # Önce daha önce sorulmamış parametreler
-    for param in missing_params:
-        if session.get_parameter_ask_count(param) == 0:
-            params_to_ask.append(param)
-            if len(params_to_ask) >= max_params:
-                break
-    
-    # Hala yer varsa, daha önce sorulmuş ama cevaplanmamış parametreler
-    if len(params_to_ask) < max_params and cfg.global_config.parameter_collection_config.retry_unanswered:
-        for param in session.unanswered_parameters:
-            if param in missing_params and param not in params_to_ask:
-                params_to_ask.append(param)
-                if len(params_to_ask) >= max_params:
-                    break
-    
-    # Hala yer varsa, kalan parametreler
-    if len(params_to_ask) < max_params:
-        for param in missing_params:
-            if param not in params_to_ask:
-                params_to_ask.append(param)
-                if len(params_to_ask) >= max_params:
-                    break
-    
-    # Parametreleri session'a kaydet
-    session.record_parameter_question(params_to_ask)
-    session.awaiting_parameters = params_to_ask
-    session.missing_ask_count += 1
-    
-    # Build smart question prompt
-    collected_params = {
-        p.name: session.variables.get(p.variable_name, "")
-        for p in intent_config.parameters
-        if p.variable_name in session.variables
-    }
-    
-    question_prompt = build_smart_parameter_question_prompt(
-        intent_config,
-        params_to_ask,
-        session.chat_history,
-        collected_params,
-        session.unanswered_parameters,
-        cfg.global_config.parameter_collection_config.collection_prompt
-    )
-    
-    # Generate natural question
-    question = await spark_generate(session, question_prompt, "")
-    
-    # Clean up the response
-    question = _trim_response(question)
-    
-    log(f"🤖 Generated smart question for {params_to_ask}: {question}")
-    
-    return question
-
-# ─────────────────────────  PARAMETER HANDLING ───────────────────────── #
-async def _extract_parameters(session: Session, intent_config, user_input: str) -> str:
-    """Extract parameters from user input"""
-    missing = _get_missing_parameters(session, intent_config)
-    log(f"🔍 Missing parameters: {missing}")
-    
-    if not missing:
-        # All parameters already available
-        log("✅ All parameters already available")
-        return await _execute_api_call(session, intent_config)
-    
-    # Build parameter extraction prompt
-    prompt = build_parameter_prompt(intent_config, missing, user_input, session.chat_history)
-    raw = await spark_generate(session, prompt, user_input)
-    
-    # Try processing with flexible parsing
-    success = _process_parameters(session, intent_config, raw)
-    
-    if success:
-        missing = _get_missing_parameters(session, intent_config)
-        log(f"📊 After extraction, missing: {missing}")
-    else:
-        log("⚠️ Failed to extract parameters from response")
-    
-    if missing:
-        # Smart parameter collection
-        if cfg.global_config.parameter_collection_config.smart_grouping:
-            # Reset parameter tracking for new intent
-            session.reset_parameter_tracking()
-            return await _generate_smart_parameter_question(session, intent_config, missing)
-        else:
-            # Simple parameter collection
-            session.state = "await_param"
-            session.awaiting_parameters = missing
-            session.missing_ask_count = 0
-            param = next(p for p in intent_config.parameters if p.name == missing[0])
-            log(f"❓ Asking for parameter: {param.name} ({param.caption})")
-            return f"{param.caption} bilgisini alabilir miyim?"
-    
-    # All parameters collected
-    log("✅ All parameters collected after extraction")
-    return await _execute_api_call(session, intent_config)
-
-def _get_missing_parameters(session: Session, intent_config) -> List[str]:
-    """Get list of missing required parameters"""
-    missing = [
-        p.name for p in intent_config.parameters 
-        if p.required and p.variable_name not in session.variables
-    ]
-    log(f"📊 Session variables: {list(session.variables.keys())}")
-    return missing
+    except requests.exceptions.Timeout:
+        log(f"⏱️ LLM timeout for session {s.session_id[:8]}")
+        raise HTTPException(status_code=504, detail="LLM request timed out")
+    except Exception as e:
+        log(f"❌ LLM error: {e}")
+        raise HTTPException(status_code=500, detail=f"LLM error: {str(e)}")
 
-def _process_parameters(session: Session, intent_config, raw: str) -> bool:
-    """Process parameter extraction response with flexible parsing"""
+# ─────────────────────────  PARAMETER EXTRACTION ───────────────────────── #
+def _extract_parameters_from_response(raw: str, session: Session, intent_config) -> bool:
+    """Extract parameters from the LLM response"""
     try:
-        # Try to parse JSON, handling both with and without #PARAMETERS: prefix
-        json_str = raw
-        if raw.startswith("#PARAMETERS:"):
-            json_str = raw[len("#PARAMETERS:"):]
-            log(f"🔍 Found #PARAMETERS: prefix, removing it")
-        
-        # Clean up any trailing content after JSON
-        # Find the closing brace for the JSON object
-        brace_count = 0
-        json_end = -1
-        in_string = False
-        escape_next = False
-        
-        for i, char in enumerate(json_str):
-            if escape_next:
-                escape_next = False
-                continue
-                
-            if char == '\\':
-                escape_next = True
-                continue
-                
-            if char == '"' and not escape_next:
-                in_string = not in_string
-                continue
-                
-            if not in_string:
-                if char == '{':
-                    brace_count += 1
-                elif char == '}':
-                    brace_count -= 1
-                    if brace_count == 0:
-                        json_end = i + 1
-                        break
-        
-        if json_end > 0:
-            json_str = json_str[:json_end]
-            log(f"🔍 Cleaned JSON string: {json_str[:200]}")
+        # Look for JSON block in response
+        json_match = re.search(r'```json\s*(.*?)\s*```', raw, re.DOTALL)
+        if not json_match:
+            # Try to find JSON without code block
+            json_match = re.search(r'\{[^}]+\}', raw)
         
-        data = json.loads(json_str)
+        if not json_match:
+            log("❌ No JSON found in response")
+            return False
         
-        extracted = data.get("extracted", [])
-        log(f"📦 Extracted data: {extracted}")
+        json_str = json_match.group(1) if '```' in raw else json_match.group(0)
+        params = json.loads(json_str)
         
         any_valid = False
-        
-        for param_data in extracted:
-            param_name = param_data.get("name")
-            param_value = param_data.get("value")
-            
-            if not param_name or not param_value:
-                log(f"⚠️ Invalid param data: {param_data}")
-                continue
-            
+        for param_name, param_value in params.items():
             # Find parameter config
             param_config = next(
                 (p for p in intent_config.parameters if p.name == param_name),
                 None
             )
+            
             if not param_config:
                 log(f"⚠️ Parameter config not found for: {param_name}")
                 continue
@@ -591,7 +181,7 @@ async def _execute_api_call(session: Session, intent_config) -> str:
                 "{{api_response}}", 
                 json.dumps(api_json, ensure_ascii=False)
             )
-            human_response = await spark_generate(session, prompt, json.dumps(api_json))
+            human_response = await llm_generate(session, prompt, json.dumps(api_json))
             session.reset_flow()
             return human_response if human_response else f"İşlem sonucu: {api_json}"
         else:
@@ -607,5 +197,194 @@ async def _execute_api_call(session: Session, intent_config) -> str:
         session.reset_flow()
         return intent_config.fallback_error_prompt or "İşlem sırasında bir hata oluştu."
 
+# ─────────────────────────  REQUEST MODELS ───────────────────────── #
+class SessionRequest(BaseModel):
+    project_name: str
+    test_mode: bool = False
+
+class ChatRequest(BaseModel):
+    message: str
+
+# ─────────────────────────  API ENDPOINTS ───────────────────────── #
+@router.post("/start_session")
+async def start_session(req: SessionRequest):
+    """Initialize a new chat session"""
+    try:
+        # Verify project exists and has published version
+        project = next((p for p in cfg.projects if p.name == req.project_name), None)
+        if not project:
+            raise HTTPException(status_code=404, detail=f"Project '{req.project_name}' not found")
+        
+        if not project.enabled:
+            raise HTTPException(status_code=400, detail=f"Project '{req.project_name}' is disabled")
+        
+        # Find published version
+        published_version = next((v for v in project.versions if v.published), None)
+        if not published_version:
+            raise HTTPException(status_code=400, detail=f"Project '{req.project_name}' has no published version")
+        
+        # Create session
+        session = Session(
+            project_name=req.project_name,
+            version_id=published_version.id,
+            test_mode=req.test_mode
+        )
+        
+        # Store version config in session
+        session.version_config = published_version
+        
+        # Store session
+        session_store.add(session)
+        
+        log(f"🔑 New session created: {session.session_id[:8]}... for project '{req.project_name}' v{published_version.id}")
+        
+        return {
+            "session_id": session.session_id,
+            "project_name": req.project_name,
+            "version": published_version.id,
+            "greeting": "Merhaba! Size nasıl yardımcı olabilirim?"
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        log(f"❌ Session creation error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/chat")
+async def chat(req: ChatRequest, x_session_id: str = Header(...)):
+    """Process chat message"""
+    try:
+        # Get session
+        session = session_store.get(x_session_id)
+        if not session:
+            raise HTTPException(status_code=404, detail="Session not found or expired")
+        
+        # Add user message to history
+        session.add_message("user", req.message)
+        log(f"💬 User [{session.session_id[:8]}...]: {req.message}")
+        
+        # Get project and version config
+        project = next((p for p in cfg.projects if p.name == session.project_name), None)
+        if not project:
+            raise HTTPException(status_code=404, detail=f"Project '{session.project_name}' not found")
+        
+        version = session.get_version_config()
+        if not version:
+            raise HTTPException(status_code=400, detail="Version config not found in session")
+        
+        # Process based on current state
+        if session.state == "idle":
+            # Build intent detection prompt
+            prompt = build_intent_prompt(version, session.chat_history, project.default_locale)
+            raw = await llm_generate(session, prompt, req.message)
+            
+            # Check for intent
+            intent_name, tail = _safe_intent_parse(raw)
+            
+            if intent_name:
+                # Find intent config
+                intent_config = next((i for i in version.intents if i.name == intent_name), None)
+                
+                if intent_config:
+                    session.current_intent = intent_name
+                    session.intent_config = intent_config
+                    session.state = "collect_params"
+                    log(f"🎯 Intent detected: {intent_name}")
+                    
+                    # Check if parameters were already extracted
+                    if tail and _extract_parameters_from_response(tail, session, intent_config):
+                        log("📦 Some parameters extracted from initial response")
+                    
+                    # Check what parameters are missing
+                    missing_params = [
+                        p for p in intent_config.parameters
+                        if p.required and p.variable_name not in session.variables
+                    ]
+                    
+                    if not missing_params:
+                        # All required parameters collected, execute API
+                        response = await _execute_api_call(session, intent_config)
+                        session.add_message("assistant", response)
+                        return {"response": response, "intent": intent_name, "state": "completed"}
+                    else:
+                        # Need to collect more parameters
+                        param_prompt = build_parameter_prompt(
+                            intent_config, 
+                            session.variables, 
+                            session.chat_history,
+                            project.default_locale
+                        )
+                        param_question = await llm_generate(session, param_prompt, req.message)
+                        clean_question = _trim_response(param_question)
+                        session.add_message("assistant", clean_question)
+                        return {"response": clean_question, "intent": intent_name, "state": "collecting_params"}
+                else:
+                    log(f"⚠️ Unknown intent: {intent_name}")
+            
+            # No intent detected, return general response
+            clean_response = _trim_response(raw)
+            session.add_message("assistant", clean_response)
+            return {"response": clean_response, "state": "idle"}
+            
+        elif session.state == "collect_params":
+            # Continue parameter collection
+            intent_config = session.intent_config
+            
+            # Try to extract parameters from user message
+            param_prompt = f"""
+            Extract parameters from user message: "{req.message}"
+            
+            Expected parameters:
+            {json.dumps([{
+                'name': p.name,
+                'type': p.type,
+                'required': p.required,
+                'extraction_prompt': p.extraction_prompt
+            } for p in intent_config.parameters if p.variable_name not in session.variables], ensure_ascii=False)}
+            
+            Return as JSON object with parameter names as keys.
+            """
+            
+            raw = await llm_generate(session, param_prompt, req.message)
+            _extract_parameters_from_response(raw, session, intent_config)
+            
+            # Check what parameters are still missing
+            missing_params = [
+                p for p in intent_config.parameters
+                if p.required and p.variable_name not in session.variables
+            ]
+            
+            if not missing_params:
+                # All parameters collected, execute API
+                response = await _execute_api_call(session, intent_config)
+                session.add_message("assistant", response)
+                return {"response": response, "intent": session.current_intent, "state": "completed"}
+            else:
+                # Still need more parameters
+                param_prompt = build_parameter_prompt(
+                    intent_config, 
+                    session.variables, 
+                    session.chat_history,
+                    project.default_locale
+                )
+                param_question = await llm_generate(session, param_prompt, req.message)
+                clean_question = _trim_response(param_question)
+                session.add_message("assistant", clean_question)
+                return {"response": clean_question, "intent": session.current_intent, "state": "collecting_params"}
+        
+        else:
+            # Unknown state, reset
+            session.reset_flow()
+            return {"response": "Bir hata oluştu, lütfen tekrar deneyin.", "state": "error"}
+            
+    except HTTPException:
+        raise
+    except Exception as e:
+        log(f"❌ Chat error: {e}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))
+
 # Initialize LLM on module load
 setup_llm_provider()