@micdrop/server 2.2.6 → 2.4.0

package/README.md

@@ -1,6 +1,6 @@
 # 🖐️🎤 Micdrop: Real-Time Voice Conversations with AI
 
-[Micdrop website](https://micdrop.dev) | [Documentation](https://micdrop.dev/docs/server) | [Demo](../../examples/demo-server)
+[Micdrop website](https://micdrop.dev) | [Documentation](https://micdrop.dev/docs/server) | [Basic example](../../examples/basic) | [Demo](../../examples/advanced)
 
 Micdrop is a set of open source Typescript packages to build real-time voice conversations with AI agents. It handles all the complexities on the browser and server side (microphone, speaker, VAD, network communication, etc) and provides ready-to-use implementations for various AI providers.
 

package/dist/index.d.mts

@@ -170,6 +170,44 @@ declare class MockAgent extends Agent {
     cancel(): void;
 }
 
+/**
+ * Streaming linear-interpolation resampler for PCM16 mono audio.
+ *
+ * Works in both directions (up or downsampling). It is stateful: it handles
+ * arbitrary byte boundaries (a network chunk can split a 16-bit sample) and
+ * keeps the fractional sample position continuous across chunks, so feeding a
+ * stream chunk by chunk yields the same result as resampling it in one go.
+ *
+ * Providers use it to bridge their own rate with the 16kHz PCM16 the Micdrop
+ * client records and plays: OpenaiSTT (16kHz -> 24kHz, the GA Realtime API
+ * requires >= 24kHz), OpenaiTTS and KokoroTTS (24kHz output -> 16kHz).
+ */
+declare class Pcm16Resampler {
+    private readonly step;
+    private leftover;
+    private pos;
+    constructor(inRate: number, outRate: number);
+    reset(): void;
+    process(chunk: Buffer): Buffer;
+}
+
+/**
+ * Conversions between the PCM16 buffers exchanged with the Micdrop client and
+ * the float samples that local speech models read and write.
+ *
+ * Both formats are mono. PCM16 is signed 16-bit little-endian, floats are in
+ * the [-1, 1] range. Only the scale changes, the sample rate is left alone.
+ */
+/** Turns float samples into a PCM16 buffer, clamping anything out of range. */
+declare function float32ToPcm16(samples: Float32Array): Buffer;
+/**
+ * Turns a PCM16 buffer into float samples.
+ *
+ * A trailing odd byte is dropped: it is half of a sample whose other half has
+ * not arrived, and a caller feeding whole utterances never produces one.
+ */
+declare function pcm16ToFloat32(buffer: Buffer): Float32Array;
+
 declare enum MicdropErrorCode {
     BadRequest = 4400,
     Unauthorized = 4401,
@@ -224,13 +262,6 @@ declare abstract class TTS extends EventEmitter<TTSEvents> {
     destroy(): void;
 }
 
-declare class MockTTS extends TTS {
-    private audioFilePaths;
-    constructor(audioFilePaths: string[]);
-    speak(textStream: Readable): PassThrough;
-    cancel(): void;
-}
-
 interface FallbackTTSOptions {
     factories: Array<() => TTS>;
 }
@@ -247,6 +278,80 @@ declare class FallbackTTS extends TTS {
     private onFailed;
 }
 
+declare class MockTTS extends TTS {
+    private audioFilePaths;
+    constructor(audioFilePaths: string[]);
+    speak(textStream: Readable): PassThrough;
+    cancel(): void;
+}
+
+/**
+ * Cuts a stream of text into sentences as it arrives.
+ *
+ * Providers that synthesize a whole input at once need complete sentences, and
+ * an agent writes its answer token by token. Feeding every fragment as it comes
+ * would either cut words in half or wait for the end of the answer, so the text
+ * is buffered until a sentence closes and released the moment it does.
+ *
+ * The splitter is stateful: `push` returns the sentences that are complete,
+ * `flush` returns whatever is left when the stream ends.
+ */
+declare class SentenceSplitter {
+    private buffer;
+    /** Adds text and returns the sentences it completes. */
+    push(text: string): string[];
+    /** Returns the sentences left in the buffer and empties it. */
+    flush(): string[];
+    /** Drops the buffered text, used when an utterance is cancelled. */
+    reset(): void;
+    private extract;
+}
+
+/**
+ * Base class for text to speech engines that read a whole input at once.
+ *
+ * A local model, and a remote endpoint without a streaming interface, cannot
+ * be fed the agent's answer token by token. This class buffers the answer into
+ * sentences, hands them over one at a time, and emits the audio in the order
+ * they were written. Subclasses only have to turn one sentence into PCM16 at
+ * the rate the Micdrop client expects.
+ *
+ * Sentences are synthesized one after the other rather than at once: a local
+ * model is single threaded, so racing two sentences through it slows both down
+ * without bringing the first word any closer.
+ */
+declare abstract class SentenceTTS extends TTS {
+    private splitter;
+    private queue;
+    private draining;
+    private controller?;
+    private generation;
+    private counter;
+    private synthesizing;
+    /**
+     * Turns one sentence into PCM16 audio at the client's sample rate.
+     *
+     * The signal is aborted when the utterance is cancelled, which is the moment
+     * to stop a subprocess or an inference that is no longer needed. Returning
+     * nothing emits nothing, which is how a cancelled synthesis reports back.
+     */
+    protected abstract synthesize(text: string, signal: AbortSignal): Promise<Buffer | undefined>;
+    /**
+     * Emits a piece of the sentence being synthesized.
+     *
+     * A model that generates progressively can hand its chunks over as they
+     * come rather than waiting for the sentence to be finished, which brings
+     * the first word forward by the duration of that sentence. The false it
+     * returns says the utterance was cancelled or replaced, so the generation
+     * it comes from can be stopped there.
+     */
+    protected emitAudio(audio: Buffer): boolean;
+    speak(textStream: Readable): void;
+    cancel(): void;
+    private enqueue;
+    private drain;
+}
+
 interface MicdropServerEvents {
     End: [MicdropCallSummary];
     UserAudio: [Buffer];
@@ -322,4 +427,4 @@ declare class MicdropRecorder extends EventEmitter<MicdropRecorderEvents> {
 
 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 AudioMessage, type DeepPartial, type ExtractJsonOptions, type ExtractOptions, type ExtractTagOptions, FallbackAgent, type FallbackAgentOptions, 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 };
+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, FallbackAgent, type FallbackAgentOptions, 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, Pcm16Resampler, STT, type STTEvents, SentenceSplitter, SentenceTTS, TTS, type TTSEvents, type Tool, float32ToPcm16, handleError, pcm16ToFloat32, waitForParams };

package/dist/index.d.ts

@@ -170,6 +170,44 @@ declare class MockAgent extends Agent {
     cancel(): void;
 }
 
+/**
+ * Streaming linear-interpolation resampler for PCM16 mono audio.
+ *
+ * Works in both directions (up or downsampling). It is stateful: it handles
+ * arbitrary byte boundaries (a network chunk can split a 16-bit sample) and
+ * keeps the fractional sample position continuous across chunks, so feeding a
+ * stream chunk by chunk yields the same result as resampling it in one go.
+ *
+ * Providers use it to bridge their own rate with the 16kHz PCM16 the Micdrop
+ * client records and plays: OpenaiSTT (16kHz -> 24kHz, the GA Realtime API
+ * requires >= 24kHz), OpenaiTTS and KokoroTTS (24kHz output -> 16kHz).
+ */
+declare class Pcm16Resampler {
+    private readonly step;
+    private leftover;
+    private pos;
+    constructor(inRate: number, outRate: number);
+    reset(): void;
+    process(chunk: Buffer): Buffer;
+}
+
+/**
+ * Conversions between the PCM16 buffers exchanged with the Micdrop client and
+ * the float samples that local speech models read and write.
+ *
+ * Both formats are mono. PCM16 is signed 16-bit little-endian, floats are in
+ * the [-1, 1] range. Only the scale changes, the sample rate is left alone.
+ */
+/** Turns float samples into a PCM16 buffer, clamping anything out of range. */
+declare function float32ToPcm16(samples: Float32Array): Buffer;
+/**
+ * Turns a PCM16 buffer into float samples.
+ *
+ * A trailing odd byte is dropped: it is half of a sample whose other half has
+ * not arrived, and a caller feeding whole utterances never produces one.
+ */
+declare function pcm16ToFloat32(buffer: Buffer): Float32Array;
+
 declare enum MicdropErrorCode {
     BadRequest = 4400,
     Unauthorized = 4401,
@@ -224,13 +262,6 @@ declare abstract class TTS extends EventEmitter<TTSEvents> {
     destroy(): void;
 }
 
-declare class MockTTS extends TTS {
-    private audioFilePaths;
-    constructor(audioFilePaths: string[]);
-    speak(textStream: Readable): PassThrough;
-    cancel(): void;
-}
-
 interface FallbackTTSOptions {
     factories: Array<() => TTS>;
 }
@@ -247,6 +278,80 @@ declare class FallbackTTS extends TTS {
     private onFailed;
 }
 
+declare class MockTTS extends TTS {
+    private audioFilePaths;
+    constructor(audioFilePaths: string[]);
+    speak(textStream: Readable): PassThrough;
+    cancel(): void;
+}
+
+/**
+ * Cuts a stream of text into sentences as it arrives.
+ *
+ * Providers that synthesize a whole input at once need complete sentences, and
+ * an agent writes its answer token by token. Feeding every fragment as it comes
+ * would either cut words in half or wait for the end of the answer, so the text
+ * is buffered until a sentence closes and released the moment it does.
+ *
+ * The splitter is stateful: `push` returns the sentences that are complete,
+ * `flush` returns whatever is left when the stream ends.
+ */
+declare class SentenceSplitter {
+    private buffer;
+    /** Adds text and returns the sentences it completes. */
+    push(text: string): string[];
+    /** Returns the sentences left in the buffer and empties it. */
+    flush(): string[];
+    /** Drops the buffered text, used when an utterance is cancelled. */
+    reset(): void;
+    private extract;
+}
+
+/**
+ * Base class for text to speech engines that read a whole input at once.
+ *
+ * A local model, and a remote endpoint without a streaming interface, cannot
+ * be fed the agent's answer token by token. This class buffers the answer into
+ * sentences, hands them over one at a time, and emits the audio in the order
+ * they were written. Subclasses only have to turn one sentence into PCM16 at
+ * the rate the Micdrop client expects.
+ *
+ * Sentences are synthesized one after the other rather than at once: a local
+ * model is single threaded, so racing two sentences through it slows both down
+ * without bringing the first word any closer.
+ */
+declare abstract class SentenceTTS extends TTS {
+    private splitter;
+    private queue;
+    private draining;
+    private controller?;
+    private generation;
+    private counter;
+    private synthesizing;
+    /**
+     * Turns one sentence into PCM16 audio at the client's sample rate.
+     *
+     * The signal is aborted when the utterance is cancelled, which is the moment
+     * to stop a subprocess or an inference that is no longer needed. Returning
+     * nothing emits nothing, which is how a cancelled synthesis reports back.
+     */
+    protected abstract synthesize(text: string, signal: AbortSignal): Promise<Buffer | undefined>;
+    /**
+     * Emits a piece of the sentence being synthesized.
+     *
+     * A model that generates progressively can hand its chunks over as they
+     * come rather than waiting for the sentence to be finished, which brings
+     * the first word forward by the duration of that sentence. The false it
+     * returns says the utterance was cancelled or replaced, so the generation
+     * it comes from can be stopped there.
+     */
+    protected emitAudio(audio: Buffer): boolean;
+    speak(textStream: Readable): void;
+    cancel(): void;
+    private enqueue;
+    private drain;
+}
+
 interface MicdropServerEvents {
     End: [MicdropCallSummary];
     UserAudio: [Buffer];
@@ -322,4 +427,4 @@ declare class MicdropRecorder extends EventEmitter<MicdropRecorderEvents> {
 
 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 AudioMessage, type DeepPartial, type ExtractJsonOptions, type ExtractOptions, type ExtractTagOptions, FallbackAgent, type FallbackAgentOptions, 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 };
+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, FallbackAgent, type FallbackAgentOptions, 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, Pcm16Resampler, STT, type STTEvents, SentenceSplitter, SentenceTTS, TTS, type TTSEvents, type Tool, float32ToPcm16, handleError, pcm16ToFloat32, waitForParams };

package/dist/index.js

@@ -50,9 +50,14 @@ __export(index_exports, {
   MockAgent: () => MockAgent,
   MockSTT: () => MockSTT,
   MockTTS: () => MockTTS,
+  Pcm16Resampler: () => Pcm16Resampler,
   STT: () => STT,
+  SentenceSplitter: () => SentenceSplitter,
+  SentenceTTS: () => SentenceTTS,
   TTS: () => TTS,
+  float32ToPcm16: () => float32ToPcm16,
   handleError: () => handleError,
+  pcm16ToFloat32: () => pcm16ToFloat32,
   waitForParams: () => waitForParams
 });
 module.exports = __toCommonJS(index_exports);
@@ -399,6 +404,69 @@ var MockAgent = class extends Agent {
   }
 };
 
+// src/audio/Pcm16Resampler.ts
+var Pcm16Resampler = class {
+  // Fractional position into the first sample of the buffer
+  constructor(inRate, outRate) {
+    this.leftover = Buffer.alloc(0);
+    this.pos = 0;
+    this.step = inRate / outRate;
+  }
+  // Reset to the initial state, to resample a new independent stream
+  // (e.g. resending buffered audio after a reconnection).
+  reset() {
+    this.leftover = Buffer.alloc(0);
+    this.pos = 0;
+  }
+  process(chunk) {
+    const buf = this.leftover.length ? Buffer.concat([this.leftover, chunk]) : chunk;
+    const samples = Math.floor(buf.length / 2);
+    if (samples < 2) {
+      this.leftover = buf;
+      return Buffer.alloc(0);
+    }
+    const out = [];
+    let p = this.pos;
+    while (Math.floor(p) + 1 < samples) {
+      const i = Math.floor(p);
+      const frac = p - i;
+      const s0 = buf.readInt16LE(i * 2);
+      const s1 = buf.readInt16LE((i + 1) * 2);
+      out.push(Math.round(s0 + (s1 - s0) * frac));
+      p += this.step;
+    }
+    const consumed = Math.floor(p);
+    this.pos = p - consumed;
+    this.leftover = buf.subarray(consumed * 2);
+    const result = Buffer.alloc(out.length * 2);
+    for (let k = 0; k < out.length; k++) {
+      result.writeInt16LE(out[k], k * 2);
+    }
+    return result;
+  }
+};
+
+// src/audio/pcm16.ts
+var PCM16_MAX = 32767;
+var PCM16_MIN = -32768;
+function float32ToPcm16(samples) {
+  const buffer = Buffer.alloc(samples.length * 2);
+  for (let i = 0; i < samples.length; i++) {
+    const scaled = Math.round(samples[i] * PCM16_MAX);
+    const clamped = Math.max(PCM16_MIN, Math.min(PCM16_MAX, scaled));
+    buffer.writeInt16LE(clamped, i * 2);
+  }
+  return buffer;
+}
+function pcm16ToFloat32(buffer) {
+  const length = Math.floor(buffer.length / 2);
+  const samples = new Float32Array(length);
+  for (let i = 0; i < length; i++) {
+    samples[i] = buffer.readInt16LE(i * 2) / PCM16_MAX;
+  }
+  return samples;
+}
+
 // src/errors.ts
 var MicdropErrorCode = /* @__PURE__ */ ((MicdropErrorCode2) => {
   MicdropErrorCode2[MicdropErrorCode2["BadRequest"] = 4400] = "BadRequest";
@@ -888,8 +956,7 @@ var FallbackSTT = class extends STT {
   }
 };
 
-// src/tts/MockTTS.ts
-var fs = __toESM(require("fs"));
+// src/tts/FallbackTTS.ts
 var import_stream4 = require("stream");
 
 // src/tts/TTS.ts
@@ -904,31 +971,7 @@ var TTS = class extends import_eventemitter35.EventEmitter {
   }
 };
 
-// src/tts/MockTTS.ts
-var MockTTS = class extends TTS {
-  constructor(audioFilePaths) {
-    super();
-    this.audioFilePaths = audioFilePaths;
-  }
-  speak(textStream) {
-    const audioStream = new import_stream4.PassThrough();
-    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/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) {
@@ -944,7 +987,7 @@ var FallbackTTS = class extends TTS {
       this.startNextTTS();
       if (chunks.length > 0) {
         this.log("Sending text chunks again");
-        const stream = new import_stream5.PassThrough();
+        const stream = new import_stream4.PassThrough();
         this.tts?.speak(stream);
         chunks.forEach((chunk) => stream.write(chunk));
         stream.end();
@@ -984,6 +1027,164 @@ var FallbackTTS = class extends TTS {
   }
 };
 
+// src/tts/MockTTS.ts
+var fs = __toESM(require("fs"));
+var import_stream5 = require("stream");
+var MockTTS = class extends TTS {
+  constructor(audioFilePaths) {
+    super();
+    this.audioFilePaths = audioFilePaths;
+  }
+  speak(textStream) {
+    const audioStream = new import_stream5.PassThrough();
+    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/tts/SentenceSplitter.ts
+var SentenceSplitter = class {
+  constructor() {
+    this.buffer = "";
+  }
+  /** Adds text and returns the sentences it completes. */
+  push(text) {
+    this.buffer += text;
+    return this.extract(false);
+  }
+  /** Returns the sentences left in the buffer and empties it. */
+  flush() {
+    const sentences = this.extract(true);
+    const rest = this.buffer.trim();
+    this.buffer = "";
+    if (rest) sentences.push(rest);
+    return sentences;
+  }
+  /** Drops the buffered text, used when an utterance is cancelled. */
+  reset() {
+    this.buffer = "";
+  }
+  extract(end) {
+    const sentences = [];
+    const regex = /[\s\S]*?[.!?…\n]+(?=\s|$)/g;
+    let match;
+    let lastIndex = 0;
+    while ((match = regex.exec(this.buffer)) !== null) {
+      if (!end && regex.lastIndex === this.buffer.length) break;
+      const sentence = match[0].trim();
+      if (sentence) sentences.push(sentence);
+      lastIndex = regex.lastIndex;
+    }
+    this.buffer = this.buffer.slice(lastIndex);
+    return sentences;
+  }
+};
+
+// src/tts/SentenceTTS.ts
+var SentenceTTS = class extends TTS {
+  constructor() {
+    super(...arguments);
+    this.splitter = new SentenceSplitter();
+    this.queue = [];
+    this.draining = false;
+    // Bumped by every speak() and every cancel(), so a call claimed late can tell
+    // whether it is still the one that should be heard.
+    this.generation = 0;
+    this.counter = 0;
+    // Identifies the current speak() call
+    this.synthesizing = 0;
+  }
+  /**
+   * Emits a piece of the sentence being synthesized.
+   *
+   * A model that generates progressively can hand its chunks over as they
+   * come rather than waiting for the sentence to be finished, which brings
+   * the first word forward by the duration of that sentence. The false it
+   * returns says the utterance was cancelled or replaced, so the generation
+   * it comes from can be stopped there.
+   */
+  emitAudio(audio) {
+    if (this.synthesizing !== this.counter) return false;
+    if (audio.length) this.emit("Audio", audio);
+    return true;
+  }
+  speak(textStream) {
+    const generation = ++this.generation;
+    let counter = 0;
+    const claimCall = () => {
+      if (counter) return true;
+      if (this.generation !== generation) return false;
+      this.counter++;
+      counter = this.counter;
+      this.splitter.reset();
+      return true;
+    };
+    textStream.on("data", (chunk) => {
+      if (!claimCall()) return;
+      if (counter !== this.counter) return;
+      this.enqueue(counter, this.splitter.push(chunk.toString("utf-8")));
+    });
+    textStream.on("error", (error) => {
+      this.log("Error in text stream", error);
+    });
+    textStream.on("end", () => {
+      if (!counter || counter !== this.counter) return;
+      this.enqueue(counter, this.splitter.flush());
+    });
+  }
+  cancel() {
+    this.log("Cancel");
+    this.generation++;
+    this.counter++;
+    this.splitter.reset();
+    this.queue = [];
+    this.controller?.abort();
+    this.controller = void 0;
+  }
+  enqueue(counter, sentences) {
+    if (sentences.length === 0) return;
+    if (counter !== this.counter) return;
+    this.queue.push(...sentences);
+    this.drain();
+  }
+  async drain() {
+    if (this.draining) return;
+    this.draining = true;
+    while (this.queue.length > 0) {
+      const counter = this.counter;
+      this.synthesizing = counter;
+      const text = this.queue.shift();
+      const controller = new AbortController();
+      this.controller = controller;
+      try {
+        this.log(`Synthesizing: "${text}"`);
+        const audio = await this.synthesize(text, controller.signal);
+        if (counter !== this.counter) continue;
+        if (audio?.length) this.emit("Audio", audio);
+      } catch (error) {
+        if (counter !== this.counter) continue;
+        this.log("Error synthesizing speech", error);
+        this.emit("Failed", [text, ...this.queue]);
+        this.queue = [];
+      } finally {
+        if (this.controller === controller) this.controller = void 0;
+      }
+    }
+    this.draining = false;
+    if (this.queue.length > 0) this.drain();
+  }
+};
+
 // src/waitForParams.ts
 async function waitForParams(socket, validate) {
   return new Promise((resolve, reject) => {
@@ -1025,9 +1226,14 @@ async function waitForParams(socket, validate) {
   MockAgent,
   MockSTT,
   MockTTS,
+  Pcm16Resampler,
   STT,
+  SentenceSplitter,
+  SentenceTTS,
   TTS,
+  float32ToPcm16,
   handleError,
+  pcm16ToFloat32,
   waitForParams
 });
 //# sourceMappingURL=index.js.map