Upload 2 files

routes/audio_routes.py

@@ -1,263 +1,398 @@
-
-"""Audio API endpoints for Flare
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Provides text-to-speech (TTS) and speech-to-text (STT) endpoints.
-"""
-
-from fastapi import APIRouter, HTTPException, Response, Body
-from pydantic import BaseModel
-from typing import Optional
-from datetime import datetime
-import sys
-
-from utils.logger import log_info, log_error, log_warning, log_debug
-from tts.tts_factory import TTSFactory
-from tts.tts_preprocessor import TTSPreprocessor
-from config.config_provider import ConfigProvider
-
-router = APIRouter(tags=["audio"])
-
-# ===================== Models =====================
-class TTSRequest(BaseModel):
-    text: str
-    voice_id: Optional[str] = None
-    language: Optional[str] = "tr-TR"
-
-class STTRequest(BaseModel):
-    audio_data: str  # Base64 encoded audio
-    language: Optional[str] = "tr-TR"
-    format: Optional[str] = "webm"  # webm, wav, mp3
-
-# ===================== Helpers =====================
-def log(message: str):
-    """Log helper with timestamp"""
-    timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
-    print(f"[{timestamp}] {message}")
-    sys.stdout.flush()
-
-# ===================== TTS Endpoints =====================
-@router.post("/tts/generate")
-async def generate_tts(request: TTSRequest):
-    """Generate TTS audio from text - public endpoint for chat"""
-    try:
-        # Create TTS provider
-        tts_provider = TTSFactory.create_provider()
-
-        if not tts_provider:
-            # Return empty response for no TTS
-            log_info("📵 TTS disabled - returning empty response")
-            return Response(
-                content=b"",
-                media_type="audio/mpeg",
-                headers={"X-TTS-Status": "disabled"}
-            )
-
-        log_info(f"🎤 TTS request: '{request.text[:50]}...' with provider: {tts_provider.get_provider_name()}")
-
-        # Preprocess text if needed
-        preprocessor = TTSPreprocessor(language=request.language)
-        processed_text = preprocessor.preprocess(
-            request.text,
-            tts_provider.get_preprocessing_flags()
-        )
-
-        log_debug(f"📝 Preprocessed text: {processed_text[:100]}...")
-
-        # Generate audio
-        audio_data = await tts_provider.synthesize(
-            text=processed_text,
-            voice_id=request.voice_id
-        )
-
-        log_info(f"✅ TTS generated {len(audio_data)} bytes of audio")
-
-        # Return audio as binary response
-        return Response(
-            content=audio_data,
-            media_type="audio/mpeg",
-            headers={
-                "Content-Disposition": 'inline; filename="tts_output.mp3"',
-                "X-TTS-Provider": tts_provider.get_provider_name(),
-                "X-TTS-Language": request.language,
-                "Cache-Control": "no-cache"
-            }
-        )
-
-    except Exception as e:
-        log_error("❌ TTS generation error", e)
-        raise HTTPException(
-            status_code=500,
-            detail=f"TTS generation failed: {str(e)}"
-        )
-
-@router.get("/tts/voices")
-async def get_tts_voices():
-    """Get available TTS voices - public endpoint"""
-    try:
-        tts_provider = TTSFactory.create_provider()
-
-        if not tts_provider:
-            return {
-                "voices": [],
-                "provider": "none",
-                "enabled": False
-            }
-
-        voices = tts_provider.get_supported_voices()
-
-        # Convert dict to list format
-        voice_list = [
-            {"id": voice_id, "name": voice_name}
-            for voice_id, voice_name in voices.items()
-        ]
-
-        return {
-            "voices": voice_list,
-            "provider": tts_provider.get_provider_name(),
-            "enabled": True
-        }
-
-    except Exception as e:
-        log_error("❌ Error getting TTS voices", e)
-        return {
-            "voices": [],
-            "provider": "error",
-            "enabled": False,
-            "error": str(e)
-        }
-
-@router.get("/tts/status")
-async def get_tts_status():
-    """Get TTS service status"""
-    cfg = ConfigProvider.get()
-
-    return {
-        "enabled": cfg.global_config.tts_provider.name != "no_tts",
-        "provider": cfg.global_config.tts_provider.name,
-        "provider_config": {
-            "name": cfg.global_config.tts_provider.name,
-            "has_api_key": bool(cfg.global_config.tts_provider.api_key),
-            "endpoint": cfg.global_config.tts_provider.endpoint
-        }
-    }
-
-# ===================== STT Endpoints =====================
-@router.post("/stt/transcribe")
-async def transcribe_audio(request: STTRequest):
-    """Transcribe audio to text"""
-    try:
-        from stt.stt_factory import STTFactory
-        from stt.stt_interface import STTConfig
-        import base64
-
-        # Create STT provider
-        stt_provider = STTFactory.create_provider()
-
-        if not stt_provider or not stt_provider.supports_realtime():
-            log_warning("📵 STT disabled or doesn't support transcription")
-            raise HTTPException(
-                status_code=503,
-                detail="STT service not available"
-            )
-
-        # Get config
-        cfg = ConfigProvider.get()
-        stt_config = cfg.global_config.stt_provider.settings
-
-        # Decode audio data
-        audio_bytes = base64.b64decode(request.audio_data)
-
-        # Create STT config
-        config = STTConfig(
-            language=request.language or stt_config.get("language", "tr-TR"),
-            sample_rate=16000,
-            encoding=request.format.upper() if request.format else "WEBM_OPUS",
-            enable_punctuation=stt_config.get("enable_punctuation", True),
-            enable_word_timestamps=False,
-            model=stt_config.get("model", "latest_long"),
-            use_enhanced=stt_config.get("use_enhanced", True),
-            single_utterance=True,
-            interim_results=False
-        )
-
-        # Start streaming session
-        await stt_provider.start_streaming(config)
-
-        # Process audio
-        transcription = ""
-        confidence = 0.0
-
-        try:
-            async for result in stt_provider.stream_audio(audio_bytes):
-                if result.is_final:
-                    transcription = result.text
-                    confidence = result.confidence
-                    break
-        finally:
-            # Stop streaming
-            await stt_provider.stop_streaming()
-
-        log_info(f"✅ STT transcription completed: '{transcription[:50]}...'")
-
-        return {
-            "text": transcription,
-            "confidence": confidence,
-            "language": request.language,
-            "provider": stt_provider.get_provider_name()
-        }
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        log_error("❌ STT transcription error", e)
-        raise HTTPException(
-            status_code=500,
-            detail=f"Transcription failed: {str(e)}"
-        )
-
-@router.get("/stt/languages")
-async def get_stt_languages():
-    """Get supported STT languages"""
-    try:
-        from stt.stt_factory import STTFactory
-
-        stt_provider = STTFactory.create_provider()
-
-        if not stt_provider:
-            return {
-                "languages": [],
-                "provider": "none",
-                "enabled": False
-            }
-
-        languages = stt_provider.get_supported_languages()
-
-        return {
-            "languages": languages,
-            "provider": stt_provider.get_provider_name(),
-            "enabled": True
-        }
-
-    except Exception as e:
-        log_error("❌ Error getting STT languages", e)
-        return {
-            "languages": [],
-            "provider": "error",
-            "enabled": False,
-            "error": str(e)
-        }
-
-@router.get("/stt/status")
-async def get_stt_status():
-    """Get STT service status"""
-    cfg = ConfigProvider.get()
-
-    return {
-        "enabled": cfg.global_config.stt_provider.name != "no_stt",
-        "provider": cfg.global_config.stt_provider.name,
-        "provider_config": {
-            "name": cfg.global_config.stt_provider.name,
-            "has_api_key": bool(cfg.global_config.stt_provider.api_key),
-            "endpoint": cfg.global_config.stt_provider.endpoint
-        }
-    }
+"""
+Audio API endpoints for Flare (Refactored with Event-Driven Architecture)
+========================================================================
+Provides text-to-speech (TTS) and speech-to-text (STT) endpoints.
+"""
+
+from fastapi import APIRouter, HTTPException, Response, Body, Request
+from pydantic import BaseModel
+from typing import Optional
+from datetime import datetime
+import sys
+import base64
+
+from utils.logger import log_info, log_error, log_warning, log_debug
+from tts.tts_factory import TTSFactory
+from tts.tts_preprocessor import TTSPreprocessor
+from config.config_provider import ConfigProvider
+
+router = APIRouter(tags=["audio"])
+
+# ===================== Models =====================
+class TTSRequest(BaseModel):
+    text: str
+    voice_id: Optional[str] = None
+    language: Optional[str] = "tr-TR"
+    session_id: Optional[str] = None  # For event-driven mode
+
+class STTRequest(BaseModel):
+    audio_data: str  # Base64 encoded audio
+    language: Optional[str] = "tr-TR"
+    format: Optional[str] = "webm"  # webm, wav, mp3
+    session_id: Optional[str] = None  # For event-driven mode
+
+# ===================== TTS Endpoints =====================
+@router.post("/tts/generate")
+async def generate_tts(request: TTSRequest, req: Request):
+    """
+    Generate TTS audio from text
+    - If session_id is provided and event bus is available, uses event-driven mode
+    - Otherwise, uses direct TTS generation
+    """
+    try:
+        # Check if we should use event-driven mode
+        if request.session_id and hasattr(req.app.state, 'event_bus'):
+            # Event-driven mode for realtime sessions
+            from event_bus import Event, EventType
+            
+            log_info(f"🎤 TTS request via event bus for session: {request.session_id}")
+            
+            # Publish TTS event
+            await req.app.state.event_bus.publish(Event(
+                type=EventType.TTS_STARTED,
+                session_id=request.session_id,
+                data={
+                    "text": request.text,
+                    "voice_id": request.voice_id,
+                    "language": request.language,
+                    "is_api_call": True  # Flag to indicate this is from REST API
+                }
+            ))
+            
+            # Return a response indicating audio will be streamed via WebSocket
+            return {
+                "status": "processing",
+                "message": "TTS audio will be streamed via WebSocket connection",
+                "session_id": request.session_id
+            }
+        
+        else:
+            # Direct TTS generation (legacy mode)
+            tts_provider = TTSFactory.create_provider()
+
+            if not tts_provider:
+                log_info("📵 TTS disabled - returning empty response")
+                return Response(
+                    content=b"",
+                    media_type="audio/mpeg",
+                    headers={"X-TTS-Status": "disabled"}
+                )
+
+            log_info(f"🎤 Direct TTS request: '{request.text[:50]}...' with provider: {tts_provider.get_provider_name()}")
+
+            # Preprocess text if needed
+            preprocessor = TTSPreprocessor(language=request.language)
+            processed_text = preprocessor.preprocess(
+                request.text,
+                tts_provider.get_preprocessing_flags()
+            )
+
+            log_debug(f"📝 Preprocessed text: {processed_text[:100]}...")
+
+            # Generate audio
+            audio_data = await tts_provider.synthesize(
+                text=processed_text,
+                voice_id=request.voice_id
+            )
+
+            log_info(f"✅ TTS generated {len(audio_data)} bytes of audio")
+
+            # Return audio as binary response
+            return Response(
+                content=audio_data,
+                media_type="audio/mpeg",
+                headers={
+                    "Content-Disposition": 'inline; filename="tts_output.mp3"',
+                    "X-TTS-Provider": tts_provider.get_provider_name(),
+                    "X-TTS-Language": request.language,
+                    "Cache-Control": "no-cache"
+                }
+            )
+
+    except Exception as e:
+        log_error("❌ TTS generation error", e)
+        raise HTTPException(
+            status_code=500,
+            detail=f"TTS generation failed: {str(e)}"
+        )
+
+@router.get("/tts/voices")
+async def get_tts_voices():
+    """Get available TTS voices"""
+    try:
+        tts_provider = TTSFactory.create_provider()
+
+        if not tts_provider:
+            return {
+                "voices": [],
+                "provider": "none",
+                "enabled": False
+            }
+
+        voices = tts_provider.get_supported_voices()
+
+        # Convert dict to list format
+        voice_list = [
+            {"id": voice_id, "name": voice_name}
+            for voice_id, voice_name in voices.items()
+        ]
+
+        return {
+            "voices": voice_list,
+            "provider": tts_provider.get_provider_name(),
+            "enabled": True
+        }
+
+    except Exception as e:
+        log_error("❌ Error getting TTS voices", e)
+        return {
+            "voices": [],
+            "provider": "error",
+            "enabled": False,
+            "error": str(e)
+        }
+
+@router.get("/tts/status")
+async def get_tts_status():
+    """Get TTS service status"""
+    cfg = ConfigProvider.get()
+
+    return {
+        "enabled": cfg.global_config.tts_provider.name != "no_tts",
+        "provider": cfg.global_config.tts_provider.name,
+        "provider_config": {
+            "name": cfg.global_config.tts_provider.name,
+            "has_api_key": bool(cfg.global_config.tts_provider.api_key),
+            "endpoint": cfg.global_config.tts_provider.endpoint
+        }
+    }
+
+# ===================== STT Endpoints =====================
+@router.post("/stt/transcribe")
+async def transcribe_audio(request: STTRequest, req: Request):
+    """
+    Transcribe audio to text
+    - If session_id is provided and event bus is available, uses event-driven mode
+    - Otherwise, uses direct STT transcription
+    """
+    try:
+        # Check if we should use event-driven mode
+        if request.session_id and hasattr(req.app.state, 'event_bus'):
+            # Event-driven mode for realtime sessions
+            from event_bus import Event, EventType
+            
+            log_info(f"🎧 STT request via event bus for session: {request.session_id}")
+            
+            # Publish audio chunk event
+            await req.app.state.event_bus.publish(Event(
+                type=EventType.AUDIO_CHUNK_RECEIVED,
+                session_id=request.session_id,
+                data={
+                    "audio_data": request.audio_data,  # Already base64
+                    "format": request.format,
+                    "language": request.language,
+                    "is_api_call": True
+                }
+            ))
+            
+            # Return a response indicating transcription will be available via WebSocket
+            return {
+                "status": "processing",
+                "message": "Transcription will be available via WebSocket connection",
+                "session_id": request.session_id
+            }
+        
+        else:
+            # Direct STT transcription (legacy mode)
+            from stt.stt_factory import STTFactory
+            from stt.stt_interface import STTConfig
+
+            # Create STT provider
+            stt_provider = STTFactory.create_provider()
+
+            if not stt_provider or not stt_provider.supports_realtime():
+                log_warning("📵 STT disabled or doesn't support transcription")
+                raise HTTPException(
+                    status_code=503,
+                    detail="STT service not available"
+                )
+
+            # Get config
+            cfg = ConfigProvider.get()
+            stt_config = cfg.global_config.stt_provider.settings
+
+            # Decode audio data
+            audio_bytes = base64.b64decode(request.audio_data)
+
+            # Create STT config
+            config = STTConfig(
+                language=request.language or stt_config.get("language", "tr-TR"),
+                sample_rate=16000,
+                encoding=request.format.upper() if request.format else "WEBM_OPUS",
+                enable_punctuation=stt_config.get("enable_punctuation", True),
+                enable_word_timestamps=False,
+                model=stt_config.get("model", "latest_long"),
+                use_enhanced=stt_config.get("use_enhanced", True),
+                single_utterance=True,
+                interim_results=False
+            )
+
+            # Start streaming session
+            await stt_provider.start_streaming(config)
+
+            # Process audio
+            transcription = ""
+            confidence = 0.0
+
+            try:
+                async for result in stt_provider.stream_audio(audio_bytes):
+                    if result.is_final:
+                        transcription = result.text
+                        confidence = result.confidence
+                        break
+            finally:
+                # Stop streaming
+                await stt_provider.stop_streaming()
+
+            log_info(f"✅ STT transcription completed: '{transcription[:50]}...'")
+
+            return {
+                "text": transcription,
+                "confidence": confidence,
+                "language": request.language,
+                "provider": stt_provider.get_provider_name()
+            }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log_error("❌ STT transcription error", e)
+        raise HTTPException(
+            status_code=500,
+            detail=f"Transcription failed: {str(e)}"
+        )
+
+@router.get("/stt/languages")
+async def get_stt_languages():
+    """Get supported STT languages"""
+    try:
+        from stt.stt_factory import STTFactory
+
+        stt_provider = STTFactory.create_provider()
+
+        if not stt_provider:
+            return {
+                "languages": [],
+                "provider": "none",
+                "enabled": False
+            }
+
+        languages = stt_provider.get_supported_languages()
+
+        return {
+            "languages": languages,
+            "provider": stt_provider.get_provider_name(),
+            "enabled": True
+        }
+
+    except Exception as e:
+        log_error("❌ Error getting STT languages", e)
+        return {
+            "languages": [],
+            "provider": "error",
+            "enabled": False,
+            "error": str(e)
+        }
+
+@router.get("/stt/status")
+async def get_stt_status():
+    """Get STT service status"""
+    cfg = ConfigProvider.get()
+
+    return {
+        "enabled": cfg.global_config.stt_provider.name != "no_stt",
+        "provider": cfg.global_config.stt_provider.name,
+        "provider_config": {
+            "name": cfg.global_config.stt_provider.name,
+            "has_api_key": bool(cfg.global_config.stt_provider.api_key),
+            "endpoint": cfg.global_config.stt_provider.endpoint
+        }
+    }
+
+# ===================== WebSocket Audio Stream Endpoint =====================
+@router.websocket("/ws/audio/{session_id}")
+async def audio_websocket(websocket: WebSocket, session_id: str, request: Request):
+    """
+    WebSocket endpoint for streaming audio
+    This is a dedicated audio stream separate from the main conversation WebSocket
+    """
+    from fastapi import WebSocketDisconnect
+    
+    try:
+        await websocket.accept()
+        log_info(f"🎵 Audio WebSocket connected for session: {session_id}")
+        
+        if not hasattr(request.app.state, 'event_bus'):
+            await websocket.send_json({
+                "type": "error",
+                "message": "Event bus not initialized"
+            })
+            await websocket.close()
+            return
+        
+        while True:
+            try:
+                # Receive audio data
+                data = await websocket.receive_json()
+                
+                if data.get("type") == "audio_chunk":
+                    # Forward to event bus
+                    from event_bus import Event, EventType
+                    
+                    await request.app.state.event_bus.publish(Event(
+                        type=EventType.AUDIO_CHUNK_RECEIVED,
+                        session_id=session_id,
+                        data={
+                            "audio_data": data.get("data"),
+                            "timestamp": data.get("timestamp"),
+                            "chunk_index": data.get("chunk_index", 0)
+                        }
+                    ))
+                    
+                elif data.get("type") == "control":
+                    action = data.get("action")
+                    
+                    if action == "start_recording":
+                        from event_bus import Event, EventType
+                        
+                        await request.app.state.event_bus.publish(Event(
+                            type=EventType.STT_STARTED,
+                            session_id=session_id,
+                            data={
+                                "language": data.get("language", "tr-TR"),
+                                "format": data.get("format", "webm")
+                            }
+                        ))
+                        
+                    elif action == "stop_recording":
+                        from event_bus import Event, EventType
+                        
+                        await request.app.state.event_bus.publish(Event(
+                            type=EventType.STT_STOPPED,
+                            session_id=session_id,
+                            data={"reason": "user_request"}
+                        ))
+                        
+            except WebSocketDisconnect:
+                break
+            except Exception as e:
+                log_error(f"Error in audio WebSocket", error=str(e))
+                await websocket.send_json({
+                    "type": "error",
+                    "message": str(e)
+                })
+                
+    except Exception as e:
+        log_error(f"Audio WebSocket error", error=str(e))
+    finally:
+        log_info(f"🎵 Audio WebSocket disconnected for session: {session_id}")

routes/chat_handler.py

@@ -1,12 +1,12 @@
 """
-Flare – Chat Handler (Refactored with LLM Factory)
-==========================================
+Flare – Chat Handler (REST API Only - Realtime moved to Event-Driven)
+====================================================================
 """
 
 import re, json, sys, httpx, os
 from datetime import datetime
 from typing import Dict, List, Optional, Any
-from fastapi import APIRouter, HTTPException, Header
+from fastapi import APIRouter, HTTPException, Header, Request
 from pydantic import BaseModel
 import requests
 
@@ -66,6 +66,48 @@ def setup_llm_provider():
         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"""
@@ -163,7 +205,7 @@ class ChatRequest(BaseModel):
 
 class StartRequest(BaseModel):
     project_name: str
-    version_no: Optional[int] = None # Opsiyonel, belirtilmezse published olan en büyük version no'yu kullan
+    version_no: Optional[int] = None
     is_realtime: bool = False
     locale: Optional[str] = None
 
@@ -173,8 +215,8 @@ class ChatResponse(BaseModel):
 
 # ─────────────────────────  API ENDPOINTS ───────────────────────── #
 @router.post("/start_session", response_model=ChatResponse)
-async def start_session(req: StartRequest):
-    """Create new session"""
+async def start_session(req: StartRequest, request: Request):
+    """Create new session - supports both REST and realtime"""
     global llm_provider
 
     try:
@@ -186,7 +228,6 @@ async def start_session(req: StartRequest):
         # 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
@@ -198,58 +239,75 @@ async def start_session(req: StartRequest):
 
         # 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.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İ
+        # Create session
         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)
+        # For realtime sessions, publish event to start the flow
+        if req.is_realtime and hasattr(request.app.state, 'event_bus'):
+            from event_bus import Event, EventType
+            
+            await request.app.state.event_bus.publish(Event(
+                type=EventType.SESSION_STARTED,
+                session_id=session.session_id,
+                data={
+                    "session": session,
+                    "has_welcome": bool(version.welcome_prompt),
+                    "welcome_text": version.welcome_prompt or "Hoş geldiniz! Size nasıl yardımcı olabilirim?",
+                    "locale": session_locale,
+                    "project_name": req.project_name,
+                    "version_no": version.no
+                }
+            ))
+            
+            # For realtime, return minimal response
+            return ChatResponse(
+                session_id=session.session_id,
+                answer="[REALTIME_MODE] Connect via WebSocket to continue."
+            )
+        
+        # For REST mode, process welcome prompt normally
+        else:
+            # Create LLM provider if not exists
+            if not llm_provider:
+                from llm.llm_factory import LLMFactory
+                llm_provider = LLMFactory.create_provider()
+                log_info(f"🤖 LLM Provider created: {type(llm_provider).__name__}")
+
+            # Process welcome prompt
+            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_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)
+
+            session.add_turn("assistant", greeting)
+
+            log_info(f"✅ Session created for project '{req.project_name}' version {version.no}")
+
+            return ChatResponse(session_id=session.session_id, answer=greeting)
 
     except HTTPException:
         raise
@@ -259,18 +317,24 @@ async def start_session(req: StartRequest):
 
 @router.post("/chat")
 async def chat(req: ChatRequest, x_session_id: str = Header(...)):
-    """Process chat message"""
+    """Process chat message - REST API only (realtime uses WebSocket)"""
     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
+        # Check if this is a realtime session
+        if session.is_realtime:
+            raise HTTPException(
+                status_code=400,
+                detail="This is a realtime session. Please use WebSocket connection instead."
+            )
+
+        # Session expiry check
         if session.is_expired():
             session_store.delete_session(x_session_id)
             raise HTTPException(
@@ -282,7 +346,6 @@ async def chat(req: ChatRequest, x_session_id: str = Header(...)):
         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}")
@@ -317,7 +380,7 @@ async def chat(req: ChatRequest, x_session_id: str = Header(...)):
 
                 if intent_config:
                     session.current_intent = intent_name
-                    session.intent_config = intent_config
+                    session.set_intent_config(intent_config)
                     session.state = "collect_params"
                     log_info(f"🎯 Intent detected: {intent_name}")
 
@@ -338,7 +401,6 @@ async def chat(req: ChatRequest, x_session_id: str = Header(...)):
                         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)
 
@@ -372,7 +434,7 @@ async def chat(req: ChatRequest, x_session_id: str = Header(...)):
 
         elif session.state == "collect_params":
             # Continue parameter collection
-            intent_config = session.intent_config
+            intent_config = session.get_intent_config()
 
             # Try to extract parameters from user message
             param_prompt = f"""
@@ -405,11 +467,9 @@ async def chat(req: ChatRequest, x_session_id: str = Header(...)):
                 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(
@@ -436,7 +496,6 @@ async def chat(req: ChatRequest, x_session_id: str = Header(...)):
     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"),
@@ -447,13 +506,42 @@ async def chat(req: ChatRequest, x_session_id: str = Header(...)):
         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
         }
 
+@router.post("/end_session")
+async def end_session(x_session_id: str = Header(...), request: Request = None):
+    """End a session - works for both REST and realtime"""
+    try:
+        session = session_store.get_session(x_session_id)
+        if not session:
+            raise HTTPException(404, "Session not found")
+
+        # For realtime sessions, publish end event
+        if session.is_realtime and request and hasattr(request.app.state, 'event_bus'):
+            from event_bus import Event, EventType
+            
+            await request.app.state.event_bus.publish(Event(
+                type=EventType.SESSION_ENDED,
+                session_id=x_session_id,
+                data={"reason": "user_request"}
+            ))
+
+        # Delete session
+        session_store.delete_session(x_session_id)
+        
+        return {"message": "Session ended successfully"}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        log_error("❌ Error ending session", e)
+        raise HTTPException(500, f"Failed to end session: {str(e)}")
+
+# ─────────────────────────  HELPER FUNCTIONS ───────────────────────── #
 def get_user_friendly_error(error_type: str, context: dict = None) -> str:
     """Get user-friendly error messages"""
     error_messages = {
@@ -522,4 +610,4 @@ def validate_parameter_with_message(param_config, value, locale="tr") -> tuple[b
         return False, "Değer kontrol edilirken bir hata oluştu."
 
 # Initialize LLM on module load
-setup_llm_provider()
+setup_llm_provider()