Delete chat_handler.py

chat_handler.py

@@ -1,720 +0,0 @@
-"""
-Flare – Chat Handler (Refactored with LLM Factory)
-==========================================
-"""
-
-import re, json, sys, httpx, os
-from datetime import datetime
-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
-from logger import log_info, log_error, log_warning, log_debug
-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
-
-# Initialize router
-router = APIRouter()
-
-# ─────────────────────────  GLOBAL VARS ───────────────────────── #
-cfg = ConfigProvider.get()
-llm_provider = None
-
-# ─────────────────────────  HELPERS ───────────────────────── #
-def _trim_response(raw: str) -> str:
-    """
-    Remove everything after the first logical assistant block or intent tag.
-    Also strips trailing 'assistant' artifacts and prompt injections.
-    """
-    # Stop at our own rules if model leaked them
-    for stop in ["#DETECTED_INTENT", "⚠️", "\nassistant", "assistant\n", "assistant"]:
-        idx = raw.find(stop)
-        if idx != -1:
-            raw = raw[:idx]
-    # Normalise selamlama
-    raw = re.sub(r"Hoş[\s-]?geldin(iz)?", "Hoş geldiniz", raw, flags=re.IGNORECASE)
-    return raw.strip()
-
-def _safe_intent_parse(raw: str) -> tuple[str, str]:
-    """Extract intent name and extra tail."""
-    m = re.search(r"#DETECTED_INTENT:\s*([A-Za-z0-9_-]+)", raw)
-    if not m:
-        return "", raw
-    name = m.group(1)
-    # Remove 'assistant' suffix if exists
-    if name.endswith("assistant"):
-        name = name[:-9]  # Remove last 9 chars ("assistant")
-        log_info(f"🔧 Removed 'assistant' suffix from intent name")
-    tail = raw[m.end():]
-    log_info(f"🎯 Parsed intent: {name}")
-    return name, tail
-
-# ─────────────────────────  LLM SETUP ───────────────────────── #
-def setup_llm_provider():
-    """Initialize LLM provider using factory pattern"""
-    global llm_provider
-    
-    try:
-        from llm_factory import LLMFactory
-        llm_provider = LLMFactory.create_provider()
-        log_info("✅ LLM provider initialized successfully")
-    except Exception as e:
-        log_error("❌ Failed to initialize LLM provider", e)
-        raise
-
-# ─────────────────────────  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 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_info(f"🚀 Calling LLM for session {s.session_id[:8]}...")
-        log_info(f"📋 Prompt preview (first 200 chars): {prompt[:200]}...")
-
-        history = s.chat_history
-        
-        # Call the configured LLM provider
-        raw = await llm_provider.generate(
-            user_input=user_msg,
-            system_prompt=prompt,
-            context=history[-10:] if history else []
-        )
-        
-        log_info(f"🪄 LLM raw response: {raw[:100]}...")
-        return raw
-        
-    except requests.exceptions.Timeout:
-        log_warning(f"⏱️ LLM timeout for session {s.session_id[:8]}")
-        raise HTTPException(status_code=504, detail="LLM request timed out")
-    except Exception as e:
-        log_error("❌ LLM error", e)
-        raise HTTPException(status_code=500, detail=f"LLM error: {str(e)}")
-
-# ─────────────────────────  PARAMETER EXTRACTION ───────────────────────── #
-def _extract_parameters_from_response(raw: str, session: Session, intent_config) -> bool:
-    """Extract parameters from the LLM response"""
-    try:
-        # 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)
-        
-        if not json_match:
-            log_info("❌ No JSON found in response")
-            return False
-        
-        json_str = json_match.group(1) if '```' in raw else json_match.group(0)
-        params = json.loads(json_str)
-        
-        any_valid = False
-        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_info(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_info(f"✅ Extracted {param_name}={param_value} → {param_config.variable_name}")
-            else:
-                log_info(f"❌ Invalid {param_name}={param_value}")
-        
-        return any_valid
-        
-    except json.JSONDecodeError as e:
-        log_error("❌ JSON parsing error", e)
-        log_error(f"❌ Failed to parse: {raw[:200]}")
-        return False
-    except Exception as e:
-        log_error("❌ 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 with better error handling"""
-    try:
-        session.state = "call_api"
-        api_name = intent_config.action
-        api_config = cfg.get_api(api_name)
-        
-        if not api_config:
-            log_info(f"❌ API config not found: {api_name}")
-            session.reset_flow()
-            return get_user_friendly_error("api_error", {"api_name": api_name})
-        
-        log_info(f"📡 Calling API: {api_name}")
-        log_info(f"📦 API variables: {session.variables}")
-        
-        # Execute API call with session
-        response = execute_api(api_config, session)
-        api_json = response.json()
-        log_info(f"✅ API response: {api_json}")
-        
-        # Humanize response
-        session.state = "humanize"
-        if api_config.response_prompt:
-            prompt = api_config.response_prompt.replace(
-                "{{api_response}}", 
-                json.dumps(api_json, ensure_ascii=False)
-            )
-            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:
-            session.reset_flow()
-            return f"İşlem tamamlandı: {api_json}"
-            
-    except requests.exceptions.Timeout:
-        log_warning(f"⏱️ API timeout: {api_name}")
-        session.reset_flow()
-        return get_user_friendly_error("api_timeout")
-    except Exception as e:
-        log_error("❌ API call error", e)
-        session.reset_flow()
-        return get_user_friendly_error("api_error", {"api_name": api_name})
-
-# ─────────────────────────  REQUEST MODELS ───────────────────────── #
-class ChatRequest(BaseModel):
-    message: str
-
-class StartRequest(BaseModel): 
-    project_name: str
-    version_no: Optional[int] = None # Opsiyonel, belirtilmezse published olan en büyük version no'yu kullan
-    is_realtime: bool = False
-    locale: Optional[str] = None
-
-class ChatResponse(BaseModel):  
-    session_id: str
-    answer: str
-    
-# ─────────────────────────  API ENDPOINTS ───────────────────────── #
-@router.post("/start_session", response_model=ChatResponse)
-async def start_session(req: StartRequest):
-    """Create new session"""
-    global llm_provider
-    
-    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")
-
-        # Determine locale
-        session_locale = req.locale
-        if not session_locale:
-            # Use project's default locale
-            session_locale = project.default_locale        
-
-        # Validate locale is supported by project
-        if session_locale not in project.supported_locales:
-            raise HTTPException(
-                400, 
-                f"Locale '{session_locale}' not supported by project. Supported: {project.supported_locales}"
-            )
-        
-        # Find version
-        if req.version_no:
-            # Specific version requested
-            version = next((v for v in project.versions if v.no == req.version_no), None)
-            if not version:
-                raise HTTPException(404, f"Version {req.version_no} not found for project '{req.project_name}'")
-        else:
-            # Find published version with highest version number
-            published_versions = [v for v in project.versions if v.published]
-            if not published_versions:
-                raise HTTPException(404, f"No published version for project '{req.project_name}'")
-            
-            # Sort by version number (no) and get the highest
-            version = max(published_versions, key=lambda v: v.no)
-        
-        # Create LLM provider if not exists
-        if not llm_provider:
-            from llm_factory import LLMFactory
-            llm_provider = LLMFactory.create_provider()
-            log_info(f"🤖 LLM Provider created: {type(llm_provider).__name__}")
-        
-        # Create session with version config - PARAMETRE DÜZELTMESİ
-        session = session_store.create_session(
-            project_name=req.project_name,
-            version_no=version.no,
-            is_realtime=req.is_realtime,
-            locale=session_locale
-        )
-        
-        # Version config'i session'a ekle
-        session.set_version_config(version)
-        
-        # Welcome prompt'u işle
-        greeting = "Hoş geldiniz! Size nasıl yardımcı olabilirim?"
-        if version.welcome_prompt:
-            log_info(f"🎉 Processing welcome prompt for session {session.session_id[:8]}...")
-            try:
-                # Welcome prompt'u LLM'e gönder
-                welcome_result = await llm_provider.generate(
-                    user_input="",
-                    system_prompt=version.welcome_prompt,
-                    context=[]
-                )
-                if welcome_result and welcome_result.strip():
-                    greeting = welcome_result.strip()
-            except Exception as e:
-                log_error("⚠️ Welcome prompt processing failed", e)
-                # Fallback to default greeting
-        
-        session.add_turn("assistant", greeting)
-        
-        log_info(f"✅ Session created for project '{req.project_name}' version {version.no} (highest published)")
-        
-        return ChatResponse(session_id=session.session_id, answer=greeting)
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        log_error("❌ Session creation error", e)
-        raise HTTPException(500, f"Session creation failed: {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_session(x_session_id)
-        if not session:
-            # Better error message
-            raise HTTPException(
-                status_code=404, 
-                detail=get_user_friendly_error("session_not_found")
-            )
-        
-        # Session expiry check ekle
-        if session.is_expired():
-            session_store.delete_session(x_session_id)
-            raise HTTPException(
-                status_code=401,
-                detail=get_user_friendly_error("session_expired")
-            )
-        
-        # Update last activity
-        session.last_activity = datetime.utcnow().isoformat()
-        session_store.update_session(session)
-        
-        # Mevcut kod devam ediyor...
-        # Add user message to history
-        session.add_message("user", req.message)
-        log_info(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=get_user_friendly_error("project_not_found")
-            )
-        
-        version = session.get_version_config()
-        if not version:
-            raise HTTPException(
-                status_code=400, 
-                detail=get_user_friendly_error("version_not_found")
-            )
-        
-        # 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_info(f"🎯 Intent detected: {intent_name}")
-                    
-                    # Check if parameters were already extracted
-                    if tail and _extract_parameters_from_response(tail, session, intent_config):
-                        log_info("📦 Some parameters extracted from initial response")
-                    
-                    # Check what parameters are missing
-                    missing_params = [
-                        p.name 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
-                        # Get parameter collection config
-                        collection_config = cfg.global_config.llm_provider.settings.get("parameter_collection_config", {})
-                        max_params = collection_config.get("max_params_per_question", 2)
-                        
-                        # Decide which parameters to ask
-                        params_to_ask = missing_params[:max_params]
-                        
-                        param_prompt = build_parameter_prompt(
-                            version=version,
-                            intent_config=intent_config,
-                            chat_history=session.chat_history,
-                            collected_params=session.variables,
-                            missing_params=missing_params,
-                            params_to_ask=params_to_ask,
-                            max_params=max_params,
-                            project_locale=project.default_locale,
-                            unanswered_params=session.unanswered_parameters
-                        )
-                        
-                        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_info(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.name 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
-                # Get parameter collection config
-                collection_config = cfg.global_config.llm_provider.settings.get("parameter_collection_config", {})
-                max_params = collection_config.get("max_params_per_question", 2)
-                
-                # Decide which parameters to ask
-                params_to_ask = missing_params[:max_params]
-                
-                param_prompt = build_parameter_prompt(
-                    version=version,
-                    intent_config=intent_config,
-                    chat_history=session.chat_history,
-                    collected_params=session.variables,
-                    missing_params=missing_params,
-                    params_to_ask=params_to_ask,
-                    max_params=max_params,
-                    project_locale=project.default_locale,
-                    unanswered_params=session.unanswered_parameters
-                )
-                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": get_user_friendly_error("internal_error"), "state": "error"}
-            
-    except HTTPException:
-        raise
-    except requests.exceptions.Timeout:
-        # Better timeout error
-        log_error(f"Timeout in chat for session {x_session_id[:8]}")
-        return {
-            "response": get_user_friendly_error("llm_timeout"),
-            "state": "error",
-            "error": True
-        }
-    except Exception as e:
-        log_error("❌ Chat error", e)
-        import traceback
-        traceback.print_exc()
-        # Better generic error
-        return {
-            "response": get_user_friendly_error("internal_error"),
-            "state": "error",
-            "error": True
-        }
-
-async def handle_new_message(session: Session, user_input: str) -> str:
-    """Handle new message (not parameter followup) - for WebSocket"""
-    try:
-        # Get version config from session
-        version = session.get_version_config()
-        if not version:
-            log_info("❌ Version config not found")
-            return "Bir hata oluştu. Lütfen tekrar deneyin."
-        
-        # Get project config
-        project = next((p for p in cfg.projects if p.name == session.project_name), None)
-        if not project:
-            return "Proje konfigürasyonu bulunamadı."
-        
-        # Build intent detection prompt
-        prompt = build_intent_prompt(version, session.chat_history, project.default_locale)
-        
-        # Get LLM response
-        raw = await llm_generate(session, prompt, user_input)
-        
-        # Empty response fallback
-        if not raw:
-            log_info("⚠️ Empty response from LLM")
-            return "Üzgünüm, mesajınızı anlayamadım. Lütfen tekrar dener misiniz?"
-        
-        # 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_info(f"🎯 Intent detected: {intent_name}")
-                
-                # Check if parameters were already extracted
-                if tail and _extract_parameters_from_response(tail, session, intent_config):
-                    log_info("📦 Some parameters extracted from initial response")
-                
-                # Check what parameters are missing
-                missing_params = [
-                    p.name 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
-                    return await _execute_api_call(session, intent_config)
-                else:
-                    # Need to collect more parameters
-                    collection_config = cfg.global_config.llm_provider.settings.get("parameter_collection_config", {})
-                    max_params = collection_config.get("max_params_per_question", 2)
-                    
-                    # Decide which parameters to ask
-                    params_to_ask = missing_params[:max_params]
-                    
-                    param_prompt = build_parameter_prompt(
-                        version=version,
-                        intent_config=intent_config,
-                        chat_history=session.chat_history,
-                        collected_params=session.variables,
-                        missing_params=missing_params,
-                        params_to_ask=params_to_ask,
-                        max_params=max_params,
-                        project_locale=project.default_locale,
-                        unanswered_params=session.unanswered_parameters
-                    )
-                    param_question = await llm_generate(session, param_prompt, user_input)
-                    return _trim_response(param_question)
-        
-        # No intent detected, return general response
-        return _trim_response(raw)
-        
-    except Exception as e:
-        log_error("❌ Error in handle_new_message", e)
-        return "Bir hata oluştu. Lütfen tekrar deneyin."
-        
-async def handle_parameter_followup(session: Session, user_input: str) -> str:
-    """Handle parameter collection followup - for WebSocket"""
-    try:
-        if not session.intent_config:
-            log_info("⚠️ No intent config in session")
-            session.reset_flow()
-            return "Üzgünüm, hangi işlem için bilgi istediğimi unuttum. Baştan başlayalım."
-        
-        intent_config = session.intent_config
-        
-        # Get project config and version
-        project = next((p for p in cfg.projects if p.name == session.project_name), None)
-        if not project:
-            return "Proje konfigürasyonu bulunamadı."
-        
-        version = session.get_version_config()
-        if not version:
-            return "Versiyon konfigürasyonu bulunamadı."
-        
-        # Try to extract parameters from user message
-        param_prompt = f"""
-        Extract parameters from user message: "{user_input}"
-        
-        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, user_input)
-        _extract_parameters_from_response(raw, session, intent_config)
-        
-        # Check what parameters are still missing
-        missing_params = [
-            p.name for p in intent_config.parameters  # p.name olmalı, sadece p değil
-            if p.required and p.variable_name not in session.variables
-        ]
-        
-        if not missing_params:
-            # All parameters collected, execute API
-            return await _execute_api_call(session, intent_config)
-        else:
-            # Still need more parameters
-            collection_config = cfg.global_config.llm_provider.settings.get("parameter_collection_config", {})
-            max_params = collection_config.get("max_params_per_question", 2)
-            
-            # Decide which parameters to ask
-            params_to_ask = missing_params[:max_params]
-            
-            param_prompt = build_parameter_prompt(
-                version=version,
-                intent_config=intent_config,
-                chat_history=session.chat_history,
-                collected_params=session.variables,
-                missing_params=missing_params,
-                params_to_ask=params_to_ask,
-                max_params=max_params,
-                project_locale=project.default_locale,
-                unanswered_params=session.unanswered_parameters
-            )
-            param_question = await llm_generate(session, param_prompt, user_input)
-            return _trim_response(param_question)
-            
-    except Exception as e:
-        log_error("❌ Error in handle_parameter_followup", e)
-        session.reset_flow()
-        return "Bir hata oluştu. Lütfen tekrar deneyin."
-        
-def get_user_friendly_error(error_type: str, context: dict = None) -> str:
-    """Get user-friendly error messages"""
-    error_messages = {
-        "session_not_found": "Oturumunuz bulunamadı. Lütfen yeni bir konuşma başlatın.",
-        "project_not_found": "Proje konfigürasyonu bulunamadı. Lütfen yönetici ile iletişime geçin.",
-        "version_not_found": "Proje versiyonu bulunamadı. Lütfen geçerli bir versiyon seçin.",
-        "intent_not_found": "Üzgünüm, ne yapmak istediğinizi anlayamadım. Lütfen daha açık bir şekilde belirtir misiniz?",
-        "api_timeout": "İşlem zaman aşımına uğradı. Lütfen tekrar deneyin.",
-        "api_error": "İşlem sırasında bir hata oluştu. Lütfen daha sonra tekrar deneyin.",
-        "parameter_validation": "Girdiğiniz bilgide bir hata var. Lütfen kontrol edip tekrar deneyin.",
-        "llm_error": "Sistem yanıt veremedi. Lütfen biraz sonra tekrar deneyin.",
-        "llm_timeout": "Sistem meşgul. Lütfen birkaç saniye bekleyip tekrar deneyin.",
-        "session_expired": "Oturumunuz zaman aşımına uğradı. Lütfen yeni bir konuşma başlatın.",
-        "rate_limit": "Çok fazla istek gönderdiniz. Lütfen biraz bekleyin.",
-        "internal_error": "Beklenmeyen bir hata oluştu. Lütfen yönetici ile iletişime geçin."
-    }
-    
-    message = error_messages.get(error_type, error_messages["internal_error"])
-    
-    # Context bilgisi varsa ekle
-    if context:
-        if error_type == "parameter_validation" and "field" in context:
-            message = f"{context['field']} alanı için {message}"
-        elif error_type == "api_error" and "api_name" in context:
-            message = f"{context['api_name']} servisi için {message}"
-    
-    return message
-
-def validate_parameter_with_message(param_config, value, locale="tr") -> tuple[bool, str]:
-    """Validate parameter and return user-friendly message"""
-    try:
-        # Type validation
-        if param_config.type == "int":
-            try:
-                int(value)
-            except ValueError:
-                return False, f"Lütfen geçerli bir sayı girin."
-                
-        elif param_config.type == "float":
-            try:
-                float(value)
-            except ValueError:
-                return False, f"Lütfen geçerli bir ondalık sayı girin."
-                
-        elif param_config.type == "date":
-            # Date parsing with locale support
-            from locale_manager import LocaleManager
-            parsed_date = LocaleManager.parse_date_expression(value, locale)
-            if not parsed_date:
-                return False, f"Lütfen geçerli bir tarih girin (örn: yarın, 15 Haziran, 2025-06-15)."
-                
-        elif param_config.type == "bool":
-            if value.lower() not in ["evet", "hayır", "yes", "no", "true", "false"]:
-                return False, f"Lütfen 'evet' veya 'hayır' olarak cevaplayın."
-        
-        # Regex validation
-        if param_config.validation_regex:
-            import re
-            if not re.match(param_config.validation_regex, value):
-                return False, param_config.invalid_prompt or "Girdiğiniz değer geçerli formatta değil."
-        
-        return True, ""
-        
-    except Exception as e:
-        log_error(f"Parameter validation error", e)
-        return False, "Değer kontrol edilirken bir hata oluştu."
-        
-# Initialize LLM on module load
-setup_llm_provider()