@kuralle-syrinx/core 4.1.0 → 4.3.0

package/src/index.ts

@@ -30,8 +30,10 @@ export {
   type VadSpeechActivityPacket,
   type SpeechToTextAudioPacket,
   type SttInterimPacket,
+  type SttPartialPacket,
   type SttResultPacket,
   type FinalizeSttPacket,
+  type SttReconfigurePacket,
   type SttErrorPacket,
   type EndOfSpeechAudioPacket,
   type EndOfSpeechPacket,
@@ -49,6 +51,16 @@ export {
   type TurnChangePacket,
 } from "./packets.js";
 
+// Telephony control packets (DTMF / transfer)
+export {
+  type DtmfDigit,
+  type DtmfReceivedPacket,
+  type DtmfSendPacket,
+  type CallTransferMode,
+  type CallTransferPacket,
+} from "./packets.js";
+export { parseDtmfDigit, dtmfReceived, dtmfSend, callTransfer } from "./packet-factories.js";
+
 // Pipeline packets — LLM
 export {
   type LlmDeltaPacket,
@@ -78,6 +90,18 @@ export {
   type ReasonerSessionStore,
 } from "./reasoner-session-store.js";
 
+// Incremental-Unit ledger (IU substrate — dormant until C2)
+export {
+  type IuState,
+  type IncrementalUnitId,
+  type IncrementalUnit,
+} from "./incremental-unit.js";
+export {
+  type IuLedger,
+  type IuLedgerAnomaly,
+  InMemoryIuLedger,
+} from "./iu-ledger.js";
+
 // Pipeline packets — TTS
 export {
   type TextToSpeechTextPacket,
@@ -113,16 +137,41 @@ export {
 export {
   type MessageCreatePacket,
   type ConversationMetricPacket,
+  type AcousticSignalPacket,
+  type AcousticSignal,
+  type TurnLocalizationPacket,
+  type UsageStage,
+  type UsageRecordedPacket,
   type TurnBoundaryKind,
   type TurnBoundaryEventPacket,
   type ObservabilityPacket,
   type PipelineErrorPacket,
 } from "./packets.js";
 
+// Metering: price catalog + spend-cap guard (standalone; session wires later)
+export {
+  type SttPrice,
+  type LlmPrice,
+  type TtsPrice,
+  type PriceCatalog,
+  type CostResult,
+  DEFAULT_PRICE_CATALOG,
+  costOf,
+} from "./pricing.js";
+export {
+  SpendCapGuard,
+  type SpendCapConfig,
+  type SpendCapCheck,
+} from "./spend-cap.js";
+
 // Observability backbone (VE-07)
 export {
   monotonicNowMs,
   type MetricTags,
+  type ObservabilityLayer,
+  type TurnLocalizationVerdict,
+  type TurnLocalizationSignals,
+  localizeTurn,
   type SpanHandle,
   type MetricsExporter,
   noopMetricsExporter,
@@ -149,6 +198,8 @@ export {
   type PluginConfig,
   type EndpointingOwner,
   type EndpointingCapability,
+  type SttReconfigure,
+  type SttReconfigurePartial,
   requireStringConfig,
   optionalStringConfig,
 } from "./plugin-contract.js";
@@ -187,8 +238,42 @@ export {
   type SyrinxAudioEnvelopeHeader,
 } from "./audio-envelope.js";
 
+export {
+  StreamingPcm16Resampler,
+  createLoudnessState,
+  normalizeLoudness,
+  type LoudnessConfig,
+  type LoudnessState,
+} from "./audio/index.js";
+
+// Interaction policy seam (IP-C1)
+export {
+  type InteractionPolicy,
+  type LifecycleInteractionPolicy,
+  isLifecycleInteractionPolicy,
+  type InteractionObservation,
+  type InteractionDecision,
+  type AcousticSignalObservation,
+  type AcousticSignalSink,
+  type WordTiming,
+} from "./interaction-policy.js";
+export { confidenceToWaitMs, type ConfidenceToWaitConfig } from "./confidence-to-wait.js";
+export { RuleBasedInteractionPolicy } from "./policies/rule-based.js";
+export { DeferInteractionPolicy } from "./policies/defer.js";
+export { InteractionCoordinator, type InteractionCaps } from "./interaction-coordinator.js";
+export {
+  type InteractionBackchannelPacket,
+  type InteractionDuckPacket,
+  type InteractionResumePacket,
+} from "./packets.js";
+
 // VoiceAgentSession
-export { VoiceAgentSession, type VoiceAgentSessionConfig, type VoiceAgentSessionEvents } from "./voice-agent-session.js";
+export {
+  VoiceAgentSession,
+  type VoiceAgentSessionConfig,
+  type VoiceAgentSessionEvents,
+  type SessionStageUsage,
+} from "./voice-agent-session.js";
 
 // Primary-speaker barge-in gate (VE-02)
 export {
@@ -196,6 +281,7 @@ export {
   extractSpeakerFingerprint,
   fingerprintSimilarity,
   type SpeakerFingerprint,
+  type PrimarySpeakerGateDecision,
   type PrimarySpeakerGateConfig,
 } from "./primary-speaker-gate.js";
 export {
@@ -221,10 +307,24 @@ export {
   type LatencyFillerFixture,
 } from "./latency-filler-fixtures.js";
 
+// Voice text: markdown/formatting normalization + leaked-tool-call guard before TTS
+export { normalizeForSpeech, stripLeakedToolCalls } from "./voice-text.js";
+
 // Reasoner seam (RFC §4.2)
 export {
   type Reasoner,
   type ReasonerTurn,
   type ReasonerMessage,
+  type ReasonerUsage,
   type ReasoningPart,
 } from "./reasoner.js";
+
+// Hedged reasoner (Lever C — reasoner-latency RFC)
+export { HedgedReasoner, type HedgedReasonerOptions } from "./reasoner-hedge.js";
+
+// Routing reasoner (Lever B — reasoner-latency RFC)
+export {
+  RoutingReasoner,
+  type RoutingReasonerOptions,
+  type ReasonerRoute,
+} from "./reasoner-route.js";

package/src/interaction-coordinator.ts

@@ -0,0 +1,240 @@
+// SPDX-License-Identifier: MIT
+
+import type { VadAudioPacket } from "./packets.js";
+import type { SttInterimPacket, SttResultPacket } from "./packets.js";
+import { Route } from "./pipeline-bus.js";
+import type { PipelineBus } from "./pipeline-bus.js";
+import { confidenceToWaitMs } from "./confidence-to-wait.js";
+import type { InteractionDecision, InteractionObservation, InteractionPolicy } from "./interaction-policy.js";
+import type { TurnArbiter } from "./turn-arbiter.js";
+import { RuleBasedInteractionPolicy } from "./policies/rule-based.js";
+import { TimerScheduler, type Scheduler } from "./scheduler.js";
+import * as make from "./packet-factories.js";
+
+export interface InteractionCaps {
+  readonly emitsBackchannel?: boolean;
+}
+
+interface PendingTakeTurn {
+  confidence: number;
+  waitMs?: number;
+  transcripts: SttResultPacket[];
+  latestInterim: string;
+  finalizeRequested: boolean;
+}
+
+export class InteractionCoordinator {
+  private readonly disposers: Array<() => void> = [];
+  private readonly pendingTakeTurns = new Map<string, PendingTakeTurn>();
+  private readonly transcriptsByContext = new Map<string, SttResultPacket[]>();
+  private readonly interimByContext = new Map<string, string>();
+  private readonly scheduler: Scheduler;
+
+  constructor(
+    private readonly deps: {
+      bus: PipelineBus;
+      policy: InteractionPolicy;
+      executor: TurnArbiter;
+      caps: InteractionCaps;
+      scheduler?: Scheduler;
+      isUserSpeaking?: () => boolean;
+      isTtsActive?: () => boolean;
+      hasCueAsset?: (cueId: string) => boolean;
+      onBackchannelEmitted?: (contextId: string) => void;
+    },
+  ) {
+    this.scheduler = deps.scheduler ?? new TimerScheduler();
+  }
+
+  initialize(): void {
+    const { bus } = this.deps;
+    this.disposers.push(
+      bus.on("stt.result", (pkt) => {
+        this.handleSttResult(pkt as SttResultPacket);
+      }),
+      bus.on("stt.interim", (pkt) => {
+        this.handleSttInterim(pkt as SttInterimPacket);
+      }),
+      bus.on("vad.speech_started", (pkt) => {
+        this.revokePendingTakeTurn((pkt as { contextId: string }).contextId);
+      }),
+    );
+  }
+
+  dispose(): void {
+    for (const contextId of this.pendingTakeTurns.keys()) {
+      this.revokePendingTakeTurn(contextId);
+    }
+    for (const dispose of this.disposers.splice(0)) {
+      dispose();
+    }
+    this.transcriptsByContext.clear();
+    this.interimByContext.clear();
+  }
+
+  observe(obs: InteractionObservation): void {
+    for (const d of this.deps.policy.observe(obs)) {
+      this.apply(d, obs);
+    }
+  }
+
+  observeBargeInAudio(pkt: VadAudioPacket): boolean {
+    this.observe({
+      kind: "vad_barge_in_audio",
+      contextId: pkt.contextId,
+      timestampMs: pkt.timestampMs,
+      audio: pkt.audio,
+    });
+    if (this.deps.policy instanceof RuleBasedInteractionPolicy) {
+      return this.deps.policy.takeBargeInAudioConsumed();
+    }
+    return this.deps.executor.observeBargeInAudio(pkt);
+  }
+
+  private apply(d: InteractionDecision, obs: InteractionObservation): void {
+    switch (d.kind) {
+      case "take_turn":
+        this.armTakeTurn(obs.contextId, d.confidence, d.waitMs, obs.timestampMs);
+        break;
+      case "hold":
+      case "keep_listening":
+        this.revokePendingTakeTurn(obs.contextId);
+        break;
+      case "interrupt":
+        this.deps.executor.emitInterruptDetected(d.interruptedContextId);
+        break;
+      case "backchannel":
+        this.applyBackchannel(d, obs);
+        break;
+      default:
+        break;
+    }
+  }
+
+  private armTakeTurn(contextId: string, confidence: number, waitMs: number | undefined, timestampMs: number): void {
+    const existing = this.pendingTakeTurns.get(contextId);
+    const pending: PendingTakeTurn = existing ?? {
+      confidence,
+      transcripts: [...(this.transcriptsByContext.get(contextId) ?? [])],
+      latestInterim: this.interimByContext.get(contextId) ?? "",
+      finalizeRequested: false,
+    };
+    pending.confidence = confidence;
+    pending.waitMs = waitMs;
+    this.pendingTakeTurns.set(contextId, pending);
+
+    if (!pending.finalizeRequested) {
+      pending.finalizeRequested = true;
+      this.deps.bus.push(Route.Critical, make.finalizeStt(contextId, timestampMs));
+    }
+    this.tryScheduleTurnComplete(contextId);
+  }
+
+  private handleSttInterim(pkt: SttInterimPacket): void {
+    const text = pkt.text.trim();
+    if (!text) return;
+    this.interimByContext.set(pkt.contextId, text);
+    const pending = this.pendingTakeTurns.get(pkt.contextId);
+    if (pending) pending.latestInterim = text;
+  }
+
+  private handleSttResult(pkt: SttResultPacket): void {
+    const text = pkt.text.trim();
+    if (!text) return;
+    const transcripts = this.transcriptsByContext.get(pkt.contextId) ?? [];
+    if (transcripts.at(-1)?.text.trim() !== text) {
+      transcripts.push(pkt);
+      this.transcriptsByContext.set(pkt.contextId, transcripts);
+    }
+    this.interimByContext.delete(pkt.contextId);
+
+    const pending = this.pendingTakeTurns.get(pkt.contextId);
+    if (!pending) return;
+    pending.transcripts = [...transcripts];
+    pending.latestInterim = "";
+    this.tryScheduleTurnComplete(pkt.contextId);
+  }
+
+  private tryScheduleTurnComplete(contextId: string): void {
+    const pending = this.pendingTakeTurns.get(contextId);
+    if (!pending) return;
+
+    // Anchor the finalize timer at the policy's commitment even before any text
+    // exists — the callback reads live transcript/interim state at fire time and
+    // is the sole gate on whether the turn actually completes.
+    const delayMs = pending.waitMs ?? confidenceToWaitMs(pending.confidence);
+    const timerKey = takeTurnTimerKey(contextId);
+    this.scheduler.cancel(timerKey);
+    this.scheduler.schedule(timerKey, delayMs, () => {
+      const live = this.pendingTakeTurns.get(contextId);
+      if (!live) return;
+
+      const finalText = joinTranscript(live.transcripts, live.latestInterim);
+      // The policy committed to this turn. Prefer real STT finals; if none ever
+      // arrived, fall back to the latest interim so a committed turn is never
+      // silently dropped. Only bail when there is genuinely nothing to commit.
+      if (!finalText) return;
+
+      this.pendingTakeTurns.delete(contextId);
+      const transcripts: SttResultPacket[] =
+        live.transcripts.length > 0
+          ? live.transcripts
+          : [{ kind: "stt.result", contextId, timestampMs: Date.now(), text: finalText, confidence: 0 }];
+      this.deps.bus.push(Route.Main, make.eosTurnComplete(contextId, Date.now(), finalText, transcripts));
+    });
+  }
+
+  private revokePendingTakeTurn(contextId: string): void {
+    if (!this.pendingTakeTurns.has(contextId)) return;
+    this.scheduler.cancel(takeTurnTimerKey(contextId));
+    this.pendingTakeTurns.delete(contextId);
+  }
+
+  private applyBackchannel(
+    d: Extract<InteractionDecision, { kind: "backchannel" }>,
+    obs: InteractionObservation,
+  ): void {
+    const contextId = obs.contextId;
+    this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.candidate", d.cue));
+
+    if (this.deps.caps.emitsBackchannel) {
+      this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.suppressed_caps", d.cue));
+      return;
+    }
+    if (this.deps.isTtsActive?.()) {
+      this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.suppressed_tts_active", d.cue));
+      return;
+    }
+    if (this.deps.isUserSpeaking?.()) {
+      this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.suppressed_user_speaking", d.cue));
+      return;
+    }
+    if (this.deps.hasCueAsset && !this.deps.hasCueAsset(d.cue)) {
+      this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.suppressed_missing_asset", d.cue));
+      return;
+    }
+
+    this.deps.bus.push(Route.Main, make.interactionBackchannel(contextId, Date.now(), d.cue));
+    this.deps.bus.push(Route.Background, make.metric(contextId, "backchannel.emitted", d.cue));
+    this.deps.onBackchannelEmitted?.(contextId);
+  }
+
+  reset(contextId: string): void {
+    this.revokePendingTakeTurn(contextId);
+    this.transcriptsByContext.delete(contextId);
+    this.interimByContext.delete(contextId);
+    this.deps.policy.reset(contextId);
+  }
+}
+
+function takeTurnTimerKey(contextId: string): string {
+  return `interaction.take_turn:${contextId}`;
+}
+
+function joinTranscript(transcripts: readonly SttResultPacket[], interim: string): string {
+  const segments = [
+    ...transcripts.map((t) => t.text.trim()),
+    ...(interim ? [interim.trim()] : []),
+  ].filter(Boolean);
+  return segments.join(" ").replace(/\s+/g, " ").trim();
+}

package/src/interaction-policy.ts

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+
+import type { AcousticSignal } from "./packets.js";
+
+export interface WordTiming {
+  readonly word: string;
+  readonly startMs: number;
+  readonly endMs: number;
+  readonly confidence: number;
+}
+
+export type InteractionObservation =
+  | {
+      readonly kind: "vad_speech_started";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly confidence: number;
+      readonly interruptedContextId?: string;
+    }
+  | {
+      readonly kind: "vad_speech_activity";
+      readonly contextId: string;
+      readonly timestampMs: number;
+    }
+  | {
+      readonly kind: "vad_speech_ended";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly hasActiveTts: boolean;
+    }
+  | {
+      readonly kind: "vad_barge_in_audio";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly audio: Uint8Array;
+    }
+  | {
+      readonly kind: "stt_partial";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly text: string;
+      readonly confidence?: number;
+      readonly interruptedContextId?: string;
+      readonly wordTimings?: readonly WordTiming[];
+    }
+  | {
+      readonly kind: "stt_final";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly text: string;
+      readonly confidence?: number;
+      readonly interruptedContextId?: string;
+      readonly wordTimings?: readonly WordTiming[];
+    }
+  | {
+      readonly kind: "audio_frame";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly audio?: Int16Array;
+      readonly sampleRateHz?: number;
+      readonly wordTimings?: readonly WordTiming[];
+      readonly prosody?: Float32Array;
+    }
+  | {
+      readonly kind: "playout_tick";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly playedOutMs?: number;
+      readonly ttsActive?: boolean;
+      /** PCM queued for assistant playout. Present on audio-bearing ticks. */
+      readonly audio?: Int16Array;
+      readonly sampleRateHz?: number;
+    }
+  | {
+      readonly kind: "delegate_state";
+      readonly contextId: string;
+      readonly timestampMs: number;
+      readonly delegateInFlight?: boolean;
+      readonly toolCallPhase?: "started" | "delayed" | "complete" | "failed";
+    };
+
+export type InteractionDecision =
+  | { readonly kind: "keep_listening" }
+  | { readonly kind: "take_turn"; readonly confidence: number; readonly waitMs?: number }
+  /** `cue` is a stable pre-cached asset id (e.g. `mm_hmm`), not free-form text. */
+  | { readonly kind: "backchannel"; readonly cue: string }
+  | { readonly kind: "hold" }
+  | { readonly kind: "interrupt"; readonly interruptedContextId: string };
+
+export interface AcousticSignalObservation {
+  readonly contextId: string;
+  readonly timestampMs: number;
+  readonly signal: AcousticSignal;
+  readonly payload?: Readonly<Record<string, unknown>>;
+}
+
+export type AcousticSignalSink = (signal: AcousticSignalObservation) => void;
+
+export interface InteractionPolicy {
+  observe(obs: InteractionObservation): readonly InteractionDecision[];
+  reset(contextId: string): void;
+  setAcousticSignalSink?(sink: AcousticSignalSink): void;
+}
+
+/** Optional lifecycle for externally supplied model policies (session-owned). */
+export interface LifecycleInteractionPolicy extends InteractionPolicy {
+  initialize(config: Record<string, unknown>): Promise<void>;
+  close(): Promise<void>;
+}
+
+export function isLifecycleInteractionPolicy(
+  policy: InteractionPolicy,
+): policy is LifecycleInteractionPolicy {
+  const candidate = policy as LifecycleInteractionPolicy;
+  return typeof candidate.initialize === "function" && typeof candidate.close === "function";
+}

package/src/iu-ledger.ts

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: MIT
+//
+// Syrinx Kernel v2 — Incremental-Unit ledger (IU substrate, RFC incremental-unit-substrate)
+
+import type { IncrementalUnit, IncrementalUnitId, IuState } from "./incremental-unit.js";
+
+export interface IuLedger {
+  add(iu: IncrementalUnit): void;
+  commit(id: IncrementalUnitId, prefix?: { chars?: number; ms?: number }): void;
+  revoke(id: IncrementalUnitId): void;
+  get(id: IncrementalUnitId): IncrementalUnit | undefined;
+  latest(contextId: string, kind: IncrementalUnit["kind"]): IncrementalUnit | undefined;
+  clear(contextId: string): void;
+}
+
+export type IuLedgerAnomaly =
+  | { readonly kind: "terminal_op"; readonly op: "commit" | "revoke"; readonly id: IncrementalUnitId; readonly state: IuState }
+  | { readonly kind: "unknown_iu"; readonly op: "commit" | "revoke"; readonly id: IncrementalUnitId };
+
+export class InMemoryIuLedger implements IuLedger {
+  private readonly byCtx = new Map<string, Map<string, IncrementalUnit>>();
+
+  constructor(
+    private readonly onEvent: (a: IuLedgerAnomaly) => void = () => {},
+    private readonly maxContexts: number = 256,
+  ) {}
+
+  add(iu: IncrementalUnit): void {
+    const ctx = iu.id.contextId;
+    if (!this.byCtx.has(ctx) && this.byCtx.size >= this.maxContexts) {
+      const oldest = this.byCtx.keys().next().value;
+      if (oldest !== undefined) this.byCtx.delete(oldest);
+    }
+    this.ctxMap(ctx).set(iu.id.iuId, iu);
+  }
+
+  commit(id: IncrementalUnitId, prefix?: { chars?: number; ms?: number }): void {
+    const ctxMap = this.byCtx.get(id.contextId);
+    if (!ctxMap) {
+      this.onEvent({ kind: "unknown_iu", op: "commit", id });
+      return;
+    }
+    const iu = ctxMap.get(id.iuId);
+    if (!iu) {
+      this.onEvent({ kind: "unknown_iu", op: "commit", id });
+      return;
+    }
+    if (iu.state !== "hypothesized") {
+      this.onEvent({ kind: "terminal_op", op: "commit", id, state: iu.state });
+      return;
+    }
+    iu.state = "committed";
+    if (prefix) {
+      iu.committedPrefix = prefix;
+    }
+  }
+
+  revoke(id: IncrementalUnitId): void {
+    const ctxMap = this.byCtx.get(id.contextId);
+    if (!ctxMap) {
+      this.onEvent({ kind: "unknown_iu", op: "revoke", id });
+      return;
+    }
+    const iu = ctxMap.get(id.iuId);
+    if (!iu) {
+      this.onEvent({ kind: "unknown_iu", op: "revoke", id });
+      return;
+    }
+    if (iu.state !== "hypothesized") {
+      this.onEvent({ kind: "terminal_op", op: "revoke", id, state: iu.state });
+      return;
+    }
+    iu.state = "revoked";
+  }
+
+  get(id: IncrementalUnitId): IncrementalUnit | undefined {
+    const ctxMap = this.byCtx.get(id.contextId);
+    if (!ctxMap) {
+      return undefined;
+    }
+    return ctxMap.get(id.iuId);
+  }
+
+  latest(contextId: string, kind: IncrementalUnit["kind"]): IncrementalUnit | undefined {
+    const ctxMap = this.byCtx.get(contextId);
+    if (!ctxMap) {
+      return undefined;
+    }
+    let found: IncrementalUnit | undefined;
+    for (const iu of ctxMap.values()) {
+      if (iu.kind === kind) {
+        found = iu;
+      }
+    }
+    return found;
+  }
+
+  clear(contextId: string): void {
+    this.byCtx.delete(contextId);
+  }
+
+  private ctxMap(contextId: string): Map<string, IncrementalUnit> {
+    let map = this.byCtx.get(contextId);
+    if (!map) {
+      map = new Map();
+      this.byCtx.set(contextId, map);
+    }
+    return map;
+  }
+}

package/src/observability-observer.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT
 
 import { Route, type PipelineBus } from "./pipeline-bus.js";
-import { monotonicNowMs, type MetricsExporter } from "./observability.js";
+import { monotonicNowMs, type MetricsExporter, type ObservabilityLayer } from "./observability.js";
 import type {
   TurnBoundaryKind,
   VadSpeechStartedPacket,
@@ -17,6 +17,7 @@ export interface ObservabilityDims {
   readonly provider: string;
   readonly model: string;
   readonly region: string;
+  readonly layer?: ObservabilityLayer;
 }
 
 export interface ObservabilityObserverDeps {
@@ -124,12 +125,11 @@ export class ObservabilityObserver {
 
     const dims = this.dimsFor(speechId, cancelled);
     const tags = {
-      sessionId: this.deps.sessionId,
-      speechId,
       provider: dims.provider,
       model: dims.model,
       region: dims.region,
       cancelled: dims.cancelled ? "true" : "false",
+      layer: dims.layer ?? "conversation",
     };
 
     if (boundary === "agent_started_speaking") {
@@ -179,12 +179,16 @@ export class ObservabilityObserver {
     });
   }
 
-  private dimsFor(speechId: string, cancelled: boolean): Required<ObservabilityDims> & { cancelled: boolean } {
+  private dimsFor(
+    speechId: string,
+    cancelled: boolean,
+  ): Required<ObservabilityDims> & { cancelled: boolean } {
     const stage = this.stageDims.get(speechId) ?? {};
     return {
       provider: stage.provider ?? this.deps.dims.provider,
       model: stage.model ?? this.deps.dims.model,
       region: stage.region ?? this.deps.dims.region,
+      layer: stage.layer ?? this.deps.dims.layer ?? "conversation",
       cancelled: cancelled || stage.cancelled === true,
     };
   }