@micdrop/server 2.1.0 → 2.2.1

package/dist/index.d.mts

@@ -4,7 +4,7 @@ import { z } from 'zod';
 import WebSocket, { WebSocket as WebSocket$1 } from 'ws';
 
 declare class Logger {
-    private readonly name;
+    name: string;
     constructor(name: string);
     log(...message: any[]): void;
 }
@@ -158,6 +158,7 @@ declare function handleError(socket: WebSocket, error: unknown): void;
 
 interface STTEvents {
     Transcript: [string];
+    Failed: [Buffer[]];
 }
 declare abstract class STT extends EventEmitter<STTEvents> {
     logger?: Logger;
@@ -171,9 +172,28 @@ declare class MockSTT extends STT {
     transcribe(): Promise<void>;
 }
 
-declare abstract class TTS {
+interface FallbackSTTOptions {
+    factories: Array<() => STT>;
+}
+declare class FallbackSTT extends STT {
+    private readonly options;
+    private stt;
+    private sttIndex;
+    constructor(options: FallbackSTTOptions);
+    transcribe(audioStream: Readable): void;
+    destroy(): void;
+    private startNextSTT;
+    private onTranscript;
+    private onFailed;
+}
+
+interface TTSEvents {
+    Audio: [Buffer];
+    Failed: [string[]];
+}
+declare abstract class TTS extends EventEmitter<TTSEvents> {
     logger?: Logger;
-    abstract speak(textStream: Readable): Readable;
+    abstract speak(textStream: Readable): void;
     abstract cancel(): void;
     protected log(...message: any[]): void;
     destroy(): void;
@@ -186,15 +206,35 @@ declare class MockTTS extends TTS {
     cancel(): void;
 }
 
+interface FallbackTTSOptions {
+    factories: Array<() => TTS>;
+}
+declare class FallbackTTS extends TTS {
+    private readonly options;
+    private tts;
+    private ttsIndex;
+    constructor(options: FallbackTTSOptions);
+    speak(textStream: Readable): void;
+    cancel(): void;
+    destroy(): void;
+    private startNextTTS;
+    private onAudio;
+    private onFailed;
+}
+
+interface MicdropServerEvents {
+    End: [MicdropCallSummary];
+    UserAudio: [Buffer];
+    AssistantAudio: [Buffer];
+}
 interface MicdropConfig {
     firstMessage?: string;
     generateFirstMessage?: boolean;
     agent: Agent;
     stt: STT;
     tts: TTS;
-    onEnd?(call: MicdropCallSummary): void;
 }
-declare class MicdropServer {
+declare class MicdropServer extends EventEmitter<MicdropServerEvents> {
     socket: WebSocket$1 | null;
     config: MicdropConfig | null;
     logger?: Logger;
@@ -211,20 +251,50 @@ declare class MicdropServer {
     cancel(): void;
     private onClose;
     private onMessage;
-    private onAudioChunk;
+    private onUserAudio;
     private onMute;
     private onStartSpeaking;
     private onStopSpeaking;
-    private onTranscript;
+    private onTranscriptSTT;
+    private onAudioTTS;
     private sendFirstMessage;
     answer(): void;
     private _answer;
     speak(message: string | Readable): void;
     private _speak;
-    sendAudio(audio: Readable): void;
-    private _sendAudio;
+}
+
+interface AudioMessage {
+    buffer: Buffer;
+    messageIndex: number;
+    message: string;
+    role: 'user' | 'assistant';
+}
+interface MicdropRecorderEvents {
+    AudioMessage: [AudioMessage];
+    Complete: [AudioMessage[]];
+}
+declare class MicdropRecorder extends EventEmitter<MicdropRecorderEvents> {
+    private server;
+    logger?: Logger;
+    private audioMessages;
+    private currentUserChunks;
+    private currentAssistantChunks;
+    private lastUserMessageIndex;
+    private lastAssistantMessageIndex;
+    constructor(server: MicdropServer);
+    private setupListeners;
+    private onUserAudio;
+    private onAssistantAudio;
+    private onMessage;
+    private finalizeUserAudio;
+    private finalizeAssistantAudio;
+    private onEnd;
+    getAudioMessages(): AudioMessage[];
+    destroy(): void;
+    protected log(...message: any[]): void;
 }
 
 declare function waitForParams<CallParams>(socket: WebSocket$1, validate: (params: any) => CallParams): Promise<CallParams>;
 
-export { AUTO_END_CALL_PROMPT, AUTO_END_CALL_TOOL_NAME, AUTO_IGNORE_USER_NOISE_PROMPT, AUTO_IGNORE_USER_NOISE_TOOL_NAME, AUTO_SEMANTIC_TURN_PROMPT, AUTO_SEMANTIC_TURN_TOOL_NAME, Agent, type AgentEvents, type AgentOptions, type DeepPartial, type ExtractJsonOptions, type ExtractOptions, type ExtractTagOptions, Logger, type MicdropAnswerMetadata, type MicdropCallSummary, MicdropClientCommands, type MicdropConfig, type MicdropConversation, type MicdropConversationItem, type MicdropConversationMessage, type MicdropConversationToolCall, type MicdropConversationToolResult, MicdropError, MicdropErrorCode, MicdropServer, MicdropServerCommands, type MicdropToolCall, MockAgent, MockSTT, MockTTS, STT, type STTEvents, TTS, type Tool, handleError, waitForParams };
+export { AUTO_END_CALL_PROMPT, AUTO_END_CALL_TOOL_NAME, AUTO_IGNORE_USER_NOISE_PROMPT, AUTO_IGNORE_USER_NOISE_TOOL_NAME, AUTO_SEMANTIC_TURN_PROMPT, AUTO_SEMANTIC_TURN_TOOL_NAME, Agent, type AgentEvents, type AgentOptions, type AudioMessage, type DeepPartial, type ExtractJsonOptions, type ExtractOptions, type ExtractTagOptions, FallbackSTT, type FallbackSTTOptions, FallbackTTS, type FallbackTTSOptions, Logger, type MicdropAnswerMetadata, type MicdropCallSummary, MicdropClientCommands, type MicdropConfig, type MicdropConversation, type MicdropConversationItem, type MicdropConversationMessage, type MicdropConversationToolCall, type MicdropConversationToolResult, MicdropError, MicdropErrorCode, MicdropRecorder, type MicdropRecorderEvents, MicdropServer, MicdropServerCommands, type MicdropServerEvents, type MicdropToolCall, MockAgent, MockSTT, MockTTS, STT, type STTEvents, TTS, type TTSEvents, type Tool, handleError, waitForParams };

package/dist/index.d.ts

@@ -4,7 +4,7 @@ import { z } from 'zod';
 import WebSocket, { WebSocket as WebSocket$1 } from 'ws';
 
 declare class Logger {
-    private readonly name;
+    name: string;
     constructor(name: string);
     log(...message: any[]): void;
 }
@@ -158,6 +158,7 @@ declare function handleError(socket: WebSocket, error: unknown): void;
 
 interface STTEvents {
     Transcript: [string];
+    Failed: [Buffer[]];
 }
 declare abstract class STT extends EventEmitter<STTEvents> {
     logger?: Logger;
@@ -171,9 +172,28 @@ declare class MockSTT extends STT {
     transcribe(): Promise<void>;
 }
 
-declare abstract class TTS {
+interface FallbackSTTOptions {
+    factories: Array<() => STT>;
+}
+declare class FallbackSTT extends STT {
+    private readonly options;
+    private stt;
+    private sttIndex;
+    constructor(options: FallbackSTTOptions);
+    transcribe(audioStream: Readable): void;
+    destroy(): void;
+    private startNextSTT;
+    private onTranscript;
+    private onFailed;
+}
+
+interface TTSEvents {
+    Audio: [Buffer];
+    Failed: [string[]];
+}
+declare abstract class TTS extends EventEmitter<TTSEvents> {
     logger?: Logger;
-    abstract speak(textStream: Readable): Readable;
+    abstract speak(textStream: Readable): void;
     abstract cancel(): void;
     protected log(...message: any[]): void;
     destroy(): void;
@@ -186,15 +206,35 @@ declare class MockTTS extends TTS {
     cancel(): void;
 }
 
+interface FallbackTTSOptions {
+    factories: Array<() => TTS>;
+}
+declare class FallbackTTS extends TTS {
+    private readonly options;
+    private tts;
+    private ttsIndex;
+    constructor(options: FallbackTTSOptions);
+    speak(textStream: Readable): void;
+    cancel(): void;
+    destroy(): void;
+    private startNextTTS;
+    private onAudio;
+    private onFailed;
+}
+
+interface MicdropServerEvents {
+    End: [MicdropCallSummary];
+    UserAudio: [Buffer];
+    AssistantAudio: [Buffer];
+}
 interface MicdropConfig {
     firstMessage?: string;
     generateFirstMessage?: boolean;
     agent: Agent;
     stt: STT;
     tts: TTS;
-    onEnd?(call: MicdropCallSummary): void;
 }
-declare class MicdropServer {
+declare class MicdropServer extends EventEmitter<MicdropServerEvents> {
     socket: WebSocket$1 | null;
     config: MicdropConfig | null;
     logger?: Logger;
@@ -211,20 +251,50 @@ declare class MicdropServer {
     cancel(): void;
     private onClose;
     private onMessage;
-    private onAudioChunk;
+    private onUserAudio;
     private onMute;
     private onStartSpeaking;
     private onStopSpeaking;
-    private onTranscript;
+    private onTranscriptSTT;
+    private onAudioTTS;
     private sendFirstMessage;
     answer(): void;
     private _answer;
     speak(message: string | Readable): void;
     private _speak;
-    sendAudio(audio: Readable): void;
-    private _sendAudio;
+}
+
+interface AudioMessage {
+    buffer: Buffer;
+    messageIndex: number;
+    message: string;
+    role: 'user' | 'assistant';
+}
+interface MicdropRecorderEvents {
+    AudioMessage: [AudioMessage];
+    Complete: [AudioMessage[]];
+}
+declare class MicdropRecorder extends EventEmitter<MicdropRecorderEvents> {
+    private server;
+    logger?: Logger;
+    private audioMessages;
+    private currentUserChunks;
+    private currentAssistantChunks;
+    private lastUserMessageIndex;
+    private lastAssistantMessageIndex;
+    constructor(server: MicdropServer);
+    private setupListeners;
+    private onUserAudio;
+    private onAssistantAudio;
+    private onMessage;
+    private finalizeUserAudio;
+    private finalizeAssistantAudio;
+    private onEnd;
+    getAudioMessages(): AudioMessage[];
+    destroy(): void;
+    protected log(...message: any[]): void;
 }
 
 declare function waitForParams<CallParams>(socket: WebSocket$1, validate: (params: any) => CallParams): Promise<CallParams>;
 
-export { AUTO_END_CALL_PROMPT, AUTO_END_CALL_TOOL_NAME, AUTO_IGNORE_USER_NOISE_PROMPT, AUTO_IGNORE_USER_NOISE_TOOL_NAME, AUTO_SEMANTIC_TURN_PROMPT, AUTO_SEMANTIC_TURN_TOOL_NAME, Agent, type AgentEvents, type AgentOptions, type DeepPartial, type ExtractJsonOptions, type ExtractOptions, type ExtractTagOptions, Logger, type MicdropAnswerMetadata, type MicdropCallSummary, MicdropClientCommands, type MicdropConfig, type MicdropConversation, type MicdropConversationItem, type MicdropConversationMessage, type MicdropConversationToolCall, type MicdropConversationToolResult, MicdropError, MicdropErrorCode, MicdropServer, MicdropServerCommands, type MicdropToolCall, MockAgent, MockSTT, MockTTS, STT, type STTEvents, TTS, type Tool, handleError, waitForParams };
+export { AUTO_END_CALL_PROMPT, AUTO_END_CALL_TOOL_NAME, AUTO_IGNORE_USER_NOISE_PROMPT, AUTO_IGNORE_USER_NOISE_TOOL_NAME, AUTO_SEMANTIC_TURN_PROMPT, AUTO_SEMANTIC_TURN_TOOL_NAME, Agent, type AgentEvents, type AgentOptions, type AudioMessage, type DeepPartial, type ExtractJsonOptions, type ExtractOptions, type ExtractTagOptions, FallbackSTT, type FallbackSTTOptions, FallbackTTS, type FallbackTTSOptions, Logger, type MicdropAnswerMetadata, type MicdropCallSummary, MicdropClientCommands, type MicdropConfig, type MicdropConversation, type MicdropConversationItem, type MicdropConversationMessage, type MicdropConversationToolCall, type MicdropConversationToolResult, MicdropError, MicdropErrorCode, MicdropRecorder, type MicdropRecorderEvents, MicdropServer, MicdropServerCommands, type MicdropServerEvents, type MicdropToolCall, MockAgent, MockSTT, MockTTS, STT, type STTEvents, TTS, type TTSEvents, type Tool, handleError, waitForParams };

package/dist/index.js

@@ -37,10 +37,13 @@ __export(index_exports, {
   AUTO_SEMANTIC_TURN_PROMPT: () => AUTO_SEMANTIC_TURN_PROMPT,
   AUTO_SEMANTIC_TURN_TOOL_NAME: () => AUTO_SEMANTIC_TURN_TOOL_NAME,
   Agent: () => Agent,
+  FallbackSTT: () => FallbackSTT,
+  FallbackTTS: () => FallbackTTS,
   Logger: () => Logger,
   MicdropClientCommands: () => MicdropClientCommands,
   MicdropError: () => MicdropError,
   MicdropErrorCode: () => MicdropErrorCode,
+  MicdropRecorder: () => MicdropRecorder,
   MicdropServer: () => MicdropServer,
   MicdropServerCommands: () => MicdropServerCommands,
   MockAgent: () => MockAgent,
@@ -307,6 +310,7 @@ var Logger = class {
 };
 
 // src/MicdropServer.ts
+var import_eventemitter32 = require("eventemitter3");
 var import_stream2 = require("stream");
 
 // src/types.ts
@@ -326,8 +330,9 @@ var MicdropServerCommands = /* @__PURE__ */ ((MicdropServerCommands2) => {
 })(MicdropServerCommands || {});
 
 // src/MicdropServer.ts
-var MicdropServer = class {
+var MicdropServer = class extends import_eventemitter32.EventEmitter {
   constructor(socket, config) {
+    super();
     this.socket = null;
     this.config = null;
     this.startTime = Date.now();
@@ -342,9 +347,8 @@ var MicdropServer = class {
       this.config.agent.destroy();
       this.config.stt.destroy();
       this.config.tts.destroy();
-      this.config.onEnd?.({
-        conversation: this.config.agent.conversation.slice(1),
-        // Remove system message
+      this.emit("End", {
+        conversation: this.config.agent.conversation,
         duration
       });
       this.socket = null;
@@ -367,10 +371,10 @@ var MicdropServer = class {
           this.onStopSpeaking();
         }
       } else if (this.currentUserStream) {
-        this.onAudioChunk(message);
+        this.onUserAudio(message);
       }
     };
-    this.onTranscript = async (transcript) => {
+    this.onTranscriptSTT = async (transcript) => {
       if (!this.config) return;
       if (transcript === "") {
         this.socket?.send("SkipAnswer" /* SkipAnswer */);
@@ -384,10 +388,17 @@ var MicdropServer = class {
         this.answer();
       }
     };
+    this.onAudioTTS = (audio) => {
+      if (!this.socket) return;
+      this.log(`Send audio chunk (${audio.byteLength} bytes)`);
+      this.socket.send(audio);
+      this.emit("AssistantAudio", audio);
+    };
     this.socket = socket;
     this.config = config;
     this.log(`Call started`);
-    this.config.stt.on("Transcript", this.onTranscript);
+    this.config.stt.on("Transcript", this.onTranscriptSTT);
+    this.config.tts.on("Audio", this.onAudioTTS);
     this.config.agent.on(
       "Message",
       (message) => this.socket?.send(
@@ -443,10 +454,11 @@ var MicdropServer = class {
     this.config?.agent.cancel();
     this.operationQueue = [];
   }
-  onAudioChunk(chunk) {
+  onUserAudio(chunk) {
     this.log(`Received chunk (${chunk.byteLength} bytes)`);
     this.currentUserStream?.write(chunk);
     this.userSpeechChunks++;
+    this.emit("UserAudio", chunk);
   }
   onMute() {
     this.userSpeechChunks = 0;
@@ -530,40 +542,143 @@ var MicdropServer = class {
     } else {
       textStream = message;
     }
-    const audio = this.config.tts.speak(textStream);
-    await this._sendAudio(audio);
+    this.config.tts.speak(textStream);
   }
-  sendAudio(audio) {
-    this.queueOperation(async () => {
-      await this._sendAudio(audio);
-    });
+};
+
+// src/recorder/MicdropRecorder.ts
+var import_eventemitter33 = require("eventemitter3");
+var MicdropRecorder = class extends import_eventemitter33.EventEmitter {
+  constructor(server) {
+    super();
+    this.server = server;
+    this.audioMessages = [];
+    this.currentUserChunks = [];
+    this.currentAssistantChunks = [];
+    this.lastUserMessageIndex = -1;
+    this.lastAssistantMessageIndex = -1;
+    this.onUserAudio = (chunk) => {
+      if (this.currentAssistantChunks.length > 0) {
+        if (this.lastAssistantMessageIndex >= 0) {
+          this.finalizeAssistantAudio();
+        } else {
+          this.log("Discarding orphaned assistant audio chunks");
+          this.currentAssistantChunks = [];
+        }
+      }
+      this.log("Recording user audio chunk");
+      this.currentUserChunks.push(chunk);
+    };
+    this.onAssistantAudio = (chunk) => {
+      if (this.currentUserChunks.length > 0) {
+        if (this.lastUserMessageIndex >= 0) {
+          this.finalizeUserAudio();
+        } else {
+          this.log("Discarding orphaned user audio chunks");
+          this.currentUserChunks = [];
+        }
+      }
+      this.log("Recording assistant audio chunk");
+      this.currentAssistantChunks.push(chunk);
+    };
+    this.onMessage = (message) => {
+      const conversation = this.server.config?.agent.conversation;
+      if (!conversation) return;
+      const messageIndex = conversation.length - 1;
+      if (message.role === "user") {
+        this.lastUserMessageIndex = messageIndex;
+        if (this.currentUserChunks.length > 0) {
+          this.finalizeUserAudio();
+        }
+      } else if (message.role === "assistant") {
+        this.lastAssistantMessageIndex = messageIndex;
+      }
+    };
+    this.onEnd = () => {
+      if (this.currentUserChunks.length > 0) {
+        this.finalizeUserAudio();
+      }
+      if (this.currentAssistantChunks.length > 0) {
+        this.finalizeAssistantAudio();
+      }
+      this.log(`Recording complete: ${this.audioMessages.length} audio messages`);
+      this.emit("Complete", this.audioMessages);
+    };
+    this.setupListeners();
+  }
+  setupListeners() {
+    this.server.on("UserAudio", this.onUserAudio);
+    this.server.on("AssistantAudio", this.onAssistantAudio);
+    this.server.on("End", this.onEnd);
+    const agent = this.server.config?.agent;
+    if (agent) {
+      agent.on("Message", this.onMessage);
+    }
   }
-  async _sendAudio(audio) {
-    if (!this.socket) return;
-    if (!audio.readable) {
-      this.log("Non readable audio, skipping", audio);
-      return;
+  finalizeUserAudio() {
+    if (this.currentUserChunks.length === 0) return;
+    if (this.lastUserMessageIndex < 0) return;
+    const conversation = this.server.config?.agent.conversation;
+    if (!conversation) return;
+    const message = conversation[this.lastUserMessageIndex];
+    const buffer = Buffer.concat(this.currentUserChunks);
+    const audioMessage = {
+      buffer,
+      messageIndex: this.lastUserMessageIndex,
+      message: "content" in message ? message.content : "",
+      role: "user"
+    };
+    this.log(
+      `Finalized user audio: ${buffer.length} bytes, message index ${this.lastUserMessageIndex}`
+    );
+    this.audioMessages.push(audioMessage);
+    this.emit("AudioMessage", audioMessage);
+    this.currentUserChunks = [];
+    this.lastUserMessageIndex = -1;
+  }
+  finalizeAssistantAudio() {
+    if (this.currentAssistantChunks.length === 0) return;
+    if (this.lastAssistantMessageIndex < 0) return;
+    const conversation = this.server.config?.agent.conversation;
+    if (!conversation) return;
+    const message = conversation[this.lastAssistantMessageIndex];
+    const buffer = Buffer.concat(this.currentAssistantChunks);
+    const audioMessage = {
+      buffer,
+      messageIndex: this.lastAssistantMessageIndex,
+      message: "content" in message ? message.content : "",
+      role: "assistant"
+    };
+    this.log(
+      `Finalized assistant audio: ${buffer.length} bytes, message index ${this.lastAssistantMessageIndex}`
+    );
+    this.audioMessages.push(audioMessage);
+    this.emit("AudioMessage", audioMessage);
+    this.currentAssistantChunks = [];
+    this.lastAssistantMessageIndex = -1;
+  }
+  getAudioMessages() {
+    return [...this.audioMessages];
+  }
+  destroy() {
+    this.log("Destroyed");
+    this.server.off("UserAudio", this.onUserAudio);
+    this.server.off("AssistantAudio", this.onAssistantAudio);
+    this.server.off("End", this.onEnd);
+    const agent = this.server.config?.agent;
+    if (agent) {
+      agent.off("Message", this.onMessage);
     }
-    await new Promise((resolve, reject) => {
-      audio.on("data", (chunk) => {
-        this.log(`Send audio chunk (${chunk.byteLength} bytes)`);
-        this.socket?.send(chunk);
-      });
-      audio.on("error", (error) => {
-        this.log("Error in audio stream", error);
-        reject(error);
-      });
-      audio.on("end", () => {
-        this.log("Audio stream ended");
-        resolve();
-      });
-    });
+    this.removeAllListeners();
+  }
+  log(...message) {
+    this.logger?.log(...message);
   }
 };
 
 // src/stt/STT.ts
-var import_eventemitter32 = require("eventemitter3");
-var STT = class extends import_eventemitter32.EventEmitter {
+var import_eventemitter34 = require("eventemitter3");
+var STT = class extends import_eventemitter34.EventEmitter {
   log(...message) {
     this.logger?.log(...message);
   }
@@ -586,12 +701,67 @@ var MockSTT = class extends STT {
   }
 };
 
+// src/stt/FallbackSTT.ts
+var import_stream3 = require("stream");
+var FallbackSTT = class extends STT {
+  // Start at -1 because we need to increment it before using it
+  constructor(options) {
+    super();
+    this.options = options;
+    this.stt = null;
+    this.sttIndex = -1;
+    this.onTranscript = (transcript) => {
+      this.emit("Transcript", transcript);
+    };
+    this.onFailed = (chunks) => {
+      this.log("STT failed, trying next STT");
+      this.startNextSTT();
+      if (chunks.length > 0) {
+        this.log("Sending audio chunks again");
+        const stream = new import_stream3.PassThrough();
+        this.stt?.transcribe(stream);
+        chunks.forEach((chunk) => stream.write(chunk));
+        stream.end();
+      }
+    };
+    if (this.options.factories.length === 0) {
+      throw new Error("FallbackSTT: No factories provided");
+    }
+    this.startNextSTT();
+  }
+  transcribe(audioStream) {
+    this.stt?.transcribe(audioStream);
+  }
+  destroy() {
+    super.destroy();
+    this.stt?.destroy();
+    this.stt = null;
+    this.sttIndex = -1;
+  }
+  startNextSTT() {
+    this.sttIndex++;
+    if (this.sttIndex >= this.options.factories.length) {
+      this.sttIndex = 0;
+    }
+    this.stt?.destroy();
+    this.stt = this.options.factories[this.sttIndex]();
+    this.stt.on("Transcript", this.onTranscript);
+    this.stt.on("Failed", this.onFailed);
+    setTimeout(() => {
+      if (this.stt && this.logger) {
+        this.stt.logger = new Logger(this.stt.constructor.name);
+      }
+    }, 0);
+  }
+};
+
 // src/tts/MockTTS.ts
 var fs = __toESM(require("fs"));
-var import_stream3 = require("stream");
+var import_stream4 = require("stream");
 
 // src/tts/TTS.ts
-var TTS = class {
+var import_eventemitter35 = require("eventemitter3");
+var TTS = class extends import_eventemitter35.EventEmitter {
   log(...message) {
     this.logger?.log(...message);
   }
@@ -608,7 +778,7 @@ var MockTTS = class extends TTS {
     this.audioFilePaths = audioFilePaths;
   }
   speak(textStream) {
-    const audioStream = new import_stream3.PassThrough();
+    const audioStream = new import_stream4.PassThrough();
     textStream.once("data", async () => {
       for (const filePath of this.audioFilePaths) {
         await new Promise((resolve) => setTimeout(resolve, 200));
@@ -624,6 +794,63 @@ var MockTTS = class extends TTS {
   }
 };
 
+// src/tts/FallbackTTS.ts
+var import_stream5 = require("stream");
+var FallbackTTS = class extends TTS {
+  // Start at -1 because we need to increment it before using it
+  constructor(options) {
+    super();
+    this.options = options;
+    this.tts = null;
+    this.ttsIndex = -1;
+    this.onAudio = (audio) => {
+      this.emit("Audio", audio);
+    };
+    this.onFailed = (chunks) => {
+      this.log("TTS failed, trying next TTS");
+      this.startNextTTS();
+      if (chunks.length > 0) {
+        this.log("Sending text chunks again");
+        const stream = new import_stream5.PassThrough();
+        this.tts?.speak(stream);
+        chunks.forEach((chunk) => stream.write(chunk));
+        stream.end();
+      }
+    };
+    if (this.options.factories.length === 0) {
+      throw new Error("FallbackTTS: No factories provided");
+    }
+    this.startNextTTS();
+  }
+  speak(textStream) {
+    this.tts?.speak(textStream);
+  }
+  cancel() {
+    this.tts?.cancel();
+  }
+  destroy() {
+    super.destroy();
+    this.tts?.destroy();
+    this.tts = null;
+    this.ttsIndex = -1;
+  }
+  startNextTTS() {
+    this.ttsIndex++;
+    if (this.ttsIndex >= this.options.factories.length) {
+      this.ttsIndex = 0;
+    }
+    this.tts?.destroy();
+    this.tts = this.options.factories[this.ttsIndex]();
+    this.tts.on("Audio", this.onAudio);
+    this.tts.on("Failed", this.onFailed);
+    setTimeout(() => {
+      if (this.tts && this.logger) {
+        this.tts.logger = new Logger(this.tts.constructor.name);
+      }
+    }, 0);
+  }
+};
+
 // src/waitForParams.ts
 async function waitForParams(socket, validate) {
   return new Promise((resolve, reject) => {
@@ -652,10 +879,13 @@ async function waitForParams(socket, validate) {
   AUTO_SEMANTIC_TURN_PROMPT,
   AUTO_SEMANTIC_TURN_TOOL_NAME,
   Agent,
+  FallbackSTT,
+  FallbackTTS,
   Logger,
   MicdropClientCommands,
   MicdropError,
   MicdropErrorCode,
+  MicdropRecorder,
   MicdropServer,
   MicdropServerCommands,
   MockAgent,