Update websocket_handler.py

websocket_handler.py

@@ -405,18 +405,6 @@ async def websocket_endpoint(websocket: WebSocket, session_id: str):
     # Initialize conversation
     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)
-    
     # Send session started confirmation
     await websocket.send_json({
         "type": "session_started",
@@ -495,14 +483,47 @@ async def websocket_endpoint(websocket: WebSocket, session_id: str):
                             log_info(f"✅ Welcome TTS sent", session_id=session_id)
                     except Exception as e:
                         log_error(f"❌ Failed to send welcome TTS", error=str(e), traceback=traceback.format_exc(), session_id=session_id)
+                        # TTS hatası durumunda direkt listening moduna geç
+                        await realtime_session.change_state(ConversationState.LISTENING)
+                        await websocket.send_json({
+                            "type": "state_change",
+                            "from": "playing_audio",
+                            "to": "listening"
+                        })
+                        # Ve STT'yi başlat
+                        await realtime_session.initialize_stt()                        
                 else:
                     log_warning(f"⚠️ No TTS provider available", session_id=session_id)
+                    # TTS yoksa direkt listening moduna geç ve STT başlat
+                    await realtime_session.change_state(ConversationState.LISTENING)
+                    await websocket.send_json({
+                        "type": "state_change",
+                        "from": "idle",
+                        "to": "listening"
+                    })
+                    await realtime_session.initialize_stt()
                 
                 break
         else:
             log_warning(f"⚠️ No assistant message found in history", session_id=session_id)
+            # Welcome mesajı yoksa direkt listening moduna geç
+            await realtime_session.change_state(ConversationState.LISTENING)
+            await websocket.send_json({
+                "type": "state_change",
+                "from": "idle",
+                "to": "listening"
+            })
+            await realtime_session.initialize_stt()
     else:
         log_warning(f"⚠️ No messages in session history", session_id=session_id)
+        # History yoksa direkt listening moduna geç
+        await realtime_session.change_state(ConversationState.LISTENING)
+        await websocket.send_json({
+            "type": "state_change",
+            "from": "idle",
+            "to": "listening"
+        })
+        await realtime_session.initialize_stt()
     
     log_info(f"💬 Ready for conversation", session_id=session_id)
 
@@ -584,30 +605,25 @@ async def handle_audio_chunk(websocket: WebSocket, session: RealtimeSession, mes
             log_warning(f"⚠️ Empty audio chunk received", session_id=session.session.session_id)
             return
         
-        # Barge-in devre dışı - TTS/audio playback sırasında audio chunk'ları işleme
+        # TTS/LLM işlenirken audio chunk'ları tamamen yoksay
         if session.state in [ConversationState.PLAYING_AUDIO, ConversationState.PROCESSING_TTS, 
                             ConversationState.PROCESSING_LLM, ConversationState.PROCESSING_STT]:
             log_debug(f"🔇 Ignoring audio chunk during state: {session.state.value}", session_id=session.session.session_id)
-            # Audio buffer'ı da temizle ki eski chunk'lar birikmesin
-            await session.audio_buffer.clear()
             return
         
-        # Change state to listening if idle
-        if session.state == ConversationState.IDLE:
-            # IDLE'dan LISTENING'e geçerken buffer'ı temizle
-            await session.audio_buffer.clear()
-            await session.change_state(ConversationState.LISTENING)
-            await websocket.send_json({
-                "type": "state_change",
-                "from": "idle",
-                "to": "listening"
-            })
-            # IDLE'dan LISTENING'e geçerken STT'yi başlat
-            if not session.is_streaming:
-                await session.restart_stt_if_needed()
-        
         # LISTENING state'inde değilse audio işleme
         if session.state != ConversationState.LISTENING:
+            log_warning(f"⚠️ Audio received in unexpected state: {session.state.value}", session_id=session.session.session_id)
+            return
+        
+        # STT yoksa veya streaming değilse hata döndür
+        if not session.stt_manager or not session.is_streaming:
+            log_warning(f"��️ STT not ready, attempting to restart", session_id=session.session.session_id)
+            await websocket.send_json({
+                "type": "error",
+                "error_type": "stt_not_ready",
+                "message": "STT is not ready. Waiting for initialization..."
+            })
             return
             
         # Add to buffer
@@ -619,92 +635,69 @@ async def handle_audio_chunk(websocket: WebSocket, session: RealtimeSession, mes
         # Check silence
         silence_duration = session.silence_detector.update(decoded_audio)
         
-        # Stream to STT if available and in LISTENING state
-        if session.stt_manager and session.state == ConversationState.LISTENING:
-            # Ensure streaming is active
-            if not session.is_streaming:
-                log_warning(f"⚠️ STT not streaming, attempting to restart", session_id=session.session.session_id)
-                restart_success = await session.restart_stt_if_needed()
-                if not restart_success:
+        # Stream to STT
+        try:
+            # Chunk counter artır
+            session.chunk_counter += 1
+            
+            if session.chunk_counter == 1:
+                log_info(f"🎤 Started streaming audio to STT", session_id=session.session.session_id)
+                # İlk chunk'ta format kontrolü yap
+                if len(decoded_audio) >= 4:
+                    if decoded_audio[:4] == b'\x1a\x45\xdf\xa3':
+                        log_info(f"✅ Valid WEBM header detected", session_id=session.session.session_id)
+                    else:
+                        log_warning(f"⚠️ Unknown audio format, first 4 bytes: {decoded_audio[:4].hex()}", session_id=session.session.session_id)
+            elif session.chunk_counter % 100 == 0:
+                log_info(f"📊 Sent {session.chunk_counter} chunks to STT so far...", session_id=session.session.session_id)
+            
+            # STT'ye gönder ve sonuçları bekle
+            async for result in session.stt_manager.stream_audio(decoded_audio):
+                # SADECE FINAL RESULT'LARI İŞLE
+                if result.is_final:
+                    log_info(f"✅ FINAL TRANSCRIPTION: '{result.text}'", session_id=session.session.session_id)
+                    
+                    # Send ONLY final transcription to frontend
                     await websocket.send_json({
-                        "type": "error",
-                        "error_type": "stt_error",
-                        "message": "STT streaming not available"
+                        "type": "transcription",
+                        "text": result.text,
+                        "is_final": True,
+                        "confidence": result.confidence
                     })
-                    return
-            
-            try:
-                # Chunk counter artır
-                session.chunk_counter += 1
-                
-                if session.chunk_counter == 1:
-                    log_info(f"🎤 Started streaming audio to STT", session_id=session.session.session_id)
-                    # İlk chunk'ta format kontrolü yap
-                    if len(decoded_audio) >= 4:
-                        if decoded_audio[:4] == b'\x1a\x45\xdf\xa3':
-                            log_info(f"✅ Valid WEBM header detected", session_id=session.session.session_id)
-                        else:
-                            log_warning(f"⚠️ Unknown audio format, first 4 bytes: {decoded_audio[:4].hex()}", session_id=session.session.session_id)
-                            # Format hatalıysa buffer'ı temizle ve chunk counter'ı resetle
-                            await session.audio_buffer.clear()
-                            session.chunk_counter = 0
-                            await session.stop_stt_streaming()
-                            await session.restart_stt_if_needed()
-                            return
-                elif session.chunk_counter % 100 == 0:
-                    log_info(f"📊 Sent {session.chunk_counter} chunks to STT so far...", session_id=session.session.session_id)
-                
-                # STT'ye gönder ve sonuçları bekle
-                async for result in session.stt_manager.stream_audio(decoded_audio):
-                    # SADECE FINAL RESULT'LARI İŞLE
-                    if result.is_final:
-                        log_info(f"✅ FINAL TRANSCRIPTION: '{result.text}'", session_id=session.session.session_id)
+                    
+                    session.current_transcription = result.text
+                    
+                    # Final transcription geldiğinde STT'yi durdur ve işle
+                    if session.current_transcription:
+                        # Önce STT'yi durdur
+                        await session.stop_stt_streaming()
                         
-                        # Send ONLY final transcription to frontend
+                        # State'i değiştir
+                        await session.change_state(ConversationState.PROCESSING_STT)
                         await websocket.send_json({
-                            "type": "transcription",
-                            "text": result.text,
-                            "is_final": True,
-                            "confidence": result.confidence
+                            "type": "state_change",
+                            "from": "listening",
+                            "to": "processing_stt"
                         })
                         
-                        session.current_transcription = result.text
-                        
-                        # Final transcription geldiğinde STT'yi durdur ve işle
-                        if session.current_transcription:
-                            # Önce STT'yi durdur
-                            await session.stop_stt_streaming()
-                            
-                            # State'i değiştir
-                            await session.change_state(ConversationState.PROCESSING_STT)
-                            await websocket.send_json({
-                                "type": "state_change",
-                                "from": "listening",
-                                "to": "processing_stt"
-                            })
-                            
-                            # Process user input
-                            await process_user_input(websocket, session)
-                            return
+                        # Process user input
+                        await process_user_input(websocket, session)
+                        return
                         
-            except Exception as e:
-                error_msg = str(e)
-                # Google STT timeout hatası kontrolü
-                if "Audio Timeout Error" in error_msg or "stream duration" in error_msg or "Exceeded maximum allowed stream duration" in error_msg:
-                    log_warning(f"⚠️ STT timeout detected, restarting stream", session_id=session.session.session_id)
-                    session.is_streaming = False
-                    session.chunk_counter = 0
-                    # Buffer'ı temizle
-                    await session.audio_buffer.clear()
-                    # Timeout durumunda yeniden başlat
-                    await session.restart_stt_if_needed()
-                else:
-                    log_error(f"❌ STT streaming error", error=error_msg, traceback=traceback.format_exc(), session_id=session.session.session_id)
-                    await websocket.send_json({
-                        "type": "error",
-                        "error_type": "stt_error",
-                        "message": f"STT error: {str(e)}"
-                    })
+        except Exception as e:
+            error_msg = str(e)
+            # Google STT timeout hatası kontrolü
+            if "Audio Timeout Error" in error_msg or "stream duration" in error_msg or "Exceeded maximum allowed stream duration" in error_msg:
+                log_warning(f"⚠️ STT timeout detected, ignoring", session_id=session.session.session_id)
+                # Timeout durumunda STT'yi yeniden başlatmaya gerek yok, 
+                # çünkü kullanıcı konuşmayı bitirdiğinde zaten yeniden başlatılacak
+            else:
+                log_error(f"❌ STT streaming error", error=error_msg, traceback=traceback.format_exc(), session_id=session.session.session_id)
+                await websocket.send_json({
+                    "type": "error",
+                    "error_type": "stt_error",
+                    "message": f"STT error: {str(e)}"
+                })
             
     except Exception as e:
         log_error(f"❌ Error in handle_audio_chunk", error=str(e), traceback=traceback.format_exc(), session_id=session.session.session_id)
@@ -713,79 +706,6 @@ async def handle_audio_chunk(websocket: WebSocket, session: RealtimeSession, mes
             "error_type": "audio_error",
             "message": f"Audio processing error: {str(e)}"
         })
-        
-async def handle_control_message(websocket: WebSocket, session: RealtimeSession, message: Dict[str, Any]):
-    """Handle control messages"""
-    action = message.get("action")
-    config = message.get("config", {})
-    
-    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_config",
-            "session_id": session.session.session_id,
-            "config": {
-                "silence_threshold_ms": session.silence_threshold_ms,
-                "audio_chunk_size": session.audio_chunk_size,
-                "supports_barge_in": False  # Barge-in devre dışı
-            }
-        })
-        
-    elif action == "end_session" or action == "stop_session":
-        # Clean up and close
-        await session.cleanup()
-        await websocket.close()
-        
-    elif action == "interrupt":
-        # Barge-in devre dışı - ignore
-        log_warning(f"⚠️ Interrupt request ignored (barge-in disabled)", session_id=session.session.session_id)
-        
-    elif action == "reset":
-        # Reset conversation state
-        await session.reset_for_new_utterance()
-        await session.stop_stt_streaming()
-        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:
-            log_info(f"🎵 Client reported audio ended", session_id=session.session.session_id)
-            await session.change_state(ConversationState.LISTENING)
-            await websocket.send_json({
-                "type": "state_change",
-                "from": "playing_audio",
-                "to": "listening"
-            })
-            # STT'yi yeniden başlat
-            success = await session.restart_stt_if_needed()
-            
-            # STT hazır olduğunda sinyal gönder
-            if success and session.is_streaming:
-                log_info(f"✅ Sending STT ready signal", session_id=session.session.session_id)
-                await websocket.send_json({
-                    "type": "stt_ready",
-                    "message": "STT is ready to receive audio"
-                })
-            else:
-                log_error(f"❌ STT not ready after restart", session_id=session.session.session_id)
-                await websocket.send_json({
-                    "type": "error",
-                    "error_type": "stt_init_failed",
-                    "message": "Failed to initialize STT after audio playback"
-                })
-            
-    elif action == "restart_stt":
-        # Manual STT restart request
-        log_info(f"🔄 Manual STT restart requested", session_id=session.session.session_id)
-        await session.stop_stt_streaming()
-        await session.restart_stt_if_needed()
 
 # ========================= PROCESSING FUNCTIONS =========================
 async def process_user_input(websocket: WebSocket, session: RealtimeSession):