Enhance metrics handling and add EOU support: Update ChannelPublisher and TurnTracer to include end-of-utterance (EOU) metrics, refactor latency calculations, and improve metric attribute handling. Modify UI tooltips for clarity and adjust test cases to validate new metrics structure.

src/agent/_channel_metrics.py

@@ -48,7 +48,13 @@ class ChannelPublisher:
                 "speech_id": speech_id,
                 "stage": stage,
                 "role": role,
-                "metrics": {"stt": None, "llm": None, "tts": None, "vad": None},
+                "metrics": {
+                    "stt": None,
+                    "eou": None,
+                    "llm": None,
+                    "tts": None,
+                    "vad": None,
+                },
                 "latencies": None,
                 "diagnostic": diagnostic,
             }
@@ -59,6 +65,8 @@ class ChannelPublisher:
                         **asdict(turn_metrics.stt),
                         "display_duration": _stt_display_duration(turn_metrics.stt),
                     }
+                if turn_metrics.eou:
+                    payload["metrics"]["eou"] = asdict(turn_metrics.eou)
                 if turn_metrics.llm:
                     payload["metrics"]["llm"] = asdict(turn_metrics.llm)
                 if turn_metrics.tts:
@@ -154,7 +162,7 @@ def _build_partial_latencies(
     if not has_signal:
         return None
 
-    baseline = eou_delay + stt_finalization_delay + llm_ttft + tts_ttfb
+    baseline = eou_delay + llm_ttft + tts_ttfb
     total = max(baseline, observed_total_latency if observed_total_latency is not None else 0.0)
     return {
         "total_latency": total,

src/agent/_turn_tracer.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 import asyncio
 import uuid
 from collections import deque
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from time import time_ns
 from typing import TYPE_CHECKING, Any, Callable, Optional
 
@@ -40,6 +40,7 @@ class TraceTurn:
     stt_duration_ms: Optional[float] = None
     stt_finalization_ms: Optional[float] = None
     stt_total_latency_ms: Optional[float] = None
+    eou_on_user_turn_completed_ms: Optional[float] = None
     llm_duration_ms: Optional[float] = None
     llm_ttft_ms: Optional[float] = None
     llm_total_latency_ms: Optional[float] = None
@@ -47,6 +48,11 @@ class TraceTurn:
     tts_ttfb_ms: Optional[float] = None
     conversational_latency_ms: Optional[float] = None
     llm_to_tts_handoff_ms: Optional[float] = None
+    stt_attributes: dict[str, Any] = field(default_factory=dict)
+    eou_attributes: dict[str, Any] = field(default_factory=dict)
+    vad_attributes: dict[str, Any] = field(default_factory=dict)
+    llm_attributes: dict[str, Any] = field(default_factory=dict)
+    tts_attributes: dict[str, Any] = field(default_factory=dict)
     trace_id: Optional[str] = None
 
 
@@ -195,6 +201,7 @@ class TurnTracer:
         transcript: str,
         duration: float,
         fallback_duration: float,
+        metric_attributes: Optional[dict[str, Any]] = None,
     ) -> Optional[TraceTurn]:
         async with self._trace_lock:
             turn = self._next_turn_where(
@@ -213,14 +220,18 @@ class TurnTracer:
             else:
                 turn.stt_duration_ms = measured_ms
                 turn.stt_status = "measured"
+            turn.stt_attributes = _sanitize_component_attributes(metric_attributes)
             _recompute_conversational_latency(turn)
             return turn
 
-    async def attach_vad(
+    async def attach_eou(
         self,
         *,
         duration: float,
         transcription_delay: float,
+        on_user_turn_completed_delay: float = 0.0,
+        metric_attributes: Optional[dict[str, Any]] = None,
+        vad_metric_attributes: Optional[dict[str, Any]] = None,
     ) -> Optional[TraceTurn]:
         async with self._trace_lock:
             turn = self._next_turn_where(
@@ -232,10 +243,15 @@ class TurnTracer:
             turn.vad_duration_ms = eou_delay_ms
             turn.stt_finalization_ms = _duration_to_ms(transcription_delay, 0.0)
             turn.stt_total_latency_ms = eou_delay_ms + (turn.stt_finalization_ms or 0.0)
+            turn.eou_on_user_turn_completed_ms = _duration_to_ms(
+                on_user_turn_completed_delay, 0.0
+            )
             if turn.stt_total_latency_ms > 0:
                 turn.stt_status = "measured"
                 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.vad_attributes = _sanitize_component_attributes(vad_metric_attributes)
             _recompute_conversational_latency(turn)
             return turn
 
@@ -244,6 +260,7 @@ class TurnTracer:
         *,
         duration: float,
         ttft: float,
+        metric_attributes: Optional[dict[str, Any]] = None,
     ) -> Optional[TraceTurn]:
         async with self._trace_lock:
             turn = self._next_turn_where(
@@ -255,6 +272,7 @@ class TurnTracer:
             turn.llm_duration_ms = _duration_to_ms(duration, 0.0)
             turn.llm_total_latency_ms = turn.llm_duration_ms
             turn.llm_ttft_ms = _duration_to_ms(ttft, 0.0)
+            turn.llm_attributes = _sanitize_component_attributes(metric_attributes)
             _recompute_conversational_latency(turn)
             return turn
 
@@ -265,6 +283,7 @@ class TurnTracer:
         fallback_duration: float,
         ttfb: float,
         observed_total_latency: Optional[float],
+        metric_attributes: Optional[dict[str, Any]] = None,
     ) -> Optional[TraceTurn]:
         async with self._trace_lock:
             turn = self._next_turn_where(
@@ -276,6 +295,7 @@ class TurnTracer:
                 return None
             turn.tts_duration_ms = _duration_to_ms(duration, fallback_duration)
             turn.tts_ttfb_ms = _duration_to_ms(ttfb, 0.0)
+            turn.tts_attributes = _sanitize_component_attributes(metric_attributes)
             _recompute_conversational_latency(turn)
             if observed_total_latency is not None:
                 observed_ms = observed_total_latency * 1000.0
@@ -287,7 +307,6 @@ class TurnTracer:
             turn.llm_to_tts_handoff_ms = _compute_llm_to_tts_handoff_ms(
                 total_latency_ms=turn.conversational_latency_ms,
                 vad_duration_ms=turn.vad_duration_ms,
-                stt_finalization_ms=turn.stt_finalization_ms,
                 llm_ttft_ms=turn.llm_ttft_ms,
                 tts_ttfb_ms=turn.tts_ttfb_ms,
             )
@@ -508,23 +527,46 @@ class TurnTracer:
                     attributes={"user_transcript": turn.user_transcript},
                     observation_input=turn.user_transcript,
                 )
-                vad_start_ns = cursor_ns
-                cursor_ns = _emit_component_span(
+                speech_end_start_ns = cursor_ns
+                _emit_component_span(
                     _tracer,
-                    name="vad",
+                    name="VADMetrics",
                     context=ctx,
-                    start_ns=cursor_ns,
+                    start_ns=speech_end_start_ns,
+                    duration_ms=vals["vad_metrics_duration_ms"],
+                    attributes=_merge_component_attributes(
+                        turn.vad_attributes,
+                        {
+                            "eou_delay_ms": vals["vad_duration_ms"],
+                        },
+                    ),
+                )
+                eou_end_ns = _emit_component_span(
+                    _tracer,
+                    name="EOUMetrics",
+                    context=ctx,
+                    start_ns=speech_end_start_ns,
                     duration_ms=vals["vad_duration_ms"],
-                    attributes={"eou_delay_ms": vals["vad_duration_ms"]},
+                    attributes=_merge_component_attributes(
+                        turn.eou_attributes,
+                        {
+                            "end_of_utterance_delay_ms": vals["vad_duration_ms"],
+                            "transcription_delay_ms": vals["stt_finalization_ms"],
+                            "on_user_turn_completed_delay_ms": vals[
+                                "eou_on_user_turn_completed_ms"
+                            ],
+                        },
+                    ),
                     observation_output=str(vals["vad_duration_ms"]),
                 )
                 stt_end_ns = _emit_component_span(
                     _tracer,
-                    name="stt",
+                    name="STTMetrics",
                     context=ctx,
-                    start_ns=vad_start_ns,
+                    start_ns=speech_end_start_ns,
                     duration_ms=vals["stt_span_duration_ms"],
                     attributes={
+                        **turn.stt_attributes,
                         "user_transcript": turn.user_transcript,
                         "stt_status": turn.stt_status,
                         "stt_processing_ms": vals["stt_processing_ms"],
@@ -533,33 +575,39 @@ class TurnTracer:
                     },
                     observation_output=turn.user_transcript,
                 )
-                cursor_ns = max(cursor_ns, stt_end_ns)
+                cursor_ns = max(cursor_ns, eou_end_ns, stt_end_ns)
                 cursor_ns = _emit_component_span(
                     _tracer,
-                    name="llm",
+                    name="LLMMetrics",
                     context=ctx,
                     start_ns=cursor_ns,
                     duration_ms=vals["llm_duration_ms"],
-                    attributes={
-                        "prompt_text": turn.prompt_text,
-                        "response_text": turn.response_text,
-                        "ttft_ms": vals["llm_ttft_ms"],
-                        "llm_total_latency_ms": vals["llm_total_latency_ms"],
-                    },
+                    attributes=_merge_component_attributes(
+                        turn.llm_attributes,
+                        {
+                            "prompt_text": turn.prompt_text,
+                            "response_text": turn.response_text,
+                            "ttft_ms": vals["llm_ttft_ms"],
+                            "llm_total_latency_ms": vals["llm_total_latency_ms"],
+                        },
+                    ),
                     observation_input=turn.prompt_text,
                     observation_output=turn.response_text,
                 )
                 cursor_ns = _emit_component_span(
                     _tracer,
-                    name="tts",
+                    name="TTSMetrics",
                     context=ctx,
                     start_ns=cursor_ns,
                     duration_ms=vals["tts_duration_ms"],
-                    attributes={
-                        "assistant_text": turn.assistant_text,
-                        "assistant_text_missing": turn.assistant_text_missing,
-                        "ttfb_ms": vals["tts_ttfb_ms"],
-                    },
+                    attributes=_merge_component_attributes(
+                        turn.tts_attributes,
+                        {
+                            "assistant_text": turn.assistant_text,
+                            "assistant_text_missing": turn.assistant_text_missing,
+                            "ttfb_ms": vals["tts_ttfb_ms"],
+                        },
+                    ),
                     observation_input=turn.assistant_text,
                     observation_output=turn.assistant_text,
                 )
@@ -569,12 +617,11 @@ class TurnTracer:
                         _tracer,
                         name="conversation_latency",
                         context=ctx,
-                        start_ns=vad_start_ns,
+                        start_ns=speech_end_start_ns,
                         duration_ms=conv_ms,
                         attributes={
                             "speech_end_to_assistant_speech_start_ms": conv_ms,
                             "eou_delay_ms": vals["vad_duration_ms"],
-                            "stt_finalization_ms": vals["stt_finalization_ms"],
                             "llm_ttft_ms": vals["llm_ttft_ms"],
                             "llm_to_tts_handoff_ms": vals["llm_to_tts_handoff_ms"],
                             "tts_ttfb_ms": vals["tts_ttfb_ms"],
@@ -583,9 +630,8 @@ class TurnTracer:
                     )
                 handoff_ms = vals["llm_to_tts_handoff_ms"]
                 if handoff_ms is not None and handoff_ms > 0:
-                    handoff_start_ns = vad_start_ns + _ms_to_ns(
+                    handoff_start_ns = speech_end_start_ns + _ms_to_ns(
                         max(vals["vad_duration_ms"], 0.0)
-                        + max(vals["stt_finalization_ms"] or 0.0, 0.0)
                         + max(vals["llm_ttft_ms"], 0.0)
                     )
                     _emit_component_span(
@@ -598,7 +644,6 @@ class TurnTracer:
                             "llm_to_tts_handoff_ms": handoff_ms,
                             "speech_end_to_assistant_speech_start_ms": conv_ms,
                             "eou_delay_ms": vals["vad_duration_ms"],
-                            "stt_finalization_ms": vals["stt_finalization_ms"],
                             "llm_ttft_ms": vals["llm_ttft_ms"],
                             "tts_ttfb_ms": vals["tts_ttfb_ms"],
                         },
@@ -662,7 +707,6 @@ def _ms_to_ns(ms: float) -> int:
 def _recompute_conversational_latency(turn: TraceTurn) -> None:
     turn.conversational_latency_ms = _compute_conversational_latency_ms(
         vad_duration_ms=turn.vad_duration_ms,
-        stt_finalization_ms=turn.stt_finalization_ms,
         llm_ttft_ms=turn.llm_ttft_ms,
         tts_ttfb_ms=turn.tts_ttfb_ms,
     )
@@ -671,11 +715,10 @@ def _recompute_conversational_latency(turn: TraceTurn) -> None:
 def _compute_conversational_latency_ms(
     *,
     vad_duration_ms: Optional[float],
-    stt_finalization_ms: Optional[float],
     llm_ttft_ms: Optional[float],
     tts_ttfb_ms: Optional[float],
 ) -> Optional[float]:
-    components = (vad_duration_ms, stt_finalization_ms, llm_ttft_ms, tts_ttfb_ms)
+    components = (vad_duration_ms, llm_ttft_ms, tts_ttfb_ms)
     if any(c is None for c in components):
         return None
     return sum(c for c in components if c is not None)
@@ -685,7 +728,6 @@ def _compute_llm_to_tts_handoff_ms(
     *,
     total_latency_ms: Optional[float],
     vad_duration_ms: Optional[float],
-    stt_finalization_ms: Optional[float],
     llm_ttft_ms: Optional[float],
     tts_ttfb_ms: Optional[float],
 ) -> Optional[float]:
@@ -693,7 +735,6 @@ def _compute_llm_to_tts_handoff_ms(
         return None
     baseline = _compute_conversational_latency_ms(
         vad_duration_ms=vad_duration_ms,
-        stt_finalization_ms=stt_finalization_ms,
         llm_ttft_ms=llm_ttft_ms,
         tts_ttfb_ms=tts_ttfb_ms,
     )
@@ -703,18 +744,14 @@ def _compute_llm_to_tts_handoff_ms(
 
 
 def _total_duration_ms(turn: TraceTurn) -> float:
-    stt = (
-        turn.stt_finalization_ms
-        if turn.stt_finalization_ms is not None
-        else (turn.stt_duration_ms if turn.stt_duration_ms is not None else 0.0)
-    )
     llm = (
         turn.llm_total_latency_ms
         if turn.llm_total_latency_ms is not None
         else (turn.llm_duration_ms or 0.0)
     )
+    handoff = turn.llm_to_tts_handoff_ms or 0.0
     calculated = (
-        (turn.vad_duration_ms or 0.0) + stt + llm + (turn.tts_duration_ms or 0.0)
+        (turn.vad_duration_ms or 0.0) + llm + handoff + (turn.tts_duration_ms or 0.0)
     )
     if turn.conversational_latency_ms is not None:
         calculated = max(calculated, turn.conversational_latency_ms)
@@ -725,6 +762,9 @@ def _prepare_span_values(turn: TraceTurn) -> dict[str, Any]:
     """Pre-compute derived values used by span emission."""
     user_input_duration_ms = 0.0 if turn.user_transcript else None
     vad_duration_ms = max(turn.vad_duration_ms or 0.0, 0.0)
+    vad_metrics_duration_ms = _duration_attribute_to_ms(
+        turn.vad_attributes.get("inference_duration_total")
+    )
     stt_processing_ms = (
         max(turn.stt_duration_ms, 0.0) if turn.stt_duration_ms is not None else None
     )
@@ -739,12 +779,12 @@ def _prepare_span_values(turn: TraceTurn) -> dict[str, Any]:
         else None
     )
     stt_span_duration_ms: Optional[float] = None
-    if stt_total_latency_ms is not None and stt_total_latency_ms > 0:
-        stt_span_duration_ms = stt_total_latency_ms
+    if stt_processing_ms is not None and stt_processing_ms > 0:
+        stt_span_duration_ms = stt_processing_ms
     elif stt_finalization_ms is not None and stt_finalization_ms > 0:
         stt_span_duration_ms = stt_finalization_ms
     else:
-        stt_span_duration_ms = stt_processing_ms
+        stt_span_duration_ms = stt_total_latency_ms
 
     llm_duration_ms = max(turn.llm_duration_ms or 0.0, 0.0)
     llm_ttft_ms = max(turn.llm_ttft_ms or 0.0, 0.0)
@@ -765,13 +805,20 @@ def _prepare_span_values(turn: TraceTurn) -> dict[str, Any]:
         if turn.llm_to_tts_handoff_ms is not None
         else None
     )
+    eou_on_user_turn_completed_ms = (
+        max(turn.eou_on_user_turn_completed_ms, 0.0)
+        if turn.eou_on_user_turn_completed_ms is not None
+        else None
+    )
     return {
         "user_input_duration_ms": user_input_duration_ms,
         "vad_duration_ms": vad_duration_ms,
+        "vad_metrics_duration_ms": vad_metrics_duration_ms,
         "stt_processing_ms": stt_processing_ms,
         "stt_finalization_ms": stt_finalization_ms,
         "stt_total_latency_ms": stt_total_latency_ms,
         "stt_span_duration_ms": stt_span_duration_ms,
+        "eou_on_user_turn_completed_ms": eou_on_user_turn_completed_ms,
         "llm_duration_ms": llm_duration_ms,
         "llm_ttft_ms": llm_ttft_ms,
         "llm_total_latency_ms": llm_total_latency_ms,
@@ -814,6 +861,9 @@ def _set_root_attributes(
         "latency_ms.stt_processing": vals["stt_processing_ms"],
         "latency_ms.stt_finalization": vals["stt_finalization_ms"],
         "latency_ms.stt_total": vals["stt_total_latency_ms"],
+        "latency_ms.eou_on_user_turn_completed": vals[
+            "eou_on_user_turn_completed_ms"
+        ],
         "latency_ms.llm": vals["llm_duration_ms"],
         "latency_ms.llm_ttft": vals["llm_ttft_ms"],
         "latency_ms.llm_total": vals["llm_total_latency_ms"],
@@ -831,6 +881,45 @@ def _set_root_attributes(
             span.set_attribute(key, value)
 
 
+def _sanitize_component_attributes(
+    attributes: Optional[dict[str, Any]],
+) -> dict[str, Any]:
+    if not attributes:
+        return {}
+    sanitized: dict[str, Any] = {}
+    for key, value in attributes.items():
+        if value is None:
+            continue
+        sanitized[key] = _safe_attribute_value(value)
+    return sanitized
+
+
+def _merge_component_attributes(
+    existing: dict[str, Any],
+    extra: dict[str, Any],
+) -> dict[str, Any]:
+    merged = dict(existing)
+    for key, value in extra.items():
+        if value is None:
+            continue
+        merged[key] = _safe_attribute_value(value)
+    return merged
+
+
+def _safe_attribute_value(value: Any) -> Any:
+    if isinstance(value, (str, bool, int, float)):
+        return value
+    if isinstance(value, (list, tuple)):
+        return [_safe_attribute_value(v) for v in value]
+    return str(value)
+
+
+def _duration_attribute_to_ms(value: Any) -> Optional[float]:
+    if isinstance(value, (int, float)):
+        return max(float(value), 0.0) * 1000.0
+    return None
+
+
 def _emit_component_span(
     _tracer: Any,
     *,

src/agent/metrics_collector.py

@@ -29,37 +29,80 @@ from src.core.settings import settings
 class STTMetrics:
     """Speech-to-text metrics."""
 
+    type: str
+    label: str
+    request_id: str
+    timestamp: float
     model_name: str
-    audio_duration: float
     duration: float
+    audio_duration: float
+    streamed: bool
+    metadata: Optional[dict[str, Any]] = None
 
 
 @dataclass
 class LLMMetrics:
     """Language model metrics."""
 
-    ttft: float
+    type: str
+    label: str
+    request_id: str
+    timestamp: float
     duration: float
-    tokens: int
+    ttft: float
+    cancelled: bool
+    completion_tokens: int
+    prompt_tokens: int
+    prompt_cached_tokens: int
+    total_tokens: int
     tokens_per_second: float
+    speech_id: Optional[str] = None
+    metadata: Optional[dict[str, Any]] = None
 
 
 @dataclass
 class TTSMetrics:
     """Text-to-speech metrics."""
 
-    ttfb: float
+    type: str
+    label: str
+    request_id: str
+    timestamp: float
     duration: float
+    ttfb: float
     audio_duration: float
+    cancelled: bool
+    characters_count: int
+    streamed: bool
+    segment_id: Optional[str] = None
+    speech_id: Optional[str] = None
+    metadata: Optional[dict[str, Any]] = None
 
 
 @dataclass
 class VADMetrics:
     """Voice activity detection metrics."""
 
+    type: str
+    label: str
+    timestamp: float
     idle_time: float
     inference_duration_total: float
     inference_count: int
+    metadata: Optional[dict[str, Any]] = None
+
+
+@dataclass
+class EOUMetrics:
+    """End-of-utterance metrics."""
+
+    type: str
+    timestamp: float
+    end_of_utterance_delay: float
+    transcription_delay: float
+    on_user_turn_completed_delay: float
+    speech_id: Optional[str] = None
+    metadata: Optional[dict[str, Any]] = None
 
 
 @dataclass
@@ -84,6 +127,7 @@ class TurnMetrics:
     role: str
     transcript: str = ""
     stt: Optional[STTMetrics] = None
+    eou: Optional[EOUMetrics] = None
     llm: Optional[LLMMetrics] = None
     tts: Optional[TTSMetrics] = None
     vad: Optional[VADMetrics] = None
@@ -97,7 +141,7 @@ class TurnMetrics:
     ) -> None:
         llm_ttft = self.llm.ttft if self.llm else 0.0
         tts_ttfb = self.tts.ttfb if self.tts else 0.0
-        baseline = eou_delay + stt_finalization_delay + llm_ttft + tts_ttfb
+        baseline = eou_delay + llm_ttft + tts_ttfb
         observed = observed_total_latency if observed_total_latency is not None else 0.0
         total = max(baseline, observed)
         self.latencies = Latencies(
@@ -129,6 +173,7 @@ class TurnMetrics:
             "transcript": self.transcript,
             "metrics": {
                 "stt": stt_metrics,
+                "eou": asdict(self.eou) if self.eou else None,
                 "llm": asdict(self.llm) if self.llm else None,
                 "tts": asdict(self.tts) if self.tts else None,
                 "vad": asdict(self.vad) if self.vad else None,
@@ -150,6 +195,7 @@ class TurnState:
     """Per-speech-id state consolidating turn metrics and timing data."""
 
     metrics: Optional[TurnMetrics] = None
+    eou_metrics: Optional[EOUMetrics] = None
     eou_delay: float = 0.0
     stt_finalization_delay: float = 0.0
     speech_end_monotonic: Optional[float] = None
@@ -202,6 +248,8 @@ class MetricsCollector:
         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
         self._llm_stall_timeout_sec = max(
             float(
                 getattr(
@@ -362,7 +410,17 @@ class MetricsCollector:
         speech_id = self._latest_agent_speech_id or f"tts-{uuid.uuid4()}"
         turn_metrics = self._get_or_create_turn(speech_id, role="agent")
         turn_metrics.tts = TTSMetrics(
-            ttfb=ttfb, duration=duration, audio_duration=audio_duration
+            type="tts_metrics",
+            label="tts_fallback",
+            request_id=f"fallback-{speech_id}",
+            timestamp=time(),
+            duration=duration,
+            ttfb=ttfb,
+            audio_duration=audio_duration,
+            cancelled=False,
+            characters_count=0,
+            streamed=True,
+            speech_id=speech_id,
         )
         await self._publish_live_update(speech_id=speech_id, stage="tts", turn_metrics=turn_metrics)
         logger.debug("TTS fallback metrics collected: speech_id=%s, ttfb=%.3fs", speech_id, ttfb)
@@ -373,6 +431,19 @@ class MetricsCollector:
             fallback_duration=audio_duration,
             ttfb=ttfb,
             observed_total_latency=self._observed_total_latency(speech_id),
+            metric_attributes={
+                "type": "tts_metrics",
+                "label": "tts_fallback",
+                "request_id": f"fallback-{speech_id}",
+                "timestamp": time(),
+                "duration": duration,
+                "ttfb": ttfb,
+                "audio_duration": audio_duration,
+                "cancelled": False,
+                "characters_count": 0,
+                "streamed": True,
+                "speech_id": speech_id,
+            },
         )
         await self._tracer.maybe_finalize(trace_turn)
 
@@ -396,9 +467,15 @@ class MetricsCollector:
             if self._pending_transcripts:
                 turn_metrics.transcript = self._pending_transcripts.popleft()
             turn_metrics.stt = STTMetrics(
+                type=collected_metrics.type,
+                label=collected_metrics.label,
+                request_id=collected_metrics.request_id,
+                timestamp=collected_metrics.timestamp,
                 model_name=self._model_name,
-                audio_duration=collected_metrics.audio_duration,
                 duration=collected_metrics.duration,
+                audio_duration=collected_metrics.audio_duration,
+                streamed=collected_metrics.streamed,
+                metadata=_metric_metadata_to_dict(collected_metrics.metadata),
             )
             await self._publish_live_update(speech_id=speech_id, stage="stt", turn_metrics=turn_metrics)
             logger.debug("STT metrics collected: request_id=%s, duration=%.3fs", speech_id, collected_metrics.duration)
@@ -406,6 +483,7 @@ class MetricsCollector:
                 transcript=turn_metrics.transcript,
                 duration=collected_metrics.duration,
                 fallback_duration=collected_metrics.audio_duration,
+                metric_attributes=_stt_metric_attributes(collected_metrics),
             )
 
         elif isinstance(collected_metrics, metrics.LLMMetrics):
@@ -416,29 +494,46 @@ class MetricsCollector:
             if self._pending_agent_transcripts and not turn_metrics.transcript:
                 turn_metrics.transcript = self._pending_agent_transcripts.popleft()
             turn_metrics.llm = LLMMetrics(
-                ttft=collected_metrics.ttft,
+                type=collected_metrics.type,
+                label=collected_metrics.label,
+                request_id=collected_metrics.request_id,
+                timestamp=collected_metrics.timestamp,
                 duration=collected_metrics.duration,
-                tokens=collected_metrics.completion_tokens,
-                tokens_per_second=(
-                    collected_metrics.completion_tokens / collected_metrics.duration
-                    if collected_metrics.duration > 0
-                    else 0.0
-                ),
+                ttft=collected_metrics.ttft,
+                cancelled=collected_metrics.cancelled,
+                completion_tokens=collected_metrics.completion_tokens,
+                prompt_tokens=collected_metrics.prompt_tokens,
+                prompt_cached_tokens=collected_metrics.prompt_cached_tokens,
+                total_tokens=collected_metrics.total_tokens,
+                tokens_per_second=collected_metrics.tokens_per_second,
+                speech_id=collected_metrics.speech_id,
+                metadata=_metric_metadata_to_dict(collected_metrics.metadata),
             )
             await self._publish_live_update(speech_id=speech_id, stage="llm", turn_metrics=turn_metrics)
             logger.debug("LLM metrics collected: speech_id=%s, ttft=%.3fs", speech_id, collected_metrics.ttft)
             trace_turn = await self._tracer.attach_llm(
                 duration=collected_metrics.duration,
                 ttft=collected_metrics.ttft,
+                metric_attributes=_llm_metric_attributes(collected_metrics),
             )
 
         elif isinstance(collected_metrics, metrics.TTSMetrics):
             speech_id = collected_metrics.speech_id or collected_metrics.request_id
             turn_metrics = self._get_or_create_turn(speech_id, role="agent")
             turn_metrics.tts = TTSMetrics(
-                ttfb=collected_metrics.ttfb,
+                type=collected_metrics.type,
+                label=collected_metrics.label,
+                request_id=collected_metrics.request_id,
+                timestamp=collected_metrics.timestamp,
                 duration=collected_metrics.duration,
+                ttfb=collected_metrics.ttfb,
                 audio_duration=collected_metrics.audio_duration,
+                cancelled=collected_metrics.cancelled,
+                characters_count=collected_metrics.characters_count,
+                streamed=collected_metrics.streamed,
+                segment_id=collected_metrics.segment_id,
+                speech_id=collected_metrics.speech_id,
+                metadata=_metric_metadata_to_dict(collected_metrics.metadata),
             )
             await self._publish_live_update(speech_id=speech_id, stage="tts", turn_metrics=turn_metrics)
             logger.debug("TTS metrics collected: speech_id=%s, ttfb=%.3fs", speech_id, collected_metrics.ttfb)
@@ -447,6 +542,7 @@ class MetricsCollector:
                 fallback_duration=collected_metrics.audio_duration,
                 ttfb=collected_metrics.ttfb,
                 observed_total_latency=self._observed_total_latency(speech_id),
+                metric_attributes=_tts_metric_attributes(collected_metrics),
             )
 
         elif isinstance(collected_metrics, metrics.EOUMetrics):
@@ -457,39 +553,57 @@ class MetricsCollector:
                     state.speech_end_monotonic = monotonic()
                 state.eou_delay = collected_metrics.end_of_utterance_delay
                 state.stt_finalization_delay = collected_metrics.transcription_delay
+                state.eou_metrics = EOUMetrics(
+                    type=collected_metrics.type,
+                    timestamp=collected_metrics.timestamp,
+                    end_of_utterance_delay=collected_metrics.end_of_utterance_delay,
+                    transcription_delay=collected_metrics.transcription_delay,
+                    on_user_turn_completed_delay=collected_metrics.on_user_turn_completed_delay,
+                    speech_id=collected_metrics.speech_id,
+                    metadata=_metric_metadata_to_dict(collected_metrics.metadata),
+                )
                 turn_metrics = state.metrics
+                if turn_metrics:
+                    turn_metrics.eou = state.eou_metrics
+                    if self._latest_vad_metrics and turn_metrics.vad is None:
+                        turn_metrics.vad = self._latest_vad_metrics
                 await self._publish_live_update(
                     speech_id=speech_id,
                     stage="eou",
                     turn_metrics=turn_metrics,
                 )
                 logger.debug("EOU metrics collected: speech_id=%s, delay=%.3fs", speech_id, collected_metrics.end_of_utterance_delay)
-                trace_turn = await self._tracer.attach_vad(
+                trace_turn = await self._tracer.attach_eou(
                     duration=collected_metrics.end_of_utterance_delay,
                     transcription_delay=collected_metrics.transcription_delay,
+                    on_user_turn_completed_delay=collected_metrics.on_user_turn_completed_delay,
+                    metric_attributes=_eou_metric_attributes(collected_metrics),
+                    vad_metric_attributes=self._latest_vad_metric_attributes,
                 )
 
         elif isinstance(collected_metrics, metrics.VADMetrics):
             speech_id = getattr(collected_metrics, "speech_id", None)
+            self._latest_vad_metrics = VADMetrics(
+                type=collected_metrics.type,
+                label=collected_metrics.label,
+                timestamp=collected_metrics.timestamp,
+                idle_time=collected_metrics.idle_time,
+                inference_duration_total=collected_metrics.inference_duration_total,
+                inference_count=collected_metrics.inference_count,
+                metadata=_metric_metadata_to_dict(collected_metrics.metadata),
+            )
+            self._latest_vad_metric_attributes = _vad_metric_attributes(collected_metrics)
             if speech_id:
                 state = self._turns.get(speech_id)
                 turn_metrics = state.metrics if state else None
             if speech_id and turn_metrics:
-                turn_metrics.vad = VADMetrics(
-                    idle_time=collected_metrics.idle_time,
-                    inference_duration_total=collected_metrics.inference_duration_total,
-                    inference_count=collected_metrics.inference_count,
-                )
+                turn_metrics.vad = self._latest_vad_metrics
             await self._publisher.publish_live_update(
                 speech_id=speech_id,
                 stage="vad",
                 role=turn_metrics.role if turn_metrics else None,
                 turn_metrics=turn_metrics,
-                vad_metrics=VADMetrics(
-                    idle_time=collected_metrics.idle_time,
-                    inference_duration_total=collected_metrics.inference_duration_total,
-                    inference_count=collected_metrics.inference_count,
-                ),
+                vad_metrics=self._latest_vad_metrics,
                 diagnostic=not bool(speech_id and turn_metrics),
                 eou_delay=self._turns[speech_id].eou_delay if speech_id and speech_id in self._turns else 0.0,
                 stt_finalization_delay=self._turns[speech_id].stt_finalization_delay if speech_id and speech_id in self._turns else 0.0,
@@ -741,3 +855,127 @@ def _extract_text_from_chat_items(chat_items: Any) -> str:
         if text.strip():
             parts.append(text.strip())
     return parts[-1] if parts else ""
+
+
+def _metric_metadata_to_dict(metadata: Any) -> Optional[dict[str, Any]]:
+    if metadata is None:
+        return None
+    if hasattr(metadata, "model_dump"):
+        dumped = metadata.model_dump(exclude_none=True)
+        if isinstance(dumped, dict):
+            return dumped
+        return {"value": dumped}
+    if isinstance(metadata, dict):
+        return metadata
+    return {"value": str(metadata)}
+
+
+def _metadata_attributes(metadata: Any) -> dict[str, Any]:
+    data = _metric_metadata_to_dict(metadata)
+    if not data:
+        return {}
+    return _flatten_attributes(data, prefix="metadata")
+
+
+def _flatten_attributes(
+    data: dict[str, Any], *, prefix: str = ""
+) -> dict[str, Any]:
+    flattened: dict[str, Any] = {}
+    for key, value in data.items():
+        full_key = f"{prefix}.{key}" if prefix else str(key)
+        if value is None:
+            continue
+        if isinstance(value, dict):
+            flattened.update(_flatten_attributes(value, prefix=full_key))
+            continue
+        if isinstance(value, (list, tuple)):
+            serialized = [_safe_attr_value(v) for v in value]
+            flattened[full_key] = serialized
+            continue
+        flattened[full_key] = _safe_attr_value(value)
+    return flattened
+
+
+def _safe_attr_value(value: Any) -> Any:
+    if isinstance(value, (str, bool, int, float)):
+        return value
+    return str(value)
+
+
+def _stt_metric_attributes(collected_metrics: metrics.STTMetrics) -> dict[str, Any]:
+    attrs = {
+        "type": collected_metrics.type,
+        "label": collected_metrics.label,
+        "request_id": collected_metrics.request_id,
+        "timestamp": collected_metrics.timestamp,
+        "duration": collected_metrics.duration,
+        "audio_duration": collected_metrics.audio_duration,
+        "streamed": collected_metrics.streamed,
+    }
+    attrs.update(_metadata_attributes(collected_metrics.metadata))
+    return attrs
+
+
+def _eou_metric_attributes(collected_metrics: metrics.EOUMetrics) -> dict[str, Any]:
+    attrs = {
+        "type": collected_metrics.type,
+        "timestamp": collected_metrics.timestamp,
+        "end_of_utterance_delay": collected_metrics.end_of_utterance_delay,
+        "transcription_delay": collected_metrics.transcription_delay,
+        "on_user_turn_completed_delay": collected_metrics.on_user_turn_completed_delay,
+        "speech_id": collected_metrics.speech_id,
+    }
+    attrs.update(_metadata_attributes(collected_metrics.metadata))
+    return attrs
+
+
+def _vad_metric_attributes(collected_metrics: metrics.VADMetrics) -> dict[str, Any]:
+    attrs = {
+        "type": collected_metrics.type,
+        "label": collected_metrics.label,
+        "timestamp": collected_metrics.timestamp,
+        "idle_time": collected_metrics.idle_time,
+        "inference_duration_total": collected_metrics.inference_duration_total,
+        "inference_count": collected_metrics.inference_count,
+    }
+    attrs.update(_metadata_attributes(collected_metrics.metadata))
+    return attrs
+
+
+def _llm_metric_attributes(collected_metrics: metrics.LLMMetrics) -> dict[str, Any]:
+    attrs = {
+        "type": collected_metrics.type,
+        "label": collected_metrics.label,
+        "request_id": collected_metrics.request_id,
+        "timestamp": collected_metrics.timestamp,
+        "duration": collected_metrics.duration,
+        "ttft": collected_metrics.ttft,
+        "cancelled": collected_metrics.cancelled,
+        "completion_tokens": collected_metrics.completion_tokens,
+        "prompt_tokens": collected_metrics.prompt_tokens,
+        "prompt_cached_tokens": collected_metrics.prompt_cached_tokens,
+        "total_tokens": collected_metrics.total_tokens,
+        "tokens_per_second": collected_metrics.tokens_per_second,
+        "speech_id": collected_metrics.speech_id,
+    }
+    attrs.update(_metadata_attributes(collected_metrics.metadata))
+    return attrs
+
+
+def _tts_metric_attributes(collected_metrics: metrics.TTSMetrics) -> dict[str, Any]:
+    attrs = {
+        "type": collected_metrics.type,
+        "label": collected_metrics.label,
+        "request_id": collected_metrics.request_id,
+        "timestamp": collected_metrics.timestamp,
+        "ttfb": collected_metrics.ttfb,
+        "duration": collected_metrics.duration,
+        "audio_duration": collected_metrics.audio_duration,
+        "cancelled": collected_metrics.cancelled,
+        "characters_count": collected_metrics.characters_count,
+        "streamed": collected_metrics.streamed,
+        "segment_id": collected_metrics.segment_id,
+        "speech_id": collected_metrics.speech_id,
+    }
+    attrs.update(_metadata_attributes(collected_metrics.metadata))
+    return attrs

src/ui/index.html

@@ -666,7 +666,7 @@
                 <span>End-to-End Latency</span>
                 <div class="tooltip tooltip-right">
                   <button type="button" class="tooltip-trigger" aria-label="What is End-to-End Latency?">i</button>
-                  <span class="tooltip-content" role="tooltip">Full response latency from end of user speech to first assistant audio, including EOU detection, STT finalization, LLM TTFT, and TTS startup.</span>
+                  <span class="tooltip-content" role="tooltip">Full response latency from end of user speech to first assistant audio: EOU delay (inclusive of transcription delay), LLM TTFT, model-to-TTS handoff, and TTS startup.</span>
                 </div>
               </div>
             </div>

src/ui/main.js

@@ -730,7 +730,6 @@ function updateLiveMetrics(turn) {
 
   const hasAllStages = (
     isFiniteNumber(liveTurnValues.eouDelay) &&
-    isFiniteNumber(liveTurnValues.sttFinalizationDelay) &&
     isFiniteNumber(liveTurnValues.llmTtft) &&
     isFiniteNumber(liveTurnValues.llmToTtsHandoff) &&
     isFiniteNumber(liveTurnValues.ttsTtfb)
@@ -739,7 +738,6 @@ function updateLiveMetrics(turn) {
   if (hasAllStages) {
     const computedTotal =
       liveTurnValues.eouDelay +
-      liveTurnValues.sttFinalizationDelay +
       liveTurnValues.llmTtft +
       liveTurnValues.llmToTtsHandoff +
       liveTurnValues.ttsTtfb;

tests/test_langfuse_turn_tracing.py

@@ -290,9 +290,27 @@ def test_turn_trace_has_required_metadata_and_spans(monkeypatch: pytest.MonkeyPa
     asyncio.run(_run())
 
     span_names = [span.name for span in fake_tracer.spans]
-    assert span_names == ["turn", "user_input", "vad", "stt", "llm", "tts", "conversation_latency"]
+    assert span_names == [
+        "turn",
+        "user_input",
+        "VADMetrics",
+        "EOUMetrics",
+        "STTMetrics",
+        "LLMMetrics",
+        "TTSMetrics",
+        "conversation_latency",
+    ]
 
-    root, user_input_span, vad_span, stt_span, llm_span, tts_span, conversational_span = fake_tracer.spans
+    (
+        root,
+        user_input_span,
+        vad_span,
+        eou_span,
+        stt_span,
+        llm_span,
+        tts_span,
+        conversational_span,
+    ) = fake_tracer.spans
     assert root.attributes["session_id"] == "session-abc"
     assert root.attributes["room_id"] == "RM123"
     assert root.attributes["participant_id"] == "web-123"
@@ -304,15 +322,23 @@ def test_turn_trace_has_required_metadata_and_spans(monkeypatch: pytest.MonkeyPa
     assert root.attributes["latency_ms.llm_ttft"] > 0
     assert root.attributes["latency_ms.llm_total"] > 0
     assert root.attributes["latency_ms.tts_ttfb"] > 0
-    assert root.attributes["latency_ms.conversational"] == pytest.approx(1600.0)
-    assert root.attributes["latency_ms.speech_end_to_assistant_speech_start"] == pytest.approx(1600.0)
+    assert root.attributes["latency_ms.conversational"] == pytest.approx(1350.0)
+    assert root.attributes["latency_ms.speech_end_to_assistant_speech_start"] == pytest.approx(1350.0)
 
     assert user_input_span.attributes["user_transcript"] == "hello there"
-    assert vad_span.attributes["duration_ms"] == pytest.approx(1100.0)
+    assert vad_span.attributes["eou_delay_ms"] == pytest.approx(1100.0)
+
+    assert eou_span.attributes["duration_ms"] == pytest.approx(1100.0)
+    assert eou_span.attributes["end_of_utterance_delay"] == pytest.approx(1.1)
+    assert eou_span.attributes["transcription_delay"] == pytest.approx(0.25)
+    assert eou_span.attributes["on_user_turn_completed_delay"] == pytest.approx(0.0)
+    assert eou_span.attributes["speech_id"] == "speech-1"
 
     assert stt_span.attributes["user_transcript"] == "hello there"
     assert stt_span.attributes["stt_status"] == "measured"
-    assert stt_span.attributes["duration_ms"] == pytest.approx(1350.0)
+    assert stt_span.attributes["duration_ms"] == pytest.approx(200.0)
+    assert stt_span.attributes["request_id"] == "stt-1"
+    assert stt_span.attributes["streamed"] is True
     assert stt_span.attributes["stt_finalization_ms"] == pytest.approx(250.0)
     assert stt_span.attributes["stt_total_latency_ms"] == pytest.approx(1350.0)
 
@@ -323,20 +349,23 @@ def test_turn_trace_has_required_metadata_and_spans(monkeypatch: pytest.MonkeyPa
     assert llm_span.attributes["input"] == "hello there"
     assert llm_span.attributes["output"] == "hi, how can I help?"
     assert llm_span.attributes["duration_ms"] > 0
+    assert llm_span.attributes["prompt_tokens"] == 12
+    assert llm_span.attributes["completion_tokens"] == 24
 
     assert tts_span.attributes["assistant_text"] == "hi, how can I help?"
     assert tts_span.attributes["ttfb_ms"] > 0
     assert tts_span.attributes["input"] == "hi, how can I help?"
     assert tts_span.attributes["output"] == "hi, how can I help?"
     assert tts_span.attributes["duration_ms"] > 0
+    assert tts_span.attributes["characters_count"] == 42
+    assert tts_span.attributes["streamed"] is True
 
-    assert conversational_span.attributes["duration_ms"] == pytest.approx(1600.0)
+    assert conversational_span.attributes["duration_ms"] == pytest.approx(1350.0)
     assert (
         conversational_span.attributes["speech_end_to_assistant_speech_start_ms"]
-        == pytest.approx(1600.0)
+        == pytest.approx(1350.0)
     )
     assert conversational_span.attributes["eou_delay_ms"] == pytest.approx(1100.0)
-    assert conversational_span.attributes["stt_finalization_ms"] == pytest.approx(250.0)
     assert conversational_span.attributes["llm_ttft_ms"] > 0
     assert conversational_span.attributes["tts_ttfb_ms"] > 0
     assert all(span.end_count == 1 for span in fake_tracer.spans)
@@ -474,8 +503,16 @@ def test_trace_emits_without_stt_metrics(monkeypatch: pytest.MonkeyPatch) -> Non
     asyncio.run(_run())
 
     span_names = [span.name for span in fake_tracer.spans]
-    assert span_names == ["turn", "user_input", "vad", "stt", "llm", "tts"]
-    stt_span = fake_tracer.spans[3]
+    assert span_names == [
+        "turn",
+        "user_input",
+        "VADMetrics",
+        "EOUMetrics",
+        "STTMetrics",
+        "LLMMetrics",
+        "TTSMetrics",
+    ]
+    stt_span = fake_tracer.spans[4]
     assert stt_span.attributes["user_transcript"] == "turn without stt metrics"
     assert stt_span.attributes["stt_status"] == "missing"
     assert "duration_ms" not in stt_span.attributes
@@ -715,7 +752,7 @@ def test_long_response_latency_accounts_for_llm_to_tts_handoff(
         await collector.on_speech_created(_FakeSpeechHandle(chat_items=[], speech_id=speech_id))
         await collector.on_user_input_transcribed("Explain neural networks", is_final=True)
         await collector.on_metrics_collected(
-            _make_eou_metrics(speech_id, delay=0.0, transcription_delay=0.0)
+            _make_eou_metrics(speech_id, delay=0.0, transcription_delay=0.2)
         )
         await collector.on_metrics_collected(
             _make_llm_metrics(speech_id, duration=2.0, ttft=0.01)
@@ -741,12 +778,12 @@ def test_long_response_latency_accounts_for_llm_to_tts_handoff(
     assert root.attributes["latency_ms.llm_to_tts_handoff"] > 150.0
     assert root.attributes["latency_ms.conversational"] == pytest.approx(
         root.attributes["latency_ms.eou_delay"]
-        + root.attributes["latency_ms.stt_finalization"]
         + root.attributes["latency_ms.llm_ttft"]
         + root.attributes["latency_ms.llm_to_tts_handoff"]
         + root.attributes["latency_ms.tts_ttfb"],
         abs=5.0,
     )
+    assert root.attributes["latency_ms.stt_finalization"] == pytest.approx(200.0)
 
     gap_spans = [span for span in fake_tracer.spans if span.name == "llm_to_tts_handoff"]
     assert len(gap_spans) == 1