@livekit/agents 1.2.0 → 1.2.2

package/src/llm/utils.ts

@@ -7,6 +7,7 @@ import sharp from 'sharp';
 import type { UnknownUserData } from '../voice/run_context.js';
 import type { ChatContext } from './chat_context.js';
 import {
+  type ChatContent,
   type ChatItem,
   FunctionCall,
   FunctionCallOutput,
@@ -241,6 +242,133 @@ export async function executeToolCall(
   }
 }
 
+export interface FormatChatHistoryOptions {
+  includeIds?: boolean;
+  includeTimestamps?: boolean;
+}
+
+/**
+ * Render a chat context into a readable multiline string for debugging and logging.
+ */
+export function formatChatHistory(
+  chatCtx: ChatContext,
+  options: FormatChatHistoryOptions = {},
+): string {
+  const { includeIds = false, includeTimestamps = false } = options;
+
+  if (chatCtx.items.length === 0) {
+    return 'Chat history (0 items)';
+  }
+
+  const formattedItems = chatCtx.items.map((item, index) =>
+    formatChatHistoryItem(item, index, {
+      includeIds,
+      includeTimestamps,
+    }),
+  );
+
+  return [
+    `Chat history (${chatCtx.items.length} items)`,
+    ...formattedItems.flatMap((item) => ['', item]),
+  ].join('\n');
+}
+
+function formatChatHistoryItem(
+  item: ChatItem,
+  index: number,
+  options: Required<FormatChatHistoryOptions>,
+): string {
+  const headerParts = [`[${index}]`];
+
+  if (item.type === 'message') {
+    headerParts.push('message', item.role);
+  } else if (item.type === 'function_call') {
+    headerParts.push('function_call', item.name, `call_id=${item.callId}`);
+  } else if (item.type === 'function_call_output') {
+    headerParts.push('function_call_output', item.name || '(unnamed)', `call_id=${item.callId}`);
+    if (item.isError) {
+      headerParts.push('error=true');
+    }
+  } else {
+    headerParts.push('agent_handoff');
+  }
+
+  if (options.includeIds) {
+    headerParts.push(`id=${item.id}`);
+  }
+
+  if (options.includeTimestamps) {
+    headerParts.push(`created_at=${item.createdAt.toFixed(3)}`);
+  }
+
+  const body = formatChatHistoryItemBody(item);
+  if (!body) {
+    return headerParts.join(' ');
+  }
+
+  return `${headerParts.join(' ')}\n${indentBlock(body, '  ')}`;
+}
+
+function formatChatHistoryItemBody(item: ChatItem): string {
+  if (item.type === 'message') {
+    const content = item.content.map((part) => formatMessageContentPart(part)).join('\n');
+    return content.trim() ? content : '(empty)';
+  }
+
+  if (item.type === 'function_call') {
+    return prettyJsonText(item.args);
+  }
+
+  if (item.type === 'function_call_output') {
+    return prettyJsonText(item.output);
+  }
+
+  return `${item.oldAgentId ?? '(none)'} -> ${item.newAgentId}`;
+}
+
+function formatMessageContentPart(part: ChatContent): string {
+  if (typeof part === 'string') {
+    return part;
+  }
+
+  if (part.type === 'image_content') {
+    if (typeof part.image === 'string') {
+      return `[image url=${truncateText(part.image, 120)}]`;
+    }
+
+    return `[image frame=${part.image.width}x${part.image.height}]`;
+  }
+
+  if (part.transcript) {
+    return `[audio transcript=${JSON.stringify(truncateText(part.transcript, 120))}]`;
+  }
+
+  return `[audio frames=${part.frame.length}]`;
+}
+
+function prettyJsonText(text: string): string {
+  try {
+    return JSON.stringify(JSON.parse(text), null, 2);
+  } catch {
+    return text;
+  }
+}
+
+function truncateText(text: string, maxLength: number): string {
+  if (text.length <= maxLength) {
+    return text;
+  }
+
+  return `${text.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+
+function indentBlock(text: string, indent: string): string {
+  return text
+    .split('\n')
+    .map((line) => `${indent}${line}`)
+    .join('\n');
+}
+
 /**
  * Standard dynamic-programming LCS to get the common subsequence
  * of IDs (in order) that appear in both old_ids and new_ids.

package/src/stt/stt.ts

@@ -248,7 +248,15 @@ export abstract class SpeechStream implements AsyncIterableIterator<SpeechEvent>
     startSoon(() => this.mainTask().finally(() => this.queue.close()));
   }
 
-  private async mainTask() {
+  /**
+   * Runs the STT with retry logic. Errors are emitted via {@link STT} error events
+   * and then re-thrown to trigger `.finally()` cleanup.
+   *
+   * @throws {APIError} When the STT request fails with a non-retryable error
+   * @throws {APIConnectionError} When all retry attempts are exhausted
+   * @internal Not annotated with Throws<> because this is fire-and-forget via startSoon()
+   */
+  private async mainTask(): Promise<void> {
     for (let i = 0; i < this._connOptions.maxRetry + 1; i++) {
       try {
         return await this.run();

package/src/tts/fallback_adapter.ts

@@ -2,6 +2,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 import { AudioResampler } from '@livekit/rtc-node';
+import type { Throws } from '@livekit/throws-transformer/throws';
 import { APIConnectionError, APIError } from '../_exceptions.js';
 import { log } from '../log.js';
 import { basic } from '../tokenize/index.js';
@@ -306,7 +307,10 @@ class FallbackChunkedStream extends ChunkedStream {
     this.connOptions = connOptions;
   }
 
-  protected async run(): Promise<void> {
+  /**
+   * @throws {APIConnectionError} When all TTS providers have been exhausted
+   */
+  protected async run(): Promise<Throws<void, APIConnectionError>> {
     const allTTSFailed = this.adapter.status.every((s) => !s.available);
     let lastRequestId: string = '';
     let lastSegmentId: string = '';
@@ -406,7 +410,10 @@ class FallbackSynthesizeStream extends SynthesizeStream {
     this.adapter = adapter;
   }
 
-  protected async run(): Promise<void> {
+  /**
+   * @throws {APIConnectionError} When all TTS providers have been exhausted
+   */
+  protected async run(): Promise<Throws<void, APIConnectionError>> {
     const allTTSFailed = this.adapter.status.every((s) => !s.available);
     if (allTTSFailed) {
       this._logger.warn('All fallback TTS instances failed, retrying from first...');

package/src/typed_promise.ts

@@ -0,0 +1,67 @@
+// SPDX-FileCopyrightText: 2026 LiveKit, Inc.
+//
+// SPDX-License-Identifier: Apache-2.0
+type InferErrors<T> = T extends TypedPromise<any, infer E> ? E : never;
+
+interface PromiseRejectedResult<E> {
+  status: 'rejected';
+  reason: E;
+}
+
+type SettledResult<T> =
+  T extends TypedPromise<infer U, infer E>
+    ? PromiseFulfilledResult<U> | PromiseRejectedResult<E>
+    : T extends PromiseLike<infer U>
+      ? PromiseFulfilledResult<U> | PromiseRejectedResult<unknown>
+      : PromiseFulfilledResult<T> | PromiseRejectedResult<unknown>;
+
+export default class TypedPromise<T, E extends Error> extends Promise<T> {
+  // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+  constructor(
+    executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason: E) => void) => void,
+  ) {
+    super(executor);
+  }
+
+  catch<TResult = never>(
+    onrejected?: ((reason: E) => TResult | PromiseLike<TResult>) | null | undefined,
+  ): TypedPromise<T | TResult, E> {
+    return super.catch(onrejected);
+  }
+
+  static resolve: {
+    (): TypedPromise<void, never>;
+    <V>(value: V): TypedPromise<Awaited<V>, never>;
+  } = <V>(value?: V): TypedPromise<Awaited<V>, never> => {
+    return super.resolve(value) as TypedPromise<Awaited<V>, never>;
+  };
+
+  static reject<E extends Error>(reason: E): TypedPromise<never, E> {
+    return super.reject(reason);
+  }
+
+  static all<T extends readonly unknown[] | []>(
+    values: T,
+  ): TypedPromise<{ -readonly [P in keyof T]: Awaited<T[P]> }, InferErrors<T[number]>> {
+    return super.all(values) as any;
+  }
+
+  static allSettled<T extends readonly unknown[] | []>(
+    values: T,
+  ): TypedPromise<{ -readonly [P in keyof T]: SettledResult<T[P]> }, never> {
+    return super.allSettled(values) as any;
+  }
+
+  static race<T extends readonly (TypedPromise<any, any> | any)[]>(
+    values: T,
+  ): TypedPromise<
+    T[number] extends TypedPromise<infer U, any>
+      ? U
+      : T[number] extends PromiseLike<infer U>
+        ? U
+        : Awaited<T[number]>,
+    InferErrors<T[number]>
+  > {
+    return super.race(values);
+  }
+}

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.
@@ -789,11 +805,11 @@ export type DelayOptions = {
  */
 export function delay(ms: number, options: DelayOptions = {}): Promise<void> {
   const { signal } = options;
-  if (signal?.aborted) return Promise.reject(signal.reason);
+  if (signal?.aborted) return Promise.reject(signal.reason ?? new Error('delay aborted'));
   return new Promise((resolve, reject) => {
     const abort = () => {
       clearTimeout(i);
-      reject(signal?.reason);
+      reject(signal?.reason ?? new Error('delay aborted'));
     };
     const done = () => {
       signal?.removeEventListener('abort', abort);
@@ -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);
+});