getpatter 0.6.2 → 0.6.4

package/dist/index.mjs

@@ -4,6 +4,7 @@ import {
 import {
   AuthenticationError,
   CallMetricsAccumulator,
+  Carrier,
   DEFAULT_MIN_SENTENCE_LEN,
   DEFAULT_PRICING,
   DeepgramModel,
@@ -18,9 +19,11 @@ import {
   OpenAILLMProvider,
   PRICING_LAST_UPDATED,
   PRICING_VERSION,
+  PatterConfigError,
   PatterConnectionError,
   PatterError,
   PipelineHookExecutor,
+  PlivoAdapter,
   PricingUnit,
   ProvisionError,
   RateLimitError,
@@ -50,9 +53,11 @@ import {
   mergePricing,
   mountApi,
   mountDashboard,
+  openclawConsult,
+  openclawPostCallNotifier,
   resolveLogRoot,
   startSpan
-} from "./chunk-LE63CSOB.mjs";
+} from "./chunk-7IIV3BY4.mjs";
 import {
   OpenAIRealtime2Adapter,
   OpenAIRealtimeAdapter,
@@ -71,8 +76,9 @@ import {
   pcm16ToMulaw,
   resample16kTo8k,
   resample24kTo16k,
-  resample8kTo16k
-} from "./chunk-CL2U3YET.mjs";
+  resample8kTo16k,
+  validateRealtimeTurnDetection
+} from "./chunk-BO227NTF.mjs";
 import {
   MinWordsStrategy,
   evaluateStrategies,
@@ -87,7 +93,7 @@ import {
 } from "./chunk-6GR5MHHQ.mjs";
 import {
   SileroVAD
-} from "./chunk-R2T4JABZ.mjs";
+} from "./chunk-3VVATR6A.mjs";
 import {
   __dirname,
   __require,
@@ -109,6 +115,9 @@ var Realtime = class {
   voice;
   reasoningEffort;
   inputAudioTranscriptionModel;
+  noiseReduction;
+  turnDetection;
+  gateResponseOnTranscript;
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
     if (!key) {
@@ -116,11 +125,20 @@ var Realtime = class {
         "OpenAI Realtime requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
       );
     }
+    if (opts.noiseReduction !== void 0 && opts.noiseReduction !== "near_field" && opts.noiseReduction !== "far_field") {
+      throw new Error(
+        `noiseReduction must be 'near_field' or 'far_field', got ${JSON.stringify(opts.noiseReduction)}`
+      );
+    }
+    validateRealtimeTurnDetection(opts.turnDetection);
     this.apiKey = key;
     this.model = opts.model ?? "gpt-realtime-mini";
     this.voice = opts.voice ?? "alloy";
     this.reasoningEffort = opts.reasoningEffort;
     this.inputAudioTranscriptionModel = opts.inputAudioTranscriptionModel;
+    this.noiseReduction = opts.noiseReduction;
+    this.turnDetection = opts.turnDetection;
+    this.gateResponseOnTranscript = opts.gateResponseOnTranscript;
   }
 };
 
@@ -133,6 +151,9 @@ var Realtime2 = class {
   voice;
   reasoningEffort;
   inputAudioTranscriptionModel;
+  noiseReduction;
+  turnDetection;
+  gateResponseOnTranscript;
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
     if (!key) {
@@ -140,11 +161,20 @@ var Realtime2 = class {
         "OpenAI Realtime 2 requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
       );
     }
+    if (opts.noiseReduction !== void 0 && opts.noiseReduction !== "near_field" && opts.noiseReduction !== "far_field") {
+      throw new Error(
+        `noiseReduction must be 'near_field' or 'far_field', got ${JSON.stringify(opts.noiseReduction)}`
+      );
+    }
+    validateRealtimeTurnDetection(opts.turnDetection);
     this.apiKey = key;
     this.model = opts.model ?? "gpt-realtime-2";
     this.voice = opts.voice ?? "alloy";
     this.reasoningEffort = opts.reasoningEffort;
     this.inputAudioTranscriptionModel = opts.inputAudioTranscriptionModel;
+    this.noiseReduction = opts.noiseReduction;
+    this.turnDetection = opts.turnDetection;
+    this.gateResponseOnTranscript = opts.gateResponseOnTranscript;
   }
 };
 
@@ -571,7 +601,7 @@ function resolvePersistRoot(persist) {
   if (typeof persist === "string") return resolveLogRoot(persist);
   const envRoot = resolveLogRoot();
   if (envRoot !== null) return envRoot;
-  return resolveLogRoot("auto");
+  return null;
 }
 function closeParkedConnections(slot) {
   if (slot.stt) {
@@ -799,7 +829,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;
@@ -855,7 +885,12 @@ var Patter = class {
           ...working,
           provider: "openai_realtime",
           model: working.model ?? engine.model,
-          voice: working.voice ?? engine.voice
+          voice: working.voice ?? engine.voice,
+          // Explicit agent() kwargs win over the engine marker value
+          // (same precedence as Python: explicit kwarg > engine > default).
+          openaiRealtimeNoiseReduction: working.openaiRealtimeNoiseReduction ?? engine.noiseReduction,
+          realtimeTurnDetection: working.realtimeTurnDetection ?? engine.turnDetection,
+          openaiRealtimeGateResponseOnTranscript: working.openaiRealtimeGateResponseOnTranscript ?? engine.gateResponseOnTranscript
         };
         if (!this.localConfig.openaiKey) {
           this.localConfig = { ...this.localConfig, openaiKey: engine.apiKey };
@@ -880,6 +915,11 @@ var Patter = class {
         throw new Error(`provider must be one of: ${valid.join(", ")}. Got: '${working.provider}'`);
       }
     }
+    if (working.consult && working.provider === "elevenlabs_convai") {
+      getLogger().warn(
+        "consult is set but provider is ElevenLabs ConvAI; the consult tool is only injected in Realtime and Pipeline modes and will be ignored for this agent."
+      );
+    }
     if (working.llm !== void 0) {
       const llm = working.llm;
       if (!llm || typeof llm.stream !== "function") {
@@ -977,16 +1017,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-7YGNRBPO.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 +1044,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,
@@ -1014,7 +1058,8 @@ var Patter = class {
       opts.onMetrics,
       opts.pricing,
       opts.dashboard ?? true,
-      opts.dashboardToken ?? ""
+      opts.dashboardToken ?? "",
+      opts.allowInsecureDashboard ?? false
     );
     this.embeddedServer.popPrewarmAudio = this.popPrewarmAudio;
     this.embeddedServer.popPrewarmedConnections = this.popPrewarmedConnections;
@@ -1033,7 +1078,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-4QLLWYVV.mjs");
     const session = new TestSession2();
     await session.run({
       agent: opts.agent,
@@ -1212,7 +1257,7 @@ var Patter = class {
     }
     if (wantsRealtimePark) {
       tasks.push((async () => {
-        const { OpenAIRealtime2Adapter: OpenAIRealtime2Adapter2 } = await import("./openai-realtime-2-CNFARP25.mjs");
+        const { OpenAIRealtime2Adapter: OpenAIRealtime2Adapter2 } = await import("./openai-realtime-2-L5EKAAUH.mjs");
         const apiKey = process.env.OPENAI_API_KEY ?? "";
         if (!apiKey) {
           getLogger().debug(`Park OpenAI Realtime skipped for ${callId}: no OPENAI_API_KEY`);
@@ -1413,20 +1458,31 @@ 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");
     }
-    if (!options.to.startsWith("+")) {
-      throw new Error(`'to' must be in E.164 format (e.g., '+1234567890'). Got: '${options.to}'`);
+    if (!/^\+[1-9]\d{6,14}$/.test(options.to)) {
+      throw new Error("'to' must be E.164 format (+<country><digits>). Got value with invalid format.");
+    }
+    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) {
-      this.embeddedServer.onMachineDetection = options.onMachineDetection;
-    }
     if (options.agent.prewarm !== false) {
       this.spawnProviderWarmup(options.agent);
     }
@@ -1471,6 +1527,12 @@ var Patter = class {
         };
         if (this.embeddedServer) {
           this.embeddedServer.metricsStore.recordCallInitiated(initiatedPayload);
+          if (options.onMachineDetection) {
+            this.embeddedServer.onMachineDetectionByCallSid.set(
+              telnyxCallId,
+              options.onMachineDetection
+            );
+          }
         }
         try {
           const { notifyDashboard: notifyDashboard2 } = await import("./persistence-LVIAHESK.mjs");
@@ -1479,11 +1541,80 @@ 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);
+          if (options.onMachineDetection) {
+            this.embeddedServer.onMachineDetectionByCallSid.set(
+              plivoCallId,
+              options.onMachineDetection
+            );
+          }
+        }
+        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;
@@ -1542,6 +1673,12 @@ var Patter = class {
       };
       if (this.embeddedServer) {
         this.embeddedServer.metricsStore.recordCallInitiated(initiatedPayload);
+        if (options.onMachineDetection) {
+          this.embeddedServer.onMachineDetectionByCallSid.set(
+            twilioCallSid,
+            options.onMachineDetection
+          );
+        }
         if (twilioNotificationsPath) {
           getLogger().info(
             `Outbound call ${twilioCallSid} placed. Twilio notifications: https://api.twilio.com${twilioNotificationsPath} (check here if the call drops with no audio).`
@@ -1555,11 +1692,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 +1779,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 +1807,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 +1885,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}`);
   }
 };
@@ -1940,8 +2159,8 @@ var FallbackLLMProvider = class {
    * markers are filtered out so callers can concatenate the yielded strings
    * directly.
    */
-  async *completeStream(messages, tools) {
-    for await (const chunk of this.stream(messages, tools)) {
+  async *completeStream(messages, tools, opts) {
+    for await (const chunk of this.stream(messages, tools, opts)) {
       if (chunk.type === "text") {
         yield chunk.content ?? "";
       }
@@ -1951,14 +2170,15 @@ var FallbackLLMProvider = class {
   // LLMProvider implementation
   // -----------------------------------------------------------------------
   /** Streaming entry point — yields chunks from the first provider that succeeds. */
-  async *stream(messages, tools) {
+  async *stream(messages, tools, opts) {
     const errors = [];
     const result = yield* this.tryProviders(
       messages,
       tools,
       /* availableOnly */
       true,
-      errors
+      errors,
+      opts
     );
     if (result === "done") return;
     getLogger().warn(
@@ -1969,7 +2189,8 @@ var FallbackLLMProvider = class {
       tools,
       /* availableOnly */
       false,
-      errors
+      errors,
+      opts
     );
     if (retryResult === "done") return;
     throw new AllProvidersFailedError(
@@ -1979,7 +2200,7 @@ var FallbackLLMProvider = class {
   // -----------------------------------------------------------------------
   // Internals
   // -----------------------------------------------------------------------
-  async *tryProviders(messages, tools, availableOnly, errors) {
+  async *tryProviders(messages, tools, availableOnly, errors, opts) {
     for (let i = 0; i < this.providers.length; i++) {
       if (availableOnly && !this.availability[i]) continue;
       for (let attempt = 0; attempt < this.maxRetryPerProvider; attempt++) {
@@ -1988,7 +2209,7 @@ var FallbackLLMProvider = class {
             `FallbackLLMProvider: trying provider ${i}${attempt > 0 ? ` (retry ${attempt})` : ""}`
           );
           let yieldedTokens = false;
-          const gen = this.providers[i].stream(messages, tools);
+          const gen = this.providers[i].stream(messages, tools, opts);
           while (true) {
             let iterResult;
             try {
@@ -2074,7 +2295,6 @@ init_esm_shims();
 
 // src/integrations/patter-tool.ts
 init_esm_shims();
-import { EventEmitter } from "events";
 var PARAMETERS_SCHEMA = {
   type: "object",
   properties: {
@@ -2101,7 +2321,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 +2329,11 @@ 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;
+  /** Cached in-progress (or completed) start promise so concurrent execute()
+   *  callers all await the same boot sequence instead of each racing into
+   *  phone.serve(). Reset to null on failure so callers can retry after a
+   *  transient error. */
+  startPromise = null;
   constructor(opts) {
     if (!opts.phone) {
       throw new Error("PatterTool: `phone` (a Patter instance) is required.");
@@ -2170,8 +2377,29 @@ 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.
+   *
+   * Idempotent and concurrency-safe: concurrent callers all await the same
+   * in-progress boot instead of each racing into `phone.serve()`.
+   */
   async start() {
+    if (this.startPromise) return this.startPromise;
+    this.startPromise = this._doStart();
+    try {
+      await this.startPromise;
+    } catch (err) {
+      this.startPromise = null;
+      throw err;
+    }
+  }
+  async _doStart() {
     if (this.started) return;
     if (!this.agent) {
       throw new Error(
@@ -2182,52 +2410,32 @@ 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;
+    this.startPromise = null;
   }
   // --- 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 +2451,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 +2494,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();
@@ -2605,7 +2790,8 @@ var UltravoxRealtimeAdapter = class {
         "X-API-Key": this.apiKey,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15e3)
     });
     if (!resp.ok) {
       const text = await resp.text().catch(() => "");
@@ -2616,12 +2802,36 @@ var UltravoxRealtimeAdapter = class {
     this.ws = new WebSocket(call.joinUrl);
     await new Promise((resolve, reject) => {
       const ws = this.ws;
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        ws.off("open", onOpen);
+        ws.off("error", onError);
+        this.ws = null;
+        try {
+          ws.close();
+        } catch {
+        }
+        reject(new Error("Ultravox WS connect timeout"));
+      }, 15e3);
       const onOpen = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
         ws.off("error", onError);
         resolve();
       };
       const onError = (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
         ws.off("open", onOpen);
+        this.ws = null;
+        try {
+          ws.close();
+        } catch {
+        }
         reject(err);
       };
       ws.once("open", onOpen);
@@ -2905,6 +3115,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 +3209,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.
@@ -3457,7 +3670,7 @@ var STT = class extends DeepgramSTT {
       {
         endpointingMs: opts.endpointingMs ?? 150,
         utteranceEndMs: opts.utteranceEndMs === null ? null : opts.utteranceEndMs ?? 1e3,
-        smartFormat: opts.smartFormat ?? true,
+        smartFormat: opts.smartFormat ?? false,
         interimResults: opts.interimResults ?? true,
         ...opts.vadEvents !== void 0 ? { vadEvents: opts.vadEvents } : {}
       }
@@ -3775,7 +3988,7 @@ var CartesiaSTT = class {
       });
       ws.once("error", (err) => {
         clearTimeout(timer);
-        reject(err);
+        reject(new Error(`Cartesia STT park connect failed: ${describeWarmupError(err)}`));
       });
     });
     return ws;
@@ -4130,7 +4343,7 @@ var SonioxSTT = class _SonioxSTT {
   /** Stable pricing/dashboard key — read by stream-handler/metrics. */
   static providerKey = "soniox";
   ws = null;
-  callbacks = [];
+  callbacks = /* @__PURE__ */ new Set();
   final = new TokenAccumulator();
   keepaliveTimer = null;
   apiKey;
@@ -4292,16 +4505,13 @@ var SonioxSTT = class _SonioxSTT {
     if (audio.length === 0) return;
     this.ws.send(audio);
   }
-  /** Register a transcript listener (max 10 concurrent listeners). */
+  /** Register a transcript listener. */
   onTranscript(callback) {
-    if (this.callbacks.length >= 10) {
-      getLogger().warn(
-        "SonioxSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback."
-      );
-      this.callbacks[this.callbacks.length - 1] = callback;
-      return;
-    }
-    this.callbacks.push(callback);
+    this.callbacks.add(callback);
+  }
+  /** Unregister a previously registered transcript listener. */
+  offTranscript(callback) {
+    this.callbacks.delete(callback);
   }
   /** Send the empty-frame stream terminator and close the WebSocket. */
   close() {
@@ -4382,12 +4592,6 @@ var VALID_DOMAINS = /* @__PURE__ */ new Set([
   AssemblyAIDomain.GENERAL,
   AssemblyAIDomain.MEDICAL_V1
 ]);
-var AssemblyAISTTNotConnectedError = class extends Error {
-  constructor(message = "AssemblyAISTT is not connected") {
-    super(message);
-    this.name = "AssemblyAISTTNotConnectedError";
-  }
-};
 var AssemblyAISTT = class _AssemblyAISTT {
   constructor(apiKey, options = {}) {
     this.apiKey = apiKey;
@@ -4711,9 +4915,10 @@ var AssemblyAISTT = class _AssemblyAISTT {
    */
   updateConfiguration(params) {
     if (!this.ws || this.ws.readyState !== WebSocket4.OPEN) {
-      throw new AssemblyAISTTNotConnectedError(
-        "AssemblyAISTT.updateConfiguration: WebSocket is not open"
+      getLogger().debug(
+        "AssemblyAISTT.updateConfiguration: WebSocket is not open \u2014 dropping update (call teardown)."
       );
+      return;
     }
     const payload = {
       type: AssemblyAIClientFrame.UPDATE_CONFIGURATION
@@ -4735,9 +4940,10 @@ var AssemblyAISTT = class _AssemblyAISTT {
   /** Force the server to finalize the current turn (for barge-in). */
   forceEndpoint() {
     if (!this.ws || this.ws.readyState !== WebSocket4.OPEN) {
-      throw new AssemblyAISTTNotConnectedError(
-        "AssemblyAISTT.forceEndpoint: WebSocket is not open"
+      getLogger().debug(
+        "AssemblyAISTT.forceEndpoint: WebSocket is not open \u2014 dropping request (call teardown)."
       );
+      return;
     }
     this.ws.send(JSON.stringify({ type: AssemblyAIClientFrame.FORCE_ENDPOINT }));
   }
@@ -4752,6 +4958,14 @@ var AssemblyAISTT = class _AssemblyAISTT {
   async close() {
     this.closing = true;
     if (!this.ws) return;
+    if (this.chunkBufferBytes > 0 && this.ws.readyState === WebSocket4.OPEN) {
+      try {
+        this.ws.send(Buffer.concat(this.chunkBuffer, this.chunkBufferBytes));
+      } catch {
+      }
+      this.chunkBuffer = [];
+      this.chunkBufferBytes = 0;
+    }
     try {
       this.ws.send(JSON.stringify({ type: AssemblyAIClientFrame.TERMINATE }));
     } catch {
@@ -5215,9 +5429,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 +5517,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;
   }
@@ -5953,7 +6169,7 @@ var TTS3 = class extends OpenAITTS {
       opts.model ?? "gpt-4o-mini-tts",
       opts.instructions ?? null,
       opts.speed ?? null,
-      opts.antiAlias ?? false
+      opts.antiAlias ?? true
     );
   }
 };
@@ -6127,7 +6343,6 @@ init_esm_shims();
 // src/providers/inworld-tts.ts
 init_esm_shims();
 var INWORLD_BASE_URL = "https://api.inworld.ai/tts/v1/voice:stream";
-var INWORLD_VOICES_URL = "https://api.inworld.ai/tts/v1/voices";
 var InworldModel = {
   TTS_2: "inworld-tts-2",
   TTS_1_5_MAX: "inworld-tts-1.5-max",
@@ -6216,7 +6431,8 @@ var InworldTTS = class {
    */
   async warmup() {
     try {
-      await fetch(INWORLD_VOICES_URL, {
+      const voicesUrl = new URL(this.baseUrl).origin + "/tts/v1/voices";
+      await fetch(voicesUrl, {
         method: "GET",
         headers: {
           Authorization: `Basic ${this.authToken}`
@@ -6473,58 +6689,87 @@ var AnthropicLLMProvider = class {
     const toolIndexByBlock = /* @__PURE__ */ new Map();
     const toolIdByBlock = /* @__PURE__ */ new Map();
     let nextIndex = 0;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data: ")) continue;
-        const data = trimmed.slice(6);
-        if (!data || data === "[DONE]") continue;
-        let event;
-        try {
-          event = JSON.parse(data);
-        } catch {
-          continue;
-        }
-        if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
-          const blockIdx = event.index ?? 0;
-          const toolId = event.content_block.id ?? "";
-          const toolName = event.content_block.name ?? "";
-          const patterIndex = nextIndex++;
-          toolIndexByBlock.set(blockIdx, patterIndex);
-          toolIdByBlock.set(blockIdx, toolId);
-          yield {
-            type: "tool_call",
-            index: patterIndex,
-            id: toolId,
-            name: toolName,
-            arguments: ""
-          };
-          continue;
-        }
-        if (event.type === "content_block_delta") {
-          if (event.delta?.type === "text_delta" && event.delta.text) {
-            yield { type: "text", content: event.delta.text };
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (!data || data === "[DONE]") continue;
+          let event;
+          try {
+            event = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          if (event.type === "message_start" && event.message?.usage) {
+            const u = event.message.usage;
+            if (u.input_tokens) inputTokens = u.input_tokens;
+            if (u.cache_creation_input_tokens) cacheWriteTokens = u.cache_creation_input_tokens;
+            if (u.cache_read_input_tokens) cacheReadTokens = u.cache_read_input_tokens;
+            continue;
+          }
+          if (event.type === "message_delta" && event.usage?.output_tokens) {
+            outputTokens = event.usage.output_tokens;
             continue;
           }
-          if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+          if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
             const blockIdx = event.index ?? 0;
-            const patterIndex = toolIndexByBlock.get(blockIdx);
-            if (patterIndex !== void 0) {
-              yield {
-                type: "tool_call",
-                index: patterIndex,
-                id: toolIdByBlock.get(blockIdx),
-                arguments: event.delta.partial_json
-              };
+            const toolId = event.content_block.id ?? "";
+            const toolName = event.content_block.name ?? "";
+            const patterIndex = nextIndex++;
+            toolIndexByBlock.set(blockIdx, patterIndex);
+            toolIdByBlock.set(blockIdx, toolId);
+            yield {
+              type: "tool_call",
+              index: patterIndex,
+              id: toolId,
+              name: toolName,
+              arguments: ""
+            };
+            continue;
+          }
+          if (event.type === "content_block_delta") {
+            if (event.delta?.type === "text_delta" && event.delta.text) {
+              yield { type: "text", content: event.delta.text };
+              continue;
+            }
+            if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+              const blockIdx = event.index ?? 0;
+              const patterIndex = toolIndexByBlock.get(blockIdx);
+              if (patterIndex !== void 0) {
+                yield {
+                  type: "tool_call",
+                  index: patterIndex,
+                  id: toolIdByBlock.get(blockIdx),
+                  arguments: event.delta.partial_json
+                };
+              }
             }
           }
         }
       }
+    } finally {
+      reader.cancel().catch(() => {
+      });
+    }
+    if (inputTokens > 0 || outputTokens > 0 || cacheReadTokens > 0 || cacheWriteTokens > 0) {
+      yield {
+        type: "usage",
+        inputTokens,
+        outputTokens,
+        cacheReadInputTokens: cacheReadTokens,
+        cacheWriteInputTokens: cacheWriteTokens
+      };
     }
     yield { type: "done" };
   }
@@ -6584,16 +6829,17 @@ function toAnthropicMessages(messages) {
     }
     if (role === "tool") {
       const contentStr = typeof rawMsg.content === "string" ? rawMsg.content : JSON.stringify(rawMsg.content);
-      out.push({
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: rawMsg.tool_call_id ?? "",
-            content: contentStr
-          }
-        ]
-      });
+      const toolResultBlock = {
+        type: "tool_result",
+        tool_use_id: rawMsg.tool_call_id ?? "",
+        content: contentStr
+      };
+      const prev = out.length > 0 ? out[out.length - 1] : void 0;
+      if (prev && prev.role === "user" && Array.isArray(prev.content) && prev.content.length > 0 && prev.content.every((b) => b["type"] === "tool_result")) {
+        prev.content.push(toolResultBlock);
+      } else {
+        out.push({ role: "user", content: [toolResultBlock] });
+      }
       continue;
     }
   }
@@ -6733,50 +6979,55 @@ async function* parseOpenAISseStream(response) {
   if (!reader) return;
   const decoder = new TextDecoder();
   let buffer = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || !trimmed.startsWith("data: ")) continue;
-      const data = trimmed.slice(6);
-      if (data === "[DONE]") continue;
-      let chunk;
-      try {
-        chunk = JSON.parse(data);
-      } catch {
-        continue;
-      }
-      const usage = chunk.usage ?? chunk.x_groq?.usage;
-      if (usage) {
-        const cached = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
-        yield {
-          type: "usage",
-          inputTokens: usage.prompt_tokens,
-          outputTokens: usage.completion_tokens,
-          cacheReadInputTokens: cached
-        };
-      }
-      const delta = chunk.choices?.[0]?.delta;
-      if (!delta) continue;
-      if (delta.content) {
-        yield { type: "text", content: delta.content };
-      }
-      if (delta.tool_calls) {
-        for (const tc of delta.tool_calls) {
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data: ")) continue;
+        const data = trimmed.slice(6);
+        if (data === "[DONE]") continue;
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        const usage = chunk.usage ?? chunk.x_groq?.usage;
+        if (usage) {
+          const cached = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
           yield {
-            type: "tool_call",
-            index: tc.index,
-            id: tc.id,
-            name: tc.function?.name,
-            arguments: tc.function?.arguments
+            type: "usage",
+            inputTokens: usage.prompt_tokens,
+            outputTokens: usage.completion_tokens,
+            cacheReadInputTokens: cached
           };
         }
+        const delta = chunk.choices?.[0]?.delta;
+        if (!delta) continue;
+        if (delta.content) {
+          yield { type: "text", content: delta.content };
+        }
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            yield {
+              type: "tool_call",
+              index: tc.index,
+              id: tc.id,
+              name: tc.function?.name,
+              arguments: tc.function?.arguments
+            };
+          }
+        }
       }
     }
+  } finally {
+    reader.cancel().catch(() => {
+    });
   }
 }
 
@@ -6941,11 +7192,21 @@ var CerebrasLLMProvider = class {
       }
       const advisoryMs = parseRateLimitResetMs(response.headers);
       const exponentialMs = RETRY_BACKOFF_BASE_MS * Math.pow(2, attempt);
-      const delayMs = Math.max(advisoryMs, exponentialMs);
+      const delayMs = Math.min(5e3, Math.max(advisoryMs, exponentialMs));
       getLogger().warn(
         `Cerebras API ${response.status} (attempt ${attempt + 1}/${maxAttempts}); retrying after ${delayMs}ms`
       );
-      await new Promise((r) => setTimeout(r, delayMs));
+      await new Promise((resolve, reject) => {
+        const t = setTimeout(resolve, delayMs);
+        opts?.signal?.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(t);
+            reject(opts.signal.reason);
+          },
+          { once: true }
+        );
+      });
     }
     throw new PatterError(`Cerebras API error ${lastStatus}: ${lastErrText || "request failed"}`);
   }
@@ -7106,47 +7367,52 @@ var GoogleLLMProvider = class {
     let buffer = "";
     let nextIndex = 0;
     let lastUsage;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data: ")) continue;
-        const data = trimmed.slice(6);
-        if (!data) continue;
-        let payload;
-        try {
-          payload = JSON.parse(data);
-        } catch {
-          continue;
-        }
-        if (payload.usageMetadata) {
-          lastUsage = payload.usageMetadata;
-        }
-        const candidate = payload.candidates?.[0];
-        const parts = candidate?.content?.parts ?? [];
-        for (const part of parts) {
-          if (part.functionCall) {
-            const args = part.functionCall.args ?? {};
-            const callId = part.functionCall.id ?? `gemini_call_${nextIndex}`;
-            yield {
-              type: "tool_call",
-              index: nextIndex,
-              id: callId,
-              name: part.functionCall.name ?? "",
-              arguments: JSON.stringify(args)
-            };
-            nextIndex++;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (!data) continue;
+          let payload;
+          try {
+            payload = JSON.parse(data);
+          } catch {
             continue;
           }
-          if (part.text) {
-            yield { type: "text", content: part.text };
+          if (payload.usageMetadata) {
+            lastUsage = payload.usageMetadata;
+          }
+          const candidate = payload.candidates?.[0];
+          const parts = candidate?.content?.parts ?? [];
+          for (const part of parts) {
+            if (part.functionCall) {
+              const args = part.functionCall.args ?? {};
+              const callId = part.functionCall.id ?? `gemini_call_${nextIndex}`;
+              yield {
+                type: "tool_call",
+                index: nextIndex,
+                id: callId,
+                name: part.functionCall.name ?? "",
+                arguments: JSON.stringify(args)
+              };
+              nextIndex++;
+              continue;
+            }
+            if (part.text) {
+              yield { type: "text", content: part.text };
+            }
           }
         }
       }
+    } finally {
+      reader.cancel().catch(() => {
+      });
     }
     if (lastUsage) {
       yield {
@@ -7240,7 +7506,17 @@ function toGeminiContents(messages) {
       continue;
     }
   }
-  return { systemInstruction: systemParts.join("\n\n"), contents };
+  const merged = [];
+  for (const entry of contents) {
+    const prev = merged[merged.length - 1];
+    const isFunctionResponseOnly = (c) => c.role === "user" && c.parts.every((p) => p.functionResponse !== void 0);
+    if (prev && isFunctionResponseOnly(prev) && isFunctionResponseOnly(entry)) {
+      prev.parts.push(...entry.parts);
+    } else {
+      merged.push(entry);
+    }
+  }
+  return { systemInstruction: systemParts.join("\n\n"), contents: merged };
 }
 
 // src/llm/google.ts
@@ -7294,6 +7570,57 @@ function float32ToPcm16(samples) {
   }
   return out;
 }
+var ArbitraryResampler = class {
+  srcRate;
+  dstRate;
+  phase = 0;
+  // fractional position into the current chunk
+  lastSample = 0;
+  // last input sample from the previous chunk
+  hasHistory = false;
+  constructor(srcRate, dstRate) {
+    this.srcRate = srcRate;
+    this.dstRate = dstRate;
+  }
+  /** Process a chunk of PCM16-LE mono audio and return resampled PCM16-LE. */
+  process(pcm) {
+    const sampleCount = Math.floor(pcm.length / 2);
+    if (sampleCount === 0) return Buffer.alloc(0);
+    const step = this.srcRate / this.dstRate;
+    const outArr = [];
+    let phase = this.phase;
+    while (true) {
+      const idx = Math.floor(phase);
+      if (idx >= sampleCount) break;
+      const frac = phase - idx;
+      let s0;
+      let s1;
+      if (idx < 0) {
+        s0 = this.hasHistory ? this.lastSample : 0;
+        s1 = pcm.readInt16LE(0);
+      } else {
+        s0 = pcm.readInt16LE(idx * 2);
+        s1 = idx + 1 < sampleCount ? pcm.readInt16LE((idx + 1) * 2) : s0;
+      }
+      const interp = Math.round(s0 + (s1 - s0) * frac);
+      outArr.push(Math.max(-32768, Math.min(32767, interp)));
+      phase += step;
+    }
+    this.lastSample = pcm.readInt16LE((sampleCount - 1) * 2);
+    this.hasHistory = true;
+    this.phase = phase - sampleCount;
+    const out = Buffer.alloc(outArr.length * 2);
+    for (let j = 0; j < outArr.length; j++) out.writeInt16LE(outArr[j], j * 2);
+    return out;
+  }
+  /** Flush any buffered state and reset. Returns any remaining tail output. */
+  flush() {
+    this.phase = 0;
+    this.lastSample = 0;
+    this.hasHistory = false;
+    return Buffer.alloc(0);
+  }
+};
 var DeepFilterNetFilter = class {
   modelPath;
   silenceWarnings;
@@ -7301,8 +7628,9 @@ var DeepFilterNetFilter = class {
   ort = null;
   warned = false;
   closed = false;
-  // Fix 5: stateful resamplers for src_sr↔48k conversions so chunk-boundary
+  // Stateful resamplers for src_sr↔48k conversions so chunk-boundary
   // samples are not discarded. Lazy-created and torn down on rate change.
+  // Uses ArbitraryResampler which supports any integer rate pair.
   _resamplerSrcRate = null;
   _upsamplerInst = null;
   _downsamplerInst = null;
@@ -7360,8 +7688,8 @@ var DeepFilterNetFilter = class {
     try {
       if (this._resamplerSrcRate !== sampleRate) {
         this._resamplerSrcRate = sampleRate;
-        this._upsamplerInst = new StatefulResampler({ srcRate: sampleRate, dstRate: DEEPFILTERNET_SR });
-        this._downsamplerInst = new StatefulResampler({ srcRate: DEEPFILTERNET_SR, dstRate: sampleRate });
+        this._upsamplerInst = new ArbitraryResampler(sampleRate, DEEPFILTERNET_SR);
+        this._downsamplerInst = new ArbitraryResampler(DEEPFILTERNET_SR, sampleRate);
       }
       const samples = pcm16ToFloat32(pcmChunk);
       const pcm16Up = this._upsamplerInst.process(float32ToPcm16(new Float32Array(samples)));
@@ -7445,7 +7773,7 @@ var KrispVivaFilter = class {
 
 // src/telephony/twilio.ts
 init_esm_shims();
-var Carrier = class {
+var Carrier2 = class {
   kind = "twilio";
   accountSid;
   authToken;
@@ -7469,7 +7797,7 @@ var Carrier = class {
 
 // src/telephony/telnyx.ts
 init_esm_shims();
-var Carrier2 = class {
+var Carrier3 = class {
   kind = "telnyx";
   apiKey;
   connectionId;
@@ -7521,6 +7849,17 @@ var Tool = class {
   parameters;
   handler;
   webhookUrl;
+  reassurance;
+  /**
+   * Per-tool execution timeout in milliseconds. `undefined` uses the
+   * executor default (10 000 ms). Mirrors Python `timeout_s`.
+   */
+  timeoutMs;
+  /**
+   * Enable OpenAI strict mode for this tool's function schema. Off by
+   * default. Mirrors Python `strict` on `Tool`.
+   */
+  strict;
   constructor(opts) {
     if (!opts.name) {
       throw new Error("Tool requires a non-empty name.");
@@ -7538,6 +7877,9 @@ var Tool = class {
     this.parameters = opts.parameters ?? { type: "object", properties: {} };
     if (hasHandler) this.handler = opts.handler;
     if (hasWebhook) this.webhookUrl = opts.webhookUrl;
+    if (opts.reassurance !== void 0) this.reassurance = opts.reassurance;
+    if (opts.timeoutMs !== void 0) this.timeoutMs = opts.timeoutMs;
+    if (opts.strict !== void 0) this.strict = opts.strict;
   }
 };
 function tool(opts) {
@@ -7696,7 +8038,6 @@ var ChatContext = class _ChatContext {
 // src/services/ivr.ts
 init_esm_shims();
 var DTMF_EVENTS = [
-  "0",
   "1",
   "2",
   "3",
@@ -7706,6 +8047,7 @@ var DTMF_EVENTS = [
   "7",
   "8",
   "9",
+  "0",
   "*",
   "#",
   "A",
@@ -8382,18 +8724,24 @@ var TelnyxAdapter = class {
       "/number_orders",
       orderBody
     );
-    const orderId = order.data?.id ?? "";
+    const orderId = order.data?.id;
+    if (!orderId) throw new Error("TelnyxAdapter: /number_orders returned no order id");
     return { phoneNumber: chosen, orderId };
   }
   /** Attach a number to a Call Control Application. */
   async configureNumber(phoneNumber, opts) {
     if (!phoneNumber) throw new Error("TelnyxAdapter: phoneNumber is required");
     if (!opts.connectionId) throw new Error("TelnyxAdapter: connectionId is required");
-    await this.request(
-      "PATCH",
-      `/phone_numbers/${encodeURIComponent(phoneNumber)}/voice`,
-      { connection_id: opts.connectionId, tech_prefix_enabled: false }
-    );
+    try {
+      await this.request(
+        "PATCH",
+        `/phone_numbers/${encodeURIComponent(phoneNumber)}/voice`,
+        { connection_id: opts.connectionId, tech_prefix_enabled: false }
+      );
+    } catch (err) {
+      const status = err instanceof Error ? err.message.replace(/\+\d{7,15}/g, "[REDACTED]") : String(err);
+      throw new Error(`TelnyxAdapter: configureNumber failed: ${status}`);
+    }
   }
   /**
    * Place an outbound call on the Call Control Application.
@@ -8497,7 +8845,7 @@ var TelnyxSTT = class {
   /** Stable pricing/dashboard key — read by stream-handler/metrics. */
   static providerKey = "telnyx_stt";
   ws = null;
-  callbacks = [];
+  callbacks = /* @__PURE__ */ new Set();
   headerSent = false;
   /** Open the streaming WebSocket and arm message handlers. */
   async connect() {
@@ -8553,14 +8901,13 @@ var TelnyxSTT = class {
     }
     this.ws.send(audio);
   }
-  /** Register a transcript listener (max 10 concurrent listeners). */
+  /** Register a transcript listener. */
   onTranscript(callback) {
-    if (this.callbacks.length >= 10) {
-      getLogger().warn("TelnyxSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback.");
-      this.callbacks[this.callbacks.length - 1] = callback;
-      return;
-    }
-    this.callbacks.push(callback);
+    this.callbacks.add(callback);
+  }
+  /** Unregister a previously-registered transcript listener. */
+  offTranscript(callback) {
+    this.callbacks.delete(callback);
   }
   /** Close the streaming WebSocket. */
   close() {
@@ -8571,6 +8918,7 @@ var TelnyxSTT = class {
       }
       this.ws = null;
     }
+    this.headerSent = false;
   }
 };
 
@@ -8591,6 +8939,7 @@ var TelnyxTTSSampleRate = {
   HZ_24000: 24e3
 };
 var DEFAULT_VOICE = TelnyxTTSVoice.NATURAL_HD_ASTRA;
+var FRAME_TIMEOUT_MS2 = 3e4;
 var TelnyxTTS = class {
   constructor(apiKey, voice = DEFAULT_VOICE, baseUrl = TELNYX_TTS_WS_URL) {
     this.apiKey = apiKey;
@@ -8618,69 +8967,83 @@ var TelnyxTTS = class {
    */
   async *synthesizeStream(text) {
     const url = `${this.baseUrl}?voice=${encodeURIComponent(this.voice)}`;
-    const ws = new WebSocket8(url, {
-      headers: { Authorization: `Bearer ${this.apiKey}` }
-    });
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("Telnyx TTS connect timeout")), 1e4);
-      ws.once("open", () => {
-        clearTimeout(timer);
-        resolve();
+    let ws = null;
+    try {
+      let push2 = function(item) {
+        const w = waiters.shift();
+        if (w) {
+          w(item);
+        } else {
+          queue.push(item);
+        }
+      };
+      var push = push2;
+      ws = new WebSocket8(url, {
+        headers: { Authorization: `Bearer ${this.apiKey}` }
       });
-      ws.once("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("Telnyx TTS connect timeout")), 1e4);
+        ws.once("open", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+        ws.once("error", (err) => {
+          clearTimeout(timer);
+          reject(err);
+        });
       });
-    });
-    const queue = [];
-    const waiters = [];
-    function push(item) {
-      const w = waiters.shift();
-      if (w) {
-        w(item);
-      } else {
-        queue.push(item);
-      }
-    }
-    ws.on("message", (raw) => {
-      let data;
-      try {
-        data = JSON.parse(raw.toString());
-      } catch {
-        getLogger().warn("TelnyxTTS: received invalid JSON");
-        return;
-      }
-      const audioB64 = data.audio;
-      if (!audioB64) return;
-      try {
-        const audioBytes = Buffer.from(audioB64, "base64");
-        if (audioBytes.length > 0) {
-          push(audioBytes);
+      const queue = [];
+      const waiters = [];
+      ws.on("message", (raw) => {
+        let data;
+        try {
+          data = JSON.parse(raw.toString());
+        } catch {
+          getLogger().warn("TelnyxTTS: received invalid JSON");
+          return;
         }
-      } catch {
-      }
-    });
-    ws.on("close", () => {
-      push(null);
-    });
-    ws.on("error", (err) => {
-      push({ error: err instanceof Error ? err : new Error(String(err)) });
-    });
-    ws.send(JSON.stringify({ text: " " }));
-    ws.send(JSON.stringify({ text }));
-    ws.send(JSON.stringify({ text: "" }));
-    try {
+        const audioB64 = data.audio;
+        if (!audioB64) return;
+        try {
+          const audioBytes = Buffer.from(audioB64, "base64");
+          if (audioBytes.length > 0) {
+            push2(audioBytes);
+          }
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        push2(null);
+      });
+      ws.on("error", (err) => {
+        push2({ error: err instanceof Error ? err : new Error(String(err)) });
+      });
+      ws.send(JSON.stringify({ text: " " }));
+      ws.send(JSON.stringify({ text }));
+      ws.send(JSON.stringify({ text: "" }));
       while (true) {
-        const item = queue.length > 0 ? queue.shift() : await new Promise((resolve) => waiters.push(resolve));
+        let frameTimer;
+        const item = queue.length > 0 ? queue.shift() : await Promise.race([
+          new Promise((resolve) => waiters.push(resolve)),
+          new Promise((_, reject) => {
+            frameTimer = setTimeout(
+              () => reject(new Error("Telnyx TTS frame timeout")),
+              FRAME_TIMEOUT_MS2
+            );
+          })
+        ]).finally(() => {
+          if (frameTimer !== void 0) clearTimeout(frameTimer);
+        });
         if (item === null) return;
         if (typeof item === "object" && "error" in item) throw item.error;
         yield item;
       }
     } finally {
       try {
-        ws.close();
+        ws?.close();
       } catch {
       }
+      ws?.removeAllListeners();
     }
   }
 };
@@ -8752,11 +9115,14 @@ export {
   PRICING_VERSION,
   PartialStreamError,
   Patter,
+  PatterConfigError,
   PatterConnectionError,
   PatterError,
   PatterTool,
   PcmCarry,
   PipelineHookExecutor,
+  Carrier as Plivo,
+  PlivoAdapter,
   PricingUnit,
   ProvisionError,
   RateLimitError,
@@ -8783,7 +9149,7 @@ export {
   TurnDetectionMode as SpeechmaticsTurnDetectionMode,
   StatefulResampler,
   Static as StaticTunnel,
-  Carrier2 as Telnyx,
+  Carrier3 as Telnyx,
   TelnyxAdapter,
   TelnyxSTT,
   TelnyxSTTInputFormat,
@@ -8794,7 +9160,7 @@ export {
   TestSession,
   TfidfLoopDetector,
   Tool,
-  Carrier as Twilio,
+  Carrier2 as Twilio,
   TwilioAdapter,
   ULTRAVOX_DEFAULT_API_BASE,
   ULTRAVOX_DEFAULT_SR,
@@ -8837,6 +9203,8 @@ export {
   mulawToPcm16,
   notifyDashboard,
   openaiTts,
+  openclawConsult,
+  openclawPostCallNotifier,
   pcm16ToMulaw,
   resample16kTo8k,
   resample24kTo16k,