@micdrop/server 1.7.0 → 2.0.0

package/dist/index.mjs

@@ -1,256 +1,476 @@
-// src/CallServer.ts
-import * as fs from "fs";
+// src/agent/Agent.ts
+import EventEmitter from "eventemitter3";
+var Agent = class extends EventEmitter {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.conversation = [{ role: "system", content: options.systemPrompt }];
+  }
+  addUserMessage(text) {
+    this.addMessage("user", text);
+  }
+  addAssistantMessage(text) {
+    this.addMessage("assistant", text);
+  }
+  addMessage(role, text) {
+    this.log(`Adding ${role} message to conversation: ${text}`);
+    const message = {
+      role,
+      content: text
+    };
+    this.conversation.push(message);
+    this.emit("Message", message);
+  }
+  endCall() {
+    this.log("Ending call");
+    this.emit("EndCall");
+  }
+  cancelLastUserMessage() {
+    this.log("Cancelling last user message");
+    const lastMessage = this.conversation[this.conversation.length - 1];
+    if (lastMessage?.role !== "user") return;
+    this.conversation.pop();
+    this.emit("CancelLastUserMessage");
+  }
+  cancelLastAssistantMessage() {
+    this.log("Cancelling last assistant message");
+    const lastMessage = this.conversation[this.conversation.length - 1];
+    if (lastMessage?.role !== "assistant") return;
+    this.conversation.pop();
+    this.emit("CancelLastAssistantMessage");
+  }
+  skipAnswer() {
+    this.log("Skipping answer");
+    this.emit("SkipAnswer");
+  }
+  createTextPromise() {
+    const result = {};
+    result.promise = new Promise((resolve, reject) => {
+      result.resolve = resolve;
+      result.reject = reject;
+    });
+    return result;
+  }
+  log(...message) {
+    this.logger?.log(...message);
+  }
+  destroy() {
+    this.log("Destroyed");
+    this.removeAllListeners();
+    this.cancel();
+  }
+};
+
+// src/agent/MockAgent.ts
+import { PassThrough } from "stream";
+var MockAgent = class extends Agent {
+  constructor() {
+    super({ systemPrompt: "" });
+    this.i = 0;
+  }
+  answer() {
+    const stream = new PassThrough();
+    const textPromise = this.createTextPromise();
+    const message = `Assistant Message ${this.i++}`;
+    this.addAssistantMessage(message);
+    stream.write(message);
+    stream.end();
+    textPromise.resolve(message);
+    return { message: textPromise.promise, stream };
+  }
+  cancel() {
+  }
+};
+
+// src/audio-convert.ts
+import ffmpegInstaller from "@ffmpeg-installer/ffmpeg";
+import ffmpeg from "fluent-ffmpeg";
+import { PassThrough as PassThrough2 } from "stream";
+ffmpeg.setFfmpegPath(ffmpegInstaller.path);
+function convertToPCM(audioStream, sampleRate = 16e3, bitDepth = 16) {
+  const pcmStream = new PassThrough2();
+  ffmpeg(audioStream).audioChannels(1).audioFrequency(sampleRate).audioCodec(`pcm_s${bitDepth}le`).format(`s${bitDepth}le`).on("error", (error) => {
+    console.error("Error converting audio stream:", error.message);
+  }).pipe(pcmStream);
+  return pcmStream;
+}
+function convertToOpus(audioStream, sampleRate = 16e3) {
+  const webmStream = new PassThrough2();
+  ffmpegToOpus(ffmpeg(audioStream), sampleRate).pipe(webmStream);
+  return webmStream;
+}
+function convertPCMToOpus(audioStream, sampleRate = 16e3) {
+  const webmStream = new PassThrough2();
+  ffmpegToOpus(ffmpeg(audioStream), sampleRate).inputFormat("s16le").inputOptions(["-f s16le", "-ar 16000", "-ac 1"]).pipe(webmStream);
+  return webmStream;
+}
+function ffmpegToOpus(ffmpegCommand, sampleRate = 16e3) {
+  return ffmpegCommand.audioChannels(1).audioFrequency(sampleRate).audioCodec("libopus").format("webm").outputOptions([
+    "-application audio",
+    `-ac 1`,
+    `-ar ${sampleRate}`,
+    `-b:a 64k`,
+    `-f webm`,
+    `-map_metadata -1`
+  ]).on("error", (error) => {
+    console.error("Error converting to Opus: ", error.message);
+  });
+}
+
+// src/errors.ts
+var MicdropErrorCode = /* @__PURE__ */ ((MicdropErrorCode2) => {
+  MicdropErrorCode2[MicdropErrorCode2["BadRequest"] = 4400] = "BadRequest";
+  MicdropErrorCode2[MicdropErrorCode2["Unauthorized"] = 4401] = "Unauthorized";
+  MicdropErrorCode2[MicdropErrorCode2["NotFound"] = 4404] = "NotFound";
+  return MicdropErrorCode2;
+})(MicdropErrorCode || {});
+var MicdropError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+function handleError(socket, error) {
+  if (error instanceof MicdropError) {
+    socket.close(error.code, error.message);
+  } else {
+    console.error(error);
+    socket.close(1011);
+  }
+  socket.terminate();
+}
+
+// src/Logger.ts
+var Logger = class {
+  constructor(name) {
+    this.name = name;
+  }
+  log(...message) {
+    const time = process.uptime().toFixed(3);
+    console.log(`[${this.name} ${time}]`, ...message);
+  }
+};
+
+// src/MicdropServer.ts
+import { PassThrough as PassThrough3 } from "stream";
 
 // src/types.ts
-var CallClientCommands = /* @__PURE__ */ ((CallClientCommands2) => {
-  CallClientCommands2["StartSpeaking"] = "StartSpeaking";
-  CallClientCommands2["StopSpeaking"] = "StopSpeaking";
-  CallClientCommands2["Mute"] = "Mute";
-  return CallClientCommands2;
-})(CallClientCommands || {});
-var CallServerCommands = /* @__PURE__ */ ((CallServerCommands2) => {
-  CallServerCommands2["Message"] = "Message";
-  CallServerCommands2["CancelLastAssistantMessage"] = "CancelLastAssistantMessage";
-  CallServerCommands2["CancelLastUserMessage"] = "CancelLastUserMessage";
-  CallServerCommands2["SkipAnswer"] = "SkipAnswer";
-  CallServerCommands2["EnableSpeakerStreaming"] = "EnableSpeakerStreaming";
-  CallServerCommands2["EndCall"] = "EndCall";
-  return CallServerCommands2;
-})(CallServerCommands || {});
+var MicdropClientCommands = /* @__PURE__ */ ((MicdropClientCommands2) => {
+  MicdropClientCommands2["StartSpeaking"] = "StartSpeaking";
+  MicdropClientCommands2["StopSpeaking"] = "StopSpeaking";
+  MicdropClientCommands2["Mute"] = "Mute";
+  return MicdropClientCommands2;
+})(MicdropClientCommands || {});
+var MicdropServerCommands = /* @__PURE__ */ ((MicdropServerCommands2) => {
+  MicdropServerCommands2["Message"] = "Message";
+  MicdropServerCommands2["CancelLastAssistantMessage"] = "CancelLastAssistantMessage";
+  MicdropServerCommands2["CancelLastUserMessage"] = "CancelLastUserMessage";
+  MicdropServerCommands2["SkipAnswer"] = "SkipAnswer";
+  MicdropServerCommands2["EndCall"] = "EndCall";
+  return MicdropServerCommands2;
+})(MicdropServerCommands || {});
 
-// src/CallServer.ts
-var CallServer = class {
+// src/MicdropServer.ts
+var MicdropServer = class {
   constructor(socket, config) {
     this.socket = null;
     this.config = null;
     this.startTime = Date.now();
-    this.lastDebug = Date.now();
-    // When user is speaking, we're waiting to chunks or to stop
-    this.isSpeaking = false;
-    // Chunks of user speech since user started speaking
-    this.chunks = [];
-    // Enable speaker streaming
-    this.speakerStreamingEnabled = false;
+    this.onClose = () => {
+      if (!this.config) return;
+      this.log("Connection closed");
+      const duration = Math.round((Date.now() - this.startTime) / 1e3);
+      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
+        duration
+      });
+      this.socket = null;
+      this.config = null;
+    };
+    this.onMessage = async (message) => {
+      if (message.byteLength === 0) return;
+      if (!Buffer.isBuffer(message)) {
+        this.log("Message is not a buffer");
+        return;
+      }
+      if (message.byteLength < 15) {
+        const cmd = message.toString();
+        this.log(`Command: ${cmd}`);
+        if (cmd === "StartSpeaking" /* StartSpeaking */) {
+          await this.onStartSpeaking();
+        } else if (cmd === "Mute" /* Mute */) {
+          await this.onMute();
+        } else if (cmd === "StopSpeaking" /* StopSpeaking */) {
+          await this.onStopSpeaking();
+        }
+      } else if (this.currentUserStream) {
+        this.log(`Received chunk (${message.byteLength} bytes)`);
+        this.currentUserStream.write(message);
+      }
+    };
+    this.onTranscript = async (transcript) => {
+      if (!this.config) return;
+      this.log(`User transcript: "${transcript}"`);
+      this.config.agent.addUserMessage(transcript);
+      if (!this.currentUserStream) {
+        this.log("User stopped speaking, answering");
+        this.answer();
+      }
+    };
     this.socket = socket;
     this.config = config;
-    this.conversation = [{ role: "system", content: config.systemPrompt }];
     this.log(`Call started`);
-    if (config.firstMessage) {
-      this.answer(config.firstMessage);
-    } else {
-      this.config.generateAnswer(this.conversation).then((answer) => this.answer(answer)).catch((error) => {
-        console.error("[CallServer]", error);
-        socket?.close();
-      });
-    }
-    socket.on("close", this.onClose.bind(this));
-    socket.on("message", this.onMessage.bind(this));
+    this.config.stt.on("Transcript", this.onTranscript);
+    this.config.agent.on(
+      "Message",
+      (message) => this.socket?.send(
+        `${"Message" /* Message */} ${JSON.stringify(message)}`
+      )
+    );
+    this.config.agent.on(
+      "CancelLastUserMessage",
+      () => this.socket?.send("CancelLastUserMessage" /* CancelLastUserMessage */)
+    );
+    this.config.agent.on(
+      "CancelLastAssistantMessage",
+      () => this.socket?.send("CancelLastAssistantMessage" /* CancelLastAssistantMessage */)
+    );
+    this.config.agent.on(
+      "SkipAnswer",
+      () => this.socket?.send("SkipAnswer" /* SkipAnswer */)
+    );
+    this.config.agent.on(
+      "EndCall",
+      () => this.socket?.send("EndCall" /* EndCall */)
+    );
+    this.sendFirstMessage();
+    socket.on("close", this.onClose);
+    socket.on("message", this.onMessage);
   }
-  // Reset conversation
-  resetConversation(conversation) {
-    this.log("Reset conversation");
-    this.conversation = conversation;
+  log(...message) {
+    this.logger?.log(...message);
   }
-  abortProcessing() {
-    if (!this.processing) return;
-    this.processing.aborted = true;
-    this.processing = void 0;
+  cancel() {
+    this.config?.tts.cancel();
+    this.config?.agent.cancel();
   }
-  addMessage(message) {
-    if (!this.socket || !this.config) return;
-    this.conversation.push(message);
-    this.socket.send(`${"Message" /* Message */} ${JSON.stringify(message)}`);
-    this.config.onMessage?.(message);
+  async onMute() {
+    this.currentUserStream?.end();
+    this.currentUserStream = void 0;
+    this.cancel();
   }
-  async sendAudio(audio, processing, onAbort) {
-    if (!this.socket) return;
-    if (processing.aborted) {
-      onAbort?.();
-      return;
-    }
-    if (Buffer.isBuffer(audio) || audio instanceof ArrayBuffer) {
-      this.log(`Send audio: (${audio.byteLength} bytes)`);
-      this.socket.send(audio);
-    } else if ("paused" in audio) {
-      if (!this.speakerStreamingEnabled) {
-        this.socket.send("EnableSpeakerStreaming" /* EnableSpeakerStreaming */);
-        this.speakerStreamingEnabled = true;
-      }
-      for await (const chunk of audio) {
-        if (processing.aborted) {
-          onAbort?.();
-          return;
-        }
-        this.log(`Send audio chunk (${chunk.length} bytes)`);
-        this.socket.send(chunk);
-      }
-    } else {
-      this.log(`Unknown audio type: ${audio}`);
-    }
-  }
-  onClose() {
+  async onStartSpeaking() {
     if (!this.config) return;
-    this.log("Connection closed");
-    this.abortProcessing();
-    const duration = Math.round((Date.now() - this.startTime) / 1e3);
-    this.config.onEnd?.({
-      conversation: this.conversation.slice(1),
-      // Remove system message
-      duration
-    });
-    this.socket = null;
-    this.config = null;
+    this.currentUserStream?.end();
+    this.currentUserStream = new PassThrough3();
+    this.config.stt.transcribe(this.currentUserStream);
+    this.cancel();
   }
-  async onMessage(message) {
-    if (!Buffer.isBuffer(message)) {
-      console.warn(`[CallServer] Message is not a buffer`);
-      return;
+  async onStopSpeaking() {
+    this.currentUserStream?.end();
+    this.currentUserStream = void 0;
+    const conversation = this.config?.agent.conversation;
+    if (conversation && conversation[conversation.length - 1].role === "user") {
+      this.log(
+        "User stopped speaking and a transcript already exists, answering"
+      );
+      this.answer();
     }
-    if (message.byteLength < 15) {
-      const cmd = message.toString();
-      this.log(`Command: ${cmd}`);
-      if (cmd === "StartSpeaking" /* StartSpeaking */) {
-        this.isSpeaking = true;
-        this.abortProcessing();
-      } else if (cmd === "Mute" /* Mute */) {
-        this.abortProcessing();
-      } else if (cmd === "StopSpeaking" /* StopSpeaking */) {
-        this.isSpeaking = false;
-        await this.onStopSpeaking();
+  }
+  async sendFirstMessage() {
+    if (!this.config) return;
+    try {
+      if (this.config.firstMessage) {
+        this.config.agent.addAssistantMessage(this.config.firstMessage);
+        await this.speak(this.config.firstMessage);
+      } else if (this.config.generateFirstMessage) {
+        await this.answer();
       }
-    } else if (Buffer.isBuffer(message) && this.isSpeaking) {
-      this.log(`Received chunk (${message.byteLength} bytes)`);
-      this.chunks.push(message);
+    } catch (error) {
+      console.error("[MicdropServer]", error);
+      this.socket?.send("SkipAnswer" /* SkipAnswer */);
     }
   }
-  async onStopSpeaking() {
+  async answer() {
     if (!this.config) return;
-    if (this.chunks.length === 0) return;
-    this.abortProcessing();
-    const processing = this.processing = { aborted: false };
-    const blob = new Blob(this.chunks, { type: "audio/ogg" });
-    this.chunks.length = 0;
+    this.cancel();
     try {
-      if (this.config.debugSaveSpeech) {
-        const filename = `speech-${Date.now()}.ogg`;
-        fs.writeFileSync(filename, Buffer.from(await blob.arrayBuffer()));
-        this.log(`Saved speech: ${filename}`);
-      }
-      const transcript = await this.config.speech2Text(
-        blob,
-        this.conversation[this.conversation.length - 1]?.content
-      );
-      if (!transcript) {
-        this.log("Ignoring empty transcript");
-        this.socket?.send("SkipAnswer" /* SkipAnswer */);
-        return;
-      }
-      this.log("User transcript:", transcript);
-      this.addMessage({ role: "user", content: transcript });
-      if (processing.aborted) {
-        this.log("Answer aborted, no answer generated");
-        return;
-      }
-      const answer = await this.config.generateAnswer(this.conversation);
-      if (processing.aborted) {
-        this.log("Answer aborted, ignoring answer");
-        return;
-      }
-      await this.answer(answer, processing);
+      const { stream } = this.config.agent.answer();
+      await this.speak(stream);
     } catch (error) {
-      console.error("[CallServer]", error);
+      console.error("[MicdropServer]", error);
       this.socket?.send("SkipAnswer" /* SkipAnswer */);
     }
   }
-  // Add assistant message and send to client with audio (TTS)
-  async answer(message, processing) {
+  // Run text-to-speech and send to client
+  async speak(message) {
     if (!this.socket || !this.config) return;
-    if (!processing) {
-      this.abortProcessing();
-      processing = this.processing = { aborted: false };
-    }
+    let textStream;
     if (typeof message === "string") {
-      message = { role: "assistant", content: message };
+      const stream = new PassThrough3();
+      stream.write(message);
+      stream.end();
+      textStream = stream;
+    } else {
+      textStream = message;
     }
-    if (message.commands?.cancelLastUserMessage) {
-      this.log("Cancelling last user message");
-      const lastMessage = this.conversation[this.conversation.length - 1];
-      if (lastMessage?.role === "user") {
-        this.conversation.pop();
-        this.socket?.send("CancelLastUserMessage" /* CancelLastUserMessage */);
-      }
+    const audio = this.config.tts.speak(textStream);
+    await this.sendAudio(audio);
+  }
+  async sendAudio(audio) {
+    if (!this.socket) return;
+    if (!audio.readable) {
+      this.log("Non readable audio, skipping", audio);
       return;
     }
-    if (!message.content.length || message.commands?.skipAnswer) {
-      this.log("Skipping answer");
-      this.socket?.send("SkipAnswer" /* SkipAnswer */);
-      return;
+    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);
+    });
+    audio.on("end", () => {
+      this.log("Audio stream ended");
+    });
+  }
+};
+
+// src/stt/STT.ts
+import EventEmitter2 from "eventemitter3";
+var MIME_TYPE_TO_EXTENSION = {
+  "audio/wav": "wav",
+  "audio/ogg": "ogg",
+  "audio/mpeg": "mp3",
+  "audio/webm": "webm",
+  "audio/mp4": "mp4",
+  "audio/flac": "flac"
+};
+var STT = class extends EventEmitter2 {
+  // Set stream of audio to transcribe
+  transcribe(audioStream) {
+    audioStream.once("data", (chunk) => {
+      this.mimeType = this.detectMimeType(chunk);
+    });
+  }
+  log(...message) {
+    this.logger?.log(...message);
+  }
+  destroy() {
+    this.log("Destroyed");
+    this.removeAllListeners();
+  }
+  get extension() {
+    return this.mimeType && MIME_TYPE_TO_EXTENSION[this.mimeType] || "bin";
+  }
+  detectMimeType(chunk) {
+    if (!chunk || chunk.byteLength === 0) {
+      throw new Error("Unable to detect mime type (empty chunk)");
     }
-    this.log("Assistant message:", message);
-    this.addMessage(message);
-    if (!this.config.disableTTS) {
-      try {
-        const onAbort = () => {
-          this.log("Answer aborted, removing last assistant message");
-          const lastMessage = this.conversation[this.conversation.length - 1];
-          if (lastMessage?.role === "assistant") {
-            this.conversation.pop();
-            this.socket?.send("CancelLastAssistantMessage" /* CancelLastAssistantMessage */);
-          }
-        };
-        if (processing.aborted) {
-          onAbort();
-          return;
-        }
-        const audio = await this.config.text2Speech(message.content);
-        await this.sendAudio(audio, processing, onAbort);
-      } catch (error) {
-        console.error("[CallServer]", error);
-        this.socket?.send("SkipAnswer" /* SkipAnswer */);
-      }
+    const arr = new Uint8Array(chunk);
+    if (arr[0] === 26 && arr[1] === 69 && arr[2] === 223 && arr[3] === 163) {
+      return "audio/webm";
+    }
+    if (arr[0] === 79 && arr[1] === 103 && arr[2] === 103 && arr[3] === 83) {
+      return "audio/ogg";
+    }
+    if (arr[0] === 82 && arr[1] === 73 && arr[2] === 70 && arr[3] === 70 && arr[8] === 87 && arr[9] === 65 && arr[10] === 86 && arr[11] === 69) {
+      return "audio/wav";
     }
-    if (message.commands?.endCall) {
-      this.log("Call ended");
-      this.socket.send("EndCall" /* EndCall */);
+    if (arr[0] === 73 && arr[1] === 68 && arr[2] === 51) {
+      return "audio/mpeg";
     }
+    if (arr[4] === 102 && arr[5] === 116 && arr[6] === 121 && arr[7] === 112) {
+      return "audio/mp4";
+    }
+    if (arr[0] === 102 && arr[1] === 76 && arr[2] === 97 && arr[3] === 67) {
+      return "audio/flac";
+    }
+    this.log("Unable to detect mime type, using default", chunk);
+    return "audio/wav";
   }
-  log(...message) {
-    if (!this.config?.debugLog) return;
-    const now = Date.now();
-    const delta = now - this.lastDebug;
-    this.lastDebug = now;
-    console.log(`[Debug +${delta}ms]`, ...message);
+};
+
+// src/stt/FileSTT.ts
+var FileSTT = class extends STT {
+  transcribe(audioStream) {
+    super.transcribe(audioStream);
+    this.log("Converting stream to file...");
+    const chunks = [];
+    audioStream.on("data", (chunk) => {
+      chunks.push(chunk);
+    });
+    audioStream.on("end", async () => {
+      if (chunks.length === 0) return;
+      const arrayBuffer = Buffer.concat(chunks);
+      const file = new File([arrayBuffer], `audio.${this.extension}`, {
+        type: this.mimeType
+      });
+      this.log("Transcribing file...");
+      const transcript = await this.transcribeFile(file);
+      this.emit("Transcript", transcript);
+    });
   }
 };
 
-// src/errors.ts
-var CallErrorCode = /* @__PURE__ */ ((CallErrorCode2) => {
-  CallErrorCode2[CallErrorCode2["BadRequest"] = 4400] = "BadRequest";
-  CallErrorCode2[CallErrorCode2["Unauthorized"] = 4401] = "Unauthorized";
-  CallErrorCode2[CallErrorCode2["NotFound"] = 4404] = "NotFound";
-  return CallErrorCode2;
-})(CallErrorCode || {});
-var CallError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
+// src/stt/MockSTT.ts
+var MockSTT = class extends FileSTT {
+  constructor() {
+    super(...arguments);
+    this.i = 0;
+  }
+  async transcribeFile(file) {
+    return `User Message ${this.i++}`;
   }
 };
-function handleError(socket, error) {
-  if (error instanceof CallError) {
-    socket.close(error.code, error.message);
-  } else {
-    console.error(error);
-    socket.close(1011);
+
+// src/tts/MockTTS.ts
+import * as fs from "fs";
+import { PassThrough as PassThrough4 } from "stream";
+
+// src/tts/TTS.ts
+var TTS = class {
+  log(...message) {
+    this.logger?.log(...message);
   }
-  socket.terminate();
-}
+  destroy() {
+    this.log("Destroyed");
+    this.cancel();
+  }
+};
+
+// src/tts/MockTTS.ts
+var MockTTS = class extends TTS {
+  constructor(audioFilePaths) {
+    super();
+    this.audioFilePaths = audioFilePaths;
+  }
+  speak(textStream) {
+    const audioStream = new PassThrough4();
+    textStream.once("data", async () => {
+      for (const filePath of this.audioFilePaths) {
+        await new Promise((resolve) => setTimeout(resolve, 200));
+        const audioBuffer = fs.readFileSync(filePath);
+        this.log(`Loaded chunk (${audioBuffer.length} bytes)`);
+        audioStream.write(audioBuffer);
+      }
+      audioStream.end();
+    });
+    return audioStream;
+  }
+  cancel() {
+  }
+};
 
 // src/waitForParams.ts
 async function waitForParams(socket, validate) {
   return new Promise((resolve, reject) => {
     const timeout = setTimeout(() => {
-      reject(new CallError(4400 /* BadRequest */, "Missing params"));
+      reject(new MicdropError(4400 /* BadRequest */, "Missing params"));
     }, 3e3);
     const onParams = (payload) => {
       clearTimeout(timeout);
@@ -259,18 +479,29 @@ async function waitForParams(socket, validate) {
         const params = validate(JSON.parse(payload));
         resolve(params);
       } catch (error) {
-        reject(new CallError(4400 /* BadRequest */, "Invalid params"));
+        reject(new MicdropError(4400 /* BadRequest */, "Invalid params"));
       }
     };
     socket.on("message", onParams);
   });
 }
 export {
-  CallClientCommands,
-  CallError,
-  CallErrorCode,
-  CallServer,
-  CallServerCommands,
+  Agent,
+  FileSTT,
+  Logger,
+  MicdropClientCommands,
+  MicdropError,
+  MicdropErrorCode,
+  MicdropServer,
+  MicdropServerCommands,
+  MockAgent,
+  MockSTT,
+  MockTTS,
+  STT,
+  TTS,
+  convertPCMToOpus,
+  convertToOpus,
+  convertToPCM,
   handleError,
   waitForParams
 };