feat: Add WebSocket support for real-time TTS integration

- Added WebSocketTTSHandler class for real-time TTS synthesis
- Integrated FastAPI WebSocket endpoints (/ws/tts, /ws/tts/{client_id})
- ZeroGPU Bark synthesis with base64 audio response
- Support for multiple voice presets via WebSocket
- Triple protocol support: Gradio + MCP + WebSocket
- Compatible with ChatCal WebRTC voice pipeline

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

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

app.py

@@ -91,6 +91,9 @@ import spaces  # Required for ZeroGPU
 import asyncio
 import threading
 import json
+import base64
+from datetime import datetime
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 
 # 6. Additional uvicorn patching after import
 try:
@@ -315,10 +318,222 @@ def get_system_info():
         "🔧 PyTorch": torch.__version__,
         "🤖 Model Status": "✅ Loaded" if model is not None else "⏳ Loading on first use",
         "🎛️ Mixed Precision": "✅ Enabled" if torch.cuda.is_available() else "❌ CPU Mode",
-        "🔌 MCP Server": "✅ Available" if MCP_AVAILABLE else "❌ Not Available"
+        "🔌 MCP Server": "✅ Available" if MCP_AVAILABLE else "❌ Not Available",
+        "🌐 WebSocket TTS": "✅ Ready" if model is not None else "⏳ Initializing"
     }
     return "\n".join([f"{k}: {v}" for k, v in info.items()])
 
+# WebSocket TTS Handler for Real-time Text-to-Speech
+class WebSocketTTSHandler:
+    """WebSocket handler for real-time TTS integration with ChatCal WebRTC"""
+    
+    def __init__(self):
+        self.active_connections = {}
+        
+    async def connect(self, websocket: WebSocket, client_id: str):
+        """Accept WebSocket connection for TTS service"""
+        await websocket.accept()
+        self.active_connections[client_id] = websocket
+        safe_log("info", f"🔌 TTS WebSocket client {client_id} connected")
+        
+        # Send connection confirmation with service info
+        await self.send_message(client_id, {
+            "type": "tts_connection_confirmed",
+            "client_id": client_id,
+            "timestamp": datetime.now().isoformat(),
+            "service": "tts-gpu-service",
+            "model_status": "✅ Loaded" if model is not None else "⏳ Loading",
+            "zerogpu_status": "✅ Active" if torch.cuda.is_available() else "❌ Not Available",
+            "available_voices": ["v2/en_speaker_6", "v2/en_speaker_9", "v2/en_speaker_3", "v2/en_speaker_1"]
+        })
+    
+    async def disconnect(self, client_id: str):
+        """Clean up connection"""
+        if client_id in self.active_connections:
+            del self.active_connections[client_id]
+        safe_log("info", f"🔌 TTS WebSocket client {client_id} disconnected")
+    
+    async def send_message(self, client_id: str, message: dict):
+        """Send JSON message to client"""
+        if client_id in self.active_connections:
+            websocket = self.active_connections[client_id]
+            try:
+                await websocket.send_text(json.dumps(message))
+            except Exception as e:
+                safe_log("error", f"Failed to send message to TTS client {client_id}: {e}")
+                await self.disconnect(client_id)
+    
+    async def handle_text_synthesis(self, client_id: str, text: str, voice_preset: str = "v2/en_speaker_6"):
+        """Process text synthesis with real TTS service"""
+        try:
+            safe_log("info", f"🔊 TTS: Processing text from {client_id}: {text[:50]}...")
+            
+            # Use the existing ZeroGPU synthesize_speech function
+            audio_path, status = synthesize_speech(text, voice_preset)
+            
+            if audio_path and "✅" in status:
+                # Read the generated audio file
+                with open(audio_path, 'rb') as audio_file:
+                    audio_data = audio_file.read()
+                
+                # Encode audio as base64 for WebSocket transmission
+                audio_b64 = base64.b64encode(audio_data).decode('utf-8')
+                
+                # Send successful synthesis
+                await self.send_message(client_id, {
+                    "type": "tts_audio_response",
+                    "audio_data": audio_b64,
+                    "audio_format": "wav",
+                    "text": text,
+                    "voice_preset": voice_preset,
+                    "timestamp": datetime.now().isoformat(),
+                    "audio_size": len(audio_data),
+                    "status": status
+                })
+                
+                safe_log("info", f"🔊 TTS: Audio response sent to {client_id} ({len(audio_data)} bytes)")
+                
+                # Clean up temporary file
+                import os
+                try:
+                    os.unlink(audio_path)
+                except:
+                    pass
+                
+            else:
+                # Send error message
+                await self.send_message(client_id, {
+                    "type": "tts_error",
+                    "message": f"TTS synthesis failed: {status}",
+                    "text": text,
+                    "timestamp": datetime.now().isoformat()
+                })
+                
+        except Exception as e:
+            safe_log("error", f"TTS WebSocket error for {client_id}: {e}")
+            await self.send_message(client_id, {
+                "type": "tts_error",
+                "message": f"TTS processing error: {str(e)}",
+                "timestamp": datetime.now().isoformat()
+            })
+    
+    async def handle_message(self, client_id: str, message_data: dict):
+        """Handle different types of WebSocket messages"""
+        message_type = message_data.get("type")
+        
+        if message_type == "tts_synthesize":
+            # Text-to-speech synthesis request
+            text = message_data.get("text", "")
+            voice_preset = message_data.get("voice_preset", "v2/en_speaker_6")
+            
+            if text.strip():
+                await self.handle_text_synthesis(client_id, text, voice_preset)
+            else:
+                await self.send_message(client_id, {
+                    "type": "tts_error",
+                    "message": "Empty text provided for synthesis",
+                    "timestamp": datetime.now().isoformat()
+                })
+        
+        elif message_type == "tts_get_voices":
+            # Request available voice presets
+            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:
+            safe_log("warning", f"Unknown TTS message type from {client_id}: {message_type}")
+
+# Global TTS WebSocket handler
+tts_websocket_handler = WebSocketTTSHandler()
+
+# FastAPI WebSocket Integration for TTS Service
+def create_tts_fastapi_app():
+    """Create FastAPI app with TTS WebSocket endpoint"""
+    import uuid
+    
+    app = FastAPI(
+        title="TTS GPU Service WebSocket API",
+        description="Real-time Text-to-Speech with ZeroGPU acceleration",
+        version="1.0.0"
+    )
+    
+    @app.websocket("/ws/tts")
+    async def tts_websocket_endpoint(websocket: WebSocket):
+        """WebSocket endpoint for real-time TTS"""
+        client_id = str(uuid.uuid4())
+        
+        try:
+            await tts_websocket_handler.connect(websocket, client_id)
+            
+            while True:
+                # Receive JSON message from client
+                data = await websocket.receive_text()
+                try:
+                    message = json.loads(data)
+                    await tts_websocket_handler.handle_message(client_id, message)
+                except json.JSONDecodeError as e:
+                    await tts_websocket_handler.send_message(client_id, {
+                        "type": "tts_error",
+                        "message": f"Invalid JSON format: {str(e)}",
+                        "timestamp": datetime.now().isoformat()
+                    })
+                    
+        except WebSocketDisconnect:
+            await tts_websocket_handler.disconnect(client_id)
+        except Exception as e:
+            safe_log("error", f"TTS WebSocket endpoint error: {e}")
+            await tts_websocket_handler.disconnect(client_id)
+    
+    @app.websocket("/ws/tts/{client_id}")
+    async def tts_websocket_with_id(websocket: WebSocket, client_id: str):
+        """WebSocket endpoint with specific client ID"""
+        try:
+            await tts_websocket_handler.connect(websocket, client_id)
+            
+            while True:
+                data = await websocket.receive_text()
+                try:
+                    message = json.loads(data)
+                    await tts_websocket_handler.handle_message(client_id, message)
+                except json.JSONDecodeError as e:
+                    await tts_websocket_handler.send_message(client_id, {
+                        "type": "tts_error",
+                        "message": f"Invalid JSON format: {str(e)}",
+                        "timestamp": datetime.now().isoformat()
+                    })
+                    
+        except WebSocketDisconnect:
+            await tts_websocket_handler.disconnect(client_id)
+        except Exception as e:
+            safe_log("error", f"TTS WebSocket endpoint error: {e}")
+            await tts_websocket_handler.disconnect(client_id)
+    
+    @app.get("/")
+    async def tts_root():
+        """TTS service status endpoint"""
+        return {
+            "service": "tts-gpu-service",
+            "status": "✅ Ready" if model is not None else "⏳ Loading",
+            "zerogpu": "✅ Active" if torch.cuda.is_available() else "❌ Not Available",
+            "websocket_endpoints": ["/ws/tts", "/ws/tts/{client_id}"],
+            "available_voices": ["v2/en_speaker_6", "v2/en_speaker_9", "v2/en_speaker_3", "v2/en_speaker_1"],
+            "model": "suno/bark"
+        }
+    
+    @app.get("/health")
+    async def tts_health():
+        """Health check endpoint"""
+        return {
+            "status": "healthy",
+            "model_loaded": model is not None,
+            "gpu_available": torch.cuda.is_available()
+        }
+    
+    return app
+
 # MCP Tool Definitions and Handlers
 if MCP_AVAILABLE:
     
@@ -826,6 +1041,28 @@ def safe_main():
             else:
                 safe_log("error", "❌ MCP not available but MCP-only mode requested")
                 sys.exit(1)
+        
+        elif "--websocket" in sys.argv:
+            # WebSocket-only mode - FastAPI with TTS WebSocket endpoints
+            safe_log("info", "🌐 Starting TTS service in WebSocket-only mode...")
+            
+            try:
+                import uvicorn
+                fastapi_app = create_tts_fastapi_app()
+                safe_log("info", "✅ TTS WebSocket Server: Starting on port 7860...")
+                
+                uvicorn.run(
+                    fastapi_app,
+                    host="0.0.0.0",
+                    port=7860,
+                    log_config=None,
+                    access_log=False,
+                    log_level="critical"
+                )
+            except Exception as e:
+                safe_log("error", f"Failed to start TTS WebSocket server: {e}")
+                sys.exit(1)
+        
         else:
             # Dual mode - both Gradio and MCP
             safe_log("info", "🚀 Starting TTS service with dual protocol support...")