@livekit/agents 1.1.0-dev.0 → 1.2.0

package/src/voice/agent_session.ts

@@ -41,7 +41,6 @@ import type { VAD } from '../vad.js';
 import type { Agent } from './agent.js';
 import { AgentActivity } from './agent_activity.js';
 import type { _TurnDetector } from './audio_recognition.js';
-import { ClientEventsHandler } from './client_events.js';
 import {
   type AgentEvent,
   AgentSessionEventTypes,
@@ -65,6 +64,7 @@ import {
 } from './events.js';
 import { AgentInput, AgentOutput } from './io.js';
 import { RecorderIO } from './recorder_io/index.js';
+import { RoomSessionTransport, SessionHost } from './remote_session.js';
 import {
   DEFAULT_TEXT_INPUT_CALLBACK,
   RoomIO,
@@ -87,68 +87,40 @@ export interface AgentSessionUsage {
   modelUsage: Array<Partial<ModelUsage>>;
 }
 
-export interface SessionOptions {
+export interface InternalSessionOptions<UserData> extends AgentSessionOptions<UserData> {
+  turnHandling: InternalTurnHandlingOptions;
+  useTtsAlignedTranscript: boolean;
   maxToolSteps: number;
-  /**
-   * Whether to speculatively begin LLM and TTS requests before an end-of-turn is detected.
-   * When `true`, the agent sends inference calls as soon as a user transcript is received rather
-   * than waiting for a definitive turn boundary. This can reduce response latency by overlapping
-   * model inference with user audio, but may incur extra compute if the user interrupts or
-   * revises mid-utterance.
-   * @defaultValue false
-   */
-  preemptiveGeneration: boolean;
-
-  /**
-   * If set, set the user state as "away" after this amount of time after user and agent are
-   * silent. Set to `null` to disable.
-   * @defaultValue 15.0
-   */
   userAwayTimeout: number | null;
-
-  /**
-   * Duration in milliseconds for AEC (Acoustic Echo Cancellation) warmup, during which
-   * interruptions from audio activity are suppressed. Set to `null` to disable.
-   * @defaultValue 3000
-   */
-  aecWarmupDuration: number | null;
-
-  /**
-   * Configuration for turn handling.
-   */
-  turnHandling: Partial<TurnHandlingOptions>;
-
-  useTtsAlignedTranscript: boolean;
-
-  /** @deprecated Use {@link SessionOptions.turnHandling}.interruption.mode instead. */
-  allowInterruptions?: boolean;
-  /** @deprecated Use {@link SessionOptions.turnHandling}.interruption.discardAudioIfUninterruptible instead. */
-  discardAudioIfUninterruptible?: boolean;
-  /** @deprecated Use {@link SessionOptions.turnHandling}.interruption.minDuration instead. */
-  minInterruptionDuration?: number;
-  /** @deprecated Use {@link SessionOptions.turnHandling}.interruption.minWords instead. */
-  minInterruptionWords?: number;
-  /** @deprecated Use {@link SessionOptions.turnHandling}.endpointing.minDelay instead. */
-  minEndpointingDelay?: number;
-  /** @deprecated Use {@link SessionOptions.turnHandling}.endpointing.maxDelay instead. */
-  maxEndpointingDelay?: number;
-}
-
-export interface InternalSessionOptions extends SessionOptions {
-  turnHandling: InternalTurnHandlingOptions;
 }
 
-export const defaultSessionOptions = {
+export const defaultAgentSessionOptions = {
   maxToolSteps: 3,
-  preemptiveGeneration: false,
+  preemptiveGeneration: true,
   userAwayTimeout: 15.0,
   aecWarmupDuration: 3000,
   turnHandling: {},
   useTtsAlignedTranscript: true,
-} as const satisfies SessionOptions;
+} as const satisfies AgentSessionOptions;
 
-/** @deprecated {@link VoiceOptions} has been renamed to {@link SessionOptions} */
-export type VoiceOptions = SessionOptions;
+/** @deprecated {@link VoiceOptions} has been flattened onto to {@link AgentSessionOptions} */
+export type VoiceOptions = {
+  maxToolSteps: number;
+  preemptiveGeneration: boolean;
+  userAwayTimeout?: number | null;
+  /** @deprecated Use {@link AgentSessionOptions.turnHandling}.interruption.mode instead. */
+  allowInterruptions?: boolean;
+  /** @deprecated Use {@link AgentSessionOptions.turnHandling}.interruption.discardAudioIfUninterruptible instead. */
+  discardAudioIfUninterruptible?: boolean;
+  /** @deprecated Use {@link AgentSessionOptions.turnHandling}.interruption.minDuration instead. */
+  minInterruptionDuration?: number;
+  /** @deprecated Use {@link AgentSessionOptions.turnHandling}.interruption.minWords instead. */
+  minInterruptionWords?: number;
+  /** @deprecated Use {@link AgentSessionOptions.turnHandling}.endpointing.minDelay instead. */
+  minEndpointingDelay?: number;
+  /** @deprecated Use {@link AgentSessionOptions.turnHandling}.endpointing.maxDelay instead. */
+  maxEndpointingDelay?: number;
+};
 
 export type TurnDetectionMode = 'stt' | 'vad' | 'realtime_llm' | 'manual' | _TurnDetector;
 
@@ -162,7 +134,7 @@ export type AgentSessionCallbacks = {
   [AgentSessionEventTypes.SpeechCreated]: (ev: SpeechCreatedEvent) => void;
   [AgentSessionEventTypes.Error]: (ev: ErrorEvent) => void;
   [AgentSessionEventTypes.Close]: (ev: CloseEvent) => void;
-  [AgentSessionEventTypes.UserOverlappingSpeech]: (ev: OverlappingSpeechEvent) => void;
+  [AgentSessionEventTypes.OverlappingSpeech]: (ev: OverlappingSpeechEvent) => void;
 };
 
 export type AgentSessionOptions<UserData = UnknownUserData> = {
@@ -171,13 +143,44 @@ export type AgentSessionOptions<UserData = UnknownUserData> = {
   llm?: LLM | RealtimeModel | LLMModels;
   tts?: TTS | TTSModelString;
   userData?: UserData;
-  options?: Partial<SessionOptions>;
   connOptions?: SessionConnectOptions;
 
-  /** @deprecated use {@link AgentSessionOptions.options}.turnHandling.turnDetection instead */
+  /** @deprecated use turnHandling.turnDetection instead */
   turnDetection?: TurnDetectionMode;
-  /** @deprecated use {@link AgentSessionOptions.options} instead */
+  /** @deprecated use top-level SessionOptions fields instead */
   voiceOptions?: Partial<VoiceOptions>;
+
+  maxToolSteps?: number;
+  /**
+   * Whether to speculatively begin LLM and TTS requests before an end-of-turn is detected.
+   * When `true`, the agent sends inference calls as soon as a user transcript is received rather
+   * than waiting for a definitive turn boundary. This can reduce response latency by overlapping
+   * model inference with user audio, but may incur extra compute if the user interrupts or
+   * revises mid-utterance.
+   * @defaultValue true
+   */
+  preemptiveGeneration?: boolean;
+
+  /**
+   * If set, set the user state as "away" after this amount of time after user and agent are
+   * silent. Set to `null` to disable.
+   * @defaultValue 15.0
+   */
+  userAwayTimeout?: number | null;
+
+  /**
+   * Duration in milliseconds for AEC (Acoustic Echo Cancellation) warmup, during which
+   * interruptions from audio activity are suppressed. Set to `null` to disable.
+   * @defaultValue 3000
+   */
+  aecWarmupDuration?: number | null;
+
+  /**
+   * Configuration for turn handling.
+   */
+  turnHandling?: Partial<TurnHandlingOptions>;
+
+  useTtsAlignedTranscript?: boolean;
 };
 
 type ActivityTransitionOptions = {
@@ -196,7 +199,11 @@ export class AgentSession<
   tts?: TTS;
   turnDetection?: TurnDetectionMode;
 
-  readonly options: InternalSessionOptions;
+  /** @deprecated use {@link sessionOptions } instead */
+  readonly options: VoiceOptions;
+
+  readonly sessionOptions: InternalSessionOptions<UserData>;
+
   private readonly activityLock = new Mutex();
 
   private agent?: Agent;
@@ -204,7 +211,7 @@ export class AgentSession<
   private nextActivity?: AgentActivity;
   private updateActivityTask?: Task<void>;
   private started = false;
-  private clientEventsHandler?: ClientEventsHandler;
+  private sessionHost?: SessionHost;
 
   private _chatCtx: ChatContext;
   private _userData: UserData | undefined;
@@ -225,14 +232,14 @@ export class AgentSession<
   // Unrecoverable error counts, reset after agent speaking
   private llmErrorCounts = 0;
   private ttsErrorCounts = 0;
-  private interruptionDetectionErrorCounts = 0;
 
   private sessionSpan?: Span;
   private agentSpeakingSpan?: Span;
 
   private _interruptionDetection?: InterruptionOptions['mode'];
 
-  private _usageCollector: ModelUsageCollector = new ModelUsageCollector();
+  /** @internal */
+  _usageCollector: ModelUsageCollector = new ModelUsageCollector();
 
   /** @internal */
   _roomIO?: RoomIO;
@@ -266,9 +273,10 @@ export class AgentSession<
   constructor(options: AgentSessionOptions<UserData>) {
     super();
 
-    const opts = migrateLegacyOptions<UserData>(options);
+    const { agentSessionOptions: opts, legacyVoiceOptions } =
+      migrateLegacyOptions<UserData>(options);
 
-    const { vad, stt, llm, tts, userData, connOptions, options: sessionOptions } = opts;
+    const { vad, stt, llm, tts, userData, connOptions, ...resolvedSessionOptions } = opts;
     // Merge user-provided connOptions with defaults
     this._connOptions = {
       sttConnOptions: { ...DEFAULT_API_CONNECT_OPTIONS, ...connOptions?.sttConnOptions },
@@ -299,8 +307,8 @@ export class AgentSession<
       this.tts = tts;
     }
 
-    this.turnDetection = sessionOptions?.turnHandling?.turnDetection;
-    this._interruptionDetection = sessionOptions?.turnHandling?.interruption?.mode;
+    this.turnDetection = resolvedSessionOptions.turnHandling.turnDetection;
+    this._interruptionDetection = resolvedSessionOptions.turnHandling.interruption?.mode;
     this._userData = userData;
 
     // configurable IO
@@ -309,8 +317,9 @@ export class AgentSession<
 
     // This is the "global" chat context, it holds the entire conversation history
     this._chatCtx = ChatContext.empty();
-    this.options = opts.options;
-    this._aecWarmupRemaining = this.options.aecWarmupDuration ?? 0;
+    this.sessionOptions = resolvedSessionOptions;
+    this.options = legacyVoiceOptions;
+    this._aecWarmupRemaining = this.sessionOptions.aecWarmupDuration ?? 0;
 
     this._onUserInputTranscribed = this._onUserInputTranscribed.bind(this);
     this.on(AgentSessionEventTypes.UserInputTranscribed, this._onUserInputTranscribed);
@@ -322,9 +331,6 @@ export class AgentSession<
   ): boolean {
     const eventData = args[0] as AgentEvent;
     this._recordedEvents.push(eventData);
-    if (event === AgentSessionEventTypes.MetricsCollected) {
-      this._usageCollector.collect((eventData as MetricsCollectedEvent).metrics);
-    }
     return super.emit(event, ...args);
   }
 
@@ -366,7 +372,7 @@ export class AgentSession<
   }
 
   get useTtsAlignedTranscript(): boolean {
-    return this.options.useTtsAlignedTranscript;
+    return this.sessionOptions.useTtsAlignedTranscript;
   }
 
   set userData(value: UserData) {
@@ -422,9 +428,11 @@ export class AgentSession<
 
       this._roomIO.start();
 
-      this.clientEventsHandler = new ClientEventsHandler(this, this._roomIO);
+      const transport = new RoomSessionTransport(room, this._roomIO);
+      this.sessionHost = new SessionHost(transport);
+      this.sessionHost.registerSession(this);
       if (inputOptions?.textEnabled !== false) {
-        this.clientEventsHandler.registerTextInput(
+        this.sessionHost.registerTextInput(
           inputOptions?.textInputCallback ?? DEFAULT_TEXT_INPUT_CALLBACK,
         );
       }
@@ -470,8 +478,8 @@ export class AgentSession<
 
     await Promise.allSettled(tasks);
 
-    if (this.clientEventsHandler) {
-      await this.clientEventsHandler.start();
+    if (this.sessionHost) {
+      await this.sessionHost.start();
     }
 
     // Log used IO configuration
@@ -877,7 +885,9 @@ export class AgentSession<
     if (this.closingTask) {
       return;
     }
-    this.closeImpl(reason, error, drain);
+    this.closingTask = this.closeImpl(reason, error, drain).finally(() => {
+      this.closingTask = null;
+    });
   }
 
   /** @internal */
@@ -900,13 +910,11 @@ export class AgentSession<
         return;
       }
     } else if (error.type === 'interruption_detection_error') {
-      this.interruptionDetectionErrorCounts += 1;
-      if (this.interruptionDetectionErrorCounts <= this._connOptions.maxUnrecoverableErrors) {
-        return;
-      }
+      this.logger.error(error.toString());
+      return;
     }
 
-    this.logger.error(error, 'AgentSession is closing due to unrecoverable error');
+    this.logger.error(error, 'AgentSession is closing due to an unrecoverable error');
 
     this.closingTask = (async () => {
       await this.closeImpl(CloseReason.ERROR, error);
@@ -935,7 +943,6 @@ export class AgentSession<
     if (state === 'speaking') {
       this.llmErrorCounts = 0;
       this.ttsErrorCounts = 0;
-      this.interruptionDetectionErrorCounts = 0;
 
       if (this.agentSpeakingSpan === undefined) {
         this.agentSpeakingSpan = tracer.startSpan({
@@ -980,7 +987,10 @@ export class AgentSession<
   }
 
   /** @internal */
-  _updateUserState(state: UserState, lastSpeakingTime?: number) {
+  _updateUserState(
+    state: UserState,
+    options?: { lastSpeakingTime?: number; otelContext?: Context },
+  ) {
     if (this._userState === state) {
       return;
     }
@@ -988,8 +998,8 @@ export class AgentSession<
     if (state === 'speaking' && this._userSpeakingSpan === undefined) {
       this._userSpeakingSpan = tracer.startSpan({
         name: 'user_speaking',
-        context: this.rootSpanContext,
-        startTime: lastSpeakingTime,
+        context: options?.otelContext ?? this.rootSpanContext,
+        startTime: options?.lastSpeakingTime,
       });
 
       const linked = this._roomIO?.linkedParticipant;
@@ -997,7 +1007,7 @@ export class AgentSession<
         setParticipantSpanAttributes(this._userSpeakingSpan, linked);
       }
     } else if (this._userSpeakingSpan !== undefined) {
-      this._userSpeakingSpan.end(lastSpeakingTime);
+      this._userSpeakingSpan.end(options?.lastSpeakingTime);
       this._userSpeakingSpan = undefined;
     }
 
@@ -1035,7 +1045,10 @@ export class AgentSession<
   private _setUserAwayTimer(): void {
     this._cancelUserAwayTimer();
 
-    if (this.options.userAwayTimeout === null || this.options.userAwayTimeout === undefined) {
+    if (
+      this.sessionOptions.userAwayTimeout === null ||
+      this.sessionOptions.userAwayTimeout === undefined
+    ) {
       return;
     }
 
@@ -1046,7 +1059,7 @@ export class AgentSession<
     this.userAwayTimer = setTimeout(() => {
       this.logger.debug('User away timeout triggered');
       this._updateUserState('away');
-    }, this.options.userAwayTimeout * 1000);
+    }, this.sessionOptions.userAwayTimeout * 1000);
   }
 
   private _cancelUserAwayTimer(): void {
@@ -1120,7 +1133,6 @@ export class AgentSession<
         try {
           await this.activity.interrupt({ force: true }).await;
         } catch (error) {
-          // Uninterruptible speech can throw during forced interruption.
           this.logger.warn({ error }, 'Error interrupting activity');
         }
       }
@@ -1150,8 +1162,8 @@ export class AgentSession<
     this.output.audio = null;
     this.output.transcription = null;
 
-    await this.clientEventsHandler?.close();
-    this.clientEventsHandler = undefined;
+    await this.sessionHost?.close();
+    this.sessionHost = undefined;
 
     await this._roomIO?.close();
     this._roomIO = undefined;
@@ -1183,7 +1195,6 @@ export class AgentSession<
     this.rootSpanContext = undefined;
     this.llmErrorCounts = 0;
     this.ttsErrorCounts = 0;
-    this.interruptionDetectionErrorCounts = 0;
 
     this.logger.info({ reason, error }, 'AgentSession closed');
   }

package/src/voice/audio_recognition.ts

@@ -12,6 +12,8 @@ import {
 } from '@opentelemetry/api';
 import type { WritableStreamDefaultWriter } from 'node:stream/web';
 import { ReadableStream } from 'node:stream/web';
+import { isAPIError } from '../_exceptions.js';
+import { apiConnectDefaults, intervalForRetry } from '../inference/interruption/defaults.js';
 import { InterruptionDetectionError } from '../inference/interruption/errors.js';
 import type { AdaptiveInterruptionDetector } from '../inference/interruption/interruption_detector.js';
 import { InterruptionStreamSentinel } from '../inference/interruption/interruption_stream.js';
@@ -19,6 +21,7 @@ import {
   type InterruptionSentinel,
   type OverlappingSpeechEvent,
 } from '../inference/interruption/types.js';
+import type { LanguageCode } from '../language.js';
 import { type ChatContext } from '../llm/chat_context.js';
 import { log } from '../log.js';
 import { DeferredReadableStream, isStreamReaderReleaseError } from '../stream/deferred_stream.js';
@@ -71,8 +74,8 @@ export interface _TurnDetector {
   readonly model: string;
   /** The provider name for this turn detector. */
   readonly provider: string;
-  unlikelyThreshold: (language?: string) => Promise<number | undefined>;
-  supportsLanguage: (language?: string) => Promise<boolean>;
+  unlikelyThreshold: (language?: LanguageCode) => Promise<number | undefined>;
+  supportsLanguage: (language?: LanguageCode) => Promise<boolean>;
   predictEndOfTurn(chatCtx: ChatContext, timeout?: number): Promise<number>;
 }
 
@@ -121,7 +124,7 @@ export class AudioRecognition {
   private turnDetectionMode?: TurnDetectionMode;
   private minEndpointingDelay: number;
   private maxEndpointingDelay: number;
-  private lastLanguage?: string;
+  private lastLanguage?: LanguageCode;
   private rootSpanContext?: Context;
   private sttModel?: string;
   private sttProvider?: string;
@@ -249,6 +252,15 @@ export class AudioRecognition {
     await this.interruptionTask?.cancelAndWait();
   }
 
+  async disableInterruptionDetection(): Promise<void> {
+    this.isInterruptionEnabled = false;
+    this.interruptionDetection = undefined;
+    await this.interruptionTask?.cancelAndWait();
+    this.interruptionTask = undefined;
+    await this.interruptionStreamChannel?.close();
+    this.interruptionStreamChannel = undefined;
+  }
+
   async onStartOfAgentSpeech() {
     this.isAgentSpeaking = true;
     return this.trySendInterruptionSentinel(InterruptionStreamSentinel.agentSpeechStarted());
@@ -1000,77 +1012,128 @@ export class AudioRecognition {
   ) {
     if (!interruptionDetection || !this.interruptionStreamChannel) return;
 
-    const stream = interruptionDetection.createStream();
-    const inputReader = this.interruptionStreamChannel.stream().getReader();
+    let numRetries = 0;
+    const maxRetries = apiConnectDefaults.maxRetries;
 
-    const cleanup = async () => {
-      try {
-        signal.removeEventListener('abort', abortHandler);
-        eventReader.releaseLock();
-        await stream.close();
-      } catch (e) {
-        this.logger.debug('createInterruptionTask: error during abort handler:', e);
-      }
-    };
+    while (!signal.aborted) {
+      const stream = interruptionDetection.createStream();
+      const eventReader = stream.stream().getReader();
+
+      const cleanup = async () => {
+        try {
+          signal.removeEventListener('abort', cleanup);
+          eventReader.releaseLock();
+          await stream.close();
+        } catch (e) {
+          this.logger.debug('createInterruptionTask: error during cleanup:', e);
+        }
+      };
+
+      signal.addEventListener('abort', cleanup, { once: true });
+
+      let forwardTask: Promise<void> | undefined;
 
-    // Forward input frames/sentinels to the interruption stream
-    const forwardTask = (async () => {
       try {
+        // Unlike Python where _agent_speech_started lives on `self` and survives retries,
+        // JS creates a fresh InterruptionStreamBase per retry with agentSpeechStarted = false.
+        // Re-inject the sentinel so the new stream knows the agent is mid-speech.
+        if (numRetries > 0 && this.isAgentSpeaking) {
+          await stream.pushFrame(InterruptionStreamSentinel.agentSpeechStarted());
+        }
+
+        forwardTask = (async () => {
+          const inputReader = this.interruptionStreamChannel!.stream().getReader();
+          const abortPromise = waitForAbort(signal);
+
+          try {
+            while (!signal.aborted) {
+              const res = await Promise.race([inputReader.read(), abortPromise]);
+              if (!res) break;
+
+              const { value, done } = res;
+              if (done) break;
+
+              if (value instanceof AudioFrame) {
+                const frameDurationMs = (value.samplesPerChannel / value.sampleRate) * 1000;
+                this._inputStartedAt ??= Date.now() - frameDurationMs;
+              } else {
+                this._inputStartedAt ??= Date.now();
+              }
+
+              await stream.pushFrame(value);
+            }
+          } finally {
+            inputReader.releaseLock();
+          }
+        })();
+
         const abortPromise = waitForAbort(signal);
+
         while (!signal.aborted) {
-          const res = await Promise.race([inputReader.read(), abortPromise]);
+          const res = await Promise.race([eventReader.read(), abortPromise]);
           if (!res) break;
-          const { value, done } = res;
+          const { done, value: ev } = res;
           if (done) break;
-          // Backdate to the actual start of the audio frame, not when it was received.
-          if (value instanceof AudioFrame) {
-            const frameDurationMs = (value.samplesPerChannel / value.sampleRate) * 1000;
-            this._inputStartedAt ??= Date.now() - frameDurationMs;
+          this.onOverlapSpeechEvent(ev);
+        }
+        break;
+      } catch (e) {
+        if (signal.aborted) break;
+
+        if (isAPIError(e)) {
+          if (maxRetries === 0 || !e.retryable) {
+            interruptionDetection.emitError(
+              new InterruptionDetectionError(
+                e.message,
+                Date.now(),
+                interruptionDetection.label,
+                false,
+              ),
+            );
+            break;
+          } else if (numRetries >= maxRetries) {
+            interruptionDetection.emitError(
+              new InterruptionDetectionError(
+                `failed to detect interruption after ${numRetries} attempts`,
+                Date.now(),
+                interruptionDetection.label,
+                false,
+              ),
+            );
+            break;
           } else {
-            this._inputStartedAt ??= Date.now();
+            const retryInterval = intervalForRetry(numRetries);
+            interruptionDetection.emitError(
+              new InterruptionDetectionError(
+                e.message,
+                Date.now(),
+                interruptionDetection.label,
+                true,
+              ),
+            );
+            this.logger.warn(
+              { model: interruptionDetection.label, attempt: numRetries },
+              `failed to detect interruption, retrying in ${retryInterval}ms`,
+            );
+            numRetries++;
+            await delay(retryInterval, { signal });
           }
-          await stream.pushFrame(value);
+        } else {
+          const msg = e instanceof Error ? e.message : String(e);
+          interruptionDetection.emitError(
+            new InterruptionDetectionError(msg, Date.now(), interruptionDetection.label, false),
+          );
+          this.logger.error(e, 'Error in interruption task');
+          break;
         }
       } finally {
-        inputReader.releaseLock();
-      }
-    })();
-
-    // Read output events from the interruption stream
-    const eventReader = stream.stream().getReader();
-    const abortHandler = async () => {
-      await cleanup();
-    };
-    signal.addEventListener('abort', abortHandler);
-
-    try {
-      const abortPromise = waitForAbort(signal);
-
-      while (!signal.aborted) {
-        const res = await Promise.race([eventReader.read(), abortPromise]);
-        if (!res) break;
-        const { done, value: ev } = res;
-        if (done) break;
-        this.onOverlapSpeechEvent(ev);
-      }
-    } catch (e) {
-      if (!signal.aborted) {
-        const cause = e instanceof Error ? e : new Error(String(e));
-        interruptionDetection.emitError(
-          new InterruptionDetectionError(
-            cause.message,
-            Date.now(),
-            interruptionDetection.label,
-            false,
-          ),
-        );
-        this.logger.error(e, 'Error in interruption task');
+        await cleanup();
+        await forwardTask?.catch((e) => {
+          this.logger.debug({ err: e }, 'interruption task exited with error');
+        });
       }
-    } finally {
-      await cleanup();
-      await forwardTask;
-      this.logger.debug('Interruption task closed');
     }
+    this.logger.debug('Interruption task closed');
   }
 
   setInputAudioStream(audioStream: ReadableStream<AudioFrame>) {