Take into account VAD start_secs when passing audio data to Smart Turn, and add an extra 500ms of pre-speech audio for good measure

src/pipecat/audio/turn/smart_turn/base_smart_turn.py

@@ -25,7 +25,7 @@ from pipecat.metrics.metrics import MetricsData, SmartTurnMetricsData
 
 # Default timing parameters
 STOP_SECS = 3
-PRE_SPEECH_MS = 0
+PRE_SPEECH_MS = 500
 MAX_DURATION_SECONDS = 8  # Max allowed segment duration
 
 
@@ -35,11 +35,15 @@ class SmartTurnParams(BaseTurnParams):
     Parameters:
         stop_secs: Maximum silence duration in seconds before ending turn.
         pre_speech_ms: Milliseconds of audio to include before speech starts.
+        vad_start_secs: Seconds VAD waits before confirming speech start (e.g. VAD STARTING window).
+            This is added to `pre_speech_ms` at inference slicing time so Smart Turn can include
+            the initial audio that occurred while VAD was still confirming speech.
         max_duration_secs: Maximum duration in seconds for audio segments.
     """
 
     stop_secs: float = STOP_SECS
     pre_speech_ms: float = PRE_SPEECH_MS
+    vad_start_secs: float = 0.0
     max_duration_secs: float = MAX_DURATION_SECONDS
 
 
@@ -181,7 +185,8 @@ class BaseSmartTurn(BaseTurnAnalyzer):
             return state, None
 
         # Extract recent audio segment for prediction
-        start_time = self._speech_start_time - (self._params.pre_speech_ms / 1000)
+        effective_pre_speech_ms = self._params.pre_speech_ms + (self._params.vad_start_secs * 1000)
+        start_time = self._speech_start_time - (effective_pre_speech_ms / 1000)
         start_index = 0
         for i, (t, _) in enumerate(audio_buffer):
             if t >= start_time:

src/pipecat/turns/user_stop/turn_analyzer_user_turn_stop_strategy.py

@@ -10,6 +10,7 @@ import asyncio
 from typing import Optional
 
 from pipecat.audio.turn.base_turn_analyzer import BaseTurnAnalyzer, EndOfTurnState
+from pipecat.audio.turn.smart_turn.base_smart_turn import SmartTurnParams
 from pipecat.frames.frames import (
     Frame,
     InputAudioRawFrame,
@@ -86,6 +87,8 @@ class TurnAnalyzerUserTurnStopStrategy(BaseUserTurnStopStrategy):
 
         if isinstance(frame, StartFrame):
             await self._start(frame)
+        elif isinstance(frame, SpeechControlParamsFrame):
+            await self._handle_speech_control_params(frame)
         elif isinstance(frame, VADUserStartedSpeakingFrame):
             await self._handle_vad_user_started_speaking(frame)
         elif isinstance(frame, VADUserStoppedSpeakingFrame):
@@ -102,6 +105,24 @@ class TurnAnalyzerUserTurnStopStrategy(BaseUserTurnStopStrategy):
         self._turn_analyzer.set_sample_rate(frame.audio_in_sample_rate)
         await self.broadcast_frame(SpeechControlParamsFrame, turn_params=self._turn_analyzer.params)
 
+    async def _handle_speech_control_params(self, frame: SpeechControlParamsFrame):
+        """Sync Smart Turn pre-speech buffering with VAD start delay.
+
+        In the new user-turn-strategies pipeline, `VADUserStartedSpeakingFrame`
+        is emitted only once VAD has *confirmed* speech (after `vad_params.start_secs`).
+        Smart Turn should still include the initial audio collected during that
+        confirmation window, so we record it in `SmartTurnParams.vad_start_secs` and
+        add it at inference slicing time (preserving `pre_speech_ms` semantics).
+        """
+        if not frame.vad_params:
+            return
+
+        params = self._turn_analyzer.params
+        if not isinstance(params, SmartTurnParams):
+            return
+
+        params.vad_start_secs = frame.vad_params.start_secs
+
     async def _handle_input_audio(self, frame: InputAudioRawFrame):
         """Handle input audio to check if the turn is completed."""
         state = self._turn_analyzer.append_audio(frame.audio, self._vad_user_speaking)