getpatter 0.3.0

package/dist/index.js

@@ -0,0 +1,4287 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/logger.ts
+function getLogger() {
+  return currentLogger;
+}
+function setLogger(logger) {
+  currentLogger = logger;
+}
+var defaultLogger, currentLogger;
+var init_logger = __esm({
+  "src/logger.ts"() {
+    "use strict";
+    defaultLogger = {
+      info: (msg, ...args) => console.log(`[PATTER] ${msg}`, ...args),
+      warn: (msg, ...args) => console.warn(`[PATTER] WARNING: ${msg}`, ...args),
+      error: (msg, ...args) => console.error(`[PATTER] ERROR: ${msg}`, ...args),
+      debug: () => {
+      }
+    };
+    currentLogger = defaultLogger;
+  }
+});
+
+// src/llm-loop.ts
+var OpenAILLMProvider, LLMLoop;
+var init_llm_loop = __esm({
+  "src/llm-loop.ts"() {
+    "use strict";
+    init_logger();
+    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)
+        });
+        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
+                };
+              }
+            }
+          }
+        }
+      }
+    };
+    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) {
+          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 test_mode_exports = {};
+__export(test_mode_exports, {
+  TestSession: () => TestSession
+});
+var import_readline, TestSession;
+var init_test_mode = __esm({
+  "src/test-mode.ts"() {
+    "use strict";
+    import_readline = require("readline");
+    init_llm_loop();
+    init_logger();
+    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]");
+          }
+        };
+        void _callControl;
+        const rl = (0, import_readline.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
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthenticationError: () => AuthenticationError,
+  CallMetricsAccumulator: () => CallMetricsAccumulator,
+  DEFAULT_PRICING: () => DEFAULT_PRICING,
+  DeepgramSTT: () => DeepgramSTT,
+  ElevenLabsConvAIAdapter: () => ElevenLabsConvAIAdapter,
+  ElevenLabsTTS: () => ElevenLabsTTS,
+  LLMLoop: () => LLMLoop,
+  MetricsStore: () => MetricsStore,
+  OpenAILLMProvider: () => OpenAILLMProvider,
+  OpenAIRealtimeAdapter: () => OpenAIRealtimeAdapter,
+  OpenAITTS: () => OpenAITTS,
+  Patter: () => Patter,
+  PatterConnectionError: () => PatterConnectionError,
+  PatterError: () => PatterError,
+  ProvisionError: () => ProvisionError,
+  RemoteMessageHandler: () => RemoteMessageHandler,
+  TestSession: () => TestSession,
+  WhisperSTT: () => WhisperSTT,
+  calculateRealtimeCost: () => calculateRealtimeCost,
+  calculateSttCost: () => calculateSttCost,
+  calculateTelephonyCost: () => calculateTelephonyCost,
+  calculateTtsCost: () => calculateTtsCost,
+  callsToCsv: () => callsToCsv,
+  callsToJson: () => callsToJson,
+  deepgram: () => deepgram,
+  elevenlabs: () => elevenlabs,
+  getLogger: () => getLogger,
+  isRemoteUrl: () => isRemoteUrl,
+  isWebSocketUrl: () => isWebSocketUrl,
+  makeAuthMiddleware: () => makeAuthMiddleware,
+  mergePricing: () => mergePricing,
+  mountApi: () => mountApi,
+  mountDashboard: () => mountDashboard,
+  mulawToPcm16: () => mulawToPcm16,
+  openaiTts: () => openaiTts,
+  pcm16ToMulaw: () => pcm16ToMulaw,
+  resample16kTo8k: () => resample16kTo8k,
+  resample24kTo16k: () => resample24kTo16k,
+  resample8kTo16k: () => resample8kTo16k,
+  setLogger: () => setLogger,
+  whisper: () => whisper
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/connection.ts
+var import_ws = __toESM(require("ws"));
+
+// src/errors.ts
+var PatterError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PatterError";
+  }
+};
+var PatterConnectionError = class extends PatterError {
+  constructor(message) {
+    super(message);
+    this.name = "PatterConnectionError";
+  }
+};
+var AuthenticationError = class extends PatterError {
+  constructor(message) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+};
+var ProvisionError = class extends PatterError {
+  constructor(message) {
+    super(message);
+    this.name = "ProvisionError";
+  }
+};
+
+// src/connection.ts
+init_logger();
+var DEFAULT_BACKEND_URL = "wss://api.getpatter.com";
+var PatterConnection = class {
+  apiKey;
+  backendUrl;
+  wsUrl;
+  ws = null;
+  onMessage = null;
+  onCallStart = null;
+  onCallEnd = null;
+  constructor(apiKey, backendUrl = DEFAULT_BACKEND_URL) {
+    this.apiKey = apiKey;
+    this.backendUrl = backendUrl.replace(/\/+$/, "");
+    this.wsUrl = `${this.backendUrl}/ws/sdk`;
+  }
+  get isConnected() {
+    return this.ws !== null && this.ws.readyState === import_ws.default.OPEN;
+  }
+  async connect(options) {
+    this.onMessage = options.onMessage;
+    this.onCallStart = options.onCallStart ?? null;
+    this.onCallEnd = options.onCallEnd ?? null;
+    return new Promise((resolve, reject) => {
+      this.ws = new import_ws.default(this.wsUrl, {
+        headers: { "X-API-Key": this.apiKey }
+      });
+      this.ws.on("open", () => {
+        this.setupListeners();
+        resolve();
+      });
+      this.ws.on("error", (err) => {
+        reject(new PatterConnectionError(`Failed to connect: ${err.message}`));
+      });
+    });
+  }
+  setupListeners() {
+    if (!this.ws) return;
+    this.ws.on("error", (err) => {
+      getLogger().error(`WebSocket error: ${err.message}`);
+    });
+    this.ws.on("message", async (data) => {
+      const raw = data.toString();
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      const msgType = parsed.type;
+      if (msgType === "message" && this.onMessage) {
+        const msg = {
+          text: parsed.text,
+          callId: parsed.call_id,
+          caller: parsed.caller ?? ""
+        };
+        try {
+          const response = await this.onMessage(msg);
+          if (response != null) {
+            await this.sendResponse(msg.callId, response);
+          }
+        } catch {
+        }
+      } else if (msgType === "call_start" && this.onCallStart) {
+        await this.onCallStart(parsed);
+      } else if (msgType === "call_end" && this.onCallEnd) {
+        await this.onCallEnd(parsed);
+      }
+    });
+    this.ws.on("close", () => {
+      this.ws = null;
+    });
+  }
+  async sendResponse(callId, text) {
+    if (!this.ws) throw new PatterConnectionError("Not connected");
+    this.ws.send(JSON.stringify({ type: "response", call_id: callId, text }));
+  }
+  async requestCall(fromNumber, toNumber, firstMessage = "") {
+    if (!this.ws) throw new PatterConnectionError("Not connected");
+    this.ws.send(
+      JSON.stringify({
+        type: "call",
+        from: fromNumber,
+        to: toNumber,
+        first_message: firstMessage
+      })
+    );
+  }
+  async disconnect() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  parseMessage(raw) {
+    try {
+      const data = JSON.parse(raw);
+      if (data.type !== "message") return null;
+      return {
+        text: data.text,
+        callId: data.call_id,
+        caller: data.caller ?? ""
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/providers.ts
+var STTConfigImpl = class {
+  provider;
+  apiKey;
+  language;
+  constructor(provider, apiKey, language = "en") {
+    this.provider = provider;
+    this.apiKey = apiKey;
+    this.language = language;
+  }
+  toDict() {
+    return { provider: this.provider, api_key: this.apiKey, language: this.language };
+  }
+};
+var TTSConfigImpl = class {
+  provider;
+  apiKey;
+  voice;
+  constructor(provider, apiKey, voice = "alloy") {
+    this.provider = provider;
+    this.apiKey = apiKey;
+    this.voice = voice;
+  }
+  toDict() {
+    return { provider: this.provider, api_key: this.apiKey, voice: this.voice };
+  }
+};
+function deepgram(opts) {
+  return new STTConfigImpl("deepgram", opts.apiKey, opts.language ?? "en");
+}
+function whisper(opts) {
+  return new STTConfigImpl("whisper", opts.apiKey, opts.language ?? "en");
+}
+function elevenlabs(opts) {
+  return new TTSConfigImpl("elevenlabs", opts.apiKey, opts.voice ?? "rachel");
+}
+function openaiTts(opts) {
+  return new TTSConfigImpl("openai", opts.apiKey, opts.voice ?? "alloy");
+}
+
+// src/server.ts
+var import_node_crypto3 = __toESM(require("crypto"));
+var import_express = __toESM(require("express"));
+var import_http = require("http");
+var import_ws5 = require("ws");
+
+// src/providers/openai-realtime.ts
+var import_ws2 = __toESM(require("ws"));
+init_logger();
+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 import_ws2.default(url, {
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "OpenAI-Beta": "realtime=v1"
+      }
+    });
+    await new Promise((resolve, reject) => {
+      let sessionCreated = false;
+      const timer = setTimeout(() => reject(new Error("OpenAI Realtime connect timeout")), 15e3);
+      this.ws.on("message", (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
+            }));
+          }
+          this.ws.send(JSON.stringify({ type: "session.update", session: config }));
+        } else if (msg.type === "session.updated") {
+          clearTimeout(timer);
+          resolve();
+        }
+      });
+      this.ws.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
+  sendAudio(mulawAudio) {
+    if (!this.ws || this.ws.readyState !== import_ws2.default.OPEN) return;
+    this.ws.send(JSON.stringify({ type: "input_audio_buffer.append", audio: mulawAudio.toString("base64") }));
+  }
+  onEvent(callback) {
+    if (!this.ws) return;
+    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") {
+        callback("audio", Buffer.from(data.delta ?? "", "base64"));
+      } else if (t === "response.audio_transcript.delta") {
+        callback("transcript_output", data.delta);
+      } else if (t === "input_audio_buffer.speech_started") {
+        callback("speech_started", null);
+      } else if (t === "conversation.item.input_audio_transcription.completed") {
+        callback("transcript_input", data.transcript);
+      } else if (t === "response.function_call_arguments.done") {
+        callback("function_call", { call_id: data.call_id, name: data.name, arguments: data.arguments });
+      } else if (t === "response.done") {
+        callback("response_done", null);
+      } else if (t === "error") {
+        callback("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
+var import_ws3 = __toESM(require("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 import_ws3.default(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) => {
+      if (!this.eventCallback) return;
+      let parsed;
+      try {
+        parsed = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      const msgType = parsed["type"];
+      if (msgType === "audio") {
+        const audioB64 = parsed["audio"];
+        if (audioB64) {
+          this.eventCallback("audio", Buffer.from(audioB64, "base64"));
+        }
+      } else if (msgType === "user_transcript") {
+        this.eventCallback("transcript_input", parsed["text"] ?? "");
+      } else if (msgType === "agent_response") {
+        this.eventCallback("transcript_output", parsed["text"] ?? "");
+      } else if (msgType === "interruption") {
+        this.eventCallback("interruption", null);
+      } else if (msgType === "error") {
+        this.eventCallback("error", parsed);
+      }
+    });
+  }
+  sendAudio(audioBytes) {
+    if (!this.ws || this.ws.readyState !== import_ws3.default.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
+var import_ws4 = __toESM(require("ws"));
+init_logger();
+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 import_ws4.default(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 !== import_ws4.default.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
+init_logger();
+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;
+  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);
+      void this.transcribeBuffer(pcm);
+    }
+  }
+  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);
+  }
+  close() {
+    this.running = false;
+    if (this.buffer.length >= this.bufferSize / 4) {
+      const pcm = this.buffer;
+      this.buffer = Buffer.alloc(0);
+      void this.transcribeBuffer(pcm);
+    } else {
+      this.buffer = Buffer.alloc(0);
+    }
+  }
+  // ------------------------------------------------------------------
+  // 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
+      });
+      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
+var import_events = require("events");
+var MetricsStore = class extends import_events.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: active?.caller || "",
+      callee: active?.callee || "",
+      direction: active?.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
+var import_node_crypto = __toESM(require("crypto"));
+function timingSafeCompare(a, b) {
+  if (a.length !== b.length) return false;
+  return import_node_crypto.default.timingSafeEqual(Buffer.from(a), Buffer.from(b));
+}
+function makeAuthMiddleware(token = "") {
+  return (req, res, next) => {
+    if (!token) {
+      next();
+      return;
+    }
+    const auth = req.headers.authorization || "";
+    const expected = `Bearer ${token}`;
+    if (auth.length === expected.length && timingSafeCompare(auth, expected)) {
+      next();
+      return;
+    }
+    const queryToken = String(req.query.token ?? "");
+    if (queryToken.length === token.length && 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>
+<style>
+  :root {
+    --bg: #0a0a0f;
+    --surface: #12121a;
+    --surface2: #1a1a26;
+    --border: #2a2a3a;
+    --text: #e4e4ef;
+    --text2: #8888a0;
+    --accent: #6366f1;
+    --accent2: #818cf8;
+    --green: #22c55e;
+    --red: #ef4444;
+    --yellow: #eab308;
+    --blue: #3b82f6;
+    --radius: 8px;
+  }
+  * { margin:0; padding:0; box-sizing:border-box; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, monospace;
+    background: var(--bg); color: var(--text);
+    min-height: 100vh;
+  }
+  header {
+    border-bottom: 1px solid var(--border);
+    padding: 16px 24px;
+    display: flex; align-items: center; gap: 16px;
+  }
+  header h1 { font-size: 18px; font-weight: 600; }
+  header h1 span { color: var(--accent); }
+  header .status {
+    margin-left: auto; font-size: 13px; color: var(--text2);
+    display: flex; align-items: center; gap: 6px;
+  }
+  header .dot {
+    width: 8px; height: 8px; border-radius: 50%;
+    background: var(--green); display: inline-block;
+  }
+  .container { max-width: 1200px; margin: 0 auto; padding: 24px; }
+  .cards {
+    display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 16px; margin-bottom: 24px;
+  }
+  .card {
+    background: var(--surface); border: 1px solid var(--border);
+    border-radius: var(--radius); padding: 16px;
+  }
+  .card .label { font-size: 12px; color: var(--text2); text-transform: uppercase; letter-spacing: 0.5px; }
+  .card .value { font-size: 28px; font-weight: 700; margin-top: 4px; }
+  .card .sub { font-size: 12px; color: var(--text2); margin-top: 2px; }
+  .section { margin-bottom: 24px; }
+  .section h2 { font-size: 15px; font-weight: 600; margin-bottom: 12px; color: var(--text2); }
+  table {
+    width: 100%; border-collapse: collapse;
+    background: var(--surface); border: 1px solid var(--border);
+    border-radius: var(--radius); overflow: hidden;
+  }
+  th { text-align: left; font-size: 11px; text-transform: uppercase;
+    color: var(--text2); padding: 10px 14px; border-bottom: 1px solid var(--border);
+    letter-spacing: 0.5px;
+  }
+  td { padding: 10px 14px; border-bottom: 1px solid var(--border); font-size: 13px; }
+  tr:last-child td { border-bottom: none; }
+  tr.clickable { cursor: pointer; }
+  tr.clickable:hover { background: var(--surface2); }
+  .badge {
+    display: inline-block; padding: 2px 8px; border-radius: 10px;
+    font-size: 11px; font-weight: 600;
+  }
+  .badge-active { background: rgba(34,197,94,0.15); color: var(--green); }
+  .badge-ended { background: rgba(136,136,160,0.15); color: var(--text2); }
+  .badge-pipeline { background: rgba(99,102,241,0.15); color: var(--accent2); }
+  .badge-realtime { background: rgba(59,130,246,0.15); color: var(--blue); }
+  .cost { color: var(--green); }
+  .latency { color: var(--yellow); }
+  .empty { text-align: center; padding: 40px; color: var(--text2); font-size: 14px; }
+  .modal-overlay {
+    display: none; position: fixed; inset: 0;
+    background: rgba(0,0,0,0.7); z-index: 100;
+    justify-content: center; align-items: flex-start;
+    padding: 60px 20px; overflow-y: auto;
+  }
+  .modal-overlay.open { display: flex; }
+  .modal {
+    background: var(--surface); border: 1px solid var(--border);
+    border-radius: 12px; max-width: 800px; width: 100%;
+    padding: 24px;
+  }
+  .modal-header {
+    display: flex; justify-content: space-between; align-items: center;
+    margin-bottom: 20px;
+  }
+  .modal-header h2 { font-size: 16px; }
+  .modal-close {
+    background: none; border: none; color: var(--text2);
+    font-size: 24px; cursor: pointer;
+  }
+  .modal-close:hover { color: var(--text); }
+  .detail-grid {
+    display: grid; grid-template-columns: 1fr 1fr;
+    gap: 16px; margin-bottom: 20px;
+  }
+  .detail-card {
+    background: var(--surface2); border-radius: var(--radius); padding: 14px;
+  }
+  .detail-card h3 { font-size: 12px; color: var(--text2); text-transform: uppercase; margin-bottom: 8px; }
+  .detail-row { display: flex; justify-content: space-between; font-size: 13px; padding: 3px 0; }
+  .detail-row .k { color: var(--text2); }
+  .transcript-box {
+    background: var(--surface2); border-radius: var(--radius);
+    padding: 14px; max-height: 300px; overflow-y: auto;
+  }
+  .transcript-box .msg { padding: 4px 0; font-size: 13px; }
+  .transcript-box .msg.user .role { color: var(--blue); }
+  .transcript-box .msg.assistant .role { color: var(--accent2); }
+  .transcript-box .role { font-weight: 600; margin-right: 8px; }
+  .turns-table { margin-top: 16px; }
+  .bar-container { display: flex; height: 14px; border-radius: 3px; overflow: hidden; min-width: 120px; }
+  .bar-stt { background: var(--blue); }
+  .bar-llm { background: var(--accent); }
+  .bar-tts { background: var(--yellow); }
+  .nav-tabs {
+    display: flex; gap: 4px; margin-bottom: 16px;
+    border-bottom: 1px solid var(--border); padding-bottom: 0;
+  }
+  .nav-tab {
+    padding: 8px 16px; font-size: 13px; color: var(--text2);
+    cursor: pointer; border: none; background: none;
+    border-bottom: 2px solid transparent; margin-bottom: -1px;
+  }
+  .nav-tab:hover { color: var(--text); }
+  .nav-tab.active { color: var(--accent2); border-bottom-color: var(--accent); }
+  .tab-content { display: none; }
+  .tab-content.active { display: block; }
+</style>
+</head>
+<body>
+<header>
+  <h1><span>Patter</span> Dashboard</h1>
+  <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 id="modal-body"></div>
+  </div>
+</div>
+
+<script>
+const $ = (s) => document.querySelector(s);
+const $$ = (s) => document.querySelectorAll(s);
+
+$$('.nav-tab').forEach(tab => {
+  tab.addEventListener('click', () => {
+    $$('.nav-tab').forEach(t => t.classList.remove('active'));
+    $$('.tab-content').forEach(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 fmt\\$(v) { return v >= 0.01 ? '$'+v.toFixed(4) : v > 0 ? '$'+v.toFixed(6) : '$0.00'; }
+function fmtMs(v) { return v > 0 ? Math.round(v)+'ms' : '-'; }
+function fmtDur(s) {
+  if (!s) 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) : '-'; }
+
+async function fetchJSON(url) {
+  const r = await fetch(url);
+  return r.json();
+}
+
+async function refreshAggregates() {
+  const d = await fetchJSON('/api/dashboard/aggregates');
+  $('#stat-total').textContent = d.total_calls;
+  $('#stat-active').textContent = d.active_calls;
+  $('#stat-cost').textContent = fmt\\$(d.total_cost);
+  const cb = d.cost_breakdown;
+  $('#stat-cost-breakdown').textContent =
+    'STT '+fmt\\$(cb.stt)+' | LLM '+fmt\\$(cb.llm)+' | TTS '+fmt\\$(cb.tts)+' | Tel '+fmt\\$(cb.telephony);
+  $('#stat-duration').textContent = fmtDur(d.avg_duration);
+  $('#stat-latency').textContent = fmtMs(d.avg_latency_ms);
+}
+
+async function refreshCalls() {
+  const calls = await fetchJSON('/api/dashboard/calls?limit=50');
+  const 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(c => {
+    const m = c.metrics || {};
+    const cost = m.cost || {};
+    const lat = m.latency_avg || {};
+    const mode = m.provider_mode || '-';
+    const turns = m.turns ? m.turns.length : 0;
+    const 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">'+fmt\\$(cost.total || 0)+'</td>'+
+      '<td class="latency">'+fmtMs(lat.total_ms || 0)+'</td>'+
+      '<td>'+turns+'</td></tr>';
+  }).join('');
+}
+
+async function refreshActive() {
+  const active = await fetchJSON('/api/dashboard/active');
+  const body = $('#active-body');
+  if (!active.length) {
+    body.innerHTML = '<tr><td colspan="6" class="empty">No active calls</td></tr>';
+    return;
+  }
+  const now = Date.now() / 1000;
+  body.innerHTML = active.map(c => {
+    const dur = c.started_at ? Math.round(now - c.started_at) : 0;
+    const 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>'+fmtDur(dur)+'</td>'+
+      '<td>'+turns+'</td></tr>';
+  }).join('');
+}
+
+async function showCall(callId) {
+  const c = await fetchJSON('/api/dashboard/calls/'+encodeURIComponent(callId));
+  if (c.error) return;
+  const m = c.metrics || {};
+  const cost = m.cost || {};
+  const latAvg = m.latency_avg || {};
+  const latP95 = m.latency_p95 || {};
+  const turns = m.turns || [];
+
+  $('#modal-title').textContent = 'Call '+shortId(c.call_id);
+
+  var html = '<div class="detail-grid">'+
+    '<div class="detail-card">'+
+      '<h3>Overview</h3>'+
+      '<div class="detail-row"><span class="k">Call ID</span><span>'+esc(c.call_id)+'</span></div>'+
+      '<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>'+(esc(c.caller) || '-')+'</span></div>'+
+      '<div class="detail-row"><span class="k">To</span><span>'+(esc(c.callee) || '-')+'</span></div>'+
+      '<div class="detail-row"><span class="k">Duration</span><span>'+fmtDur(m.duration_seconds)+'</span></div>'+
+      '<div class="detail-row"><span class="k">Mode</span><span>'+(esc(m.provider_mode) || '-')+'</span></div>'+
+      '<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 Breakdown</h3>'+
+      '<div class="detail-row"><span class="k">STT</span><span class="cost">'+fmt\\$(cost.stt || 0)+'</span></div>'+
+      '<div class="detail-row"><span class="k">LLM</span><span class="cost">'+fmt\\$(cost.llm || 0)+'</span></div>'+
+      '<div class="detail-row"><span class="k">TTS</span><span class="cost">'+fmt\\$(cost.tts || 0)+'</span></div>'+
+      '<div class="detail-row"><span class="k">Telephony</span><span class="cost">'+fmt\\$(cost.telephony || 0)+'</span></div>'+
+      '<div class="detail-row" style="border-top:1px solid var(--border);padding-top:6px;margin-top:4px">'+
+        '<span class="k" style="font-weight:600">Total</span><span class="cost" style="font-weight:700">'+fmt\\$(cost.total || 0)+'</span>'+
+      '</div>'+
+      '<h3 style="margin-top:14px">Latency (avg / p95)</h3>'+
+      '<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">Total</span><span class="latency" style="font-weight:700">'+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:8px;font-size:11px;color:var(--text2)">'+
+        '<span style="color:var(--blue)">&#9632;</span> STT &nbsp;'+
+        '<span style="color:var(--accent)">&#9632;</span> LLM &nbsp;'+
+        '<span style="color:var(--yellow)">&#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(); });
+
+async function refresh() {
+  try {
+    await Promise.all([refreshAggregates(), refreshCalls(), refreshActive()]);
+    $('#status-text').textContent = 'Listening';
+  } catch (e) {
+    $('#status-text').textContent = 'Connection error';
+  }
+}
+
+refresh();
+
+if (typeof EventSource !== 'undefined') {
+  var tokenParam = new URLSearchParams(window.location.search).get('token');
+  var sseUrl = '/api/dashboard/events' + (tokenParam ? '?' + new URLSearchParams({ token: tokenParam }).toString() : '');
+  var sseBackoff = 1000;
+  var sseFailures = 0;
+  var SSE_MAX_BACKOFF = 30000;
+  var SSE_MAX_FAILURES = 5;
+  var sseTimer = null;
+
+  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 (SSE unavailable)';
+        setInterval(refresh, 5000);
+        return;
+      }
+      $('#status-text').textContent = 'Reconnecting...';
+      sseTimer = setTimeout(function() {
+        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);
+      res.write(`event: ${event.type}
+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
+var import_node_crypto2 = __toESM(require("crypto"));
+init_logger();
+var MAX_RESPONSE_BYTES = 64 * 1024;
+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 import_node_crypto2.default.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) {
+    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) {
+    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: WebSocket5 } = await import("ws");
+    const ws = new WebSocket5(url);
+    const chunks = [];
+    let done = false;
+    let error = null;
+    await new Promise((resolve, reject) => {
+      ws.on("open", () => {
+        ws.send(JSON.stringify(data));
+        resolve();
+      });
+      ws.on("error", (err) => {
+        error = err;
+        reject(err);
+      });
+    });
+    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) resolveNext(null);
+            return;
+          }
+          text = frame.text || null;
+        } else {
+          text = String(frame);
+        }
+      } catch {
+        text = rawStr;
+      }
+      if (text && resolveNext) {
+        resolveNext(text);
+        resolveNext = null;
+      } else if (text) {
+        chunks.push(text);
+      }
+    });
+    ws.on("close", () => {
+      done = true;
+      if (resolveNext) resolveNext(null);
+    });
+    ws.on("error", (err) => {
+      error = err;
+      done = true;
+      if (resolveNext) resolveNext(null);
+    });
+    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;
+  }
+};
+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 })
+    });
+    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 {
+      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"
+      })
+    });
+    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 {
+      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 ----
+  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;
+    }
+    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/stream-handler.ts
+init_llm_loop();
+
+// src/handler-utils.ts
+init_logger();
+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/stream-handler.ts
+init_logger();
+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;
+  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;
+    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"
+    });
+    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) {
+      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) {
+      this.stt.sendAudio(audioBuffer);
+    } else if (this.adapter) {
+      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() {
+    this.stt?.close();
+    this.adapter?.close();
+    await this.fireCallEnd();
+  }
+  /** Handle WebSocket close event. */
+  async handleWsClose() {
+    await this.fireCallEnd();
+    this.stt?.close();
+    this.adapter?.close();
+  }
+  // ---------------------------------------------------------------------------
+  // 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);
+      return;
+    }
+    if (this.deps.agent.firstMessage && !this.deps.onMessage && this.tts) {
+      try {
+        for await (const chunk of this.tts.synthesizeStream(this.deps.agent.firstMessage)) {
+          const encoded = chunk.toString("base64");
+          this.deps.bridge.sendAudio(this.ws, encoded, this.streamSid);
+        }
+      } catch (e) {
+        getLogger().error(`First message TTS error (${label}):`, e);
+      }
+    }
+    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);
+      });
+    }
+  }
+  /** Handle a final transcript from STT in pipeline mode. */
+  async handleTranscript(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);
+    this.history.push({ role: "user", text: transcript.text, timestamp: Date.now() });
+    if (this.deps.onTranscript) {
+      await this.deps.onTranscript({
+        role: "user",
+        text: transcript.text,
+        call_id: this.callId,
+        history: [...this.history.entries]
+      });
+    }
+    let responseText = "";
+    if (this.deps.onMessage && typeof this.deps.onMessage === "function") {
+      try {
+        responseText = await this.deps.onMessage({
+          text: transcript.text,
+          call_id: this.callId,
+          caller: this.caller,
+          history: [...this.history.entries]
+        });
+      } catch (e) {
+        getLogger().error(`onMessage error (${label}):`, e);
+        return;
+      }
+    } else if (this.deps.onMessage && isRemoteUrl(this.deps.onMessage)) {
+      const msgData = {
+        text: transcript.text,
+        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 parts = [];
+      this.metricsAcc.recordLlmComplete();
+      this.isSpeaking = true;
+      try {
+        for await (const token of this.llmLoop.run(transcript.text, this.history.entries, callCtx)) {
+          parts.push(token);
+        }
+      } catch (e) {
+        getLogger().error(`LLM loop error (${label}):`, e);
+      }
+      responseText = parts.join("");
+    } else {
+      return;
+    }
+    if (!responseText) return;
+    this.metricsAcc.recordLlmComplete();
+    this.history.push({ role: "assistant", text: responseText, timestamp: Date.now() });
+    this.isSpeaking = true;
+    this.metricsAcc.recordTtsFirstByte();
+    try {
+      for await (const chunk of this.tts.synthesizeStream(responseText)) {
+        if (!this.isSpeaking) break;
+        const encoded = chunk.toString("base64");
+        this.deps.bridge.sendAudio(this.ws, encoded, this.streamSid);
+      }
+    } catch (e) {
+      getLogger().error(`TTS streaming error (${label}):`, e);
+    } finally {
+      this.isSpeaking = false;
+    }
+    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;
+    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;
+            const encoded = audioChunk.toString("base64");
+            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.recordTtsFirstByte();
+    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);
+      return;
+    }
+    if (this.deps.agent.firstMessage && 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") {
+      const encoded = eventData.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() });
+      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.history.push({ role: "assistant", text: outputText, timestamp: Date.now() });
+      }
+    } else if (type === "speech_started" || type === "interruption") {
+      this.deps.bridge.sendClear(this.ws, this.streamSid);
+      if (this.adapter instanceof OpenAIRealtimeAdapter) {
+        this.adapter.cancelResponse();
+      }
+    } 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;
+    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();
+    this.deps.metricsStore.recordCallEnd(
+      { call_id: this.callId, transcript: [...this.history.entries] },
+      finalMetrics
+    );
+    if (this.deps.onCallEnd) {
+      await this.deps.onCallEnd({
+        call_id: this.callId,
+        transcript: [...this.history.entries],
+        metrics: finalMetrics
+      });
+    }
+  }
+};
+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
+init_logger();
+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 = import_node_crypto3.default.createPublicKey({
+      key: keyBuffer,
+      format: "der",
+      type: "spki"
+    });
+    return import_node_crypto3.default.verify(null, Buffer.from(payload), keyObject, sigBuffer);
+  } catch {
+    return false;
+  }
+}
+function validateTwilioSignature(url, params, signature, authToken) {
+  const data = url + Object.keys(params).sort().reduce((acc, key) => acc + key + (params[key] ?? ""), "");
+  const expected = import_node_crypto3.default.createHmac("sha1", authToken).update(data).digest("base64");
+  try {
+    return import_node_crypto3.default.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) {
+      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) {
+      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) {
+      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 {
+      }
+    }
+  }
+};
+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) {
+    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 endCall(_callId, ws) {
+    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 = false, 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();
+  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 = (0, import_express.default)();
+    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(import_express.default.json());
+    app.use(import_express.default.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 = body["RecordingSid"] ?? "";
+      const recordingUrl = body["RecordingUrl"] ?? "";
+      const callSid = 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 ${callSid}: ${answeredBy}`);
+      if ((answeredBy === "machine_end_beep" || answeredBy === "machine_end_silence") && this.voicemailMessage && this.config.twilioSid && this.config.twilioToken) {
+        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 ${callSid}`);
+          } else {
+            getLogger().warn(`Could not drop voicemail: ${await vmResp.text()}`);
+          }
+        } catch (e) {
+          getLogger().warn(`Could not drop voicemail: ${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 || "";
+      const caller = req.body.From || "";
+      const callee = req.body.To || "";
+      const rawStreamUrl = `wss://${this.config.webhookUrl}/ws/stream/${callSid}?caller=${encodeURIComponent(caller)}&callee=${encodeURIComponent(callee)}`;
+      const xmlStreamUrl = xmlEscape(rawStreamUrl);
+      const twiml = `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${xmlStreamUrl}"/></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.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 = (0, import_http.createServer)(app);
+    this.wss = new import_ws5.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, "0.0.0.0", () => {
+        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 with 10 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 ?? {};
+          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 () => {
+      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 ?? "";
+          await handler.handleCallStart(callControlId);
+        } else if (eventType === "media") {
+          const audioChunk = data.payload?.audio?.chunk ?? "";
+          if (!audioChunk) return;
+          handler.handleAudio(Buffer.from(audioChunk, "base64"));
+        } 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());
+    });
+    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/client.ts
+var DEFAULT_BACKEND_URL2 = "wss://api.getpatter.com";
+var DEFAULT_REST_URL = "https://api.getpatter.com";
+var Patter = class {
+  apiKey;
+  backendUrl;
+  restUrl;
+  connection;
+  mode;
+  localConfig;
+  embeddedServer = null;
+  constructor(options) {
+    if ("mode" in options && options.mode === "local") {
+      const local = options;
+      if (!local.phoneNumber) {
+        throw new Error("Local mode requires phoneNumber");
+      }
+      if (!local.webhookUrl) {
+        throw new Error("Local mode requires webhookUrl (e.g., your ngrok URL)");
+      }
+      if (!local.twilioSid && !local.telnyxKey) {
+        throw new Error("Local mode requires twilioSid or telnyxKey");
+      }
+      if (local.twilioSid && !local.twilioToken) {
+        throw new Error("twilioToken is required when using twilioSid");
+      }
+      this.mode = "local";
+      this.localConfig = options;
+      this.apiKey = "";
+      this.backendUrl = DEFAULT_BACKEND_URL2;
+      this.restUrl = DEFAULT_REST_URL;
+      this.connection = new PatterConnection("", DEFAULT_BACKEND_URL2);
+    } else {
+      const cloudOpts = options;
+      this.mode = "cloud";
+      this.localConfig = null;
+      this.apiKey = cloudOpts.apiKey;
+      this.backendUrl = cloudOpts.backendUrl ?? DEFAULT_BACKEND_URL2;
+      this.restUrl = cloudOpts.restUrl ?? DEFAULT_REST_URL;
+      this.connection = new PatterConnection(this.apiKey, this.backendUrl);
+    }
+  }
+  // === Local mode ===
+  agent(opts) {
+    if (opts.provider) {
+      const valid = ["openai_realtime", "elevenlabs_convai", "pipeline"];
+      if (!valid.includes(opts.provider)) {
+        throw new Error(`provider must be one of: ${valid.join(", ")}. Got: '${opts.provider}'`);
+      }
+    }
+    if (opts.tools) {
+      if (!Array.isArray(opts.tools)) {
+        throw new TypeError("tools must be an array");
+      }
+      opts.tools.forEach((tool, i) => {
+        if (!tool.name) throw new Error(`tools[${i}] missing required 'name' field`);
+        if (!tool.webhookUrl && !tool.handler) throw new Error(`tools[${i}] requires either 'webhookUrl' or 'handler'`);
+      });
+    }
+    if (opts.variables !== void 0 && (typeof opts.variables !== "object" || Array.isArray(opts.variables))) {
+      throw new TypeError("variables must be an object");
+    }
+    return { ...opts };
+  }
+  async serve(opts) {
+    if (this.mode !== "local" || !this.localConfig) {
+      throw new Error("serve() is only available in local mode");
+    }
+    if (!opts.agent || typeof opts.agent !== "object") {
+      throw new TypeError("agent is required. Use phone.agent() to create one.");
+    }
+    if (!opts.agent.systemPrompt && opts.agent.provider !== "pipeline") {
+      throw new Error("agent.systemPrompt is required");
+    }
+    if (opts.port !== void 0) {
+      if (typeof opts.port !== "number" || opts.port < 1 || opts.port > 65535) {
+        throw new RangeError(`port must be between 1 and 65535, got ${opts.port}`);
+      }
+    }
+    const validProviders = ["openai_realtime", "elevenlabs_convai", "pipeline"];
+    if (opts.agent.provider && !validProviders.includes(opts.agent.provider)) {
+      throw new Error(`agent.provider must be one of: ${validProviders.join(", ")}`);
+    }
+    this.embeddedServer = new EmbeddedServer(
+      {
+        twilioSid: this.localConfig.twilioSid,
+        twilioToken: this.localConfig.twilioToken,
+        openaiKey: this.localConfig.openaiKey,
+        phoneNumber: this.localConfig.phoneNumber,
+        webhookUrl: this.localConfig.webhookUrl,
+        telephonyProvider: this.localConfig.telephonyProvider,
+        telnyxKey: this.localConfig.telnyxKey,
+        telnyxConnectionId: this.localConfig.telnyxConnectionId,
+        telnyxPublicKey: this.localConfig.telnyxPublicKey
+      },
+      opts.agent,
+      opts.onCallStart,
+      opts.onCallEnd,
+      opts.onTranscript,
+      opts.onMessage,
+      opts.recording ?? false,
+      opts.voicemailMessage ?? "",
+      opts.onMetrics,
+      opts.pricing,
+      opts.dashboard ?? false,
+      opts.dashboardToken ?? ""
+    );
+    await this.embeddedServer.start(opts.port ?? 8e3);
+  }
+  async test(opts) {
+    if (this.mode !== "local") {
+      throw new Error("test() is only available in local mode");
+    }
+    const { TestSession: TestSession2 } = await Promise.resolve().then(() => (init_test_mode(), test_mode_exports));
+    const session = new TestSession2();
+    await session.run({
+      agent: opts.agent,
+      openaiKey: this.localConfig?.openaiKey,
+      onMessage: typeof opts.onMessage === "function" ? opts.onMessage : void 0,
+      onCallStart: opts.onCallStart,
+      onCallEnd: opts.onCallEnd
+    });
+  }
+  // === Cloud mode legacy ===
+  async connect(options) {
+    if (options.provider && options.providerKey && options.number) {
+      await this.registerNumber(
+        options.provider,
+        options.providerKey,
+        options.number,
+        options.providerSecret,
+        options.country ?? "US",
+        options.stt,
+        options.tts
+      );
+    }
+    await this.connection.connect({
+      onMessage: options.onMessage,
+      onCallStart: options.onCallStart,
+      onCallEnd: options.onCallEnd
+    });
+  }
+  async call(options) {
+    if (this.mode === "local") {
+      const localOpts = options;
+      if (!localOpts.to) {
+        throw new Error("'to' phone number is required");
+      }
+      if (!localOpts.to.startsWith("+")) {
+        throw new Error(`'to' must be in E.164 format (e.g., '+1234567890'). Got: '${localOpts.to}'`);
+      }
+      if (!this.localConfig) {
+        throw new Error("local config missing");
+      }
+      const { phoneNumber, webhookUrl, telephonyProvider } = this.localConfig;
+      if (telephonyProvider === "telnyx") {
+        const telnyxKey = this.localConfig.telnyxKey ?? "";
+        const connectionId = this.localConfig.telnyxConnectionId ?? "";
+        const streamUrl = `wss://${webhookUrl}/ws/stream/${encodeURIComponent(localOpts.to)}?caller=${encodeURIComponent(phoneNumber)}&callee=${encodeURIComponent(localOpts.to)}`;
+        const response2 = await fetch("https://api.telnyx.com/v2/calls", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${telnyxKey}`
+          },
+          body: JSON.stringify({
+            connection_id: connectionId,
+            from: phoneNumber,
+            to: localOpts.to,
+            stream_url: streamUrl,
+            stream_track: "both_tracks"
+          })
+        });
+        if (!response2.ok) {
+          throw new ProvisionError(`Failed to initiate Telnyx call: ${await response2.text()}`);
+        }
+        return;
+      }
+      const twilioSid = this.localConfig.twilioSid ?? "";
+      const twilioToken = this.localConfig.twilioToken ?? "";
+      const statusCallbackUrl = `https://${webhookUrl}/webhooks/twilio/status`;
+      const url = `https://api.twilio.com/2010-04-01/Accounts/${twilioSid}/Calls.json`;
+      const params = new URLSearchParams({
+        To: localOpts.to,
+        From: phoneNumber,
+        Url: `https://${webhookUrl}/webhooks/twilio/voice`,
+        StatusCallback: statusCallbackUrl,
+        StatusCallbackMethod: "POST"
+      });
+      if (localOpts.machineDetection) {
+        params.append("MachineDetection", "DetectMessageEnd");
+        params.append("AsyncAmd", "true");
+        params.append("AsyncAmdStatusCallback", `https://${webhookUrl}/webhooks/twilio/amd`);
+      }
+      if (localOpts.voicemailMessage && this.embeddedServer) {
+        this.embeddedServer.voicemailMessage = localOpts.voicemailMessage;
+      }
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Authorization: `Basic ${Buffer.from(`${twilioSid}:${twilioToken}`).toString("base64")}`
+        },
+        body: params.toString()
+      });
+      if (!response.ok) {
+        throw new ProvisionError(`Failed to initiate call: ${await response.text()}`);
+      }
+      return;
+    }
+    const cloudOpts = options;
+    if (!this.connection.isConnected) {
+      if (cloudOpts.onMessage) {
+        await this.connection.connect({ onMessage: cloudOpts.onMessage });
+      } else {
+        throw new PatterConnectionError(
+          "Not connected. Call connect() first or pass onMessage."
+        );
+      }
+    }
+    await this.connection.requestCall(
+      cloudOpts.fromNumber ?? "",
+      cloudOpts.to,
+      cloudOpts.firstMessage ?? ""
+    );
+  }
+  async disconnect() {
+    await this.connection.disconnect();
+  }
+  // === Agent Management ===
+  async createAgent(opts) {
+    const response = await fetch(`${this.restUrl}/api/agents`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-API-Key": this.apiKey },
+      body: JSON.stringify({
+        name: opts.name,
+        system_prompt: opts.systemPrompt,
+        model: opts.model ?? "gpt-4o-mini-realtime-preview",
+        voice: opts.voice ?? "alloy",
+        voice_provider: opts.voiceProvider ?? "openai",
+        language: opts.language ?? "en",
+        first_message: opts.firstMessage ?? null,
+        tools: opts.tools?.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters, webhook_url: t.webhookUrl })) ?? null
+      })
+    });
+    if (response.status !== 201) throw new ProvisionError(`Failed to create agent: ${await response.text()}`);
+    const data = await response.json();
+    return { id: data.id, name: data.name, systemPrompt: data.system_prompt, model: data.model, voice: data.voice, voiceProvider: data.voice_provider, language: data.language, firstMessage: data.first_message, tools: data.tools };
+  }
+  async listAgents() {
+    const response = await fetch(`${this.restUrl}/api/agents`, { headers: { "X-API-Key": this.apiKey } });
+    if (!response.ok) throw new ProvisionError(`Failed to list agents: ${response.status}`);
+    const data = await response.json();
+    return data.map((a) => ({ id: a.id, name: a.name, systemPrompt: a.system_prompt, model: a.model, voice: a.voice, voiceProvider: a.voice_provider, language: a.language, firstMessage: a.first_message, tools: a.tools }));
+  }
+  async buyNumber(opts = {}) {
+    const response = await fetch(`${this.restUrl}/api/numbers/buy`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-API-Key": this.apiKey },
+      body: JSON.stringify({ country: opts.country ?? "US", provider: opts.provider ?? "twilio" })
+    });
+    if (response.status !== 201) throw new ProvisionError(`Failed to buy number: ${await response.text()}`);
+    const data = await response.json();
+    return { id: data.id, number: data.number, provider: data.provider, country: data.country, status: data.status, agentId: data.agent_id };
+  }
+  async assignAgent(numberId, agentId) {
+    const response = await fetch(`${this.restUrl}/api/phone-numbers/${numberId}/assign-agent`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-API-Key": this.apiKey },
+      body: JSON.stringify({ agent_id: agentId })
+    });
+    if (response.status !== 200) throw new ProvisionError(`Failed to assign agent: ${await response.text()}`);
+  }
+  async listCalls(limit = 50) {
+    if (!Number.isInteger(limit) || limit < 1 || limit > 1e3) {
+      throw new RangeError(`limit must be an integer between 1 and 1000, got ${limit}`);
+    }
+    const response = await fetch(`${this.restUrl}/api/calls?limit=${limit}`, { headers: { "X-API-Key": this.apiKey } });
+    if (!response.ok) throw new ProvisionError(`Failed to list calls: ${response.status}`);
+    const data = await response.json();
+    return data.map((c) => ({ id: c.id, direction: c.direction, caller: c.caller, callee: c.callee, startedAt: c.started_at, endedAt: c.ended_at, durationSeconds: c.duration_seconds, status: c.status, transcript: c.transcript }));
+  }
+  // Provider helpers
+  static deepgram = deepgram;
+  static whisper = whisper;
+  static elevenlabs = elevenlabs;
+  static openaiTts = openaiTts;
+  static guardrail(opts) {
+    return {
+      name: opts.name,
+      blockedTerms: opts.blockedTerms,
+      check: opts.check,
+      replacement: opts.replacement ?? "I'm sorry, I can't respond to that."
+    };
+  }
+  /**
+   * Create a tool definition for use with `agent({ tools: [...] })`.
+   *
+   * Either `handler` (a function) or `webhookUrl` must be provided.
+   *
+   * @param opts.name - Tool name (visible to the LLM).
+   * @param opts.description - What the tool does (visible to the LLM).
+   * @param opts.parameters - JSON Schema for tool arguments.
+   * @param opts.handler - Async function called in-process when the LLM invokes the tool.
+   * @param opts.webhookUrl - URL to POST to when the LLM invokes the tool.
+   *
+   * @example
+   * ```ts
+   * phone.agent({
+   *   systemPrompt: 'You are a pizza bot.',
+   *   tools: [
+   *     Patter.tool({
+   *       name: 'check_menu',
+   *       description: 'Check available menu items',
+   *       handler: async (args) => JSON.stringify({ items: ['margherita'] }),
+   *     }),
+   *   ],
+   * });
+   * ```
+   */
+  static tool(opts) {
+    if (!opts.handler && !opts.webhookUrl) {
+      throw new Error("tool() requires either handler or webhookUrl");
+    }
+    const t = {
+      name: opts.name,
+      description: opts.description ?? "",
+      parameters: opts.parameters ?? { type: "object", properties: {} }
+    };
+    if (opts.handler) {
+      t.handler = opts.handler;
+    }
+    if (opts.webhookUrl) {
+      t.webhookUrl = opts.webhookUrl;
+    }
+    return t;
+  }
+  // Internal
+  async registerNumber(provider, providerKey, number, providerSecret, country = "US", stt, tts) {
+    const credentials = { api_key: providerKey };
+    if (providerSecret) credentials.api_secret = providerSecret;
+    const response = await fetch(`${this.restUrl}/api/phone-numbers`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey
+      },
+      body: JSON.stringify({
+        number,
+        provider,
+        provider_credentials: credentials,
+        country,
+        stt_config: stt?.toDict() ?? null,
+        tts_config: tts?.toDict() ?? null
+      })
+    });
+    if (response.status === 409) return;
+    if (response.status !== 201) {
+      throw new ProvisionError(
+        `Failed to register number: ${await response.text()}`
+      );
+    }
+  }
+};
+
+// src/index.ts
+init_logger();
+init_llm_loop();
+init_test_mode();
+
+// 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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  CallMetricsAccumulator,
+  DEFAULT_PRICING,
+  DeepgramSTT,
+  ElevenLabsConvAIAdapter,
+  ElevenLabsTTS,
+  LLMLoop,
+  MetricsStore,
+  OpenAILLMProvider,
+  OpenAIRealtimeAdapter,
+  OpenAITTS,
+  Patter,
+  PatterConnectionError,
+  PatterError,
+  ProvisionError,
+  RemoteMessageHandler,
+  TestSession,
+  WhisperSTT,
+  calculateRealtimeCost,
+  calculateSttCost,
+  calculateTelephonyCost,
+  calculateTtsCost,
+  callsToCsv,
+  callsToJson,
+  deepgram,
+  elevenlabs,
+  getLogger,
+  isRemoteUrl,
+  isWebSocketUrl,
+  makeAuthMiddleware,
+  mergePricing,
+  mountApi,
+  mountDashboard,
+  mulawToPcm16,
+  openaiTts,
+  pcm16ToMulaw,
+  resample16kTo8k,
+  resample24kTo16k,
+  resample8kTo16k,
+  setLogger,
+  whisper
+});