Update chat_handler.py

chat_handler.py

@@ -18,9 +18,20 @@ from validation_engine import validate
 from session import session_store, Session
 from llm_interface import LLMInterface, SparkLLM, GPT4oLLM
 from config_provider import ConfigProvider
-from locale_manager import LocaleManager
 
-# ─────────────────────────  GLOBAL ───────────────────────── #
+# ─────────────────────────  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()
+
 # Global LLM instance
 llm_provider: Optional[LLMInterface] = None
 
@@ -52,83 +63,93 @@ def _safe_intent_parse(raw: str) -> tuple[str, str]:
     tail = raw[m.end():]
     log(f"🎯 Parsed intent: {name}")
     return name, tail
-    
-# ─────────────────────────  SPARK ───────────────────────── #
-def initialize_llm(force_reload=False):
-    """Initialize LLM provider based on work_mode"""
+
+# ─────────────────────────  LLM SETUP ───────────────────────── #
+def setup_llm_provider():
+    """Initialize LLM provider based on internal_prompt config"""
     global llm_provider
     
-    cfg = ConfigProvider.get()
-    
-    work_mode = cfg.global_config.work_mode
-    
-    if cfg.global_config.is_gpt_mode():
-        # GPT mode
-        api_key = cfg.global_config.get_plain_token()
+    cfg = ConfigProvider.get()  # Her zaman güncel config'i al
+    internal_prompt = cfg.global_config.internal_prompt
+    if not internal_prompt:
+        log("⚠️ No internal_prompt configured, using default Spark")
+        llm_provider = SparkLLM(cfg)
+        return
+    
+    # Parse internal prompt format: "provider:model"
+    parts = internal_prompt.split(":", 1)
+    if len(parts) != 2:
+        log(f"⚠️ Invalid internal_prompt format: {internal_prompt}, using Spark")
+        llm_provider = SparkLLM(cfg)
+        return
+    
+    provider, model = parts[0].lower(), parts[1]
+    
+    if provider == "openai":
+        # Get API key from environment
+        api_key = os.getenv("OPENAI_API_KEY")
         if not api_key:
-            raise ValueError("OpenAI API key not configured")
+            log("❌ OPENAI_API_KEY not found in environment")
+            llm_provider = SparkLLM(cfg)
+            return
         
-        model = cfg.global_config.get_gpt_model()
+        log(f"🤖 Using OpenAI with model: {model}")
         llm_provider = GPT4oLLM(api_key, model)
-        log(f"✅ Initialized {model} provider")
     else:
-        # Spark mode
-        spark_token = _get_spark_token()
-        if not spark_token:
-            raise ValueError("Spark token not configured")
-            
-        spark_endpoint = str(cfg.global_config.spark_endpoint)
-        llm_provider = SparkLLM(spark_endpoint, spark_token)
-        log("✅ Initialized Spark provider")
-
-# ─────────────────────────  SPARK ───────────────────────── #
-def _get_spark_token() -> Optional[str]:
-    """Get Spark token based on work_mode"""
-    cfg = ConfigProvider.get()
-
-    work_mode = cfg.global_config.work_mode
-    
-    if cfg.global_config.is_cloud_mode(): 
-        token = os.getenv("SPARK_TOKEN")
-        if not token and not cfg.global_config.is_gpt_mode():
-            # GPT modları için SPARK_TOKEN gerekmez
-            log("❌ SPARK_TOKEN not found in cloud Secrets!")
-        return token
-    else:
-        # On-premise mode - use .env file
-        from dotenv import load_dotenv
-        load_dotenv()
-        return os.getenv("SPARK_TOKEN")
+        log(f"⚠️ Unknown provider: {provider}, using Spark")
+        llm_provider = SparkLLM(cfg)
 
+# ─────────────────────────  SPARK/LLM CALL ───────────────────────── #
 async def spark_generate(s: Session, prompt: str, user_msg: str) -> str:
-    """Call LLM provider with proper error handling"""
+    """Call LLM (Spark or configured provider) with proper error handling"""
+    global llm_provider
+    
+    if llm_provider is None:
+        setup_llm_provider()
+    
     try:
-        # Always reinitialize to get fresh config
-        initialize_llm(force_reload=True)
-        
-        if not llm_provider:
-            raise ValueError("Failed to initialize LLM provider")
+        # Get version config from session
+        version = s.get_version_config()
+        if not version:
+            # 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")
+        
+        log(f"🚀 Calling LLM for session {s.session_id[:8]}...")
+        log(f"📋 Prompt preview (first 200 chars): {prompt[:200]}...")
+        
+        # Call the configured LLM provider
+        raw = await llm_provider.generate(
+            project_name=s.project_name,
+            user_input=user_msg,
+            system_prompt=prompt,
+            context=s.chat_history[-10:],
+            version_config=version
+        )
         
-        # Use the abstract interface
-        raw = await llm_provider.generate(prompt, user_msg, s.chat_history)
         log(f"🪄 LLM raw response: {raw[:120]!r}")
         return raw
-        
+            
+    except httpx.TimeoutException:
+        log(f"⏱️ LLM timeout for session {s.session_id[:8]}")
+        raise
     except Exception as e:
         log(f"❌ LLM error: {e}")
         raise
 
+# ─────────────────────────  ALLOWED INTENTS ───────────────────────── #
+ALLOWED_INTENTS = {"flight-booking", "flight-info", "booking-cancel"}
+
 # ─────────────────────────  FASTAPI ───────────────────────── #
 router = APIRouter()
 
-@router.get("/health")
-def health_check():
-    """Health check endpoint for monitoring"""
-    return {
-        "status": "ok",
-        "sessions": len(session_store._sessions),
-        "timestamp": datetime.now().isoformat()
-    }
+@router.get("/")
+def health(): 
+    return {"status": "ok", "sessions": len(session_store._sessions)}
 
 class StartRequest(BaseModel): 
     project_name: str
@@ -144,19 +165,17 @@ class ChatResponse(BaseModel):
 async def start_session(req: StartRequest):
     """Create new session"""
     try:
-        cfg = ConfigProvider.get()
-
         # 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")
-
-        # Get published version
+        
+        # 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 found for project '{req.project_name}'")
-
-        # Create session
+            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)
@@ -194,10 +213,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 parametresi kaldırıldı
+            answer = await _handle_parameter_followup(session, user_input)
         else:
             log("🆕 Handling new message")
-            answer = await _handle_new_message(session, user_input)  # version parametresi kaldırıldı
+            answer = await _handle_new_message(session, user_input)
         
         session.add_turn("assistant", answer)
         return ChatResponse(session_id=session.session_id, answer=answer)
@@ -226,8 +245,7 @@ async def _handle_new_message(session: Session, user_input: str) -> str:
         version.general_prompt,
         session.chat_history,
         user_input,
-        version.intents,
-        session.project_name
+        version.intents
     )
     
     # Get LLM response
@@ -247,10 +265,9 @@ async def _handle_new_message(session: Session, user_input: str) -> str:
     # Parse intent
     intent_name, tail = _safe_intent_parse(raw)
     
-    # Validate intent against version's intents
-    valid_intents = {intent.name for intent in version.intents}
-    if intent_name not in valid_intents:
-        log(f"⚠️ Invalid intent: {intent_name} (valid: {valid_intents})")
+    # 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)
@@ -274,8 +291,8 @@ async def _handle_new_message(session: Session, user_input: str) -> str:
     # Extract parameters
     return await _extract_parameters(session, intent_config, user_input)
 
-async def _handle_parameter_followup(session: Session, user_input: str, version) -> str:
-    """Handle parameter collection followup with smart question generation"""
+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()
@@ -295,6 +312,51 @@ async def _handle_parameter_followup(session: Session, user_input: str, version)
         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}")
+        
+        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}")
@@ -331,40 +393,80 @@ async def _handle_parameter_followup(session: Session, user_input: str, version)
             session.reset_flow()
             return "Üzgünüm, istediğiniz bilgileri anlayamadım. Başka bir konuda yardımcı olabilir miyim?"
         
-        session.missing_ask_count += 1
-        
-        # Akıllı soru üret
-        question = await _generate_smart_parameter_question(
-            session, intent_config, still_missing, version
-        )
-        
-        # Sorulan parametreleri tahmin et ve kaydet
-        params_in_question = extract_params_from_question(question, still_missing, intent_config)
-        session.record_parameter_question(params_in_question)
-        session.awaiting_parameters = params_in_question
-        
-        log(f"🤖 Smart question generated for params: {params_in_question}")
-        return question
+        # Smart parameter question oluştur
+        return await _generate_smart_parameter_question(session, intent_config, still_missing)
     
-    # All parameters collected, call API
+    # Tüm parametreler toplandı
     log("✅ All parameters collected, calling API")
     session.state = "call_api"
     return await _execute_api_call(session, intent_config)
 
-# ─────────────────────────  PARAMETER HANDLING ───────────────────────── #
-async def _extract_parameters(session: Session, intent_config, user_input: str) -> str:
-    """Extract parameters from user input with smart question generation"""
-
-    # Version config'i al
-    version = session.get_version_config()
-    if not version:
-        log("❌ Version config not found")
-        return "Bir hata oluştu. Lütfen tekrar deneyin."
+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
+    )
     
-    # Yeni intent için parametre takibini sıfırla
-    if session.parameter_ask_rounds == 0:
-        session.reset_parameter_tracking()
+    # 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}")
     
@@ -374,7 +476,7 @@ async def _extract_parameters(session: Session, intent_config, user_input: str)
         return await _execute_api_call(session, intent_config)
     
     # Build parameter extraction prompt
-    prompt = build_parameter_prompt(intent_config, missing, user_input, session.chat_history, intent_config.locale)
+    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
@@ -387,133 +489,24 @@ async def _extract_parameters(session: Session, intent_config, user_input: str)
         log("⚠️ Failed to extract parameters from response")
     
     if missing:
-        # Still missing parameters - generate smart question
-        session.state = "await_param"
-        session.missing_ask_count = 0
-        
-        # Akıllı soru üret
-        question = await _generate_smart_parameter_question(
-            session, intent_config, missing, version
-        )
-        
-        # Sorulan parametreleri tahmin et ve kaydet
-        params_in_question = extract_params_from_question(question, missing, intent_config)
-        session.record_parameter_question(params_in_question)
-        session.awaiting_parameters = params_in_question
-        
-        log(f"🤖 Smart question generated for initial params: {params_in_question}")
-        return question
+        # 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)
 
-async def _generate_smart_parameter_question(
-    session: Session, 
-    intent_config,
-    missing_params: List[str],
-    version
-) -> str:
-    """LLM kullanarak doğal parametre sorusu üret"""
-    cfg = ConfigProvider.get()
-    
-    # Config'i al
-    collection_config = cfg.global_config.parameter_collection_config
-    
-    # Öncelik sıralaması: önce cevaplanmayanlar
-    prioritized_params = []
-    
-    # 1. Daha önce sorulup cevaplanmayanlar
-    for param in session.unanswered_parameters:
-        if param in missing_params:
-            prioritized_params.append(param)
-            log(f"🔝 Priority param (unanswered): {param}")
-    
-    # 2. Hiç sorulmamışlar
-    for param in missing_params:
-        if param not in prioritized_params:
-            prioritized_params.append(param)
-            log(f"➕ Additional param (not asked): {param}")
-    
-    # Maksimum parametre sayısını belirle
-    max_params = min(
-        len(prioritized_params),
-        collection_config.max_params_per_question
-    )
-    params_to_ask = prioritized_params[:max_params]
-    
-    log(f"📋 Params to ask in this round: {params_to_ask}")
-    
-    # Proje dilini belirle
-    project = next((p for p in cfg.projects if p.name == session.project_name), None)
-    if project and hasattr(project, 'default_language'):
-        # default_language locale code'dur (tr-TR, en-US vb.)
-        project_locale_code = project.default_language
-        # Locale'den dil adını al
-        locale_data = LocaleManager.get_locale(project_locale_code)
-        project_language = locale_data.get('name', 'Turkish')
-    else:
-        project_locale_code = 'tr-TR'
-        project_language = 'Turkish'
-    
-    log(f"📋 Project locale: {project_locale_code}, language: {project_language}")
-    
-    # Prompt oluştur
-    prompt = build_smart_parameter_question_prompt(
-        collection_config,
-        intent_config,
-        params_to_ask,  # Sadece bu turda sorulacak parametreler
-        session,
-        project_language,
-        intent_config.locale  # Locale code'u da gönder
-    )
-    
-    # LLM'den soru üret
-    response = await spark_generate(session, prompt, "")
-    
-    # Güvenlik: Eğer LLM boş veya hatalı response verirse fallback
-    if not response or len(response.strip()) < 10:
-        log("⚠️ Empty or invalid response from LLM, using fallback")
-        # En yüksek öncelikli parametre için fallback soru
-        param = params_to_ask[0]
-        param_config = next(p for p in intent_config.parameters if p.name == param)
-        
-        # Intent'in locale'ini kullan
-        intent_locale_code = getattr(intent_config, 'locale', project_locale_code)
-        locale_data = LocaleManager.get_locale(intent_locale_code)
-        
-        # Parametrenin kaç kez sorulduğuna göre farklı fallback
-        ask_count = session.get_parameter_ask_count(param)
-        fallback_questions = locale_data.get('parameter_collection', {}).get('fallback_questions', {})
-        
-        # Caption'ı küçük harfe çevir (Türkçe için özel)
-        caption = param_config.caption
-        if intent_locale_code.startswith('tr'):
-            caption_lower = caption.lower()
-        else:
-            caption_lower = caption
-        
-        if ask_count == 0:
-            template = fallback_questions.get('first_ask', '{caption} bilgisini alabilir miyim?')
-            return template.replace('{caption}', caption)
-        elif ask_count == 1:
-            template = fallback_questions.get('second_ask', 'Lütfen {caption} bilgisini paylaşır mısınız?')
-            return template.replace('{caption}', caption_lower)
-        else:
-            template = fallback_questions.get('third_ask', 'Devam edebilmem için {caption} bilgisine ihtiyacım var.')
-            return template.replace('{caption}', caption_lower)
-    
-    # Response'u temizle
-    clean_response = response.strip()
-    
-    # Eğer response yanlışlıkla başka şeyler içeriyorsa temizle
-    if "#" in clean_response or "assistant:" in clean_response.lower():
-        # İlk satırı al
-        clean_response = clean_response.split('\n')[0].strip()
-    
-    log(f"💬 Generated smart question: {clean_response[:100]}...")
-    return clean_response
-
 def _get_missing_parameters(session: Session, intent_config) -> List[str]:
     """Get list of missing required parameters"""
     missing = [
@@ -588,16 +581,6 @@ def _process_parameters(session: Session, intent_config, raw: str) -> bool:
             if not param_config:
                 log(f"⚠️ Parameter config not found for: {param_name}")
                 continue
-
-            # Date tipi için özel kontrol
-            if param_config.type == "date":
-                try:
-                    # ISO format kontrolü
-                    from datetime import datetime
-                    datetime.strptime(str(param_value), "%Y-%m-%d")
-                except ValueError:
-                    log(f"❌ Invalid date format for {param_name}: {param_value}")
-                    continue
             
             # Validate parameter
             if validate(str(param_value), param_config):
@@ -612,42 +595,17 @@ def _process_parameters(session: Session, intent_config, raw: str) -> bool:
     except json.JSONDecodeError as e:
         log(f"❌ JSON parsing error: {e}")
         log(f"❌ Failed to parse: {raw[:200]}")
-        
-        # Fallback: Try to extract simple values from user input
-        # This is especially useful for single parameter responses
-        if session.state == "await_param" and len(session.awaiting_parameters) > 0:
-            # Get the first missing parameter
-            first_missing = session.awaiting_parameters[0]
-            param_config = next(
-                (p for p in intent_config.parameters if p.name == first_missing),
-                None
-            )
-            
-            if param_config and session.chat_history:
-                # Get the last user input
-                last_user_input = session.chat_history[-1].get("content", "").strip()
-                
-                # For simple inputs like city names, try direct assignment
-                if param_config.type in ["str", "string"] and len(last_user_input.split()) <= 3:
-                    if validate(last_user_input, param_config):
-                        session.variables[param_config.variable_name] = last_user_input
-                        log(f"✅ Fallback extraction: {first_missing}={last_user_input}")
-                        return True
-        
         return False
     except Exception as e:
         log(f"❌ Parameter processing error: {e}")
         return False
-        
+
 # ─────────────────────────  API EXECUTION ───────────────────────── #
 async def _execute_api_call(session: Session, intent_config) -> str:
     """Execute API call and return humanized response"""
     try:
         session.state = "call_api"
         api_name = intent_config.action
-
-        cfg = ConfigProvider.get()
-
         api_config = cfg.get_api(api_name)
         
         if not api_config:
@@ -671,10 +629,8 @@ async def _execute_api_call(session: Session, intent_config) -> str:
                 json.dumps(api_json, ensure_ascii=False)
             )
             human_response = await spark_generate(session, prompt, json.dumps(api_json))
-            # Trim response to remove any trailing "assistant" artifacts
-            trimmed_response = _trim_response(human_response)
             session.reset_flow()
-            return trimmed_response if trimmed_response else f"İşlem sonucu: {api_json}"
+            return human_response if human_response else f"İşlem sonucu: {api_json}"
         else:
             session.reset_flow()
             return f"İşlem tamamlandı: {api_json}"
@@ -686,4 +642,7 @@ async def _execute_api_call(session: Session, intent_config) -> str:
     except Exception as e:
         log(f"❌ API call error: {e}")
         session.reset_flow()
-        return intent_config.fallback_error_prompt or "İşlem sırasında bir hata oluştu."
+        return intent_config.fallback_error_prompt or "İşlem sırasında bir hata oluştu."
+
+# Initialize LLM on module load
+setup_llm_provider()