getpatter 0.6.1 → 0.6.3

package/dist/{chunk-TEW3NAZJ.mjs → chunk-Z6W5XFWS.mjs}

@@ -1,3 +1,11 @@
+import {
+  OpenAIRealtime2Adapter,
+  OpenAIRealtimeAdapter,
+  createResampler16kTo8k,
+  createResampler8kTo16k,
+  mulawToPcm16,
+  pcm16ToMulaw
+} from "./chunk-CL2U3YET.mjs";
 import {
   getLogger
 } from "./chunk-MVOQFAEO.mjs";
@@ -16,1264 +24,14 @@ init_esm_shims();
 
 // src/server.ts
 init_esm_shims();
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 import express from "express";
 import { createServer } from "http";
 import { WebSocketServer } from "ws";
 
-// src/providers/openai-realtime.ts
-init_esm_shims();
-import WebSocket from "ws";
-var OpenAIRealtimeAudioFormat = {
-  G711_ULAW: "g711_ulaw",
-  G711_ALAW: "g711_alaw",
-  PCM16: "pcm16"
-};
-var OpenAIRealtimeModel = {
-  GPT_REALTIME: "gpt-realtime",
-  GPT_REALTIME_2: "gpt-realtime-2",
-  GPT_REALTIME_MINI: "gpt-realtime-mini",
-  GPT_4O_REALTIME_PREVIEW: "gpt-4o-realtime-preview",
-  GPT_4O_MINI_REALTIME_PREVIEW: "gpt-4o-mini-realtime-preview"
-};
-var OpenAIVoice = {
-  ALLOY: "alloy",
-  ASH: "ash",
-  BALLAD: "ballad",
-  CORAL: "coral",
-  ECHO: "echo",
-  FABLE: "fable",
-  NOVA: "nova",
-  ONYX: "onyx",
-  SAGE: "sage",
-  SHIMMER: "shimmer",
-  VERSE: "verse"
-};
-var OpenAITranscriptionModel = {
-  WHISPER_1: "whisper-1",
-  GPT_4O_TRANSCRIBE: "gpt-4o-transcribe",
-  GPT_4O_MINI_TRANSCRIBE: "gpt-4o-mini-transcribe",
-  GPT_REALTIME_WHISPER: "gpt-realtime-whisper"
-};
-var OpenAIRealtimeVADType = {
-  SERVER_VAD: "server_vad",
-  SEMANTIC_VAD: "semantic_vad"
-};
-var OpenAIRealtimeAdapter = class {
-  constructor(apiKey, model = OpenAIRealtimeModel.GPT_REALTIME_MINI, voice = OpenAIVoice.ALLOY, instructions = "", tools, audioFormat = OpenAIRealtimeAudioFormat.G711_ULAW, options = {}) {
-    this.apiKey = apiKey;
-    this.model = model;
-    this.voice = voice;
-    this.instructions = instructions;
-    this.tools = tools;
-    this.audioFormat = audioFormat;
-    this.options = options;
-  }
-  apiKey;
-  model;
-  voice;
-  instructions;
-  tools;
-  audioFormat;
-  // Fields exposed `protected` (not `private`) so a subclass can implement
-  // alternate transports — e.g. `OpenAIRealtime2Adapter` overrides
-  // `connect()` to speak the GA Realtime API while reusing the rest of
-  // the runtime (audio dispatch, barge-in, heartbeat).
-  ws = null;
-  eventCallbacks = /* @__PURE__ */ new Set();
-  messageListenerAttached = false;
-  heartbeat = null;
-  // Track the in-flight assistant item id so we can truncate cleanly on
-  // barge-in (see ``cancelResponse``) — matches the Python adapter.
-  currentResponseItemId = null;
-  currentResponseAudioMs = 0;
-  // Wall-clock timestamp (Date.now()) of the first ``response.audio.delta``
-  // received since the current response item started. ``cancelResponse``
-  // uses this to bound ``audio_end_ms`` to what the caller could plausibly
-  // have heard — generated audio frequently arrives 5-10x real-time, so
-  // ``audio_end_ms`` driven purely by the per-chunk byte counter overshoots
-  // reality and leaves phantom assistant text on the conversation. The
-  // wall-clock cap corresponds to the maximum playback that real-time TTS
-  // could have produced, which is what the user actually heard.
-  currentResponseFirstAudioAt = null;
-  options;
-  /**
-   * Build the production session.update body. Mirrors the body sent
-   * inside `connect()` so warmup can apply identical configuration to
-   * the upstream session and prime it without billing.
-   */
-  buildSessionConfig() {
-    const config = {
-      input_audio_format: this.audioFormat,
-      output_audio_format: this.audioFormat,
-      voice: this.voice,
-      instructions: this.instructions || "You are a helpful voice assistant. Be concise.",
-      turn_detection: {
-        type: this.options.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
-        threshold: 0.5,
-        prefix_padding_ms: 300,
-        silence_duration_ms: this.options.silenceDurationMs ?? 300
-      },
-      input_audio_transcription: {
-        model: this.options.inputAudioTranscriptionModel ?? OpenAITranscriptionModel.WHISPER_1
-      }
-    };
-    if (this.options.temperature !== void 0) config.temperature = this.options.temperature;
-    if (this.options.maxResponseOutputTokens !== void 0) {
-      config.max_response_output_tokens = this.options.maxResponseOutputTokens;
-    }
-    if (this.options.modalities !== void 0) config.modalities = this.options.modalities;
-    if (this.options.toolChoice !== void 0) config.tool_choice = this.options.toolChoice;
-    if (this.options.reasoningEffort !== void 0) {
-      config.reasoning = { effort: this.options.reasoningEffort };
-    }
-    if (this.tools?.length) {
-      config.tools = this.tools.map((t) => {
-        const def = {
-          type: "function",
-          name: t.name,
-          description: t.description,
-          parameters: t.parameters
-        };
-        if (t.strict === true) {
-          def.strict = true;
-        }
-        return def;
-      });
-    }
-    return config;
-  }
-  /**
-   * Pre-call WebSocket warmup for the OpenAI Realtime endpoint.
-   *
-   * The canonical session-only warm step on the Realtime API: open the
-   * WS, wait for `session.created`, send a single `session.update`
-   * containing the same fields that the production `connect()` path
-   * applies (`input_audio_format`, `output_audio_format`, `voice`,
-   * `instructions`, `turn_detection`, `input_audio_transcription`,
-   * plus any opt-in fields populated on the adapter), wait for the
-   * matching `session.updated` ack, then close cleanly. This primes
-   * the per-session state on the OpenAI side — DNS + TLS + auth
-   * handshake + initial config exchange — without ever invoking the
-   * model.
-   *
-   * Earlier revisions sent `response.create` with
-   * `{"response": {"generate": false}}` to prime the inference path.
-   * That field is NOT in the OpenAI Realtime API schema; the server
-   * either ignores it (and bills tokens for a real model response) or
-   * rejects the request with `invalid_request_error`. Both behaviours
-   * are billing-unsafe or a no-op beyond TLS warm. The
-   * `session.update` flow is documented and side-effect-free.
-   *
-   * Billing safety: `session.update` only mutates session
-   * configuration. It does NOT invoke the model, does NOT consume any
-   * audio buffer, and does NOT trigger token generation, so no
-   * per-token cost is accrued. Best-effort: failures are logged at
-   * debug level and never raised.
-   */
-  async warmup() {
-    const url = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(this.model)}`;
-    let ws = null;
-    try {
-      ws = await new Promise((resolve, reject) => {
-        const sock = new WebSocket(url, {
-          headers: {
-            Authorization: `Bearer ${this.apiKey}`,
-            "OpenAI-Beta": "realtime=v1"
-          }
-        });
-        const timer = setTimeout(() => {
-          try {
-            sock.close();
-          } catch {
-          }
-          reject(new Error("OpenAI Realtime warmup connect timeout"));
-        }, 5e3);
-        sock.once("open", () => {
-          clearTimeout(timer);
-          resolve(sock);
-        });
-        sock.once("error", (err) => {
-          clearTimeout(timer);
-          reject(err);
-        });
-      });
-      const sessionCreated = await new Promise((resolve) => {
-        const timer = setTimeout(() => resolve(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);
-            }
-          } catch {
-          }
-        };
-        ws.on("message", onMsg);
-      });
-      if (!sessionCreated) return;
-      try {
-        ws.send(JSON.stringify({ type: "session.update", session: this.buildSessionConfig() }));
-      } catch {
-        return;
-      }
-      await new Promise((resolve) => {
-        const timer = setTimeout(() => resolve(), 1500);
-        const onMsg = (raw) => {
-          try {
-            const data = JSON.parse(raw.toString());
-            if (data.type === "session.updated") {
-              clearTimeout(timer);
-              ws.off("message", onMsg);
-              resolve();
-            }
-          } catch {
-          }
-        };
-        ws.on("message", onMsg);
-      });
-    } catch (err) {
-      getLogger().debug(`OpenAI Realtime warmup failed (best-effort): ${String(err)}`);
-    } finally {
-      if (ws) {
-        try {
-          ws.close();
-        } catch {
-        }
-      }
-    }
-  }
-  /** Open the Realtime WebSocket and apply the session configuration. */
-  async connect() {
-    const url = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(this.model)}`;
-    this.ws = new WebSocket(url, {
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`,
-        "OpenAI-Beta": "realtime=v1"
-      }
-    });
-    await new Promise((resolve, reject) => {
-      let sessionCreated = false;
-      let settled = false;
-      const ws = this.ws;
-      const onSetupMessage = (raw) => {
-        let msg;
-        try {
-          msg = JSON.parse(raw.toString());
-        } catch (e) {
-          getLogger().warn(`OpenAI Realtime: failed to parse message: ${String(e)}`);
-          return;
-        }
-        if (msg.type === "session.created" && !sessionCreated) {
-          sessionCreated = true;
-          ws.send(JSON.stringify({ type: "session.update", session: this.buildSessionConfig() }));
-        } else if (msg.type === "session.updated") {
-          cleanup();
-          resolve();
-        }
-      };
-      const onSetupError = (err) => {
-        cleanup();
-        try {
-          ws.close();
-        } catch {
-        }
-        reject(err);
-      };
-      const cleanup = () => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        ws.off("message", onSetupMessage);
-        ws.off("error", onSetupError);
-      };
-      const timer = setTimeout(() => {
-        cleanup();
-        try {
-          ws.close();
-        } catch {
-        }
-        reject(new Error("OpenAI Realtime connect timeout"));
-      }, 15e3);
-      ws.on("message", onSetupMessage);
-      ws.on("error", onSetupError);
-    });
-    this.armHeartbeatAndListener();
-  }
-  /**
-   * Adopt a pre-opened, already-`session.updated` Realtime WebSocket
-   * produced by the prewarm pipeline (see `Patter.parkProviderConnections`).
-   * Skips the fresh `new WebSocket()` + `session.created` /
-   * `session.update` round-trip — saves ~250-450 ms on first turn.
-   *
-   * Caller MUST verify `ws.readyState === OPEN` before calling and MUST
-   * have already received `session.updated` on the parked socket. If
-   * the parked WS died between park and adopt, fall back to `connect()`.
-   */
-  adoptWebSocket(ws) {
-    this.ws = ws;
-    this.armHeartbeatAndListener();
-  }
-  armHeartbeatAndListener() {
-    this.heartbeat = setInterval(() => {
-      try {
-        this.ws?.ping();
-      } catch {
-      }
-    }, 2e4);
-    this.ensureMessageListener();
-  }
-  /**
-   * Open a fresh Realtime WS, exchange `session.created` /
-   * `session.update` / `session.updated` (so the upstream session is
-   * fully primed), and return the OPEN socket WITHOUT arming the
-   * heartbeat / message listener. Used by the prewarm pipeline to park
-   * a Realtime connection during ringing; the live consumer adopts it
-   * via {@link adoptWebSocket}.
-   *
-   * Bounded by 8 s. Throws on timeout / handshake failure — callers
-   * (the prewarm pipeline) treat any error as a cache miss and the
-   * call falls through to the cold `connect()` path.
-   *
-   * Billing safety: `session.update` does not invoke the model. No
-   * tokens are billed.
-   */
-  async openParkedConnection() {
-    const url = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(this.model)}`;
-    const ws = new WebSocket(url, {
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`,
-        "OpenAI-Beta": "realtime=v1"
-      }
-    });
-    await new Promise((resolve, 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.buildSessionConfig() }));
-          } catch (err) {
-            cleanup();
-            reject(err instanceof Error ? err : new Error(String(err)));
-          }
-        } else if (msg.type === "session.updated") {
-          cleanup();
-          resolve();
-        }
-      };
-      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 park connect timeout"));
-      }, 8e3);
-      ws.on("message", onMessage);
-      ws.on("error", onError);
-    });
-    return ws;
-  }
-  /** Append a base64-encoded audio chunk to the realtime input buffer. */
-  sendAudio(mulawAudio) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
-    this.ws.send(JSON.stringify({ type: "input_audio_buffer.append", audio: mulawAudio.toString("base64") }));
-  }
-  /**
-   * Register a listener for parsed realtime events.
-   *
-   * Previously every call attached a new ``ws.on('message')`` handler,
-   * which leaked listeners across retries and multi-consumer hooks. We now
-   * route all traffic through a single persistent handler that fans out to
-   * a Set of callbacks. Use {@link offEvent} to remove one.
-   */
-  onEvent(callback) {
-    this.eventCallbacks.add(callback);
-    this.ensureMessageListener();
-  }
-  /** Remove a previously registered {@link onEvent} callback. */
-  offEvent(callback) {
-    this.eventCallbacks.delete(callback);
-  }
-  ensureMessageListener() {
-    if (this.messageListenerAttached || !this.ws) return;
-    this.messageListenerAttached = true;
-    const ws = this.ws;
-    const dispatch = (type, payload) => {
-      for (const cb of this.eventCallbacks) {
-        void Promise.resolve(cb(type, payload)).catch(
-          (err) => getLogger().error("onEvent callback error:", err)
-        );
-      }
-    };
-    ws.on("message", (raw) => {
-      let data;
-      try {
-        data = JSON.parse(raw.toString());
-      } catch (e) {
-        getLogger().warn(`OpenAI Realtime: failed to parse event message: ${String(e)}`);
-        return;
-      }
-      const t = data.type;
-      if (t === "response.audio.delta") {
-        const buf = Buffer.from(data.delta ?? "", "base64");
-        this.currentResponseAudioMs += estimateAudioMs(buf, this.audioFormat);
-        if (this.currentResponseFirstAudioAt === null) {
-          this.currentResponseFirstAudioAt = Date.now();
-        }
-        dispatch("audio", buf);
-      } else if (t === "response.audio_transcript.delta") {
-        dispatch("transcript_output", data.delta);
-      } else if (t === "response.content_part.added" || t === "response.output_item.added") {
-        const itemId = data.item?.id ?? data.item_id ?? null;
-        if (itemId) {
-          this.currentResponseItemId = itemId;
-          this.currentResponseAudioMs = 0;
-          this.currentResponseFirstAudioAt = null;
-        }
-      } else if (t === "input_audio_buffer.speech_started") {
-        dispatch("speech_started", null);
-      } else if (t === "input_audio_buffer.speech_stopped") {
-        dispatch("speech_stopped", null);
-      } else if (t === "conversation.item.input_audio_transcription.completed") {
-        dispatch("transcript_input", data.transcript);
-      } else if (t === "response.function_call_arguments.done") {
-        dispatch("function_call", { call_id: data.call_id, name: data.name, arguments: data.arguments });
-      } else if (t === "response.done") {
-        this.currentResponseItemId = null;
-        this.currentResponseAudioMs = 0;
-        this.currentResponseFirstAudioAt = null;
-        dispatch("response_done", data.response ?? null);
-      } else if (t === "error") {
-        dispatch("error", data.error);
-      }
-    });
-    ws.on("close", (code, reason) => {
-      if (code !== 1e3) {
-        dispatch("error", {
-          type: "connection_closed",
-          code,
-          reason: reason?.toString() ?? ""
-        });
-      }
-    });
-    ws.on("error", (err) => {
-      dispatch("error", { type: "socket_error", message: err?.message ?? String(err) });
-    });
-  }
-  /** Truncate the in-flight assistant turn and cancel the active response.
-   *
-   * ``audio_end_ms`` MUST reflect what the caller actually heard, not what
-   * the server generated. OpenAI streams audio at 5-10x real-time, so the
-   * byte-derived counter overstates playback whenever the consumer cleared
-   * its playout buffer (e.g. ``send_clear``) before the audio reached the
-   * speaker. We bound the truncate point by wall-clock time since the first
-   * chunk of this response — that's the physical maximum a 1x real-time
-   * playback could have produced. Without this cap, OpenAI keeps the full
-   * generated assistant text on the transcript, and the model replays /
-   * resumes from it on the next turn — manifesting as re-greetings and
-   * mid-sentence fragments after a barge-in storm.
-   */
-  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)}`);
-      }
-    }
-    this.ws.send(JSON.stringify({ type: "response.cancel" }));
-    this.currentResponseItemId = null;
-    this.currentResponseAudioMs = 0;
-    this.currentResponseFirstAudioAt = null;
-  }
-  /** Inject a user text turn and request a new response. */
-  async sendText(text) {
-    this.ws?.send(JSON.stringify({
-      type: "conversation.item.create",
-      item: { type: "message", role: "user", content: [{ type: "input_text", text }] }
-    }));
-    this.ws?.send(JSON.stringify({ type: "response.create" }));
-  }
-  /**
-   * Make the AI speak ``text`` as its opening line.
-   *
-   * Triggers ``response.create`` with explicit ``instructions`` that force
-   * the model to render ``text`` verbatim as its first audio utterance.
-   * This is the correct semantics for ``Agent.firstMessage`` per its
-   * docstring ("What the AI says when the callee answers").
-   *
-   * Without this, ``sendText(firstMessage)`` would inject ``text`` as
-   * ``role: user`` and the AI would *reply* to its own greeting, producing
-   * role-confused openings (e.g. a receptionist agent responding "I'd like
-   * to schedule a haircut" because it took its own first_message as a
-   * customer cue).
-   */
-  async sendFirstMessage(text) {
-    this.ws?.send(JSON.stringify({
-      type: "response.create",
-      response: {
-        modalities: ["audio", "text"],
-        instructions: `Say exactly the following sentence as your first turn and nothing else: "${text}"`
-      }
-    }));
-  }
-  /** Submit a tool/function-call result and request the next response. */
-  async sendFunctionResult(callId, result) {
-    this.ws?.send(JSON.stringify({
-      type: "conversation.item.create",
-      item: { type: "function_call_output", call_id: callId, output: result }
-    }));
-    this.ws?.send(JSON.stringify({ type: "response.create" }));
-  }
-  /** Stop the heartbeat, drop listeners, and close the Realtime WebSocket. */
-  close() {
-    if (this.heartbeat) {
-      clearInterval(this.heartbeat);
-      this.heartbeat = null;
-    }
-    this.eventCallbacks.clear();
-    this.messageListenerAttached = false;
-    this.ws?.close();
-    this.ws = null;
-  }
-};
-function estimateAudioMs(chunk, format) {
-  if (chunk.length === 0) return 0;
-  if (format === OpenAIRealtimeAudioFormat.G711_ULAW || format === OpenAIRealtimeAudioFormat.G711_ALAW)
-    return Math.floor(chunk.length / 8);
-  if (format === OpenAIRealtimeAudioFormat.PCM16) {
-    return Math.floor(chunk.length / 48);
-  }
-  return 0;
-}
-
-// src/providers/openai-realtime-2.ts
-init_esm_shims();
-import WebSocket2 from "ws";
-
-// src/audio/transcoding.ts
-init_esm_shims();
-var MULAW_TO_PCM16_TABLE = (() => {
-  const table = new Int16Array(256);
-  for (let i = 0; i < 256; i++) {
-    const mu = ~i & 255;
-    const sign = mu & 128 ? -1 : 1;
-    const exponent = mu >> 4 & 7;
-    const mantissa = mu & 15;
-    const magnitude = (mantissa << 1 | 33) << exponent + 2;
-    table[i] = sign * (magnitude - 132);
-  }
-  return table;
-})();
-var PCM16_TO_MULAW_TABLE = (() => {
-  const BIAS = 132;
-  const CLIP = 32635;
-  const table = new Uint8Array(65536);
-  for (let i = 0; i < 65536; i++) {
-    let sample = i >= 32768 ? i - 65536 : i;
-    const sign = sample < 0 ? 128 : 0;
-    if (sample < 0) sample = -sample;
-    if (sample > CLIP) sample = CLIP;
-    sample += BIAS;
-    let exponent = 7;
-    const exponentMask = 16384;
-    for (let shift = exponentMask; shift > 0 && (sample & shift) === 0; shift >>= 1) {
-      exponent--;
-    }
-    const mantissa = sample >> exponent + 3 & 15;
-    const mulaw = ~(sign | exponent << 4 | mantissa) & 255;
-    table[i] = mulaw;
-  }
-  return table;
-})();
-function mulawToPcm16(mulawData) {
-  const out = Buffer.alloc(mulawData.length * 2);
-  for (let i = 0; i < mulawData.length; i++) {
-    out.writeInt16LE(MULAW_TO_PCM16_TABLE[mulawData[i]], i * 2);
-  }
-  return out;
-}
-function pcm16ToMulaw(pcmData) {
-  const sampleCount = Math.floor(pcmData.length / 2);
-  const out = Buffer.alloc(sampleCount);
-  for (let i = 0; i < sampleCount; i++) {
-    const sample = pcmData.readInt16LE(i * 2);
-    out[i] = PCM16_TO_MULAW_TABLE[sample + 65536 & 65535];
-  }
-  return out;
-}
-var PcmCarry = class {
-  pending = null;
-  /**
-   * Prepend any carried odd byte, return the even-length prefix, and stash
-   * any new trailing odd byte for the next call.
-   *
-   * Returns a zero-length buffer when no complete sample is yet available.
-   */
-  push(chunk) {
-    const combined = this.pending !== null ? Buffer.concat([this.pending, chunk]) : chunk;
-    this.pending = null;
-    const alignedLen = combined.length & ~1;
-    if (alignedLen < combined.length) {
-      this.pending = combined.subarray(alignedLen);
-    }
-    return combined.subarray(0, alignedLen);
-  }
-  /**
-   * Return any pending byte as a 1-byte buffer (rare in practice — only if
-   * the entire stream had an odd byte count), then reset internal state.
-   */
-  flush() {
-    if (this.pending === null) return Buffer.alloc(0);
-    const out = this.pending;
-    this.pending = null;
-    return out;
-  }
-  /** Reset carry state without flushing. */
-  reset() {
-    this.pending = null;
-  }
-};
-var StatefulResampler = class {
-  srcRate;
-  dstRate;
-  // 16k→8k: 5-tap FIR state.
-  // Extended sample buffer carries the 2 history samples that precede the
-  // current chunk AND any "pending" input sample that did not yet generate
-  // output (i.e. the odd sample when the chunk had an odd sample count).
-  // `firPhase` = 0 means the next output is at input position 0 of the
-  // current chunk; 1 means it starts at input position 1 (because the
-  // previous chunk ended on an even-output boundary).
-  firHistory = new Int16Array(2);
-  // [s_{-2}, s_{-1}]
-  firHistoryValid = false;
-  // Pending sample carried from odd-count chunks (not the byte carry —
-  // this is a complete Int16 sample that becomes the first input for the
-  // next call).
-  firPendingSample = null;
-  // 8k→16k: last input sample deferred across chunk boundaries.
-  upsampleLast = 0;
-  upsampleHasHistory = false;
-  // 24k→16k: fractional phase and last input sample across chunks.
-  resample24Last = 0;
-  resample24Phase = 0;
-  resample24HasHistory = false;
-  // Odd-byte alignment carry.
-  carry = new PcmCarry();
-  constructor(opts) {
-    this.srcRate = opts.srcRate;
-    this.dstRate = opts.dstRate;
-    if (opts.channels !== void 0 && opts.channels !== 1) {
-      throw new Error("StatefulResampler: only mono (channels=1) is supported");
-    }
-    const key = `${this.srcRate}->${this.dstRate}`;
-    if (key !== "16000->8000" && key !== "8000->16000" && key !== "24000->16000" && key !== "24000->8000") {
-      throw new Error(
-        `StatefulResampler: unsupported conversion ${key}. Supported: 16000->8000, 8000->16000, 24000->16000, 24000->8000`
-      );
-    }
-  }
-  /**
-   * Process a chunk of PCM16-LE samples.
-   *
-   * Handles odd-byte inputs via an internal carry buffer. Returns an even-byte-
-   * aligned output buffer; may return a zero-length buffer if not enough
-   * aligned input is available yet.
-   */
-  process(pcm) {
-    const aligned = this.carry.push(pcm);
-    if (aligned.length === 0) return Buffer.alloc(0);
-    if (this.srcRate === 16e3 && this.dstRate === 8e3) {
-      return this._downsample16kTo8k(aligned);
-    }
-    if (this.srcRate === 8e3 && this.dstRate === 16e3) {
-      return this._upsample8kTo16k(aligned);
-    }
-    if (this.srcRate === 24e3 && this.dstRate === 8e3) {
-      return this._resample24kTo8k(aligned);
-    }
-    return this._resample24kTo16k(aligned);
-  }
-  /**
-   * Flush internal state and return any remaining output samples.
-   *
-   * For 8k→16k: the deferred last sample is emitted duplicated (matching
-   * the stateless helper's end-of-stream behaviour).
-   * For 16k→8k: any pending odd sample is processed with edge-replication.
-   * Resets all state after flushing.
-   */
-  flush() {
-    this.carry.flush();
-    if (this.srcRate === 16e3 && this.dstRate === 8e3 && this.firPendingSample !== null) {
-      const s = this.firPendingSample;
-      const tmp = Buffer.alloc(4);
-      tmp.writeInt16LE(s, 0);
-      tmp.writeInt16LE(s, 2);
-      const out = this._downsample16kTo8k(tmp);
-      this.firPendingSample = null;
-      return out;
-    }
-    if (this.srcRate === 8e3 && this.dstRate === 16e3 && this.upsampleHasHistory) {
-      const out = Buffer.alloc(4);
-      out.writeInt16LE(this.upsampleLast, 0);
-      out.writeInt16LE(this.upsampleLast, 2);
-      this.upsampleHasHistory = false;
-      this.upsampleLast = 0;
-      return out;
-    }
-    return Buffer.alloc(0);
-  }
-  /** Reset all carried state (e.g. at call boundaries). */
-  reset() {
-    this.firHistory = new Int16Array(2);
-    this.firHistoryValid = false;
-    this.firPendingSample = null;
-    this.upsampleLast = 0;
-    this.upsampleHasHistory = false;
-    this.resample24Last = 0;
-    this.resample24Phase = 0;
-    this.resample24HasHistory = false;
-    this.carry.reset();
-  }
-  // ---------------------------------------------------------------------------
-  // Private: 16 kHz → 8 kHz
-  // ---------------------------------------------------------------------------
-  /**
-   * 2:1 decimation with a 5-tap binomial FIR anti-alias filter.
-   *
-   * FIR coefficients: [1, 4, 6, 4, 1] / 16 (cutoff ~Fs/4 = 4 kHz).
-   *
-   * Cross-chunk state:
-   * - `firHistory[0]` = s_{-2}, `firHistory[1]` = s_{-1} relative to the
-   *   virtual stream (seeded to first-sample on the very first call).
-   * - `firPendingSample` = a lone input sample carried from a chunk whose
-   *   sample count was odd; it will become the first input of the next chunk.
-   *
-   * Decimation: outputs are at even positions (0, 2, 4 …) in the virtual
-   * extended stream, so every 2 input samples yield 1 output. An odd-sample-
-   * count chunk leaves 1 sample in `firPendingSample`; the next chunk
-   * prepends it so the output cadence is unbroken.
-   */
-  _downsample16kTo8k(buf) {
-    const newSampleCount = buf.length >> 1;
-    const hasPending = this.firPendingSample !== null;
-    const totalInput = newSampleCount + (hasPending ? 1 : 0);
-    const input = new Int16Array(totalInput);
-    if (hasPending) {
-      input[0] = this.firPendingSample;
-      for (let j = 0; j < newSampleCount; j++) input[j + 1] = buf.readInt16LE(j * 2);
-    } else {
-      for (let j = 0; j < newSampleCount; j++) input[j] = buf.readInt16LE(j * 2);
-    }
-    this.firPendingSample = null;
-    if (totalInput === 0) return Buffer.alloc(0);
-    if (!this.firHistoryValid) {
-      this.firHistory[0] = 0;
-      this.firHistory[1] = 0;
-      this.firHistoryValid = true;
-    }
-    const extended = new Int16Array(totalInput + 2);
-    extended[0] = this.firHistory[0];
-    extended[1] = this.firHistory[1];
-    for (let j = 0; j < totalInput; j++) extended[j + 2] = input[j];
-    const outSamples = totalInput >> 1;
-    const out = Buffer.alloc(outSamples * 2);
-    for (let i = 0; i < outSamples; i++) {
-      const c = 2 + i * 2;
-      const sM2 = extended[c - 2];
-      const sM1 = extended[c - 1];
-      const s0 = extended[c];
-      const sP1 = c + 1 < extended.length ? extended[c + 1] : extended[extended.length - 1];
-      const sP2 = c + 2 < extended.length ? extended[c + 2] : extended[extended.length - 1];
-      const filtered = sM2 + 4 * sM1 + 6 * s0 + 4 * sP1 + sP2 + 8 >> 4;
-      out.writeInt16LE(Math.max(-32768, Math.min(32767, filtered)), i * 2);
-    }
-    if (totalInput % 2 === 1) {
-      this.firPendingSample = input[totalInput - 1];
-    }
-    if (totalInput >= 2) {
-      this.firHistory[0] = input[totalInput - 2];
-      this.firHistory[1] = input[totalInput - 1];
-    } else {
-      this.firHistory[0] = this.firHistory[1];
-      this.firHistory[1] = input[0];
-    }
-    return out;
-  }
-  // ---------------------------------------------------------------------------
-  // Private: 8 kHz → 16 kHz
-  // ---------------------------------------------------------------------------
-  /**
-   * 1:2 linear-interpolation upsampler.
-   *
-   * For the first chunk (no history): emits 2*(N-1) samples and defers the
-   * last sample. For subsequent chunks (with history): emits the deferred
-   * sample + its interpolated midpoint THEN 2*(N-1) samples from the new
-   * chunk, deferring the new last sample. Total across K chunks + flush =
-   * 2*total_input_samples (correct output length).
-   *
-   * Call flush() after the final chunk to emit the last deferred sample
-   * pair (self-duplicate at end of stream).
-   */
-  _upsample8kTo16k(buf) {
-    const sampleCount = buf.length >> 1;
-    if (sampleCount === 0) return Buffer.alloc(0);
-    const outArr = [];
-    if (this.upsampleHasHistory) {
-      const next = buf.readInt16LE(0);
-      outArr.push(this.upsampleLast);
-      outArr.push(Math.round((this.upsampleLast + next) / 2));
-    }
-    for (let i = 0; i < sampleCount - 1; i++) {
-      const s0 = buf.readInt16LE(i * 2);
-      const s1 = buf.readInt16LE((i + 1) * 2);
-      outArr.push(s0);
-      outArr.push(Math.round((s0 + s1) / 2));
-    }
-    this.upsampleLast = buf.readInt16LE((sampleCount - 1) * 2);
-    this.upsampleHasHistory = true;
-    const outBuf = Buffer.alloc(outArr.length * 2);
-    for (let j = 0; j < outArr.length; j++) outBuf.writeInt16LE(outArr[j], j * 2);
-    return outBuf;
-  }
-  // ---------------------------------------------------------------------------
-  // Private: 24 kHz → 16 kHz / 8 kHz
-  // ---------------------------------------------------------------------------
-  /**
-   * 3:2 linear-interpolation decimator (ratio srcRate/dstRate = 1.5).
-   *
-   * `resample24Phase` tracks the fractional input position of the next output
-   * sample relative to the START of the next chunk. Negative phase means the
-   * next output straddles the previous/current chunk boundary; those are
-   * handled using `resample24Last`.
-   */
-  _resample24kTo16k(buf) {
-    return this._resample24kStep(buf, 24e3 / 16e3);
-  }
-  /** 3:1 decimation — collapses the 24k→16k→8k chain into a single step. */
-  _resample24kTo8k(buf) {
-    return this._resample24kStep(buf, 24e3 / 8e3);
-  }
-  /** Shared phase-stepping resampler used by 24→16 (step 1.5) and 24→8 (step 3). */
-  _resample24kStep(buf, step) {
-    const sampleCount = buf.length >> 1;
-    if (sampleCount === 0) return Buffer.alloc(0);
-    const outArr = [];
-    let phase = this.resample24Phase;
-    while (true) {
-      const idx = Math.floor(phase);
-      if (idx >= sampleCount) break;
-      const frac = phase - idx;
-      let s0;
-      let s1;
-      if (idx < 0) {
-        s0 = this.resample24HasHistory ? this.resample24Last : 0;
-        s1 = buf.readInt16LE(0);
-      } else {
-        s0 = buf.readInt16LE(idx * 2);
-        s1 = idx + 1 < sampleCount ? buf.readInt16LE((idx + 1) * 2) : s0;
-      }
-      const interp = Math.round(s0 + (s1 - s0) * frac);
-      outArr.push(Math.max(-32768, Math.min(32767, interp)));
-      phase += step;
-    }
-    this.resample24Last = buf.readInt16LE((sampleCount - 1) * 2);
-    this.resample24HasHistory = true;
-    this.resample24Phase = phase - sampleCount;
-    const outBuf = Buffer.alloc(outArr.length * 2);
-    for (let j = 0; j < outArr.length; j++) outBuf.writeInt16LE(outArr[j], j * 2);
-    return outBuf;
-  }
-};
-function createResampler16kTo8k() {
-  return new StatefulResampler({ srcRate: 16e3, dstRate: 8e3 });
-}
-function createResampler8kTo16k() {
-  return new StatefulResampler({ srcRate: 8e3, dstRate: 16e3 });
-}
-function createResampler24kTo16k() {
-  return new StatefulResampler({ srcRate: 24e3, dstRate: 16e3 });
-}
-function createResampler24kTo8k() {
-  return new StatefulResampler({ srcRate: 24e3, dstRate: 8e3 });
-}
-var _warnedResample8kTo16k = false;
-var _warnedResample16kTo8k = false;
-var _warnedResample24kTo16k = false;
-function resample8kTo16k(pcm8k) {
-  if (!_warnedResample8kTo16k) {
-    _warnedResample8kTo16k = true;
-    getLogger().warn(
-      "[patter] resample8kTo16k() is deprecated. Use createResampler8kTo16k() (StatefulResampler) to eliminate chunk-boundary discontinuities."
-    );
-  }
-  if (pcm8k.length === 0) return Buffer.alloc(0);
-  const r = createResampler8kTo16k();
-  const main = r.process(pcm8k);
-  const tail = r.flush();
-  return tail.length > 0 ? Buffer.concat([main, tail]) : main;
-}
-function resample16kTo8k(pcm16k) {
-  if (!_warnedResample16kTo8k) {
-    _warnedResample16kTo8k = true;
-    getLogger().warn(
-      "[patter] resample16kTo8k() is deprecated. Use createResampler16kTo8k() (StatefulResampler) to eliminate chunk-boundary discontinuities."
-    );
-  }
-  if (pcm16k.length === 0) return Buffer.alloc(0);
-  const r = createResampler16kTo8k();
-  const out = r.process(pcm16k);
-  const tail = r.flush();
-  return tail.length > 0 ? Buffer.concat([out, tail]) : out;
-}
-function resample24kTo16k(pcm24k) {
-  if (!_warnedResample24kTo16k) {
-    _warnedResample24kTo16k = true;
-    getLogger().warn(
-      "[patter] resample24kTo16k() is deprecated. Use createResampler24kTo16k() (StatefulResampler) or OpenAITTS.resampleStreaming for anti-aliased resampling."
-    );
-  }
-  if (pcm24k.length === 0) return Buffer.alloc(0);
-  const sampleCount = Math.floor(pcm24k.length / 2);
-  const outSamples = Math.floor(sampleCount * 2 / 3);
-  const out = Buffer.alloc(outSamples * 2);
-  for (let i = 0; i < outSamples; i++) {
-    const pos = i * 1.5;
-    const idx = Math.floor(pos);
-    const frac = pos - idx;
-    const s0 = pcm24k.readInt16LE(idx * 2);
-    const s1 = idx + 1 < sampleCount ? pcm24k.readInt16LE((idx + 1) * 2) : s0;
-    const interp = Math.round(s0 + (s1 - s0) * frac);
-    out.writeInt16LE(Math.max(-32768, Math.min(32767, interp)), i * 2);
-  }
-  return out;
-}
-
-// src/providers/openai-realtime-2.ts
-var GA_TO_V1_EVENT_NAMES = {
-  "response.output_audio.delta": "response.audio.delta",
-  "response.output_audio.done": "response.audio.done",
-  "response.output_audio_transcript.delta": "response.audio_transcript.delta",
-  "response.output_audio_transcript.done": "response.audio_transcript.done"
-};
-var OpenAIRealtime2Adapter = class extends OpenAIRealtimeAdapter {
-  /** Two-stage outbound resampler for 24 kHz → 8 kHz. Created lazily on
-   *  the first audio frame so each Realtime session has its own state.
-   *
-   *  We chain `24k → 16k → 8k` instead of using the direct `24k → 8k`
-   *  variant of {@link StatefulResampler}: the direct path is a 3:1
-   *  decimation with linear interpolation only — no anti-alias filter
-   *  — so any energy above 4 kHz in the source aliases down into the
-   *  audible band and is heard as raspy/scratchy artefacts on speech.
-   *  `gpt-realtime-2` outputs voice with significant content above
-   *  4 kHz. The second stage (16k → 8k) uses a 5-tap FIR anti-alias
-   *  filter which removes the offending band before decimation, and
-   *  empirically (see commit message) the chain produces audibly
-   *  cleaner output. The 24k → 16k step is still pure linear-interp
-   *  but the inputs to it stay below the Nyquist of the 16 kHz stage,
-   *  so it doesn't introduce new artefacts.
-   */
-  outboundResampler24To16 = null;
-  outboundResampler16To8 = null;
-  /** Last 8 kHz input sample carried across chunk boundaries for the
-   *  direct 3× linear upsample (see `transcodeInboundMulaw8ToPcm24`).
-   *  The carry guarantees the very first output of each chunk
-   *  interpolates from the *real* preceding sample, not from the chunk's
-   *  own first sample replicated — without it every 20 ms Twilio frame
-   *  boundary becomes a small DC step that the GA server VAD interprets
-   *  as constant low-energy noise, which never crosses the speech
-   *  threshold. */
-  inbound8kCarry = null;
-  /** GA-shape `session.update` payload. See module-level docstring. */
-  buildGASessionConfig() {
-    const opts = this.options;
-    const fmt = { type: "audio/pcm", rate: 24e3 };
-    const config = {
-      type: "realtime",
-      output_modalities: opts.modalities ?? ["audio"],
-      audio: {
-        input: {
-          format: fmt,
-          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.
-          turn_detection: {
-            type: opts.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
-            threshold: 0.1,
-            prefix_padding_ms: 300,
-            silence_duration_ms: opts.silenceDurationMs ?? 500
-          }
-        },
-        output: {
-          format: fmt,
-          voice: this.voice
-        }
-      },
-      instructions: this.instructions || "You are a helpful voice assistant. Be concise."
-    };
-    if (opts.temperature !== void 0) config.temperature = opts.temperature;
-    if (opts.maxResponseOutputTokens !== void 0) {
-      config.max_output_tokens = opts.maxResponseOutputTokens;
-    }
-    if (opts.toolChoice !== void 0) config.tool_choice = opts.toolChoice;
-    if (opts.reasoningEffort !== void 0) {
-      config.reasoning = { effort: opts.reasoningEffort };
-    }
-    if (this.tools?.length) {
-      config.tools = this.tools.map((t) => {
-        const def = {
-          type: "function",
-          name: t.name,
-          description: t.description,
-          parameters: t.parameters
-        };
-        if (t.strict === true) def.strict = true;
-        return def;
-      });
-    }
-    return config;
-  }
-  /**
-   * Open the Realtime WebSocket against the GA endpoint and apply the GA
-   * session configuration. Header `OpenAI-Beta: realtime=v1` is OMITTED
-   * (the GA endpoint rejects it). Wire shape uses nested `audio.{input,
-   * output}` + `output_modalities` + `session.type === "realtime"`.
-   */
-  async connect() {
-    const url = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(this.model)}`;
-    this.ws = new WebSocket2(url, {
-      headers: { Authorization: `Bearer ${this.apiKey}` }
-    });
-    const wsRef = this.ws;
-    const originalOn = wsRef.on.bind(this.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 && t in GA_TO_V1_EVENT_NAMES) {
-            const newType = GA_TO_V1_EVENT_NAMES[t];
-            if (t === "response.output_audio.delta" && typeof parsed.delta === "string") {
-              const mulaw = this.transcodeOutboundPcm24ToMulaw8Buffer(parsed.delta);
-              const FRAME_BYTES = 160;
-              if (mulaw.length === 0) return;
-              for (let off = 0; off < mulaw.length; off += FRAME_BYTES) {
-                const slice = mulaw.subarray(off, Math.min(off + FRAME_BYTES, mulaw.length));
-                const frame = { ...parsed, type: newType, delta: slice.toString("base64") };
-                handler(Buffer.from(JSON.stringify(frame)), ...rest);
-              }
-              return;
-            }
-            parsed.type = newType;
-            handler(Buffer.from(JSON.stringify(parsed)), ...rest);
-            return;
-          }
-        } catch {
-        }
-        handler(raw, ...rest);
-      };
-      return originalOn(event, wrapped);
-    };
-    await new Promise((resolve, reject) => {
-      let sessionCreated = false;
-      let settled = false;
-      const ws = this.ws;
-      const onSetupMessage = (raw) => {
-        let msg;
-        try {
-          msg = JSON.parse(raw.toString());
-        } catch (e) {
-          getLogger().warn(`OpenAI Realtime 2: failed to parse message: ${String(e)}`);
-          return;
-        }
-        if (msg.type === "session.created" && !sessionCreated) {
-          sessionCreated = true;
-          ws.send(JSON.stringify({ type: "session.update", session: this.buildGASessionConfig() }));
-        } else if (msg.type === "session.updated") {
-          cleanup();
-          resolve();
-        } else if (msg.type === "error") {
-          cleanup();
-          try {
-            ws.close();
-          } catch {
-          }
-          reject(new Error(`OpenAI Realtime 2 setup error: ${msg.error?.message ?? JSON.stringify(msg)}`));
-        }
-      };
-      const onSetupError = (err) => {
-        cleanup();
-        try {
-          ws.close();
-        } catch {
-        }
-        reject(err);
-      };
-      const cleanup = () => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(timer);
-        ws.off("message", onSetupMessage);
-        ws.off("error", onSetupError);
-      };
-      const timer = setTimeout(() => {
-        cleanup();
-        try {
-          ws.close();
-        } catch {
-        }
-        reject(new Error("OpenAI Realtime 2 connect timeout"));
-      }, 15e3);
-      ws.on("message", onSetupMessage);
-      ws.on("error", onSetupError);
-    });
-    this.armHeartbeatAndListener();
-  }
-  /**
-   * GA-API variant of {@link OpenAIRealtimeAdapter.sendFirstMessage}. Two
-   * differences from the v1 path:
-   *
-   * 1. The v1 implementation sends `response.modalities` which the GA
-   *    endpoint rejects with `Unknown parameter: 'response.modalities'`.
-   *    Use `output_modalities` to match the GA `session.update` shape.
-   *
-   * 2. The GA `response.create` does NOT inherit `audio.output.voice`
-   *    from the session — it falls back to the server-side default
-   *    (`marin`, female) when the field is omitted on the response
-   *    itself. Session-level `voice: "alloy"` only affects subsequent
-   *    server-VAD-triggered responses, NOT this explicit
-   *    `response.create`. We re-inject the configured voice here so the
-   *    first-message voice matches the rest of the call.
-   */
-  /**
-   * Override the parent `sendAudio` to transcode inbound carrier audio
-   * (mulaw 8 kHz from Twilio/Telnyx) into PCM-16 24 kHz before sending
-   * `input_audio_buffer.append`. The GA server's audio engine ignores
-   * mulaw frames (commit returns "buffer only has 0.00ms of audio") even
-   * though it accepts `audio/pcmu` at the protocol level.
-   */
-  sendAudio(mulawAudio) {
-    if (!this.ws || this.ws.readyState !== this.ws.OPEN) return;
-    const pcm24k = this.transcodeInboundMulaw8ToPcm24(mulawAudio);
-    this.ws.send(JSON.stringify({
-      type: "input_audio_buffer.append",
-      audio: pcm24k.toString("base64")
-    }));
-  }
-  /**
-   * mulaw 8 kHz Buffer → PCM-16-LE 24 kHz Buffer.
-   *
-   * Direct 3× linear-interpolation upsample with a one-sample carry
-   * across chunk boundaries. For every consecutive pair of 8 kHz
-   * samples `(s_a, s_b)` we emit three 24 kHz samples:
-   *
-   *     out_0 = s_a
-   *     out_1 = 2/3·s_a + 1/3·s_b
-   *     out_2 = 1/3·s_a + 2/3·s_b
-   *
-   * The carry stores the last 8 kHz sample of the chunk so the next
-   * chunk can start by pairing `(carry, firstNewSample)` — that's what
-   * keeps the output rate exact (each input sample → 3 output samples)
-   * and eliminates the chunk-boundary DC step that confused the GA
-   * server VAD. The first chunk has no carry and loses 3 samples at
-   * the leading edge (375 µs of audio); that's well below any audible
-   * artefact and well below the GA VAD's 300 ms prefix-padding window.
-   */
-  transcodeInboundMulaw8ToPcm24(mulaw) {
-    const pcm8 = mulawToPcm16(mulaw);
-    const samples8 = pcm8.length / 2;
-    if (samples8 === 0) return Buffer.alloc(0);
-    const GAIN = 2;
-    const inputs = [];
-    if (this.inbound8kCarry !== null) inputs.push(this.inbound8kCarry);
-    for (let i = 0; i < samples8; i++) {
-      const raw = pcm8.readInt16LE(i * 2) * GAIN;
-      inputs.push(Math.max(-32768, Math.min(32767, raw)));
-    }
-    this.inbound8kCarry = inputs[inputs.length - 1];
-    const numPairs = inputs.length - 1;
-    if (numPairs <= 0) return Buffer.alloc(0);
-    const out = Buffer.allocUnsafe(numPairs * 3 * 2);
-    for (let i = 0; i < numPairs; i++) {
-      const s0 = inputs[i];
-      const s1 = inputs[i + 1];
-      out.writeInt16LE(s0, i * 6);
-      out.writeInt16LE(Math.round((s0 * 2 + s1) / 3), i * 6 + 2);
-      out.writeInt16LE(Math.round((s0 + s1 * 2) / 3), i * 6 + 4);
-    }
-    return out;
-  }
-  /**
-   * Base64 PCM-16-LE 24 kHz → Base64 mulaw 8 kHz. Used by the WS
-   * translation shim on each `response.output_audio.delta`. The stateful
-   * resampler is created lazily and reused across all deltas in this
-   * session so the 3:1 decimator's phase carries across chunk
-   * boundaries — without that, every chunk boundary produces a click.
-   */
-  transcodeOutboundPcm24ToMulaw8Buffer(deltaB64) {
-    if (!this.outboundResampler24To16) {
-      this.outboundResampler24To16 = new StatefulResampler({ srcRate: 24e3, dstRate: 16e3 });
-      this.outboundResampler16To8 = new StatefulResampler({ srcRate: 16e3, dstRate: 8e3 });
-    }
-    const pcm24 = Buffer.from(deltaB64, "base64");
-    const pcm16 = this.outboundResampler24To16.process(pcm24);
-    const pcm8 = this.outboundResampler16To8.process(pcm16);
-    if (pcm8.length === 0) return Buffer.alloc(0);
-    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}"`
-      }
-    }));
-  }
-};
-
 // src/providers/elevenlabs-convai.ts
 init_esm_shims();
-import WebSocket3 from "ws";
+import WebSocket from "ws";
 var ELEVENLABS_CONVAI_URL = "wss://api.elevenlabs.io/v1/convai/conversation";
 var ELEVENLABS_SIGNED_URL = "https://api.elevenlabs.io/v1/convai/conversation/get-signed-url";
 var AGENT_SILENCE_MS = 500;
@@ -1395,8 +153,8 @@ var ElevenLabsConvAIAdapter = class _ElevenLabsConvAIAdapter {
       wsUrl = this.agentId ? `${ELEVENLABS_CONVAI_URL}?agent_id=${encodeURIComponent(this.agentId)}` : ELEVENLABS_CONVAI_URL;
       wsOptions = { headers: { "xi-api-key": this.apiKey } };
     }
-    this.ws = new WebSocket3(wsUrl, wsOptions);
-    await new Promise((resolve, reject) => {
+    this.ws = new WebSocket(wsUrl, wsOptions);
+    await new Promise((resolve2, reject) => {
       const timeout = setTimeout(
         () => reject(new Error("ElevenLabs ConvAI connect timeout")),
         15e3
@@ -1420,7 +178,7 @@ var ElevenLabsConvAIAdapter = class _ElevenLabsConvAIAdapter {
           conversation_config_override: override
         };
         this.ws.send(JSON.stringify(config));
-        resolve();
+        resolve2();
       });
       this.ws.once("error", (err) => {
         clearTimeout(timeout);
@@ -1457,7 +215,7 @@ var ElevenLabsConvAIAdapter = class _ElevenLabsConvAIAdapter {
   }
   respondToPing(eventId, delayMs) {
     const send = () => {
-      if (!this.ws || this.ws.readyState !== WebSocket3.OPEN) return;
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
       try {
         this.ws.send(JSON.stringify({ type: "pong", event_id: eventId }));
       } catch (err) {
@@ -1554,7 +312,7 @@ var ElevenLabsConvAIAdapter = class _ElevenLabsConvAIAdapter {
   }
   /** Send a caller-side audio chunk to ConvAI as a base64 `user_audio_chunk`. */
   sendAudio(audioBytes) {
-    if (!this.ws || this.ws.readyState !== WebSocket3.OPEN) return;
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
     this.ws.send(
       JSON.stringify({
         user_audio_chunk: audioBytes.toString("base64")
@@ -1577,20 +335,20 @@ var ElevenLabsConvAIAdapter = class _ElevenLabsConvAIAdapter {
       return;
     }
     const ws = this.ws;
-    this.closePromise = new Promise((resolve) => {
-      if (ws.readyState === WebSocket3.CLOSED || ws.readyState === WebSocket3.CLOSING) {
-        resolve();
+    this.closePromise = new Promise((resolve2) => {
+      if (ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
+        resolve2();
         return;
       }
       const done = () => {
-        resolve();
+        resolve2();
       };
       ws.once("close", done);
       ws.once("error", done);
       try {
         ws.close();
       } catch {
-        resolve();
+        resolve2();
       }
     });
     try {
@@ -1603,6 +361,157 @@ var ElevenLabsConvAIAdapter = class _ElevenLabsConvAIAdapter {
   }
 };
 
+// src/providers/plivo-adapter.ts
+init_esm_shims();
+var PLIVO_API_BASE = "https://api.plivo.com/v1";
+async function dropPlivoVoicemail(callUuid, voicemailMessage, authId, authToken) {
+  if (!callUuid || !voicemailMessage || !authId || !authToken) return;
+  const auth = `Basic ${Buffer.from(`${authId}:${authToken}`).toString("base64")}`;
+  const base = `${PLIVO_API_BASE}/Account/${encodeURIComponent(authId)}/Call/${encodeURIComponent(callUuid)}`;
+  try {
+    const speak = await fetch(`${base}/Speak/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded", Authorization: auth },
+      body: new URLSearchParams({ text: voicemailMessage }).toString(),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!speak.ok) {
+      getLogger().warn(
+        `Plivo voicemail Speak failed (${speak.status}): ${(await speak.text()).slice(0, 200)}`
+      );
+      return;
+    }
+    await new Promise(
+      (r) => setTimeout(r, Math.min(3e4, voicemailMessage.length * 60))
+    );
+    await fetch(`${base}/`, { method: "DELETE", headers: { Authorization: auth } });
+    getLogger().info(`Voicemail dropped for ${callUuid}`);
+  } catch (e) {
+    getLogger().warn(`Could not drop voicemail: ${String(e)}`);
+  }
+}
+function xmlEscapePlivo(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var PlivoAdapter = class {
+  authId;
+  baseUrl;
+  authHeader;
+  constructor(authId, authToken) {
+    if (!authId) throw new Error("PlivoAdapter: authId is required");
+    if (!authToken) throw new Error("PlivoAdapter: authToken is required");
+    this.authId = authId;
+    this.baseUrl = `${PLIVO_API_BASE}/Account/${encodeURIComponent(authId)}`;
+    this.authHeader = `Basic ${Buffer.from(`${authId}:${authToken}`).toString("base64")}`;
+  }
+  async request(method, path4, jsonBody) {
+    const headers = { Authorization: this.authHeader };
+    if (jsonBody !== void 0) headers["Content-Type"] = "application/json";
+    const response = await fetch(`${this.baseUrl}${path4}`, {
+      method,
+      headers,
+      body: jsonBody !== void 0 ? JSON.stringify(jsonBody) : void 0,
+      signal: AbortSignal.timeout(3e4)
+    });
+    const text = await response.text();
+    if (!response.ok && response.status !== 404) {
+      throw new Error(`Plivo ${method} ${path4} failed: ${response.status} ${text}`);
+    }
+    let data = {};
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+      }
+    }
+    return { status: response.status, data };
+  }
+  /** Search and rent an available Plivo number for the given ISO country. */
+  async provisionNumber(countryIso) {
+    const { data } = await this.request(
+      "GET",
+      `/PhoneNumber/?country_iso=${encodeURIComponent(countryIso)}&limit=1`
+    );
+    const number = data.objects?.[0]?.number;
+    if (!number) throw new Error(`PlivoAdapter: no numbers available for ${countryIso}`);
+    await this.request("POST", `/PhoneNumber/${encodeURIComponent(number)}/`);
+    return number;
+  }
+  /**
+   * Point the inbound answer flow for ``number`` at ``answerUrl`` by creating
+   * (or reusing) a Plivo Application and linking the number to it. Most
+   * production deployments pre-configure this in the Plivo console; this
+   * mirrors Twilio's ``configureNumber`` auto-setup convenience.
+   */
+  async configureNumber(number, answerUrl) {
+    const { data } = await this.request("POST", "/Application/", {
+      app_name: "patter-inbound",
+      answer_url: answerUrl,
+      answer_method: "POST"
+    });
+    if (!data.app_id) {
+      getLogger().warn("Plivo Application create returned no app_id");
+      return;
+    }
+    await this.request("POST", `/Number/${encodeURIComponent(number)}/`, { app_id: data.app_id });
+  }
+  /**
+   * Place an outbound Plivo call routed through ``answerUrl``. Returns Plivo's
+   * ``request_uuid``. The WSS URL travels inside the answer XML, not as a dial
+   * parameter — mirroring the Python adapter.
+   */
+  async initiateCall(opts) {
+    const payload = {
+      from: opts.from,
+      to: opts.to,
+      answer_url: opts.answerUrl,
+      answer_method: "POST"
+    };
+    if (opts.ringTimeout != null) payload.ring_timeout = Math.max(1, Math.floor(opts.ringTimeout));
+    if (opts.machineDetection) {
+      payload.machine_detection = "true";
+      payload.machine_detection_time = 5e3;
+      if (opts.machineDetectionUrl) {
+        payload.machine_detection_url = opts.machineDetectionUrl;
+        payload.machine_detection_method = "POST";
+      }
+    }
+    const { data } = await this.request("POST", "/Call/", payload);
+    return { requestUuid: data.request_uuid ?? "" };
+  }
+  /** Hang up an active Plivo call by CallUUID. 204 and 404 are both success. */
+  async endCall(callUuid) {
+    if (!callUuid) throw new Error("PlivoAdapter: callUuid is required");
+    try {
+      await this.request("DELETE", `/Call/${encodeURIComponent(callUuid)}/`);
+    } catch (err) {
+      getLogger().warn(`[PlivoAdapter] endCall failed for ${callUuid}: ${String(err)}`);
+      throw err;
+    }
+  }
+  /**
+   * Build the Plivo answer XML. Unlike Twilio (``url=`` attribute), Plivo's
+   * ``<Stream>`` takes the WSS URL as its **text content**. ``bidirectional``
+   * enables two-way audio; ``keepCallAlive`` keeps the leg up for the lifetime
+   * of the WebSocket. ``extraHeaders`` (comma-separated ``key=value``) is
+   * delivered back on the WS ``start`` frame as a caller/callee fallback.
+   *
+   * Mirrors the Python adapter's ``generate_stream_xml``.
+   */
+  static generateStreamXml(streamUrl, contentType = "audio/x-mulaw;rate=8000", extraHeaders) {
+    let attrs = `bidirectional="true" keepCallAlive="true" contentType="${xmlEscapePlivo(contentType)}"`;
+    if (extraHeaders) {
+      const joined = Object.entries(extraHeaders).map(([k, v]) => `${k}=${v}`).join(",");
+      attrs += ` extraHeaders="${xmlEscapePlivo(joined)}"`;
+    }
+    return `<Response><Stream ${attrs}>${xmlEscapePlivo(streamUrl)}</Stream></Response>`;
+  }
+};
+
+// src/telephony/plivo.ts
+init_esm_shims();
+import crypto from "crypto";
+
 // src/provider-factory.ts
 init_esm_shims();
 async function createSTT(agent) {
@@ -1612,8 +521,172 @@ async function createTTS(agent) {
   return agent.tts ?? null;
 }
 
+// src/telephony/plivo.ts
+var Carrier = class {
+  kind = "plivo";
+  authId;
+  authToken;
+  constructor(opts = {}) {
+    const authId = opts.authId ?? process.env.PLIVO_AUTH_ID;
+    const authToken = opts.authToken ?? process.env.PLIVO_AUTH_TOKEN;
+    if (!authId) {
+      throw new Error(
+        "Plivo carrier requires authId. Pass { authId: 'MA...' } or set PLIVO_AUTH_ID in the environment."
+      );
+    }
+    if (!authToken) {
+      throw new Error(
+        "Plivo carrier requires authToken. Pass { authToken: '...' } or set PLIVO_AUTH_TOKEN in the environment."
+      );
+    }
+    this.authId = authId;
+    this.authToken = authToken;
+  }
+};
+function classifyPlivoAmd(result) {
+  const r = (result || "").trim().toLowerCase();
+  if (r === "human" || r === "person") return "human";
+  if (r.startsWith("machine") || r === "answering_machine" || r === "amd" || r === "true") {
+    return "machine";
+  }
+  if (r === "fax") return "fax";
+  return "unknown";
+}
+function validatePlivoSignature(url, nonce, signature, authToken, params, method = "POST") {
+  if (!signature || !nonce || !authToken) return false;
+  let base = url;
+  if (method === "POST" && params && Object.keys(params).length > 0) {
+    const keys = Object.keys(params).sort();
+    base += keys.map((k) => `${k}${params[k]}`).join("");
+  }
+  const signed = `${base}.${nonce}`;
+  const expected = crypto.createHmac("sha256", authToken).update(signed).digest("base64");
+  const expBuf = Buffer.from(expected);
+  for (const rawSig of signature.split(",")) {
+    const trimmed = rawSig.trim();
+    if (!trimmed) continue;
+    try {
+      const sigBuf = Buffer.from(trimmed);
+      if (sigBuf.length === expBuf.length && crypto.timingSafeEqual(sigBuf, expBuf)) {
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+var PLIVO_DTMF_ALLOWED = new Set("0123456789*#ABCDabcdwW");
+var PlivoBridge = class {
+  constructor(config) {
+    this.config = config;
+    const authId = config.plivoAuthId ?? "";
+    const authToken = config.plivoAuthToken ?? "";
+    this.authHeader = `Basic ${Buffer.from(`${authId}:${authToken}`).toString("base64")}`;
+    this.apiBase = `https://api.plivo.com/v1/Account/${encodeURIComponent(authId)}`;
+  }
+  config;
+  label = "Plivo";
+  telephonyProvider = "plivo";
+  inputWireFormat = "ulaw_8000";
+  authHeader;
+  apiBase;
+  sendAudio(ws, audioBase64, _streamSid) {
+    ws.send(
+      JSON.stringify({
+        event: "playAudio",
+        media: { contentType: "audio/x-mulaw", sampleRate: 8e3, payload: audioBase64 }
+      })
+    );
+  }
+  sendMark(ws, markName, streamSid) {
+    ws.send(JSON.stringify({ event: "checkpoint", streamId: streamSid, name: markName }));
+  }
+  sendClear(ws, streamSid) {
+    ws.send(JSON.stringify({ event: "clearAudio", streamId: streamSid }));
+  }
+  async transferCall(callId, toNumber) {
+    if (!/^\+[1-9]\d{6,14}$/.test(toNumber)) {
+      getLogger().warn(`PlivoBridge.transferCall rejected: invalid target ${JSON.stringify(toNumber)}`);
+      return;
+    }
+    if (!this.config.plivoAuthId || !this.config.plivoAuthToken || !callId) return;
+    if (!this.config.webhookUrl) {
+      getLogger().warn("PlivoBridge.transferCall skipped: no webhookUrl for aleg_url");
+      return;
+    }
+    const alegUrl = `https://${this.config.webhookUrl}/webhooks/plivo/transfer?to=${encodeURIComponent(toNumber)}`;
+    await fetch(`${this.apiBase}/Call/${encodeURIComponent(callId)}/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: this.authHeader },
+      body: JSON.stringify({ legs: "aleg", aleg_url: alegUrl, aleg_method: "GET" })
+    });
+    getLogger().info(`Call transferred to ${toNumber}`);
+  }
+  async sendDtmf(ws, _callId, digits, _delayMs) {
+    const filtered = Array.from(digits ?? "").filter((d) => PLIVO_DTMF_ALLOWED.has(d)).join("");
+    if (!filtered) {
+      getLogger().warn(`PlivoBridge.sendDtmf: no valid digits in ${JSON.stringify(digits)}`);
+      return;
+    }
+    ws.send(JSON.stringify({ event: "sendDTMF", dtmf: filtered }));
+  }
+  async startRecording(callId) {
+    if (!this.config.plivoAuthId || !this.config.plivoAuthToken || !callId) return;
+    try {
+      const resp = await fetch(`${this.apiBase}/Call/${encodeURIComponent(callId)}/Record/`, {
+        method: "POST",
+        headers: { Authorization: this.authHeader }
+      });
+      if (!resp.ok) {
+        getLogger().warn(`Plivo record start failed (${resp.status}): ${(await resp.text()).slice(0, 200)}`);
+      } else {
+        getLogger().info("Plivo recording started");
+      }
+    } catch (e) {
+      getLogger().warn(`Plivo record start error: ${String(e)}`);
+    }
+  }
+  async endCall(callId, _ws) {
+    if (!this.config.plivoAuthId || !this.config.plivoAuthToken || !callId) return;
+    try {
+      const resp = await fetch(`${this.apiBase}/Call/${encodeURIComponent(callId)}/`, {
+        method: "DELETE",
+        headers: { Authorization: this.authHeader }
+      });
+      if (!resp.ok && resp.status !== 404) {
+        getLogger().warn(`Plivo hangup returned ${resp.status}`);
+      }
+    } catch {
+    }
+  }
+  createStt(agent) {
+    return createSTT(agent);
+  }
+  async queryTelephonyCost(metricsAcc, callId) {
+    if (!this.config.plivoAuthId || !this.config.plivoAuthToken || !callId) return;
+    try {
+      const resp = await fetch(`${this.apiBase}/Call/${encodeURIComponent(callId)}/`, {
+        headers: { Authorization: this.authHeader },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (resp.ok) {
+        const data = await resp.json();
+        if (data.total_amount != null) {
+          metricsAcc.setActualTelephonyCost(Math.abs(parseFloat(data.total_amount)));
+          getLogger().info(`Plivo actual cost: $${data.total_amount}`);
+        }
+      }
+    } catch (err) {
+      getLogger().debug(`queryTelephonyCost(plivo) failed: ${err?.message ?? err}`);
+    }
+  }
+};
+
 // src/pricing.ts
 init_esm_shims();
+var PRICING_VERSION = "2026.3";
+var PRICING_LAST_UPDATED = "2026-05-08";
 var PricingUnit = {
   MINUTE: "minute",
   THOUSAND_CHARS: "1k_chars",
@@ -1852,7 +925,7 @@ var DEFAULT_PRICING = {
   // twilio default = US inbound local (the 99% case for voice agents receiving
   // calls on a local number). For US toll-free inbound ($0.022/min) or US
   // outbound local ($0.0140/min), override via Patter({ pricing: { twilio: {...} } }).
-  twilio: { unit: PricingUnit.MINUTE, price: 85e-4 },
+  twilio: { unit: PricingUnit.MINUTE, price: 85e-4, roundUp: true },
   // Telnyx — direction-aware rates as of 2026-05-11.
   // Sources:
   //   https://telnyx.com/pricing/elastic-sip
@@ -1870,7 +943,17 @@ var DEFAULT_PRICING = {
   // price: 0.0035 } } })`` to bill all inbound at the lower rate.
   telnyx: { unit: PricingUnit.MINUTE, price: 7e-3 },
   telnyx_inbound: { unit: PricingUnit.MINUTE, price: 35e-4 },
-  telnyx_outbound: { unit: PricingUnit.MINUTE, price: 7e-3 }
+  telnyx_outbound: { unit: PricingUnit.MINUTE, price: 7e-3 },
+  // Plivo — official US pay-as-you-go voice rates (per minute; Plivo rounds
+  // partial minutes up like Twilio). Source: https://www.plivo.com/voice/pricing/
+  //   US local inbound:    $0.0055/min
+  //   US local outbound:   $0.0115/min
+  //   US toll-free inbound: $0.0180/min (override via new Patter({ pricing }))
+  // The flat ``plivo`` key defaults to inbound local; the billed amount is
+  // also reconciled post-call from the Plivo CDR (``total_amount``).
+  plivo: { unit: PricingUnit.MINUTE, price: 55e-4, roundUp: true },
+  plivo_inbound: { unit: PricingUnit.MINUTE, price: 55e-4, roundUp: true },
+  plivo_outbound: { unit: PricingUnit.MINUTE, price: 0.0115, roundUp: true }
 };
 function cloneProviderEntry(entry) {
   const out = { ...entry };
@@ -2056,15 +1139,35 @@ function calculateLlmCost(provider2, model, inputTokens, outputTokens, cacheRead
 function calculateTelephonyCost(provider2, durationSeconds, pricing) {
   const config = pricing[provider2];
   if (!config || config.unit !== "minute") return 0;
-  const minutes = provider2 === "twilio" ? Math.ceil(durationSeconds / 60) : durationSeconds / 60;
+  const minutes = config.roundUp ? Math.ceil(durationSeconds / 60) : durationSeconds / 60;
   return minutes * (config.price ?? 0);
 }
 
 // src/dashboard/store.ts
 init_esm_shims();
 import { EventEmitter } from "events";
+import * as fs2 from "fs";
+import * as path2 from "path";
+
+// src/version.ts
+init_esm_shims();
 import * as fs from "fs";
 import * as path from "path";
+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 VERSION = readVersion();
+
+// src/dashboard/store.ts
+function sdkVersion() {
+  return VERSION;
+}
 var MetricsStore = class extends EventEmitter {
   maxCalls;
   calls = [];
@@ -2347,15 +1450,15 @@ var MetricsStore = class extends EventEmitter {
   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)}`
@@ -2388,7 +1491,8 @@ var MetricsStore = class extends EventEmitter {
         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;
@@ -2427,7 +1531,8 @@ var MetricsStore = class extends EventEmitter {
         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()
     };
   }
   /**
@@ -2463,11 +1568,11 @@ var MetricsStore = class extends EventEmitter {
    */
   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) {
@@ -2481,19 +1586,19 @@ var MetricsStore = class extends EventEmitter {
         );
       }
     }
-    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);
@@ -2501,10 +1606,10 @@ var MetricsStore = class extends EventEmitter {
           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 meta = JSON.parse(raw);
           const callId = meta.call_id || entry.name;
           if (!callId || seen.has(callId)) continue;
@@ -2517,7 +1622,7 @@ var MetricsStore = class extends EventEmitter {
           }
           if (!record.transcript || record.transcript.length === 0) {
             const fromJsonl = loadTranscriptJsonl(
-              path.join(childPath, "transcript.jsonl")
+              path2.join(childPath, "transcript.jsonl")
             );
             if (fromJsonl.length > 0) record.transcript = fromJsonl;
           }
@@ -2596,8 +1701,8 @@ function metadataToCallRecord(callId, meta) {
 }
 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) {
@@ -2640,15 +1745,15 @@ init_esm_shims();
 
 // src/dashboard/auth.ts
 init_esm_shims();
-import crypto from "crypto";
+import crypto2 from "crypto";
 function timingSafeCompare(a, b) {
   const aBuf = Buffer.from(a);
   const bBuf = Buffer.from(b);
   if (aBuf.length !== bBuf.length) {
-    crypto.timingSafeEqual(aBuf, aBuf);
+    crypto2.timingSafeEqual(aBuf, aBuf);
     return false;
   }
-  return crypto.timingSafeEqual(aBuf, bBuf);
+  return crypto2.timingSafeEqual(aBuf, bBuf);
 }
 function makeAuthMiddleware(token = "") {
   return (req, res, next) => {
@@ -2731,7 +1836,7 @@ function csvEscape(value) {
 
 // src/dashboard/ui.ts
 init_esm_shims();
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { join as join2, dirname as dirname2 } from "path";
 var FALLBACK_HTML = `<!doctype html>
 <html><head><meta charset="utf-8"><title>Patter dashboard</title></head>
@@ -2748,9 +1853,9 @@ function loadDashboardHtml() {
     join2(here, "dashboard", "ui.html"),
     join2(here, "..", "dashboard", "ui.html")
   ];
-  for (const path3 of candidates) {
+  for (const path4 of candidates) {
     try {
-      return readFileSync2(path3, "utf8");
+      return readFileSync3(path4, "utf8");
     } catch {
     }
   }
@@ -2937,7 +2042,7 @@ function mountApi(app, store, token = "") {
 
 // src/remote-message.ts
 init_esm_shims();
-import crypto2 from "crypto";
+import crypto3 from "crypto";
 var MAX_RESPONSE_BYTES = 64 * 1024;
 function validateWebSocketUrl(url) {
   let translated = url;
@@ -2965,7 +2070,7 @@ var RemoteMessageHandler = class {
     if (!this.webhookSecret) {
       throw new Error("Cannot sign without a webhookSecret");
     }
-    return crypto2.createHmac("sha256", this.webhookSecret).update(body).digest("hex");
+    return crypto3.createHmac("sha256", this.webhookSecret).update(body).digest("hex");
   }
   /**
    * Release resources held by this handler.
@@ -3047,8 +2152,8 @@ var RemoteMessageHandler = class {
         "WebSocket URL uses unencrypted ws:// \u2014 call transcripts and phone numbers will be sent in plaintext. Use wss:// in production."
       );
     }
-    const { WebSocket: WebSocket5 } = await import("ws");
-    const ws = new WebSocket5(url);
+    const { WebSocket: WebSocket3 } = await import("ws");
+    const ws = new WebSocket3(url);
     const chunks = [];
     let done = false;
     let error = null;
@@ -3102,10 +2207,10 @@ var RemoteMessageHandler = class {
       }
     });
     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);
@@ -3115,11 +2220,11 @@ var RemoteMessageHandler = class {
         yield chunks.shift();
       }
       while (!done && !error) {
-        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;
@@ -3146,7 +2251,7 @@ init_esm_shims();
 
 // src/providers/deepgram-stt.ts
 init_esm_shims();
-import WebSocket4 from "ws";
+import WebSocket2 from "ws";
 
 // src/errors.ts
 init_esm_shims();
@@ -3327,8 +2432,8 @@ var DeepgramSTT = class _DeepgramSTT {
     const url = `${DEEPGRAM_WS_URL}?${params.toString()}`;
     let ws = null;
     try {
-      ws = await new Promise((resolve, reject) => {
-        const sock = new WebSocket4(url, {
+      ws = await new Promise((resolve2, reject) => {
+        const sock = new WebSocket2(url, {
           headers: { Authorization: `Token ${this.apiKey}` }
         });
         const timer = setTimeout(() => {
@@ -3340,7 +2445,7 @@ var DeepgramSTT = class _DeepgramSTT {
         }, 5e3);
         sock.once("open", () => {
           clearTimeout(timer);
-          resolve(sock);
+          resolve2(sock);
         });
         sock.once("error", (err) => {
           clearTimeout(timer);
@@ -3367,11 +2472,11 @@ var DeepgramSTT = class _DeepgramSTT {
   }
   async openSocket() {
     const url = this.buildUrl();
-    const ws = new WebSocket4(url, {
+    const ws = new WebSocket2(url, {
       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;
@@ -3383,7 +2488,7 @@ var DeepgramSTT = class _DeepgramSTT {
         () => 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;
@@ -3404,7 +2509,7 @@ var DeepgramSTT = class _DeepgramSTT {
     ws.on("close", (code, reason) => this.handleClose(code, reason.toString()));
     ws.on("error", (err) => this.handleError(err));
     this.keepaliveTimer = setInterval(() => {
-      if (this.ws && this.ws.readyState === WebSocket4.OPEN) {
+      if (this.ws && this.ws.readyState === WebSocket2.OPEN) {
         try {
           this.ws.send(JSON.stringify({ type: "KeepAlive" }));
         } catch {
@@ -3523,7 +2628,7 @@ var DeepgramSTT = class _DeepgramSTT {
   }
   /** Send a binary audio chunk to Deepgram for transcription. */
   sendAudio(audio) {
-    if (!this.ws || this.ws.readyState !== WebSocket4.OPEN) {
+    if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) {
       this.audioDroppedCount++;
       if (this.audioDroppedCount === 1 || this.audioDroppedCount % 50 === 0) {
         getLogger().info(
@@ -3572,7 +2677,7 @@ var DeepgramSTT = class _DeepgramSTT {
    */
   finalize() {
     const ws = this.ws;
-    if (!ws || ws.readyState !== WebSocket4.OPEN) {
+    if (!ws || ws.readyState !== WebSocket2.OPEN) {
       getLogger().info(
         `[DIAG] DeepgramSTT.finalize SKIPPED (ws state=${ws?.readyState ?? "null"})`
       );
@@ -3593,7 +2698,7 @@ var DeepgramSTT = class _DeepgramSTT {
     if (!ws) return;
     this.ws = null;
     const sendSafe = (payload) => {
-      if (ws.readyState === WebSocket4.OPEN) {
+      if (ws.readyState === WebSocket2.OPEN) {
         try {
           ws.send(payload);
         } catch {
@@ -3607,7 +2712,7 @@ var DeepgramSTT = class _DeepgramSTT {
       } catch {
       }
     };
-    if (ws.readyState !== WebSocket4.OPEN) {
+    if (ws.readyState !== WebSocket2.OPEN) {
       finishClose();
       return;
     }
@@ -3676,6 +2781,21 @@ var CallMetricsAccumulator = class {
   _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;
@@ -3773,6 +2893,7 @@ var CallMetricsAccumulator = class {
     this._bargeinStoppedAt = null;
     this._turnUserText = "";
     this._turnSttAudioSeconds = 0;
+    this._turnAlreadyClosed = false;
     this._vadStoppedAt = null;
     this._sttFinalAt = null;
     this._turnCommittedAt = null;
@@ -3929,8 +3050,18 @@ var CallMetricsAccumulator = class {
   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,
@@ -3943,13 +3074,23 @@ var CallMetricsAccumulator = class {
     };
     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,
@@ -3964,6 +3105,7 @@ var CallMetricsAccumulator = class {
     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;
@@ -5236,6 +4378,35 @@ function maskPhoneNumber(number) {
 function isValidE164(number) {
   return /^\+[1-9]\d{6,14}$/.test(number);
 }
+function augmentWithBuiltinHandoffTools(userTools, callbacks) {
+  const out = [...userTools ?? []];
+  if (callbacks.transferCall) {
+    const transferCall = callbacks.transferCall;
+    out.push({
+      ...TRANSFER_CALL_TOOL,
+      handler: async (args) => {
+        const number = typeof args.number === "string" ? args.number : "";
+        if (!isValidE164(number)) {
+          return JSON.stringify({ error: "Invalid phone number format", status: "rejected" });
+        }
+        await transferCall(number);
+        return JSON.stringify({ status: "transferring", to: number });
+      }
+    });
+  }
+  if (callbacks.endCall) {
+    const endCall = callbacks.endCall;
+    out.push({
+      ...END_CALL_TOOL,
+      handler: async (args) => {
+        const reason = typeof args.reason === "string" ? args.reason : "conversation_complete";
+        await endCall(reason);
+        return JSON.stringify({ status: "ending", reason });
+      }
+    });
+  }
+  return out;
+}
 var HALLUCINATIONS = /* @__PURE__ */ new Set([
   "you",
   "thank you",
@@ -5252,7 +4423,23 @@ var HALLUCINATIONS = /* @__PURE__ */ new Set([
   ".",
   "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)"
 ]);
 var StreamHandler = class _StreamHandler {
   deps;
@@ -5378,13 +4565,17 @@ var StreamHandler = class _StreamHandler {
    * 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;
   /**
@@ -5424,30 +4615,12 @@ var StreamHandler = class _StreamHandler {
    * 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
@@ -5512,6 +4685,14 @@ var StreamHandler = class _StreamHandler {
       } 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
@@ -5528,56 +4709,19 @@ var StreamHandler = class _StreamHandler {
     }
     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. */
@@ -5854,8 +4998,8 @@ var StreamHandler = class _StreamHandler {
     this.ttsByteCarry = null;
   }
   /**
-   * Start call recording when configured. Currently Twilio-only — bridges may
-   * expose ``startRecording`` for parity when we add other carriers.
+   * Start call recording when configured. Bridges expose
+   * ``startRecording`` for carrier parity (Twilio and Telnyx supported).
    */
   async startRecordingIfRequested(callId) {
     const { recording, config } = this.deps;
@@ -6015,7 +5159,7 @@ var StreamHandler = class _StreamHandler {
       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(
@@ -6101,7 +5245,7 @@ var StreamHandler = class _StreamHandler {
         this.metricsAcc.addSttAudioBytes(pcm16k.length);
       }
     } else if (this.adapter) {
-      if (this.adapter instanceof ElevenLabsConvAIAdapter && this.deps.bridge.telephonyProvider === "twilio" && this.adapter.inputAudioFormat !== "ulaw_8000") {
+      if (this.adapter instanceof ElevenLabsConvAIAdapter && this.deps.bridge.inputWireFormat === "ulaw_8000" && this.adapter.inputAudioFormat !== "ulaw_8000") {
         const pcm8k = mulawToPcm16(audioBuffer);
         const pcm16k = this.inboundResampler.process(pcm8k);
         this.adapter.sendAudio(pcm16k);
@@ -6151,9 +5295,21 @@ var StreamHandler = class _StreamHandler {
   /** 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();
@@ -6166,9 +5322,21 @@ var StreamHandler = class _StreamHandler {
   /** 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();
@@ -6207,13 +5375,40 @@ var StreamHandler = class _StreamHandler {
    * 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";
+    if (carrier === "plivo") return fmt === "ulaw_8000";
+    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.
@@ -6224,17 +5419,11 @@ var StreamHandler = class _StreamHandler {
     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
@@ -6250,7 +5439,7 @@ var StreamHandler = class _StreamHandler {
     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
@@ -6267,30 +5456,20 @@ var StreamHandler = class _StreamHandler {
    */
   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) {
-      if (!this.isSpeaking) break;
-      await this.waitForMarkWindow();
+    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;
-      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;
   }
@@ -6310,6 +5489,12 @@ var StreamHandler = class _StreamHandler {
           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`);
@@ -6319,7 +5504,7 @@ var StreamHandler = class _StreamHandler {
     }
     if (!this.deps.agent.vad) {
       try {
-        const { SileroVAD } = await import("./silero-vad-NSEXI4XS.mjs");
+        const { SileroVAD } = await import("./silero-vad-LNDFGIY7.mjs");
         this.autoVad = await SileroVAD.forPhoneCall();
         getLogger().info(
           `auto-VAD enabled (SileroVAD, phone preset). Pass agent.vad=\u2026 to override.`
@@ -6338,12 +5523,9 @@ var StreamHandler = class _StreamHandler {
       }
     }
     if (this.deps.agent.echoCancellation) {
-      const carrier = this.deps.bridge.telephonyProvider;
-      if (carrier === "twilio" || carrier === "telnyx") {
-        getLogger().warn(
-          `echoCancellation: true on ${carrier} (PSTN). Server-side NLMS cannot model PSTN's ~250\u20131500 ms round-trip echo with a 32 ms filter window \u2014 it will silently no-op. Best practice: keep echoCancellation: false; rely on the carrier + caller device's built-in echo suppression and Patter's self-hearing guard. Enable AEC only for browser/native deployments where the SDK owns the audio path end-to-end.`
-        );
-      }
+      getLogger().warn(
+        `echoCancellation: true on ${this.deps.bridge.telephonyProvider} (PSTN). Server-side NLMS cannot model PSTN's ~250\u20131500 ms round-trip echo with a 32 ms filter window \u2014 it will silently no-op. Best practice: keep echoCancellation: false; rely on the carrier + caller device's built-in echo suppression and Patter's self-hearing guard. Enable AEC only for browser/native deployments where the SDK owns the audio path end-to-end.`
+      );
       try {
         const { NlmsEchoCanceller } = await import("./aec-PJJMUM5E.mjs");
         this.aec = new NlmsEchoCanceller({ sampleRate: 16e3 });
@@ -6476,13 +5658,20 @@ var StreamHandler = class _StreamHandler {
         );
       }
       const providerModel = this.deps.agent.llm?.model ?? "";
+      const augmentedTools = augmentWithBuiltinHandoffTools(
+        this.deps.agent.tools,
+        {
+          transferCall: (number) => this.deps.bridge.transferCall(this.callId, number),
+          endCall: () => this.deps.bridge.endCall(this.callId, this.ws)
+        }
+      );
       this.llmLoop = new LLMLoop(
         "",
         // apiKey unused when llmProvider is supplied
         providerModel,
         // propagate so calculateLlmCost can match the price row
         resolvedPrompt,
-        this.deps.agent.tools,
+        augmentedTools,
         this.deps.agent.llm,
         this.deps.agent.disablePhonePreamble ?? false
       );
@@ -6493,11 +5682,18 @@ var StreamHandler = class _StreamHandler {
     } else if (!this.deps.onMessage && this.deps.config.openaiKey) {
       let llmModel = this.deps.agent.model || "gpt-4o-mini";
       if (llmModel.includes("realtime")) llmModel = "gpt-4o-mini";
+      const augmentedTools = augmentWithBuiltinHandoffTools(
+        this.deps.agent.tools,
+        {
+          transferCall: (number) => this.deps.bridge.transferCall(this.callId, number),
+          endCall: () => this.deps.bridge.endCall(this.callId, this.ws)
+        }
+      );
       this.llmLoop = new LLMLoop(
         this.deps.config.openaiKey,
         llmModel,
         resolvedPrompt,
-        this.deps.agent.tools,
+        augmentedTools,
         void 0,
         this.deps.agent.disablePhonePreamble ?? false
       );
@@ -7012,16 +6208,49 @@ var StreamHandler = class _StreamHandler {
   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();
@@ -7141,8 +6370,21 @@ var StreamHandler = class _StreamHandler {
     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 = "";
@@ -7294,6 +6536,18 @@ var StreamHandler = class _StreamHandler {
     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();
@@ -7528,32 +6782,32 @@ async function queryDeepgramCost(metricsAcc, deepgramKey, deepgramRequestId) {
 
 // src/services/call-log.ts
 init_esm_shims();
-import * as crypto3 from "crypto";
-import * as fs2 from "fs";
+import * as crypto4 from "crypto";
+import * as fs3 from "fs";
 import { promises as fsp } from "fs";
 import * as os from "os";
-import * as path2 from "path";
+import * as path3 from "path";
 var SCHEMA_VERSION = "1.0";
 var DEFAULT_RETENTION_DAYS = 30;
 function xdgDataHome() {
-  return process.env.XDG_DATA_HOME || path2.join(os.homedir(), ".local", "share");
+  return process.env.XDG_DATA_HOME || path3.join(os.homedir(), ".local", "share");
 }
 function platformDefaultRoot() {
   if (process.platform === "darwin") {
-    return path2.join(os.homedir(), "Library", "Application Support", "patter");
+    return path3.join(os.homedir(), "Library", "Application Support", "patter");
   }
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA;
-    if (localAppData) return path2.join(localAppData, "patter");
-    return path2.join(os.homedir(), "AppData", "Local", "patter");
+    if (localAppData) return path3.join(localAppData, "patter");
+    return path3.join(os.homedir(), "AppData", "Local", "patter");
   }
-  return path2.join(xdgDataHome(), "patter");
+  return path3.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 path2.join(os.homedir(), value.slice(1));
+  if (value.startsWith("~")) return path3.join(os.homedir(), value.slice(1));
   return value;
 }
 function retentionDays() {
@@ -7564,16 +6818,16 @@ 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 "";
   const mode = redactMode();
   if (mode === "full") return raw;
   if (mode === "hash_only") {
-    return "sha256:" + crypto3.createHash("sha256").update(raw, "utf8").digest("hex").slice(0, 16);
+    return "sha256:" + crypto4.createHash("sha256").update(raw, "utf8").digest("hex").slice(0, 16);
   }
   return maskPhoneNumber(raw);
 }
@@ -7582,9 +6836,9 @@ function utcIso(tsSeconds) {
   return new Date(ms).toISOString();
 }
 async function atomicWriteJson(filePath, payload) {
-  const dir = path2.dirname(filePath);
+  const dir = path3.dirname(filePath);
   await fsp.mkdir(dir, { recursive: true });
-  const tmp = path2.join(dir, `.tmp.${process.pid}.${crypto3.randomBytes(4).toString("hex")}.json`);
+  const tmp = path3.join(dir, `.tmp.${process.pid}.${crypto4.randomBytes(4).toString("hex")}.json`);
   try {
     const handle = await fsp.open(tmp, "w");
     try {
@@ -7603,7 +6857,7 @@ async function atomicWriteJson(filePath, payload) {
   }
 }
 async function appendJsonl(filePath, record) {
-  await fsp.mkdir(path2.dirname(filePath), { recursive: true });
+  await fsp.mkdir(path3.dirname(filePath), { recursive: true });
   await fsp.appendFile(filePath, JSON.stringify(record) + "\n", { encoding: "utf8" });
 }
 var CallLogger = class {
@@ -7613,9 +6867,9 @@ var CallLogger = class {
       this.root = null;
       return;
     }
-    const resolved = root.startsWith("~") ? path2.join(os.homedir(), root.slice(1)) : root;
+    const resolved = root.startsWith("~") ? path3.join(os.homedir(), root.slice(1)) : root;
     try {
-      fs2.mkdirSync(resolved, { recursive: true });
+      fs3.mkdirSync(resolved, { recursive: true });
       this.root = resolved;
       getLogger().info(`Call logs: ${resolved}`);
     } catch (err) {
@@ -7637,7 +6891,7 @@ var CallLogger = class {
     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 path2.join(this.root, "calls", year, month, day, safeId);
+    return path3.join(this.root, "calls", year, month, day, safeId);
   }
   /** Write the initial `metadata.json` for a new call. */
   async logCallStart(callId, input = {}) {
@@ -7655,6 +6909,7 @@ var CallLogger = class {
       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 ?? {},
@@ -7664,11 +6919,11 @@ var CallLogger = class {
       error: null
     };
     try {
-      await atomicWriteJson(path2.join(dir, "metadata.json"), metadata);
+      await atomicWriteJson(path3.join(dir, "metadata.json"), metadata);
     } catch (err) {
       getLogger().warn(`call_log write failed (${sanitizeLogValue(callId)}): ${sanitizeLogValue(String(err))}`);
     }
-    if (crypto3.randomBytes(1)[0] < 5) {
+    if (crypto4.randomBytes(1)[0] < 5) {
       this.sweepOldDays();
     }
   }
@@ -7683,7 +6938,7 @@ var CallLogger = class {
       ...turn
     };
     try {
-      await appendJsonl(path2.join(dir, "transcript.jsonl"), record);
+      await appendJsonl(path3.join(dir, "transcript.jsonl"), record);
     } catch (err) {
       getLogger().warn(
         `call_log turn write failed (${sanitizeLogValue(callId)}): ${sanitizeLogValue(String(err))}`
@@ -7702,7 +6957,7 @@ var CallLogger = class {
       data: payload
     };
     try {
-      await appendJsonl(path2.join(dir, "events.jsonl"), record);
+      await appendJsonl(path3.join(dir, "events.jsonl"), record);
     } catch (err) {
       getLogger().warn(
         `call_log event write failed (${sanitizeLogValue(callId)}): ${sanitizeLogValue(String(err))}`
@@ -7714,7 +6969,7 @@ var CallLogger = class {
     if (!this.enabled) return;
     const dir = this.callDir(callId);
     if (dir === null) return;
-    const metadataPath = path2.join(dir, "metadata.json");
+    const metadataPath = path3.join(dir, "metadata.json");
     let existing = {};
     try {
       existing = JSON.parse(await fsp.readFile(metadataPath, "utf8"));
@@ -7749,20 +7004,20 @@ var CallLogger = class {
     const days = retentionDays();
     if (days === 0) return;
     const cutoff = Date.now() / 1e3 - days * 86400;
-    const callsRoot = path2.join(this.root, "calls");
-    if (!fs2.existsSync(callsRoot)) return;
+    const callsRoot = path3.join(this.root, "calls");
+    if (!fs3.existsSync(callsRoot)) return;
     try {
-      for (const yearName of fs2.readdirSync(callsRoot)) {
+      for (const yearName of fs3.readdirSync(callsRoot)) {
         if (!/^\d+$/.test(yearName)) continue;
-        const yearDir = path2.join(callsRoot, yearName);
-        if (!fs2.statSync(yearDir).isDirectory()) continue;
-        for (const monthName of fs2.readdirSync(yearDir)) {
+        const yearDir = path3.join(callsRoot, yearName);
+        if (!fs3.statSync(yearDir).isDirectory()) continue;
+        for (const monthName of fs3.readdirSync(yearDir)) {
           if (!/^\d+$/.test(monthName)) continue;
-          const monthDir = path2.join(yearDir, monthName);
-          if (!fs2.statSync(monthDir).isDirectory()) continue;
-          for (const dayName of fs2.readdirSync(monthDir)) {
+          const monthDir = path3.join(yearDir, monthName);
+          if (!fs3.statSync(monthDir).isDirectory()) continue;
+          for (const dayName of fs3.readdirSync(monthDir)) {
             if (!/^\d+$/.test(dayName)) continue;
-            const dayDir = path2.join(monthDir, dayName);
+            const dayDir = path3.join(monthDir, dayName);
             const y = Number.parseInt(yearName, 10);
             const m = Number.parseInt(monthName, 10);
             const d = Number.parseInt(dayName, 10);
@@ -7772,12 +7027,12 @@ var CallLogger = class {
             }
           }
           try {
-            if (fs2.readdirSync(monthDir).length === 0) fs2.rmdirSync(monthDir);
+            if (fs3.readdirSync(monthDir).length === 0) fs3.rmdirSync(monthDir);
           } catch {
           }
         }
         try {
-          if (fs2.readdirSync(yearDir).length === 0) fs2.rmdirSync(yearDir);
+          if (fs3.readdirSync(yearDir).length === 0) fs3.rmdirSync(yearDir);
         } catch {
         }
       }
@@ -7788,19 +7043,19 @@ var CallLogger = class {
 };
 function rmTree(target) {
   try {
-    for (const child of fs2.readdirSync(target)) {
-      const childPath = path2.join(target, child);
-      const stat = fs2.lstatSync(childPath);
+    for (const child of fs3.readdirSync(target)) {
+      const childPath = path3.join(target, child);
+      const stat = fs3.lstatSync(childPath);
       if (stat.isDirectory()) {
         rmTree(childPath);
       } else {
         try {
-          fs2.unlinkSync(childPath);
+          fs3.unlinkSync(childPath);
         } catch {
         }
       }
     }
-    fs2.rmdirSync(target);
+    fs3.rmdirSync(target);
   } catch {
   }
 }
@@ -7848,6 +7103,19 @@ function classifyTelnyxAmd(result) {
   if (result === "fax") return "fax";
   return "unknown";
 }
+function twilioStatusToOutcome(callStatus) {
+  const s = (callStatus || "").toLowerCase();
+  if (s === "no-answer") return "no_answer";
+  if (s === "busy") return "busy";
+  return "failed";
+}
+function telnyxHangupOutcome(cause) {
+  const c = (cause || "").toLowerCase();
+  if (c === "no_answer" || c === "timeout" || c === "no_user_response") return "no_answer";
+  if (c === "user_busy" || c === "busy") return "busy";
+  if (c === "call_rejected" || c === "rejected" || c === "destination_out_of_order") return "failed";
+  return null;
+}
 function validateWebhookUrl(url) {
   const parsed = new URL(url);
   if (!["http:", "https:"].includes(parsed.protocol)) {
@@ -7905,7 +7173,7 @@ function validateTelnyxSignature(rawBody, signature, timestamp, publicKey, toler
     if (ageMs < 0 || ageMs > toleranceSec * 1e3) return false;
     const payload = `${timestamp}|${rawBody}`;
     const keyBuffer = Buffer.from(publicKey, "base64");
-    const keyObject = crypto4.createPublicKey({
+    const keyObject = crypto5.createPublicKey({
       key: keyBuffer,
       format: "der",
       type: "spki"
@@ -7915,7 +7183,7 @@ function validateTelnyxSignature(rawBody, signature, timestamp, publicKey, toler
       if (!trimmed) continue;
       try {
         const sigBuffer = Buffer.from(trimmed, "base64");
-        if (crypto4.verify(null, Buffer.from(payload), keyObject, sigBuffer)) {
+        if (crypto5.verify(null, Buffer.from(payload), keyObject, sigBuffer)) {
           return true;
         }
       } catch {
@@ -7932,12 +7200,12 @@ function validateTwilioSid(sid, prefix = "CA") {
 }
 function validateTwilioSignature(url, params, signature, authToken) {
   const data = url + Object.keys(params).sort().reduce((acc, key) => acc + key + (params[key] ?? ""), "");
-  const expected = crypto4.createHmac("sha1", authToken).update(data).digest("base64");
+  const expected = crypto5.createHmac("sha1", authToken).update(data).digest("base64");
   try {
     const sigBuf = Buffer.from(signature);
     const expBuf = Buffer.from(expected);
     if (sigBuf.length !== expBuf.length) return false;
-    return crypto4.timingSafeEqual(sigBuf, expBuf);
+    return crypto5.timingSafeEqual(sigBuf, expBuf);
   } catch {
     return false;
   }
@@ -8010,6 +7278,7 @@ var TwilioBridge = class {
   config;
   label = "Twilio";
   telephonyProvider = "twilio";
+  inputWireFormat = "ulaw_8000";
   sendAudio(ws, audioBase64, streamSid) {
     ws.send(JSON.stringify({ event: "media", streamSid, media: { payload: audioBase64 } }));
   }
@@ -8097,7 +7366,7 @@ var TELNYX_DTMF_ALLOWED = new Set("0123456789*#ABCDabcdwW");
 var TELNYX_DTMF_DURATION_MS = 250;
 async function sleep(ms) {
   if (ms <= 0) return;
-  await new Promise((resolve) => setTimeout(resolve, ms));
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
 }
 var TelnyxBridge = class {
   constructor(config) {
@@ -8106,6 +7375,11 @@ var TelnyxBridge = class {
   config;
   label = "Telnyx";
   telephonyProvider = "telnyx";
+  // ``streaming_start`` negotiates PCMU bidirectional by default — keeping
+  // ``ulaw_8000`` here matches what TwilioBridge does and keeps the stream
+  // handler's input-transcode branch in the right shape. If a deployment
+  // overrides the negotiation to L16, this should flip to ``pcm_16000``.
+  inputWireFormat = "ulaw_8000";
   sendAudio(ws, audioBase64, _streamSid) {
     ws.send(JSON.stringify({ event: "media", media: { payload: audioBase64 } }));
   }
@@ -8127,7 +7401,7 @@ var TelnyxBridge = class {
     });
     getLogger().info(`Telnyx call transferred to ${toNumber}`);
   }
-  async sendDtmf(callId, digits, delayMs) {
+  async sendDtmf(_ws, callId, digits, delayMs) {
     if (!digits) {
       getLogger().warn("TelnyxBridge.sendDtmf called with empty digits");
       return;
@@ -8325,6 +7599,99 @@ var EmbeddedServer = class {
    * (tests) work without further setup. See FIX #91.
    */
   recordPrewarmWaste = () => void 0;
+  /**
+   * Per-callId completion deferreds for ``Patter.call({ wait: true })``.
+   * Resolved by the FIRST terminal signal: the Twilio/Telnyx status callback
+   * for no-media outcomes (no-answer / busy / failed), or ``onCallEnd`` for a
+   * connected call (answered / voicemail). The AMD classification is recorded
+   * per callId so the connected-call path can distinguish ``answered`` from
+   * ``voicemail``. This is what lets ``call({ wait: true })`` resolve to a
+   * structured {@link CallResult} without the caller hand-wiring ``onCallEnd``
+   * to a promise. Public so ``client.ts`` can register/await + fail in-flight
+   * waiters on ``disconnect()``. Mirrors Python's ``EmbeddedServer._completions``.
+   */
+  completions = /* @__PURE__ */ new Map();
+  /** AMD classification recorded per callId, used by the connected-call path. */
+  amdClass = /* @__PURE__ */ new Map();
+  // === Outbound completion registry (call({ wait: true })) ===
+  /**
+   * Register (or return) a completion promise for an outbound call.
+   *
+   * Called by ``Patter.call({ wait: true })`` immediately after the carrier
+   * accepts the dial — the promise resolves to a {@link CallResult} once a
+   * terminal signal arrives. Idempotent: returns the existing pending promise
+   * if one is already registered for ``callId``. Mirrors Python's
+   * ``register_completion``.
+   */
+  registerCompletion(callId) {
+    const existing = this.completions.get(callId);
+    if (existing && !existing.done) {
+      return existing.promise;
+    }
+    let resolve2;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve2 = res;
+      reject = rej;
+    });
+    this.completions.set(callId, { promise, resolve: resolve2, reject, done: false });
+    return promise;
+  }
+  /** Drop a registered completion (e.g. on a backstop timeout) without resolving it. */
+  deleteCompletion(callId) {
+    this.completions.delete(callId);
+    this.amdClass.delete(callId);
+  }
+  /**
+   * Resolve a pending completion with a {@link CallResult}.
+   *
+   * No-op when no completion is registered for ``callId`` (the common case —
+   * most calls are placed without ``wait: true``) or it is already done.
+   * Builds the result from the ``onCallEnd`` payload when ``data`` is provided
+   * (connected calls carry transcript + {@link CallMetrics}); no-media
+   * outcomes pass ``data`` undefined and yield an empty transcript / no cost.
+   * Mirrors Python's ``_resolve_completion``.
+   */
+  resolveCompletion(callId, args) {
+    const entry = this.completions.get(callId);
+    if (!entry || entry.done) return;
+    const data = args.data;
+    const metrics = data?.metrics ?? null;
+    const cost = metrics?.cost ?? null;
+    const durationRaw = metrics?.duration_seconds;
+    const duration = typeof durationRaw === "number" ? durationRaw : 0;
+    const transcriptRaw = data?.transcript;
+    const transcript = Array.isArray(transcriptRaw) ? transcriptRaw : [];
+    const result = {
+      callId,
+      outcome: args.outcome,
+      status: args.status,
+      durationSeconds: duration,
+      transcript,
+      cost,
+      metrics
+    };
+    entry.done = true;
+    entry.resolve(result);
+    this.completions.delete(callId);
+    this.amdClass.delete(callId);
+  }
+  /**
+   * Fail every in-flight completion with ``error``. Called by
+   * ``Patter.disconnect()`` so a ``call({ wait: true })`` awaiter does not
+   * hang until its backstop timeout once the server is gone. Mirrors the
+   * Python ``disconnect()`` change that fails in-flight ``wait=True`` awaiters.
+   */
+  failPendingCompletions(error) {
+    for (const entry of this.completions.values()) {
+      if (!entry.done) {
+        entry.done = true;
+        entry.reject(error);
+      }
+    }
+    this.completions.clear();
+    this.amdClass.clear();
+  }
   /** Bind HTTP + WebSocket listeners on `port`, mount carrier webhooks and dashboard routes. */
   async start(port = 8e3) {
     const webhookUrlPattern = /^[a-zA-Z0-9][a-zA-Z0-9.\-]+[a-zA-Z0-9]$/;
@@ -8388,8 +7755,10 @@ var EmbeddedServer = class {
         return;
       }
       const body = req.body;
-      const callSid = sanitizeLogValue(body["CallSid"] ?? "");
-      const callStatus = sanitizeLogValue(body["CallStatus"] ?? "");
+      const rawCallSid = body["CallSid"] ?? "";
+      const rawCallStatus = body["CallStatus"] ?? "";
+      const callSid = sanitizeLogValue(rawCallSid);
+      const callStatus = sanitizeLogValue(rawCallStatus);
       const duration = body["CallDuration"] ?? body["Duration"] ?? "";
       getLogger().info(
         `Twilio status ${callStatus} for call ${callSid} (duration=${duration})`
@@ -8406,6 +7775,10 @@ var EmbeddedServer = class {
         } catch (err) {
           getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
         }
+        this.resolveCompletion(rawCallSid, {
+          outcome: twilioStatusToOutcome(rawCallStatus),
+          status: rawCallStatus
+        });
       }
       res.status(204).send();
     });
@@ -8448,6 +7821,9 @@ var EmbeddedServer = class {
       const answeredBy = body["AnsweredBy"] ?? "";
       const callSid = body["CallSid"] ?? "";
       getLogger().info(`AMD result for ${sanitizeLogValue(callSid)}: ${sanitizeLogValue(answeredBy)}`);
+      if (callSid) {
+        this.amdClass.set(callSid, classifyTwilioAmd(answeredBy));
+      }
       const cb = this.onMachineDetection;
       if (cb && callSid) {
         try {
@@ -8573,6 +7949,9 @@ var EmbeddedServer = class {
         getLogger().info(
           `Telnyx AMD result for ${sanitizeLogValue(amdCallId)}: ${sanitizeLogValue(amdResult)}`
         );
+        if (amdCallId) {
+          this.amdClass.set(amdCallId, classifyTelnyxAmd(amdResult));
+        }
         const cbTx = this.onMachineDetection;
         if (cbTx && amdCallId) {
           try {
@@ -8609,6 +7988,13 @@ var EmbeddedServer = class {
           } catch (err) {
             getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
           }
+          const noMediaOutcome = telnyxHangupOutcome(hangupCause);
+          if (noMediaOutcome !== null) {
+            this.resolveCompletion(hangupCallId, {
+              outcome: noMediaOutcome,
+              status: hangupCause
+            });
+          }
         }
         return res.status(200).send();
       }
@@ -8661,6 +8047,121 @@ var EmbeddedServer = class {
       }
       return res.status(200).send();
     });
+    const validatePlivoRequest = (req, res) => {
+      const authToken = this.config.plivoAuthToken;
+      if (!authToken) {
+        if (this.config.requireSignature !== false) {
+          getLogger().error(
+            "Plivo webhook rejected: plivoAuthToken not configured and requireSignature is not false"
+          );
+          res.status(503).send("Webhook signature required");
+          return false;
+        }
+        return true;
+      }
+      const method = req.method.toUpperCase();
+      const params = method === "POST" && req.body && typeof req.body === "object" ? Object.fromEntries(
+        Object.entries(req.body).map(([k, v]) => [k, String(v)])
+      ) : {};
+      const signature = req.headers["x-plivo-signature-v3"] || "";
+      const nonce = req.headers["x-plivo-signature-v3-nonce"] || "";
+      const url = `https://${this.config.webhookUrl}${req.originalUrl}`;
+      if (!validatePlivoSignature(url, nonce, signature, authToken, params, method)) {
+        getLogger().warn("Plivo webhook rejected: invalid or missing V3 signature");
+        res.status(403).send("Invalid signature");
+        return false;
+      }
+      return true;
+    };
+    app.post("/webhooks/plivo/voice", (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const body = req.body ?? {};
+      const callUuid = body["CallUUID"] ?? "";
+      const caller = body["From"] ?? "";
+      const callee = body["To"] ?? "";
+      const qs = `?caller=${encodeURIComponent(caller)}&callee=${encodeURIComponent(callee)}`;
+      const streamUrl = `wss://${this.config.webhookUrl}/ws/plivo/stream/${callUuid || "outbound"}${qs}`;
+      const xml = PlivoAdapter.generateStreamXml(streamUrl, "audio/x-mulaw;rate=8000", {
+        "X-PH-caller": caller,
+        "X-PH-callee": callee
+      });
+      res.type("text/xml").send(xml);
+    });
+    app.post("/webhooks/plivo/status", (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const body = req.body ?? {};
+      const callUuid = body["CallUUID"] ?? "";
+      const callStatus = body["CallStatus"] ?? body["Status"] ?? "";
+      const duration = body["Duration"] ?? body["BillDuration"] ?? "";
+      getLogger().info(
+        `Plivo status ${sanitizeLogValue(callStatus)} for call ${sanitizeLogValue(callUuid)} (duration=${duration})`
+      );
+      if (callUuid && callStatus) {
+        const extra = {};
+        const parsed = parseFloat(duration);
+        if (!Number.isNaN(parsed)) extra.duration_seconds = parsed;
+        this.metricsStore.updateCallStatus(callUuid, callStatus, extra);
+      }
+      if (callUuid && ["no-answer", "busy", "failed", "timeout", "cancel"].includes(callStatus)) {
+        try {
+          this.recordPrewarmWaste(callUuid);
+        } catch (err) {
+          getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
+        }
+        const outcome = callStatus === "no-answer" || callStatus === "timeout" ? "no_answer" : callStatus === "busy" ? "busy" : "failed";
+        this.resolveCompletion(callUuid, { outcome, status: callStatus });
+      }
+      res.status(200).send();
+    });
+    app.post("/webhooks/plivo/amd", async (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const body = req.body ?? {};
+      const callUuid = body["CallUUID"] ?? "";
+      const amdRaw = body["Machine"] || body["MachineDetection"] || body["AnsweredBy"] || body["CallStatus"] || "";
+      getLogger().info(`AMD result for ${sanitizeLogValue(callUuid)}: ${sanitizeLogValue(amdRaw)}`);
+      const classification = classifyPlivoAmd(amdRaw);
+      if (callUuid) this.amdClass.set(callUuid, classification);
+      const cb = this.onMachineDetection;
+      if (cb && callUuid) {
+        try {
+          await cb({
+            call_id: callUuid,
+            carrier: "plivo",
+            classification,
+            raw: amdRaw,
+            detected_at: Date.now() / 1e3
+          });
+        } catch (err) {
+          getLogger().warn(`onMachineDetection callback threw: ${sanitizeLogValue(String(err))}`);
+        }
+      }
+      if (classification === "machine" && callUuid) {
+        try {
+          this.recordPrewarmWaste(callUuid);
+        } catch (err) {
+          getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
+        }
+        if (this.voicemailMessage && this.config.plivoAuthId && this.config.plivoAuthToken) {
+          await dropPlivoVoicemail(
+            callUuid,
+            this.voicemailMessage,
+            this.config.plivoAuthId,
+            this.config.plivoAuthToken
+          );
+        }
+      }
+      res.status(200).send();
+    });
+    app.all("/webhooks/plivo/transfer", (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const to = String(req.query.to ?? "");
+      if (!to || !/^\+[1-9]\d{6,14}$/.test(to)) {
+        getLogger().warn(`Plivo transfer XML: invalid target ${JSON.stringify(to)}`);
+        res.type("text/xml").send("<Response><Hangup/></Response>");
+        return;
+      }
+      res.type("text/xml").send(`<Response><Dial><Number>${xmlEscape(to)}</Number></Dial></Response>`);
+    });
     this.server = createServer(app);
     this.wss = new WebSocketServer({ noServer: true });
     const MAX_WS_PER_IP = 10;
@@ -8693,14 +8194,16 @@ var EmbeddedServer = class {
       ws.once("close", () => {
         this.activeConnections.delete(ws);
       });
-      const isTelnyx = this.config.telephonyProvider === "telnyx";
-      if (isTelnyx) {
+      const provider2 = this.config.telephonyProvider;
+      if (provider2 === "telnyx") {
         this.handleTelnyxStream(ws, url);
+      } else if (provider2 === "plivo") {
+        this.handlePlivoStream(ws, url);
       } else {
         this.handleTwilioStream(ws, url);
       }
     });
-    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}`);
@@ -8722,7 +8225,7 @@ var EmbeddedServer = class {
           }
           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();
       });
     });
   }
@@ -8765,7 +8268,7 @@ var EmbeddedServer = class {
           `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,
@@ -8836,9 +8339,11 @@ var EmbeddedServer = class {
         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 logger.logCallStart(callId, {
           caller: resolvedCaller,
           callee: resolvedCallee,
+          direction: resolvedDirection,
           telephonyProvider: bridge.telephonyProvider,
           providerMode: agent.provider ?? "",
           agent: agentSnapshot()
@@ -8877,6 +8382,12 @@ var EmbeddedServer = class {
         }).catch((err) => getLogger().error(`call_log end error: ${String(err)}`));
       }
       if (userEnd) await userEnd(data);
+      const cid = typeof data.call_id === "string" ? data.call_id : "";
+      if (cid) {
+        const cls = this.amdClass.get(cid);
+        const outcome = cls === "machine" ? "voicemail" : "answered";
+        this.resolveCompletion(cid, { outcome, status: "completed", data });
+      }
     };
     return [wrappedStart, wrappedMetrics, wrappedEnd];
   }
@@ -8983,6 +8494,52 @@ var EmbeddedServer = class {
     });
   }
   // ---------------------------------------------------------------------------
+  // Plivo WebSocket message parser (thin layer)
+  // ---------------------------------------------------------------------------
+  handlePlivoStream(ws, url) {
+    const caller = url.searchParams.get("caller") ?? "";
+    const callee = url.searchParams.get("callee") ?? "";
+    const bridge = new PlivoBridge(this.config);
+    const handler = new StreamHandler(this.buildStreamHandlerDeps(bridge), ws, caller, callee);
+    ws.on("message", async (raw) => {
+      try {
+        let data;
+        try {
+          data = JSON.parse(raw.toString());
+        } catch (e) {
+          getLogger().error("Failed to parse Plivo WS message:", e);
+          return;
+        }
+        const event = data.event ?? "";
+        if (event === "start") {
+          handler.setStreamSid(data.start?.streamId ?? "");
+          const callId = data.start?.callId ?? "";
+          if (callId) this.activeCallIds.set(ws, callId);
+          await handler.handleCallStart(callId);
+        } else if (event === "media") {
+          const payload = data.media?.payload ?? "";
+          if (payload) handler.handleAudio(Buffer.from(payload, "base64"));
+        } else if (event === "playedStream") {
+          const markName = String(data.name ?? "");
+          if (markName) await handler.onMark(markName);
+        } else if (event === "dtmf") {
+          const digit = String(data.dtmf?.digit ?? "").trim();
+          if (digit) await handler.handleDtmf(digit);
+        } else if (event === "playFailed" || event === "error") {
+          getLogger().warn(`Plivo ${event}: ${data.reason ?? "unknown"}`);
+        } else if (event === "stop") {
+          await handler.handleStop();
+        }
+      } catch (err) {
+        getLogger().error("Stream handler error (Plivo):", err);
+      }
+    });
+    ws.on("close", async () => {
+      this.activeCallIds.delete(ws);
+      await handler.handleWsClose();
+    });
+  }
+  // ---------------------------------------------------------------------------
   // Graceful shutdown
   // ---------------------------------------------------------------------------
   /**
@@ -8996,13 +8553,13 @@ var EmbeddedServer = class {
    */
   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";
+    const provider2 = this.config.telephonyProvider;
     for (const [ws, callId] of this.activeCallIds) {
       try {
-        const bridge = isTelnyx ? new TelnyxBridge(this.config) : new TwilioBridge(this.config);
+        const bridge = provider2 === "telnyx" ? new TelnyxBridge(this.config) : provider2 === "plivo" ? new PlivoBridge(this.config) : new TwilioBridge(this.config);
         await bridge.endCall(callId, ws);
       } catch {
       }
@@ -9017,15 +8574,15 @@ var EmbeddedServer = class {
     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) {
@@ -9782,7 +9339,7 @@ var TestSession = class {
       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;
@@ -9881,26 +9438,19 @@ export {
   AuthenticationError,
   ProvisionError,
   RateLimitError,
-  OpenAIRealtimeAdapter,
-  mulawToPcm16,
-  pcm16ToMulaw,
-  PcmCarry,
-  StatefulResampler,
-  createResampler16kTo8k,
-  createResampler8kTo16k,
-  createResampler24kTo16k,
-  createResampler24kTo8k,
-  resample8kTo16k,
-  resample16kTo8k,
-  resample24kTo16k,
-  OpenAIRealtime2Adapter,
   ElevenLabsConvAIAdapter,
+  PlivoAdapter,
+  Carrier,
+  PRICING_VERSION,
+  PRICING_LAST_UPDATED,
+  PricingUnit,
   DEFAULT_PRICING,
   mergePricing,
   calculateSttCost,
   calculateTtsCost,
   calculateRealtimeCost,
   calculateTelephonyCost,
+  VERSION,
   MetricsStore,
   makeAuthMiddleware,
   callsToCsv,
@@ -9910,6 +9460,7 @@ export {
   RemoteMessageHandler,
   isRemoteUrl,
   isWebSocketUrl,
+  DeepgramModel,
   DeepgramSTT,
   CallMetricsAccumulator,
   SPAN_CALL,