ttp-agent-sdk 2.34.7 → 2.34.8

package/dist/agent-widget.dev.js

@@ -13660,7 +13660,7 @@ var TTPChatWidget = /*#__PURE__*/function () {
         this.landingScreen.setupEventHandlers({
           onSelectVoice: function () {
             var _onSelectVoice = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
-              var _this6$voiceInterface4, _this6$voiceInterface5, _this6$voiceInterface6, _this6$voiceInterface8, _this6$config$behavio, idleState, isDomainError, statusTitle, _this6$voiceInterface7, titleText, domainErrorTitle, _widgetMode, _this6$voiceInterface0, _this6$config$behavio2, _this6$voiceInterface9, _widgetMode2, _t;
+              var _this6$voiceInterface4, _this6$voiceInterface5, _this6$voiceInterface6, _this6$voiceInterface7, _this6$shadowRoot, floatingButton, _this6$voiceInterface8, _this6$voiceInterface0, _this6$config$behavio, idleState, isDomainError, statusTitle, _this6$voiceInterface9, titleText, domainErrorTitle, _widgetMode, _this6$voiceInterface10, _this6$voiceInterface11, _this6$config$behavio2, _this6$voiceInterface1, _this6$voiceInterface12, _this6$shadowRoot2, existingBar, _floatingButton, _widgetMode2, _t;
               return _regenerator().w(function (_context) {
                 while (1) switch (_context.p = _context.n) {
                   case 0:
@@ -13694,30 +13694,52 @@ var TTPChatWidget = /*#__PURE__*/function () {
                       _this6.voiceInterface.showConnectingState();
                     }
 
-                    // Start the call
+                    // CRITICAL: On mobile, show minimized bar immediately BEFORE blocking operations
+                    // This ensures UI is visible while permission/connection happens
+                    if (!((_this6$voiceInterface5 = _this6.voiceInterface) !== null && _this6$voiceInterface5 !== void 0 && _this6$voiceInterface5.isMobile && (_this6$voiceInterface6 = _this6.voiceInterface) !== null && _this6$voiceInterface6 !== void 0 && _this6$voiceInterface6.createMobileMinimizedBar)) {
+                      _context.n = 3;
+                      break;
+                    }
+                    // Hide floating button immediately so minimized bar is visible
+                    floatingButton = ((_this6$shadowRoot = _this6.shadowRoot) === null || _this6$shadowRoot === void 0 ? void 0 : _this6$shadowRoot.getElementById('text-chat-button')) || document.getElementById('text-chat-button');
+                    if (floatingButton) {
+                      floatingButton.style.display = 'none';
+                    }
+                    // Create minimized bar with connecting state
+                    _this6.voiceInterface.createMobileMinimizedBar();
+                    // Show connecting status in minimized bar
+                    _this6.voiceInterface.updateMobileStatus('connecting');
+                    // Ensure UI is painted before starting heavy operations
                     _context.n = 3;
-                    return _this6.startVoiceCall();
+                    return new Promise(function (resolve) {
+                      return requestAnimationFrame(function () {
+                        return requestAnimationFrame(resolve);
+                      });
+                    });
                   case 3:
-                    if (!((_this6$voiceInterface5 = _this6.voiceInterface) !== null && _this6$voiceInterface5 !== void 0 && _this6$voiceInterface5.isActive)) {
-                      _context.n = 4;
+                    _context.n = 4;
+                    return _this6.startVoiceCall();
+                  case 4:
+                    if (!((_this6$voiceInterface7 = _this6.voiceInterface) !== null && _this6$voiceInterface7 !== void 0 && _this6$voiceInterface7.isActive)) {
+                      _context.n = 5;
                       break;
                     }
                     console.log('✅ Voice call started successfully');
-                    _context.n = 6;
+                    _context.n = 7;
                     break;
-                  case 4:
+                  case 5:
                     // This shouldn't happen if startVoiceCall() throws properly, but just in case
                     console.warn('⚠️ startVoiceCall() returned but call is not active');
 
                     // CRITICAL: Check if we're showing a domain error - if so, stay on voice interface
                     // We check by looking at the status title text content
-                    idleState = (_this6$voiceInterface6 = _this6.voiceInterface) === null || _this6$voiceInterface6 === void 0 || (_this6$voiceInterface6 = _this6$voiceInterface6.shadowRoot) === null || _this6$voiceInterface6 === void 0 ? void 0 : _this6$voiceInterface6.getElementById('voiceIdleState');
+                    idleState = (_this6$voiceInterface8 = _this6.voiceInterface) === null || _this6$voiceInterface8 === void 0 || (_this6$voiceInterface8 = _this6$voiceInterface8.shadowRoot) === null || _this6$voiceInterface8 === void 0 ? void 0 : _this6$voiceInterface8.getElementById('voiceIdleState');
                     isDomainError = false;
                     if (idleState && idleState.style.display !== 'none') {
                       statusTitle = idleState.querySelector('.voice-status-title');
                       if (statusTitle) {
                         titleText = statusTitle.textContent.trim();
-                        domainErrorTitle = (_this6$voiceInterface7 = _this6.voiceInterface) === null || _this6$voiceInterface7 === void 0 ? void 0 : _this6$voiceInterface7.t('domainNotValidated');
+                        domainErrorTitle = (_this6$voiceInterface9 = _this6.voiceInterface) === null || _this6$voiceInterface9 === void 0 ? void 0 : _this6$voiceInterface9.t('domainNotValidated');
                         console.log('🔍 Checking for domain error - titleText:', titleText, 'domainErrorTitle:', domainErrorTitle);
                         if (titleText === domainErrorTitle || titleText.includes('Domain not') || titleText.includes('not whitelisted')) {
                           isDomainError = true;
@@ -13726,7 +13748,7 @@ var TTPChatWidget = /*#__PURE__*/function () {
                       }
                     }
                     if (!isDomainError) {
-                      _context.n = 5;
+                      _context.n = 6;
                       break;
                     }
                     // Set currentView to voice so we don't return to landing
@@ -13736,42 +13758,55 @@ var TTPChatWidget = /*#__PURE__*/function () {
                     // Don't reset connecting state or return to landing - stay on voice interface showing error
                     console.log('✅ Staying on voice interface with domain error displayed');
                     return _context.a(2);
-                  case 5:
+                  case 6:
                     // Not a domain error - reset connecting state and return to landing
                     console.log('⚠️ Not a domain error - returning to landing screen');
-                    if ((_this6$voiceInterface8 = _this6.voiceInterface) !== null && _this6$voiceInterface8 !== void 0 && _this6$voiceInterface8.resetConnectingState) {
+                    if ((_this6$voiceInterface0 = _this6.voiceInterface) !== null && _this6$voiceInterface0 !== void 0 && _this6$voiceInterface0.resetConnectingState) {
                       _this6.voiceInterface.resetConnectingState();
                     }
                     _widgetMode = ((_this6$config$behavio = _this6.config.behavior) === null || _this6$config$behavio === void 0 ? void 0 : _this6$config$behavio.mode) || 'unified';
                     if (_widgetMode === 'unified') {
                       _this6.showLanding();
                     }
-                  case 6:
-                    _context.n = 9;
-                    break;
                   case 7:
-                    _context.p = 7;
+                    _context.n = 10;
+                    break;
+                  case 8:
+                    _context.p = 8;
                     _t = _context.v;
                     if (!(_t.isServerRejection || _t.name === 'ServerRejected')) {
-                      _context.n = 8;
+                      _context.n = 9;
                       break;
                     }
                     // Server rejection is expected - the error handler will show domain error message
                     // Reset connecting state but don't log as error
-                    if ((_this6$voiceInterface9 = _this6.voiceInterface) !== null && _this6$voiceInterface9 !== void 0 && _this6$voiceInterface9.resetConnectingState) {
+                    if ((_this6$voiceInterface1 = _this6.voiceInterface) !== null && _this6$voiceInterface1 !== void 0 && _this6$voiceInterface1.resetConnectingState) {
                       _this6.voiceInterface.resetConnectingState();
                     }
                     // Don't show toast for server rejection - domain error handler will show message
                     return _context.a(2);
-                  case 8:
+                  case 9:
                     // Log other errors (permission denied, etc.)
                     console.error('❌ Failed to start voice call:', _t);
 
                     // Reset connecting state on error
-                    if ((_this6$voiceInterface0 = _this6.voiceInterface) !== null && _this6$voiceInterface0 !== void 0 && _this6$voiceInterface0.resetConnectingState) {
+                    if ((_this6$voiceInterface10 = _this6.voiceInterface) !== null && _this6$voiceInterface10 !== void 0 && _this6$voiceInterface10.resetConnectingState) {
                       _this6.voiceInterface.resetConnectingState();
                     }
 
+                    // Clean up mobile bar if it was created early
+                    if ((_this6$voiceInterface11 = _this6.voiceInterface) !== null && _this6$voiceInterface11 !== void 0 && _this6$voiceInterface11.isMobile) {
+                      existingBar = document.getElementById('mobile-voice-call-bar-container');
+                      if (existingBar && (_this6$voiceInterface12 = _this6.voiceInterface) !== null && _this6$voiceInterface12 !== void 0 && _this6$voiceInterface12.removeMobileMinimizedBar) {
+                        _this6.voiceInterface.removeMobileMinimizedBar();
+                      }
+                      // Restore floating button if it was hidden
+                      _floatingButton = ((_this6$shadowRoot2 = _this6.shadowRoot) === null || _this6$shadowRoot2 === void 0 ? void 0 : _this6$shadowRoot2.getElementById('text-chat-button')) || document.getElementById('text-chat-button');
+                      if (_floatingButton) {
+                        _floatingButton.style.display = '';
+                      }
+                    }
+
                     // Show user-friendly error message (unless it's a user cancellation)
                     if (_t.message !== 'Call cancelled by user') {
                       _this6.showErrorToast(_t.message || 'Failed to start voice call. Please try again.', 'error');
@@ -13782,15 +13817,15 @@ var TTPChatWidget = /*#__PURE__*/function () {
                     if (_widgetMode2 === 'unified') {
                       _this6.showLanding();
                     }
-                  case 9:
-                    _context.p = 9;
+                  case 10:
+                    _context.p = 10;
                     // ✅ Always reset flag, even if showVoice() or startVoiceCall() throws
                     _this6.isStartingCall = false;
-                    return _context.f(9);
-                  case 10:
+                    return _context.f(10);
+                  case 11:
                     return _context.a(2);
                 }
-              }, _callee, null, [[2, 7, 9, 10]]);
+              }, _callee, null, [[2, 8, 10, 11]]);
             }));
             function onSelectVoice() {
               return _onSelectVoice.apply(this, arguments);
@@ -16132,7 +16167,7 @@ var VoiceInterface = /*#__PURE__*/function () {
     value: (function () {
       var _proceedWithVoiceCall = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5() {
         var _this3 = this;
-        var isResumeCall, panel, header, toggleText, _voiceInterface, originalSection, compactSection, idleState, _panel, fallbackPanel, sampleRate, mediaStream, floatingButton, fallbackButton, _idleState, _panel2, _fallbackPanel, deviceInfo, _idleState2, activeState, voiceInterface, signedUrl, connected, serverRejected, originalOnError, originalOnDisconnected, attempts, _this$sdk$voiceSDK, error, _idleState3, _panel3, _fallbackPanel2, _floatingButton, _fallbackButton, updateTimer, _idleState4, _panel4, _fallbackPanel3, _floatingButton2, _fallbackButton2, _updateTimer, _deviceInfo, _t2, _t3, _t4, _t5, _t6, _t7;
+        var isResumeCall, panel, header, toggleText, _voiceInterface, originalSection, compactSection, idleState, _panel, fallbackPanel, sampleRate, mediaStream, floatingButton, fallbackButton, existingBar, _floatingButton, _fallbackButton, _idleState, _panel2, _fallbackPanel, deviceInfo, _idleState2, activeState, voiceInterface, signedUrl, connected, serverRejected, originalOnError, originalOnDisconnected, attempts, _this$sdk$voiceSDK, error, _existingBar, _existingBar2, _idleState3, _panel3, _fallbackPanel2, _floatingButton2, _fallbackButton2, updateTimer, _existingBar3, _existingBar4, _idleState4, _panel4, _fallbackPanel3, _floatingButton3, _fallbackButton3, _updateTimer, _deviceInfo, _t2, _t3, _t4, _t5, _t6, _t7;
         return _regenerator().w(function (_context5) {
           while (1) switch (_context5.p = _context5.n) {
             case 0:
@@ -16247,6 +16282,23 @@ var VoiceInterface = /*#__PURE__*/function () {
               console.error('❌ Mobile: Permission denied before connecting:', _t2);
               // Permission was denied - reset connecting state and restore UI
               this.resetConnectingState();
+
+              // Remove mobile bar if it was created early
+              existingBar = document.getElementById('mobile-voice-call-bar-container');
+              if (existingBar) {
+                this.removeMobileMinimizedBar();
+              }
+
+              // Restore floating button visibility
+              _floatingButton = this.shadowRoot.getElementById('text-chat-button');
+              if (_floatingButton) {
+                _floatingButton.style.display = '';
+              } else {
+                _fallbackButton = document.getElementById('text-chat-button');
+                if (_fallbackButton) {
+                  _fallbackButton.style.display = '';
+                }
+              }
               _idleState = this.shadowRoot.getElementById('voiceIdleState');
               if (_idleState) {
                 _idleState.style.display = 'flex';
@@ -16380,6 +16432,11 @@ var VoiceInterface = /*#__PURE__*/function () {
                 _context5.n = 15;
                 break;
               }
+              // ✅ Connection is ready (hello_ack received) - update status BEFORE audio can start
+              // This ensures status is "listening" when agent starts speaking
+              if (this.isMobile) {
+                this.updateMobileStatus('listening');
+              }
               return _context5.a(3, 17);
             case 15:
               _context5.n = 16;
@@ -16419,6 +16476,17 @@ var VoiceInterface = /*#__PURE__*/function () {
                 break;
               }
               console.log('✅ WebSocket ready, starting listening...');
+
+              // ✅ CRITICAL: Update status to "listening" IMMEDIATELY after hello_ack
+              // This ensures status is correct BEFORE agent starts sending audio
+              // Agent can start sending audio immediately after hello_ack, so we need
+              // to update status now, not after startListening() completes
+              if (this.isMobile) {
+                // Status was already updated to "listening" in the hello_ack wait loop above
+                // But ensure it's set here too in case we didn't go through that path
+                this.updateMobileStatus('listening');
+              }
+
               // CRITICAL: startListening() will request microphone permission
               // This must be called directly from user interaction (button click)
               // to work on mobile browsers
@@ -16452,13 +16520,17 @@ var VoiceInterface = /*#__PURE__*/function () {
               console.log('🎤 Started listening - permission granted');
               this.isActive = true;
 
-              // ONLY NOW that permission is granted and call is active, create mobile bar (mobile only)
+              // Update mobile bar if it already exists (created early), otherwise create it
               if (this.isMobile) {
-                console.log('📱 Mobile device - permission granted, creating minimized bar');
-
-                // Panel and floating button are already hidden from permission request step
-                // Just create the mobile minimized bar
-                this.createMobileMinimizedBar();
+                _existingBar = document.getElementById('mobile-voice-call-bar-container');
+                if (!_existingBar) {
+                  console.log('📱 Mobile device - permission granted, creating minimized bar');
+                  // Panel and floating button are already hidden from permission request step
+                  // Just create the mobile minimized bar
+                  this.createMobileMinimizedBar();
+                } else {
+                  console.log('📱 Mobile device - bar already exists, updating status');
+                }
 
                 // Initialize messages with welcome message
                 if (this.messages.length === 0) {
@@ -16469,7 +16541,7 @@ var VoiceInterface = /*#__PURE__*/function () {
                 }
                 // Start waveform animation
                 this.startWaveformAnimation();
-                // Update status
+                // Update status to listening (was connecting before)
                 this.updateMobileStatus('listening');
               } else {
                 // Desktop: initialize UI
@@ -16498,6 +16570,11 @@ var VoiceInterface = /*#__PURE__*/function () {
               // Permission was denied or error occurred - reset connecting state and restore UI
               this.resetConnectingState();
               if (this.isMobile) {
+                // Remove mobile bar if it was created early
+                _existingBar2 = document.getElementById('mobile-voice-call-bar-container');
+                if (_existingBar2) {
+                  this.removeMobileMinimizedBar();
+                }
                 // Restore idle state so user can try again
                 _idleState3 = this.shadowRoot.getElementById('voiceIdleState');
                 if (_idleState3) {
@@ -16514,13 +16591,13 @@ var VoiceInterface = /*#__PURE__*/function () {
                   }
                 }
                 // Ensure floating button is visible
-                _floatingButton = this.shadowRoot.getElementById('text-chat-button');
-                if (_floatingButton) {
-                  _floatingButton.style.display = '';
+                _floatingButton2 = this.shadowRoot.getElementById('text-chat-button');
+                if (_floatingButton2) {
+                  _floatingButton2.style.display = '';
                 } else {
-                  _fallbackButton = document.getElementById('text-chat-button');
-                  if (_fallbackButton) {
-                    _fallbackButton.style.display = '';
+                  _fallbackButton2 = document.getElementById('text-chat-button');
+                  if (_fallbackButton2) {
+                    _fallbackButton2.style.display = '';
                   }
                 }
               }
@@ -16575,13 +16652,17 @@ var VoiceInterface = /*#__PURE__*/function () {
               console.log('🎤 Started listening - permission granted');
               this.isActive = true;
 
-              // ONLY NOW that permission is granted and call is active, create mobile bar (mobile only)
+              // Update mobile bar if it already exists (created early), otherwise create it
               if (this.isMobile) {
-                console.log('📱 Mobile device - permission granted, creating minimized bar');
-
-                // Panel and floating button are already hidden from permission request step
-                // Just create the mobile minimized bar
-                this.createMobileMinimizedBar();
+                _existingBar3 = document.getElementById('mobile-voice-call-bar-container');
+                if (!_existingBar3) {
+                  console.log('📱 Mobile device - permission granted, creating minimized bar');
+                  // Panel and floating button are already hidden from permission request step
+                  // Just create the mobile minimized bar
+                  this.createMobileMinimizedBar();
+                } else {
+                  console.log('📱 Mobile device - bar already exists, updating status');
+                }
 
                 // Initialize messages with welcome message
                 if (this.messages.length === 0) {
@@ -16592,7 +16673,7 @@ var VoiceInterface = /*#__PURE__*/function () {
                 }
                 // Start waveform animation
                 this.startWaveformAnimation();
-                // Update status
+                // Update status to listening (was connecting before)
                 this.updateMobileStatus('listening');
               } else {
                 // Desktop: initialize UI
@@ -16621,6 +16702,11 @@ var VoiceInterface = /*#__PURE__*/function () {
               // Permission was denied or error occurred - reset connecting state and restore UI
               this.resetConnectingState();
               if (this.isMobile) {
+                // Remove mobile bar if it was created early
+                _existingBar4 = document.getElementById('mobile-voice-call-bar-container');
+                if (_existingBar4) {
+                  this.removeMobileMinimizedBar();
+                }
                 // Restore idle state so user can try again
                 _idleState4 = this.shadowRoot.getElementById('voiceIdleState');
                 if (_idleState4) {
@@ -16637,13 +16723,13 @@ var VoiceInterface = /*#__PURE__*/function () {
                   }
                 }
                 // Ensure floating button is visible
-                _floatingButton2 = this.shadowRoot.getElementById('text-chat-button');
-                if (_floatingButton2) {
-                  _floatingButton2.style.display = '';
+                _floatingButton3 = this.shadowRoot.getElementById('text-chat-button');
+                if (_floatingButton3) {
+                  _floatingButton3.style.display = '';
                 } else {
-                  _fallbackButton2 = document.getElementById('text-chat-button');
-                  if (_fallbackButton2) {
-                    _fallbackButton2.style.display = '';
+                  _fallbackButton3 = document.getElementById('text-chat-button');
+                  if (_fallbackButton3) {
+                    _fallbackButton3.style.display = '';
                   }
                 }
               }
@@ -18595,7 +18681,10 @@ var Mobile = /*#__PURE__*/function () {
         dotColor = this.config.statusDotColor || '#10b981';
       } else {
         // Use dynamic status based on state
-        if (status === 'listening' || status === 'recording') {
+        if (status === 'connecting') {
+          displayText = this.t('connecting') || 'Connecting...';
+          dotColor = '#3b82f6'; // Blue for connecting
+        } else if (status === 'listening' || status === 'recording') {
           displayText = this.t('listening') || 'Listening...';
           dotColor = '#22c55e';
         } else if (status === 'speaking') {
@@ -23062,9 +23151,16 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
     var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     _classCallCheck(this, AudioPlayer);
     _this = _callSuper(this, AudioPlayer);
+
+    // Version identification log
+    console.log('%c🔊 AUDIO PLAYER - SILENT BUFFER PRIMING FIX ENABLED', 'background: #10b981; color: white; font-size: 14px; font-weight: bold; padding: 4px 8px; border-radius: 4px;');
+    console.log('%cAndroid Greeting Cut-Off Fix: Silent buffer priming (100ms) + dynamic startup buffer', 'background: #d1fae5; color: #065f46; font-size: 12px; padding: 2px 6px; border-radius: 3px;');
+    console.log('%cBuild: 2026-01-30-SILENT-BUFFER-PRIMING | Look for [scheduleWAV] and priming logs', 'background: #e0e7ff; color: #1e40af; font-size: 11px; padding: 2px 6px; border-radius: 3px;');
+    console.log('');
     _this.config = config;
     _this.audioContext = null;
     _this.gainNode = null; // GainNode for volume/mute control
+    _this._audioContextPrimed = false; // Track if AudioContext has been primed with silent buffer
 
     // Track temporary listener in waitForAudioContextReady() for cleanup
     _this._waitForReadyStateHandler = null;
@@ -23522,13 +23618,19 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
                       currentTime = _this4.audioContext.currentTime; // Ensure we don't schedule in the past, but NEVER decrease nextStartTime
                       // This prevents overlapping audio by maintaining sequential ordering
                       if (_this4.scheduledBuffers === 0) {
-                        // First chunk: Add startup buffer on mobile to account for AudioContext initialization latency
-                        // On mobile, when AudioContext transitions from suspended to running, there's startup delay
-                        // Scheduling at time 0 causes the beginning to be skipped due to this latency
+                        // First chunk: Use dynamic startup buffer based on audio priming status
                         isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
-                        startupBuffer = isMobile ? 0.1 : 0; // 100ms buffer on mobile
+                        startupBuffer = 0.03; // 30ms default for responses
+                        if (isMobile) {
+                          if (_this4._audioContextPrimed) {
+                            startupBuffer = 0; // Primed - no buffer needed
+                          } else {
+                            startupBuffer = 2.0; // Not primed yet - 2000ms safety fallback
+                            console.warn('⚠️ AudioPlayer: Audio not primed yet, using 2000ms fallback buffer');
+                          }
+                        }
                         _this4.nextStartTime = currentTime + startupBuffer;
-                        console.log("\uD83C\uDFB5 [scheduleWAV] FIRST FRAME - state: ".concat(_this4.audioContext.state, ", currentTime: ").concat(currentTime, ", nextStartTime: ").concat(_this4.nextStartTime), isMobile ? '(mobile)' : '(desktop)');
+                        console.log("\uD83C\uDFB5 [scheduleWAV] FIRST FRAME - primed: ".concat(_this4._audioContextPrimed, ", buffer: ").concat(startupBuffer * 1000, "ms"));
                       } else {
                         // Subsequent chunks: ensure nextStartTime is not in the past
                         // If nextStartTime is already in the future, use it (seamless playback)
@@ -24478,6 +24580,9 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
         this.gainNode.gain.value = 1.0; // Default to full volume
         this.gainNode.connect(this.audioContext.destination);
         console.log('✅ AudioPlayer: GainNode created for volume control');
+
+        // Prime audio hardware for Android
+        this._primeAudioContext();
       } catch (error) {
         // Fallback to default if browser doesn't support custom sample rate
         console.error("\u274C Failed to create AudioContext:", error);
@@ -24492,13 +24597,65 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
         this.gainNode.gain.value = 1.0; // Default to full volume
         this.gainNode.connect(this.audioContext.destination);
         console.log('✅ AudioPlayer: GainNode created for volume control (fallback)');
+
+        // Prime audio hardware for Android
+        this._primeAudioContext();
       }
     }
 
+    /**
+     * Prime AudioContext with silent buffer to initialize Android hardware
+     * This prevents the first audio frame from being cut off on Android devices
+     */
+  }, {
+    key: "_primeAudioContext",
+    value: (function () {
+      var _primeAudioContext2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5() {
+        var sampleRate, silentBuffer, source, _t3;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.p = _context6.n) {
+            case 0:
+              _context6.p = 0;
+              if (!(!this.audioContext || this._audioContextPrimed)) {
+                _context6.n = 1;
+                break;
+              }
+              return _context6.a(2);
+            case 1:
+              sampleRate = this.audioContext.sampleRate;
+              silentBuffer = this.audioContext.createBuffer(1, sampleRate * 0.1, sampleRate);
+              source = this.audioContext.createBufferSource();
+              source.buffer = silentBuffer;
+              source.connect(this.audioContext.destination);
+              source.start();
+              _context6.n = 2;
+              return new Promise(function (resolve) {
+                return setTimeout(resolve, 100);
+              });
+            case 2:
+              this._audioContextPrimed = true;
+              console.log('✅ AudioPlayer: Audio hardware primed with silent buffer');
+              _context6.n = 4;
+              break;
+            case 3:
+              _context6.p = 3;
+              _t3 = _context6.v;
+              console.error('❌ AudioPlayer: Audio priming failed:', _t3);
+            case 4:
+              return _context6.a(2);
+          }
+        }, _callee5, this, [[0, 3]]);
+      }));
+      function _primeAudioContext() {
+        return _primeAudioContext2.apply(this, arguments);
+      }
+      return _primeAudioContext;
+    }()
     /**
      * Clean up AudioContext and its event listeners
      * Ensures listeners are removed before context is closed/nullified to prevent race conditions
      */
+    )
   }, {
     key: "_cleanupAudioContext",
     value: function _cleanupAudioContext() {
@@ -24533,6 +24690,7 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
 
       // Set to null after cleanup
       this.audioContext = null;
+      this._audioContextPrimed = false;
     }
 
     /**
@@ -24601,35 +24759,35 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "processQueue",
     value: (function () {
-      var _processQueue = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5() {
+      var _processQueue = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
         var _this8 = this;
-        var audioBlob, wasFirstPlay, audioContext, arrayBuffer, audioBuffer, shouldEmitStart, source, _t3;
-        return _regenerator().w(function (_context6) {
-          while (1) switch (_context6.p = _context6.n) {
+        var audioBlob, wasFirstPlay, audioContext, arrayBuffer, audioBuffer, shouldEmitStart, source, _t4;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.p = _context7.n) {
             case 0:
               if (!this._isStopped) {
-                _context6.n = 1;
+                _context7.n = 1;
                 break;
               }
               console.log('🛑 AudioPlayer: Not processing queue - playback was stopped (barge-in)');
-              return _context6.a(2);
+              return _context7.a(2);
             case 1:
               if (!(this.isProcessingQueue || this.audioQueue.length === 0)) {
-                _context6.n = 2;
+                _context7.n = 2;
                 break;
               }
-              return _context6.a(2);
+              return _context7.a(2);
             case 2:
               this.isProcessingQueue = true;
               audioBlob = this.audioQueue.shift();
               if (audioBlob) {
-                _context6.n = 3;
+                _context7.n = 3;
                 break;
               }
               this.isProcessingQueue = false;
-              return _context6.a(2);
+              return _context7.a(2);
             case 3:
-              _context6.p = 3;
+              _context7.p = 3;
               wasFirstPlay = !this.isPlaying && this.currentSource === null; // Initialize audio context if needed
               if (!this.audioContext) {
                 this.initializeAudioContext();
@@ -24638,18 +24796,18 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
               // ✅ NEW: Wait for AudioContext to be in 'running' state before proceeding
               // This is critical for mobile devices where AudioContext initialization takes time
               // Replaces fixed timeouts with event-driven waiting
-              _context6.n = 4;
+              _context7.n = 4;
               return this.waitForAudioContextReady();
             case 4:
               audioContext = this.audioContext; // Decode audio
-              _context6.n = 5;
+              _context7.n = 5;
               return audioBlob.arrayBuffer();
             case 5:
-              arrayBuffer = _context6.v;
-              _context6.n = 6;
+              arrayBuffer = _context7.v;
+              _context7.n = 6;
               return audioContext.decodeAudioData(arrayBuffer);
             case 6:
-              audioBuffer = _context6.v;
+              audioBuffer = _context7.v;
               shouldEmitStart = wasFirstPlay && !this.isPlaying && this.currentSource === null; // Create source
               source = audioContext.createBufferSource();
               source.buffer = audioBuffer;
@@ -24692,14 +24850,14 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
               // Start playback - AudioContext should now be fully ready
 
               source.start();
-              _context6.n = 8;
+              _context7.n = 8;
               break;
             case 7:
-              _context6.p = 7;
-              _t3 = _context6.v;
-              console.error('❌ AudioPlayer v2: Error processing queue:', _t3);
+              _context7.p = 7;
+              _t4 = _context7.v;
+              console.error('❌ AudioPlayer v2: Error processing queue:', _t4);
               this.currentSource = null;
-              this.emit('playbackError', _t3);
+              this.emit('playbackError', _t4);
 
               // Try next chunk
 
@@ -24714,9 +24872,9 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
                 this.emit('playbackStopped');
               }
             case 8:
-              return _context6.a(2);
+              return _context7.a(2);
           }
-        }, _callee5, this, [[3, 7]]);
+        }, _callee6, this, [[3, 7]]);
       }));
       function processQueue() {
         return _processQueue.apply(this, arguments);
@@ -24990,39 +25148,39 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "resumeAudioContext",
     value: (function () {
-      var _resumeAudioContext = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6() {
-        var _t4;
-        return _regenerator().w(function (_context7) {
-          while (1) switch (_context7.p = _context7.n) {
+      var _resumeAudioContext = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7() {
+        var _t5;
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.p = _context8.n) {
             case 0:
               if (!(!this.audioContext || this.audioContext.state === 'closed')) {
-                _context7.n = 2;
+                _context8.n = 2;
                 break;
               }
-              _context7.n = 1;
+              _context8.n = 1;
               return this.initializeAudioContext();
             case 1:
-              return _context7.a(2);
+              return _context8.a(2);
             case 2:
               if (!(this.audioContext.state === 'suspended')) {
-                _context7.n = 6;
+                _context8.n = 6;
                 break;
               }
-              _context7.p = 3;
-              _context7.n = 4;
+              _context8.p = 3;
+              _context8.n = 4;
               return this.audioContext.resume();
             case 4:
               console.log('✅ AudioPlayer v2: AudioContext resumed after mic permission');
-              _context7.n = 6;
+              _context8.n = 6;
               break;
             case 5:
-              _context7.p = 5;
-              _t4 = _context7.v;
-              console.warn('⚠️ AudioPlayer v2: Failed to resume AudioContext:', _t4);
+              _context8.p = 5;
+              _t5 = _context8.v;
+              console.warn('⚠️ AudioPlayer v2: Failed to resume AudioContext:', _t5);
             case 6:
-              return _context7.a(2);
+              return _context8.a(2);
           }
-        }, _callee6, this, [[3, 5]]);
+        }, _callee7, this, [[3, 5]]);
       }));
       function resumeAudioContext() {
         return _resumeAudioContext.apply(this, arguments);
@@ -25261,6 +25419,7 @@ var VoiceSDK_v2 = /*#__PURE__*/function (_EventEmitter) {
     _this.transcriptQueue = []; // Queue of transcripts for history
     _this.currentPlayingSentenceId = null; // Sentence ID currently being played
     _this.audioFrameCount = 0; // Track number of audio frames received
+    _this.lastAudioStartTime = 0; // Timestamp of last audio_start message (to prevent premature stop_playing)
 
     // Screen wake lock - keeps screen on during voice calls (mobile)
     _this.wakeLock = null;
@@ -26334,6 +26493,16 @@ var VoiceSDK_v2 = /*#__PURE__*/function (_EventEmitter) {
             this.stopAudioPlayback();
             break;
           case 'stop_playing':
+            // CRITICAL: Ignore stop_playing messages that arrive too soon after audio_start
+            // Backend sometimes sends stop_playing immediately after audio_start, which cuts sentences prematurely
+            // Only honor stop_playing if it's been at least 200ms since the last audio_start
+            var timeSinceAudioStart = Date.now() - this.lastAudioStartTime;
+            var MIN_STOP_PLAYING_DELAY_MS = 200; // 200ms grace period after audio_start
+
+            if (timeSinceAudioStart < MIN_STOP_PLAYING_DELAY_MS) {
+              console.warn("\u26A0\uFE0F VoiceSDK v2: Ignoring premature stop_playing (".concat(timeSinceAudioStart, "ms after audio_start, minimum ").concat(MIN_STOP_PLAYING_DELAY_MS, "ms required)"));
+              break;
+            }
             this.emit('stopPlaying', message);
             this.stopAudioPlayback();
             break;
@@ -26342,6 +26511,9 @@ var VoiceSDK_v2 = /*#__PURE__*/function (_EventEmitter) {
             // Store the text in AudioPlayer for synced display when audio actually starts playing
             console.log('📝 VoiceSDK v2: Received audio_start with text:', message.text);
 
+            // CRITICAL: Record timestamp to prevent premature stop_playing messages from cutting sentences
+            this.lastAudioStartTime = Date.now();
+
             // NOTE: We do NOT stop current audio here - that only happens on user barge-in (stop_playing)
             // If audio is already playing, the new sentence will queue and wait for current one to finish
             // This allows sentences to play sequentially without interruption
@@ -26475,7 +26647,149 @@ var VoiceSDK_v2 = /*#__PURE__*/function (_EventEmitter) {
             this.emit('message', message);
         }
       } catch (error) {
+        var _error$message, _error$message2;
+        // Enhanced error logging to help debug JSON parsing issues
+        var rawData = typeof event.data === 'string' ? event.data : String(event.data);
+        var errorPosition = ((_error$message = error.message) === null || _error$message === void 0 || (_error$message = _error$message.match(/position (\d+)/)) === null || _error$message === void 0 ? void 0 : _error$message[1]) || 'unknown';
+        var position = parseInt(errorPosition, 10);
         console.error('VoiceSDK v2: Error parsing message:', error);
+        console.error('VoiceSDK v2: Raw message length:', rawData.length);
+        console.error('VoiceSDK v2: Error at position:', position);
+
+        // Show context around the error position
+        if (position !== 'unknown' && position > 0) {
+          var start = Math.max(0, position - 50);
+          var end = Math.min(rawData.length, position + 50);
+          var context = rawData.substring(start, end);
+          var relativePos = position - start;
+          var marker = ' '.repeat(relativePos) + '^';
+          console.error('VoiceSDK v2: Context around error:');
+          console.error(context);
+          console.error(marker);
+
+          // Show the problematic character(s)
+          var problematicChar = rawData.charAt(position);
+          var charCode = problematicChar.charCodeAt(0);
+          console.error("VoiceSDK v2: Problematic character: \"".concat(problematicChar, "\" (charCode: ").concat(charCode, ")"));
+
+          // Check for common control characters
+          if (charCode < 32 && charCode !== 9 && charCode !== 10 && charCode !== 13) {
+            console.error('VoiceSDK v2: This is an unescaped control character. The backend should escape it in JSON strings.');
+          }
+        }
+
+        // Try to detect if this was a client_tool_call message
+        var looksLikeToolCall = rawData.includes('client_tool_call') || rawData.includes('"t":"client_tool_call"');
+        if (looksLikeToolCall) {
+          console.error('⚠️ VoiceSDK v2: CRITICAL - Failed to parse client_tool_call message!');
+          console.error('⚠️ VoiceSDK v2: This means a tool execution (like form filling) was lost due to JSON parsing error.');
+          console.error('⚠️ VoiceSDK v2: The backend sent malformed JSON with unescaped control characters.');
+
+          // Try to extract tool name from raw string (basic regex attempt)
+          var toolNameMatch = rawData.match(/"toolName"\s*:\s*"([^"]+)"/);
+          if (toolNameMatch) {
+            console.error("\u26A0\uFE0F VoiceSDK v2: Attempted tool: \"".concat(toolNameMatch[1], "\""));
+          }
+
+          // Try to extract toolCallId
+          var toolCallIdMatch = rawData.match(/"toolCallId"\s*:\s*"([^"]+)"/);
+          if (toolCallIdMatch) {
+            console.error("\u26A0\uFE0F VoiceSDK v2: Tool call ID: \"".concat(toolCallIdMatch[1], "\""));
+          }
+        }
+
+        // Attempt recovery: sanitize control characters and try parsing again
+        if ((_error$message2 = error.message) !== null && _error$message2 !== void 0 && _error$message2.includes('Bad control character')) {
+          console.warn('VoiceSDK v2: Attempting to recover by sanitizing control characters...');
+          try {
+            // Replace unescaped control characters (except \t, \n, \r which are sometimes valid)
+            // This is a best-effort recovery - may not work for all cases
+            var sanitized = rawData;
+            // Replace control characters that aren't properly escaped
+            // Look for control chars that aren't part of \n, \t, \r, \\ sequences
+            sanitized = sanitized.replace(/([^\\])([\x00-\x08\x0B\x0C\x0E-\x1F])/g, function (match, prev, ctrl) {
+              var code = ctrl.charCodeAt(0);
+              // Map common control chars to escape sequences
+              var escapes = {
+                0: "\\u0000",
+                1: "\\u0001",
+                2: "\\u0002",
+                3: "\\u0003",
+                4: "\\u0004",
+                5: "\\u0005",
+                6: "\\u0006",
+                7: "\\u0007",
+                8: '\\b',
+                11: "\\u000B",
+                12: '\\f',
+                14: "\\u000E",
+                15: "\\u000F",
+                16: "\\u0010",
+                17: "\\u0011",
+                18: "\\u0012",
+                19: "\\u0013",
+                20: "\\u0014",
+                21: "\\u0015",
+                22: "\\u0016",
+                23: "\\u0017",
+                24: "\\u0018",
+                25: "\\u0019",
+                26: "\\u001A",
+                27: "\\u001B",
+                28: "\\u001C",
+                29: "\\u001D",
+                30: "\\u001E",
+                31: "\\u001F"
+              };
+              return prev + (escapes[code] || "\\u".concat(code.toString(16).padStart(4, '0')));
+            });
+            var recoveredMessage = JSON.parse(sanitized);
+            console.warn('✅ VoiceSDK v2: Successfully recovered message after sanitization!');
+            console.warn('✅ VoiceSDK v2: Processing recovered message...');
+
+            // Process the recovered message
+            if (recoveredMessage.t === 'client_tool_call' && this.clientToolsRegistry) {
+              console.warn('✅ VoiceSDK v2: Recovered client_tool_call - executing tool');
+              this.clientToolsRegistry.handleToolCall(recoveredMessage);
+            } else {
+              // Re-process through normal flow
+              var _message = recoveredMessage;
+              if (_message.t !== 'audio') {
+                console.log('📥 VoiceSDK v2: Received message type:', _message.t, 'Full message:', JSON.stringify(_message).substring(0, 200));
+              }
+              if (!this.conversationId && _message.conversationId) {
+                this.conversationId = _message.conversationId;
+                console.log('🔍 VoiceSDK v2: Captured conversationId from message:', this.conversationId);
+                this.emit('conversationIdChanged', this.conversationId);
+              }
+              if (_message.t !== 'audio') {
+                console.log('📨 VoiceSDK v2: Received message type:', _message.t, _message);
+              }
+              // Re-enter switch statement logic (simplified - just handle client_tool_call)
+              if (_message.t === 'client_tool_call') {
+                this.clientToolsRegistry.handleToolCall(_message);
+              } else {
+                this.emit('message', _message);
+              }
+            }
+            return; // Successfully recovered, exit error handler
+          } catch (recoveryError) {
+            console.error('❌ VoiceSDK v2: Recovery attempt failed:', recoveryError);
+          }
+        }
+
+        // Show first 500 chars of raw message for debugging
+        console.error('VoiceSDK v2: First 500 chars of raw message:', rawData.substring(0, 500));
+
+        // Emit error event so listeners can handle it
+        this.emit('error', {
+          type: 'json_parse_error',
+          error: error,
+          rawMessage: rawData.substring(0, 1000),
+          // Include first 1000 chars for debugging
+          position: position,
+          wasToolCall: looksLikeToolCall
+        });
       }
     }