getpatter 0.4.1 → 0.4.3

package/dist/chunk-35EVXMGB.mjs

@@ -0,0 +1,4472 @@
+import {
+  getLogger
+} from "./chunk-FMNRCP5X.mjs";
+
+// src/test-mode.ts
+import { createInterface } from "readline";
+
+// src/server.ts
+import crypto3 from "crypto";
+import express from "express";
+import { createServer } from "http";
+import { WebSocketServer } from "ws";
+
+// src/providers/openai-realtime.ts
+import WebSocket from "ws";
+var OpenAIRealtimeAdapter = class {
+  constructor(apiKey, model = "gpt-4o-mini-realtime-preview", voice = "alloy", instructions = "", tools) {
+    this.apiKey = apiKey;
+    this.model = model;
+    this.voice = voice;
+    this.instructions = instructions;
+    this.tools = tools;
+  }
+  ws = null;
+  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;
+          const config = {
+            input_audio_format: "g711_ulaw",
+            output_audio_format: "g711_ulaw",
+            voice: this.voice,
+            instructions: this.instructions || "You are a helpful voice assistant. Be concise.",
+            turn_detection: { type: "server_vad", threshold: 0.5, prefix_padding_ms: 300, silence_duration_ms: 500 },
+            input_audio_transcription: { model: "whisper-1" }
+          };
+          if (this.tools?.length) {
+            config.tools = this.tools.map((t) => ({
+              type: "function",
+              name: t.name,
+              description: t.description,
+              parameters: t.parameters
+            }));
+          }
+          ws.send(JSON.stringify({ type: "session.update", session: config }));
+        } 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);
+    });
+  }
+  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") }));
+  }
+  onEvent(callback) {
+    if (!this.ws) return;
+    const safeInvoke = (type, data) => {
+      void Promise.resolve(callback(type, data)).catch(
+        (err) => getLogger().error("onEvent callback error:", err)
+      );
+    };
+    this.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") {
+        safeInvoke("audio", Buffer.from(data.delta ?? "", "base64"));
+      } else if (t === "response.audio_transcript.delta") {
+        safeInvoke("transcript_output", data.delta);
+      } else if (t === "input_audio_buffer.speech_started") {
+        safeInvoke("speech_started", null);
+      } else if (t === "conversation.item.input_audio_transcription.completed") {
+        safeInvoke("transcript_input", data.transcript);
+      } else if (t === "response.function_call_arguments.done") {
+        safeInvoke("function_call", { call_id: data.call_id, name: data.name, arguments: data.arguments });
+      } else if (t === "response.done") {
+        safeInvoke("response_done", data.response ?? null);
+      } else if (t === "error") {
+        safeInvoke("error", data.error);
+      }
+    });
+  }
+  cancelResponse() {
+    this.ws?.send(JSON.stringify({ type: "response.cancel" }));
+  }
+  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" }));
+  }
+  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" }));
+  }
+  close() {
+    this.ws?.close();
+    this.ws = null;
+  }
+};
+
+// src/providers/elevenlabs-convai.ts
+import WebSocket2 from "ws";
+var ELEVENLABS_CONVAI_URL = "wss://api.elevenlabs.io/v1/convai/conversation";
+var ElevenLabsConvAIAdapter = class {
+  constructor(apiKey, agentId = "", voiceId = "21m00Tcm4TlvDq8ikWAM", _modelId = "eleven_turbo_v2_5", _language = "en", firstMessage = "") {
+    this.apiKey = apiKey;
+    this.agentId = agentId;
+    this.voiceId = voiceId;
+    this.firstMessage = firstMessage;
+  }
+  ws = null;
+  eventCallback = null;
+  async connect() {
+    const url = this.agentId ? `${ELEVENLABS_CONVAI_URL}?agent_id=${encodeURIComponent(this.agentId)}` : ELEVENLABS_CONVAI_URL;
+    this.ws = new WebSocket2(url, {
+      headers: { "xi-api-key": this.apiKey }
+    });
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(
+        () => reject(new Error("ElevenLabs ConvAI connect timeout")),
+        15e3
+      );
+      this.ws.once("open", () => {
+        clearTimeout(timeout);
+        const config = {
+          type: "conversation_initiation_client_data",
+          conversation_config_override: {
+            tts: { voice_id: this.voiceId }
+          }
+        };
+        if (this.firstMessage) {
+          config["conversation_config_override"]["agent"] = {
+            first_message: this.firstMessage
+          };
+        }
+        this.ws.send(JSON.stringify(config));
+        resolve();
+      });
+      this.ws.once("error", (err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+    this.ws.on("message", (raw) => {
+      const cb = this.eventCallback;
+      if (!cb) return;
+      const safeInvoke = (type, data) => {
+        void Promise.resolve(cb(type, data)).catch(
+          (err) => getLogger().error("onEvent callback error:", err)
+        );
+      };
+      let parsed;
+      try {
+        parsed = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      const msgType = parsed["type"];
+      if (msgType === "audio") {
+        const audioB64 = parsed["audio"];
+        if (audioB64) {
+          safeInvoke("audio", Buffer.from(audioB64, "base64"));
+        }
+      } else if (msgType === "user_transcript") {
+        safeInvoke("transcript_input", parsed["text"] ?? "");
+      } else if (msgType === "agent_response") {
+        safeInvoke("transcript_output", parsed["text"] ?? "");
+        safeInvoke("response_done", null);
+      } else if (msgType === "interruption") {
+        safeInvoke("interruption", null);
+      } else if (msgType === "error") {
+        safeInvoke("error", parsed);
+      }
+    });
+  }
+  sendAudio(audioBytes) {
+    if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) return;
+    this.ws.send(
+      JSON.stringify({
+        type: "audio",
+        audio: audioBytes.toString("base64")
+      })
+    );
+  }
+  onEvent(callback) {
+    this.eventCallback = callback;
+  }
+  close() {
+    this.ws?.close();
+    this.ws = null;
+    this.eventCallback = null;
+  }
+};
+
+// src/providers/deepgram-stt.ts
+import WebSocket3 from "ws";
+var DEEPGRAM_WS_URL = "wss://api.deepgram.com/v1/listen";
+var DeepgramSTT = class _DeepgramSTT {
+  constructor(apiKey, language = "en", model = "nova-3", encoding = "linear16", sampleRate = 16e3) {
+    this.apiKey = apiKey;
+    this.language = language;
+    this.model = model;
+    this.encoding = encoding;
+    this.sampleRate = sampleRate;
+  }
+  ws = null;
+  callbacks = [];
+  /** Request ID from Deepgram — used to query actual cost post-call. */
+  requestId = "";
+  /** Factory for Twilio calls — mulaw 8 kHz. */
+  static forTwilio(apiKey, language = "en", model = "nova-3") {
+    return new _DeepgramSTT(apiKey, language, model, "mulaw", 8e3);
+  }
+  async connect() {
+    const params = new URLSearchParams({
+      model: this.model,
+      language: this.language,
+      encoding: this.encoding,
+      sample_rate: String(this.sampleRate),
+      channels: "1",
+      interim_results: "true",
+      endpointing: "300",
+      smart_format: "true",
+      vad_events: "true",
+      no_delay: "true"
+    });
+    const url = `${DEEPGRAM_WS_URL}?${params.toString()}`;
+    this.ws = new WebSocket3(url, {
+      headers: { Authorization: `Token ${this.apiKey}` }
+    });
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("Deepgram connect timeout")), 1e4);
+      this.ws.once("open", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      this.ws.once("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+    this.ws.on("message", (raw) => {
+      let data;
+      try {
+        data = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      if (data.type === "Metadata" && data.request_id) {
+        this.requestId = data.request_id;
+        return;
+      }
+      if (data.type !== "Results") return;
+      const alternatives = data.channel?.alternatives ?? [];
+      if (!alternatives.length) return;
+      const best = alternatives[0];
+      const text = (best.transcript ?? "").trim();
+      if (!text) return;
+      const transcript = {
+        text,
+        isFinal: Boolean(data.is_final) && Boolean(data.speech_final),
+        confidence: best.confidence ?? 0
+      };
+      for (const cb of this.callbacks) {
+        cb(transcript);
+      }
+    });
+  }
+  sendAudio(audio) {
+    if (!this.ws || this.ws.readyState !== WebSocket3.OPEN) return;
+    this.ws.send(audio);
+  }
+  onTranscript(callback) {
+    if (this.callbacks.length >= 10) {
+      getLogger().warn("DeepgramSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback.");
+      this.callbacks[this.callbacks.length - 1] = callback;
+      return;
+    }
+    this.callbacks.push(callback);
+  }
+  close() {
+    if (this.ws) {
+      try {
+        this.ws.send(JSON.stringify({ type: "CloseStream" }));
+      } catch {
+      }
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+};
+
+// src/providers/whisper-stt.ts
+var OPENAI_TRANSCRIPTION_URL = "https://api.openai.com/v1/audio/transcriptions";
+var DEFAULT_BUFFER_SIZE = 16e3 * 2;
+function wrapPcmInWav(pcm, sampleRate = 16e3, channels = 1, bitsPerSample = 16) {
+  const dataSize = pcm.length;
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + dataSize, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(channels, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(sampleRate * channels * (bitsPerSample / 8), 28);
+  header.writeUInt16LE(channels * (bitsPerSample / 8), 32);
+  header.writeUInt16LE(bitsPerSample, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(dataSize, 40);
+  return Buffer.concat([header, pcm]);
+}
+var WhisperSTT = class _WhisperSTT {
+  apiKey;
+  model;
+  language;
+  bufferSize;
+  buffer = Buffer.alloc(0);
+  callbacks = [];
+  running = false;
+  pendingTranscriptions = [];
+  constructor(apiKey, model = "whisper-1", language, bufferSize = DEFAULT_BUFFER_SIZE) {
+    this.apiKey = apiKey;
+    this.model = model;
+    this.language = language;
+    this.bufferSize = bufferSize;
+  }
+  /** Factory for Twilio calls — mulaw 8 kHz is transcoded upstream, so we still receive PCM 16-bit. */
+  static forTwilio(apiKey, language = "en", model = "whisper-1") {
+    return new _WhisperSTT(apiKey, model, language);
+  }
+  async connect() {
+    this.running = true;
+    this.buffer = Buffer.alloc(0);
+  }
+  sendAudio(audio) {
+    if (!this.running) return;
+    this.buffer = Buffer.concat([this.buffer, audio]);
+    if (this.buffer.length >= this.bufferSize) {
+      const pcm = this.buffer;
+      this.buffer = Buffer.alloc(0);
+      this.trackTranscription(this.transcribeBuffer(pcm));
+    }
+  }
+  trackTranscription(promise) {
+    const wrapped = promise.finally(() => {
+      const idx = this.pendingTranscriptions.indexOf(wrapped);
+      if (idx !== -1) this.pendingTranscriptions.splice(idx, 1);
+    });
+    this.pendingTranscriptions.push(wrapped);
+  }
+  onTranscript(callback) {
+    if (this.callbacks.length >= 10) {
+      getLogger().warn("WhisperSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback.");
+      this.callbacks[this.callbacks.length - 1] = callback;
+      return;
+    }
+    this.callbacks.push(callback);
+  }
+  async close() {
+    this.running = false;
+    if (this.buffer.length >= this.bufferSize / 4) {
+      const pcm = this.buffer;
+      this.buffer = Buffer.alloc(0);
+      this.trackTranscription(this.transcribeBuffer(pcm));
+    } else {
+      this.buffer = Buffer.alloc(0);
+    }
+    await Promise.allSettled(this.pendingTranscriptions);
+    this.callbacks = [];
+  }
+  // ------------------------------------------------------------------
+  // Private
+  // ------------------------------------------------------------------
+  async transcribeBuffer(pcm) {
+    const wav = wrapPcmInWav(pcm);
+    const formData = new FormData();
+    formData.append("file", new Blob([wav.buffer.slice(wav.byteOffset, wav.byteOffset + wav.byteLength)], { type: "audio/wav" }), "audio.wav");
+    formData.append("model", this.model);
+    if (this.language) {
+      formData.append("language", this.language);
+    }
+    try {
+      const resp = await fetch(OPENAI_TRANSCRIPTION_URL, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.apiKey}` },
+        body: formData,
+        signal: AbortSignal.timeout(15e3)
+      });
+      if (!resp.ok) {
+        const body = await resp.text();
+        getLogger().error(`WhisperSTT transcription error: ${resp.status} ${body}`);
+        return;
+      }
+      const json = await resp.json();
+      const text = (json.text ?? "").trim();
+      if (!text) return;
+      const transcript = {
+        text,
+        isFinal: true,
+        confidence: 1
+      };
+      for (const cb of this.callbacks) {
+        cb(transcript);
+      }
+    } catch (err) {
+      getLogger().error(`WhisperSTT transcription error: ${String(err)}`);
+    }
+  }
+};
+
+// src/pricing.ts
+var DEFAULT_PRICING = {
+  // STT — per minute of audio processed
+  deepgram: { unit: "minute", price: 43e-4 },
+  whisper: { unit: "minute", price: 6e-3 },
+  // TTS — per 1,000 characters synthesized
+  elevenlabs: { unit: "1k_chars", price: 0.18 },
+  openai_tts: { unit: "1k_chars", price: 0.015 },
+  // OpenAI Realtime — per token
+  openai_realtime: {
+    unit: "token",
+    audio_input_per_token: 1e-4,
+    audio_output_per_token: 4e-4,
+    text_input_per_token: 5e-6,
+    text_output_per_token: 2e-5
+  },
+  // Telephony — per minute of call duration
+  twilio: { unit: "minute", price: 0.013 },
+  telnyx: { unit: "minute", price: 7e-3 }
+};
+function mergePricing(overrides) {
+  const merged = {};
+  for (const [k, v] of Object.entries(DEFAULT_PRICING)) {
+    merged[k] = { ...v };
+  }
+  if (!overrides) return merged;
+  for (const [provider, values] of Object.entries(overrides)) {
+    if (merged[provider]) {
+      merged[provider] = { ...merged[provider], ...values };
+    } else {
+      merged[provider] = { unit: "minute", ...values };
+    }
+  }
+  return merged;
+}
+function calculateSttCost(provider, audioSeconds, pricing) {
+  const config = pricing[provider];
+  if (!config || config.unit !== "minute") return 0;
+  return audioSeconds / 60 * (config.price ?? 0);
+}
+function calculateTtsCost(provider, characterCount, pricing) {
+  const config = pricing[provider];
+  if (!config || config.unit !== "1k_chars") return 0;
+  return characterCount / 1e3 * (config.price ?? 0);
+}
+function calculateRealtimeCost(usage, pricing) {
+  const config = pricing.openai_realtime;
+  if (!config || config.unit !== "token") return 0;
+  const input = usage.input_token_details ?? {};
+  const output = usage.output_token_details ?? {};
+  let cost = 0;
+  cost += (input.audio_tokens ?? 0) * (config.audio_input_per_token ?? 0);
+  cost += (input.text_tokens ?? 0) * (config.text_input_per_token ?? 0);
+  cost += (output.audio_tokens ?? 0) * (config.audio_output_per_token ?? 0);
+  cost += (output.text_tokens ?? 0) * (config.text_output_per_token ?? 0);
+  return cost;
+}
+function calculateTelephonyCost(provider, durationSeconds, pricing) {
+  const config = pricing[provider];
+  if (!config || config.unit !== "minute") return 0;
+  return durationSeconds / 60 * (config.price ?? 0);
+}
+
+// src/dashboard/store.ts
+import { EventEmitter } from "events";
+var MetricsStore = class extends EventEmitter {
+  maxCalls;
+  calls = [];
+  activeCalls = /* @__PURE__ */ new Map();
+  constructor(maxCalls = 500) {
+    super();
+    this.maxCalls = maxCalls;
+  }
+  publish(eventType, data) {
+    this.emit("sse", { type: eventType, data });
+  }
+  recordCallStart(data) {
+    const callId = data.call_id || "";
+    if (!callId) return;
+    const record = {
+      call_id: callId,
+      caller: data.caller || "",
+      callee: data.callee || "",
+      direction: data.direction || "inbound",
+      started_at: Date.now() / 1e3,
+      turns: []
+    };
+    this.activeCalls.set(callId, record);
+    this.publish("call_start", {
+      call_id: callId,
+      caller: record.caller,
+      callee: record.callee,
+      direction: record.direction
+    });
+  }
+  recordTurn(data) {
+    const callId = data.call_id || "";
+    const turn = data.turn;
+    if (!callId || turn == null) return;
+    const active = this.activeCalls.get(callId);
+    if (active) {
+      if (!active.turns) active.turns = [];
+      active.turns.push(turn);
+    }
+    this.publish("turn_complete", { call_id: callId, turn });
+  }
+  recordCallEnd(data, metrics) {
+    const callId = data.call_id || "";
+    if (!callId) return;
+    const active = this.activeCalls.get(callId);
+    this.activeCalls.delete(callId);
+    const entry = {
+      call_id: callId,
+      caller: data.caller || active?.caller || "",
+      callee: data.callee || active?.callee || "",
+      direction: active?.direction || data.direction || "inbound",
+      started_at: active?.started_at || 0,
+      ended_at: Date.now() / 1e3,
+      transcript: data.transcript || [],
+      metrics: metrics ?? null
+    };
+    this.calls.push(entry);
+    if (this.calls.length > this.maxCalls) {
+      this.calls = this.calls.slice(-this.maxCalls);
+    }
+    this.publish("call_end", {
+      call_id: callId,
+      metrics: entry.metrics ?? null
+    });
+  }
+  getCalls(limit = 50, offset = 0) {
+    const ordered = [...this.calls].reverse();
+    return ordered.slice(offset, offset + limit);
+  }
+  getCall(callId) {
+    for (let i = this.calls.length - 1; i >= 0; i--) {
+      if (this.calls[i].call_id === callId) return this.calls[i];
+    }
+    return null;
+  }
+  getActiveCalls() {
+    return Array.from(this.activeCalls.values());
+  }
+  getAggregates() {
+    const totalCalls = this.calls.length;
+    if (totalCalls === 0) {
+      return {
+        total_calls: 0,
+        total_cost: 0,
+        avg_duration: 0,
+        avg_latency_ms: 0,
+        cost_breakdown: { stt: 0, tts: 0, llm: 0, telephony: 0 },
+        active_calls: this.activeCalls.size
+      };
+    }
+    let totalCost = 0;
+    let totalDuration = 0;
+    let totalLatency = 0;
+    let latencyCount = 0;
+    let costStt = 0;
+    let costTts = 0;
+    let costLlm = 0;
+    let costTel = 0;
+    for (const call of this.calls) {
+      const m = call.metrics;
+      if (!m) continue;
+      const cost = m.cost || {};
+      totalCost += cost.total || 0;
+      costStt += cost.stt || 0;
+      costTts += cost.tts || 0;
+      costLlm += cost.llm || 0;
+      costTel += cost.telephony || 0;
+      totalDuration += m.duration_seconds || 0;
+      const avgLat = m.latency_avg || {};
+      const tMs = avgLat.total_ms || 0;
+      if (tMs > 0) {
+        totalLatency += tMs;
+        latencyCount++;
+      }
+    }
+    return {
+      total_calls: totalCalls,
+      total_cost: Math.round(totalCost * 1e6) / 1e6,
+      avg_duration: Math.round(totalDuration / totalCalls * 100) / 100,
+      avg_latency_ms: latencyCount > 0 ? Math.round(totalLatency / latencyCount * 10) / 10 : 0,
+      cost_breakdown: {
+        stt: Math.round(costStt * 1e6) / 1e6,
+        tts: Math.round(costTts * 1e6) / 1e6,
+        llm: Math.round(costLlm * 1e6) / 1e6,
+        telephony: Math.round(costTel * 1e6) / 1e6
+      },
+      active_calls: this.activeCalls.size
+    };
+  }
+  getCallsInRange(fromTs = 0, toTs = 0) {
+    return this.calls.filter((call) => {
+      const started = call.started_at || 0;
+      if (fromTs && started < fromTs) return false;
+      if (toTs && started > toTs) return false;
+      return true;
+    });
+  }
+  get callCount() {
+    return this.calls.length;
+  }
+};
+
+// src/dashboard/auth.ts
+import crypto from "crypto";
+function timingSafeCompare(a, b) {
+  const aBuf = Buffer.from(a);
+  const bBuf = Buffer.from(b);
+  if (aBuf.length !== bBuf.length) {
+    crypto.timingSafeEqual(aBuf, aBuf);
+    return false;
+  }
+  return crypto.timingSafeEqual(aBuf, bBuf);
+}
+function makeAuthMiddleware(token = "") {
+  return (req, res, next) => {
+    if (!token) {
+      next();
+      return;
+    }
+    const auth = req.headers.authorization || "";
+    const expected = `Bearer ${token}`;
+    if (timingSafeCompare(auth, expected)) {
+      next();
+      return;
+    }
+    const queryToken = String(req.query.token ?? "");
+    if (timingSafeCompare(queryToken, token)) {
+      next();
+      return;
+    }
+    res.status(401).json({ error: "Unauthorized" });
+  };
+}
+
+// src/dashboard/export.ts
+function callsToCsv(calls) {
+  const header = [
+    "call_id",
+    "caller",
+    "callee",
+    "direction",
+    "started_at",
+    "ended_at",
+    "duration_s",
+    "cost_total",
+    "cost_stt",
+    "cost_tts",
+    "cost_llm",
+    "cost_telephony",
+    "avg_latency_ms",
+    "turns_count",
+    "provider_mode"
+  ];
+  const rows = [header.join(",")];
+  for (const call of calls) {
+    const m = call.metrics || {};
+    const cost = m.cost || {};
+    const latencyAvg = m.latency_avg || {};
+    const turns = m.turns;
+    const turnsCount = Array.isArray(turns) ? turns.length : "";
+    const row = [
+      csvEscape(call.call_id || ""),
+      csvEscape(call.caller || ""),
+      csvEscape(call.callee || ""),
+      csvEscape(call.direction || ""),
+      call.started_at ?? "",
+      call.ended_at ?? "",
+      m.duration_seconds ?? "",
+      cost.total ?? "",
+      cost.stt ?? "",
+      cost.tts ?? "",
+      cost.llm ?? "",
+      cost.telephony ?? "",
+      latencyAvg.total_ms ?? "",
+      turnsCount,
+      m.provider_mode ?? ""
+    ];
+    rows.push(row.map(String).join(","));
+  }
+  return rows.join("\n") + "\n";
+}
+function callsToJson(calls) {
+  return JSON.stringify(calls);
+}
+function csvEscape(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+
+// src/dashboard/ui.ts
+var DASHBOARD_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Patter | Dashboard</title>
+<link rel="icon" type="image/svg+xml" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 1188 1773' fill='none'%3E%3Cstyle%3Epath%7Bstroke:%2309090b%7D@media(prefers-color-scheme:dark)%7Bpath%7Bstroke:%23e4e4e7%7D%7D%3C/style%3E%3Cpath d='M25 561L245 694M25 561V818M245 694V951M25 961V1218M25 1357V1614M245 1489V1747M245 1093V1351M942 823V1080M1161 955V1213M1162 555V812M942 422V679M669 585V843L787 913M942 25V282M1162 158V415M25 818L245 951M244 1094L464 962M25 961L143 890M244 1352L464 1219M942 823L1162 956M942 679L1162 812M721 811L942 679M669 842L724 809M669 586L724 553M1041 883L1162 812M245 1747L1161 1213M244 1490L942 1080M25 1357L142 1289M518 1071L942 823M721 555L942 422M942 422L1162 556M942 282L1162 415M942 25L1162 158M942 1080L1161 1213M25 1218L245 1351M25 961L245 1094M464 962L519 929M464 1219L519 1186V928L403 859M25 1357L245 1490M25 1614L245 1747M25 561L942 25M244 694L941 282M1043 484L1162 415M245 951L668 704' stroke-width='50' stroke-linecap='round'/%3E%3C/svg%3E">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Instrument+Sans:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet">
+<style>
+  :root {
+    --bg: #fdfcfc;
+    --fg: #09090b;
+    --card: #ffffff;
+    --primary: #18181b;
+    --primary-fg: #fafafa;
+    --secondary: #f4f4f5;
+    --muted: #71717b;
+    --border: #e4e4e7;
+    --border-d: #d4d4d8;
+    --green: #22c55e;
+    --red: #ef4444;
+    --blue: #3b82f6;
+    --purple: #a78bfa;
+    --orange: #fb923c;
+    --yellow: #eab308;
+    --radius: 12px;
+    --font: 'Instrument Sans', ui-sans-serif, system-ui, sans-serif;
+    --mono: 'JetBrains Mono', ui-monospace, SFMono-Regular, Menlo, monospace;
+    --header-bg: #fff;
+    --assistant-bubble: #f0eeff;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #151518;
+      --fg: #e4e4e7;
+      --card: #1c1c21;
+      --primary: #e4e4e7;
+      --primary-fg: #18181b;
+      --secondary: #232329;
+      --muted: #8b8b95;
+      --border: #2c2c33;
+      --border-d: #3a3a44;
+      --green: #34d399;
+      --red: #f87171;
+      --blue: #60a5fa;
+      --purple: #c4b5fd;
+      --orange: #fdba74;
+      --yellow: #fbbf24;
+      --header-bg: #1a1a1f;
+      --assistant-bubble: #252230;
+    }
+  }
+  * { margin:0; padding:0; box-sizing:border-box; }
+  html { -webkit-font-smoothing: antialiased; }
+  body {
+    font-family: var(--font);
+    font-size: 15px;
+    line-height: 1.6;
+    color: var(--fg);
+    background: var(--bg);
+    min-height: 100vh;
+  }
+
+  /* Header */
+  header {
+    position: sticky; top: 0; z-index: 100;
+    background: var(--header-bg);
+    border-bottom: 1px solid var(--border);
+    padding: 0 24px;
+    height: 56px;
+    display: flex; align-items: center; gap: 14px;
+  }
+  .logo {
+    display: flex; align-items: center; gap: 10px;
+    font-weight: 700; font-size: 18px; letter-spacing: -0.02em;
+    text-decoration: none; color: var(--fg);
+  }
+  .logo svg { width: 22px; height: 22px; }
+  .header-sep {
+    width: 1px; height: 20px; background: var(--border-d); margin: 0 2px;
+  }
+  .header-title {
+    font-size: 14px; font-weight: 500; color: var(--muted);
+  }
+  .badge-beta {
+    font-size: 10px; font-weight: 600; letter-spacing: 0.5px;
+    color: #e67e22; background: rgba(230,126,34,0.1);
+    border: 1px solid rgba(230,126,34,0.25);
+    padding: 2px 8px; border-radius: 100px; text-transform: uppercase;
+  }
+  .status {
+    margin-left: auto; font-size: 13px; color: var(--muted);
+    display: flex; align-items: center; gap: 6px;
+  }
+  .dot {
+    width: 7px; height: 7px; border-radius: 50%;
+    background: var(--green); display: inline-block;
+  }
+
+  /* Layout */
+  .container { max-width: 1200px; margin: 0 auto; padding: 24px; }
+
+  /* Stat cards */
+  .cards {
+    display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 14px; margin-bottom: 28px;
+  }
+  .card {
+    background: var(--card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 18px 20px;
+  }
+  .card .label {
+    font-size: 12px; color: var(--muted);
+    text-transform: uppercase; letter-spacing: 0.5px; font-weight: 500;
+  }
+  .card .value {
+    font-size: 28px; font-weight: 700; margin-top: 4px;
+    font-family: var(--mono); letter-spacing: -0.02em;
+  }
+  .card .sub { font-size: 12px; color: var(--muted); margin-top: 2px; }
+
+  /* Tabs */
+  .nav-tabs {
+    display: flex; gap: 0; margin-bottom: 16px;
+    border-bottom: 1px solid var(--border);
+  }
+  .nav-tab {
+    padding: 10px 20px; font-size: 13px; font-weight: 500;
+    color: var(--muted); cursor: pointer;
+    border: none; background: none;
+    border-bottom: 2px solid transparent;
+    margin-bottom: -1px; font-family: var(--font);
+    transition: color .15s;
+  }
+  .nav-tab:hover { color: var(--fg); }
+  .nav-tab.active { color: var(--fg); border-bottom-color: var(--primary); }
+
+  .tab-content { display: none; }
+  .tab-content.active { display: block; }
+
+  /* Tables */
+  table {
+    width: 100%; border-collapse: collapse;
+    background: var(--card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    overflow: hidden;
+  }
+  th {
+    text-align: left; font-size: 11px; text-transform: uppercase;
+    color: var(--muted); padding: 12px 16px;
+    border-bottom: 1px solid var(--border);
+    letter-spacing: 0.5px; font-weight: 600;
+    background: var(--secondary);
+  }
+  td {
+    padding: 12px 16px; border-bottom: 1px solid var(--border);
+    font-size: 13px;
+  }
+  tr:last-child td { border-bottom: none; }
+  tr.clickable { cursor: pointer; transition: background .1s; }
+  tr.clickable:hover { background: var(--secondary); }
+
+  code {
+    font-family: var(--mono); font-size: 12px;
+    background: var(--secondary); padding: 2px 6px;
+    border-radius: 4px;
+  }
+
+  /* Badges */
+  .badge {
+    display: inline-block; padding: 3px 10px; border-radius: 100px;
+    font-size: 11px; font-weight: 600;
+  }
+  .badge-active { background: rgba(34,197,94,0.1); color: #16a34a; }
+  .badge-ended { background: var(--secondary); color: var(--muted); }
+  .badge-pipeline { background: rgba(167,139,250,0.1); color: #7c3aed; }
+  .badge-realtime { background: rgba(59,130,246,0.1); color: #2563eb; }
+
+  .cost { color: #16a34a; font-family: var(--mono); font-size: 13px; }
+  .latency { color: #ca8a04; font-family: var(--mono); font-size: 13px; }
+  @media (prefers-color-scheme: dark) {
+    .cost { color: var(--green); }
+    .latency { color: var(--yellow); }
+    code { background: var(--secondary); color: var(--fg); }
+  }
+  .empty {
+    text-align: center; padding: 48px; color: var(--muted);
+    font-size: 14px;
+  }
+
+  /* Modal */
+  .modal-overlay {
+    display: none; position: fixed; inset: 0;
+    background: rgba(0,0,0,0.4); backdrop-filter: blur(6px);
+    z-index: 200;
+    justify-content: center; align-items: flex-start;
+    padding: 48px 20px; overflow-y: auto;
+  }
+  .modal-overlay.open { display: flex; }
+  .modal {
+    background: var(--card);
+    border: 1px solid var(--border);
+    border-radius: 16px;
+    max-width: 820px; width: 100%;
+    padding: 0;
+    box-shadow: 0 24px 64px rgba(0,0,0,0.12), 0 0 0 1px rgba(0,0,0,0.03);
+    overflow: hidden;
+  }
+  .modal-header {
+    display: flex; justify-content: space-between; align-items: center;
+    padding: 20px 28px;
+    border-bottom: 1px solid var(--border);
+    background: var(--bg);
+  }
+  .modal-header h2 { font-size: 15px; font-weight: 600; display: flex; align-items: center; gap: 10px; }
+  .modal-close {
+    background: none; border: 1px solid var(--border);
+    color: var(--muted); width: 30px; height: 30px;
+    border-radius: 8px; font-size: 16px; cursor: pointer;
+    display: flex; align-items: center; justify-content: center;
+    transition: all .15s;
+  }
+  .modal-close:hover { background: var(--secondary); color: var(--fg); }
+  .modal-body { padding: 24px 28px; }
+
+  .detail-grid {
+    display: grid; grid-template-columns: 1fr 1fr;
+    gap: 14px; margin-bottom: 20px;
+  }
+  .detail-card {
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: var(--radius); padding: 16px 18px;
+  }
+  .detail-card h3 {
+    font-size: 11px; color: var(--muted);
+    text-transform: uppercase; letter-spacing: 0.5px;
+    margin-bottom: 10px; font-weight: 600;
+  }
+  .detail-row {
+    display: flex; justify-content: space-between; align-items: baseline;
+    font-size: 13px; padding: 5px 0;
+  }
+  .detail-row .k { color: var(--muted); font-weight: 500; }
+  .detail-row span:last-child { font-weight: 500; text-align: right; }
+  .detail-row .mono { font-family: var(--mono); font-size: 12px; }
+  .detail-sep {
+    border-top: 1px solid var(--border); padding-top: 8px; margin-top: 6px;
+  }
+
+  .transcript-box {
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 16px; max-height: 340px; overflow-y: auto;
+    background: var(--bg);
+  }
+  .transcript-box .msg {
+    padding: 8px 12px; border-radius: 10px; font-size: 13px;
+    max-width: 85%; margin-bottom: 6px; line-height: 1.5;
+  }
+  .transcript-box .msg.user {
+    background: var(--secondary); margin-left: auto;
+    border-bottom-right-radius: 4px;
+  }
+  .transcript-box .msg.assistant {
+    background: var(--assistant-bubble); margin-right: auto;
+    border-bottom-left-radius: 4px;
+  }
+  .transcript-box .role {
+    font-weight: 600; font-size: 11px; text-transform: uppercase;
+    letter-spacing: 0.3px; display: block; margin-bottom: 2px;
+  }
+  .transcript-box .msg.user .role { color: var(--blue); }
+  .transcript-box .msg.assistant .role { color: #7c3aed; }
+
+  /* Turn bars */
+  .turns-table { margin-top: 16px; }
+  .turns-table table { border: 1px solid var(--border); }
+  .bar-container { display: flex; height: 14px; border-radius: 4px; overflow: hidden; min-width: 120px; }
+  .bar-stt { background: var(--blue); }
+  .bar-llm { background: var(--purple); }
+  .bar-tts { background: var(--orange); }
+</style>
+</head>
+<body>
+<header>
+  <a href="/" class="logo">
+    <svg viewBox="0 0 1188 1773" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path d="M25 561L245 694M25 561V818M245 694V951M25 961V1218M25 1357V1614M245 1489V1747M245 1093V1351M942 823V1080M1161 955V1213M1162 555V812M942 422V679M669 585V843L787 913M942 25V282M1162 158V415M25 818L245 951M244 1094L464 962M25 961L143 890M244 1352L464 1219M942 823L1162 956M942 679L1162 812M721 811L942 679M669 842L724 809M669 586L724 553M1041 883L1162 812M245 1747L1161 1213M244 1490L942 1080M25 1357L142 1289M518 1071L942 823M721 555L942 422M942 422L1162 556M942 282L1162 415M942 25L1162 158M942 1080L1161 1213M25 1218L245 1351M25 961L245 1094M464 962L519 929M464 1219L519 1186V928L403 859M25 1357L245 1490M25 1614L245 1747M25 561L942 25M244 694L941 282M1043 484L1162 415M245 951L668 704" stroke="currentColor" stroke-width="50" stroke-linecap="round"/>
+    </svg>
+    Patter
+  </a>
+  <div class="header-sep"></div>
+  <span class="header-title">Dashboard</span>
+  <span class="badge-beta">Beta</span>
+  <div class="status"><span class="dot"></span> <span id="status-text">Listening</span></div>
+</header>
+
+<div class="container">
+  <div class="cards">
+    <div class="card">
+      <div class="label">Total Calls</div>
+      <div class="value" id="stat-total">0</div>
+      <div class="sub"><span id="stat-active">0</span> active</div>
+    </div>
+    <div class="card">
+      <div class="label">Total Cost</div>
+      <div class="value cost" id="stat-cost">$0.00</div>
+      <div class="sub" id="stat-cost-breakdown">-</div>
+    </div>
+    <div class="card">
+      <div class="label">Avg Duration</div>
+      <div class="value" id="stat-duration">0s</div>
+    </div>
+    <div class="card">
+      <div class="label">Avg Latency</div>
+      <div class="value latency" id="stat-latency">0ms</div>
+      <div class="sub">end-to-end response</div>
+    </div>
+  </div>
+
+  <div class="nav-tabs">
+    <button class="nav-tab active" data-tab="calls">Calls</button>
+    <button class="nav-tab" data-tab="active">Active</button>
+  </div>
+
+  <div class="tab-content active" id="tab-calls">
+    <div class="section">
+      <table id="calls-table">
+        <thead>
+          <tr>
+            <th>Call ID</th><th>Direction</th><th>From / To</th>
+            <th>Duration</th><th>Mode</th><th>Cost</th><th>Avg Latency</th><th>Turns</th>
+          </tr>
+        </thead>
+        <tbody id="calls-body">
+          <tr><td colspan="8" class="empty">No calls yet. Waiting for incoming calls...</td></tr>
+        </tbody>
+      </table>
+    </div>
+  </div>
+
+  <div class="tab-content" id="tab-active">
+    <div class="section">
+      <table>
+        <thead>
+          <tr><th>Call ID</th><th>Caller</th><th>Callee</th><th>Direction</th><th>Duration</th><th>Turns</th></tr>
+        </thead>
+        <tbody id="active-body">
+          <tr><td colspan="6" class="empty">No active calls</td></tr>
+        </tbody>
+      </table>
+    </div>
+  </div>
+</div>
+
+<div class="modal-overlay" id="modal">
+  <div class="modal">
+    <div class="modal-header">
+      <h2 id="modal-title">Call Detail</h2>
+      <button class="modal-close" onclick="closeModal()">&times;</button>
+    </div>
+    <div class="modal-body" id="modal-body"></div>
+  </div>
+</div>
+
+<script>
+var _$ = function(s) { return document.querySelector(s); };
+var _$$ = function(s) { return document.querySelectorAll(s); };
+
+_$$('.nav-tab').forEach(function(tab) {
+  tab.addEventListener('click', function() {
+    _$$('.nav-tab').forEach(function(t) { t.classList.remove('active'); });
+    _$$('.tab-content').forEach(function(t) { t.classList.remove('active'); });
+    tab.classList.add('active');
+    document.querySelector('#tab-'+tab.dataset.tab).classList.add('active');
+  });
+});
+
+function esc(s) {
+  if (!s) return '';
+  return String(s).replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;').replace(/'/g,'&#39;');
+}
+function fmtCost(v) { return v >= 0.01 ? '$'+v.toFixed(4) : v > 0 ? '$'+v.toFixed(6) : '$0.00'; }
+function fmtMs(v) { return v != null && v >= 0 ? Math.round(v)+'ms' : '-'; }
+function fmtDur(s) {
+  if (s == null || s < 0) return '-';
+  if (s < 60) return Math.round(s)+'s';
+  return Math.floor(s/60)+'m '+Math.round(s%60)+'s';
+}
+function shortId(id) { return id ? esc(id.length > 16 ? id.slice(0,8)+'...'+id.slice(-4) : id) : '-'; }
+
+function fetchJSON(url) {
+  return fetch(url).then(function(r) { return r.json(); });
+}
+
+function refreshAggregates() {
+  return fetchJSON('/api/dashboard/aggregates').then(function(d) {
+    _$('#stat-total').textContent = d.total_calls;
+    _$('#stat-active').textContent = d.active_calls;
+    _$('#stat-cost').textContent = fmtCost(d.total_cost);
+    var cb = d.cost_breakdown;
+    _$('#stat-cost-breakdown').textContent =
+      'STT '+fmtCost(cb.stt)+' | LLM '+fmtCost(cb.llm)+' | TTS '+fmtCost(cb.tts)+' | Tel '+fmtCost(cb.telephony);
+    _$('#stat-duration').textContent = fmtDur(d.avg_duration);
+    _$('#stat-latency').textContent = fmtMs(d.avg_latency_ms);
+  });
+}
+
+function refreshCalls() {
+  return fetchJSON('/api/dashboard/calls?limit=50').then(function(calls) {
+    var body = _$('#calls-body');
+    if (!calls.length) {
+      body.innerHTML = '<tr><td colspan="8" class="empty">No calls yet. Waiting for incoming calls...</td></tr>';
+      return;
+    }
+    body.innerHTML = calls.map(function(c) {
+      var m = c.metrics || {};
+      var cost = m.cost || {};
+      var lat = m.latency_avg || {};
+      var mode = m.provider_mode || '-';
+      var turns = m.turns ? m.turns.length : 0;
+      var modeClass = mode === 'pipeline' ? 'badge-pipeline' : 'badge-realtime';
+      return '<tr class="clickable" onclick="showCall(\\''+esc(c.call_id)+'\\')">'+
+        '<td><code>'+shortId(c.call_id)+'</code></td>'+
+        '<td>'+(esc(c.direction) || '-')+'</td>'+
+        '<td>'+(esc(c.caller) || '-')+' &rarr; '+(esc(c.callee) || '-')+'</td>'+
+        '<td>'+fmtDur(m.duration_seconds)+'</td>'+
+        '<td><span class="badge '+modeClass+'">'+esc(mode)+'</span></td>'+
+        '<td class="cost">'+fmtCost(cost.total || 0)+'</td>'+
+        '<td class="latency">'+fmtMs(lat.total_ms || 0)+'</td>'+
+        '<td>'+turns+'</td></tr>';
+    }).join('');
+  });
+}
+
+function refreshActive() {
+  return fetchJSON('/api/dashboard/active').then(function(active) {
+    var body = _$('#active-body');
+    if (!active.length) {
+      body.innerHTML = '<tr><td colspan="6" class="empty">No active calls</td></tr>';
+      return;
+    }
+    var now = Date.now() / 1000;
+    body.innerHTML = active.map(function(c) {
+      var dur = c.started_at ? Math.round(now - c.started_at) : 0;
+      var turns = c.turns ? c.turns.length : 0;
+      return '<tr>'+
+        '<td><code>'+shortId(c.call_id)+'</code></td>'+
+        '<td>'+(esc(c.caller) || '-')+'</td>'+
+        '<td>'+(esc(c.callee) || '-')+'</td>'+
+        '<td>'+(esc(c.direction) || '-')+'</td>'+
+        '<td data-started="'+(c.started_at || 0)+'">'+fmtDur(dur)+'</td>'+
+        '<td>'+turns+'</td></tr>';
+    }).join('');
+  });
+}
+
+function showCall(callId) {
+  fetchJSON('/api/dashboard/calls/'+encodeURIComponent(callId)).then(function(c) {
+    if (c.error) return;
+    var m = c.metrics || {};
+    var cost = m.cost || {};
+    var latAvg = m.latency_avg || {};
+    var latP95 = m.latency_p95 || {};
+    var turns = m.turns || [];
+
+    var modeLabel = (m.provider_mode || '').replace(/_/g, ' ');
+    var modeBadgeClass = (m.provider_mode || '').indexOf('pipeline') !== -1 ? 'badge-pipeline' : 'badge-realtime';
+    _$('#modal-title').innerHTML = 'Call <code>'+shortId(c.call_id)+'</code> <span class="badge '+modeBadgeClass+'" style="font-size:10px">'+esc(modeLabel)+'</span>';
+
+    var isRealtime = (m.provider_mode || '').indexOf('realtime') !== -1;
+
+    var html = '<div class="detail-grid">'+
+      '<div class="detail-card">'+
+        '<h3>Overview</h3>'+
+        '<div class="detail-row"><span class="k">Direction</span><span>'+(esc(c.direction) || '-')+'</span></div>'+
+        '<div class="detail-row"><span class="k">From</span><span class="mono">'+(esc(c.caller) || '-')+'</span></div>'+
+        '<div class="detail-row"><span class="k">To</span><span class="mono">'+(esc(c.callee) || '-')+'</span></div>'+
+        '<div class="detail-row"><span class="k">Duration</span><span style="font-weight:600">'+fmtDur(m.duration_seconds)+'</span></div>'+
+        (isRealtime ? '' :
+          '<div class="detail-row"><span class="k">STT</span><span>'+(esc(m.stt_provider) || '-')+'</span></div>'+
+          '<div class="detail-row"><span class="k">TTS</span><span>'+(esc(m.tts_provider) || '-')+'</span></div>'+
+          '<div class="detail-row"><span class="k">LLM</span><span>'+(esc(m.llm_provider) || '-')+'</span></div>'
+        )+
+        '<div class="detail-row"><span class="k">Telephony</span><span>'+(esc(m.telephony_provider) || '-')+'</span></div>'+
+      '</div>'+
+      '<div class="detail-card">'+
+        '<h3>Cost</h3>'+
+        (isRealtime ?
+          '<div class="detail-row"><span class="k">OpenAI</span><span class="cost">'+fmtCost(cost.llm || 0)+'</span></div>' :
+          '<div class="detail-row"><span class="k">STT</span><span class="cost">'+fmtCost(cost.stt || 0)+'</span></div>'+
+          '<div class="detail-row"><span class="k">LLM</span><span class="cost">'+fmtCost(cost.llm || 0)+'</span></div>'+
+          '<div class="detail-row"><span class="k">TTS</span><span class="cost">'+fmtCost(cost.tts || 0)+'</span></div>'
+        )+
+        '<div class="detail-row"><span class="k">Telephony</span><span class="cost">'+fmtCost(cost.telephony || 0)+'</span></div>'+
+        '<div class="detail-row detail-sep">'+
+          '<span class="k" style="font-weight:600">Total</span><span class="cost" style="font-weight:700;font-size:14px">'+fmtCost(cost.total || 0)+'</span>'+
+        '</div>'+
+        '<h3 style="margin-top:16px">Latency <span style="font-weight:400;text-transform:none;letter-spacing:0;color:var(--muted)">(avg / p95)</span></h3>'+
+        (isRealtime ? '' :
+          '<div class="detail-row"><span class="k">STT</span><span class="latency">'+fmtMs(latAvg.stt_ms)+' / '+fmtMs(latP95.stt_ms)+'</span></div>'+
+          '<div class="detail-row"><span class="k">LLM</span><span class="latency">'+fmtMs(latAvg.llm_ms)+' / '+fmtMs(latP95.llm_ms)+'</span></div>'+
+          '<div class="detail-row"><span class="k">TTS</span><span class="latency">'+fmtMs(latAvg.tts_ms)+' / '+fmtMs(latP95.tts_ms)+'</span></div>'
+        )+
+        '<div class="detail-row"><span class="k">'+(isRealtime ? 'End-to-end' : 'Total')+'</span><span class="latency" style="font-weight:700;font-size:14px">'+fmtMs(latAvg.total_ms)+' / '+fmtMs(latP95.total_ms)+'</span></div>'+
+      '</div></div>';
+
+    if (turns.length) {
+      var maxMs = Math.max.apply(null, turns.map(function(t) {
+        var l = t.latency || {};
+        return (l.stt_ms||0) + (l.llm_ms||0) + (l.tts_ms||0) + (l.total_ms||0);
+      }).concat([1]));
+      html += '<div class="detail-card turns-table"><h3>Turns ('+turns.length+')</h3>'+
+        '<table><thead><tr><th>#</th><th>User</th><th>Agent</th><th>Latency</th><th>Breakdown</th></tr></thead><tbody>';
+      turns.forEach(function(t, i) {
+        var l = t.latency || {};
+        var total = l.total_ms || ((l.stt_ms||0) + (l.llm_ms||0) + (l.tts_ms||0));
+        var scale = total > 0 ? 120 / maxMs : 0;
+        var sttW = (l.stt_ms||0) * scale;
+        var llmW = (l.llm_ms||0) * scale;
+        var ttsW = (l.tts_ms||0) * scale;
+        var totalW = total > 0 && sttW === 0 && llmW === 0 && ttsW === 0 ? total * scale : 0;
+        html += '<tr>'+
+          '<td>'+(t.turn_index !== undefined ? t.turn_index : i)+'</td>'+
+          '<td title="'+esc(t.user_text||'')+'">'+esc((t.user_text||'').slice(0,40))+((t.user_text||'').length>40?'...':'')+'</td>'+
+          '<td title="'+esc(t.agent_text||'')+'">'+esc((t.agent_text||'').slice(0,40))+((t.agent_text||'').length>40?'...':'')+'</td>'+
+          '<td class="latency">'+fmtMs(total)+'</td>'+
+          '<td><div class="bar-container">'+
+            (sttW > 0 ? '<div class="bar-stt" style="width:'+sttW+'px" title="STT '+fmtMs(l.stt_ms)+'"></div>' : '')+
+            (llmW > 0 ? '<div class="bar-llm" style="width:'+llmW+'px" title="LLM '+fmtMs(l.llm_ms)+'"></div>' : '')+
+            (ttsW > 0 ? '<div class="bar-tts" style="width:'+ttsW+'px" title="TTS '+fmtMs(l.tts_ms)+'"></div>' : '')+
+            (totalW > 0 ? '<div class="bar-llm" style="width:'+totalW+'px" title="Total '+fmtMs(total)+'"></div>' : '')+
+          '</div></td></tr>';
+      });
+      html += '</tbody></table>'+
+        '<div style="margin-top:10px;font-size:11px;color:var(--muted)">'+
+          (isRealtime ?
+            '<span style="color:var(--purple)">&#9632;</span> End-to-end' :
+            '<span style="color:var(--blue)">&#9632;</span> STT &nbsp;'+
+            '<span style="color:var(--purple)">&#9632;</span> LLM &nbsp;'+
+            '<span style="color:var(--orange)">&#9632;</span> TTS'
+          )+
+        '</div></div>';
+    }
+
+    var transcript = c.transcript || [];
+    if (transcript.length) {
+      html += '<div class="detail-card" style="margin-top:16px"><h3>Transcript</h3><div class="transcript-box">';
+      transcript.forEach(function(msg) {
+        var role = esc(msg.role || 'unknown');
+        html += '<div class="msg '+role+'"><span class="role">'+role+'</span>'+esc(msg.text || '')+'</div>';
+      });
+      html += '</div></div>';
+    }
+
+    _$('#modal-body').innerHTML = html;
+    _$('#modal').classList.add('open');
+  });
+}
+
+function closeModal() { _$('#modal').classList.remove('open'); }
+_$('#modal').addEventListener('click', function(e) { if (e.target === _$('#modal')) closeModal(); });
+document.addEventListener('keydown', function(e) { if (e.key === 'Escape') closeModal(); });
+
+function refresh() {
+  return Promise.all([refreshAggregates(), refreshCalls(), refreshActive()]).then(function() {
+    _$('#status-text').textContent = 'Listening';
+  }).catch(function() {
+    _$('#status-text').textContent = 'Connection error';
+  });
+}
+
+refresh();
+
+// Update active call durations every second
+setInterval(function() {
+  var cells = document.querySelectorAll('#active-body td[data-started]');
+  if (!cells.length) return;
+  var now = Date.now() / 1000;
+  cells.forEach(function(td) {
+    var started = parseFloat(td.getAttribute('data-started'));
+    if (started) td.textContent = fmtDur(Math.round(now - started));
+  });
+}, 1000);
+
+if (typeof EventSource !== 'undefined') {
+  var sseUrl = '/api/dashboard/events';
+  var sseBackoff = 1000;
+  var sseFailures = 0;
+  var SSE_MAX_BACKOFF = 30000;
+  var SSE_MAX_FAILURES = 5;
+
+  function connectSSE() {
+    var es = new EventSource(sseUrl);
+    function onEvent() { sseBackoff = 1000; sseFailures = 0; }
+    es.addEventListener('call_start', function() { onEvent(); refresh(); });
+    es.addEventListener('turn_complete', function() { onEvent(); refreshAggregates(); });
+    es.addEventListener('call_end', function() { onEvent(); refresh(); });
+    es.onerror = function() {
+      es.close();
+      sseFailures++;
+      if (sseFailures >= SSE_MAX_FAILURES) {
+        _$('#status-text').textContent = 'Polling';
+        setInterval(refresh, 5000);
+        return;
+      }
+      _$('#status-text').textContent = 'Reconnecting...';
+      setTimeout(connectSSE, sseBackoff);
+      sseBackoff = Math.min(sseBackoff * 2, SSE_MAX_BACKOFF);
+    };
+  }
+  connectSSE();
+} else {
+  setInterval(refresh, 3000);
+}
+</script>
+</body>
+</html>`;
+
+// src/dashboard/routes.ts
+function mountDashboard(app, store, token = "") {
+  const auth = makeAuthMiddleware(token);
+  app.get("/", auth, (_req, res) => {
+    res.type("text/html").send(DASHBOARD_HTML);
+  });
+  app.get("/api/dashboard/calls", auth, (req, res) => {
+    const limit = Math.min(parseInt(req.query.limit || "50", 10) || 50, 1e3);
+    const offset = parseInt(req.query.offset || "0", 10) || 0;
+    res.json(store.getCalls(limit, offset));
+  });
+  app.get("/api/dashboard/calls/:callId", auth, (req, res) => {
+    const call = store.getCall(String(req.params.callId));
+    if (!call) {
+      res.status(404).json({ error: "Not found" });
+      return;
+    }
+    res.json(call);
+  });
+  app.get("/api/dashboard/active", auth, (_req, res) => {
+    res.json(store.getActiveCalls());
+  });
+  app.get("/api/dashboard/aggregates", auth, (_req, res) => {
+    res.json(store.getAggregates());
+  });
+  app.get("/api/dashboard/events", auth, (req, res) => {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    });
+    const listener = (event) => {
+      const data = JSON.stringify(event.data);
+      const safeType = String(event.type ?? "message").replace(/[\r\n]/g, "");
+      res.write(`event: ${safeType}
+data: ${data}
+
+`);
+    };
+    store.on("sse", listener);
+    const keepalive = setInterval(() => {
+      res.write(": keepalive\n\n");
+    }, 3e4);
+    req.on("close", () => {
+      clearInterval(keepalive);
+      store.off("sse", listener);
+    });
+  });
+  app.get("/api/dashboard/export/calls", auth, (req, res) => {
+    const fmt = req.query.format || "json";
+    const fromDate = req.query.from || "";
+    const toDate = req.query.to || "";
+    let fromTs = 0;
+    let toTs = 0;
+    if (fromDate) {
+      const d = new Date(fromDate);
+      if (!isNaN(d.getTime())) fromTs = d.getTime() / 1e3;
+    }
+    if (toDate) {
+      const d = new Date(toDate);
+      if (!isNaN(d.getTime())) toTs = d.getTime() / 1e3;
+    }
+    const calls = fromTs || toTs ? store.getCallsInRange(fromTs, toTs) : store.getCalls(1e4);
+    if (fmt === "csv") {
+      const csvData = callsToCsv(calls);
+      res.setHeader("Content-Type", "text/csv");
+      res.setHeader("Content-Disposition", "attachment; filename=patter_calls.csv");
+      res.send(csvData);
+    } else {
+      const jsonData = callsToJson(calls);
+      res.setHeader("Content-Type", "application/json");
+      res.setHeader("Content-Disposition", "attachment; filename=patter_calls.json");
+      res.send(jsonData);
+    }
+  });
+}
+function mountApi(app, store, token = "") {
+  const auth = makeAuthMiddleware(token);
+  app.get("/api/v1/calls", auth, (req, res) => {
+    const limit = Math.min(parseInt(req.query.limit || "50", 10) || 50, 1e3);
+    const offset = parseInt(req.query.offset || "0", 10) || 0;
+    const calls = store.getCalls(limit, offset);
+    res.json({
+      data: calls,
+      pagination: {
+        limit,
+        offset,
+        count: calls.length,
+        total: store.callCount
+      }
+    });
+  });
+  app.get("/api/v1/calls/active", auth, (_req, res) => {
+    const active = store.getActiveCalls();
+    res.json({ data: active, count: active.length });
+  });
+  app.get("/api/v1/calls/:callId", auth, (req, res) => {
+    const call = store.getCall(String(req.params.callId));
+    if (!call) {
+      res.status(404).json({ error: "Call not found" });
+      return;
+    }
+    res.json({ data: call });
+  });
+  app.get("/api/v1/analytics/overview", auth, (_req, res) => {
+    res.json({ data: store.getAggregates() });
+  });
+  app.get("/api/v1/analytics/costs", auth, (req, res) => {
+    const fromDate = req.query.from || "";
+    const toDate = req.query.to || "";
+    let fromTs = 0;
+    let toTs = 0;
+    if (fromDate) {
+      const d = new Date(fromDate);
+      if (!isNaN(d.getTime())) fromTs = d.getTime() / 1e3;
+    }
+    if (toDate) {
+      const d = new Date(toDate);
+      if (!isNaN(d.getTime())) toTs = d.getTime() / 1e3;
+    }
+    const calls = fromTs || toTs ? store.getCallsInRange(fromTs, toTs) : store.getCalls(1e4);
+    let totalCost = 0;
+    let costStt = 0;
+    let costTts = 0;
+    let costLlm = 0;
+    let costTelephony = 0;
+    let callsWithCost = 0;
+    for (const call of calls) {
+      const m = call.metrics;
+      if (!m) continue;
+      const cost = m.cost || {};
+      totalCost += cost.total || 0;
+      costStt += cost.stt || 0;
+      costTts += cost.tts || 0;
+      costLlm += cost.llm || 0;
+      costTelephony += cost.telephony || 0;
+      callsWithCost++;
+    }
+    res.json({
+      data: {
+        total_cost: Math.round(totalCost * 1e6) / 1e6,
+        breakdown: {
+          stt: Math.round(costStt * 1e6) / 1e6,
+          tts: Math.round(costTts * 1e6) / 1e6,
+          llm: Math.round(costLlm * 1e6) / 1e6,
+          telephony: Math.round(costTelephony * 1e6) / 1e6
+        },
+        calls_analyzed: callsWithCost,
+        period: {
+          from: fromDate || null,
+          to: toDate || null
+        }
+      }
+    });
+  });
+}
+
+// src/remote-message.ts
+import crypto2 from "crypto";
+var MAX_RESPONSE_BYTES = 64 * 1024;
+function validateWebSocketUrl(url) {
+  let translated = url;
+  if (url.startsWith("ws://")) {
+    translated = "http://" + url.slice("ws://".length);
+  } else if (url.startsWith("wss://")) {
+    translated = "https://" + url.slice("wss://".length);
+  }
+  validateWebhookUrl(translated);
+}
+var RemoteMessageHandler = class {
+  webhookSecret;
+  /**
+   * @param webhookSecret Optional HMAC secret. When provided, outgoing webhook
+   *   requests include an `X-Patter-Signature` header so the receiver can
+   *   verify the payload originated from Patter.
+   */
+  constructor(webhookSecret) {
+    this.webhookSecret = webhookSecret;
+  }
+  /**
+   * Compute HMAC-SHA256 hex digest for the given body.
+   */
+  signPayload(body) {
+    if (!this.webhookSecret) {
+      throw new Error("Cannot sign without a webhookSecret");
+    }
+    return crypto2.createHmac("sha256", this.webhookSecret).update(body).digest("hex");
+  }
+  /**
+   * Release resources held by this handler.
+   */
+  close() {
+  }
+  /**
+   * POST transcript to HTTP webhook, return response text.
+   *
+   * The webhook receives a JSON payload:
+   *   { text, call_id, caller, callee, history }
+   *
+   * The response can be plain text or JSON { text: "..." }.
+   *
+   * When `webhookSecret` was provided at construction time, the request
+   * includes an `X-Patter-Signature` header with the HMAC-SHA256 hex
+   * digest of the JSON body.
+   */
+  async callWebhook(url, data) {
+    try {
+      validateWebhookUrl(url);
+    } catch (e) {
+      getLogger().warn(`Webhook URL rejected by SSRF guard: ${String(e)}`);
+      return "";
+    }
+    if (url.startsWith("http://")) {
+      getLogger().warn(
+        "Webhook URL uses unencrypted http:// \u2014 call transcripts and phone numbers will be sent in plaintext. Use https:// in production."
+      );
+    }
+    const body = JSON.stringify(data);
+    const headers = { "Content-Type": "application/json" };
+    if (this.webhookSecret) {
+      headers["X-Patter-Signature"] = this.signPayload(body);
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body,
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      throw new Error(`Webhook returned HTTP ${response.status}`);
+    }
+    const text = await response.text();
+    if (text.length > MAX_RESPONSE_BYTES) {
+      throw new Error(`Webhook response too large: ${text.length} bytes (max ${MAX_RESPONSE_BYTES})`);
+    }
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      try {
+        const body2 = JSON.parse(text);
+        if (typeof body2 === "object" && body2 !== null && "text" in body2) {
+          return String(body2.text);
+        }
+        return String(body2);
+      } catch {
+        return text;
+      }
+    }
+    return text;
+  }
+  /**
+   * Send transcript via WebSocket, yield response chunks.
+   *
+   * Sends the message data as JSON. Receives one or more JSON frames
+   * with { text: "..." } - multiple frames enable streaming.
+   * A frame with { done: true } signals end of response.
+   */
+  async *callWebSocket(url, data) {
+    try {
+      validateWebSocketUrl(url);
+    } catch (e) {
+      getLogger().warn(`WebSocket URL rejected by SSRF guard: ${String(e)}`);
+      return;
+    }
+    if (url.startsWith("ws://")) {
+      getLogger().warn(
+        "WebSocket URL uses unencrypted ws:// \u2014 call transcripts and phone numbers will be sent in plaintext. Use wss:// in production."
+      );
+    }
+    const { WebSocket: WebSocket4 } = await import("ws");
+    const ws = new WebSocket4(url);
+    const chunks = [];
+    let done = false;
+    let error = null;
+    let resolveNext = null;
+    ws.on("message", (raw) => {
+      const rawStr = raw.toString();
+      let text = null;
+      try {
+        const frame = JSON.parse(rawStr);
+        if (typeof frame === "object" && frame !== null) {
+          if (frame.done) {
+            done = true;
+            ws.close();
+            if (resolveNext) {
+              const r = resolveNext;
+              resolveNext = null;
+              r(null);
+            }
+            return;
+          }
+          text = frame.text || null;
+        } else {
+          text = String(frame);
+        }
+      } catch {
+        text = rawStr;
+      }
+      if (text && resolveNext) {
+        const r = resolveNext;
+        resolveNext = null;
+        r(text);
+      } else if (text) {
+        chunks.push(text);
+      }
+    });
+    ws.on("close", () => {
+      done = true;
+      if (resolveNext) {
+        const r = resolveNext;
+        resolveNext = null;
+        r(null);
+      }
+    });
+    ws.on("error", (err) => {
+      error = err;
+      done = true;
+      if (resolveNext) {
+        const r = resolveNext;
+        resolveNext = null;
+        r(null);
+      }
+    });
+    try {
+      await new Promise((resolve, reject) => {
+        ws.on("open", () => {
+          ws.send(JSON.stringify(data));
+          resolve();
+        });
+        ws.on("error", (err) => {
+          reject(err);
+        });
+      });
+      while (chunks.length > 0) {
+        yield chunks.shift();
+      }
+      while (!done && !error) {
+        const text = await new Promise((resolve) => {
+          if (chunks.length > 0) {
+            resolve(chunks.shift());
+          } else {
+            resolveNext = resolve;
+          }
+        });
+        if (text === null) break;
+        yield text;
+      }
+      if (error) throw error;
+    } finally {
+      if (ws.readyState !== ws.CLOSED && ws.readyState !== ws.CLOSING) {
+        ws.close();
+      }
+    }
+  }
+};
+function isRemoteUrl(onMessage) {
+  if (typeof onMessage !== "string") return false;
+  return onMessage.startsWith("http://") || onMessage.startsWith("https://") || onMessage.startsWith("ws://") || onMessage.startsWith("wss://");
+}
+function isWebSocketUrl(url) {
+  return url.startsWith("ws://") || url.startsWith("wss://");
+}
+
+// src/providers/elevenlabs-tts.ts
+var ELEVENLABS_BASE_URL = "https://api.elevenlabs.io/v1";
+var ElevenLabsTTS = class {
+  constructor(apiKey, voiceId = "21m00Tcm4TlvDq8ikWAM", modelId = "eleven_turbo_v2_5", outputFormat = "pcm_16000") {
+    this.apiKey = apiKey;
+    this.voiceId = voiceId;
+    this.modelId = modelId;
+    this.outputFormat = outputFormat;
+  }
+  /**
+   * Synthesise text to speech and return the full audio as a single Buffer.
+   *
+   * For large chunks (or when latency matters) call `synthesizeStream` instead.
+   */
+  async synthesize(text) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+  /**
+   * Synthesise text and yield audio chunks as they arrive (streaming).
+   *
+   * The yielded buffers are raw PCM at 16 kHz (or whatever `outputFormat` is
+   * configured to).
+   */
+  async *synthesizeStream(text) {
+    const url = `${ELEVENLABS_BASE_URL}/text-to-speech/${encodeURIComponent(this.voiceId)}/stream?output_format=${encodeURIComponent(this.outputFormat)}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "xi-api-key": this.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ text, model_id: this.modelId }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`ElevenLabs TTS error ${response.status}: ${body}`);
+    }
+    if (!response.body) {
+      throw new Error("ElevenLabs TTS: no response body");
+    }
+    const reader = response.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value && value.length > 0) {
+          yield Buffer.from(value);
+        }
+      }
+    } finally {
+      if (typeof reader.cancel === "function") await reader.cancel().catch(() => {
+      });
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/providers/openai-tts.ts
+var OPENAI_TTS_URL = "https://api.openai.com/v1/audio/speech";
+var OpenAITTS = class _OpenAITTS {
+  constructor(apiKey, voice = "alloy", model = "tts-1") {
+    this.apiKey = apiKey;
+    this.voice = voice;
+    this.model = model;
+  }
+  /**
+   * Synthesise text to speech and return the full audio as a single Buffer.
+   *
+   * For large chunks (or when latency matters) call `synthesizeStream` instead.
+   */
+  async synthesize(text) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+  /**
+   * Synthesise text and yield audio chunks as they arrive (streaming).
+   *
+   * OpenAI returns 24 kHz PCM16; each chunk is resampled to 16 kHz before
+   * yielding so the output is ready for telephony pipelines.
+   */
+  async *synthesizeStream(text) {
+    const response = await fetch(OPENAI_TTS_URL, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        input: text,
+        voice: this.voice,
+        response_format: "pcm"
+      }),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`OpenAI TTS error ${response.status}: ${body}`);
+    }
+    if (!response.body) {
+      throw new Error("OpenAI TTS: no response body");
+    }
+    const reader = response.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value && value.length > 0) {
+          yield _OpenAITTS.resample24kTo16k(Buffer.from(value));
+        }
+      }
+    } finally {
+      if (typeof reader.cancel === "function") await reader.cancel().catch(() => {
+      });
+      reader.releaseLock();
+    }
+  }
+  /**
+   * Resample 24 kHz PCM16-LE to 16 kHz by taking 2 out of every 3 samples.
+   *
+   * For each group of 3 input samples the first is kept as-is and the second
+   * output sample is the average of input samples 2 and 3.  This matches the
+   * Python SDK implementation.
+   */
+  static resample24kTo16k(audio) {
+    if (audio.length < 2) return audio;
+    const sampleCount = Math.floor(audio.length / 2);
+    const samples = new Int16Array(sampleCount);
+    for (let i = 0; i < sampleCount; i++) {
+      samples[i] = audio.readInt16LE(i * 2);
+    }
+    const resampled = [];
+    for (let i = 0; i < samples.length; i += 3) {
+      resampled.push(samples[i]);
+      if (i + 1 < samples.length) {
+        if (i + 2 < samples.length) {
+          resampled.push(Math.trunc((samples[i + 1] + samples[i + 2]) / 2));
+        } else {
+          resampled.push(samples[i + 1]);
+        }
+      }
+    }
+    const out = Buffer.alloc(resampled.length * 2);
+    for (let i = 0; i < resampled.length; i++) {
+      out.writeInt16LE(resampled[i], i * 2);
+    }
+    return out;
+  }
+};
+
+// src/metrics.ts
+function round(value, decimals) {
+  const factor = 10 ** decimals;
+  return Math.round(value * factor) / factor;
+}
+function hrTimeMs() {
+  const [sec, ns] = process.hrtime();
+  return sec * 1e3 + ns / 1e6;
+}
+function p95(values) {
+  if (values.length === 0) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const idx = Math.min(Math.floor(sorted.length * 0.95), sorted.length - 1);
+  return sorted[idx];
+}
+var CallMetricsAccumulator = class {
+  callId;
+  providerMode;
+  telephonyProvider;
+  sttProvider;
+  ttsProvider;
+  llmProvider;
+  _pricing;
+  _callStart;
+  _turns = [];
+  // Per-turn timing state
+  _turnStart = null;
+  _sttComplete = null;
+  _llmComplete = null;
+  _ttsFirstByte = null;
+  _turnUserText = "";
+  _turnSttAudioSeconds = 0;
+  // Cumulative usage counters
+  _totalSttAudioSeconds = 0;
+  _totalTtsCharacters = 0;
+  _totalRealtimeCost = 0;
+  _sttByteCount = 0;
+  _sttSampleRate = 16e3;
+  _sttBytesPerSample = 2;
+  _actualTelephonyCost = null;
+  _actualSttCost = null;
+  constructor(opts) {
+    this.callId = opts.callId;
+    this.providerMode = opts.providerMode;
+    this.telephonyProvider = opts.telephonyProvider;
+    this.sttProvider = opts.sttProvider ?? "";
+    this.ttsProvider = opts.ttsProvider ?? "";
+    this.llmProvider = opts.llmProvider ?? "";
+    this._pricing = mergePricing(opts.pricing);
+    this._callStart = hrTimeMs();
+  }
+  /** Configure audio format for STT byte-to-seconds conversion. */
+  configureSttFormat(sampleRate = 16e3, bytesPerSample = 2) {
+    this._sttSampleRate = sampleRate;
+    this._sttBytesPerSample = bytesPerSample;
+  }
+  // ---- Turn lifecycle ----
+  /** Whether a turn is currently being measured (startTurn called, not yet completed). */
+  get turnActive() {
+    return this._turnStart !== null;
+  }
+  startTurn() {
+    this._turnStart = hrTimeMs();
+    this._sttComplete = null;
+    this._llmComplete = null;
+    this._ttsFirstByte = null;
+    this._turnUserText = "";
+    this._turnSttAudioSeconds = 0;
+  }
+  recordSttComplete(text, audioSeconds = 0) {
+    this._sttComplete = hrTimeMs();
+    this._turnUserText = text;
+    this._turnSttAudioSeconds = audioSeconds;
+    this._totalSttAudioSeconds += audioSeconds;
+  }
+  recordLlmComplete() {
+    this._llmComplete = hrTimeMs();
+  }
+  recordTtsFirstByte() {
+    if (this._ttsFirstByte === null) {
+      this._ttsFirstByte = hrTimeMs();
+    }
+  }
+  recordTtsComplete(text) {
+    this._totalTtsCharacters += text.length;
+  }
+  recordTurnComplete(agentText) {
+    const latency = this._computeTurnLatency();
+    const turn = {
+      turn_index: this._turns.length,
+      user_text: this._turnUserText,
+      agent_text: agentText,
+      latency,
+      stt_audio_seconds: this._turnSttAudioSeconds,
+      tts_characters: agentText.length,
+      timestamp: Date.now() / 1e3
+    };
+    this._turns.push(turn);
+    this._resetTurnState();
+    return turn;
+  }
+  recordTurnInterrupted() {
+    if (this._turnStart === null) return null;
+    const latency = this._computeTurnLatency();
+    const turn = {
+      turn_index: this._turns.length,
+      user_text: this._turnUserText,
+      agent_text: "[interrupted]",
+      latency,
+      stt_audio_seconds: this._turnSttAudioSeconds,
+      tts_characters: 0,
+      timestamp: Date.now() / 1e3
+    };
+    this._turns.push(turn);
+    this._resetTurnState();
+    return turn;
+  }
+  // ---- Usage tracking ----
+  addSttAudioBytes(byteCount) {
+    this._sttByteCount += byteCount;
+  }
+  recordRealtimeUsage(usage) {
+    this._totalRealtimeCost += calculateRealtimeCost(usage, this._pricing);
+  }
+  setActualTelephonyCost(cost) {
+    this._actualTelephonyCost = cost;
+  }
+  setActualSttCost(cost) {
+    this._actualSttCost = cost;
+  }
+  // ---- Finalize ----
+  endCall() {
+    const duration = (hrTimeMs() - this._callStart) / 1e3;
+    if (this._totalSttAudioSeconds === 0 && this._sttByteCount > 0) {
+      this._totalSttAudioSeconds = this._sttByteCount / (this._sttSampleRate * this._sttBytesPerSample);
+    }
+    const cost = this._computeCost(duration);
+    const latencyAvg = this._computeAverageLatency();
+    const latencyP95 = this._computeP95Latency();
+    return {
+      call_id: this.callId,
+      duration_seconds: round(duration, 2),
+      turns: [...this._turns],
+      cost,
+      latency_avg: latencyAvg,
+      latency_p95: latencyP95,
+      provider_mode: this.providerMode,
+      stt_provider: this.sttProvider,
+      tts_provider: this.ttsProvider,
+      llm_provider: this.llmProvider,
+      telephony_provider: this.telephonyProvider
+    };
+  }
+  getCostSoFar() {
+    const duration = (hrTimeMs() - this._callStart) / 1e3;
+    return this._computeCost(duration);
+  }
+  // ---- Internal ----
+  _resetTurnState() {
+    this._turnStart = null;
+    this._sttComplete = null;
+    this._llmComplete = null;
+    this._ttsFirstByte = null;
+    this._turnUserText = "";
+    this._turnSttAudioSeconds = 0;
+  }
+  _computeTurnLatency() {
+    let stt_ms = 0;
+    let llm_ms = 0;
+    let tts_ms = 0;
+    let total_ms = 0;
+    if (this._turnStart !== null && this._sttComplete !== null) {
+      stt_ms = this._sttComplete - this._turnStart;
+    }
+    if (this._sttComplete !== null && this._llmComplete !== null) {
+      llm_ms = this._llmComplete - this._sttComplete;
+    }
+    if (this._llmComplete !== null && this._ttsFirstByte !== null) {
+      tts_ms = this._ttsFirstByte - this._llmComplete;
+    }
+    if (this._turnStart !== null && this._ttsFirstByte !== null) {
+      total_ms = this._ttsFirstByte - this._turnStart;
+    }
+    if (total_ms > 0 && stt_ms === 0 && llm_ms === 0 && tts_ms === 0) {
+      llm_ms = total_ms;
+    }
+    return {
+      stt_ms: round(stt_ms, 1),
+      llm_ms: round(llm_ms, 1),
+      tts_ms: round(tts_ms, 1),
+      total_ms: round(total_ms, 1)
+    };
+  }
+  _computeCost(durationSeconds) {
+    let stt;
+    let tts;
+    let llm;
+    if (this.providerMode === "openai_realtime") {
+      stt = 0;
+      tts = 0;
+      llm = this._totalRealtimeCost;
+    } else if (this.providerMode === "elevenlabs_convai") {
+      stt = 0;
+      tts = 0;
+      llm = 0;
+    } else {
+      stt = this._actualSttCost !== null ? this._actualSttCost : calculateSttCost(this.sttProvider, this._totalSttAudioSeconds, this._pricing);
+      tts = calculateTtsCost(this.ttsProvider, this._totalTtsCharacters, this._pricing);
+      llm = 0;
+    }
+    const telephony = this._actualTelephonyCost !== null ? this._actualTelephonyCost : calculateTelephonyCost(this.telephonyProvider, durationSeconds, this._pricing);
+    const total = stt + tts + llm + telephony;
+    return {
+      stt: round(stt, 6),
+      tts: round(tts, 6),
+      llm: round(llm, 6),
+      telephony: round(telephony, 6),
+      total: round(total, 6)
+    };
+  }
+  _computeAverageLatency() {
+    if (this._turns.length === 0) {
+      return { stt_ms: 0, llm_ms: 0, tts_ms: 0, total_ms: 0 };
+    }
+    const n = this._turns.length;
+    return {
+      stt_ms: round(this._turns.reduce((s, t) => s + t.latency.stt_ms, 0) / n, 1),
+      llm_ms: round(this._turns.reduce((s, t) => s + t.latency.llm_ms, 0) / n, 1),
+      tts_ms: round(this._turns.reduce((s, t) => s + t.latency.tts_ms, 0) / n, 1),
+      total_ms: round(this._turns.reduce((s, t) => s + t.latency.total_ms, 0) / n, 1)
+    };
+  }
+  _computeP95Latency() {
+    if (this._turns.length === 0) {
+      return { stt_ms: 0, llm_ms: 0, tts_ms: 0, total_ms: 0 };
+    }
+    return {
+      stt_ms: round(p95(this._turns.map((t) => t.latency.stt_ms)), 1),
+      llm_ms: round(p95(this._turns.map((t) => t.latency.llm_ms)), 1),
+      tts_ms: round(p95(this._turns.map((t) => t.latency.tts_ms)), 1),
+      total_ms: round(p95(this._turns.map((t) => t.latency.total_ms)), 1)
+    };
+  }
+};
+
+// src/transcoding.ts
+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;
+}
+function resample8kTo16k(pcm8k) {
+  if (pcm8k.length === 0) return Buffer.alloc(0);
+  const sampleCount = Math.floor(pcm8k.length / 2);
+  const out = Buffer.alloc(sampleCount * 2 * 2);
+  for (let i = 0; i < sampleCount; i++) {
+    const current = pcm8k.readInt16LE(i * 2);
+    const next = i + 1 < sampleCount ? pcm8k.readInt16LE((i + 1) * 2) : current;
+    const interpolated = Math.round((current + next) / 2);
+    out.writeInt16LE(current, i * 4);
+    out.writeInt16LE(interpolated, i * 4 + 2);
+  }
+  return out;
+}
+function resample16kTo8k(pcm16k) {
+  if (pcm16k.length === 0) return Buffer.alloc(0);
+  const sampleCount = Math.floor(pcm16k.length / 2);
+  const outSamples = Math.floor(sampleCount / 2);
+  const out = Buffer.alloc(outSamples * 2);
+  for (let i = 0; i < outSamples; i++) {
+    const sample = pcm16k.readInt16LE(i * 2 * 2);
+    out.writeInt16LE(sample, i * 2);
+  }
+  return out;
+}
+function resample24kTo16k(pcm24k) {
+  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);
+  let outIdx = 0;
+  for (let i = 0; i < sampleCount && outIdx < outSamples; i++) {
+    if (i % 3 === 2) continue;
+    out.writeInt16LE(pcm24k.readInt16LE(i * 2), outIdx * 2);
+    outIdx++;
+  }
+  return out;
+}
+
+// src/handler-utils.ts
+function createHistoryManager(maxSize) {
+  const entries = [];
+  const push = (entry) => {
+    if (entries.length >= maxSize) entries.shift();
+    entries.push(entry);
+  };
+  const getHistory = () => [...entries];
+  return { push, getHistory, entries };
+}
+async function executeToolWebhook(webhookUrl, toolName, parsedArgs, context, label = "") {
+  try {
+    validateWebhookUrl(webhookUrl);
+  } catch (e) {
+    const tag = label ? ` (${label})` : "";
+    getLogger().error(`Tool webhook URL rejected${tag}: ${String(e)}`);
+    return JSON.stringify({ error: String(e), fallback: true });
+  }
+  let result = "";
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const resp = await fetch(webhookUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          tool: toolName,
+          arguments: parsedArgs,
+          call_id: context.callId,
+          caller: context.caller,
+          attempt: attempt + 1
+        }),
+        signal: AbortSignal.timeout(1e4)
+      });
+      if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+      result = JSON.stringify(await resp.json());
+      const MAX_RESPONSE_BYTES2 = 1 * 1024 * 1024;
+      if (result.length > MAX_RESPONSE_BYTES2) {
+        const tag = label ? ` (${label})` : "";
+        getLogger().warn(`Tool webhook response too large: ${result.length} bytes (max ${MAX_RESPONSE_BYTES2})${tag}`);
+        return JSON.stringify({ error: `Webhook response too large: ${result.length} bytes (max ${MAX_RESPONSE_BYTES2})`, fallback: true });
+      }
+      return result;
+    } catch (e) {
+      if (attempt < 2) {
+        const tag = label ? ` (${label})` : "";
+        getLogger().info(`Tool webhook retry ${attempt + 1}${tag}: ${String(e)}`);
+        await new Promise((r) => setTimeout(r, 500));
+      } else {
+        result = JSON.stringify({ error: `Tool failed after 3 attempts: ${String(e)}`, fallback: true });
+      }
+    }
+  }
+  return result;
+}
+
+// src/sentence-chunker.ts
+var DEFAULT_MIN_SENTENCE_LEN = 20;
+function splitSentences(text, minSentenceLen = DEFAULT_MIN_SENTENCE_LEN) {
+  const alphabets = "([A-Za-z])";
+  const prefixes = "(Mr|St|Mrs|Ms|Dr)[.]";
+  const suffixes = "(Inc|Ltd|Jr|Sr|Co)";
+  const starters = "(Mr|Mrs|Ms|Dr|Prof|Capt|Cpt|Lt|He\\s|She\\s|It\\s|They\\s|Their\\s|Our\\s|We\\s|But\\s|However\\s|That\\s|This\\s|Wherever)";
+  const acronyms = "([A-Z][.][A-Z][.](?:[A-Z][.])?)";
+  const websites = "[.](com|net|org|io|gov|edu|me)";
+  const digits = "([0-9])";
+  const multipleDots = "\\.{2,}";
+  text = text.replace(/\n/g, " ");
+  text = text.replace(new RegExp(prefixes, "g"), "$1<prd>");
+  text = text.replace(new RegExp(websites, "g"), "<prd>$1");
+  text = text.replace(new RegExp(digits + "[.]" + digits, "g"), "$1<prd>$2");
+  text = text.replace(new RegExp(multipleDots, "g"), (m) => "<prd>".repeat(m.length));
+  if (text.includes("Ph.D")) {
+    text = text.replace(/Ph\.D\./g, "Ph<prd>D<prd>");
+  }
+  text = text.replace(new RegExp("\\s" + alphabets + "[.] ", "g"), " $1<prd> ");
+  text = text.replace(new RegExp(acronyms + " " + starters, "g"), "$1<stop> $2");
+  text = text.replace(
+    new RegExp(alphabets + "[.]" + alphabets + "[.]" + alphabets + "[.]", "g"),
+    "$1<prd>$2<prd>$3<prd>"
+  );
+  text = text.replace(
+    new RegExp(alphabets + "[.]" + alphabets + "[.]", "g"),
+    "$1<prd>$2<prd>"
+  );
+  text = text.replace(new RegExp(" " + suffixes + "[.] " + starters, "g"), " $1<stop> $2");
+  text = text.replace(new RegExp(" " + suffixes + "[.]", "g"), " $1<prd>");
+  text = text.replace(new RegExp(" " + alphabets + "[.]", "g"), " $1<prd>");
+  text = text.replace(/([.!?\u3002\uff01\uff1f])(["\u201d])/g, "$1$2<stop>");
+  text = text.replace(/([.!?\u3002\uff01\uff1f])(?!["\u201d])/g, "$1<stop>");
+  text = text.replace(/<prd>/g, ".");
+  const splitted = text.split("<stop>");
+  text = text.replace(/<stop>/g, "");
+  const sentences = [];
+  let buff = "";
+  let startPos = 0;
+  let endPos = 0;
+  for (const match of splitted) {
+    const sentence = match.trim();
+    if (!sentence) continue;
+    buff += " " + sentence;
+    endPos += match.length;
+    if (buff.length > minSentenceLen) {
+      sentences.push([buff.trimStart(), startPos, endPos]);
+      startPos = endPos;
+      buff = "";
+    }
+  }
+  if (buff) {
+    sentences.push([buff.trimStart(), startPos, text.length - 1]);
+  }
+  return sentences;
+}
+var SentenceChunker = class {
+  buffer = "";
+  minSentenceLen;
+  constructor(options) {
+    this.minSentenceLen = options?.minSentenceLen ?? DEFAULT_MIN_SENTENCE_LEN;
+  }
+  /** Feed a token. Returns zero or more complete sentences. */
+  push(token) {
+    this.buffer += token;
+    if (this.buffer.length < this.minSentenceLen) {
+      return [];
+    }
+    const sentences = splitSentences(this.buffer, this.minSentenceLen);
+    if (sentences.length <= 1) {
+      return [];
+    }
+    const result = [];
+    for (let i = 0; i < sentences.length - 1; i++) {
+      const text = sentences[i][0].trim();
+      if (text) result.push(text);
+    }
+    this.buffer = sentences[sentences.length - 1]?.[0] ?? "";
+    return result;
+  }
+  /** Flush remaining buffer as final sentence(s). Call at end of stream. */
+  flush() {
+    const remaining = this.buffer.trim();
+    this.buffer = "";
+    if (!remaining) return [];
+    return [remaining];
+  }
+  /** Discard buffered text. Call on interrupt. */
+  reset() {
+    this.buffer = "";
+  }
+};
+
+// src/pipeline-hooks.ts
+var PipelineHookExecutor = class {
+  hooks;
+  constructor(hooks) {
+    this.hooks = hooks;
+  }
+  /**
+   * Run beforeSendToStt hook. Returns null to drop the audio chunk.
+   * If no hook is defined, returns the audio unchanged.
+   * Fail-open: on exception, the original audio passes through.
+   */
+  async runBeforeSendToStt(audio, ctx) {
+    if (!this.hooks?.beforeSendToStt) return audio;
+    try {
+      return await this.hooks.beforeSendToStt(audio, ctx);
+    } catch (e) {
+      getLogger().error("Pipeline hook beforeSendToStt threw:", e);
+      return audio;
+    }
+  }
+  /**
+   * Run afterTranscribe hook. Returns null if hook vetoes the turn.
+   * If no hook is defined, returns the transcript unchanged.
+   */
+  async runAfterTranscribe(transcript, ctx) {
+    if (!this.hooks?.afterTranscribe) return transcript;
+    try {
+      return await this.hooks.afterTranscribe(transcript, ctx);
+    } catch (e) {
+      getLogger().error("Pipeline hook afterTranscribe threw:", e);
+      return transcript;
+    }
+  }
+  /**
+   * Run beforeSynthesize hook. Returns null if hook vetoes TTS for this sentence.
+   * If no hook is defined, returns the text unchanged.
+   */
+  async runBeforeSynthesize(text, ctx) {
+    if (!this.hooks?.beforeSynthesize) return text;
+    try {
+      return await this.hooks.beforeSynthesize(text, ctx);
+    } catch (e) {
+      getLogger().error("Pipeline hook beforeSynthesize threw:", e);
+      return text;
+    }
+  }
+  /**
+   * Run afterSynthesize hook. Returns null if hook vetoes this audio chunk.
+   * If no hook is defined, returns the audio unchanged.
+   */
+  async runAfterSynthesize(audio, text, ctx) {
+    if (!this.hooks?.afterSynthesize) return audio;
+    try {
+      return await this.hooks.afterSynthesize(audio, text, ctx);
+    } catch (e) {
+      getLogger().error("Pipeline hook afterSynthesize threw:", e);
+      return audio;
+    }
+  }
+};
+
+// src/stream-handler.ts
+function checkGuardrails(text, guardrails) {
+  if (!guardrails) return null;
+  for (const guard of guardrails) {
+    let blocked = false;
+    if (guard.blockedTerms) {
+      blocked = guard.blockedTerms.some((term) => text.toLowerCase().includes(term.toLowerCase()));
+    }
+    if (!blocked && guard.check) {
+      blocked = guard.check(text);
+    }
+    if (blocked) return guard;
+  }
+  return null;
+}
+function sanitizeLogValue(v, maxLen = 200) {
+  const cleaned = v.replace(/[\x00-\x1f\x7f]/g, "");
+  return cleaned.length > maxLen ? cleaned.slice(0, maxLen) + "..." : cleaned;
+}
+function isValidE164(number) {
+  return /^\+[1-9]\d{6,14}$/.test(number);
+}
+var StreamHandler = class {
+  deps;
+  ws;
+  caller;
+  callee;
+  // Mutable call state
+  streamSid = "";
+  callId = "";
+  adapter = null;
+  stt = null;
+  tts = null;
+  isSpeaking = false;
+  llmLoop = null;
+  chunkCount = 0;
+  callEndFired = false;
+  sttClosed = false;
+  currentAgentText = "";
+  responseAudioStarted = false;
+  maxDurationTimer = null;
+  transcriptProcessing = false;
+  transcriptQueue = [];
+  history;
+  metricsAcc;
+  constructor(deps, ws, caller, callee) {
+    this.deps = deps;
+    this.ws = ws;
+    this.caller = caller;
+    this.callee = callee;
+    this.history = createHistoryManager(200);
+    const sttProviderName = deps.agent.stt?.provider || (deps.agent.deepgramKey ? "deepgram" : void 0);
+    const ttsProviderName = deps.agent.tts?.provider === "elevenlabs" ? "elevenlabs" : deps.agent.tts?.provider === "openai" ? "openai_tts" : deps.agent.elevenlabsKey ? "elevenlabs" : void 0;
+    const providerMode = deps.agent.provider ?? "openai_realtime";
+    this.metricsAcc = new CallMetricsAccumulator({
+      callId: "",
+      providerMode,
+      telephonyProvider: deps.bridge.telephonyProvider,
+      sttProvider: sttProviderName,
+      ttsProvider: ttsProviderName,
+      pricing: deps.pricing
+    });
+    getLogger().info(`WebSocket connection opened (${deps.bridge.label})`);
+  }
+  // ---------------------------------------------------------------------------
+  // Public: called by the provider-specific parsers in server.ts
+  // ---------------------------------------------------------------------------
+  /**
+   * Handle the call-start event.
+   *
+   * @param callId       Call SID (Twilio) or call_control_id (Telnyx)
+   * @param customParams TwiML custom parameters (Twilio only, empty for Telnyx)
+   */
+  async handleCallStart(callId, customParams = {}) {
+    this.callId = callId;
+    this.metricsAcc.callId = callId;
+    if (customParams.caller && !this.caller) this.caller = customParams.caller;
+    if (customParams.callee && !this.callee) this.callee = customParams.callee;
+    getLogger().info(`Call started: ${callId}`);
+    if (Object.keys(customParams).length > 0) {
+      getLogger().info(`Custom params: ${sanitizeLogValue(JSON.stringify(customParams))}`);
+    }
+    this.deps.metricsStore.recordCallStart({
+      call_id: callId,
+      caller: this.caller,
+      callee: this.callee,
+      direction: "inbound"
+    });
+    const MAX_CALL_DURATION_MS = 60 * 60 * 1e3;
+    this.maxDurationTimer = setTimeout(async () => {
+      getLogger().warn(`Call ${callId} hit max duration (${MAX_CALL_DURATION_MS / 6e4}min), terminating`);
+      try {
+        await this.deps.bridge.endCall(callId, this.ws);
+      } catch {
+      }
+    }, MAX_CALL_DURATION_MS);
+    try {
+      const { notifyDashboard } = await import("./persistence-CYIGNHSU.mjs");
+      notifyDashboard({
+        call_id: callId,
+        caller: this.caller,
+        callee: this.callee,
+        direction: "inbound"
+      });
+    } catch {
+    }
+    if (this.deps.onCallStart) {
+      await this.deps.onCallStart({
+        call_id: callId,
+        caller: this.caller,
+        callee: this.callee,
+        direction: "inbound",
+        ...Object.keys(customParams).length > 0 ? { custom_params: customParams } : {}
+      });
+    }
+    if (this.deps.recording && this.deps.config.twilioSid && this.deps.config.twilioToken && callId) {
+      if (!validateTwilioSid(callId)) {
+        getLogger().warn(`Recording skipped: invalid Twilio CallSid format ${JSON.stringify(callId)}`);
+      } else {
+        try {
+          const recUrl = `https://api.twilio.com/2010-04-01/Accounts/${this.deps.config.twilioSid}/Calls/${callId}/Recordings.json`;
+          const recResp = await fetch(recUrl, {
+            method: "POST",
+            headers: {
+              "Authorization": `Basic ${Buffer.from(`${this.deps.config.twilioSid}:${this.deps.config.twilioToken}`).toString("base64")}`
+            }
+          });
+          if (recResp.ok) {
+            getLogger().info(`Recording started for ${callId}`);
+          } else {
+            getLogger().warn(`could not start recording: ${await recResp.text()}`);
+          }
+        } catch (e) {
+          getLogger().warn(`could not start recording: ${String(e)}`);
+        }
+      }
+    }
+    const agentVars = this.deps.sanitizeVariables(this.deps.agent.variables ?? {});
+    const safeCustomParams = this.deps.sanitizeVariables(customParams);
+    const allVars = { ...agentVars, ...safeCustomParams };
+    const resolvedPrompt = Object.keys(allVars).length > 0 ? this.deps.resolveVariables(this.deps.agent.systemPrompt, allVars) : this.deps.agent.systemPrompt;
+    const provider = this.deps.agent.provider ?? "openai_realtime";
+    if (provider === "pipeline") {
+      await this.initPipeline(resolvedPrompt);
+    } else {
+      await this.initRealtimeAdapter(resolvedPrompt);
+    }
+  }
+  /** Set the stream SID (Twilio only, called after parsing 'start' event). */
+  setStreamSid(sid) {
+    this.streamSid = sid;
+  }
+  /** Handle an incoming audio chunk (already decoded from base64). */
+  handleAudio(audioBuffer) {
+    const provider = this.deps.agent.provider ?? "openai_realtime";
+    if (provider === "pipeline" && this.stt && !this.isSpeaking) {
+      if (this.deps.bridge.telephonyProvider === "twilio") {
+        const pcm8k = mulawToPcm16(audioBuffer);
+        const pcm16k = resample8kTo16k(pcm8k);
+        this.stt.sendAudio(pcm16k);
+      } else {
+        this.stt.sendAudio(audioBuffer);
+      }
+    } else if (this.adapter) {
+      if (this.adapter instanceof ElevenLabsConvAIAdapter && this.deps.bridge.telephonyProvider === "twilio") {
+        const pcm8k = mulawToPcm16(audioBuffer);
+        const pcm16k = resample8kTo16k(pcm8k);
+        this.adapter.sendAudio(pcm16k);
+      } else {
+        this.adapter.sendAudio(audioBuffer);
+      }
+    }
+  }
+  /** Handle a DTMF keypress event (Twilio only). */
+  async handleDtmf(digit) {
+    getLogger().info(`DTMF: ${digit}`);
+    if (this.adapter instanceof OpenAIRealtimeAdapter) {
+      await this.adapter.sendText(`The user pressed key ${digit} on their phone keypad.`);
+    }
+    if (this.deps.onTranscript) {
+      await this.deps.onTranscript({ role: "user", text: `[DTMF: ${digit}]`, call_id: this.callId });
+    }
+  }
+  /** Handle call stop / stream end. */
+  async handleStop() {
+    await this.closeSttOnce();
+    try {
+      this.adapter?.close();
+    } catch {
+    }
+    await this.fireCallEnd();
+  }
+  /** Handle WebSocket close event. */
+  async handleWsClose() {
+    await this.closeSttOnce();
+    try {
+      this.adapter?.close();
+    } catch {
+    }
+    await this.fireCallEnd();
+    try {
+      await this.deps.bridge.endCall(this.callId, this.ws);
+    } catch {
+    }
+  }
+  /** Close STT at most once; swallow errors. */
+  async closeSttOnce() {
+    if (this.sttClosed) return;
+    this.sttClosed = true;
+    try {
+      await this.stt?.close();
+    } catch {
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private: Audio encoding for pipeline mode
+  // ---------------------------------------------------------------------------
+  /**
+   * Encode a PCM 16kHz audio chunk for the telephony provider.
+   * Twilio requires mulaw 8kHz; Telnyx accepts PCM 16kHz natively.
+   */
+  encodePipelineAudio(pcm16k) {
+    if (this.deps.bridge.telephonyProvider === "twilio") {
+      const pcm8k = resample16kTo8k(pcm16k);
+      const mulaw = pcm16ToMulaw(pcm8k);
+      return mulaw.toString("base64");
+    }
+    return pcm16k.toString("base64");
+  }
+  // ---------------------------------------------------------------------------
+  // Private: Pipeline mode
+  // ---------------------------------------------------------------------------
+  async initPipeline(resolvedPrompt) {
+    const label = this.deps.bridge.label;
+    this.stt = this.deps.bridge.createStt(this.deps.agent);
+    if (this.deps.agent.tts) {
+      if (this.deps.agent.tts.provider === "elevenlabs") {
+        this.tts = new ElevenLabsTTS(this.deps.agent.tts.apiKey, this.deps.agent.tts.voice ?? "21m00Tcm4TlvDq8ikWAM");
+      }
+      if (this.deps.agent.tts.provider === "openai") {
+        this.tts = new OpenAITTS(this.deps.agent.tts.apiKey, this.deps.agent.tts.voice ?? "alloy");
+      }
+    } else if (this.deps.agent.elevenlabsKey) {
+      const voiceId = this.deps.agent.voice && this.deps.agent.voice !== "alloy" ? this.deps.agent.voice : "21m00Tcm4TlvDq8ikWAM";
+      this.tts = new ElevenLabsTTS(this.deps.agent.elevenlabsKey, voiceId);
+    }
+    if (!this.stt) {
+      getLogger().info(`Pipeline mode (${label}): no STT configured`);
+    }
+    if (!this.tts) {
+      getLogger().info(`Pipeline mode (${label}): no TTS configured`);
+    }
+    try {
+      if (this.stt) await this.stt.connect();
+      getLogger().info(`Pipeline mode (${label}): STT + TTS connected`);
+    } catch (e) {
+      getLogger().error(`Pipeline connect FAILED (${label}):`, e);
+      try {
+        await this.deps.bridge.endCall(this.callId, this.ws);
+      } catch {
+      }
+      return;
+    }
+    if (this.deps.agent.firstMessage && !this.deps.onMessage && this.tts) {
+      this.metricsAcc.startTurn();
+      let firstChunkSent = false;
+      try {
+        for await (const chunk of this.tts.synthesizeStream(this.deps.agent.firstMessage)) {
+          if (!firstChunkSent) {
+            firstChunkSent = true;
+            this.metricsAcc.recordTtsFirstByte();
+          }
+          const encoded = this.encodePipelineAudio(chunk);
+          this.deps.bridge.sendAudio(this.ws, encoded, this.streamSid);
+        }
+      } catch (e) {
+        getLogger().error(`First message TTS error (${label}):`, e);
+      }
+      if (firstChunkSent) {
+        const turn = this.metricsAcc.recordTurnComplete(this.deps.agent.firstMessage);
+        if (turn) {
+          this.deps.metricsStore.recordTurn({ call_id: this.callId, turn });
+          if (this.deps.onMetrics) await this.deps.onMetrics({ call_id: this.callId, turn });
+        }
+        this.history.push({ role: "assistant", text: this.deps.agent.firstMessage, timestamp: Date.now() });
+      }
+    }
+    if (!this.deps.onMessage && this.deps.config.openaiKey) {
+      let llmModel = this.deps.agent.model || "gpt-4o-mini";
+      if (llmModel.includes("realtime")) llmModel = "gpt-4o-mini";
+      this.llmLoop = new LLMLoop(
+        this.deps.config.openaiKey,
+        llmModel,
+        resolvedPrompt,
+        this.deps.agent.tools
+      );
+      getLogger().info(`Built-in LLM loop active (pipeline, ${label})`);
+    }
+    if (this.stt) {
+      this.stt.onTranscript(async (transcript) => {
+        await this.handleTranscript(transcript);
+      });
+    }
+  }
+  /** Build a HookContext for the current call state. */
+  buildHookContext() {
+    return {
+      callId: this.callId,
+      caller: this.caller,
+      callee: this.callee,
+      history: [...this.history.entries]
+    };
+  }
+  /** Synthesize a single sentence through TTS with hooks, sending audio to telephony. */
+  async synthesizeSentence(sentence, hookExecutor, hookCtx, ttsFirstByteSent) {
+    if (!this.tts || !this.isSpeaking) return;
+    let transformed = sentence;
+    const transforms = this.deps.agent.textTransforms;
+    if (transforms) {
+      for (const fn of transforms) {
+        transformed = fn(transformed);
+      }
+    }
+    const processedText = await hookExecutor.runBeforeSynthesize(transformed, hookCtx);
+    if (processedText === null) return;
+    try {
+      for await (const chunk of this.tts.synthesizeStream(processedText)) {
+        if (!this.isSpeaking) break;
+        const processedAudio = await hookExecutor.runAfterSynthesize(chunk, processedText, hookCtx);
+        if (processedAudio === null) continue;
+        if (!ttsFirstByteSent.value) {
+          ttsFirstByteSent.value = true;
+          this.metricsAcc.recordTtsFirstByte();
+        }
+        const encoded = this.encodePipelineAudio(processedAudio);
+        this.deps.bridge.sendAudio(this.ws, encoded, this.streamSid);
+      }
+    } catch (e) {
+      getLogger().error(`TTS streaming error (${this.deps.bridge.label}):`, e);
+    }
+  }
+  /** Handle a final transcript from STT in pipeline mode. */
+  async handleTranscript(transcript) {
+    this.transcriptQueue.push(transcript);
+    if (this.transcriptProcessing) return;
+    this.transcriptProcessing = true;
+    try {
+      while (this.transcriptQueue.length > 0) {
+        const next = this.transcriptQueue.shift();
+        await this.processTranscript(next);
+      }
+    } finally {
+      this.transcriptProcessing = false;
+    }
+  }
+  async processTranscript(transcript) {
+    if (!transcript.isFinal || !transcript.text) return;
+    const label = this.deps.bridge.label;
+    getLogger().info(`User (${label} pipeline): ${sanitizeLogValue(transcript.text)}`);
+    this.metricsAcc.startTurn();
+    this.metricsAcc.recordSttComplete(transcript.text);
+    if (this.deps.onTranscript) {
+      await this.deps.onTranscript({
+        role: "user",
+        text: transcript.text,
+        call_id: this.callId,
+        history: [...this.history.entries]
+      });
+    }
+    const hookExecutor = new PipelineHookExecutor(this.deps.agent.hooks);
+    const hookCtx = this.buildHookContext();
+    const filteredTranscript = await hookExecutor.runAfterTranscribe(transcript.text, hookCtx);
+    if (filteredTranscript === null) {
+      getLogger().info(`afterTranscribe hook vetoed turn (${label})`);
+      this.metricsAcc.recordTurnInterrupted();
+      return;
+    }
+    this.history.push({ role: "user", text: filteredTranscript, timestamp: Date.now() });
+    let responseText = "";
+    if (this.deps.onMessage && typeof this.deps.onMessage === "function") {
+      try {
+        responseText = await this.deps.onMessage({
+          text: filteredTranscript,
+          call_id: this.callId,
+          caller: this.caller,
+          callee: this.callee,
+          history: [...this.history.entries]
+        });
+      } catch (e) {
+        getLogger().error(`onMessage error (${label}):`, e);
+        return;
+      }
+      if (!responseText) {
+        getLogger().warn(
+          `onMessage returned empty/void (${label}) \u2014 no TTS will play. If you intended to observe transcripts, use onTranscript instead; if you meant to answer via the built-in LLM, remove onMessage and pass openaiKey.`
+        );
+      }
+    } else if (this.deps.onMessage && isRemoteUrl(this.deps.onMessage)) {
+      const msgData = {
+        text: filteredTranscript,
+        call_id: this.callId,
+        caller: this.caller,
+        callee: this.callee,
+        history: [...this.history.entries]
+      };
+      if (isWebSocketUrl(this.deps.onMessage)) {
+        await this.handleWebSocketResponse(msgData);
+        return;
+      } else {
+        try {
+          responseText = await this.deps.remoteHandler.callWebhook(this.deps.onMessage, msgData);
+        } catch (e) {
+          getLogger().error(`Webhook remote error (${label}):`, e);
+          return;
+        }
+      }
+    } else if (this.llmLoop) {
+      const callCtx = { call_id: this.callId, caller: this.caller, callee: this.callee };
+      const chunker = new SentenceChunker();
+      const allParts = [];
+      const ttsFirstByteSent = { value: false };
+      this.isSpeaking = true;
+      let llmError = false;
+      try {
+        try {
+          for await (const token of this.llmLoop.run(filteredTranscript, this.history.entries, callCtx)) {
+            allParts.push(token);
+            const sentences = chunker.push(token);
+            for (const sentence of sentences) {
+              if (!this.isSpeaking) break;
+              const guard = checkGuardrails(sentence, this.deps.agent.guardrails);
+              const sentenceText = guard ? guard.replacement ?? "I'm sorry, I can't respond to that." : sentence;
+              await this.synthesizeSentence(sentenceText, hookExecutor, hookCtx, ttsFirstByteSent);
+            }
+            if (!this.isSpeaking) break;
+          }
+        } catch (e) {
+          llmError = true;
+          chunker.reset();
+          getLogger().error(`LLM loop error (${label}):`, e);
+        }
+        this.metricsAcc.recordLlmComplete();
+        if (!llmError && this.isSpeaking) {
+          for (const sentence of chunker.flush()) {
+            if (!this.isSpeaking) break;
+            const guard = checkGuardrails(sentence, this.deps.agent.guardrails);
+            const sentenceText = guard ? guard.replacement ?? "I'm sorry, I can't respond to that." : sentence;
+            await this.synthesizeSentence(sentenceText, hookExecutor, hookCtx, ttsFirstByteSent);
+          }
+        }
+      } finally {
+        this.isSpeaking = false;
+      }
+      responseText = allParts.join("");
+    } else {
+      return;
+    }
+    if (!responseText) return;
+    if (!this.llmLoop) {
+      const guard = checkGuardrails(responseText, this.deps.agent.guardrails);
+      if (guard) {
+        getLogger().info(`Guardrail '${guard.name}' triggered (pipeline)`);
+        responseText = guard.replacement ?? "I'm sorry, I can't respond to that.";
+      }
+      this.metricsAcc.recordLlmComplete();
+      this.history.push({ role: "assistant", text: responseText, timestamp: Date.now() });
+      const chunker = new SentenceChunker();
+      const sentences = [...chunker.push(responseText), ...chunker.flush()];
+      const ttsFirstByteSent = { value: false };
+      let interrupted = false;
+      this.isSpeaking = true;
+      try {
+        for (const sentence of sentences) {
+          if (!this.isSpeaking) {
+            interrupted = true;
+            break;
+          }
+          await this.synthesizeSentence(sentence, hookExecutor, hookCtx, ttsFirstByteSent);
+        }
+      } finally {
+        this.isSpeaking = false;
+      }
+      if (!interrupted) {
+        this.metricsAcc.recordTtsComplete(responseText);
+      }
+    } else {
+      this.history.push({ role: "assistant", text: responseText, timestamp: Date.now() });
+      this.metricsAcc.recordTtsComplete(responseText);
+    }
+    const turn = this.metricsAcc.recordTurnComplete(responseText);
+    if (turn) {
+      this.deps.metricsStore.recordTurn({ call_id: this.callId, turn });
+      if (this.deps.onMetrics) await this.deps.onMetrics({ call_id: this.callId, turn });
+    }
+  }
+  /** Handle streaming WebSocket remote response with TTS. */
+  async handleWebSocketResponse(msgData) {
+    const onMessage = this.deps.onMessage;
+    const parts = [];
+    this.metricsAcc.recordLlmComplete();
+    this.isSpeaking = true;
+    let wsTtsStarted = false;
+    try {
+      for await (const chunk of this.deps.remoteHandler.callWebSocket(onMessage, msgData)) {
+        parts.push(chunk);
+        if (this.tts) {
+          for await (const audioChunk of this.tts.synthesizeStream(chunk)) {
+            if (!this.isSpeaking) break;
+            if (!wsTtsStarted) {
+              wsTtsStarted = true;
+              this.metricsAcc.recordTtsFirstByte();
+            }
+            const encoded = this.encodePipelineAudio(audioChunk);
+            this.deps.bridge.sendAudio(this.ws, encoded, this.streamSid);
+          }
+        }
+      }
+    } catch (e) {
+      getLogger().error(`WebSocket remote error (${this.deps.bridge.label}):`, e);
+    } finally {
+      this.isSpeaking = false;
+    }
+    const responseText = parts.join("");
+    this.metricsAcc.recordTtsComplete(responseText);
+    const turn = this.metricsAcc.recordTurnComplete(responseText);
+    if (turn) {
+      this.deps.metricsStore.recordTurn({ call_id: this.callId, turn });
+      if (this.deps.onMetrics) await this.deps.onMetrics({ call_id: this.callId, turn });
+    }
+    if (responseText) this.history.push({ role: "assistant", text: responseText, timestamp: Date.now() });
+  }
+  // ---------------------------------------------------------------------------
+  // Private: OpenAI Realtime / ElevenLabs ConvAI mode
+  // ---------------------------------------------------------------------------
+  async initRealtimeAdapter(resolvedPrompt) {
+    const label = this.deps.bridge.label;
+    this.adapter = this.deps.buildAIAdapter(resolvedPrompt);
+    try {
+      await this.adapter.connect();
+      getLogger().info(`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;
+    }
+    if (this.deps.agent.firstMessage) {
+      this.metricsAcc.startTurn();
+      if (this.adapter instanceof OpenAIRealtimeAdapter) {
+        await this.adapter.sendText(this.deps.agent.firstMessage);
+      }
+    }
+    this.adapter.onEvent(async (type, eventData) => {
+      try {
+        await this.handleAdapterEvent(type, eventData);
+      } catch (err) {
+        getLogger().error(`Adapter event handler error (${label}):`, err);
+      }
+    });
+  }
+  async handleAdapterEvent(type, eventData) {
+    if (type === "audio") {
+      if (!this.responseAudioStarted) {
+        this.responseAudioStarted = true;
+        if (this.metricsAcc.turnActive === false) {
+          this.metricsAcc.startTurn();
+        }
+        this.metricsAcc.recordTtsFirstByte();
+      }
+      let outAudio = eventData;
+      if (this.deps.bridge.telephonyProvider === "telnyx") {
+        outAudio = resample8kTo16k(mulawToPcm16(outAudio));
+      }
+      const encoded = outAudio.toString("base64");
+      this.deps.bridge.sendAudio(this.ws, encoded, this.streamSid);
+      this.chunkCount++;
+      this.deps.bridge.sendMark(this.ws, `audio_${this.chunkCount}`, this.streamSid);
+    } else if (type === "transcript_input") {
+      const inputText = eventData;
+      getLogger().info(`User (${this.deps.bridge.label}): ${sanitizeLogValue(inputText)}`);
+      this.history.push({ role: "user", text: inputText, timestamp: Date.now() });
+      this.metricsAcc.startTurn();
+      this.currentAgentText = "";
+      this.responseAudioStarted = false;
+      if (this.deps.onTranscript) {
+        await this.deps.onTranscript({
+          role: "user",
+          text: inputText,
+          call_id: this.callId,
+          history: [...this.history.entries]
+        });
+      }
+    } else if (type === "transcript_output") {
+      const outputText = eventData;
+      if (outputText) {
+        const triggered = checkGuardrails(outputText, this.deps.agent.guardrails);
+        if (triggered) {
+          getLogger().info(`Guardrail '${triggered.name}' triggered`);
+          if (this.adapter instanceof OpenAIRealtimeAdapter) {
+            this.adapter.cancelResponse();
+            await this.adapter.sendText(triggered.replacement ?? "I'm sorry, I can't respond to that.");
+          }
+        }
+        this.currentAgentText += outputText;
+      }
+    } else if (type === "response_done") {
+      const responseData = eventData;
+      if (responseData) {
+        const usage = responseData.usage;
+        if (usage) {
+          this.metricsAcc.recordRealtimeUsage(usage);
+        }
+      }
+      if (this.currentAgentText) {
+        this.history.push({ role: "assistant", text: this.currentAgentText, timestamp: Date.now() });
+        const turn = this.metricsAcc.recordTurnComplete(this.currentAgentText);
+        this.responseAudioStarted = false;
+        if (this.deps.onMetrics) {
+          await this.deps.onMetrics({
+            call_id: this.callId,
+            turn
+          });
+        }
+        this.deps.metricsStore.recordTurn({ call_id: this.callId, turn });
+        this.currentAgentText = "";
+      } else {
+        this.metricsAcc.recordTurnInterrupted();
+        this.responseAudioStarted = false;
+      }
+    } else if (type === "speech_started" || type === "interruption") {
+      this.deps.bridge.sendClear(this.ws, this.streamSid);
+      if (this.adapter instanceof OpenAIRealtimeAdapter) {
+        this.adapter.cancelResponse();
+      }
+      this.metricsAcc.recordTurnInterrupted();
+      this.currentAgentText = "";
+      this.responseAudioStarted = false;
+    } else if (type === "function_call" && this.adapter instanceof OpenAIRealtimeAdapter) {
+      await this.handleFunctionCall(eventData);
+    }
+  }
+  async handleFunctionCall(fc) {
+    const adapter = this.adapter;
+    if (fc.name === "transfer_call") {
+      let transferArgs;
+      try {
+        transferArgs = JSON.parse(fc.arguments || "{}");
+      } catch {
+        transferArgs = {};
+      }
+      const transferTo = transferArgs.number ?? "";
+      if (!isValidE164(transferTo)) {
+        getLogger().warn(`transfer_call rejected (${this.deps.bridge.label}): invalid number ${JSON.stringify(transferTo)}`);
+        await adapter.sendFunctionResult(fc.call_id, JSON.stringify({ error: "Invalid phone number format", status: "rejected" }));
+        return;
+      }
+      getLogger().info(`Transferring call to ${transferTo}`);
+      await adapter.sendFunctionResult(fc.call_id, JSON.stringify({ status: "transferring", to: transferTo }));
+      await this.deps.bridge.transferCall(this.callId, transferTo);
+      if (this.deps.onTranscript) {
+        await this.deps.onTranscript({ role: "system", text: `Call transferred to ${transferTo}`, call_id: this.callId });
+      }
+      return;
+    }
+    if (fc.name === "end_call") {
+      let endArgs;
+      try {
+        endArgs = JSON.parse(fc.arguments || "{}");
+      } catch {
+        endArgs = {};
+      }
+      const reason = endArgs.reason ?? "conversation_complete";
+      getLogger().info(`Ending call (${this.deps.bridge.label}): ${reason}`);
+      await adapter.sendFunctionResult(fc.call_id, JSON.stringify({ status: "ending", reason }));
+      await this.deps.bridge.endCall(this.callId, this.ws);
+      if (this.deps.onTranscript) {
+        await this.deps.onTranscript({ role: "system", text: `Call ended: ${reason}`, call_id: this.callId });
+      }
+      return;
+    }
+    const toolDef = this.deps.agent.tools?.find((t) => t.name === fc.name);
+    if (toolDef?.webhookUrl) {
+      let parsedArgs;
+      try {
+        parsedArgs = JSON.parse(fc.arguments || "{}");
+      } catch {
+        parsedArgs = {};
+      }
+      const result = await executeToolWebhook(
+        toolDef.webhookUrl,
+        fc.name,
+        parsedArgs,
+        { callId: this.callId, caller: this.caller },
+        this.deps.bridge.label === "Twilio" ? "" : this.deps.bridge.label
+      );
+      await adapter.sendFunctionResult(fc.call_id, result);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private: call end / metrics finalization
+  // ---------------------------------------------------------------------------
+  async fireCallEnd() {
+    if (this.callEndFired) return;
+    this.callEndFired = true;
+    if (this.maxDurationTimer) {
+      clearTimeout(this.maxDurationTimer);
+      this.maxDurationTimer = null;
+    }
+    await this.deps.bridge.queryTelephonyCost(this.metricsAcc, this.callId);
+    const deepgramKey = this.deps.agent.deepgramKey;
+    const deepgramRequestId = this.stt?.requestId;
+    if (deepgramKey && deepgramRequestId) {
+      await queryDeepgramCost(this.metricsAcc, deepgramKey, deepgramRequestId);
+    }
+    const finalMetrics = this.metricsAcc.endCall();
+    const callEndData = {
+      call_id: this.callId,
+      caller: this.caller,
+      callee: this.callee,
+      ended_at: Date.now() / 1e3,
+      transcript: [...this.history.entries],
+      metrics: finalMetrics
+    };
+    this.deps.metricsStore.recordCallEnd(
+      callEndData,
+      finalMetrics
+    );
+    try {
+      const { notifyDashboard } = await import("./persistence-CYIGNHSU.mjs");
+      notifyDashboard(callEndData);
+    } catch {
+    }
+    if (this.deps.onCallEnd) {
+      await this.deps.onCallEnd(callEndData);
+    }
+  }
+};
+async function queryDeepgramCost(metricsAcc, deepgramKey, deepgramRequestId) {
+  try {
+    const projResp = await fetch("https://api.deepgram.com/v1/projects", {
+      headers: { "Authorization": `Token ${deepgramKey}` },
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (projResp.ok) {
+      const projData = await projResp.json();
+      const projectId = projData.projects?.[0]?.project_id;
+      if (projectId) {
+        const reqResp = await fetch(
+          `https://api.deepgram.com/v1/projects/${projectId}/requests/${deepgramRequestId}`,
+          {
+            headers: { "Authorization": `Token ${deepgramKey}` },
+            signal: AbortSignal.timeout(5e3)
+          }
+        );
+        if (reqResp.ok) {
+          const reqData = await reqResp.json();
+          const usd = reqData.response?.details?.usd;
+          if (usd != null) {
+            metricsAcc.setActualSttCost(usd);
+            getLogger().info(`Deepgram actual cost: $${usd}`);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+}
+
+// src/server.ts
+var TRANSFER_CALL_TOOL = {
+  name: "transfer_call",
+  description: "Transfer the call to a human agent at the specified phone number",
+  parameters: {
+    type: "object",
+    properties: {
+      number: {
+        type: "string",
+        description: "Phone number to transfer to (E.164 format)"
+      }
+    },
+    required: ["number"]
+  }
+};
+var END_CALL_TOOL = {
+  name: "end_call",
+  description: "End the current phone call. Use when the conversation is complete or the user says goodbye.",
+  parameters: {
+    type: "object",
+    properties: {
+      reason: {
+        type: "string",
+        description: "Reason for ending the call (e.g., 'conversation_complete', 'user_requested', 'no_response')"
+      }
+    }
+  }
+};
+function xmlEscape(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function validateWebhookUrl(url) {
+  const parsed = new URL(url);
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new Error(`Invalid webhook URL scheme: ${parsed.protocol}`);
+  }
+  const hostname = parsed.hostname;
+  const blocked = [
+    /^127\./,
+    /^10\./,
+    /^172\.(1[6-9]|2\d|3[01])\./,
+    /^192\.168\./,
+    /^169\.254\./,
+    /^0\./,
+    /^::1$/,
+    /^localhost$/i,
+    /^metadata\.google\.internal$/i
+  ];
+  if (blocked.some((re) => re.test(hostname))) {
+    throw new Error(`Webhook URL blocked: ${hostname} is a private/internal address`);
+  }
+}
+function validateTelnyxSignature(rawBody, signature, timestamp, publicKey, toleranceSec = 300) {
+  try {
+    const ts = parseInt(timestamp, 10);
+    if (!Number.isFinite(ts)) return false;
+    const ageMs = Date.now() - ts;
+    if (ageMs < 0 || ageMs > toleranceSec * 1e3) return false;
+    const payload = `${timestamp}|${rawBody}`;
+    const keyBuffer = Buffer.from(publicKey, "base64");
+    const sigBuffer = Buffer.from(signature, "base64");
+    const keyObject = crypto3.createPublicKey({
+      key: keyBuffer,
+      format: "der",
+      type: "spki"
+    });
+    return crypto3.verify(null, Buffer.from(payload), keyObject, sigBuffer);
+  } catch {
+    return false;
+  }
+}
+function validateTwilioSid(sid, prefix = "CA") {
+  return sid.length === 34 && sid.startsWith(prefix) && /^[A-Z]{2}[0-9a-f]{32}$/.test(sid);
+}
+function validateTwilioSignature(url, params, signature, authToken) {
+  const data = url + Object.keys(params).sort().reduce((acc, key) => acc + key + (params[key] ?? ""), "");
+  const expected = crypto3.createHmac("sha1", authToken).update(data).digest("base64");
+  try {
+    return crypto3.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+  } catch {
+    return false;
+  }
+}
+function sanitizeVariables(raw) {
+  const BLOCKED_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+  const safe = /* @__PURE__ */ Object.create(null);
+  for (const key of Object.keys(raw)) {
+    if (BLOCKED_KEYS.has(key)) continue;
+    const val = raw[key];
+    safe[key] = typeof val === "string" ? val : String(val ?? "");
+  }
+  return safe;
+}
+function resolveVariables(template, variables) {
+  let result = template;
+  for (const [key, value] of Object.entries(variables)) {
+    result = result.replaceAll(`{${key}}`, value);
+  }
+  return result;
+}
+function buildAIAdapter(config, agent, resolvedPrompt) {
+  if (agent.provider === "elevenlabs_convai") {
+    const key = agent.elevenlabsKey ?? "";
+    return new ElevenLabsConvAIAdapter(
+      key,
+      agent.elevenlabsAgentId ?? "",
+      agent.voice ?? "21m00Tcm4TlvDq8ikWAM",
+      "eleven_turbo_v2_5",
+      agent.language ?? "en",
+      agent.firstMessage ?? ""
+    );
+  }
+  const agentTools = agent.tools?.map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: t.parameters
+  })) ?? [];
+  const tools = [...agentTools, TRANSFER_CALL_TOOL, END_CALL_TOOL];
+  return new OpenAIRealtimeAdapter(
+    config.openaiKey ?? "",
+    agent.model,
+    agent.voice,
+    resolvedPrompt ?? agent.systemPrompt,
+    tools
+  );
+}
+var TwilioBridge = class {
+  constructor(config) {
+    this.config = config;
+  }
+  label = "Twilio";
+  telephonyProvider = "twilio";
+  sendAudio(ws, audioBase64, streamSid) {
+    ws.send(JSON.stringify({ event: "media", streamSid, media: { payload: audioBase64 } }));
+  }
+  sendMark(ws, markName, streamSid) {
+    ws.send(JSON.stringify({ event: "mark", streamSid, mark: { name: markName } }));
+  }
+  sendClear(ws, streamSid) {
+    ws.send(JSON.stringify({ event: "clear", streamSid }));
+  }
+  async transferCall(callId, toNumber) {
+    if (this.config.twilioSid && this.config.twilioToken && callId) {
+      if (!validateTwilioSid(callId)) {
+        getLogger().warn(`TwilioBridge.transferCall rejected: invalid CallSid ${JSON.stringify(callId)}`);
+        return;
+      }
+      const transferUrl = `https://api.twilio.com/2010-04-01/Accounts/${this.config.twilioSid}/Calls/${callId}.json`;
+      await fetch(transferUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Authorization": `Basic ${Buffer.from(`${this.config.twilioSid}:${this.config.twilioToken}`).toString("base64")}`
+        },
+        body: new URLSearchParams({ Twiml: `<Response><Dial>${xmlEscape(toNumber)}</Dial></Response>` }).toString()
+      });
+      getLogger().info(`Call transferred to ${toNumber}`);
+    }
+  }
+  async endCall(callId, _ws) {
+    if (this.config.twilioSid && this.config.twilioToken && callId) {
+      if (!validateTwilioSid(callId)) {
+        getLogger().warn(`TwilioBridge.endCall rejected: invalid CallSid ${JSON.stringify(callId)}`);
+        return;
+      }
+      const endUrl = `https://api.twilio.com/2010-04-01/Accounts/${this.config.twilioSid}/Calls/${callId}.json`;
+      await fetch(endUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Authorization": `Basic ${Buffer.from(`${this.config.twilioSid}:${this.config.twilioToken}`).toString("base64")}`
+        },
+        body: new URLSearchParams({ Status: "completed" }).toString()
+      });
+    }
+  }
+  createStt(agent) {
+    if (agent.stt) {
+      if (agent.stt.provider === "deepgram") {
+        return DeepgramSTT.forTwilio(agent.stt.apiKey, agent.stt.language ?? "en");
+      } else if (agent.stt.provider === "whisper") {
+        return WhisperSTT.forTwilio(agent.stt.apiKey, agent.stt.language ?? "en");
+      }
+    } else if (agent.deepgramKey) {
+      return DeepgramSTT.forTwilio(agent.deepgramKey, agent.language ?? "en");
+    }
+    return null;
+  }
+  async queryTelephonyCost(metricsAcc, callId) {
+    if (this.config.twilioSid && this.config.twilioToken && callId) {
+      if (!validateTwilioSid(callId)) {
+        getLogger().warn(`TwilioBridge.queryTelephonyCost rejected: invalid CallSid ${JSON.stringify(callId)}`);
+        return;
+      }
+      try {
+        const resp = await fetch(
+          `https://api.twilio.com/2010-04-01/Accounts/${this.config.twilioSid}/Calls/${callId}.json`,
+          {
+            headers: {
+              "Authorization": `Basic ${Buffer.from(`${this.config.twilioSid}:${this.config.twilioToken}`).toString("base64")}`
+            },
+            signal: AbortSignal.timeout(5e3)
+          }
+        );
+        if (resp.ok) {
+          const data = await resp.json();
+          if (data.price != null) {
+            metricsAcc.setActualTelephonyCost(Math.abs(parseFloat(data.price)));
+            getLogger().info(`Twilio actual cost: $${Math.abs(parseFloat(data.price))}`);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+};
+function isValidTelnyxTransferTarget(target) {
+  if (typeof target !== "string" || !target) return false;
+  if (/^\+[1-9]\d{6,14}$/.test(target)) return true;
+  return /^sips?:[^\s@]+(@[^\s]+)?$/i.test(target);
+}
+var TELNYX_DTMF_ALLOWED = new Set("0123456789*#ABCDabcd");
+var TELNYX_DTMF_DURATION_MS = 250;
+async function sleep(ms) {
+  if (ms <= 0) return;
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+var TelnyxBridge = class {
+  constructor(config) {
+    this.config = config;
+  }
+  label = "Telnyx";
+  telephonyProvider = "telnyx";
+  sendAudio(ws, audioBase64, _streamSid) {
+    ws.send(JSON.stringify({ event_type: "media", payload: { audio: { chunk: audioBase64 } } }));
+  }
+  sendMark(_ws, _markName, _streamSid) {
+  }
+  sendClear(ws, _streamSid) {
+    ws.send(JSON.stringify({ event_type: "media_stop" }));
+  }
+  async transferCall(callId, toNumber) {
+    if (!isValidTelnyxTransferTarget(toNumber)) {
+      getLogger().warn(`TelnyxBridge.transferCall rejected: invalid target ${JSON.stringify(toNumber)}`);
+      return;
+    }
+    const telnyxKey = this.config.telnyxKey ?? "";
+    await fetch(`https://api.telnyx.com/v2/calls/${callId}/actions/transfer`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${telnyxKey}` },
+      body: JSON.stringify({ to: toNumber })
+    });
+    getLogger().info(`Telnyx call transferred to ${toNumber}`);
+  }
+  async sendDtmf(callId, digits, delayMs) {
+    if (!digits) {
+      getLogger().warn("TelnyxBridge.sendDtmf called with empty digits");
+      return;
+    }
+    const telnyxKey = this.config.telnyxKey ?? "";
+    if (!telnyxKey || !callId) {
+      getLogger().warn("TelnyxBridge.sendDtmf skipped: telnyxKey or callId missing");
+      return;
+    }
+    const filtered = Array.from(digits).filter((d) => TELNYX_DTMF_ALLOWED.has(d));
+    if (filtered.length === 0) {
+      getLogger().warn(`TelnyxBridge.sendDtmf: no valid digits in ${JSON.stringify(digits)}`);
+      return;
+    }
+    const duration = Math.max(100, Math.min(500, TELNYX_DTMF_DURATION_MS));
+    for (let i = 0; i < filtered.length; i += 1) {
+      await fetch(`https://api.telnyx.com/v2/calls/${callId}/actions/send_dtmf`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${telnyxKey}` },
+        body: JSON.stringify({ digits: filtered[i], duration_millis: duration })
+      });
+      if (i < filtered.length - 1) {
+        await sleep(delayMs);
+      }
+    }
+    getLogger().info(`Telnyx DTMF sent (${filtered.length} digits, delay=${delayMs}ms)`);
+  }
+  async startRecording(callId) {
+    const telnyxKey = this.config.telnyxKey ?? "";
+    if (!telnyxKey || !callId) return;
+    try {
+      const resp = await fetch(`https://api.telnyx.com/v2/calls/${callId}/actions/record_start`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${telnyxKey}` },
+        body: JSON.stringify({ format: "mp3", channels: "single" })
+      });
+      if (!resp.ok) {
+        getLogger().warn(`Telnyx record_start failed (${resp.status}): ${(await resp.text()).slice(0, 200)}`);
+      } else {
+        getLogger().info("Telnyx recording started");
+      }
+    } catch (e) {
+      getLogger().warn(`Telnyx record_start error: ${String(e)}`);
+    }
+  }
+  async stopRecording(callId) {
+    const telnyxKey = this.config.telnyxKey ?? "";
+    if (!telnyxKey || !callId) return;
+    try {
+      const resp = await fetch(`https://api.telnyx.com/v2/calls/${callId}/actions/record_stop`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${telnyxKey}` },
+        body: JSON.stringify({})
+      });
+      if (!resp.ok) {
+        getLogger().warn(`Telnyx record_stop failed (${resp.status}): ${(await resp.text()).slice(0, 200)}`);
+      } else {
+        getLogger().info("Telnyx recording stopped");
+      }
+    } catch (e) {
+      getLogger().warn(`Telnyx record_stop error: ${String(e)}`);
+    }
+  }
+  async endCall(callId, ws) {
+    const telnyxKey = this.config.telnyxKey ?? "";
+    if (callId && telnyxKey) {
+      try {
+        await fetch(`https://api.telnyx.com/v2/calls/${callId}/actions/hangup`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", "Authorization": `Bearer ${telnyxKey}` },
+          body: JSON.stringify({})
+        });
+      } catch {
+      }
+    }
+    ws.close();
+  }
+  createStt(agent) {
+    if (agent.stt) {
+      if (agent.stt.provider === "deepgram") {
+        return new DeepgramSTT(agent.stt.apiKey, agent.stt.language ?? "en", "nova-3", "linear16", 16e3);
+      } else if (agent.stt.provider === "whisper") {
+        return new WhisperSTT(agent.stt.apiKey, "whisper-1", agent.stt.language ?? "en");
+      }
+    } else if (agent.deepgramKey) {
+      return new DeepgramSTT(agent.deepgramKey, agent.language ?? "en", "nova-3", "linear16", 16e3);
+    }
+    return null;
+  }
+  async queryTelephonyCost(metricsAcc, callId) {
+    if (this.config.telnyxKey && callId) {
+      try {
+        const resp = await fetch(
+          `https://api.telnyx.com/v2/calls/${callId}`,
+          {
+            headers: { "Authorization": `Bearer ${this.config.telnyxKey}` },
+            signal: AbortSignal.timeout(5e3)
+          }
+        );
+        if (resp.ok) {
+          const body = await resp.json();
+          const amount = body.data?.cost?.amount;
+          if (amount != null) {
+            metricsAcc.setActualTelephonyCost(Math.abs(parseFloat(amount)));
+            getLogger().info(`Telnyx actual cost: $${Math.abs(parseFloat(amount))}`);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+};
+var GRACEFUL_SHUTDOWN_TIMEOUT_MS = 1e4;
+var EmbeddedServer = class {
+  constructor(config, agent, onCallStart, onCallEnd, onTranscript, onMessage, recording = false, voicemailMessage = "", onMetrics, pricingOverrides, dashboard = true, dashboardToken = "") {
+    this.config = config;
+    this.agent = agent;
+    this.onCallStart = onCallStart;
+    this.onCallEnd = onCallEnd;
+    this.onTranscript = onTranscript;
+    this.onMessage = onMessage;
+    this.recording = recording;
+    this.voicemailMessage = voicemailMessage;
+    this.onMetrics = onMetrics;
+    this.dashboard = dashboard;
+    this.dashboardToken = dashboardToken;
+    this.metricsStore = new MetricsStore();
+    this.pricing = mergePricing(pricingOverrides);
+  }
+  server = null;
+  wss = null;
+  twilioTokenWarningLogged = false;
+  metricsStore;
+  pricing;
+  remoteHandler = new RemoteMessageHandler();
+  /** Active WebSocket connections tracked for graceful shutdown. */
+  activeConnections = /* @__PURE__ */ new Set();
+  activeCallIds = /* @__PURE__ */ new Map();
+  async start(port = 8e3) {
+    const webhookUrlPattern = /^[a-zA-Z0-9][a-zA-Z0-9.\-]+[a-zA-Z0-9]$/;
+    if (!webhookUrlPattern.test(this.config.webhookUrl)) {
+      throw new Error(`Invalid webhookUrl: must be a hostname with no protocol prefix or path (got: '${this.config.webhookUrl}')`);
+    }
+    const app = express();
+    app.use((req, _res, next) => {
+      if (req.path === "/webhooks/telnyx/voice") {
+        let raw = "";
+        req.setEncoding("utf8");
+        req.on("data", (chunk) => {
+          raw += chunk;
+        });
+        req.on("end", () => {
+          req.rawBody = raw;
+          try {
+            req.body = JSON.parse(raw);
+          } catch {
+            req.body = {};
+          }
+          next();
+        });
+      } else {
+        next();
+      }
+    });
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+    app.get("/health", (_req, res) => {
+      res.json({ status: "ok", mode: "local" });
+    });
+    if (this.dashboard) {
+      if (!this.dashboardToken) {
+        getLogger().warn(
+          "Dashboard is enabled without authentication. Set dashboardToken to protect call data. This is safe for local development but should not be exposed on a public network."
+        );
+      }
+      mountDashboard(app, this.metricsStore, this.dashboardToken);
+      mountApi(app, this.metricsStore, this.dashboardToken);
+      getLogger().info("Dashboard: http://127.0.0.1:" + port + "/");
+    }
+    app.post("/webhooks/twilio/recording", (req, res) => {
+      if (this.config.twilioToken) {
+        const signature = req.headers["x-twilio-signature"] || "";
+        const url = `https://${this.config.webhookUrl}${req.originalUrl}`;
+        const params = req.body ?? {};
+        if (!validateTwilioSignature(url, params, signature, this.config.twilioToken)) {
+          res.status(403).send("Invalid signature");
+          return;
+        }
+      }
+      const body = req.body;
+      const recordingSid = sanitizeLogValue(body["RecordingSid"] ?? "");
+      const recordingUrl = sanitizeLogValue(body["RecordingUrl"] ?? "");
+      const callSid = sanitizeLogValue(body["CallSid"] ?? "");
+      getLogger().info(`Recording ${recordingSid} for call ${callSid}: ${recordingUrl}`);
+      res.status(204).send();
+    });
+    app.post("/webhooks/twilio/amd", async (req, res) => {
+      if (this.config.twilioToken) {
+        const signature = req.headers["x-twilio-signature"] || "";
+        const url = `https://${this.config.webhookUrl}${req.originalUrl}`;
+        const params = req.body ?? {};
+        if (!validateTwilioSignature(url, params, signature, this.config.twilioToken)) {
+          res.status(403).send("Invalid signature");
+          return;
+        }
+      }
+      const body = req.body;
+      const answeredBy = body["AnsweredBy"] ?? "";
+      const callSid = body["CallSid"] ?? "";
+      getLogger().info(`AMD result for ${sanitizeLogValue(callSid)}: ${sanitizeLogValue(answeredBy)}`);
+      if ((answeredBy === "machine_end_beep" || answeredBy === "machine_end_silence") && this.voicemailMessage && this.config.twilioSid && this.config.twilioToken) {
+        if (!validateTwilioSid(callSid)) {
+          getLogger().warn(`AMD webhook rejected: invalid CallSid ${JSON.stringify(sanitizeLogValue(callSid))}`);
+          res.status(400).send("Invalid CallSid");
+          return;
+        }
+        const twiml = `<Response><Say>${xmlEscape(this.voicemailMessage)}</Say><Hangup/></Response>`;
+        try {
+          const vmUrl = `https://api.twilio.com/2010-04-01/Accounts/${this.config.twilioSid}/Calls/${callSid}.json`;
+          const vmResp = await fetch(vmUrl, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/x-www-form-urlencoded",
+              "Authorization": `Basic ${Buffer.from(`${this.config.twilioSid}:${this.config.twilioToken}`).toString("base64")}`
+            },
+            body: new URLSearchParams({ Twiml: twiml }).toString()
+          });
+          if (vmResp.ok) {
+            getLogger().info(`Voicemail dropped for ${sanitizeLogValue(callSid)}`);
+          } else {
+            getLogger().warn(`Could not drop voicemail: ${sanitizeLogValue(await vmResp.text())}`);
+          }
+        } catch (e) {
+          getLogger().warn(`Could not drop voicemail: ${sanitizeLogValue(String(e))}`);
+        }
+      }
+      res.status(204).send();
+    });
+    app.post("/webhooks/twilio/voice", (req, res) => {
+      if (this.config.twilioToken) {
+        const signature = req.headers["x-twilio-signature"] || "";
+        const url = `https://${this.config.webhookUrl}${req.originalUrl}`;
+        const params = req.body ?? {};
+        if (!validateTwilioSignature(url, params, signature, this.config.twilioToken)) {
+          res.status(403).send("Invalid signature");
+          return;
+        }
+      } else if (!this.twilioTokenWarningLogged) {
+        this.twilioTokenWarningLogged = true;
+        getLogger().warn("Twilio webhook signature validation disabled \u2014 set twilioToken for production");
+      }
+      const callSid = req.body.CallSid || "";
+      if (callSid && !validateTwilioSid(callSid)) {
+        getLogger().warn(`Twilio voice webhook rejected: invalid CallSid ${JSON.stringify(callSid)}`);
+        res.status(400).send("Invalid CallSid");
+        return;
+      }
+      const caller = req.body.From || "";
+      const callee = req.body.To || "";
+      const rawStreamUrl = `wss://${this.config.webhookUrl}/ws/stream/${callSid}`;
+      const xmlStreamUrl = xmlEscape(rawStreamUrl);
+      const twiml = `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${xmlStreamUrl}"><Parameter name="caller" value="${xmlEscape(caller)}"/><Parameter name="callee" value="${xmlEscape(callee)}"/></Stream></Connect></Response>`;
+      res.type("text/xml").send(twiml);
+    });
+    app.post("/webhooks/telnyx/voice", (req, res) => {
+      if (this.config.telnyxPublicKey) {
+        const rawBody = req.rawBody ?? "";
+        const signature = req.headers["telnyx-signature-ed25519"] ?? "";
+        const timestamp = req.headers["telnyx-timestamp"] ?? "";
+        if (!signature || !timestamp || !validateTelnyxSignature(rawBody, signature, timestamp, this.config.telnyxPublicKey)) {
+          getLogger().warn("Telnyx webhook rejected: invalid or missing Ed25519 signature");
+          return res.status(403).send("Invalid signature");
+        }
+      } else {
+        getLogger().warn("Telnyx webhook signature verification is disabled. Set telnyxPublicKey in LocalOptions for production use.");
+      }
+      const body = req.body;
+      if (typeof body?.data !== "object" || body.data === null || Array.isArray(body.data)) {
+        return res.status(400).send("Invalid body");
+      }
+      if (typeof body.data.event_type !== "string" || typeof body.data.payload !== "object" || body.data.payload === null) {
+        return res.status(400).send("Invalid body");
+      }
+      const eventType = body?.data?.event_type ?? "";
+      if (eventType === "call.dtmf.received") {
+        const digit = String(body.data?.payload?.digit ?? "").trim();
+        if (digit) {
+          getLogger().info(`Telnyx DTMF received (webhook): ${sanitizeLogValue(digit)}`);
+        }
+        return res.json({ received: true });
+      }
+      if (eventType === "call.recording.saved") {
+        const recordingUrl = body.data?.payload?.recording_urls?.mp3 ?? body.data?.payload?.recording_urls?.wav ?? body.data?.payload?.public_recording_urls?.mp3 ?? "";
+        if (recordingUrl) {
+          getLogger().info(`Telnyx recording saved (webhook): ${sanitizeLogValue(recordingUrl)}`);
+        }
+        return res.json({ received: true });
+      }
+      if (eventType === "call.initiated") {
+        const payload = body?.data?.payload ?? {};
+        const callControlId = payload.call_control_id ?? "";
+        const caller = payload.from ?? "";
+        const callee = payload.to ?? "";
+        const streamUrl = `wss://${this.config.webhookUrl}/ws/stream/${encodeURIComponent(callControlId)}?caller=${encodeURIComponent(caller)}&callee=${encodeURIComponent(callee)}`;
+        const commands = [
+          { command: "answer" },
+          {
+            command: "stream_start",
+            params: {
+              stream_url: streamUrl,
+              stream_track: "both_tracks"
+            }
+          }
+        ];
+        res.json({ commands });
+      } else {
+        res.json({ received: true });
+      }
+    });
+    this.server = createServer(app);
+    this.wss = new WebSocketServer({ noServer: true });
+    const MAX_WS_PER_IP = 10;
+    const wsConnectionsByIp = /* @__PURE__ */ new Map();
+    this.server.on("upgrade", (req, socket, head) => {
+      const remoteIp = (req.socket?.remoteAddress ?? "unknown").replace(/^::ffff:/, "");
+      const currentCount = wsConnectionsByIp.get(remoteIp) ?? 0;
+      if (currentCount >= MAX_WS_PER_IP) {
+        getLogger().warn(`WebSocket upgrade rejected: too many connections from ${remoteIp}`);
+        socket.write("HTTP/1.1 429 Too Many Requests\r\n\r\n");
+        socket.destroy();
+        return;
+      }
+      getLogger().info(`Upgrade request: ${req.url}`);
+      this.wss.handleUpgrade(req, socket, head, (ws) => {
+        wsConnectionsByIp.set(remoteIp, (wsConnectionsByIp.get(remoteIp) ?? 0) + 1);
+        ws.once("close", () => {
+          const count = (wsConnectionsByIp.get(remoteIp) ?? 1) - 1;
+          if (count <= 0) {
+            wsConnectionsByIp.delete(remoteIp);
+          } else {
+            wsConnectionsByIp.set(remoteIp, count);
+          }
+        });
+        this.wss.emit("connection", ws, req);
+      });
+    });
+    this.wss.on("connection", (ws, req) => {
+      const url = new URL(req.url ?? "", `http://localhost`);
+      getLogger().info(`WebSocket connected: ${req.url}`);
+      this.activeConnections.add(ws);
+      ws.once("close", () => {
+        this.activeConnections.delete(ws);
+      });
+      const isTelnyx = this.config.telephonyProvider === "telnyx";
+      if (isTelnyx) {
+        this.handleTelnyxStream(ws, url);
+      } else {
+        this.handleTwilioStream(ws, url);
+      }
+    });
+    await new Promise((resolve) => {
+      this.server.listen(port, "127.0.0.1", () => {
+        getLogger().info(`
+\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551   \u2588\u2588\u2551      \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551   \u2588\u2588\u2551      \u2588\u2588\u2551   \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2551     \u2588\u2588\u2551  \u2588\u2588\u2551   \u2588\u2588\u2551      \u2588\u2588\u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2551
+\u255A\u2550\u255D     \u255A\u2550\u255D  \u255A\u2550\u255D   \u255A\u2550\u255D      \u255A\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D
+
+Connect AI agents to phone numbers in 4 lines of code
+`);
+        getLogger().info(`Server on port ${port}`);
+        getLogger().info(`Webhook: https://${this.config.webhookUrl}`);
+        getLogger().info(`Phone: ${this.config.phoneNumber}`);
+        resolve();
+      });
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Stream handler helpers
+  // ---------------------------------------------------------------------------
+  /** Build the shared StreamHandlerDeps for the current server configuration. */
+  buildStreamHandlerDeps(bridge) {
+    return {
+      config: this.config,
+      agent: this.agent,
+      bridge,
+      metricsStore: this.metricsStore,
+      pricing: this.pricing,
+      remoteHandler: this.remoteHandler,
+      onCallStart: this.onCallStart,
+      onCallEnd: this.onCallEnd,
+      onTranscript: this.onTranscript,
+      onMessage: this.onMessage,
+      onMetrics: this.onMetrics,
+      recording: this.recording,
+      buildAIAdapter: (resolvedPrompt) => buildAIAdapter(this.config, this.agent, resolvedPrompt),
+      sanitizeVariables,
+      resolveVariables
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Twilio WebSocket message parser (thin layer)
+  // ---------------------------------------------------------------------------
+  handleTwilioStream(ws, url) {
+    const caller = url.searchParams.get("caller") ?? "";
+    const callee = url.searchParams.get("callee") ?? "";
+    const bridge = new TwilioBridge(this.config);
+    const handler = new StreamHandler(this.buildStreamHandlerDeps(bridge), ws, caller, callee);
+    ws.on("message", async (raw) => {
+      try {
+        let data;
+        try {
+          data = JSON.parse(raw.toString());
+        } catch (e) {
+          getLogger().error("Failed to parse WS message:", e);
+          return;
+        }
+        const event = data.event;
+        getLogger().info(`WS event: ${event}`);
+        if (event === "start") {
+          handler.setStreamSid(data.streamSid ?? "");
+          const callSid = data.start?.callSid ?? "";
+          const customParameters = data.start?.customParameters ?? {};
+          if (callSid) this.activeCallIds.set(ws, callSid);
+          await handler.handleCallStart(callSid, customParameters);
+        } else if (event === "media") {
+          const payload = data.media?.payload ?? "";
+          handler.handleAudio(Buffer.from(payload, "base64"));
+        } else if (event === "mark") {
+        } else if (event === "dtmf") {
+          const digit = data.dtmf?.digit ?? "";
+          await handler.handleDtmf(digit);
+        } else if (event === "stop") {
+          await handler.handleStop();
+        }
+      } catch (err) {
+        getLogger().error("Stream handler error:", err);
+      }
+    });
+    ws.on("close", async () => {
+      this.activeCallIds.delete(ws);
+      await handler.handleWsClose();
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Telnyx WebSocket message parser (thin layer)
+  // ---------------------------------------------------------------------------
+  handleTelnyxStream(ws, url) {
+    const caller = url.searchParams.get("caller") ?? "";
+    const callee = url.searchParams.get("callee") ?? "";
+    const bridge = new TelnyxBridge(this.config);
+    const handler = new StreamHandler(this.buildStreamHandlerDeps(bridge), ws, caller, callee);
+    let streamStarted = false;
+    ws.on("message", async (raw) => {
+      try {
+        let data;
+        try {
+          data = JSON.parse(raw.toString());
+        } catch (e) {
+          getLogger().error("Failed to parse Telnyx WS message:", e);
+          return;
+        }
+        const eventType = data.event_type ?? "";
+        getLogger().info(`Telnyx event: ${eventType}`);
+        if (eventType === "stream_started" && !streamStarted) {
+          streamStarted = true;
+          const callControlId = data.payload?.call_control_id ?? "";
+          if (callControlId) this.activeCallIds.set(ws, callControlId);
+          await handler.handleCallStart(callControlId);
+          if (this.recording) {
+            try {
+              await bridge.startRecording?.(callControlId);
+            } catch (e) {
+              getLogger().warn(`Could not start recording: ${String(e)}`);
+            }
+          }
+        } else if (eventType === "media") {
+          const audioChunk = data.payload?.audio?.chunk ?? "";
+          if (!audioChunk) return;
+          handler.handleAudio(Buffer.from(audioChunk, "base64"));
+        } else if (eventType === "call.dtmf.received") {
+          const digit = String(data.payload?.digit ?? "").trim();
+          if (digit) {
+            getLogger().info(`Telnyx DTMF received: ${digit}`);
+            await handler.handleDtmf(digit);
+          }
+        } else if (eventType === "call.recording.saved") {
+          const recordingUrl = data.payload?.recording_urls?.mp3 ?? data.payload?.recording_urls?.wav ?? data.payload?.public_recording_urls?.mp3 ?? "";
+          if (recordingUrl) {
+            getLogger().info(`Telnyx recording saved: ${recordingUrl}`);
+          }
+        } else if (eventType === "stream_stopped") {
+          await handler.handleStop();
+        }
+      } catch (err) {
+        getLogger().error("Stream handler error (Telnyx):", err);
+      }
+    });
+    ws.on("close", async () => {
+      await handler.handleWsClose();
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Graceful shutdown
+  // ---------------------------------------------------------------------------
+  /**
+   * Gracefully stop the server.
+   *
+   * 1. Stop accepting new connections (close the HTTP server).
+   * 2. Send close to all active WebSockets.
+   * 3. Wait up to 10 seconds for active calls to finish.
+   * 4. Force-close remaining connections.
+   * 5. Close the HTTP server.
+   */
+  async stop() {
+    if (!this.server) return;
+    const httpClosePromise = new Promise((resolve) => {
+      this.server.close(() => resolve());
+    });
+    const isTelnyx = this.config.telephonyProvider === "telnyx";
+    for (const [ws, callId] of this.activeCallIds) {
+      try {
+        const bridge = isTelnyx ? new TelnyxBridge(this.config) : new TwilioBridge(this.config);
+        await bridge.endCall(callId, ws);
+      } catch {
+      }
+    }
+    this.activeCallIds.clear();
+    for (const ws of this.activeConnections) {
+      try {
+        ws.close(1001, "Server shutting down");
+      } catch {
+      }
+    }
+    if (this.activeConnections.size > 0) {
+      getLogger().info(`Waiting for ${this.activeConnections.size} active connection(s) to close...`);
+      await Promise.race([
+        new Promise((resolve) => {
+          const checkInterval = setInterval(() => {
+            if (this.activeConnections.size === 0) {
+              clearInterval(checkInterval);
+              resolve();
+            }
+          }, 100);
+        }),
+        new Promise((resolve) => setTimeout(resolve, GRACEFUL_SHUTDOWN_TIMEOUT_MS))
+      ]);
+    }
+    if (this.activeConnections.size > 0) {
+      getLogger().info(`Force-closing ${this.activeConnections.size} remaining connection(s)`);
+      for (const ws of this.activeConnections) {
+        try {
+          ws.terminate();
+        } catch {
+        }
+      }
+      this.activeConnections.clear();
+    }
+    await httpClosePromise;
+    this.server = null;
+    this.wss = null;
+  }
+};
+
+// src/llm-loop.ts
+var OpenAILLMProvider = class {
+  apiKey;
+  model;
+  constructor(apiKey, model) {
+    this.apiKey = apiKey;
+    this.model = model;
+  }
+  async *stream(messages, tools) {
+    const body = {
+      model: this.model,
+      messages,
+      stream: true
+    };
+    if (tools) {
+      body.tools = tools;
+    }
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      getLogger().error(`LLM API error: ${response.status} ${errText}`);
+      return;
+    }
+    const reader = response.body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data: ")) continue;
+        const data = trimmed.slice(6);
+        if (data === "[DONE]") continue;
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        const delta = chunk.choices?.[0]?.delta;
+        if (!delta) continue;
+        if (delta.content) {
+          yield { type: "text", content: delta.content };
+        }
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            yield {
+              type: "tool_call",
+              index: tc.index,
+              id: tc.id,
+              name: tc.function?.name,
+              arguments: tc.function?.arguments
+            };
+          }
+        }
+      }
+    }
+  }
+};
+var LLMLoop = class {
+  provider;
+  systemPrompt;
+  tools;
+  openaiTools;
+  toolMap;
+  constructor(apiKey, model, systemPrompt, tools, llmProvider) {
+    this.provider = llmProvider ?? new OpenAILLMProvider(apiKey, model);
+    this.systemPrompt = systemPrompt;
+    this.tools = tools ?? null;
+    this.toolMap = /* @__PURE__ */ new Map();
+    this.openaiTools = null;
+    if (this.tools && this.tools.length > 0) {
+      this.openaiTools = [];
+      for (const t of this.tools) {
+        this.openaiTools.push({
+          type: "function",
+          function: {
+            name: t.name,
+            description: t.description || "",
+            parameters: t.parameters || { type: "object", properties: {} }
+          }
+        });
+        this.toolMap.set(t.name, t);
+      }
+    }
+  }
+  /**
+   * Stream LLM response tokens, handling tool calls automatically.
+   * Yields text tokens as they arrive from the LLM.
+   */
+  async *run(userText, history, callContext) {
+    const messages = this.buildMessages(history, userText);
+    const maxIterations = 10;
+    for (let iter = 0; iter < maxIterations; iter++) {
+      const toolCallsAccumulated = /* @__PURE__ */ new Map();
+      const textParts = [];
+      let hasToolCalls = false;
+      for await (const chunk of this.provider.stream(messages, this.openaiTools)) {
+        if (chunk.type === "text" && chunk.content) {
+          textParts.push(chunk.content);
+          yield chunk.content;
+        } else if (chunk.type === "tool_call") {
+          hasToolCalls = true;
+          const idx = chunk.index ?? 0;
+          if (!toolCallsAccumulated.has(idx)) {
+            toolCallsAccumulated.set(idx, { id: "", name: "", arguments: "" });
+          }
+          const acc = toolCallsAccumulated.get(idx);
+          if (chunk.id) acc.id = chunk.id;
+          if (chunk.name) acc.name = chunk.name;
+          if (chunk.arguments) acc.arguments += chunk.arguments;
+        }
+      }
+      if (!hasToolCalls) return;
+      const assistantMsg = {
+        role: "assistant",
+        content: textParts.join("") || null,
+        tool_calls: []
+      };
+      const sortedIndices = [...toolCallsAccumulated.keys()].sort((a, b) => a - b);
+      for (const idx of sortedIndices) {
+        const tc = toolCallsAccumulated.get(idx);
+        assistantMsg.tool_calls.push({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: tc.arguments }
+        });
+      }
+      messages.push(assistantMsg);
+      for (const tcData of assistantMsg.tool_calls) {
+        const toolName = tcData.function.name;
+        let args;
+        try {
+          args = JSON.parse(tcData.function.arguments);
+        } catch {
+          args = {};
+        }
+        const result = await this.executeTool(toolName, args, callContext);
+        messages.push({
+          role: "tool",
+          tool_call_id: tcData.id,
+          content: result
+        });
+      }
+    }
+    getLogger().warn(`LLM loop hit max iterations (${maxIterations})`);
+  }
+  async executeTool(toolName, args, callContext) {
+    const toolDef = this.toolMap.get(toolName);
+    if (!toolDef) {
+      return JSON.stringify({ error: `Unknown tool: ${toolName}` });
+    }
+    if (toolDef.handler) {
+      try {
+        return await toolDef.handler(args, callContext);
+      } catch (e) {
+        return JSON.stringify({ error: `Tool handler error: ${String(e)}` });
+      }
+    }
+    if (toolDef.webhookUrl) {
+      try {
+        validateWebhookUrl(toolDef.webhookUrl);
+      } catch (e) {
+        return JSON.stringify({ error: `Tool webhook URL rejected: ${String(e)}` });
+      }
+      for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+          const resp = await fetch(toolDef.webhookUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              tool: toolName,
+              arguments: args,
+              ...callContext,
+              attempt: attempt + 1
+            }),
+            signal: AbortSignal.timeout(1e4)
+          });
+          if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+          const result = JSON.stringify(await resp.json());
+          const MAX_RESPONSE_BYTES2 = 1 * 1024 * 1024;
+          if (result.length > MAX_RESPONSE_BYTES2) {
+            return JSON.stringify({ error: `Webhook response too large: ${result.length} bytes (max ${MAX_RESPONSE_BYTES2})`, fallback: true });
+          }
+          return result;
+        } catch (e) {
+          if (attempt < 2) {
+            await new Promise((r) => setTimeout(r, 500));
+          } else {
+            return JSON.stringify({ error: `Tool failed after 3 attempts: ${String(e)}` });
+          }
+        }
+      }
+    }
+    return JSON.stringify({ error: `No handler or webhookUrl for tool '${toolName}'` });
+  }
+  buildMessages(history, userText) {
+    const messages = [
+      { role: "system", content: this.systemPrompt }
+    ];
+    for (const entry of history) {
+      messages.push({
+        role: entry.role === "assistant" ? "assistant" : "user",
+        content: entry.text
+      });
+    }
+    messages.push({ role: "user", content: userText });
+    return messages;
+  }
+};
+
+// src/test-mode.ts
+var TestSession = class {
+  async run(opts) {
+    const { agent, openaiKey, onMessage, onCallStart, onCallEnd } = opts;
+    const callId = `test_${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+    const caller = "+15550000001";
+    const callee = "+15550000002";
+    const conversationHistory = [];
+    const log = getLogger();
+    log.info("");
+    log.info("=".repeat(60));
+    log.info("  PATTER TEST MODE");
+    log.info("=".repeat(60));
+    log.info(`  Agent: ${agent.model || "default"} / ${agent.voice || "default"}`);
+    log.info(`  Provider: ${agent.provider || "openai_realtime"}`);
+    log.info(`  Call ID: ${callId}`);
+    log.info(`  Caller: ${caller}  ->  Callee: ${callee}`);
+    log.info("-".repeat(60));
+    log.info("  Commands: /quit  /transfer <number>  /hangup  /history");
+    log.info("=".repeat(60));
+    log.info("");
+    if (onCallStart) {
+      await onCallStart({
+        call_id: callId,
+        caller,
+        callee,
+        direction: "test"
+      });
+    }
+    if (agent.firstMessage) {
+      log.info(`  Agent: ${agent.firstMessage}`);
+      log.info("");
+      conversationHistory.push({
+        role: "assistant",
+        text: agent.firstMessage,
+        timestamp: Date.now()
+      });
+    }
+    let llmLoop = null;
+    if (!onMessage && openaiKey) {
+      let llmModel = agent.model || "gpt-4o-mini";
+      if (llmModel.includes("realtime")) llmModel = "gpt-4o-mini";
+      let resolvedPrompt = agent.systemPrompt;
+      if (agent.variables) {
+        for (const [k, v] of Object.entries(agent.variables)) {
+          resolvedPrompt = resolvedPrompt.replaceAll(`{${k}}`, v);
+        }
+      }
+      llmLoop = new LLMLoop(
+        openaiKey,
+        llmModel,
+        resolvedPrompt,
+        agent.tools
+      );
+    }
+    let ended = false;
+    const _callControl = {
+      callId,
+      caller,
+      callee,
+      transfer: async (number) => {
+        ended = true;
+        log.info(`  [Transfer -> ${number}]`);
+      },
+      hangup: async () => {
+        ended = true;
+        log.info("  [Call ended by agent]");
+      },
+      sendDtmf: async (digits, _opts) => {
+        log.info(`  [DTMF -> ${digits}]`);
+      }
+    };
+    void _callControl;
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const askQuestion = (prompt) => new Promise((resolve) => rl.question(prompt, resolve));
+    try {
+      while (!ended) {
+        let userInput;
+        try {
+          userInput = await askQuestion("  You: ");
+        } catch {
+          log.info("\n  [Session ended]");
+          break;
+        }
+        userInput = userInput.trim();
+        if (!userInput) continue;
+        if (userInput === "/quit") {
+          log.info("  [Session ended]");
+          break;
+        } else if (userInput === "/hangup") {
+          log.info("  [You hung up]");
+          break;
+        } else if (userInput.startsWith("/transfer ")) {
+          const number = userInput.slice(10).trim();
+          log.info(`  [Transfer -> ${number}]`);
+          break;
+        } else if (userInput === "/history") {
+          for (const entry of conversationHistory) {
+            const role = entry.role.charAt(0).toUpperCase() + entry.role.slice(1);
+            log.info(`    ${role}: ${entry.text}`);
+          }
+          continue;
+        }
+        conversationHistory.push({
+          role: "user",
+          text: userInput,
+          timestamp: Date.now()
+        });
+        if (onMessage) {
+          try {
+            const responseText = await onMessage({
+              text: userInput,
+              call_id: callId,
+              caller,
+              history: [...conversationHistory]
+            });
+            if (responseText) {
+              log.info(`  Agent: ${responseText}`);
+              conversationHistory.push({
+                role: "assistant",
+                text: responseText,
+                timestamp: Date.now()
+              });
+              log.info("");
+            }
+          } catch (e) {
+            log.error(`  [Error: ${String(e)}]`);
+          }
+        } else if (llmLoop) {
+          const callCtx = { call_id: callId, caller, callee };
+          const parts = [];
+          process.stdout.write("  Agent: ");
+          for await (const token of llmLoop.run(userInput, conversationHistory, callCtx)) {
+            parts.push(token);
+            process.stdout.write(token);
+          }
+          log.info("");
+          const responseText = parts.join("");
+          if (responseText) {
+            conversationHistory.push({
+              role: "assistant",
+              text: responseText,
+              timestamp: Date.now()
+            });
+          }
+          log.info("");
+        } else {
+          log.info("  [No onMessage handler or LLM loop configured]");
+        }
+        if (ended) break;
+      }
+    } finally {
+      rl.close();
+    }
+    if (onCallEnd) {
+      await onCallEnd({
+        call_id: callId,
+        caller,
+        callee,
+        direction: "test",
+        transcript: conversationHistory
+      });
+    }
+  }
+};
+
+export {
+  OpenAIRealtimeAdapter,
+  ElevenLabsConvAIAdapter,
+  DeepgramSTT,
+  WhisperSTT,
+  DEFAULT_PRICING,
+  mergePricing,
+  calculateSttCost,
+  calculateTtsCost,
+  calculateRealtimeCost,
+  calculateTelephonyCost,
+  MetricsStore,
+  makeAuthMiddleware,
+  callsToCsv,
+  callsToJson,
+  mountDashboard,
+  mountApi,
+  RemoteMessageHandler,
+  isRemoteUrl,
+  isWebSocketUrl,
+  ElevenLabsTTS,
+  OpenAITTS,
+  CallMetricsAccumulator,
+  mulawToPcm16,
+  pcm16ToMulaw,
+  resample8kTo16k,
+  resample16kTo8k,
+  resample24kTo16k,
+  OpenAILLMProvider,
+  LLMLoop,
+  DEFAULT_MIN_SENTENCE_LEN,
+  SentenceChunker,
+  PipelineHookExecutor,
+  EmbeddedServer,
+  TestSession
+};