feat(D-G6/D-G7/D-G9): settings delta + TTS context seam + usage metrics

D-G6 — sparse mid-call settings delta (Pipecat ServiceSettings parity):
- SttSettingsDelta {model/language/encoding/sample_rate/punctuation/extra}
  (None = not in delta) + merge_into returning the CHANGED-field set (a
  field equal to the current value is not a change — no spurious
  reconnects).
- BaseSTT::apply_settings_delta — merge + reconnect decision standardized
  in the base: reconnect ONLY when a connection-relevant field
  (model/language/encoding/sample_rate) changed; non-connection knobs store
  via set_config_only without touching the transport. extra overflow rides
  opaque and is never connection-relevant.
Pins: merge-only-given + changed-set, equal-value no-op, non-connection 0
reconnects, connection field exactly 1 reconnect, extra roundtrip.

D-G7 — standardized TTS audio-context seam:
- BaseTTS::on_audio_context_interrupted (default delegates to clear(); WS
  context-aware providers can override to cancel the specific server-side
  context) + on_audio_context_completed (default no-op) — all 36 providers
  express the hook through the base, zero changes to speak() sites.
- The barge-in path (VoiceManager::clear_tts) now calls the seam.
Pins: default-interrupted ≡ clear() behavior, completed default no-op.

D-G9 — provider usage metrics:
- waav_tts_chars_total{provider} bumped at the VoiceManager speak choke
  point (covers every provider).
- waav_llm_tokens_total{provider,kind} for prompt/completion/cache_read/
  cache_creation/reasoning — kinds emitted ONLY when the wire usage object
  carried them (details objects parsed); exported at both response sites
  (sync + streaming) with a stable AdapterKind::as_str label.
Pins: chars accumulate by text length; kinds split; unreported kinds absent.

Floor: 6101/0 lib (all features) + default-features check + clippy clean.
Live: Deepgram Aura TTS 4 voices green (speak path with chars counter).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: jithinAB

gateway/src/core/llm/adapter.rs

@@ -46,6 +46,17 @@ pub enum AdapterKind {
     Gemini,
 }
 
+impl AdapterKind {
+    /// Stable label for metrics (`provider` tag — no per-call alloc).
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::OpenAi => "openai",
+            Self::Anthropic => "anthropic",
+            Self::Gemini => "gemini",
+        }
+    }
+}
+
 /// A fully rendered HTTP request: vendor endpoint + auth headers + JSON body.
 #[derive(Debug, Clone)]
 pub struct RenderedRequest {

gateway/src/core/llm/mod.rs

@@ -404,6 +404,28 @@ pub struct Usage {
 // Client configuration + per-session history
 // =============================================================================
 
+/// D-G9: export wire-reported token usage as counters. Kinds beyond
+/// prompt/completion come from the details objects (cached_tokens,
+/// reasoning_tokens) and are emitted ONLY when the wire carried them.
+fn export_usage_metrics(provider: &str, usage: &Usage) {
+    use crate::core::metrics::bridge::count_llm_tokens;
+    count_llm_tokens(provider, "prompt", usage.prompt_tokens as u64);
+    count_llm_tokens(provider, "completion", usage.completion_tokens as u64);
+    if let Some(d) = &usage.prompt_tokens_details {
+        if let Some(n) = d.get("cached_tokens").and_then(|v| v.as_u64()) {
+            count_llm_tokens(provider, "cache_read", n);
+        }
+        if let Some(n) = d.get("cache_creation_tokens").and_then(|v| v.as_u64()) {
+            count_llm_tokens(provider, "cache_creation", n);
+        }
+    }
+    if let Some(d) = &usage.completion_tokens_details
+        && let Some(n) = d.get("reasoning_tokens").and_then(|v| v.as_u64())
+    {
+        count_llm_tokens(provider, "reasoning", n);
+    }
+}
+
 /// LLM client configuration. Field-compatible with the former
 /// `LlmEndpointConfig` so the DAG node can keep deserializing the same JSON.
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -882,7 +904,12 @@ impl LlmClient {
             content: parsed.message.content.clone().unwrap_or_default(),
             finish_reason: parsed.finish_reason,
             tool_calls: parsed.message.tool_calls.clone().unwrap_or_default(),
-            usage: parsed.usage,
+            usage: {
+                if let Some(u) = &parsed.usage {
+                    export_usage_metrics(self.adapter.kind().as_str(), u);
+                }
+                parsed.usage
+            },
         })
     }
 
@@ -971,7 +998,12 @@ impl LlmClient {
             content: parsed.message.content.clone().unwrap_or_default(),
             finish_reason: parsed.finish_reason,
             tool_calls: parsed.message.tool_calls.clone().unwrap_or_default(),
-            usage: parsed.usage,
+            usage: {
+                if let Some(u) = &parsed.usage {
+                    export_usage_metrics(self.adapter.kind().as_str(), u);
+                }
+                parsed.usage
+            },
         })
     }
 

gateway/src/core/metrics/bridge.rs

@@ -47,6 +47,14 @@ pub const CIRCUIT_BREAKER_STATE: &str = "waav_circuit_breaker_state";
 /// `circuit_open`=breaker rejected the attempt). Makes the reconnect path observable (W-C1).
 pub const RECONNECTS_TOTAL: &str = "waav_reconnects_total";
 
+/// D-G9: characters submitted to TTS synthesis, per provider (cost proxy).
+pub const TTS_CHARS_TOTAL: &str = "waav_tts_chars_total";
+
+/// D-G9: LLM token usage by kind, per provider
+/// (`kind` ∈ prompt|completion|cache_read|cache_creation|reasoning —
+/// a kind is emitted only when the wire usage object carries it).
+pub const LLM_TOKENS_TOTAL: &str = "waav_llm_tokens_total";
+
 // -----------------------------------------------------------------------------
 // Live latency-profiling series (per-turn + per-frame realtime budget).
 // `path` ∈ {conversation,dag}; `stage`/`outcome`/`queue` are fixed enums; `node`
@@ -276,6 +284,14 @@ fn describe_series() {
         "TTS time-to-first-byte (turn perspective) by path"
     );
     metrics::describe_counter!(TURNS_TOTAL, "Total turns by path and outcome");
+    metrics::describe_counter!(
+        TTS_CHARS_TOTAL,
+        "Characters submitted to TTS synthesis, per provider (D-G9)"
+    );
+    metrics::describe_counter!(
+        LLM_TOKENS_TOTAL,
+        "LLM token usage by kind (prompt/completion/cache_read/cache_creation/reasoning), per provider (D-G9)"
+    );
     metrics::describe_counter!(
         TURN_BOTTLENECK_TOTAL,
         "Dominant-stage tally for completed turns"
@@ -345,6 +361,21 @@ pub fn set_circuit_breaker_state(provider: &str, state_code: u8) {
 /// Record a reconnect attempt outcome on `waav_reconnects_total`. `outcome` is one of
 /// `success` / `failure` / `exhausted` / `circuit_open`. Emitted from the streaming reconnect
 /// path so reconnects are observable (W-C1).
+/// D-G9: count TTS characters (call with `text.len()` at submit time).
+pub fn count_tts_chars(provider: &str, chars: usize) {
+    counter!(TTS_CHARS_TOTAL, "provider" => provider.to_string()).increment(chars as u64);
+}
+
+/// D-G9: count LLM tokens of one kind (emit only kinds the wire reported).
+pub fn count_llm_tokens(provider: &str, kind: &'static str, tokens: u64) {
+    counter!(
+        LLM_TOKENS_TOTAL,
+        "provider" => provider.to_string(),
+        "kind" => kind,
+    )
+    .increment(tokens);
+}
+
 pub fn record_reconnect(provider: &str, outcome: &str) {
     counter!(
         RECONNECTS_TOTAL,
@@ -478,6 +509,38 @@ mod tests {
         );
     }
 
+    /// D-G9: TTS chars accumulate by text length; LLM tokens split by kind
+    /// and only wire-reported kinds appear.
+    #[test]
+    fn dg9_usage_series_render() {
+        let _ = metrics_handle();
+        count_tts_chars("unit-tts", 27);
+        count_tts_chars("unit-tts", 13);
+        count_llm_tokens("unit-llm", "prompt", 100);
+        count_llm_tokens("unit-llm", "completion", 40);
+        count_llm_tokens("unit-llm", "reasoning", 7);
+
+        let text = render();
+        let chars_line = text
+            .lines()
+            .find(|l| l.starts_with(TTS_CHARS_TOTAL) && l.contains("unit-tts"))
+            .expect("tts chars series present");
+        assert!(chars_line.ends_with(" 40"), "27+13 chars: {chars_line}");
+        assert!(
+            text.lines().any(|l| l.contains(LLM_TOKENS_TOTAL)
+                && l.contains("unit-llm")
+                && l.contains("kind=\"reasoning\"")
+                && l.ends_with(" 7")),
+            "reasoning kind present with its count"
+        );
+        assert!(
+            !text.lines().any(|l| l.contains(LLM_TOKENS_TOTAL)
+                && l.contains("unit-llm")
+                && l.contains("kind=\"cache_read\"")),
+            "kinds the wire never reported must not appear"
+        );
+    }
+
     #[test]
     fn profiling_series_render() {
         let _ = metrics_handle();