getpatter 0.6.2 → 0.6.3

package/dist/index.js

@@ -1901,6 +1901,160 @@ var init_elevenlabs_convai = __esm({
   }
 });
 
+// src/providers/plivo-adapter.ts
+async function dropPlivoVoicemail(callUuid, voicemailMessage, authId, authToken) {
+  if (!callUuid || !voicemailMessage || !authId || !authToken) return;
+  const auth2 = `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: auth2 },
+      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: auth2 } });
+    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 PLIVO_API_BASE, PlivoAdapter;
+var init_plivo_adapter = __esm({
+  "src/providers/plivo-adapter.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    PLIVO_API_BASE = "https://api.plivo.com/v1";
+    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, path6, jsonBody) {
+        const headers = { Authorization: this.authHeader };
+        if (jsonBody !== void 0) headers["Content-Type"] = "application/json";
+        const response = await fetch(`${this.baseUrl}${path6}`, {
+          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} ${path6} 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 number4 = data.objects?.[0]?.number;
+        if (!number4) throw new Error(`PlivoAdapter: no numbers available for ${countryIso}`);
+        await this.request("POST", `/PhoneNumber/${encodeURIComponent(number4)}/`);
+        return number4;
+      }
+      /**
+       * 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(number4, 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(number4)}/`, { 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/provider-factory.ts
 async function createSTT(agent) {
   return agent.stt ?? null;
@@ -1915,6 +2069,178 @@ var init_provider_factory = __esm({
   }
 });
 
+// src/telephony/plivo.ts
+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(url2, nonce, signature, authToken, params, method = "POST") {
+  if (!signature || !nonce || !authToken) return false;
+  let base = url2;
+  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 = import_node_crypto.default.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 && import_node_crypto.default.timingSafeEqual(sigBuf, expBuf)) {
+        return true;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+var import_node_crypto, Carrier, PLIVO_DTMF_ALLOWED, PlivoBridge;
+var init_plivo = __esm({
+  "src/telephony/plivo.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_crypto = __toESM(require("crypto"));
+    init_provider_factory();
+    init_logger();
+    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;
+      }
+    };
+    PLIVO_DTMF_ALLOWED = new Set("0123456789*#ABCDabcdwW");
+    PlivoBridge = class {
+      constructor(config2) {
+        this.config = config2;
+        const authId = config2.plivoAuthId ?? "";
+        const authToken = config2.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
 function resolveProviderRates(providerConfig, model) {
   if (!providerConfig) return { unit: "" };
@@ -2054,7 +2380,7 @@ function calculateLlmCost(provider2, model, inputTokens, outputTokens, cacheRead
 function calculateTelephonyCost(provider2, durationSeconds, pricing) {
   const config2 = pricing[provider2];
   if (!config2 || config2.unit !== "minute") return 0;
-  const minutes = provider2 === "twilio" ? Math.ceil(durationSeconds / 60) : durationSeconds / 60;
+  const minutes = config2.roundUp ? Math.ceil(durationSeconds / 60) : durationSeconds / 60;
   return minutes * (config2.price ?? 0);
 }
 var PRICING_VERSION, PRICING_LAST_UPDATED, PricingUnit, DEFAULT_PRICING, llmPricing;
@@ -2283,7 +2609,7 @@ var init_pricing = __esm({
       // 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
@@ -2301,7 +2627,17 @@ var init_pricing = __esm({
       // 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 }
     };
     llmPricing = {
       anthropic: {
@@ -2985,10 +3321,10 @@ function timingSafeCompare(a, b) {
   const aBuf = Buffer.from(a);
   const bBuf = Buffer.from(b);
   if (aBuf.length !== bBuf.length) {
-    import_node_crypto.default.timingSafeEqual(aBuf, aBuf);
+    import_node_crypto2.default.timingSafeEqual(aBuf, aBuf);
     return false;
   }
-  return import_node_crypto.default.timingSafeEqual(aBuf, bBuf);
+  return import_node_crypto2.default.timingSafeEqual(aBuf, bBuf);
 }
 function makeAuthMiddleware(token = "") {
   return (req, res, next) => {
@@ -3010,12 +3346,12 @@ function makeAuthMiddleware(token = "") {
     res.status(401).json({ error: "Unauthorized" });
   };
 }
-var import_node_crypto;
+var import_node_crypto2;
 var init_auth = __esm({
   "src/dashboard/auth.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_crypto = __toESM(require("crypto"));
+    import_node_crypto2 = __toESM(require("crypto"));
   }
 });
 
@@ -3320,12 +3656,12 @@ function isRemoteUrl(onMessage) {
 function isWebSocketUrl(url2) {
   return url2.startsWith("ws://") || url2.startsWith("wss://");
 }
-var import_node_crypto2, MAX_RESPONSE_BYTES, RemoteMessageHandler;
+var import_node_crypto3, MAX_RESPONSE_BYTES, RemoteMessageHandler;
 var init_remote_message = __esm({
   "src/remote-message.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_crypto2 = __toESM(require("crypto"));
+    import_node_crypto3 = __toESM(require("crypto"));
     init_logger();
     init_server();
     MAX_RESPONSE_BYTES = 64 * 1024;
@@ -3346,7 +3682,7 @@ var init_remote_message = __esm({
         if (!this.webhookSecret) {
           throw new Error("Cannot sign without a webhookSecret");
         }
-        return import_node_crypto2.default.createHmac("sha256", this.webhookSecret).update(body).digest("hex");
+        return import_node_crypto3.default.createHmac("sha256", this.webhookSecret).update(body).digest("hex");
       }
       /**
        * Release resources held by this handler.
@@ -22119,7 +22455,7 @@ var init_transport = __esm({
 
 // node_modules/pkce-challenge/dist/index.node.js
 async function getRandomValues(size) {
-  return (await crypto3).getRandomValues(new Uint8Array(size));
+  return (await crypto4).getRandomValues(new Uint8Array(size));
 }
 async function random(size) {
   const mask = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";
@@ -22139,7 +22475,7 @@ async function generateVerifier(length) {
   return await random(length);
 }
 async function generateChallenge(code_verifier) {
-  const buffer = await (await crypto3).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
+  const buffer = await (await crypto4).subtle.digest("SHA-256", new TextEncoder().encode(code_verifier));
   return btoa(String.fromCharCode(...new Uint8Array(buffer))).replace(/\//g, "_").replace(/\+/g, "-").replace(/=/g, "");
 }
 async function pkceChallenge(length) {
@@ -22155,12 +22491,12 @@ async function pkceChallenge(length) {
     code_challenge: challenge
   };
 }
-var crypto3;
+var crypto4;
 var init_index_node = __esm({
   "node_modules/pkce-challenge/dist/index.node.js"() {
     "use strict";
     init_cjs_shims();
-    crypto3 = globalThis.crypto?.webcrypto ?? // Node.js [18-16] REPL
+    crypto4 = globalThis.crypto?.webcrypto ?? // Node.js [18-16] REPL
     globalThis.crypto ?? // Node.js >18
     import("crypto").then((m) => m.webcrypto);
   }
@@ -26754,6 +27090,35 @@ function maskPhoneNumber(number4) {
 function isValidE164(number4) {
   return /^\+[1-9]\d{6,14}$/.test(number4);
 }
+function augmentWithBuiltinHandoffTools(userTools, callbacks) {
+  const out = [...userTools ?? []];
+  if (callbacks.transferCall) {
+    const transferCall = callbacks.transferCall;
+    out.push({
+      ...TRANSFER_CALL_TOOL,
+      handler: async (args) => {
+        const number4 = typeof args.number === "string" ? args.number : "";
+        if (!isValidE164(number4)) {
+          return JSON.stringify({ error: "Invalid phone number format", status: "rejected" });
+        }
+        await transferCall(number4);
+        return JSON.stringify({ status: "transferring", to: number4 });
+      }
+    });
+  }
+  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;
+}
 async function queryDeepgramCost(metricsAcc, deepgramKey, deepgramRequestId) {
   try {
     const projResp = await fetch("https://api.deepgram.com/v1/projects", {
@@ -27397,8 +27762,8 @@ var init_stream_handler = __esm({
         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: config2 } = this.deps;
@@ -27644,7 +28009,7 @@ var init_stream_handler = __esm({
             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);
@@ -27805,6 +28170,7 @@ var init_stream_handler = __esm({
         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;
       }
       /**
@@ -27921,12 +28287,9 @@ var init_stream_handler = __esm({
           }
         }
         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: NlmsEchoCanceller2 } = await Promise.resolve().then(() => (init_aec(), aec_exports));
             this.aec = new NlmsEchoCanceller2({ sampleRate: 16e3 });
@@ -28059,13 +28422,20 @@ var init_stream_handler = __esm({
             );
           }
           const providerModel = this.deps.agent.llm?.model ?? "";
+          const augmentedTools = augmentWithBuiltinHandoffTools(
+            this.deps.agent.tools,
+            {
+              transferCall: (number4) => this.deps.bridge.transferCall(this.callId, number4),
+              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
           );
@@ -28076,11 +28446,18 @@ var init_stream_handler = __esm({
         } 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: (number4) => this.deps.bridge.transferCall(this.callId, number4),
+              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
           );
@@ -29178,7 +29555,7 @@ function redactPhone(raw) {
   const mode = redactMode();
   if (mode === "full") return raw;
   if (mode === "hash_only") {
-    return "sha256:" + crypto4.createHash("sha256").update(raw, "utf8").digest("hex").slice(0, 16);
+    return "sha256:" + crypto5.createHash("sha256").update(raw, "utf8").digest("hex").slice(0, 16);
   }
   return maskPhoneNumber(raw);
 }
@@ -29189,7 +29566,7 @@ function utcIso(tsSeconds) {
 async function atomicWriteJson(filePath, payload) {
   const dir = path4.dirname(filePath);
   await import_node_fs2.promises.mkdir(dir, { recursive: true });
-  const tmp = path4.join(dir, `.tmp.${process.pid}.${crypto4.randomBytes(4).toString("hex")}.json`);
+  const tmp = path4.join(dir, `.tmp.${process.pid}.${crypto5.randomBytes(4).toString("hex")}.json`);
   try {
     const handle = await import_node_fs2.promises.open(tmp, "w");
     try {
@@ -29229,12 +29606,12 @@ function rmTree(target) {
   } catch {
   }
 }
-var crypto4, fs4, import_node_fs2, os, path4, SCHEMA_VERSION, DEFAULT_RETENTION_DAYS, CallLogger;
+var crypto5, fs4, import_node_fs2, os, path4, SCHEMA_VERSION, DEFAULT_RETENTION_DAYS, CallLogger;
 var init_call_log = __esm({
   "src/services/call-log.ts"() {
     "use strict";
     init_cjs_shims();
-    crypto4 = __toESM(require("crypto"));
+    crypto5 = __toESM(require("crypto"));
     fs4 = __toESM(require("fs"));
     import_node_fs2 = require("fs");
     os = __toESM(require("os"));
@@ -29306,7 +29683,7 @@ var init_call_log = __esm({
         } catch (err) {
           getLogger().warn(`call_log write failed (${sanitizeLogValue(callId)}): ${sanitizeLogValue(String(err))}`);
         }
-        if (crypto4.randomBytes(1)[0] < 5) {
+        if (crypto5.randomBytes(1)[0] < 5) {
           this.sweepOldDays();
         }
       }
@@ -29443,6 +29820,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(url2) {
   const parsed = new URL(url2);
   if (!["http:", "https:"].includes(parsed.protocol)) {
@@ -29500,7 +29890,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 = import_node_crypto3.default.createPublicKey({
+    const keyObject = import_node_crypto4.default.createPublicKey({
       key: keyBuffer,
       format: "der",
       type: "spki"
@@ -29510,7 +29900,7 @@ function validateTelnyxSignature(rawBody, signature, timestamp, publicKey, toler
       if (!trimmed) continue;
       try {
         const sigBuffer = Buffer.from(trimmed, "base64");
-        if (import_node_crypto3.default.verify(null, Buffer.from(payload), keyObject, sigBuffer)) {
+        if (import_node_crypto4.default.verify(null, Buffer.from(payload), keyObject, sigBuffer)) {
           return true;
         }
       } catch {
@@ -29527,12 +29917,12 @@ function validateTwilioSid(sid, prefix = "CA") {
 }
 function validateTwilioSignature(url2, params, signature, authToken) {
   const data = url2 + Object.keys(params).sort().reduce((acc, key) => acc + key + (params[key] ?? ""), "");
-  const expected = import_node_crypto3.default.createHmac("sha1", authToken).update(data).digest("base64");
+  const expected = import_node_crypto4.default.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 import_node_crypto3.default.timingSafeEqual(sigBuf, expBuf);
+    return import_node_crypto4.default.timingSafeEqual(sigBuf, expBuf);
   } catch {
     return false;
   }
@@ -29607,18 +29997,20 @@ async function sleep(ms) {
   if (ms <= 0) return;
   await new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-var import_node_crypto3, import_express, import_http, import_ws5, TRANSFER_CALL_TOOL, END_CALL_TOOL, TwilioBridge, TELNYX_DTMF_ALLOWED, TELNYX_DTMF_DURATION_MS, TelnyxBridge, GRACEFUL_SHUTDOWN_TIMEOUT_MS, EmbeddedServer;
+var import_node_crypto4, import_express, import_http, import_ws5, TRANSFER_CALL_TOOL, END_CALL_TOOL, TwilioBridge, TELNYX_DTMF_ALLOWED, TELNYX_DTMF_DURATION_MS, TelnyxBridge, GRACEFUL_SHUTDOWN_TIMEOUT_MS, EmbeddedServer;
 var init_server = __esm({
   "src/server.ts"() {
     "use strict";
     init_cjs_shims();
-    import_node_crypto3 = __toESM(require("crypto"));
+    import_node_crypto4 = __toESM(require("crypto"));
     import_express = __toESM(require("express"));
     import_http = require("http");
     import_ws5 = require("ws");
     init_openai_realtime();
     init_openai_realtime_2();
     init_elevenlabs_convai();
+    init_plivo_adapter();
+    init_plivo();
     init_provider_factory();
     init_pricing();
     init_store();
@@ -29661,6 +30053,7 @@ var init_server = __esm({
       config;
       label = "Twilio";
       telephonyProvider = "twilio";
+      inputWireFormat = "ulaw_8000";
       sendAudio(ws, audioBase64, streamSid) {
         ws.send(JSON.stringify({ event: "media", streamSid, media: { payload: audioBase64 } }));
       }
@@ -29748,6 +30141,11 @@ var init_server = __esm({
       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 } }));
       }
@@ -29769,7 +30167,7 @@ var init_server = __esm({
         });
         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;
@@ -29967,6 +30365,99 @@ var init_server = __esm({
        * (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 duration3 = 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: duration3,
+          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(error2) {
+        for (const entry of this.completions.values()) {
+          if (!entry.done) {
+            entry.done = true;
+            entry.reject(error2);
+          }
+        }
+        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]$/;
@@ -30030,8 +30521,10 @@ var init_server = __esm({
             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 duration3 = body["CallDuration"] ?? body["Duration"] ?? "";
           getLogger().info(
             `Twilio status ${callStatus} for call ${callSid} (duration=${duration3})`
@@ -30048,6 +30541,10 @@ var init_server = __esm({
             } catch (err) {
               getLogger().debug(`recordPrewarmWaste threw: ${String(err)}`);
             }
+            this.resolveCompletion(rawCallSid, {
+              outcome: twilioStatusToOutcome(rawCallStatus),
+              status: rawCallStatus
+            });
           }
           res.status(204).send();
         });
@@ -30090,6 +30587,9 @@ var init_server = __esm({
           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 {
@@ -30215,6 +30715,9 @@ var init_server = __esm({
             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 {
@@ -30251,6 +30754,13 @@ var init_server = __esm({
               } 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();
           }
@@ -30303,6 +30813,121 @@ var init_server = __esm({
           }
           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 url2 = `https://${this.config.webhookUrl}${req.originalUrl}`;
+          if (!validatePlivoSignature(url2, 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 duration3 = body["Duration"] ?? body["BillDuration"] ?? "";
+          getLogger().info(
+            `Plivo status ${sanitizeLogValue(callStatus)} for call ${sanitizeLogValue(callUuid)} (duration=${duration3})`
+          );
+          if (callUuid && callStatus) {
+            const extra = {};
+            const parsed = parseFloat(duration3);
+            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 = (0, import_http.createServer)(app);
         this.wss = new import_ws5.WebSocketServer({ noServer: true });
         const MAX_WS_PER_IP = 10;
@@ -30335,9 +30960,11 @@ var init_server = __esm({
           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, url2);
+          } else if (provider2 === "plivo") {
+            this.handlePlivoStream(ws, url2);
           } else {
             this.handleTwilioStream(ws, url2);
           }
@@ -30521,6 +31148,12 @@ var init_server = __esm({
             }).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];
       }
@@ -30627,6 +31260,52 @@ var init_server = __esm({
         });
       }
       // ---------------------------------------------------------------------------
+      // Plivo WebSocket message parser (thin layer)
+      // ---------------------------------------------------------------------------
+      handlePlivoStream(ws, url2) {
+        const caller = url2.searchParams.get("caller") ?? "";
+        const callee = url2.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
       // ---------------------------------------------------------------------------
       /**
@@ -30643,10 +31322,10 @@ var init_server = __esm({
         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 {
           }
@@ -30795,6 +31474,7 @@ var init_tunnel = __esm({
 var carrier_config_exports = {};
 __export(carrier_config_exports, {
   autoConfigureCarrier: () => autoConfigureCarrier,
+  configurePlivoNumber: () => configurePlivoNumber,
   configureTelnyxNumber: () => configureTelnyxNumber,
   configureTwilioNumber: () => configureTwilioNumber
 });
@@ -30846,9 +31526,38 @@ async function configureTelnyxNumber(apiKey, connectionId, phoneNumber) {
     );
   }
 }
+async function configurePlivoNumber(authId, authToken, phoneNumber, answerUrl) {
+  const auth2 = `Basic ${Buffer.from(`${authId}:${authToken}`).toString("base64")}`;
+  const base = `${PLIVO_API_BASE2}/Account/${encodeURIComponent(authId)}`;
+  const appResp = await fetch(`${base}/Application/`, {
+    method: "POST",
+    headers: { Authorization: auth2, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      app_name: "patter-inbound",
+      answer_url: answerUrl,
+      answer_method: "POST"
+    })
+  });
+  if (!appResp.ok) {
+    throw new Error(`Plivo Application create failed: ${appResp.status} ${await appResp.text()}`);
+  }
+  const appBody = await appResp.json();
+  if (!appBody.app_id) {
+    getLogger().warn("Plivo Application create returned no app_id");
+    return;
+  }
+  const linkResp = await fetch(`${base}/Number/${encodeURIComponent(phoneNumber)}/`, {
+    method: "POST",
+    headers: { Authorization: auth2, "Content-Type": "application/json" },
+    body: JSON.stringify({ app_id: appBody.app_id })
+  });
+  if (!linkResp.ok) {
+    throw new Error(`Plivo Number update failed: ${linkResp.status} ${await linkResp.text()}`);
+  }
+}
 async function autoConfigureCarrier(params) {
   const log3 = getLogger();
-  const provider2 = params.telephonyProvider ?? (params.twilioSid ? "twilio" : "telnyx");
+  const provider2 = params.telephonyProvider ?? (params.twilioSid ? "twilio" : params.plivoAuthId ? "plivo" : "telnyx");
   if (provider2 === "twilio" && params.twilioSid && params.twilioToken) {
     const voiceUrl = `https://${params.webhookHost}/webhooks/twilio/voice`;
     try {
@@ -30867,9 +31576,20 @@ async function autoConfigureCarrier(params) {
     } catch (err) {
       log3.warn("Could not auto-configure Telnyx number: %s", err instanceof Error ? err.message : String(err));
     }
+    return;
+  }
+  if (provider2 === "plivo" && params.plivoAuthId && params.plivoAuthToken) {
+    const answerUrl = `https://${params.webhookHost}/webhooks/plivo/voice`;
+    try {
+      await configurePlivoNumber(params.plivoAuthId, params.plivoAuthToken, params.phoneNumber, answerUrl);
+      log3.info("Plivo answer URL set to %s", answerUrl);
+    } catch (err) {
+      log3.warn("Could not auto-configure Plivo answer URL: %s", err instanceof Error ? err.message : String(err));
+      log3.info("Set the Plivo application answer URL manually to: %s", answerUrl);
+    }
   }
 }
-var TWILIO_API_BASE, TELNYX_API_BASE;
+var TWILIO_API_BASE, TELNYX_API_BASE, PLIVO_API_BASE2;
 var init_carrier_config = __esm({
   "src/carrier-config.ts"() {
     "use strict";
@@ -30877,6 +31597,7 @@ var init_carrier_config = __esm({
     init_logger();
     TWILIO_API_BASE = "https://api.twilio.com/2010-04-01";
     TELNYX_API_BASE = "https://api.telnyx.com/v2";
+    PLIVO_API_BASE2 = "https://api.plivo.com/v1";
   }
 });
 
@@ -32500,6 +33221,8 @@ __export(index_exports, {
   PatterTool: () => PatterTool,
   PcmCarry: () => PcmCarry,
   PipelineHookExecutor: () => PipelineHookExecutor,
+  Plivo: () => Carrier,
+  PlivoAdapter: () => PlivoAdapter,
   PricingUnit: () => PricingUnit,
   ProvisionError: () => ProvisionError,
   RateLimitError: () => RateLimitError,
@@ -32526,7 +33249,7 @@ __export(index_exports, {
   SpeechmaticsTurnDetectionMode: () => TurnDetectionMode,
   StatefulResampler: () => StatefulResampler,
   StaticTunnel: () => Static,
-  Telnyx: () => Carrier2,
+  Telnyx: () => Carrier3,
   TelnyxAdapter: () => TelnyxAdapter,
   TelnyxSTT: () => TelnyxSTT,
   TelnyxSTTInputFormat: () => TelnyxSTTInputFormat,
@@ -32537,7 +33260,7 @@ __export(index_exports, {
   TestSession: () => TestSession,
   TfidfLoopDetector: () => TfidfLoopDetector,
   Tool: () => Tool,
-  Twilio: () => Carrier,
+  Twilio: () => Carrier2,
   TwilioAdapter: () => TwilioAdapter,
   ULTRAVOX_DEFAULT_API_BASE: () => ULTRAVOX_DEFAULT_API_BASE,
   ULTRAVOX_DEFAULT_SR: () => ULTRAVOX_DEFAULT_SR,
@@ -33314,7 +34037,7 @@ var Patter = class {
     }
     if (!options.carrier) {
       throw new Error(
-        "Local mode requires a `carrier` instance. Pass `carrier: new Twilio({...})` or `carrier: new Telnyx({...})`."
+        "Local mode requires a `carrier` instance. Pass `carrier: new Twilio({...})`, `carrier: new Telnyx({...})` or `carrier: new Plivo({...})`."
       );
     }
     const carrier = options.carrier;
@@ -33492,7 +34215,7 @@ var Patter = class {
       throw err;
     }
     const carrier = this.localConfig.carrier;
-    const telephonyProvider = carrier.kind === "twilio" ? "twilio" : "telnyx";
+    const telephonyProvider = carrier.kind;
     const wantsCarrierManagement = opts.manageWebhook !== false || wantsCloudflared;
     if (wantsCarrierManagement) {
       const { autoConfigureCarrier: autoConfigureCarrier2 } = await Promise.resolve().then(() => (init_carrier_config(), carrier_config_exports));
@@ -33502,6 +34225,8 @@ var Patter = class {
         twilioToken: carrier.kind === "twilio" ? carrier.authToken : void 0,
         telnyxKey: carrier.kind === "telnyx" ? carrier.apiKey : void 0,
         telnyxConnectionId: carrier.kind === "telnyx" ? carrier.connectionId : void 0,
+        plivoAuthId: carrier.kind === "plivo" ? carrier.authId : void 0,
+        plivoAuthToken: carrier.kind === "plivo" ? carrier.authToken : void 0,
         phoneNumber: this.localConfig.phoneNumber,
         webhookHost: webhookUrl
       });
@@ -33517,6 +34242,8 @@ var Patter = class {
         telnyxKey: carrier.kind === "telnyx" ? carrier.apiKey : void 0,
         telnyxConnectionId: carrier.kind === "telnyx" ? carrier.connectionId : void 0,
         telnyxPublicKey: carrier.kind === "telnyx" ? carrier.publicKey : void 0,
+        plivoAuthId: carrier.kind === "plivo" ? carrier.authId : void 0,
+        plivoAuthToken: carrier.kind === "plivo" ? carrier.authToken : void 0,
         persistRoot: this.localConfig.persistRoot
       },
       opts.agent,
@@ -33928,7 +34655,15 @@ var Patter = class {
       this.prewarmTtlTimers.set(callId, handle);
     });
   }
-  /** Place an outbound call via the configured carrier. */
+  /**
+   * Place an outbound call via the configured carrier.
+   *
+   * With `wait: false` (default) this resolves to `void` the instant the
+   * carrier accepts the dial (fire-and-forget). With `wait: true` it blocks
+   * until the call reaches a terminal state and resolves to a
+   * {@link CallResult} — see {@link LocalCallOptions.wait}. Mirrors Python's
+   * `Patter.call(..., wait=False)`.
+   */
   async call(options) {
     if (!options.to) {
       throw new Error("'to' phone number is required");
@@ -33936,7 +34671,13 @@ var Patter = class {
     if (!options.to.startsWith("+")) {
       throw new Error(`'to' must be in E.164 format (e.g., '+1234567890'). Got: '${options.to}'`);
     }
+    if (options.wait && !this.embeddedServer) {
+      throw new PatterConnectionError(
+        "call({ wait: true }) requires an active server to receive the carrier completion webhooks. Call `await phone.serve(...)` first, or use `await using phone = new Patter(...)` (and serve inside the block) which keeps the server up for the duration of the block."
+      );
+    }
     const { phoneNumber, webhookUrl, carrier } = this.localConfig;
+    let callId = "";
     const effectiveRingTimeout = options.ringTimeout === void 0 ? 25 : options.ringTimeout;
     const wantsAmd = options.machineDetection !== false || Boolean(options.voicemailMessage);
     if (this.embeddedServer) {
@@ -33994,11 +34735,74 @@ var Patter = class {
         }
       }
       if (telnyxCallId) {
+        callId = telnyxCallId;
         this.spawnPrewarmFirstMessage(options.agent, telnyxCallId, effectiveRingTimeout, "telnyx");
         if (options.agent.prewarm !== false) {
           this.parkProviderConnections(options.agent, telnyxCallId);
         }
       }
+      return this.maybeAwaitCompletion(options, callId, effectiveRingTimeout);
+    }
+    if (carrier.kind === "plivo") {
+      const auth2 = `Basic ${Buffer.from(`${carrier.authId}:${carrier.authToken}`).toString("base64")}`;
+      const plivoPayload = {
+        from: phoneNumber,
+        to: options.to,
+        answer_url: `https://${webhookUrl}/webhooks/plivo/voice`,
+        answer_method: "POST",
+        // hangup_url is Plivo's StatusCallback analogue — without it the
+        // /webhooks/plivo/status route never fires for outbound calls and
+        // the dashboard misses no-answer / busy / failed.
+        hangup_url: `https://${webhookUrl}/webhooks/plivo/status`,
+        hangup_method: "POST"
+      };
+      if (effectiveRingTimeout !== null && effectiveRingTimeout !== void 0) {
+        plivoPayload.ring_timeout = Math.max(1, Math.floor(effectiveRingTimeout));
+      }
+      if (wantsAmd) {
+        plivoPayload.machine_detection = "true";
+        plivoPayload.machine_detection_time = 5e3;
+        plivoPayload.machine_detection_url = `https://${webhookUrl}/webhooks/plivo/amd`;
+        plivoPayload.machine_detection_method = "POST";
+      }
+      if (options.voicemailMessage && this.embeddedServer) {
+        this.embeddedServer.voicemailMessage = options.voicemailMessage;
+      }
+      const response2 = await fetch(`https://api.plivo.com/v1/Account/${carrier.authId}/Call/`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: auth2 },
+        body: JSON.stringify(plivoPayload)
+      });
+      if (!response2.ok) {
+        throw new ProvisionError(`Failed to initiate Plivo call: ${await response2.text()}`);
+      }
+      let plivoCallId;
+      try {
+        const body = await response2.clone().json();
+        plivoCallId = body.request_uuid;
+      } catch {
+      }
+      if (plivoCallId) {
+        const initiatedPayload = {
+          call_id: plivoCallId,
+          caller: phoneNumber,
+          callee: options.to,
+          direction: "outbound",
+          status: "initiated"
+        };
+        if (this.embeddedServer) {
+          this.embeddedServer.metricsStore.recordCallInitiated(initiatedPayload);
+        }
+        try {
+          const { notifyDashboard: notifyDashboard2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
+          notifyDashboard2(initiatedPayload);
+        } catch {
+        }
+        this.spawnPrewarmFirstMessage(options.agent, plivoCallId, effectiveRingTimeout, "plivo");
+        if (options.agent.prewarm !== false) {
+          this.parkProviderConnections(options.agent, plivoCallId);
+        }
+      }
       return;
     }
     const twilioSid = carrier.accountSid;
@@ -34070,11 +34874,53 @@ var Patter = class {
       }
     }
     if (twilioCallSid) {
+      callId = twilioCallSid;
       this.spawnPrewarmFirstMessage(options.agent, twilioCallSid, effectiveRingTimeout, "twilio");
       if (options.agent.prewarm !== false) {
         this.parkProviderConnections(options.agent, twilioCallSid);
       }
     }
+    return this.maybeAwaitCompletion(options, callId, effectiveRingTimeout);
+  }
+  /**
+   * When `options.wait` is set, register a completion promise keyed by the
+   * carrier-issued `callId` and await it (bounded by a backstop timeout).
+   * Otherwise resolve to `void` immediately (fire-and-forget).
+   *
+   * The registration happens here — after the carrier accepted the dial and
+   * issued the id — so the future correlates to the right call. The race
+   * window between `initiateCall` returning and this registration is
+   * harmless: the callee is still ringing, so no terminal signal can fire
+   * before we register. Mirrors the Python `call(wait=True)` tail block.
+   */
+  async maybeAwaitCompletion(options, callId, ringTimeout) {
+    if (!options.wait) return;
+    const server = this.embeddedServer;
+    if (!server || !callId) {
+      throw new PatterConnectionError(
+        "call({ wait: true }): no active server or carrier call id."
+      );
+    }
+    const completion = server.registerCompletion(callId);
+    const backstopMs = ((ringTimeout ?? 25) + 1800) * 1e3;
+    let timer;
+    const backstop = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        server.deleteCompletion(callId);
+        reject(
+          new PatterConnectionError(
+            `call({ wait: true }): no terminal signal for call ${callId} within ${(backstopMs / 1e3).toFixed(0)}s`,
+            { code: ErrorCode.TIMEOUT }
+          )
+        );
+      }, backstopMs);
+      timer.unref?.();
+    });
+    try {
+      return await Promise.race([completion, backstop]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
   }
   /**
    * Stop the embedded server and any running tunnel. Safe to call multiple
@@ -34115,6 +34961,11 @@ var Patter = class {
       this.tunnelHandle = null;
     }
     if (this.embeddedServer) {
+      this.embeddedServer.failPendingCompletions(
+        new PatterConnectionError(
+          "Patter.disconnect() called while a call({ wait: true }) was still in flight."
+        )
+      );
       await this.embeddedServer.stop();
       this.embeddedServer = null;
     }
@@ -34138,6 +34989,30 @@ var Patter = class {
     this._ready.catch(() => {
     });
   }
+  /**
+   * Explicit-resource-management disposer so callers can write
+   * ``await using phone = new Patter(...)`` and have {@link disconnect} run
+   * automatically when the block exits — on the normal path AND when the
+   * body throws. This guarantees the embedded server, any auto-started
+   * tunnel, and in-flight prewarm/TTS work are torn down so a still-running
+   * TTS WebSocket cannot keep the user billed after the block ends, and any
+   * in-flight ``call({ wait: true })`` awaiter is failed rather than left
+   * hanging. ``disconnect()`` is idempotent, so an explicit ``disconnect()``
+   * inside the block is still safe. Mirrors Python's ``async with Patter(...)``.
+   *
+   * Note: this does NOT start the server (``serve()`` blocks until shutdown,
+   * so it cannot run from a disposer) — call ``serve(...)`` inside the block:
+   *
+   * ```ts
+   * await using phone = new Patter({ carrier: new Twilio(), phoneNumber: "+1555..." });
+   * await phone.serve({ agent });               // inbound, or
+   * const result = await phone.call({ to: "+1555...", agent, wait: true });
+   * // disconnect() has run here — nothing left running.
+   * ```
+   */
+  async [Symbol.asyncDispose]() {
+    await this.disconnect();
+  }
   /**
    * Terminate an active call on the configured carrier.
    *
@@ -34192,6 +35067,17 @@ var Patter = class {
       }
       return;
     }
+    if (carrier.kind === "plivo") {
+      const auth2 = Buffer.from(`${carrier.authId}:${carrier.authToken}`).toString("base64");
+      const res = await fetch(
+        `https://api.plivo.com/v1/Account/${carrier.authId}/Call/${encodeURIComponent(callSid)}/`,
+        { method: "DELETE", headers: { Authorization: `Basic ${auth2}` } }
+      );
+      if (!res.ok && res.status !== 404) {
+        throw new Error(`Plivo hangup failed: ${res.status} ${await res.text()}`);
+      }
+      return;
+    }
     throw new Error(`endCall() requires a configured carrier; got kind=${carrier.kind}`);
   }
 };
@@ -34612,7 +35498,6 @@ init_cjs_shims();
 
 // src/integrations/patter-tool.ts
 init_cjs_shims();
-var import_node_events = require("events");
 var PARAMETERS_SCHEMA = {
   type: "object",
   properties: {
@@ -34639,7 +35524,7 @@ var PARAMETERS_SCHEMA = {
 };
 var DEFAULT_NAME = "make_phone_call";
 var DEFAULT_DESCRIPTION = "Place a real outbound phone call. Returns a JSON object with the full transcript, call status, duration in seconds, and cost. Use this when the user asks you to call someone, schedule appointments by phone, or otherwise reach a human via voice.";
-var PatterTool = class _PatterTool {
+var PatterTool = class {
   name;
   description;
   phone;
@@ -34647,24 +35532,6 @@ var PatterTool = class _PatterTool {
   maxDurationSec;
   recording;
   started = false;
-  /** Resolver for the next `call_initiated` SSE event. Only set inside the
-   *  dial mutex (`dialQueue`), so two parallel `execute()` calls never share
-   *  it and never lose a dispatch. */
-  pendingDial = null;
-  /** Mutex that serializes the dial → call_id capture critical section.
-   *  Each `execute()` chains a continuation onto this promise so the
-   *  `pendingDial` slot is owned by exactly one caller at a time. */
-  dialQueue = Promise.resolve();
-  /** Captured SSE listener so `stop()` can detach it (prevents leaks when
-   *  the underlying Patter instance outlives this tool). */
-  sseListener = null;
-  /** Captured Patter metrics store, for cleanup in `stop()`. */
-  metricsStoreRef = null;
-  /** call_id → pending promise machinery. */
-  pending = /* @__PURE__ */ new Map();
-  bus = new import_node_events.EventEmitter();
-  /** How long to wait for the `call_initiated` SSE before failing the dial. */
-  static DIAL_CAPTURE_TIMEOUT_MS = 1e4;
   constructor(opts) {
     if (!opts.phone) {
       throw new Error("PatterTool: `phone` (a Patter instance) is required.");
@@ -34708,7 +35575,15 @@ var PatterTool = class _PatterTool {
     };
   }
   // --- Lifecycle ----------------------------------------------------------
-  /** Start the underlying Patter server. Idempotent. */
+  /**
+   * Start the underlying Patter server. Idempotent.
+   *
+   * `execute()` relies on `Patter.call({ wait: true })`, which requires an
+   * active server to receive the carrier completion webhooks — that's what
+   * `serve()` provides here. No `onCallEnd` callback is wired: the SDK's own
+   * per-callId completion registry resolves the result, so the user's
+   * `onCallEnd` slot is left free.
+   */
   async start() {
     if (this.started) return;
     if (!this.agent) {
@@ -34720,52 +35595,31 @@ var PatterTool = class _PatterTool {
     await this.phone.serve({
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       agent: builtAgent,
-      recording: this.recording,
-      onCallEnd: this.onCallEndHandler.bind(this)
+      recording: this.recording
     });
-    const store = this.phone.metricsStore;
-    if (!store) {
-      throw new Error(
-        "PatterTool.start: phone.metricsStore is null after serve() \u2014 is the dashboard disabled?"
-      );
-    }
-    const listener = (event) => {
-      if (event.type === "call_initiated" && this.pendingDial) {
-        const callId = event.data.call_id || "";
-        if (callId) {
-          const dispatch = this.pendingDial;
-          this.pendingDial = null;
-          dispatch(callId);
-        }
-      }
-    };
-    store.on("sse", listener);
-    this.sseListener = listener;
-    this.metricsStoreRef = store;
     this.started = true;
   }
-  /** Stop the underlying Patter server (and reject any pending calls). */
+  /** Best-effort shutdown — tear the Patter server down via `disconnect()`. */
   async stop() {
     if (!this.started) return;
-    if (this.metricsStoreRef && this.sseListener) {
-      this.metricsStoreRef.off("sse", this.sseListener);
-    }
-    this.sseListener = null;
-    this.metricsStoreRef = null;
-    this.pendingDial = null;
-    for (const [, p] of this.pending) {
-      clearTimeout(p.timer);
-      p.reject(new Error("PatterTool: shutdown while call pending"));
-    }
-    this.pending.clear();
-    const stoppable = this.phone;
-    if (typeof stoppable.stop === "function") {
-      await stoppable.stop();
+    const disconnectable = this.phone;
+    if (typeof disconnectable.disconnect === "function") {
+      try {
+        await disconnectable.disconnect();
+      } catch {
+      }
     }
     this.started = false;
   }
   // --- Execution ----------------------------------------------------------
-  /** Place an outbound call and resolve once it ends with the transcript and metrics. */
+  /**
+   * Dial outbound, wait for the call to end, return a structured result.
+   *
+   * Thin wrapper over `Patter.call({ wait: true })`: the SDK now owns the
+   * dial → callId → terminal-signal correlation, so this just bounds the wait
+   * with `max_duration_sec` and maps the {@link CallResult} into the tool's
+   * public envelope. Mirrors Python's `PatterTool.execute`.
+   */
   async execute(args) {
     if (!this.started) await this.start();
     if (!args || typeof args.to !== "string" || !args.to.startsWith("+")) {
@@ -34781,55 +35635,32 @@ var PatterTool = class _PatterTool {
       ...args.goal !== void 0 ? { systemPrompt: args.goal } : {},
       ...args.first_message !== void 0 ? { firstMessage: args.first_message } : {}
     });
-    const callId = await this.acquireCallId(args.to, overrideAgent);
-    return new Promise((resolve2, reject) => {
-      const timer = setTimeout(() => {
-        this.pending.delete(callId);
-        reject(new Error(`PatterTool.execute: call ${callId} exceeded ${timeoutSec}s timeout`));
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new Error(
+            `PatterTool.execute: call to ${args.to} exceeded ${timeoutSec}s timeout`
+          )
+        );
       }, timeoutSec * 1e3);
-      this.pending.set(callId, {
-        resolve: resolve2,
-        reject,
-        timer,
-        startedAt: Date.now() / 1e3
-      });
-    });
-  }
-  /** Issue the outbound dial under the mutex and return its assigned call_id. */
-  async acquireCallId(to, agent) {
-    let release;
-    const slot = new Promise((r) => {
-      release = r;
+      timer.unref?.();
     });
-    const previous = this.dialQueue;
-    this.dialQueue = previous.then(() => slot);
-    await previous;
-    let captureTimer = null;
+    let result;
     try {
-      const callIdPromise = new Promise((resolve2, reject) => {
-        this.pendingDial = resolve2;
-        captureTimer = setTimeout(() => {
-          this.pendingDial = null;
-          reject(
-            new Error(
-              `PatterTool.execute: did not observe call_initiated within ${_PatterTool.DIAL_CAPTURE_TIMEOUT_MS}ms`
-            )
-          );
-        }, _PatterTool.DIAL_CAPTURE_TIMEOUT_MS);
-      });
-      await this.phone.call({
-        to,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        agent
-      });
-      const callId = await callIdPromise;
-      if (captureTimer) clearTimeout(captureTimer);
-      return callId;
+      result = await Promise.race([
+        this.phone.call({
+          to: args.to,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          agent: overrideAgent,
+          wait: true
+        }),
+        timeout
+      ]);
     } finally {
-      if (captureTimer) clearTimeout(captureTimer);
-      this.pendingDial = null;
-      release();
+      if (timer) clearTimeout(timer);
     }
+    return resultFromCallResult(result);
   }
   /**
    * Hermes-style handler: `(args, kwargs) => Promise<string>` returning a JSON
@@ -34847,32 +35678,32 @@ var PatterTool = class _PatterTool {
       }
     };
   }
-  // --- Internal: onCallEnd dispatcher -------------------------------------
-  async onCallEndHandler(data) {
-    const callId = data.call_id || "";
-    if (!callId) return;
-    const pending = this.pending.get(callId);
-    if (!pending) {
-      this.bus.emit("orphan_end", { call_id: callId, data });
-      return;
-    }
-    clearTimeout(pending.timer);
-    this.pending.delete(callId);
-    const metrics = data.metrics && typeof data.metrics === "object" ? data.metrics : null;
-    const cost = metrics && typeof metrics.cost === "object" && metrics.cost && typeof metrics.cost.total === "number" ? metrics.cost.total : void 0;
-    const duration3 = typeof metrics?.duration_seconds === "number" ? metrics?.duration_seconds : Math.max(0, Date.now() / 1e3 - pending.startedAt);
-    const transcript = Array.isArray(data.transcript) ? data.transcript : [];
-    const status = data.status || "completed";
-    pending.resolve({
-      call_id: callId,
-      status,
-      duration_seconds: duration3,
-      cost_usd: cost,
-      transcript,
-      metrics
-    });
-  }
 };
+function resultFromCallResult(result) {
+  if (!result) {
+    return {
+      call_id: "",
+      status: "completed",
+      outcome: "",
+      duration_seconds: 0,
+      cost_usd: void 0,
+      transcript: [],
+      metrics: null
+    };
+  }
+  const costTotal = result.cost?.total;
+  const costUsd = typeof costTotal === "number" ? costTotal : void 0;
+  const metrics = result.metrics ? result.metrics : null;
+  return {
+    call_id: result.callId || "",
+    status: result.status || "completed",
+    outcome: result.outcome || "",
+    duration_seconds: typeof result.durationSeconds === "number" ? result.durationSeconds : 0,
+    cost_usd: costUsd,
+    transcript: result.transcript ? [...result.transcript] : [],
+    metrics
+  };
+}
 
 // src/index.ts
 init_test_mode();
@@ -35451,6 +36282,12 @@ var ELEVENLABS_VOICE_ID_BY_NAME = {
   alloy: "EXAVITQu4vr4xnSDxMaL"
 };
 var VOICE_ID_PATTERN = /^[A-Za-z0-9]{20}$/;
+var CARRIER_NATIVE_FORMAT = {
+  twilio: "ulaw_8000",
+  telnyx: "pcm_16000",
+  // Plivo streams mulaw 8 kHz (we pin contentType in the answer XML).
+  plivo: "ulaw_8000"
+};
 function resolveVoiceId(voice) {
   if (!voice) return voice;
   if (VOICE_ID_PATTERN.test(voice)) return voice;
@@ -35539,11 +36376,8 @@ var ElevenLabsTTS = class _ElevenLabsTTS {
    */
   setTelephonyCarrier(carrier) {
     if (this._outputFormatExplicit) return;
-    if (carrier === "twilio") {
-      this._outputFormat = ElevenLabsOutputFormat.ULAW_8000;
-    } else if (carrier === "telnyx") {
-      this._outputFormat = ElevenLabsOutputFormat.PCM_16000;
-    }
+    const native = CARRIER_NATIVE_FORMAT[carrier];
+    if (native !== void 0) this._outputFormat = native;
   }
   /**
    * Construct an instance pre-configured for Twilio Media Streams.
@@ -37776,9 +38610,11 @@ var PLAN_REQUIRED_MSG = "ElevenLabs WS streaming requires a Pro plan or higher (
 function sanitiseLogStr(value, limit = 200) {
   return String(value).replace(/[\r\n\x00]/g, " ").slice(0, limit);
 }
-var CARRIER_NATIVE_FORMAT = {
+var CARRIER_NATIVE_FORMAT2 = {
   twilio: "ulaw_8000",
-  telnyx: "pcm_16000"
+  telnyx: "pcm_16000",
+  // Plivo streams mulaw 8 kHz (we pin contentType in the answer XML).
+  plivo: "ulaw_8000"
 };
 var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
   static providerKey = "elevenlabs_ws";
@@ -37862,7 +38698,7 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
    */
   setTelephonyCarrier(carrier) {
     if (this._outputFormatExplicit) return;
-    const native = CARRIER_NATIVE_FORMAT[carrier];
+    const native = CARRIER_NATIVE_FORMAT2[carrier];
     if (!native) return;
     this._outputFormat = native;
   }
@@ -40024,7 +40860,7 @@ var KrispVivaFilter = class {
 
 // src/telephony/twilio.ts
 init_cjs_shims();
-var Carrier = class {
+var Carrier2 = class {
   kind = "twilio";
   accountSid;
   authToken;
@@ -40048,7 +40884,7 @@ var Carrier = class {
 
 // src/telephony/telnyx.ts
 init_cjs_shims();
-var Carrier2 = class {
+var Carrier3 = class {
   kind = "telnyx";
   apiKey;
   connectionId;
@@ -40074,6 +40910,7 @@ var Carrier2 = class {
 };
 
 // src/index.ts
+init_plivo();
 init_openai_realtime_2();
 
 // src/public-api.ts
@@ -40132,9 +40969,9 @@ init_tunnel();
 
 // src/chat-context.ts
 init_cjs_shims();
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 function generateId() {
-  return (0, import_node_crypto4.randomUUID)().replace(/-/g, "").slice(0, 12);
+  return (0, import_node_crypto5.randomUUID)().replace(/-/g, "").slice(0, 12);
 }
 function createMessage(role, content, options) {
   return Object.freeze({
@@ -40914,7 +41751,7 @@ var TwilioAdapter = class _TwilioAdapter {
 
 // src/providers/telnyx-adapter.ts
 init_cjs_shims();
-var import_node_crypto5 = require("crypto");
+var import_node_crypto6 = require("crypto");
 init_logger();
 var TELNYX_API_BASE2 = "https://api.telnyx.com/v2";
 var TelnyxAdapter = class {
@@ -41018,7 +41855,7 @@ var TelnyxAdapter = class {
     if (!callControlId) throw new Error("TelnyxAdapter: callControlId is required");
     const encoded = encodeURIComponent(callControlId);
     const body = {
-      command_id: opts.commandId ?? (0, import_node_crypto5.randomUUID)()
+      command_id: opts.commandId ?? (0, import_node_crypto6.randomUUID)()
     };
     try {
       await this.request(
@@ -41035,6 +41872,9 @@ var TelnyxAdapter = class {
   }
 };
 
+// src/index.ts
+init_plivo_adapter();
+
 // src/providers/telnyx-stt.ts
 init_cjs_shims();
 var import_ws12 = __toESM(require("ws"));
@@ -41352,6 +42192,8 @@ init_event_bus();
   PatterTool,
   PcmCarry,
   PipelineHookExecutor,
+  Plivo,
+  PlivoAdapter,
   PricingUnit,
   ProvisionError,
   RateLimitError,