@livekit/agents 1.0.43 → 1.0.45

package/dist/tts/fallback_adapter.d.cts

@@ -0,0 +1,110 @@
+import { AudioResampler } from '@livekit/rtc-node';
+import { type APIConnectOptions } from '../types.js';
+import { Task } from '../utils.js';
+import { ChunkedStream, SynthesizeStream, TTS } from './tts.js';
+/**
+ * Internal status tracking for each TTS instance.
+ * @internal
+ */
+interface TTSStatus {
+    available: boolean;
+    recoveringTask: Task<void> | null;
+}
+/**
+ * Options for creating a FallbackAdapter.
+ */
+export interface FallbackAdapterOptions {
+    /** List of TTS instances to use for fallback (in priority order). At least one is required. */
+    ttsInstances: TTS[];
+    /** Number of internal retries per TTS instance before moving to the next one. Defaults to 2. */
+    maxRetryPerTTS?: number;
+    /** Delay in milliseconds before attempting to recover a failed TTS instance. Defaults to 1000. */
+    recoveryDelayMs?: number;
+}
+/**
+ * Event emitted when a TTS instance's availability changes.
+ */
+export interface AvailabilityChangedEvent {
+    /** The TTS instance whose availability changed. */
+    tts: TTS;
+    /** Whether the TTS instance is now available. */
+    available: boolean;
+}
+/**
+ * FallbackAdapter is a TTS wrapper that provides automatic failover between multiple TTS providers.
+ *
+ * When the primary TTS fails, it automatically switches to the next available provider in the list.
+ * Failed providers are monitored in the background and restored when they recover.
+ *
+ * Features:
+ * - Automatic failover to backup TTS providers on failure
+ * - Background health checks to restore recovered providers
+ * - Automatic audio resampling when TTS providers have different sample rates
+ * - Support for both streaming and non-streaming TTS providers
+ *
+ * @example
+ * ```typescript
+ * import { FallbackAdapter } from '@livekit/agents';
+ * import { TTS as OpenAITTS } from '@livekit/agents-plugin-openai';
+ * import { TTS as ElevenLabsTTS } from '@livekit/agents-plugin-elevenlabs';
+ *
+ * const fallbackTTS = new FallbackAdapter({
+ *   ttsInstances: [
+ *     new OpenAITTS(),      // Primary
+ *     new ElevenLabsTTS(),  // Fallback
+ *   ],
+ *   maxRetryPerTTS: 2,      // Retry each TTS twice before moving to next
+ *   recoveryDelayMs: 1000,  // Check recovery every 1 second
+ * });
+ *
+ * ```
+ */
+export declare class FallbackAdapter extends TTS {
+    /** The list of TTS instances used for fallback (in priority order). */
+    readonly ttsInstances: TTS[];
+    /** Number of retries per TTS instance before falling back to the next one. */
+    readonly maxRetryPerTTS: number;
+    /** Delay in milliseconds before attempting to recover a failed TTS instance. */
+    readonly recoveryDelayMs: number;
+    private _status;
+    private _logger;
+    private _recoveryTimeouts;
+    label: string;
+    constructor(opts: FallbackAdapterOptions);
+    private static aggregateCapabilities;
+    private setupEventForwarding;
+    /**
+     * Returns the current status of all TTS instances, including availability and recovery state.
+     */
+    get status(): TTSStatus[];
+    getStreamingInstance(index: number): TTS;
+    /**
+     * Creates a new AudioResampler for the given TTS index if needed.
+     * Returns null if the TTS sample rate matches the adapter's output rate.
+     * Each stream should create its own resampler to avoid concurrency issues.
+     * @internal
+     */
+    createResamplerForTTS(index: number): AudioResampler | null;
+    private emitAvailabilityChanged;
+    private tryRecovery;
+    markUnAvailable(index: number): void;
+    /**
+     * Receives text and returns synthesis in the form of a {@link ChunkedStream}
+     */
+    synthesize(text: string, connOptions?: APIConnectOptions, abortSignal?: AbortSignal): ChunkedStream;
+    /**
+     * Returns a {@link SynthesizeStream} that can be used to push text and receive audio data
+     *
+     * @param options - Optional configuration including connection options
+     */
+    stream(options?: {
+        connOptions?: APIConnectOptions;
+    }): SynthesizeStream;
+    /**
+     * Close the FallbackAdapter and all underlying TTS instances.
+     * This cancels any ongoing recovery tasks and cleans up resources.
+     */
+    close(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=fallback_adapter.d.ts.map

package/dist/tts/fallback_adapter.d.ts

@@ -0,0 +1,110 @@
+import { AudioResampler } from '@livekit/rtc-node';
+import { type APIConnectOptions } from '../types.js';
+import { Task } from '../utils.js';
+import { ChunkedStream, SynthesizeStream, TTS } from './tts.js';
+/**
+ * Internal status tracking for each TTS instance.
+ * @internal
+ */
+interface TTSStatus {
+    available: boolean;
+    recoveringTask: Task<void> | null;
+}
+/**
+ * Options for creating a FallbackAdapter.
+ */
+export interface FallbackAdapterOptions {
+    /** List of TTS instances to use for fallback (in priority order). At least one is required. */
+    ttsInstances: TTS[];
+    /** Number of internal retries per TTS instance before moving to the next one. Defaults to 2. */
+    maxRetryPerTTS?: number;
+    /** Delay in milliseconds before attempting to recover a failed TTS instance. Defaults to 1000. */
+    recoveryDelayMs?: number;
+}
+/**
+ * Event emitted when a TTS instance's availability changes.
+ */
+export interface AvailabilityChangedEvent {
+    /** The TTS instance whose availability changed. */
+    tts: TTS;
+    /** Whether the TTS instance is now available. */
+    available: boolean;
+}
+/**
+ * FallbackAdapter is a TTS wrapper that provides automatic failover between multiple TTS providers.
+ *
+ * When the primary TTS fails, it automatically switches to the next available provider in the list.
+ * Failed providers are monitored in the background and restored when they recover.
+ *
+ * Features:
+ * - Automatic failover to backup TTS providers on failure
+ * - Background health checks to restore recovered providers
+ * - Automatic audio resampling when TTS providers have different sample rates
+ * - Support for both streaming and non-streaming TTS providers
+ *
+ * @example
+ * ```typescript
+ * import { FallbackAdapter } from '@livekit/agents';
+ * import { TTS as OpenAITTS } from '@livekit/agents-plugin-openai';
+ * import { TTS as ElevenLabsTTS } from '@livekit/agents-plugin-elevenlabs';
+ *
+ * const fallbackTTS = new FallbackAdapter({
+ *   ttsInstances: [
+ *     new OpenAITTS(),      // Primary
+ *     new ElevenLabsTTS(),  // Fallback
+ *   ],
+ *   maxRetryPerTTS: 2,      // Retry each TTS twice before moving to next
+ *   recoveryDelayMs: 1000,  // Check recovery every 1 second
+ * });
+ *
+ * ```
+ */
+export declare class FallbackAdapter extends TTS {
+    /** The list of TTS instances used for fallback (in priority order). */
+    readonly ttsInstances: TTS[];
+    /** Number of retries per TTS instance before falling back to the next one. */
+    readonly maxRetryPerTTS: number;
+    /** Delay in milliseconds before attempting to recover a failed TTS instance. */
+    readonly recoveryDelayMs: number;
+    private _status;
+    private _logger;
+    private _recoveryTimeouts;
+    label: string;
+    constructor(opts: FallbackAdapterOptions);
+    private static aggregateCapabilities;
+    private setupEventForwarding;
+    /**
+     * Returns the current status of all TTS instances, including availability and recovery state.
+     */
+    get status(): TTSStatus[];
+    getStreamingInstance(index: number): TTS;
+    /**
+     * Creates a new AudioResampler for the given TTS index if needed.
+     * Returns null if the TTS sample rate matches the adapter's output rate.
+     * Each stream should create its own resampler to avoid concurrency issues.
+     * @internal
+     */
+    createResamplerForTTS(index: number): AudioResampler | null;
+    private emitAvailabilityChanged;
+    private tryRecovery;
+    markUnAvailable(index: number): void;
+    /**
+     * Receives text and returns synthesis in the form of a {@link ChunkedStream}
+     */
+    synthesize(text: string, connOptions?: APIConnectOptions, abortSignal?: AbortSignal): ChunkedStream;
+    /**
+     * Returns a {@link SynthesizeStream} that can be used to push text and receive audio data
+     *
+     * @param options - Optional configuration including connection options
+     */
+    stream(options?: {
+        connOptions?: APIConnectOptions;
+    }): SynthesizeStream;
+    /**
+     * Close the FallbackAdapter and all underlying TTS instances.
+     * This cancels any ongoing recovery tasks and cleans up resources.
+     */
+    close(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=fallback_adapter.d.ts.map

package/dist/tts/fallback_adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fallback_adapter.d.ts","sourceRoot":"","sources":["../../src/tts/fallback_adapter.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAInD,OAAO,EAAE,KAAK,iBAAiB,EAA+B,MAAM,aAAa,CAAC;AAClF,OAAO,EAAE,IAAI,EAAiB,MAAM,aAAa,CAAC;AAElD,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,GAAG,EAAwB,MAAM,UAAU,CAAC;AAEtF;;;GAGG;AACH,UAAU,SAAS;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,+FAA+F;IAC/F,YAAY,EAAE,GAAG,EAAE,CAAC;IACpB,gGAAgG;IAChG,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kGAAkG;IAClG,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,mDAAmD;IACnD,GAAG,EAAE,GAAG,CAAC;IACT,iDAAiD;IACjD,SAAS,EAAE,OAAO,CAAC;CACpB;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,eAAgB,SAAQ,GAAG;IACtC,uEAAuE;IACvE,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE,CAAC;IAC7B,8EAA8E;IAC9E,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,gFAAgF;IAChF,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IAEjC,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,iBAAiB,CAA0C;IAEnE,KAAK,EAAE,MAAM,CAAyB;gBAE1B,IAAI,EAAE,sBAAsB;IAqBxC,OAAO,CAAC,MAAM,CAAC,qBAAqB;IAMpC,OAAO,CAAC,oBAAoB;IAW5B;;OAEG;IACH,IAAI,MAAM,IAAI,SAAS,EAAE,CAExB;IAED,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG;IASxC;;;;;OAKG;IACH,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAW3D,OAAO,CAAC,uBAAuB;IAQ/B,OAAO,CAAC,WAAW;IA8CnB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAYpC;;OAEG;IACH,UAAU,CACR,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,iBAAiB,EAC/B,WAAW,CAAC,EAAE,WAAW,GACxB,aAAa;IAShB;;;;OAIG;IACH,MAAM,CAAC,OAAO,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,iBAAiB,CAAA;KAAE,GAAG,gBAAgB;IAOvE;;;OAGG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAyB7B"}

package/dist/tts/fallback_adapter.js

@@ -0,0 +1,442 @@
+import { AudioResampler } from "@livekit/rtc-node";
+import { APIConnectionError, APIError } from "../_exceptions.js";
+import { log } from "../log.js";
+import { basic } from "../tokenize/index.js";
+import { DEFAULT_API_CONNECT_OPTIONS } from "../types.js";
+import { Task, cancelAndWait } from "../utils.js";
+import { StreamAdapter } from "./stream_adapter.js";
+import { ChunkedStream, SynthesizeStream, TTS } from "./tts.js";
+const DEFAULT_FALLBACK_API_CONNECT_OPTIONS = {
+  maxRetry: 0,
+  timeoutMs: DEFAULT_API_CONNECT_OPTIONS.timeoutMs,
+  retryIntervalMs: DEFAULT_API_CONNECT_OPTIONS.retryIntervalMs
+};
+const FORWARD_POLL_MS = 10;
+class FallbackAdapter extends TTS {
+  /** The list of TTS instances used for fallback (in priority order). */
+  ttsInstances;
+  /** Number of retries per TTS instance before falling back to the next one. */
+  maxRetryPerTTS;
+  /** Delay in milliseconds before attempting to recover a failed TTS instance. */
+  recoveryDelayMs;
+  _status = [];
+  _logger = log();
+  _recoveryTimeouts = /* @__PURE__ */ new Map();
+  label = `tts.FallbackAdapter`;
+  constructor(opts) {
+    if (!opts.ttsInstances || opts.ttsInstances.length < 1) {
+      throw new Error("at least one TTS instance must be provided.");
+    }
+    const numChannels = opts.ttsInstances[0].numChannels;
+    const allNumChannelsMatch = opts.ttsInstances.every((tts) => tts.numChannels === numChannels);
+    if (!allNumChannelsMatch) {
+      throw new Error("All TTS instances should have the same number of channels");
+    }
+    const sampleRate = Math.max(...opts.ttsInstances.map((t) => t.sampleRate));
+    const capabilities = FallbackAdapter.aggregateCapabilities(opts.ttsInstances);
+    super(sampleRate, numChannels, capabilities);
+    this.ttsInstances = opts.ttsInstances;
+    this.maxRetryPerTTS = opts.maxRetryPerTTS ?? 2;
+    this.recoveryDelayMs = opts.recoveryDelayMs ?? 1e3;
+    this._status = opts.ttsInstances.map(() => ({
+      available: true,
+      recoveringTask: null
+    }));
+    this.setupEventForwarding();
+  }
+  static aggregateCapabilities(instances) {
+    const streaming = instances.some((tts) => tts.capabilities.streaming);
+    const alignedTranscript = instances.every((tts) => tts.capabilities.alignedTranscript === true);
+    return { streaming, alignedTranscript };
+  }
+  setupEventForwarding() {
+    this.ttsInstances.forEach((tts) => {
+      tts.on("metrics_collected", (metrics) => {
+        this.emit("metrics_collected", metrics);
+      });
+      tts.on("error", (error) => {
+        this.emit("error", error);
+      });
+    });
+  }
+  /**
+   * Returns the current status of all TTS instances, including availability and recovery state.
+   */
+  get status() {
+    return this._status;
+  }
+  getStreamingInstance(index) {
+    const tts = this.ttsInstances[index];
+    if (tts.capabilities.streaming) {
+      return tts;
+    }
+    return new StreamAdapter(tts, new basic.SentenceTokenizer());
+  }
+  /**
+   * Creates a new AudioResampler for the given TTS index if needed.
+   * Returns null if the TTS sample rate matches the adapter's output rate.
+   * Each stream should create its own resampler to avoid concurrency issues.
+   * @internal
+   */
+  createResamplerForTTS(index) {
+    const tts = this.ttsInstances[index];
+    if (this.sampleRate !== tts.sampleRate) {
+      this._logger.debug(
+        `resampling ${tts.label} from ${tts.sampleRate}Hz to ${this.sampleRate}Hz`
+      );
+      return new AudioResampler(tts.sampleRate, this.sampleRate, tts.numChannels);
+    }
+    return null;
+  }
+  emitAvailabilityChanged(tts, available) {
+    const event = { tts, available };
+    this.emit(
+      "tts_availability_changed",
+      event
+    );
+  }
+  tryRecovery(index) {
+    const status = this._status[index];
+    const tts = this.ttsInstances[index];
+    if (status.recoveringTask && !status.recoveringTask.done) {
+      return;
+    }
+    status.recoveringTask = Task.from(async (controller) => {
+      try {
+        const testStream = tts.synthesize(
+          "Hello world, this is a recovery test.",
+          {
+            maxRetry: 0,
+            timeoutMs: 1e4,
+            retryIntervalMs: 1e3
+          },
+          controller.signal
+        );
+        let audioReceived = false;
+        for await (const _ of testStream) {
+          audioReceived = true;
+        }
+        if (!audioReceived) {
+          throw new Error("Recovery test completed but no audio was received");
+        }
+        status.available = true;
+        status.recoveringTask = null;
+        this._logger.info({ tts: tts.label }, "TTS recovered");
+        this.emitAvailabilityChanged(tts, true);
+      } catch (error) {
+        status.recoveringTask = null;
+        if (controller.signal.aborted) {
+          return;
+        }
+        this._logger.debug({ tts: tts.label, error }, "TTS recovery failed, will retry");
+        const timeoutId = setTimeout(() => {
+          this._recoveryTimeouts.delete(index);
+          this.tryRecovery(index);
+        }, this.recoveryDelayMs);
+        this._recoveryTimeouts.set(index, timeoutId);
+      }
+    });
+  }
+  markUnAvailable(index) {
+    const status = this._status[index];
+    if (status.recoveringTask && !status.recoveringTask.done) {
+      return;
+    }
+    if (status.available) {
+      status.available = false;
+      this.emitAvailabilityChanged(this.ttsInstances[index], false);
+    }
+    this.tryRecovery(index);
+  }
+  /**
+   * Receives text and returns synthesis in the form of a {@link ChunkedStream}
+   */
+  synthesize(text, connOptions, abortSignal) {
+    return new FallbackChunkedStream(
+      this,
+      text,
+      connOptions ?? DEFAULT_FALLBACK_API_CONNECT_OPTIONS,
+      abortSignal
+    );
+  }
+  /**
+   * Returns a {@link SynthesizeStream} that can be used to push text and receive audio data
+   *
+   * @param options - Optional configuration including connection options
+   */
+  stream(options) {
+    return new FallbackSynthesizeStream(
+      this,
+      (options == null ? void 0 : options.connOptions) ?? DEFAULT_FALLBACK_API_CONNECT_OPTIONS
+    );
+  }
+  /**
+   * Close the FallbackAdapter and all underlying TTS instances.
+   * This cancels any ongoing recovery tasks and cleans up resources.
+   */
+  async close() {
+    this._recoveryTimeouts.forEach((timeoutId) => {
+      clearTimeout(timeoutId);
+    });
+    this._recoveryTimeouts.clear();
+    const recoveryTasks = this._status.map((s) => s.recoveringTask).filter((t) => t !== null);
+    if (recoveryTasks.length > 0) {
+      await cancelAndWait(recoveryTasks, 1e3);
+    }
+    for (const tts of this.ttsInstances) {
+      tts.removeAllListeners("metrics_collected");
+      tts.removeAllListeners("error");
+    }
+    await Promise.all(this.ttsInstances.map((tts) => tts.close()));
+  }
+}
+class FallbackChunkedStream extends ChunkedStream {
+  adapter;
+  connOptions;
+  _logger = log();
+  label = "tts.FallbackChunkedStream";
+  constructor(adapter, text, connOptions, abortSignal) {
+    super(text, adapter, connOptions, abortSignal);
+    this.adapter = adapter;
+    this.connOptions = connOptions;
+  }
+  async run() {
+    const allTTSFailed = this.adapter.status.every((s) => !s.available);
+    let lastRequestId = "";
+    let lastSegmentId = "";
+    if (allTTSFailed) {
+      this._logger.warn("All fallback TTS instances failed, retrying from first...");
+    }
+    for (let i = 0; i < this.adapter.ttsInstances.length; i++) {
+      const tts = this.adapter.ttsInstances[i];
+      const status = this.adapter.status[i];
+      if (!status.available && !allTTSFailed) {
+        this.adapter.markUnAvailable(i);
+        continue;
+      }
+      try {
+        this._logger.debug({ tts: tts.label }, "attempting TTS synthesis");
+        const connOptions = {
+          ...this.connOptions,
+          maxRetry: this.adapter.maxRetryPerTTS
+        };
+        const stream = tts.synthesize(this.inputText, connOptions, this.abortSignal);
+        let audioReceived = false;
+        const resampler = this.adapter.createResamplerForTTS(i);
+        for await (const audio of stream) {
+          if (this.abortController.signal.aborted) {
+            stream.close();
+            return;
+          }
+          if (resampler) {
+            for (const frame of resampler.push(audio.frame)) {
+              this.queue.put({
+                ...audio,
+                frame
+              });
+              audioReceived = true;
+            }
+          } else {
+            this.queue.put(audio);
+            audioReceived = true;
+          }
+          lastRequestId = audio.requestId;
+          lastSegmentId = audio.segmentId;
+        }
+        if (resampler) {
+          for (const frame of resampler.flush()) {
+            this.queue.put({
+              requestId: lastRequestId || "",
+              segmentId: lastSegmentId || "",
+              frame,
+              final: true
+            });
+            audioReceived = true;
+          }
+        }
+        if (!audioReceived) {
+          throw new APIConnectionError({
+            message: "TTS synthesis completed but no audio was received"
+          });
+        }
+        this._logger.debug({ tts: tts.label }, "TTS synthesis succeeded");
+        return;
+      } catch (error) {
+        if (error instanceof APIError || error instanceof APIConnectionError) {
+          this._logger.warn({ tts: tts.label, error }, "TTS failed, switching to next instance");
+          this.adapter.markUnAvailable(i);
+        } else {
+          throw error;
+        }
+      }
+    }
+    const labels = this.adapter.ttsInstances.map((t) => t.label).join(", ");
+    throw new APIConnectionError({
+      message: `all TTS instances failed (${labels})`
+    });
+  }
+}
+class FallbackSynthesizeStream extends SynthesizeStream {
+  adapter;
+  tokenBuffer = [];
+  audioPushed = false;
+  _logger = log();
+  label = "tts.FallbackSynthesizeStream";
+  constructor(adapter, connOptions) {
+    super(adapter, connOptions);
+    this.adapter = adapter;
+  }
+  async run() {
+    const allTTSFailed = this.adapter.status.every((s) => !s.available);
+    if (allTTSFailed) {
+      this._logger.warn("All fallback TTS instances failed, retrying from first...");
+    }
+    const readInputLLMStream = (async () => {
+      try {
+        for await (const input of this.input) {
+          if (this.abortController.signal.aborted) break;
+          this.tokenBuffer.push(input);
+        }
+      } catch (error) {
+        this._logger.debug({ error }, "Error reading input LLM stream");
+        throw error;
+      } finally {
+        this.tokenBuffer.push(SynthesizeStream.END_OF_STREAM);
+      }
+    })();
+    for (let i = 0; i < this.adapter.ttsInstances.length; i++) {
+      const tts = this.adapter.getStreamingInstance(i);
+      const originalTts = this.adapter.ttsInstances[i];
+      const status = this.adapter.status[i];
+      let lastRequestId = "";
+      let lastSegmentId = "";
+      if (!status.available && !allTTSFailed) {
+        this.adapter.markUnAvailable(i);
+        continue;
+      }
+      try {
+        this._logger.debug({ tts: originalTts.label }, "attempting TTS stream");
+        const connOptions = {
+          ...this.connOptions,
+          maxRetry: this.adapter.maxRetryPerTTS
+        };
+        const stream = tts.stream({ connOptions });
+        const resampler = this.adapter.createResamplerForTTS(i);
+        let bufferIndex = 0;
+        let streamOutputCompleted = false;
+        const forwardBufferToTTS = async () => {
+          while (true) {
+            while (bufferIndex < this.tokenBuffer.length) {
+              const token = this.tokenBuffer[bufferIndex++];
+              if (token === SynthesizeStream.FLUSH_SENTINEL) {
+                stream.flush();
+              } else if (token === SynthesizeStream.END_OF_STREAM) {
+                stream.endInput();
+                return;
+              } else {
+                stream.pushText(token);
+              }
+            }
+            await new Promise((resolve) => setTimeout(resolve, FORWARD_POLL_MS));
+            if (this.abortController.signal.aborted || streamOutputCompleted) {
+              stream.endInput();
+              return;
+            }
+          }
+        };
+        const processOutput = async () => {
+          try {
+            for await (const audio of stream) {
+              if (this.abortController.signal.aborted) {
+                stream.close();
+                return;
+              }
+              if (audio === SynthesizeStream.END_OF_STREAM) {
+                continue;
+              }
+              if (resampler) {
+                for (const frame of resampler.push(audio.frame)) {
+                  this.queue.put({
+                    ...audio,
+                    frame
+                  });
+                  this.audioPushed = true;
+                }
+              } else {
+                this.queue.put(audio);
+                this.audioPushed = true;
+              }
+              lastRequestId = audio.requestId;
+              lastSegmentId = audio.segmentId;
+            }
+            if (resampler) {
+              for (const frame of resampler.flush()) {
+                this.queue.put({
+                  requestId: lastRequestId || "",
+                  segmentId: lastSegmentId || "",
+                  frame,
+                  final: true
+                });
+                this.audioPushed = true;
+              }
+            }
+          } finally {
+            streamOutputCompleted = true;
+          }
+        };
+        const [outputResult, forwardBufferResult] = await Promise.allSettled([
+          processOutput(),
+          forwardBufferToTTS().catch((err) => {
+            stream.close();
+            throw err;
+          })
+        ]);
+        if (outputResult.status === "rejected") {
+          stream.close();
+          throw outputResult.reason;
+        }
+        if (forwardBufferResult.status === "rejected") {
+          stream.close();
+          throw forwardBufferResult.reason;
+        }
+        if (!this.audioPushed) {
+          throw new APIConnectionError({
+            message: "TTS stream completed but no audio was received"
+          });
+        }
+        this.queue.put(SynthesizeStream.END_OF_STREAM);
+        this._logger.debug({ tts: originalTts.label }, "TTS stream succeeded");
+        await readInputLLMStream.catch(() => {
+        });
+        return;
+      } catch (error) {
+        if (this.audioPushed) {
+          this._logger.error(
+            { tts: originalTts.label },
+            "TTS failed after audio pushed, cannot fallback mid-utterance"
+          );
+          throw error;
+        }
+        if (error instanceof APIError || error instanceof APIConnectionError) {
+          this._logger.warn(
+            { tts: originalTts.label, error },
+            "TTS failed, switching to next instance"
+          );
+          this.adapter.markUnAvailable(i);
+        } else {
+          throw error;
+        }
+      }
+    }
+    await readInputLLMStream.catch(() => {
+    });
+    const labels = this.adapter.ttsInstances.map((t) => t.label).join(", ");
+    throw new APIConnectionError({
+      message: `all TTS instances failed (${labels})`
+    });
+  }
+}
+export {
+  FallbackAdapter
+};
+//# sourceMappingURL=fallback_adapter.js.map