getpatter 0.6.1 → 0.6.2

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

@@ -1,3 +1,11 @@
+import {
+  OpenAIRealtime2Adapter,
+  OpenAIRealtimeAdapter,
+  createResampler16kTo8k,
+  createResampler8kTo16k,
+  mulawToPcm16,
+  pcm16ToMulaw
+} from "./chunk-CL2U3YET.mjs";
 import {
   getLogger
 } from "./chunk-MVOQFAEO.mjs";
@@ -21,1259 +29,9 @@ 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 {
@@ -1614,6 +372,8 @@ async function createTTS(agent) {
 
 // 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",
@@ -2063,8 +823,28 @@ function calculateTelephonyCost(provider2, durationSeconds, pricing) {
 // 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 +1127,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 +1168,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 +1208,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 +1245,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 +1263,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 +1283,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 +1299,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 +1378,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) {
@@ -2731,7 +1513,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 +1530,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 {
     }
   }
@@ -3047,8 +1829,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 +1884,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 +1897,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 +1928,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 +2109,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 +2122,7 @@ var DeepgramSTT = class _DeepgramSTT {
         }, 5e3);
         sock.once("open", () => {
           clearTimeout(timer);
-          resolve(sock);
+          resolve2(sock);
         });
         sock.once("error", (err) => {
           clearTimeout(timer);
@@ -3367,11 +2149,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 +2165,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 +2186,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 +2305,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 +2354,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 +2375,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 +2389,7 @@ var DeepgramSTT = class _DeepgramSTT {
       } catch {
       }
     };
-    if (ws.readyState !== WebSocket4.OPEN) {
+    if (ws.readyState !== WebSocket2.OPEN) {
       finishClose();
       return;
     }
@@ -3676,6 +2458,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 +2570,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 +2727,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 +2751,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 +2782,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;
@@ -5252,7 +4071,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 +4213,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 +4263,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 +4333,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 +4357,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. */
@@ -6015,7 +4807,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(
@@ -6151,9 +4943,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 +4970,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 +5023,39 @@ 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";
+    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 +5066,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 +5086,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 +5103,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 +5136,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 +5151,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.`
@@ -7012,16 +5844,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 +6006,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 +6172,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();
@@ -7529,31 +6419,31 @@ 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 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,9 +6454,9 @@ function retentionDays() {
   return Math.max(0, parsed);
 }
 function redactMode() {
-  const raw = (process.env.PATTER_LOG_REDACT_PHONE || "mask").trim().toLowerCase();
+  const raw = (process.env.PATTER_LOG_REDACT_PHONE || "full").trim().toLowerCase();
   if (raw === "full" || raw === "mask" || raw === "hash_only") return raw;
-  return "mask";
+  return "full";
 }
 function redactPhone(raw) {
   if (!raw) return "";
@@ -7582,9 +6472,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}.${crypto3.randomBytes(4).toString("hex")}.json`);
   try {
     const handle = await fsp.open(tmp, "w");
     try {
@@ -7603,7 +6493,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 +6503,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 +6527,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 +6545,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,7 +6555,7 @@ 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))}`);
     }
@@ -7683,7 +6574,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 +6593,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 +6605,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 +6640,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 +6663,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 +6679,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 {
   }
 }
@@ -8097,7 +6988,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) {
@@ -8700,7 +7591,7 @@ var EmbeddedServer = class {
         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 +7613,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 +7656,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 +7727,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()
@@ -8996,8 +7889,8 @@ 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";
     for (const [ws, callId] of this.activeCallIds) {
@@ -9017,15 +7910,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 +8675,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 +8774,17 @@ export {
   AuthenticationError,
   ProvisionError,
   RateLimitError,
-  OpenAIRealtimeAdapter,
-  mulawToPcm16,
-  pcm16ToMulaw,
-  PcmCarry,
-  StatefulResampler,
-  createResampler16kTo8k,
-  createResampler8kTo16k,
-  createResampler24kTo16k,
-  createResampler24kTo8k,
-  resample8kTo16k,
-  resample16kTo8k,
-  resample24kTo16k,
-  OpenAIRealtime2Adapter,
   ElevenLabsConvAIAdapter,
+  PRICING_VERSION,
+  PRICING_LAST_UPDATED,
+  PricingUnit,
   DEFAULT_PRICING,
   mergePricing,
   calculateSttCost,
   calculateTtsCost,
   calculateRealtimeCost,
   calculateTelephonyCost,
+  VERSION,
   MetricsStore,
   makeAuthMiddleware,
   callsToCsv,
@@ -9910,6 +8794,7 @@ export {
   RemoteMessageHandler,
   isRemoteUrl,
   isWebSocketUrl,
+  DeepgramModel,
   DeepgramSTT,
   CallMetricsAccumulator,
   SPAN_CALL,