@livekit/agents 1.2.1 → 1.2.2

package/src/ipc/supervised_proc.test.ts

@@ -125,6 +125,102 @@ describe('IPC send on dead process', () => {
   });
 });
 
+describe('init timeout rejection handling', () => {
+  it('does not produce unhandled rejection when init times out', async () => {
+    // Regression test: before the fix, run() was called without await in start().
+    // When init timed out, the rejection in run()'s `await this.init.await` escaped
+    // as an unhandled rejection — crashing the Node.js process.
+    const unhandled: unknown[] = [];
+    const handler = (reason: unknown) => unhandled.push(reason);
+    process.on('unhandledRejection', handler);
+
+    // Child that responds AFTER the timeout — simulates slow init under CPU pressure.
+    // Timeout fires at 50ms (init.reject), child responds at 200ms (once() resolves).
+    // Before the fix, init.reject caused an unhandled rejection in run().
+    const slowScript = join(tmpdir(), 'test_slow_init_child.mjs');
+    writeFileSync(
+      slowScript,
+      `process.on('message', () => {
+        setTimeout(() => process.send({ case: 'initializeResponse' }), 200);
+      });
+      setInterval(() => {}, 1000);`,
+    );
+
+    const { SupervisedProc } = await import('./supervised_proc.js');
+    class TestProc extends SupervisedProc {
+      createProcess() {
+        return fork(slowScript, [], { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] });
+      }
+      async mainTask() {}
+    }
+
+    const proc = new TestProc(
+      50, // initializeTimeout — fires before child responds at 200ms
+      1000, // closeTimeout
+      0, // memoryWarnMB
+      0, // memoryLimitMB
+      5000, // pingInterval
+      60000, // pingTimeout
+      2500, // highPingThreshold
+    );
+
+    await proc.start();
+    // initialize() returns normally: child responds at 200ms, once() resolves,
+    // but init was already rejected at 50ms — run() gets the rejection.
+    await proc.initialize();
+
+    // Give the event loop a tick for any unhandled rejection to surface
+    await new Promise((r) => setTimeout(r, 100));
+
+    process.off('unhandledRejection', handler);
+    proc.proc?.kill();
+    try {
+      unlinkSync(slowScript);
+    } catch {}
+
+    expect(unhandled).toEqual([]);
+  });
+
+  it('join() resolves after init timeout instead of hanging forever', async () => {
+    // When run() fails early (before registering proc event handlers),
+    // #join must still resolve so that join() and close() don't hang.
+    const slowScript = join(tmpdir(), 'test_slow_init_child_join.mjs');
+    writeFileSync(
+      slowScript,
+      `process.on('message', () => {
+        setTimeout(() => process.send({ case: 'initializeResponse' }), 200);
+      });
+      setInterval(() => {}, 1000);`,
+    );
+
+    const { SupervisedProc } = await import('./supervised_proc.js');
+    class TestProc extends SupervisedProc {
+      createProcess() {
+        return fork(slowScript, [], { stdio: ['pipe', 'pipe', 'pipe', 'ipc'] });
+      }
+      async mainTask() {}
+    }
+
+    const proc = new TestProc(50, 1000, 0, 0, 5000, 60000, 2500);
+
+    await proc.start();
+    await proc.initialize();
+
+    // join() must resolve within a reasonable time, not hang forever
+    const result = await Promise.race([
+      proc.join().then(() => 'resolved'),
+      new Promise((r) => setTimeout(() => r('timeout'), 2000)),
+    ]);
+
+    proc.proc?.kill();
+    try {
+      unlinkSync(slowScript);
+    } catch {}
+
+    expect(result).toBe('resolved');
+  });
+});
+
 describe('timer cleanup', () => {
   it('clearInterval stops the interval', async () => {
     let count = 0;

package/src/ipc/supervised_proc.ts

@@ -84,7 +84,14 @@ export abstract class SupervisedProc {
     this.proc = this.createProcess();
 
     this.#started = true;
-    this.run();
+    this.run().catch((err) => {
+      this.#logger.child({ err }).warn('supervised process run failed');
+      // Note: we intentionally do NOT kill the child process here. Killing it
+      // would race with initialize()'s `once(proc, 'message')`, causing
+      // initialize() to hang forever and deadlocking the caller (proc_pool).
+      // The child process is cleaned up when the pool shuts down.
+      this.#join.resolve();
+    });
   }
 
   async run() {

package/src/job.ts

@@ -283,6 +283,7 @@ export class JobContext {
       startedAt: targetSession._startedAt,
       audioRecordingPath: recorderIO?.outputPath,
       audioRecordingStartedAt: recorderIO?.recordingStartedAt,
+      modelUsage: targetSession._usageCollector.flatten(),
     });
   }
 

package/src/utils.ts

@@ -9,6 +9,7 @@ import type {
   TrackKind,
 } from '@livekit/rtc-node';
 import { AudioFrame, AudioResampler, RoomEvent } from '@livekit/rtc-node';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { EventEmitter, once } from 'node:events';
 import type { ReadableStream } from 'node:stream/web';
@@ -752,6 +753,21 @@ export function isStreamClosedError(error: unknown): boolean {
   );
 }
 
+/** FFmpeg error messages expected during normal teardown/shutdown. */
+const FFMPEG_TEARDOWN_ERRORS = ['Output stream closed', 'received signal 2', 'SIGKILL', 'SIGINT'];
+
+/**
+ * Check if an error is an expected FFmpeg teardown error that can be safely ignored during cleanup.
+ *
+ * @param error - The error to check.
+ * @returns True if the error is an expected FFmpeg shutdown error.
+ */
+export function isFfmpegTeardownError(error: unknown): boolean {
+  return (
+    error instanceof Error && FFMPEG_TEARDOWN_ERRORS.some((msg) => error.message?.includes(msg))
+  );
+}
+
 /**
  * In JS an error can be any arbitrary value.
  * This function converts an unknown error to an Error and stores the original value in the error object.
@@ -804,6 +820,33 @@ export function delay(ms: number, options: DelayOptions = {}): Promise<void> {
   });
 }
 
+export class IdleTimeoutError extends Error {
+  constructor(message = 'idle timeout') {
+    super(message);
+    this.name = 'IdleTimeoutError';
+  }
+}
+
+/**
+ * Race a promise against an idle timeout. If the promise does not settle within
+ * `timeoutMs` milliseconds, the returned promise rejects with {@link IdleTimeoutError}
+ * (or the error returned by `throwError` when provided).
+ * The timer is properly cleaned up on settlement to avoid leaking handles.
+ */
+export function waitUntilTimeout<T, E extends Error = IdleTimeoutError>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  throwError?: () => E,
+): Promise<Throws<T, E>> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  return Promise.race([
+    promise,
+    new Promise<never>((_, reject) => {
+      timer = setTimeout(() => reject(throwError?.() ?? new IdleTimeoutError()), timeoutMs);
+    }),
+  ]).finally(() => clearTimeout(timer)) as Promise<Throws<T, E>>;
+}
+
 /**
  * Returns a participant that matches the given identity. If identity is None, the first
  * participant that joins the room will be returned.

package/src/voice/agent_activity.ts

@@ -67,6 +67,7 @@ import {
   createErrorEvent,
   createFunctionToolsExecutedEvent,
   createMetricsCollectedEvent,
+  createSessionUsageUpdatedEvent,
   createSpeechCreatedEvent,
   createUserInputTranscribedEvent,
 } from './events.js';
@@ -157,10 +158,15 @@ export class AgentActivity implements RecognitionHooks {
 
   private readonly onInterruptionMetricsCollected = (ev: InterruptionMetrics): void => {
     this.agentSession._usageCollector.collect(ev);
+    const usage = this.agentSession.usage;
     this.agentSession.emit(
       AgentSessionEventTypes.MetricsCollected,
       createMetricsCollectedEvent({ metrics: ev }),
     );
+    this.agentSession.emit(
+      AgentSessionEventTypes.SessionUsageUpdated,
+      createSessionUsageUpdatedEvent({ usage }),
+    );
   };
 
   private readonly onInterruptionError = (ev: InterruptionDetectionError): void => {
@@ -730,11 +736,16 @@ export class AgentActivity implements RecognitionHooks {
     }
 
     this.agentSession._usageCollector.collect(ev);
+    const usage = this.agentSession.usage;
 
     this.agentSession.emit(
       AgentSessionEventTypes.MetricsCollected,
       createMetricsCollectedEvent({ metrics: ev }),
     );
+    this.agentSession.emit(
+      AgentSessionEventTypes.SessionUsageUpdated,
+      createSessionUsageUpdatedEvent({ usage }),
+    );
   };
 
   private onError(ev: RealtimeModelError | STTError | TTSError | LLMError): void {

package/src/voice/agent_session.ts

@@ -52,6 +52,7 @@ import {
   type ErrorEvent,
   type FunctionToolsExecutedEvent,
   type MetricsCollectedEvent,
+  type SessionUsageUpdatedEvent,
   type ShutdownReason,
   type SpeechCreatedEvent,
   type UserInputTranscribedEvent,
@@ -131,6 +132,7 @@ export type AgentSessionCallbacks = {
   [AgentSessionEventTypes.ConversationItemAdded]: (ev: ConversationItemAddedEvent) => void;
   [AgentSessionEventTypes.FunctionToolsExecuted]: (ev: FunctionToolsExecutedEvent) => void;
   [AgentSessionEventTypes.MetricsCollected]: (ev: MetricsCollectedEvent) => void;
+  [AgentSessionEventTypes.SessionUsageUpdated]: (ev: SessionUsageUpdatedEvent) => void;
   [AgentSessionEventTypes.SpeechCreated]: (ev: SpeechCreatedEvent) => void;
   [AgentSessionEventTypes.Error]: (ev: ErrorEvent) => void;
   [AgentSessionEventTypes.Close]: (ev: CloseEvent) => void;
@@ -649,7 +651,8 @@ export class AgentSession<
   }
 
   generateReply(options?: {
-    userInput?: string;
+    userInput?: string | ChatMessage;
+    chatCtx?: ChatContext;
     instructions?: string;
     toolChoice?: ToolChoice;
     allowInterruptions?: boolean;
@@ -658,12 +661,15 @@ export class AgentSession<
       throw new Error('AgentSession is not running');
     }
 
-    const userMessage = options?.userInput
-      ? new ChatMessage({
-          role: 'user',
-          content: options.userInput,
-        })
-      : undefined;
+    const userMessage =
+      options?.userInput instanceof ChatMessage
+        ? options.userInput
+        : options?.userInput
+          ? new ChatMessage({
+              role: 'user',
+              content: options.userInput,
+            })
+          : undefined;
 
     const doGenerateReply = (activity: AgentActivity, nextActivity?: AgentActivity) => {
       if (activity.schedulingPaused) {

package/src/voice/events.ts

@@ -18,6 +18,7 @@ import type { STT } from '../stt/index.js';
 import type { STTError } from '../stt/stt.js';
 import type { TTS } from '../tts/index.js';
 import type { TTSError } from '../tts/tts.js';
+import type { AgentSessionUsage } from './agent_session.js';
 import type { SpeechHandle } from './speech_handle.js';
 
 export enum AgentSessionEventTypes {
@@ -27,6 +28,7 @@ export enum AgentSessionEventTypes {
   ConversationItemAdded = 'conversation_item_added',
   FunctionToolsExecuted = 'function_tools_executed',
   MetricsCollected = 'metrics_collected',
+  SessionUsageUpdated = 'session_usage_updated',
   SpeechCreated = 'speech_created',
   OverlappingSpeech = 'overlapping_speech',
   Error = 'error',
@@ -133,6 +135,24 @@ export const createMetricsCollectedEvent = ({
   createdAt,
 });
 
+export type SessionUsageUpdatedEvent = {
+  type: 'session_usage_updated';
+  usage: AgentSessionUsage;
+  createdAt: number;
+};
+
+export const createSessionUsageUpdatedEvent = ({
+  usage,
+  createdAt = Date.now(),
+}: {
+  usage: AgentSessionUsage;
+  createdAt?: number;
+}): SessionUsageUpdatedEvent => ({
+  type: 'session_usage_updated',
+  usage,
+  createdAt,
+});
+
 export type ConversationItemAddedEvent = {
   type: 'conversation_item_added';
   item: ChatMessage;
@@ -264,6 +284,7 @@ export type AgentEvent =
   | UserStateChangedEvent
   | AgentStateChangedEvent
   | MetricsCollectedEvent
+  | SessionUsageUpdatedEvent
   | ConversationItemAddedEvent
   | FunctionToolsExecutedEvent
   | SpeechCreatedEvent

package/src/voice/generation.ts

@@ -25,7 +25,15 @@ import { log } from '../log.js';
 import { IdentityTransform } from '../stream/identity_transform.js';
 import { traceTypes, tracer } from '../telemetry/index.js';
 import { USERDATA_TIMED_TRANSCRIPT } from '../types.js';
-import { Future, Task, shortuuid, toError, waitForAbort } from '../utils.js';
+import {
+  Future,
+  IdleTimeoutError,
+  Task,
+  shortuuid,
+  toError,
+  waitForAbort,
+  waitUntilTimeout,
+} from '../utils.js';
 import {
   type Agent,
   type ModelSettings,
@@ -46,6 +54,8 @@ import {
 import { RunContext } from './run_context.js';
 import type { SpeechHandle } from './speech_handle.js';
 
+const TTS_READ_IDLE_TIMEOUT_MS = 10_000;
+
 /** @internal */
 export class _LLMGenerationData {
   generatedText: string = '';
@@ -550,6 +560,7 @@ export function performTTSInference(
   model?: string,
   provider?: string,
 ): [Task<void>, _TTSGenerationData] {
+  const logger = log();
   const audioStream = new IdentityTransform<AudioFrame>();
   const outputWriter = audioStream.writable.getWriter();
   const audioOutputStream = audioStream.readable;
@@ -624,12 +635,15 @@ export function performTTSInference(
       // JS currently only does single inference, so initialPushedDuration is always 0.
       // TODO: Add FlushSentinel + multi-segment loop
       const initialPushedDuration = pushedDuration;
-
       while (true) {
         if (signal.aborted) {
           break;
         }
-        const { done, value: frame } = await ttsStreamReader.read();
+
+        const { done, value: frame } = await waitUntilTimeout(
+          ttsStreamReader.read(),
+          TTS_READ_IDLE_TIMEOUT_MS,
+        );
         if (done) {
           break;
         }
@@ -671,14 +685,15 @@ export function performTTSInference(
         pushedDuration += frameDuration;
       }
     } catch (error) {
-      if (error instanceof DOMException && error.name === 'AbortError') {
-        // Abort signal was triggered, handle gracefully
+      if (error instanceof IdleTimeoutError) {
+        logger.warn('TTS stream stalled after producing audio, forcing close');
+      } else if (error instanceof DOMException && error.name === 'AbortError') {
         return;
+      } else {
+        throw error;
       }
-      throw error;
     } finally {
       if (!timedTextsFut.done) {
-        // Ensure downstream consumers don't hang on errors.
         timedTextsFut.resolve(null);
       }
       ttsStreamReader?.releaseLock();
@@ -773,9 +788,12 @@ async function forwardAudio(
   out: _AudioOut,
   signal?: AbortSignal,
 ): Promise<void> {
+  const logger = log();
   const reader = ttsStream.getReader();
   let resampler: AudioResampler | null = null;
 
+  const FORWARD_AUDIO_IDLE_TIMEOUT_MS = 10_000;
+
   const onPlaybackStarted = (ev: { createdAt: number }) => {
     if (!out.firstFrameFut.done) {
       out.firstFrameFut.resolve(ev.createdAt);
@@ -791,7 +809,10 @@ async function forwardAudio(
         break;
       }
 
-      const { done, value: frame } = await reader.read();
+      const { done, value: frame } = await waitUntilTimeout(
+        reader.read(),
+        FORWARD_AUDIO_IDLE_TIMEOUT_MS,
+      );
       if (done) break;
 
       out.audio.push(frame);
@@ -819,6 +840,12 @@ async function forwardAudio(
         await audioOutput.captureFrame(f);
       }
     }
+  } catch (e) {
+    if (e instanceof IdleTimeoutError) {
+      logger.warn('audio forwarding stalled waiting for TTS frames, forcing close');
+    } else {
+      throw e;
+    }
   } finally {
     audioOutput.off(AudioOutput.EVENT_PLAYBACK_STARTED, onPlaybackStarted);
 

package/src/voice/generation_tts_timeout.test.ts

@@ -0,0 +1,112 @@
+// SPDX-FileCopyrightText: 2026 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import { AudioFrame } from '@livekit/rtc-node';
+import { ReadableStream } from 'stream/web';
+import { describe, expect, it, vi } from 'vitest';
+import { initializeLogger } from '../log.js';
+import { performAudioForwarding, performTTSInference } from './generation.js';
+import { AudioOutput } from './io.js';
+
+function createSilentFrame(sampleRate = 24000, channels = 1, durationMs = 20): AudioFrame {
+  const samplesPerChannel = Math.floor((sampleRate * durationMs) / 1000);
+  const data = new Int16Array(samplesPerChannel * channels);
+  return new AudioFrame(data, sampleRate, channels, samplesPerChannel);
+}
+
+class MockAudioOutput extends AudioOutput {
+  capturedFrames: AudioFrame[] = [];
+
+  constructor() {
+    super(24000);
+  }
+
+  async captureFrame(frame: AudioFrame): Promise<void> {
+    await super.captureFrame(frame);
+    this.capturedFrames.push(frame);
+    this.onPlaybackStarted(Date.now());
+  }
+
+  clearBuffer(): void {
+    // no-op for mock
+  }
+}
+
+describe('TTS stream idle timeout', () => {
+  initializeLogger({ pretty: false, level: 'silent' });
+
+  it('forwardAudio completes when TTS stream stalls after producing frames', async () => {
+    const stalledStream = new ReadableStream<AudioFrame>({
+      start(controller) {
+        controller.enqueue(createSilentFrame());
+        controller.enqueue(createSilentFrame());
+      },
+    });
+
+    const audioOutput = new MockAudioOutput();
+    const controller = new AbortController();
+
+    const [task, audioOut] = performAudioForwarding(stalledStream, audioOutput, controller);
+
+    vi.useFakeTimers();
+
+    const taskPromise = task.result;
+    await vi.advanceTimersByTimeAsync(11_000);
+    await taskPromise;
+
+    vi.useRealTimers();
+
+    expect(audioOutput.capturedFrames.length).toBe(2);
+    expect(audioOut.firstFrameFut.done).toBe(true);
+  }, 10_000);
+
+  it('forwardAudio completes normally when TTS stream closes properly', async () => {
+    const normalStream = new ReadableStream<AudioFrame>({
+      start(controller) {
+        controller.enqueue(createSilentFrame());
+        controller.enqueue(createSilentFrame());
+        controller.enqueue(createSilentFrame());
+        controller.close();
+      },
+    });
+
+    const audioOutput = new MockAudioOutput();
+    const controller = new AbortController();
+
+    const [task, audioOut] = performAudioForwarding(normalStream, audioOutput, controller);
+
+    await task.result;
+
+    expect(audioOutput.capturedFrames.length).toBe(3);
+    expect(audioOut.firstFrameFut.done).toBe(true);
+  });
+
+  it('performTTSInference completes when TTS node returns stalled stream', async () => {
+    const stalledTtsStream = new ReadableStream<AudioFrame>({
+      start(controller) {
+        controller.enqueue(createSilentFrame());
+      },
+    });
+
+    const ttsNode = async () => stalledTtsStream;
+    const textInput = new ReadableStream<string>({
+      start(controller) {
+        controller.enqueue('Hello world');
+        controller.close();
+      },
+    });
+
+    const controller = new AbortController();
+    const [task, genData] = performTTSInference(ttsNode, textInput, {}, controller);
+
+    vi.useFakeTimers();
+
+    const taskPromise = task.result;
+    await vi.advanceTimersByTimeAsync(11_000);
+    await taskPromise;
+
+    vi.useRealTimers();
+
+    expect(genData.ttfb).toBeDefined();
+  }, 10_000);
+});

package/src/voice/index.ts

@@ -2,7 +2,12 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 export { Agent, AgentTask, StopResponse, type AgentOptions, type ModelSettings } from './agent.js';
-export { AgentSession, type AgentSessionOptions, type VoiceOptions } from './agent_session.js';
+export {
+  AgentSession,
+  type AgentSessionOptions,
+  type AgentSessionUsage,
+  type VoiceOptions,
+} from './agent_session.js';
 export * from './avatar/index.js';
 export * from './background_audio.js';
 export {

package/src/voice/recorder_io/recorder_io.ts

@@ -13,7 +13,7 @@ import { TransformStream } from 'node:stream/web';
 import { log } from '../../log.js';
 import { isStreamReaderReleaseError } from '../../stream/deferred_stream.js';
 import { type StreamChannel, createStreamChannel } from '../../stream/stream_channel.js';
-import { Future, Task, cancelAndWait, delay } from '../../utils.js';
+import { Future, Task, cancelAndWait, delay, isFfmpegTeardownError } from '../../utils.js';
 import type { AgentSession } from '../agent_session.js';
 import { AudioInput, AudioOutput, type PlaybackFinishedEvent } from '../io.js';
 
@@ -203,12 +203,7 @@ export class RecorderIO {
         })
         .on('error', (err) => {
           // Ignore errors from intentional stream closure or SIGINT during shutdown
-          if (
-            err.message?.includes('Output stream closed') ||
-            err.message?.includes('received signal 2') ||
-            err.message?.includes('SIGKILL') ||
-            err.message?.includes('SIGINT')
-          ) {
+          if (isFfmpegTeardownError(err)) {
             resolve();
           } else {
             this.logger.error({ err }, 'FFmpeg encoding error');

package/src/voice/report.test.ts

@@ -3,7 +3,10 @@
 // SPDX-License-Identifier: Apache-2.0
 import { describe, expect, it } from 'vitest';
 import { ChatContext } from '../llm/chat_context.js';
+import type { ModelUsage } from '../metrics/model_usage.js';
 import type { AgentSessionOptions, VoiceOptions } from './agent_session.js';
+import { AgentSessionEventTypes, createSessionUsageUpdatedEvent } from './events.js';
+import type { AgentSessionUsage } from './index.js';
 import { createSessionReport, sessionReportToJSON } from './report.js';
 
 type ReportOptions = AgentSessionOptions & Partial<VoiceOptions>;
@@ -133,4 +136,79 @@ describe('sessionReportToJSON', () => {
       max_tool_steps: 3,
     });
   });
+
+  it('serializes model usage as usage', () => {
+    const usage: ModelUsage[] = [
+      {
+        type: 'tts_usage',
+        provider: 'elevenlabs',
+        model: 'eleven_flash_v2_5',
+        inputTokens: 0,
+        outputTokens: 0,
+        charactersCount: 42,
+        audioDurationMs: 1200,
+      },
+    ];
+
+    const report = createSessionReport({
+      jobId: 'job',
+      roomId: 'room-id',
+      room: 'room',
+      options: baseOptions(),
+      events: [],
+      chatHistory: ChatContext.empty(),
+      enableRecording: false,
+      timestamp: 0,
+      startedAt: 0,
+      modelUsage: usage,
+    });
+
+    const payload = sessionReportToJSON(report);
+    expect(payload.usage).toEqual([
+      {
+        type: 'tts_usage',
+        provider: 'elevenlabs',
+        model: 'eleven_flash_v2_5',
+        charactersCount: 42,
+        audioDurationMs: 1200,
+      },
+    ]);
+  });
+
+  it('omits session usage update events from serialized events', () => {
+    const report = createSessionReport({
+      jobId: 'job',
+      roomId: 'room-id',
+      room: 'room',
+      options: baseOptions(),
+      events: [
+        createSessionUsageUpdatedEvent({
+          usage: {
+            modelUsage: [
+              {
+                type: 'tts_usage',
+                provider: 'elevenlabs',
+                model: 'eleven_flash_v2_5',
+              },
+            ],
+          },
+          createdAt: 123,
+        }),
+      ],
+      chatHistory: ChatContext.empty(),
+      enableRecording: false,
+      timestamp: 0,
+      startedAt: 0,
+    });
+
+    const payload = sessionReportToJSON(report);
+    expect(payload.events).toEqual([]);
+  });
+
+  it('exports AgentSessionUsage from the voice barrel', () => {
+    const usage: AgentSessionUsage = { modelUsage: [] };
+    const eventType: AgentSessionEventTypes = AgentSessionEventTypes.SessionUsageUpdated;
+    expect(usage.modelUsage).toEqual([]);
+    expect(eventType).toBe('session_usage_updated');
+  });
 });

package/src/voice/report.ts

@@ -111,7 +111,7 @@ export function sessionReportToJSON(report: SessionReport): Record<string, unkno
     options.voiceOptions?.maxEndpointingDelay;
 
   for (const event of report.events) {
-    if (event.type === 'metrics_collected') {
+    if (event.type === 'metrics_collected' || event.type === 'session_usage_updated') {
       continue; // metrics are too noisy, Cloud is using the chat_history as the source of truth
     }