getpatter 0.6.1 → 0.6.2

package/dist/index.js

@@ -5,10 +5,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __glob = (map) => (path5) => {
-  var fn = map[path5];
+var __glob = (map) => (path6) => {
+  var fn = map[path6];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path5);
+  throw new Error("Module not found in bundle: " + path6);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -303,11 +303,10 @@ var init_openai_realtime = __esm({
         const url2 = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(this.model)}`;
         let ws = null;
         try {
-          ws = await new Promise((resolve, reject) => {
+          ws = await new Promise((resolve2, reject) => {
             const sock = new import_ws.default(url2, {
               headers: {
-                Authorization: `Bearer ${this.apiKey}`,
-                "OpenAI-Beta": "realtime=v1"
+                Authorization: `Bearer ${this.apiKey}`
               }
             });
             const timer = setTimeout(() => {
@@ -319,22 +318,22 @@ var init_openai_realtime = __esm({
             }, 5e3);
             sock.once("open", () => {
               clearTimeout(timer);
-              resolve(sock);
+              resolve2(sock);
             });
             sock.once("error", (err) => {
               clearTimeout(timer);
               reject(err);
             });
           });
-          const sessionCreated = await new Promise((resolve) => {
-            const timer = setTimeout(() => resolve(false), 2e3);
+          const sessionCreated = await new Promise((resolve2) => {
+            const timer = setTimeout(() => resolve2(false), 2e3);
             const onMsg = (raw) => {
               try {
                 const data = JSON.parse(raw.toString());
                 if (data.type === "session.created") {
                   clearTimeout(timer);
                   ws.off("message", onMsg);
-                  resolve(true);
+                  resolve2(true);
                 }
               } catch {
               }
@@ -347,15 +346,15 @@ var init_openai_realtime = __esm({
           } catch {
             return;
           }
-          await new Promise((resolve) => {
-            const timer = setTimeout(() => resolve(), 1500);
+          await new Promise((resolve2) => {
+            const timer = setTimeout(() => resolve2(), 1500);
             const onMsg = (raw) => {
               try {
                 const data = JSON.parse(raw.toString());
                 if (data.type === "session.updated") {
                   clearTimeout(timer);
                   ws.off("message", onMsg);
-                  resolve();
+                  resolve2();
                 }
               } catch {
               }
@@ -378,11 +377,10 @@ var init_openai_realtime = __esm({
         const url2 = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(this.model)}`;
         this.ws = new import_ws.default(url2, {
           headers: {
-            Authorization: `Bearer ${this.apiKey}`,
-            "OpenAI-Beta": "realtime=v1"
+            Authorization: `Bearer ${this.apiKey}`
           }
         });
-        await new Promise((resolve, reject) => {
+        await new Promise((resolve2, reject) => {
           let sessionCreated = false;
           let settled = false;
           const ws = this.ws;
@@ -399,7 +397,7 @@ var init_openai_realtime = __esm({
               ws.send(JSON.stringify({ type: "session.update", session: this.buildSessionConfig() }));
             } else if (msg.type === "session.updated") {
               cleanup();
-              resolve();
+              resolve2();
             }
           };
           const onSetupError = (err) => {
@@ -472,11 +470,10 @@ var init_openai_realtime = __esm({
         const url2 = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(this.model)}`;
         const ws = new import_ws.default(url2, {
           headers: {
-            Authorization: `Bearer ${this.apiKey}`,
-            "OpenAI-Beta": "realtime=v1"
+            Authorization: `Bearer ${this.apiKey}`
           }
         });
-        await new Promise((resolve, reject) => {
+        await new Promise((resolve2, reject) => {
           let sessionCreated = false;
           let settled = false;
           const onMessage = (raw) => {
@@ -496,7 +493,7 @@ var init_openai_realtime = __esm({
               }
             } else if (msg.type === "session.updated") {
               cleanup();
-              resolve();
+              resolve2();
             }
           };
           const onError = (err) => {
@@ -621,22 +618,23 @@ var init_openai_realtime = __esm({
        */
       cancelResponse() {
         if (!this.ws) return;
-        if (this.currentResponseItemId) {
-          let audioEndMs = this.currentResponseAudioMs;
-          if (this.currentResponseFirstAudioAt !== null) {
-            const elapsedMs = Date.now() - this.currentResponseFirstAudioAt;
-            audioEndMs = Math.min(audioEndMs, Math.max(elapsedMs, 0));
-          }
-          try {
-            this.ws.send(JSON.stringify({
-              type: "conversation.item.truncate",
-              item_id: this.currentResponseItemId,
-              content_index: 0,
-              audio_end_ms: audioEndMs
-            }));
-          } catch (err) {
-            getLogger().debug?.(`conversation.item.truncate failed: ${String(err)}`);
-          }
+        if (!this.currentResponseItemId) {
+          return;
+        }
+        let audioEndMs = this.currentResponseAudioMs;
+        if (this.currentResponseFirstAudioAt !== null) {
+          const elapsedMs = Date.now() - this.currentResponseFirstAudioAt;
+          audioEndMs = Math.min(audioEndMs, Math.max(elapsedMs, 0));
+        }
+        try {
+          this.ws.send(JSON.stringify({
+            type: "conversation.item.truncate",
+            item_id: this.currentResponseItemId,
+            content_index: 0,
+            audio_end_ms: audioEndMs
+          }));
+        } catch (err) {
+          getLogger().debug?.(`conversation.item.truncate failed: ${String(err)}`);
         }
         this.ws.send(JSON.stringify({ type: "response.cancel" }));
         this.currentResponseItemId = null;
@@ -651,6 +649,19 @@ var init_openai_realtime = __esm({
         }));
         this.ws?.send(JSON.stringify({ type: "response.create" }));
       }
+      /**
+       * Trigger `response.create` with no new user item.
+       *
+       * Used by the Realtime stream-handler to drive a response after the
+       * client-side hallucination filter accepts an
+       * `input_audio_transcription.completed` event. The server VAD config
+       * sets `create_response: false` so OpenAI no longer auto-creates a
+       * response on every `input_audio_buffer.committed`; Patter is now
+       * responsible for triggering it explicitly when a real user turn lands.
+       */
+      async requestResponse() {
+        this.ws?.send(JSON.stringify({ type: "response.create" }));
+      }
       /**
        * Make the AI speak ``text`` as its opening line.
        *
@@ -1103,6 +1114,10 @@ var init_transcoding = __esm({
 });
 
 // src/providers/openai-realtime-2.ts
+var openai_realtime_2_exports = {};
+__export(openai_realtime_2_exports, {
+  OpenAIRealtime2Adapter: () => OpenAIRealtime2Adapter
+});
 var import_ws2, GA_TO_V1_EVENT_NAMES, OpenAIRealtime2Adapter;
 var init_openai_realtime_2 = __esm({
   "src/providers/openai-realtime-2.ts"() {
@@ -1159,17 +1174,33 @@ var init_openai_realtime_2 = __esm({
               transcription: {
                 model: opts.inputAudioTranscriptionModel ?? OpenAITranscriptionModel.WHISPER_1
               },
-              // Lower threshold (0.3 vs the 0.5 default) because the inbound
-              // audio is telephony-band (8 kHz) linearly upsampled to 24 kHz —
-              // the upper 4-12 kHz band is interpolation, not real harmonics,
-              // and the GA server VAD's default tuning was calibrated against
-              // studio-quality 24 kHz audio. A more permissive threshold
-              // recovers reliable speech detection on phone-band input.
+              // VAD threshold raised back to the OpenAI default (0.5) on
+              // 2026-05-22. The earlier 0.1 tuning (motivated by the
+              // upsampled telephony-band loss in high frequencies) made the
+              // server VAD trigger on the carrier-loopback echo of the
+              // agent's OWN outbound audio in PSTN no-AEC scenarios.
+              // Combined with the default ``turn_detection.create_response:
+              // true``, every phantom ``speech_started`` ended a turn early
+              // and auto-created a new response that the agent immediately
+              // spoke over, leading to a runaway loop where the first
+              // message was repeatedly cut and re-generated.
               turn_detection: {
                 type: opts.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
-                threshold: 0.1,
+                threshold: 0.5,
                 prefix_padding_ms: 300,
-                silence_duration_ms: opts.silenceDurationMs ?? 500
+                silence_duration_ms: opts.silenceDurationMs ?? 500,
+                // Defer ``response.create`` to the application: when OpenAI's
+                // server VAD commits an ``input_audio_buffer.committed`` segment
+                // that turns out to be a Whisper hallucination on silence/echo,
+                // auto-creating a response would generate a phantom turn (the
+                // model reads the hallucinated text as user input). Patter
+                // triggers ``response.create`` explicitly in the Realtime
+                // stream-handler AFTER validating ``transcript_input`` against
+                // the hallucination filter. Pair with ``interrupt_response:
+                // false`` so server VAD also leaves in-flight responses alone —
+                // barge-in is gated client-side.
+                create_response: false,
+                interrupt_response: false
               }
             },
             output: {
@@ -1244,7 +1275,7 @@ var init_openai_realtime_2 = __esm({
           };
           return originalOn(event, wrapped);
         };
-        await new Promise((resolve, reject) => {
+        await new Promise((resolve2, reject) => {
           let sessionCreated = false;
           let settled = false;
           const ws = this.ws;
@@ -1261,7 +1292,7 @@ var init_openai_realtime_2 = __esm({
               ws.send(JSON.stringify({ type: "session.update", session: this.buildGASessionConfig() }));
             } else if (msg.type === "session.updated") {
               cleanup();
-              resolve();
+              resolve2();
             } else if (msg.type === "error") {
               cleanup();
               try {
@@ -1299,6 +1330,131 @@ var init_openai_realtime_2 = __esm({
         });
         this.armHeartbeatAndListener();
       }
+      /**
+       * GA-API variant of {@link OpenAIRealtimeAdapter.openParkedConnection}.
+       * Opens a fresh Realtime WS against the GA endpoint, exchanges
+       * `session.created` → GA-shape `session.update` → `session.updated`
+       * so the upstream session is fully primed, and returns the OPEN
+       * socket WITHOUT taking it on `this.ws` or arming the heartbeat /
+       * message listener.
+       *
+       * Used by `Patter.parkProviderConnections` during the carrier
+       * ringing window so the per-call `StreamHandler` can adopt the
+       * primed socket at carrier `start` — eliminating the TCP + TLS +
+       * HTTP-101 + `session.update` ack round-trip from the critical path.
+       * Saves ~300-600 ms of first-audible-word latency.
+       *
+       * Bounded by 8 s. Throws on timeout / handshake failure / GA-side
+       * rejection. Callers treat any error as a cache miss and fall
+       * through to the cold {@link connect} path.
+       *
+       * Billing safety: confirmed by OpenAI's Managing Realtime Costs
+       * guide — `session.update` does NOT invoke the model and bills no
+       * tokens. An idle parked socket costs $0.
+       */
+      async openParkedConnection() {
+        const url2 = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(this.model)}`;
+        const ws = new import_ws2.default(url2, {
+          headers: { Authorization: `Bearer ${this.apiKey}` }
+        });
+        await new Promise((resolve2, reject) => {
+          let sessionCreated = false;
+          let settled = false;
+          const onMessage = (raw) => {
+            let msg;
+            try {
+              msg = JSON.parse(raw.toString());
+            } catch {
+              return;
+            }
+            if (msg.type === "session.created" && !sessionCreated) {
+              sessionCreated = true;
+              try {
+                ws.send(JSON.stringify({ type: "session.update", session: this.buildGASessionConfig() }));
+              } catch (err) {
+                cleanup();
+                reject(err instanceof Error ? err : new Error(String(err)));
+              }
+            } else if (msg.type === "session.updated") {
+              cleanup();
+              resolve2();
+            } else if (msg.type === "error") {
+              cleanup();
+              reject(new Error(`OpenAI Realtime 2 parked-setup error: ${msg.error?.message ?? JSON.stringify(msg)}`));
+            }
+          };
+          const onError = (err) => {
+            cleanup();
+            reject(err);
+          };
+          const cleanup = () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            ws.off("message", onMessage);
+            ws.off("error", onError);
+          };
+          const timer = setTimeout(() => {
+            cleanup();
+            reject(new Error("OpenAI Realtime 2 park connect timeout"));
+          }, 8e3);
+          ws.on("message", onMessage);
+          ws.on("error", onError);
+        });
+        const keepalive = setInterval(() => {
+          if (ws.readyState !== ws.OPEN) {
+            clearInterval(keepalive);
+            return;
+          }
+          try {
+            ws.send(JSON.stringify({ type: "session.update", session: this.buildGASessionConfig() }));
+          } catch {
+            clearInterval(keepalive);
+          }
+        }, 3e3);
+        ws._parkedKeepalive = keepalive;
+        return ws;
+      }
+      /**
+       * GA-API variant of {@link OpenAIRealtimeAdapter.adoptWebSocket}. Takes
+       * over a WS that {@link openParkedConnection} produced (already through
+       * `session.created` + `session.update` + `session.updated`) and arms
+       * the heartbeat + message listener so the GA event-translation shim
+       * is wired up. Skips the cold-connect path — saves ~300-600 ms on
+       * first audible word.
+       *
+       * Caller MUST verify `ws.readyState === OPEN` before calling. If the
+       * parked WS died between park and adopt, fall back to {@link connect}.
+       */
+      adoptWebSocket(ws) {
+        const wsAny = ws;
+        if (wsAny._parkedKeepalive) {
+          clearInterval(wsAny._parkedKeepalive);
+          delete wsAny._parkedKeepalive;
+        }
+        this.ws = ws;
+        const wsRef = ws;
+        const originalOn = wsRef.on.bind(ws);
+        wsRef.on = (event, handler) => {
+          if (event !== "message") return originalOn(event, handler);
+          const wrapped = (raw, ...rest) => {
+            try {
+              const text = typeof raw === "string" ? raw : raw.toString();
+              const parsed = JSON.parse(text);
+              const t = parsed.type;
+              if (t && Object.prototype.hasOwnProperty.call(GA_TO_V1_EVENT_NAMES, t)) {
+                parsed.type = GA_TO_V1_EVENT_NAMES[t];
+                handler(JSON.stringify(parsed), ...rest);
+                return;
+              }
+            } catch {
+            }
+            handler(raw, ...rest);
+          };
+          return originalOn(event, wrapped);
+        };
+        this.armHeartbeatAndListener();
+      }
       /**
        * GA-API variant of {@link OpenAIRealtimeAdapter.sendFirstMessage}. Two
        * differences from the v1 path:
@@ -1392,15 +1548,15 @@ var init_openai_realtime_2 = __esm({
         return pcm16ToMulaw(pcm8);
       }
       async sendFirstMessage(text) {
-        this.ws?.send(JSON.stringify({
-          type: "response.create",
-          response: {
-            output_modalities: ["audio"],
-            audio: { output: { voice: this.voice } },
-            reasoning: { effort: "minimal" },
-            instructions: `Say exactly the following sentence as your first turn and nothing else: "${text}"`
-          }
-        }));
+        const responseBody = {
+          output_modalities: ["audio"],
+          audio: { output: { voice: this.voice } },
+          instructions: `Say exactly the following sentence as your first turn and nothing else: "${text}"`
+        };
+        if (this.options.reasoningEffort !== void 0) {
+          responseBody.reasoning = { effort: this.options.reasoningEffort };
+        }
+        this.ws?.send(JSON.stringify({ type: "response.create", response: responseBody }));
       }
     };
   }
@@ -1536,7 +1692,7 @@ var init_elevenlabs_convai = __esm({
           wsOptions = { headers: { "xi-api-key": this.apiKey } };
         }
         this.ws = new import_ws3.default(wsUrl, wsOptions);
-        await new Promise((resolve, reject) => {
+        await new Promise((resolve2, reject) => {
           const timeout = setTimeout(
             () => reject(new Error("ElevenLabs ConvAI connect timeout")),
             15e3
@@ -1560,7 +1716,7 @@ var init_elevenlabs_convai = __esm({
               conversation_config_override: override
             };
             this.ws.send(JSON.stringify(config2));
-            resolve();
+            resolve2();
           });
           this.ws.once("error", (err) => {
             clearTimeout(timeout);
@@ -1717,20 +1873,20 @@ var init_elevenlabs_convai = __esm({
           return;
         }
         const ws = this.ws;
-        this.closePromise = new Promise((resolve) => {
+        this.closePromise = new Promise((resolve2) => {
           if (ws.readyState === import_ws3.default.CLOSED || ws.readyState === import_ws3.default.CLOSING) {
-            resolve();
+            resolve2();
             return;
           }
           const done = () => {
-            resolve();
+            resolve2();
           };
           ws.once("close", done);
           ws.once("error", done);
           try {
             ws.close();
           } catch {
-            resolve();
+            resolve2();
           }
         });
         try {
@@ -1901,11 +2057,13 @@ function calculateTelephonyCost(provider2, durationSeconds, pricing) {
   const minutes = provider2 === "twilio" ? Math.ceil(durationSeconds / 60) : durationSeconds / 60;
   return minutes * (config2.price ?? 0);
 }
-var PricingUnit, DEFAULT_PRICING, llmPricing;
+var PRICING_VERSION, PRICING_LAST_UPDATED, PricingUnit, DEFAULT_PRICING, llmPricing;
 var init_pricing = __esm({
   "src/pricing.ts"() {
     "use strict";
     init_cjs_shims();
+    PRICING_VERSION = "2026.3";
+    PRICING_LAST_UPDATED = "2026-05-08";
     PricingUnit = {
       MINUTE: "minute",
       THOUSAND_CHARS: "1k_chars",
@@ -2213,7 +2371,31 @@ var init_pricing = __esm({
   }
 });
 
+// src/version.ts
+function readVersion() {
+  try {
+    const pkgPath = path.resolve(__dirname, "..", "package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return typeof pkg.version === "string" && pkg.version.length > 0 ? pkg.version : "";
+  } catch {
+    return "";
+  }
+}
+var fs, path, VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs = __toESM(require("fs"));
+    path = __toESM(require("path"));
+    VERSION = readVersion();
+  }
+});
+
 // src/dashboard/store.ts
+function sdkVersion() {
+  return VERSION;
+}
 function metricsFromTopLevel(meta2) {
   const cost = meta2.cost && typeof meta2.cost === "object" ? meta2.cost : null;
   const latency = meta2.latency && typeof meta2.latency === "object" ? meta2.latency : null;
@@ -2268,8 +2450,8 @@ function metadataToCallRecord(callId, meta2) {
 }
 function loadTranscriptJsonl(filePath) {
   try {
-    if (!fs.existsSync(filePath)) return [];
-    const raw = fs.readFileSync(filePath, "utf8");
+    if (!fs2.existsSync(filePath)) return [];
+    const raw = fs2.readFileSync(filePath, "utf8");
     const lines = raw.split("\n").filter((l) => l.trim().length > 0);
     const out = [];
     for (const line of lines) {
@@ -2306,15 +2488,16 @@ function parseTimestamp(raw) {
   }
   return null;
 }
-var import_events, fs, path, MetricsStore;
+var import_events, fs2, path2, MetricsStore;
 var init_store = __esm({
   "src/dashboard/store.ts"() {
     "use strict";
     init_cjs_shims();
     import_events = require("events");
-    fs = __toESM(require("fs"));
-    path = __toESM(require("path"));
+    fs2 = __toESM(require("fs"));
+    path2 = __toESM(require("path"));
     init_logger();
+    init_version();
     MetricsStore = class extends import_events.EventEmitter {
       maxCalls;
       calls = [];
@@ -2597,15 +2780,15 @@ var init_store = __esm({
       persistDeletedIds() {
         if (this.deletedIdsPath === null) return;
         try {
-          const dir = path.dirname(this.deletedIdsPath);
-          fs.mkdirSync(dir, { recursive: true });
+          const dir = path2.dirname(this.deletedIdsPath);
+          fs2.mkdirSync(dir, { recursive: true });
           const tmp = this.deletedIdsPath + ".tmp";
           const payload = {
             version: 1,
             deleted_call_ids: Array.from(this.deletedCallIds).sort()
           };
-          fs.writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf8");
-          fs.renameSync(tmp, this.deletedIdsPath);
+          fs2.writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf8");
+          fs2.renameSync(tmp, this.deletedIdsPath);
         } catch (err) {
           getLogger().debug(
             `MetricsStore.persistDeletedIds: ${String(err)}`
@@ -2638,7 +2821,8 @@ var init_store = __esm({
             avg_duration: 0,
             avg_latency_ms: 0,
             cost_breakdown: { stt: 0, tts: 0, llm: 0, telephony: 0 },
-            active_calls: this.activeCalls.size
+            active_calls: this.activeCalls.size,
+            sdk_version: sdkVersion()
           };
         }
         let totalCost = 0;
@@ -2677,7 +2861,8 @@ var init_store = __esm({
             llm: Math.round(costLlm * 1e6) / 1e6,
             telephony: Math.round(costTel * 1e6) / 1e6
           },
-          active_calls: this.activeCalls.size
+          active_calls: this.activeCalls.size,
+          sdk_version: sdkVersion()
         };
       }
       /**
@@ -2713,11 +2898,11 @@ var init_store = __esm({
        */
       hydrate(logRoot) {
         if (!logRoot) return 0;
-        const deletedIdsPath = path.join(logRoot, ".deleted_call_ids.json");
+        const deletedIdsPath = path2.join(logRoot, ".deleted_call_ids.json");
         this.deletedIdsPath = deletedIdsPath;
-        if (fs.existsSync(deletedIdsPath)) {
+        if (fs2.existsSync(deletedIdsPath)) {
           try {
-            const raw = fs.readFileSync(deletedIdsPath, "utf8");
+            const raw = fs2.readFileSync(deletedIdsPath, "utf8");
             const payload = JSON.parse(raw);
             const arr = Array.isArray(payload.deleted_call_ids) ? payload.deleted_call_ids : [];
             for (const cid of arr) {
@@ -2731,19 +2916,19 @@ var init_store = __esm({
             );
           }
         }
-        const callsRoot = path.join(logRoot, "calls");
-        if (!fs.existsSync(callsRoot)) return 0;
+        const callsRoot = path2.join(logRoot, "calls");
+        if (!fs2.existsSync(callsRoot)) return 0;
         const collected = [];
         const seen = new Set(this.calls.map((c) => c.call_id));
         const walk = (dir, depth) => {
           let entries;
           try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
+            entries = fs2.readdirSync(dir, { withFileTypes: true });
           } catch {
             return;
           }
           for (const entry of entries) {
-            const childPath = path.join(dir, entry.name);
+            const childPath = path2.join(dir, entry.name);
             if (depth < 3) {
               if (entry.isDirectory() && /^\d+$/.test(entry.name)) {
                 walk(childPath, depth + 1);
@@ -2751,10 +2936,10 @@ var init_store = __esm({
               continue;
             }
             if (!entry.isDirectory()) continue;
-            const metadataPath = path.join(childPath, "metadata.json");
-            if (!fs.existsSync(metadataPath)) continue;
+            const metadataPath = path2.join(childPath, "metadata.json");
+            if (!fs2.existsSync(metadataPath)) continue;
             try {
-              const raw = fs.readFileSync(metadataPath, "utf8");
+              const raw = fs2.readFileSync(metadataPath, "utf8");
               const meta2 = JSON.parse(raw);
               const callId = meta2.call_id || entry.name;
               if (!callId || seen.has(callId)) continue;
@@ -2767,7 +2952,7 @@ var init_store = __esm({
               }
               if (!record2.transcript || record2.transcript.length === 0) {
                 const fromJsonl = loadTranscriptJsonl(
-                  path.join(childPath, "transcript.jsonl")
+                  path2.join(childPath, "transcript.jsonl")
                 );
                 if (fromJsonl.length > 0) record2.transcript = fromJsonl;
               }
@@ -2905,9 +3090,9 @@ function loadDashboardHtml() {
     (0, import_node_path.join)(here, "dashboard", "ui.html"),
     (0, import_node_path.join)(here, "..", "dashboard", "ui.html")
   ];
-  for (const path5 of candidates) {
+  for (const path6 of candidates) {
     try {
-      return (0, import_node_fs.readFileSync)(path5, "utf8");
+      return (0, import_node_fs.readFileSync)(path6, "utf8");
     } catch {
     }
   }
@@ -3298,10 +3483,10 @@ var init_remote_message = __esm({
           }
         });
         try {
-          await new Promise((resolve, reject) => {
+          await new Promise((resolve2, reject) => {
             ws.on("open", () => {
               ws.send(JSON.stringify(data));
-              resolve();
+              resolve2();
             });
             ws.on("error", (err) => {
               reject(err);
@@ -3311,11 +3496,11 @@ var init_remote_message = __esm({
             yield chunks.shift();
           }
           while (!done && !error2) {
-            const text = await new Promise((resolve) => {
+            const text = await new Promise((resolve2) => {
               if (chunks.length > 0) {
-                resolve(chunks.shift());
+                resolve2(chunks.shift());
               } else {
-                resolveNext = resolve;
+                resolveNext = resolve2;
               }
             });
             if (text === null) break;
@@ -3461,7 +3646,7 @@ var init_deepgram_stt = __esm({
         const url2 = `${DEEPGRAM_WS_URL}?${params.toString()}`;
         let ws = null;
         try {
-          ws = await new Promise((resolve, reject) => {
+          ws = await new Promise((resolve2, reject) => {
             const sock = new import_ws4.default(url2, {
               headers: { Authorization: `Token ${this.apiKey}` }
             });
@@ -3474,7 +3659,7 @@ var init_deepgram_stt = __esm({
             }, 5e3);
             sock.once("open", () => {
               clearTimeout(timer);
-              resolve(sock);
+              resolve2(sock);
             });
             sock.once("error", (err) => {
               clearTimeout(timer);
@@ -3505,7 +3690,7 @@ var init_deepgram_stt = __esm({
           headers: { Authorization: `Token ${this.apiKey}` }
         });
         this.ws = ws;
-        await new Promise((resolve, reject) => {
+        await new Promise((resolve2, reject) => {
           let settled = false;
           const settle = (fn) => {
             if (settled) return;
@@ -3517,7 +3702,7 @@ var init_deepgram_stt = __esm({
             () => settle(() => reject(new PatterConnectionError("Deepgram connect timeout"))),
             1e4
           );
-          ws.once("open", () => settle(resolve));
+          ws.once("open", () => settle(resolve2));
           ws.once("error", (err) => settle(() => reject(err)));
           ws.once("unexpected-response", (_req, res) => {
             const status = res?.statusCode ?? 0;
@@ -3817,6 +4002,21 @@ var init_metrics = __esm({
       _bargeinStoppedAt = null;
       _turnUserText = "";
       _turnSttAudioSeconds = 0;
+      /**
+       * Guard against the recordTurnInterrupted / recordTurnComplete race.
+       *
+       * A VAD-path barge-in fires ``recordTurnInterrupted`` synchronously
+       * inside ``handleAudioAsync`` while the in-flight pipeline LLM stream
+       * keeps unwinding on its own task. When the LLM stream eventually
+       * exits, the existing pipeline path falls through to
+       * ``recordTurnComplete``, which would push a second turn for the same
+       * logical exchange (this time carrying ``user_text=''`` because the
+       * field was already reset). ``_turnAlreadyClosed`` is flipped by
+       * ``recordTurnInterrupted`` and read by ``recordTurnComplete`` so the
+       * late ``recordTurnComplete`` becomes a no-op until the next
+       * ``startTurn`` re-arms the accumulator.
+       */
+      _turnAlreadyClosed = false;
       // Cumulative usage counters
       _totalSttAudioSeconds = 0;
       _totalTtsCharacters = 0;
@@ -3914,6 +4114,7 @@ var init_metrics = __esm({
         this._bargeinStoppedAt = null;
         this._turnUserText = "";
         this._turnSttAudioSeconds = 0;
+        this._turnAlreadyClosed = false;
         this._vadStoppedAt = null;
         this._sttFinalAt = null;
         this._turnCommittedAt = null;
@@ -4070,8 +4271,18 @@ var init_metrics = __esm({
       recordTtsStopped(ts) {
         this._bargeinStoppedAt = ts ?? hrTimeMs();
       }
-      /** Close the current turn cleanly and append a `TurnMetrics` record. */
+      /**
+       * Close the current turn cleanly and append a `TurnMetrics` record.
+       *
+       * Returns ``null`` when ``recordTurnInterrupted`` has already closed
+       * the current turn — this protects against the VAD-barge-in /
+       * pipeline-LLM race where both paths try to finalise the same logical
+       * turn and the second would otherwise push a phantom entry with
+       * ``user_text=''``. The caller treats ``null`` as "nothing to emit";
+       * ``emitTurnMetrics`` is already null-safe.
+       */
       recordTurnComplete(agentText) {
+        if (this._turnAlreadyClosed) return null;
         const latency = this._computeTurnLatency();
         const turn = {
           turn_index: this._turns.length,
@@ -4084,13 +4295,23 @@ var init_metrics = __esm({
         };
         this._turns.push(turn);
         this._resetTurnState();
+        this._turnAlreadyClosed = true;
         this._eventBus?.emit("turn_ended", { callId: this.callId, turn });
         this._eventBus?.emit("metrics_collected", { callId: this.callId, turn });
         return turn;
       }
-      /** Close the current turn as interrupted (barge-in) and return the recorded metrics. */
+      /**
+       * Close the current turn as interrupted (barge-in) and return the
+       * recorded metrics. Returns ``null`` when no turn is open, OR when
+       * ``recordTurnComplete`` has already finalised the current turn —
+       * bidirectional parity with the guard at the top of
+       * ``recordTurnComplete``. Prevents an out-of-order interruption (e.g.
+       * a future refactor that reorders the bargein + LLM-unwind paths)
+       * from overwriting a turn that the complete path already emitted.
+       */
       recordTurnInterrupted() {
         if (this._turnStart === null) return null;
+        if (this._turnAlreadyClosed) return null;
         const latency = this._computeTurnLatency();
         const turn = {
           turn_index: this._turns.length,
@@ -4105,6 +4326,7 @@ var init_metrics = __esm({
         this._eventBus?.emit("turn_ended", { callId: this.callId, turn });
         this._eventBus?.emit("metrics_collected", { callId: this.callId, turn });
         this._resetTurnState();
+        this._turnAlreadyClosed = true;
         this._turnCommittedMono = null;
         this._endpointSignalAt = null;
         return turn;
@@ -5615,10 +5837,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path6) {
+  if (!path6)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path6.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -5946,11 +6168,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path6, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path6);
     return iss;
   });
 }
@@ -6169,16 +6391,16 @@ function flattenError(error2, mapper = (issue2) => issue2.message) {
 }
 function formatError(error2, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error3, path5 = []) => {
+  const processError = (error3, path6 = []) => {
     for (const issue2 of error3.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path6, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path6, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path6, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -13684,7 +13906,7 @@ var init_protocol = __esm({
               return;
             }
             const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
             options?.signal?.throwIfAborted();
           }
         } catch (error2) {
@@ -13701,7 +13923,7 @@ var init_protocol = __esm({
        */
       request(request, resultSchema, options) {
         const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           const earlyReject = (error2) => {
             reject(error2);
           };
@@ -13779,7 +14001,7 @@ var init_protocol = __esm({
               if (!parseResult.success) {
                 reject(parseResult.error);
               } else {
-                resolve(parseResult.data);
+                resolve2(parseResult.data);
               }
             } catch (error2) {
               reject(error2);
@@ -14040,12 +14262,12 @@ var init_protocol = __esm({
           }
         } catch {
         }
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           if (signal.aborted) {
             reject(new McpError(ErrorCode2.InvalidRequest, "Request cancelled"));
             return;
           }
-          const timeoutId = setTimeout(resolve, interval);
+          const timeoutId = setTimeout(resolve2, interval);
           signal.addEventListener("abort", () => {
             clearTimeout(timeoutId);
             reject(new McpError(ErrorCode2.InvalidRequest, "Request cancelled"));
@@ -17093,7 +17315,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve.call(this, root, ref);
+      let _sch = resolve2.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -17120,7 +17342,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve(root, ref) {
+    function resolve2(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -17339,8 +17561,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path5) {
-      let input = path5;
+    function removeDotSegments(path6) {
+      let input = path6;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -17593,8 +17815,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path5, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path5 && path5 !== "/" ? path5 : void 0;
+        const [path6, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path6 && path6 !== "/" ? path6 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -17754,7 +17976,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve(baseURI, relativeURI, options) {
+    function resolve2(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -18012,7 +18234,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve,
+      resolve: resolve2,
       resolveComponent,
       equal,
       serialize,
@@ -21033,12 +21255,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs5, exportName) {
+    function addFormats(ajv, list, fs6, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs5[f]);
+        ajv.addFormat(f, fs6[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -24732,7 +24954,7 @@ var require_tensor_factory_impl = __commonJS({
           throw new Error("Can not access image data");
         }
       } else if (isString) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           const canvas = createCanvas();
           const context = createCanvasContext(canvas);
           if (!image || !context) {
@@ -24748,7 +24970,7 @@ var require_tensor_factory_impl = __commonJS({
             const img = context.getImageData(0, 0, canvas.width, canvas.height);
             bufferToTensorOptions.height = canvas.height;
             bufferToTensorOptions.width = canvas.width;
-            resolve((0, exports2.bufferToTensor)(img.data, bufferToTensorOptions));
+            resolve2((0, exports2.bufferToTensor)(img.data, bufferToTensorOptions));
           };
         });
       } else {
@@ -25776,10 +25998,10 @@ var require_backend2 = __commonJS({
       endProfiling() {
       }
       async run(feeds, fetches, options) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           setImmediate(() => {
             try {
-              resolve(__classPrivateFieldGet(this, _OnnxruntimeSessionHandler_inferenceSession, "f").run(feeds, fetches, options));
+              resolve2(__classPrivateFieldGet(this, _OnnxruntimeSessionHandler_inferenceSession, "f").run(feeds, fetches, options));
             } catch (e) {
               reject(e);
             }
@@ -25793,10 +26015,10 @@ var require_backend2 = __commonJS({
         return Promise.resolve();
       }
       async createInferenceSessionHandler(pathOrBuffer, options) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           setImmediate(() => {
             try {
-              resolve(new OnnxruntimeSessionHandler(pathOrBuffer, options || {}));
+              resolve2(new OnnxruntimeSessionHandler(pathOrBuffer, options || {}));
             } catch (e) {
               reject(e);
             }
@@ -25873,20 +26095,20 @@ function resolveModuleDirs() {
   }
   try {
     const url2 = importMetaUrl;
-    if (url2) candidates.push(path2.dirname((0, import_node_url.fileURLToPath)(url2)));
+    if (url2) candidates.push(path3.dirname((0, import_node_url.fileURLToPath)(url2)));
   } catch {
   }
   try {
     const url2 = importMetaUrl;
     if (url2) {
       const req = (0, import_node_module.createRequire)(url2);
-      candidates.push(path2.dirname(req.resolve("getpatter/package.json")));
+      candidates.push(path3.dirname(req.resolve("getpatter/package.json")));
     }
   } catch {
   }
   try {
-    const req = (0, import_node_module.createRequire)(path2.join(process.cwd(), "package.json"));
-    candidates.push(path2.dirname(req.resolve("getpatter/package.json")));
+    const req = (0, import_node_module.createRequire)(path3.join(process.cwd(), "package.json"));
+    candidates.push(path3.dirname(req.resolve("getpatter/package.json")));
   } catch {
   }
   candidates.push(process.cwd());
@@ -25895,13 +26117,13 @@ function resolveModuleDirs() {
 function resolveDefaultModelPath() {
   for (const dir of MODULE_DIRS) {
     const candidates = [
-      path2.join(dir, "resources", "silero_vad.onnx"),
-      path2.join(dir, "..", "resources", "silero_vad.onnx"),
-      path2.join(dir, "dist", "resources", "silero_vad.onnx")
+      path3.join(dir, "resources", "silero_vad.onnx"),
+      path3.join(dir, "..", "resources", "silero_vad.onnx"),
+      path3.join(dir, "dist", "resources", "silero_vad.onnx")
     ];
-    for (const c of candidates) if (fs2.existsSync(c)) return c;
+    for (const c of candidates) if (fs3.existsSync(c)) return c;
   }
-  return path2.join(MODULE_DIRS[0] ?? process.cwd(), "resources", "silero_vad.onnx");
+  return path3.join(MODULE_DIRS[0] ?? process.cwd(), "resources", "silero_vad.onnx");
 }
 function classifyOnnxError(err) {
   const msg = err?.message ?? String(err);
@@ -25919,7 +26141,7 @@ async function loadOnnxRuntime() {
     firstErr = e;
   }
   try {
-    const req = (0, import_node_module.createRequire)(path2.join(process.cwd(), "package.json"));
+    const req = (0, import_node_module.createRequire)(path3.join(process.cwd(), "package.json"));
     return req("onnxruntime-node");
   } catch (secondErr) {
     const importClass = classifyOnnxError(firstErr);
@@ -25955,14 +26177,14 @@ ${remedy}
     throw err;
   }
 }
-var import_node_module, fs2, path2, import_node_url, SUPPORTED_SAMPLE_RATES, MODULE_DIRS, DEFAULT_MODEL_PATH, ExpFilter, OnnxModel, SileroVAD;
+var import_node_module, fs3, path3, import_node_url, SUPPORTED_SAMPLE_RATES, MODULE_DIRS, DEFAULT_MODEL_PATH, ExpFilter, OnnxModel, SileroVAD;
 var init_silero_vad = __esm({
   "src/providers/silero-vad.ts"() {
     "use strict";
     init_cjs_shims();
     import_node_module = require("module");
-    fs2 = __toESM(require("fs"));
-    path2 = __toESM(require("path"));
+    fs3 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
     import_node_url = require("url");
     SUPPORTED_SAMPLE_RATES = [8e3, 16e3];
     MODULE_DIRS = resolveModuleDirs();
@@ -26127,6 +26349,19 @@ var init_silero_vad = __esm({
       static forPhoneCall(options = {}) {
         return _SileroVAD.load({
           sampleRate: 16e3,
+          // Telephony bumps the activation threshold from the upstream
+          // 0.5 → 0.8 (with deactivation 0.65) so background voices and
+          // low-volume audio in the caller's room don't trip barge-in.
+          // Near-mic speech typically scores 0.85-0.98 on Silero — above
+          // 0.8 — while a distant second speaker through a phone's noise-
+          // suppression pipeline lands around 0.4-0.6 and is now correctly
+          // ignored. Bumped twice during 2026-05-20 acceptance: first 0.5
+          // → 0.7 (still triggered on quiet voices), then 0.7 → 0.8.
+          // Trade-off: a whispered legitimate input may not trigger;
+          // typical phone-call speakers are unaffected. Pass an explicit
+          // ``activationThreshold`` to override per call site.
+          activationThreshold: 0.8,
+          deactivationThreshold: 0.65,
           ...options
         });
       }
@@ -26587,7 +26822,23 @@ var init_stream_handler = __esm({
       ".",
       "bye",
       "right",
-      "cool"
+      "cool",
+      // Whisper YouTube-caption hallucinations
+      "thank you for watching",
+      "thanks for watching",
+      "thank you for watching!",
+      "thanks for watching!",
+      "thank you so much for watching",
+      "thanks for listening",
+      "please subscribe",
+      "subscribe",
+      "music",
+      "[music]",
+      "\u266A",
+      "[no audio]",
+      "[silence]",
+      "[blank_audio]",
+      "(silence)"
     ]);
     StreamHandler = class _StreamHandler {
       deps;
@@ -26713,13 +26964,17 @@ var init_stream_handler = __esm({
        * Same as the AEC variant but for deployments where AEC is OFF
        * (default on PSTN — Twilio/Telnyx). Without an adaptive filter to
        * converge, the only justification for a gate is anti-flicker on
-       * micro-events (cough, click). 100 ms covers the first PSTN echo
-       * round-trip (~40-100 ms) while allowing barge-in from 100 ms into
-       * the agent's turn — covering nearly all of any response.
-       * Previously 250 ms, which blocked barge-in entirely on short (<500 ms)
-       * agent responses.
-       */
-      static MIN_AGENT_SPEAKING_MS_BEFORE_BARGE_IN_NO_AEC = 100;
+       * micro-events (cough, click). Raised 100 → 500 ms on 2026-05-19
+       * after the 0.6.2 acceptance run showed a phantom VAD speech_start
+       * firing on the very first inbound frame (~500 ms into the call,
+       * which is past a 100 ms gate). The phantom barge-in cancelled the
+       * prewarmed firstMessage, the user heard a clipped (graffiante)
+       * audio fragment, and the SDK left ``_turnAlreadyClosed=true`` so
+       * subsequent ``recordTurnComplete`` calls were no-ops. 500 ms
+       * filters those phantoms while still letting a real interruption
+       * land within half a second of agent onset.
+       */
+      static MIN_AGENT_SPEAKING_MS_BEFORE_BARGE_IN_NO_AEC = 500;
       /** Handle for the pending grace-period timer, so it can be cleared on cleanup. */
       graceTimer = null;
       /**
@@ -26759,30 +27014,12 @@ var init_stream_handler = __esm({
        * coexist without name collisions even when firstMessage finishes while
        * a Realtime turn is still streaming.
        */
-      firstMessageMarkCounter = 0;
-      /**
-       * Maximum unconfirmed Twilio marks while streaming firstMessage. Each
-       * chunk is 40 ms of audio at 16 kHz PCM16, so a window of 3 caps
-       * the in-flight queue at ~120 ms. This means a barge-in's
-       * ``sendClear`` has at most 120 ms of already-buffered audio to flush
-       * — vs. ~2-5 s with the previous burst-send code, which was the
-       * root cause of "firstMessage non interrompibile". Higher values
-       * smooth playback under jittery RTT (each mark echo adds ~150-250 ms
-       * RTT on PSTN) at the cost of longer barge-in latency; lower values
-       * risk under-buffering. 3 hit the smallest barge-in cap without
-       * audible gaps in 2026-05 acceptance.
-       */
-      static FIRST_MESSAGE_MARK_WINDOW = 3;
-      /**
-       * Per-chunk soft timeout (ms) while awaiting a mark echo. Twilio's
-       * mark echoes typically arrive within 100-250 ms of audio playback.
-       * Capping at 500 ms guards against carriers (or test doubles) that
-       * never echo — without it a stalled echo would deadlock the loop and
-       * the agent would freeze mid-utterance. On timeout we drop the
-       * waiter from the queue and continue: playout may glitch by one
-       * chunk but the call stays alive.
-       */
-      static MARK_AWAIT_TIMEOUT_MS = 500;
+      // firstMessageMarkCounter / FIRST_MESSAGE_MARK_WINDOW /
+      // MARK_AWAIT_TIMEOUT_MS were retired with the move to the Twilio-FIFO-
+      // trusts model (sendPacedFirstMessageBytes no longer emits marks).
+      // Marks are still consumed via ``onMark`` for any adapter that wants
+      // to round-trip one, but the firstMessage path no longer back-pressures
+      // on them.
       /**
        * Minimum drain window (ms) between a ``cancelSpeaking`` and the next
        * ``beginSpeaking``. 150 ms covers a typical PSTN jitter buffer drain
@@ -26847,6 +27084,14 @@ var init_stream_handler = __esm({
           } catch {
           }
         }
+        const ttsCancelable = this.tts;
+        if (typeof ttsCancelable?.cancelActiveStream === "function") {
+          try {
+            ttsCancelable.cancelActiveStream();
+          } catch (err) {
+            getLogger().debug(`TTS cancelActiveStream raised: ${String(err)}`);
+          }
+        }
       }
       /**
        * Resolve every entry in ``pendingMarks`` and empty the queue. Idempotent
@@ -26863,56 +27108,19 @@ var init_stream_handler = __esm({
         }
         this.pendingMarks.length = 0;
       }
+      // Mark-based back-pressure (sendMarkAwaitable / waitForMarkWindow)
+      // was removed when sendPacedFirstMessageBytes switched to the
+      // Twilio-FIFO-trusts model — see that method's doc comment for
+      // rationale. ``pendingMarks`` and ``onMark`` are still kept so an
+      // adapter that wants to round-trip a mark for some other purpose can
+      // still do so without breaking the firstMessage path.
       /**
-       * Push a Twilio ``mark`` event AFTER the corresponding audio chunk and
-       * return a promise that resolves when the mark is echoed back via
-       * ``onMark`` (or when ``cancelSpeaking`` drains the queue, or after
-       * ``MARK_AWAIT_TIMEOUT_MS``). Returns null on non-Twilio carriers — the
-       * caller is expected to fall back to time-based pacing in that case.
-       */
-      sendMarkAwaitable() {
-        if (this.deps.bridge.telephonyProvider !== "twilio") return null;
-        this.firstMessageMarkCounter += 1;
-        const markName = `fm_${this.firstMessageMarkCounter}`;
-        let resolve;
-        const promise = new Promise((r) => {
-          resolve = r;
-        });
-        this.pendingMarks.push({ name: markName, resolve, promise });
-        try {
-          this.deps.bridge.sendMark(this.ws, markName, this.streamSid);
-        } catch (err) {
-          getLogger().debug(`sendMark failed (${markName}): ${String(err)}`);
-          const idx = this.pendingMarks.findIndex((m) => m.name === markName);
-          if (idx >= 0) this.pendingMarks.splice(idx, 1);
-          return Promise.resolve();
-        }
-        return promise;
-      }
-      /**
-       * If the in-flight mark queue is at or above ``FIRST_MESSAGE_MARK_WINDOW``
-       * entries, wait for the oldest entry to clear (mark echoed, agent
-       * cancelled, or per-mark timeout). Repeats until the queue depth is
-       * within the window — under high RTT the carrier may have several
-       * marks queued and we want every loop iteration to be naturally back-
-       * pressured by playback.
-       */
-      async waitForMarkWindow() {
-        while (this.isSpeaking && this.pendingMarks.length >= _StreamHandler.FIRST_MESSAGE_MARK_WINDOW) {
-          const oldest = this.pendingMarks[0];
-          const timeout = new Promise(
-            (resolve) => setTimeout(resolve, _StreamHandler.MARK_AWAIT_TIMEOUT_MS)
-          );
-          await Promise.race([oldest.promise, timeout]);
-          if (this.pendingMarks[0] === oldest) {
-            this.pendingMarks.shift();
-          }
-        }
-      }
-      /**
-       * Bytes-per-millisecond for a 16 kHz PCM16 mono stream. Used by the
-       * non-Twilio firstMessage pacing path to translate chunk size into a
-       * playout-duration sleep. 16000 samples/sec × 2 bytes = 32 bytes/ms.
+       * Bytes-per-millisecond for a 16 kHz PCM16 mono stream. Used by
+       * ``sendPacedFirstMessageBytes`` to translate chunk size into a
+       * playout-duration sleep so we never deliver faster than the carrier
+       * can decode + play out (which manifested as severe crackling on the
+       * HTTP-TTS path with client-side resampling). 16000 samples/sec × 2
+       * bytes/sample = 32 bytes/ms.
        */
       static PCM16_16K_BYTES_PER_MS = 32;
       /** Cancel and clear the pending grace timer, if any. */
@@ -27350,7 +27558,7 @@ var init_stream_handler = __esm({
           if (activeVad && !this.vadDisabled) {
             try {
               const vadPromise = activeVad.processFrame(pcm16k, 16e3);
-              const timeoutPromise = new Promise((resolve) => setTimeout(() => resolve(null), 25));
+              const timeoutPromise = new Promise((resolve2) => setTimeout(() => resolve2(null), 25));
               const evt = await Promise.race([vadPromise, timeoutPromise]);
               if (evt) {
                 getLogger().info(
@@ -27486,9 +27694,21 @@ var init_stream_handler = __esm({
       /** Handle call stop / stream end. */
       /** Handle a carrier-emitted `stop` event signalling the call has ended. */
       async handleStop() {
+        if (this.llmAbort !== null) {
+          try {
+            this.llmAbort.abort();
+          } catch {
+          }
+        }
+        const ttsCancelable = this.tts;
+        if (typeof ttsCancelable?.cancelActiveStream === "function") {
+          try {
+            ttsCancelable.cancelActiveStream();
+          } catch {
+          }
+        }
         this.clearPendingBargeIn();
         this.drainPendingMarks();
-        this.firstMessageMarkCounter = 0;
         this.clearGraceTimer();
         this.flushResamplers();
         await this.closeSttOnce();
@@ -27501,9 +27721,21 @@ var init_stream_handler = __esm({
       /** Handle WebSocket close event. */
       /** Tear down adapter, STT/TTS, and per-call state when the carrier WebSocket closes. */
       async handleWsClose() {
+        if (this.llmAbort !== null) {
+          try {
+            this.llmAbort.abort();
+          } catch {
+          }
+        }
+        const ttsCancelable = this.tts;
+        if (typeof ttsCancelable?.cancelActiveStream === "function") {
+          try {
+            ttsCancelable.cancelActiveStream();
+          } catch {
+          }
+        }
         this.clearPendingBargeIn();
         this.drainPendingMarks();
-        this.firstMessageMarkCounter = 0;
         this.clearGraceTimer();
         this.flushResamplers();
         await this.closeSttOnce();
@@ -27542,13 +27774,39 @@ var init_stream_handler = __esm({
        * Maintains a 1-byte carry across calls so unaligned HTTP chunks from
        * streaming TTS providers never byte-swap the PCM16 samples downstream.
        */
-      encodePipelineAudio(pcm16k) {
-        const aligned = this.alignPcm16(pcm16k);
+      encodePipelineAudio(audioChunk) {
+        if (this.ttsOutputFormatNativeForCarrier === true) {
+          return audioChunk.toString("base64");
+        }
+        const aligned = this.alignPcm16(audioChunk);
         if (aligned.length === 0) return "";
         const pcm8k = this.outboundResampler.process(aligned);
         const mulaw = pcm16ToMulaw(pcm8k);
         return mulaw.toString("base64");
       }
+      /**
+       * Cached result of ``isTtsOutputFormatNativeForCarrier()`` — settled
+       * once at ``initPipeline`` time after ``setTelephonyCarrier`` has run
+       * on the TTS adapter. Stable for the call lifetime: changes to the
+       * adapter's output format mid-call would NOT flip this. ``true`` means
+       * ``encodePipelineAudio`` can take the bypass path.
+       */
+      ttsOutputFormatNativeForCarrier = false;
+      /**
+       * Probe whether the TTS adapter is configured to emit bytes already in
+       * the carrier's wire codec. Currently: Twilio expects ``ulaw_8000``,
+       * Telnyx expects ``pcm_16000`` (no client transcode in either case if
+       * matched). Anything else takes the resample-and-encode path.
+       */
+      isTtsOutputFormatNativeForCarrier() {
+        if (!this.tts) return false;
+        const fmt = this.tts.outputFormat;
+        if (typeof fmt !== "string") return false;
+        const carrier = this.deps.bridge.telephonyProvider;
+        if (carrier === "twilio") return fmt === "ulaw_8000";
+        if (carrier === "telnyx") return fmt === "pcm_16000";
+        return false;
+      }
       /**
        * Prepend any carry byte from the previous chunk, return the even-length
        * portion, and stash the final odd byte (if any) for the next call.
@@ -27559,17 +27817,11 @@ var init_stream_handler = __esm({
         this.ttsByteCarry = alignedLen < combined.length ? combined.subarray(alignedLen) : null;
         return combined.subarray(0, alignedLen);
       }
-      /**
-       * 40 ms @ 16 kHz mono PCM16 = 1280 bytes. Sized to mirror the smallest
-       * live-TTS chunk boundary so cancel granularity (mark/clear bookkeeping)
-       * is identical regardless of whether the firstMessage came from the
-       * prewarm cache or a live ``tts.synthesizeStream`` stream.
-       */
-      static PREWARM_CHUNK_BYTES = 1280;
       /**
        * Stream a cached firstMessage buffer in pacing-friendly chunks.
        *
-       * Splits ``prewarmBytes`` into ``PREWARM_CHUNK_BYTES`` slices and
+       * Splits ``prewarmBytes`` into 20 ms slices (matching Twilio's PSTN
+       * frame quantum) and
        * forwards each through ``deps.bridge.sendAudio`` exactly like the
        * live TTS path does — preserving Twilio mark/clear granularity. A
        * single multi-second sendAudio call would push the whole intro into
@@ -27585,7 +27837,7 @@ var init_stream_handler = __esm({
         return this.sendPacedFirstMessageBytes(prewarmBytes);
       }
       /**
-       * Iterate ``bytes`` as ``PREWARM_CHUNK_BYTES``-sized PCM16 slices and
+       * Iterate ``bytes`` in 20 ms slices (Twilio PSTN frame quantum) and
        * forward each via ``deps.bridge.sendAudio`` with mark-gated pacing
        * (Twilio) or playout-time-based pacing (Telnyx). Caps the carrier-
        * side buffer at ``FIRST_MESSAGE_MARK_WINDOW`` chunks so a barge-in's
@@ -27602,30 +27854,20 @@ var init_stream_handler = __esm({
        */
       async sendPacedFirstMessageBytes(bytes) {
         if (this.pendingMarks.length > 0) this.drainPendingMarks();
-        this.firstMessageMarkCounter = 0;
         let firstChunkSent = false;
-        let initialFillComplete = false;
-        for (let i = 0; i < bytes.length; i += _StreamHandler.PREWARM_CHUNK_BYTES) {
+        const PSTN_FRAME_MS = 20;
+        const bytesPerMs = this.ttsOutputFormatNativeForCarrier ? 8 : _StreamHandler.PCM16_16K_BYTES_PER_MS;
+        const sliceBytes = bytesPerMs * PSTN_FRAME_MS;
+        for (let i = 0; i < bytes.length; i += sliceBytes) {
           if (!this.isSpeaking) break;
-          await this.waitForMarkWindow();
-          if (!this.isSpeaking) break;
-          const chunk = bytes.subarray(i, i + _StreamHandler.PREWARM_CHUNK_BYTES);
+          const chunk = bytes.subarray(i, i + sliceBytes);
           if (!firstChunkSent) firstChunkSent = true;
-          if (this.aec) this.aec.pushFarEnd(chunk);
+          if (this.aec && !this.ttsOutputFormatNativeForCarrier) {
+            this.aec.pushFarEnd(chunk);
+          }
           const encoded = this.encodePipelineAudio(chunk);
           this.deps.bridge.sendAudio(this.ws, encoded, this.streamSid);
           this.markFirstAudioSent();
-          const markPromise = this.sendMarkAwaitable();
-          if (!initialFillComplete && this.pendingMarks.length >= _StreamHandler.FIRST_MESSAGE_MARK_WINDOW) {
-            initialFillComplete = true;
-          }
-          if (markPromise === null || initialFillComplete) {
-            const playoutMs = Math.max(
-              1,
-              Math.floor(chunk.length / _StreamHandler.PCM16_16K_BYTES_PER_MS)
-            );
-            await new Promise((resolve) => setTimeout(resolve, playoutMs));
-          }
         }
         return firstChunkSent;
       }
@@ -27645,6 +27887,12 @@ var init_stream_handler = __esm({
               getLogger().debug(`TTS setTelephonyCarrier failed (${label}): ${String(e)}`);
             }
           }
+          this.ttsOutputFormatNativeForCarrier = this.isTtsOutputFormatNativeForCarrier();
+          if (this.ttsOutputFormatNativeForCarrier) {
+            getLogger().debug(
+              `TTS outputFormat matches ${this.deps.bridge.telephonyProvider} wire codec \u2014 bypassing client-side transcode`
+            );
+          }
         }
         if (!this.stt) {
           getLogger().debug(`Pipeline mode (${label}): no STT configured`);
@@ -28347,16 +28595,49 @@ var init_stream_handler = __esm({
       async initRealtimeAdapter(resolvedPrompt) {
         const label = this.deps.bridge.label;
         this.adapter = this.deps.buildAIAdapter(resolvedPrompt);
-        try {
-          await this.adapter.connect();
-          getLogger().debug(`AI adapter connected (${label})`);
-        } catch (e) {
-          getLogger().error(`AI adapter connect FAILED (${label}):`, e);
+        let parked;
+        if (typeof this.deps.popPrewarmedConnections === "function") {
           try {
-            await this.deps.bridge.endCall(this.callId, this.ws);
-          } catch {
+            parked = this.deps.popPrewarmedConnections(this.callId);
+          } catch (err) {
+            getLogger().debug(`popPrewarmedConnections raised: ${String(err)}`);
+          }
+        }
+        const parkedRealtimeWs = parked?.openaiRealtime;
+        let adoptOk = false;
+        if (parkedRealtimeWs !== void 0) {
+          const adapterAny = this.adapter;
+          const wsAlive = parkedRealtimeWs.readyState === 1;
+          if (typeof adapterAny?.adoptWebSocket === "function" && wsAlive) {
+            try {
+              adapterAny.adoptWebSocket(parkedRealtimeWs);
+              getLogger().info(
+                `[CONNECT] callId=${this.callId} provider=openai_realtime source=adopted ms=0`
+              );
+              adoptOk = true;
+            } catch (err) {
+              getLogger().debug(`Realtime adoptWebSocket failed: ${String(err)}; falling back`);
+            }
+          }
+          if (!adoptOk) {
+            try {
+              parkedRealtimeWs.close();
+            } catch {
+            }
+          }
+        }
+        if (!adoptOk) {
+          try {
+            await this.adapter.connect();
+            getLogger().debug(`AI adapter connected (${label})`);
+          } catch (e) {
+            getLogger().error(`AI adapter connect FAILED (${label}):`, e);
+            try {
+              await this.deps.bridge.endCall(this.callId, this.ws);
+            } catch {
+            }
+            return;
           }
-          return;
         }
         if (this.deps.agent.firstMessage) {
           this.metricsAcc.startTurn();
@@ -28476,8 +28757,21 @@ var init_stream_handler = __esm({
         await this.emitUserSpeechEnded();
       }
       async onAdapterTranscriptInput(inputText) {
+        const stripped = inputText.trim().toLowerCase();
+        if (HALLUCINATIONS.has(stripped) || stripped === "") {
+          getLogger().debug(
+            `Realtime transcript_input dropped (likely Whisper hallucination on silence/echo): ${sanitizeLogValue(inputText.slice(0, 60))}`
+          );
+          this.userTranscriptPending = false;
+          return;
+        }
         getLogger().debug(`User (${this.deps.bridge.label}): ${sanitizeLogValue(inputText)}`);
         this.history.push({ role: "user", text: inputText, timestamp: Date.now() });
+        if (this.adapter instanceof OpenAIRealtimeAdapter) {
+          void this.adapter.requestResponse().catch(
+            (err) => getLogger().debug(`Realtime requestResponse failed: ${String(err)}`)
+          );
+        }
         if (!this.metricsAcc.turnActive) {
           this.metricsAcc.startTurn();
           this.currentAgentText = "";
@@ -28629,6 +28923,18 @@ var init_stream_handler = __esm({
         await this.flushAssistantTurn(text);
       }
       async onAdapterSpeechInterrupt() {
+        if (this.adapter instanceof OpenAIRealtimeAdapter) {
+          const startedAt = this.adapter.currentResponseFirstAudioAt;
+          if (startedAt !== null) {
+            const elapsedMs = Date.now() - startedAt;
+            if (elapsedMs < _StreamHandler.MIN_AGENT_SPEAKING_MS_BEFORE_BARGE_IN_NO_AEC) {
+              getLogger().info(
+                `Realtime barge-in suppressed (response < gate, ${elapsedMs}ms)`
+              );
+              return;
+            }
+          }
+        }
         this.deps.bridge.sendClear(this.ws, this.streamSid);
         if (this.adapter instanceof OpenAIRealtimeAdapter) this.adapter.cancelResponse();
         this.metricsAcc.recordTurnInterrupted();
@@ -28835,24 +29141,24 @@ var init_stream_handler = __esm({
 
 // src/services/call-log.ts
 function xdgDataHome() {
-  return process.env.XDG_DATA_HOME || path3.join(os.homedir(), ".local", "share");
+  return process.env.XDG_DATA_HOME || path4.join(os.homedir(), ".local", "share");
 }
 function platformDefaultRoot() {
   if (process.platform === "darwin") {
-    return path3.join(os.homedir(), "Library", "Application Support", "patter");
+    return path4.join(os.homedir(), "Library", "Application Support", "patter");
   }
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA;
-    if (localAppData) return path3.join(localAppData, "patter");
-    return path3.join(os.homedir(), "AppData", "Local", "patter");
+    if (localAppData) return path4.join(localAppData, "patter");
+    return path4.join(os.homedir(), "AppData", "Local", "patter");
   }
-  return path3.join(xdgDataHome(), "patter");
+  return path4.join(xdgDataHome(), "patter");
 }
 function resolveLogRoot(explicit) {
   const value = explicit ?? process.env.PATTER_LOG_DIR;
   if (!value) return null;
   if (value.trim().toLowerCase() === "auto") return platformDefaultRoot();
-  if (value.startsWith("~")) return path3.join(os.homedir(), value.slice(1));
+  if (value.startsWith("~")) return path4.join(os.homedir(), value.slice(1));
   return value;
 }
 function retentionDays() {
@@ -28863,9 +29169,9 @@ function retentionDays() {
   return Math.max(0, parsed);
 }
 function redactMode() {
-  const raw = (process.env.PATTER_LOG_REDACT_PHONE || "mask").trim().toLowerCase();
+  const raw = (process.env.PATTER_LOG_REDACT_PHONE || "full").trim().toLowerCase();
   if (raw === "full" || raw === "mask" || raw === "hash_only") return raw;
-  return "mask";
+  return "full";
 }
 function redactPhone(raw) {
   if (!raw) return "";
@@ -28881,9 +29187,9 @@ function utcIso(tsSeconds) {
   return new Date(ms).toISOString();
 }
 async function atomicWriteJson(filePath, payload) {
-  const dir = path3.dirname(filePath);
+  const dir = path4.dirname(filePath);
   await import_node_fs2.promises.mkdir(dir, { recursive: true });
-  const tmp = path3.join(dir, `.tmp.${process.pid}.${crypto4.randomBytes(4).toString("hex")}.json`);
+  const tmp = path4.join(dir, `.tmp.${process.pid}.${crypto4.randomBytes(4).toString("hex")}.json`);
   try {
     const handle = await import_node_fs2.promises.open(tmp, "w");
     try {
@@ -28902,37 +29208,37 @@ async function atomicWriteJson(filePath, payload) {
   }
 }
 async function appendJsonl(filePath, record2) {
-  await import_node_fs2.promises.mkdir(path3.dirname(filePath), { recursive: true });
+  await import_node_fs2.promises.mkdir(path4.dirname(filePath), { recursive: true });
   await import_node_fs2.promises.appendFile(filePath, JSON.stringify(record2) + "\n", { encoding: "utf8" });
 }
 function rmTree(target) {
   try {
-    for (const child of fs3.readdirSync(target)) {
-      const childPath = path3.join(target, child);
-      const stat = fs3.lstatSync(childPath);
+    for (const child of fs4.readdirSync(target)) {
+      const childPath = path4.join(target, child);
+      const stat = fs4.lstatSync(childPath);
       if (stat.isDirectory()) {
         rmTree(childPath);
       } else {
         try {
-          fs3.unlinkSync(childPath);
+          fs4.unlinkSync(childPath);
         } catch {
         }
       }
     }
-    fs3.rmdirSync(target);
+    fs4.rmdirSync(target);
   } catch {
   }
 }
-var crypto4, fs3, import_node_fs2, os, path3, SCHEMA_VERSION, DEFAULT_RETENTION_DAYS, CallLogger;
+var crypto4, fs4, import_node_fs2, os, path4, SCHEMA_VERSION, DEFAULT_RETENTION_DAYS, CallLogger;
 var init_call_log = __esm({
   "src/services/call-log.ts"() {
     "use strict";
     init_cjs_shims();
     crypto4 = __toESM(require("crypto"));
-    fs3 = __toESM(require("fs"));
+    fs4 = __toESM(require("fs"));
     import_node_fs2 = require("fs");
     os = __toESM(require("os"));
-    path3 = __toESM(require("path"));
+    path4 = __toESM(require("path"));
     init_logger();
     init_stream_handler();
     SCHEMA_VERSION = "1.0";
@@ -28944,9 +29250,9 @@ var init_call_log = __esm({
           this.root = null;
           return;
         }
-        const resolved = root.startsWith("~") ? path3.join(os.homedir(), root.slice(1)) : root;
+        const resolved = root.startsWith("~") ? path4.join(os.homedir(), root.slice(1)) : root;
         try {
-          fs3.mkdirSync(resolved, { recursive: true });
+          fs4.mkdirSync(resolved, { recursive: true });
           this.root = resolved;
           getLogger().info(`Call logs: ${resolved}`);
         } catch (err) {
@@ -28968,7 +29274,7 @@ var init_call_log = __esm({
         const month = String(dt.getUTCMonth() + 1).padStart(2, "0");
         const day = String(dt.getUTCDate()).padStart(2, "0");
         const safeId = sanitizeLogValue(callId, 64).replace(/\//g, "_") || "unknown";
-        return path3.join(this.root, "calls", year, month, day, safeId);
+        return path4.join(this.root, "calls", year, month, day, safeId);
       }
       /** Write the initial `metadata.json` for a new call. */
       async logCallStart(callId, input = {}) {
@@ -28986,6 +29292,7 @@ var init_call_log = __esm({
           status: "in_progress",
           caller: redactPhone(input.caller ?? ""),
           callee: redactPhone(input.callee ?? ""),
+          direction: input.direction || "inbound",
           telephony_provider: input.telephonyProvider ?? "",
           provider_mode: input.providerMode ?? "",
           agent: input.agent ?? {},
@@ -28995,7 +29302,7 @@ var init_call_log = __esm({
           error: null
         };
         try {
-          await atomicWriteJson(path3.join(dir, "metadata.json"), metadata);
+          await atomicWriteJson(path4.join(dir, "metadata.json"), metadata);
         } catch (err) {
           getLogger().warn(`call_log write failed (${sanitizeLogValue(callId)}): ${sanitizeLogValue(String(err))}`);
         }
@@ -29014,7 +29321,7 @@ var init_call_log = __esm({
           ...turn
         };
         try {
-          await appendJsonl(path3.join(dir, "transcript.jsonl"), record2);
+          await appendJsonl(path4.join(dir, "transcript.jsonl"), record2);
         } catch (err) {
           getLogger().warn(
             `call_log turn write failed (${sanitizeLogValue(callId)}): ${sanitizeLogValue(String(err))}`
@@ -29033,7 +29340,7 @@ var init_call_log = __esm({
           data: payload
         };
         try {
-          await appendJsonl(path3.join(dir, "events.jsonl"), record2);
+          await appendJsonl(path4.join(dir, "events.jsonl"), record2);
         } catch (err) {
           getLogger().warn(
             `call_log event write failed (${sanitizeLogValue(callId)}): ${sanitizeLogValue(String(err))}`
@@ -29045,7 +29352,7 @@ var init_call_log = __esm({
         if (!this.enabled) return;
         const dir = this.callDir(callId);
         if (dir === null) return;
-        const metadataPath = path3.join(dir, "metadata.json");
+        const metadataPath = path4.join(dir, "metadata.json");
         let existing = {};
         try {
           existing = JSON.parse(await import_node_fs2.promises.readFile(metadataPath, "utf8"));
@@ -29080,20 +29387,20 @@ var init_call_log = __esm({
         const days = retentionDays();
         if (days === 0) return;
         const cutoff = Date.now() / 1e3 - days * 86400;
-        const callsRoot = path3.join(this.root, "calls");
-        if (!fs3.existsSync(callsRoot)) return;
+        const callsRoot = path4.join(this.root, "calls");
+        if (!fs4.existsSync(callsRoot)) return;
         try {
-          for (const yearName of fs3.readdirSync(callsRoot)) {
+          for (const yearName of fs4.readdirSync(callsRoot)) {
             if (!/^\d+$/.test(yearName)) continue;
-            const yearDir = path3.join(callsRoot, yearName);
-            if (!fs3.statSync(yearDir).isDirectory()) continue;
-            for (const monthName of fs3.readdirSync(yearDir)) {
+            const yearDir = path4.join(callsRoot, yearName);
+            if (!fs4.statSync(yearDir).isDirectory()) continue;
+            for (const monthName of fs4.readdirSync(yearDir)) {
               if (!/^\d+$/.test(monthName)) continue;
-              const monthDir = path3.join(yearDir, monthName);
-              if (!fs3.statSync(monthDir).isDirectory()) continue;
-              for (const dayName of fs3.readdirSync(monthDir)) {
+              const monthDir = path4.join(yearDir, monthName);
+              if (!fs4.statSync(monthDir).isDirectory()) continue;
+              for (const dayName of fs4.readdirSync(monthDir)) {
                 if (!/^\d+$/.test(dayName)) continue;
-                const dayDir = path3.join(monthDir, dayName);
+                const dayDir = path4.join(monthDir, dayName);
                 const y = Number.parseInt(yearName, 10);
                 const m = Number.parseInt(monthName, 10);
                 const d = Number.parseInt(dayName, 10);
@@ -29103,12 +29410,12 @@ var init_call_log = __esm({
                 }
               }
               try {
-                if (fs3.readdirSync(monthDir).length === 0) fs3.rmdirSync(monthDir);
+                if (fs4.readdirSync(monthDir).length === 0) fs4.rmdirSync(monthDir);
               } catch {
               }
             }
             try {
-              if (fs3.readdirSync(yearDir).length === 0) fs3.rmdirSync(yearDir);
+              if (fs4.readdirSync(yearDir).length === 0) fs4.rmdirSync(yearDir);
             } catch {
             }
           }
@@ -29298,7 +29605,7 @@ function isValidTelnyxTransferTarget(target) {
 }
 async function sleep(ms) {
   if (ms <= 0) return;
-  await new Promise((resolve) => setTimeout(resolve, ms));
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 var import_node_crypto3, import_express, import_http, import_ws5, TRANSFER_CALL_TOOL, END_CALL_TOOL, TwilioBridge, TELNYX_DTMF_ALLOWED, TELNYX_DTMF_DURATION_MS, TelnyxBridge, GRACEFUL_SHUTDOWN_TIMEOUT_MS, EmbeddedServer;
 var init_server = __esm({
@@ -30035,7 +30342,7 @@ var init_server = __esm({
             this.handleTwilioStream(ws, url2);
           }
         });
-        await new Promise((resolve) => {
+        await new Promise((resolve2) => {
           const bindHost = process.env.PATTER_BIND_HOST ?? "127.0.0.1";
           this.server.listen(port, bindHost, () => {
             getLogger().info(`Server on port ${port}`);
@@ -30057,7 +30364,7 @@ var init_server = __esm({
               }
               console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
             }
-            resolve();
+            resolve2();
           });
         });
       }
@@ -30100,7 +30407,7 @@ var init_server = __esm({
               `Telnyx voicemail speak failed: ${speakResp.status} ${(await speakResp.text()).slice(0, 200)}`
             );
           }
-          await new Promise((resolve) => setTimeout(resolve, estimatedMs));
+          await new Promise((resolve2) => setTimeout(resolve2, estimatedMs));
           await fetch(`https://api.telnyx.com/v2/calls/${encoded}/actions/hangup`, {
             method: "POST",
             headers,
@@ -30171,9 +30478,11 @@ var init_server = __esm({
             const active = callId ? store.getActive(callId) : void 0;
             const resolvedCaller = dataCaller || active?.caller || "";
             const resolvedCallee = dataCallee || active?.callee || "";
+            const resolvedDirection = (typeof data.direction === "string" ? data.direction : "") || active?.direction || "inbound";
             void logger2.logCallStart(callId, {
               caller: resolvedCaller,
               callee: resolvedCallee,
+              direction: resolvedDirection,
               telephonyProvider: bridge.telephonyProvider,
               providerMode: agent.provider ?? "",
               agent: agentSnapshot()
@@ -30331,8 +30640,8 @@ var init_server = __esm({
        */
       async stop() {
         if (!this.server) return;
-        const httpClosePromise = new Promise((resolve) => {
-          this.server.close(() => resolve());
+        const httpClosePromise = new Promise((resolve2) => {
+          this.server.close(() => resolve2());
         });
         const isTelnyx = this.config.telephonyProvider === "telnyx";
         for (const [ws, callId] of this.activeCallIds) {
@@ -30352,15 +30661,15 @@ var init_server = __esm({
         if (this.activeConnections.size > 0) {
           getLogger().info(`Waiting for ${this.activeConnections.size} active connection(s) to close...`);
           await Promise.race([
-            new Promise((resolve) => {
+            new Promise((resolve2) => {
               const checkInterval = setInterval(() => {
                 if (this.activeConnections.size === 0) {
                   clearInterval(checkInterval);
-                  resolve();
+                  resolve2();
                 }
               }, 100);
             }),
-            new Promise((resolve) => setTimeout(resolve, GRACEFUL_SHUTDOWN_TIMEOUT_MS))
+            new Promise((resolve2) => setTimeout(resolve2, GRACEFUL_SHUTDOWN_TIMEOUT_MS))
           ]);
         }
         if (this.activeConnections.size > 0) {
@@ -30453,8 +30762,8 @@ async function startTunnel(port, timeoutMs = 3e4) {
     instance = result;
   }
   const tunnelUrl = await Promise.race([
-    new Promise((resolve) => {
-      instance.on("url", (url2) => resolve(url2));
+    new Promise((resolve2) => {
+      instance.on("url", (url2) => resolve2(url2));
     }),
     new Promise(
       (_, reject) => setTimeout(() => reject(new Error(
@@ -30663,7 +30972,7 @@ var init_test_mode = __esm({
           input: process.stdin,
           output: process.stdout
         });
-        const askQuestion = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+        const askQuestion = (prompt) => new Promise((resolve2) => rl.question(prompt, resolve2));
         try {
           while (!ended) {
             let userInput;
@@ -30852,11 +31161,11 @@ var require_tracked_promise = __commonJS({
       value;
       constructor(executor) {
         this.state = "pending";
-        this.promise = new Promise((resolve, reject) => {
+        this.promise = new Promise((resolve2, reject) => {
           executor((value) => {
             this.state = "fulfilled";
             this.value = value;
-            resolve(value);
+            resolve2(value);
           }, (error2) => {
             this.state = "rejected";
             this.error = error2;
@@ -30961,7 +31270,7 @@ var require_runner = __commonJS({
           }
         };
         const runTask = (date4) => {
-          return new Promise(async (resolve) => {
+          return new Promise(async (resolve2) => {
             const execution = {
               id: (0, create_id_1.createID)("exec"),
               reason: "scheduled"
@@ -30986,18 +31295,18 @@ var require_runner = __commonJS({
                   execution.error = error2;
                   this.onError(date4, error2, execution);
                 }
-                resolve(true);
+                resolve2(true);
               }, randomDelay);
             }
           });
         };
         const checkAndRun = (date4) => {
-          return new tracked_promise_1.TrackedPromise(async (resolve, reject) => {
+          return new tracked_promise_1.TrackedPromise(async (resolve2, reject) => {
             try {
               if (this.timeMatcher.match(date4)) {
                 await runTask(date4);
               }
-              resolve(true);
+              resolve2(true);
             } catch (err) {
               reject(err);
             }
@@ -31672,14 +31981,14 @@ var require_inline_scheduled_task = __commonJS({
         this.emitter.emit("task:destroyed", this.createContext(/* @__PURE__ */ new Date()));
       }
       execute() {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           const onFail = (context) => {
             this.off("execution:finished", onFail);
             reject(context.execution?.error);
           };
           const onFinished = (context) => {
             this.off("execution:failed", onFail);
-            resolve(context.execution?.result);
+            resolve2(context.execution?.result);
           };
           this.once("execution:finished", onFinished);
           this.once("execution:failed", onFail);
@@ -31873,9 +32182,9 @@ var require_background_scheduled_task = __commonJS({
         return null;
       }
       start() {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           if (this.forkProcess) {
-            return resolve(void 0);
+            return resolve2(void 0);
           }
           const timeout = setTimeout(() => {
             reject(new Error("Start operation timed out"));
@@ -31914,7 +32223,7 @@ var require_background_scheduled_task = __commonJS({
             this.once("task:started", () => {
               this.stateMachine.changeState("idle");
               clearTimeout(timeout);
-              resolve(void 0);
+              resolve2(void 0);
             });
             this.forkProcess.send({
               command: "task:start",
@@ -31928,9 +32237,9 @@ var require_background_scheduled_task = __commonJS({
         });
       }
       stop() {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           if (!this.forkProcess) {
-            return resolve(void 0);
+            return resolve2(void 0);
           }
           const timeoutId = setTimeout(() => {
             clearTimeout(timeoutId);
@@ -31940,7 +32249,7 @@ var require_background_scheduled_task = __commonJS({
             clearTimeout(timeoutId);
             this.off("task:stopped", onStopped);
             this.forkProcess = void 0;
-            resolve(void 0);
+            resolve2(void 0);
           };
           const onStopped = () => {
             cleanupAndResolve();
@@ -31955,9 +32264,9 @@ var require_background_scheduled_task = __commonJS({
         return this.stateMachine.state;
       }
       destroy() {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           if (!this.forkProcess) {
-            return resolve(void 0);
+            return resolve2(void 0);
           }
           const timeoutId = setTimeout(() => {
             clearTimeout(timeoutId);
@@ -31966,7 +32275,7 @@ var require_background_scheduled_task = __commonJS({
           const onDestroy = () => {
             clearTimeout(timeoutId);
             this.off("task:destroyed", onDestroy);
-            resolve(void 0);
+            resolve2(void 0);
           };
           this.once("task:destroyed", onDestroy);
           this.forkProcess.send({
@@ -31975,7 +32284,7 @@ var require_background_scheduled_task = __commonJS({
         });
       }
       execute() {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           if (!this.forkProcess) {
             return reject(new Error("Cannot execute background task because it hasn't been started yet. Please initialize the task using the start() method before attempting to execute it."));
           }
@@ -31990,7 +32299,7 @@ var require_background_scheduled_task = __commonJS({
           };
           const onFinished = (context) => {
             cleanupListeners();
-            resolve(context.execution?.result);
+            resolve2(context.execution?.result);
           };
           const onFail = (context) => {
             cleanupListeners();
@@ -32131,6 +32440,8 @@ __export(index_exports, {
   CallMetricsAccumulator: () => CallMetricsAccumulator,
   CartesiaSTT: () => STT4,
   CartesiaTTS: () => TTS4,
+  CartesiaTTSModel: () => CartesiaTTSModel,
+  CartesiaTTSVoiceMode: () => CartesiaTTSVoiceMode,
   CerebrasLLM: () => LLM4,
   ChatContext: () => ChatContext,
   CloudflareTunnel: () => CloudflareTunnel,
@@ -32138,10 +32449,13 @@ __export(index_exports, {
   DEFAULT_PRICING: () => DEFAULT_PRICING,
   DTMF_EVENTS: () => DTMF_EVENTS,
   DeepFilterNetFilter: () => DeepFilterNetFilter,
+  DeepgramModel: () => DeepgramModel,
   DeepgramSTT: () => STT,
   DefaultToolExecutor: () => DefaultToolExecutor,
   ElevenLabsConvAI: () => ConvAI,
   ElevenLabsConvAIAdapter: () => ElevenLabsConvAIAdapter,
+  ElevenLabsModel: () => ElevenLabsModel,
+  ElevenLabsOutputFormat: () => ElevenLabsOutputFormat,
   ElevenLabsRestTTS: () => ElevenLabsTTS,
   ElevenLabsTTS: () => TTS,
   ElevenLabsWebSocketTTS: () => TTS2,
@@ -32170,8 +32484,15 @@ __export(index_exports, {
   OpenAIRealtime2: () => Realtime2,
   OpenAIRealtime2Adapter: () => OpenAIRealtime2Adapter,
   OpenAIRealtimeAdapter: () => OpenAIRealtimeAdapter,
+  OpenAIRealtimeAudioFormat: () => OpenAIRealtimeAudioFormat,
+  OpenAIRealtimeModel: () => OpenAIRealtimeModel,
+  OpenAIRealtimeVADType: () => OpenAIRealtimeVADType,
   OpenAITTS: () => TTS3,
   OpenAITranscribeSTT: () => STT3,
+  OpenAITranscriptionModel: () => OpenAITranscriptionModel,
+  OpenAIVoice: () => OpenAIVoice,
+  PRICING_LAST_UPDATED: () => PRICING_LAST_UPDATED,
+  PRICING_VERSION: () => PRICING_VERSION,
   PartialStreamError: () => PartialStreamError,
   Patter: () => Patter,
   PatterConnectionError: () => PatterConnectionError,
@@ -32179,9 +32500,12 @@ __export(index_exports, {
   PatterTool: () => PatterTool,
   PcmCarry: () => PcmCarry,
   PipelineHookExecutor: () => PipelineHookExecutor,
+  PricingUnit: () => PricingUnit,
   ProvisionError: () => ProvisionError,
   RateLimitError: () => RateLimitError,
   RemoteMessageHandler: () => RemoteMessageHandler,
+  RimeAudioFormat: () => RimeAudioFormat,
+  RimeModel: () => RimeModel,
   RimeTTS: () => TTS5,
   SPAN_BARGEIN: () => SPAN_BARGEIN,
   SPAN_CALL: () => SPAN_CALL,
@@ -32301,7 +32625,7 @@ var Realtime = class {
       );
     }
     this.apiKey = key;
-    this.model = opts.model ?? "gpt-4o-mini-realtime-preview";
+    this.model = opts.model ?? "gpt-realtime-mini";
     this.voice = opts.voice ?? "alloy";
     this.reasoningEffort = opts.reasoningEffort;
     this.inputAudioTranscriptionModel = opts.inputAudioTranscriptionModel;
@@ -32760,7 +33084,9 @@ function resolvePersistRoot(persist) {
   if (persist === false) return null;
   if (persist === true) return resolveLogRoot("auto");
   if (typeof persist === "string") return resolveLogRoot(persist);
-  return resolveLogRoot();
+  const envRoot = resolveLogRoot();
+  if (envRoot !== null) return envRoot;
+  return resolveLogRoot("auto");
 }
 function closeParkedConnections(slot) {
   if (slot.stt) {
@@ -32776,6 +33102,11 @@ function closeParkedConnections(slot) {
     }
   }
   if (slot.openaiRealtime) {
+    const wsAny = slot.openaiRealtime;
+    if (wsAny._parkedKeepalive) {
+      clearInterval(wsAny._parkedKeepalive);
+      delete wsAny._parkedKeepalive;
+    }
     try {
       slot.openaiRealtime.close();
     } catch {
@@ -33007,8 +33338,8 @@ var Patter = class {
       openaiKey: options.openaiKey,
       persistRoot: resolvePersistRoot(options.persist)
     };
-    this._tunnelReady = new Promise((resolve, reject) => {
-      this._tunnelReadyResolve = resolve;
+    this._tunnelReady = new Promise((resolve2, reject) => {
+      this._tunnelReadyResolve = resolve2;
       this._tunnelReadyReject = reject;
     });
     this._tunnelReady.catch(() => {
@@ -33016,8 +33347,8 @@ var Patter = class {
     if (normalizedWebhook) {
       this._tunnelReadyResolve(normalizedWebhook);
     }
-    this._ready = new Promise((resolve, reject) => {
-      this._readyResolve = resolve;
+    this._ready = new Promise((resolve2, reject) => {
+      this._readyResolve = resolve2;
       this._readyReject = reject;
     });
     this._ready.catch(() => {
@@ -33347,7 +33678,9 @@ var Patter = class {
     const tts = agent.tts;
     const sttOpen = typeof stt?.openParkedConnection === "function" ? stt.openParkedConnection.bind(stt) : null;
     const ttsOpen = typeof tts?.openParkedConnection === "function" ? tts.openParkedConnection.bind(tts) : null;
-    if (!sttOpen && !ttsOpen) return;
+    const providerStr = agent.provider ?? "";
+    const wantsRealtimePark = providerStr === "openai_realtime" || providerStr === "openai_realtime_2";
+    if (!sttOpen && !ttsOpen && !wantsRealtimePark) return;
     const slot = {};
     this.prewarmedConnections.set(callId, slot);
     const startedAt = Date.now();
@@ -33392,6 +33725,43 @@ var Patter = class {
         }
       })());
     }
+    if (wantsRealtimePark) {
+      tasks.push((async () => {
+        const { OpenAIRealtime2Adapter: OpenAIRealtime2Adapter2 } = await Promise.resolve().then(() => (init_openai_realtime_2(), openai_realtime_2_exports));
+        const apiKey = process.env.OPENAI_API_KEY ?? "";
+        if (!apiKey) {
+          getLogger().debug(`Park OpenAI Realtime skipped for ${callId}: no OPENAI_API_KEY`);
+          return;
+        }
+        try {
+          const tmpAdapter = new OpenAIRealtime2Adapter2(
+            apiKey,
+            agent.model ?? "gpt-realtime-mini",
+            agent.voice ?? "alloy",
+            agent.systemPrompt ?? "",
+            [],
+            // audioFormat — the GA adapter always emits audio/pcm@24000
+            // internally regardless of this value, but it's a required
+            // positional param. Default to g711_ulaw (Twilio wire format).
+            void 0
+          );
+          const ws = await tmpAdapter.openParkedConnection();
+          if (this.prewarmedConnections.get(callId) !== slot) {
+            try {
+              ws.close();
+            } catch {
+            }
+            return;
+          }
+          slot.openaiRealtime = ws;
+          getLogger().info(
+            `[PREWARM] callId=${callId} provider=openai_realtime ms=${Date.now() - startedAt}`
+          );
+        } catch (err) {
+          getLogger().debug(`Park OpenAI Realtime failed for ${callId}: ${String(err)}`);
+        }
+      })());
+    }
     const task = (async () => {
       await Promise.allSettled(tasks);
     })();
@@ -33469,7 +33839,7 @@ var Patter = class {
    * with a warn when the cap is reached (the call still proceeds —
    * StreamHandler falls back to live TTS).
    */
-  spawnPrewarmFirstMessage(agent, callId, ringTimeout) {
+  spawnPrewarmFirstMessage(agent, callId, ringTimeout, carrier) {
     if (!agent.prewarmFirstMessage) return;
     const providerMode = agent.provider ?? "openai_realtime";
     if (providerMode !== "pipeline") {
@@ -33482,6 +33852,18 @@ var Patter = class {
     const tts = agent.tts;
     if (!firstMessage || !tts) return;
     if (typeof tts.synthesizeStream !== "function") return;
+    if (carrier) {
+      const carrierAware = tts;
+      if (typeof carrierAware.setTelephonyCarrier === "function") {
+        try {
+          carrierAware.setTelephonyCarrier(carrier);
+        } catch (err) {
+          getLogger().debug(
+            `Prewarm TTS setTelephonyCarrier failed for ${callId}: ${String(err)}`
+          );
+        }
+      }
+    }
     const inFlight = this.prewarmAudio.size + this.prewarmTasks.size;
     if (inFlight >= PREWARM_CACHE_MAX) {
       getLogger().warn(
@@ -33594,16 +33976,25 @@ var Patter = class {
         telnyxCallId = body.data?.call_control_id;
       } catch {
       }
-      if (this.embeddedServer && telnyxCallId) {
-        this.embeddedServer.metricsStore.recordCallInitiated({
+      if (telnyxCallId) {
+        const initiatedPayload = {
           call_id: telnyxCallId,
           caller: phoneNumber,
           callee: options.to,
-          direction: "outbound"
-        });
+          direction: "outbound",
+          status: "initiated"
+        };
+        if (this.embeddedServer) {
+          this.embeddedServer.metricsStore.recordCallInitiated(initiatedPayload);
+        }
+        try {
+          const { notifyDashboard: notifyDashboard2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
+          notifyDashboard2(initiatedPayload);
+        } catch {
+        }
       }
       if (telnyxCallId) {
-        this.spawnPrewarmFirstMessage(options.agent, telnyxCallId, effectiveRingTimeout);
+        this.spawnPrewarmFirstMessage(options.agent, telnyxCallId, effectiveRingTimeout, "telnyx");
         if (options.agent.prewarm !== false) {
           this.parkProviderConnections(options.agent, telnyxCallId);
         }
@@ -33656,21 +34047,30 @@ var Patter = class {
       twilioNotificationsPath = body.subresource_uris?.notifications;
     } catch {
     }
-    if (this.embeddedServer && twilioCallSid) {
-      this.embeddedServer.metricsStore.recordCallInitiated({
+    if (twilioCallSid) {
+      const initiatedPayload = {
         call_id: twilioCallSid,
         caller: phoneNumber,
         callee: options.to,
-        direction: "outbound"
-      });
-      if (twilioNotificationsPath) {
-        getLogger().info(
-          `Outbound call ${twilioCallSid} placed. Twilio notifications: https://api.twilio.com${twilioNotificationsPath} (check here if the call drops with no audio).`
-        );
+        direction: "outbound",
+        status: "initiated"
+      };
+      if (this.embeddedServer) {
+        this.embeddedServer.metricsStore.recordCallInitiated(initiatedPayload);
+        if (twilioNotificationsPath) {
+          getLogger().info(
+            `Outbound call ${twilioCallSid} placed. Twilio notifications: https://api.twilio.com${twilioNotificationsPath} (check here if the call drops with no audio).`
+          );
+        }
+      }
+      try {
+        const { notifyDashboard: notifyDashboard2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
+        notifyDashboard2(initiatedPayload);
+      } catch {
       }
     }
     if (twilioCallSid) {
-      this.spawnPrewarmFirstMessage(options.agent, twilioCallSid, effectiveRingTimeout);
+      this.spawnPrewarmFirstMessage(options.agent, twilioCallSid, effectiveRingTimeout, "twilio");
       if (options.agent.prewarm !== false) {
         this.parkProviderConnections(options.agent, twilioCallSid);
       }
@@ -33695,7 +34095,7 @@ var Patter = class {
     if (this.prewarmTasks.size > 0) {
       const drain = Promise.allSettled(Array.from(this.prewarmTasks));
       const timer = new Promise(
-        (resolve) => setTimeout(resolve, 1e3).unref?.()
+        (resolve2) => setTimeout(resolve2, 1e3).unref?.()
       );
       await Promise.race([drain, timer]);
     }
@@ -33722,8 +34122,8 @@ var Patter = class {
       this.localConfig = { ...this.localConfig, webhookUrl: void 0 };
       this.tunnelOwnsWebhookUrl = false;
     }
-    this._tunnelReady = new Promise((resolve, reject) => {
-      this._tunnelReadyResolve = resolve;
+    this._tunnelReady = new Promise((resolve2, reject) => {
+      this._tunnelReadyResolve = resolve2;
       this._tunnelReadyReject = reject;
     });
     this._tunnelReady.catch(() => {
@@ -33731,8 +34131,8 @@ var Patter = class {
     if (this.localConfig.webhookUrl) {
       this._tunnelReadyResolve(this.localConfig.webhookUrl);
     }
-    this._ready = new Promise((resolve, reject) => {
-      this._readyResolve = resolve;
+    this._ready = new Promise((resolve2, reject) => {
+      this._readyResolve = resolve2;
       this._readyReject = reject;
     });
     this._ready.catch(() => {
@@ -34382,13 +34782,13 @@ var PatterTool = class _PatterTool {
       ...args.first_message !== void 0 ? { firstMessage: args.first_message } : {}
     });
     const callId = await this.acquireCallId(args.to, overrideAgent);
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(callId);
         reject(new Error(`PatterTool.execute: call ${callId} exceeded ${timeoutSec}s timeout`));
       }, timeoutSec * 1e3);
       this.pending.set(callId, {
-        resolve,
+        resolve: resolve2,
         reject,
         timer,
         startedAt: Date.now() / 1e3
@@ -34406,8 +34806,8 @@ var PatterTool = class _PatterTool {
     await previous;
     let captureTimer = null;
     try {
-      const callIdPromise = new Promise((resolve, reject) => {
-        this.pendingDial = resolve;
+      const callIdPromise = new Promise((resolve2, reject) => {
+        this.pendingDial = resolve2;
         captureTimer = setTimeout(() => {
           this.pendingDial = null;
           reject(
@@ -34759,11 +35159,11 @@ var UltravoxRealtimeAdapter = class {
     const call = await resp.json();
     if (!call.joinUrl) throw new Error("Ultravox response missing joinUrl");
     this.ws = new import_ws6.default(call.joinUrl);
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const ws = this.ws;
       const onOpen = () => {
         ws.off("error", onError);
-        resolve();
+        resolve2();
       };
       const onError = (err) => {
         ws.off("open", onOpen);
@@ -34995,6 +35395,601 @@ function scheduleInterval(intervalOrOpts, callback) {
   };
 }
 
+// src/index.ts
+init_openai_realtime();
+
+// src/providers/elevenlabs-tts.ts
+init_cjs_shims();
+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",
+  sarah: "EXAVITQu4vr4xnSDxMaL",
+  alloy: "EXAVITQu4vr4xnSDxMaL"
+};
+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 ElevenLabsModel = {
+  V3: "eleven_v3",
+  FLASH_V2_5: "eleven_flash_v2_5",
+  TURBO_V2_5: "eleven_turbo_v2_5",
+  MULTILINGUAL_V2: "eleven_multilingual_v2",
+  MONOLINGUAL_V1: "eleven_monolingual_v1"
+};
+var ElevenLabsOutputFormat = {
+  MP3_22050_32: "mp3_22050_32",
+  MP3_44100_32: "mp3_44100_32",
+  MP3_44100_64: "mp3_44100_64",
+  MP3_44100_96: "mp3_44100_96",
+  MP3_44100_128: "mp3_44100_128",
+  MP3_44100_192: "mp3_44100_192",
+  PCM_8000: "pcm_8000",
+  PCM_16000: "pcm_16000",
+  PCM_22050: "pcm_22050",
+  PCM_24000: "pcm_24000",
+  PCM_44100: "pcm_44100",
+  ULAW_8000: "ulaw_8000"
+};
+var ElevenLabsTTS = class _ElevenLabsTTS {
+  // Stable pricing/dashboard key — read by stream-handler / metrics via
+  // ``(agent.tts.constructor as any).providerKey``. Without this the cost
+  // calculator falls back to ``constructor.name`` ("ElevenLabsTTS") which
+  // does NOT match the pricing table key "elevenlabs", silently zeroing
+  // TTS cost for callers that construct the raw REST class directly
+  // (exposed at top level as ``ElevenLabsRestTTS``).
+  static providerKey = "elevenlabs";
+  apiKey;
+  voiceId;
+  modelId;
+  _outputFormat;
+  _outputFormatExplicit;
+  voiceSettings;
+  languageCode;
+  chunkSize;
+  /**
+   * Public view of the (possibly auto-flipped) wire format. Read by the
+   * stream-handler to decide whether to skip the client-side resample +
+   * mulaw encode when the bytes are already in the carrier's wire codec.
+   */
+  get outputFormat() {
+    return this._outputFormat;
+  }
+  constructor(apiKey, voiceIdOrOptions = "21m00Tcm4TlvDq8ikWAM", modelId = ElevenLabsModel.FLASH_V2_5, outputFormat = ElevenLabsOutputFormat.PCM_16000) {
+    this.apiKey = apiKey;
+    if (typeof voiceIdOrOptions === "object") {
+      const o = voiceIdOrOptions;
+      this.voiceId = resolveVoiceId(o.voiceId ?? "21m00Tcm4TlvDq8ikWAM");
+      this.modelId = o.modelId ?? ElevenLabsModel.FLASH_V2_5;
+      this._outputFormatExplicit = o.outputFormat !== void 0;
+      this._outputFormat = o.outputFormat ?? ElevenLabsOutputFormat.PCM_16000;
+      this.voiceSettings = o.voiceSettings;
+      this.languageCode = o.languageCode;
+      this.chunkSize = o.chunkSize ?? 4096;
+    } else {
+      this.voiceId = resolveVoiceId(voiceIdOrOptions);
+      this.modelId = modelId;
+      this._outputFormatExplicit = outputFormat !== ElevenLabsOutputFormat.PCM_16000;
+      this._outputFormat = outputFormat;
+      this.voiceSettings = void 0;
+      this.languageCode = void 0;
+      this.chunkSize = 4096;
+    }
+  }
+  /**
+   * Hook called by ``StreamHandler.initPipeline`` to advise the carrier
+   * wire format. When the user did NOT pass an explicit ``outputFormat``,
+   * auto-flip to the carrier's native codec so the audio bytes ElevenLabs
+   * returns are already in Twilio/Telnyx wire format — eliminating the
+   * client-side 16 kHz → 8 kHz resample and PCM → μ-law encode. The
+   * resample/encode chain was a source of audible artifacts on the
+   * prewarmed firstMessage (see 0.6.2 acceptance notes — burst delivery
+   * of resampled audio crackled on the carrier-side jitter buffer).
+   *
+   * No-op when the caller passed an explicit ``outputFormat`` (incl. via
+   * the ``forTwilio`` / ``forTelnyx`` factories) — user wins.
+   *
+   * Parity with {@link ElevenLabsWebSocketTTS.setTelephonyCarrier}.
+   */
+  setTelephonyCarrier(carrier) {
+    if (this._outputFormatExplicit) return;
+    if (carrier === "twilio") {
+      this._outputFormat = ElevenLabsOutputFormat.ULAW_8000;
+    } else if (carrier === "telnyx") {
+      this._outputFormat = ElevenLabsOutputFormat.PCM_16000;
+    }
+  }
+  /**
+   * Construct an instance pre-configured for Twilio Media Streams.
+   *
+   * Sets `outputFormat='ulaw_8000'` so ElevenLabs emits μ-law @ 8 kHz
+   * directly — the exact wire format Twilio's media stream uses — letting
+   * the SDK skip the 16 kHz→8 kHz resample and PCM→μ-law conversion in
+   * `TwilioAudioSender`. Saves ~30–80 ms first-byte and per-frame CPU,
+   * and removes a potential aliasing source.
+   *
+   * `voiceSettings` defaults to a low-bandwidth-friendly profile
+   * (speaker boost off, modest stability) which sounds cleaner at 8 kHz
+   * μ-law than the studio default. Pass an explicit object to override.
+   */
+  static forTwilio(apiKey, options = {}) {
+    const voiceSettings = options.voiceSettings ?? {
+      // Speaker boost adds high-frequency emphasis that aliases ugly over an
+      // 8 kHz μ-law line. Slightly higher stability tames the excursions
+      // that compander quantization noise can amplify.
+      stability: 0.6,
+      similarity_boost: 0.75,
+      use_speaker_boost: false
+    };
+    return new _ElevenLabsTTS(apiKey, {
+      ...options,
+      voiceSettings,
+      outputFormat: ElevenLabsOutputFormat.ULAW_8000
+    });
+  }
+  /**
+   * Construct an instance pre-configured for Telnyx bidirectional media.
+   *
+   * Telnyx's default media-streaming codec is L16 PCM @ 16 kHz, which
+   * matches our default Telnyx handler. We pick `pcm_16000` so the audio
+   * flows end-to-end with zero resampling or transcoding.
+   *
+   * Trade-off: if your Telnyx profile is pinned to PCMU/8000 (μ-law),
+   * construct `ElevenLabsTTS` directly with `outputFormat: 'ulaw_8000'`
+   * — Telnyx supports that natively too.
+   */
+  static forTelnyx(apiKey, options = {}) {
+    return new _ElevenLabsTTS(apiKey, {
+      ...options,
+      outputFormat: ElevenLabsOutputFormat.PCM_16000
+    });
+  }
+  /**
+   * 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). `chunkSize` controls the maximum yield size — 512 is a
+   * good choice for low-latency telephony.
+   */
+  async *synthesizeStream(text) {
+    const url2 = `${ELEVENLABS_BASE_URL}/text-to-speech/${encodeURIComponent(this.voiceId)}/stream?output_format=${encodeURIComponent(this._outputFormat)}`;
+    const body = {
+      text,
+      model_id: this.modelId
+    };
+    if (this.voiceSettings) body["voice_settings"] = this.voiceSettings;
+    if (this.languageCode) body["language_code"] = this.languageCode;
+    const response = await fetch(url2, {
+      method: "POST",
+      headers: {
+        "xi-api-key": this.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const errBody = await response.text();
+      throw new Error(`ElevenLabs TTS error ${response.status}: ${errBody}`);
+    }
+    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) continue;
+        const buf = Buffer.from(value);
+        for (let offset = 0; offset < buf.length; offset += this.chunkSize) {
+          yield buf.subarray(offset, Math.min(offset + this.chunkSize, buf.length));
+        }
+      }
+    } finally {
+      if (typeof reader.cancel === "function") await reader.cancel().catch(() => {
+      });
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/index.ts
+init_deepgram_stt();
+
+// src/providers/cartesia-tts.ts
+init_cjs_shims();
+init_logger();
+var CARTESIA_BASE_URL = "https://api.cartesia.ai";
+var CARTESIA_API_VERSION = "2025-04-16";
+var CARTESIA_DEFAULT_VOICE_ID = "f786b574-daa5-4673-aa0c-cbe3e8534c02";
+var CartesiaTTSModel = {
+  SONIC_3: "sonic-3",
+  SONIC_2: "sonic-2",
+  SONIC: "sonic"
+};
+var CartesiaTTSContainer = {
+  RAW: "raw",
+  WAV: "wav",
+  MP3: "mp3"
+};
+var CartesiaTTSEncoding = {
+  PCM_S16LE: "pcm_s16le",
+  PCM_F32LE: "pcm_f32le",
+  PCM_MULAW: "pcm_mulaw",
+  PCM_ALAW: "pcm_alaw"
+};
+var CartesiaTTSSampleRate = {
+  HZ_8000: 8e3,
+  HZ_16000: 16e3,
+  HZ_22050: 22050,
+  HZ_24000: 24e3,
+  HZ_44100: 44100
+};
+var CartesiaTTSVoiceMode = {
+  ID: "id",
+  EMBEDDING: "embedding"
+};
+var CartesiaTTS = class _CartesiaTTS {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "cartesia_tts";
+  apiKey;
+  model;
+  voice;
+  language;
+  sampleRate;
+  speed;
+  emotion;
+  volume;
+  baseUrl;
+  apiVersion;
+  constructor(apiKey, opts = {}) {
+    this.apiKey = apiKey;
+    this.model = opts.model ?? CartesiaTTSModel.SONIC_3;
+    this.voice = opts.voice ?? CARTESIA_DEFAULT_VOICE_ID;
+    this.language = opts.language ?? "en";
+    this.sampleRate = opts.sampleRate ?? CartesiaTTSSampleRate.HZ_16000;
+    this.speed = opts.speed;
+    this.emotion = typeof opts.emotion === "string" ? [opts.emotion] : opts.emotion;
+    this.volume = opts.volume;
+    this.baseUrl = opts.baseUrl ?? CARTESIA_BASE_URL;
+    this.apiVersion = opts.apiVersion ?? CARTESIA_API_VERSION;
+  }
+  /**
+   * Construct an instance pre-configured for Twilio Media Streams.
+   *
+   * Sets `sampleRate=8000` so Cartesia emits PCM_S16LE @ 8 kHz directly.
+   * Twilio's media stream uses μ-law @ 8 kHz so the SDK still does the
+   * PCM → μ-law transcode client-side, but the 16 kHz → 8 kHz resample
+   * step is skipped. Saves ~10–30 ms first-byte plus per-frame CPU and
+   * removes a potential aliasing source.
+   */
+  static forTwilio(apiKey, options = {}) {
+    return new _CartesiaTTS(apiKey, {
+      ...options,
+      sampleRate: CartesiaTTSSampleRate.HZ_8000
+    });
+  }
+  /**
+   * Construct an instance pre-configured for Telnyx bidirectional media.
+   *
+   * Sets `sampleRate=16000` to match Telnyx's L16/16000 default codec —
+   * audio flows end-to-end with zero resampling or transcoding. Same as
+   * the bare-constructor default; exists for API symmetry with
+   * {@link CartesiaTTS.forTwilio}.
+   */
+  static forTelnyx(apiKey, options = {}) {
+    return new _CartesiaTTS(apiKey, {
+      ...options,
+      sampleRate: CartesiaTTSSampleRate.HZ_16000
+    });
+  }
+  /** Build the JSON payload for the Cartesia bytes endpoint. */
+  buildPayload(text) {
+    const payload = {
+      model_id: this.model,
+      voice: { mode: CartesiaTTSVoiceMode.ID, id: this.voice },
+      transcript: text,
+      output_format: {
+        container: CartesiaTTSContainer.RAW,
+        encoding: CartesiaTTSEncoding.PCM_S16LE,
+        sample_rate: this.sampleRate
+      },
+      language: this.language
+    };
+    const generationConfig = {};
+    if (this.speed !== void 0) generationConfig.speed = this.speed;
+    if (this.emotion && this.emotion.length > 0)
+      generationConfig.emotion = this.emotion[0];
+    if (this.volume !== void 0) generationConfig.volume = this.volume;
+    if (Object.keys(generationConfig).length > 0) {
+      payload.generation_config = generationConfig;
+    }
+    return payload;
+  }
+  /**
+   * Pre-call HTTP warmup for the Cartesia `/tts/bytes` endpoint.
+   *
+   * Issues a lightweight `GET <baseUrl>/voices` so DNS, TLS, and HTTP/2
+   * are already up by the time the first `synthesizeStream()` POST
+   * lands. Best-effort: 5 s timeout, all exceptions swallowed at
+   * debug level.
+   *
+   * Billing safety: `GET /voices` is a free metadata read on
+   * Cartesia's REST surface (per https://docs.cartesia.ai). It does
+   * not consume synthesis credits. The actual synthesis is billed
+   * only when `POST /tts/bytes` runs with a non-empty `transcript`.
+   *
+   * Note: Cartesia TTS uses the HTTP path (vs the WebSocket variant
+   * Cartesia also exposes) — connection warmup is therefore HTTP-GET
+   * based, not WebSocket pre-handshake. The latency win is smaller
+   * (~50-150 ms vs the ~200-500 ms of a WS prewarm) but still real.
+   */
+  async warmup() {
+    try {
+      await fetch(`${this.baseUrl}/voices`, {
+        method: "GET",
+        headers: {
+          "X-API-Key": this.apiKey,
+          "Cartesia-Version": this.apiVersion
+        },
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch (err) {
+      getLogger().debug(`Cartesia TTS warmup failed (best-effort): ${String(err)}`);
+    }
+  }
+  /** Synthesize text and return the concatenated audio buffer. */
+  async synthesize(text) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+  /**
+   * Synthesize text and yield raw PCM_S16LE chunks at the configured
+   * `sampleRate` as they arrive from Cartesia.
+   */
+  async *synthesizeStream(text) {
+    const response = await fetch(`${this.baseUrl}/tts/bytes`, {
+      method: "POST",
+      headers: {
+        "X-API-Key": this.apiKey,
+        "Cartesia-Version": this.apiVersion,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(this.buildPayload(text)),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Cartesia TTS error ${response.status}: ${body}`);
+    }
+    if (!response.body) {
+      throw new Error("Cartesia 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/providers/rime-tts.ts
+init_cjs_shims();
+var RIME_BASE_URL = "https://users.rime.ai/v1/rime-tts";
+var RimeModel = {
+  ARCANA: "arcana",
+  MIST: "mist",
+  MIST_V2: "mistv2"
+};
+var RimeAudioFormat = {
+  PCM: "audio/pcm",
+  MP3: "audio/mp3",
+  WAV: "audio/wav",
+  MULAW: "audio/mulaw"
+};
+var ARCANA_MODEL_TIMEOUT_MS = 60 * 4 * 1e3;
+var MIST_MODEL_TIMEOUT_MS = 30 * 1e3;
+function isMistModel(model) {
+  return model.includes(RimeModel.MIST);
+}
+function timeoutForModel(model) {
+  if (model === RimeModel.ARCANA) return ARCANA_MODEL_TIMEOUT_MS;
+  return MIST_MODEL_TIMEOUT_MS;
+}
+var RimeTTS = class {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "rime";
+  apiKey;
+  model;
+  speaker;
+  lang;
+  sampleRate;
+  repetitionPenalty;
+  temperature;
+  topP;
+  maxTokens;
+  speedAlpha;
+  reduceLatency;
+  pauseBetweenBrackets;
+  phonemizeBetweenBrackets;
+  baseUrl;
+  totalTimeoutMs;
+  constructor(apiKey, opts = {}) {
+    this.apiKey = apiKey;
+    this.model = opts.model ?? RimeModel.ARCANA;
+    const defaultSpeaker = isMistModel(this.model) ? "cove" : "astra";
+    this.speaker = opts.speaker ?? defaultSpeaker;
+    this.lang = opts.lang ?? "eng";
+    this.sampleRate = opts.sampleRate ?? 16e3;
+    this.repetitionPenalty = opts.repetitionPenalty;
+    this.temperature = opts.temperature;
+    this.topP = opts.topP;
+    this.maxTokens = opts.maxTokens;
+    this.speedAlpha = opts.speedAlpha;
+    this.reduceLatency = opts.reduceLatency;
+    this.pauseBetweenBrackets = opts.pauseBetweenBrackets;
+    this.phonemizeBetweenBrackets = opts.phonemizeBetweenBrackets;
+    this.baseUrl = opts.baseUrl ?? RIME_BASE_URL;
+    this.totalTimeoutMs = timeoutForModel(this.model);
+  }
+  buildPayload(text) {
+    const payload = {
+      speaker: this.speaker,
+      text,
+      modelId: this.model
+    };
+    if (this.model === RimeModel.ARCANA) {
+      if (this.repetitionPenalty !== void 0)
+        payload.repetition_penalty = this.repetitionPenalty;
+      if (this.temperature !== void 0) payload.temperature = this.temperature;
+      if (this.topP !== void 0) payload.top_p = this.topP;
+      if (this.maxTokens !== void 0) payload.max_tokens = this.maxTokens;
+      payload.lang = this.lang;
+      payload.samplingRate = this.sampleRate;
+    } else if (isMistModel(this.model)) {
+      payload.lang = this.lang;
+      payload.samplingRate = this.sampleRate;
+      if (this.speedAlpha !== void 0) payload.speedAlpha = this.speedAlpha;
+      if (this.model === RimeModel.MIST_V2 && this.reduceLatency !== void 0) {
+        payload.reduceLatency = this.reduceLatency;
+      }
+      if (this.pauseBetweenBrackets !== void 0) {
+        payload.pauseBetweenBrackets = this.pauseBetweenBrackets;
+      }
+      if (this.phonemizeBetweenBrackets !== void 0) {
+        payload.phonemizeBetweenBrackets = this.phonemizeBetweenBrackets;
+      }
+    }
+    return payload;
+  }
+  /** Synthesize text and return the concatenated audio buffer. */
+  async synthesize(text) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+  /**
+   * Synthesize text and yield raw PCM_S16LE chunks at the configured
+   * `sampleRate` as they stream in.
+   */
+  async *synthesizeStream(text) {
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: {
+        accept: RimeAudioFormat.PCM,
+        Authorization: `Bearer ${this.apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(this.buildPayload(text)),
+      signal: AbortSignal.timeout(this.totalTimeoutMs)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`Rime TTS error ${response.status}: ${body}`);
+    }
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.startsWith("audio")) {
+      const body = await response.text();
+      throw new Error(`Rime returned non-audio response: ${body.slice(0, 500)}`);
+    }
+    if (!response.body) {
+      throw new Error("Rime 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/index.ts
+init_pricing();
+
 // src/stt/deepgram.ts
 init_cjs_shims();
 init_deepgram_stt();
@@ -35325,14 +36320,14 @@ var CartesiaSTT = class {
     const ws = new import_ws7.default(url2, {
       headers: { "User-Agent": USER_AGENT }
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(
         () => reject(new Error("Cartesia STT park connect timeout")),
         CONNECT_TIMEOUT_MS
       );
       ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       ws.once("error", (err) => {
         clearTimeout(timer);
@@ -35382,7 +36377,7 @@ var CartesiaSTT = class {
     const url2 = this.buildWsUrl();
     let ws = null;
     try {
-      ws = await new Promise((resolve, reject) => {
+      ws = await new Promise((resolve2, reject) => {
         const sock = new import_ws7.default(url2, {
           headers: { "User-Agent": USER_AGENT }
         });
@@ -35395,7 +36390,7 @@ var CartesiaSTT = class {
         }, 5e3);
         sock.once("open", () => {
           clearTimeout(timer);
-          resolve(sock);
+          resolve2(sock);
         });
         sock.once("error", (err) => {
           clearTimeout(timer);
@@ -35422,14 +36417,14 @@ var CartesiaSTT = class {
     this.ws = new import_ws7.default(url2, {
       headers: { "User-Agent": USER_AGENT }
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(
         () => reject(new Error("Cartesia STT connect timeout")),
         CONNECT_TIMEOUT_MS
       );
       this.ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       this.ws.once("error", (err) => {
         clearTimeout(timer);
@@ -35517,12 +36512,12 @@ var CartesiaSTT = class {
    */
   async finalize() {
     if (!this.ws || this.ws.readyState !== import_ws7.default.OPEN) return;
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       this.ws.send(CartesiaSTTClientFrame.FINALIZE, (err) => {
         if (err) {
           getLogger().debug(`Cartesia finalize send failed: ${String(err)}`);
         }
-        resolve();
+        resolve2();
       });
     });
   }
@@ -35571,10 +36566,10 @@ var CartesiaSTT = class {
     if (!ws) return;
     if (ws.readyState === import_ws7.default.OPEN) {
       try {
-        await new Promise((resolve) => {
+        await new Promise((resolve2) => {
           ws.send(CartesiaSTTClientFrame.FINALIZE, (err) => {
             if (err) getLogger().warn(`CartesiaSTT finalize send failed: ${String(err)}`);
-            resolve();
+            resolve2();
           });
         });
       } catch (err) {
@@ -35582,18 +36577,18 @@ var CartesiaSTT = class {
       }
     }
     if (ws.readyState === import_ws7.default.OPEN || ws.readyState === import_ws7.default.CONNECTING) {
-      await new Promise((resolve) => {
+      await new Promise((resolve2) => {
         const done = () => {
           ws.off("close", done);
           ws.off("error", done);
-          resolve();
+          resolve2();
         };
         ws.once("close", done);
         ws.once("error", done);
         try {
           ws.close();
         } catch {
-          resolve();
+          resolve2();
         }
       });
     }
@@ -35758,11 +36753,11 @@ var SonioxSTT = class _SonioxSTT {
   async connect() {
     this.final.reset();
     this.ws = new import_ws8.default(this.baseUrl);
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(() => reject(new Error("Soniox connect timeout")), 1e4);
       this.ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       this.ws.once("error", (err) => {
         clearTimeout(timer);
@@ -36080,7 +37075,7 @@ var AssemblyAISTT = class _AssemblyAISTT {
     const headers = this.buildHeaders();
     let ws = null;
     try {
-      ws = await new Promise((resolve, reject) => {
+      ws = await new Promise((resolve2, reject) => {
         const sock = new import_ws9.default(url2, { headers });
         const timer = setTimeout(() => {
           try {
@@ -36091,7 +37086,7 @@ var AssemblyAISTT = class _AssemblyAISTT {
         }, 5e3);
         sock.once("open", () => {
           clearTimeout(timer);
-          resolve(sock);
+          resolve2(sock);
         });
         sock.once("error", (err) => {
           clearTimeout(timer);
@@ -36125,14 +37120,14 @@ var AssemblyAISTT = class _AssemblyAISTT {
     this.attachHandlers(this.ws);
   }
   async awaitOpen(ws) {
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(
         () => reject(new Error("AssemblyAI connect timeout")),
         CONNECT_TIMEOUT_MS2
       );
       ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       ws.once("error", (err) => {
         clearTimeout(timer);
@@ -36319,14 +37314,14 @@ var AssemblyAISTT = class _AssemblyAISTT {
       this.ws.send(JSON.stringify({ type: AssemblyAIClientFrame.TERMINATE }));
     } catch {
     }
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       const timer = setTimeout(() => {
         this.terminationResolve = null;
-        resolve();
+        resolve2();
       }, TERMINATION_WAIT_TIMEOUT_MS);
       this.terminationResolve = () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       };
     });
     try {
@@ -36513,7 +37508,7 @@ var SpeechmaticsSTT = class {
       headers: { Authorization: `Bearer ${this.apiKey}` }
     });
     this.ws = ws;
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       let settled = false;
       const settle = (fn) => {
         if (settled) return;
@@ -36527,7 +37522,7 @@ var SpeechmaticsSTT = class {
         ),
         CONNECT_TIMEOUT_MS3
       );
-      ws.once("open", () => settle(resolve));
+      ws.once("open", () => settle(resolve2));
       ws.once("error", (err) => settle(() => reject(err)));
       ws.once("unexpected-response", (_req, res) => {
         const status = res?.statusCode ?? 0;
@@ -36722,228 +37717,6 @@ var STT7 = class extends SpeechmaticsSTT {
 
 // src/tts/elevenlabs.ts
 init_cjs_shims();
-
-// src/providers/elevenlabs-tts.ts
-init_cjs_shims();
-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",
-  sarah: "EXAVITQu4vr4xnSDxMaL",
-  alloy: "EXAVITQu4vr4xnSDxMaL"
-};
-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 ElevenLabsModel = {
-  V3: "eleven_v3",
-  FLASH_V2_5: "eleven_flash_v2_5",
-  TURBO_V2_5: "eleven_turbo_v2_5",
-  MULTILINGUAL_V2: "eleven_multilingual_v2",
-  MONOLINGUAL_V1: "eleven_monolingual_v1"
-};
-var ElevenLabsOutputFormat = {
-  MP3_22050_32: "mp3_22050_32",
-  MP3_44100_32: "mp3_44100_32",
-  MP3_44100_64: "mp3_44100_64",
-  MP3_44100_96: "mp3_44100_96",
-  MP3_44100_128: "mp3_44100_128",
-  MP3_44100_192: "mp3_44100_192",
-  PCM_8000: "pcm_8000",
-  PCM_16000: "pcm_16000",
-  PCM_22050: "pcm_22050",
-  PCM_24000: "pcm_24000",
-  PCM_44100: "pcm_44100",
-  ULAW_8000: "ulaw_8000"
-};
-var ElevenLabsTTS = class _ElevenLabsTTS {
-  // Stable pricing/dashboard key — read by stream-handler / metrics via
-  // ``(agent.tts.constructor as any).providerKey``. Without this the cost
-  // calculator falls back to ``constructor.name`` ("ElevenLabsTTS") which
-  // does NOT match the pricing table key "elevenlabs", silently zeroing
-  // TTS cost for callers that construct the raw REST class directly
-  // (exposed at top level as ``ElevenLabsRestTTS``).
-  static providerKey = "elevenlabs";
-  apiKey;
-  voiceId;
-  modelId;
-  outputFormat;
-  voiceSettings;
-  languageCode;
-  chunkSize;
-  constructor(apiKey, voiceIdOrOptions = "21m00Tcm4TlvDq8ikWAM", modelId = ElevenLabsModel.FLASH_V2_5, outputFormat = ElevenLabsOutputFormat.PCM_16000) {
-    this.apiKey = apiKey;
-    if (typeof voiceIdOrOptions === "object") {
-      const o = voiceIdOrOptions;
-      this.voiceId = resolveVoiceId(o.voiceId ?? "21m00Tcm4TlvDq8ikWAM");
-      this.modelId = o.modelId ?? ElevenLabsModel.FLASH_V2_5;
-      this.outputFormat = o.outputFormat ?? ElevenLabsOutputFormat.PCM_16000;
-      this.voiceSettings = o.voiceSettings;
-      this.languageCode = o.languageCode;
-      this.chunkSize = o.chunkSize ?? 4096;
-    } else {
-      this.voiceId = resolveVoiceId(voiceIdOrOptions);
-      this.modelId = modelId;
-      this.outputFormat = outputFormat;
-      this.voiceSettings = void 0;
-      this.languageCode = void 0;
-      this.chunkSize = 4096;
-    }
-  }
-  /**
-   * Construct an instance pre-configured for Twilio Media Streams.
-   *
-   * Sets `outputFormat='ulaw_8000'` so ElevenLabs emits μ-law @ 8 kHz
-   * directly — the exact wire format Twilio's media stream uses — letting
-   * the SDK skip the 16 kHz→8 kHz resample and PCM→μ-law conversion in
-   * `TwilioAudioSender`. Saves ~30–80 ms first-byte and per-frame CPU,
-   * and removes a potential aliasing source.
-   *
-   * `voiceSettings` defaults to a low-bandwidth-friendly profile
-   * (speaker boost off, modest stability) which sounds cleaner at 8 kHz
-   * μ-law than the studio default. Pass an explicit object to override.
-   */
-  static forTwilio(apiKey, options = {}) {
-    const voiceSettings = options.voiceSettings ?? {
-      // Speaker boost adds high-frequency emphasis that aliases ugly over an
-      // 8 kHz μ-law line. Slightly higher stability tames the excursions
-      // that compander quantization noise can amplify.
-      stability: 0.6,
-      similarity_boost: 0.75,
-      use_speaker_boost: false
-    };
-    return new _ElevenLabsTTS(apiKey, {
-      ...options,
-      voiceSettings,
-      outputFormat: ElevenLabsOutputFormat.ULAW_8000
-    });
-  }
-  /**
-   * Construct an instance pre-configured for Telnyx bidirectional media.
-   *
-   * Telnyx's default media-streaming codec is L16 PCM @ 16 kHz, which
-   * matches our default Telnyx handler. We pick `pcm_16000` so the audio
-   * flows end-to-end with zero resampling or transcoding.
-   *
-   * Trade-off: if your Telnyx profile is pinned to PCMU/8000 (μ-law),
-   * construct `ElevenLabsTTS` directly with `outputFormat: 'ulaw_8000'`
-   * — Telnyx supports that natively too.
-   */
-  static forTelnyx(apiKey, options = {}) {
-    return new _ElevenLabsTTS(apiKey, {
-      ...options,
-      outputFormat: ElevenLabsOutputFormat.PCM_16000
-    });
-  }
-  /**
-   * 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). `chunkSize` controls the maximum yield size — 512 is a
-   * good choice for low-latency telephony.
-   */
-  async *synthesizeStream(text) {
-    const url2 = `${ELEVENLABS_BASE_URL}/text-to-speech/${encodeURIComponent(this.voiceId)}/stream?output_format=${encodeURIComponent(this.outputFormat)}`;
-    const body = {
-      text,
-      model_id: this.modelId
-    };
-    if (this.voiceSettings) body["voice_settings"] = this.voiceSettings;
-    if (this.languageCode) body["language_code"] = this.languageCode;
-    const response = await fetch(url2, {
-      method: "POST",
-      headers: {
-        "xi-api-key": this.apiKey,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (!response.ok) {
-      const errBody = await response.text();
-      throw new Error(`ElevenLabs TTS error ${response.status}: ${errBody}`);
-    }
-    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) continue;
-        const buf = Buffer.from(value);
-        for (let offset = 0; offset < buf.length; offset += this.chunkSize) {
-          yield buf.subarray(offset, Math.min(offset + this.chunkSize, buf.length));
-        }
-      }
-    } finally {
-      if (typeof reader.cancel === "function") await reader.cancel().catch(() => {
-      });
-      reader.releaseLock();
-    }
-  }
-};
-
-// src/tts/elevenlabs.ts
 function resolveApiKey(apiKey) {
   const key = apiKey ?? process.env.ELEVENLABS_API_KEY;
   if (!key) {
@@ -36959,7 +37732,7 @@ var TTS = class _TTS extends ElevenLabsTTS {
     super(resolveApiKey(opts.apiKey), {
       voiceId: opts.voiceId ?? "EXAVITQu4vr4xnSDxMaL",
       modelId: opts.modelId ?? "eleven_flash_v2_5",
-      outputFormat: opts.outputFormat ?? "pcm_16000",
+      ...opts.outputFormat !== void 0 ? { outputFormat: opts.outputFormat } : {},
       languageCode: opts.languageCode,
       voiceSettings: opts.voiceSettings
     });
@@ -37031,6 +37804,20 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
    * changes.
    */
   adoptedConnection = null;
+  /**
+   * Active WS for the in-flight ``synthesizeStream`` call, if any. Set
+   * when a stream starts, cleared in its ``finally`` block. The
+   * stream-handler calls ``cancelActiveStream()`` from ``cancelSpeaking``
+   * to unblock the generator's inner ``await Promise<frame>`` — without
+   * it, a barge-in on the firstMessage live path leaves the for-await
+   * stuck waiting for the next frame; ElevenLabs never sends
+   * ``isFinal=true`` after the consumer breaks, the 30 s frame timeout
+   * fires post-call, and meanwhile ``initPipeline`` never returns so
+   * the STT ``onTranscript`` callback never registers and subsequent
+   * user turns are silently dropped (root cause of the 2026-05-20
+   * "first message OK, then no response" symptom).
+   */
+  activeStreamWs = null;
   /**
    * The wire format requested over the ElevenLabs WS. Initially set from
    * the constructor; ``setTelephonyCarrier`` may auto-flip it to the
@@ -37079,6 +37866,32 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
     if (!native) return;
     this._outputFormat = native;
   }
+  /**
+   * Force-close the WebSocket of any in-flight ``synthesizeStream`` call.
+   * Called by the stream-handler from ``cancelSpeaking`` (barge-in) so
+   * the generator's inner ``await Promise<frame>`` loop unblocks cleanly
+   * via the ``onClose`` handler — instead of waiting up to 30 s for the
+   * ``FRAME_TIMEOUT_MS`` watchdog to fire. No-op when no stream is in
+   * flight or when the WS is already closing.
+   *
+   * Without this, a barge-in during the firstMessage live path left the
+   * for-await stuck (ElevenLabs never sends ``isFinal=true`` after the
+   * consumer breaks), ``initPipeline`` never returned, the STT
+   * ``onTranscript`` callback never registered, and the entire remainder
+   * of the call was silent for the user. Surfaced during the 2026-05-20
+   * acceptance run.
+   */
+  cancelActiveStream() {
+    const ws = this.activeStreamWs;
+    if (!ws) return;
+    this.activeStreamWs = null;
+    try {
+      if (ws.readyState === import_ws11.default.OPEN || ws.readyState === import_ws11.default.CONNECTING) {
+        ws.close();
+      }
+    } catch {
+    }
+  }
   /** Pre-configured for Twilio Media Streams (`ulaw_8000`). */
   static forTwilio(opts) {
     return new _ElevenLabsWebSocketTTS({
@@ -37164,6 +37977,7 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
         headers: { "xi-api-key": this.apiKey }
       });
     }
+    this.activeStreamWs = ws;
     const queue = [];
     let done = false;
     let pendingError = null;
@@ -37234,7 +38048,7 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
     ws.on("error", onError);
     try {
       if (!adopted) {
-        await new Promise((resolve, reject) => {
+        await new Promise((resolve2, reject) => {
           connectTimer = setTimeout(
             () => reject(new Error("ElevenLabs WS connect timeout")),
             CONNECT_TIMEOUT_MS4
@@ -37242,7 +38056,7 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
           ws.once("open", () => {
             if (connectTimer) clearTimeout(connectTimer);
             connectTimer = void 0;
-            resolve();
+            resolve2();
           });
           ws.once("error", (err) => {
             if (connectTimer) clearTimeout(connectTimer);
@@ -37284,6 +38098,7 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
       }
     } finally {
       if (connectTimer) clearTimeout(connectTimer);
+      if (this.activeStreamWs === ws) this.activeStreamWs = null;
       try {
         if (ws.readyState === import_ws11.default.OPEN) {
           ws.send(JSON.stringify({ text: "" }));
@@ -37326,14 +38141,14 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
       headers: { "xi-api-key": this.apiKey }
     });
     try {
-      await new Promise((resolve, reject) => {
+      await new Promise((resolve2, reject) => {
         const timer = setTimeout(
           () => reject(new Error("ElevenLabs WS TTS warmup connect timeout")),
           CONNECT_TIMEOUT_MS4
         );
         ws.once("open", () => {
           clearTimeout(timer);
-          resolve();
+          resolve2();
         });
         ws.once("error", (err) => {
           clearTimeout(timer);
@@ -37377,14 +38192,14 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
     const ws = new import_ws11.default(this.buildUrl(), {
       headers: { "xi-api-key": this.apiKey }
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(
         () => reject(new Error("ElevenLabs WS park connect timeout")),
         CONNECT_TIMEOUT_MS4
       );
       ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       ws.once("error", (err) => {
         clearTimeout(timer);
@@ -37456,9 +38271,9 @@ function buildOpts(opts) {
   const out = {
     apiKey: resolveApiKey2(opts.apiKey),
     modelId: opts.modelId ?? "eleven_flash_v2_5",
-    outputFormat: opts.outputFormat ?? "pcm_16000",
     autoMode: opts.autoMode ?? true
   };
+  if (opts.outputFormat !== void 0) out.outputFormat = opts.outputFormat;
   if (opts.voiceId !== void 0) out.voiceId = opts.voiceId;
   if (opts.voiceSettings !== void 0) out.voiceSettings = opts.voiceSettings;
   if (opts.languageCode !== void 0) out.languageCode = opts.languageCode;
@@ -37706,198 +38521,6 @@ var TTS3 = class extends OpenAITTS {
 
 // src/tts/cartesia.ts
 init_cjs_shims();
-
-// src/providers/cartesia-tts.ts
-init_cjs_shims();
-init_logger();
-var CARTESIA_BASE_URL = "https://api.cartesia.ai";
-var CARTESIA_API_VERSION = "2025-04-16";
-var CARTESIA_DEFAULT_VOICE_ID = "f786b574-daa5-4673-aa0c-cbe3e8534c02";
-var CartesiaTTSModel = {
-  SONIC_3: "sonic-3",
-  SONIC_2: "sonic-2",
-  SONIC: "sonic"
-};
-var CartesiaTTSContainer = {
-  RAW: "raw",
-  WAV: "wav",
-  MP3: "mp3"
-};
-var CartesiaTTSEncoding = {
-  PCM_S16LE: "pcm_s16le",
-  PCM_F32LE: "pcm_f32le",
-  PCM_MULAW: "pcm_mulaw",
-  PCM_ALAW: "pcm_alaw"
-};
-var CartesiaTTSSampleRate = {
-  HZ_8000: 8e3,
-  HZ_16000: 16e3,
-  HZ_22050: 22050,
-  HZ_24000: 24e3,
-  HZ_44100: 44100
-};
-var CartesiaTTSVoiceMode = {
-  ID: "id",
-  EMBEDDING: "embedding"
-};
-var CartesiaTTS = class _CartesiaTTS {
-  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
-  static providerKey = "cartesia_tts";
-  apiKey;
-  model;
-  voice;
-  language;
-  sampleRate;
-  speed;
-  emotion;
-  volume;
-  baseUrl;
-  apiVersion;
-  constructor(apiKey, opts = {}) {
-    this.apiKey = apiKey;
-    this.model = opts.model ?? CartesiaTTSModel.SONIC_3;
-    this.voice = opts.voice ?? CARTESIA_DEFAULT_VOICE_ID;
-    this.language = opts.language ?? "en";
-    this.sampleRate = opts.sampleRate ?? CartesiaTTSSampleRate.HZ_16000;
-    this.speed = opts.speed;
-    this.emotion = typeof opts.emotion === "string" ? [opts.emotion] : opts.emotion;
-    this.volume = opts.volume;
-    this.baseUrl = opts.baseUrl ?? CARTESIA_BASE_URL;
-    this.apiVersion = opts.apiVersion ?? CARTESIA_API_VERSION;
-  }
-  /**
-   * Construct an instance pre-configured for Twilio Media Streams.
-   *
-   * Sets `sampleRate=8000` so Cartesia emits PCM_S16LE @ 8 kHz directly.
-   * Twilio's media stream uses μ-law @ 8 kHz so the SDK still does the
-   * PCM → μ-law transcode client-side, but the 16 kHz → 8 kHz resample
-   * step is skipped. Saves ~10–30 ms first-byte plus per-frame CPU and
-   * removes a potential aliasing source.
-   */
-  static forTwilio(apiKey, options = {}) {
-    return new _CartesiaTTS(apiKey, {
-      ...options,
-      sampleRate: CartesiaTTSSampleRate.HZ_8000
-    });
-  }
-  /**
-   * Construct an instance pre-configured for Telnyx bidirectional media.
-   *
-   * Sets `sampleRate=16000` to match Telnyx's L16/16000 default codec —
-   * audio flows end-to-end with zero resampling or transcoding. Same as
-   * the bare-constructor default; exists for API symmetry with
-   * {@link CartesiaTTS.forTwilio}.
-   */
-  static forTelnyx(apiKey, options = {}) {
-    return new _CartesiaTTS(apiKey, {
-      ...options,
-      sampleRate: CartesiaTTSSampleRate.HZ_16000
-    });
-  }
-  /** Build the JSON payload for the Cartesia bytes endpoint. */
-  buildPayload(text) {
-    const payload = {
-      model_id: this.model,
-      voice: { mode: CartesiaTTSVoiceMode.ID, id: this.voice },
-      transcript: text,
-      output_format: {
-        container: CartesiaTTSContainer.RAW,
-        encoding: CartesiaTTSEncoding.PCM_S16LE,
-        sample_rate: this.sampleRate
-      },
-      language: this.language
-    };
-    const generationConfig = {};
-    if (this.speed !== void 0) generationConfig.speed = this.speed;
-    if (this.emotion && this.emotion.length > 0)
-      generationConfig.emotion = this.emotion[0];
-    if (this.volume !== void 0) generationConfig.volume = this.volume;
-    if (Object.keys(generationConfig).length > 0) {
-      payload.generation_config = generationConfig;
-    }
-    return payload;
-  }
-  /**
-   * Pre-call HTTP warmup for the Cartesia `/tts/bytes` endpoint.
-   *
-   * Issues a lightweight `GET <baseUrl>/voices` so DNS, TLS, and HTTP/2
-   * are already up by the time the first `synthesizeStream()` POST
-   * lands. Best-effort: 5 s timeout, all exceptions swallowed at
-   * debug level.
-   *
-   * Billing safety: `GET /voices` is a free metadata read on
-   * Cartesia's REST surface (per https://docs.cartesia.ai). It does
-   * not consume synthesis credits. The actual synthesis is billed
-   * only when `POST /tts/bytes` runs with a non-empty `transcript`.
-   *
-   * Note: Cartesia TTS uses the HTTP path (vs the WebSocket variant
-   * Cartesia also exposes) — connection warmup is therefore HTTP-GET
-   * based, not WebSocket pre-handshake. The latency win is smaller
-   * (~50-150 ms vs the ~200-500 ms of a WS prewarm) but still real.
-   */
-  async warmup() {
-    try {
-      await fetch(`${this.baseUrl}/voices`, {
-        method: "GET",
-        headers: {
-          "X-API-Key": this.apiKey,
-          "Cartesia-Version": this.apiVersion
-        },
-        signal: AbortSignal.timeout(5e3)
-      });
-    } catch (err) {
-      getLogger().debug(`Cartesia TTS warmup failed (best-effort): ${String(err)}`);
-    }
-  }
-  /** Synthesize text and return the concatenated audio buffer. */
-  async synthesize(text) {
-    const chunks = [];
-    for await (const chunk of this.synthesizeStream(text)) {
-      chunks.push(chunk);
-    }
-    return Buffer.concat(chunks);
-  }
-  /**
-   * Synthesize text and yield raw PCM_S16LE chunks at the configured
-   * `sampleRate` as they arrive from Cartesia.
-   */
-  async *synthesizeStream(text) {
-    const response = await fetch(`${this.baseUrl}/tts/bytes`, {
-      method: "POST",
-      headers: {
-        "X-API-Key": this.apiKey,
-        "Cartesia-Version": this.apiVersion,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(this.buildPayload(text)),
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Cartesia TTS error ${response.status}: ${body}`);
-    }
-    if (!response.body) {
-      throw new Error("Cartesia 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/cartesia.ts
 function resolveApiKey3(apiKey) {
   const key = apiKey ?? process.env.CARTESIA_API_KEY;
   if (!key) {
@@ -37927,150 +38550,6 @@ var TTS4 = class _TTS extends CartesiaTTS {
 
 // src/tts/rime.ts
 init_cjs_shims();
-
-// src/providers/rime-tts.ts
-init_cjs_shims();
-var RIME_BASE_URL = "https://users.rime.ai/v1/rime-tts";
-var RimeModel = {
-  ARCANA: "arcana",
-  MIST: "mist",
-  MIST_V2: "mistv2"
-};
-var RimeAudioFormat = {
-  PCM: "audio/pcm",
-  MP3: "audio/mp3",
-  WAV: "audio/wav",
-  MULAW: "audio/mulaw"
-};
-var ARCANA_MODEL_TIMEOUT_MS = 60 * 4 * 1e3;
-var MIST_MODEL_TIMEOUT_MS = 30 * 1e3;
-function isMistModel(model) {
-  return model.includes(RimeModel.MIST);
-}
-function timeoutForModel(model) {
-  if (model === RimeModel.ARCANA) return ARCANA_MODEL_TIMEOUT_MS;
-  return MIST_MODEL_TIMEOUT_MS;
-}
-var RimeTTS = class {
-  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
-  static providerKey = "rime";
-  apiKey;
-  model;
-  speaker;
-  lang;
-  sampleRate;
-  repetitionPenalty;
-  temperature;
-  topP;
-  maxTokens;
-  speedAlpha;
-  reduceLatency;
-  pauseBetweenBrackets;
-  phonemizeBetweenBrackets;
-  baseUrl;
-  totalTimeoutMs;
-  constructor(apiKey, opts = {}) {
-    this.apiKey = apiKey;
-    this.model = opts.model ?? RimeModel.ARCANA;
-    const defaultSpeaker = isMistModel(this.model) ? "cove" : "astra";
-    this.speaker = opts.speaker ?? defaultSpeaker;
-    this.lang = opts.lang ?? "eng";
-    this.sampleRate = opts.sampleRate ?? 16e3;
-    this.repetitionPenalty = opts.repetitionPenalty;
-    this.temperature = opts.temperature;
-    this.topP = opts.topP;
-    this.maxTokens = opts.maxTokens;
-    this.speedAlpha = opts.speedAlpha;
-    this.reduceLatency = opts.reduceLatency;
-    this.pauseBetweenBrackets = opts.pauseBetweenBrackets;
-    this.phonemizeBetweenBrackets = opts.phonemizeBetweenBrackets;
-    this.baseUrl = opts.baseUrl ?? RIME_BASE_URL;
-    this.totalTimeoutMs = timeoutForModel(this.model);
-  }
-  buildPayload(text) {
-    const payload = {
-      speaker: this.speaker,
-      text,
-      modelId: this.model
-    };
-    if (this.model === RimeModel.ARCANA) {
-      if (this.repetitionPenalty !== void 0)
-        payload.repetition_penalty = this.repetitionPenalty;
-      if (this.temperature !== void 0) payload.temperature = this.temperature;
-      if (this.topP !== void 0) payload.top_p = this.topP;
-      if (this.maxTokens !== void 0) payload.max_tokens = this.maxTokens;
-      payload.lang = this.lang;
-      payload.samplingRate = this.sampleRate;
-    } else if (isMistModel(this.model)) {
-      payload.lang = this.lang;
-      payload.samplingRate = this.sampleRate;
-      if (this.speedAlpha !== void 0) payload.speedAlpha = this.speedAlpha;
-      if (this.model === RimeModel.MIST_V2 && this.reduceLatency !== void 0) {
-        payload.reduceLatency = this.reduceLatency;
-      }
-      if (this.pauseBetweenBrackets !== void 0) {
-        payload.pauseBetweenBrackets = this.pauseBetweenBrackets;
-      }
-      if (this.phonemizeBetweenBrackets !== void 0) {
-        payload.phonemizeBetweenBrackets = this.phonemizeBetweenBrackets;
-      }
-    }
-    return payload;
-  }
-  /** Synthesize text and return the concatenated audio buffer. */
-  async synthesize(text) {
-    const chunks = [];
-    for await (const chunk of this.synthesizeStream(text)) {
-      chunks.push(chunk);
-    }
-    return Buffer.concat(chunks);
-  }
-  /**
-   * Synthesize text and yield raw PCM_S16LE chunks at the configured
-   * `sampleRate` as they stream in.
-   */
-  async *synthesizeStream(text) {
-    const response = await fetch(this.baseUrl, {
-      method: "POST",
-      headers: {
-        accept: RimeAudioFormat.PCM,
-        Authorization: `Bearer ${this.apiKey}`,
-        "content-type": "application/json"
-      },
-      body: JSON.stringify(this.buildPayload(text)),
-      signal: AbortSignal.timeout(this.totalTimeoutMs)
-    });
-    if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`Rime TTS error ${response.status}: ${body}`);
-    }
-    const contentType = response.headers.get("content-type") ?? "";
-    if (!contentType.startsWith("audio")) {
-      const body = await response.text();
-      throw new Error(`Rime returned non-audio response: ${body.slice(0, 500)}`);
-    }
-    if (!response.body) {
-      throw new Error("Rime 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/rime.ts
 var TTS5 = class extends RimeTTS {
   static providerKey = "rime";
   constructor(opts = {}) {
@@ -38715,12 +39194,7 @@ init_cjs_shims();
 init_cjs_shims();
 init_llm_loop();
 init_logger();
-
-// src/version.ts
-init_cjs_shims();
-var VERSION = "0.5.5";
-
-// src/providers/groq-llm.ts
+init_version();
 var GROQ_BASE_URL = "https://api.groq.com/openai/v1";
 var GroqModel = {
   LLAMA_3_3_70B_VERSATILE: "llama-3.3-70b-versatile",
@@ -38910,6 +39384,7 @@ init_cjs_shims();
 init_llm_loop();
 init_logger();
 init_errors();
+init_version();
 var CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
 var CerebrasModel = {
   GPT_OSS_120B: "gpt-oss-120b",
@@ -40308,8 +40783,8 @@ var TwilioAdapter = class _TwilioAdapter {
     this.baseUrl = opts.region ? `https://api.${opts.region}.twilio.com/2010-04-01` : TWILIO_API_BASE2;
     this.authHeader = `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`;
   }
-  async request(method, path5, body) {
-    const url2 = `${this.baseUrl}/Accounts/${encodeURIComponent(this.accountSid)}${path5}`;
+  async request(method, path6, body) {
+    const url2 = `${this.baseUrl}/Accounts/${encodeURIComponent(this.accountSid)}${path6}`;
     const headers = { Authorization: this.authHeader };
     if (body) headers["Content-Type"] = "application/x-www-form-urlencoded";
     const response = await fetch(url2, {
@@ -40320,7 +40795,7 @@ var TwilioAdapter = class _TwilioAdapter {
     });
     const text = await response.text();
     if (!response.ok) {
-      throw new Error(`Twilio ${method} ${path5} failed: ${response.status} ${text}`);
+      throw new Error(`Twilio ${method} ${path6} failed: ${response.status} ${text}`);
     }
     if (!text) return {};
     try {
@@ -40338,8 +40813,8 @@ var TwilioAdapter = class _TwilioAdapter {
     const country = encodeURIComponent(opts.countryCode);
     const queryParts = ["PageSize=1"];
     if (opts.areaCode) queryParts.push(`AreaCode=${encodeURIComponent(opts.areaCode)}`);
-    const path5 = `/AvailablePhoneNumbers/${country}/Local.json?${queryParts.join("&")}`;
-    const available = await this.request("GET", path5);
+    const path6 = `/AvailablePhoneNumbers/${country}/Local.json?${queryParts.join("&")}`;
+    const available = await this.request("GET", path6);
     const first = available.available_phone_numbers?.[0]?.phone_number;
     if (!first) {
       throw new Error(`TwilioAdapter: no numbers available for country ${opts.countryCode}`);
@@ -40397,12 +40872,28 @@ var TwilioAdapter = class _TwilioAdapter {
     return { callSid: call.sid };
   }
   /**
-   * Build a minimal ``<Response><Connect><Stream url="..."/></Connect></Response>``
-   * TwiML document. Mirrors the Python adapter's ``generate_stream_twiml``.
+   * Build a ``<Response><Connect><Stream url="...">`` TwiML document.
+   *
+   * ``parameters`` is forwarded as ``<Parameter name="..." value="..."/>``
+   * children of ``<Stream>``. Twilio Media Streams strips query-string params
+   * from the ``<Stream url=...>`` before the WS handshake, so
+   * ``<Parameter>`` tags are the supported way to pre-populate
+   * ``start.customParameters`` on the WS ``start`` frame. Used by the
+   * inbound path to carry caller / callee through to the bridge.
+   *
+   * Mirrors the Python adapter's ``generate_stream_twiml``.
    */
-  static generateStreamTwiml(streamUrl) {
-    const escaped = streamUrl.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-    return `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${escaped}"/></Connect></Response>`;
+  static generateStreamTwiml(streamUrl, parameters) {
+    const esc2 = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+    const escapedUrl = esc2(streamUrl);
+    let paramTags = "";
+    if (parameters) {
+      for (const [name, value] of Object.entries(parameters)) {
+        if (value == null) continue;
+        paramTags += `<Parameter name="${esc2(name)}" value="${esc2(String(value))}"/>`;
+      }
+    }
+    return `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${escapedUrl}">${paramTags}</Stream></Connect></Response>`;
   }
   /** Force-complete an in-progress call. */
   async endCall(callSid) {
@@ -40435,8 +40926,8 @@ var TelnyxAdapter = class {
     this.apiKey = apiKey;
     this.connectionId = connectionId;
   }
-  async request(method, path5, body) {
-    const url2 = `${this.baseUrl}${path5}`;
+  async request(method, path6, body) {
+    const url2 = `${this.baseUrl}${path6}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`
     };
@@ -40449,7 +40940,7 @@ var TelnyxAdapter = class {
     });
     const text = await response.text();
     if (!response.ok) {
-      throw new Error(`Telnyx ${method} ${path5} failed: ${response.status} ${text}`);
+      throw new Error(`Telnyx ${method} ${path6} failed: ${response.status} ${text}`);
     }
     if (!text) return {};
     try {
@@ -40610,11 +41101,11 @@ var TelnyxSTT = class {
     this.ws = new import_ws12.default(url2, {
       headers: { Authorization: `Bearer ${this.apiKey}` }
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(() => reject(new Error("Telnyx STT connect timeout")), 1e4);
       this.ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       this.ws.once("error", (err) => {
         clearTimeout(timer);
@@ -40722,11 +41213,11 @@ var TelnyxTTS = class {
     const ws = new import_ws13.default(url2, {
       headers: { Authorization: `Bearer ${this.apiKey}` }
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(() => reject(new Error("Telnyx TTS connect timeout")), 1e4);
       ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       ws.once("error", (err) => {
         clearTimeout(timer);
@@ -40772,7 +41263,7 @@ var TelnyxTTS = class {
     ws.send(JSON.stringify({ text: "" }));
     try {
       while (true) {
-        const item = queue.length > 0 ? queue.shift() : await new Promise((resolve) => waiters.push(resolve));
+        const item = queue.length > 0 ? queue.shift() : await new Promise((resolve2) => waiters.push(resolve2));
         if (item === null) return;
         if (typeof item === "object" && "error" in item) throw item.error;
         yield item;
@@ -40801,6 +41292,8 @@ init_event_bus();
   CallMetricsAccumulator,
   CartesiaSTT,
   CartesiaTTS,
+  CartesiaTTSModel,
+  CartesiaTTSVoiceMode,
   CerebrasLLM,
   ChatContext,
   CloudflareTunnel,
@@ -40808,10 +41301,13 @@ init_event_bus();
   DEFAULT_PRICING,
   DTMF_EVENTS,
   DeepFilterNetFilter,
+  DeepgramModel,
   DeepgramSTT,
   DefaultToolExecutor,
   ElevenLabsConvAI,
   ElevenLabsConvAIAdapter,
+  ElevenLabsModel,
+  ElevenLabsOutputFormat,
   ElevenLabsRestTTS,
   ElevenLabsTTS,
   ElevenLabsWebSocketTTS,
@@ -40840,8 +41336,15 @@ init_event_bus();
   OpenAIRealtime2,
   OpenAIRealtime2Adapter,
   OpenAIRealtimeAdapter,
+  OpenAIRealtimeAudioFormat,
+  OpenAIRealtimeModel,
+  OpenAIRealtimeVADType,
   OpenAITTS,
   OpenAITranscribeSTT,
+  OpenAITranscriptionModel,
+  OpenAIVoice,
+  PRICING_LAST_UPDATED,
+  PRICING_VERSION,
   PartialStreamError,
   Patter,
   PatterConnectionError,
@@ -40849,9 +41352,12 @@ init_event_bus();
   PatterTool,
   PcmCarry,
   PipelineHookExecutor,
+  PricingUnit,
   ProvisionError,
   RateLimitError,
   RemoteMessageHandler,
+  RimeAudioFormat,
+  RimeModel,
   RimeTTS,
   SPAN_BARGEIN,
   SPAN_CALL,