Update flare-ui/src/app/services/conversation-manager.service.ts

flare-ui/src/app/services/conversation-manager.service.ts

@@ -440,84 +440,105 @@ export class ConversationManagerService implements OnDestroy {
     try {
       // Validate audio data
       if (!message['data']) {
-        console.warn('TTS audio message missing data');
+        console.warn('❌ TTS audio message missing data');
         return;
       }
       
-      // Debug log
-      console.log('TTS chunk received:', {
+      // Detailed log
+      console.log('🎵 TTS chunk received:', {
+        chunkIndex: message['chunk_index'],
+        totalChunks: message['total_chunks'],
         dataLength: message['data'].length,
-        dataPreview: message['data'].substring(0, 50),
+        dataPreview: message['data'].substring(0, 50) + '...',
         isLast: message['is_last'],
         mimeType: message['mime_type']
       });
       
       // Accumulate audio chunks (already base64)
       this.audioQueue.push(message['data']);
+      console.log(`📦 Audio queue size: ${this.audioQueue.length} chunks`);
       
       if (message['is_last']) {
+        console.log('🔧 Processing final audio chunk...');
+        
         try {
           // All chunks received, combine and create audio blob
           const combinedBase64 = this.audioQueue.join('');
-          console.log('Combined audio data:', {
+          console.log('✅ Combined audio data:', {
             totalLength: combinedBase64.length,
-            preview: combinedBase64.substring(0, 100)
+            queueSize: this.audioQueue.length,
+            preview: combinedBase64.substring(0, 100) + '...'
           });
           
           // Validate base64
+          console.log('🔍 Validating base64...');
           if (!this.isValidBase64(combinedBase64)) {
             throw new Error('Invalid base64 data received');
           }
+          console.log('✅ Base64 validation passed');
           
           const audioBlob = this.base64ToBlob(combinedBase64, message['mime_type'] || 'audio/mpeg');
           const audioUrl = URL.createObjectURL(audioBlob);
+          console.log('🎧 Audio URL created:', audioUrl);
           
           // Update last message with audio URL
           const messages = this.messagesSubject.value;
           if (messages.length > 0 && messages[messages.length - 1].role === 'assistant') {
             messages[messages.length - 1].audioUrl = audioUrl;
             this.messagesSubject.next([...messages]);
+            console.log('✅ Audio URL attached to assistant message');
+          } else {
+            console.warn('⚠️ No assistant message found to attach audio');
           }
           
           // Clear queue
           this.audioQueue = [];
+          console.log('🧹 Audio queue cleared');
           
-          console.log('✅ Audio blob created successfully');
+          console.log('✅ Audio processing completed successfully');
         } catch (error) {
-          console.error('Error creating audio blob:', error);
+          console.error('❌ Error creating audio blob:', error);
+          console.error('Queue size was:', this.audioQueue.length);
           this.audioQueue = [];
         }
       }
     } catch (error) {
-      console.error('Error handling TTS audio:', error);
+      console.error('❌ Error handling TTS audio:', error);
       this.audioQueue = []; // Clear queue on error
     }
   }
   
   private isValidBase64(str: string): boolean {
     try {
+      console.log(`🔍 Checking base64 validity for ${str.length} chars`);
+      
       // Check if string contains only valid base64 characters
       const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
       if (!base64Regex.test(str)) {
+        console.error('❌ Base64 regex test failed');
         return false;
       }
       
       // Try to decode to verify
-      atob(str);
+      const decoded = atob(str);
+      console.log(`✅ Base64 decode successful, decoded length: ${decoded.length}`);
       return true;
     } catch (e) {
+      console.error('❌ Base64 validation error:', e);
       return false;
     }
   }
   
   private base64ToBlob(base64: string, mimeType: string): Blob {
     try {
-      console.log('Converting base64 to blob:', {
-        length: base64.length,
+      console.log('🔄 Converting base64 to blob:', {
+        base64Length: base64.length,
         mimeType: mimeType
       });
       
       const byteCharacters = atob(base64);
+      console.log(`📊 Decoded to ${byteCharacters.length} bytes`);
+      
       const byteNumbers = new Array(byteCharacters.length);
       
       for (let i = 0; i < byteCharacters.length; i++) {
@@ -527,16 +548,20 @@ export class ConversationManagerService implements OnDestroy {
       const byteArray = new Uint8Array(byteNumbers);
       const blob = new Blob([byteArray], { type: mimeType });
       
-      console.log('Blob created:', {
+      console.log('✅ Blob created:', {
         size: blob.size,
-        type: blob.type
+        type: blob.type,
+        sizeKB: (blob.size / 1024).toFixed(2) + ' KB'
       });
       
       return blob;
     } catch (error) {
-      console.error('Error converting base64 to blob:', error);
-      console.log('Base64 length:', base64.length);
-      console.log('Base64 preview:', base64.substring(0, 100));
+      console.error('❌ Error converting base64 to blob:', error);
+      console.error('Input details:', {
+        base64Length: base64.length,
+        base64Preview: base64.substring(0, 100) + '...',
+        mimeType: mimeType
+      });
       throw new Error('Failed to convert audio data');
     }
   }