Add 89999999999999999999999999999

app.py

@@ -226,33 +226,68 @@ async def websocket_endpoint(websocket: WebSocket):
 @app.websocket("/ws/stream")
 async def websocket_stream_endpoint(websocket: WebSocket):
     """
-    Enhanced WebSocket endpoint with Groq ASR for superior voice transcription
-    Based on friend's superior implementation for better accuracy
+    Enhanced WebSocket endpoint compatible with friend's frontend format
+    Handles both JSON audio format and friend's JSON+Binary format
     """
     from groq_websocket_handler import groq_websocket_handler
     import json
+    import base64
     
     # Accept connection and get session ID
     session_id = await groq_websocket_handler.connect(websocket)
     
+    # Send connection successful message (friend's format)
+    await websocket.send_json({"type": "connection_successful"})
+    
     try:
         while True:
-            # Receive message from client
-            message_text = await websocket.receive_text()
-            
             try:
+                # Try to receive JSON message first
+                message_text = await websocket.receive_text()
                 message = json.loads(message_text)
+                
+                # Check if this is friend's format with lang field
+                if "lang" in message and "type" not in message:
+                    logger.info(f"📱 Received friend's format: {message}")
+                    
+                    # This is friend's format - expect binary audio next
+                    try:
+                        # Receive the binary audio data
+                        audio_bytes = await websocket.receive_bytes()
+                        logger.info(f"🎤 Received {len(audio_bytes)} bytes of audio data")
+                        
+                        # Convert to base64 for internal processing
+                        audio_base64 = base64.b64encode(audio_bytes).decode('utf-8')
+                        
+                        # Create standard message format for internal processing
+                        standard_message = {
+                            "type": "audio_data",
+                            "language": "en" if message.get("lang", "").lower().startswith("eng") else message.get("lang", "en"),
+                            "audio_data": audio_base64,
+                            "user_id": message.get("user_id")
+                        }
+                        
+                        # Process using standard handler
+                        await groq_websocket_handler.handle_stream_message(websocket, session_id, standard_message)
+                        
+                    except Exception as audio_error:
+                        logger.error(f"❌ Error receiving binary audio: {audio_error}")
+                        await websocket.send_json({
+                            "type": "error", 
+                            "message": "Failed to receive audio data"
+                        })
+                        
+                else:
+                    # This is standard format - process normally
+                    await groq_websocket_handler.handle_stream_message(websocket, session_id, message)
+                    
             except json.JSONDecodeError:
-                await groq_websocket_handler.send_message(session_id, {
+                await websocket.send_json({
                     "type": "error",
-                    "message": "Invalid JSON message",
-                    "timestamp": datetime.now().isoformat()
+                    "message": "Invalid JSON message"
                 })
                 continue
-            
-            # Handle different message types
-            await groq_websocket_handler.handle_stream_message(websocket, session_id, message)
-            
+                
     except Exception as e:
         logger.error(f"❌ WebSocket stream error: {e}")
     finally:

groq_websocket_handler.py

@@ -159,7 +159,7 @@ class GroqWebSocketHandler:
                 })
                 return
             
-            # Send transcription result
+            # Send transcription result (both formats for compatibility)
             await self.send_message(session_id, {
                 "type": "transcription_complete",
                 "transcribed_text": transcribed_text,
@@ -168,6 +168,12 @@ class GroqWebSocketHandler:
                 "timestamp": time.time()
             })
             
+            # Also send friend's format
+            await self.send_message(session_id, {
+                "type": "transcription",
+                "text": transcribed_text
+            })
+            
             # Process the transcribed query
             await self._process_transcribed_query(websocket, session_id, transcribed_text, user_language)
             
@@ -229,16 +235,24 @@ class GroqWebSocketHandler:
             
             processing_time = time.time() - processing_start
             
-            # Send response
+            # Send response (both formats for compatibility)
+            response_text = response_data.get("response", "I couldn't generate a response.")
+            
             await self.send_message(session_id, {
                 "type": "response_complete",
-                "response": response_data.get("response", "I couldn't generate a response."),
+                "response": response_text,
                 "sources": response_data.get("sources", []),
                 "processing_time": processing_time,
                 "query_context": query_context,
                 "timestamp": time.time()
             })
             
+            # Also send friend's format
+            await self.send_message(session_id, {
+                "type": "llm_response",
+                "text": response_text
+            })
+            
             # Update conversation history
             if session_id in self.user_sessions:
                 self.user_sessions[session_id]["conversation_history"].append({