getpatter 0.6.2 → 0.6.3

package/dist/{chunk-LE63CSOB.mjs → chunk-Z6W5XFWS.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 };
@@ -816,7 +1139,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);
 }
 
@@ -1422,15 +1745,15 @@ init_esm_shims();
 
 // src/dashboard/auth.ts
 init_esm_shims();
-import crypto from "crypto";
+import crypto2 from "crypto";
 function timingSafeCompare(a, b) {
   const aBuf = Buffer.from(a);
   const bBuf = Buffer.from(b);
   if (aBuf.length !== bBuf.length) {
-    crypto.timingSafeEqual(aBuf, aBuf);
+    crypto2.timingSafeEqual(aBuf, aBuf);
     return false;
   }
-  return crypto.timingSafeEqual(aBuf, bBuf);
+  return crypto2.timingSafeEqual(aBuf, bBuf);
 }
 function makeAuthMiddleware(token = "") {
   return (req, res, next) => {
@@ -1719,7 +2042,7 @@ function mountApi(app, store, token = "") {
 
 // src/remote-message.ts
 init_esm_shims();
-import crypto2 from "crypto";
+import crypto3 from "crypto";
 var MAX_RESPONSE_BYTES = 64 * 1024;
 function validateWebSocketUrl(url) {
   let translated = url;
@@ -1747,7 +2070,7 @@ var RemoteMessageHandler = class {
     if (!this.webhookSecret) {
       throw new Error("Cannot sign without a webhookSecret");
     }
-    return crypto2.createHmac("sha256", this.webhookSecret).update(body).digest("hex");
+    return crypto3.createHmac("sha256", this.webhookSecret).update(body).digest("hex");
   }
   /**
    * Release resources held by this handler.
@@ -4055,6 +4378,35 @@ function maskPhoneNumber(number) {
 function isValidE164(number) {
   return /^\+[1-9]\d{6,14}$/.test(number);
 }
+function augmentWithBuiltinHandoffTools(userTools, callbacks) {
+  const out = [...userTools ?? []];
+  if (callbacks.transferCall) {
+    const transferCall = callbacks.transferCall;
+    out.push({
+      ...TRANSFER_CALL_TOOL,
+      handler: async (args) => {
+        const number = typeof args.number === "string" ? args.number : "";
+        if (!isValidE164(number)) {
+          return JSON.stringify({ error: "Invalid phone number format", status: "rejected" });
+        }
+        await transferCall(number);
+        return JSON.stringify({ status: "transferring", to: number });
+      }
+    });
+  }
+  if (callbacks.endCall) {
+    const endCall = callbacks.endCall;
+    out.push({
+      ...END_CALL_TOOL,
+      handler: async (args) => {
+        const reason = typeof args.reason === "string" ? args.reason : "conversation_complete";
+        await endCall(reason);
+        return JSON.stringify({ status: "ending", reason });
+      }
+    });
+  }
+  return out;
+}
 var HALLUCINATIONS = /* @__PURE__ */ new Set([
   "you",
   "thank you",
@@ -4646,8 +4998,8 @@ var StreamHandler = class _StreamHandler {
     this.ttsByteCarry = null;
   }
   /**
-   * Start call recording when configured. Currently Twilio-only — bridges may
-   * expose ``startRecording`` for parity when we add other carriers.
+   * Start call recording when configured. Bridges expose
+   * ``startRecording`` for carrier parity (Twilio and Telnyx supported).
    */
   async startRecordingIfRequested(callId) {
     const { recording, config } = this.deps;
@@ -4893,7 +5245,7 @@ var StreamHandler = class _StreamHandler {
         this.metricsAcc.addSttAudioBytes(pcm16k.length);
       }
     } else if (this.adapter) {
-      if (this.adapter instanceof ElevenLabsConvAIAdapter && this.deps.bridge.telephonyProvider === "twilio" && this.adapter.inputAudioFormat !== "ulaw_8000") {
+      if (this.adapter instanceof ElevenLabsConvAIAdapter && this.deps.bridge.inputWireFormat === "ulaw_8000" && this.adapter.inputAudioFormat !== "ulaw_8000") {
         const pcm8k = mulawToPcm16(audioBuffer);
         const pcm16k = this.inboundResampler.process(pcm8k);
         this.adapter.sendAudio(pcm16k);
@@ -5054,6 +5406,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;
   }
   /**
@@ -5170,12 +5523,9 @@ var StreamHandler = class _StreamHandler {
       }
     }
     if (this.deps.agent.echoCancellation) {
-      const carrier = this.deps.bridge.telephonyProvider;
-      if (carrier === "twilio" || carrier === "telnyx") {
-        getLogger().warn(
-          `echoCancellation: true on ${carrier} (PSTN). Server-side NLMS cannot model PSTN's ~250\u20131500 ms round-trip echo with a 32 ms filter window \u2014 it will silently no-op. Best practice: keep echoCancellation: false; rely on the carrier + caller device's built-in echo suppression and Patter's self-hearing guard. Enable AEC only for browser/native deployments where the SDK owns the audio path end-to-end.`
-        );
-      }
+      getLogger().warn(
+        `echoCancellation: true on ${this.deps.bridge.telephonyProvider} (PSTN). Server-side NLMS cannot model PSTN's ~250\u20131500 ms round-trip echo with a 32 ms filter window \u2014 it will silently no-op. Best practice: keep echoCancellation: false; rely on the carrier + caller device's built-in echo suppression and Patter's self-hearing guard. Enable AEC only for browser/native deployments where the SDK owns the audio path end-to-end.`
+      );
       try {
         const { NlmsEchoCanceller } = await import("./aec-PJJMUM5E.mjs");
         this.aec = new NlmsEchoCanceller({ sampleRate: 16e3 });
@@ -5308,13 +5658,20 @@ var StreamHandler = class _StreamHandler {
         );
       }
       const providerModel = this.deps.agent.llm?.model ?? "";
+      const augmentedTools = augmentWithBuiltinHandoffTools(
+        this.deps.agent.tools,
+        {
+          transferCall: (number) => this.deps.bridge.transferCall(this.callId, number),
+          endCall: () => this.deps.bridge.endCall(this.callId, this.ws)
+        }
+      );
       this.llmLoop = new LLMLoop(
         "",
         // apiKey unused when llmProvider is supplied
         providerModel,
         // propagate so calculateLlmCost can match the price row
         resolvedPrompt,
-        this.deps.agent.tools,
+        augmentedTools,
         this.deps.agent.llm,
         this.deps.agent.disablePhonePreamble ?? false
       );
@@ -5325,11 +5682,18 @@ var StreamHandler = class _StreamHandler {
     } else if (!this.deps.onMessage && this.deps.config.openaiKey) {
       let llmModel = this.deps.agent.model || "gpt-4o-mini";
       if (llmModel.includes("realtime")) llmModel = "gpt-4o-mini";
+      const augmentedTools = augmentWithBuiltinHandoffTools(
+        this.deps.agent.tools,
+        {
+          transferCall: (number) => this.deps.bridge.transferCall(this.callId, number),
+          endCall: () => this.deps.bridge.endCall(this.callId, this.ws)
+        }
+      );
       this.llmLoop = new LLMLoop(
         this.deps.config.openaiKey,
         llmModel,
         resolvedPrompt,
-        this.deps.agent.tools,
+        augmentedTools,
         void 0,
         this.deps.agent.disablePhonePreamble ?? false
       );
@@ -6418,7 +6782,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 +6827,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 +6838,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,7 +6923,7 @@ var CallLogger = class {
     } catch (err) {
       getLogger().warn(`call_log write failed (${sanitizeLogValue(callId)}): ${sanitizeLogValue(String(err))}`);
     }
-    if (crypto3.randomBytes(1)[0] < 5) {
+    if (crypto4.randomBytes(1)[0] < 5) {
       this.sweepOldDays();
     }
   }
@@ -6739,6 +7103,19 @@ function classifyTelnyxAmd(result) {
   if (result === "fax") return "fax";
   return "unknown";
 }
+function twilioStatusToOutcome(callStatus) {
+  const s = (callStatus || "").toLowerCase();
+  if (s === "no-answer") return "no_answer";
+  if (s === "busy") return "busy";
+  return "failed";
+}
+function telnyxHangupOutcome(cause) {
+  const c = (cause || "").toLowerCase();
+  if (c === "no_answer" || c === "timeout" || c === "no_user_response") return "no_answer";
+  if (c === "user_busy" || c === "busy") return "busy";
+  if (c === "call_rejected" || c === "rejected" || c === "destination_out_of_order") return "failed";
+  return null;
+}
 function validateWebhookUrl(url) {
   const parsed = new URL(url);
   if (!["http:", "https:"].includes(parsed.protocol)) {
@@ -6796,7 +7173,7 @@ function validateTelnyxSignature(rawBody, signature, timestamp, publicKey, toler
     if (ageMs < 0 || ageMs > toleranceSec * 1e3) return false;
     const payload = `${timestamp}|${rawBody}`;
     const keyBuffer = Buffer.from(publicKey, "base64");
-    const keyObject = crypto4.createPublicKey({
+    const keyObject = crypto5.createPublicKey({
       key: keyBuffer,
       format: "der",
       type: "spki"
@@ -6806,7 +7183,7 @@ function validateTelnyxSignature(rawBody, signature, timestamp, publicKey, toler
       if (!trimmed) continue;
       try {
         const sigBuffer = Buffer.from(trimmed, "base64");
-        if (crypto4.verify(null, Buffer.from(payload), keyObject, sigBuffer)) {
+        if (crypto5.verify(null, Buffer.from(payload), keyObject, sigBuffer)) {
           return true;
         }
       } catch {
@@ -6823,12 +7200,12 @@ function validateTwilioSid(sid, prefix = "CA") {
 }
 function validateTwilioSignature(url, params, signature, authToken) {
   const data = url + Object.keys(params).sort().reduce((acc, key) => acc + key + (params[key] ?? ""), "");
-  const expected = crypto4.createHmac("sha1", authToken).update(data).digest("base64");
+  const expected = crypto5.createHmac("sha1", authToken).update(data).digest("base64");
   try {
     const sigBuf = Buffer.from(signature);
     const expBuf = Buffer.from(expected);
     if (sigBuf.length !== expBuf.length) return false;
-    return crypto4.timingSafeEqual(sigBuf, expBuf);
+    return crypto5.timingSafeEqual(sigBuf, expBuf);
   } catch {
     return false;
   }
@@ -6901,6 +7278,7 @@ var TwilioBridge = class {
   config;
   label = "Twilio";
   telephonyProvider = "twilio";
+  inputWireFormat = "ulaw_8000";
   sendAudio(ws, audioBase64, streamSid) {
     ws.send(JSON.stringify({ event: "media", streamSid, media: { payload: audioBase64 } }));
   }
@@ -6997,6 +7375,11 @@ var TelnyxBridge = class {
   config;
   label = "Telnyx";
   telephonyProvider = "telnyx";
+  // ``streaming_start`` negotiates PCMU bidirectional by default — keeping
+  // ``ulaw_8000`` here matches what TwilioBridge does and keeps the stream
+  // handler's input-transcode branch in the right shape. If a deployment
+  // overrides the negotiation to L16, this should flip to ``pcm_16000``.
+  inputWireFormat = "ulaw_8000";
   sendAudio(ws, audioBase64, _streamSid) {
     ws.send(JSON.stringify({ event: "media", media: { payload: audioBase64 } }));
   }
@@ -7018,7 +7401,7 @@ var TelnyxBridge = class {
     });
     getLogger().info(`Telnyx call transferred to ${toNumber}`);
   }
-  async sendDtmf(callId, digits, delayMs) {
+  async sendDtmf(_ws, callId, digits, delayMs) {
     if (!digits) {
       getLogger().warn("TelnyxBridge.sendDtmf called with empty digits");
       return;
@@ -7216,6 +7599,99 @@ var EmbeddedServer = class {
    * (tests) work without further setup. See FIX #91.
    */
   recordPrewarmWaste = () => void 0;
+  /**
+   * Per-callId completion deferreds for ``Patter.call({ wait: true })``.
+   * Resolved by the FIRST terminal signal: the Twilio/Telnyx status callback
+   * for no-media outcomes (no-answer / busy / failed), or ``onCallEnd`` for a
+   * connected call (answered / voicemail). The AMD classification is recorded
+   * per callId so the connected-call path can distinguish ``answered`` from
+   * ``voicemail``. This is what lets ``call({ wait: true })`` resolve to a
+   * structured {@link CallResult} without the caller hand-wiring ``onCallEnd``
+   * to a promise. Public so ``client.ts`` can register/await + fail in-flight
+   * waiters on ``disconnect()``. Mirrors Python's ``EmbeddedServer._completions``.
+   */
+  completions = /* @__PURE__ */ new Map();
+  /** AMD classification recorded per callId, used by the connected-call path. */
+  amdClass = /* @__PURE__ */ new Map();
+  // === Outbound completion registry (call({ wait: true })) ===
+  /**
+   * Register (or return) a completion promise for an outbound call.
+   *
+   * Called by ``Patter.call({ wait: true })`` immediately after the carrier
+   * accepts the dial — the promise resolves to a {@link CallResult} once a
+   * terminal signal arrives. Idempotent: returns the existing pending promise
+   * if one is already registered for ``callId``. Mirrors Python's
+   * ``register_completion``.
+   */
+  registerCompletion(callId) {
+    const existing = this.completions.get(callId);
+    if (existing && !existing.done) {
+      return existing.promise;
+    }
+    let resolve2;
+    let reject;
+    const promise = new Promise((res, rej) => {
+      resolve2 = res;
+      reject = rej;
+    });
+    this.completions.set(callId, { promise, resolve: resolve2, reject, done: false });
+    return promise;
+  }
+  /** Drop a registered completion (e.g. on a backstop timeout) without resolving it. */
+  deleteCompletion(callId) {
+    this.completions.delete(callId);
+    this.amdClass.delete(callId);
+  }
+  /**
+   * Resolve a pending completion with a {@link CallResult}.
+   *
+   * No-op when no completion is registered for ``callId`` (the common case —
+   * most calls are placed without ``wait: true``) or it is already done.
+   * Builds the result from the ``onCallEnd`` payload when ``data`` is provided
+   * (connected calls carry transcript + {@link CallMetrics}); no-media
+   * outcomes pass ``data`` undefined and yield an empty transcript / no cost.
+   * Mirrors Python's ``_resolve_completion``.
+   */
+  resolveCompletion(callId, args) {
+    const entry = this.completions.get(callId);
+    if (!entry || entry.done) return;
+    const data = args.data;
+    const metrics = data?.metrics ?? null;
+    const cost = metrics?.cost ?? null;
+    const durationRaw = metrics?.duration_seconds;
+    const duration = typeof durationRaw === "number" ? durationRaw : 0;
+    const transcriptRaw = data?.transcript;
+    const transcript = Array.isArray(transcriptRaw) ? transcriptRaw : [];
+    const result = {
+      callId,
+      outcome: args.outcome,
+      status: args.status,
+      durationSeconds: duration,
+      transcript,
+      cost,
+      metrics
+    };
+    entry.done = true;
+    entry.resolve(result);
+    this.completions.delete(callId);
+    this.amdClass.delete(callId);
+  }
+  /**
+   * Fail every in-flight completion with ``error``. Called by
+   * ``Patter.disconnect()`` so a ``call({ wait: true })`` awaiter does not
+   * hang until its backstop timeout once the server is gone. Mirrors the
+   * Python ``disconnect()`` change that fails in-flight ``wait=True`` awaiters.
+   */
+  failPendingCompletions(error) {
+    for (const entry of this.completions.values()) {
+      if (!entry.done) {
+        entry.done = true;
+        entry.reject(error);
+      }
+    }
+    this.completions.clear();
+    this.amdClass.clear();
+  }
   /** Bind HTTP + WebSocket listeners on `port`, mount carrier webhooks and dashboard routes. */
   async start(port = 8e3) {
     const webhookUrlPattern = /^[a-zA-Z0-9][a-zA-Z0-9.\-]+[a-zA-Z0-9]$/;
@@ -7279,8 +7755,10 @@ var EmbeddedServer = class {
         return;
       }
       const body = req.body;
-      const callSid = sanitizeLogValue(body["CallSid"] ?? "");
-      const callStatus = sanitizeLogValue(body["CallStatus"] ?? "");
+      const rawCallSid = body["CallSid"] ?? "";
+      const rawCallStatus = body["CallStatus"] ?? "";
+      const callSid = sanitizeLogValue(rawCallSid);
+      const callStatus = sanitizeLogValue(rawCallStatus);
       const duration = body["CallDuration"] ?? body["Duration"] ?? "";
       getLogger().info(
         `Twilio status ${callStatus} for call ${callSid} (duration=${duration})`
@@ -7297,6 +7775,10 @@ var EmbeddedServer = class {
         } catch (err) {
           getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
         }
+        this.resolveCompletion(rawCallSid, {
+          outcome: twilioStatusToOutcome(rawCallStatus),
+          status: rawCallStatus
+        });
       }
       res.status(204).send();
     });
@@ -7339,6 +7821,9 @@ var EmbeddedServer = class {
       const answeredBy = body["AnsweredBy"] ?? "";
       const callSid = body["CallSid"] ?? "";
       getLogger().info(`AMD result for ${sanitizeLogValue(callSid)}: ${sanitizeLogValue(answeredBy)}`);
+      if (callSid) {
+        this.amdClass.set(callSid, classifyTwilioAmd(answeredBy));
+      }
       const cb = this.onMachineDetection;
       if (cb && callSid) {
         try {
@@ -7464,6 +7949,9 @@ var EmbeddedServer = class {
         getLogger().info(
           `Telnyx AMD result for ${sanitizeLogValue(amdCallId)}: ${sanitizeLogValue(amdResult)}`
         );
+        if (amdCallId) {
+          this.amdClass.set(amdCallId, classifyTelnyxAmd(amdResult));
+        }
         const cbTx = this.onMachineDetection;
         if (cbTx && amdCallId) {
           try {
@@ -7500,6 +7988,13 @@ var EmbeddedServer = class {
           } catch (err) {
             getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
           }
+          const noMediaOutcome = telnyxHangupOutcome(hangupCause);
+          if (noMediaOutcome !== null) {
+            this.resolveCompletion(hangupCallId, {
+              outcome: noMediaOutcome,
+              status: hangupCause
+            });
+          }
         }
         return res.status(200).send();
       }
@@ -7552,6 +8047,121 @@ var EmbeddedServer = class {
       }
       return res.status(200).send();
     });
+    const validatePlivoRequest = (req, res) => {
+      const authToken = this.config.plivoAuthToken;
+      if (!authToken) {
+        if (this.config.requireSignature !== false) {
+          getLogger().error(
+            "Plivo webhook rejected: plivoAuthToken not configured and requireSignature is not false"
+          );
+          res.status(503).send("Webhook signature required");
+          return false;
+        }
+        return true;
+      }
+      const method = req.method.toUpperCase();
+      const params = method === "POST" && req.body && typeof req.body === "object" ? Object.fromEntries(
+        Object.entries(req.body).map(([k, v]) => [k, String(v)])
+      ) : {};
+      const signature = req.headers["x-plivo-signature-v3"] || "";
+      const nonce = req.headers["x-plivo-signature-v3-nonce"] || "";
+      const url = `https://${this.config.webhookUrl}${req.originalUrl}`;
+      if (!validatePlivoSignature(url, nonce, signature, authToken, params, method)) {
+        getLogger().warn("Plivo webhook rejected: invalid or missing V3 signature");
+        res.status(403).send("Invalid signature");
+        return false;
+      }
+      return true;
+    };
+    app.post("/webhooks/plivo/voice", (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const body = req.body ?? {};
+      const callUuid = body["CallUUID"] ?? "";
+      const caller = body["From"] ?? "";
+      const callee = body["To"] ?? "";
+      const qs = `?caller=${encodeURIComponent(caller)}&callee=${encodeURIComponent(callee)}`;
+      const streamUrl = `wss://${this.config.webhookUrl}/ws/plivo/stream/${callUuid || "outbound"}${qs}`;
+      const xml = PlivoAdapter.generateStreamXml(streamUrl, "audio/x-mulaw;rate=8000", {
+        "X-PH-caller": caller,
+        "X-PH-callee": callee
+      });
+      res.type("text/xml").send(xml);
+    });
+    app.post("/webhooks/plivo/status", (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const body = req.body ?? {};
+      const callUuid = body["CallUUID"] ?? "";
+      const callStatus = body["CallStatus"] ?? body["Status"] ?? "";
+      const duration = body["Duration"] ?? body["BillDuration"] ?? "";
+      getLogger().info(
+        `Plivo status ${sanitizeLogValue(callStatus)} for call ${sanitizeLogValue(callUuid)} (duration=${duration})`
+      );
+      if (callUuid && callStatus) {
+        const extra = {};
+        const parsed = parseFloat(duration);
+        if (!Number.isNaN(parsed)) extra.duration_seconds = parsed;
+        this.metricsStore.updateCallStatus(callUuid, callStatus, extra);
+      }
+      if (callUuid && ["no-answer", "busy", "failed", "timeout", "cancel"].includes(callStatus)) {
+        try {
+          this.recordPrewarmWaste(callUuid);
+        } catch (err) {
+          getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
+        }
+        const outcome = callStatus === "no-answer" || callStatus === "timeout" ? "no_answer" : callStatus === "busy" ? "busy" : "failed";
+        this.resolveCompletion(callUuid, { outcome, status: callStatus });
+      }
+      res.status(200).send();
+    });
+    app.post("/webhooks/plivo/amd", async (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const body = req.body ?? {};
+      const callUuid = body["CallUUID"] ?? "";
+      const amdRaw = body["Machine"] || body["MachineDetection"] || body["AnsweredBy"] || body["CallStatus"] || "";
+      getLogger().info(`AMD result for ${sanitizeLogValue(callUuid)}: ${sanitizeLogValue(amdRaw)}`);
+      const classification = classifyPlivoAmd(amdRaw);
+      if (callUuid) this.amdClass.set(callUuid, classification);
+      const cb = this.onMachineDetection;
+      if (cb && callUuid) {
+        try {
+          await cb({
+            call_id: callUuid,
+            carrier: "plivo",
+            classification,
+            raw: amdRaw,
+            detected_at: Date.now() / 1e3
+          });
+        } catch (err) {
+          getLogger().warn(`onMachineDetection callback threw: ${sanitizeLogValue(String(err))}`);
+        }
+      }
+      if (classification === "machine" && callUuid) {
+        try {
+          this.recordPrewarmWaste(callUuid);
+        } catch (err) {
+          getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
+        }
+        if (this.voicemailMessage && this.config.plivoAuthId && this.config.plivoAuthToken) {
+          await dropPlivoVoicemail(
+            callUuid,
+            this.voicemailMessage,
+            this.config.plivoAuthId,
+            this.config.plivoAuthToken
+          );
+        }
+      }
+      res.status(200).send();
+    });
+    app.all("/webhooks/plivo/transfer", (req, res) => {
+      if (!validatePlivoRequest(req, res)) return;
+      const to = String(req.query.to ?? "");
+      if (!to || !/^\+[1-9]\d{6,14}$/.test(to)) {
+        getLogger().warn(`Plivo transfer XML: invalid target ${JSON.stringify(to)}`);
+        res.type("text/xml").send("<Response><Hangup/></Response>");
+        return;
+      }
+      res.type("text/xml").send(`<Response><Dial><Number>${xmlEscape(to)}</Number></Dial></Response>`);
+    });
     this.server = createServer(app);
     this.wss = new WebSocketServer({ noServer: true });
     const MAX_WS_PER_IP = 10;
@@ -7584,9 +8194,11 @@ 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);
       }
@@ -7770,6 +8382,12 @@ var EmbeddedServer = class {
         }).catch((err) => getLogger().error(`call_log end error: ${String(err)}`));
       }
       if (userEnd) await userEnd(data);
+      const cid = typeof data.call_id === "string" ? data.call_id : "";
+      if (cid) {
+        const cls = this.amdClass.get(cid);
+        const outcome = cls === "machine" ? "voicemail" : "answered";
+        this.resolveCompletion(cid, { outcome, status: "completed", data });
+      }
     };
     return [wrappedStart, wrappedMetrics, wrappedEnd];
   }
@@ -7876,6 +8494,52 @@ var EmbeddedServer = class {
     });
   }
   // ---------------------------------------------------------------------------
+  // Plivo WebSocket message parser (thin layer)
+  // ---------------------------------------------------------------------------
+  handlePlivoStream(ws, url) {
+    const caller = url.searchParams.get("caller") ?? "";
+    const callee = url.searchParams.get("callee") ?? "";
+    const bridge = new PlivoBridge(this.config);
+    const handler = new StreamHandler(this.buildStreamHandlerDeps(bridge), ws, caller, callee);
+    ws.on("message", async (raw) => {
+      try {
+        let data;
+        try {
+          data = JSON.parse(raw.toString());
+        } catch (e) {
+          getLogger().error("Failed to parse Plivo WS message:", e);
+          return;
+        }
+        const event = data.event ?? "";
+        if (event === "start") {
+          handler.setStreamSid(data.start?.streamId ?? "");
+          const callId = data.start?.callId ?? "";
+          if (callId) this.activeCallIds.set(ws, callId);
+          await handler.handleCallStart(callId);
+        } else if (event === "media") {
+          const payload = data.media?.payload ?? "";
+          if (payload) handler.handleAudio(Buffer.from(payload, "base64"));
+        } else if (event === "playedStream") {
+          const markName = String(data.name ?? "");
+          if (markName) await handler.onMark(markName);
+        } else if (event === "dtmf") {
+          const digit = String(data.dtmf?.digit ?? "").trim();
+          if (digit) await handler.handleDtmf(digit);
+        } else if (event === "playFailed" || event === "error") {
+          getLogger().warn(`Plivo ${event}: ${data.reason ?? "unknown"}`);
+        } else if (event === "stop") {
+          await handler.handleStop();
+        }
+      } catch (err) {
+        getLogger().error("Stream handler error (Plivo):", err);
+      }
+    });
+    ws.on("close", async () => {
+      this.activeCallIds.delete(ws);
+      await handler.handleWsClose();
+    });
+  }
+  // ---------------------------------------------------------------------------
   // Graceful shutdown
   // ---------------------------------------------------------------------------
   /**
@@ -7892,10 +8556,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 {
       }
@@ -8775,6 +9439,8 @@ export {
   ProvisionError,
   RateLimitError,
   ElevenLabsConvAIAdapter,
+  PlivoAdapter,
+  Carrier,
   PRICING_VERSION,
   PRICING_LAST_UPDATED,
   PricingUnit,