getpatter 0.6.2 → 0.6.3

package/dist/index.mjs

@@ -4,6 +4,7 @@ import {
 import {
   AuthenticationError,
   CallMetricsAccumulator,
+  Carrier,
   DEFAULT_MIN_SENTENCE_LEN,
   DEFAULT_PRICING,
   DeepgramModel,
@@ -21,6 +22,7 @@ import {
   PatterConnectionError,
   PatterError,
   PipelineHookExecutor,
+  PlivoAdapter,
   PricingUnit,
   ProvisionError,
   RateLimitError,
@@ -52,7 +54,7 @@ import {
   mountDashboard,
   resolveLogRoot,
   startSpan
-} from "./chunk-LE63CSOB.mjs";
+} from "./chunk-Z6W5XFWS.mjs";
 import {
   OpenAIRealtime2Adapter,
   OpenAIRealtimeAdapter,
@@ -799,7 +801,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;
@@ -977,16 +979,18 @@ 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 } = await import("./carrier-config-4ZKVYAWV.mjs");
+      const { autoConfigureCarrier } = await import("./carrier-config-3WDQXP5J.mjs");
       await autoConfigureCarrier({
         telephonyProvider,
         twilioSid: carrier.kind === "twilio" ? carrier.accountSid : void 0,
         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
       });
@@ -1002,6 +1006,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,
@@ -1033,7 +1039,7 @@ var Patter = class {
   }
   /** Run the agent in interactive terminal-test mode (no real telephony). */
   async test(opts) {
-    const { TestSession: TestSession2 } = await import("./test-mode-RS57BDM6.mjs");
+    const { TestSession: TestSession2 } = await import("./test-mode-MDBQ4ECE.mjs");
     const session = new TestSession2();
     await session.run({
       agent: opts.agent,
@@ -1413,7 +1419,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");
@@ -1421,7 +1435,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) {
@@ -1479,11 +1499,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 auth = `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: auth },
+        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 import("./persistence-LVIAHESK.mjs");
+          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;
@@ -1555,11 +1638,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
@@ -1600,6 +1725,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;
     }
@@ -1623,6 +1753,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.
    *
@@ -1677,6 +1831,17 @@ var Patter = class {
       }
       return;
     }
+    if (carrier.kind === "plivo") {
+      const auth = 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 ${auth}` } }
+      );
+      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}`);
   }
 };
@@ -2074,7 +2239,6 @@ init_esm_shims();
 
 // src/integrations/patter-tool.ts
 init_esm_shims();
-import { EventEmitter } from "events";
 var PARAMETERS_SCHEMA = {
   type: "object",
   properties: {
@@ -2101,7 +2265,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;
@@ -2109,24 +2273,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 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.");
@@ -2170,7 +2316,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) {
@@ -2182,52 +2336,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("+")) {
@@ -2243,55 +2376,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((resolve, 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,
-        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((resolve, reject) => {
-        this.pendingDial = resolve;
-        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
@@ -2309,32 +2419,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 duration = 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: duration,
-      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/providers/gemini-live.ts
 init_esm_shims();
@@ -2905,6 +3015,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;
@@ -2993,11 +3109,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.
@@ -5215,9 +5328,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";
@@ -5301,7 +5416,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;
   }
@@ -7445,7 +7560,7 @@ var KrispVivaFilter = class {
 
 // src/telephony/twilio.ts
 init_esm_shims();
-var Carrier = class {
+var Carrier2 = class {
   kind = "twilio";
   accountSid;
   authToken;
@@ -7469,7 +7584,7 @@ var Carrier = class {
 
 // src/telephony/telnyx.ts
 init_esm_shims();
-var Carrier2 = class {
+var Carrier3 = class {
   kind = "telnyx";
   apiKey;
   connectionId;
@@ -8757,6 +8872,8 @@ export {
   PatterTool,
   PcmCarry,
   PipelineHookExecutor,
+  Carrier as Plivo,
+  PlivoAdapter,
   PricingUnit,
   ProvisionError,
   RateLimitError,
@@ -8783,7 +8900,7 @@ export {
   TurnDetectionMode as SpeechmaticsTurnDetectionMode,
   StatefulResampler,
   Static as StaticTunnel,
-  Carrier2 as Telnyx,
+  Carrier3 as Telnyx,
   TelnyxAdapter,
   TelnyxSTT,
   TelnyxSTTInputFormat,
@@ -8794,7 +8911,7 @@ export {
   TestSession,
   TfidfLoopDetector,
   Tool,
-  Carrier as Twilio,
+  Carrier2 as Twilio,
   TwilioAdapter,
   ULTRAVOX_DEFAULT_API_BASE,
   ULTRAVOX_DEFAULT_SR,

package/dist/{test-mode-RS57BDM6.mjs → test-mode-MDBQ4ECE.mjs}

@@ -1,6 +1,6 @@
 import {
   TestSession
-} from "./chunk-LE63CSOB.mjs";
+} from "./chunk-Z6W5XFWS.mjs";
 import "./chunk-CL2U3YET.mjs";
 import "./chunk-MVOQFAEO.mjs";
 import "./chunk-N565J3CF.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "getpatter",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Open-source voice AI SDK — connect any AI agent to real phone calls in 4 lines of code",
   "license": "MIT",
   "author": {