feat: Enhance voice activity detection and turn tracing features

- Updated VAD parameters in `.env.example` for improved responsiveness and accuracy, including adjustments to `VAD_MIN_SILENCE_DURATION`, `VAD_THRESHOLD`, and endpointing delays.
- Introduced a new `PendingUserUtterance` class in `metrics_collector.py` to manage user utterances more effectively, allowing for better tracking of speech-to-text transitions.
- Refactored `TurnTracer` to support coalescing of user transcripts, enabling the merging of immediate continuations into prior turns for a more seamless conversation flow.
- Updated settings in `settings.py` to reflect new defaults for voice processing and turn detection.
- Enhanced tests to validate the new features and ensure proper functionality of the updated VAD and turn tracing mechanisms.

.env.example

@@ -46,6 +46,7 @@ LANGFUSE_TRACE_FINALIZE_TIMEOUT_MS=8000
 LANGFUSE_POST_TOOL_RESPONSE_TIMEOUT_MS=30000
 LANGFUSE_MAX_PENDING_TRACE_TASKS=200
 LANGFUSE_TRACE_FLUSH_TIMEOUT_MS=1000
+LANGFUSE_CONTINUATION_COALESCE_WINDOW_MS=1500  # Merge immediate continuation turns into one trace; 0 disables it
 
 # Common LLM Parameters
 LLM_TEMPERATURE=0.7
@@ -85,19 +86,19 @@ LIVEKIT_NUM_IDLE_PROCESSES=1  # Use 0-1 locally to reduce memory pressure
 LIVEKIT_INITIALIZE_PROCESS_TIMEOUT_SEC=20.0  # Increase idle worker bootstrap timeout
 LIVEKIT_JOB_MEMORY_WARN_MB=6144  # Per-job memory warning threshold (6 GB)
 
-# LiveKit Audio Input Configuration - OPTIMIZED FOR FALSE DETECTION FIX
+# LiveKit audio input configuration
 LIVEKIT_SAMPLE_RATE=24000
 LIVEKIT_NUM_CHANNELS=1
-LIVEKIT_FRAME_SIZE_MS=20  # Smaller = faster VAD response, less latency
+LIVEKIT_FRAME_SIZE_MS=60  # Larger frames slightly reduce responsiveness but avoid over-eager VAD transitions
 LIVEKIT_PRE_CONNECT_AUDIO=true
 LIVEKIT_PRE_CONNECT_TIMEOUT=3.0
 
-# Voice Activity Detection (VAD) Configuration - OPTIMIZED FOR FALSE DETECTION FIX
-VAD_MIN_SPEECH_DURATION=0.18  # Require 180ms of speech before activation (faster turn pickup)
-VAD_MIN_SILENCE_DURATION=0.30  # Require 300ms of silence before deactivation (faster turn end)
-VAD_THRESHOLD=0.6  # Higher = less sensitive to noise (0.5 is default)
+# Voice Activity Detection (VAD) configuration
+VAD_MIN_SPEECH_DURATION=0.18  # Require 180ms of speech before activation
+VAD_MIN_SILENCE_DURATION=0.55  # Wait longer before treating a pause as end of speech
+VAD_THRESHOLD=0.5  # Silero default; keep balanced sensitivity for speech vs background noise
 
-# Turn endpointing and responsiveness tuning
-MIN_ENDPOINTING_DELAY=0.35  # Minimum wait before end-of-turn commit
-MAX_ENDPOINTING_DELAY=1.5  # Upper bound wait when turn detector predicts continuation
-PREEMPTIVE_GENERATION=true  # Start generating earlier to reduce perceived latency
+# Turn endpointing tuning
+MIN_ENDPOINTING_DELAY=0.8  # Add a bit more patience before committing a turn to avoid false splits
+MAX_ENDPOINTING_DELAY=3.0  # Let the detector wait longer when phrasing suggests continuation
+PREEMPTIVE_GENERATION=false  # Wait for the committed turn before generating a reply

.gitignore

@@ -29,4 +29,5 @@ model_cache/
 
 # OS
 .DS_Store
-codex-skills/
+codex-skills/
+blog/

src/agent/runtime/session.py

@@ -12,7 +12,7 @@ from livekit.agents import AgentServer, AgentSession, room_io
 from livekit.agents.types import APIConnectOptions
 from livekit.agents.voice.agent_session import SessionConnectOptions
 from livekit.plugins import noise_cancellation, silero
-from livekit.plugins.turn_detector.multilingual import MultilingualModel
+from livekit.plugins.turn_detector.english import EnglishModel
 
 from src.agent.models.llm_runtime import (
     build_llm_runtime,
@@ -71,6 +71,15 @@ def _resolve_stt_metrics_model_name() -> str:
     return settings.stt.NVIDIA_STT_MODEL
 
 
+def _resolve_stt_language() -> str:
+    provider = settings.stt.STT_PROVIDER.lower()
+    if provider == "moonshine":
+        return settings.stt.MOONSHINE_LANGUAGE
+    if provider == "deepgram":
+        return settings.stt.DEEPGRAM_STT_LANGUAGE
+    return settings.stt.NVIDIA_STT_LANGUAGE_CODE
+
+
 def _build_session_connect_options() -> tuple[APIConnectOptions, SessionConnectOptions]:
     llm_conn_options = build_api_connect_options(
         max_retry=settings.llm.LLM_CONN_MAX_RETRY,
@@ -173,8 +182,21 @@ async def session_handler(ctx: agents.JobContext) -> None:
         model=llm_runtime.model,
     )
 
+    stt_engine = create_stt()
+    logger.info(
+        "Turn profile: detector=%s stt_provider=%s stt_model=%s stt_language=%s vad_min_silence=%.2fs min_endpointing=%.2fs max_endpointing=%.2fs preemptive_generation=%s",
+        "EnglishModel",
+        settings.stt.STT_PROVIDER,
+        _resolve_stt_metrics_model_name(),
+        _resolve_stt_language(),
+        settings.voice.VAD_MIN_SILENCE_DURATION,
+        settings.voice.MIN_ENDPOINTING_DELAY,
+        settings.voice.MAX_ENDPOINTING_DELAY,
+        settings.voice.PREEMPTIVE_GENERATION,
+    )
+
     session_kwargs: dict[str, Any] = dict(
-        stt=create_stt(),
+        stt=stt_engine,
         llm=llm_runtime.llm,
         tts=tts_engine,
         vad=silero.VAD.load(
@@ -182,7 +204,7 @@ async def session_handler(ctx: agents.JobContext) -> None:
             min_silence_duration=settings.voice.VAD_MIN_SILENCE_DURATION,
             activation_threshold=settings.voice.VAD_THRESHOLD,
         ),
-        turn_detection=MultilingualModel(),
+        turn_detection=EnglishModel(),
         min_endpointing_delay=settings.voice.MIN_ENDPOINTING_DELAY,
         max_endpointing_delay=settings.voice.MAX_ENDPOINTING_DELAY,
         preemptive_generation=settings.voice.PREEMPTIVE_GENERATION,

src/agent/traces/metrics_collector.py

@@ -202,6 +202,17 @@ class TurnState:
     first_audio_monotonic: Optional[float] = None
 
 
+@dataclass
+class PendingUserUtterance:
+    """Logical user utterance that may span multiple final STT chunks."""
+
+    transcript: str
+    committed: bool = False
+    stt_observed: bool = False
+    llm_started: bool = False
+    watchdog_id: Optional[str] = None
+
+
 # ------------------------------------------------------------------
 # Facade
 # ------------------------------------------------------------------
@@ -241,12 +252,11 @@ class MetricsCollector:
         )
 
         self._publisher = ChannelPublisher(room)
-        self._pending_transcripts: deque[str] = deque()
+        self._pending_user_utterances: deque[PendingUserUtterance] = deque()
         self._pending_agent_transcripts: deque[str] = deque()
         self._pending_speech_ids_for_first_audio: deque[str] = deque()
         self._latest_agent_speech_id: Optional[str] = None
         self._turns: dict[str, TurnState] = {}
-        self._pending_llm_watchdog_ids: deque[str] = deque()
         self._llm_stall_tasks: dict[str, asyncio.Task[None]] = {}
         self._latest_vad_metrics: Optional[VADMetrics] = None
         self._latest_vad_metric_attributes: Optional[dict[str, Any]] = None
@@ -318,18 +328,34 @@ class MetricsCollector:
         normalized = transcript.strip()
         if not normalized:
             return
-        self._pending_transcripts.append(normalized)
+        utterance = self._current_open_user_utterance()
+        if utterance is None:
+            utterance = PendingUserUtterance(transcript=normalized)
+            utterance.watchdog_id = self._start_llm_stall_watchdog(transcript=normalized)
+            self._pending_user_utterances.append(utterance)
+        else:
+            utterance.transcript = _merge_user_transcripts(
+                utterance.transcript,
+                normalized,
+            )
+            if utterance.watchdog_id is not None:
+                self._update_llm_stall_watchdog(
+                    utterance.watchdog_id,
+                    utterance.transcript,
+                )
         if not self._first_final_user_turn_logged:
             self._first_final_user_turn_logged = True
             logger.info(
                 "First finalized user transcript received: room=%s chars=%s preview=%r",
                 self._room_name,
-                len(normalized),
-                normalized[:80],
+                len(utterance.transcript),
+                utterance.transcript[:80],
             )
-        self._start_llm_stall_watchdog(transcript=normalized)
         room_id = await self._resolve_room_id()
-        await self._tracer.create_turn(user_transcript=normalized, room_id=room_id)
+        await self._tracer.create_turn(
+            user_transcript=utterance.transcript,
+            room_id=room_id,
+        )
 
     async def on_conversation_item_added(
         self,
@@ -345,7 +371,28 @@ class MetricsCollector:
         if not normalized:
             return
         if role == "user":
-            _append_if_new(self._pending_transcripts, normalized)
+            utterance = self._latest_user_utterance()
+            if utterance is None:
+                utterance = PendingUserUtterance(
+                    transcript=normalized,
+                    committed=True,
+                )
+                self._pending_user_utterances.append(utterance)
+            else:
+                utterance.transcript = normalized
+                utterance.committed = True
+                if utterance.watchdog_id is not None:
+                    self._update_llm_stall_watchdog(
+                        utterance.watchdog_id,
+                        utterance.transcript,
+                    )
+            user_event_created_at = (
+                item_created_at if item_created_at is not None else event_created_at
+            )
+            await self._tracer.attach_user_text(
+                normalized,
+                event_created_at=user_event_created_at,
+            )
             return
         assistant_event_created_at = (
             item_created_at if item_created_at is not None else event_created_at
@@ -519,8 +566,10 @@ class MetricsCollector:
         if isinstance(collected_metrics, metrics.STTMetrics):
             speech_id = collected_metrics.request_id
             turn_metrics = self._get_or_create_turn(speech_id, role="user")
-            if self._pending_transcripts:
-                turn_metrics.transcript = self._pending_transcripts.popleft()
+            utterance = self._next_user_utterance_for_stt()
+            if utterance is not None:
+                turn_metrics.transcript = utterance.transcript
+                utterance.stt_observed = True
             turn_metrics.stt = STTMetrics(
                 type=collected_metrics.type,
                 label=collected_metrics.label,
@@ -605,6 +654,7 @@ class MetricsCollector:
         elif isinstance(collected_metrics, metrics.EOUMetrics):
             speech_id = collected_metrics.speech_id
             if speech_id:
+                self._mark_oldest_open_user_utterance_committed()
                 state = self._get_or_create_state(speech_id)
                 if state.speech_end_monotonic is None:
                     state.speech_end_monotonic = monotonic()
@@ -788,12 +838,44 @@ class MetricsCollector:
             s for s in self._pending_speech_ids_for_first_audio if s != speech_id
         )
 
-    def _start_llm_stall_watchdog(self, *, transcript: str) -> None:
-        if self._llm_stall_timeout_sec <= 0:
+    def _current_open_user_utterance(self) -> Optional[PendingUserUtterance]:
+        utterance = self._latest_user_utterance()
+        if utterance is None or utterance.committed:
+            return None
+        return utterance
+
+    def _latest_user_utterance(self) -> Optional[PendingUserUtterance]:
+        if not self._pending_user_utterances:
+            return None
+        return self._pending_user_utterances[-1]
+
+    def _next_user_utterance_for_stt(self) -> Optional[PendingUserUtterance]:
+        for utterance in self._pending_user_utterances:
+            if utterance.stt_observed:
+                continue
+            return utterance
+        return None
+
+    def _mark_oldest_open_user_utterance_committed(self) -> None:
+        for utterance in self._pending_user_utterances:
+            if utterance.committed:
+                continue
+            utterance.committed = True
+            self._prune_resolved_user_utterances()
             return
 
+    def _prune_resolved_user_utterances(self) -> None:
+        while self._pending_user_utterances:
+            utterance = self._pending_user_utterances[0]
+            if not utterance.committed or not utterance.llm_started:
+                break
+            self._pending_user_utterances.popleft()
+
+    def _start_llm_stall_watchdog(self, *, transcript: str) -> str | None:
+        if self._llm_stall_timeout_sec <= 0:
+            return None
+
         watchdog_id = str(uuid.uuid4())
-        self._pending_llm_watchdog_ids.append(watchdog_id)
         task = asyncio.create_task(
             self._warn_if_turn_stalled_before_llm(
                 watchdog_id=watchdog_id,
@@ -807,14 +889,36 @@ class MetricsCollector:
             self._llm_stall_tasks.pop(watchdog_id, None)
 
         task.add_done_callback(_on_done)
+        return watchdog_id
+
+    def _update_llm_stall_watchdog(self, watchdog_id: str, transcript: str) -> None:
+        utterance = self._find_user_utterance_by_watchdog(watchdog_id)
+        if utterance is None or utterance.llm_started:
+            return
+        utterance.transcript = transcript
 
     def _mark_llm_stage_reached(self) -> None:
-        while self._pending_llm_watchdog_ids:
-            watchdog_id = self._pending_llm_watchdog_ids.popleft()
-            task = self._llm_stall_tasks.pop(watchdog_id, None)
-            if task:
-                task.cancel()
-                return
+        for utterance in self._pending_user_utterances:
+            if utterance.llm_started:
+                continue
+            utterance.llm_started = True
+            watchdog_id = utterance.watchdog_id
+            utterance.watchdog_id = None
+            if watchdog_id is not None:
+                task = self._llm_stall_tasks.pop(watchdog_id, None)
+                if task:
+                    task.cancel()
+            self._prune_resolved_user_utterances()
+            return
+
+    def _find_user_utterance_by_watchdog(
+        self,
+        watchdog_id: str,
+    ) -> Optional[PendingUserUtterance]:
+        for utterance in self._pending_user_utterances:
+            if utterance.watchdog_id == watchdog_id:
+                return utterance
+        return None
 
     async def _warn_if_turn_stalled_before_llm(
         self,
@@ -827,21 +931,21 @@ class MetricsCollector:
         except asyncio.CancelledError:
             return
 
-        if watchdog_id not in self._pending_llm_watchdog_ids:
+        utterance = self._find_user_utterance_by_watchdog(watchdog_id)
+        if utterance is None or utterance.llm_started:
             return
 
-        self._pending_llm_watchdog_ids = deque(
-            wid for wid in self._pending_llm_watchdog_ids if wid != watchdog_id
-        )
-
-        preview = transcript[:80]
+        utterance.watchdog_id = None
+        utterance.llm_started = True
+        preview = utterance.transcript[:80] if utterance.transcript else transcript[:80]
         logger.warning(
             "Turn stalled before LLM stage: timeout=%.2fs room=%s transcript_chars=%s transcript_preview=%r",
             self._llm_stall_timeout_sec,
             self._room_name,
-            len(transcript),
+            len(utterance.transcript or transcript),
             preview,
         )
+        self._prune_resolved_user_utterances()
 
     async def _resolve_room_id(self) -> str:
         if self._room_id and self._room_id != self._room_name:
@@ -881,6 +985,32 @@ def _append_if_new(queue: deque[str], value: str) -> None:
     queue.append(value)
 
 
+def _merge_user_transcripts(existing: str, incoming: str) -> str:
+    left = existing.strip()
+    right = incoming.strip()
+    if not left:
+        return right
+    if not right:
+        return left
+    if left == right:
+        return left
+    if right.startswith(left):
+        return right
+    if left.startswith(right):
+        return left
+
+    left_words = left.split()
+    right_words = right.split()
+    max_overlap = min(len(left_words), len(right_words))
+    for overlap in range(max_overlap, 0, -1):
+        left_suffix = [word.casefold() for word in left_words[-overlap:]]
+        right_prefix = [word.casefold() for word in right_words[:overlap]]
+        if left_suffix == right_prefix:
+            merged_words = [*left_words, *right_words[overlap:]]
+            return " ".join(merged_words).strip()
+    return f"{left} {right}".strip()
+
+
 def _trace_turn_has_tool_activity(trace_turn: Optional[TraceTurn]) -> bool:
     if trace_turn is None:
         return False

src/agent/traces/turn_tracer.py

@@ -32,6 +32,10 @@ class TraceTurn:
     participant_id: str
     user_transcript: str
     prompt_text: str
+    created_at: float = field(default_factory=time)
+    user_turn_committed: bool = False
+    user_turn_committed_at: Optional[float] = None
+    user_transcript_updated_at: Optional[float] = None
     response_text: str = ""
     assistant_text: str = ""
     assistant_text_missing: bool = False
@@ -72,6 +76,9 @@ class TraceTurn:
     tts_updated_order: Optional[int] = None
     event_counter: int = 0
     tool_post_response_missing: bool = False
+    coalesced_turn_ids: list[str] = field(default_factory=list)
+    coalesced_user_transcripts: list[str] = field(default_factory=list)
+    coalesced_fragment_count: int = 0
     trace_id: Optional[str] = None
 
 
@@ -153,6 +160,7 @@ _DEFAULT_TRACE_FINALIZE_TIMEOUT_MS = 8000.0
 _DEFAULT_POST_TOOL_RESPONSE_TIMEOUT_MS = 30000.0
 _DEFAULT_MAX_PENDING_TRACE_TASKS = 200
 _DEFAULT_TRACE_FLUSH_TIMEOUT_SEC = 1.0
+_DEFAULT_CONTINUATION_COALESCE_WINDOW_MS = 1500.0
 _TOOL_ERROR_FALLBACK_TEXT = "I couldn't complete that tool request. Please rephrase the query."
 
 
@@ -233,6 +241,17 @@ class TurnTracer:
             )
             / 1000.0
         )
+        self._continuation_coalesce_window_sec = (
+            max(
+                getattr(
+                    settings.langfuse,
+                    "LANGFUSE_CONTINUATION_COALESCE_WINDOW_MS",
+                    _DEFAULT_CONTINUATION_COALESCE_WINDOW_MS,
+                ),
+                0.0,
+            )
+            / 1000.0
+        )
 
     # ------------------------------------------------------------------
     # Session context
@@ -287,16 +306,60 @@ class TurnTracer:
 
     async def create_turn(self, *, user_transcript: str, room_id: str) -> None:
         async with self._trace_lock:
-            self._pending_trace_turns.append(
-                TraceTurn(
-                    turn_id=str(uuid.uuid4()),
-                    session_id=self._session_id,
-                    room_id=room_id,
-                    participant_id=self._participant_id,
-                    user_transcript=user_transcript,
-                    prompt_text=user_transcript,
-                )
+            normalized = user_transcript.strip()
+            if not normalized:
+                return
+
+            current_turn = self._latest_turn_where(lambda c: not c.user_turn_committed)
+            if current_turn is not None:
+                self._update_user_turn_text(current_turn, normalized)
+                return
+
+            new_turn = TraceTurn(
+                turn_id=str(uuid.uuid4()),
+                session_id=self._session_id,
+                room_id=room_id,
+                participant_id=self._participant_id,
+                user_transcript=normalized,
+                prompt_text=normalized,
+            )
+            new_turn.user_transcript_updated_at = new_turn.created_at
+
+            coalesced_turn = self._coalesced_turn_candidate()
+            if coalesced_turn is not None:
+                self._absorb_coalesced_turn_metadata(new_turn, coalesced_turn)
+                self._pending_trace_turns.remove(coalesced_turn)
+                self._cancel_finalize_timeout(coalesced_turn.turn_id)
+
+            self._pending_trace_turns.append(new_turn)
+
+    async def attach_user_text(
+        self,
+        user_transcript: str,
+        *,
+        event_created_at: Optional[float] = None,
+    ) -> Optional[TraceTurn]:
+        async with self._trace_lock:
+            turn = self._latest_turn_where(lambda c: not c.assistant_text.strip())
+            if turn is None:
+                turn = self._latest_turn_where(lambda _: True)
+            if turn is None:
+                return None
+
+            normalized = user_transcript.strip()
+            if not normalized:
+                return turn
+
+            self._update_user_turn_text(
+                turn,
+                normalized,
+                event_created_at=event_created_at,
             )
+            turn.user_turn_committed = True
+            turn.user_turn_committed_at = _resolved_event_timestamp(
+                _to_optional_float(event_created_at)
+            )
+            return turn
 
     # ------------------------------------------------------------------
     # Stage attachment
@@ -358,6 +421,10 @@ class TurnTracer:
                 if turn.stt_duration_ms is None:
                     turn.stt_duration_ms = turn.stt_total_latency_ms
             turn.eou_attributes = _sanitize_component_attributes(metric_attributes)
+            turn.user_turn_committed = True
+            turn.user_turn_committed_at = _resolved_event_timestamp(
+                _to_optional_float(turn.eou_attributes.get("timestamp"))
+            )
             metric_speech_id = _normalize_optional_str(
                 turn.eou_attributes.get("speech_id")
             )
@@ -620,6 +687,88 @@ class TurnTracer:
     # Internal helpers
     # ------------------------------------------------------------------
 
+    def _update_user_turn_text(
+        self,
+        turn: TraceTurn,
+        user_transcript: str,
+        *,
+        event_created_at: Optional[float] = None,
+    ) -> None:
+        normalized = user_transcript.strip()
+        if not normalized:
+            return
+        merged = _merge_user_transcripts(turn.user_transcript, normalized)
+        turn.user_transcript = merged
+        turn.prompt_text = merged
+        turn.user_transcript_updated_at = _resolved_event_timestamp(
+            _to_optional_float(event_created_at)
+        )
+
+    def _coalesced_turn_candidate(self) -> Optional[TraceTurn]:
+        if self._continuation_coalesce_window_sec <= 0.0:
+            return None
+
+        now = time()
+        for turn in reversed(self._pending_trace_turns):
+            if not self._can_coalesce_turn(turn):
+                continue
+            activity_at = self._turn_recent_activity_at(turn)
+            if activity_at is None:
+                continue
+            if now - activity_at > self._continuation_coalesce_window_sec:
+                return None
+            return turn
+        return None
+
+    def _can_coalesce_turn(self, turn: TraceTurn) -> bool:
+        if not turn.user_turn_committed:
+            return False
+        if not turn.user_transcript.strip():
+            return False
+        if turn.assistant_text.strip() or turn.response_text.strip():
+            return False
+        if turn.tool_step_announced or turn.tool_executions or turn.last_tool_event_order is not None:
+            return False
+        return bool(turn.llm_calls and turn.tts_calls)
+
+    def _turn_recent_activity_at(self, turn: TraceTurn) -> Optional[float]:
+        candidates = [
+            turn.assistant_text_updated_at,
+            turn.tts_updated_at,
+            turn.last_tool_completed_at,
+            turn.last_tool_event_at,
+            turn.user_turn_committed_at,
+            turn.user_transcript_updated_at,
+            turn.created_at,
+        ]
+        resolved = [candidate for candidate in candidates if candidate is not None]
+        if not resolved:
+            return None
+        return max(resolved)
+
+    def _absorb_coalesced_turn_metadata(
+        self,
+        new_turn: TraceTurn,
+        absorbed_turn: TraceTurn,
+    ) -> None:
+        combined_input = _merge_user_transcripts(
+            absorbed_turn.user_transcript,
+            new_turn.user_transcript,
+        )
+        new_turn.user_transcript = combined_input
+        new_turn.prompt_text = combined_input
+        new_turn.coalesced_turn_ids = [
+            *absorbed_turn.coalesced_turn_ids,
+            absorbed_turn.turn_id,
+        ]
+        new_turn.coalesced_user_transcripts = [
+            *absorbed_turn.coalesced_user_transcripts,
+            absorbed_turn.user_transcript,
+        ]
+        new_turn.coalesced_fragment_count = (
+            absorbed_turn.coalesced_fragment_count + 1
+        )
+
     def _next_turn_where(
         self,
         predicate: Callable[[TraceTurn], bool],
@@ -2005,6 +2154,11 @@ def _set_root_attributes(
         "langfuse.trace.metadata.stt_status": turn.stt_status,
         "langfuse.trace.metadata.tool_phase_announced": turn.tool_step_announced,
         "langfuse.trace.metadata.tool_post_response_missing": turn.tool_post_response_missing,
+        "langfuse.trace.metadata.user_turn_committed": turn.user_turn_committed,
+        "langfuse.trace.metadata.coalesced_turn_count": len(turn.coalesced_turn_ids),
+        "langfuse.trace.metadata.coalesced_fragment_count": turn.coalesced_fragment_count,
+        "langfuse.trace.metadata.coalesced_turn_ids": turn.coalesced_turn_ids,
+        "langfuse.trace.metadata.coalesced_inputs": turn.coalesced_user_transcripts,
         "duration_ms": _total_duration_ms(turn),
         "latency_ms.user_input": vals["user_input_duration_ms"],
         "latency_ms.vad": vals["vad_duration_ms"],
@@ -2036,6 +2190,7 @@ def _set_root_attributes(
         "tool.phase_announced": turn.tool_step_announced,
         "tool.post_response_missing": turn.tool_post_response_missing,
         "stt_status": turn.stt_status,
+        "user_turn.committed": turn.user_turn_committed,
     }
     for key, value in attrs.items():
         if value is not None:
@@ -2100,6 +2255,32 @@ def _stringify_observation(value: Any) -> str:
     return str(value)
 
 
+def _merge_user_transcripts(existing: str, incoming: str) -> str:
+    left = existing.strip()
+    right = incoming.strip()
+    if not left:
+        return right
+    if not right:
+        return left
+    if left == right:
+        return left
+    if right.startswith(left):
+        return right
+    if left.startswith(right):
+        return left
+
+    left_words = left.split()
+    right_words = right.split()
+    max_overlap = min(len(left_words), len(right_words))
+    for overlap in range(max_overlap, 0, -1):
+        left_suffix = [word.casefold() for word in left_words[-overlap:]]
+        right_prefix = [word.casefold() for word in right_words[:overlap]]
+        if left_suffix == right_prefix:
+            merged_words = [*left_words, *right_words[overlap:]]
+            return " ".join(merged_words).strip()
+    return f"{left} {right}".strip()
+
+
 def _emit_component_span(
     _tracer: Any,
     *,

src/core/settings.py

@@ -60,7 +60,7 @@ class CoreSettings(BaseSettings):
 
 class VoiceSettings(CoreSettings):
     TTS_PROVIDER: str = Field(
-        default="nvidia",
+        default="pocket",
         description="TTS provider: 'pocket', 'deepgram', or 'nvidia'",
     )
     DEEPGRAM_API_KEY: Optional[str] = Field(
@@ -129,7 +129,7 @@ class VoiceSettings(CoreSettings):
         description="Number of audio input channels (1=mono)",
     )
     LIVEKIT_FRAME_SIZE_MS: int = Field(
-        default=20,
+        default=60,
         ge=10,
         le=100,
         description="Audio frame size in milliseconds (smaller = faster VAD response)",
@@ -153,31 +153,34 @@ class VoiceSettings(CoreSettings):
         description="Minimum speech duration (seconds) before VAD activation",
     )
     VAD_MIN_SILENCE_DURATION: float = Field(
-        default=0.30,
+        default=0.55,
         ge=0.1,
         le=2.0,
         description="Minimum silence duration (seconds) before VAD deactivation",
     )
     VAD_THRESHOLD: float = Field(
-        default=0.6,
+        default=0.5,
         ge=0.0,
         le=1.0,
         description="VAD activation threshold (higher = less sensitive, 0.5 is Silero default)",
     )
     MIN_ENDPOINTING_DELAY: float = Field(
-        default=0.15,
+        default=0.5,
         ge=0.0,
         le=10.0,
-        description="Minimum endpointing delay (seconds) before committing user turn",
+        description=(
+            "Minimum endpointing delay (seconds) before committing user turn; "
+            "slightly higher values reduce false turn splits"
+        ),
     )
     MAX_ENDPOINTING_DELAY: float = Field(
-        default=1.5,
+        default=3.0,
         ge=0.1,
         le=10.0,
         description="Maximum endpointing delay (seconds) when turn detector expects continuation",
     )
     PREEMPTIVE_GENERATION: bool = Field(
-        default=True,
+        default=False,
         description="Enable speculative LLM/TTS generation before final turn commit",
     )
 
@@ -280,7 +283,7 @@ class LLMSettings(CoreSettings):
         ),
     )
     OLLAMA_MODEL: str = Field(
-        default= "ministral-3:14b-cloud", #"ministral-3:8b-cloud", #"qwen3-coder-next",#minimax-m2.5 #"ministral-3:8b", #"qwen2.5:7b" #"qwen3:8b" #"qwen3.5:4b",
+        default= "ministral-3:14b", #"ministral-3:14b-cloud", #"ministral-3:8b-cloud", #"qwen3-coder-next",#minimax-m2.5 #"ministral-3:8b", #"qwen2.5:7b" #"qwen3:8b" #"qwen3.5:4b",
         description="Ollama model tag",
     )
     OLLAMA_API_KEY: Optional[str] = Field(
@@ -290,7 +293,7 @@ class LLMSettings(CoreSettings):
 
     # Common LLM parameters
     LLM_TEMPERATURE: float = Field(default=0.7, ge=0.0, le=2.0)
-    LLM_MAX_TOKENS: int = Field(default=1024, gt=0)
+    LLM_MAX_TOKENS: int = Field(default=256, gt=0)
     LLM_CONN_TIMEOUT_SEC: float = Field(
         default=20.0,
         gt=0.0,
@@ -349,7 +352,7 @@ class LiveKitSettings(CoreSettings):
     LIVEKIT_API_KEY: Optional[str] = Field(default=None)
     LIVEKIT_API_SECRET: Optional[str] = Field(default=None)
     LIVEKIT_AGENT_NAME: str = Field(default="open-voice-agent")
-    LIVEKIT_NUM_IDLE_PROCESSES: int = Field(default=1, ge=0)
+    LIVEKIT_NUM_IDLE_PROCESSES: int = Field(default=0, ge=0)
     LIVEKIT_INITIALIZE_PROCESS_TIMEOUT_SEC: float = Field(
         default=20.0,
         gt=0.0,
@@ -413,6 +416,15 @@ class LangfuseSettings(CoreSettings):
         le=10000.0,
         description="Best-effort tracer flush timeout in milliseconds",
     )
+    LANGFUSE_CONTINUATION_COALESCE_WINDOW_MS: float = Field(
+        default=1500.0,
+        ge=0.0,
+        le=10000.0,
+        description=(
+            "Window to merge an immediately-following continuation into a prior aborted "
+            "turn trace; set to 0 to disable"
+        ),
+    )
 
 
 class Settings(CoreSettings):

tests/test_langfuse_turn_tracing.py

@@ -1676,6 +1676,328 @@ def test_creates_new_trace_for_each_finalized_transcript(
     assert turn_spans[0].trace_id != turn_spans[1].trace_id
 
 
+def test_multiple_final_transcripts_are_merged_into_one_turn(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import src.agent.traces.metrics_collector as metrics_collector_module
+
+    fake_tracer = _FakeTracer()
+    monkeypatch.setattr(metrics_collector_module, "tracer", fake_tracer)
+
+    room = _FakeRoom()
+    collector = MetricsCollector(
+        room=room,  # type: ignore[arg-type]
+        model_name="moonshine",
+        room_name=room.name,
+        room_id="RM123",
+        participant_id="web-123",
+        langfuse_enabled=True,
+    )
+
+    async def _run() -> None:
+        await collector.on_session_metadata(
+            session_id="session-merged-finals",
+            participant_id="web-123",
+        )
+        await collector.on_user_input_transcribed("What", is_final=True)
+        await collector.on_user_input_transcribed(
+            "the difference between speech to text and speech recognition?",
+            is_final=True,
+        )
+        await collector.on_metrics_collected(_make_stt_metrics("stt-merged"))
+        await collector.on_metrics_collected(
+            _make_eou_metrics("speech-merged", delay=0.9, transcription_delay=0.2)
+        )
+        await collector.on_conversation_item_added(
+            role="user",
+            content="What the difference between speech to text and speech recognition?",
+        )
+        await collector.on_metrics_collected(_make_llm_metrics("speech-merged"))
+        await collector.on_conversation_item_added(role="assistant", content="Speech to text writes words down.")
+        await collector.on_metrics_collected(_make_tts_metrics("speech-merged"))
+        await collector.wait_for_pending_trace_tasks()
+
+    asyncio.run(_run())
+
+    turn_spans = [span for span in fake_tracer.spans if span.name == "turn"]
+    assert len(turn_spans) == 1
+    root = turn_spans[0]
+    stt_span = next(span for span in fake_tracer.spans if span.name == "STTMetrics")
+    assert (
+        root.attributes["langfuse.trace.input"]
+        == "What the difference between speech to text and speech recognition?"
+    )
+    assert (
+        stt_span.attributes["user_transcript"]
+        == "What the difference between speech to text and speech recognition?"
+    )
+    assert root.attributes["langfuse.trace.metadata.coalesced_turn_count"] == 0
+
+
+def test_immediate_continuation_coalesces_aborted_prior_turn(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import src.agent.traces.metrics_collector as metrics_collector_module
+
+    fake_tracer = _FakeTracer()
+    monkeypatch.setattr(metrics_collector_module, "tracer", fake_tracer)
+    monkeypatch.setattr(
+        metrics_collector_module.settings.langfuse,
+        "LANGFUSE_CONTINUATION_COALESCE_WINDOW_MS",
+        1500.0,
+    )
+
+    room = _FakeRoom()
+    collector = MetricsCollector(
+        room=room,  # type: ignore[arg-type]
+        model_name="moonshine",
+        room_name=room.name,
+        room_id="RM123",
+        participant_id="web-123",
+        langfuse_enabled=True,
+    )
+
+    async def _run() -> None:
+        await collector.on_session_metadata(
+            session_id="session-coalesce",
+            participant_id="web-123",
+        )
+        await collector.on_user_input_transcribed("What", is_final=True)
+        await collector.on_metrics_collected(
+            _make_eou_metrics("speech-a", delay=0.7, transcription_delay=0.2)
+        )
+        await collector.on_metrics_collected(_make_llm_metrics("speech-a"))
+        await collector.on_metrics_collected(_make_tts_metrics("speech-a"))
+
+        await collector.on_user_input_transcribed(
+            "the difference between speech to text and speech recognition?",
+            is_final=True,
+        )
+        await collector.on_metrics_collected(
+            _make_eou_metrics("speech-b", delay=0.7, transcription_delay=0.2)
+        )
+        await collector.on_conversation_item_added(
+            role="user",
+            content="What the difference between speech to text and speech recognition?",
+        )
+        await collector.on_metrics_collected(_make_llm_metrics("speech-b"))
+        await collector.on_conversation_item_added(role="assistant", content="Speech to text writes words down.")
+        await collector.on_metrics_collected(_make_tts_metrics("speech-b"))
+        await collector.wait_for_pending_trace_tasks()
+
+    asyncio.run(_run())
+
+    turn_spans = [span for span in fake_tracer.spans if span.name == "turn"]
+    assert len(turn_spans) == 1
+    root = turn_spans[0]
+    assert (
+        root.attributes["langfuse.trace.input"]
+        == "What the difference between speech to text and speech recognition?"
+    )
+    assert root.attributes["langfuse.trace.metadata.coalesced_turn_count"] == 1
+    assert root.attributes["langfuse.trace.metadata.coalesced_fragment_count"] == 1
+    assert root.attributes["langfuse.trace.metadata.coalesced_inputs"] == ["What"]
+
+
+def test_visible_assistant_reply_prevents_continuation_coalescing(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import src.agent.traces.metrics_collector as metrics_collector_module
+
+    fake_tracer = _FakeTracer()
+    monkeypatch.setattr(metrics_collector_module, "tracer", fake_tracer)
+
+    room = _FakeRoom()
+    collector = MetricsCollector(
+        room=room,  # type: ignore[arg-type]
+        model_name="moonshine",
+        room_name=room.name,
+        room_id="RM123",
+        participant_id="web-123",
+        langfuse_enabled=True,
+    )
+
+    async def _run() -> None:
+        await collector.on_session_metadata(
+            session_id="session-no-coalesce-visible-reply",
+            participant_id="web-123",
+        )
+        await collector.on_user_input_transcribed("first turn", is_final=True)
+        await collector.on_metrics_collected(_make_stt_metrics("stt-first-visible"))
+        await collector.on_metrics_collected(_make_eou_metrics("speech-first-visible"))
+        await collector.on_metrics_collected(_make_llm_metrics("speech-first-visible"))
+        await collector.on_conversation_item_added(role="assistant", content="first reply")
+        await collector.on_metrics_collected(_make_tts_metrics("speech-first-visible"))
+
+        await collector.on_user_input_transcribed("second turn", is_final=True)
+        await collector.on_metrics_collected(_make_stt_metrics("stt-second-visible"))
+        await collector.on_metrics_collected(_make_eou_metrics("speech-second-visible"))
+        await collector.on_metrics_collected(_make_llm_metrics("speech-second-visible"))
+        await collector.on_conversation_item_added(role="assistant", content="second reply")
+        await collector.on_metrics_collected(_make_tts_metrics("speech-second-visible"))
+        await collector.wait_for_pending_trace_tasks()
+
+    asyncio.run(_run())
+
+    turn_spans = [span for span in fake_tracer.spans if span.name == "turn"]
+    assert len(turn_spans) == 2
+    assert turn_spans[0].attributes["langfuse.trace.metadata.coalesced_turn_count"] == 0
+    assert turn_spans[1].attributes["langfuse.trace.metadata.coalesced_turn_count"] == 0
+
+
+def test_tool_activity_prevents_continuation_coalescing(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import src.agent.traces.metrics_collector as metrics_collector_module
+
+    fake_tracer = _FakeTracer()
+    monkeypatch.setattr(metrics_collector_module, "tracer", fake_tracer)
+
+    room = _FakeRoom()
+    collector = MetricsCollector(
+        room=room,  # type: ignore[arg-type]
+        model_name="moonshine",
+        room_name=room.name,
+        room_id="RM123",
+        participant_id="web-123",
+        langfuse_enabled=True,
+    )
+    collector._trace_finalize_timeout_sec = 0.05
+    collector._trace_post_tool_response_timeout_sec = 0.05
+
+    async def _run() -> None:
+        await collector.on_session_metadata(
+            session_id="session-no-coalesce-tools",
+            participant_id="web-123",
+        )
+        await collector.on_user_input_transcribed("run tool", is_final=True)
+        await collector.on_metrics_collected(_make_eou_metrics("speech-tool-a"))
+        await collector.on_metrics_collected(_make_llm_metrics("speech-tool-a"))
+        await collector.on_metrics_collected(_make_tts_metrics("speech-tool-a"))
+        await collector.on_tool_step_started()
+        await collector.on_function_tools_executed(
+            function_calls=[
+                _FakeFunctionCall(
+                    name="search_web",
+                    call_id="tool-a",
+                    arguments='{"q":"speech models"}',
+                    created_at=1.0,
+                )
+            ],
+            function_call_outputs=[
+                _FakeFunctionCallOutput(
+                    output='{"results":[]}',
+                    is_error=False,
+                    created_at=1.1,
+                )
+            ],
+            created_at=1.1,
+        )
+
+        await collector.on_user_input_transcribed("follow-up turn", is_final=True)
+        await collector.on_metrics_collected(_make_eou_metrics("speech-tool-b"))
+        await collector.on_metrics_collected(_make_llm_metrics("speech-tool-b"))
+        await collector.on_conversation_item_added(role="assistant", content="second reply")
+        await collector.on_metrics_collected(_make_tts_metrics("speech-tool-b"))
+        await asyncio.sleep(0.08)
+        await collector.wait_for_pending_trace_tasks()
+
+    asyncio.run(_run())
+
+    turn_spans = [span for span in fake_tracer.spans if span.name == "turn"]
+    assert len(turn_spans) == 2
+    assert turn_spans[1].attributes["langfuse.trace.metadata.coalesced_turn_count"] == 0
+
+
+def test_multiple_final_transcripts_share_one_llm_stall_watchdog() -> None:
+    room = _FakeRoom()
+    collector = MetricsCollector(
+        room=room,  # type: ignore[arg-type]
+        model_name="moonshine",
+        room_name=room.name,
+        room_id="RM123",
+        participant_id="web-123",
+        langfuse_enabled=False,
+    )
+
+    async def _run() -> None:
+        await collector.on_user_input_transcribed("Search for the most popular", is_final=True)
+        await collector.on_user_input_transcribed("test to speech model.", is_final=True)
+        assert len(collector._pending_user_utterances) == 1
+        assert len(collector._llm_stall_tasks) == 1
+        assert (
+            collector._pending_user_utterances[0].transcript
+            == "Search for the most popular test to speech model."
+        )
+
+        await collector.on_metrics_collected(_make_llm_metrics("speech-watchdog"))
+        await asyncio.sleep(0)
+
+    asyncio.run(_run())
+
+    assert not collector._llm_stall_tasks
+
+
+def test_continuation_coalescing_can_be_disabled(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import src.agent.traces.metrics_collector as metrics_collector_module
+
+    fake_tracer = _FakeTracer()
+    monkeypatch.setattr(metrics_collector_module, "tracer", fake_tracer)
+    monkeypatch.setattr(
+        metrics_collector_module.settings.langfuse,
+        "LANGFUSE_CONTINUATION_COALESCE_WINDOW_MS",
+        0.0,
+    )
+
+    room = _FakeRoom()
+    collector = MetricsCollector(
+        room=room,  # type: ignore[arg-type]
+        model_name="moonshine",
+        room_name=room.name,
+        room_id="RM123",
+        participant_id="web-123",
+        langfuse_enabled=True,
+    )
+    collector._trace_finalize_timeout_sec = 0.01
+
+    async def _run() -> None:
+        await collector.on_session_metadata(
+            session_id="session-no-coalesce-disabled",
+            participant_id="web-123",
+        )
+        await collector.on_user_input_transcribed("What", is_final=True)
+        await collector.on_metrics_collected(
+            _make_eou_metrics("speech-disabled-a", delay=0.7, transcription_delay=0.2)
+        )
+        await collector.on_metrics_collected(_make_llm_metrics("speech-disabled-a"))
+        await collector.on_metrics_collected(_make_tts_metrics("speech-disabled-a"))
+        await asyncio.sleep(0.03)
+
+        await collector.on_user_input_transcribed(
+            "the difference between speech to text and speech recognition?",
+            is_final=True,
+        )
+        await collector.on_metrics_collected(
+            _make_eou_metrics("speech-disabled-b", delay=0.7, transcription_delay=0.2)
+        )
+        await collector.on_metrics_collected(_make_llm_metrics("speech-disabled-b"))
+        await collector.on_conversation_item_added(role="assistant", content="Speech to text writes words down.")
+        await collector.on_metrics_collected(_make_tts_metrics("speech-disabled-b"))
+        await collector.wait_for_pending_trace_tasks()
+
+    asyncio.run(_run())
+
+    turn_spans = [span for span in fake_tracer.spans if span.name == "turn"]
+    assert len(turn_spans) == 2
+    assert turn_spans[0].attributes["langfuse.trace.input"] == "What"
+    assert (
+        turn_spans[1].attributes["langfuse.trace.input"]
+        == "the difference between speech to text and speech recognition?"
+    )
+
+
 def test_trace_emits_without_stt_metrics(monkeypatch: pytest.MonkeyPatch) -> None:
     import src.agent.traces.metrics_collector as metrics_collector_module
 

tests/test_runtime_settings.py

@@ -3,7 +3,14 @@ from __future__ import annotations
 import pytest
 from pydantic import ValidationError
 
-from src.core.settings import LLMSettings, LiveKitSettings, STTSettings, Settings, VoiceSettings
+from src.core.settings import (
+    LLMSettings,
+    LangfuseSettings,
+    LiveKitSettings,
+    STTSettings,
+    Settings,
+    VoiceSettings,
+)
 
 
 def test_llm_runtime_tuning_defaults_are_declared() -> None:
@@ -15,7 +22,7 @@ def test_llm_runtime_tuning_defaults_are_declared() -> None:
     assert fields["MCP_SERVER_URL"].default == "https://huggingface.co/mcp"
     assert fields["MCP_EXTRA_SERVER_URLS"].default == "https://docs.livekit.io/mcp"
     assert fields["OLLAMA_CLOUD_MODE"].default is True
-    assert fields["OLLAMA_MODEL"].default == "ministral-3:14b-cloud"
+    assert fields["OLLAMA_MODEL"].default == "ministral-3:14b"
     assert fields["OLLAMA_API_KEY"].default == "ollama"
     assert fields["LLM_CONN_TIMEOUT_SEC"].default == 20.0
     assert fields["LLM_CONN_MAX_RETRY"].default == 1
@@ -28,7 +35,7 @@ def test_llm_runtime_tuning_defaults_are_declared() -> None:
 def test_livekit_runtime_tuning_defaults_are_declared() -> None:
     fields = LiveKitSettings.model_fields
 
-    assert fields["LIVEKIT_NUM_IDLE_PROCESSES"].default == 1
+    assert fields["LIVEKIT_NUM_IDLE_PROCESSES"].default == 0
     assert fields["LIVEKIT_INITIALIZE_PROCESS_TIMEOUT_SEC"].default == 20.0
     assert fields["LIVEKIT_JOB_MEMORY_WARN_MB"].default == 6144
 
@@ -36,16 +43,25 @@ def test_livekit_runtime_tuning_defaults_are_declared() -> None:
 def test_voice_runtime_tuning_defaults_are_declared() -> None:
     fields = VoiceSettings.model_fields
 
-    assert fields["TTS_PROVIDER"].default == "deepgram"
+    assert fields["TTS_PROVIDER"].default == "pocket"
     assert fields["NVIDIA_TTS_VOICE"].default == "Magpie-Multilingual.EN-US.Leo"
     assert fields["NVIDIA_TTS_USE_SSL"].default is True
     assert fields["POCKET_TTS_CONN_TIMEOUT_SEC"].default == 45.0
+    assert fields["MIN_ENDPOINTING_DELAY"].default == 0.8
+
+
+def test_langfuse_runtime_tuning_defaults_are_declared() -> None:
+    fields = LangfuseSettings.model_fields
+
+    assert fields["LANGFUSE_TRACE_FINALIZE_TIMEOUT_MS"].default == 8000.0
+    assert fields["LANGFUSE_POST_TOOL_RESPONSE_TIMEOUT_MS"].default == 30000.0
+    assert fields["LANGFUSE_CONTINUATION_COALESCE_WINDOW_MS"].default == 1500.0
 
 
 def test_stt_runtime_tuning_defaults_are_declared() -> None:
     fields = STTSettings.model_fields
 
-    assert fields["STT_PROVIDER"].default == "moonshine"
+    assert fields["STT_PROVIDER"].default == "deepgram"
     assert fields["DEEPGRAM_STT_MODEL"].default == "nova-3"
     assert fields["DEEPGRAM_STT_LANGUAGE"].default == "en-US"
 

tests/test_session_conn_options.py

@@ -2,11 +2,15 @@ from __future__ import annotations
 
 import asyncio
 import types
+from pathlib import Path
 
 from livekit.agents.inference_runner import _InferenceRunner
 
 from src.agent.runtime import session as runtime_session
-from src.core.settings import settings
+from src.core.settings import VoiceSettings, settings
+
+
+ENV_EXAMPLE_PATH = Path(__file__).resolve().parents[1] / ".env.example"
 
 
 class _FakeJobContext:
@@ -70,8 +74,8 @@ def test_build_server_uses_livekit_process_initialization_settings(monkeypatch)
     assert server._job_memory_warn_mb == 8192.0
 
 
-def test_importing_session_registers_multilingual_turn_detector_runner() -> None:
-    assert "lk_end_of_utterance_multilingual" in _InferenceRunner.registered_runners
+def test_importing_session_registers_english_turn_detector_runner() -> None:
+    assert "lk_end_of_utterance_en" in _InferenceRunner.registered_runners
 
 
 def test_resolve_stt_metrics_model_name_uses_deepgram_model(monkeypatch) -> None:
@@ -119,9 +123,12 @@ def test_session_handler_runs_llm_warmup_before_session_start(monkeypatch) -> No
     monkeypatch.setattr(runtime_session, "install_mcp_generate_reply_guard", lambda *args, **kwargs: None)
     monkeypatch.setattr(runtime_session, "run_startup_greeting", lambda *args, **kwargs: None)
     monkeypatch.setattr(runtime_session.silero.VAD, "load", lambda **kwargs: "vad")
-    monkeypatch.setattr(runtime_session, "MultilingualModel", lambda: "turn-detector")
+    monkeypatch.setattr(runtime_session, "EnglishModel", lambda: "turn-detector")
     monkeypatch.setattr(runtime_session.room_io, "AudioInputOptions", lambda **kwargs: kwargs)
     monkeypatch.setattr(runtime_session.room_io, "RoomOptions", lambda **kwargs: kwargs)
+    monkeypatch.setattr(settings.voice, "MIN_ENDPOINTING_DELAY", 1.0)
+    monkeypatch.setattr(settings.voice, "MAX_ENDPOINTING_DELAY", 4.0)
+    monkeypatch.setattr(settings.voice, "PREEMPTIVE_GENERATION", False)
 
     async def _fake_run_llm_warmup(**kwargs) -> None:
         order.append("llm")
@@ -133,3 +140,45 @@ def test_session_handler_runs_llm_warmup_before_session_start(monkeypatch) -> No
     assert order == ["llm", "start"]
     assert len(created_sessions) == 1
     assert created_sessions[0].start_calls
+    assert created_sessions[0].kwargs["turn_detection"] == "turn-detector"
+    assert created_sessions[0].kwargs["min_endpointing_delay"] == 1.0
+    assert created_sessions[0].kwargs["max_endpointing_delay"] == 4.0
+    assert created_sessions[0].kwargs["preemptive_generation"] is False
+
+
+def test_env_example_turn_profile_matches_voice_defaults() -> None:
+    env_values = _parse_env_file(ENV_EXAMPLE_PATH)
+
+    assert env_values["LIVEKIT_FRAME_SIZE_MS"] == str(
+        VoiceSettings.model_fields["LIVEKIT_FRAME_SIZE_MS"].default
+    )
+    assert env_values["VAD_MIN_SILENCE_DURATION"] == str(
+        VoiceSettings.model_fields["VAD_MIN_SILENCE_DURATION"].default
+    )
+    assert env_values["VAD_THRESHOLD"] == str(
+        VoiceSettings.model_fields["VAD_THRESHOLD"].default
+    )
+    assert env_values["MIN_ENDPOINTING_DELAY"] == str(
+        VoiceSettings.model_fields["MIN_ENDPOINTING_DELAY"].default
+    )
+    assert env_values["MAX_ENDPOINTING_DELAY"] == str(
+        VoiceSettings.model_fields["MAX_ENDPOINTING_DELAY"].default
+    )
+    assert env_values["PREEMPTIVE_GENERATION"] == _env_bool(
+        VoiceSettings.model_fields["PREEMPTIVE_GENERATION"].default
+    )
+
+
+def _parse_env_file(path: Path) -> dict[str, str]:
+    values: dict[str, str] = {}
+    for raw_line in path.read_text(encoding="utf-8").splitlines():
+        line = raw_line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        values[key.strip()] = value.split(" #", 1)[0].strip()
+    return values
+
+
+def _env_bool(value: bool) -> str:
+    return "true" if value else "false"