feat: Complete TTS playback integration for voice responses v0.4.9

- Added WebSocket TTS handler to TTS service with ZeroGPU synthesis
- Integrated TTS WebSocket client in ChatCal WebRTC handler
- Real-time text-to-speech with base64 audio transmission
- Auto-generate demo TTS responses after STT transcription
- Client-side audio playback with proper error handling
- Complete voice interaction loop: Speech → Text → Response → Audio

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

version.py

@@ -2,8 +2,8 @@
 Version information for ChatCal Voice-Enabled AI Assistant
 """
 
-__version__ = "0.4.8"
-__build_date__ = "2025-08-20T16:45:00"
+__version__ = "0.4.9"
+__build_date__ = "2025-08-20T17:00:00"
 __description__ = "Voice-Enabled ChatCal AI Assistant with Hugging Face deployment"
 
 def get_version_info():

webrtc/server/fastapi_integration.py

@@ -158,6 +158,19 @@ def create_fastapi_app() -> FastAPI:
             
             if (data.type === 'transcription') {
                 addTranscription(data.text, data.timestamp);
+                
+                // Auto-generate TTS response for demo
+                if (data.text && data.text.trim()) {
+                    const demoResponse = `I heard you say: "${data.text}". This is a demo TTS response.`;
+                    setTimeout(() => {
+                        requestTTSPlayback(demoResponse);
+                    }, 1000); // Wait 1 second before TTS response
+                }
+            } else if (data.type === 'tts_playback') {
+                playTTSAudio(data.audio_data, data.text);
+            } else if (data.type === 'tts_error') {
+                console.error('TTS Error:', data.message);
+                addTranscription(`TTS Error: ${data.message}`, data.timestamp, true);
             } else if (data.type === 'error') {
                 addTranscription(`Error: ${data.message}`, data.timestamp, true);
             }
@@ -250,6 +263,61 @@ def create_fastapi_app() -> FastAPI:
             }
         }
         
+        function requestTTSPlayback(text, voicePreset = 'v2/en_speaker_6') {
+            console.log('Requesting TTS playback:', text);
+            if (websocket && websocket.readyState === WebSocket.OPEN) {
+                websocket.send(JSON.stringify({
+                    type: 'tts_request',
+                    text: text,
+                    voice_preset: voicePreset
+                }));
+            } else {
+                console.error('WebSocket not available for TTS request');
+            }
+        }
+        
+        function playTTSAudio(audioBase64, text) {
+            console.log('Playing TTS audio for:', text);
+            try {
+                // Convert base64 to audio blob
+                const audioData = atob(audioBase64);
+                const arrayBuffer = new ArrayBuffer(audioData.length);
+                const uint8Array = new Uint8Array(arrayBuffer);
+                
+                for (let i = 0; i < audioData.length; i++) {
+                    uint8Array[i] = audioData.charCodeAt(i);
+                }
+                
+                const audioBlob = new Blob([arrayBuffer], { type: 'audio/wav' });
+                const audioUrl = URL.createObjectURL(audioBlob);
+                
+                const audio = new Audio(audioUrl);
+                audio.onloadeddata = () => {
+                    console.log('TTS audio loaded, playing...');
+                    addTranscription(`🔊 Playing: ${text}`, new Date().toISOString(), false);
+                };
+                
+                audio.onended = () => {
+                    console.log('TTS audio finished playing');
+                    URL.revokeObjectURL(audioUrl); // Clean up
+                };
+                
+                audio.onerror = (error) => {
+                    console.error('TTS audio playback error:', error);
+                    addTranscription(`TTS Playback Error: ${error}`, new Date().toISOString(), true);
+                };
+                
+                audio.play().catch(error => {
+                    console.error('Failed to play TTS audio:', error);
+                    addTranscription(`TTS Play Error: User interaction may be required`, new Date().toISOString(), true);
+                });
+                
+            } catch (error) {
+                console.error('Error processing TTS audio:', error);
+                addTranscription(`TTS Processing Error: ${error}`, new Date().toISOString(), true);
+            }
+        }
+        
         // Event listeners
         recordBtn.addEventListener('click', startRecording);
         stopBtn.addEventListener('click', stopRecording);

webrtc/server/websocket_handler.py

@@ -27,6 +27,10 @@ class WebRTCHandler:
         self.stt_websocket_url = "wss://pgits-stt-gpu-service.hf.space/ws/stt"
         self.stt_connections: Dict[str, websockets.WebSocketClientProtocol] = {}
         
+        self.tts_service_url = "https://pgits-tts-gpu-service.hf.space"
+        self.tts_websocket_url = "wss://pgits-tts-gpu-service.hf.space/ws/tts"
+        self.tts_connections: Dict[str, websockets.WebSocketClientProtocol] = {}
+        
     async def connect(self, websocket: WebSocket, client_id: str):
         """Accept WebSocket connection and initialize audio buffer"""
         await websocket.accept()
@@ -56,6 +60,9 @@ class WebRTCHandler:
         # Clean up STT connection if exists
         await self.disconnect_from_stt_service(client_id)
         
+        # Clean up TTS connection if exists
+        await self.disconnect_from_tts_service(client_id)
+        
         logger.info(f"🔌 WebRTC client {client_id} disconnected")
     
     async def send_message(self, client_id: str, message: dict):
@@ -196,6 +203,130 @@ class WebRTCHandler:
             # Cleanup connection on error
             await self.disconnect_from_stt_service(client_id)
             return None
+    
+    # TTS WebSocket Methods
+    async def connect_to_tts_service(self, client_id: str) -> bool:
+        """Connect to the TTS WebSocket service"""
+        try:
+            logger.info(f"🔌 Connecting to TTS service for client {client_id}: {self.tts_websocket_url}")
+            
+            # Connect to TTS WebSocket service
+            tts_ws = await websockets.connect(self.tts_websocket_url)
+            self.tts_connections[client_id] = tts_ws
+            
+            # Wait for connection confirmation
+            confirmation = await tts_ws.recv()
+            confirmation_data = json.loads(confirmation)
+            
+            if confirmation_data.get("type") == "tts_connection_confirmed":
+                logger.info(f"✅ TTS service connected for client {client_id}")
+                return True
+            else:
+                logger.warning(f"⚠️ Unexpected TTS confirmation: {confirmation_data}")
+                return False
+                
+        except Exception as e:
+            logger.error(f"❌ Failed to connect to TTS service for {client_id}: {e}")
+            return False
+    
+    async def disconnect_from_tts_service(self, client_id: str):
+        """Disconnect from TTS WebSocket service"""
+        if client_id in self.tts_connections:
+            try:
+                tts_ws = self.tts_connections[client_id]
+                await tts_ws.close()
+                del self.tts_connections[client_id]
+                logger.info(f"🔌 Disconnected from TTS service for client {client_id}")
+            except Exception as e:
+                logger.error(f"Error disconnecting from TTS service: {e}")
+    
+    async def send_text_to_tts_service(self, client_id: str, text: str, voice_preset: str = "v2/en_speaker_6") -> Optional[bytes]:
+        """Send text to TTS service and get audio response"""
+        if client_id not in self.tts_connections:
+            # Try to connect if not already connected
+            success = await self.connect_to_tts_service(client_id)
+            if not success:
+                return None
+        
+        try:
+            tts_ws = self.tts_connections[client_id]
+            
+            # Send TTS synthesis message
+            message = {
+                "type": "tts_synthesize",
+                "text": text,
+                "voice_preset": voice_preset
+            }
+            
+            await tts_ws.send(json.dumps(message))
+            logger.info(f"📤 Sent text to TTS service: {text[:50]}...")
+            
+            # Wait for audio response
+            response = await tts_ws.recv()
+            response_data = json.loads(response)
+            
+            if response_data.get("type") == "tts_audio_response":
+                # Decode base64 audio data
+                audio_b64 = response_data.get("audio_data", "")
+                audio_bytes = base64.b64decode(audio_b64)
+                logger.info(f"🔊 TTS audio received: {len(audio_bytes)} bytes")
+                return audio_bytes
+            elif response_data.get("type") == "tts_error":
+                error_msg = response_data.get("message", "Unknown TTS error")
+                logger.error(f"❌ TTS service error: {error_msg}")
+                return None
+            else:
+                logger.warning(f"⚠️ Unexpected TTS response: {response_data}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"❌ Error communicating with TTS service: {e}")
+            # Cleanup connection on error
+            await self.disconnect_from_tts_service(client_id)
+            return None
+    
+    async def play_tts_response(self, client_id: str, text: str, voice_preset: str = "v2/en_speaker_6"):
+        """Generate TTS audio and send to client for playback"""
+        try:
+            logger.info(f"🔊 Generating TTS response for client {client_id}: {text[:50]}...")
+            
+            # Get audio from TTS service
+            audio_data = await self.send_text_to_tts_service(client_id, text, voice_preset)
+            
+            if audio_data:
+                # Convert audio to base64 for WebSocket transmission
+                audio_b64 = base64.b64encode(audio_data).decode('utf-8')
+                
+                # Send audio playback message to client
+                await self.send_message(client_id, {
+                    "type": "tts_playback",
+                    "audio_data": audio_b64,
+                    "audio_format": "wav",
+                    "text": text,
+                    "voice_preset": voice_preset,
+                    "timestamp": datetime.now().isoformat(),
+                    "audio_size": len(audio_data)
+                })
+                
+                logger.info(f"🔊 TTS playback sent to {client_id} ({len(audio_data)} bytes)")
+            else:
+                logger.warning(f"⚠️ TTS service failed to generate audio for: {text[:50]}...")
+                
+                # Send error message
+                await self.send_message(client_id, {
+                    "type": "tts_error",
+                    "message": "TTS audio generation failed",
+                    "text": text,
+                    "timestamp": datetime.now().isoformat()
+                })
+                
+        except Exception as e:
+            logger.error(f"❌ TTS playback error for {client_id}: {e}")
+            await self.send_message(client_id, {
+                "type": "tts_error",
+                "message": f"TTS playback error: {str(e)}",
+                "timestamp": datetime.now().isoformat()
+            })
 
     async def process_audio_file_webrtc(self, audio_file_path: str, sample_rate: int) -> Optional[str]:
         """Process audio file with real STT service via WebSocket"""
@@ -280,6 +411,28 @@ class WebRTCHandler:
             })
             logger.info(f"🎤 Recording stopped for {client_id}")
         
+        elif message_type == "tts_request":
+            # Client requesting TTS playback
+            text = message_data.get("text", "")
+            voice_preset = message_data.get("voice_preset", "v2/en_speaker_6")
+            
+            if text.strip():
+                await self.play_tts_response(client_id, text, voice_preset)
+            else:
+                await self.send_message(client_id, {
+                    "type": "tts_error",
+                    "message": "Empty text provided for TTS",
+                    "timestamp": datetime.now().isoformat()
+                })
+        
+        elif message_type == "get_tts_voices":
+            # Client requesting available TTS voices
+            await self.send_message(client_id, {
+                "type": "tts_voices_list",
+                "voices": ["v2/en_speaker_6", "v2/en_speaker_9", "v2/en_speaker_3", "v2/en_speaker_1"],
+                "timestamp": datetime.now().isoformat()
+            })
+        
         else:
             logger.warning(f"Unknown message type from {client_id}: {message_type}")