ttp-agent-sdk 2.34.3 → 2.34.4

package/dist/agent-widget.dev.js

@@ -23031,9 +23031,18 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
 
     // Queue for prepared AudioBuffers (ready to schedule)
     _this.preparedBuffer = [];
+
+    // Maximum buffer sizes to prevent unbounded memory growth
+    // If backend sends sentences faster than playback, oldest frames are dropped
+    _this.MAX_PREPARED_BUFFER_SIZE = 200; // Max prepared frames (~10-12 seconds at 600ms per frame)
+    _this.MAX_PCM_CHUNK_QUEUE_SIZE = 50; // Max raw PCM chunks
+
     _this.isProcessingPcmQueue = false;
     _this.isSchedulingFrames = false;
 
+    // Timeout to detect empty sentences (audio_start but no chunks)
+    _this._emptySentenceTimeout = null;
+
     // Minimal scheduling delay to avoid scheduling audio in the past
     // REMOVED: Lookahead buffering was causing quality degradation due to browser resampling/timing issues
     // Now we only schedule with minimal delay (20ms) just enough to avoid gaps
@@ -23049,6 +23058,10 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
     // Cleared when markNewSentence() is called (signals new audio is starting)
     _this._isStopped = false;
 
+    // Track current sentence ID to reject chunks from previous sentences
+    // Incremented each time markNewSentence() is called
+    _this._currentSentenceId = 0;
+
     // Codec registry
 
     _this.codecs = {
@@ -23185,7 +23198,7 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
     value: (function () {
       var _playChunk = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(pcmData) {
         var _this3 = this;
-        var preparedFrame, _this$audioContext;
+        var preparedFrame, dropped, _this$audioContext;
         return _regenerator().w(function (_context) {
           while (1) switch (_context.n) {
             case 0:
@@ -23199,6 +23212,20 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
               // Pre-process frame immediately (convert to AudioBuffer)
               preparedFrame = this.prepareChunk(pcmData);
               if (preparedFrame) {
+                // CRITICAL: Clear empty sentence timeout since chunks are arriving
+                // This resets the timer for the current sentence
+                if (this._emptySentenceTimeout) {
+                  clearTimeout(this._emptySentenceTimeout);
+                  this._emptySentenceTimeout = null;
+                }
+
+                // CRITICAL: Prevent unbounded buffer growth
+                // If backend sends sentences faster than playback, drop oldest frames
+                if (this.preparedBuffer.length >= this.MAX_PREPARED_BUFFER_SIZE) {
+                  dropped = this.preparedBuffer.shift(); // Drop oldest frame
+                  console.warn("\u26A0\uFE0F AudioPlayer: preparedBuffer at max size (".concat(this.MAX_PREPARED_BUFFER_SIZE, "), dropped oldest frame"));
+                }
+
                 // Add prepared frame to buffer
                 this.preparedBuffer.push(preparedFrame);
 
@@ -23206,7 +23233,7 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
 
                 // Use requestAnimationFrame to avoid blocking, but ensure scheduling happens
 
-                if (!this.isSchedulingFrames) {
+                if (!this.isSchedulingFrames && !this._isStopped) {
                   // Schedule immediately if not already scheduling
 
                   this.schedulePreparedFrames();
@@ -23218,7 +23245,7 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
                   // Use a short timeout to ensure we check again after current scheduling completes
 
                   setTimeout(function () {
-                    if (_this3.preparedBuffer.length > 0 && !_this3.isSchedulingFrames) {
+                    if (_this3.preparedBuffer.length > 0 && !_this3.isSchedulingFrames && !_this3._isStopped) {
                       _this3.schedulePreparedFrames();
                     }
                   }, 5); // Very short delay to check after current scheduling completes
@@ -23357,7 +23384,7 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
     value: (function () {
       var _schedulePreparedFrames = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
         var _this4 = this;
-        var queuedFrames, targetLookaheadFrames, _this$audioContext2, _this$audioContext3, _this$audioContext4, _this$audioContext5, scheduledCount, _loop, _t;
+        var queuedFrames, targetLookaheadFrames, _this$audioContext2, _this$audioContext3, _this$audioContext4, _this$audioContext5, scheduledCount, _loop, _ret, _t;
         return _regenerator().w(function (_context3) {
           while (1) switch (_context3.p = _context3.n) {
             case 0:
@@ -23409,14 +23436,21 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
                 return _regenerator().w(function (_context2) {
                   while (1) switch (_context2.n) {
                     case 0:
+                      if (!_this4._isStopped) {
+                        _context2.n = 1;
+                        break;
+                      }
+                      console.log('🛑 AudioPlayer: Stopping frame scheduling - playback was stopped');
+                      return _context2.a(2, 0);
+                    case 1:
                       // Get next prepared frame
                       preparedFrame = _this4.preparedBuffer.shift();
                       if (preparedFrame) {
-                        _context2.n = 1;
+                        _context2.n = 2;
                         break;
                       }
-                      return _context2.a(2, 1);
-                    case 1:
+                      return _context2.a(2, 0);
+                    case 2:
                       // Create source and schedule playback
                       source = _this4.audioContext.createBufferSource();
                       source.buffer = preparedFrame.buffer;
@@ -23493,29 +23527,46 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
                       // Track when this buffer finishes (for cleanup only)
 
                       source.onended = function () {
-                        // Remove from tracked sources
+                        // CRITICAL: Check if playback was stopped before processing cleanup
+                        // This prevents race conditions where onended fires after stopImmediate() was called
+                        if (_this4._isStopped) {
+                          // Playback was stopped, ignore this callback
+                          return;
+                        }
 
+                        // CRITICAL: Only process if source is still in scheduledSources set
+                        // This prevents race conditions where stopImmediate() cleared the set but callback fires later
+                        if (!_this4.scheduledSources.has(source)) {
+                          // Source was already removed (probably by stopImmediate), ignore this callback
+                          return;
+                        }
+
+                        // Remove from tracked sources
                         _this4.scheduledSources.delete(source);
-                        _this4.scheduledBuffers--;
+
+                        // Only decrement if we're still playing and buffer count is positive
+                        if (!_this4._isStopped && _this4.scheduledBuffers > 0) {
+                          _this4.scheduledBuffers--;
+                        }
 
                         // If no more scheduled buffers and no prepared frames, playback is complete
 
-                        if (_this4.scheduledBuffers === 0 && _this4.preparedBuffer.length === 0 && _this4.pcmChunkQueue.length === 0) {
+                        if (_this4.scheduledBuffers === 0 && _this4.preparedBuffer.length === 0 && _this4.pcmChunkQueue.length === 0 && !_this4._isStopped) {
                           _this4.isPlaying = false;
                           _this4.isSchedulingFrames = false;
                           console.log('🛑 AudioPlayer: Emitting playbackStopped event (all buffers finished)');
                           _this4.emit('playbackStopped');
-                        } else if (_this4.preparedBuffer.length > 0) {
+                        } else if (_this4.preparedBuffer.length > 0 && !_this4._isStopped) {
                           // More frames available, schedule them immediately
 
                           // Use setTimeout to avoid blocking, but schedule quickly
 
                           setTimeout(function () {
-                            if (_this4.preparedBuffer.length > 0 && !_this4.isSchedulingFrames) {
+                            if (_this4.preparedBuffer.length > 0 && !_this4.isSchedulingFrames && !_this4._isStopped) {
                               _this4.schedulePreparedFrames();
                             }
                           }, 0);
-                        } else if (_this4.scheduledBuffers > 0) {
+                        } else if (_this4.scheduledBuffers > 0 && !_this4._isStopped) {
                           // No more prepared frames but still have scheduled buffers playing
 
                           // Set up a check to schedule new frames when they arrive
@@ -23523,9 +23574,13 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
                           // Keep checking periodically until we have no more scheduled buffers
 
                           var _checkForMoreFrames = function checkForMoreFrames() {
+                            // CRITICAL: Check if stopped before scheduling
+                            if (_this4._isStopped) {
+                              return;
+                            }
                             if (_this4.preparedBuffer.length > 0 && !_this4.isSchedulingFrames && _this4.scheduledBuffers > 0) {
                               _this4.schedulePreparedFrames();
-                            } else if (_this4.scheduledBuffers > 0) {
+                            } else if (_this4.scheduledBuffers > 0 && !_this4._isStopped) {
                               // Keep checking - frames might arrive soon
 
                               setTimeout(_checkForMoreFrames, 10);
@@ -23539,7 +23594,7 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
                         console.log('🎵 AudioPlayer: Emitting playbackStarted event');
                         _this4.emit('playbackStarted');
                       }
-                    case 2:
+                    case 3:
                       return _context2.a(2);
                   }
                 }, _loop);
@@ -23551,7 +23606,8 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
               }
               return _context3.d(_regeneratorValues(_loop()), 6);
             case 6:
-              if (!_context3.v) {
+              _ret = _context3.v;
+              if (!(_ret === 0)) {
                 _context3.n = 7;
                 break;
               }
@@ -23568,11 +23624,11 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
 
               // Use requestAnimationFrame for smooth scheduling without blocking
 
-              if (this.preparedBuffer.length > 0) {
+              if (this.preparedBuffer.length > 0 && !this._isStopped) {
                 // More frames arrived, schedule them immediately
 
                 requestAnimationFrame(function () {
-                  if (_this4.preparedBuffer.length > 0 && !_this4.isSchedulingFrames) {
+                  if (_this4.preparedBuffer.length > 0 && !_this4.isSchedulingFrames && !_this4._isStopped) {
                     _this4.schedulePreparedFrames();
                   }
                 });
@@ -23580,19 +23636,19 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
 
               // Always set up a periodic check if we have scheduled buffers playing
               // This ensures continuous playback even if frames arrive slowly
-              if (this.scheduledBuffers > 0) {
+              if (this.scheduledBuffers > 0 && !this._isStopped) {
                 // Set up a periodic check to schedule new frames as they arrive
                 // Use a shorter interval to catch new frames quickly
                 setTimeout(function () {
-                  if (_this4.preparedBuffer.length > 0 && !_this4.isSchedulingFrames && _this4.scheduledBuffers > 0) {
+                  if (_this4.preparedBuffer.length > 0 && !_this4.isSchedulingFrames && _this4.scheduledBuffers > 0 && !_this4._isStopped) {
                     _this4.schedulePreparedFrames();
-                  } else if (_this4.scheduledBuffers > 0) {
+                  } else if (_this4.scheduledBuffers > 0 && !_this4._isStopped) {
                     // Keep checking even if no frames yet - they might arrive soon
 
                     // Recursively check until we have no more scheduled buffers
 
                     setTimeout(function () {
-                      if (_this4.preparedBuffer.length > 0 && !_this4.isSchedulingFrames && _this4.scheduledBuffers > 0) {
+                      if (_this4.preparedBuffer.length > 0 && !_this4.isSchedulingFrames && _this4.scheduledBuffers > 0 && !_this4._isStopped) {
                         _this4.schedulePreparedFrames();
                       }
                     }, 10);
@@ -23659,16 +23715,23 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
               return this.waitForAudioContextReady();
             case 4:
               if (!(this.pcmChunkQueue.length > 0)) {
-                _context4.n = 6;
+                _context4.n = 7;
+                break;
+              }
+              if (!this._isStopped) {
+                _context4.n = 5;
                 break;
               }
+              console.log('🛑 AudioPlayer: Stopping PCM queue processing - playback was stopped');
+              return _context4.a(3, 7);
+            case 5:
               pcmData = this.pcmChunkQueue.shift();
               if (pcmData) {
-                _context4.n = 5;
+                _context4.n = 6;
                 break;
               }
               return _context4.a(3, 4);
-            case 5:
+            case 6:
               // Ensure even byte count for 16-bit PCM
               processedData = pcmData;
               if (pcmData.byteLength % 2 !== 0) {
@@ -23762,23 +23825,23 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
               }
               _context4.n = 4;
               break;
-            case 6:
+            case 7:
               // end while loop
 
               // All chunks scheduled, reset processing flag
               this.isProcessingPcmQueue = false;
-              _context4.n = 8;
+              _context4.n = 9;
               break;
-            case 7:
-              _context4.p = 7;
+            case 8:
+              _context4.p = 8;
               _t2 = _context4.v;
               console.error('❌ AudioPlayer v2: Error playing chunk:', _t2);
               this.emit('playbackError', _t2);
               this.isProcessingPcmQueue = false;
-            case 8:
+            case 9:
               return _context4.a(2);
           }
-        }, _callee3, this, [[3, 7]]);
+        }, _callee3, this, [[3, 8]]);
       }));
       function processPcmQueue() {
         return _processPcmQueue.apply(this, arguments);
@@ -24638,6 +24701,15 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
       console.log('   scheduledSources.size:', this.scheduledSources.size);
       console.log('   scheduledBuffers:', this.scheduledBuffers);
 
+      // CRITICAL: Set stopped flag FIRST to prevent new audio from being queued/scheduled
+      // This prevents race conditions where audio chunks arrive after stop but before sources are stopped
+      // The flag will be cleared when markNewSentence() is called (signals new audio is starting)
+      this._isStopped = true;
+
+      // CRITICAL: Stop scheduling immediately to prevent frames from being scheduled
+      // This ensures schedulePreparedFrames() loop will exit on next _isStopped check
+      this.isSchedulingFrames = false;
+
       // Stop current source (legacy queue-based system)
 
       if (this.currentSource) {
@@ -24659,27 +24731,31 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
       if (this.scheduledSources.size > 0) {
         console.log("   Stopping ".concat(this.scheduledSources.size, " scheduled sources..."));
         var stoppedCount = 0;
-        var _iterator = _createForOfIteratorHelper(this.scheduledSources),
-          _step;
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var source = _step.value;
-            try {
-              source.stop();
-              stoppedCount++;
-            } catch (e) {
-              // Ignore if already stopped or not started yet
 
-              console.log('   Source already stopped or not started:', e.message);
-            }
+        // Store sources to stop and count before clearing the set
+        var sourcesToStop = Array.from(this.scheduledSources);
+        var sourcesCount = sourcesToStop.length;
+
+        // Clear the set BEFORE stopping sources to prevent onended callbacks from modifying it
+        // This ensures onended callbacks will see empty set and return early
+        this.scheduledSources.clear();
+
+        // CRITICAL: Reset scheduledBuffers to 0 BEFORE stopping sources
+        // This prevents onended callbacks from decrementing it below 0
+        // Any onended callbacks that fire will see scheduledSources is empty and return early
+        this.scheduledBuffers = 0;
+        for (var _i = 0, _sourcesToStop = sourcesToStop; _i < _sourcesToStop.length; _i++) {
+          var source = _sourcesToStop[_i];
+          try {
+            source.stop();
+            stoppedCount++;
+          } catch (e) {
+            // Ignore if already stopped or not started yet
+
+            console.log('   Source already stopped or not started:', e.message);
           }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
         }
-        console.log("   Stopped ".concat(stoppedCount, " sources"));
-        this.scheduledSources.clear();
+        console.log("   Stopped ".concat(stoppedCount, " sources (cleared ").concat(sourcesCount, " from scheduledSources)"));
       }
 
       // Clear state
@@ -24695,15 +24771,15 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
       this.isProcessingPcmQueue = false;
       this.isSchedulingFrames = false;
 
-      // CRITICAL: Set stopped flag to prevent new audio from being queued
-      // This prevents race conditions where audio chunks arrive after stop but before sources are stopped
-      // The flag will be cleared when markNewSentence() is called (signals new audio is starting)
-      this._isStopped = true;
+      // Clear empty sentence timeout (barge-in means sentence was interrupted, not empty)
+      if (this._emptySentenceTimeout) {
+        clearTimeout(this._emptySentenceTimeout);
+        this._emptySentenceTimeout = null;
+      }
 
       // Reset scheduling properties
-
+      // Note: scheduledBuffers was already reset to 0 above when clearing scheduledSources
       this.nextStartTime = 0;
-      this.scheduledBuffers = 0;
 
       // Clear transcript state
       this.clearTranscriptState();
@@ -24723,14 +24799,77 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "markNewSentence",
     value: function markNewSentence(text) {
-      // CRITICAL: Clear stopped flag when new audio starts
+      var _this9 = this;
+      var wasStopped = this._isStopped;
+      var isCurrentlyPlaying = this.isPlaying || this.scheduledSources.size > 0;
+
+      // CRITICAL: Clear stopped flag when new audio starts (after barge-in)
       // This allows new audio chunks to be queued after barge-in
       if (this._isStopped) {
-        console.log('🛑 AudioPlayer: Clearing stopped flag - new audio starting');
+        console.log('🛑 AudioPlayer: Clearing stopped flag - new audio starting after barge-in');
         this._isStopped = false;
+
+        // CRITICAL: Reset scheduling state when starting a new sentence after a stop
+        // This ensures the new sentence starts immediately without delay
+        // Reset nextStartTime so first chunk schedules immediately (not in the past)
+        this.nextStartTime = 0;
+
+        // CRITICAL: Reset scheduledBuffers to 0, but ensure it's not negative
+        // This accounts for any onended callbacks that might fire from stopped sources
+        // If scheduledBuffers is negative, it means onended callbacks fired after stopImmediate()
+        // In that case, we should reset to 0 to start fresh
+        if (this.scheduledBuffers < 0) {
+          console.log("\uD83D\uDD04 AudioPlayer: scheduledBuffers was negative (".concat(this.scheduledBuffers, "), resetting to 0"));
+        }
+        this.scheduledBuffers = 0;
+
+        // CRITICAL: ALWAYS clear preparedBuffer after barge-in - any remaining chunks are from previous sentence
+        // This prevents old audio from playing when new sentence starts after interruption
+        if (this.preparedBuffer.length > 0) {
+          console.log("\uD83D\uDD04 AudioPlayer: Clearing ".concat(this.preparedBuffer.length, " prepared frames from previous sentence (after barge-in)"));
+        }
+        this.preparedBuffer = [];
+
+        // CRITICAL: Also clear pcmChunkQueue to prevent raw chunks from previous sentence being processed
+        if (this.pcmChunkQueue.length > 0) {
+          console.log("\uD83D\uDD04 AudioPlayer: Clearing ".concat(this.pcmChunkQueue.length, " raw PCM chunks from previous sentence (after barge-in)"));
+        }
+        this.pcmChunkQueue = [];
+        this.isProcessingPcmQueue = false;
+        console.log('🔄 AudioPlayer: Reset scheduling state for new sentence (after barge-in)');
+      } else if (isCurrentlyPlaying) {
+        // New sentence received while audio is currently playing (no barge-in)
+        // Don't clear buffers or reset state - let current sentence finish, then new one will play
+        console.log("\uD83D\uDCDD AudioPlayer: New sentence queued while audio playing - will start after current sentence finishes");
       }
+
+      // Always update pending sentence text (for transcript display)
       this.pendingSentenceText = text;
-      console.log("\uD83D\uDCDD AudioPlayer: New sentence marked: \"".concat(text.substring(0, 40), "...\""));
+      console.log("\uD83D\uDCDD AudioPlayer: New sentence marked: \"".concat(text.substring(0, 40), "...\" (wasStopped: ").concat(wasStopped, ", isPlaying: ").concat(isCurrentlyPlaying, ")"));
+
+      // CRITICAL: Set timeout to detect empty sentences (audio_start but no chunks)
+      // This prevents queue blocking if backend sends audio_start but no audio chunks follow
+      if (this._emptySentenceTimeout) {
+        clearTimeout(this._emptySentenceTimeout);
+      }
+      var sentenceText = text; // Capture for timeout callback
+      this._emptySentenceTimeout = setTimeout(function () {
+        // Check if this sentence still has no chunks after timeout
+        if (_this9.pendingSentenceText === sentenceText && _this9.scheduledBuffers === 0 && _this9.preparedBuffer.length === 0 && _this9.pcmChunkQueue.length === 0 && !_this9._isStopped) {
+          console.warn("\u26A0\uFE0F AudioPlayer: Empty sentence detected after 5s timeout - no chunks received for: \"".concat(sentenceText.substring(0, 40), "...\""));
+          // Clear pending sentence to unblock next sentence
+          if (_this9.pendingSentenceText === sentenceText) {
+            _this9.pendingSentenceText = null;
+          }
+          // Emit playbackStopped to allow next sentence to start
+          // Only if we're not currently playing (to avoid interrupting real playback)
+          if (!_this9.isPlaying && _this9.scheduledSources.size === 0) {
+            console.log('🛑 AudioPlayer: Emitting playbackStopped for empty sentence timeout');
+            _this9.emit('playbackStopped');
+          }
+        }
+        _this9._emptySentenceTimeout = null;
+      }, 5000); // 5 second timeout - adjust based on expected chunk arrival rate
     }
 
     /**
@@ -24739,35 +24878,35 @@ var AudioPlayer = /*#__PURE__*/function (_EventEmitter) {
   }, {
     key: "startTranscriptChecker",
     value: function startTranscriptChecker() {
-      var _this9 = this;
+      var _this0 = this;
       if (this.isCheckingTranscripts) return;
       this.isCheckingTranscripts = true;
       console.log('📝 AudioPlayer: Transcript checker started');
       var _checkLoop = function checkLoop() {
-        if (!_this9.isCheckingTranscripts || !_this9.audioContext) return;
-        var currentTime = _this9.audioContext.currentTime;
-        var _iterator2 = _createForOfIteratorHelper(_this9.sentenceTimings),
-          _step2;
+        if (!_this0.isCheckingTranscripts || !_this0.audioContext) return;
+        var currentTime = _this0.audioContext.currentTime;
+        var _iterator = _createForOfIteratorHelper(_this0.sentenceTimings),
+          _step;
         try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var timing = _step2.value;
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var timing = _step.value;
             if (!timing.displayed && currentTime >= timing.startTime) {
               timing.displayed = true;
               console.log("\uD83D\uDCDD AudioPlayer: Display transcript at ".concat(currentTime.toFixed(3), "s: \"").concat(timing.text.substring(0, 40), "...\""));
-              _this9.emit('transcriptDisplay', {
+              _this0.emit('transcriptDisplay', {
                 text: timing.text
               });
             }
           }
         } catch (err) {
-          _iterator2.e(err);
+          _iterator.e(err);
         } finally {
-          _iterator2.f();
+          _iterator.f();
         }
-        if (_this9.isPlaying || _this9.scheduledBuffers > 0) {
+        if (_this0.isPlaying || _this0.scheduledBuffers > 0) {
           requestAnimationFrame(_checkLoop);
         } else {
-          _this9.isCheckingTranscripts = false;
+          _this0.isCheckingTranscripts = false;
           console.log('📝 AudioPlayer: Transcript checker stopped');
         }
       };
@@ -26129,15 +26268,16 @@ 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: Stop any currently playing audio when new sentence starts
-            // This prevents overlapping audio from multiple sentences playing simultaneously
+            // 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
             if (this.audioPlayer && (this.audioPlayer.isPlaying || ((_this$audioPlayer$sch = this.audioPlayer.scheduledSources) === null || _this$audioPlayer$sch === void 0 ? void 0 : _this$audioPlayer$sch.size) > 0)) {
-              console.log('🛑 VoiceSDK v2: Stopping current audio playback - new sentence starting');
-              this.audioPlayer.stopImmediate();
+              console.log('📝 VoiceSDK v2: New sentence received while audio playing - will queue and wait for current sentence to finish');
             }
             if (message.text && this.audioPlayer) {
               // Use AudioPlayer's transcript sync mechanism
               // AudioPlayer will emit transcriptDisplay when audio actually starts playing (synced with audioContext.currentTime)
+              // If audio is currently playing, markNewSentence will queue this sentence
               this.audioPlayer.markNewSentence(message.text);
             }
             // Also emit as message for other listeners