Add text bot support to groq websocket handler - route text clients to structured responses instead of audio

groq_websocket_handler.py

@@ -87,6 +87,10 @@ class GroqWebSocketHandler:
                 await self._process_audio_stream(websocket, session_id, message)
             elif message_type == "text_query":
                 await self._process_text_query(websocket, session_id, message)
+            elif message_type == "voice_message":
+                await self._process_voice_message(websocket, session_id, message)
+            elif message_type == "connection":
+                await self._handle_connection_message(websocket, session_id, message)
             elif message_type == "conversation_state":
                 await self._handle_conversation_state(websocket, session_id, message)
             elif message_type == "voice_settings":
@@ -177,7 +181,7 @@ class GroqWebSocketHandler:
             })
             
             # Process the transcribed query
-            await self._process_transcribed_query(websocket, session_id, transcribed_text, user_language)
+            await self._process_transcribed_query(websocket, session_id, transcribed_text, user_language, client_type="voice")
             
         except Exception as e:
             logger.error(f"❌ Audio processing error: {e}")
@@ -187,7 +191,71 @@ class GroqWebSocketHandler:
                 "timestamp": time.time()
             })
 
-    async def _process_transcribed_query(self, websocket: WebSocket, session_id: str, query: str, language: str = "en"):
+    async def _process_voice_message(self, websocket: WebSocket, session_id: str, message: Dict[str, Any]):
+        """Process voice message with direct transcription (for text clients)"""
+        try:
+            transcription = message.get("transcription", "")
+            client_type = message.get("client_type", "voice")
+            language = message.get("lang", "english")
+            
+            # Check session data for client type override
+            if session_id in self.user_sessions:
+                stored_client_type = self.user_sessions[session_id].get("client_type")
+                if stored_client_type:
+                    client_type = stored_client_type
+            
+            if not transcription:
+                await self.send_message(session_id, {
+                    "type": "error",
+                    "message": "No transcription provided",
+                    "timestamp": time.time()
+                })
+                return
+                
+            logger.info(f"💬 Processing voice message from {client_type} client: {transcription}")
+            
+            # Process the query (same as transcribed query)
+            await self._process_transcribed_query(websocket, session_id, transcription, 
+                                                language, client_type=client_type)
+            
+        except Exception as e:
+            logger.error(f"❌ Voice message processing error: {e}")
+            await self.send_message(session_id, {
+                "type": "error",
+                "message": f"Voice message processing failed: {str(e)}",
+                "timestamp": time.time()
+            })
+
+    async def _handle_connection_message(self, websocket: WebSocket, session_id: str, message: Dict[str, Any]):
+        """Handle connection message to store client preferences"""
+        try:
+            client_type = message.get("client_type", "voice")
+            knowledge_base = message.get("knowledge_base", "government_docs")
+            
+            # Update session data with client type
+            if session_id in self.user_sessions:
+                self.user_sessions[session_id]["client_type"] = client_type
+                self.user_sessions[session_id]["knowledge_base"] = knowledge_base
+                
+            logger.info(f"🔗 Client type set to: {client_type} for session {session_id}")
+            
+            # Send confirmation
+            await self.send_message(session_id, {
+                "type": "connection_confirmed",
+                "client_type": client_type,
+                "knowledge_base": knowledge_base,
+                "timestamp": time.time()
+            })
+            
+        except Exception as e:
+            logger.error(f"❌ Connection message handling error: {e}")
+            await self.send_message(session_id, {
+                "type": "error",
+                "message": f"Connection setup failed: {str(e)}",
+                "timestamp": time.time()
+            })
+
+    async def _process_transcribed_query(self, websocket: WebSocket, session_id: str, query: str, language: str = "en", client_type: str = "voice"):
         """Process transcribed query and generate response"""
         try:
             # Update session activity
@@ -256,11 +324,31 @@ class GroqWebSocketHandler:
                 "timestamp": time.time()
             })
             
-            # Also send friend's format
-            await self.send_message(session_id, {
-                "type": "llm_response",
-                "text": response_text
-            })
+            # Send different response formats based on client type
+            if client_type == "text":
+                # For text clients, send structured response
+                await self.send_message(session_id, {
+                    "type": "streaming_response",
+                    "clause_text": response_text,
+                    "summary": response_text[:200] + "..." if len(response_text) > 200 else response_text,
+                    "role_checklist": [],
+                    "source_title": "Government Document Assistant",
+                    "clause_id": f"response_{int(time.time())}",
+                    "date": time.strftime("%Y-%m-%d"),
+                    "url": "",
+                    "score": 1.0,
+                    "scenario_analysis": None,
+                    "charts": []
+                })
+            else:
+                # For voice clients, send friend's format
+                await self.send_message(session_id, {
+                    "type": "llm_response",
+                    "text": response_text
+                })
+                
+                # Generate TTS audio response (like friend's backend)
+                await self._generate_audio_response(session_id, response_text)
             
             # Update conversation history
             if session_id in self.user_sessions:
@@ -271,9 +359,6 @@ class GroqWebSocketHandler:
                     "timestamp": time.time()
                 })
             
-            # Generate TTS audio response (like friend's backend)
-            await self._generate_audio_response(session_id, response_text)
-            
         except Exception as e:
             logger.error(f"❌ Query processing error: {e}")
             await self.send_message(session_id, {