@livekit/agents 1.2.0 → 1.2.2

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
     }
 

package/src/voice/room_io/room_io.test.ts

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: 2026 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+import { describe, expect, it } from 'vitest';
+import { IdentityTransform } from '../../stream/identity_transform.js';
+
+/**
+ * Regression tests proving WritableStream.close() rejects when the writer is
+ * already closed or errored — the exact scenario RoomIO.close() guards against
+ * with a try/catch.
+ *
+ * RoomIO holds a WritableStreamDefaultWriter for user transcript forwarding.
+ * During teardown, the writer may already be closed or errored (e.g. a
+ * concurrent write failed during speech interruption). Without the guard,
+ * close() throws ERR_INVALID_STATE and crashes teardown.
+ */
+describe('RoomIO WritableStream close guard', () => {
+  it('should reject when closing an already-closed writer', async () => {
+    const transform = new IdentityTransform<string>();
+    const writer = transform.writable.getWriter();
+
+    await writer.close();
+
+    // Proves the bug: second close() rejects — RoomIO.close() must guard this.
+    await expect(writer.close()).rejects.toThrow();
+  });
+
+  it('should reject when closing a writer on an errored stream', async () => {
+    const transform = new IdentityTransform<string>();
+    const writer = transform.writable.getWriter();
+
+    // Force the stream into an errored state
+    await writer.abort(new Error('simulated write failure'));
+
+    // Proves the bug: close() on errored writer rejects — RoomIO.close() must guard this.
+    await expect(writer.close()).rejects.toThrow();
+  });
+});

package/src/voice/room_io/room_io.ts

@@ -529,8 +529,13 @@ export class RoomIO {
     await this.initTask?.cancelAndWait();
 
     // Close stream FIRST so reader.read() in forwardUserTranscript can exit.
-    // This is a workaround for a race condition in the stream API.
-    this.userTranscriptWriter.close();
+    // Writer may already be closed or errored if a concurrent write failed
+    // during session teardown (e.g. speech interruption race). Safe to ignore.
+    try {
+      await this.userTranscriptWriter.close();
+    } catch (e) {
+      this.logger.debug({ error: e }, 'userTranscriptWriter already closed or errored');
+    }
     await this.forwardUserTranscriptTask?.cancelAndWait();
 
     await this.audioInput?.close();