getpatter 0.4.3 → 0.5.0

package/dist/index.js

@@ -305,235 +305,16 @@ var init_elevenlabs_convai = __esm({
   }
 });
 
-// src/providers/deepgram-stt.ts
-var import_ws4, DEEPGRAM_WS_URL, DeepgramSTT;
-var init_deepgram_stt = __esm({
-  "src/providers/deepgram-stt.ts"() {
-    "use strict";
-    import_ws4 = __toESM(require("ws"));
-    init_logger();
-    DEEPGRAM_WS_URL = "wss://api.deepgram.com/v1/listen";
-    DeepgramSTT = class _DeepgramSTT {
-      constructor(apiKey, language = "en", model = "nova-3", encoding = "linear16", sampleRate = 16e3) {
-        this.apiKey = apiKey;
-        this.language = language;
-        this.model = model;
-        this.encoding = encoding;
-        this.sampleRate = sampleRate;
-      }
-      ws = null;
-      callbacks = [];
-      /** Request ID from Deepgram — used to query actual cost post-call. */
-      requestId = "";
-      /** Factory for Twilio calls — mulaw 8 kHz. */
-      static forTwilio(apiKey, language = "en", model = "nova-3") {
-        return new _DeepgramSTT(apiKey, language, model, "mulaw", 8e3);
-      }
-      async connect() {
-        const params = new URLSearchParams({
-          model: this.model,
-          language: this.language,
-          encoding: this.encoding,
-          sample_rate: String(this.sampleRate),
-          channels: "1",
-          interim_results: "true",
-          endpointing: "300",
-          smart_format: "true",
-          vad_events: "true",
-          no_delay: "true"
-        });
-        const url = `${DEEPGRAM_WS_URL}?${params.toString()}`;
-        this.ws = new import_ws4.default(url, {
-          headers: { Authorization: `Token ${this.apiKey}` }
-        });
-        await new Promise((resolve, reject) => {
-          const timer = setTimeout(() => reject(new Error("Deepgram connect timeout")), 1e4);
-          this.ws.once("open", () => {
-            clearTimeout(timer);
-            resolve();
-          });
-          this.ws.once("error", (err) => {
-            clearTimeout(timer);
-            reject(err);
-          });
-        });
-        this.ws.on("message", (raw) => {
-          let data;
-          try {
-            data = JSON.parse(raw.toString());
-          } catch {
-            return;
-          }
-          if (data.type === "Metadata" && data.request_id) {
-            this.requestId = data.request_id;
-            return;
-          }
-          if (data.type !== "Results") return;
-          const alternatives = data.channel?.alternatives ?? [];
-          if (!alternatives.length) return;
-          const best = alternatives[0];
-          const text = (best.transcript ?? "").trim();
-          if (!text) return;
-          const transcript = {
-            text,
-            isFinal: Boolean(data.is_final) && Boolean(data.speech_final),
-            confidence: best.confidence ?? 0
-          };
-          for (const cb of this.callbacks) {
-            cb(transcript);
-          }
-        });
-      }
-      sendAudio(audio) {
-        if (!this.ws || this.ws.readyState !== import_ws4.default.OPEN) return;
-        this.ws.send(audio);
-      }
-      onTranscript(callback) {
-        if (this.callbacks.length >= 10) {
-          getLogger().warn("DeepgramSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback.");
-          this.callbacks[this.callbacks.length - 1] = callback;
-          return;
-        }
-        this.callbacks.push(callback);
-      }
-      close() {
-        if (this.ws) {
-          try {
-            this.ws.send(JSON.stringify({ type: "CloseStream" }));
-          } catch {
-          }
-          this.ws.close();
-          this.ws = null;
-        }
-      }
-    };
-  }
-});
-
-// src/providers/whisper-stt.ts
-function wrapPcmInWav(pcm, sampleRate = 16e3, channels = 1, bitsPerSample = 16) {
-  const dataSize = pcm.length;
-  const header = Buffer.alloc(44);
-  header.write("RIFF", 0);
-  header.writeUInt32LE(36 + dataSize, 4);
-  header.write("WAVE", 8);
-  header.write("fmt ", 12);
-  header.writeUInt32LE(16, 16);
-  header.writeUInt16LE(1, 20);
-  header.writeUInt16LE(channels, 22);
-  header.writeUInt32LE(sampleRate, 24);
-  header.writeUInt32LE(sampleRate * channels * (bitsPerSample / 8), 28);
-  header.writeUInt16LE(channels * (bitsPerSample / 8), 32);
-  header.writeUInt16LE(bitsPerSample, 34);
-  header.write("data", 36);
-  header.writeUInt32LE(dataSize, 40);
-  return Buffer.concat([header, pcm]);
+// src/provider-factory.ts
+async function createSTT(agent) {
+  return agent.stt ?? null;
+}
+async function createTTS(agent) {
+  return agent.tts ?? null;
 }
-var OPENAI_TRANSCRIPTION_URL, DEFAULT_BUFFER_SIZE, WhisperSTT;
-var init_whisper_stt = __esm({
-  "src/providers/whisper-stt.ts"() {
+var init_provider_factory = __esm({
+  "src/provider-factory.ts"() {
     "use strict";
-    init_logger();
-    OPENAI_TRANSCRIPTION_URL = "https://api.openai.com/v1/audio/transcriptions";
-    DEFAULT_BUFFER_SIZE = 16e3 * 2;
-    WhisperSTT = class _WhisperSTT {
-      apiKey;
-      model;
-      language;
-      bufferSize;
-      buffer = Buffer.alloc(0);
-      callbacks = [];
-      running = false;
-      pendingTranscriptions = [];
-      constructor(apiKey, model = "whisper-1", language, bufferSize = DEFAULT_BUFFER_SIZE) {
-        this.apiKey = apiKey;
-        this.model = model;
-        this.language = language;
-        this.bufferSize = bufferSize;
-      }
-      /** Factory for Twilio calls — mulaw 8 kHz is transcoded upstream, so we still receive PCM 16-bit. */
-      static forTwilio(apiKey, language = "en", model = "whisper-1") {
-        return new _WhisperSTT(apiKey, model, language);
-      }
-      async connect() {
-        this.running = true;
-        this.buffer = Buffer.alloc(0);
-      }
-      sendAudio(audio) {
-        if (!this.running) return;
-        this.buffer = Buffer.concat([this.buffer, audio]);
-        if (this.buffer.length >= this.bufferSize) {
-          const pcm = this.buffer;
-          this.buffer = Buffer.alloc(0);
-          this.trackTranscription(this.transcribeBuffer(pcm));
-        }
-      }
-      trackTranscription(promise) {
-        const wrapped = promise.finally(() => {
-          const idx = this.pendingTranscriptions.indexOf(wrapped);
-          if (idx !== -1) this.pendingTranscriptions.splice(idx, 1);
-        });
-        this.pendingTranscriptions.push(wrapped);
-      }
-      onTranscript(callback) {
-        if (this.callbacks.length >= 10) {
-          getLogger().warn("WhisperSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback.");
-          this.callbacks[this.callbacks.length - 1] = callback;
-          return;
-        }
-        this.callbacks.push(callback);
-      }
-      async close() {
-        this.running = false;
-        if (this.buffer.length >= this.bufferSize / 4) {
-          const pcm = this.buffer;
-          this.buffer = Buffer.alloc(0);
-          this.trackTranscription(this.transcribeBuffer(pcm));
-        } else {
-          this.buffer = Buffer.alloc(0);
-        }
-        await Promise.allSettled(this.pendingTranscriptions);
-        this.callbacks = [];
-      }
-      // ------------------------------------------------------------------
-      // Private
-      // ------------------------------------------------------------------
-      async transcribeBuffer(pcm) {
-        const wav = wrapPcmInWav(pcm);
-        const formData = new FormData();
-        formData.append("file", new Blob([wav.buffer.slice(wav.byteOffset, wav.byteOffset + wav.byteLength)], { type: "audio/wav" }), "audio.wav");
-        formData.append("model", this.model);
-        if (this.language) {
-          formData.append("language", this.language);
-        }
-        try {
-          const resp = await fetch(OPENAI_TRANSCRIPTION_URL, {
-            method: "POST",
-            headers: { Authorization: `Bearer ${this.apiKey}` },
-            body: formData,
-            signal: AbortSignal.timeout(15e3)
-          });
-          if (!resp.ok) {
-            const body = await resp.text();
-            getLogger().error(`WhisperSTT transcription error: ${resp.status} ${body}`);
-            return;
-          }
-          const json = await resp.json();
-          const text = (json.text ?? "").trim();
-          if (!text) return;
-          const transcript = {
-            text,
-            isFinal: true,
-            confidence: 1
-          };
-          for (const cb of this.callbacks) {
-            cb(transcript);
-          }
-        } catch (err) {
-          getLogger().error(`WhisperSTT transcription error: ${String(err)}`);
-        }
-      }
-    };
   }
 });
 
@@ -616,9 +397,15 @@ var init_store = __esm({
       maxCalls;
       calls = [];
       activeCalls = /* @__PURE__ */ new Map();
-      constructor(maxCalls = 500) {
+      /**
+       * Accepts either a numeric ``maxCalls`` (legacy positional — matches the
+       * original TS API) or an options object ``{ maxCalls }`` to align with the
+       * Python SDK's keyword-argument style. Plain literals also work:
+       * ``new MetricsStore()`` / ``new MetricsStore(100)`` / ``new MetricsStore({ maxCalls: 100 })``.
+       */
+      constructor(maxCallsOrOpts = 500) {
         super();
-        this.maxCalls = maxCalls;
+        this.maxCalls = typeof maxCallsOrOpts === "number" ? maxCallsOrOpts : maxCallsOrOpts.maxCalls ?? 500;
       }
       publish(eventType, data) {
         this.emit("sse", { type: eventType, data });
@@ -626,22 +413,100 @@ var init_store = __esm({
       recordCallStart(data) {
         const callId = data.call_id || "";
         if (!callId) return;
+        const existing = this.activeCalls.get(callId);
+        if (existing) {
+          existing.caller = data.caller || existing.caller;
+          existing.callee = data.callee || existing.callee;
+          existing.direction = data.direction || existing.direction;
+          existing.status = "in-progress";
+          existing.turns = existing.turns || [];
+        } else {
+          const record = {
+            call_id: callId,
+            caller: data.caller || "",
+            callee: data.callee || "",
+            direction: data.direction || "inbound",
+            started_at: Date.now() / 1e3,
+            status: "in-progress",
+            turns: []
+          };
+          this.activeCalls.set(callId, record);
+        }
+        this.publish("call_start", {
+          call_id: callId,
+          caller: data.caller || "",
+          callee: data.callee || "",
+          direction: data.direction || "inbound"
+        });
+      }
+      /**
+       * Pre-register an outbound call before any webhook fires. Lets the
+       * dashboard surface attempts that never reach media (no-answer, busy,
+       * carrier-rejected). Mirrors the Python ``record_call_initiated``.
+       */
+      recordCallInitiated(data) {
+        const callId = data.call_id || "";
+        if (!callId) return;
+        if (this.activeCalls.has(callId)) return;
         const record = {
           call_id: callId,
           caller: data.caller || "",
           callee: data.callee || "",
-          direction: data.direction || "inbound",
+          direction: data.direction || "outbound",
           started_at: Date.now() / 1e3,
+          status: "initiated",
           turns: []
         };
         this.activeCalls.set(callId, record);
-        this.publish("call_start", {
+        this.publish("call_initiated", {
           call_id: callId,
           caller: record.caller,
           callee: record.callee,
-          direction: record.direction
+          direction: record.direction,
+          status: record.status
         });
       }
+      /**
+       * Update the status of an active or completed call. Terminal states
+       * (completed, no-answer, busy, failed, canceled, webhook_error) move the
+       * row from active to completed so the UI freezes the live duration timer.
+       */
+      updateCallStatus(callId, status, extra = {}) {
+        if (!callId || !status) return;
+        const TERMINAL = /* @__PURE__ */ new Set(["completed", "no-answer", "busy", "failed", "canceled", "webhook_error"]);
+        const active = this.activeCalls.get(callId);
+        if (active) {
+          active.status = status;
+          Object.assign(active, extra);
+          if (TERMINAL.has(status)) {
+            const entry = {
+              call_id: callId,
+              caller: active.caller || "",
+              callee: active.callee || "",
+              direction: active.direction || "outbound",
+              started_at: active.started_at || 0,
+              ended_at: Date.now() / 1e3,
+              status,
+              metrics: null,
+              ...extra
+            };
+            this.activeCalls.delete(callId);
+            this.calls.push(entry);
+            if (this.calls.length > this.maxCalls) {
+              this.calls = this.calls.slice(-this.maxCalls);
+            }
+          }
+        } else {
+          for (let i = this.calls.length - 1; i >= 0; i--) {
+            if (this.calls[i].call_id === callId) {
+              this.calls[i].status = status;
+              Object.assign(this.calls[i], extra);
+              break;
+            }
+          }
+        }
+        this.publish("call_status", { call_id: callId, status, ...extra });
+      }
       recordTurn(data) {
         const callId = data.call_id || "";
         const turn = data.turn;
@@ -658,6 +523,8 @@ var init_store = __esm({
         if (!callId) return;
         const active = this.activeCalls.get(callId);
         this.activeCalls.delete(callId);
+        const activeStatus = active?.status;
+        const resolvedStatus = activeStatus && activeStatus !== "in-progress" ? activeStatus : "completed";
         const entry = {
           call_id: callId,
           caller: data.caller || active?.caller || "",
@@ -666,6 +533,7 @@ var init_store = __esm({
           started_at: active?.started_at || 0,
           ended_at: Date.now() / 1e3,
           transcript: data.transcript || [],
+          status: resolvedStatus,
           metrics: metrics ?? null
         };
         this.calls.push(entry);
@@ -1866,171 +1734,125 @@ var init_remote_message = __esm({
   }
 });
 
-// src/providers/elevenlabs-tts.ts
-var ELEVENLABS_BASE_URL, ElevenLabsTTS;
-var init_elevenlabs_tts = __esm({
-  "src/providers/elevenlabs-tts.ts"() {
+// src/providers/deepgram-stt.ts
+var import_ws4, DEEPGRAM_WS_URL, DeepgramSTT;
+var init_deepgram_stt = __esm({
+  "src/providers/deepgram-stt.ts"() {
     "use strict";
-    ELEVENLABS_BASE_URL = "https://api.elevenlabs.io/v1";
-    ElevenLabsTTS = class {
-      constructor(apiKey, voiceId = "21m00Tcm4TlvDq8ikWAM", modelId = "eleven_turbo_v2_5", outputFormat = "pcm_16000") {
+    import_ws4 = __toESM(require("ws"));
+    init_logger();
+    DEEPGRAM_WS_URL = "wss://api.deepgram.com/v1/listen";
+    DeepgramSTT = class _DeepgramSTT {
+      ws = null;
+      callbacks = [];
+      /** Request ID from Deepgram — used to query actual cost post-call. */
+      requestId = "";
+      apiKey;
+      language;
+      model;
+      encoding;
+      sampleRate;
+      endpointingMs;
+      utteranceEndMs;
+      smartFormat;
+      interimResults;
+      vadEvents;
+      constructor(apiKey, languageOrOptions, model, encoding, sampleRate, options) {
         this.apiKey = apiKey;
-        this.voiceId = voiceId;
-        this.modelId = modelId;
-        this.outputFormat = outputFormat;
-      }
-      /**
-       * Synthesise text to speech and return the full audio as a single Buffer.
-       *
-       * For large chunks (or when latency matters) call `synthesizeStream` instead.
-       */
-      async synthesize(text) {
-        const chunks = [];
-        for await (const chunk of this.synthesizeStream(text)) {
-          chunks.push(chunk);
-        }
-        return Buffer.concat(chunks);
+        const opts = typeof languageOrOptions === "object" && languageOrOptions !== null ? languageOrOptions : options ?? {};
+        this.language = (typeof languageOrOptions === "string" ? languageOrOptions : opts.language) ?? "en";
+        this.model = model ?? opts.model ?? "nova-3";
+        this.encoding = encoding ?? opts.encoding ?? "linear16";
+        this.sampleRate = sampleRate ?? opts.sampleRate ?? 16e3;
+        this.endpointingMs = opts.endpointingMs ?? 150;
+        this.utteranceEndMs = opts.utteranceEndMs === null ? null : opts.utteranceEndMs ?? 1e3;
+        this.smartFormat = opts.smartFormat ?? true;
+        this.interimResults = opts.interimResults ?? true;
+        this.vadEvents = opts.vadEvents ?? true;
+      }
+      /** Factory for Twilio calls — mulaw 8 kHz. Forwards tuning options through. */
+      static forTwilio(apiKey, language = "en", model = "nova-3", options = {}) {
+        return new _DeepgramSTT(apiKey, language, model, "mulaw", 8e3, options);
       }
-      /**
-       * Synthesise text and yield audio chunks as they arrive (streaming).
-       *
-       * The yielded buffers are raw PCM at 16 kHz (or whatever `outputFormat` is
-       * configured to).
-       */
-      async *synthesizeStream(text) {
-        const url = `${ELEVENLABS_BASE_URL}/text-to-speech/${encodeURIComponent(this.voiceId)}/stream?output_format=${encodeURIComponent(this.outputFormat)}`;
-        const response = await fetch(url, {
-          method: "POST",
-          headers: {
-            "xi-api-key": this.apiKey,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({ text, model_id: this.modelId }),
-          signal: AbortSignal.timeout(3e4)
+      async connect() {
+        const params = new URLSearchParams({
+          model: this.model,
+          language: this.language,
+          encoding: this.encoding,
+          sample_rate: String(this.sampleRate),
+          channels: "1",
+          interim_results: this.interimResults ? "true" : "false",
+          endpointing: String(this.endpointingMs),
+          smart_format: this.smartFormat ? "true" : "false",
+          vad_events: this.vadEvents ? "true" : "false",
+          no_delay: "true"
         });
-        if (!response.ok) {
-          const body = await response.text();
-          throw new Error(`ElevenLabs TTS error ${response.status}: ${body}`);
+        if (this.utteranceEndMs !== null) {
+          params.set("utterance_end_ms", String(Math.max(this.utteranceEndMs, 1e3)));
         }
-        if (!response.body) {
-          throw new Error("ElevenLabs TTS: no response body");
-        }
-        const reader = response.body.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            if (value && value.length > 0) {
-              yield Buffer.from(value);
-            }
-          }
-        } finally {
-          if (typeof reader.cancel === "function") await reader.cancel().catch(() => {
+        const url = `${DEEPGRAM_WS_URL}?${params.toString()}`;
+        this.ws = new import_ws4.default(url, {
+          headers: { Authorization: `Token ${this.apiKey}` }
+        });
+        await new Promise((resolve, reject) => {
+          const timer = setTimeout(() => reject(new Error("Deepgram connect timeout")), 1e4);
+          this.ws.once("open", () => {
+            clearTimeout(timer);
+            resolve();
+          });
+          this.ws.once("error", (err) => {
+            clearTimeout(timer);
+            reject(err);
           });
-          reader.releaseLock();
-        }
-      }
-    };
-  }
-});
-
-// src/providers/openai-tts.ts
-var OPENAI_TTS_URL, OpenAITTS;
-var init_openai_tts = __esm({
-  "src/providers/openai-tts.ts"() {
-    "use strict";
-    OPENAI_TTS_URL = "https://api.openai.com/v1/audio/speech";
-    OpenAITTS = class _OpenAITTS {
-      constructor(apiKey, voice = "alloy", model = "tts-1") {
-        this.apiKey = apiKey;
-        this.voice = voice;
-        this.model = model;
-      }
-      /**
-       * Synthesise text to speech and return the full audio as a single Buffer.
-       *
-       * For large chunks (or when latency matters) call `synthesizeStream` instead.
-       */
-      async synthesize(text) {
-        const chunks = [];
-        for await (const chunk of this.synthesizeStream(text)) {
-          chunks.push(chunk);
-        }
-        return Buffer.concat(chunks);
-      }
-      /**
-       * Synthesise text and yield audio chunks as they arrive (streaming).
-       *
-       * OpenAI returns 24 kHz PCM16; each chunk is resampled to 16 kHz before
-       * yielding so the output is ready for telephony pipelines.
-       */
-      async *synthesizeStream(text) {
-        const response = await fetch(OPENAI_TTS_URL, {
-          method: "POST",
-          headers: {
-            "Authorization": `Bearer ${this.apiKey}`,
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify({
-            model: this.model,
-            input: text,
-            voice: this.voice,
-            response_format: "pcm"
-          }),
-          signal: AbortSignal.timeout(3e4)
         });
-        if (!response.ok) {
-          const body = await response.text();
-          throw new Error(`OpenAI TTS error ${response.status}: ${body}`);
-        }
-        if (!response.body) {
-          throw new Error("OpenAI TTS: no response body");
-        }
-        const reader = response.body.getReader();
-        try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            if (value && value.length > 0) {
-              yield _OpenAITTS.resample24kTo16k(Buffer.from(value));
-            }
+        this.ws.on("message", (raw) => {
+          let data;
+          try {
+            data = JSON.parse(raw.toString());
+          } catch {
+            return;
           }
-        } finally {
-          if (typeof reader.cancel === "function") await reader.cancel().catch(() => {
-          });
-          reader.releaseLock();
+          if (data.type === "Metadata" && data.request_id) {
+            this.requestId = data.request_id;
+            return;
+          }
+          if (data.type !== "Results") return;
+          const alternatives = data.channel?.alternatives ?? [];
+          if (!alternatives.length) return;
+          const best = alternatives[0];
+          const text = (best.transcript ?? "").trim();
+          if (!text) return;
+          const transcript = {
+            text,
+            isFinal: Boolean(data.is_final) || Boolean(data.speech_final),
+            confidence: best.confidence ?? 0
+          };
+          for (const cb of this.callbacks) {
+            cb(transcript);
+          }
+        });
+      }
+      sendAudio(audio) {
+        if (!this.ws || this.ws.readyState !== import_ws4.default.OPEN) return;
+        this.ws.send(audio);
+      }
+      onTranscript(callback) {
+        if (this.callbacks.length >= 10) {
+          getLogger().warn("DeepgramSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback.");
+          this.callbacks[this.callbacks.length - 1] = callback;
+          return;
         }
+        this.callbacks.push(callback);
       }
-      /**
-       * Resample 24 kHz PCM16-LE to 16 kHz by taking 2 out of every 3 samples.
-       *
-       * For each group of 3 input samples the first is kept as-is and the second
-       * output sample is the average of input samples 2 and 3.  This matches the
-       * Python SDK implementation.
-       */
-      static resample24kTo16k(audio) {
-        if (audio.length < 2) return audio;
-        const sampleCount = Math.floor(audio.length / 2);
-        const samples = new Int16Array(sampleCount);
-        for (let i = 0; i < sampleCount; i++) {
-          samples[i] = audio.readInt16LE(i * 2);
-        }
-        const resampled = [];
-        for (let i = 0; i < samples.length; i += 3) {
-          resampled.push(samples[i]);
-          if (i + 1 < samples.length) {
-            if (i + 2 < samples.length) {
-              resampled.push(Math.trunc((samples[i + 1] + samples[i + 2]) / 2));
-            } else {
-              resampled.push(samples[i + 1]);
-            }
+      close() {
+        if (this.ws) {
+          try {
+            this.ws.send(JSON.stringify({ type: "CloseStream" }));
+          } catch {
           }
+          this.ws.close();
+          this.ws = null;
         }
-        const out = Buffer.alloc(resampled.length * 2);
-        for (let i = 0; i < resampled.length; i++) {
-          out.writeInt16LE(resampled[i], i * 2);
-        }
-        return out;
       }
     };
   }
@@ -2940,8 +2762,8 @@ var init_stream_handler = __esm({
     "use strict";
     init_openai_realtime();
     init_elevenlabs_convai();
-    init_elevenlabs_tts();
-    init_openai_tts();
+    init_deepgram_stt();
+    init_provider_factory();
     init_metrics();
     init_transcoding();
     init_llm_loop();
@@ -2972,6 +2794,9 @@ var init_stream_handler = __esm({
       maxDurationTimer = null;
       transcriptProcessing = false;
       transcriptQueue = [];
+      // BUG #22 throttle state — mirror Python impl.
+      lastCommitText = "";
+      lastCommitAt = 0;
       history;
       metricsAcc;
       constructor(deps, ws, caller, callee) {
@@ -2980,8 +2805,8 @@ var init_stream_handler = __esm({
         this.caller = caller;
         this.callee = callee;
         this.history = createHistoryManager(200);
-        const sttProviderName = deps.agent.stt?.provider || (deps.agent.deepgramKey ? "deepgram" : void 0);
-        const ttsProviderName = deps.agent.tts?.provider === "elevenlabs" ? "elevenlabs" : deps.agent.tts?.provider === "openai" ? "openai_tts" : deps.agent.elevenlabsKey ? "elevenlabs" : void 0;
+        const sttProviderName = deps.agent.stt ? deps.agent.stt.constructor?.name ?? "custom" : void 0;
+        const ttsProviderName = deps.agent.tts ? deps.agent.tts.constructor?.name ?? "custom" : void 0;
         const providerMode = deps.agent.provider ?? "openai_realtime";
         this.metricsAcc = new CallMetricsAccumulator({
           callId: "",
@@ -3082,15 +2907,23 @@ var init_stream_handler = __esm({
         this.streamSid = sid;
       }
       /** Handle an incoming audio chunk (already decoded from base64). */
-      handleAudio(audioBuffer) {
+      async handleAudio(audioBuffer) {
         const provider = this.deps.agent.provider ?? "openai_realtime";
-        if (provider === "pipeline" && this.stt && !this.isSpeaking) {
-          if (this.deps.bridge.telephonyProvider === "twilio") {
-            const pcm8k = mulawToPcm16(audioBuffer);
-            const pcm16k = resample8kTo16k(pcm8k);
-            this.stt.sendAudio(pcm16k);
+        if (provider === "pipeline" && this.stt) {
+          if (this.isSpeaking && (this.deps.agent.bargeInThresholdMs ?? 300) === 0) {
+            return;
+          }
+          const pcm8k = mulawToPcm16(audioBuffer);
+          const pcm16k = resample8kTo16k(pcm8k);
+          const hooks = this.deps.agent.hooks;
+          if (hooks) {
+            const hookExecutor = new PipelineHookExecutor(hooks);
+            const hookCtx = this.buildHookContext();
+            const processed = await hookExecutor.runBeforeSendToStt(pcm16k, hookCtx);
+            if (processed === null) return;
+            this.stt.sendAudio(processed);
           } else {
-            this.stt.sendAudio(audioBuffer);
+            this.stt.sendAudio(pcm16k);
           }
         } else if (this.adapter) {
           if (this.adapter instanceof ElevenLabsConvAIAdapter && this.deps.bridge.telephonyProvider === "twilio") {
@@ -3163,18 +2996,8 @@ var init_stream_handler = __esm({
       // ---------------------------------------------------------------------------
       async initPipeline(resolvedPrompt) {
         const label = this.deps.bridge.label;
-        this.stt = this.deps.bridge.createStt(this.deps.agent);
-        if (this.deps.agent.tts) {
-          if (this.deps.agent.tts.provider === "elevenlabs") {
-            this.tts = new ElevenLabsTTS(this.deps.agent.tts.apiKey, this.deps.agent.tts.voice ?? "21m00Tcm4TlvDq8ikWAM");
-          }
-          if (this.deps.agent.tts.provider === "openai") {
-            this.tts = new OpenAITTS(this.deps.agent.tts.apiKey, this.deps.agent.tts.voice ?? "alloy");
-          }
-        } else if (this.deps.agent.elevenlabsKey) {
-          const voiceId = this.deps.agent.voice && this.deps.agent.voice !== "alloy" ? this.deps.agent.voice : "21m00Tcm4TlvDq8ikWAM";
-          this.tts = new ElevenLabsTTS(this.deps.agent.elevenlabsKey, voiceId);
-        }
+        this.stt = await this.deps.bridge.createStt(this.deps.agent);
+        this.tts = await createTTS(this.deps.agent);
         if (!this.stt) {
           getLogger().info(`Pipeline mode (${label}): no STT configured`);
         }
@@ -3285,7 +3108,59 @@ var init_stream_handler = __esm({
         }
       }
       async processTranscript(transcript) {
+        if (transcript.text && this.isSpeaking) {
+          getLogger().info(
+            `Barge-in: caller spoke over agent (${sanitizeLogValue(transcript.text.slice(0, 40))})`
+          );
+          this.isSpeaking = false;
+          try {
+            this.deps.bridge.sendClear(this.ws, this.streamSid);
+          } catch (err) {
+            getLogger().debug(`sendClear during barge-in failed: ${String(err)}`);
+          }
+          this.metricsAcc.recordTurnInterrupted();
+        }
         if (!transcript.isFinal || !transcript.text) return;
+        const now = Date.now();
+        const normalised = transcript.text.trim().toLowerCase();
+        const stripped = normalised.replace(/[.,!?;: ]+$/, "").trim();
+        const sinceLastMs = now - this.lastCommitAt;
+        const HALLUCINATIONS = /* @__PURE__ */ new Set([
+          "you",
+          "thank you",
+          "thanks",
+          "yeah",
+          "yes",
+          "no",
+          "okay",
+          "ok",
+          "uh",
+          "um",
+          "mmm",
+          "hmm",
+          ".",
+          "bye",
+          "right",
+          "cool"
+        ]);
+        if (HALLUCINATIONS.has(stripped) || stripped === "") {
+          getLogger().info(`Dropped likely STT hallucination: ${sanitizeLogValue(normalised.slice(0, 40))}`);
+          return;
+        }
+        if (sinceLastMs < 2e3 && normalised === this.lastCommitText) {
+          getLogger().info(
+            `Dropped duplicate final transcript (${(sinceLastMs / 1e3).toFixed(1)}s since last): ${sanitizeLogValue(normalised.slice(0, 40))}`
+          );
+          return;
+        }
+        if (sinceLastMs < 500) {
+          getLogger().info(
+            `Dropped back-to-back final transcript (${(sinceLastMs / 1e3).toFixed(2)}s since last): ${sanitizeLogValue(normalised.slice(0, 40))}`
+          );
+          return;
+        }
+        this.lastCommitText = normalised;
+        this.lastCommitAt = now;
         const label = this.deps.bridge.label;
         getLogger().info(`User (${label} pipeline): ${sanitizeLogValue(transcript.text)}`);
         this.metricsAcc.startTurn();
@@ -3640,10 +3515,11 @@ var init_stream_handler = __esm({
           this.maxDurationTimer = null;
         }
         await this.deps.bridge.queryTelephonyCost(this.metricsAcc, this.callId);
-        const deepgramKey = this.deps.agent.deepgramKey;
-        const deepgramRequestId = this.stt?.requestId;
-        if (deepgramKey && deepgramRequestId) {
-          await queryDeepgramCost(this.metricsAcc, deepgramKey, deepgramRequestId);
+        if (this.stt instanceof DeepgramSTT && this.stt.requestId) {
+          const dgKey = this.stt.apiKey;
+          if (dgKey) {
+            await queryDeepgramCost(this.metricsAcc, dgKey, this.stt.requestId);
+          }
         }
         const finalMetrics = this.metricsAcc.endCall();
         const callEndData = {
@@ -3745,11 +3621,16 @@ function resolveVariables(template, variables) {
   return result;
 }
 function buildAIAdapter(config, agent, resolvedPrompt) {
+  const engine = agent.engine;
   if (agent.provider === "elevenlabs_convai") {
-    const key = agent.elevenlabsKey ?? "";
+    if (!engine || engine.kind !== "elevenlabs_convai") {
+      throw new Error(
+        "ElevenLabs ConvAI mode requires `agent.engine = new ElevenLabsConvAI({...})`."
+      );
+    }
     return new ElevenLabsConvAIAdapter(
-      key,
-      agent.elevenlabsAgentId ?? "",
+      engine.apiKey,
+      engine.agentId,
       agent.voice ?? "21m00Tcm4TlvDq8ikWAM",
       "eleven_turbo_v2_5",
       agent.language ?? "en",
@@ -3762,8 +3643,9 @@ function buildAIAdapter(config, agent, resolvedPrompt) {
     parameters: t.parameters
   })) ?? [];
   const tools = [...agentTools, TRANSFER_CALL_TOOL, END_CALL_TOOL];
+  const openaiKey = engine && engine.kind === "openai_realtime" ? engine.apiKey : config.openaiKey ?? "";
   return new OpenAIRealtimeAdapter(
-    config.openaiKey ?? "",
+    openaiKey,
     agent.model,
     agent.voice,
     resolvedPrompt ?? agent.systemPrompt,
@@ -3789,8 +3671,7 @@ var init_server = __esm({
     import_ws5 = require("ws");
     init_openai_realtime();
     init_elevenlabs_convai();
-    init_deepgram_stt();
-    init_whisper_stt();
+    init_provider_factory();
     init_pricing();
     init_store();
     init_routes();
@@ -3875,16 +3756,7 @@ var init_server = __esm({
         }
       }
       createStt(agent) {
-        if (agent.stt) {
-          if (agent.stt.provider === "deepgram") {
-            return DeepgramSTT.forTwilio(agent.stt.apiKey, agent.stt.language ?? "en");
-          } else if (agent.stt.provider === "whisper") {
-            return WhisperSTT.forTwilio(agent.stt.apiKey, agent.stt.language ?? "en");
-          }
-        } else if (agent.deepgramKey) {
-          return DeepgramSTT.forTwilio(agent.deepgramKey, agent.language ?? "en");
-        }
-        return null;
+        return createSTT(agent);
       }
       async queryTelephonyCost(metricsAcc, callId) {
         if (this.config.twilioSid && this.config.twilioToken && callId) {
@@ -3923,12 +3795,12 @@ var init_server = __esm({
       label = "Telnyx";
       telephonyProvider = "telnyx";
       sendAudio(ws, audioBase64, _streamSid) {
-        ws.send(JSON.stringify({ event_type: "media", payload: { audio: { chunk: audioBase64 } } }));
+        ws.send(JSON.stringify({ event: "media", media: { payload: audioBase64 } }));
       }
       sendMark(_ws, _markName, _streamSid) {
       }
       sendClear(ws, _streamSid) {
-        ws.send(JSON.stringify({ event_type: "media_stop" }));
+        ws.send(JSON.stringify({ event: "clear" }));
       }
       async transferCall(callId, toNumber) {
         if (!isValidTelnyxTransferTarget(toNumber)) {
@@ -4022,16 +3894,7 @@ var init_server = __esm({
         ws.close();
       }
       createStt(agent) {
-        if (agent.stt) {
-          if (agent.stt.provider === "deepgram") {
-            return new DeepgramSTT(agent.stt.apiKey, agent.stt.language ?? "en", "nova-3", "linear16", 16e3);
-          } else if (agent.stt.provider === "whisper") {
-            return new WhisperSTT(agent.stt.apiKey, "whisper-1", agent.stt.language ?? "en");
-          }
-        } else if (agent.deepgramKey) {
-          return new DeepgramSTT(agent.deepgramKey, agent.language ?? "en", "nova-3", "linear16", 16e3);
-        }
-        return null;
+        return createSTT(agent);
       }
       async queryTelephonyCost(metricsAcc, callId) {
         if (this.config.telnyxKey && callId) {
@@ -4076,6 +3939,7 @@ var init_server = __esm({
       server = null;
       wss = null;
       twilioTokenWarningLogged = false;
+      telnyxSigWarningLogged = false;
       metricsStore;
       pricing;
       remoteHandler = new RemoteMessageHandler();
@@ -4123,6 +3987,31 @@ var init_server = __esm({
           mountApi(app, this.metricsStore, this.dashboardToken);
           getLogger().info("Dashboard: http://127.0.0.1:" + port + "/");
         }
+        app.post("/webhooks/twilio/status", (req, res) => {
+          if (this.config.twilioToken) {
+            const signature = req.headers["x-twilio-signature"] || "";
+            const url = `https://${this.config.webhookUrl}${req.originalUrl}`;
+            const params = req.body ?? {};
+            if (!validateTwilioSignature(url, params, signature, this.config.twilioToken)) {
+              res.status(403).send("Invalid signature");
+              return;
+            }
+          }
+          const body = req.body;
+          const callSid = sanitizeLogValue(body["CallSid"] ?? "");
+          const callStatus = sanitizeLogValue(body["CallStatus"] ?? "");
+          const duration = body["CallDuration"] ?? body["Duration"] ?? "";
+          getLogger().info(
+            `Twilio status ${callStatus} for call ${callSid} (duration=${duration})`
+          );
+          if (callSid && callStatus) {
+            const extra = {};
+            const parsed = parseFloat(duration);
+            if (!Number.isNaN(parsed)) extra.duration_seconds = parsed;
+            this.metricsStore.updateCallStatus(callSid, callStatus, extra);
+          }
+          res.status(204).send();
+        });
         app.post("/webhooks/twilio/recording", (req, res) => {
           if (this.config.twilioToken) {
             const signature = req.headers["x-twilio-signature"] || "";
@@ -4208,7 +4097,7 @@ var init_server = __esm({
           const twiml = `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${xmlStreamUrl}"><Parameter name="caller" value="${xmlEscape(caller)}"/><Parameter name="callee" value="${xmlEscape(callee)}"/></Stream></Connect></Response>`;
           res.type("text/xml").send(twiml);
         });
-        app.post("/webhooks/telnyx/voice", (req, res) => {
+        app.post("/webhooks/telnyx/voice", async (req, res) => {
           if (this.config.telnyxPublicKey) {
             const rawBody = req.rawBody ?? "";
             const signature = req.headers["telnyx-signature-ed25519"] ?? "";
@@ -4217,7 +4106,8 @@ var init_server = __esm({
               getLogger().warn("Telnyx webhook rejected: invalid or missing Ed25519 signature");
               return res.status(403).send("Invalid signature");
             }
-          } else {
+          } else if (!this.telnyxSigWarningLogged) {
+            this.telnyxSigWarningLogged = true;
             getLogger().warn("Telnyx webhook signature verification is disabled. Set telnyxPublicKey in LocalOptions for production use.");
           }
           const body = req.body;
@@ -4227,41 +4117,77 @@ var init_server = __esm({
           if (typeof body.data.event_type !== "string" || typeof body.data.payload !== "object" || body.data.payload === null) {
             return res.status(400).send("Invalid body");
           }
-          const eventType = body?.data?.event_type ?? "";
+          const eventType = body.data.event_type ?? "";
+          const payload = body.data.payload ?? {};
           if (eventType === "call.dtmf.received") {
-            const digit = String(body.data?.payload?.digit ?? "").trim();
+            const digit = String(payload.digit ?? "").trim();
             if (digit) {
               getLogger().info(`Telnyx DTMF received (webhook): ${sanitizeLogValue(digit)}`);
             }
-            return res.json({ received: true });
+            return res.status(200).send();
           }
           if (eventType === "call.recording.saved") {
-            const recordingUrl = body.data?.payload?.recording_urls?.mp3 ?? body.data?.payload?.recording_urls?.wav ?? body.data?.payload?.public_recording_urls?.mp3 ?? "";
+            const recordingUrl = payload.recording_urls?.mp3 ?? payload.recording_urls?.wav ?? payload.public_recording_urls?.mp3 ?? "";
             if (recordingUrl) {
               getLogger().info(`Telnyx recording saved (webhook): ${sanitizeLogValue(recordingUrl)}`);
             }
-            return res.json({ received: true });
-          }
-          if (eventType === "call.initiated") {
-            const payload = body?.data?.payload ?? {};
-            const callControlId = payload.call_control_id ?? "";
-            const caller = payload.from ?? "";
-            const callee = payload.to ?? "";
-            const streamUrl = `wss://${this.config.webhookUrl}/ws/stream/${encodeURIComponent(callControlId)}?caller=${encodeURIComponent(caller)}&callee=${encodeURIComponent(callee)}`;
-            const commands = [
-              { command: "answer" },
-              {
-                command: "stream_start",
-                params: {
+            return res.status(200).send();
+          }
+          const callControlId = payload.call_control_id ?? "";
+          if (!callControlId) {
+            getLogger().warn("Telnyx webhook rejected: missing call_control_id");
+            return res.status(400).send("Invalid webhook payload");
+          }
+          const apiKey = this.config.telnyxKey;
+          if (!apiKey) {
+            getLogger().warn("Telnyx webhook: missing telnyxKey in LocalOptions");
+            return res.status(500).send("Missing Telnyx API key");
+          }
+          const apiBase = "https://api.telnyx.com/v2";
+          const authHeaders = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`
+          };
+          try {
+            if (eventType === "call.initiated") {
+              getLogger().info(`Telnyx call.initiated ${callControlId} \u2014 answering`);
+              const resp = await fetch(`${apiBase}/calls/${encodeURIComponent(callControlId)}/actions/answer`, {
+                method: "POST",
+                headers: authHeaders,
+                body: JSON.stringify({}),
+                signal: AbortSignal.timeout(1e4)
+              });
+              if (!resp.ok) {
+                getLogger().warn(`Telnyx answer failed: ${resp.status} ${(await resp.text()).slice(0, 200)}`);
+              }
+            } else if (eventType === "call.answered") {
+              const caller = payload.from ?? "";
+              const callee = payload.to ?? "";
+              const streamUrl = `wss://${this.config.webhookUrl}/ws/stream/${encodeURIComponent(callControlId)}?caller=${encodeURIComponent(caller)}&callee=${encodeURIComponent(callee)}`;
+              getLogger().info(`Telnyx call.answered ${callControlId} \u2014 starting stream`);
+              const resp = await fetch(`${apiBase}/calls/${encodeURIComponent(callControlId)}/actions/streaming_start`, {
+                method: "POST",
+                headers: authHeaders,
+                body: JSON.stringify({
                   stream_url: streamUrl,
-                  stream_track: "both_tracks"
-                }
+                  stream_track: "both_tracks",
+                  stream_bidirectional_mode: "rtp",
+                  stream_bidirectional_codec: "PCMU",
+                  stream_bidirectional_sampling_rate: 8e3,
+                  stream_bidirectional_target_legs: "self"
+                }),
+                signal: AbortSignal.timeout(1e4)
+              });
+              if (!resp.ok) {
+                getLogger().warn(`Telnyx streaming_start failed: ${resp.status} ${(await resp.text()).slice(0, 200)}`);
               }
-            ];
-            res.json({ commands });
-          } else {
-            res.json({ received: true });
+            } else {
+              getLogger().debug(`Telnyx event ignored: ${eventType}`);
+            }
+          } catch (e) {
+            getLogger().error(`Telnyx webhook handler error: ${String(e)}`);
           }
+          return res.status(200).send();
         });
         this.server = (0, import_http.createServer)(app);
         this.wss = new import_ws5.WebSocketServer({ noServer: true });
@@ -4408,11 +4334,12 @@ Connect AI agents to phone numbers in 4 lines of code
               getLogger().error("Failed to parse Telnyx WS message:", e);
               return;
             }
-            const eventType = data.event_type ?? "";
-            getLogger().info(`Telnyx event: ${eventType}`);
-            if (eventType === "stream_started" && !streamStarted) {
+            const event = data.event ?? "";
+            if (event === "connected") return;
+            getLogger().info(`Telnyx event: ${event}`);
+            if (event === "start" && !streamStarted) {
               streamStarted = true;
-              const callControlId = data.payload?.call_control_id ?? "";
+              const callControlId = data.start?.call_control_id ?? "";
               if (callControlId) this.activeCallIds.set(ws, callControlId);
               await handler.handleCallStart(callControlId);
               if (this.recording) {
@@ -4422,22 +4349,21 @@ Connect AI agents to phone numbers in 4 lines of code
                   getLogger().warn(`Could not start recording: ${String(e)}`);
                 }
               }
-            } else if (eventType === "media") {
-              const audioChunk = data.payload?.audio?.chunk ?? "";
+            } else if (event === "media") {
+              const track = data.media?.track ?? "inbound";
+              if (track !== "inbound") return;
+              const audioChunk = data.media?.payload ?? "";
               if (!audioChunk) return;
               handler.handleAudio(Buffer.from(audioChunk, "base64"));
-            } else if (eventType === "call.dtmf.received") {
-              const digit = String(data.payload?.digit ?? "").trim();
+            } else if (event === "dtmf") {
+              const digit = String(data.dtmf?.digit ?? "").trim();
               if (digit) {
                 getLogger().info(`Telnyx DTMF received: ${digit}`);
                 await handler.handleDtmf(digit);
               }
-            } else if (eventType === "call.recording.saved") {
-              const recordingUrl = data.payload?.recording_urls?.mp3 ?? data.payload?.recording_urls?.wav ?? data.payload?.public_recording_urls?.mp3 ?? "";
-              if (recordingUrl) {
-                getLogger().info(`Telnyx recording saved: ${recordingUrl}`);
-              }
-            } else if (eventType === "stream_stopped") {
+            } else if (event === "error") {
+              getLogger().warn(`Telnyx stream error: ${JSON.stringify(data)}`);
+            } else if (event === "stop") {
               await handler.handleStop();
             }
           } catch (err) {
@@ -5407,6 +5333,94 @@ var init_tunnel = __esm({
   }
 });
 
+// src/carrier-config.ts
+var carrier_config_exports = {};
+__export(carrier_config_exports, {
+  autoConfigureCarrier: () => autoConfigureCarrier,
+  configureTelnyxNumber: () => configureTelnyxNumber,
+  configureTwilioNumber: () => configureTwilioNumber
+});
+async function configureTwilioNumber(accountSid, authToken, phoneNumber, voiceUrl) {
+  const auth = `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`;
+  const listUrl = `${TWILIO_API_BASE}/Accounts/${accountSid}/IncomingPhoneNumbers.json?PhoneNumber=${encodeURIComponent(phoneNumber)}`;
+  const listResp = await fetch(listUrl, {
+    method: "GET",
+    headers: { Authorization: auth }
+  });
+  if (!listResp.ok) {
+    throw new Error(
+      `Twilio IncomingPhoneNumbers.list failed: ${listResp.status} ${await listResp.text()}`
+    );
+  }
+  const body = await listResp.json();
+  const match = body.incoming_phone_numbers?.[0];
+  if (!match) {
+    throw new Error(`Twilio number ${phoneNumber} not found on account ${accountSid}`);
+  }
+  const updateUrl = `${TWILIO_API_BASE}/Accounts/${accountSid}/IncomingPhoneNumbers/${match.sid}.json`;
+  const form = new URLSearchParams({ VoiceUrl: voiceUrl, VoiceMethod: "POST" });
+  const updateResp = await fetch(updateUrl, {
+    method: "POST",
+    headers: {
+      Authorization: auth,
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: form.toString()
+  });
+  if (!updateResp.ok) {
+    throw new Error(
+      `Twilio IncomingPhoneNumbers.update failed: ${updateResp.status} ${await updateResp.text()}`
+    );
+  }
+}
+async function configureTelnyxNumber(apiKey, connectionId, phoneNumber) {
+  const resp = await fetch(`${TELNYX_API_BASE}/phone_numbers/${encodeURIComponent(phoneNumber)}`, {
+    method: "PATCH",
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ connection_id: connectionId })
+  });
+  if (!resp.ok) {
+    throw new Error(
+      `Telnyx PATCH /phone_numbers/${phoneNumber} failed: ${resp.status} ${await resp.text()}`
+    );
+  }
+}
+async function autoConfigureCarrier(params) {
+  const log2 = getLogger();
+  const provider = params.telephonyProvider ?? (params.twilioSid ? "twilio" : "telnyx");
+  if (provider === "twilio" && params.twilioSid && params.twilioToken) {
+    const voiceUrl = `https://${params.webhookHost}/webhooks/twilio/voice`;
+    try {
+      await configureTwilioNumber(params.twilioSid, params.twilioToken, params.phoneNumber, voiceUrl);
+      log2.info("Twilio webhook set to %s", voiceUrl);
+    } catch (err) {
+      log2.warn("Could not auto-configure Twilio webhook: %s", err instanceof Error ? err.message : String(err));
+      log2.info("Set webhook manually to: %s", voiceUrl);
+    }
+    return;
+  }
+  if (provider === "telnyx" && params.telnyxKey && params.telnyxConnectionId) {
+    try {
+      await configureTelnyxNumber(params.telnyxKey, params.telnyxConnectionId, params.phoneNumber);
+      log2.info("Telnyx number %s associated with connection %s", params.phoneNumber, params.telnyxConnectionId);
+    } catch (err) {
+      log2.warn("Could not auto-configure Telnyx number: %s", err instanceof Error ? err.message : String(err));
+    }
+  }
+}
+var TWILIO_API_BASE, TELNYX_API_BASE;
+var init_carrier_config = __esm({
+  "src/carrier-config.ts"() {
+    "use strict";
+    init_logger();
+    TWILIO_API_BASE = "https://api.twilio.com/2010-04-01";
+    TELNYX_API_BASE = "https://api.telnyx.com/v2";
+  }
+});
+
 // src/test-mode.ts
 var test_mode_exports = {};
 __export(test_mode_exports, {
@@ -6521,31 +6535,35 @@ var require_node_cron = __commonJS({
 var index_exports = {};
 __export(index_exports, {
   AllProvidersFailedError: () => AllProvidersFailedError,
-  AssemblyAISTT: () => AssemblyAISTT,
+  AssemblyAISTT: () => STT5,
   AuthenticationError: () => AuthenticationError,
   BackgroundAudioPlayer: () => BackgroundAudioPlayer,
   BuiltinAudioClip: () => BuiltinAudioClip,
   CallMetricsAccumulator: () => CallMetricsAccumulator,
-  CartesiaSTT: () => CartesiaSTT,
-  CartesiaTTS: () => CartesiaTTS,
+  CartesiaSTT: () => STT3,
+  CartesiaTTS: () => TTS3,
   ChatContext: () => ChatContext,
+  CloudflareTunnel: () => CloudflareTunnel,
   DEFAULT_MIN_SENTENCE_LEN: () => DEFAULT_MIN_SENTENCE_LEN,
   DEFAULT_PRICING: () => DEFAULT_PRICING,
   DTMF_EVENTS: () => DTMF_EVENTS,
-  DeepgramSTT: () => DeepgramSTT,
+  DeepgramSTT: () => STT,
+  ElevenLabsConvAI: () => ConvAI,
   ElevenLabsConvAIAdapter: () => ElevenLabsConvAIAdapter,
-  ElevenLabsTTS: () => ElevenLabsTTS,
+  ElevenLabsTTS: () => TTS,
   FallbackLLMProvider: () => FallbackLLMProvider,
   GEMINI_DEFAULT_INPUT_SR: () => GEMINI_DEFAULT_INPUT_SR,
   GEMINI_DEFAULT_OUTPUT_SR: () => GEMINI_DEFAULT_OUTPUT_SR,
   GeminiLiveAdapter: () => GeminiLiveAdapter,
+  Guardrail: () => Guardrail,
   IVRActivity: () => IVRActivity,
   LLMLoop: () => LLMLoop,
-  LMNTTTS: () => LMNTTTS,
+  LMNTTTS: () => TTS5,
   MetricsStore: () => MetricsStore,
   OpenAILLMProvider: () => OpenAILLMProvider,
+  OpenAIRealtime: () => Realtime,
   OpenAIRealtimeAdapter: () => OpenAIRealtimeAdapter,
-  OpenAITTS: () => OpenAITTS,
+  OpenAITTS: () => TTS2,
   PartialStreamError: () => PartialStreamError,
   Patter: () => Patter,
   PatterConnectionError: () => PatterConnectionError,
@@ -6553,15 +6571,19 @@ __export(index_exports, {
   PipelineHookExecutor: () => PipelineHookExecutor,
   ProvisionError: () => ProvisionError,
   RemoteMessageHandler: () => RemoteMessageHandler,
-  RimeTTS: () => RimeTTS,
+  RimeTTS: () => TTS4,
   SentenceChunker: () => SentenceChunker,
-  SonioxSTT: () => SonioxSTT,
+  SonioxSTT: () => STT4,
+  StaticTunnel: () => Static,
+  Telnyx: () => Carrier2,
   TestSession: () => TestSession,
   TfidfLoopDetector: () => TfidfLoopDetector,
+  Tool: () => Tool,
+  Twilio: () => Carrier,
   ULTRAVOX_DEFAULT_API_BASE: () => ULTRAVOX_DEFAULT_API_BASE,
   ULTRAVOX_DEFAULT_SR: () => ULTRAVOX_DEFAULT_SR,
   UltravoxRealtimeAdapter: () => UltravoxRealtimeAdapter,
-  WhisperSTT: () => WhisperSTT,
+  WhisperSTT: () => STT2,
   builtinClipPath: () => builtinClipPath,
   calculateRealtimeCost: () => calculateRealtimeCost,
   calculateSttCost: () => calculateSttCost,
@@ -6577,6 +6599,7 @@ __export(index_exports, {
   filterMarkdown: () => filterMarkdown,
   formatDtmf: () => formatDtmf,
   getLogger: () => getLogger,
+  guardrail: () => guardrail,
   isRemoteUrl: () => isRemoteUrl,
   isWebSocketUrl: () => isWebSocketUrl,
   makeAuthMiddleware: () => makeAuthMiddleware,
@@ -6598,6 +6621,7 @@ __export(index_exports, {
   selectSoundFromList: () => selectSoundFromList,
   setLogger: () => setLogger,
   startTunnel: () => startTunnel,
+  tool: () => tool,
   whisper: () => whisper
 });
 module.exports = __toCommonJS(index_exports);
@@ -6743,50 +6767,89 @@ var PatterConnection = class {
   }
 };
 
-// src/providers.ts
-var STTConfigImpl = class {
-  provider;
+// src/client.ts
+init_server();
+
+// src/engines/openai.ts
+var Realtime = class {
+  kind = "openai_realtime";
   apiKey;
-  language;
-  constructor(provider, apiKey, language = "en") {
-    this.provider = provider;
-    this.apiKey = apiKey;
-    this.language = language;
-  }
-  toDict() {
-    return { provider: this.provider, api_key: this.apiKey, language: this.language };
+  model;
+  voice;
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!key) {
+      throw new Error(
+        "OpenAI Realtime requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
+      );
+    }
+    this.apiKey = key;
+    this.model = opts.model ?? "gpt-4o-mini-realtime-preview";
+    this.voice = opts.voice ?? "alloy";
   }
 };
-var TTSConfigImpl = class {
-  provider;
+
+// src/engines/elevenlabs.ts
+var ConvAI = class {
+  kind = "elevenlabs_convai";
   apiKey;
+  agentId;
   voice;
-  constructor(provider, apiKey, voice = "alloy") {
-    this.provider = provider;
-    this.apiKey = apiKey;
-    this.voice = voice;
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.ELEVENLABS_API_KEY;
+    const agent = opts.agentId ?? process.env.ELEVENLABS_AGENT_ID;
+    if (!key) {
+      throw new Error(
+        "ElevenLabs ConvAI requires an apiKey. Pass { apiKey: '...' } or set ELEVENLABS_API_KEY in the environment."
+      );
+    }
+    if (!agent) {
+      throw new Error(
+        "ElevenLabs ConvAI requires an agentId. Pass { agentId: 'agent_...' } or set ELEVENLABS_AGENT_ID in the environment."
+      );
+    }
+    this.apiKey = key;
+    this.agentId = agent;
+    this.voice = opts.voice;
   }
-  toDict() {
-    return { provider: this.provider, api_key: this.apiKey, voice: this.voice };
+};
+
+// src/tunnels/index.ts
+var CloudflareTunnel = class {
+  kind = "cloudflare";
+};
+var Static = class {
+  kind = "static";
+  hostname;
+  constructor(opts) {
+    if (!opts.hostname) {
+      throw new Error("Static tunnel requires a non-empty hostname.");
+    }
+    this.hostname = opts.hostname;
   }
 };
-function deepgram(opts) {
-  return new STTConfigImpl("deepgram", opts.apiKey, opts.language ?? "en");
-}
-function whisper(opts) {
-  return new STTConfigImpl("whisper", opts.apiKey, opts.language ?? "en");
-}
-function elevenlabs(opts) {
-  return new TTSConfigImpl("elevenlabs", opts.apiKey, opts.voice ?? "rachel");
-}
-function openaiTts(opts) {
-  return new TTSConfigImpl("openai", opts.apiKey, opts.voice ?? "alloy");
-}
 
 // src/client.ts
-init_server();
 var DEFAULT_BACKEND_URL2 = "wss://api.getpatter.com";
 var DEFAULT_REST_URL = "https://api.getpatter.com";
+function sttConfigToDict(cfg) {
+  const out = {
+    provider: cfg.provider,
+    api_key: cfg.apiKey,
+    language: cfg.language
+  };
+  if (cfg.options) out.options = { ...cfg.options };
+  return out;
+}
+function ttsConfigToDict(cfg) {
+  const out = {
+    provider: cfg.provider,
+    api_key: cfg.apiKey,
+    voice: cfg.voice
+  };
+  if (cfg.options) out.options = { ...cfg.options };
+  return out;
+}
 var Patter = class {
   apiKey;
   backendUrl;
@@ -6797,20 +6860,39 @@ var Patter = class {
   embeddedServer = null;
   tunnelHandle = null;
   constructor(options) {
-    if ("mode" in options && options.mode === "local") {
+    const hasCarrier = "carrier" in options && options.carrier !== void 0;
+    const isLocal = "mode" in options && options.mode === "local" || hasCarrier;
+    if (isLocal) {
       const local = options;
       if (!local.phoneNumber) {
         throw new Error("Local mode requires phoneNumber");
       }
-      if (!local.twilioSid && !local.telnyxKey) {
-        throw new Error("Local mode requires twilioSid or telnyxKey");
+      if (!local.carrier) {
+        throw new Error(
+          "Local mode requires a `carrier` instance. Pass `carrier: new Twilio({...})` or `carrier: new Telnyx({...})`."
+        );
       }
-      if (local.twilioSid && !local.twilioToken) {
-        throw new Error("twilioToken is required when using twilioSid");
+      const carrier = local.carrier;
+      const tunnel = local.tunnel;
+      let tunnelWebhookUrl;
+      if (tunnel instanceof Static) {
+        if (local.webhookUrl) {
+          throw new Error(
+            "Cannot use both `tunnel: new StaticTunnel(...)` and `webhookUrl`. Pick one."
+          );
+        }
+        tunnelWebhookUrl = tunnel.hostname;
       }
       this.mode = "local";
-      const normalizedLocal = local.webhookUrl ? { ...local, webhookUrl: local.webhookUrl.replace(/^https?:\/\//, "").replace(/\/$/, "") } : local;
-      this.localConfig = normalizedLocal;
+      const rawWebhook = tunnelWebhookUrl ?? local.webhookUrl;
+      const normalizedWebhook = rawWebhook ? rawWebhook.replace(/^https?:\/\//, "").replace(/\/$/, "") : void 0;
+      this.localConfig = {
+        carrier,
+        phoneNumber: local.phoneNumber,
+        webhookUrl: normalizedWebhook,
+        tunnel: local.tunnel,
+        openaiKey: local.openaiKey
+      };
       this.apiKey = "";
       this.backendUrl = DEFAULT_BACKEND_URL2;
       this.restUrl = DEFAULT_REST_URL;
@@ -6827,25 +6909,55 @@ var Patter = class {
   }
   // === Local mode ===
   agent(opts) {
-    if (opts.provider) {
+    let working = { ...opts };
+    if (opts.engine) {
+      if (opts.provider) {
+        throw new Error(
+          "Cannot pass both `engine:` and `provider:`. Use one (engine is preferred)."
+        );
+      }
+      const engine = opts.engine;
+      if (engine instanceof Realtime) {
+        working = {
+          ...working,
+          provider: "openai_realtime",
+          model: working.model ?? engine.model,
+          voice: working.voice ?? engine.voice
+        };
+        if (this.localConfig && !this.localConfig.openaiKey) {
+          this.localConfig = { ...this.localConfig, openaiKey: engine.apiKey };
+        }
+      } else if (engine instanceof ConvAI) {
+        working = {
+          ...working,
+          provider: "elevenlabs_convai",
+          voice: working.voice ?? engine.voice
+        };
+      } else {
+        throw new Error(
+          "Unknown engine. Expected OpenAIRealtime or ElevenLabsConvAI instance."
+        );
+      }
+    }
+    if (working.provider) {
       const valid = ["openai_realtime", "elevenlabs_convai", "pipeline"];
-      if (!valid.includes(opts.provider)) {
-        throw new Error(`provider must be one of: ${valid.join(", ")}. Got: '${opts.provider}'`);
+      if (!valid.includes(working.provider)) {
+        throw new Error(`provider must be one of: ${valid.join(", ")}. Got: '${working.provider}'`);
       }
     }
-    if (opts.tools) {
-      if (!Array.isArray(opts.tools)) {
+    if (working.tools) {
+      if (!Array.isArray(working.tools)) {
         throw new TypeError("tools must be an array");
       }
-      opts.tools.forEach((tool, i) => {
-        if (!tool.name) throw new Error(`tools[${i}] missing required 'name' field`);
-        if (!tool.webhookUrl && !tool.handler) throw new Error(`tools[${i}] requires either 'webhookUrl' or 'handler'`);
+      working.tools.forEach((tool2, i) => {
+        if (!tool2.name) throw new Error(`tools[${i}] missing required 'name' field`);
+        if (!tool2.webhookUrl && !tool2.handler) throw new Error(`tools[${i}] requires either 'webhookUrl' or 'handler'`);
       });
     }
-    if (opts.variables !== void 0 && (typeof opts.variables !== "object" || Array.isArray(opts.variables))) {
+    if (working.variables !== void 0 && (typeof working.variables !== "object" || Array.isArray(working.variables))) {
       throw new TypeError("variables must be an object");
     }
-    return { ...opts };
+    return working;
   }
   async serve(opts) {
     if (this.mode !== "local" || !this.localConfig) {
@@ -6868,10 +6980,14 @@ var Patter = class {
     }
     let webhookUrl = this.localConfig.webhookUrl ?? "";
     const port = opts.port ?? 8e3;
-    if (opts.tunnel && webhookUrl) {
+    const ctorTunnel = this.localConfig.tunnel;
+    const wantsCloudflaredFromServe = opts.tunnel === true;
+    const wantsCloudflaredFromCtor = ctorTunnel === true || ctorTunnel instanceof CloudflareTunnel;
+    const wantsCloudflared = wantsCloudflaredFromServe || wantsCloudflaredFromCtor;
+    if (wantsCloudflared && webhookUrl) {
       throw new Error("Cannot use both tunnel: true and webhookUrl. Pick one.");
     }
-    if (opts.tunnel) {
+    if (wantsCloudflared) {
       const { startTunnel: startTunnel2 } = await Promise.resolve().then(() => (init_tunnel(), tunnel_exports));
       this.tunnelHandle = await startTunnel2(port);
       webhookUrl = this.tunnelHandle.hostname;
@@ -6881,17 +6997,29 @@ var Patter = class {
         "No webhookUrl configured. Either:\n  - Pass webhookUrl in the Patter constructor\n  - Use tunnel: true in serve() to auto-create a tunnel"
       );
     }
+    const carrier = this.localConfig.carrier;
+    const telephonyProvider = carrier.kind === "twilio" ? "twilio" : "telnyx";
+    const { autoConfigureCarrier: autoConfigureCarrier2 } = await Promise.resolve().then(() => (init_carrier_config(), carrier_config_exports));
+    await autoConfigureCarrier2({
+      telephonyProvider,
+      twilioSid: carrier.kind === "twilio" ? carrier.accountSid : void 0,
+      twilioToken: carrier.kind === "twilio" ? carrier.authToken : void 0,
+      telnyxKey: carrier.kind === "telnyx" ? carrier.apiKey : void 0,
+      telnyxConnectionId: carrier.kind === "telnyx" ? carrier.connectionId : void 0,
+      phoneNumber: this.localConfig.phoneNumber,
+      webhookHost: webhookUrl
+    });
     this.embeddedServer = new EmbeddedServer(
       {
-        twilioSid: this.localConfig.twilioSid,
-        twilioToken: this.localConfig.twilioToken,
+        twilioSid: carrier.kind === "twilio" ? carrier.accountSid : void 0,
+        twilioToken: carrier.kind === "twilio" ? carrier.authToken : void 0,
         openaiKey: this.localConfig.openaiKey,
         phoneNumber: this.localConfig.phoneNumber,
         webhookUrl,
-        telephonyProvider: this.localConfig.telephonyProvider,
-        telnyxKey: this.localConfig.telnyxKey,
-        telnyxConnectionId: this.localConfig.telnyxConnectionId,
-        telnyxPublicKey: this.localConfig.telnyxPublicKey
+        telephonyProvider,
+        telnyxKey: carrier.kind === "telnyx" ? carrier.apiKey : void 0,
+        telnyxConnectionId: carrier.kind === "telnyx" ? carrier.connectionId : void 0,
+        telnyxPublicKey: carrier.kind === "telnyx" ? carrier.publicKey : void 0
       },
       opts.agent,
       opts.onCallStart,
@@ -6952,32 +7080,51 @@ var Patter = class {
       if (!this.localConfig) {
         throw new Error("local config missing");
       }
-      const { phoneNumber, webhookUrl, telephonyProvider } = this.localConfig;
-      if (telephonyProvider === "telnyx") {
-        const telnyxKey = this.localConfig.telnyxKey ?? "";
-        const connectionId = this.localConfig.telnyxConnectionId ?? "";
+      const { phoneNumber, webhookUrl, carrier } = this.localConfig;
+      if (carrier.kind === "telnyx") {
+        const telnyxKey = carrier.apiKey;
+        const connectionId = carrier.connectionId;
         const streamUrl = `wss://${webhookUrl}/ws/stream/${encodeURIComponent(localOpts.to)}?caller=${encodeURIComponent(phoneNumber)}&callee=${encodeURIComponent(localOpts.to)}`;
+        const telnyxPayload = {
+          connection_id: connectionId,
+          from: phoneNumber,
+          to: localOpts.to,
+          stream_url: streamUrl,
+          stream_track: "both_tracks"
+        };
+        if (localOpts.ringTimeout !== void 0) {
+          telnyxPayload.timeout_secs = Math.max(1, Math.floor(localOpts.ringTimeout));
+        }
         const response2 = await fetch("https://api.telnyx.com/v2/calls", {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
             Authorization: `Bearer ${telnyxKey}`
           },
-          body: JSON.stringify({
-            connection_id: connectionId,
-            from: phoneNumber,
-            to: localOpts.to,
-            stream_url: streamUrl,
-            stream_track: "both_tracks"
-          })
+          body: JSON.stringify(telnyxPayload)
         });
         if (!response2.ok) {
           throw new ProvisionError(`Failed to initiate Telnyx call: ${await response2.text()}`);
         }
-        return;
-      }
-      const twilioSid = this.localConfig.twilioSid ?? "";
-      const twilioToken = this.localConfig.twilioToken ?? "";
+        if (this.embeddedServer) {
+          try {
+            const body = await response2.clone().json();
+            const callId = body.data?.call_control_id;
+            if (callId) {
+              this.embeddedServer.metricsStore.recordCallInitiated({
+                call_id: callId,
+                caller: phoneNumber,
+                callee: localOpts.to,
+                direction: "outbound"
+              });
+            }
+          } catch {
+          }
+        }
+        return;
+      }
+      const twilioSid = carrier.accountSid;
+      const twilioToken = carrier.authToken;
       const statusCallbackUrl = `https://${webhookUrl}/webhooks/twilio/status`;
       const url = `https://api.twilio.com/2010-04-01/Accounts/${twilioSid}/Calls.json`;
       const params = new URLSearchParams({
@@ -6985,13 +7132,19 @@ var Patter = class {
         From: phoneNumber,
         Url: `https://${webhookUrl}/webhooks/twilio/voice`,
         StatusCallback: statusCallbackUrl,
-        StatusCallbackMethod: "POST"
+        StatusCallbackMethod: "POST",
+        // Full lifecycle so the dashboard sees ringing/no-answer/busy/failed
+        // transitions even when media never arrives.
+        StatusCallbackEvent: "initiated ringing answered completed"
       });
       if (localOpts.machineDetection) {
         params.append("MachineDetection", "DetectMessageEnd");
         params.append("AsyncAmd", "true");
         params.append("AsyncAmdStatusCallback", `https://${webhookUrl}/webhooks/twilio/amd`);
       }
+      if (localOpts.ringTimeout !== void 0) {
+        params.append("Timeout", String(Math.max(1, Math.floor(localOpts.ringTimeout))));
+      }
       if (localOpts.voicemailMessage && this.embeddedServer) {
         this.embeddedServer.voicemailMessage = localOpts.voicemailMessage;
       }
@@ -7006,6 +7159,21 @@ var Patter = class {
       if (!response.ok) {
         throw new ProvisionError(`Failed to initiate call: ${await response.text()}`);
       }
+      if (this.embeddedServer) {
+        try {
+          const body = await response.clone().json();
+          const callSid = body.sid;
+          if (callSid) {
+            this.embeddedServer.metricsStore.recordCallInitiated({
+              call_id: callSid,
+              caller: phoneNumber,
+              callee: localOpts.to,
+              direction: "outbound"
+            });
+          }
+        } catch {
+        }
+      }
       return;
     }
     const cloudOpts = options;
@@ -7088,61 +7256,6 @@ var Patter = class {
     const data = await response.json();
     return data.map((c) => ({ id: c.id, direction: c.direction, caller: c.caller, callee: c.callee, startedAt: c.started_at, endedAt: c.ended_at, durationSeconds: c.duration_seconds, status: c.status, transcript: c.transcript }));
   }
-  // Provider helpers
-  static deepgram = deepgram;
-  static whisper = whisper;
-  static elevenlabs = elevenlabs;
-  static openaiTts = openaiTts;
-  static guardrail(opts) {
-    return {
-      name: opts.name,
-      blockedTerms: opts.blockedTerms,
-      check: opts.check,
-      replacement: opts.replacement ?? "I'm sorry, I can't respond to that."
-    };
-  }
-  /**
-   * Create a tool definition for use with `agent({ tools: [...] })`.
-   *
-   * Either `handler` (a function) or `webhookUrl` must be provided.
-   *
-   * @param opts.name - Tool name (visible to the LLM).
-   * @param opts.description - What the tool does (visible to the LLM).
-   * @param opts.parameters - JSON Schema for tool arguments.
-   * @param opts.handler - Async function called in-process when the LLM invokes the tool.
-   * @param opts.webhookUrl - URL to POST to when the LLM invokes the tool.
-   *
-   * @example
-   * ```ts
-   * phone.agent({
-   *   systemPrompt: 'You are a pizza bot.',
-   *   tools: [
-   *     Patter.tool({
-   *       name: 'check_menu',
-   *       description: 'Check available menu items',
-   *       handler: async (args) => JSON.stringify({ items: ['margherita'] }),
-   *     }),
-   *   ],
-   * });
-   * ```
-   */
-  static tool(opts) {
-    if (!opts.handler && !opts.webhookUrl) {
-      throw new Error("tool() requires either handler or webhookUrl");
-    }
-    const t = {
-      name: opts.name,
-      description: opts.description ?? "",
-      parameters: opts.parameters ?? { type: "object", properties: {} }
-    };
-    if (opts.handler) {
-      t.handler = opts.handler;
-    }
-    if (opts.webhookUrl) {
-      t.webhookUrl = opts.webhookUrl;
-    }
-    return t;
-  }
   // Internal
   async registerNumber(provider, providerKey, number, providerSecret, country = "US", stt, tts) {
     const credentials = { api_key: providerKey };
@@ -7158,8 +7271,8 @@ var Patter = class {
         provider,
         provider_credentials: credentials,
         country,
-        stt_config: stt?.toDict() ?? null,
-        tts_config: tts?.toDict() ?? null
+        stt_config: stt ? stt.toDict?.() ?? sttConfigToDict(stt) : null,
+        tts_config: tts ? tts.toDict?.() ?? ttsConfigToDict(tts) : null
       })
     });
     if (response.status === 409) return;
@@ -7237,6 +7350,62 @@ function filterForTTS(text) {
   return filterEmoji(filterMarkdown(text));
 }
 
+// src/providers.ts
+var STTConfigImpl = class {
+  provider;
+  apiKey;
+  language;
+  options;
+  constructor(provider, apiKey, language = "en", options) {
+    this.provider = provider;
+    this.apiKey = apiKey;
+    this.language = language;
+    if (options) this.options = options;
+  }
+  toDict() {
+    const out = {
+      provider: this.provider,
+      api_key: this.apiKey,
+      language: this.language
+    };
+    if (this.options) out.options = { ...this.options };
+    return out;
+  }
+};
+var TTSConfigImpl = class {
+  provider;
+  apiKey;
+  voice;
+  constructor(provider, apiKey, voice = "alloy") {
+    this.provider = provider;
+    this.apiKey = apiKey;
+    this.voice = voice;
+  }
+  toDict() {
+    return { provider: this.provider, api_key: this.apiKey, voice: this.voice };
+  }
+};
+function deepgram(opts) {
+  const options = {
+    model: opts.model ?? "nova-3",
+    endpointing_ms: opts.endpointingMs ?? 150,
+    utterance_end_ms: opts.utteranceEndMs === null ? null : opts.utteranceEndMs ?? 1e3,
+    smart_format: opts.smartFormat ?? true,
+    interim_results: opts.interimResults ?? true
+  };
+  if (opts.vadEvents !== void 0) options.vad_events = opts.vadEvents;
+  return new STTConfigImpl("deepgram", opts.apiKey, opts.language ?? "en", options);
+}
+function whisper(opts) {
+  return new STTConfigImpl("whisper", opts.apiKey, opts.language ?? "en");
+}
+function elevenlabs(opts) {
+  return new TTSConfigImpl("elevenlabs", opts.apiKey, opts.voice ?? "rachel");
+}
+function openaiTts(opts) {
+  return new TTSConfigImpl("openai", opts.apiKey, opts.voice ?? "alloy");
+}
+
 // src/index.ts
 init_pricing();
 init_metrics();
@@ -7293,6 +7462,37 @@ var FallbackLLMProvider = class {
       }
     }
   }
+  /**
+   * Async-friendly disposer. Parity with Python's ``FallbackLLMProvider.aclose()``
+   * — safe to call multiple times, returns a resolved Promise once all probe
+   * timers are cleared. Prefer this in async contexts so awaiting the
+   * shutdown integrates naturally with the owning lifecycle.
+   */
+  async aclose() {
+    this.destroy();
+  }
+  /**
+   * Explicit-resource-management hook so callers can write
+   * ``await using fallback = new FallbackLLMProvider([...])`` and have
+   * background probe timers cleared automatically when the block exits.
+   * Mirrors Python's ``async with FallbackLLMProvider(...)``.
+   */
+  async [Symbol.asyncDispose]() {
+    await this.aclose();
+  }
+  /**
+   * Stream only the text deltas, flattening the chunk envelope. Parity with
+   * Python's ``FallbackLLMProvider.complete_stream``. Tool-call and done
+   * markers are filtered out so callers can concatenate the yielded strings
+   * directly.
+   */
+  async *completeStream(messages, tools) {
+    for await (const chunk of this.stream(messages, tools)) {
+      if (chunk.type === "text") {
+        yield chunk.content ?? "";
+      }
+    }
+  }
   // -----------------------------------------------------------------------
   // LLMProvider implementation
   // -----------------------------------------------------------------------
@@ -7815,13 +8015,37 @@ function wrapCallback(cb) {
     }
   };
 }
-async function scheduleCron(cron, callback) {
-  const cm = await loadCron();
-  if (!cm.validate(cron)) {
-    throw new Error(`Invalid cron expression: ${cron}`);
-  }
-  const task = cm.schedule(cron, wrapCallback(callback));
-  return makeHandle(`cron-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, task);
+function scheduleCron(cron, callback) {
+  let cancelled = false;
+  let task = null;
+  const jobId = `cron-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  loadCron().then((cm) => {
+    if (cancelled) return;
+    if (!cm.validate(cron)) {
+      throw new Error(`Invalid cron expression: ${cron}`);
+    }
+    task = cm.schedule(cron, wrapCallback(callback));
+  }).catch((err) => getLogger().error(`scheduleCron failed: ${String(err)}`));
+  return {
+    jobId,
+    cancel() {
+      if (cancelled) return;
+      cancelled = true;
+      if (task) {
+        try {
+          task.stop();
+        } catch {
+        }
+        try {
+          task.destroy?.();
+        } catch {
+        }
+      }
+    },
+    get pending() {
+      return !cancelled;
+    }
+  };
 }
 function scheduleOnce(at, callback) {
   const delayMs = at.getTime() - Date.now();
@@ -7843,8 +8067,18 @@ function scheduleOnce(at, callback) {
     }
   };
 }
-function scheduleInterval(intervalMs, callback) {
-  if (intervalMs <= 0) throw new Error("intervalMs must be positive");
+function scheduleInterval(intervalOrOpts, callback) {
+  let intervalMs;
+  if (typeof intervalOrOpts === "number") {
+    intervalMs = intervalOrOpts;
+  } else if (intervalOrOpts.intervalMs !== void 0) {
+    intervalMs = intervalOrOpts.intervalMs;
+  } else if (intervalOrOpts.seconds !== void 0) {
+    intervalMs = intervalOrOpts.seconds * 1e3;
+  } else {
+    throw new Error("scheduleInterval requires seconds or intervalMs");
+  }
+  if (intervalMs <= 0) throw new Error("interval must be positive");
   let cancelled = false;
   const wrapped = wrapCallback(callback);
   const timer = setInterval(() => {
@@ -7861,111 +8095,404 @@ function scheduleInterval(intervalMs, callback) {
     }
   };
 }
-function makeHandle(jobId, task) {
-  let cancelled = false;
-  return {
-    jobId,
-    cancel() {
-      if (cancelled) return;
-      cancelled = true;
-      try {
-        task.stop();
-      } catch {
-      }
-      try {
-        task.destroy?.();
-      } catch {
-      }
-    },
-    get pending() {
-      return !cancelled;
-    }
-  };
-}
 
-// src/index.ts
+// src/stt/deepgram.ts
 init_deepgram_stt();
+var STT = class extends DeepgramSTT {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.DEEPGRAM_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Deepgram STT requires an apiKey. Pass { apiKey: 'dg_...' } or set DEEPGRAM_API_KEY in the environment."
+      );
+    }
+    super(
+      key,
+      opts.language ?? "en",
+      opts.model ?? "nova-3",
+      opts.encoding ?? "linear16",
+      opts.sampleRate ?? 16e3,
+      {
+        endpointingMs: opts.endpointingMs ?? 150,
+        utteranceEndMs: opts.utteranceEndMs === null ? null : opts.utteranceEndMs ?? 1e3,
+        smartFormat: opts.smartFormat ?? true,
+        interimResults: opts.interimResults ?? true,
+        ...opts.vadEvents !== void 0 ? { vadEvents: opts.vadEvents } : {}
+      }
+    );
+  }
+};
 
-// src/providers/soniox-stt.ts
-var import_ws7 = __toESM(require("ws"));
+// src/providers/whisper-stt.ts
 init_logger();
-var SONIOX_WS_URL = "wss://stt-rt.soniox.com/transcribe-websocket";
-var KEEPALIVE_MESSAGE = '{"type": "keepalive"}';
-var END_TOKEN = "<end>";
-var FINALIZED_TOKEN = "<fin>";
-var KEEPALIVE_INTERVAL_MS = 5e3;
-function isEndToken(token) {
-  return token.text === END_TOKEN || token.text === FINALIZED_TOKEN;
+var OPENAI_TRANSCRIPTION_URL = "https://api.openai.com/v1/audio/transcriptions";
+var DEFAULT_BUFFER_SIZE = 16e3 * 2;
+function wrapPcmInWav(pcm, sampleRate = 16e3, channels = 1, bitsPerSample = 16) {
+  const dataSize = pcm.length;
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + dataSize, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(channels, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(sampleRate * channels * (bitsPerSample / 8), 28);
+  header.writeUInt16LE(channels * (bitsPerSample / 8), 32);
+  header.writeUInt16LE(bitsPerSample, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(dataSize, 40);
+  return Buffer.concat([header, pcm]);
 }
-var TokenAccumulator = class {
-  text = "";
-  confSum = 0;
-  confCount = 0;
-  update(token) {
-    if (token.text) {
-      this.text += token.text;
-    }
-    if (typeof token.confidence === "number") {
-      this.confSum += token.confidence;
-      this.confCount += 1;
-    }
+var WhisperSTT = class _WhisperSTT {
+  apiKey;
+  model;
+  language;
+  bufferSize;
+  buffer = Buffer.alloc(0);
+  callbacks = [];
+  running = false;
+  pendingTranscriptions = [];
+  constructor(apiKey, model = "whisper-1", language, bufferSize = DEFAULT_BUFFER_SIZE) {
+    this.apiKey = apiKey;
+    this.model = model;
+    this.language = language;
+    this.bufferSize = bufferSize;
   }
-  get confidence() {
-    return this.confCount === 0 ? 0 : this.confSum / this.confCount;
+  /** Factory for Twilio calls — mulaw 8 kHz is transcoded upstream, so we still receive PCM 16-bit. */
+  static forTwilio(apiKey, language = "en", model = "whisper-1") {
+    return new _WhisperSTT(apiKey, model, language);
   }
-  reset() {
-    this.text = "";
-    this.confSum = 0;
-    this.confCount = 0;
+  async connect() {
+    this.running = true;
+    this.buffer = Buffer.alloc(0);
   }
-  get raw() {
-    return { sum: this.confSum, count: this.confCount };
+  sendAudio(audio) {
+    if (!this.running) return;
+    this.buffer = Buffer.concat([this.buffer, audio]);
+    if (this.buffer.length >= this.bufferSize) {
+      const pcm = this.buffer;
+      this.buffer = Buffer.alloc(0);
+      this.trackTranscription(this.transcribeBuffer(pcm));
+    }
+  }
+  trackTranscription(promise) {
+    const wrapped = promise.finally(() => {
+      const idx = this.pendingTranscriptions.indexOf(wrapped);
+      if (idx !== -1) this.pendingTranscriptions.splice(idx, 1);
+    });
+    this.pendingTranscriptions.push(wrapped);
   }
-};
-var SonioxSTT = class _SonioxSTT {
-  ws = null;
-  callbacks = [];
-  final = new TokenAccumulator();
-  keepaliveTimer = null;
-  apiKey;
-  model;
-  languageHints;
-  languageHintsStrict;
-  sampleRate;
-  numChannels;
-  enableSpeakerDiarization;
-  enableLanguageIdentification;
-  maxEndpointDelayMs;
-  clientReferenceId;
-  baseUrl;
-  constructor(apiKey, options = {}) {
-    if (!apiKey) {
-      throw new Error("Soniox apiKey is required");
+  onTranscript(callback) {
+    if (this.callbacks.length >= 10) {
+      getLogger().warn("WhisperSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback.");
+      this.callbacks[this.callbacks.length - 1] = callback;
+      return;
     }
-    const maxEndpointDelayMs = options.maxEndpointDelayMs ?? 500;
-    if (maxEndpointDelayMs < 500 || maxEndpointDelayMs > 3e3) {
-      throw new Error("maxEndpointDelayMs must be between 500 and 3000");
+    this.callbacks.push(callback);
+  }
+  async close() {
+    this.running = false;
+    if (this.buffer.length >= this.bufferSize / 4) {
+      const pcm = this.buffer;
+      this.buffer = Buffer.alloc(0);
+      this.trackTranscription(this.transcribeBuffer(pcm));
+    } else {
+      this.buffer = Buffer.alloc(0);
+    }
+    await Promise.allSettled(this.pendingTranscriptions);
+    this.callbacks = [];
+  }
+  // ------------------------------------------------------------------
+  // Private
+  // ------------------------------------------------------------------
+  async transcribeBuffer(pcm) {
+    const wav = wrapPcmInWav(pcm);
+    const formData = new FormData();
+    formData.append("file", new Blob([wav.buffer.slice(wav.byteOffset, wav.byteOffset + wav.byteLength)], { type: "audio/wav" }), "audio.wav");
+    formData.append("model", this.model);
+    if (this.language) {
+      formData.append("language", this.language);
+    }
+    try {
+      const resp = await fetch(OPENAI_TRANSCRIPTION_URL, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+        body: formData,
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        getLogger().error(`WhisperSTT transcription error: ${resp.status} ${body}`);
+        return;
+      }
+      const json = await resp.json();
+      const text = (json.text ?? "").trim();
+      if (!text) return;
+      const transcript = {
+        text,
+        isFinal: true,
+        confidence: 1
+      };
+      for (const cb of this.callbacks) {
+        cb(transcript);
+      }
+    } catch (err) {
+      getLogger().error(`WhisperSTT transcription error: ${String(err)}`);
     }
-    this.apiKey = apiKey;
-    this.model = options.model ?? "stt-rt-v4";
-    this.languageHints = options.languageHints;
-    this.languageHintsStrict = options.languageHintsStrict ?? false;
-    this.sampleRate = options.sampleRate ?? 16e3;
-    this.numChannels = options.numChannels ?? 1;
-    this.enableSpeakerDiarization = options.enableSpeakerDiarization ?? false;
-    this.enableLanguageIdentification = options.enableLanguageIdentification ?? true;
-    this.maxEndpointDelayMs = maxEndpointDelayMs;
-    this.clientReferenceId = options.clientReferenceId;
-    this.baseUrl = options.baseUrl ?? SONIOX_WS_URL;
   }
-  /** Factory for Twilio-style 8 kHz linear PCM. */
-  static forTwilio(apiKey, languageHints) {
-    return new _SonioxSTT(apiKey, { sampleRate: 8e3, languageHints });
+};
+
+// src/stt/whisper.ts
+var STT2 = class extends WhisperSTT {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Whisper STT requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
+      );
+    }
+    super(key, opts.model ?? "whisper-1", opts.language, opts.bufferSize);
   }
-  buildConfig() {
-    const config = {
-      api_key: this.apiKey,
-      model: this.model,
+};
+
+// src/providers/cartesia-stt.ts
+var import_ws7 = __toESM(require("ws"));
+init_logger();
+var DEFAULT_BASE_URL = "https://api.cartesia.ai";
+var API_VERSION = "2025-04-16";
+var USER_AGENT = "Patter/1.0 (integration=LiveKit-port; provider=Cartesia)";
+var KEEPALIVE_INTERVAL_MS = 3e4;
+var CONNECT_TIMEOUT_MS = 1e4;
+var MAX_CALLBACKS = 10;
+var CartesiaSTT = class {
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.options = options;
+    if (!apiKey) {
+      throw new Error("CartesiaSTT requires a non-empty apiKey");
+    }
+  }
+  ws = null;
+  callbacks = [];
+  keepaliveTimer = null;
+  /** Cartesia request id — set from the server transcript events. */
+  requestId = "";
+  buildWsUrl() {
+    const opts = this.options;
+    const rawBase = opts.baseUrl ?? DEFAULT_BASE_URL;
+    let base;
+    if (rawBase.startsWith("http://")) {
+      base = `ws://${rawBase.slice("http://".length)}`;
+    } else if (rawBase.startsWith("https://")) {
+      base = `wss://${rawBase.slice("https://".length)}`;
+    } else if (rawBase.startsWith("ws://") || rawBase.startsWith("wss://")) {
+      base = rawBase;
+    } else {
+      base = `wss://${rawBase}`;
+    }
+    const language = opts.language ?? "en";
+    const params = new URLSearchParams({
+      model: opts.model ?? "ink-whisper",
+      sample_rate: String(opts.sampleRate ?? 16e3),
+      encoding: opts.encoding ?? "pcm_s16le",
+      cartesia_version: API_VERSION,
+      api_key: this.apiKey,
+      language
+    });
+    return `${base}/stt/websocket?${params.toString()}`;
+  }
+  async connect() {
+    const url = this.buildWsUrl();
+    this.ws = new import_ws7.default(url, {
+      headers: { "User-Agent": USER_AGENT }
+    });
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error("Cartesia STT connect timeout")),
+        CONNECT_TIMEOUT_MS
+      );
+      this.ws.once("open", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      this.ws.once("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+    this.ws.on("message", (raw) => {
+      let event;
+      try {
+        event = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      this.handleEvent(event);
+    });
+    this.keepaliveTimer = setInterval(() => {
+      if (this.ws && this.ws.readyState === import_ws7.default.OPEN) {
+        try {
+          this.ws.ping();
+        } catch {
+        }
+      }
+    }, KEEPALIVE_INTERVAL_MS);
+  }
+  handleEvent(event) {
+    const type = event.type;
+    if (type === "transcript") {
+      const text = (event.text ?? "").trim();
+      const isFinal = Boolean(event.is_final);
+      if (!text && !isFinal) return;
+      if (event.request_id) {
+        this.requestId = event.request_id;
+      }
+      if (!text) return;
+      const confidence = Number(event.probability ?? 1);
+      this.emit({ text, isFinal, confidence });
+      return;
+    }
+    if (type === "error") {
+      getLogger().error(`Cartesia STT error: ${event.message ?? "unknown"}`);
+      return;
+    }
+  }
+  emit(transcript) {
+    for (const cb of this.callbacks) {
+      cb(transcript);
+    }
+  }
+  sendAudio(audio) {
+    if (!this.ws || this.ws.readyState !== import_ws7.default.OPEN) return;
+    this.ws.send(audio);
+  }
+  onTranscript(callback) {
+    if (this.callbacks.length >= MAX_CALLBACKS) {
+      getLogger().warn(
+        "CartesiaSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback."
+      );
+      this.callbacks[this.callbacks.length - 1] = callback;
+      return;
+    }
+    this.callbacks.push(callback);
+  }
+  close() {
+    if (this.keepaliveTimer) {
+      clearInterval(this.keepaliveTimer);
+      this.keepaliveTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.send("finalize");
+      } catch {
+      }
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+};
+
+// src/stt/cartesia.ts
+var STT3 = class extends CartesiaSTT {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.CARTESIA_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Cartesia STT requires an apiKey. Pass { apiKey: '...' } or set CARTESIA_API_KEY in the environment."
+      );
+    }
+    super(key, {
+      model: opts.model,
+      language: opts.language,
+      encoding: opts.encoding,
+      sampleRate: opts.sampleRate,
+      baseUrl: opts.baseUrl
+    });
+  }
+};
+
+// src/providers/soniox-stt.ts
+var import_ws8 = __toESM(require("ws"));
+init_logger();
+var SONIOX_WS_URL = "wss://stt-rt.soniox.com/transcribe-websocket";
+var KEEPALIVE_MESSAGE = '{"type": "keepalive"}';
+var END_TOKEN = "<end>";
+var FINALIZED_TOKEN = "<fin>";
+var KEEPALIVE_INTERVAL_MS2 = 5e3;
+function isEndToken(token) {
+  return token.text === END_TOKEN || token.text === FINALIZED_TOKEN;
+}
+var TokenAccumulator = class {
+  text = "";
+  confSum = 0;
+  confCount = 0;
+  update(token) {
+    if (token.text) {
+      this.text += token.text;
+    }
+    if (typeof token.confidence === "number") {
+      this.confSum += token.confidence;
+      this.confCount += 1;
+    }
+  }
+  get confidence() {
+    return this.confCount === 0 ? 0 : this.confSum / this.confCount;
+  }
+  reset() {
+    this.text = "";
+    this.confSum = 0;
+    this.confCount = 0;
+  }
+  get raw() {
+    return { sum: this.confSum, count: this.confCount };
+  }
+};
+var SonioxSTT = class _SonioxSTT {
+  ws = null;
+  callbacks = [];
+  final = new TokenAccumulator();
+  keepaliveTimer = null;
+  apiKey;
+  model;
+  languageHints;
+  languageHintsStrict;
+  sampleRate;
+  numChannels;
+  enableSpeakerDiarization;
+  enableLanguageIdentification;
+  maxEndpointDelayMs;
+  clientReferenceId;
+  baseUrl;
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new Error("Soniox apiKey is required");
+    }
+    const maxEndpointDelayMs = options.maxEndpointDelayMs ?? 500;
+    if (maxEndpointDelayMs < 500 || maxEndpointDelayMs > 3e3) {
+      throw new Error("maxEndpointDelayMs must be between 500 and 3000");
+    }
+    this.apiKey = apiKey;
+    this.model = options.model ?? "stt-rt-v4";
+    this.languageHints = options.languageHints;
+    this.languageHintsStrict = options.languageHintsStrict ?? false;
+    this.sampleRate = options.sampleRate ?? 16e3;
+    this.numChannels = options.numChannels ?? 1;
+    this.enableSpeakerDiarization = options.enableSpeakerDiarization ?? false;
+    this.enableLanguageIdentification = options.enableLanguageIdentification ?? true;
+    this.maxEndpointDelayMs = maxEndpointDelayMs;
+    this.clientReferenceId = options.clientReferenceId;
+    this.baseUrl = options.baseUrl ?? SONIOX_WS_URL;
+  }
+  /** Factory for Twilio-style 8 kHz linear PCM. */
+  static forTwilio(apiKey, languageHints) {
+    return new _SonioxSTT(apiKey, { sampleRate: 8e3, languageHints });
+  }
+  buildConfig() {
+    const config = {
+      api_key: this.apiKey,
+      model: this.model,
       audio_format: "pcm_s16le",
       num_channels: this.numChannels,
       sample_rate: this.sampleRate,
@@ -7984,7 +8511,7 @@ var SonioxSTT = class _SonioxSTT {
     return config;
   }
   async connect() {
-    this.ws = new import_ws7.default(this.baseUrl);
+    this.ws = new import_ws8.default(this.baseUrl);
     await new Promise((resolve, reject) => {
       const timer = setTimeout(() => reject(new Error("Soniox connect timeout")), 1e4);
       this.ws.once("open", () => {
@@ -8003,13 +8530,13 @@ var SonioxSTT = class _SonioxSTT {
       getLogger().error(`SonioxSTT WebSocket error: ${String(err)}`);
     });
     this.keepaliveTimer = setInterval(() => {
-      if (this.ws && this.ws.readyState === import_ws7.default.OPEN) {
+      if (this.ws && this.ws.readyState === import_ws8.default.OPEN) {
         try {
           this.ws.send(KEEPALIVE_MESSAGE);
         } catch {
         }
       }
-    }, KEEPALIVE_INTERVAL_MS);
+    }, KEEPALIVE_INTERVAL_MS2);
   }
   clearKeepalive() {
     if (this.keepaliveTimer) {
@@ -8076,7 +8603,7 @@ var SonioxSTT = class _SonioxSTT {
     }
   }
   sendAudio(audio) {
-    if (!this.ws || this.ws.readyState !== import_ws7.default.OPEN) return;
+    if (!this.ws || this.ws.readyState !== import_ws8.default.OPEN) return;
     if (audio.length === 0) return;
     this.ws.send(audio);
   }
@@ -8106,16 +8633,28 @@ var SonioxSTT = class _SonioxSTT {
   }
 };
 
-// src/index.ts
-init_whisper_stt();
+// src/stt/soniox.ts
+var STT4 = class extends SonioxSTT {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.SONIOX_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Soniox STT requires an apiKey. Pass { apiKey: '...' } or set SONIOX_API_KEY in the environment."
+      );
+    }
+    const { apiKey: _ignored, ...rest } = opts;
+    void _ignored;
+    super(key, rest);
+  }
+};
 
 // src/providers/assemblyai-stt.ts
-var import_ws8 = __toESM(require("ws"));
+var import_ws9 = __toESM(require("ws"));
 init_logger();
-var DEFAULT_BASE_URL = "wss://streaming.assemblyai.com";
+var DEFAULT_BASE_URL2 = "wss://streaming.assemblyai.com";
 var DEFAULT_MIN_TURN_SILENCE_MS = 100;
-var CONNECT_TIMEOUT_MS = 1e4;
-var MAX_CALLBACKS = 10;
+var CONNECT_TIMEOUT_MS2 = 1e4;
+var MAX_CALLBACKS2 = 10;
 var AssemblyAISTT = class _AssemblyAISTT {
   constructor(apiKey, options = {}) {
     this.apiKey = apiKey;
@@ -8172,174 +8711,27 @@ var AssemblyAISTT = class _AssemblyAISTT {
     const params = new URLSearchParams();
     for (const [key, value] of Object.entries(raw)) {
       if (value === void 0 || value === null) continue;
-      if (typeof value === "boolean") {
-        params.set(key, value ? "true" : "false");
-      } else {
-        params.set(key, String(value));
-      }
-    }
-    const base = opts.baseUrl ?? DEFAULT_BASE_URL;
-    return `${base}/v3/ws?${params.toString()}`;
-  }
-  async connect() {
-    const url = this.buildUrl();
-    this.ws = new import_ws8.default(url, {
-      headers: {
-        Authorization: this.apiKey,
-        "Content-Type": "application/json",
-        "User-Agent": "Patter/1.0 (integration=LiveKit-port)"
-      }
-    });
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(
-        () => reject(new Error("AssemblyAI connect timeout")),
-        CONNECT_TIMEOUT_MS
-      );
-      this.ws.once("open", () => {
-        clearTimeout(timer);
-        resolve();
-      });
-      this.ws.once("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-    });
-    this.ws.on("message", (raw) => {
-      let event;
-      try {
-        event = JSON.parse(raw.toString());
-      } catch {
-        return;
-      }
-      this.handleEvent(event);
-    });
-  }
-  handleEvent(event) {
-    const type = event.type;
-    if (type === "Begin") {
-      this.sessionId = event.id ?? "";
-      this.expiresAt = event.expires_at ?? 0;
-      return;
-    }
-    if (type !== "Turn") {
-      return;
-    }
-    const endOfTurn = Boolean(event.end_of_turn);
-    const turnIsFormatted = Boolean(event.turn_is_formatted);
-    const words = event.words ?? [];
-    const transcriptText = (event.transcript ?? "").trim();
-    if (endOfTurn) {
-      if (this.options.formatTurns && !turnIsFormatted) return;
-      if (!transcriptText) return;
-      this.emit({
-        text: transcriptText,
-        isFinal: true,
-        confidence: averageConfidence(words)
-      });
-      return;
-    }
-    if (!words.length) return;
-    const interim = words.map((w) => (w.text ?? "").trim()).filter(Boolean).join(" ");
-    if (!interim) return;
-    this.emit({
-      text: interim,
-      isFinal: false,
-      confidence: averageConfidence(words)
-    });
-  }
-  emit(transcript) {
-    for (const cb of this.callbacks) {
-      cb(transcript);
-    }
-  }
-  sendAudio(audio) {
-    if (!this.ws || this.ws.readyState !== import_ws8.default.OPEN) return;
-    this.ws.send(audio);
-  }
-  onTranscript(callback) {
-    if (this.callbacks.length >= MAX_CALLBACKS) {
-      getLogger().warn(
-        "AssemblyAISTT: maximum of 10 onTranscript callbacks reached; replacing the last callback."
-      );
-      this.callbacks[this.callbacks.length - 1] = callback;
-      return;
-    }
-    this.callbacks.push(callback);
-  }
-  close() {
-    if (this.ws) {
-      try {
-        this.ws.send(JSON.stringify({ type: "Terminate" }));
-      } catch {
-      }
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-};
-function averageConfidence(words) {
-  if (!words.length) return 0;
-  let total = 0;
-  for (const w of words) {
-    total += Number(w.confidence ?? 0);
-  }
-  return total / words.length;
-}
-
-// src/providers/cartesia-stt.ts
-var import_ws9 = __toESM(require("ws"));
-init_logger();
-var DEFAULT_BASE_URL2 = "https://api.cartesia.ai";
-var API_VERSION = "2025-04-16";
-var USER_AGENT = "Patter/1.0 (integration=LiveKit-port; provider=Cartesia)";
-var KEEPALIVE_INTERVAL_MS2 = 3e4;
-var CONNECT_TIMEOUT_MS2 = 1e4;
-var MAX_CALLBACKS2 = 10;
-var CartesiaSTT = class {
-  constructor(apiKey, options = {}) {
-    this.apiKey = apiKey;
-    this.options = options;
-    if (!apiKey) {
-      throw new Error("CartesiaSTT requires a non-empty apiKey");
-    }
-  }
-  ws = null;
-  callbacks = [];
-  keepaliveTimer = null;
-  /** Cartesia request id — set from the server transcript events. */
-  requestId = "";
-  buildWsUrl() {
-    const opts = this.options;
-    const rawBase = opts.baseUrl ?? DEFAULT_BASE_URL2;
-    let base;
-    if (rawBase.startsWith("http://")) {
-      base = `ws://${rawBase.slice("http://".length)}`;
-    } else if (rawBase.startsWith("https://")) {
-      base = `wss://${rawBase.slice("https://".length)}`;
-    } else if (rawBase.startsWith("ws://") || rawBase.startsWith("wss://")) {
-      base = rawBase;
-    } else {
-      base = `wss://${rawBase}`;
-    }
-    const language = opts.language ?? "en";
-    const params = new URLSearchParams({
-      model: opts.model ?? "ink-whisper",
-      sample_rate: String(opts.sampleRate ?? 16e3),
-      encoding: opts.encoding ?? "pcm_s16le",
-      cartesia_version: API_VERSION,
-      api_key: this.apiKey,
-      language
-    });
-    return `${base}/stt/websocket?${params.toString()}`;
+      if (typeof value === "boolean") {
+        params.set(key, value ? "true" : "false");
+      } else {
+        params.set(key, String(value));
+      }
+    }
+    const base = opts.baseUrl ?? DEFAULT_BASE_URL2;
+    return `${base}/v3/ws?${params.toString()}`;
   }
   async connect() {
-    const url = this.buildWsUrl();
+    const url = this.buildUrl();
     this.ws = new import_ws9.default(url, {
-      headers: { "User-Agent": USER_AGENT }
+      headers: {
+        Authorization: this.apiKey,
+        "Content-Type": "application/json",
+        "User-Agent": "Patter/1.0 (integration=LiveKit-port)"
+      }
     });
     await new Promise((resolve, reject) => {
       const timer = setTimeout(
-        () => reject(new Error("Cartesia STT connect timeout")),
+        () => reject(new Error("AssemblyAI connect timeout")),
         CONNECT_TIMEOUT_MS2
       );
       this.ws.once("open", () => {
@@ -8360,33 +8752,39 @@ var CartesiaSTT = class {
       }
       this.handleEvent(event);
     });
-    this.keepaliveTimer = setInterval(() => {
-      if (this.ws && this.ws.readyState === import_ws9.default.OPEN) {
-        try {
-          this.ws.ping();
-        } catch {
-        }
-      }
-    }, KEEPALIVE_INTERVAL_MS2);
   }
   handleEvent(event) {
     const type = event.type;
-    if (type === "transcript") {
-      const text = (event.text ?? "").trim();
-      const isFinal = Boolean(event.is_final);
-      if (!text && !isFinal) return;
-      if (event.request_id) {
-        this.requestId = event.request_id;
-      }
-      if (!text) return;
-      const confidence = Number(event.probability ?? 1);
-      this.emit({ text, isFinal, confidence });
+    if (type === "Begin") {
+      this.sessionId = event.id ?? "";
+      this.expiresAt = event.expires_at ?? 0;
       return;
     }
-    if (type === "error") {
-      getLogger().error(`Cartesia STT error: ${event.message ?? "unknown"}`);
+    if (type !== "Turn") {
+      return;
+    }
+    const endOfTurn = Boolean(event.end_of_turn);
+    const turnIsFormatted = Boolean(event.turn_is_formatted);
+    const words = event.words ?? [];
+    const transcriptText = (event.transcript ?? "").trim();
+    if (endOfTurn) {
+      if (this.options.formatTurns && !turnIsFormatted) return;
+      if (!transcriptText) return;
+      this.emit({
+        text: transcriptText,
+        isFinal: true,
+        confidence: averageConfidence(words)
+      });
       return;
     }
+    if (!words.length) return;
+    const interim = words.map((w) => (w.text ?? "").trim()).filter(Boolean).join(" ");
+    if (!interim) return;
+    this.emit({
+      text: interim,
+      isFinal: false,
+      confidence: averageConfidence(words)
+    });
   }
   emit(transcript) {
     for (const cb of this.callbacks) {
@@ -8400,7 +8798,7 @@ var CartesiaSTT = class {
   onTranscript(callback) {
     if (this.callbacks.length >= MAX_CALLBACKS2) {
       getLogger().warn(
-        "CartesiaSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback."
+        "AssemblyAISTT: maximum of 10 onTranscript callbacks reached; replacing the last callback."
       );
       this.callbacks[this.callbacks.length - 1] = callback;
       return;
@@ -8408,13 +8806,9 @@ var CartesiaSTT = class {
     this.callbacks.push(callback);
   }
   close() {
-    if (this.keepaliveTimer) {
-      clearInterval(this.keepaliveTimer);
-      this.keepaliveTimer = null;
-    }
     if (this.ws) {
       try {
-        this.ws.send("finalize");
+        this.ws.send(JSON.stringify({ type: "Terminate" }));
       } catch {
       }
       this.ws.close();
@@ -8422,10 +8816,305 @@ var CartesiaSTT = class {
     }
   }
 };
+function averageConfidence(words) {
+  if (!words.length) return 0;
+  let total = 0;
+  for (const w of words) {
+    total += Number(w.confidence ?? 0);
+  }
+  return total / words.length;
+}
 
-// src/index.ts
-init_elevenlabs_tts();
-init_openai_tts();
+// src/stt/assemblyai.ts
+var STT5 = class extends AssemblyAISTT {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.ASSEMBLYAI_API_KEY;
+    if (!key) {
+      throw new Error(
+        "AssemblyAI STT requires an apiKey. Pass { apiKey: '...' } or set ASSEMBLYAI_API_KEY in the environment."
+      );
+    }
+    const { apiKey: _ignored, ...rest } = opts;
+    void _ignored;
+    super(key, rest);
+  }
+};
+
+// src/providers/elevenlabs-tts.ts
+var ELEVENLABS_BASE_URL = "https://api.elevenlabs.io/v1";
+var ELEVENLABS_VOICE_ID_BY_NAME = {
+  rachel: "21m00Tcm4TlvDq8ikWAM",
+  drew: "29vD33N1CtxCmqQRPOHJ",
+  clyde: "2EiwWnXFnvU5JabPnv8n",
+  paul: "5Q0t7uMcjvnagumLfvZi",
+  domi: "AZnzlk1XvdvUeBnXmlld",
+  dave: "CYw3kZ02Hs0563khs1Fj",
+  fin: "D38z5RcWu1voky8WS1ja",
+  bella: "EXAVITQu4vr4xnSDxMaL",
+  antoni: "ErXwobaYiN019PkySvjV",
+  thomas: "GBv7mTt0atIp3Br8iCZE",
+  charlie: "IKne3meq5aSn9XLyUdCD",
+  george: "JBFqnCBsd6RMkjVDRZzb",
+  emily: "LcfcDJNUP1GQjkzn1xUU",
+  elli: "MF3mGyEYCl7XYWbV9V6O",
+  callum: "N2lVS1w4EtoT3dr4eOWO",
+  patrick: "ODq5zmih8GrVes37Dizd",
+  harry: "SOYHLrjzK2X1ezoPC6cr",
+  liam: "TX3LPaxmHKxFdv7VOQHJ",
+  dorothy: "ThT5KcBeYPX3keUQqHPh",
+  josh: "TxGEqnHWrfWFTfGW9XjX",
+  arnold: "VR6AewLTigWG4xSOukaG",
+  charlotte: "XB0fDUnXU5powFXDhCwa",
+  matilda: "XrExE9yKIg1WjnnlVkGX",
+  matthew: "Yko7PKHZNXotIFUBG7I9",
+  james: "ZQe5CZNOzWyzPSCn5a3c",
+  joseph: "Zlb1dXrM653N07WRdFW3",
+  jeremy: "bVMeCyTHy58xNoL34h3p",
+  michael: "flq6f7yk4E4fJM5XTYuZ",
+  ethan: "g5CIjZEefAph4nQFvHAz",
+  gigi: "jBpfuIE2acCO8z3wKNLl",
+  freya: "jsCqWAovK2LkecY7zXl4",
+  brian: "nPczCjzI2devNBz1zQrb",
+  grace: "oWAxZDx7w5VEj9dCyTzz",
+  daniel: "onwK4e9ZLuTAKqWW03F9",
+  lily: "pFZP5JQG7iQjIQuC4Bku",
+  serena: "pMsXgVXv3BLzUgSXRplE",
+  adam: "pNInz6obpgDQGcFmaJgB",
+  nicole: "piTKgcLEGmPE4e6mEKli",
+  bill: "pqHfZKP75CvOlQylNhV4",
+  jessie: "t0jbNlBVZ17f02VDIeMI",
+  ryan: "wViXBPUzp2ZZixB1xQuM",
+  sam: "yoZ06aMxZJJ28mfd3POQ",
+  glinda: "z9fAnlkpzviPz146aGWa",
+  giovanni: "zcAOhNBS3c14rBihAFp1",
+  mimi: "zrHiDhphv9ZnVXBqCLjz",
+  alloy: "21m00Tcm4TlvDq8ikWAM"
+};
+var VOICE_ID_PATTERN = /^[A-Za-z0-9]{20}$/;
+function resolveVoiceId(voice) {
+  if (!voice) return voice;
+  if (VOICE_ID_PATTERN.test(voice)) return voice;
+  return ELEVENLABS_VOICE_ID_BY_NAME[voice.toLowerCase()] ?? voice;
+}
+var ElevenLabsTTS = class {
+  constructor(apiKey, voiceId = "21m00Tcm4TlvDq8ikWAM", modelId = "eleven_turbo_v2_5", outputFormat = "pcm_16000") {
+    this.apiKey = apiKey;
+    this.modelId = modelId;
+    this.outputFormat = outputFormat;
+    this.voiceId = resolveVoiceId(voiceId);
+  }
+  voiceId;
+  /**
+   * Synthesise text to speech and return the full audio as a single Buffer.
+   *
+   * For large chunks (or when latency matters) call `synthesizeStream` instead.
+   */
+  async synthesize(text) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+  /**
+   * Synthesise text and yield audio chunks as they arrive (streaming).
+   *
+   * The yielded buffers are raw PCM at 16 kHz (or whatever `outputFormat` is
+   * configured to).
+   */
+  async *synthesizeStream(text) {
+    const url = `${ELEVENLABS_BASE_URL}/text-to-speech/${encodeURIComponent(this.voiceId)}/stream?output_format=${encodeURIComponent(this.outputFormat)}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "xi-api-key": this.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ text, model_id: this.modelId }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`ElevenLabs TTS error ${response.status}: ${body}`);
+    }
+    if (!response.body) {
+      throw new Error("ElevenLabs TTS: no response body");
+    }
+    const reader = response.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value && value.length > 0) {
+          yield Buffer.from(value);
+        }
+      }
+    } finally {
+      if (typeof reader.cancel === "function") await reader.cancel().catch(() => {
+      });
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/tts/elevenlabs.ts
+var TTS = class extends ElevenLabsTTS {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.ELEVENLABS_API_KEY;
+    if (!key) {
+      throw new Error(
+        "ElevenLabs TTS requires an apiKey. Pass { apiKey: '...' } or set ELEVENLABS_API_KEY in the environment."
+      );
+    }
+    super(
+      key,
+      opts.voiceId ?? "21m00Tcm4TlvDq8ikWAM",
+      opts.modelId ?? "eleven_turbo_v2_5",
+      opts.outputFormat ?? "pcm_16000"
+    );
+  }
+};
+
+// src/providers/openai-tts.ts
+var OPENAI_TTS_URL = "https://api.openai.com/v1/audio/speech";
+var OpenAITTS = class _OpenAITTS {
+  constructor(apiKey, voice = "alloy", model = "tts-1") {
+    this.apiKey = apiKey;
+    this.voice = voice;
+    this.model = model;
+  }
+  /**
+   * Synthesise text to speech and return the full audio as a single Buffer.
+   *
+   * For large chunks (or when latency matters) call `synthesizeStream` instead.
+   */
+  async synthesize(text) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+  /**
+   * Synthesise text and yield audio chunks as they arrive (streaming).
+   *
+   * OpenAI returns 24 kHz PCM16; each chunk is resampled to 16 kHz before
+   * yielding so the output is ready for telephony pipelines.
+   *
+   * The resampler carries state (buffered samples + odd trailing byte)
+   * between chunks — without that state cross-chunk sample alignment drifts
+   * and the caller hears pops / dropped audio (BUG #23, mirror of the
+   * Python `audioop.ratecv` fix).
+   */
+  async *synthesizeStream(text) {
+    const response = await fetch(OPENAI_TTS_URL, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        input: text,
+        voice: this.voice,
+        response_format: "pcm"
+      }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`OpenAI TTS error ${response.status}: ${body}`);
+    }
+    if (!response.body) {
+      throw new Error("OpenAI TTS: no response body");
+    }
+    const ctx = { carryByte: null, leftover: [] };
+    const reader = response.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value && value.length > 0) {
+          const out = _OpenAITTS.resampleStreaming(Buffer.from(value), ctx);
+          if (out.length > 0) yield out;
+        }
+      }
+      if (ctx.leftover.length > 0) {
+        const tail = Buffer.alloc(ctx.leftover.length * 2);
+        for (let i = 0; i < ctx.leftover.length; i++) {
+          tail.writeInt16LE(ctx.leftover[i], i * 2);
+        }
+        yield tail;
+      }
+    } finally {
+      if (typeof reader.cancel === "function") await reader.cancel().catch(() => {
+      });
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Streaming 24 kHz → 16 kHz resampler (PCM16-LE). Maintains cross-chunk
+   * state so the 3:2 pattern doesn't reset at every network read.
+   */
+  static resampleStreaming(audio, ctx) {
+    let buf;
+    if (ctx.carryByte !== null) {
+      buf = Buffer.concat([Buffer.from([ctx.carryByte]), audio]);
+      ctx.carryByte = null;
+    } else {
+      buf = audio;
+    }
+    if (buf.length % 2 === 1) {
+      ctx.carryByte = buf[buf.length - 1];
+      buf = buf.subarray(0, buf.length - 1);
+    }
+    if (buf.length === 0 && ctx.leftover.length === 0) {
+      return Buffer.alloc(0);
+    }
+    const sampleCount = buf.length / 2;
+    const samples = ctx.leftover.slice();
+    for (let i2 = 0; i2 < sampleCount; i2++) {
+      samples.push(buf.readInt16LE(i2 * 2));
+    }
+    const out = [];
+    let i = 0;
+    while (i + 2 < samples.length) {
+      out.push(samples[i]);
+      out.push(Math.trunc((samples[i + 1] + samples[i + 2]) / 2));
+      i += 3;
+    }
+    ctx.leftover = samples.slice(i);
+    const buffer = Buffer.alloc(out.length * 2);
+    for (let j = 0; j < out.length; j++) {
+      buffer.writeInt16LE(out[j], j * 2);
+    }
+    return buffer;
+  }
+  /** @deprecated use {@link resampleStreaming} with persistent state. */
+  static resample24kTo16k(audio) {
+    const ctx = { carryByte: null, leftover: [] };
+    const out = _OpenAITTS.resampleStreaming(audio, ctx);
+    if (ctx.leftover.length === 0) return out;
+    const tail = Buffer.alloc(ctx.leftover.length * 2);
+    for (let i = 0; i < ctx.leftover.length; i++) {
+      tail.writeInt16LE(ctx.leftover[i], i * 2);
+    }
+    return Buffer.concat([out, tail]);
+  }
+};
+
+// src/tts/openai.ts
+var TTS2 = class extends OpenAITTS {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!key) {
+      throw new Error(
+        "OpenAI TTS requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
+      );
+    }
+    super(key, opts.voice ?? "alloy", opts.model ?? "tts-1");
+  }
+};
 
 // src/providers/cartesia-tts.ts
 var CARTESIA_BASE_URL = "https://api.cartesia.ai";
@@ -8525,6 +9214,21 @@ var CartesiaTTS = class {
   }
 };
 
+// src/tts/cartesia.ts
+var TTS3 = class extends CartesiaTTS {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.CARTESIA_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Cartesia TTS requires an apiKey. Pass { apiKey: '...' } or set CARTESIA_API_KEY in the environment."
+      );
+    }
+    const { apiKey: _ignored, ...rest } = opts;
+    void _ignored;
+    super(key, rest);
+  }
+};
+
 // src/providers/rime-tts.ts
 var RIME_BASE_URL = "https://users.rime.ai/v1/rime-tts";
 var ARCANA_MODEL_TIMEOUT_MS = 60 * 4 * 1e3;
@@ -8652,6 +9356,21 @@ var RimeTTS = class {
   }
 };
 
+// src/tts/rime.ts
+var TTS4 = class extends RimeTTS {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.RIME_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Rime TTS requires an apiKey. Pass { apiKey: '...' } or set RIME_API_KEY in the environment."
+      );
+    }
+    const { apiKey: _ignored, ...rest } = opts;
+    void _ignored;
+    super(key, rest);
+  }
+};
+
 // src/providers/lmnt-tts.ts
 var LMNT_BASE_URL = "https://api.lmnt.com/v1/ai/speech/bytes";
 var LMNTTTS = class {
@@ -8730,6 +9449,119 @@ var LMNTTTS = class {
   }
 };
 
+// src/tts/lmnt.ts
+var TTS5 = class extends LMNTTTS {
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.LMNT_API_KEY;
+    if (!key) {
+      throw new Error(
+        "LMNT TTS requires an apiKey. Pass { apiKey: '...' } or set LMNT_API_KEY in the environment."
+      );
+    }
+    const { apiKey: _ignored, ...rest } = opts;
+    void _ignored;
+    super(key, rest);
+  }
+};
+
+// src/carriers/twilio.ts
+var Carrier = class {
+  kind = "twilio";
+  accountSid;
+  authToken;
+  constructor(opts = {}) {
+    const sid = opts.accountSid ?? process.env.TWILIO_ACCOUNT_SID;
+    const tok = opts.authToken ?? process.env.TWILIO_AUTH_TOKEN;
+    if (!sid) {
+      throw new Error(
+        "Twilio carrier requires accountSid. Pass { accountSid: 'AC...' } or set TWILIO_ACCOUNT_SID in the environment."
+      );
+    }
+    if (!tok) {
+      throw new Error(
+        "Twilio carrier requires authToken. Pass { authToken: '...' } or set TWILIO_AUTH_TOKEN in the environment."
+      );
+    }
+    this.accountSid = sid;
+    this.authToken = tok;
+  }
+};
+
+// src/carriers/telnyx.ts
+var Carrier2 = class {
+  kind = "telnyx";
+  apiKey;
+  connectionId;
+  publicKey;
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.TELNYX_API_KEY;
+    const conn = opts.connectionId ?? process.env.TELNYX_CONNECTION_ID;
+    const pub = opts.publicKey ?? process.env.TELNYX_PUBLIC_KEY;
+    if (!key) {
+      throw new Error(
+        "Telnyx carrier requires apiKey. Pass { apiKey: '...' } or set TELNYX_API_KEY in the environment."
+      );
+    }
+    if (!conn) {
+      throw new Error(
+        "Telnyx carrier requires connectionId. Pass { connectionId: '...' } or set TELNYX_CONNECTION_ID in the environment."
+      );
+    }
+    this.apiKey = key;
+    this.connectionId = conn;
+    this.publicKey = pub;
+  }
+};
+
+// src/public-api.ts
+var DEFAULT_GUARDRAIL_REPLACEMENT = "I'm sorry, I can't respond to that.";
+var Guardrail = class {
+  name;
+  blockedTerms;
+  check;
+  replacement;
+  constructor(opts) {
+    if (!opts.name) {
+      throw new Error("Guardrail requires a non-empty name.");
+    }
+    this.name = opts.name;
+    if (opts.blockedTerms) this.blockedTerms = opts.blockedTerms;
+    if (opts.check) this.check = opts.check;
+    this.replacement = opts.replacement ?? DEFAULT_GUARDRAIL_REPLACEMENT;
+  }
+};
+function guardrail(opts) {
+  return new Guardrail(opts);
+}
+var Tool = class {
+  name;
+  description;
+  parameters;
+  handler;
+  webhookUrl;
+  constructor(opts) {
+    if (!opts.name) {
+      throw new Error("Tool requires a non-empty name.");
+    }
+    const hasHandler = typeof opts.handler === "function";
+    const hasWebhook = typeof opts.webhookUrl === "string" && opts.webhookUrl.length > 0;
+    if (!hasHandler && !hasWebhook) {
+      throw new Error("Tool requires either handler or webhookUrl.");
+    }
+    if (hasHandler && hasWebhook) {
+      throw new Error("Tool accepts handler OR webhookUrl, not both.");
+    }
+    this.name = opts.name;
+    this.description = opts.description ?? "";
+    this.parameters = opts.parameters ?? { type: "object", properties: {} };
+    if (hasHandler) this.handler = opts.handler;
+    if (hasWebhook) this.webhookUrl = opts.webhookUrl;
+  }
+};
+function tool(opts) {
+  return new Tool(opts);
+}
+
 // src/index.ts
 init_transcoding();
 init_tunnel();
@@ -9354,21 +10186,25 @@ function isAudioConfig(value) {
   CartesiaSTT,
   CartesiaTTS,
   ChatContext,
+  CloudflareTunnel,
   DEFAULT_MIN_SENTENCE_LEN,
   DEFAULT_PRICING,
   DTMF_EVENTS,
   DeepgramSTT,
+  ElevenLabsConvAI,
   ElevenLabsConvAIAdapter,
   ElevenLabsTTS,
   FallbackLLMProvider,
   GEMINI_DEFAULT_INPUT_SR,
   GEMINI_DEFAULT_OUTPUT_SR,
   GeminiLiveAdapter,
+  Guardrail,
   IVRActivity,
   LLMLoop,
   LMNTTTS,
   MetricsStore,
   OpenAILLMProvider,
+  OpenAIRealtime,
   OpenAIRealtimeAdapter,
   OpenAITTS,
   PartialStreamError,
@@ -9381,8 +10217,12 @@ function isAudioConfig(value) {
   RimeTTS,
   SentenceChunker,
   SonioxSTT,
+  StaticTunnel,
+  Telnyx,
   TestSession,
   TfidfLoopDetector,
+  Tool,
+  Twilio,
   ULTRAVOX_DEFAULT_API_BASE,
   ULTRAVOX_DEFAULT_SR,
   UltravoxRealtimeAdapter,
@@ -9402,6 +10242,7 @@ function isAudioConfig(value) {
   filterMarkdown,
   formatDtmf,
   getLogger,
+  guardrail,
   isRemoteUrl,
   isWebSocketUrl,
   makeAuthMiddleware,
@@ -9423,5 +10264,6 @@ function isAudioConfig(value) {
   selectSoundFromList,
   setLogger,
   startTunnel,
+  tool,
   whisper
 });