@vellumai/assistant 0.12.3-staging.1 → 0.12.3-staging.2

package/src/live-voice/live-voice-tts.ts

@@ -148,6 +148,23 @@ export async function streamLiveVoiceTtsAudio(
   // a trailing odd byte is carried into the next chunk to keep frames aligned.
   const pcmAligner = createPcmChunkAligner(2);
 
+  // Send the first available samples immediately, then frame PCM in 100ms
+  // blocks. Provider read sizes must not determine websocket queue pressure.
+  const frameBytes = Math.max(2, Math.floor(sampleRate / 10) * 2);
+  let pendingPcm: Buffer = Buffer.alloc(0);
+  const emitPcm = (audio: Buffer, flush = false): void => {
+    pendingPcm =
+      pendingPcm.length > 0 ? Buffer.concat([pendingPcm, audio]) : audio;
+    while (
+      pendingPcm.length >= frameBytes ||
+      (pendingPcm.length > 0 && (chunks === 0 || flush))
+    ) {
+      const length = Math.min(frameBytes, pendingPcm.length);
+      emitAudioFrame(chunkContentType, pendingPcm.subarray(0, length));
+      pendingPcm = pendingPcm.subarray(length);
+    }
+  };
+
   try {
     const result = await synthesizeAndEmit({
       provider,
@@ -160,16 +177,17 @@ export async function streamLiveVoiceTtsAudio(
       signal: options.signal,
       onChunk: (chunk) => {
         if (canStreamChunks) {
-          emitAudioFrame(
-            chunk.contentType || chunkContentType,
-            pcmAligner.align(chunk.audio),
-          );
+          emitPcm(pcmAligner.align(chunk.audio));
         } else {
           bufferedAudio.push(chunk.audio);
         }
       },
     });
 
+    if (canStreamChunks && !result.stopped && !options.signal?.aborted) {
+      emitPcm(Buffer.alloc(0), true);
+    }
+
     // A dangling final byte is malformed provider output — drop it rather
     // than emit a torn sample.
     if (pcmAligner.carryLength() > 0) {

package/src/live-voice/microphone-idle-gate.ts

@@ -0,0 +1,56 @@
+import { Buffer } from "node:buffer";
+
+const IDLE_TIMEOUT_MS = 1_000;
+const PRE_ROLL_MS = 200;
+
+/** Gates PCM16 mono room audio while preserving the provider's audio clock. */
+export class MicrophoneIdleGate {
+  private readonly tailBytes: number;
+  private readonly preRollBytes: number;
+  private quietBytes = 0;
+  private pending: Buffer = Buffer.alloc(0);
+
+  constructor(sampleRate: number) {
+    this.tailBytes = Math.round((sampleRate * IDLE_TIMEOUT_MS) / 1_000) * 2;
+    this.preRollBytes = Math.round((sampleRate * PRE_ROLL_MS) / 1_000) * 2;
+  }
+
+  get closed(): boolean {
+    return this.quietBytes >= this.tailBytes;
+  }
+
+  process(chunk: Buffer, hasSpeech: boolean): Buffer {
+    if (hasSpeech) {
+      this.quietBytes = 0;
+      const pending = this.pending;
+      this.pending = Buffer.alloc(0);
+      return pending.byteLength > 0 ? Buffer.concat([pending, chunk]) : chunk;
+    }
+
+    const passBytes = Math.min(
+      chunk.byteLength,
+      this.tailBytes - this.quietBytes,
+    );
+    this.quietBytes = Math.min(
+      this.tailBytes,
+      this.quietBytes + chunk.byteLength,
+    );
+    if (passBytes === chunk.byteLength) {
+      return chunk;
+    }
+
+    // Hold only the newest onset audio. Older samples become silence before
+    // submission, so reopening never replays an already-sent time interval.
+    const buffered = Buffer.concat([this.pending, chunk.subarray(passBytes)]);
+    const silenceBytes = Math.max(0, buffered.byteLength - this.preRollBytes);
+    this.pending = Buffer.from(buffered.subarray(silenceBytes));
+    const output = Buffer.alloc(passBytes + silenceBytes);
+    chunk.copy(output, 0, 0, passBytes);
+    return output;
+  }
+
+  reset(): void {
+    this.quietBytes = 0;
+    this.pending = Buffer.alloc(0);
+  }
+}

package/src/live-voice/protocol.ts

@@ -1,3 +1,4 @@
+import type { VoiceEscalationProfileSource } from "../calls/voice-escalation-target.js";
 import { type ClientOs, parseClientOs } from "../channels/types.js";
 
 const LIVE_VOICE_CLIENT_FRAME_TYPES = [
@@ -9,6 +10,8 @@ const LIVE_VOICE_CLIENT_FRAME_TYPES = [
   "update_config",
   "attach_image",
   "attach_frame",
+  "sight_start",
+  "sight_end",
   "sight_frame",
   "text",
 ] as const;
@@ -67,6 +70,20 @@ type LiveVoiceParseResult<T> =
   | { ok: true; frame: T }
   | { ok: false; error: LiveVoiceProtocolError };
 
+type LiveVoiceParseFailure = Extract<
+  LiveVoiceParseResult<never>,
+  { ok: false }
+>;
+
+function liveVoiceParseFailure(
+  code: LiveVoiceProtocolErrorCode,
+  message: string,
+  field: string,
+  frameType: string,
+): LiveVoiceParseFailure {
+  return { ok: false, error: { code, message, field, frameType } };
+}
+
 export interface LiveVoiceAudioConfig {
   readonly mimeType: "audio/pcm";
   readonly sampleRate: number;
@@ -363,6 +380,8 @@ export interface LiveVoiceClientAttachFrameFrame {
 export interface LiveVoiceClientSightFrameFrame {
   readonly type: "sight_frame";
   readonly attachmentId: string;
+  readonly cameraEpoch?: number;
+  readonly source?: LiveVoiceSightSource;
   /**
    * How long the client's half of the frame took, for the daemon's log. The
    * daemon adds its own half and the distance from the speech onset it
@@ -372,6 +391,19 @@ export interface LiveVoiceClientSightFrameFrame {
   readonly timing?: LiveVoiceSightFrameTiming;
 }
 
+export type LiveVoiceSightSource = "live" | "ambient";
+
+export interface LiveVoiceClientSightStartFrame {
+  readonly type: "sight_start";
+  readonly cameraEpoch: number;
+  readonly source?: LiveVoiceSightSource;
+}
+
+export interface LiveVoiceClientSightEndFrame {
+  readonly type: "sight_end";
+  readonly cameraEpoch: number;
+}
+
 /**
  * The client leg of one kept frame, as durations between its own marks.
  *
@@ -451,6 +483,8 @@ export type LiveVoiceClientFrame =
   | LiveVoiceClientUpdateConfigFrame
   | LiveVoiceClientAttachImageFrame
   | LiveVoiceClientAttachFrameFrame
+  | LiveVoiceClientSightStartFrame
+  | LiveVoiceClientSightEndFrame
   | LiveVoiceClientSightFrameFrame
   | LiveVoiceClientTextTurnFrame;
 
@@ -481,6 +515,8 @@ export interface LiveVoiceReadyServerFrame extends LiveVoiceServerFrameBase {
    * every typed turn with an `unknown_type` error.
    */
   readonly textInput?: boolean;
+  /** Whether this session accepts camera lifecycle epochs. */
+  readonly sightSessions?: boolean;
   /**
    * Whether the session's speech-to-text leg is live. Absent means yes, which
    * is the only thing an older daemon can have meant: it rejects a session it
@@ -575,8 +611,9 @@ export interface LiveVoiceThinkingServerFrame extends LiveVoiceServerFrameBase {
  * the room) can otherwise only say "Thinking...". The label is composed here
  * rather than by each surface for the same reason phase wording is composed
  * once: the Live Activity has two independent drivers (this socket and an APNs
- * push the daemon dispatches), they must carry identical content, and the only
- * way to guarantee that is for both to be handed the same string.
+ * push the daemon dispatches), they must carry compatible content. Structured
+ * kinds let in-conversation surfaces use localized copy while system-level
+ * surfaces can suppress internal detail.
  *
  * An empty `label` means "no current activity", which is what a turn's end
  * sends. Emitted only on change, never per tool result.
@@ -585,6 +622,12 @@ export interface LiveVoiceActivityServerFrame extends LiveVoiceServerFrameBase {
   readonly type: "activity";
   readonly turnId: string;
   readonly label: string;
+  /** Structured reason for the activity, when a client needs custom display. */
+  readonly kind?: "escalation";
+  /** Selected inference profile for diagnostics, never default UI copy. */
+  readonly profile?: string;
+  /** Why the selected profile won for this leg. */
+  readonly profileSource?: VoiceEscalationProfileSource;
   /**
    * The confirmation this turn is blocked on, when the label describes a wait
    * rather than work in flight. Absent otherwise.
@@ -896,6 +939,10 @@ export function validateLiveVoiceClientFrame(
       return validateAttachImageFrame(value);
     case "attach_frame":
       return validateAttachFrameFrame(value);
+    case "sight_start":
+      return validateSightStartFrame(value);
+    case "sight_end":
+      return validateSightEndFrame(value);
     case "sight_frame":
       return validateSightFrameFrame(value);
     case "text":
@@ -1044,10 +1091,19 @@ function validateSightFrameFrame(
     );
   }
 
+  const lifecycle = validateOptionalSightLifecycle(value, "sight_frame");
+  if (!lifecycle.ok) {
+    return lifecycle;
+  }
+
   if (!("timing" in value) || value.timing === undefined) {
     return {
       ok: true,
-      frame: { type: "sight_frame", attachmentId: value.attachmentId },
+      frame: {
+        type: "sight_frame",
+        attachmentId: value.attachmentId,
+        ...lifecycle.fields,
+      },
     };
   }
 
@@ -1063,10 +1119,121 @@ function validateSightFrameFrame(
 
   return {
     ok: true,
-    frame: { type: "sight_frame", attachmentId: value.attachmentId, timing },
+    frame: {
+      type: "sight_frame",
+      attachmentId: value.attachmentId,
+      ...lifecycle.fields,
+      timing,
+    },
+  };
+}
+
+function validateSightStartFrame(
+  value: Record<string, unknown>,
+): LiveVoiceParseResult<LiveVoiceClientSightStartFrame> {
+  const lifecycle = validateRequiredSightLifecycle(value, "sight_start");
+  if (!lifecycle.ok) {
+    return lifecycle;
+  }
+  return {
+    ok: true,
+    frame: { type: "sight_start", ...lifecycle.fields },
+  };
+}
+
+function validateSightEndFrame(
+  value: Record<string, unknown>,
+): LiveVoiceParseResult<LiveVoiceClientSightEndFrame> {
+  if (!isPositiveSafeInteger(value.cameraEpoch)) {
+    return protocolError(
+      "invalid_field",
+      "sight_end frame field cameraEpoch must be a positive safe integer",
+      "cameraEpoch",
+      "sight_end",
+    );
+  }
+  return {
+    ok: true,
+    frame: { type: "sight_end", cameraEpoch: value.cameraEpoch },
   };
 }
 
+function validateRequiredSightLifecycle(
+  value: Record<string, unknown>,
+  frameType: "sight_start",
+):
+  | { ok: true; fields: { cameraEpoch: number; source?: LiveVoiceSightSource } }
+  | LiveVoiceParseFailure {
+  if (!isPositiveSafeInteger(value.cameraEpoch)) {
+    return liveVoiceParseFailure(
+      "invalid_field",
+      `${frameType} frame field cameraEpoch must be a positive safe integer`,
+      "cameraEpoch",
+      frameType,
+    );
+  }
+  if (value.source !== undefined && !isLiveVoiceSightSource(value.source)) {
+    return liveVoiceParseFailure(
+      "invalid_field",
+      `${frameType} frame field source must be live or ambient`,
+      "source",
+      frameType,
+    );
+  }
+  return {
+    ok: true,
+    fields: {
+      cameraEpoch: value.cameraEpoch,
+      ...(value.source ? { source: value.source } : {}),
+    },
+  };
+}
+
+function validateOptionalSightLifecycle(
+  value: Record<string, unknown>,
+  frameType: "sight_frame",
+):
+  | {
+      ok: true;
+      fields: { cameraEpoch?: number; source?: LiveVoiceSightSource };
+    }
+  | LiveVoiceParseFailure {
+  if (value.cameraEpoch === undefined && value.source === undefined) {
+    return { ok: true, fields: {} };
+  }
+  if (!isPositiveSafeInteger(value.cameraEpoch)) {
+    return liveVoiceParseFailure(
+      "invalid_field",
+      `${frameType} frame field cameraEpoch must be a positive safe integer when lifecycle fields are present`,
+      "cameraEpoch",
+      frameType,
+    );
+  }
+  if (value.source !== undefined && !isLiveVoiceSightSource(value.source)) {
+    return liveVoiceParseFailure(
+      "invalid_field",
+      `${frameType} frame field source must be live or ambient`,
+      "source",
+      frameType,
+    );
+  }
+  return {
+    ok: true,
+    fields: {
+      cameraEpoch: value.cameraEpoch,
+      ...(value.source ? { source: value.source } : {}),
+    },
+  };
+}
+
+function isPositiveSafeInteger(value: unknown): value is number {
+  return Number.isSafeInteger(value) && typeof value === "number" && value > 0;
+}
+
+function isLiveVoiceSightSource(value: unknown): value is LiveVoiceSightSource {
+  return value === "live" || value === "ambient";
+}
+
 /**
  * Parse a `sight_frame`'s `timing`. Null for anything off-shape: a timing is
  * for the log, so nothing about it is coerced, but a malformed one still

package/src/live-voice/session-controls.ts

@@ -44,7 +44,7 @@ const CLIENT_CONTROL_LINES: Record<LiveVoiceSessionControl, string> = {
 const LOOK_FRAME_CONTROL_LINES: Partial<
   Record<LiveVoiceSessionControl, string>
 > = {
-  look_screen: `- To look at their screen (for example "take a look at my screen", or "can you see it now?" after something on it changed), say in a few words that you are taking a look, then end your reply with ${LOOK_SCREEN_MARKER}. Use it even when their screen is already shared with you, to see it as it is now. You get a fresh view right after you finish speaking and answer from that, so do not describe the screen yet and do not ask them to say anything more.`,
+  look_screen: `- To look at their screen (for example "take a look at my screen", or "can you see it now?" after something on it changed), say in a few words that you are taking a look, then end your reply with ${LOOK_SCREEN_MARKER}. Use it even when their screen is already shared with you, to see it as it is now. You get a fresh view right after you finish speaking, so do not describe the screen yet or ask them to say anything more. This only obtains a view; showing them where to click still needs screen annotation after the view arrives.`,
   look_camera: `- To look through their camera (for example "look at this" or "can you see this?" while they hold something up), say in a few words that you are taking a look, then end your reply with ${LOOK_CAMERA_MARKER}. Use it even when the camera is already on, to see what it shows now. You get a fresh view right after you finish speaking and answer from that, so do not describe it yet and do not ask them to say anything more.`,
 };
 
@@ -61,6 +61,11 @@ export type LookSessionControl = Extract<
   "look_screen" | "look_camera"
 >;
 
+export interface LookFollowUp {
+  action: LookSessionControl;
+  callerUtterance: string;
+}
+
 export function isLookSessionControl(
   action: string,
 ): action is LookSessionControl {
@@ -78,9 +83,12 @@ export const LOOK_FOLLOW_UP_CONTENT = "(fresh view taken; answer from it now)";
  * Appended to the control prompt of the turn that answers a look: the reply
  * that asked for it only acknowledged, and the frame it asked for has landed.
  */
-export function lookFollowUpNote(action: LookSessionControl): string {
+export function lookFollowUpNote({
+  action,
+  callerUtterance,
+}: LookFollowUp): string {
   const what = action === "look_screen" ? "their screen" : "their camera";
-  return `You just took a fresh look at ${what}, and the newest image in the conversation is what it shows right now. Answer what they wanted you to look at, out loud, in a few spoken sentences. If the image does not show what they meant, say briefly what you do see and ask. You have already said you were taking a look, so do not say it again and do not end with a look marker.`;
+  return `You just took a fresh look at ${what}, and the newest image in the conversation is what it shows right now. Resume the caller's request ${JSON.stringify(callerUtterance)} using that view and the latest conversation context. Complete any requested action, not just a spoken description.${action === "look_screen" ? " Showing or pointing out where to click needs the screen-annotation tools." : ""} If the request needs tools and this leg has none, escalate. Otherwise answer in a few spoken sentences. If the image does not show what they meant, say briefly what you do see and ask. You have already said you were taking a look, so do not say it again and do not end with a look marker.`;
 }
 
 // Always taught: narration is the session's own, so no client has to be able

package/src/live-voice/task-outcomes.ts

@@ -0,0 +1,131 @@
+import type { SubagentParentNotification } from "../subagent/parent-notification.js";
+
+export interface VoiceTaskOutcome extends SubagentParentNotification {
+  source: "subagent" | "continuation";
+}
+
+interface Delivery {
+  outcome: VoiceTaskOutcome | null;
+  interrupted: boolean;
+  lastPlayedReply: string | null;
+}
+
+/** Session-local delivery receipts. Generated text and context exposure are not receipts. */
+export class VoiceTaskOutcomes {
+  private readonly deliveries = new Map<string, Delivery>();
+  private playback: {
+    outcomes: readonly VoiceTaskOutcome[];
+    announcement: boolean;
+    reply: string;
+    untilMs: number;
+  } | null = null;
+
+  get hasPending(): boolean {
+    return this.next() !== undefined;
+  }
+
+  enqueue(outcome: VoiceTaskOutcome): void {
+    const previous = this.deliveries.get(outcome.taskId);
+    this.deliveries.set(outcome.taskId, {
+      outcome,
+      interrupted: previous?.interrupted ?? false,
+      lastPlayedReply: previous?.lastPlayedReply ?? null,
+    });
+  }
+
+  next(): VoiceTaskOutcome | undefined {
+    for (const delivery of this.deliveries.values()) {
+      if (delivery.outcome !== null) {
+        return delivery.outcome;
+      }
+    }
+    return undefined;
+  }
+
+  pendingOutcomes(): VoiceTaskOutcome[] {
+    return [...this.deliveries.values()].flatMap(({ outcome }) =>
+      outcome === null ? [] : [outcome],
+    );
+  }
+
+  deliveryContext(outcome: VoiceTaskOutcome): string {
+    const delivery = this.deliveries.get(outcome.taskId);
+    const status = delivery?.interrupted
+      ? "An earlier attempt to deliver this task's findings was interrupted before playback completed. Resume the useful unheard findings briefly."
+      : "This update is still pending delivery.";
+    const heard = delivery?.lastPlayedReply;
+    return `${status} Generated assistant text in conversation history is not evidence that the user heard it. ${heard ? `The latest reply with completed audio playback for this task was: ${JSON.stringify(heard)}. Use that receipt to avoid repeating findings actually heard.` : "There is no completed audio playback receipt for this task."}`;
+  }
+
+  finish(outcome: VoiceTaskOutcome, playbackUntilMs: number, reply = ""): void {
+    this.playback = {
+      outcomes: [outcome],
+      announcement: true,
+      reply,
+      untilMs: playbackUntilMs,
+    };
+  }
+
+  finishContextReply(
+    outcomes: readonly VoiceTaskOutcome[],
+    playbackUntilMs: number,
+    reply: string,
+  ): void {
+    if (outcomes.length > 0) {
+      this.playback = {
+        outcomes,
+        announcement: false,
+        reply,
+        untilMs: playbackUntilMs,
+      };
+    }
+  }
+
+  acknowledgePlayback(now: number): void {
+    const playback = this.playback;
+    if (playback === null || now < playback.untilMs) {
+      return;
+    }
+    for (const outcome of playback.outcomes) {
+      const delivery = this.deliveries.get(outcome.taskId);
+      if (delivery === undefined) {
+        continue;
+      }
+      if (playback.reply.length > 0) {
+        delivery.lastPlayedReply = playback.reply;
+      }
+      if (playback.announcement) {
+        delivery.interrupted = false;
+      }
+      if (playback.announcement && delivery.outcome === outcome) {
+        delivery.outcome = null;
+      }
+    }
+    this.playback = null;
+  }
+
+  interrupt(outcome: VoiceTaskOutcome): void {
+    const delivery = this.deliveries.get(outcome.taskId);
+    if (delivery?.outcome != null) {
+      delivery.interrupted = true;
+    }
+  }
+
+  interruptPlayback(now: number): void {
+    this.acknowledgePlayback(now);
+    if (this.playback?.announcement) {
+      for (const outcome of this.playback.outcomes) {
+        this.interrupt(outcome);
+      }
+    }
+    this.playback = null;
+  }
+
+  drain(now: number): VoiceTaskOutcome[] {
+    this.acknowledgePlayback(now);
+    const outcomes = this.pendingOutcomes();
+    this.deliveries.clear();
+    this.playback = null;
+    return outcomes;
+  }
+}

package/src/live-voice/voice-input-diagnostics.ts

@@ -0,0 +1,117 @@
+export interface VoiceInputSample {
+  receivedAtMs: number;
+  chunkMs: number;
+  meanAmplitude: number;
+  baseThreshold: number;
+  roomNoiseFloor: number | null;
+  echoEnergy: number;
+  echoOnsetLapsed: boolean;
+  echoWindowMs: number;
+  echoGuardCarryover: boolean;
+  echoReferenceMs: number;
+  echoProbeMs: number;
+  echoCorrelation: number | null;
+  playbackRemainingMs: number;
+  playbackEchoPossible: boolean;
+  speechMs: number;
+  silenceMs: number;
+  echoMs: number;
+}
+
+const SUMMARY_INTERVAL_MS = 5_000;
+const TRACE_WINDOW_MS = 2_000;
+const MAX_TRACE_SAMPLES = 40;
+
+/** Bounded signal measurements only. Never retains PCM or transcript text. */
+export class VoiceInputDiagnostics {
+  private recent: VoiceInputSample[] = [];
+  private lastArrivalAtMs: number | null = null;
+  private lastSttSubmissionAtMs: number | null = null;
+  private window = this.emptyWindow();
+
+  recordSttSubmission(atMs: number, audioMs: number): void {
+    this.window.sttSubmittedChunks += 1;
+    this.window.sttSubmittedAudioMs += audioMs;
+    if (this.lastSttSubmissionAtMs !== null) {
+      this.window.sttMaxSubmissionGapMs = Math.max(
+        this.window.sttMaxSubmissionGapMs,
+        atMs - this.lastSttSubmissionAtMs,
+      );
+    }
+    this.lastSttSubmissionAtMs = atMs;
+  }
+
+  observe(sample: VoiceInputSample): Record<string, number> | null {
+    this.recent.push(sample);
+    while (
+      this.recent.length > MAX_TRACE_SAMPLES ||
+      (this.recent[0] &&
+        sample.receivedAtMs - this.recent[0].receivedAtMs > TRACE_WINDOW_MS)
+    ) {
+      this.recent.shift();
+    }
+    const window = this.window;
+    window.firstAtMs ??= sample.receivedAtMs;
+    window.lastAtMs = sample.receivedAtMs;
+    window.chunks += 1;
+    window.audioMs += sample.chunkMs;
+    window.weightedAmplitude += sample.meanAmplitude * sample.chunkMs;
+    window.minAmplitude = Math.min(window.minAmplitude, sample.meanAmplitude);
+    window.maxAmplitude = Math.max(window.maxAmplitude, sample.meanAmplitude);
+    window.zeroAudioMs += sample.meanAmplitude === 0 ? sample.chunkMs : 0;
+    window.speechMs += sample.speechMs;
+    window.silenceMs += sample.silenceMs;
+    window.echoMs += sample.echoMs;
+    if (this.lastArrivalAtMs !== null) {
+      window.maxArrivalGapMs = Math.max(
+        window.maxArrivalGapMs,
+        sample.receivedAtMs - this.lastArrivalAtMs,
+      );
+    }
+    this.lastArrivalAtMs = sample.receivedAtMs;
+    return sample.receivedAtMs - window.firstAtMs >= SUMMARY_INTERVAL_MS
+      ? this.flush()
+      : null;
+  }
+
+  snapshot(nowMs: number): VoiceInputSample[] {
+    return this.recent
+      .filter((entry) => nowMs - entry.receivedAtMs <= TRACE_WINDOW_MS)
+      .map((entry) => ({ ...entry }));
+  }
+
+  flush(): Record<string, number> | null {
+    const window = this.window;
+    if (window.chunks === 0) {
+      return null;
+    }
+    this.window = this.emptyWindow();
+    const { weightedAmplitude, firstAtMs, ...summary } = window;
+    return {
+      ...summary,
+      firstAtMs: firstAtMs!,
+      meanAmplitude:
+        window.audioMs > 0 ? weightedAmplitude / window.audioMs : 0,
+    };
+  }
+
+  private emptyWindow() {
+    return {
+      firstAtMs: null as number | null,
+      lastAtMs: 0,
+      chunks: 0,
+      audioMs: 0,
+      weightedAmplitude: 0,
+      minAmplitude: Infinity,
+      maxAmplitude: 0,
+      zeroAudioMs: 0,
+      speechMs: 0,
+      silenceMs: 0,
+      echoMs: 0,
+      maxArrivalGapMs: 0,
+      sttSubmittedChunks: 0,
+      sttSubmittedAudioMs: 0,
+      sttMaxSubmissionGapMs: 0,
+    };
+  }
+}