getpatter 0.6.2 → 0.6.4

package/dist/{chunk-LE63CSOB.mjs → chunk-7IIV3BY4.mjs}

@@ -5,7 +5,7 @@ import {
   createResampler8kTo16k,
   mulawToPcm16,
   pcm16ToMulaw
-} from "./chunk-CL2U3YET.mjs";
+} from "./chunk-BO227NTF.mjs";
 import {
   getLogger
 } from "./chunk-MVOQFAEO.mjs";
@@ -24,7 +24,7 @@ init_esm_shims();
 
 // src/server.ts
 init_esm_shims();
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 import express from "express";
 import { createServer } from "http";
 import { WebSocketServer } from "ws";
@@ -361,6 +361,157 @@ var ElevenLabsConvAIAdapter = class _ElevenLabsConvAIAdapter {
   }
 };
 
+// src/providers/plivo-adapter.ts
+init_esm_shims();
+var PLIVO_API_BASE = "https://api.plivo.com/v1";
+async function dropPlivoVoicemail(callUuid, voicemailMessage, authId, authToken) {
+  if (!callUuid || !voicemailMessage || !authId || !authToken) return;
+  const auth = `Basic ${Buffer.from(`${authId}:${authToken}`).toString("base64")}`;
+  const base = `${PLIVO_API_BASE}/Account/${encodeURIComponent(authId)}/Call/${encodeURIComponent(callUuid)}`;
+  try {
+    const speak = await fetch(`${base}/Speak/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded", Authorization: auth },
+      body: new URLSearchParams({ text: voicemailMessage }).toString(),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!speak.ok) {
+      getLogger().warn(
+        `Plivo voicemail Speak failed (${speak.status}): ${(await speak.text()).slice(0, 200)}`
+      );
+      return;
+    }
+    await new Promise(
+      (r) => setTimeout(r, Math.min(3e4, voicemailMessage.length * 60))
+    );
+    await fetch(`${base}/`, { method: "DELETE", headers: { Authorization: auth } });
+    getLogger().info(`Voicemail dropped for ${callUuid}`);
+  } catch (e) {
+    getLogger().warn(`Could not drop voicemail: ${String(e)}`);
+  }
+}
+function xmlEscapePlivo(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var PlivoAdapter = class {
+  authId;
+  baseUrl;
+  authHeader;
+  constructor(authId, authToken) {
+    if (!authId) throw new Error("PlivoAdapter: authId is required");
+    if (!authToken) throw new Error("PlivoAdapter: authToken is required");
+    this.authId = authId;
+    this.baseUrl = `${PLIVO_API_BASE}/Account/${encodeURIComponent(authId)}`;
+    this.authHeader = `Basic ${Buffer.from(`${authId}:${authToken}`).toString("base64")}`;
+  }
+  async request(method, path4, jsonBody) {
+    const headers = { Authorization: this.authHeader };
+    if (jsonBody !== void 0) headers["Content-Type"] = "application/json";
+    const response = await fetch(`${this.baseUrl}${path4}`, {
+      method,
+      headers,
+      body: jsonBody !== void 0 ? JSON.stringify(jsonBody) : void 0,
+      signal: AbortSignal.timeout(3e4)
+    });
+    const text = await response.text();
+    if (!response.ok && response.status !== 404) {
+      throw new Error(`Plivo ${method} ${path4} failed: ${response.status} ${text}`);
+    }
+    let data = {};
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+      }
+    }
+    return { status: response.status, data };
+  }
+  /** Search and rent an available Plivo number for the given ISO country. */
+  async provisionNumber(countryIso) {
+    const { data } = await this.request(
+      "GET",
+      `/PhoneNumber/?country_iso=${encodeURIComponent(countryIso)}&limit=1`
+    );
+    const number = data.objects?.[0]?.number;
+    if (!number) throw new Error(`PlivoAdapter: no numbers available for ${countryIso}`);
+    await this.request("POST", `/PhoneNumber/${encodeURIComponent(number)}/`);
+    return number;
+  }
+  /**
+   * Point the inbound answer flow for ``number`` at ``answerUrl`` by creating
+   * (or reusing) a Plivo Application and linking the number to it. Most
+   * production deployments pre-configure this in the Plivo console; this
+   * mirrors Twilio's ``configureNumber`` auto-setup convenience.
+   */
+  async configureNumber(number, answerUrl) {
+    const { data } = await this.request("POST", "/Application/", {
+      app_name: "patter-inbound",
+      answer_url: answerUrl,
+      answer_method: "POST"
+    });
+    if (!data.app_id) {
+      getLogger().warn("Plivo Application create returned no app_id");
+      return;
+    }
+    await this.request("POST", `/Number/${encodeURIComponent(number)}/`, { app_id: data.app_id });
+  }
+  /**
+   * Place an outbound Plivo call routed through ``answerUrl``. Returns Plivo's
+   * ``request_uuid``. The WSS URL travels inside the answer XML, not as a dial
+   * parameter — mirroring the Python adapter.
+   */
+  async initiateCall(opts) {
+    const payload = {
+      from: opts.from,
+      to: opts.to,
+      answer_url: opts.answerUrl,
+      answer_method: "POST"
+    };
+    if (opts.ringTimeout != null) payload.ring_timeout = Math.max(1, Math.floor(opts.ringTimeout));
+    if (opts.machineDetection) {
+      payload.machine_detection = "true";
+      payload.machine_detection_time = 5e3;
+      if (opts.machineDetectionUrl) {
+        payload.machine_detection_url = opts.machineDetectionUrl;
+        payload.machine_detection_method = "POST";
+      }
+    }
+    const { data } = await this.request("POST", "/Call/", payload);
+    return { requestUuid: data.request_uuid ?? "" };
+  }
+  /** Hang up an active Plivo call by CallUUID. 204 and 404 are both success. */
+  async endCall(callUuid) {
+    if (!callUuid) throw new Error("PlivoAdapter: callUuid is required");
+    try {
+      await this.request("DELETE", `/Call/${encodeURIComponent(callUuid)}/`);
+    } catch (err) {
+      getLogger().warn(`[PlivoAdapter] endCall failed for ${callUuid}: ${String(err)}`);
+      throw err;
+    }
+  }
+  /**
+   * Build the Plivo answer XML. Unlike Twilio (``url=`` attribute), Plivo's
+   * ``<Stream>`` takes the WSS URL as its **text content**. ``bidirectional``
+   * enables two-way audio; ``keepCallAlive`` keeps the leg up for the lifetime
+   * of the WebSocket. ``extraHeaders`` (comma-separated ``key=value``) is
+   * delivered back on the WS ``start`` frame as a caller/callee fallback.
+   *
+   * Mirrors the Python adapter's ``generate_stream_xml``.
+   */
+  static generateStreamXml(streamUrl, contentType = "audio/x-mulaw;rate=8000", extraHeaders) {
+    let attrs = `bidirectional="true" keepCallAlive="true" contentType="${xmlEscapePlivo(contentType)}"`;
+    if (extraHeaders) {
+      const joined = Object.entries(extraHeaders).map(([k, v]) => `${k}=${v}`).join(",");
+      attrs += ` extraHeaders="${xmlEscapePlivo(joined)}"`;
+    }
+    return `<Response><Stream ${attrs}>${xmlEscapePlivo(streamUrl)}</Stream></Response>`;
+  }
+};
+
+// src/telephony/plivo.ts
+init_esm_shims();
+import crypto from "crypto";
+
 // src/provider-factory.ts
 init_esm_shims();
 async function createSTT(agent) {
@@ -370,6 +521,168 @@ async function createTTS(agent) {
   return agent.tts ?? null;
 }
 
+// src/telephony/plivo.ts
+var Carrier = class {
+  kind = "plivo";
+  authId;
+  authToken;
+  constructor(opts = {}) {
+    const authId = opts.authId ?? process.env.PLIVO_AUTH_ID;
+    const authToken = opts.authToken ?? process.env.PLIVO_AUTH_TOKEN;
+    if (!authId) {
+      throw new Error(
+        "Plivo carrier requires authId. Pass { authId: 'MA...' } or set PLIVO_AUTH_ID in the environment."
+      );
+    }
+    if (!authToken) {
+      throw new Error(
+        "Plivo carrier requires authToken. Pass { authToken: '...' } or set PLIVO_AUTH_TOKEN in the environment."
+      );
+    }
+    this.authId = authId;
+    this.authToken = authToken;
+  }
+};
+function classifyPlivoAmd(result) {
+  const r = (result || "").trim().toLowerCase();
+  if (r === "human" || r === "person") return "human";
+  if (r.startsWith("machine") || r === "answering_machine" || r === "amd" || r === "true") {
+    return "machine";
+  }
+  if (r === "fax") return "fax";
+  return "unknown";
+}
+function validatePlivoSignature(url, nonce, signature, authToken, params, method = "POST") {
+  if (!signature || !nonce || !authToken) return false;
+  let base = url;
+  if (method === "POST" && params && Object.keys(params).length > 0) {
+    const keys = Object.keys(params).sort();
+    base += keys.map((k) => `${k}${params[k]}`).join("");
+  }
+  const signed = `${base}.${nonce}`;
+  const expected = crypto.createHmac("sha256", authToken).update(signed).digest("base64");
+  const expBuf = Buffer.from(expected);
+  for (const rawSig of signature.split(",")) {
+    const trimmed = rawSig.trim();
+    if (!trimmed) continue;
+    try {
+      const sigBuf = Buffer.from(trimmed);
+      if (sigBuf.length === expBuf.length && crypto.timingSafeEqual(sigBuf, expBuf)) {
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+var PLIVO_DTMF_ALLOWED = new Set("0123456789*#ABCDabcdwW");
+var PlivoBridge = class {
+  constructor(config) {
+    this.config = config;
+    const authId = config.plivoAuthId ?? "";
+    const authToken = config.plivoAuthToken ?? "";
+    this.authHeader = `Basic ${Buffer.from(`${authId}:${authToken}`).toString("base64")}`;
+    this.apiBase = `https://api.plivo.com/v1/Account/${encodeURIComponent(authId)}`;
+  }
+  config;
+  label = "Plivo";
+  telephonyProvider = "plivo";
+  inputWireFormat = "ulaw_8000";
+  authHeader;
+  apiBase;
+  sendAudio(ws, audioBase64, _streamSid) {
+    ws.send(
+      JSON.stringify({
+        event: "playAudio",
+        media: { contentType: "audio/x-mulaw", sampleRate: 8e3, payload: audioBase64 }
+      })
+    );
+  }
+  sendMark(ws, markName, streamSid) {
+    ws.send(JSON.stringify({ event: "checkpoint", streamId: streamSid, name: markName }));
+  }
+  sendClear(ws, streamSid) {
+    ws.send(JSON.stringify({ event: "clearAudio", streamId: streamSid }));
+  }
+  async transferCall(callId, toNumber) {
+    if (!/^\+[1-9]\d{6,14}$/.test(toNumber)) {
+      getLogger().warn(`PlivoBridge.transferCall rejected: invalid target ${JSON.stringify(toNumber)}`);
+      return;
+    }
+    if (!this.config.plivoAuthId || !this.config.plivoAuthToken || !callId) return;
+    if (!this.config.webhookUrl) {
+      getLogger().warn("PlivoBridge.transferCall skipped: no webhookUrl for aleg_url");
+      return;
+    }
+    const alegUrl = `https://${this.config.webhookUrl}/webhooks/plivo/transfer?to=${encodeURIComponent(toNumber)}`;
+    await fetch(`${this.apiBase}/Call/${encodeURIComponent(callId)}/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: this.authHeader },
+      body: JSON.stringify({ legs: "aleg", aleg_url: alegUrl, aleg_method: "GET" })
+    });
+    getLogger().info(`Call transferred to ${toNumber}`);
+  }
+  async sendDtmf(ws, _callId, digits, _delayMs) {
+    const filtered = Array.from(digits ?? "").filter((d) => PLIVO_DTMF_ALLOWED.has(d)).join("");
+    if (!filtered) {
+      getLogger().warn(`PlivoBridge.sendDtmf: no valid digits in ${JSON.stringify(digits)}`);
+      return;
+    }
+    ws.send(JSON.stringify({ event: "sendDTMF", dtmf: filtered }));
+  }
+  async startRecording(callId) {
+    if (!this.config.plivoAuthId || !this.config.plivoAuthToken || !callId) return;
+    try {
+      const resp = await fetch(`${this.apiBase}/Call/${encodeURIComponent(callId)}/Record/`, {
+        method: "POST",
+        headers: { Authorization: this.authHeader }
+      });
+      if (!resp.ok) {
+        getLogger().warn(`Plivo record start failed (${resp.status}): ${(await resp.text()).slice(0, 200)}`);
+      } else {
+        getLogger().info("Plivo recording started");
+      }
+    } catch (e) {
+      getLogger().warn(`Plivo record start error: ${String(e)}`);
+    }
+  }
+  async endCall(callId, _ws) {
+    if (!this.config.plivoAuthId || !this.config.plivoAuthToken || !callId) return;
+    try {
+      const resp = await fetch(`${this.apiBase}/Call/${encodeURIComponent(callId)}/`, {
+        method: "DELETE",
+        headers: { Authorization: this.authHeader }
+      });
+      if (!resp.ok && resp.status !== 404) {
+        getLogger().warn(`Plivo hangup returned ${resp.status}`);
+      }
+    } catch {
+    }
+  }
+  createStt(agent) {
+    return createSTT(agent);
+  }
+  async queryTelephonyCost(metricsAcc, callId) {
+    if (!this.config.plivoAuthId || !this.config.plivoAuthToken || !callId) return;
+    try {
+      const resp = await fetch(`${this.apiBase}/Call/${encodeURIComponent(callId)}/`, {
+        headers: { Authorization: this.authHeader },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (resp.ok) {
+        const data = await resp.json();
+        if (data.total_amount != null) {
+          metricsAcc.setActualTelephonyCost(Math.abs(parseFloat(data.total_amount)));
+          getLogger().info(`Plivo actual cost: $${data.total_amount}`);
+        }
+      }
+    } catch (err) {
+      getLogger().debug(`queryTelephonyCost(plivo) failed: ${err?.message ?? err}`);
+    }
+  }
+};
+
 // src/pricing.ts
 init_esm_shims();
 var PRICING_VERSION = "2026.3";
@@ -612,7 +925,7 @@ var DEFAULT_PRICING = {
   // twilio default = US inbound local (the 99% case for voice agents receiving
   // calls on a local number). For US toll-free inbound ($0.022/min) or US
   // outbound local ($0.0140/min), override via Patter({ pricing: { twilio: {...} } }).
-  twilio: { unit: PricingUnit.MINUTE, price: 85e-4 },
+  twilio: { unit: PricingUnit.MINUTE, price: 85e-4, roundUp: true },
   // Telnyx — direction-aware rates as of 2026-05-11.
   // Sources:
   //   https://telnyx.com/pricing/elastic-sip
@@ -630,7 +943,17 @@ var DEFAULT_PRICING = {
   // price: 0.0035 } } })`` to bill all inbound at the lower rate.
   telnyx: { unit: PricingUnit.MINUTE, price: 7e-3 },
   telnyx_inbound: { unit: PricingUnit.MINUTE, price: 35e-4 },
-  telnyx_outbound: { unit: PricingUnit.MINUTE, price: 7e-3 }
+  telnyx_outbound: { unit: PricingUnit.MINUTE, price: 7e-3 },
+  // Plivo — official US pay-as-you-go voice rates (per minute; Plivo rounds
+  // partial minutes up like Twilio). Source: https://www.plivo.com/voice/pricing/
+  //   US local inbound:    $0.0055/min
+  //   US local outbound:   $0.0115/min
+  //   US toll-free inbound: $0.0180/min (override via new Patter({ pricing }))
+  // The flat ``plivo`` key defaults to inbound local; the billed amount is
+  // also reconciled post-call from the Plivo CDR (``total_amount``).
+  plivo: { unit: PricingUnit.MINUTE, price: 55e-4, roundUp: true },
+  plivo_inbound: { unit: PricingUnit.MINUTE, price: 55e-4, roundUp: true },
+  plivo_outbound: { unit: PricingUnit.MINUTE, price: 0.0115, roundUp: true }
 };
 function cloneProviderEntry(entry) {
   const out = { ...entry };
@@ -716,11 +1039,25 @@ function calculateRealtimeCachedSavings(usage, pricing, model) {
   const rates = resolveProviderRates(pricing.openai_realtime, model);
   if (rates.unit !== "token") return 0;
   const input = usage.input_token_details ?? {};
-  const cached = input.cached_tokens_details ?? {};
   const cachedAudioRate = rates.cached_audio_input_per_token ?? rates.audio_input_per_token ?? 0;
   const cachedTextRate = rates.cached_text_input_per_token ?? rates.text_input_per_token ?? 0;
-  const cachedAudio = Math.min(cached.audio_tokens ?? 0, input.audio_tokens ?? 0);
-  const cachedText = Math.min(cached.text_tokens ?? 0, input.text_tokens ?? 0);
+  const totalAudio = input.audio_tokens ?? 0;
+  const totalText = input.text_tokens ?? 0;
+  let cachedAudio;
+  let cachedText;
+  const details = input.cached_tokens_details;
+  if (details && (details.audio_tokens !== void 0 || details.text_tokens !== void 0)) {
+    cachedAudio = Math.min(details.audio_tokens ?? 0, totalAudio);
+    cachedText = Math.min(details.text_tokens ?? 0, totalText);
+  } else if (input.cached_tokens && input.cached_tokens > 0) {
+    const totalIn = totalAudio + totalText;
+    const ratio = totalIn > 0 ? input.cached_tokens / totalIn : 0;
+    cachedAudio = Math.min(Math.round(totalAudio * ratio), totalAudio);
+    cachedText = Math.min(Math.round(totalText * ratio), totalText);
+  } else {
+    cachedAudio = 0;
+    cachedText = 0;
+  }
   const fullAudio = cachedAudio * (rates.audio_input_per_token ?? 0);
   const fullText = cachedText * (rates.text_input_per_token ?? 0);
   const discountedAudio = cachedAudio * cachedAudioRate;
@@ -816,7 +1153,7 @@ function calculateLlmCost(provider2, model, inputTokens, outputTokens, cacheRead
 function calculateTelephonyCost(provider2, durationSeconds, pricing) {
   const config = pricing[provider2];
   if (!config || config.unit !== "minute") return 0;
-  const minutes = provider2 === "twilio" ? Math.ceil(durationSeconds / 60) : durationSeconds / 60;
+  const minutes = config.roundUp ? Math.ceil(durationSeconds / 60) : durationSeconds / 60;
   return minutes * (config.price ?? 0);
 }
 
@@ -967,14 +1304,49 @@ var MetricsStore = class extends EventEmitter {
     } else {
       for (let i = this.calls.length - 1; i >= 0; i--) {
         if (this.calls[i].call_id === callId) {
-          this.calls[i].status = status;
-          Object.assign(this.calls[i], extra);
+          this.calls[i] = { ...this.calls[i], status, ...extra };
           break;
         }
       }
     }
     this.publish("call_status", { call_id: callId, status, ...extra });
   }
+  /**
+   * Record a single transcript line (user/assistant) as it becomes known.
+   *
+   * FIX-5 (issue #154): the live forward path for the dashboard transcript.
+   * The Realtime stream handler calls this the moment each line is known — the
+   * user line right after the hallucination filter accepts it, the assistant
+   * line when its turn flushes — keyed by the monotonic ``turnIndex`` reserved
+   * at turn-open (``reserveTurnIndex``). Each line is appended to the active
+   * call's ``transcript`` array and broadcast over SSE as a ``transcript_line``
+   * event so the dashboard can render lines as they arrive and re-sort by
+   * ``(turnIndex, user<assistant)`` — making a late-arriving user line land
+   * ABOVE its agent line. ``recordTurn`` de-dups against the lines pushed here
+   * by ``(turnIndex, role)`` so the metrics path never double-pushes the same
+   * text. Parity with Python ``record_transcript_line``.
+   */
+  recordTranscriptLine(data) {
+    const callId = data.call_id || "";
+    const { role, text, turnIndex } = data;
+    if (!callId || role !== "user" && role !== "assistant" || !text) return;
+    const active = this.activeCalls.get(callId);
+    if (active) {
+      if (!active.transcript) active.transcript = [];
+      active.transcript.push({
+        role,
+        text,
+        timestamp: Date.now() / 1e3,
+        turnIndex
+      });
+    }
+    this.publish("transcript_line", {
+      call_id: callId,
+      turnIndex,
+      role,
+      text
+    });
+  }
   /** Append a single conversation turn to an active call and broadcast it via SSE. */
   recordTurn(data) {
     const callId = data.call_id || "";
@@ -989,14 +1361,19 @@ var MetricsStore = class extends EventEmitter {
       const userText = typeof turnRecord.user_text === "string" ? turnRecord.user_text : "";
       const agentText = typeof turnRecord.agent_text === "string" ? turnRecord.agent_text : "";
       const ts = typeof turnRecord.timestamp === "number" ? turnRecord.timestamp : Date.now() / 1e3;
-      if (userText.length > 0) {
-        active.transcript.push({ role: "user", text: userText, timestamp: ts });
+      const turnIndex = typeof turnRecord.turn_index === "number" ? turnRecord.turn_index : void 0;
+      const alreadyLive = (role) => turnIndex !== void 0 && (active.transcript ?? []).some(
+        (e) => e.turnIndex === turnIndex && e.role === role
+      );
+      if (userText.length > 0 && !alreadyLive("user")) {
+        active.transcript.push({ role: "user", text: userText, timestamp: ts, turnIndex });
       }
-      if (agentText.length > 0 && agentText !== "[interrupted]") {
+      if (agentText.length > 0 && agentText !== "[interrupted]" && !alreadyLive("assistant")) {
         active.transcript.push({
           role: "assistant",
           text: agentText,
-          timestamp: ts
+          timestamp: ts,
+          turnIndex
         });
       }
     }
@@ -1069,7 +1446,7 @@ var MetricsStore = class extends EventEmitter {
   getCall(callId) {
     if (this.deletedCallIds.has(callId)) return null;
     for (let i = this.calls.length - 1; i >= 0; i--) {
-      if (this.calls[i].call_id === callId) return this.calls[i];
+      if (this.calls[i].call_id === callId) return { ...this.calls[i] };
     }
     return null;
   }
@@ -1111,7 +1488,9 @@ var MetricsStore = class extends EventEmitter {
     }
     if (accepted.length === 0) return [];
     accepted.sort();
-    this.persistDeletedIds();
+    this.persistDeletedIds().catch(
+      (err) => getLogger().debug(`MetricsStore.deleteCalls: persistDeletedIds failed: ${String(err)}`)
+    );
     this.publish("calls_deleted", { call_ids: accepted });
     return accepted;
   }
@@ -1123,19 +1502,19 @@ var MetricsStore = class extends EventEmitter {
   getDeletedCallIds() {
     return Array.from(this.deletedCallIds).sort();
   }
-  /** Atomically persist the deleted-ids set to disk. Best-effort. */
-  persistDeletedIds() {
+  /** Atomically persist the deleted-ids set to disk. Best-effort async. */
+  async persistDeletedIds() {
     if (this.deletedIdsPath === null) return;
     try {
       const dir = path2.dirname(this.deletedIdsPath);
-      fs2.mkdirSync(dir, { recursive: true });
+      await fs2.promises.mkdir(dir, { recursive: true });
       const tmp = this.deletedIdsPath + ".tmp";
       const payload = {
         version: 1,
         deleted_call_ids: Array.from(this.deletedCallIds).sort()
       };
-      fs2.writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf8");
-      fs2.renameSync(tmp, this.deletedIdsPath);
+      await fs2.promises.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
+      await fs2.promises.rename(tmp, this.deletedIdsPath);
     } catch (err) {
       getLogger().debug(
         `MetricsStore.persistDeletedIds: ${String(err)}`
@@ -1144,7 +1523,8 @@ var MetricsStore = class extends EventEmitter {
   }
   /** Look up an active call by id (returns undefined if not active or unknown). */
   getActive(callId) {
-    return this.activeCalls.get(callId);
+    const rec = this.activeCalls.get(callId);
+    return rec !== void 0 ? { ...rec } : void 0;
   }
   /** Return all currently active (not yet ended) calls. */
   getActiveCalls() {
@@ -1389,8 +1769,8 @@ function loadTranscriptJsonl(filePath) {
       } catch {
         continue;
       }
-      const tsIso = typeof row.ts === "string" ? Date.parse(row.ts) : NaN;
-      const tsNumeric = typeof row.timestamp === "number" ? row.timestamp * 1e3 : NaN;
+      const tsIso = typeof row.ts === "string" ? Date.parse(row.ts) / 1e3 : NaN;
+      const tsNumeric = typeof row.timestamp === "number" ? row.timestamp : NaN;
       const timestamp = Number.isFinite(tsIso) ? tsIso : Number.isFinite(tsNumeric) ? tsNumeric : 0;
       const userText = typeof row.user_text === "string" ? row.user_text : "";
       const agentText = typeof row.agent_text === "string" ? row.agent_text : "";
@@ -1422,15 +1802,15 @@ init_esm_shims();
 
 // src/dashboard/auth.ts
 init_esm_shims();
-import crypto from "crypto";
+import crypto2 from "crypto";
 function timingSafeCompare(a, b) {
   const aBuf = Buffer.from(a);
   const bBuf = Buffer.from(b);
   if (aBuf.length !== bBuf.length) {
-    crypto.timingSafeEqual(aBuf, aBuf);
+    crypto2.timingSafeEqual(aBuf, aBuf);
     return false;
   }
-  return crypto.timingSafeEqual(aBuf, bBuf);
+  return crypto2.timingSafeEqual(aBuf, bBuf);
 }
 function makeAuthMiddleware(token = "") {
   return (req, res, next) => {
@@ -1547,8 +1927,8 @@ function mountDashboard(app, store, token = "") {
     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;
+    const limit = Math.min(Math.max(0, parseInt(req.query.limit || "50", 10) || 50), 1e3);
+    const offset = Math.max(0, parseInt(req.query.offset || "0", 10) || 0);
     res.json(store.getCalls(limit, offset));
   });
   app.get("/api/dashboard/calls/:callId", auth, (req, res) => {
@@ -1638,8 +2018,8 @@ data: ${data}
 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 limit = Math.min(Math.max(0, parseInt(req.query.limit || "50", 10) || 50), 1e3);
+    const offset = Math.max(0, parseInt(req.query.offset || "0", 10) || 0);
     const calls = store.getCalls(limit, offset);
     res.json({
       data: calls,
@@ -1719,7 +2099,7 @@ function mountApi(app, store, token = "") {
 
 // src/remote-message.ts
 init_esm_shims();
-import crypto2 from "crypto";
+import crypto3 from "crypto";
 var MAX_RESPONSE_BYTES = 64 * 1024;
 function validateWebSocketUrl(url) {
   let translated = url;
@@ -1747,7 +2127,7 @@ var RemoteMessageHandler = class {
     if (!this.webhookSecret) {
       throw new Error("Cannot sign without a webhookSecret");
     }
-    return crypto2.createHmac("sha256", this.webhookSecret).update(body).digest("hex");
+    return crypto3.createHmac("sha256", this.webhookSecret).update(body).digest("hex");
   }
   /**
    * Release resources held by this handler.
@@ -1896,14 +2276,31 @@ var RemoteMessageHandler = class {
       while (chunks.length > 0) {
         yield chunks.shift();
       }
+      const READ_TIMEOUT_MS = 3e4;
       while (!done && !error) {
-        const text = await new Promise((resolve2) => {
+        const messagePromise = new Promise((resolve2) => {
           if (chunks.length > 0) {
             resolve2(chunks.shift());
           } else {
             resolveNext = resolve2;
           }
         });
+        let timeoutHandle;
+        const timeoutPromise = new Promise((_, reject) => {
+          timeoutHandle = setTimeout(
+            () => reject(new Error("WebSocket read timeout: no frame received within 30 s")),
+            READ_TIMEOUT_MS
+          );
+        });
+        let text;
+        try {
+          text = await Promise.race([messagePromise, timeoutPromise]);
+        } catch (timeoutErr) {
+          resolveNext = null;
+          throw timeoutErr;
+        } finally {
+          clearTimeout(timeoutHandle);
+        }
         if (text === null) break;
         yield text;
       }
@@ -1963,6 +2360,12 @@ var PatterError = class extends Error {
     this.code = options?.code ?? ErrorCode.INTERNAL;
   }
 };
+var PatterConfigError = class extends PatterError {
+  constructor(message, options) {
+    super(message, { code: options?.code ?? ErrorCode.CONFIG });
+    this.name = "PatterConfigError";
+  }
+};
 var PatterConnectionError = class extends PatterError {
   constructor(message, options) {
     super(message, { code: options?.code ?? ErrorCode.CONNECTION });
@@ -2207,18 +2610,6 @@ var DeepgramSTT = class _DeepgramSTT {
     } catch {
       return;
     }
-    const dataType = String(data.type ?? "unknown");
-    if (dataType === "Results") {
-      const transcript2 = (data.channel?.alternatives?.[0]?.transcript ?? "").trim();
-      const isFinal = Boolean(data.is_final);
-      const speechFinal2 = Boolean(data.speech_final);
-      const fromFinalize = Boolean(data.from_finalize);
-      getLogger().info(
-        `[DIAG] DG Results text=${JSON.stringify(transcript2.slice(0, 60))} isFinal=${isFinal} speechFinal=${speechFinal2} fromFinalize=${fromFinalize}`
-      );
-    } else if (dataType !== "Metadata") {
-      getLogger().info(`[DIAG] DG event type=${dataType}`);
-    }
     if (data.type === "Metadata" && data.request_id) {
       this.requestId = data.request_id;
       return;
@@ -2308,7 +2699,7 @@ var DeepgramSTT = class _DeepgramSTT {
     if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) {
       this.audioDroppedCount++;
       if (this.audioDroppedCount === 1 || this.audioDroppedCount % 50 === 0) {
-        getLogger().info(
+        getLogger().debug(
           `[DIAG] DeepgramSTT.sendAudio dropped (ws state=${this.ws?.readyState ?? "null"}) \u2014 total dropped=${this.audioDroppedCount}`
         );
       }
@@ -2317,7 +2708,7 @@ var DeepgramSTT = class _DeepgramSTT {
     if (audio.length === 0) return;
     this.audioSentCount++;
     if (this.audioSentCount === 1 || this.audioSentCount % 100 === 0) {
-      getLogger().info(
+      getLogger().debug(
         `[DIAG] DeepgramSTT.sendAudio: total chunks sent=${this.audioSentCount} (last=${audio.length} bytes)`
       );
     }
@@ -2355,16 +2746,16 @@ var DeepgramSTT = class _DeepgramSTT {
   finalize() {
     const ws = this.ws;
     if (!ws || ws.readyState !== WebSocket2.OPEN) {
-      getLogger().info(
+      getLogger().debug(
         `[DIAG] DeepgramSTT.finalize SKIPPED (ws state=${ws?.readyState ?? "null"})`
       );
       return;
     }
     try {
       ws.send(JSON.stringify({ type: "Finalize" }));
-      getLogger().info("[DIAG] DeepgramSTT.finalize sent {type:Finalize}");
+      getLogger().debug("[DIAG] DeepgramSTT.finalize sent {type:Finalize}");
     } catch (err) {
-      getLogger().info(`[DIAG] DeepgramSTT.finalize send failed: ${String(err)}`);
+      getLogger().debug(`[DIAG] DeepgramSTT.finalize send failed: ${String(err)}`);
     }
   }
   /** Send Finalize, briefly drain trailing transcripts, then close the socket. */
@@ -2437,6 +2828,7 @@ var CallMetricsAccumulator = class {
   _pricing;
   _callStart;
   _turns = [];
+  // mutable internal array; immutable when exposed via TurnMetrics[] → readonly TurnMetrics[]
   // Per-turn timing state
   _turnStart = null;
   _sttComplete = null;
@@ -2523,6 +2915,16 @@ var CallMetricsAccumulator = class {
    * (the common cause of missing endpoint signals).
    */
   _endpointSignalMissingCount = 0;
+  /**
+   * Monotonic per-call turn counter. Reserved at turn OPEN
+   * (``onAdapterSpeechStopped`` / ``speech_stopped``) via
+   * ``reserveTurnIndex()`` and threaded through the buffering pipeline into
+   * ``recordTurnComplete`` / ``recordTurnInterrupted`` as ``preReservedIndex``.
+   * This makes ``turn_index`` stable under drops / interrupts (previously it
+   * was assigned at completion as ``this._turns.length``, which shifted when a
+   * turn was dropped). Parity with Python ``_next_turn_index``.
+   */
+  _nextTurnIndex = 0;
   constructor(opts) {
     this.callId = opts.callId;
     this.providerMode = opts.providerMode;
@@ -2571,12 +2973,27 @@ var CallMetricsAccumulator = class {
     this._turnUserText = "";
     this._turnSttAudioSeconds = 0;
     this._turnAlreadyClosed = false;
+    this._initialTtfbEmitted = false;
     this._vadStoppedAt = null;
     this._sttFinalAt = null;
     this._turnCommittedAt = null;
     this._onUserTurnCompletedDelayMs = null;
     this._eventBus?.emit("turn_started", { callId: this.callId });
   }
+  /**
+   * Reserve and return the next monotonic turn index.
+   *
+   * Called once per turn at the moment the turn OPENS (Realtime:
+   * ``onAdapterSpeechStopped``). The returned index is threaded through the
+   * buffering pipeline and handed back to ``recordTurnComplete`` /
+   * ``recordTurnInterrupted`` as ``preReservedIndex`` so the emitted
+   * ``turn_index`` matches the live per-line transcript ordering even when a
+   * turn is dropped or interrupted between open and close. Parity with Python
+   * ``reserve_turn_index``.
+   */
+  reserveTurnIndex() {
+    return this._nextTurnIndex++;
+  }
   /**
    * Start a new turn only if no turn is currently open.
    * Use this at inbound-audio ingestion points so the turn timer begins
@@ -2614,6 +3031,7 @@ var CallMetricsAccumulator = class {
   anchorUserSpeechStart() {
     if (this._turnCommittedMono !== null) return;
     this._turnStart = hrTimeMs();
+    this._turnAlreadyClosed = false;
     this._endpointSignalAt = null;
     this._vadStoppedAt = null;
     this._sttFinalAt = null;
@@ -2737,11 +3155,14 @@ var CallMetricsAccumulator = class {
    * ``user_text=''``. The caller treats ``null`` as "nothing to emit";
    * ``emitTurnMetrics`` is already null-safe.
    */
-  recordTurnComplete(agentText) {
+  recordTurnComplete(agentText, preReservedIndex) {
     if (this._turnAlreadyClosed) return null;
     const latency = this._computeTurnLatency();
     const turn = {
-      turn_index: this._turns.length,
+      // Use the pre-reserved index (stable across drops/interrupts) when the
+      // caller threaded one through; otherwise fall back to the append
+      // position for back-compat with callers that never reserved.
+      turn_index: preReservedIndex ?? this._turns.length,
       user_text: this._turnUserText,
       agent_text: agentText,
       latency,
@@ -2750,10 +3171,10 @@ var CallMetricsAccumulator = class {
       timestamp: Date.now() / 1e3
     };
     this._turns.push(turn);
-    this._resetTurnState();
-    this._turnAlreadyClosed = true;
     this._eventBus?.emit("turn_ended", { callId: this.callId, turn });
     this._eventBus?.emit("metrics_collected", { callId: this.callId, turn });
+    this._resetTurnState();
+    this._turnAlreadyClosed = true;
     return turn;
   }
   /**
@@ -2765,12 +3186,12 @@ var CallMetricsAccumulator = class {
    * a future refactor that reorders the bargein + LLM-unwind paths)
    * from overwriting a turn that the complete path already emitted.
    */
-  recordTurnInterrupted() {
+  recordTurnInterrupted(preReservedIndex) {
     if (this._turnStart === null) return null;
     if (this._turnAlreadyClosed) return null;
     const latency = this._computeTurnLatency();
     const turn = {
-      turn_index: this._turns.length,
+      turn_index: preReservedIndex ?? this._turns.length,
       user_text: this._turnUserText,
       agent_text: "[interrupted]",
       latency,
@@ -2822,8 +3243,10 @@ var CallMetricsAccumulator = class {
   }
   /**
    * Record the delta (ms) between turn-committed and when on_user_turn_completed
-   * pipeline hook finished.  Stored for inclusion in the next ``emitEouMetrics``
-   * call (or an explicit re-emit if desired).
+   * pipeline hook finished. Does NOT re-emit: like Python's
+   * ``record_on_user_turn_completed_delay``, this only stores the value; the
+   * single EOU emission happens on ``recordTurnCommitted`` (3-timestamp guard,
+   * delay defaults to 0 if not yet recorded).
    */
   recordOnUserTurnCompletedDelay(delayMs) {
     this._onUserTurnCompletedDelayMs = delayMs;
@@ -2836,7 +3259,7 @@ var CallMetricsAccumulator = class {
    * ``transcriptionDelay``       = turnCommitted − vadStopped  (ms)
    * ``onUserTurnCompletedDelay`` = caller-supplied delta (ms) or 0
    */
-  /** Emit `EOUMetrics` once VAD-stop, STT-final, and turn-committed timestamps are all known. */
+  /** Emit `EOUMetrics` once VAD-stop, STT-final, turn-committed, and on_user_turn_completed delay are all known. */
   emitEouMetrics() {
     if (this._vadStoppedAt === null || this._sttFinalAt === null || this._turnCommittedAt === null) {
       return;
@@ -3252,10 +3675,16 @@ var MCPManager = class {
     }
     const aggregatedTools = [];
     for (const cfg of this.configs) {
+      try {
+        validateWebhookUrl(cfg.url);
+      } catch (e) {
+        getLogger().error(`MCP server '${cfg.name}' (${cfg.url}) rejected by SSRF guard: ${String(e)}`);
+        continue;
+      }
       const transport = new transportModule.StreamableHTTPClientTransport(new URL(cfg.url), {
         requestInit: { headers: cfg.headers }
       });
-      const client = new mcpModule.Client({ name: "patter", version: "0.6.0" });
+      const client = new mcpModule.Client({ name: "patter", version: VERSION });
       try {
         await client.connect(transport);
       } catch (e) {
@@ -3327,6 +3756,268 @@ var MCPManager = class {
   }
 };
 
+// src/consult.ts
+init_esm_shims();
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_TOOL_NAME = "consult_agent";
+var DEFAULT_DESCRIPTION = "Consult your back-office agent for deeper reasoning, fresh information, or actions beyond this call. Use when the caller asks something you cannot answer directly.";
+var MAX_RESPONSE_CHARS = 1e6;
+var REPLY_KEYS = ["reply", "response", "text", "result", "answer", "message"];
+var GRACEFUL_FALLBACK = "I wasn't able to reach the system to get that answer right now.";
+var OPENCLAW_DEFAULT_BASE_URL = "http://127.0.0.1:18789/v1";
+var OPENCLAW_API_KEY_ENV = "OPENCLAW_API_KEY";
+var OPENCLAW_SESSION_HEADER = "x-openclaw-session-key";
+var OPENCLAW_DESCRIPTION = "Consult your OpenClaw agent for anything account-specific \u2014 appointments, customer records, schedules, or actions in the back-office system. NEVER state an appointment time, customer detail, or schedule fact from your own memory; ALWAYS call this tool for those and read back what it returns.";
+var OPENCLAW_REASSURANCE = "Let me check on that for you, one moment.";
+var OPENCLAW_AGENT_RE = /^[A-Za-z0-9._:/-]+$/;
+var PARAMETERS = {
+  type: "object",
+  properties: {
+    request: {
+      type: "string",
+      description: "The question or task to send to your back-office agent for deeper reasoning, fresh information, or an action beyond this call. State it self-containedly \u2014 the dialog history is not forwarded with the consult."
+    }
+  },
+  required: ["request"]
+};
+function isLoopbackOrPrivateHost(baseUrl) {
+  let host;
+  try {
+    host = new URL(baseUrl).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
+  if (host === "localhost" || host === "0.0.0.0" || host === "::1") return true;
+  if (host.endsWith(".local")) return true;
+  if (/^127\./.test(host) || /^10\./.test(host) || /^192\.168\./.test(host)) return true;
+  if (/^169\.254\./.test(host)) return true;
+  const m = host.match(/^172\.(\d+)\./);
+  if (m) {
+    const octet = Number(m[1]);
+    if (octet >= 16 && octet <= 31) return true;
+  }
+  if (host.includes(":") && (/^f[cd][0-9a-f]{2}:/.test(host) || /^fe[89ab][0-9a-f]:/.test(host))) {
+    return true;
+  }
+  return false;
+}
+function openclawConsult(agent, opts = {}) {
+  if (!agent || !OPENCLAW_AGENT_RE.test(agent)) {
+    throw new Error(
+      "OpenClaw agent must be a non-empty id of letters, digits, and ._:/- only"
+    );
+  }
+  const baseUrl = opts.baseUrl ?? OPENCLAW_DEFAULT_BASE_URL;
+  const model = agent.includes("/") || agent.includes(":") ? agent : `openclaw/${agent}`;
+  return {
+    openaiCompatible: {
+      baseUrl,
+      model,
+      apiKey: opts.apiKey,
+      apiKeyEnv: OPENCLAW_API_KEY_ENV,
+      sessionHeader: OPENCLAW_SESSION_HEADER
+    },
+    timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    toolName: opts.toolName ?? DEFAULT_TOOL_NAME,
+    description: opts.description ?? OPENCLAW_DESCRIPTION,
+    reassurance: opts.reassurance ?? OPENCLAW_REASSURANCE,
+    headers: opts.headers,
+    allowLoopback: opts.allowLoopback ?? isLoopbackOrPrivateHost(baseUrl)
+  };
+}
+function buildConsultTool(config) {
+  const hasUrl = config.url != null;
+  const hasOpenAI = config.openaiCompatible != null;
+  if (hasUrl === hasOpenAI) {
+    throw new Error("ConsultConfig requires exactly one of url or openaiCompatible");
+  }
+  const timeoutMs = config.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const baseHeaders = {
+    ...config.headers ?? {},
+    "Content-Type": "application/json"
+  };
+  const handler = hasOpenAI ? buildOpenAIHandler(config.openaiCompatible, baseHeaders, timeoutMs, config.allowLoopback ?? false) : buildWebhookHandler(config.url, baseHeaders, timeoutMs, config.allowLoopback ?? false);
+  const tool = {
+    name: config.toolName ?? DEFAULT_TOOL_NAME,
+    description: config.description ?? DEFAULT_DESCRIPTION,
+    parameters: PARAMETERS,
+    handler
+  };
+  return config.reassurance != null ? { ...tool, reassurance: config.reassurance } : tool;
+}
+function buildWebhookHandler(url, headers, timeoutMs, allowLoopback) {
+  validateWebhookUrl(url, allowLoopback);
+  return async (args, context) => {
+    const requestText = typeof args?.request === "string" ? args.request : "";
+    const payload = {
+      request: requestText,
+      call_id: context?.call_id ?? "",
+      caller: context?.caller ?? "",
+      callee: context?.callee ?? ""
+    };
+    let body;
+    try {
+      const resp = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!resp.ok) {
+        getLogger().warn(`consult tool: orchestrator returned HTTP ${resp.status}`);
+        return GRACEFUL_FALLBACK;
+      }
+      body = (await resp.text()).slice(0, MAX_RESPONSE_CHARS);
+    } catch (e) {
+      getLogger().warn(
+        `consult tool: orchestrator call failed: ${e instanceof Error ? e.name : "error"}`
+      );
+      return GRACEFUL_FALLBACK;
+    }
+    try {
+      const data = JSON.parse(body);
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        const obj = data;
+        for (const key of REPLY_KEYS) {
+          if (typeof obj[key] === "string") return obj[key];
+        }
+      }
+      return JSON.stringify(data);
+    } catch {
+      return body;
+    }
+  };
+}
+function buildOpenAIHandler(oc, baseHeaders, timeoutMs, allowLoopback) {
+  const endpoint = oc.baseUrl.replace(/\/+$/, "") + "/chat/completions";
+  validateWebhookUrl(endpoint, allowLoopback);
+  const apiKey = oc.apiKey ?? (oc.apiKeyEnv ? process.env[oc.apiKeyEnv] : void 0);
+  const headers = { ...baseHeaders };
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  const sessionHeader = oc.sessionHeader;
+  const model = oc.model;
+  return async (args, context) => {
+    const requestText = typeof args?.request === "string" ? args.request : "";
+    const callId = context?.call_id ?? "";
+    const caller = context?.caller ?? "";
+    const callee = context?.callee ?? "";
+    const contextLines = ["You are answering an inbound phone call relayed by a voice agent."];
+    if (caller) contextLines.push(`Caller: ${caller}`);
+    if (callee) contextLines.push(`Line dialed: ${callee}`);
+    contextLines.push(
+      "Reply concisely in a spoken, conversational style \u2014 it is read aloud to the caller."
+    );
+    const reqHeaders = { ...headers };
+    if (sessionHeader && callId) reqHeaders[sessionHeader] = callId;
+    const payload = {
+      model,
+      messages: [
+        { role: "system", content: contextLines.join("\n") },
+        { role: "user", content: requestText }
+      ],
+      stream: false
+    };
+    if (callId) payload.user = callId;
+    try {
+      const resp = await fetch(endpoint, {
+        method: "POST",
+        headers: reqHeaders,
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (resp.status === 404) {
+        getLogger().warn(
+          "consult tool: OpenAI-compatible endpoint returned 404 \u2014 is it enabled? (OpenClaw: set gateway.http.endpoints.chatCompletions.enabled = true)"
+        );
+        return GRACEFUL_FALLBACK;
+      }
+      if (!resp.ok) {
+        getLogger().warn(`consult tool: openai-compatible returned HTTP ${resp.status}`);
+        return GRACEFUL_FALLBACK;
+      }
+      const data = await resp.json();
+      const content = data?.choices?.[0]?.message?.content;
+      if (typeof content === "string" && content.trim()) {
+        return content.trim().slice(0, MAX_RESPONSE_CHARS);
+      }
+      getLogger().warn("consult tool: response missing choices[0].message.content");
+      return GRACEFUL_FALLBACK;
+    } catch (e) {
+      getLogger().warn(
+        `consult tool: openai-compatible call failed: ${e instanceof Error ? e.name : "error"}`
+      );
+      return GRACEFUL_FALLBACK;
+    }
+  };
+}
+var POSTCALL_INSTRUCTION = "A phone call handled by the voice agent has just ended. Here is the record of the call. Log it and follow up if anything needs action.";
+var POSTCALL_MAX_TRANSCRIPT_CHARS = 12e3;
+function buildPostCallRecord(data, includeTranscript) {
+  const lines = [];
+  const caller = data.caller;
+  const callee = data.callee;
+  if (caller) lines.push(`Caller: ${caller}`);
+  if (callee) lines.push(`Line dialed: ${callee}`);
+  const metrics = data.metrics;
+  const duration = metrics?.durationSeconds ?? metrics?.duration_seconds;
+  if (typeof duration === "number") lines.push(`Duration: ${Math.round(duration)}s`);
+  if (includeTranscript) {
+    const entries = data.transcript ?? [];
+    const rendered = entries.filter((e) => e && typeof e === "object").map((e) => `${e.role ?? "?"}: ${e.text ?? ""}`).join("\n");
+    if (rendered) lines.push("Transcript:\n" + rendered.slice(0, POSTCALL_MAX_TRANSCRIPT_CHARS));
+  }
+  return lines.length ? lines.join("\n") : "(no call details available)";
+}
+function openclawPostCallNotifier(agent, opts = {}) {
+  const cfg = openclawConsult(agent, {
+    baseUrl: opts.baseUrl,
+    apiKey: opts.apiKey,
+    timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    allowLoopback: opts.allowLoopback
+  });
+  const oc = cfg.openaiCompatible;
+  const endpoint = oc.baseUrl.replace(/\/+$/, "") + "/chat/completions";
+  validateWebhookUrl(endpoint, cfg.allowLoopback ?? false);
+  const apiKey = oc.apiKey ?? (oc.apiKeyEnv ? process.env[oc.apiKeyEnv] : void 0);
+  const sessionHeader = oc.sessionHeader;
+  const model = oc.model;
+  const timeoutMs = cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const includeTranscript = opts.includeTranscript ?? true;
+  const instruction = opts.instruction ?? POSTCALL_INSTRUCTION;
+  return async (data) => {
+    const callId = (data ?? {}).call_id ?? "";
+    const record = buildPostCallRecord(data ?? {}, includeTranscript);
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+    if (sessionHeader && callId) headers[sessionHeader] = callId;
+    const payload = {
+      model,
+      messages: [
+        { role: "system", content: instruction },
+        { role: "user", content: record }
+      ],
+      stream: false
+    };
+    if (callId) payload.user = callId;
+    try {
+      const resp = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!resp.ok) {
+        getLogger().warn(`openclaw post-call notify: HTTP ${resp.status}`);
+      }
+    } catch (e) {
+      getLogger().warn(
+        `openclaw post-call notify failed: ${e instanceof Error ? e.name : "error"}`
+      );
+    }
+  };
+}
+
 // src/sentence-chunker.ts
 init_esm_shims();
 var DEFAULT_MIN_SENTENCE_LEN = 20;
@@ -4028,6 +4719,52 @@ async function withSpan(name, attrs, fn) {
 }
 
 // src/stream-handler.ts
+var DEFAULT_TOOL_CALL_PREAMBLE_BLOCK = `# Preambles
+
+Use short preambles only when they help the user understand that work is happening. A preamble is one short spoken update describing the action you are about to take \u2014 not hidden reasoning, and never a claim about the result.
+
+## When to use a preamble
+Use a preamble when:
+- you are about to call a tool that may take noticeable time;
+- you need to reason through a multi-step request;
+- you are checking records, availability, account state, or policy details;
+- you are preparing an escalation or handoff;
+- silence would make the assistant feel unresponsive.
+
+When a preamble is needed, output it immediately before the reasoning or tool call.
+
+## When to NOT use a preamble
+Do not use a preamble when:
+- the answer is direct and can be given immediately;
+- the user is only confirming, correcting, or declining something;
+- the audio is unclear and you need clarification instead;
+- the tool call is lightweight and the user would not benefit from an update.
+
+## Style
+- Keep it to one short sentence (two only before a high-impact action).
+- Vary the wording across turns; do not reuse the same opener.
+- Describe the action, not the internal reasoning.
+- Never imply success or failure before the tool returns.
+
+Prefer:
+- "I'll check that order now."
+- "I'll look up your appointment details."
+- "I'll verify that before we make any changes."
+- "I'll check the policy and then give you the next step."
+- "I'll pull that up so we can make sure it's the right account."
+
+Avoid:
+- "Let me think about that for a second."
+- "Please wait while I process your request."
+- "I'm going to use my tools now."
+- "Hmm..." / "One moment while I process that..."`;
+function applyToolCallPreambles(prompt, knob) {
+  if (!knob) return prompt;
+  const block = typeof knob === "string" ? knob : DEFAULT_TOOL_CALL_PREAMBLE_BLOCK;
+  return prompt ? `${block}
+
+${prompt}` : block;
+}
 function checkGuardrails(text, guardrails) {
   if (!guardrails) return null;
   for (const guard of guardrails) {
@@ -4055,40 +4792,93 @@ function maskPhoneNumber(number) {
 function isValidE164(number) {
   return /^\+[1-9]\d{6,14}$/.test(number);
 }
+function augmentWithBuiltinHandoffTools(userTools, callbacks) {
+  const out = [...userTools ?? []];
+  if (callbacks.transferCall) {
+    const transferCall = callbacks.transferCall;
+    out.push({
+      ...TRANSFER_CALL_TOOL,
+      handler: async (args) => {
+        const number = typeof args.number === "string" ? args.number : "";
+        if (!isValidE164(number)) {
+          return JSON.stringify({ error: "Invalid phone number format", status: "rejected" });
+        }
+        await transferCall(number);
+        return JSON.stringify({ status: "transferring", to: number });
+      }
+    });
+  }
+  if (callbacks.endCall) {
+    const endCall = callbacks.endCall;
+    out.push({
+      ...END_CALL_TOOL,
+      handler: async (args) => {
+        const reason = typeof args.reason === "string" ? args.reason : "conversation_complete";
+        await endCall(reason);
+        return JSON.stringify({ status: "ending", reason });
+      }
+    });
+  }
+  return out;
+}
 var HALLUCINATIONS = /* @__PURE__ */ new Set([
-  "you",
-  "thank you",
-  "thanks",
-  "yeah",
-  "yes",
-  "no",
-  "okay",
-  "ok",
-  "uh",
-  "um",
-  "mmm",
-  "hmm",
-  ".",
-  "bye",
-  "right",
-  "cool",
-  // Whisper YouTube-caption hallucinations
+  // Issue #154: the hallucination filter is now DISPLAY-ONLY — it no longer
+  // gates response creation (the server drives the response on
+  // ``input_audio_buffer.committed`` by default). Dropping a phrase here
+  // therefore deletes the user's transcript line (recordSttComplete never
+  // fires → empty user_text → dashboard skips the user line). So this set is
+  // restricted to genuine NON-SPEECH artefacts that Whisper emits on
+  // silence / TTS echo, NOT real conversational words. Standalone words like
+  // 'yes', 'no', 'okay', 'right', 'you', 'thanks' were REMOVED — they are
+  // legitimate user replies and must reach the transcript. Parity with
+  // Python ``_STT_HALLUCINATIONS``.
+  //
+  // Whisper caption / training-set hallucinations. Whisper was trained heavily
+  // on captioned video, so on silence / PSTN echo it falls back to the most
+  // common caption credits + sign-offs. Curated from widely-reported
+  // Whisper-on-silence outputs across the open-source ASR community.
   "thank you for watching",
   "thanks for watching",
   "thank you for watching!",
   "thanks for watching!",
   "thank you so much for watching",
+  "thank you for watching please subscribe",
+  "thanks for watching please subscribe",
   "thanks for listening",
+  "we'll see you next time",
+  "see you next time",
+  "bye bye",
   "please subscribe",
+  "please subscribe to my channel",
+  "don't forget to subscribe",
+  "like and subscribe",
   "subscribe",
+  "subtitles by the amara.org community",
+  "subtitles by the amara org community",
+  "subtitles by",
+  "transcribed by",
+  "transcription by castingwords",
+  "the end",
+  // Music / sound markers.
   "music",
   "[music]",
+  "piano music",
+  "applause",
+  "[applause]",
   "\u266A",
+  // Silence markers.
   "[no audio]",
   "[silence]",
   "[blank_audio]",
   "(silence)"
 ]);
+function isSttHallucination(text) {
+  const stripped = text.trim().toLowerCase().replace(/[.,!?;:…。！？\s]+$/u, "").trim();
+  if (stripped === "") return true;
+  if (HALLUCINATIONS.has(stripped)) return true;
+  const pieces = stripped.split(/[.!?…。！？]+/u).map((p) => p.trim()).filter((p) => p.length > 0);
+  return pieces.length > 1 && pieces.every((p) => HALLUCINATIONS.has(p));
+}
 var StreamHandler = class _StreamHandler {
   deps;
   ws;
@@ -4387,7 +5177,14 @@ var StreamHandler = class _StreamHandler {
    * barge-in armed during the audible tail. Tunable via env.
    */
   endSpeakingWithGrace() {
-    const grace = Number(process.env.PATTER_TTS_TAIL_GRACE_MS ?? 1500);
+    const rawGrace = process.env.PATTER_TTS_TAIL_GRACE_MS;
+    const parsedGrace = rawGrace !== void 0 ? Number(rawGrace) : NaN;
+    const grace = rawGrace !== void 0 && Number.isFinite(parsedGrace) ? parsedGrace : 1500;
+    if (rawGrace !== void 0 && !Number.isFinite(parsedGrace)) {
+      getLogger().warn(
+        `PATTER_TTS_TAIL_GRACE_MS="${rawGrace}" is not a valid number \u2014 using default 1500ms`
+      );
+    }
     if (grace > 0) {
       const gen = this.speakingGeneration;
       this.clearGraceTimer();
@@ -4481,6 +5278,14 @@ var StreamHandler = class _StreamHandler {
       `[DIAG] Flushed ${replayed} pre-barge-in frame(s) (~${replayed * 20} ms) to STT`
     );
   }
+  /**
+   * Per-call resolved tool list. Starts as ``null`` (falls back to
+   * ``deps.agent.tools``). Populated by ``initMcpTools`` when MCP servers
+   * are configured so discovered tools are merged in without mutating the
+   * shared ``AgentOptions`` object. Code that needs the effective tool list
+   * should read ``this.resolvedTools ?? this.deps.agent.tools``.
+   */
+  resolvedTools = null;
   llmLoop = null;
   /**
    * Per-call tool executor — provides retry-with-exponential-backoff and a
@@ -4524,6 +5329,17 @@ var StreamHandler = class _StreamHandler {
   userTranscriptPending = false;
   pendingAssistantTurn = null;
   pendingAssistantTimer = null;
+  /**
+   * Reserved monotonic turn index for the in-flight Realtime turn (issue
+   * #154, fix 5/6). Reserved in ``onAdapterSpeechStopped`` via
+   * ``metricsAcc.reserveTurnIndex()`` the moment the turn OPENS, then threaded
+   * through to the live per-line transcript events (``recordTranscriptLine``)
+   * and into ``recordTurnComplete`` / ``recordTurnInterrupted`` so the
+   * dashboard can sort a late-arriving user line ABOVE its agent line by
+   * ``(turnIndex, role)``. ``null`` until the first turn opens. Parity with
+   * Python ``_current_turn_index``.
+   */
+  currentTurnIndex = null;
   /**
    * Hard cap on how long we wait for the user transcript before flushing
    * the buffered assistant turn alone. 3 s covers OpenAI Whisper's typical
@@ -4605,6 +5421,23 @@ var StreamHandler = class _StreamHandler {
    * streaming/regular LLM, WebSocket remote, Realtime response_done) so the
    * payload shape lives in one place.
    */
+  /**
+   * Emit a live per-line transcript event to the dashboard store (issue #154,
+   * fix 5). Routed through a single helper so the call shape lives in one
+   * place. ``recordTranscriptLine`` appends the line to the active call's
+   * transcript and publishes a ``transcript_line`` SSE event; the dashboard
+   * sorts by (turnIndex, user<assistant) so a late user line lands above its
+   * agent line. No-op when no turn index has been reserved yet.
+   */
+  emitTranscriptLine(role, text) {
+    if (this.currentTurnIndex === null) return;
+    this.deps.metricsStore.recordTranscriptLine({
+      call_id: this.callId,
+      turnIndex: this.currentTurnIndex,
+      role,
+      text
+    });
+  }
   async emitTurnMetrics(turn) {
     if (turn == null) return;
     this.deps.metricsStore.recordTurn({ call_id: this.callId, turn });
@@ -4646,8 +5479,8 @@ var StreamHandler = class _StreamHandler {
     this.ttsByteCarry = null;
   }
   /**
-   * Start call recording when configured. Currently Twilio-only — bridges may
-   * expose ``startRecording`` for parity when we add other carriers.
+   * Start call recording when configured. Bridges expose
+   * ``startRecording`` for carrier parity (Twilio and Telnyx supported).
    */
   async startRecordingIfRequested(callId) {
     const { recording, config } = this.deps;
@@ -4711,7 +5544,7 @@ var StreamHandler = class _StreamHandler {
     if (customParams.callee && !this.callee) this.callee = customParams.callee;
     const mode = this.deps.agent.engine ? `engine=${this.deps.agent.engine.kind ?? "unknown"}` : "pipeline";
     getLogger().info(
-      `Call started: ${callId} (${this.deps.bridge.label}, ${mode}, ${sanitizeLogValue(this.caller || "?")} \u2192 ${sanitizeLogValue(this.callee || "?")})`
+      `Call started: ${callId} (${this.deps.bridge.label}, ${mode}, ${maskPhoneNumber(this.caller || "?")} \u2192 ${maskPhoneNumber(this.callee || "?")})`
     );
     if (Object.keys(customParams).length > 0) {
       getLogger().debug(`Custom params: ${sanitizeLogValue(JSON.stringify(customParams))}`);
@@ -4756,10 +5589,13 @@ var StreamHandler = class _StreamHandler {
     const resolvedPrompt = Object.keys(allVars).length > 0 ? this.deps.resolveVariables(this.deps.agent.systemPrompt, allVars) : this.deps.agent.systemPrompt;
     const provider2 = this.deps.agent.provider ?? "openai_realtime";
     await this.initMcpTools();
+    this.injectConsultTool();
     if (provider2 === "pipeline") {
       await this.initPipeline(resolvedPrompt);
     } else {
-      await this.initRealtimeAdapter(resolvedPrompt);
+      await this.initRealtimeAdapter(
+        applyToolCallPreambles(resolvedPrompt, this.deps.agent.toolCallPreambles)
+      );
     }
   }
   /**
@@ -4784,10 +5620,25 @@ var StreamHandler = class _StreamHandler {
     }
     if (discovered.length === 0) return;
     MCPManager.assertNoConflicts(this.deps.agent.tools, discovered);
-    const mutableAgent = this.deps.agent;
-    mutableAgent.tools = [...mutableAgent.tools ?? [], ...discovered];
+    this.resolvedTools = [...this.deps.agent.tools ?? [], ...discovered];
     getLogger().info(`MCP: merged ${discovered.length} tool(s) into agent`);
   }
+  /**
+   * Merge the built-in ``consult`` tool into the per-call tool list when
+   * ``agent.consult`` is set, mirroring {@link initMcpTools}: the shared
+   * ``deps.agent`` is NOT mutated; the merged list is stored on
+   * ``this.resolvedTools`` so ``buildAIAdapter`` (Realtime) and the pipeline
+   * ``LLMLoop`` both see it. Idempotent — a no-op if a tool with the same name
+   * is already present.
+   */
+  injectConsultTool() {
+    const consult = this.deps.agent.consult;
+    if (!consult) return;
+    const consultTool = buildConsultTool(consult);
+    const base = this.resolvedTools ?? (this.deps.agent.tools ?? []);
+    if (base.some((t) => t.name === consultTool.name)) return;
+    this.resolvedTools = [...base, consultTool];
+  }
   /** Set the stream SID (Twilio only, called after parsing 'start' event). */
   /** Set the carrier-side stream id (Twilio `streamSid` / Telnyx stream identifier). */
   setStreamSid(sid) {
@@ -4807,8 +5658,12 @@ var StreamHandler = class _StreamHandler {
       if (activeVad && !this.vadDisabled) {
         try {
           const vadPromise = activeVad.processFrame(pcm16k, 16e3);
-          const timeoutPromise = new Promise((resolve2) => setTimeout(() => resolve2(null), 25));
+          let vadTimeoutId;
+          const timeoutPromise = new Promise((resolve2) => {
+            vadTimeoutId = setTimeout(() => resolve2(null), 25);
+          });
           const evt = await Promise.race([vadPromise, timeoutPromise]);
+          clearTimeout(vadTimeoutId);
           if (evt) {
             getLogger().info(
               `[VAD] ${evt.type}  agentSpeaking=${this.isSpeaking}`
@@ -4881,7 +5736,7 @@ var StreamHandler = class _StreamHandler {
         if ((this.deps.agent.bargeInThresholdMs ?? 300) === 0) return;
       }
       const hooks = this.deps.agent.hooks;
-      if (hooks) {
+      if (hooks?.beforeSendToStt) {
         const hookExecutor = new PipelineHookExecutor(hooks);
         const hookCtx = this.buildHookContext();
         const processed = await hookExecutor.runBeforeSendToStt(pcm16k, hookCtx);
@@ -4893,7 +5748,7 @@ var StreamHandler = class _StreamHandler {
         this.metricsAcc.addSttAudioBytes(pcm16k.length);
       }
     } else if (this.adapter) {
-      if (this.adapter instanceof ElevenLabsConvAIAdapter && this.deps.bridge.telephonyProvider === "twilio" && this.adapter.inputAudioFormat !== "ulaw_8000") {
+      if (this.adapter instanceof ElevenLabsConvAIAdapter && this.deps.bridge.inputWireFormat === "ulaw_8000" && this.adapter.inputAudioFormat !== "ulaw_8000") {
         const pcm8k = mulawToPcm16(audioBuffer);
         const pcm16k = this.inboundResampler.process(pcm8k);
         this.adapter.sendAudio(pcm16k);
@@ -5054,6 +5909,7 @@ var StreamHandler = class _StreamHandler {
     const carrier = this.deps.bridge.telephonyProvider;
     if (carrier === "twilio") return fmt === "ulaw_8000";
     if (carrier === "telnyx") return fmt === "pcm_16000";
+    if (carrier === "plivo") return fmt === "ulaw_8000";
     return false;
   }
   /**
@@ -5151,7 +6007,7 @@ var StreamHandler = class _StreamHandler {
     }
     if (!this.deps.agent.vad) {
       try {
-        const { SileroVAD } = await import("./silero-vad-LNDFGIY7.mjs");
+        const { SileroVAD } = await import("./silero-vad-RGF5HCIR.mjs");
         this.autoVad = await SileroVAD.forPhoneCall();
         getLogger().info(
           `auto-VAD enabled (SileroVAD, phone preset). Pass agent.vad=\u2026 to override.`
@@ -5170,12 +6026,9 @@ var StreamHandler = class _StreamHandler {
       }
     }
     if (this.deps.agent.echoCancellation) {
-      const carrier = this.deps.bridge.telephonyProvider;
-      if (carrier === "twilio" || carrier === "telnyx") {
-        getLogger().warn(
-          `echoCancellation: true on ${carrier} (PSTN). Server-side NLMS cannot model PSTN's ~250\u20131500 ms round-trip echo with a 32 ms filter window \u2014 it will silently no-op. Best practice: keep echoCancellation: false; rely on the carrier + caller device's built-in echo suppression and Patter's self-hearing guard. Enable AEC only for browser/native deployments where the SDK owns the audio path end-to-end.`
-        );
-      }
+      getLogger().warn(
+        `echoCancellation: true on ${this.deps.bridge.telephonyProvider} (PSTN). Server-side NLMS cannot model PSTN's ~250\u20131500 ms round-trip echo with a 32 ms filter window \u2014 it will silently no-op. Best practice: keep echoCancellation: false; rely on the carrier + caller device's built-in echo suppression and Patter's self-hearing guard. Enable AEC only for browser/native deployments where the SDK owns the audio path end-to-end.`
+      );
       try {
         const { NlmsEchoCanceller } = await import("./aec-PJJMUM5E.mjs");
         this.aec = new NlmsEchoCanceller({ sampleRate: 16e3 });
@@ -5308,13 +6161,20 @@ var StreamHandler = class _StreamHandler {
         );
       }
       const providerModel = this.deps.agent.llm?.model ?? "";
+      const augmentedTools = augmentWithBuiltinHandoffTools(
+        this.resolvedTools ?? this.deps.agent.tools,
+        {
+          transferCall: (number) => this.deps.bridge.transferCall(this.callId, number),
+          endCall: () => this.deps.bridge.endCall(this.callId, this.ws)
+        }
+      );
       this.llmLoop = new LLMLoop(
         "",
         // apiKey unused when llmProvider is supplied
         providerModel,
         // propagate so calculateLlmCost can match the price row
         resolvedPrompt,
-        this.deps.agent.tools,
+        augmentedTools,
         this.deps.agent.llm,
         this.deps.agent.disablePhonePreamble ?? false
       );
@@ -5325,11 +6185,18 @@ var StreamHandler = class _StreamHandler {
     } else if (!this.deps.onMessage && this.deps.config.openaiKey) {
       let llmModel = this.deps.agent.model || "gpt-4o-mini";
       if (llmModel.includes("realtime")) llmModel = "gpt-4o-mini";
+      const augmentedTools = augmentWithBuiltinHandoffTools(
+        this.resolvedTools ?? this.deps.agent.tools,
+        {
+          transferCall: (number) => this.deps.bridge.transferCall(this.callId, number),
+          endCall: () => this.deps.bridge.endCall(this.callId, this.ws)
+        }
+      );
       this.llmLoop = new LLMLoop(
         this.deps.config.openaiKey,
         llmModel,
         resolvedPrompt,
-        this.deps.agent.tools,
+        augmentedTools,
         void 0,
         this.deps.agent.disablePhonePreamble ?? false
       );
@@ -5843,7 +6710,7 @@ var StreamHandler = class _StreamHandler {
   // ---------------------------------------------------------------------------
   async initRealtimeAdapter(resolvedPrompt) {
     const label = this.deps.bridge.label;
-    this.adapter = this.deps.buildAIAdapter(resolvedPrompt);
+    this.adapter = this.deps.buildAIAdapter(resolvedPrompt, this.resolvedTools ?? void 0);
     let parked;
     if (typeof this.deps.popPrewarmedConnections === "function") {
       try {
@@ -5916,6 +6783,7 @@ var StreamHandler = class _StreamHandler {
     response_done: async (eventData) => this.onAdapterResponseDone(eventData),
     speech_started: async () => this.onAdapterSpeechInterrupt(),
     interruption: async () => this.onAdapterSpeechInterrupt(),
+    error: async (eventData) => this.onAdapterError(eventData),
     function_call: async (eventData) => {
       if (this.adapter instanceof OpenAIRealtimeAdapter) {
         await this.handleFunctionCall(eventData);
@@ -6002,21 +6870,31 @@ var StreamHandler = class _StreamHandler {
     if (!this.metricsAcc.turnActive) this.metricsAcc.startTurn();
     this.currentAgentText = "";
     this.responseAudioStarted = false;
+    this.currentTurnIndex = this.metricsAcc.reserveTurnIndex();
     this.userTranscriptPending = true;
     await this.emitUserSpeechEnded();
   }
   async onAdapterTranscriptInput(inputText) {
-    const stripped = inputText.trim().toLowerCase();
-    if (HALLUCINATIONS.has(stripped) || stripped === "") {
+    if (isSttHallucination(inputText)) {
       getLogger().debug(
         `Realtime transcript_input dropped (likely Whisper hallucination on silence/echo): ${sanitizeLogValue(inputText.slice(0, 60))}`
       );
       this.userTranscriptPending = false;
+      if (this.pendingAssistantTurn !== null) {
+        const buffered = this.pendingAssistantTurn;
+        this.pendingAssistantTurn = null;
+        if (this.pendingAssistantTimer) {
+          clearTimeout(this.pendingAssistantTimer);
+          this.pendingAssistantTimer = null;
+        }
+        await this.flushAssistantTurn(buffered);
+      }
       return;
     }
     getLogger().debug(`User (${this.deps.bridge.label}): ${sanitizeLogValue(inputText)}`);
     this.history.push({ role: "user", text: inputText, timestamp: Date.now() });
-    if (this.adapter instanceof OpenAIRealtimeAdapter) {
+    this.emitTranscriptLine("user", inputText);
+    if (this.adapter instanceof OpenAIRealtimeAdapter && this.adapter.getGateResponseOnTranscript()) {
       void this.adapter.requestResponse().catch(
         (err) => getLogger().debug(`Realtime requestResponse failed: ${String(err)}`)
       );
@@ -6063,8 +6941,12 @@ var StreamHandler = class _StreamHandler {
         history: [...this.history.entries]
       });
     }
+    const reservedIndex = this.currentTurnIndex;
+    this.emitTranscriptLine("assistant", text);
     this.responseAudioStarted = false;
-    await this.emitTurnMetrics(this.metricsAcc.recordTurnComplete(text));
+    await this.emitTurnMetrics(
+      this.metricsAcc.recordTurnComplete(text, reservedIndex ?? void 0)
+    );
   }
   /**
    * Push an assistant turn into history and fire `onTranscript` so host
@@ -6163,7 +7045,9 @@ var StreamHandler = class _StreamHandler {
         this.pendingAssistantTimer = null;
         this.userTranscriptPending = false;
         if (buffered !== null) {
-          void this.flushAssistantTurn(buffered);
+          this.flushAssistantTurn(buffered).catch(
+            (err) => getLogger().error("flushAssistantTurn (fallback timer) failed:", err)
+          );
         }
       }, _StreamHandler.REALTIME_USER_TRANSCRIPT_WAIT_MS);
       this.responseAudioStarted = false;
@@ -6172,7 +7056,9 @@ var StreamHandler = class _StreamHandler {
     await this.flushAssistantTurn(text);
   }
   async onAdapterSpeechInterrupt() {
-    if (this.adapter instanceof OpenAIRealtimeAdapter) {
+    const isEngine = this.adapter instanceof OpenAIRealtimeAdapter;
+    const clientManaged = isEngine && this.adapter.getGateResponseOnTranscript();
+    if (clientManaged) {
       const startedAt = this.adapter.currentResponseFirstAudioAt;
       if (startedAt !== null) {
         const elapsedMs = Date.now() - startedAt;
@@ -6185,12 +7071,20 @@ var StreamHandler = class _StreamHandler {
       }
     }
     this.deps.bridge.sendClear(this.ws, this.streamSid);
-    if (this.adapter instanceof OpenAIRealtimeAdapter) this.adapter.cancelResponse();
+    if (clientManaged) {
+      this.metricsAcc.recordBargeinDetected();
+      this.adapter.cancelResponse();
+    } else if (isEngine) {
+      this.adapter.truncate();
+    }
     this.metricsAcc.recordTurnInterrupted();
     if (this.responseAudioStarted) {
       await this.emitAgentSpeechEnded(true);
     }
     await this.emitUserSpeechStarted();
+    if (clientManaged) {
+      this.metricsAcc.anchorUserSpeechStart();
+    }
     this.currentAgentText = "";
     this.responseAudioStarted = false;
     this.pendingAssistantTurn = null;
@@ -6200,6 +7094,28 @@ var StreamHandler = class _StreamHandler {
     }
     this.userTranscriptPending = false;
   }
+  /**
+   * Handle a Realtime ``error`` event (issue #154, fix 4).
+   *
+   * Both Realtime providers dispatch ``('error', …)`` for server-side errors,
+   * non-normal socket closes, and socket errors, but the stream handler
+   * previously had no entry for it in the dispatch table so these were
+   * silently swallowed. We surface them at WARN level with ONLY the error
+   * envelope fields (``type`` / ``code`` / ``message``) — never any audio or
+   * transcript body, to avoid logging PII. The call is NOT terminated: the
+   * provider decides whether to recover, and many of these (e.g. a transient
+   * ``input_audio_buffer_commit_empty``) are non-fatal. Parity with the
+   * Python ``elif ev_type == 'error'`` branches.
+   */
+  async onAdapterError(eventData) {
+    const err = eventData ?? {};
+    const type = typeof err.type === "string" ? err.type : "unknown";
+    const code = typeof err.code === "string" ? err.code : "";
+    const message = typeof err.message === "string" ? err.message : "";
+    getLogger().warn(
+      `Realtime error (${this.deps.bridge.label}) type=${type} code=${code} message=${sanitizeLogValue(message)}`
+    );
+  }
   /**
    * Emit a tool-invocation event into the transcript timeline. Pushes a
    * `role=tool` entry into `history` (so it appears in the dashboard
@@ -6267,7 +7183,8 @@ var StreamHandler = class _StreamHandler {
       }
       return;
     }
-    const toolDef = this.deps.agent.tools?.find((t) => t.name === fc.name);
+    const effectiveTools = this.resolvedTools ?? this.deps.agent.tools;
+    const toolDef = effectiveTools?.find((t) => t.name === fc.name);
     if (!toolDef) {
       getLogger().warn(`Realtime tool '${fc.name}' not found in agent.tools \u2014 skipping`);
       const result2 = JSON.stringify({ error: `Tool '${fc.name}' not registered`, fallback: true });
@@ -6290,7 +7207,8 @@ var StreamHandler = class _StreamHandler {
       if (msg && this.adapter instanceof OpenAIRealtimeAdapter) {
         const realtimeAdapter = this.adapter;
         reassuranceTimer = setTimeout(() => {
-          realtimeAdapter.sendText(msg).catch((e) => {
+          const fire = typeof realtimeAdapter.sendReassurance === "function" ? realtimeAdapter.sendReassurance(msg) : realtimeAdapter.sendText(msg);
+          fire.catch((e) => {
             getLogger().warn(`Reassurance message failed for tool '${fc.name}': ${String(e)}`);
           });
         }, afterMs);
@@ -6310,7 +7228,8 @@ var StreamHandler = class _StreamHandler {
         parsedArgs,
         {
           call_id: this.callId,
-          caller: this.caller
+          caller: this.caller,
+          callee: this.callee
         },
         onProgress
       );
@@ -6418,7 +7337,7 @@ async function queryDeepgramCost(metricsAcc, deepgramKey, deepgramRequestId) {
 
 // src/services/call-log.ts
 init_esm_shims();
-import * as crypto3 from "crypto";
+import * as crypto4 from "crypto";
 import * as fs3 from "fs";
 import { promises as fsp } from "fs";
 import * as os from "os";
@@ -6463,7 +7382,7 @@ function redactPhone(raw) {
   const mode = redactMode();
   if (mode === "full") return raw;
   if (mode === "hash_only") {
-    return "sha256:" + crypto3.createHash("sha256").update(raw, "utf8").digest("hex").slice(0, 16);
+    return "sha256:" + crypto4.createHash("sha256").update(raw, "utf8").digest("hex").slice(0, 16);
   }
   return maskPhoneNumber(raw);
 }
@@ -6474,7 +7393,7 @@ function utcIso(tsSeconds) {
 async function atomicWriteJson(filePath, payload) {
   const dir = path3.dirname(filePath);
   await fsp.mkdir(dir, { recursive: true });
-  const tmp = path3.join(dir, `.tmp.${process.pid}.${crypto3.randomBytes(4).toString("hex")}.json`);
+  const tmp = path3.join(dir, `.tmp.${process.pid}.${crypto4.randomBytes(4).toString("hex")}.json`);
   try {
     const handle = await fsp.open(tmp, "w");
     try {
@@ -6559,8 +7478,10 @@ var CallLogger = class {
     } catch (err) {
       getLogger().warn(`call_log write failed (${sanitizeLogValue(callId)}): ${sanitizeLogValue(String(err))}`);
     }
-    if (crypto3.randomBytes(1)[0] < 5) {
-      this.sweepOldDays();
+    if (crypto4.randomBytes(1)[0] < 5) {
+      void this.sweepOldDays().catch(
+        (e) => getLogger().debug(`call_log sweep failed: ${sanitizeLogValue(String(e))}`)
+      );
     }
   }
   /** Append a single turn record to the call's `transcript.jsonl`. */
@@ -6635,23 +7556,27 @@ var CallLogger = class {
     }
   }
   // --- Retention ---------------------------------------------------------
-  sweepOldDays() {
+  async sweepOldDays() {
     if (this.root === null) return;
     const days = retentionDays();
     if (days === 0) return;
     const cutoff = Date.now() / 1e3 - days * 86400;
     const callsRoot = path3.join(this.root, "calls");
-    if (!fs3.existsSync(callsRoot)) return;
     try {
-      for (const yearName of fs3.readdirSync(callsRoot)) {
+      await fsp.access(callsRoot);
+    } catch {
+      return;
+    }
+    try {
+      for (const yearName of await fsp.readdir(callsRoot)) {
         if (!/^\d+$/.test(yearName)) continue;
         const yearDir = path3.join(callsRoot, yearName);
-        if (!fs3.statSync(yearDir).isDirectory()) continue;
-        for (const monthName of fs3.readdirSync(yearDir)) {
+        if (!(await fsp.stat(yearDir)).isDirectory()) continue;
+        for (const monthName of await fsp.readdir(yearDir)) {
           if (!/^\d+$/.test(monthName)) continue;
           const monthDir = path3.join(yearDir, monthName);
-          if (!fs3.statSync(monthDir).isDirectory()) continue;
-          for (const dayName of fs3.readdirSync(monthDir)) {
+          if (!(await fsp.stat(monthDir)).isDirectory()) continue;
+          for (const dayName of await fsp.readdir(monthDir)) {
             if (!/^\d+$/.test(dayName)) continue;
             const dayDir = path3.join(monthDir, dayName);
             const y = Number.parseInt(yearName, 10);
@@ -6659,16 +7584,16 @@ var CallLogger = class {
             const d = Number.parseInt(dayName, 10);
             const ts = Date.UTC(y, m - 1, d) / 1e3;
             if (ts < cutoff) {
-              rmTree(dayDir);
+              await rmTreeAsync(dayDir);
             }
           }
           try {
-            if (fs3.readdirSync(monthDir).length === 0) fs3.rmdirSync(monthDir);
+            if ((await fsp.readdir(monthDir)).length === 0) await fsp.rmdir(monthDir);
           } catch {
           }
         }
         try {
-          if (fs3.readdirSync(yearDir).length === 0) fs3.rmdirSync(yearDir);
+          if ((await fsp.readdir(yearDir)).length === 0) await fsp.rmdir(yearDir);
         } catch {
         }
       }
@@ -6677,21 +7602,21 @@ var CallLogger = class {
     }
   }
 };
-function rmTree(target) {
+async function rmTreeAsync(target) {
   try {
-    for (const child of fs3.readdirSync(target)) {
+    for (const child of await fsp.readdir(target)) {
       const childPath = path3.join(target, child);
-      const stat = fs3.lstatSync(childPath);
+      const stat = await fsp.lstat(childPath);
       if (stat.isDirectory()) {
-        rmTree(childPath);
+        await rmTreeAsync(childPath);
       } else {
         try {
-          fs3.unlinkSync(childPath);
+          await fsp.unlink(childPath);
         } catch {
         }
       }
     }
-    fs3.rmdirSync(target);
+    await fsp.rmdir(target);
   } catch {
   }
 }
@@ -6739,13 +7664,29 @@ function classifyTelnyxAmd(result) {
   if (result === "fax") return "fax";
   return "unknown";
 }
-function validateWebhookUrl(url) {
+function twilioStatusToOutcome(callStatus) {
+  const s = (callStatus || "").toLowerCase();
+  if (s === "no-answer") return "no_answer";
+  if (s === "busy") return "busy";
+  return "failed";
+}
+function telnyxHangupOutcome(cause) {
+  const c = (cause || "").toLowerCase();
+  if (c === "no_answer" || c === "timeout" || c === "no_user_response") return "no_answer";
+  if (c === "user_busy" || c === "busy") return "busy";
+  if (c === "call_rejected" || c === "rejected" || c === "destination_out_of_order") return "failed";
+  return null;
+}
+function validateWebhookUrl(url, allowLoopback = false) {
   const parsed = new URL(url);
   if (!["http:", "https:"].includes(parsed.protocol)) {
     throw new Error(`Invalid webhook URL scheme: ${parsed.protocol}`);
   }
   const rawHost = parsed.hostname;
   const host = rawHost.replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
+  if (allowLoopback) {
+    return;
+  }
   const BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
     "localhost",
     "ip6-localhost",
@@ -6787,6 +7728,34 @@ function validateWebhookUrl(url) {
     }
   }
 }
+function extractHost(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  let host = trimmed.replace(/^[a-z]+:\/\//i, "").replace(/\/.*$/, "");
+  if (host.startsWith("[")) {
+    return host.slice(1).split("]", 1)[0].toLowerCase();
+  }
+  if (!host.includes("::")) {
+    const lastColon = host.lastIndexOf(":");
+    if (lastColon !== -1 && /^\d+$/.test(host.slice(lastColon + 1))) {
+      host = host.slice(0, lastColon);
+    }
+  }
+  return host.toLowerCase();
+}
+function isLoopbackHost(value) {
+  const host = extractHost(value);
+  if (!host) return false;
+  if (host === "localhost" || host === "ip6-localhost" || host === "ip6-loopback") {
+    return true;
+  }
+  if (host === "::1" || host === "::ffff:127.0.0.1") return true;
+  const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (v4) {
+    return parseInt(v4[1], 10) === 127;
+  }
+  return false;
+}
 function validateTelnyxSignature(rawBody, signature, timestamp, publicKey, toleranceSec = 300) {
   try {
     const ts = parseInt(timestamp, 10);
@@ -6796,7 +7765,7 @@ function validateTelnyxSignature(rawBody, signature, timestamp, publicKey, toler
     if (ageMs < 0 || ageMs > toleranceSec * 1e3) return false;
     const payload = `${timestamp}|${rawBody}`;
     const keyBuffer = Buffer.from(publicKey, "base64");
-    const keyObject = crypto4.createPublicKey({
+    const keyObject = crypto5.createPublicKey({
       key: keyBuffer,
       format: "der",
       type: "spki"
@@ -6806,7 +7775,7 @@ function validateTelnyxSignature(rawBody, signature, timestamp, publicKey, toler
       if (!trimmed) continue;
       try {
         const sigBuffer = Buffer.from(trimmed, "base64");
-        if (crypto4.verify(null, Buffer.from(payload), keyObject, sigBuffer)) {
+        if (crypto5.verify(null, Buffer.from(payload), keyObject, sigBuffer)) {
           return true;
         }
       } catch {
@@ -6823,12 +7792,12 @@ function validateTwilioSid(sid, prefix = "CA") {
 }
 function validateTwilioSignature(url, params, signature, authToken) {
   const data = url + Object.keys(params).sort().reduce((acc, key) => acc + key + (params[key] ?? ""), "");
-  const expected = crypto4.createHmac("sha1", authToken).update(data).digest("base64");
+  const expected = crypto5.createHmac("sha1", authToken).update(data).digest("base64");
   try {
     const sigBuf = Buffer.from(signature);
     const expBuf = Buffer.from(expected);
     if (sigBuf.length !== expBuf.length) return false;
-    return crypto4.timingSafeEqual(sigBuf, expBuf);
+    return crypto5.timingSafeEqual(sigBuf, expBuf);
   } catch {
     return false;
   }
@@ -6850,7 +7819,7 @@ function resolveVariables(template, variables) {
   }
   return result;
 }
-function buildAIAdapter(config, agent, resolvedPrompt) {
+function buildAIAdapter(config, agent, resolvedPrompt, toolsOverride) {
   const engine = agent.engine;
   if (agent.provider === "elevenlabs_convai") {
     if (!engine || engine.kind !== "elevenlabs_convai") {
@@ -6865,12 +7834,24 @@ function buildAIAdapter(config, agent, resolvedPrompt) {
       agent.firstMessage ?? ""
     );
   }
-  const agentTools = agent.tools?.map((t) => ({
-    name: t.name,
-    description: t.description,
-    parameters: t.parameters,
-    strict: t.strict
-  })) ?? [];
+  const preamblesOn = Boolean(agent.toolCallPreambles);
+  const agentTools = (toolsOverride ?? agent.tools)?.map((t) => {
+    let description = t.description;
+    const reassurance = t.reassurance;
+    const sample = typeof reassurance === "string" ? reassurance : void 0;
+    if (preamblesOn && sample) {
+      description = `${description}
+
+Preamble sample phrases:
+- ${sample}`;
+    }
+    return {
+      name: t.name,
+      description,
+      parameters: t.parameters,
+      strict: t.strict
+    };
+  }) ?? [];
   const tools = [...agentTools, TRANSFER_CALL_TOOL, END_CALL_TOOL];
   const isOpenAIEngine = engine && (engine.kind === "openai_realtime" || engine.kind === "openai_realtime_2");
   const openaiKey = isOpenAIEngine ? engine.apiKey : config.openaiKey ?? "";
@@ -6882,8 +7863,27 @@ function buildAIAdapter(config, agent, resolvedPrompt) {
     if (engine.inputAudioTranscriptionModel !== void 0) {
       adapterOptions.inputAudioTranscriptionModel = engine.inputAudioTranscriptionModel;
     }
+    if (engine.noiseReduction !== void 0) {
+      adapterOptions.noiseReduction = engine.noiseReduction;
+    }
+    if (engine.turnDetection !== void 0) {
+      adapterOptions.turnDetection = engine.turnDetection;
+    }
+    if (engine.gateResponseOnTranscript !== void 0) {
+      adapterOptions.gateResponseOnTranscript = engine.gateResponseOnTranscript;
+    }
+  }
+  const agentOpts = agent;
+  if (agentOpts.openaiRealtimeNoiseReduction !== void 0) {
+    adapterOptions.noiseReduction = agentOpts.openaiRealtimeNoiseReduction;
+  }
+  if (agentOpts.realtimeTurnDetection !== void 0) {
+    adapterOptions.turnDetection = agentOpts.realtimeTurnDetection;
+  }
+  if (agentOpts.openaiRealtimeGateResponseOnTranscript !== void 0) {
+    adapterOptions.gateResponseOnTranscript = agentOpts.openaiRealtimeGateResponseOnTranscript;
   }
-  const AdapterCtor = engine && engine.kind === "openai_realtime_2" ? OpenAIRealtime2Adapter : OpenAIRealtimeAdapter;
+  const AdapterCtor = OpenAIRealtime2Adapter;
   return new AdapterCtor(
     openaiKey,
     agent.model,
@@ -6901,6 +7901,7 @@ var TwilioBridge = class {
   config;
   label = "Twilio";
   telephonyProvider = "twilio";
+  inputWireFormat = "ulaw_8000";
   sendAudio(ws, audioBase64, streamSid) {
     ws.send(JSON.stringify({ event: "media", streamSid, media: { payload: audioBase64 } }));
   }
@@ -6916,6 +7917,11 @@ var TwilioBridge = class {
         getLogger().warn(`TwilioBridge.transferCall rejected: invalid CallSid ${JSON.stringify(callId)}`);
         return;
       }
+      const E164_RE = /^\+[1-9]\d{6,14}$/;
+      if (!E164_RE.test(toNumber)) {
+        getLogger().warn(`TwilioBridge.transferCall rejected: invalid target ${JSON.stringify(toNumber)}`);
+        return;
+      }
       const transferUrl = `https://api.twilio.com/2010-04-01/Accounts/${this.config.twilioSid}/Calls/${callId}.json`;
       await fetch(transferUrl, {
         method: "POST",
@@ -6997,6 +8003,11 @@ var TelnyxBridge = class {
   config;
   label = "Telnyx";
   telephonyProvider = "telnyx";
+  // ``streaming_start`` negotiates PCMU bidirectional by default — keeping
+  // ``ulaw_8000`` here matches what TwilioBridge does and keeps the stream
+  // handler's input-transcode branch in the right shape. If a deployment
+  // overrides the negotiation to L16, this should flip to ``pcm_16000``.
+  inputWireFormat = "ulaw_8000";
   sendAudio(ws, audioBase64, _streamSid) {
     ws.send(JSON.stringify({ event: "media", media: { payload: audioBase64 } }));
   }
@@ -7018,7 +8029,7 @@ var TelnyxBridge = class {
     });
     getLogger().info(`Telnyx call transferred to ${toNumber}`);
   }
-  async sendDtmf(callId, digits, delayMs) {
+  async sendDtmf(_ws, callId, digits, delayMs) {
     if (!digits) {
       getLogger().warn("TelnyxBridge.sendDtmf called with empty digits");
       return;
@@ -7126,7 +8137,7 @@ var TelnyxBridge = class {
 };
 var GRACEFUL_SHUTDOWN_TIMEOUT_MS = 1e4;
 var EmbeddedServer = class {
-  constructor(config, agent, onCallStart, onCallEnd, onTranscript, onMessage, recording = false, voicemailMessage = "", onMetrics, pricingOverrides, dashboard = true, dashboardToken = "") {
+  constructor(config, agent, onCallStart, onCallEnd, onTranscript, onMessage, recording = false, voicemailMessage = "", onMetrics, pricingOverrides, dashboard = true, dashboardToken = "", allowInsecureDashboard = false) {
     this.config = config;
     this.agent = agent;
     this.onCallStart = onCallStart;
@@ -7138,6 +8149,7 @@ var EmbeddedServer = class {
     this.onMetrics = onMetrics;
     this.dashboard = dashboard;
     this.dashboardToken = dashboardToken;
+    this.allowInsecureDashboard = allowInsecureDashboard;
     this.metricsStore = new MetricsStore();
     this.pricing = mergePricing(pricingOverrides);
     const logRoot = config.persistRoot === void 0 ? resolveLogRoot() : config.persistRoot;
@@ -7164,8 +8176,31 @@ var EmbeddedServer = class {
   onMetrics;
   dashboard;
   dashboardToken;
+  allowInsecureDashboard;
   server = null;
   wss = null;
+  /**
+   * Whether the dashboard + ``/api/*`` routes were mounted in ``start()``.
+   * The dashboard is now ALWAYS mounted when enabled (it never 404s): an
+   * exposed, token-less bind is protected with an auto-generated token
+   * rather than refused. This flag is therefore ``true`` whenever the
+   * dashboard is enabled — kept so the startup banner can gate on it.
+   */
+  dashboardMounted = false;
+  /**
+   * The token actually in effect for the dashboard + ``/api/*`` routes,
+   * resolved in ``start()``. One of: the explicit ``dashboardToken`` if set;
+   * a freshly generated UUID when the bind is exposed and
+   * ``allowInsecureDashboard`` is ``false``; or ``''`` (OPEN) for loopback
+   * local dev and for an exposed bind with ``allowInsecureDashboard=true``.
+   * Read by the startup banner (to print the ready URL with ``?token=``) and
+   * by authentic tests (to authenticate).
+   */
+  effectiveDashboardToken = "";
+  /** The token in effect for the dashboard, resolved at ``start()``. Empty string = served OPEN. */
+  get resolvedDashboardToken() {
+    return this.effectiveDashboardToken;
+  }
   twilioTokenWarningLogged = false;
   telnyxSigWarningLogged = false;
   metricsStore;
@@ -7183,12 +8218,14 @@ var EmbeddedServer = class {
   activeConnections = /* @__PURE__ */ new Set();
   activeCallIds = /* @__PURE__ */ new Map();
   /**
-   * Per-call AMD result callback set by ``Patter.call()`` for the most
-   * recent outbound call. Public so ``client.ts`` can populate it after
-   * server start. Cleared after firing once per call to avoid leaking
-   * across calls.
+   * Per-call AMD result callbacks keyed by CallSid / call_control_id.
+   * Public so ``client.ts`` can register a callback per outbound call.
+   * The Map slot is deleted after the callback fires once — preventing
+   * cross-call misfires when multiple concurrent outbound calls are in
+   * flight (single-slot was a race condition: the last registered callback
+   * would win for every in-flight AMD result).
    */
-  onMachineDetection;
+  onMachineDetectionByCallSid = /* @__PURE__ */ new Map();
   /**
    * Pre-warm first-message audio accessor wired by ``Patter.serve()``.
    * The per-call StreamHandler invokes this with its ``callId`` at the
@@ -7216,6 +8253,135 @@ var EmbeddedServer = class {
    * (tests) work without further setup. See FIX #91.
    */
   recordPrewarmWaste = () => void 0;
+  /**
+   * Per-callId completion deferreds for ``Patter.call({ wait: true })``.
+   * Resolved by the FIRST terminal signal: the Twilio/Telnyx status callback
+   * for no-media outcomes (no-answer / busy / failed), or ``onCallEnd`` for a
+   * connected call (answered / voicemail). The AMD classification is recorded
+   * per callId so the connected-call path can distinguish ``answered`` from
+   * ``voicemail``. This is what lets ``call({ wait: true })`` resolve to a
+   * structured {@link CallResult} without the caller hand-wiring ``onCallEnd``
+   * to a promise. Public so ``client.ts`` can register/await + fail in-flight
+   * waiters on ``disconnect()``. Mirrors Python's ``EmbeddedServer._completions``.
+   */
+  completions = /* @__PURE__ */ new Map();
+  /** AMD classification recorded per callId, used by the connected-call path. */
+  amdClass = /* @__PURE__ */ new Map();
+  // === Outbound completion registry (call({ wait: true })) ===
+  /**
+   * Register (or return) a completion promise for an outbound call.
+   *
+   * Called by ``Patter.call({ wait: true })`` immediately after the carrier
+   * accepts the dial — the promise resolves to a {@link CallResult} once a
+   * terminal signal arrives. Idempotent: returns the existing pending promise
+   * if one is already registered for ``callId``. Mirrors Python's
+   * ``register_completion``.
+   */
+  registerCompletion(callId) {
+    const existing = this.completions.get(callId);
+    if (existing && !existing.done) {
+      return existing.promise;
+    }
+    let resolve2;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve2 = res;
+      reject = rej;
+    });
+    this.completions.set(callId, { promise, resolve: resolve2, reject, done: false });
+    return promise;
+  }
+  /** Drop a registered completion (e.g. on a backstop timeout) without resolving it. */
+  deleteCompletion(callId) {
+    this.completions.delete(callId);
+    this.amdClass.delete(callId);
+  }
+  /**
+   * Resolve a pending completion with a {@link CallResult}.
+   *
+   * No-op when no completion is registered for ``callId`` (the common case —
+   * most calls are placed without ``wait: true``) or it is already done.
+   * Builds the result from the ``onCallEnd`` payload when ``data`` is provided
+   * (connected calls carry transcript + {@link CallMetrics}); no-media
+   * outcomes pass ``data`` undefined and yield an empty transcript / no cost.
+   * Mirrors Python's ``_resolve_completion``.
+   */
+  resolveCompletion(callId, args) {
+    const entry = this.completions.get(callId);
+    if (!entry || entry.done) return;
+    const data = args.data;
+    const metrics = data?.metrics ?? null;
+    const cost = metrics?.cost ?? null;
+    const durationRaw = metrics?.duration_seconds;
+    const duration = typeof durationRaw === "number" ? durationRaw : 0;
+    const transcriptRaw = data?.transcript;
+    const transcript = Array.isArray(transcriptRaw) ? transcriptRaw : [];
+    const result = {
+      callId,
+      outcome: args.outcome,
+      status: args.status,
+      durationSeconds: duration,
+      transcript,
+      cost,
+      metrics
+    };
+    entry.done = true;
+    entry.resolve(result);
+    this.completions.delete(callId);
+    this.amdClass.delete(callId);
+  }
+  /**
+   * Fail every in-flight completion with ``error``. Called by
+   * ``Patter.disconnect()`` so a ``call({ wait: true })`` awaiter does not
+   * hang until its backstop timeout once the server is gone. Mirrors the
+   * Python ``disconnect()`` change that fails in-flight ``wait=True`` awaiters.
+   */
+  failPendingCompletions(error) {
+    for (const entry of this.completions.values()) {
+      if (!entry.done) {
+        entry.done = true;
+        entry.reject(error);
+      }
+    }
+    this.completions.clear();
+    this.amdClass.clear();
+  }
+  /**
+   * Decide whether this server is reachable beyond loopback (127.0.0.1).
+   *
+   * The dashboard serves call transcripts and metadata (PII), so before
+   * mounting it unauthenticated we must know whether anyone off-host can
+   * reach the port. Signals (in order):
+   *
+   *   (a)+(b) — a public webhook URL. ``client.ts`` resolves
+   *       ``config.webhookUrl`` to the live hostname for every serve path:
+   *       a cloudflared quick-tunnel host, a {@link StaticTunnel} hostname,
+   *       or an explicit ``webhookUrl``. A tunnel directive (signal a) and a
+   *       public webhook URL (signal b) therefore both surface here as a
+   *       non-loopback, non-private webhook host. This is the case that
+   *       matters for tunnels — the whole port (dashboard included) is
+   *       published on a public ``*.trycloudflare.com`` URL.
+   *
+   *   (c) — an EXPLICIT non-loopback bind override via ``PATTER_BIND_HOST``.
+   *       Node's ``http.Server.listen(port, host)`` defaults to 127.0.0.1
+   *       here (see ``start()``), so plain local dev is never flagged; only
+   *       an operator who set ``PATTER_BIND_HOST`` to e.g. ``0.0.0.0`` is.
+   *
+   * Only loopback webhook hosts (127.0.0.0/8, localhost, ::1) are treated as
+   * not-exposed. RFC1918 / LAN hosts ARE exposure — they are reachable by
+   * other machines on the network — matching the Python SDK's gate.
+   */
+  isExposed() {
+    const bindOverride = process.env.PATTER_BIND_HOST;
+    if (bindOverride && !isLoopbackHost(bindOverride)) {
+      return true;
+    }
+    const host = extractHost(this.config.webhookUrl ?? "");
+    if (host && !isLoopbackHost(host)) {
+      return true;
+    }
+    return false;
+  }
   /** Bind HTTP + WebSocket listeners on `port`, mount carrier webhooks and dashboard routes. */
   async start(port = 8e3) {
     const webhookUrlPattern = /^[a-zA-Z0-9][a-zA-Z0-9.\-]+[a-zA-Z0-9]$/;
@@ -7251,6 +8417,9 @@ var EmbeddedServer = class {
           }
           next();
         });
+        req.on("error", (err) => {
+          next(err);
+        });
       } else {
         next();
       }
@@ -7261,8 +8430,25 @@ var EmbeddedServer = class {
       res.json({ status: "ok", mode: "local" });
     });
     if (this.dashboard) {
-      mountDashboard(app, this.metricsStore, this.dashboardToken);
-      mountApi(app, this.metricsStore, this.dashboardToken);
+      const exposed = this.isExposed();
+      if (this.dashboardToken) {
+        this.effectiveDashboardToken = this.dashboardToken;
+      } else if (exposed && !this.allowInsecureDashboard) {
+        this.effectiveDashboardToken = crypto5.randomUUID();
+        getLogger().warn(
+          `Dashboard is reachable beyond 127.0.0.1 without a configured token; protecting it with an auto-generated token. Open: http://127.0.0.1:${port}/?token=${this.effectiveDashboardToken}  Set dashboardToken for a stable token, or allowInsecureDashboard=true to serve it open.`
+        );
+      } else if (exposed && this.allowInsecureDashboard) {
+        this.effectiveDashboardToken = "";
+        getLogger().warn(
+          "Dashboard served WITHOUT authentication on a publicly-reachable bind (allowInsecureDashboard=true). Call transcripts and metadata are exposed to anyone who can reach this URL."
+        );
+      } else {
+        this.effectiveDashboardToken = "";
+      }
+      mountDashboard(app, this.metricsStore, this.effectiveDashboardToken);
+      mountApi(app, this.metricsStore, this.effectiveDashboardToken);
+      this.dashboardMounted = true;
     }
     app.post("/webhooks/twilio/status", (req, res) => {
       if (this.config.twilioToken) {
@@ -7279,8 +8465,10 @@ var EmbeddedServer = class {
         return;
       }
       const body = req.body;
-      const callSid = sanitizeLogValue(body["CallSid"] ?? "");
-      const callStatus = sanitizeLogValue(body["CallStatus"] ?? "");
+      const rawCallSid = body["CallSid"] ?? "";
+      const rawCallStatus = body["CallStatus"] ?? "";
+      const callSid = sanitizeLogValue(rawCallSid);
+      const callStatus = sanitizeLogValue(rawCallStatus);
       const duration = body["CallDuration"] ?? body["Duration"] ?? "";
       getLogger().info(
         `Twilio status ${callStatus} for call ${callSid} (duration=${duration})`
@@ -7297,6 +8485,10 @@ var EmbeddedServer = class {
         } catch (err) {
           getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
         }
+        this.resolveCompletion(rawCallSid, {
+          outcome: twilioStatusToOutcome(rawCallStatus),
+          status: rawCallStatus
+        });
       }
       res.status(204).send();
     });
@@ -7339,8 +8531,12 @@ var EmbeddedServer = class {
       const answeredBy = body["AnsweredBy"] ?? "";
       const callSid = body["CallSid"] ?? "";
       getLogger().info(`AMD result for ${sanitizeLogValue(callSid)}: ${sanitizeLogValue(answeredBy)}`);
-      const cb = this.onMachineDetection;
+      if (callSid) {
+        this.amdClass.set(callSid, classifyTwilioAmd(answeredBy));
+      }
+      const cb = callSid ? this.onMachineDetectionByCallSid.get(callSid) : void 0;
       if (cb && callSid) {
+        this.onMachineDetectionByCallSid.delete(callSid);
         try {
           await cb({
             call_id: callSid,
@@ -7464,8 +8660,12 @@ var EmbeddedServer = class {
         getLogger().info(
           `Telnyx AMD result for ${sanitizeLogValue(amdCallId)}: ${sanitizeLogValue(amdResult)}`
         );
-        const cbTx = this.onMachineDetection;
+        if (amdCallId) {
+          this.amdClass.set(amdCallId, classifyTelnyxAmd(amdResult));
+        }
+        const cbTx = amdCallId ? this.onMachineDetectionByCallSid.get(amdCallId) : void 0;
         if (cbTx && amdCallId) {
+          this.onMachineDetectionByCallSid.delete(amdCallId);
           try {
             await cbTx({
               call_id: amdCallId,
@@ -7500,6 +8700,13 @@ var EmbeddedServer = class {
           } catch (err) {
             getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
           }
+          const noMediaOutcome = telnyxHangupOutcome(hangupCause);
+          if (noMediaOutcome !== null) {
+            this.resolveCompletion(hangupCallId, {
+              outcome: noMediaOutcome,
+              status: hangupCause
+            });
+          }
         }
         return res.status(200).send();
       }
@@ -7552,6 +8759,126 @@ var EmbeddedServer = class {
       }
       return res.status(200).send();
     });
+    const validatePlivoRequest = (req, res) => {
+      const authToken = this.config.plivoAuthToken;
+      if (!authToken) {
+        if (this.config.requireSignature !== false) {
+          getLogger().error(
+            "Plivo webhook rejected: plivoAuthToken not configured and requireSignature is not false"
+          );
+          res.status(503).send("Webhook signature required");
+          return false;
+        }
+        return true;
+      }
+      const method = req.method.toUpperCase();
+      const params = method === "POST" && req.body && typeof req.body === "object" ? Object.fromEntries(
+        Object.entries(req.body).map(([k, v]) => [k, String(v)])
+      ) : {};
+      const signature = req.headers["x-plivo-signature-v3"] || "";
+      const nonce = req.headers["x-plivo-signature-v3-nonce"] || "";
+      const url = `https://${this.config.webhookUrl}${req.originalUrl}`;
+      if (!validatePlivoSignature(url, nonce, signature, authToken, params, method)) {
+        getLogger().warn("Plivo webhook rejected: invalid or missing V3 signature");
+        res.status(403).send("Invalid signature");
+        return false;
+      }
+      return true;
+    };
+    app.post("/webhooks/plivo/voice", (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const body = req.body ?? {};
+      const callUuid = body["CallUUID"] ?? "";
+      const caller = body["From"] ?? "";
+      const callee = body["To"] ?? "";
+      const qs = `?caller=${encodeURIComponent(caller)}&callee=${encodeURIComponent(callee)}`;
+      const streamUrl = `wss://${this.config.webhookUrl}/ws/plivo/stream/${callUuid || "outbound"}${qs}`;
+      const xml = PlivoAdapter.generateStreamXml(streamUrl, "audio/x-mulaw;rate=8000", {
+        "X-PH-caller": caller,
+        "X-PH-callee": callee
+      });
+      res.type("text/xml").send(xml);
+    });
+    app.post("/webhooks/plivo/status", (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const body = req.body ?? {};
+      const callUuid = body["CallUUID"] ?? "";
+      const callStatus = body["CallStatus"] ?? body["Status"] ?? "";
+      const duration = body["Duration"] ?? body["BillDuration"] ?? "";
+      getLogger().info(
+        `Plivo status ${sanitizeLogValue(callStatus)} for call ${sanitizeLogValue(callUuid)} (duration=${duration})`
+      );
+      if (callUuid && callStatus) {
+        const extra = {};
+        const parsed = parseFloat(duration);
+        if (!Number.isNaN(parsed)) extra.duration_seconds = parsed;
+        this.metricsStore.updateCallStatus(callUuid, callStatus, extra);
+      }
+      if (callUuid && ["no-answer", "busy", "failed", "timeout", "cancel"].includes(callStatus)) {
+        try {
+          this.recordPrewarmWaste(callUuid);
+        } catch (err) {
+          getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
+        }
+        const outcome = callStatus === "no-answer" || callStatus === "timeout" ? "no_answer" : callStatus === "busy" ? "busy" : "failed";
+        this.resolveCompletion(callUuid, { outcome, status: callStatus });
+      }
+      res.status(200).send();
+    });
+    app.post("/webhooks/plivo/amd", async (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const body = req.body ?? {};
+      const callUuid = body["CallUUID"] ?? "";
+      const amdRaw = body["Machine"] || body["MachineDetection"] || body["AnsweredBy"] || body["CallStatus"] || "";
+      getLogger().info(`AMD result for ${sanitizeLogValue(callUuid)}: ${sanitizeLogValue(amdRaw)}`);
+      const classification = classifyPlivoAmd(amdRaw);
+      if (callUuid) this.amdClass.set(callUuid, classification);
+      let cbKey = callUuid && this.onMachineDetectionByCallSid.has(callUuid) ? callUuid : void 0;
+      if (cbKey === void 0 && this.onMachineDetectionByCallSid.size === 1) {
+        cbKey = this.onMachineDetectionByCallSid.keys().next().value;
+      }
+      const cb = cbKey !== void 0 ? this.onMachineDetectionByCallSid.get(cbKey) : void 0;
+      if (cb && callUuid) {
+        if (cbKey !== void 0) this.onMachineDetectionByCallSid.delete(cbKey);
+        try {
+          await cb({
+            call_id: callUuid,
+            carrier: "plivo",
+            classification,
+            raw: amdRaw,
+            detected_at: Date.now() / 1e3
+          });
+        } catch (err) {
+          getLogger().warn(`onMachineDetection callback threw: ${sanitizeLogValue(String(err))}`);
+        }
+      }
+      if (classification === "machine" && callUuid) {
+        try {
+          this.recordPrewarmWaste(callUuid);
+        } catch (err) {
+          getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
+        }
+        if (this.voicemailMessage && this.config.plivoAuthId && this.config.plivoAuthToken) {
+          await dropPlivoVoicemail(
+            callUuid,
+            this.voicemailMessage,
+            this.config.plivoAuthId,
+            this.config.plivoAuthToken
+          );
+        }
+      }
+      res.status(200).send();
+    });
+    app.all("/webhooks/plivo/transfer", (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const to = String(req.query.to ?? "");
+      if (!to || !/^\+[1-9]\d{6,14}$/.test(to)) {
+        getLogger().warn(`Plivo transfer XML: invalid target ${JSON.stringify(to)}`);
+        res.type("text/xml").send("<Response><Hangup/></Response>");
+        return;
+      }
+      res.type("text/xml").send(`<Response><Dial><Number>${xmlEscape(to)}</Number></Dial></Response>`);
+    });
     this.server = createServer(app);
     this.wss = new WebSocketServer({ noServer: true });
     const MAX_WS_PER_IP = 10;
@@ -7584,34 +8911,43 @@ var EmbeddedServer = class {
       ws.once("close", () => {
         this.activeConnections.delete(ws);
       });
-      const isTelnyx = this.config.telephonyProvider === "telnyx";
-      if (isTelnyx) {
+      const provider2 = this.config.telephonyProvider;
+      if (provider2 === "telnyx") {
         this.handleTelnyxStream(ws, url);
+      } else if (provider2 === "plivo") {
+        this.handlePlivoStream(ws, url);
       } else {
         this.handleTwilioStream(ws, url);
       }
     });
-    await new Promise((resolve2) => {
+    await new Promise((resolve2, reject) => {
       const bindHost = process.env.PATTER_BIND_HOST ?? "127.0.0.1";
+      this.server.once("error", reject);
       this.server.listen(port, bindHost, () => {
+        this.server.off("error", reject);
         getLogger().info(`Server on port ${port}`);
         getLogger().info(`Webhook: https://${this.config.webhookUrl}`);
         getLogger().info(`Phone:   ${this.config.phoneNumber}`);
         const model = this.agent.model ?? "";
-        if (model && model !== "gpt-4o-mini-realtime-preview" && model.includes("realtime")) {
+        const calibrated = ["gpt-realtime-mini", "gpt-4o-mini-realtime-preview"];
+        if (model && !calibrated.includes(model) && model.includes("realtime")) {
           getLogger().warn(
-            `Agent uses "${sanitizeLogValue(model)}" but DEFAULT_PRICING.openai_realtime is calibrated for "gpt-4o-mini-realtime-preview". Pass Patter({ pricing: { openai_realtime: {...} } }) to set rates for this model, otherwise the dashboard cost display will under-report.`
+            `Agent uses "${sanitizeLogValue(model)}" but DEFAULT_PRICING.openai_realtime is calibrated for the default Realtime models (gpt-realtime-mini / gpt-4o-mini-realtime-preview). Pass Patter({ pricing: { openai_realtime: {...} } }) to set rates for this model, otherwise the dashboard cost display will under-report.`
           );
         }
-        if (this.dashboard) {
-          console.log("\n\u2500\u2500\u2500\u2500 Dashboard \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-          getLogger().info(`URL: http://127.0.0.1:${port}/`);
-          if (!this.dashboardToken) {
+        if (this.dashboard && this.dashboardMounted) {
+          getLogger().info("\u2500\u2500\u2500\u2500 Dashboard \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+          if (this.effectiveDashboardToken) {
+            getLogger().info(
+              `URL: http://127.0.0.1:${port}/?token=${this.effectiveDashboardToken}`
+            );
+          } else {
+            getLogger().info(`URL: http://127.0.0.1:${port}/`);
             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."
             );
           }
-          console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+          getLogger().info("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
         }
         resolve2();
       });
@@ -7687,7 +9023,7 @@ var EmbeddedServer = class {
       onMessage: this.onMessage,
       onMetrics: wrappedMetrics,
       recording: this.recording,
-      buildAIAdapter: (resolvedPrompt) => buildAIAdapter(this.config, this.agent, resolvedPrompt),
+      buildAIAdapter: (resolvedPrompt, toolsOverride) => buildAIAdapter(this.config, this.agent, resolvedPrompt, toolsOverride),
       sanitizeVariables,
       resolveVariables,
       popPrewarmAudio: this.popPrewarmAudio,
@@ -7770,6 +9106,12 @@ var EmbeddedServer = class {
         }).catch((err) => getLogger().error(`call_log end error: ${String(err)}`));
       }
       if (userEnd) await userEnd(data);
+      const cid = typeof data.call_id === "string" ? data.call_id : "";
+      if (cid) {
+        const cls = this.amdClass.get(cid);
+        const outcome = cls === "machine" ? "voicemail" : "answered";
+        this.resolveCompletion(cid, { outcome, status: "completed", data });
+      }
     };
     return [wrappedStart, wrappedMetrics, wrappedEnd];
   }
@@ -7876,6 +9218,52 @@ var EmbeddedServer = class {
     });
   }
   // ---------------------------------------------------------------------------
+  // Plivo WebSocket message parser (thin layer)
+  // ---------------------------------------------------------------------------
+  handlePlivoStream(ws, url) {
+    const caller = url.searchParams.get("caller") ?? "";
+    const callee = url.searchParams.get("callee") ?? "";
+    const bridge = new PlivoBridge(this.config);
+    const handler = new StreamHandler(this.buildStreamHandlerDeps(bridge), ws, caller, callee);
+    ws.on("message", async (raw) => {
+      try {
+        let data;
+        try {
+          data = JSON.parse(raw.toString());
+        } catch (e) {
+          getLogger().error("Failed to parse Plivo WS message:", e);
+          return;
+        }
+        const event = data.event ?? "";
+        if (event === "start") {
+          handler.setStreamSid(data.start?.streamId ?? "");
+          const callId = data.start?.callId ?? "";
+          if (callId) this.activeCallIds.set(ws, callId);
+          await handler.handleCallStart(callId);
+        } else if (event === "media") {
+          const payload = data.media?.payload ?? "";
+          if (payload) handler.handleAudio(Buffer.from(payload, "base64"));
+        } else if (event === "playedStream") {
+          const markName = String(data.name ?? "");
+          if (markName) await handler.onMark(markName);
+        } else if (event === "dtmf") {
+          const digit = String(data.dtmf?.digit ?? "").trim();
+          if (digit) await handler.handleDtmf(digit);
+        } else if (event === "playFailed" || event === "error") {
+          getLogger().warn(`Plivo ${event}: ${data.reason ?? "unknown"}`);
+        } else if (event === "stop") {
+          await handler.handleStop();
+        }
+      } catch (err) {
+        getLogger().error("Stream handler error (Plivo):", err);
+      }
+    });
+    ws.on("close", async () => {
+      this.activeCallIds.delete(ws);
+      await handler.handleWsClose();
+    });
+  }
+  // ---------------------------------------------------------------------------
   // Graceful shutdown
   // ---------------------------------------------------------------------------
   /**
@@ -7892,10 +9280,10 @@ var EmbeddedServer = class {
     const httpClosePromise = new Promise((resolve2) => {
       this.server.close(() => resolve2());
     });
-    const isTelnyx = this.config.telephonyProvider === "telnyx";
+    const provider2 = this.config.telephonyProvider;
     for (const [ws, callId] of this.activeCallIds) {
       try {
-        const bridge = isTelnyx ? new TelnyxBridge(this.config) : new TwilioBridge(this.config);
+        const bridge = provider2 === "telnyx" ? new TelnyxBridge(this.config) : provider2 === "plivo" ? new PlivoBridge(this.config) : new TwilioBridge(this.config);
         await bridge.endCall(callId, ws);
       } catch {
       }
@@ -7909,17 +9297,18 @@ var EmbeddedServer = class {
     }
     if (this.activeConnections.size > 0) {
       getLogger().info(`Waiting for ${this.activeConnections.size} active connection(s) to close...`);
-      await Promise.race([
-        new Promise((resolve2) => {
-          const checkInterval = setInterval(() => {
-            if (this.activeConnections.size === 0) {
-              clearInterval(checkInterval);
-              resolve2();
-            }
-          }, 100);
-        }),
-        new Promise((resolve2) => setTimeout(resolve2, GRACEFUL_SHUTDOWN_TIMEOUT_MS))
-      ]);
+      let checkInterval;
+      const drainPromise = new Promise((resolve2) => {
+        checkInterval = setInterval(() => {
+          if (this.activeConnections.size === 0) {
+            clearInterval(checkInterval);
+            resolve2();
+          }
+        }, 100);
+      });
+      const timeoutPromise = new Promise((resolve2) => setTimeout(resolve2, GRACEFUL_SHUTDOWN_TIMEOUT_MS));
+      await Promise.race([drainPromise, timeoutPromise]);
+      clearInterval(checkInterval);
     }
     if (this.activeConnections.size > 0) {
       getLogger().info(`Force-closing ${this.activeConnections.size} remaining connection(s)`);
@@ -7966,10 +9355,13 @@ var CircuitBreakerRegistry = class {
     if (s.state === CircuitBreakerState.OPEN) {
       if (this.clock() - s.openedAt >= this.cooldownMs) {
         s.state = CircuitBreakerState.HALF_OPEN;
+        s.probeInFlight = true;
         return true;
       }
       return false;
     }
+    if (s.probeInFlight) return false;
+    s.probeInFlight = true;
     return true;
   }
   /** Mark a successful execution. Resets the breaker to CLOSED. */
@@ -7979,19 +9371,21 @@ var CircuitBreakerRegistry = class {
     s.state = CircuitBreakerState.CLOSED;
     s.consecutiveFailures = 0;
     s.openedAt = 0;
+    s.probeInFlight = false;
   }
   /** Mark a failed execution; trips OPEN once threshold is reached. */
   recordFailure(toolName) {
     if (this.threshold <= 0) return;
     let s = this.state.get(toolName);
     if (!s) {
-      s = { state: CircuitBreakerState.CLOSED, consecutiveFailures: 0, openedAt: 0 };
+      s = { state: CircuitBreakerState.CLOSED, consecutiveFailures: 0, openedAt: 0, probeInFlight: false };
       this.state.set(toolName, s);
     }
     s.consecutiveFailures += 1;
     if (s.consecutiveFailures >= this.threshold) {
       s.state = CircuitBreakerState.OPEN;
       s.openedAt = this.clock();
+      s.probeInFlight = false;
     }
   }
   /**
@@ -8016,7 +9410,18 @@ var CircuitBreakerRegistry = class {
 var DEFAULT_TOOL_MAX_RETRIES = 2;
 var DEFAULT_TOOL_RETRY_DELAY_MS = 500;
 var DEFAULT_TOOL_TIMEOUT_MS = 1e4;
+var MAX_TOOL_TIMEOUT_MS = 3e5;
 var TOOL_MAX_RESPONSE_BYTES = 1 * 1024 * 1024;
+var ToolTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolTimeoutError";
+  }
+};
+function resolveToolTimeoutMs(toolTimeoutMs, defaultMs) {
+  if (toolTimeoutMs === void 0) return defaultMs;
+  return Math.max(100, Math.min(toolTimeoutMs, MAX_TOOL_TIMEOUT_MS));
+}
 async function invokeHandler(handler, args, callContext, onProgress) {
   const invoked = handler(args, callContext);
   if (invoked && typeof invoked === "object" && typeof invoked[Symbol.asyncIterator] === "function" && typeof invoked.next === "function") {
@@ -8076,15 +9481,41 @@ var DefaultToolExecutor = class {
         retry_after_ms: cooldown
       });
     }
+    const effectiveTimeoutMs = resolveToolTimeoutMs(
+      toolDef.timeoutMs,
+      this.requestTimeoutMs
+    );
     if (toolDef.handler) {
       const totalAttempts = this.maxRetries + 1;
       let lastErr = null;
       for (let attempt = 0; attempt < totalAttempts; attempt++) {
+        let timeoutTimer;
         try {
-          const result = await invokeHandler(toolDef.handler, args, callContext, onProgress);
+          const handlerPromise = invokeHandler(toolDef.handler, args, callContext, onProgress);
+          const result = await Promise.race([
+            handlerPromise,
+            new Promise((_, reject) => {
+              timeoutTimer = setTimeout(
+                () => reject(
+                  new ToolTimeoutError(
+                    `Tool handler '${toolDef.name}' timed out after ${effectiveTimeoutMs}ms`
+                  )
+                ),
+                effectiveTimeoutMs
+              );
+            })
+          ]);
           this.breaker.recordSuccess(toolDef.name);
           return result;
         } catch (e) {
+          if (e instanceof ToolTimeoutError) {
+            getLogger().error(String(e));
+            this.breaker.recordFailure(toolDef.name);
+            return JSON.stringify({
+              error: String(e),
+              fallback: true
+            });
+          }
           lastErr = e;
           if (attempt < totalAttempts - 1) {
             getLogger().warn(
@@ -8092,6 +9523,8 @@ var DefaultToolExecutor = class {
             );
             await new Promise((r) => setTimeout(r, backoffDelayMs(this.retryDelayMs, attempt)));
           }
+        } finally {
+          if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
         }
       }
       this.breaker.recordFailure(toolDef.name);
@@ -8128,7 +9561,10 @@ var DefaultToolExecutor = class {
                   ...callContext,
                   attempt: attempt + 1
                 }),
-                signal: AbortSignal.timeout(this.requestTimeoutMs)
+                // Use per-tool timeout when set, otherwise fall back to
+                // the executor-level default. Mirrors Python's per-request
+                // ``timeout=`` override on httpx.AsyncClient.post().
+                signal: AbortSignal.timeout(effectiveTimeoutMs)
               });
               if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
               const result = JSON.stringify(await resp.json());
@@ -8278,7 +9714,7 @@ var OpenAILLMProvider = class {
       body.tools = tools;
     }
     const signal = mergeAbortSignals(opts?.signal, AbortSignal.timeout(3e4));
-    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -8298,50 +9734,55 @@ var OpenAILLMProvider = class {
     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;
-        }
-        if (chunk.usage) {
-          const cached = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
-          const uncachedInput = Math.max(0, (chunk.usage.prompt_tokens ?? 0) - cached);
-          yield {
-            type: "usage",
-            inputTokens: uncachedInput,
-            outputTokens: chunk.usage.completion_tokens,
-            cacheReadInputTokens: cached
-          };
-        }
-        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) {
+    try {
+      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;
+          }
+          if (chunk.usage) {
+            const cached = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+            const uncachedInput = Math.max(0, (chunk.usage.prompt_tokens ?? 0) - cached);
             yield {
-              type: "tool_call",
-              index: tc.index,
-              id: tc.id,
-              name: tc.function?.name,
-              arguments: tc.function?.arguments
+              type: "usage",
+              inputTokens: uncachedInput,
+              outputTokens: chunk.usage.completion_tokens,
+              cacheReadInputTokens: cached
             };
           }
+          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
+              };
+            }
+          }
         }
       }
+    } finally {
+      reader.cancel().catch(() => {
+      });
     }
   }
 };
@@ -8475,7 +9916,7 @@ ${systemPrompt}` : DEFAULT_PHONE_PREAMBLE;
             chunk.inputTokens ?? 0,
             chunk.outputTokens ?? 0,
             chunk.cacheReadInputTokens ?? 0,
-            chunk.cacheCreationInputTokens ?? 0
+            chunk.cacheWriteInputTokens ?? 0
           );
         } else if (chunk.type === "tool_call") {
           hasToolCalls = true;
@@ -8704,12 +10145,12 @@ var TestSession = class {
           }
           continue;
         }
-        conversationHistory.push({
-          role: "user",
-          text: userInput,
-          timestamp: Date.now()
-        });
         if (onMessage) {
+          conversationHistory.push({
+            role: "user",
+            text: userInput,
+            timestamp: Date.now()
+          });
           try {
             const responseText = await onMessage({
               text: userInput,
@@ -8739,6 +10180,11 @@ var TestSession = class {
           }
           log.info("");
           const responseText = parts.join("");
+          conversationHistory.push({
+            role: "user",
+            text: userInput,
+            timestamp: Date.now()
+          });
           if (responseText) {
             conversationHistory.push({
               role: "assistant",
@@ -8770,11 +10216,14 @@ var TestSession = class {
 export {
   ErrorCode,
   PatterError,
+  PatterConfigError,
   PatterConnectionError,
   AuthenticationError,
   ProvisionError,
   RateLimitError,
   ElevenLabsConvAIAdapter,
+  PlivoAdapter,
+  Carrier,
   PRICING_VERSION,
   PRICING_LAST_UPDATED,
   PricingUnit,
@@ -8811,6 +10260,8 @@ export {
   mergeAbortSignals,
   OpenAILLMProvider,
   LLMLoop,
+  openclawConsult,
+  openclawPostCallNotifier,
   DEFAULT_MIN_SENTENCE_LEN,
   SentenceChunker,
   PipelineHookExecutor,