Update websocket_handler.py

websocket_handler.py

@@ -12,13 +12,13 @@ from enum import Enum
 import numpy as np
 import traceback
 
-from realtime_session_manager import send_tts_welcome_message
 from session import Session, session_store
 from config_provider import ConfigProvider
 from chat_handler import handle_new_message, handle_parameter_followup
 from stt_factory import STTFactory
 from tts_factory import TTSFactory
 from logger import log_info, log_error, log_debug, log_warning
+from realtime_session_manager import send_tts_welcome_message
 
 # ========================= CONSTANTS =========================
 # Default values - will be overridden by config
@@ -180,39 +180,21 @@ class RealtimeSession:
         """Initialize STT provider"""
         try:
             self.stt_manager = STTFactory.create_provider()
-            if self.stt_manager and self.stt_manager.supports_realtime():
+            if self.stt_manager:
                 config = ConfigProvider.get().global_config.stt_provider.settings
-                
-                # STTConfig nesnesi oluştur, dict değil!
-                from stt_interface import STTConfig
-                stt_config = STTConfig(
-                    language=config.get("language", "tr-TR"),
-                    interim_results=config.get("interim_results", True),
-                    single_utterance=False,
-                    enable_punctuation=config.get("enable_punctuation", True),
-                    sample_rate=16000,
-                    encoding="WEBM_OPUS",
-                    model=config.get("model", "latest_long"),
-                    use_enhanced=config.get("use_enhanced", True),
-                    # Voice Activity Detection
-                    vad_enabled=True,
-                    speech_timeout_ms=config.get("speech_timeout_ms", 2000),
-                    # Noise reduction
-                    noise_reduction_enabled=True,
-                    noise_reduction_level=config.get("noise_reduction_level", 2)
-                )
-                
-                await self.stt_manager.start_streaming(stt_config)
+                await self.stt_manager.start_streaming({
+                    "language": config.get("language", "tr-TR"),
+                    "interim_results": config.get("interim_results", True),
+                    "single_utterance": False,
+                    "enable_punctuation": config.get("enable_punctuation", True),
+                    "sample_rate": 16000,
+                    "encoding": "WEBM_OPUS"
+                })
                 log_info("STT manager initialized", session_id=self.session.session_id)
                 return True
-            else:
-                log_warning("STT provider does not support realtime", session_id=self.session.session_id)
-                return False
         except Exception as e:
             log_error(f"Failed to initialize STT", error=str(e), session_id=self.session.session_id)
-            # STT başarısız oldu, manager'ı None yap
-            self.stt_manager = None
-            return False
+        return False
     
     async def change_state(self, new_state: ConversationState):
         """Change conversation state"""
@@ -248,12 +230,15 @@ class RealtimeSession:
 # ========================= MAIN HANDLER =========================
 async def websocket_endpoint(websocket: WebSocket, session_id: str):
     """Main WebSocket endpoint for real-time conversation"""
+    log_info(f"🔌 WebSocket connection attempt", session_id=session_id)
+    
     await websocket.accept()
-    log_info(f"WebSocket connected", session_id=session_id)
+    log_info(f"✅ WebSocket accepted", session_id=session_id)
     
     # Get session
     session = session_store.get_session(session_id)
     if not session:
+        log_error(f"❌ Session not found", session_id=session_id)
         await websocket.send_json({
             "type": "error",
             "message": "Session not found"
@@ -261,6 +246,8 @@ async def websocket_endpoint(websocket: WebSocket, session_id: str):
         await websocket.close()
         return
     
+    log_info(f"✅ Session found", session_id=session_id, project=session.project_name)
+    
     # Mark as realtime session
     session.is_realtime = True
     session_store.update_session(session)
@@ -269,54 +256,59 @@ async def websocket_endpoint(websocket: WebSocket, session_id: str):
     realtime_session = RealtimeSession(session)
     
     # Initialize STT
+    log_info(f"🎤 Initializing STT...", session_id=session_id)
     stt_initialized = await realtime_session.initialize_stt()
     if not stt_initialized:
+        log_error(f"❌ STT initialization failed", session_id=session_id)
         await websocket.send_json({
             "type": "error",
             "message": "STT initialization failed"
         })
+    else:
+        log_info(f"✅ STT initialized", session_id=session_id)
     
-    # Generate and send welcome message TTS
-    tts_provider = TTSFactory.create_provider()
-    if tts_provider:
-        # Get welcome text from session history
-        welcome_text = None
-        if session.chat_history and len(session.chat_history) > 0:
-            # Find the first assistant message (welcome message)
-            for msg in session.chat_history:
-                if msg.get('role') == 'assistant':
-                    welcome_text = msg.get('content', '')
-                    break
-        
-        if welcome_text:
-            await send_tts_welcome_message(
-                websocket, 
-                session_id, 
-                tts_provider, 
-                welcome_text
-            )
+    # Send session started confirmation
+    await websocket.send_json({
+        "type": "session_started",
+        "session_id": session_id,
+        "stt_initialized": stt_initialized
+    })
+    
+    # Don't send welcome TTS here - it's already sent by the frontend
+    log_info(f"💬 Ready for conversation", session_id=session_id)
     
     try:
         while True:
-            # Receive message
-            message = await websocket.receive_json()
-            message_type = message.get("type")
-            
-            if message_type == "audio_chunk":
-                await handle_audio_chunk(websocket, realtime_session, message)
+            try:
+                # Receive message with timeout
+                message = await asyncio.wait_for(
+                    websocket.receive_json(), 
+                    timeout=60.0  # 60 second timeout
+                )
                 
-            elif message_type == "control":
-                await handle_control_message(websocket, realtime_session, message)
+                message_type = message.get("type")
+                log_debug(f"📨 Received message type: {message_type}", session_id=session_id)
                 
-            elif message_type == "ping":
-                # Keep-alive ping
-                await websocket.send_json({"type": "pong"})
+                if message_type == "audio_chunk":
+                    await handle_audio_chunk(websocket, realtime_session, message)
+                    
+                elif message_type == "control":
+                    await handle_control_message(websocket, realtime_session, message)
+                    
+                elif message_type == "ping":
+                    # Keep-alive ping
+                    await websocket.send_json({"type": "pong"})
+                    log_debug(f"🏓 Ping-pong", session_id=session_id)
+                    
+            except asyncio.TimeoutError:
+                log_warning(f"⏱️ WebSocket timeout - sending ping", session_id=session_id)
+                await websocket.send_json({"type": "ping"})
                 
-    except WebSocketDisconnect:
-        log_info(f"WebSocket disconnected", session_id=session_id)
+    except WebSocketDisconnect as e:
+        log_info(f"🔌 WebSocket disconnected", session_id=session_id, code=e.code, reason=e.reason)
     except Exception as e:
         log_error(
-            f"WebSocket error",
+            f"❌ WebSocket error",
             error=str(e),
             traceback=traceback.format_exc(),
             session_id=session_id
@@ -326,6 +318,7 @@ async def websocket_endpoint(websocket: WebSocket, session_id: str):
             "message": str(e)
         })
     finally:
+        log_info(f"🧹 Cleaning up WebSocket connection", session_id=session_id)
         await realtime_session.cleanup()
 
 
@@ -335,18 +328,9 @@ async def handle_audio_chunk(websocket: WebSocket, session: RealtimeSession, mes
     try:
         audio_data = message.get("data")
         if not audio_data:
+            log_warning(f"⚠️ Empty audio chunk received", session_id=session.session.session_id)
             return
-
-        # STT manager kontrolü
-        if not session.stt_manager:
-            log_warning("No STT manager available, ignoring audio chunk", session_id=session.session.session_id)
-            await websocket.send_json({
-                "type": "error",
-                "message": "Speech recognition not available",
-                "error_type": "stt_unavailable"
-            })
-            return
-            
+        
         # Check for barge-in during TTS/audio playback
         if session.state in [ConversationState.PLAYING_AUDIO, ConversationState.PROCESSING_TTS]:
             await session.handle_barge_in()
@@ -354,7 +338,7 @@ async def handle_audio_chunk(websocket: WebSocket, session: RealtimeSession, mes
                 "type": "control",
                 "action": "stop_playback"
             })
-            log_info(f"Barge-in detected", session_id=session.session.session_id, state=session.state.value)
+            log_info(f"🛑 Barge-in detected", session_id=session.session.session_id, state=session.state.value)
         
         # Change state to listening if idle
         if session.state == ConversationState.IDLE:
@@ -387,11 +371,12 @@ async def handle_audio_chunk(websocket: WebSocket, session: RealtimeSession, mes
                 
                 if result.is_final:
                     session.current_transcription = result.text
+                    log_info(f"📝 Final transcription: {result.text}", session_id=session.session.session_id)
         
         # Process if silence detected and we have transcription
         if silence_duration > session.silence_threshold_ms and session.current_transcription:
             log_info(
-                f"User stopped speaking",
+                f"🔇 User stopped speaking",
                 session_id=session.session.session_id,
                 silence_ms=silence_duration,
                 text=session.current_transcription
@@ -400,7 +385,7 @@ async def handle_audio_chunk(websocket: WebSocket, session: RealtimeSession, mes
             
     except Exception as e:
         log_error(
-            f"Audio chunk handling error",
+            f"❌ Audio chunk handling error",
             error=str(e),
             traceback=traceback.format_exc(),
             session_id=session.session.session_id
@@ -416,12 +401,12 @@ async def handle_control_message(websocket: WebSocket, session: RealtimeSession,
     action = message.get("action")
     config = message.get("config", {})
     
-    log_debug(f"Control message", action=action, session_id=session.session.session_id)
+    log_debug(f"🎮 Control message", action=action, session_id=session.session.session_id)
     
     if action == "start_session":
         # Session configuration
         await websocket.send_json({
-            "type": "session_started",
+            "type": "session_config",
             "session_id": session.session.session_id,
             "config": {
                 "silence_threshold_ms": session.silence_threshold_ms,
@@ -430,38 +415,38 @@ async def handle_control_message(websocket: WebSocket, session: RealtimeSession,
             }
         })
         
-        # Send welcome message and TTS if available
-        chat_history = session.session.chat_history
-        if chat_history and len(chat_history) > 0:
-            last_message = chat_history[-1]
-            if last_message["role"] == "assistant":
-                welcome_text = last_message["content"]
-                
-                # Send text message
-                await websocket.send_json({
-                    "type": "assistant_response",
-                    "text": welcome_text
-                })
-                
-                # Generate TTS if enabled
-                tts_provider = TTSFactory.create_provider()
-                if tts_provider:
-                    await session.change_state(ConversationState.PROCESSING_TTS)
-                    await websocket.send_json({
-                        "type": "state_change",
-                        "from": "idle",
-                        "to": "processing_tts"
-                    })
-                    
-                    # Generate and stream TTS
-                    tts_task = session.barge_in_handler.start_tts_task(
-                        generate_and_stream_tts(websocket, session, tts_provider, welcome_text)
-                    )
-                    
-                    try:
-                        await tts_task
-                    except asyncio.CancelledError:
-                        log_info("Welcome TTS cancelled", session_id=session.session.session_id)
+    elif action == "end_session" or action == "stop_session":
+        # Clean up and close
+        await session.cleanup()
+        await websocket.close()
+        
+    elif action == "interrupt":
+        # Handle explicit interrupt
+        await session.handle_barge_in()
+        await websocket.send_json({
+            "type": "control",
+            "action": "interrupt_acknowledged"
+        })
+        
+    elif action == "reset":
+        # Reset conversation state
+        await session.reset_for_new_utterance()
+        await session.change_state(ConversationState.IDLE)
+        await websocket.send_json({
+            "type": "state_change",
+            "from": session.state.value,
+            "to": "idle"
+        })
+        
+    elif action == "audio_ended":
+        # Audio playback ended on client
+        if session.state == ConversationState.PLAYING_AUDIO:
+            await session.change_state(ConversationState.IDLE)
+            await websocket.send_json({
+                "type": "state_change",
+                "from": "playing_audio",
+                "to": "idle"
+            })
 
 
 # ========================= PROCESSING FUNCTIONS =========================
@@ -470,11 +455,12 @@ async def process_user_input(websocket: WebSocket, session: RealtimeSession):
     try:
         user_text = session.current_transcription
         if not user_text:
+            log_warning(f"⚠️ Empty transcription, resetting", session_id=session.session.session_id)
             await session.reset_for_new_utterance()
             await session.change_state(ConversationState.IDLE)
             return
         
-        log_info(f"Processing user input", text=user_text, session_id=session.session.session_id)
+        log_info(f"🎯 Processing user input", text=user_text, session_id=session.session.session_id)
         
         # State: STT Processing
         await session.change_state(ConversationState.PROCESSING_STT)
@@ -504,11 +490,15 @@ async def process_user_input(websocket: WebSocket, session: RealtimeSession):
         session.session.add_message("user", user_text)
         
         # Get LLM response based on session state
+        log_info(f"🤖 Getting LLM response", session_state=session.session.state, session_id=session.session.session_id)
+        
         if session.session.state == "collect_params":
             response_text = await handle_parameter_followup(session.session, user_text)
         else:
             response_text = await handle_new_message(session.session, user_text)
         
+        log_info(f"💬 LLM response: {response_text[:50]}...", session_id=session.session.session_id)
+        
         # Add response to history
         session.session.add_message("assistant", response_text)
         
@@ -529,14 +519,14 @@ async def process_user_input(websocket: WebSocket, session: RealtimeSession):
             })
             
             # Generate TTS with barge-in support
-            tts_task = session.barge_in_handler.start_tts_task(
+            tts_task = await session.barge_in_handler.start_tts_task(
                 generate_and_stream_tts(websocket, session, tts_provider, response_text)
             )
             
             try:
                 await tts_task
             except asyncio.CancelledError:
-                log_info("TTS cancelled due to barge-in", session_id=session.session.session_id)
+                log_info("⚡ TTS cancelled due to barge-in", session_id=session.session.session_id)
         else:
             # No TTS, go back to idle
             await session.change_state(ConversationState.IDLE)
@@ -551,7 +541,7 @@ async def process_user_input(websocket: WebSocket, session: RealtimeSession):
         
     except Exception as e:
         log_error(
-            f"Error processing user input",
+            f"❌ Error processing user input",
             error=str(e),
             traceback=traceback.format_exc(),
             session_id=session.session.session_id
@@ -572,8 +562,11 @@ async def generate_and_stream_tts(
 ):
     """Generate and stream TTS audio with cancellation support"""
     try:
+        log_info(f"🎤 Starting TTS generation for text: '{text[:50]}...'", session_id=session.session.session_id)
+        
         # Generate audio
         audio_data = await tts_provider.synthesize(text)
+        log_info(f"✅ TTS generated: {len(audio_data)} bytes, type: {type(audio_data)}", session_id=session.session.session_id)
         
         # Change state to playing
         await session.change_state(ConversationState.PLAYING_AUDIO)
@@ -585,29 +578,38 @@ async def generate_and_stream_tts(
         
         # Convert entire audio to base64 for transmission
         import base64
+        log_debug(f"📦 Converting audio to base64...")
         audio_base64 = base64.b64encode(audio_data).decode('utf-8')
+        log_info(f"📊 Base64 conversion complete: {len(audio_base64)} chars from {len(audio_data)} bytes", session_id=session.session.session_id)
+        
+        # Log first 100 chars of base64 to verify it's valid
+        log_debug(f"🔍 Base64 preview: {audio_base64[:100]}...")
         
         # Stream audio in chunks
         chunk_size = 16384  # Larger chunk size for base64
         total_length = len(audio_base64)
         total_chunks = (total_length + chunk_size - 1) // chunk_size
         
-        log_info(f"Streaming TTS audio: {len(audio_data)} bytes as {total_length} base64 chars in {total_chunks} chunks")
+        log_info(f"📤 Streaming TTS audio: {len(audio_data)} bytes as {total_length} base64 chars in {total_chunks} chunks", session_id=session.session.session_id)
         
         for i in range(0, total_length, chunk_size):
             # Check for cancellation
             if asyncio.current_task().cancelled():
+                log_info(f"⚡ Streaming cancelled at chunk {i//chunk_size}", session_id=session.session.session_id)
                 break
                 
             chunk = audio_base64[i:i + chunk_size]
             chunk_index = i // chunk_size
+            is_last = chunk_index == total_chunks - 1
+            
+            log_debug(f"📨 Sending chunk {chunk_index}/{total_chunks}, size: {len(chunk)}, is_last: {is_last}")
             
             await websocket.send_json({
                 "type": "tts_audio",
                 "data": chunk,
                 "chunk_index": chunk_index,
                 "total_chunks": total_chunks,
-                "is_last": chunk_index == total_chunks - 1,
+                "is_last": is_last,
                 "mime_type": "audio/mpeg"
             })
             
@@ -615,19 +617,21 @@ async def generate_and_stream_tts(
             await asyncio.sleep(0.01)
         
         log_info(
-            f"TTS streaming completed",
+            f"✅ TTS streaming completed successfully",
             session_id=session.session.session_id,
             text_length=len(text),
-            audio_size=len(audio_data)
+            audio_size=len(audio_data),
+            chunks_sent=total_chunks
         )
         
     except asyncio.CancelledError:
-        log_info("TTS streaming cancelled", session_id=session.session.session_id)
+        log_info("🛑 TTS streaming cancelled", session_id=session.session.session_id)
         raise
     except Exception as e:
         log_error(
-            f"TTS generation error",
+            f"❌ TTS generation error",
             error=str(e),
+            traceback=traceback.format_exc(),
             session_id=session.session.session_id
         )
         await websocket.send_json({