getpatter 0.6.0 → 0.6.1

package/dist/index.mjs

@@ -15,6 +15,7 @@ import {
   LLMLoop,
   MetricsStore,
   OpenAILLMProvider,
+  OpenAIRealtime2Adapter,
   OpenAIRealtimeAdapter,
   PatterConnectionError,
   PatterError,
@@ -59,7 +60,12 @@ import {
   resample8kTo16k,
   resolveLogRoot,
   startSpan
-} from "./chunk-JUQ5WQTQ.mjs";
+} from "./chunk-TEW3NAZJ.mjs";
+import {
+  MinWordsStrategy,
+  evaluateStrategies,
+  resetStrategies
+} from "./chunk-D4424JZR.mjs";
 import {
   getLogger,
   setLogger
@@ -69,7 +75,7 @@ import {
 } from "./chunk-6GR5MHHQ.mjs";
 import {
   SileroVAD
-} from "./chunk-X3364LSI.mjs";
+} from "./chunk-RV7APPYE.mjs";
 import {
   __dirname,
   __require,
@@ -106,6 +112,30 @@ var Realtime = class {
   }
 };
 
+// src/engines/openai-2.ts
+init_esm_shims();
+var Realtime2 = class {
+  kind = "openai_realtime_2";
+  apiKey;
+  model;
+  voice;
+  reasoningEffort;
+  inputAudioTranscriptionModel;
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!key) {
+      throw new Error(
+        "OpenAI Realtime 2 requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
+      );
+    }
+    this.apiKey = key;
+    this.model = opts.model ?? "gpt-realtime-2";
+    this.voice = opts.voice ?? "alloy";
+    this.reasoningEffort = opts.reasoningEffort;
+    this.inputAudioTranscriptionModel = opts.inputAudioTranscriptionModel;
+  }
+};
+
 // src/engines/elevenlabs.ts
 init_esm_shims();
 var ConvAI = class {
@@ -520,12 +550,35 @@ function filterUndef(obj) {
 }
 
 // src/client.ts
+var PREWARM_CACHE_MAX = 200;
+var PREWARM_TTL_GRACE_MS = 5e3;
+var PARKED_CONN_TTL_MS = 3e4;
 function resolvePersistRoot(persist) {
   if (persist === false) return null;
   if (persist === true) return resolveLogRoot("auto");
   if (typeof persist === "string") return resolveLogRoot(persist);
   return resolveLogRoot();
 }
+function closeParkedConnections(slot) {
+  if (slot.stt) {
+    try {
+      slot.stt.close();
+    } catch {
+    }
+  }
+  if (slot.tts) {
+    try {
+      slot.tts.ws.close();
+    } catch {
+    }
+  }
+  if (slot.openaiRealtime) {
+    try {
+      slot.openaiRealtime.close();
+    } catch {
+    }
+  }
+}
 var Patter = class {
   localConfig;
   embeddedServer = null;
@@ -546,6 +599,65 @@ var Patter = class {
    * ``Cannot use both tunnel: true and webhookUrl``.
    */
   tunnelOwnsWebhookUrl = false;
+  /**
+   * Pre-rendered first-message TTS audio per outbound call_id. Populated
+   * by :meth:`call` when ``agent.prewarmFirstMessage`` is true; consumed
+   * by the StreamHandler firstMessage emit so the greeting streams
+   * instantly on ``start`` instead of paying the 200-700 ms TTS first-byte
+   * latency. See ``AgentOptions.prewarmFirstMessage``.
+   *
+   * Stores raw bytes in the TTS provider's native sample rate; the
+   * carrier-side audio sender resamples on emit.
+   */
+  prewarmAudio = /* @__PURE__ */ new Map();
+  /**
+   * Call IDs whose prewarm cache slot has already been consumed —
+   * either by ``popPrewarmAudio`` (cache hit OR miss on the firstMessage
+   * emit path) or by ``recordPrewarmWaste`` (call ended before pickup).
+   * The prewarm task checks this set BEFORE writing bytes so a slow
+   * synth that finishes after the consumer already polled doesn't
+   * orphan bytes in ``prewarmAudio``. See FIX #92 in the parity audit.
+   */
+  prewarmConsumed = /* @__PURE__ */ new Set();
+  /**
+   * Background tasks tracked so :meth:`disconnect` can wait on / drop any
+   * still-running prewarm-first-message synth before tearing down.
+   */
+  prewarmTasks = /* @__PURE__ */ new Set();
+  /**
+   * TTL eviction timers keyed by call_id so :meth:`disconnect` (and
+   * normal consumption / waste-record paths) can cancel any pending
+   * timer when the slot drains naturally. Without this, the timer
+   * would WARN spuriously after the cache was already emptied.
+   */
+  prewarmTtlTimers = /* @__PURE__ */ new Map();
+  /**
+   * Pre-opened, fully-handshaked provider WebSockets keyed by
+   * carrier-issued call_id. Populated by ``parkProviderConnections``
+   * during the carrier ringing window; consumed by the per-call
+   * StreamHandler at ``start`` via ``adoptWebSocket(...)`` so STT / TTS
+   * / Realtime audio can flow on the first turn without paying the
+   * 150-900 ms TLS + WS-upgrade + protocol-handshake round-trip again.
+   *
+   * Distinct from ``prewarmAudio`` (which holds pre-rendered TTS bytes
+   * for the first message); the two features are complementary and
+   * orthogonal — both can be active for the same call.
+   *
+   * Each slot may hold up to three parked connections (STT, TTS,
+   * Realtime). Drained by:
+   *   - {@link popPrewarmedConnections} on the carrier ``start`` event
+   *     (consumed normally — the handles transfer to the StreamHandler)
+   *   - {@link recordPrewarmWaste} on call-termination paths (no-answer,
+   *     busy, failed, canceled, AMD voicemail). Closes parked sockets.
+   *   - {@link disconnect} on Patter teardown. Closes all parked sockets.
+   */
+  prewarmedConnections = /* @__PURE__ */ new Map();
+  /**
+   * TTL eviction handles keyed by call_id for connections that are never
+   * adopted (e.g. a carrier that swallows ``start``). Closes the parked
+   * sockets so they don't leak past the safety window.
+   */
+  prewarmedConnTimers = /* @__PURE__ */ new Map();
   /**
    * Speech-edge events for turn-taking instrumentation. Public surface: the
    * seven `on*` proxy accessors below plus the `conversationState` snapshot.
@@ -553,13 +665,15 @@ var Patter = class {
    * the previous behaviour.
    *
    * See `src/_speech-events.ts` for the full event taxonomy and the
-   * industry-alignment table (LiveKit / Pipecat / OpenAI Realtime).
+   * OpenAI Realtime alignment table.
    */
   speechEvents = new SpeechEvents();
   // ---- Speech-edge event callback proxies ------------------------------
-  // The seven `on*` properties below mirror the public APIs of LiveKit
-  // Agents, Pipecat and OpenAI Realtime. They proxy to `speechEvents` so
-  // the dispatcher remains the single source of truth (state + OTel).
+  // The seven `on*` properties below follow the canonical voice-agent
+  // metric set (user/agent state transitions, turn boundaries, TTFT, audio
+  // first-byte) and align with OpenAI Realtime where applicable. They
+  // proxy to `speechEvents` so the dispatcher remains the single source of
+  // truth (state + OTel).
   get onUserSpeechStarted() {
     return this.speechEvents.onUserSpeechStarted;
   }
@@ -604,8 +718,8 @@ var Patter = class {
   }
   /**
    * Snapshot of the current per-side state of the call.
-   * Mirrors LiveKit's `user_state_changed` / `agent_state_changed`
-   * payloads. Read-only and safe to call at any time.
+   * Returns the user_state / agent_state payload shape — read-only and
+   * safe to call at any time.
    */
   get conversationState() {
     return this.speechEvents.conversationState;
@@ -717,7 +831,7 @@ var Patter = class {
         );
       }
       const engine = opts.engine;
-      if (engine instanceof Realtime) {
+      if (engine instanceof Realtime || engine instanceof Realtime2) {
         working = {
           ...working,
           provider: "openai_realtime",
@@ -735,7 +849,7 @@ var Patter = class {
         };
       } else {
         throw new Error(
-          "Unknown engine. Expected OpenAIRealtime or ElevenLabsConvAI instance."
+          "Unknown engine. Expected OpenAIRealtime, OpenAIRealtime2, or ElevenLabsConvAI instance."
         );
       }
     } else if (!working.provider && (working.stt !== void 0 || working.tts !== void 0 || working.llm !== void 0)) {
@@ -795,6 +909,13 @@ var Patter = class {
     if (!opts.agent.systemPrompt && opts.agent.provider !== "pipeline") {
       throw new Error("agent.systemPrompt is required");
     }
+    if (opts.agent.echoCancellation) {
+      try {
+        await import("./aec-PJJMUM5E.mjs");
+      } catch (err) {
+        getLogger().debug(`AEC pre-import failed at serve(): ${String(err)}`);
+      }
+    }
     if (opts.port !== void 0) {
       if (typeof opts.port !== "number" || opts.port < 1 || opts.port > 65535) {
         throw new RangeError(`port must be between 1 and 65535, got ${opts.port}`);
@@ -876,6 +997,9 @@ var Patter = class {
       opts.dashboard ?? true,
       opts.dashboardToken ?? ""
     );
+    this.embeddedServer.popPrewarmAudio = this.popPrewarmAudio;
+    this.embeddedServer.popPrewarmedConnections = this.popPrewarmedConnections;
+    this.embeddedServer.recordPrewarmWaste = this.recordPrewarmWaste;
     try {
       await this.embeddedServer.start(port);
       if (this.tunnelHandle) {
@@ -890,7 +1014,7 @@ var Patter = class {
   }
   /** Run the agent in interactive terminal-test mode (no real telephony). */
   async test(opts) {
-    const { TestSession: TestSession2 } = await import("./test-mode-Y7YG5LFZ.mjs");
+    const { TestSession: TestSession2 } = await import("./test-mode-WEKKNBLD.mjs");
     const session = new TestSession2();
     await session.run({
       agent: opts.agent,
@@ -900,6 +1024,325 @@ var Patter = class {
       onCallEnd: opts.onCallEnd
     });
   }
+  /**
+   * Pop and return the pre-synthesised first-message audio for ``callId``.
+   *
+   * Returns ``undefined`` when ``agent.prewarmFirstMessage`` was not set
+   * for the originating outbound call, or when the synth was still in
+   * flight at the moment the carrier emitted ``start`` (cache miss — the
+   * StreamHandler falls back to live TTS).
+   *
+   * Called by the per-call StreamHandler at the start of the firstMessage
+   * emit. Returning bytes here lets the handler skip the live TTS
+   * synthesis and stream the cached buffer directly.
+   *
+   * Marks ``callId`` as consumed regardless of cache hit/miss so a slow
+   * synth task that finishes after this call drops its bytes instead of
+   * orphaning them in ``prewarmAudio``. See FIX #92.
+   */
+  popPrewarmAudio = (callId) => {
+    this.prewarmConsumed.add(callId);
+    const ttl = this.prewarmTtlTimers.get(callId);
+    if (ttl !== void 0) {
+      clearTimeout(ttl);
+      this.prewarmTtlTimers.delete(callId);
+    }
+    const buf = this.prewarmAudio.get(callId);
+    if (buf !== void 0) this.prewarmAudio.delete(callId);
+    return buf;
+  };
+  /**
+   * Log a warning if a prewarmed greeting was paid for but never used.
+   * The TTS bill for ``agent.firstMessage`` has already been incurred by
+   * the background synth task, so the user should know — opt-in feature
+   * with a known cost surface.
+   *
+   * Idempotent: the second call for the same ``callId`` is a no-op, so
+   * the status callback firing first and ``endCall`` running afterwards
+   * (or vice-versa) does not double-WARN. Public so the embedded
+   * server's webhook handlers can invoke it on no-answer / busy /
+   * failed / canceled / AMD-machine paths. See FIX #91.
+   */
+  recordPrewarmWaste = (callId) => {
+    this.closePrewarmedConnections(callId);
+    if (this.prewarmConsumed.has(callId)) {
+      this.prewarmAudio.delete(callId);
+      return;
+    }
+    this.prewarmConsumed.add(callId);
+    const ttl = this.prewarmTtlTimers.get(callId);
+    if (ttl !== void 0) {
+      clearTimeout(ttl);
+      this.prewarmTtlTimers.delete(callId);
+    }
+    const buf = this.prewarmAudio.get(callId);
+    if (buf !== void 0) {
+      this.prewarmAudio.delete(callId);
+      getLogger().warn(
+        `Prewarm wasted for call ${callId} \u2014 first-message TTS already paid (~${buf.byteLength} bytes synthesised) but call ended before pickup.`
+      );
+    }
+  };
+  /**
+   * Pop and return the parked provider WebSockets for ``callId``, or
+   * ``undefined`` when no parked connections exist.
+   *
+   * Wired into ``EmbeddedServer.popPrewarmedConnections`` so the
+   * per-call ``StreamHandler`` can adopt the parked sockets at the
+   * carrier ``start`` event instead of opening fresh ones — saving
+   * ~150-900 ms of cold-start handshake on the first turn.
+   */
+  popPrewarmedConnections = (callId) => {
+    const slot = this.prewarmedConnections.get(callId);
+    if (slot === void 0) return void 0;
+    this.prewarmedConnections.delete(callId);
+    const ttl = this.prewarmedConnTimers.get(callId);
+    if (ttl !== void 0) {
+      clearTimeout(ttl);
+      this.prewarmedConnTimers.delete(callId);
+    }
+    return slot;
+  };
+  /**
+   * Close any parked provider WebSockets for ``callId``. Wired into
+   * ``EmbeddedServer.closePrewarmedConnections`` so call-termination
+   * paths (no-answer, busy, failed, canceled, AMD voicemail) drop the
+   * sockets cleanly instead of leaving them to the upstream timeout.
+   */
+  closePrewarmedConnections = (callId) => {
+    const slot = this.prewarmedConnections.get(callId);
+    if (slot === void 0) return;
+    this.prewarmedConnections.delete(callId);
+    const ttl = this.prewarmedConnTimers.get(callId);
+    if (ttl !== void 0) {
+      clearTimeout(ttl);
+      this.prewarmedConnTimers.delete(callId);
+    }
+    closeParkedConnections(slot);
+  };
+  /**
+   * Open and park provider WebSockets in parallel with the carrier-side
+   * ``initiateCall``. Unlike :meth:`spawnProviderWarmup` (which closes
+   * the WS after a brief idle), the sockets opened here stay OPEN and
+   * are handed off to the per-call ``StreamHandler`` on ``start``.
+   *
+   * This is the structural fix for first-turn cold-start: on Node's
+   * ``ws`` package, opening + closing a WS does NOT warm TLS for the
+   * next open — every fresh ``new WebSocket()`` re-pays the full
+   * TCP + TLS + HTTP-101 round-trip. By keeping the WS open and
+   * adopting it directly, the live first turn skips the handshake
+   * entirely (saves ~150-900 ms depending on provider).
+   *
+   * Best-effort: each provider's parking task is wrapped in
+   * ``Promise.allSettled`` so a slow or failing endpoint cannot block
+   * the others. Providers without ``openParkedConnection`` contribute
+   * nothing — the call falls through to the cold ``connect()`` path
+   * for that provider.
+   */
+  parkProviderConnections(agent, callId) {
+    const stt = agent.stt;
+    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 slot = {};
+    this.prewarmedConnections.set(callId, slot);
+    const startedAt = Date.now();
+    const tasks = [];
+    if (sttOpen) {
+      tasks.push((async () => {
+        try {
+          const ws = await sttOpen();
+          if (this.prewarmedConnections.get(callId) !== slot) {
+            try {
+              ws.close();
+            } catch {
+            }
+            return;
+          }
+          slot.stt = ws;
+          getLogger().info(
+            `[PREWARM] callId=${callId} provider=stt ms=${Date.now() - startedAt}`
+          );
+        } catch (err) {
+          getLogger().debug(`Park STT failed for ${callId}: ${String(err)}`);
+        }
+      })());
+    }
+    if (ttsOpen) {
+      tasks.push((async () => {
+        try {
+          const parked = await ttsOpen();
+          if (this.prewarmedConnections.get(callId) !== slot) {
+            try {
+              parked.ws.close();
+            } catch {
+            }
+            return;
+          }
+          slot.tts = parked;
+          getLogger().info(
+            `[PREWARM] callId=${callId} provider=tts ms=${Date.now() - startedAt}`
+          );
+        } catch (err) {
+          getLogger().debug(`Park TTS failed for ${callId}: ${String(err)}`);
+        }
+      })());
+    }
+    const task = (async () => {
+      await Promise.allSettled(tasks);
+    })();
+    this.prewarmTasks.add(task);
+    void task.finally(() => {
+      this.prewarmTasks.delete(task);
+      if (!this.prewarmedConnections.has(callId)) return;
+      const handle = setTimeout(() => {
+        this.prewarmedConnTimers.delete(callId);
+        const orphan = this.prewarmedConnections.get(callId);
+        if (orphan === void 0) return;
+        this.prewarmedConnections.delete(callId);
+        closeParkedConnections(orphan);
+        getLogger().warn(
+          `[PREWARM] parked connections evicted by TTL for ${callId} \u2014 call never reached start (~${(PARKED_CONN_TTL_MS / 1e3).toFixed(0)}s).`
+        );
+      }, PARKED_CONN_TTL_MS);
+      handle.unref?.();
+      this.prewarmedConnTimers.set(callId, handle);
+    });
+  }
+  /**
+   * Spawn a fire-and-forget task that warms up STT / TTS / LLM in
+   * parallel with the carrier-side ``initiateCall``.
+   *
+   * Best-effort: each provider's optional ``warmup()`` is wrapped in
+   * ``Promise.allSettled`` so a slow or failing endpoint cannot block
+   * the others. Providers without ``warmup`` contribute nothing.
+   */
+  spawnProviderWarmup(agent) {
+    const targets = [];
+    const collect = (provider, label) => {
+      if (!provider || typeof provider !== "object") return;
+      const fn = provider.warmup;
+      if (typeof fn !== "function") return;
+      targets.push({
+        name: label,
+        fn: fn.bind(provider)
+      });
+    };
+    collect(agent.stt, "stt");
+    collect(agent.tts, "tts");
+    collect(agent.llm, "llm");
+    if (targets.length === 0) return;
+    const task = (async () => {
+      const results = await Promise.allSettled(targets.map((t) => t.fn()));
+      results.forEach((r, i) => {
+        if (r.status === "rejected") {
+          getLogger().debug(
+            `Provider warmup failed (${targets[i].name}): ${String(r.reason)}`
+          );
+        }
+      });
+    })();
+    this.prewarmTasks.add(task);
+    void task.finally(() => this.prewarmTasks.delete(task));
+  }
+  /**
+   * Pre-render ``agent.firstMessage`` to TTS bytes during the ringing
+   * window and stash them in ``prewarmAudio.set(callId, buf)``.
+   *
+   * Skipped silently when ``agent.prewarmFirstMessage`` is false or
+   * when ``agent.tts`` / ``agent.firstMessage`` is missing. The synth
+   * is bounded by ``ringTimeout`` (default 25 s) so a never-answered
+   * call doesn't tie up the TTS connection. On timeout / error the
+   * cache is left empty and the StreamHandler falls back to live TTS.
+   *
+   * **Pipeline mode only.** Realtime / ConvAI provider modes never
+   * consume the prewarm cache (the StreamHandler for those modes runs
+   * its first-message emit through the provider's own audio path).
+   * Spawning the prewarm in those modes pays the TTS bill for nothing
+   * — refused with a warn.
+   *
+   * **Capped at ``PREWARM_CACHE_MAX`` concurrent entries.** Refused
+   * with a warn when the cap is reached (the call still proceeds —
+   * StreamHandler falls back to live TTS).
+   */
+  spawnPrewarmFirstMessage(agent, callId, ringTimeout) {
+    if (!agent.prewarmFirstMessage) return;
+    const providerMode = agent.provider ?? "openai_realtime";
+    if (providerMode !== "pipeline") {
+      getLogger().warn(
+        `agent.prewarmFirstMessage=true is only supported in pipeline mode (provider=${providerMode}); skipping pre-synth to avoid wasted TTS spend.`
+      );
+      return;
+    }
+    const firstMessage = agent.firstMessage ?? "";
+    const tts = agent.tts;
+    if (!firstMessage || !tts) return;
+    if (typeof tts.synthesizeStream !== "function") return;
+    const inFlight = this.prewarmAudio.size + this.prewarmTasks.size;
+    if (inFlight >= PREWARM_CACHE_MAX) {
+      getLogger().warn(
+        `Prewarm cache full (${inFlight}/${PREWARM_CACHE_MAX} in-flight) \u2014 skipping pre-synth for call ${callId}; falling back to live TTS at pickup.`
+      );
+      return;
+    }
+    const timeoutMs = (typeof ringTimeout === "number" ? ringTimeout : 25) * 1e3;
+    const task = (async () => {
+      try {
+        const accumulate = async () => {
+          const chunks = [];
+          for await (const chunk of tts.synthesizeStream(firstMessage)) {
+            const u = chunk;
+            if (Buffer.isBuffer(u)) chunks.push(u);
+            else if (ArrayBuffer.isView(u))
+              chunks.push(Buffer.from(u.buffer, u.byteOffset, u.byteLength));
+          }
+          return Buffer.concat(chunks);
+        };
+        const timer = new Promise(
+          (_resolve, reject) => setTimeout(
+            () => reject(new Error("prewarm-first-message timeout")),
+            timeoutMs
+          ).unref?.()
+        );
+        const buf = await Promise.race([accumulate(), timer]);
+        if (buf.byteLength > 0) {
+          if (this.prewarmConsumed.has(callId)) {
+            getLogger().warn(
+              `Prewarm orphaned for call ${callId} \u2014 synth completed (~${buf.byteLength} bytes) AFTER consumer polled; bytes dropped, TTS bill already paid.`
+            );
+            return;
+          }
+          this.prewarmAudio.set(callId, buf);
+          getLogger().debug(
+            `Prewarm first-message ready for call ${callId} (${buf.byteLength} bytes)`
+          );
+        }
+      } catch (err) {
+        getLogger().debug(
+          `Prewarm first-message failed for call ${callId}: ${String(err)}`
+        );
+      }
+    })();
+    this.prewarmTasks.add(task);
+    void task.finally(() => {
+      this.prewarmTasks.delete(task);
+      if (!this.prewarmAudio.has(callId)) return;
+      const ttlMs = timeoutMs + PREWARM_TTL_GRACE_MS;
+      const handle = setTimeout(() => {
+        this.prewarmTtlTimers.delete(callId);
+        const orphan = this.prewarmAudio.get(callId);
+        if (orphan === void 0) return;
+        this.prewarmAudio.delete(callId);
+        this.prewarmConsumed.add(callId);
+        getLogger().warn(
+          `Prewarm bytes evicted by TTL \u2014 call ${callId} never consumed them (~${orphan.byteLength} bytes synthesised, ${(ttlMs / 1e3).toFixed(1)}s after ringTimeout).`
+        );
+      }, ttlMs);
+      handle.unref?.();
+      this.prewarmTtlTimers.set(callId, handle);
+    });
+  }
   /** Place an outbound call via the configured carrier. */
   async call(options) {
     if (!options.to) {
@@ -914,6 +1357,9 @@ var Patter = class {
     if (this.embeddedServer) {
       this.embeddedServer.onMachineDetection = options.onMachineDetection;
     }
+    if (options.agent.prewarm !== false) {
+      this.spawnProviderWarmup(options.agent);
+    }
     if (carrier.kind === "telnyx") {
       const telnyxKey = carrier.apiKey;
       const connectionId = carrier.connectionId;
@@ -939,19 +1385,24 @@ var Patter = class {
       if (!response2.ok) {
         throw new ProvisionError(`Failed to initiate Telnyx call: ${await response2.text()}`);
       }
-      if (this.embeddedServer) {
-        try {
-          const body = await response2.clone().json();
-          const callId = body.data?.call_control_id;
-          if (callId) {
-            this.embeddedServer.metricsStore.recordCallInitiated({
-              call_id: callId,
-              caller: phoneNumber,
-              callee: options.to,
-              direction: "outbound"
-            });
-          }
-        } catch {
+      let telnyxCallId;
+      try {
+        const body = await response2.clone().json();
+        telnyxCallId = body.data?.call_control_id;
+      } catch {
+      }
+      if (this.embeddedServer && telnyxCallId) {
+        this.embeddedServer.metricsStore.recordCallInitiated({
+          call_id: telnyxCallId,
+          caller: phoneNumber,
+          callee: options.to,
+          direction: "outbound"
+        });
+      }
+      if (telnyxCallId) {
+        this.spawnPrewarmFirstMessage(options.agent, telnyxCallId, effectiveRingTimeout);
+        if (options.agent.prewarm !== false) {
+          this.parkProviderConnections(options.agent, telnyxCallId);
         }
       }
       return;
@@ -994,25 +1445,31 @@ var Patter = class {
     if (!response.ok) {
       throw new ProvisionError(`Failed to initiate call: ${await response.text()}`);
     }
-    if (this.embeddedServer) {
-      try {
-        const body = await response.clone().json();
-        const callSid = body.sid;
-        if (callSid) {
-          this.embeddedServer.metricsStore.recordCallInitiated({
-            call_id: callSid,
-            caller: phoneNumber,
-            callee: options.to,
-            direction: "outbound"
-          });
-          const notificationsPath = body.subresource_uris?.notifications;
-          if (notificationsPath) {
-            getLogger().info(
-              `Outbound call ${callSid} placed. Twilio notifications: https://api.twilio.com${notificationsPath} (check here if the call drops with no audio).`
-            );
-          }
-        }
-      } catch {
+    let twilioCallSid;
+    let twilioNotificationsPath;
+    try {
+      const body = await response.clone().json();
+      twilioCallSid = body.sid;
+      twilioNotificationsPath = body.subresource_uris?.notifications;
+    } catch {
+    }
+    if (this.embeddedServer && twilioCallSid) {
+      this.embeddedServer.metricsStore.recordCallInitiated({
+        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).`
+        );
+      }
+    }
+    if (twilioCallSid) {
+      this.spawnPrewarmFirstMessage(options.agent, twilioCallSid, effectiveRingTimeout);
+      if (options.agent.prewarm !== false) {
+        this.parkProviderConnections(options.agent, twilioCallSid);
       }
     }
   }
@@ -1020,8 +1477,36 @@ var Patter = class {
    * Stop the embedded server and any running tunnel. Safe to call multiple
    * times. Leaves the instance reusable: a subsequent ``serve()`` works as
    * if the previous lifecycle never happened.
+   *
+   * Also clears any pending TTL eviction timers, awaits in-flight
+   * prewarm-first-message synth tasks (best-effort, with a 1 s safety
+   * timeout), and clears the prewarm cache. Without this a still-running
+   * TTS WS keeps the user billed long after SDK teardown, and stale
+   * entries leak across ``serve`` / ``disconnect`` cycles. See FIX #93.
    */
   async disconnect() {
+    for (const handle of this.prewarmTtlTimers.values()) {
+      clearTimeout(handle);
+    }
+    this.prewarmTtlTimers.clear();
+    if (this.prewarmTasks.size > 0) {
+      const drain = Promise.allSettled(Array.from(this.prewarmTasks));
+      const timer = new Promise(
+        (resolve) => setTimeout(resolve, 1e3).unref?.()
+      );
+      await Promise.race([drain, timer]);
+    }
+    this.prewarmTasks.clear();
+    this.prewarmAudio.clear();
+    this.prewarmConsumed.clear();
+    for (const handle of this.prewarmedConnTimers.values()) {
+      clearTimeout(handle);
+    }
+    this.prewarmedConnTimers.clear();
+    for (const slot of this.prewarmedConnections.values()) {
+      closeParkedConnections(slot);
+    }
+    this.prewarmedConnections.clear();
     if (this.tunnelHandle) {
       this.tunnelHandle.stop();
       this.tunnelHandle = null;
@@ -1072,6 +1557,7 @@ var Patter = class {
     if (!callSid) {
       throw new Error("callSid must be a non-empty string");
     }
+    this.recordPrewarmWaste(callSid);
     const carrier = this.localConfig.carrier;
     if (carrier.kind === "twilio") {
       const auth = Buffer.from(`${carrier.accountSid}:${carrier.authToken}`).toString("base64");
@@ -1107,7 +1593,7 @@ var Patter = class {
   }
 };
 async function waitForTunnelPubliclyReachable(hostname, totalTimeoutMs = 6e4, graceMs = 5e3) {
-  const log = getLogger();
+  const log2 = getLogger();
   const { Resolver } = await import("dns/promises");
   const resolver = new Resolver({ timeout: 1500, tries: 1 });
   resolver.setServers(["1.1.1.1", "8.8.8.8"]);
@@ -1119,7 +1605,7 @@ async function waitForTunnelPubliclyReachable(hostname, totalTimeoutMs = 6e4, gr
     try {
       const records = await resolver.resolve4(hostname);
       const first = records[0] ?? "<unknown>";
-      log.info(
+      log2.info(
         "Tunnel DNS resolved \u2192 %s (attempt %d); waiting %d ms grace",
         first,
         attempt,
@@ -2333,6 +2819,8 @@ function wrapPcmInWav(pcm, sampleRate = 16e3, channels = 1, bitsPerSample = 16)
   return Buffer.concat([header, pcm]);
 }
 var WhisperSTT = class _WhisperSTT {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "whisper";
   apiKey;
   model;
   language;
@@ -2501,6 +2989,8 @@ init_esm_shims();
 var ALLOWED_MODELS2 = /* @__PURE__ */ new Set(["gpt-4o-transcribe", "gpt-4o-mini-transcribe"]);
 var DEFAULT_BUFFER_SIZE2 = 16e3 * 2;
 var OpenAITranscribeSTT = class extends WhisperSTT {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "openai_transcribe";
   /**
    * @param apiKey OpenAI API key.
    * @param language ISO-639-1 language code (e.g. ``"en"``, ``"it"``). Optional.
@@ -2576,6 +3066,8 @@ var CartesiaSTT = class {
   }
   apiKey;
   options;
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "cartesia_stt";
   ws = null;
   callbacks = /* @__PURE__ */ new Set();
   keepaliveTimer = null;
@@ -2584,6 +3076,37 @@ var CartesiaSTT = class {
    * `null` until the first transcript event arrives (matches Python's `None`).
    */
   requestId = null;
+  /**
+   * Open a fresh WebSocket without arming any message / keepalive handlers
+   * and without taking ownership on `this.ws`. Returns the OPEN socket so
+   * the caller (the prewarm pipeline) can park it for later adoption via
+   * `adoptWebSocket`. Bounded by `CONNECT_TIMEOUT_MS`.
+   *
+   * Billing safety: opening + parking the WS does not stream audio
+   * (Cartesia STT bills on streamed audio seconds), so no charge is
+   * incurred. Close the returned WS yourself if it is never adopted.
+   */
+  async openParkedConnection() {
+    const url = this.buildWsUrl();
+    const ws = new WebSocket2(url, {
+      headers: { "User-Agent": USER_AGENT }
+    });
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error("Cartesia STT park connect timeout")),
+        CONNECT_TIMEOUT_MS
+      );
+      ws.once("open", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      ws.once("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+    return ws;
+  }
   buildWsUrl() {
     const opts = this.options;
     const rawBase = opts.baseUrl ?? DEFAULT_BASE_URL;
@@ -2608,6 +3131,57 @@ var CartesiaSTT = class {
     });
     return `${base}/stt/websocket?${params.toString()}`;
   }
+  /**
+   * Pre-call WebSocket warmup for the Cartesia STT `/stt/websocket` endpoint.
+   *
+   * Opens the WS (DNS + TLS + auth handshake), idles ~250 ms so the
+   * Cartesia edge keeps session state warm, then closes. By the time
+   * `connect()` is invoked at call-pickup the resolver and TLS session
+   * are hot — net wire time saving of 200-500 ms.
+   *
+   * Billing safety: Cartesia STT bills on streamed audio seconds (per
+   * https://docs.cartesia.ai/2025-04-16/api-reference/stt/stt). Opening
+   * + closing the WebSocket without forwarding audio does not consume
+   * billable seconds. Best-effort: failures logged at debug level.
+   */
+  async warmup() {
+    const url = this.buildWsUrl();
+    let ws = null;
+    try {
+      ws = await new Promise((resolve, reject) => {
+        const sock = new WebSocket2(url, {
+          headers: { "User-Agent": USER_AGENT }
+        });
+        const timer = setTimeout(() => {
+          try {
+            sock.close();
+          } catch {
+          }
+          reject(new Error("Cartesia STT warmup connect timeout"));
+        }, 5e3);
+        sock.once("open", () => {
+          clearTimeout(timer);
+          resolve(sock);
+        });
+        sock.once("error", (err) => {
+          clearTimeout(timer);
+          reject(err);
+        });
+      });
+      await new Promise((r) => setTimeout(r, 250));
+    } catch (err) {
+      getLogger().debug(
+        `Cartesia STT warmup failed (best-effort): ${describeWarmupError(err)}`
+      );
+    } finally {
+      if (ws) {
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+    }
+  }
   /** Open the streaming WebSocket and arm message + keepalive handlers. */
   async connect() {
     const url = this.buildWsUrl();
@@ -2628,6 +3202,24 @@ var CartesiaSTT = class {
         reject(err);
       });
     });
+    this.armMessageAndKeepalive();
+  }
+  /**
+   * Adopt a pre-opened, already-OPEN WebSocket produced by the prewarm
+   * pipeline (see `Patter.parkProviderConnections`). Skips the fresh
+   * `new WebSocket()` + handshake — the WS is already through DNS, TLS
+   * and HTTP-101 so audio frames can flow on this turn instead of
+   * paying ~150-400 ms of handshake.
+   *
+   * Caller MUST verify `ws.readyState === OPEN` before calling. If the
+   * parked WS died between park and adopt, fall back to `connect()`.
+   */
+  adoptWebSocket(ws) {
+    this.ws = ws;
+    this.armMessageAndKeepalive();
+  }
+  armMessageAndKeepalive() {
+    if (!this.ws) return;
     this.ws.on("message", (raw) => {
       let event;
       try {
@@ -2675,6 +3267,31 @@ var CartesiaSTT = class {
     if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) return;
     this.ws.send(audio);
   }
+  /**
+   * Force Cartesia to finalise the in-flight utterance immediately.
+   *
+   * Sends a ``finalize`` text frame on the live WebSocket. Cartesia
+   * replies with the final transcript followed by ``flush_done``,
+   * bypassing its conservative internal silence heuristic (which can
+   * wait 2-7 s on PSTN audio before naturally finalising). Wired
+   * into ``StreamHandler`` on the VAD ``speech_end`` event so the
+   * SDK's authoritative end-of-speech detection forces an immediate
+   * STT finalisation — turning Cartesia's natural-pause endpointing
+   * into a deterministic VAD-driven one, parity with the Deepgram
+   * fast-path. No-op when the WS isn't open. Parity with Python
+   * ``CartesiaSTT.finalize``.
+   */
+  async finalize() {
+    if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) return;
+    await new Promise((resolve) => {
+      this.ws.send(CartesiaSTTClientFrame.FINALIZE, (err) => {
+        if (err) {
+          getLogger().debug(`Cartesia finalize send failed: ${String(err)}`);
+        }
+        resolve();
+      });
+    });
+  }
   /** Register a transcript listener. */
   onTranscript(callback) {
     this.callbacks.add(callback);
@@ -2748,6 +3365,17 @@ var CartesiaSTT = class {
     }
   }
 };
+function describeWarmupError(err) {
+  if (typeof err === "object" && err !== null) {
+    const e = err;
+    if (typeof e.statusCode === "number") return `HTTP ${e.statusCode}`;
+    if (typeof e.code === "number" && e.code >= 100 && e.code < 600) return `HTTP ${e.code}`;
+    const ctor = e.constructor?.name;
+    if (typeof ctor === "string" && ctor !== "Object") return ctor;
+    if (typeof e.name === "string") return e.name;
+  }
+  return typeof err;
+}
 
 // src/stt/cartesia.ts
 var STT4 = class extends CartesiaSTT {
@@ -2826,6 +3454,8 @@ var TokenAccumulator = class {
   }
 };
 var SonioxSTT = class _SonioxSTT {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "soniox";
   ws = null;
   callbacks = [];
   final = new TokenAccumulator();
@@ -3103,6 +3733,8 @@ var AssemblyAISTT = class _AssemblyAISTT {
   }
   apiKey;
   options;
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "assemblyai";
   ws = null;
   callbacks = /* @__PURE__ */ new Set();
   closing = false;
@@ -3192,6 +3824,62 @@ var AssemblyAISTT = class _AssemblyAISTT {
     }
     return headers;
   }
+  /**
+   * Pre-call WebSocket warmup for the AssemblyAI v3 `/v3/ws` endpoint.
+   *
+   * Opens the WS (DNS + TLS + auth handshake), idles ~250 ms so the
+   * AssemblyAI edge keeps the session state warm, then sends Terminate
+   * and closes. By the time `connect()` is invoked at call-pickup the
+   * resolver and TLS session are hot — net wire time saving of
+   * 200-500 ms.
+   *
+   * Billing safety: AssemblyAI Universal Streaming bills on streamed
+   * audio seconds (per https://www.assemblyai.com/pricing). Opening +
+   * closing the WebSocket without forwarding any audio frames does
+   * not consume billable seconds. Best-effort: failures logged at
+   * debug level.
+   */
+  async warmup() {
+    const url = this.buildUrl();
+    const headers = this.buildHeaders();
+    let ws = null;
+    try {
+      ws = await new Promise((resolve, reject) => {
+        const sock = new WebSocket4(url, { headers });
+        const timer = setTimeout(() => {
+          try {
+            sock.close();
+          } catch {
+          }
+          reject(new Error("AssemblyAI STT warmup connect timeout"));
+        }, 5e3);
+        sock.once("open", () => {
+          clearTimeout(timer);
+          resolve(sock);
+        });
+        sock.once("error", (err) => {
+          clearTimeout(timer);
+          reject(err);
+        });
+      });
+      await new Promise((r) => setTimeout(r, 250));
+      try {
+        ws.send(JSON.stringify({ type: AssemblyAIClientFrame.TERMINATE }));
+      } catch {
+      }
+    } catch (err) {
+      getLogger().debug(
+        `AssemblyAI STT warmup failed (best-effort): ${describeWarmupError2(err)}`
+      );
+    } finally {
+      if (ws) {
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+    }
+  }
   /** Open the streaming WebSocket and arm message handlers. */
   async connect() {
     this.closing = false;
@@ -3420,6 +4108,17 @@ function averageConfidence(words) {
   }
   return total / words.length;
 }
+function describeWarmupError2(err) {
+  if (typeof err === "object" && err !== null) {
+    const e = err;
+    if (typeof e.statusCode === "number") return `HTTP ${e.statusCode}`;
+    if (typeof e.code === "number" && e.code >= 100 && e.code < 600) return `HTTP ${e.code}`;
+    const ctor = e.constructor?.name;
+    if (typeof ctor === "string" && ctor !== "Object") return ctor;
+    if (typeof e.name === "string") return e.name;
+  }
+  return typeof err;
+}
 
 // src/stt/assemblyai.ts
 var STT6 = class extends AssemblyAISTT {
@@ -3476,6 +4175,8 @@ var SpeechmaticsServerMessage = {
   ERROR: "Error"
 };
 var SpeechmaticsSTT = class {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "speechmatics";
   ws = null;
   transcriptCallbacks = /* @__PURE__ */ new Set();
   errorCallbacks = /* @__PURE__ */ new Set();
@@ -3864,6 +4565,13 @@ var ElevenLabsOutputFormat = {
   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;
@@ -4052,7 +4760,7 @@ var ElevenLabsPlanError = class extends ElevenLabsTTSError {
     this.name = "ElevenLabsPlanError";
   }
 };
-var PLAN_REQUIRED_MSG = "ElevenLabs WS streaming requires a Pro plan or higher (the WS endpoint returned `payment_required`). Either upgrade at https://elevenlabs.io/pricing, or use the HTTP `ElevenLabsTTS` class which works on all plans (drop-in API).";
+var PLAN_REQUIRED_MSG = "ElevenLabs WS streaming requires a Pro plan or higher (the WS endpoint returned `payment_required`). Either upgrade at https://elevenlabs.io/pricing, or use `ElevenLabsRestTTS` for HTTP REST instead which works on all plans (drop-in API).";
 function sanitiseLogStr(value, limit = 200) {
   return String(value).replace(/[\r\n\x00]/g, " ").slice(0, limit);
 }
@@ -4071,6 +4779,19 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
   inactivityTimeout;
   chunkLengthSchedule;
   chunkSize;
+  /**
+   * Single-slot adoption queue. The prewarm pipeline parks one WS per
+   * outbound call here; the next `synthesizeStream` call consumes it
+   * (skipping `new WebSocket()` and the BOS send) instead of opening
+   * a fresh socket. The slot is consumed exactly once: if a second
+   * `synthesizeStream` runs before the first, only the first benefits.
+   *
+   * We keep this on the adapter (not in a parameter) so the existing
+   * `for await (const chunk of agent.tts.synthesizeStream(...))` call
+   * site in `StreamHandler` continues to work without signature
+   * changes.
+   */
+  adoptedConnection = null;
   /**
    * The wire format requested over the ElevenLabs WS. Initially set from
    * the constructor; ``setTelephonyCarrier`` may auto-flip it to the
@@ -4086,7 +4807,7 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
   constructor(opts) {
     if (opts.modelId === "eleven_v3") {
       throw new Error(
-        "eleven_v3 is not supported by the WebSocket stream-input endpoint \u2014 use the HTTP ElevenLabsTTS class instead."
+        "eleven_v3 is not supported by the WebSocket stream-input endpoint \u2014 use `ElevenLabsRestTTS` for HTTP REST instead."
       );
     }
     this.apiKey = opts.apiKey;
@@ -4148,6 +4869,24 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
     if (this.languageCode) params.set("language_code", this.languageCode);
     return `${WS_BASE}/${encodeURIComponent(this.voiceId)}/stream-input?${params.toString()}`;
   }
+  /**
+   * Build the protocol-required BOS frame sent on every fresh WS.
+   *
+   * The single-space `{"text": " "}` keep-alive establishes the session
+   * without committing any synthesis (no `flush: true`, no real text).
+   * Production `synthesizeStream()` and `warmup()` share this exact
+   * construction so the upstream worker chooses the same per-session
+   * config in both cases — otherwise the warm session is on a different
+   * worker than the live request, which defeats the warmup goal.
+   */
+  buildBosFrame() {
+    const init = { text: " " };
+    if (this.voiceSettings) init["voice_settings"] = this.voiceSettings;
+    if (!this.autoMode && this.chunkLengthSchedule) {
+      init["generation_config"] = { chunk_length_schedule: this.chunkLengthSchedule };
+    }
+    return init;
+  }
   /**
    * Single-shot synthesis: open WS, send text, yield bytes, close.
    *
@@ -4166,9 +4905,26 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
    *   after flush — auto_mode could otherwise truncate the tail audio).
    */
   async *synthesizeStream(text) {
-    const ws = new WebSocket6(this.buildUrl(), {
-      headers: { "xi-api-key": this.apiKey }
-    });
+    let ws;
+    let bosAlreadySent = false;
+    let adopted = false;
+    const parked = this.adoptedConnection;
+    this.adoptedConnection = null;
+    if (parked && parked.ws.readyState === WebSocket6.OPEN) {
+      ws = parked.ws;
+      bosAlreadySent = parked.bosSent;
+      adopted = true;
+    } else {
+      if (parked) {
+        try {
+          parked.ws.close();
+        } catch {
+        }
+      }
+      ws = new WebSocket6(this.buildUrl(), {
+        headers: { "xi-api-key": this.apiKey }
+      });
+    }
     const queue = [];
     let done = false;
     let pendingError = null;
@@ -4238,28 +4994,27 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
     };
     ws.on("error", onError);
     try {
-      await new Promise((resolve, reject) => {
-        connectTimer = setTimeout(
-          () => reject(new Error("ElevenLabs WS connect timeout")),
-          CONNECT_TIMEOUT_MS4
-        );
-        ws.once("open", () => {
-          if (connectTimer) clearTimeout(connectTimer);
-          connectTimer = void 0;
-          resolve();
-        });
-        ws.once("error", (err) => {
-          if (connectTimer) clearTimeout(connectTimer);
-          connectTimer = void 0;
-          reject(err);
+      if (!adopted) {
+        await new Promise((resolve, reject) => {
+          connectTimer = setTimeout(
+            () => reject(new Error("ElevenLabs WS connect timeout")),
+            CONNECT_TIMEOUT_MS4
+          );
+          ws.once("open", () => {
+            if (connectTimer) clearTimeout(connectTimer);
+            connectTimer = void 0;
+            resolve();
+          });
+          ws.once("error", (err) => {
+            if (connectTimer) clearTimeout(connectTimer);
+            connectTimer = void 0;
+            reject(err);
+          });
         });
-      });
-      const init = { text: " " };
-      if (this.voiceSettings) init["voice_settings"] = this.voiceSettings;
-      if (!this.autoMode && this.chunkLengthSchedule) {
-        init["generation_config"] = { chunk_length_schedule: this.chunkLengthSchedule };
       }
-      ws.send(JSON.stringify(init));
+      if (!bosAlreadySent) {
+        ws.send(JSON.stringify(this.buildBosFrame()));
+      }
       ws.send(JSON.stringify({ text: text + " ", flush: true }));
       ws.on("message", onMessage);
       ws.on("close", onClose);
@@ -4305,8 +5060,141 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
       ws.removeAllListeners();
     }
   }
+  /**
+   * Pre-call WebSocket warmup for the ElevenLabs `/stream-input` endpoint.
+   *
+   * Opens the WS (DNS + TLS + auth handshake), sends the EXACT same BOS
+   * frame the production `synthesizeStream()` path sends — including
+   * `voice_settings` and (when configured) `generation_config` — so
+   * ElevenLabs instantiates the same per-session worker for both
+   * warmup and the live request. If the BOS frames differ, the server
+   * may route warmup and the real call to two different workers, and
+   * the warmed worker is wasted. Idles ~250 ms, then closes. By the
+   * time the first `synthesizeStream()` call lands during the call,
+   * the connection pool has the upstream warm — net wire time saving
+   * of 200-500 ms.
+   *
+   * Billing safety: ElevenLabs bills on synthesised characters
+   * delivered via `audio` frames (per https://elevenlabs.io/pricing).
+   * The keepalive (single-space `text`, no `flush: true`, no real
+   * transcript) is documented as the session-establishment frame and
+   * does NOT generate synthesis. Closing without sending the actual
+   * transcript does not consume billable characters. Best-effort:
+   * failures logged at debug level.
+   */
+  async warmup() {
+    const ws = new WebSocket6(this.buildUrl(), {
+      headers: { "xi-api-key": this.apiKey }
+    });
+    try {
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(
+          () => reject(new Error("ElevenLabs WS TTS warmup connect timeout")),
+          CONNECT_TIMEOUT_MS4
+        );
+        ws.once("open", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+        ws.once("error", (err) => {
+          clearTimeout(timer);
+          reject(err);
+        });
+      });
+      try {
+        ws.send(JSON.stringify(this.buildBosFrame()));
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, 250));
+    } catch (err) {
+      getLogger().debug(`ElevenLabs WS TTS warmup failed (best-effort): ${String(err)}`);
+    } finally {
+      try {
+        if (ws.readyState === WebSocket6.OPEN || ws.readyState === WebSocket6.CONNECTING) {
+          ws.close();
+        }
+      } catch {
+      }
+      ws.removeAllListeners();
+    }
+  }
+  /**
+   * Open a fresh WS, send the EXACT BOS frame the live `synthesizeStream`
+   * sends, and return the OPEN socket without closing it. Used by the
+   * prewarm pipeline to park a TTS connection during the carrier ringing
+   * window so the next `synthesizeStream` call can adopt it via
+   * {@link adoptWebSocket} and skip ~400-900 ms of TLS + BOS round-trip.
+   *
+   * Returns a parked-handle the caller stashes; the next
+   * `synthesizeStream` will detect the adoption queue and skip its own
+   * `new WebSocket()` + BOS send.
+   *
+   * Billing safety: BOS is the documented session-establishment frame
+   * (single space `text`, no `flush: true`) and does not generate
+   * synthesis. ElevenLabs bills on `audio` frames received from the
+   * server, not on BOS bytes sent by the client.
+   */
+  async openParkedConnection() {
+    const ws = new WebSocket6(this.buildUrl(), {
+      headers: { "xi-api-key": this.apiKey }
+    });
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => reject(new Error("ElevenLabs WS park connect timeout")),
+        CONNECT_TIMEOUT_MS4
+      );
+      ws.once("open", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      ws.once("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+    let bosSent = false;
+    try {
+      ws.send(JSON.stringify(this.buildBosFrame()));
+      bosSent = true;
+    } catch {
+    }
+    return { ws, bosSent };
+  }
+  /**
+   * Stash a parked WS handle so the next `synthesizeStream` call adopts
+   * it instead of opening a fresh socket. Caller is responsible for
+   * holding the handle alive until either the live request consumes it
+   * or the call ends (in which case `discardAdoptedConnection()`
+   * cleans it up).
+   */
+  adoptWebSocket(parked) {
+    const prev = this.adoptedConnection;
+    this.adoptedConnection = parked;
+    if (prev && prev !== parked) {
+      try {
+        prev.ws.close();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Drop and close any pending parked WS without consuming it. Used on
+   * call-failure paths so a never-started call does not leak a TTS WS
+   * that ElevenLabs will close after its inactivity timeout anyway.
+   */
+  discardAdoptedConnection() {
+    const parked = this.adoptedConnection;
+    this.adoptedConnection = null;
+    if (parked) {
+      try {
+        parked.ws.close();
+      } catch {
+      }
+    }
+  }
   /** No-op — connections are per-utterance and torn down inside synthesizeStream. */
   async close() {
+    this.discardAdoptedConnection();
   }
 };
 function looksLikeJson(buf) {
@@ -4386,6 +5274,8 @@ var OpenAITTS = class _OpenAITTS {
   speed;
   antiAlias;
   targetSampleRate;
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "openai_tts";
   /**
    * Synthesise text to speech and return the full audio as a single Buffer.
    *
@@ -4611,6 +5501,8 @@ var CartesiaTTSVoiceMode = {
   EMBEDDING: "embedding"
 };
 var CartesiaTTS = class _CartesiaTTS {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "cartesia_tts";
   apiKey;
   model;
   voice;
@@ -4685,6 +5577,38 @@ var CartesiaTTS = class _CartesiaTTS {
     }
     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 = [];
@@ -4788,6 +5712,8 @@ function timeoutForModel(model) {
   return MIST_MODEL_TIMEOUT_MS;
 }
 var RimeTTS = class {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "rime";
   apiKey;
   model;
   speaker;
@@ -4943,6 +5869,8 @@ var LMNTSampleRate = {
   HZ_24000: 24e3
 };
 var LMNTTTS = class {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "lmnt";
   apiKey;
   model;
   voice;
@@ -5041,6 +5969,7 @@ init_esm_shims();
 // src/providers/inworld-tts.ts
 init_esm_shims();
 var INWORLD_BASE_URL = "https://api.inworld.ai/tts/v1/voice:stream";
+var INWORLD_VOICES_URL = "https://api.inworld.ai/tts/v1/voices";
 var InworldModel = {
   TTS_2: "inworld-tts-2",
   TTS_1_5_MAX: "inworld-tts-1.5-max",
@@ -5055,6 +5984,8 @@ var InworldAudioEncoding = {
   MP3: "MP3"
 };
 var InworldTTS = class {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "inworld";
   authToken;
   model;
   voice;
@@ -5099,6 +6030,45 @@ var InworldTTS = class {
     if (this.deliveryMode !== void 0) payload.deliveryMode = this.deliveryMode;
     return payload;
   }
+  /**
+   * Pre-call HTTP warmup for the Inworld TTS API.
+   *
+   * Issues a lightweight `GET /tts/v1/voices` against the API host so
+   * DNS + TLS + HTTP/2 connection are already up by the time the first
+   * `synthesizeStream()` POST lands. Best-effort: 5 s timeout, all
+   * exceptions swallowed at debug level.
+   *
+   * Earlier revisions issued `HEAD` against the streaming endpoint
+   * (`/tts/v1/voice:stream`). That endpoint is POST-only so HEAD
+   * returns `405 Method Not Allowed` — the warmup still completed the
+   * TLS handshake but spammed 405 errors into Inworld's audit logs and
+   * into our own logs. Switching to a documented `GET /tts/v1/voices`
+   * metadata read is a 2xx-clean equivalent.
+   *
+   * Billing safety: `GET /tts/v1/voices` is a free metadata endpoint
+   * (per https://docs.inworld.ai/). It returns the voice catalogue
+   * without invoking the synthesis pipeline. The actual synthesis is
+   * billed only when `POST /tts/v1/voice:stream` runs with a non-empty
+   * `text`.
+   *
+   * Note: Inworld TTS uses the HTTP NDJSON streaming path rather than
+   * a persistent WebSocket — connection warmup is therefore HTTP-based,
+   * not WebSocket pre-handshake. The latency win is smaller (~50-150 ms)
+   * than the WS-based prewarms but still real on cold-start calls.
+   */
+  async warmup() {
+    try {
+      await fetch(INWORLD_VOICES_URL, {
+        method: "GET",
+        headers: {
+          Authorization: `Basic ${this.authToken}`
+        },
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch (err) {
+      getLogger().debug(`Inworld TTS warmup failed (best-effort): ${String(err)}`);
+    }
+  }
   /** Synthesize text and return the concatenated audio buffer. */
   async synthesize(text) {
     const chunks = [];
@@ -5238,6 +6208,8 @@ var DEFAULT_MODEL = AnthropicModel.CLAUDE_HAIKU_4_5_20251001;
 var DEFAULT_MAX_TOKENS = 1024;
 var PROMPT_CACHING_BETA = "prompt-caching-2024-07-31";
 var AnthropicLLMProvider = class {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "anthropic";
   apiKey;
   model;
   maxTokens;
@@ -5259,6 +6231,27 @@ var AnthropicLLMProvider = class {
     this.anthropicVersion = options.anthropicVersion ?? DEFAULT_ANTHROPIC_VERSION;
     this.promptCaching = options.promptCaching ?? true;
   }
+  /**
+   * Pre-call DNS / TLS warmup for the Anthropic Messages API.
+   * Issues a lightweight ``GET https://api.anthropic.com/v1/models`` so
+   * DNS, TLS and HTTP/2 are already up by the time the first ``messages``
+   * call lands. Best-effort: 5 s timeout, exceptions swallowed at debug.
+   */
+  async warmup() {
+    try {
+      const modelsUrl = this.url.replace(/\/messages\/?$/, "/models");
+      await fetch(modelsUrl, {
+        method: "GET",
+        headers: {
+          "x-api-key": this.apiKey,
+          "anthropic-version": this.anthropicVersion
+        },
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch (err) {
+      getLogger().debug(`Anthropic LLM warmup failed (best-effort): ${String(err)}`);
+    }
+  }
   /** Stream Patter-format LLM chunks for the given OpenAI-style chat history. */
   async *stream(messages, tools, opts) {
     const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
@@ -5494,6 +6487,8 @@ var GroqModel = {
 };
 var DEFAULT_MODEL2 = GroqModel.LLAMA_3_3_70B_VERSATILE;
 var GroqLLMProvider = class {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "groq";
   apiKey;
   model;
   baseUrl;
@@ -5527,6 +6522,21 @@ var GroqLLMProvider = class {
     this.presencePenalty = options.presencePenalty;
     this.stop = options.stop;
   }
+  /**
+   * Pre-call DNS / TLS warmup for the Groq inference endpoint.
+   * Best-effort: 5 s timeout, all exceptions swallowed at debug level.
+   */
+  async warmup() {
+    try {
+      await fetch(`${this.baseUrl}/models`, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch (err) {
+      getLogger().debug(`Groq LLM warmup failed (best-effort): ${String(err)}`);
+    }
+  }
   /** Stream Patter-format LLM chunks from the Groq chat completions API. */
   async *stream(messages, tools, opts) {
     const body = {
@@ -5662,6 +6672,8 @@ var CerebrasModel = {
 var DEFAULT_MODEL3 = CerebrasModel.GPT_OSS_120B;
 var RETRY_BACKOFF_BASE_MS = 500;
 var CerebrasLLMProvider = class {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "cerebras";
   apiKey;
   model;
   baseUrl;
@@ -5697,6 +6709,21 @@ var CerebrasLLMProvider = class {
     this.presencePenalty = options.presencePenalty;
     this.stop = options.stop;
   }
+  /**
+   * Pre-call DNS / TLS warmup for the Cerebras inference endpoint.
+   * Best-effort: 5 s timeout, all exceptions swallowed at debug level.
+   */
+  async warmup() {
+    try {
+      await fetch(`${this.baseUrl}/models`, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch (err) {
+      getLogger().debug(`Cerebras LLM warmup failed (best-effort): ${String(err)}`);
+    }
+  }
   /** Stream Patter-format LLM chunks from the Cerebras chat completions API. */
   async *stream(messages, tools, opts) {
     const body = {
@@ -5859,6 +6886,8 @@ var GoogleModel = {
 var DEFAULT_MODEL4 = GoogleModel.GEMINI_2_5_FLASH;
 var DEFAULT_BASE_URL3 = "https://generativelanguage.googleapis.com/v1beta";
 var GoogleLLMProvider = class {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "google";
   apiKey;
   model;
   baseUrl;
@@ -5876,6 +6905,23 @@ var GoogleLLMProvider = class {
     this.temperature = options.temperature;
     this.maxOutputTokens = options.maxOutputTokens;
   }
+  /**
+   * Pre-call DNS / TLS warmup for the Gemini API.
+   * Issues a lightweight ``GET ${baseUrl}/models?key=...`` so DNS, TLS
+   * and HTTP/2 are already up by the time the first
+   * ``streamGenerateContent`` call lands. Best-effort: 5 s timeout, all
+   * exceptions swallowed at debug level.
+   */
+  async warmup() {
+    try {
+      await fetch(`${this.baseUrl}/models?key=${encodeURIComponent(this.apiKey)}`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch (err) {
+      getLogger().debug(`Google LLM warmup failed (best-effort): ${String(err)}`);
+    }
+  }
   /** Stream Patter-format LLM chunks from the Gemini SSE endpoint. */
   async *stream(messages, tools, opts) {
     const { systemInstruction, contents } = toGeminiContents(messages);
@@ -6065,6 +7111,186 @@ var LLM5 = class extends GoogleLLMProvider {
   }
 };
 
+// src/providers/deepfilternet-filter.ts
+init_esm_shims();
+function log() {
+  return getLogger();
+}
+var DEEPFILTERNET_SR = 48e3;
+async function loadOnnxRuntime() {
+  try {
+    const specifier = "onnxruntime-node";
+    const mod = await import(specifier);
+    return mod;
+  } catch {
+    return null;
+  }
+}
+function pcm16ToFloat32(pcm) {
+  const view = new Int16Array(pcm.buffer, pcm.byteOffset, Math.floor(pcm.byteLength / 2));
+  const out = new Float32Array(view.length);
+  for (let i = 0; i < view.length; i += 1) {
+    out[i] = view[i] / 32768;
+  }
+  return out;
+}
+function float32ToPcm16(samples) {
+  const out = Buffer.alloc(samples.length * 2);
+  for (let i = 0; i < samples.length; i += 1) {
+    const clamped = Math.max(-1, Math.min(1, samples[i]));
+    out.writeInt16LE(Math.round(clamped * 32767), i * 2);
+  }
+  return out;
+}
+var DeepFilterNetFilter = class {
+  modelPath;
+  silenceWarnings;
+  session = null;
+  ort = null;
+  warned = false;
+  closed = false;
+  // Fix 5: stateful resamplers for src_sr↔48k conversions so chunk-boundary
+  // samples are not discarded. Lazy-created and torn down on rate change.
+  _resamplerSrcRate = null;
+  _upsamplerInst = null;
+  _downsamplerInst = null;
+  constructor(options = {}) {
+    this.modelPath = options.modelPath;
+    this.silenceWarnings = options.silenceWarnings === true;
+  }
+  async ensureSession() {
+    if (this.session !== null) {
+      return this.session;
+    }
+    if (!this.modelPath) {
+      if (!this.warned && !this.silenceWarnings) {
+        log().warn(
+          "DeepFilterNetFilter: no modelPath provided; audio will pass through unmodified. Provide a DeepFilterNet ONNX model to enable noise suppression."
+        );
+        this.warned = true;
+      }
+      return null;
+    }
+    if (this.ort === null) {
+      this.ort = await loadOnnxRuntime();
+    }
+    if (this.ort === null) {
+      if (!this.warned && !this.silenceWarnings) {
+        log().warn(
+          "DeepFilterNetFilter: onnxruntime-node is not installed; audio will pass through unmodified. Run `npm install onnxruntime-node` to enable noise suppression."
+        );
+        this.warned = true;
+      }
+      return null;
+    }
+    try {
+      this.session = await this.ort.InferenceSession.create(this.modelPath);
+      return this.session;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log().error(`DeepFilterNetFilter: failed to load model: ${message}`);
+      this.warned = true;
+      return null;
+    }
+  }
+  /** Run noise suppression on a PCM16 chunk; pass-through when no model is loaded. */
+  async process(pcmChunk, sampleRate) {
+    if (this.closed) {
+      throw new Error("DeepFilterNetFilter is closed");
+    }
+    if (pcmChunk.length === 0) {
+      return pcmChunk;
+    }
+    const session = await this.ensureSession();
+    if (session === null || this.ort === null) {
+      return pcmChunk;
+    }
+    try {
+      if (this._resamplerSrcRate !== sampleRate) {
+        this._resamplerSrcRate = sampleRate;
+        this._upsamplerInst = new StatefulResampler({ srcRate: sampleRate, dstRate: DEEPFILTERNET_SR });
+        this._downsamplerInst = new StatefulResampler({ srcRate: DEEPFILTERNET_SR, dstRate: sampleRate });
+      }
+      const samples = pcm16ToFloat32(pcmChunk);
+      const pcm16Up = this._upsamplerInst.process(float32ToPcm16(new Float32Array(samples)));
+      const upsampled = pcm16ToFloat32(pcm16Up);
+      const inputName = session.inputNames[0];
+      const outputName = session.outputNames[0];
+      const tensor = new this.ort.Tensor("float32", upsampled, [1, upsampled.length]);
+      const feeds = { [inputName]: tensor };
+      const results = await session.run(feeds);
+      const output = results[outputName];
+      if (!output || !output.data) {
+        return pcmChunk;
+      }
+      const enhanced = output.data instanceof Float32Array ? output.data : new Float32Array(output.data);
+      const pcm16Enhanced = float32ToPcm16(enhanced);
+      const pcm16Restored = this._downsamplerInst.process(pcm16Enhanced);
+      return pcm16Restored;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log().error(`DeepFilterNetFilter.process failed: ${message}`);
+      return pcmChunk;
+    }
+  }
+  /** Flush resamplers, release the ONNX session, and mark the filter closed. */
+  async close() {
+    try {
+      this._upsamplerInst?.flush();
+    } catch {
+    }
+    try {
+      this._downsamplerInst?.flush();
+    } catch {
+    }
+    this._upsamplerInst = null;
+    this._downsamplerInst = null;
+    if (this.session !== null && typeof this.session.release === "function") {
+      try {
+        await this.session.release();
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        log().warn(`DeepFilterNetFilter.close: release failed: ${message}`);
+      }
+    }
+    this.session = null;
+    this.closed = true;
+  }
+};
+
+// src/providers/krisp-filter.ts
+init_esm_shims();
+var KrispSampleRate = {
+  HZ_8000: 8e3,
+  HZ_16000: 16e3,
+  HZ_32000: 32e3,
+  HZ_44100: 44100,
+  HZ_48000: 48e3
+};
+var KrispFrameDuration = {
+  MS_10: 10,
+  MS_15: 15,
+  MS_20: 20,
+  MS_30: 30,
+  MS_32: 32
+};
+var NODE_SDK_UNAVAILABLE_MESSAGE = "Krisp VIVA Filter is not yet available for the Patter TypeScript SDK.\n\nAs of 2026-05, Krisp does not publish an official Node.js (server) SDK. The Patter TypeScript SDK ships only the AudioFilter interface scaffold (this file) for parity with the Python implementation, since Patter runs server-side on a real-time audio stream from the telephony carrier.\n\nAvailable paths today:\n  1. Use the Python SDK: `from getpatter.providers.krisp_filter import KrispVivaFilter` \u2014 fully implemented, requires `pip install getpatter[krisp]` + `KRISP_VIVA_SDK_LICENSE_KEY` + `KRISP_VIVA_FILTER_MODEL_PATH`.\n  2. Use DeepFilterNet on TS: `new DeepFilterNetFilter({ modelPath: '.../DeepFilterNet3.onnx' })` \u2014 community ONNX export, no license needed.\n\nBrowser/React Native (not applicable to Patter server-side, listed for completeness):\n  - Browser WASM wrappers (various third-party packages) process local microphone capture, not server-received PCM/mulaw audio.\n  - Mobile client wrappers (iOS/Android, various third-party packages) are likewise client-side only.\n\nTrack Node SDK status:\n  - https://krisp.ai/developers/\n  - Patter backlog: task #38 \"Krisp TS port decision\"\n";
+var KrispVivaFilter = class {
+  static providerKey = "krisp_viva";
+  constructor(_options = {}) {
+    throw new Error(NODE_SDK_UNAVAILABLE_MESSAGE);
+  }
+  // The two methods below are unreachable at runtime (constructor throws)
+  // but kept so the class structurally satisfies `AudioFilter`. When the
+  // Node binding lands, replace constructor + these stubs with the real
+  // implementation.
+  async process(pcmChunk, _sampleRate) {
+    return pcmChunk;
+  }
+  async close() {
+  }
+};
+
 // src/telephony/twilio.ts
 init_esm_shims();
 var Carrier = class {
@@ -7100,6 +8326,8 @@ var TelnyxSTT = class {
   transcriptionEngine;
   sampleRate;
   baseUrl;
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "telnyx_stt";
   ws = null;
   callbacks = [];
   headerSent = false;
@@ -7204,6 +8432,8 @@ var TelnyxTTS = class {
   apiKey;
   voice;
   baseUrl;
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "telnyx_tts";
   /** Collect every audio chunk into a single Buffer. */
   async synthesize(text) {
     const chunks = [];
@@ -7305,10 +8535,12 @@ export {
   DEFAULT_MIN_SENTENCE_LEN,
   DEFAULT_PRICING,
   DTMF_EVENTS,
+  DeepFilterNetFilter,
   STT as DeepgramSTT,
   DefaultToolExecutor,
   ConvAI as ElevenLabsConvAI,
   ElevenLabsConvAIAdapter,
+  ElevenLabsTTS as ElevenLabsRestTTS,
   TTS as ElevenLabsTTS,
   TTS2 as ElevenLabsWebSocketTTS,
   ErrorCode,
@@ -7322,13 +8554,19 @@ export {
   Guardrail,
   IVRActivity,
   TTS7 as InworldTTS,
+  KrispFrameDuration,
+  KrispSampleRate,
+  KrispVivaFilter,
   LLMLoop,
   TTS6 as LMNTTTS,
   MetricsStore,
+  MinWordsStrategy,
   Ngrok,
   LLM as OpenAILLM,
   OpenAILLMProvider,
   Realtime as OpenAIRealtime,
+  Realtime2 as OpenAIRealtime2,
+  OpenAIRealtime2Adapter,
   OpenAIRealtimeAdapter,
   TTS3 as OpenAITTS,
   STT3 as OpenAITranscribeSTT,
@@ -7395,6 +8633,7 @@ export {
   deepgram,
   defineTool,
   elevenlabs,
+  evaluateStrategies as evaluateBargeInStrategies,
   filterEmoji,
   filterForTTS,
   filterMarkdown,
@@ -7420,6 +8659,7 @@ export {
   resample24kTo16k,
   resample8kTo16k,
   resamplePcm,
+  resetStrategies as resetBargeInStrategies,
   rime,
   scheduleCron,
   scheduleInterval,