Update chat_handler.py

chat_handler.py

@@ -1,5 +1,5 @@
 """
-Flare – Chat Handler  (v1.5 · modüler yapı)
+Flare – Chat Handler  (v1.6 · detaylı log)
 ==========================================
 """
 
@@ -16,6 +16,7 @@ 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
+
 # ─────────────────────────  HELPERS ───────────────────────── #
 def _trim_response(raw: str) -> str:
     """
@@ -38,6 +39,7 @@ def _safe_intent_parse(raw: str) -> tuple[str, str]:
         return "", raw
     name = m.group(1)
     tail = raw[m.end():]
+    log(f"🎯 Parsed intent: {name}")
     return name, tail
 
 # ─────────────────────────  CONFIG ───────────────────────── #
@@ -65,6 +67,8 @@ async def spark_generate(s: Session, prompt: str, user_msg: str) -> str:
         }
         
         log(f"🚀 Calling Spark for session {s.session_id[:8]}...")
+        log(f"📋 Prompt preview (first 200 chars): {prompt[:200]}...")
+        
         async with httpx.AsyncClient(timeout=60) as client:
             response = await client.post(SPARK_URL + "/generate", json=payload)
             response.raise_for_status()
@@ -130,6 +134,9 @@ async def chat(body: ChatRequest, x_session_id: str = Header(...)):
         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}")
+        
         session.add_turn("user", user_input)
         
         # Get project config
@@ -143,8 +150,10 @@ async def chat(body: ChatRequest, x_session_id: str = Header(...)):
 
         # 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, version)
         else:
+            log("🆕 Handling new message")
             answer = await _handle_new_message(session, user_input, version)
         
         session.add_turn("assistant", answer)
@@ -175,11 +184,13 @@ async def _handle_new_message(session: Session, user_input: str, version) -> str
     
     # Empty response fallback
     if not raw:
+        log("⚠️ Empty response from Spark")
         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
@@ -187,19 +198,26 @@ async def _handle_new_message(session: Session, user_input: str, version) -> str
     
     # 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)
@@ -207,23 +225,29 @@ async def _handle_new_message(session: Session, user_input: str, version) -> str
 async def _handle_parameter_followup(session: Session, user_input: str, version) -> 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 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."
     
     # 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)
     raw = await spark_generate(session, prompt, user_input)
     
     if not raw.startswith("#PARAMETERS:"):
         # Increment miss count
         session.missing_ask_count += 1
+        log(f"⚠️ No parameters extracted, miss count: {session.missing_ask_count}")
+        
         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?"
@@ -232,16 +256,20 @@ async def _handle_parameter_followup(session: Session, user_input: str, version)
     # Process parameters
     success = _process_parameters(session, intent_config, raw)
     if not success:
+        log("❌ Parameter processing failed")
         return "Girdiğiniz bilgilerde bir hata var. Lütfen kontrol edip tekrar deneyin."
     
     # 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)
 
@@ -249,8 +277,11 @@ async def _handle_parameter_followup(session: Session, user_input: str, version)
 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
@@ -261,6 +292,9 @@ async def _extract_parameters(session: Session, intent_config, user_input: str)
         success = _process_parameters(session, intent_config, raw)
         if success:
             missing = _get_missing_parameters(session, intent_config)
+            log(f"📊 After extraction, missing: {missing}")
+    else:
+        log("⚠️ No #PARAMETERS tag in response")
     
     if missing:
         # Still missing parameters
@@ -268,25 +302,32 @@ async def _extract_parameters(session: Session, intent_config, user_input: str)
         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"""
-    return [
+    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
 
 def _process_parameters(session: Session, intent_config, raw: str) -> bool:
     """Process parameter extraction response"""
     try:
         json_str = raw[len("#PARAMETERS:"):]
+        log(f"🔍 Parsing parameters JSON: {json_str[:200]}")
         data = json.loads(json_str)
         
         extracted = data.get("extracted", [])
+        log(f"📦 Extracted data: {extracted}")
+        
         any_valid = False
         
         for param_data in extracted:
@@ -294,6 +335,7 @@ def _process_parameters(session: Session, intent_config, raw: str) -> bool:
             param_value = param_data.get("value")
             
             if not param_name or not param_value:
+                log(f"⚠️ Invalid param data: {param_data}")
                 continue
             
             # Find parameter config
@@ -302,13 +344,14 @@ def _process_parameters(session: Session, intent_config, raw: str) -> bool:
                 None
             )
             if not param_config:
+                log(f"⚠️ Parameter config not found for: {param_name}")
                 continue
             
             # Validate parameter
             if validate(str(param_value), param_config):
                 session.variables[param_config.variable_name] = str(param_value)
                 any_valid = True
-                log(f"✅ Extracted {param_name}={param_value}")
+                log(f"✅ Extracted {param_name}={param_value} → {param_config.variable_name}")
             else:
                 log(f"❌ Invalid {param_name}={param_value}")
         
@@ -327,14 +370,17 @@ async def _execute_api_call(session: Session, intent_config) -> str:
         api_config = cfg.get_api(api_name)
         
         if not api_config:
+            log(f"❌ API config not found: {api_name}")
             session.reset_flow()
             return intent_config.fallback_error_prompt or "İşlem başarısız oldu."
         
         log(f"📡 Calling API: {api_name}")
+        log(f"📦 API variables: {session.variables}")
         
         # Execute API call with session
-        response = execute_api(api_config, session)  # Pass session instead of just variables
+        response = execute_api(api_config, session)
         api_json = response.json()
+        log(f"✅ API response: {api_json}")
         
         # Humanize response
         session.state = "humanize"
@@ -351,6 +397,7 @@ async def _execute_api_call(session: Session, intent_config) -> str:
             return f"İşlem tamamlandı: {api_json}"
             
     except requests.exceptions.Timeout:
+        log(f"⏱️ API timeout: {api_name}")
         session.reset_flow()
         return intent_config.fallback_timeout_prompt or "İşlem zaman aşımına uğradı."
     except Exception as e: