getpatter 0.5.1 → 0.5.3

package/dist/index.mjs

@@ -3,21 +3,37 @@ import {
 } from "./chunk-AFUYSNDH.mjs";
 import {
   startTunnel
-} from "./chunk-AKQFOFLG.mjs";
+} from "./chunk-SEMKNPCD.mjs";
 import {
+  AuthenticationError,
   CallMetricsAccumulator,
   DEFAULT_MIN_SENTENCE_LEN,
   DEFAULT_PRICING,
   DeepgramSTT,
+  DefaultToolExecutor,
   ElevenLabsConvAIAdapter,
   EmbeddedServer,
+  EventBus,
   LLMLoop,
   MetricsStore,
   OpenAILLMProvider,
   OpenAIRealtimeAdapter,
+  PatterConnectionError,
+  PatterError,
+  PcmCarry,
   PipelineHookExecutor,
+  ProvisionError,
+  RateLimitError,
   RemoteMessageHandler,
+  SPAN_BARGEIN,
+  SPAN_CALL,
+  SPAN_ENDPOINT,
+  SPAN_LLM,
+  SPAN_STT,
+  SPAN_TOOL,
+  SPAN_TTS,
   SentenceChunker,
+  StatefulResampler,
   TestSession,
   calculateRealtimeCost,
   calculateSttCost,
@@ -25,7 +41,12 @@ import {
   calculateTtsCost,
   callsToCsv,
   callsToJson,
+  createResampler16kTo8k,
+  createResampler24kTo16k,
+  createResampler8kTo16k,
+  initTracing,
   isRemoteUrl,
+  isTracingEnabled,
   isWebSocketUrl,
   makeAuthMiddleware,
   mergePricing,
@@ -35,153 +56,14 @@ import {
   pcm16ToMulaw,
   resample16kTo8k,
   resample24kTo16k,
-  resample8kTo16k
-} from "./chunk-B6C3KIBG.mjs";
+  resample8kTo16k,
+  startSpan
+} from "./chunk-FIFIWBL7.mjs";
 import {
   getLogger,
   setLogger
-} from "./chunk-FMNRCP5X.mjs";
-import "./chunk-OOIUSZB4.mjs";
-
-// src/connection.ts
-import WebSocket from "ws";
-
-// src/errors.ts
-var PatterError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "PatterError";
-  }
-};
-var PatterConnectionError = class extends PatterError {
-  constructor(message) {
-    super(message);
-    this.name = "PatterConnectionError";
-  }
-};
-var AuthenticationError = class extends PatterError {
-  constructor(message) {
-    super(message);
-    this.name = "AuthenticationError";
-  }
-};
-var ProvisionError = class extends PatterError {
-  constructor(message) {
-    super(message);
-    this.name = "ProvisionError";
-  }
-};
-
-// src/connection.ts
-var DEFAULT_BACKEND_URL = "wss://api.getpatter.com";
-var PatterConnection = class {
-  apiKey;
-  backendUrl;
-  wsUrl;
-  ws = null;
-  onMessage = null;
-  onCallStart = null;
-  onCallEnd = null;
-  constructor(apiKey, backendUrl = DEFAULT_BACKEND_URL) {
-    this.apiKey = apiKey;
-    this.backendUrl = backendUrl.replace(/\/+$/, "");
-    this.wsUrl = `${this.backendUrl}/ws/sdk`;
-  }
-  get isConnected() {
-    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
-  }
-  async connect(options) {
-    this.onMessage = options.onMessage;
-    this.onCallStart = options.onCallStart ?? null;
-    this.onCallEnd = options.onCallEnd ?? null;
-    return new Promise((resolve, reject) => {
-      this.ws = new WebSocket(this.wsUrl, {
-        headers: { "X-API-Key": this.apiKey }
-      });
-      const onError = (err) => {
-        this.ws?.off("error", onError);
-        reject(new PatterConnectionError(`Failed to connect: ${err.message}`));
-      };
-      this.ws.once("open", () => {
-        this.ws?.off("error", onError);
-        this.setupListeners();
-        resolve();
-      });
-      this.ws.on("error", onError);
-    });
-  }
-  setupListeners() {
-    if (!this.ws) return;
-    this.ws.on("error", (err) => {
-      getLogger().error(`WebSocket error: ${err.message}`);
-    });
-    this.ws.on("message", async (data) => {
-      const raw = data.toString();
-      let parsed;
-      try {
-        parsed = JSON.parse(raw);
-      } catch {
-        return;
-      }
-      const msgType = parsed.type;
-      if (msgType === "message" && this.onMessage) {
-        const msg = {
-          text: parsed.text,
-          callId: parsed.call_id,
-          caller: parsed.caller ?? ""
-        };
-        try {
-          const response = await this.onMessage(msg);
-          if (response != null) {
-            await this.sendResponse(msg.callId, response);
-          }
-        } catch {
-        }
-      } else if (msgType === "call_start" && this.onCallStart) {
-        await this.onCallStart(parsed);
-      } else if (msgType === "call_end" && this.onCallEnd) {
-        await this.onCallEnd(parsed);
-      }
-    });
-    this.ws.on("close", () => {
-      this.ws = null;
-    });
-  }
-  async sendResponse(callId, text) {
-    if (!this.ws) throw new PatterConnectionError("Not connected");
-    this.ws.send(JSON.stringify({ type: "response", call_id: callId, text }));
-  }
-  async requestCall(fromNumber, toNumber, firstMessage = "") {
-    if (!this.ws) throw new PatterConnectionError("Not connected");
-    this.ws.send(
-      JSON.stringify({
-        type: "call",
-        from: fromNumber,
-        to: toNumber,
-        first_message: firstMessage
-      })
-    );
-  }
-  async disconnect() {
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-  }
-  parseMessage(raw) {
-    try {
-      const data = JSON.parse(raw);
-      if (data.type !== "message") return null;
-      return {
-        text: data.text,
-        callId: data.call_id,
-        caller: data.caller ?? ""
-      };
-    } catch {
-      return null;
-    }
-  }
-};
+} from "./chunk-VJVDG4V5.mjs";
+import "./chunk-QHHBUCMT.mjs";
 
 // src/engines/openai.ts
 var Realtime = class {
@@ -241,86 +123,77 @@ var Static = class {
     this.hostname = opts.hostname;
   }
 };
+var Ngrok = class {
+  kind = "ngrok";
+  hostname;
+  constructor(opts = {}) {
+    this.hostname = opts.hostname ?? "";
+  }
+  /**
+   * Returns the configured hostname or throws if the marker was constructed
+   * without one. Patter does not start ngrok itself — the user is expected
+   * to either supply a hostname or run ngrok out-of-band.
+   */
+  start() {
+    if (!this.hostname) {
+      throw new Error(
+        'Ngrok requires a hostname; pass new Ngrok({ hostname: "abc.ngrok.io" })'
+      );
+    }
+    return this.hostname;
+  }
+};
 
 // src/client.ts
-var DEFAULT_BACKEND_URL2 = "wss://api.getpatter.com";
-var DEFAULT_REST_URL = "https://api.getpatter.com";
-function sttConfigToDict(cfg) {
-  const out = {
-    provider: cfg.provider,
-    api_key: cfg.apiKey,
-    language: cfg.language
-  };
-  if (cfg.options) out.options = { ...cfg.options };
-  return out;
-}
-function ttsConfigToDict(cfg) {
-  const out = {
-    provider: cfg.provider,
-    api_key: cfg.apiKey,
-    voice: cfg.voice
-  };
-  if (cfg.options) out.options = { ...cfg.options };
-  return out;
-}
 var Patter = class {
-  apiKey;
-  backendUrl;
-  restUrl;
-  connection;
-  mode;
   localConfig;
   embeddedServer = null;
   tunnelHandle = null;
+  /**
+   * Live `MetricsStore` for the embedded server. Returns `null` before
+   * `serve()` is called. Exposed so integrations like `PatterTool` can
+   * subscribe to per-call lifecycle events (`call_initiated`,
+   * `call_start`, `call_end`).
+   */
+  get metricsStore() {
+    return this.embeddedServer?.metricsStore ?? null;
+  }
   constructor(options) {
-    const hasCarrier = "carrier" in options && options.carrier !== void 0;
-    const isLocal = "mode" in options && options.mode === "local" || hasCarrier;
-    if (isLocal) {
-      const local = options;
-      if (!local.phoneNumber) {
-        throw new Error("Local mode requires phoneNumber");
-      }
-      if (!local.carrier) {
+    if (options.apiKey !== void 0) {
+      throw new Error(
+        "Patter Cloud is not yet available in this SDK release. Use local mode with `carrier:` and `phoneNumber:`. Cloud mode will return in a future release."
+      );
+    }
+    if (!options.phoneNumber) {
+      throw new Error("Local mode requires phoneNumber");
+    }
+    if (!options.carrier) {
+      throw new Error(
+        "Local mode requires a `carrier` instance. Pass `carrier: new Twilio({...})` or `carrier: new Telnyx({...})`."
+      );
+    }
+    const carrier = options.carrier;
+    const tunnel = options.tunnel;
+    let tunnelWebhookUrl;
+    if (tunnel instanceof Static) {
+      if (options.webhookUrl) {
         throw new Error(
-          "Local mode requires a `carrier` instance. Pass `carrier: new Twilio({...})` or `carrier: new Telnyx({...})`."
+          "Cannot use both `tunnel: new StaticTunnel(...)` and `webhookUrl`. Pick one."
         );
       }
-      const carrier = local.carrier;
-      const tunnel = local.tunnel;
-      let tunnelWebhookUrl;
-      if (tunnel instanceof Static) {
-        if (local.webhookUrl) {
-          throw new Error(
-            "Cannot use both `tunnel: new StaticTunnel(...)` and `webhookUrl`. Pick one."
-          );
-        }
-        tunnelWebhookUrl = tunnel.hostname;
-      }
-      this.mode = "local";
-      const rawWebhook = tunnelWebhookUrl ?? local.webhookUrl;
-      const normalizedWebhook = rawWebhook ? rawWebhook.replace(/^https?:\/\//, "").replace(/\/$/, "") : void 0;
-      this.localConfig = {
-        carrier,
-        phoneNumber: local.phoneNumber,
-        webhookUrl: normalizedWebhook,
-        tunnel: local.tunnel,
-        openaiKey: local.openaiKey
-      };
-      this.apiKey = "";
-      this.backendUrl = DEFAULT_BACKEND_URL2;
-      this.restUrl = DEFAULT_REST_URL;
-      this.connection = new PatterConnection("", DEFAULT_BACKEND_URL2);
-    } else {
-      const cloudOpts = options;
-      this.mode = "cloud";
-      this.localConfig = null;
-      this.apiKey = cloudOpts.apiKey;
-      this.backendUrl = cloudOpts.backendUrl ?? DEFAULT_BACKEND_URL2;
-      this.restUrl = cloudOpts.restUrl ?? DEFAULT_REST_URL;
-      this.connection = new PatterConnection(this.apiKey, this.backendUrl);
-    }
+      tunnelWebhookUrl = tunnel.hostname;
+    }
+    const rawWebhook = tunnelWebhookUrl ?? options.webhookUrl;
+    const normalizedWebhook = rawWebhook ? rawWebhook.replace(/^https?:\/\//, "").replace(/\/$/, "") : void 0;
+    this.localConfig = {
+      carrier,
+      phoneNumber: options.phoneNumber,
+      webhookUrl: normalizedWebhook,
+      tunnel: options.tunnel,
+      openaiKey: options.openaiKey
+    };
   }
-  // === Local mode ===
+  // === Agent definition ===
   agent(opts) {
     let working = { ...opts };
     if (opts.engine) {
@@ -337,7 +210,7 @@ var Patter = class {
           model: working.model ?? engine.model,
           voice: working.voice ?? engine.voice
         };
-        if (this.localConfig && !this.localConfig.openaiKey) {
+        if (!this.localConfig.openaiKey) {
           this.localConfig = { ...this.localConfig, openaiKey: engine.apiKey };
         }
       } else if (engine instanceof ConvAI) {
@@ -387,10 +260,8 @@ var Patter = class {
     }
     return working;
   }
+  // === Serve / test / call ===
   async serve(opts) {
-    if (this.mode !== "local" || !this.localConfig) {
-      throw new Error("serve() is only available in local mode");
-    }
     if (!opts.agent || typeof opts.agent !== "object") {
       throw new TypeError("agent is required. Use phone.agent() to create one.");
     }
@@ -415,10 +286,13 @@ var Patter = class {
     if (wantsCloudflared && webhookUrl) {
       throw new Error("Cannot use both tunnel: true and webhookUrl. Pick one.");
     }
+    const { showBanner } = await import("./banner-3GNZ6VQK.mjs");
+    showBanner();
     if (wantsCloudflared) {
-      const { startTunnel: startTunnel2 } = await import("./tunnel-O7ICMSTP.mjs");
+      const { startTunnel: startTunnel2 } = await import("./tunnel-UVR3PPAU.mjs");
       this.tunnelHandle = await startTunnel2(port);
       webhookUrl = this.tunnelHandle.hostname;
+      this.localConfig = { ...this.localConfig, webhookUrl };
     }
     if (!webhookUrl) {
       throw new Error(
@@ -427,7 +301,7 @@ var Patter = class {
     }
     const carrier = this.localConfig.carrier;
     const telephonyProvider = carrier.kind === "twilio" ? "twilio" : "telnyx";
-    const { autoConfigureCarrier } = await import("./carrier-config-CPG5CROM.mjs");
+    const { autoConfigureCarrier } = await import("./carrier-config-33HQ2W4V.mjs");
     await autoConfigureCarrier({
       telephonyProvider,
       twilioSid: carrier.kind === "twilio" ? carrier.accountSid : void 0,
@@ -464,138 +338,56 @@ var Patter = class {
     await this.embeddedServer.start(port);
   }
   async test(opts) {
-    if (this.mode !== "local") {
-      throw new Error("test() is only available in local mode");
-    }
-    const { TestSession: TestSession2 } = await import("./test-mode-JZMYE5HY.mjs");
+    const { TestSession: TestSession2 } = await import("./test-mode-MVJ3SKG4.mjs");
     const session = new TestSession2();
     await session.run({
       agent: opts.agent,
-      openaiKey: this.localConfig?.openaiKey,
+      openaiKey: this.localConfig.openaiKey,
       onMessage: typeof opts.onMessage === "function" ? opts.onMessage : void 0,
       onCallStart: opts.onCallStart,
       onCallEnd: opts.onCallEnd
     });
   }
-  // === Cloud mode legacy ===
-  async connect(options) {
-    if (options.provider && options.providerKey && options.number) {
-      await this.registerNumber(
-        options.provider,
-        options.providerKey,
-        options.number,
-        options.providerSecret,
-        options.country ?? "US",
-        options.stt,
-        options.tts
-      );
-    }
-    await this.connection.connect({
-      onMessage: options.onMessage,
-      onCallStart: options.onCallStart,
-      onCallEnd: options.onCallEnd
-    });
-  }
   async call(options) {
-    if (this.mode === "local") {
-      const localOpts = options;
-      if (!localOpts.to) {
-        throw new Error("'to' phone number is required");
-      }
-      if (!localOpts.to.startsWith("+")) {
-        throw new Error(`'to' must be in E.164 format (e.g., '+1234567890'). Got: '${localOpts.to}'`);
-      }
-      if (!this.localConfig) {
-        throw new Error("local config missing");
-      }
-      const { phoneNumber, webhookUrl, carrier } = this.localConfig;
-      if (carrier.kind === "telnyx") {
-        const telnyxKey = carrier.apiKey;
-        const connectionId = carrier.connectionId;
-        const streamUrl = `wss://${webhookUrl}/ws/stream/${encodeURIComponent(localOpts.to)}?caller=${encodeURIComponent(phoneNumber)}&callee=${encodeURIComponent(localOpts.to)}`;
-        const telnyxPayload = {
-          connection_id: connectionId,
-          from: phoneNumber,
-          to: localOpts.to,
-          stream_url: streamUrl,
-          stream_track: "both_tracks"
-        };
-        if (localOpts.ringTimeout !== void 0) {
-          telnyxPayload.timeout_secs = Math.max(1, Math.floor(localOpts.ringTimeout));
-        }
-        const response2 = await fetch("https://api.telnyx.com/v2/calls", {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${telnyxKey}`
-          },
-          body: JSON.stringify(telnyxPayload)
-        });
-        if (!response2.ok) {
-          throw new ProvisionError(`Failed to initiate Telnyx call: ${await response2.text()}`);
-        }
-        if (this.embeddedServer) {
-          try {
-            const body = await response2.clone().json();
-            const callId = body.data?.call_control_id;
-            if (callId) {
-              this.embeddedServer.metricsStore.recordCallInitiated({
-                call_id: callId,
-                caller: phoneNumber,
-                callee: localOpts.to,
-                direction: "outbound"
-              });
-            }
-          } catch {
-          }
-        }
-        return;
-      }
-      const twilioSid = carrier.accountSid;
-      const twilioToken = carrier.authToken;
-      const statusCallbackUrl = `https://${webhookUrl}/webhooks/twilio/status`;
-      const url = `https://api.twilio.com/2010-04-01/Accounts/${twilioSid}/Calls.json`;
-      const params = new URLSearchParams({
-        To: localOpts.to,
-        From: phoneNumber,
-        Url: `https://${webhookUrl}/webhooks/twilio/voice`,
-        StatusCallback: statusCallbackUrl,
-        StatusCallbackMethod: "POST",
-        // Full lifecycle so the dashboard sees ringing/no-answer/busy/failed
-        // transitions even when media never arrives.
-        StatusCallbackEvent: "initiated ringing answered completed"
-      });
-      if (localOpts.machineDetection) {
-        params.append("MachineDetection", "DetectMessageEnd");
-        params.append("AsyncAmd", "true");
-        params.append("AsyncAmdStatusCallback", `https://${webhookUrl}/webhooks/twilio/amd`);
-      }
-      if (localOpts.ringTimeout !== void 0) {
-        params.append("Timeout", String(Math.max(1, Math.floor(localOpts.ringTimeout))));
-      }
-      if (localOpts.voicemailMessage && this.embeddedServer) {
-        this.embeddedServer.voicemailMessage = localOpts.voicemailMessage;
+    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}'`);
+    }
+    const { phoneNumber, webhookUrl, carrier } = this.localConfig;
+    const effectiveRingTimeout = options.ringTimeout === void 0 ? 25 : options.ringTimeout;
+    if (carrier.kind === "telnyx") {
+      const telnyxKey = carrier.apiKey;
+      const connectionId = carrier.connectionId;
+      const telnyxPayload = {
+        connection_id: connectionId,
+        from: phoneNumber,
+        to: options.to
+      };
+      if (effectiveRingTimeout !== null && effectiveRingTimeout !== void 0) {
+        telnyxPayload.timeout_secs = Math.max(1, Math.floor(effectiveRingTimeout));
       }
-      const response = await fetch(url, {
+      const response2 = await fetch("https://api.telnyx.com/v2/calls", {
         method: "POST",
         headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          Authorization: `Basic ${Buffer.from(`${twilioSid}:${twilioToken}`).toString("base64")}`
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${telnyxKey}`
         },
-        body: params.toString()
+        body: JSON.stringify(telnyxPayload)
       });
-      if (!response.ok) {
-        throw new ProvisionError(`Failed to initiate call: ${await response.text()}`);
+      if (!response2.ok) {
+        throw new ProvisionError(`Failed to initiate Telnyx call: ${await response2.text()}`);
       }
       if (this.embeddedServer) {
         try {
-          const body = await response.clone().json();
-          const callSid = body.sid;
-          if (callSid) {
+          const body = await response2.clone().json();
+          const callId = body.data?.call_control_id;
+          if (callId) {
             this.embeddedServer.metricsStore.recordCallInitiated({
-              call_id: callSid,
+              call_id: callId,
               caller: phoneNumber,
-              callee: localOpts.to,
+              callee: options.to,
               direction: "outbound"
             });
           }
@@ -604,21 +396,59 @@ var Patter = class {
       }
       return;
     }
-    const cloudOpts = options;
-    if (!this.connection.isConnected) {
-      if (cloudOpts.onMessage) {
-        await this.connection.connect({ onMessage: cloudOpts.onMessage });
-      } else {
-        throw new PatterConnectionError(
-          "Not connected. Call connect() first or pass onMessage."
-        );
+    const twilioSid = carrier.accountSid;
+    const twilioToken = carrier.authToken;
+    const statusCallbackUrl = `https://${webhookUrl}/webhooks/twilio/status`;
+    const url = `https://api.twilio.com/2010-04-01/Accounts/${twilioSid}/Calls.json`;
+    const streamUrl = `wss://${webhookUrl}/ws/stream/outbound`;
+    const inlineTwiml = `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${streamUrl}"/></Connect></Response>`;
+    const params = new URLSearchParams({
+      To: options.to,
+      From: phoneNumber,
+      Twiml: inlineTwiml,
+      StatusCallback: statusCallbackUrl,
+      StatusCallbackMethod: "POST",
+      // Full lifecycle so the dashboard sees ringing/no-answer/busy/failed
+      // transitions even when media never arrives.
+      StatusCallbackEvent: "initiated ringing answered completed"
+    });
+    if (options.machineDetection) {
+      params.append("MachineDetection", "DetectMessageEnd");
+      params.append("AsyncAmd", "true");
+      params.append("AsyncAmdStatusCallback", `https://${webhookUrl}/webhooks/twilio/amd`);
+    }
+    if (effectiveRingTimeout !== null && effectiveRingTimeout !== void 0) {
+      params.append("Timeout", String(Math.max(1, Math.floor(effectiveRingTimeout))));
+    }
+    if (options.voicemailMessage && this.embeddedServer) {
+      this.embeddedServer.voicemailMessage = options.voicemailMessage;
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Authorization: `Basic ${Buffer.from(`${twilioSid}:${twilioToken}`).toString("base64")}`
+      },
+      body: params.toString()
+    });
+    if (!response.ok) {
+      throw new ProvisionError(`Failed to initiate call: ${await response.text()}`);
+    }
+    if (this.embeddedServer) {
+      try {
+        const body = await response.clone().json();
+        const callSid = body.sid;
+        if (callSid) {
+          this.embeddedServer.metricsStore.recordCallInitiated({
+            call_id: callSid,
+            caller: phoneNumber,
+            callee: options.to,
+            direction: "outbound"
+          });
+        }
+      } catch {
       }
     }
-    await this.connection.requestCall(
-      cloudOpts.fromNumber ?? "",
-      cloudOpts.to,
-      cloudOpts.firstMessage ?? ""
-    );
   }
   async disconnect() {
     if (this.tunnelHandle) {
@@ -629,86 +459,6 @@ var Patter = class {
       await this.embeddedServer.stop();
       this.embeddedServer = null;
     }
-    await this.connection.disconnect();
-  }
-  // === Agent Management ===
-  async createAgent(opts) {
-    const response = await fetch(`${this.restUrl}/api/agents`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", "X-API-Key": this.apiKey },
-      body: JSON.stringify({
-        name: opts.name,
-        system_prompt: opts.systemPrompt,
-        model: opts.model ?? "gpt-4o-mini-realtime-preview",
-        voice: opts.voice ?? "alloy",
-        voice_provider: opts.voiceProvider ?? "openai",
-        language: opts.language ?? "en",
-        first_message: opts.firstMessage ?? null,
-        tools: opts.tools?.map((t) => ({ name: t.name, description: t.description, parameters: t.parameters, webhook_url: t.webhookUrl })) ?? null
-      })
-    });
-    if (response.status !== 201) throw new ProvisionError(`Failed to create agent: ${await response.text()}`);
-    const data = await response.json();
-    return { id: data.id, name: data.name, systemPrompt: data.system_prompt, model: data.model, voice: data.voice, voiceProvider: data.voice_provider, language: data.language, firstMessage: data.first_message, tools: data.tools };
-  }
-  async listAgents() {
-    const response = await fetch(`${this.restUrl}/api/agents`, { headers: { "X-API-Key": this.apiKey } });
-    if (!response.ok) throw new ProvisionError(`Failed to list agents: ${response.status}`);
-    const data = await response.json();
-    return data.map((a) => ({ id: a.id, name: a.name, systemPrompt: a.system_prompt, model: a.model, voice: a.voice, voiceProvider: a.voice_provider, language: a.language, firstMessage: a.first_message, tools: a.tools }));
-  }
-  async buyNumber(opts = {}) {
-    const response = await fetch(`${this.restUrl}/api/numbers/buy`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", "X-API-Key": this.apiKey },
-      body: JSON.stringify({ country: opts.country ?? "US", provider: opts.provider ?? "twilio" })
-    });
-    if (response.status !== 201) throw new ProvisionError(`Failed to buy number: ${await response.text()}`);
-    const data = await response.json();
-    return { id: data.id, number: data.number, provider: data.provider, country: data.country, status: data.status, agentId: data.agent_id };
-  }
-  async assignAgent(numberId, agentId) {
-    const response = await fetch(`${this.restUrl}/api/phone-numbers/${numberId}/assign-agent`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", "X-API-Key": this.apiKey },
-      body: JSON.stringify({ agent_id: agentId })
-    });
-    if (response.status !== 200) throw new ProvisionError(`Failed to assign agent: ${await response.text()}`);
-  }
-  async listCalls(limit = 50) {
-    if (!Number.isInteger(limit) || limit < 1 || limit > 1e3) {
-      throw new RangeError(`limit must be an integer between 1 and 1000, got ${limit}`);
-    }
-    const response = await fetch(`${this.restUrl}/api/calls?limit=${limit}`, { headers: { "X-API-Key": this.apiKey } });
-    if (!response.ok) throw new ProvisionError(`Failed to list calls: ${response.status}`);
-    const data = await response.json();
-    return data.map((c) => ({ id: c.id, direction: c.direction, caller: c.caller, callee: c.callee, startedAt: c.started_at, endedAt: c.ended_at, durationSeconds: c.duration_seconds, status: c.status, transcript: c.transcript }));
-  }
-  // Internal
-  async registerNumber(provider, providerKey, number, providerSecret, country = "US", stt, tts) {
-    const credentials = { api_key: providerKey };
-    if (providerSecret) credentials.api_secret = providerSecret;
-    const response = await fetch(`${this.restUrl}/api/phone-numbers`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-API-Key": this.apiKey
-      },
-      body: JSON.stringify({
-        number,
-        provider,
-        provider_credentials: credentials,
-        country,
-        stt_config: stt ? stt.toDict?.() ?? sttConfigToDict(stt) : null,
-        tts_config: tts ? tts.toDict?.() ?? ttsConfigToDict(tts) : null
-      })
-    });
-    if (response.status === 409) return;
-    if (response.status !== 201) {
-      throw new ProvisionError(
-        `Failed to register number: ${await response.text()}`
-      );
-    }
   }
 };
 
@@ -828,6 +578,46 @@ function elevenlabs(opts) {
 function openaiTts(opts) {
   return new TTSConfigImpl("openai", opts.apiKey, opts.voice ?? "alloy");
 }
+function soniox(opts) {
+  return new STTConfigImpl("soniox", opts.apiKey, opts.language ?? "en");
+}
+function speechmatics(_opts) {
+  throw new Error(
+    "speechmatics() is Python-only right now \u2014 the TS Speechmatics adapter has not shipped yet. Use the Python SDK (sdk-py) or pick another STT provider such as deepgram() / assemblyai() / soniox()."
+  );
+}
+function assemblyai(opts) {
+  return new STTConfigImpl("assemblyai", opts.apiKey, opts.language ?? "en");
+}
+function cartesia(opts) {
+  return new TTSConfigImpl(
+    "cartesia",
+    opts.apiKey,
+    opts.voice ?? "f786b574-daa5-4673-aa0c-cbe3e8534c02"
+  );
+}
+function rime(opts) {
+  return new TTSConfigImpl("rime", opts.apiKey, opts.voice ?? "astra");
+}
+function lmnt(opts) {
+  return new TTSConfigImpl("lmnt", opts.apiKey, opts.voice ?? "leah");
+}
+function ultravox(opts) {
+  return {
+    provider: "ultravox",
+    apiKey: opts.apiKey,
+    model: opts.model,
+    voice: opts.voice
+  };
+}
+function geminiLive(opts) {
+  return {
+    provider: "gemini_live",
+    apiKey: opts.apiKey,
+    model: opts.model,
+    voice: opts.voice
+  };
+}
 
 // src/fallback-provider.ts
 var AllProvidersFailedError = class extends Error {
@@ -1026,13 +816,275 @@ var FallbackLLMProvider = class {
   }
 };
 
+// src/integrations/patter-tool.ts
+import { EventEmitter } from "events";
+var PARAMETERS_SCHEMA = {
+  type: "object",
+  properties: {
+    to: {
+      type: "string",
+      description: 'Destination phone number in E.164 format (e.g. "+15551234567"). Required.'
+    },
+    goal: {
+      type: "string",
+      description: "What the agent should accomplish on the call. Becomes the in-call agent's system prompt for this single call."
+    },
+    first_message: {
+      type: "string",
+      description: "Optional first message the agent speaks when the callee answers. Defaults to a generic greeting."
+    },
+    max_duration_sec: {
+      type: "integer",
+      description: "Hard timeout for the call in seconds. Default 180. The call is force-ended at this deadline whether or not it has resolved.",
+      minimum: 5,
+      maximum: 1800
+    }
+  },
+  required: ["to"]
+};
+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 {
+  name;
+  description;
+  phone;
+  agent;
+  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.");
+    }
+    this.phone = opts.phone;
+    this.agent = opts.agent;
+    this.name = opts.name ?? DEFAULT_NAME;
+    this.description = opts.description ?? DEFAULT_DESCRIPTION;
+    this.maxDurationSec = Math.max(5, Math.min(1800, opts.maxDurationSec ?? 180));
+    this.recording = opts.recording ?? false;
+  }
+  // --- Schema exporters ---------------------------------------------------
+  /** OpenAI Chat Completions / Assistants tool spec. */
+  openaiSchema() {
+    return {
+      type: "function",
+      function: {
+        name: this.name,
+        description: this.description,
+        parameters: PARAMETERS_SCHEMA
+      }
+    };
+  }
+  /** Anthropic Messages API tool spec. */
+  anthropicSchema() {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: PARAMETERS_SCHEMA
+    };
+  }
+  /**
+   * Hermes Agent (Nous Research) registry schema. Same JSON-Schema shape as
+   * Anthropic's; Hermes consumes it via `registry.register({ schema: ... })`.
+   */
+  hermesSchema() {
+    return {
+      name: this.name,
+      description: this.description,
+      parameters: PARAMETERS_SCHEMA
+    };
+  }
+  // --- Lifecycle ----------------------------------------------------------
+  /** Start the underlying Patter server. Idempotent. */
+  async start() {
+    if (this.started) return;
+    if (!this.agent) {
+      throw new Error(
+        "PatterTool.start: `agent` config is required. Pass `{ stt, llm, tts }` or an `engine` (e.g. OpenAIRealtime) when constructing PatterTool."
+      );
+    }
+    const builtAgent = this.phone.agent(this.agent);
+    await this.phone.serve({
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      agent: builtAgent,
+      recording: this.recording,
+      onCallEnd: this.onCallEndHandler.bind(this)
+    });
+    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). */
+  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();
+    }
+    this.started = false;
+  }
+  // --- Execution ----------------------------------------------------------
+  async execute(args) {
+    if (!this.started) await this.start();
+    if (!args || typeof args.to !== "string" || !args.to.startsWith("+")) {
+      throw new Error('PatterTool.execute: `to` must be an E.164 phone number (e.g. "+15551234567").');
+    }
+    const timeoutSec = Math.max(
+      5,
+      Math.min(1800, args.max_duration_sec ?? this.maxDurationSec)
+    );
+    const baseAgent = this.agent ?? {};
+    const overrideAgent = this.phone.agent({
+      ...baseAgent,
+      ...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`));
+      }, 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;
+    });
+    const previous = this.dialQueue;
+    this.dialQueue = previous.then(() => slot);
+    await previous;
+    let captureTimer = null;
+    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;
+    } finally {
+      if (captureTimer) clearTimeout(captureTimer);
+      this.pendingDial = null;
+      release();
+    }
+  }
+  /**
+   * Hermes-style handler: `(args, kwargs) => Promise<string>` returning a JSON
+   * string with either the result envelope or an `{"error": "..."}` payload.
+   * Mirrors the Python `PatterTool.hermes_handler` so cross-SDK adapters share
+   * the same wire contract.
+   */
+  hermesHandler() {
+    return async (args) => {
+      try {
+        const result = await this.execute(args);
+        return JSON.stringify(result);
+      } catch (err) {
+        return JSON.stringify({ error: err instanceof Error ? err.message : String(err) });
+      }
+    };
+  }
+  // --- 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
+    });
+  }
+};
+
 // src/providers/gemini-live.ts
 var GEMINI_DEFAULT_INPUT_SR = 16e3;
 var GEMINI_DEFAULT_OUTPUT_SR = 24e3;
 var GeminiLiveAdapter = class {
   constructor(apiKey, options = {}) {
     this.apiKey = apiKey;
-    this.model = options.model ?? "gemini-2.0-flash-exp";
+    this.model = options.model ?? "gemini-2.5-flash-native-audio-preview-09-2025";
     this.voice = options.voice ?? "Puck";
     this.instructions = options.instructions ?? "";
     this.language = options.language ?? "en-US";
@@ -1055,18 +1107,27 @@ var GeminiLiveAdapter = class {
   receiveLoop = null;
   handlers = [];
   running = false;
+  /**
+   * Tracks call_id -> function name so tool responses can be sent back with
+   * the correct `name` field (Gemini expects the original function name,
+   * not the call_id).
+   */
+  pendingToolCalls = /* @__PURE__ */ new Map();
   async connect() {
     let genaiModule;
     try {
       const modName = "@google/genai";
       genaiModule = await import(modName);
-    } catch (err) {
+    } catch {
       throw new Error(
-        "Gemini Live requires the '@google/genai' package. Install with: npm install @google/genai"
+        '\nGemini Live requires the "@google/genai" package, which is not installed.\n\n  Install:  npm install @google/genai\n\nThis is an optional peer dependency of getpatter \u2014 it is only needed when\nyou use GeminiLive as an agent engine. Other LLM/engine providers do not\nrequire it.\n'
       );
     }
     const { GoogleGenAI } = genaiModule;
-    this.client = new GoogleGenAI({ apiKey: this.apiKey });
+    this.client = new GoogleGenAI({
+      apiKey: this.apiKey,
+      httpOptions: { apiVersion: "v1alpha" }
+    });
     const config = {
       responseModalities: ["AUDIO"],
       speechConfig: {
@@ -1123,9 +1184,11 @@ var GeminiLiveAdapter = class {
   async sendFunctionResult(callId, result) {
     if (!this.session) return;
     const sess = this.session;
+    const name = this.pendingToolCalls.get(callId) ?? callId;
+    this.pendingToolCalls.delete(callId);
     await sess.sendToolResponse?.({
       functionResponses: [
-        { id: callId, name: callId, response: { result } }
+        { id: callId, name, response: { result } }
       ]
     });
   }
@@ -1169,9 +1232,14 @@ var GeminiLiveAdapter = class {
         if (r.toolCall) {
           for (const fn of r.toolCall.functionCalls ?? []) {
             const args = fn.args ?? {};
+            const callId = fn.id ?? "";
+            const fnName = fn.name ?? "";
+            if (callId && fnName) {
+              this.pendingToolCalls.set(callId, fnName);
+            }
             await this.emit("function_call", {
-              call_id: fn.id ?? "",
-              name: fn.name ?? "",
+              call_id: callId,
+              name: fnName,
               arguments: typeof args === "string" ? args : JSON.stringify(args)
             });
           }
@@ -1198,11 +1266,12 @@ var GeminiLiveAdapter = class {
       await this.receiveLoop.catch(() => void 0);
       this.receiveLoop = null;
     }
+    this.pendingToolCalls.clear();
   }
 };
 
 // src/providers/ultravox-realtime.ts
-import WebSocket2 from "ws";
+import WebSocket from "ws";
 var ULTRAVOX_DEFAULT_API_BASE = "https://api.ultravox.ai/api";
 var ULTRAVOX_DEFAULT_SR = 16e3;
 var UltravoxRealtimeAdapter = class {
@@ -1239,7 +1308,6 @@ var UltravoxRealtimeAdapter = class {
           outputSampleRate: this.sampleRate
         }
       },
-      firstSpeaker: this.firstMessage ? "FIRST_SPEAKER_AGENT" : "FIRST_SPEAKER_USER",
       recordingEnabled: false
     };
     if (this.voice) body.voice = this.voice;
@@ -1249,6 +1317,8 @@ var UltravoxRealtimeAdapter = class {
       body.initialMessages = [
         { role: "MESSAGE_ROLE_AGENT", text: this.firstMessage }
       ];
+    } else {
+      body.firstSpeaker = "FIRST_SPEAKER_USER";
     }
     if (this.tools?.length) {
       body.selectedTools = this.tools.map((t) => ({
@@ -1273,7 +1343,7 @@ var UltravoxRealtimeAdapter = class {
     }
     const call = await resp.json();
     if (!call.joinUrl) throw new Error("Ultravox response missing joinUrl");
-    this.ws = new WebSocket2(call.joinUrl);
+    this.ws = new WebSocket(call.joinUrl);
     await new Promise((resolve, reject) => {
       const ws = this.ws;
       const onOpen = () => {
@@ -1298,14 +1368,16 @@ var UltravoxRealtimeAdapter = class {
     });
   }
   sendAudio(pcm) {
-    if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) return;
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
     this.ws.send(pcm, { binary: true });
   }
   async sendText(text) {
-    this.ws?.send(JSON.stringify({ type: "input_text_message", text }));
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.ws.send(JSON.stringify({ type: "input_text_message", text }));
   }
   async sendFunctionResult(callId, result) {
-    this.ws?.send(
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.ws.send(
       JSON.stringify({
         type: "client_tool_result",
         invocationId: callId,
@@ -1315,7 +1387,8 @@ var UltravoxRealtimeAdapter = class {
     );
   }
   cancelResponse() {
-    this.ws?.send(JSON.stringify({ type: "playback_clear_buffer" }));
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    this.ws.send(JSON.stringify({ type: "playback_clear_buffer" }));
   }
   onEvent(handler) {
     this.handlers.push(handler);
@@ -1396,7 +1469,7 @@ async function loadCron() {
   try {
     const imported = await import(
       /* @vite-ignore */
-      "./node-cron-373UVDIO.mjs"
+      "./node-cron-6PRPSBG5.mjs"
     );
     cronModule = imported && imported.default ? imported.default : imported;
     return cronModule;
@@ -1504,6 +1577,7 @@ function scheduleInterval(intervalOrOpts, callback) {
 
 // src/stt/deepgram.ts
 var STT = class extends DeepgramSTT {
+  static providerKey = "deepgram";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.DEEPGRAM_API_KEY;
     if (!key) {
@@ -1531,6 +1605,7 @@ var STT = class extends DeepgramSTT {
 // src/providers/whisper-stt.ts
 var OPENAI_TRANSCRIPTION_URL = "https://api.openai.com/v1/audio/transcriptions";
 var DEFAULT_BUFFER_SIZE = 16e3 * 2;
+var ALLOWED_MODELS = /* @__PURE__ */ new Set(["whisper-1", "gpt-4o-transcribe", "gpt-4o-mini-transcribe"]);
 function wrapPcmInWav(pcm, sampleRate = 16e3, channels = 1, bitsPerSample = 16) {
   const dataSize = pcm.length;
   const header = Buffer.alloc(44);
@@ -1554,33 +1629,63 @@ var WhisperSTT = class _WhisperSTT {
   model;
   language;
   bufferSize;
-  buffer = Buffer.alloc(0);
-  callbacks = [];
+  responseFormat;
+  // Accumulate chunks in an array and concat once on flush — avoids the
+  // per-``sendAudio`` O(n) ``Buffer.concat([buffer, chunk])`` that quickly
+  // dominates CPU when the phone leg delivers 20 ms frames.
+  chunks = [];
+  bufferedBytes = 0;
+  callbacks = /* @__PURE__ */ new Set();
   running = false;
   pendingTranscriptions = [];
-  constructor(apiKey, model = "whisper-1", language, bufferSize = DEFAULT_BUFFER_SIZE) {
+  /**
+   * @param apiKey OpenAI API key.
+   * @param language ISO-639-1 language code (e.g. ``"en"``, ``"it"``). Optional.
+   * @param model One of ``whisper-1``, ``gpt-4o-transcribe``, ``gpt-4o-mini-transcribe``.
+   * @param bufferSize Bytes of PCM16 to buffer before each transcription request.
+   * @param responseFormat ``"json"`` (default) or ``"verbose_json"``.
+   *
+   * Argument order matches the Python SDK's ``WhisperSTT(api_key, language, model, response_format)``
+   * for cross-language parity. Pre-0.5.3 the TS positional order was
+   * ``(apiKey, model, language, bufferSize, responseFormat)`` — callers using
+   * the old order will need to swap ``language`` and ``model``.
+   */
+  constructor(apiKey, language, model = "whisper-1", bufferSize = DEFAULT_BUFFER_SIZE, responseFormat = "json") {
+    if (!ALLOWED_MODELS.has(model)) {
+      throw new Error(
+        `WhisperSTT: unsupported model "${model}". Expected one of ${[...ALLOWED_MODELS].join(", ")}.`
+      );
+    }
     this.apiKey = apiKey;
     this.model = model;
     this.language = language;
     this.bufferSize = bufferSize;
+    this.responseFormat = responseFormat;
   }
   /** Factory for Twilio calls — mulaw 8 kHz is transcoded upstream, so we still receive PCM 16-bit. */
   static forTwilio(apiKey, language = "en", model = "whisper-1") {
-    return new _WhisperSTT(apiKey, model, language);
+    return new _WhisperSTT(apiKey, language, model);
   }
   async connect() {
     this.running = true;
-    this.buffer = Buffer.alloc(0);
+    this.chunks = [];
+    this.bufferedBytes = 0;
   }
   sendAudio(audio) {
     if (!this.running) return;
-    this.buffer = Buffer.concat([this.buffer, audio]);
-    if (this.buffer.length >= this.bufferSize) {
-      const pcm = this.buffer;
-      this.buffer = Buffer.alloc(0);
+    this.chunks.push(audio);
+    this.bufferedBytes += audio.length;
+    if (this.bufferedBytes >= this.bufferSize) {
+      const pcm = this.flushChunks();
       this.trackTranscription(this.transcribeBuffer(pcm));
     }
   }
+  flushChunks() {
+    const pcm = this.chunks.length === 1 ? this.chunks[0] : Buffer.concat(this.chunks, this.bufferedBytes);
+    this.chunks = [];
+    this.bufferedBytes = 0;
+    return pcm;
+  }
   trackTranscription(promise) {
     const wrapped = promise.finally(() => {
       const idx = this.pendingTranscriptions.indexOf(wrapped);
@@ -1588,25 +1693,25 @@ var WhisperSTT = class _WhisperSTT {
     });
     this.pendingTranscriptions.push(wrapped);
   }
+  /**
+   * Register a transcript listener. Unlike the previous implementation
+   * which capped at 10 and silently replaced the last one, we now keep all
+   * registered callbacks in a Set; use {@link offTranscript} to remove one.
+   */
   onTranscript(callback) {
-    if (this.callbacks.length >= 10) {
-      getLogger().warn("WhisperSTT: 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);
+  }
+  offTranscript(callback) {
+    this.callbacks.delete(callback);
   }
   async close() {
     this.running = false;
-    if (this.buffer.length >= this.bufferSize / 4) {
-      const pcm = this.buffer;
-      this.buffer = Buffer.alloc(0);
+    if (this.bufferedBytes > 0) {
+      const pcm = this.flushChunks();
       this.trackTranscription(this.transcribeBuffer(pcm));
-    } else {
-      this.buffer = Buffer.alloc(0);
     }
     await Promise.allSettled(this.pendingTranscriptions);
-    this.callbacks = [];
+    this.callbacks.clear();
   }
   // ------------------------------------------------------------------
   // Private
@@ -1616,6 +1721,7 @@ var WhisperSTT = class _WhisperSTT {
     const formData = new FormData();
     formData.append("file", new Blob([wav.buffer.slice(wav.byteOffset, wav.byteOffset + wav.byteLength)], { type: "audio/wav" }), "audio.wav");
     formData.append("model", this.model);
+    formData.append("response_format", this.responseFormat);
     if (this.language) {
       formData.append("language", this.language);
     }
@@ -1637,7 +1743,7 @@ var WhisperSTT = class _WhisperSTT {
       const transcript = {
         text,
         isFinal: true,
-        confidence: 1
+        confidence: extractConfidence(json)
       };
       for (const cb of this.callbacks) {
         cb(transcript);
@@ -1647,9 +1753,23 @@ var WhisperSTT = class _WhisperSTT {
     }
   }
 };
+function extractConfidence(payload) {
+  const segments = payload.segments;
+  if (!segments || segments.length === 0) return 1;
+  const scores = [];
+  for (const seg of segments) {
+    const logp = seg.avg_logprob;
+    if (typeof logp === "number") {
+      scores.push(Math.max(0, Math.min(1, Math.exp(logp))));
+    }
+  }
+  if (scores.length === 0) return 1;
+  return scores.reduce((a, b) => a + b, 0) / scores.length;
+}
 
 // src/stt/whisper.ts
 var STT2 = class extends WhisperSTT {
+  static providerKey = "whisper";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
     if (!key) {
@@ -1657,18 +1777,53 @@ var STT2 = class extends WhisperSTT {
         "Whisper STT requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
       );
     }
-    super(key, opts.model ?? "whisper-1", opts.language, opts.bufferSize);
+    super(key, opts.language, opts.model ?? "whisper-1", opts.bufferSize, opts.responseFormat ?? "json");
+  }
+};
+
+// src/providers/openai-transcribe-stt.ts
+var ALLOWED_MODELS2 = /* @__PURE__ */ new Set(["gpt-4o-transcribe", "gpt-4o-mini-transcribe"]);
+var DEFAULT_BUFFER_SIZE2 = 16e3 * 2;
+var OpenAITranscribeSTT = class extends WhisperSTT {
+  /**
+   * @param apiKey OpenAI API key.
+   * @param language ISO-639-1 language code (e.g. ``"en"``, ``"it"``). Optional.
+   * @param model One of ``gpt-4o-transcribe`` (default), ``gpt-4o-mini-transcribe``.
+   *   ``"whisper-1"`` is intentionally rejected here — use ``WhisperSTT`` for that.
+   * @param bufferSize Bytes of PCM16 to buffer before each transcription request.
+   * @param responseFormat ``"json"`` (default) or ``"verbose_json"``.
+   */
+  constructor(apiKey, language, model = "gpt-4o-transcribe", bufferSize = DEFAULT_BUFFER_SIZE2, responseFormat = "json") {
+    if (!ALLOWED_MODELS2.has(model)) {
+      throw new Error(
+        `OpenAITranscribeSTT: unsupported model "${model}". Expected one of ${[...ALLOWED_MODELS2].join(", ")}. For "whisper-1", use WhisperSTT instead.`
+      );
+    }
+    super(apiKey, language, model, bufferSize, responseFormat);
+  }
+};
+
+// src/stt/openai-transcribe.ts
+var STT3 = class extends OpenAITranscribeSTT {
+  static providerKey = "openai_transcribe";
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!key) {
+      throw new Error(
+        "OpenAI Transcribe STT requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
+      );
+    }
+    super(key, opts.language, opts.model ?? "gpt-4o-transcribe", opts.bufferSize, opts.responseFormat ?? "json");
   }
 };
 
 // src/providers/cartesia-stt.ts
-import WebSocket3 from "ws";
+import WebSocket2 from "ws";
 var DEFAULT_BASE_URL = "https://api.cartesia.ai";
 var API_VERSION = "2025-04-16";
 var USER_AGENT = "Patter/1.0 (integration=LiveKit-port; provider=Cartesia)";
 var KEEPALIVE_INTERVAL_MS = 3e4;
 var CONNECT_TIMEOUT_MS = 1e4;
-var MAX_CALLBACKS = 10;
 var CartesiaSTT = class {
   constructor(apiKey, options = {}) {
     this.apiKey = apiKey;
@@ -1678,10 +1833,13 @@ var CartesiaSTT = class {
     }
   }
   ws = null;
-  callbacks = [];
+  callbacks = /* @__PURE__ */ new Set();
   keepaliveTimer = null;
-  /** Cartesia request id — set from the server transcript events. */
-  requestId = "";
+  /**
+   * Cartesia request id — set from the server transcript events.
+   * `null` until the first transcript event arrives (matches Python's `None`).
+   */
+  requestId = null;
   buildWsUrl() {
     const opts = this.options;
     const rawBase = opts.baseUrl ?? DEFAULT_BASE_URL;
@@ -1708,7 +1866,7 @@ var CartesiaSTT = class {
   }
   async connect() {
     const url = this.buildWsUrl();
-    this.ws = new WebSocket3(url, {
+    this.ws = new WebSocket2(url, {
       headers: { "User-Agent": USER_AGENT }
     });
     await new Promise((resolve, reject) => {
@@ -1735,7 +1893,7 @@ var CartesiaSTT = class {
       this.handleEvent(event);
     });
     this.keepaliveTimer = setInterval(() => {
-      if (this.ws && this.ws.readyState === WebSocket3.OPEN) {
+      if (this.ws && this.ws.readyState === WebSocket2.OPEN) {
         try {
           this.ws.ping();
         } catch {
@@ -1768,19 +1926,24 @@ var CartesiaSTT = class {
     }
   }
   sendAudio(audio) {
-    if (!this.ws || this.ws.readyState !== WebSocket3.OPEN) return;
+    if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) return;
     this.ws.send(audio);
   }
   onTranscript(callback) {
-    if (this.callbacks.length >= MAX_CALLBACKS) {
-      getLogger().warn(
-        "CartesiaSTT: 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);
   }
+  /** Remove a previously registered transcript callback. */
+  offTranscript(callback) {
+    this.callbacks.delete(callback);
+  }
+  /**
+   * Synchronous best-effort close. Sends `finalize` and closes the socket
+   * without waiting for the server to flush any remaining transcripts.
+   *
+   * Limitation: any transcript events produced between the `finalize` send
+   * and the socket close may be dropped. Callers that need to guarantee all
+   * transcripts are delivered should await :meth:`closeAsync` instead.
+   */
   close() {
     if (this.keepaliveTimer) {
       clearInterval(this.keepaliveTimer);
@@ -1795,10 +1958,53 @@ var CartesiaSTT = class {
       this.ws = null;
     }
   }
+  /**
+   * Graceful close that awaits the `finalize` send and the socket closing
+   * handshake, matching the Python adapter's behavior. Use this when you
+   * need any in-flight transcripts to be flushed before teardown.
+   */
+  async closeAsync() {
+    if (this.keepaliveTimer) {
+      clearInterval(this.keepaliveTimer);
+      this.keepaliveTimer = null;
+    }
+    const ws = this.ws;
+    this.ws = null;
+    if (!ws) return;
+    if (ws.readyState === WebSocket2.OPEN) {
+      try {
+        await new Promise((resolve) => {
+          ws.send("finalize", (err) => {
+            if (err) getLogger().warn(`CartesiaSTT finalize send failed: ${String(err)}`);
+            resolve();
+          });
+        });
+      } catch (err) {
+        getLogger().warn(`CartesiaSTT finalize error: ${String(err)}`);
+      }
+    }
+    if (ws.readyState === WebSocket2.OPEN || ws.readyState === WebSocket2.CONNECTING) {
+      await new Promise((resolve) => {
+        const done = () => {
+          ws.off("close", done);
+          ws.off("error", done);
+          resolve();
+        };
+        ws.once("close", done);
+        ws.once("error", done);
+        try {
+          ws.close();
+        } catch {
+          resolve();
+        }
+      });
+    }
+  }
 };
 
 // src/stt/cartesia.ts
-var STT3 = class extends CartesiaSTT {
+var STT4 = class extends CartesiaSTT {
+  static providerKey = "cartesia_stt";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.CARTESIA_API_KEY;
     if (!key) {
@@ -1817,7 +2023,7 @@ var STT3 = class extends CartesiaSTT {
 };
 
 // src/providers/soniox-stt.ts
-import WebSocket4 from "ws";
+import WebSocket3 from "ws";
 var SONIOX_WS_URL = "wss://stt-rt.soniox.com/transcribe-websocket";
 var KEEPALIVE_MESSAGE = '{"type": "keepalive"}';
 var END_TOKEN = "<end>";
@@ -1913,7 +2119,8 @@ var SonioxSTT = class _SonioxSTT {
     return config;
   }
   async connect() {
-    this.ws = new WebSocket4(this.baseUrl);
+    this.final.reset();
+    this.ws = new WebSocket3(this.baseUrl);
     await new Promise((resolve, reject) => {
       const timer = setTimeout(() => reject(new Error("Soniox connect timeout")), 1e4);
       this.ws.once("open", () => {
@@ -1932,7 +2139,7 @@ var SonioxSTT = class _SonioxSTT {
       getLogger().error(`SonioxSTT WebSocket error: ${String(err)}`);
     });
     this.keepaliveTimer = setInterval(() => {
-      if (this.ws && this.ws.readyState === WebSocket4.OPEN) {
+      if (this.ws && this.ws.readyState === WebSocket3.OPEN) {
         try {
           this.ws.send(KEEPALIVE_MESSAGE);
         } catch {
@@ -2005,7 +2212,7 @@ var SonioxSTT = class _SonioxSTT {
     }
   }
   sendAudio(audio) {
-    if (!this.ws || this.ws.readyState !== WebSocket4.OPEN) return;
+    if (!this.ws || this.ws.readyState !== WebSocket3.OPEN) return;
     if (audio.length === 0) return;
     this.ws.send(audio);
   }
@@ -2036,7 +2243,8 @@ var SonioxSTT = class _SonioxSTT {
 };
 
 // src/stt/soniox.ts
-var STT4 = class extends SonioxSTT {
+var STT5 = class extends SonioxSTT {
+  static providerKey = "soniox";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.SONIOX_API_KEY;
     if (!key) {
@@ -2051,11 +2259,21 @@ var STT4 = class extends SonioxSTT {
 };
 
 // src/providers/assemblyai-stt.ts
-import WebSocket5 from "ws";
+import WebSocket4 from "ws";
 var DEFAULT_BASE_URL2 = "wss://streaming.assemblyai.com";
-var DEFAULT_MIN_TURN_SILENCE_MS = 100;
+var DEFAULT_MIN_TURN_SILENCE_MS = 400;
 var CONNECT_TIMEOUT_MS2 = 1e4;
-var MAX_CALLBACKS2 = 10;
+var TERMINATION_WAIT_TIMEOUT_MS = 500;
+var MIN_CHUNK_DURATION_MS = 50;
+var MAX_CHUNK_DURATION_MS = 1e3;
+var RECONNECT_ERROR_CODES = /* @__PURE__ */ new Set([3005, 3008]);
+var VALID_DOMAINS = /* @__PURE__ */ new Set(["general", "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;
@@ -2063,13 +2281,24 @@ var AssemblyAISTT = class _AssemblyAISTT {
     if (!apiKey) {
       throw new Error("AssemblyAISTT requires a non-empty apiKey");
     }
+    if (options.domain !== void 0 && !VALID_DOMAINS.has(options.domain)) {
+      const hint = options.domain === "medical" ? ' \u2014 did you mean "medical-v1"?' : "";
+      throw new Error(
+        `AssemblyAISTT: invalid domain "${options.domain}"; expected one of [${Array.from(
+          VALID_DOMAINS
+        ).map((d) => `"${d}"`).join(", ")}]${hint}`
+      );
+    }
   }
   ws = null;
-  callbacks = [];
+  callbacks = /* @__PURE__ */ new Set();
+  closing = false;
+  reconnectAttempts = 0;
+  terminationResolve = null;
   /** AssemblyAI session id — set when the `Begin` message arrives. */
-  sessionId = "";
+  sessionId = null;
   /** Unix timestamp when the AssemblyAI session expires. */
-  expiresAt = 0;
+  expiresAt = null;
   /** Factory for Twilio calls — mulaw 8 kHz. */
   static forTwilio(apiKey, model = "universal-streaming-english") {
     return new _AssemblyAISTT(apiKey, {
@@ -2104,11 +2333,14 @@ var AssemblyAISTT = class _AssemblyAISTT {
       keyterms_prompt: opts.keytermsPrompt ? JSON.stringify(opts.keytermsPrompt) : void 0,
       language_detection: languageDetection,
       prompt: opts.prompt,
-      vad_threshold: opts.vadThreshold,
+      // vad_threshold intentionally omitted — not a valid v3 parameter.
       speaker_labels: opts.speakerLabels,
       max_speakers: opts.maxSpeakers,
       domain: opts.domain
     };
+    if (opts.useQueryToken) {
+      raw.token = this.apiKey;
+    }
     const params = new URLSearchParams();
     for (const [key, value] of Object.entries(raw)) {
       if (value === void 0 || value === null) continue;
@@ -2121,30 +2353,41 @@ var AssemblyAISTT = class _AssemblyAISTT {
     const base = opts.baseUrl ?? DEFAULT_BASE_URL2;
     return `${base}/v3/ws?${params.toString()}`;
   }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": "Patter/1.0"
+    };
+    if (!this.options.useQueryToken) {
+      headers.Authorization = this.apiKey;
+    }
+    return headers;
+  }
   async connect() {
+    this.closing = false;
     const url = this.buildUrl();
-    this.ws = new WebSocket5(url, {
-      headers: {
-        Authorization: this.apiKey,
-        "Content-Type": "application/json",
-        "User-Agent": "Patter/1.0 (integration=LiveKit-port)"
-      }
-    });
+    this.ws = new WebSocket4(url, { headers: this.buildHeaders() });
+    await this.awaitOpen(this.ws);
+    this.attachHandlers(this.ws);
+  }
+  async awaitOpen(ws) {
     await new Promise((resolve, reject) => {
       const timer = setTimeout(
         () => reject(new Error("AssemblyAI connect timeout")),
         CONNECT_TIMEOUT_MS2
       );
-      this.ws.once("open", () => {
+      ws.once("open", () => {
         clearTimeout(timer);
         resolve();
       });
-      this.ws.once("error", (err) => {
+      ws.once("error", (err) => {
         clearTimeout(timer);
         reject(err);
       });
     });
-    this.ws.on("message", (raw) => {
+  }
+  attachHandlers(ws) {
+    ws.on("message", (raw) => {
       let event;
       try {
         event = JSON.parse(raw.toString());
@@ -2153,12 +2396,45 @@ var AssemblyAISTT = class _AssemblyAISTT {
       }
       this.handleEvent(event);
     });
+    ws.on("close", (code) => {
+      if (!this.closing && RECONNECT_ERROR_CODES.has(code) && this.reconnectAttempts < 1) {
+        this.reconnectAttempts += 1;
+        getLogger().warn(
+          `AssemblyAISTT: close code ${code} \u2014 attempting single reconnect.`
+        );
+        this.reconnect().catch((err) => {
+          getLogger().error("AssemblyAISTT reconnect failed", err);
+        });
+      }
+    });
+  }
+  async reconnect() {
+    const url = this.buildUrl();
+    this.ws = new WebSocket4(url, { headers: this.buildHeaders() });
+    await this.awaitOpen(this.ws);
+    this.attachHandlers(this.ws);
   }
   handleEvent(event) {
     const type = event.type;
     if (type === "Begin") {
-      this.sessionId = event.id ?? "";
-      this.expiresAt = event.expires_at ?? 0;
+      this.sessionId = event.id ?? null;
+      this.expiresAt = event.expires_at ?? null;
+      return;
+    }
+    if (type === "Termination") {
+      if (this.terminationResolve) {
+        this.terminationResolve();
+        this.terminationResolve = null;
+      }
+      return;
+    }
+    if (type === "SpeechStarted") {
+      this.emit({
+        text: "",
+        isFinal: false,
+        confidence: 0,
+        eventType: "SpeechStarted"
+      });
       return;
     }
     if (type !== "Turn") {
@@ -2193,28 +2469,89 @@ var AssemblyAISTT = class _AssemblyAISTT {
     }
   }
   sendAudio(audio) {
-    if (!this.ws || this.ws.readyState !== WebSocket5.OPEN) return;
+    if (!this.ws || this.ws.readyState !== WebSocket4.OPEN) {
+      throw new AssemblyAISTTNotConnectedError(
+        "AssemblyAISTT.sendAudio: WebSocket is not open"
+      );
+    }
+    const durationMs = this.estimateChunkDurationMs(audio.length);
+    if (durationMs !== null && (durationMs < MIN_CHUNK_DURATION_MS || durationMs > MAX_CHUNK_DURATION_MS)) {
+      getLogger().warn(
+        `AssemblyAISTT: audio chunk duration ${durationMs.toFixed(1)}ms outside 50-1000ms bounds (may trigger error 3007).`
+      );
+    }
     this.ws.send(audio);
   }
-  onTranscript(callback) {
-    if (this.callbacks.length >= MAX_CALLBACKS2) {
-      getLogger().warn(
-        "AssemblyAISTT: maximum of 10 onTranscript callbacks reached; replacing the last callback."
+  estimateChunkDurationMs(byteLength) {
+    if (byteLength <= 0) return null;
+    const sampleRate = this.options.sampleRate ?? 16e3;
+    if (sampleRate <= 0) return null;
+    const bytesPerSample = (this.options.encoding ?? "pcm_s16le") === "pcm_s16le" ? 2 : 1;
+    const samples = byteLength / bytesPerSample;
+    return samples / sampleRate * 1e3;
+  }
+  /**
+   * Send an `UpdateConfiguration` frame to change settings mid-stream.
+   * Only defined fields are included.
+   */
+  updateConfiguration(params) {
+    if (!this.ws || this.ws.readyState !== WebSocket4.OPEN) {
+      throw new AssemblyAISTTNotConnectedError(
+        "AssemblyAISTT.updateConfiguration: WebSocket is not open"
       );
-      this.callbacks[this.callbacks.length - 1] = callback;
-      return;
     }
-    this.callbacks.push(callback);
+    const payload = { type: "UpdateConfiguration" };
+    if (params.keytermsPrompt !== void 0) {
+      payload.keyterms_prompt = JSON.stringify(params.keytermsPrompt);
+    }
+    if (params.prompt !== void 0) {
+      payload.prompt = params.prompt;
+    }
+    if (params.minTurnSilence !== void 0) {
+      payload.min_turn_silence = params.minTurnSilence;
+    }
+    if (params.maxTurnSilence !== void 0) {
+      payload.max_turn_silence = params.maxTurnSilence;
+    }
+    this.ws.send(JSON.stringify(payload));
   }
-  close() {
-    if (this.ws) {
-      try {
-        this.ws.send(JSON.stringify({ type: "Terminate" }));
-      } catch {
-      }
+  /** 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"
+      );
+    }
+    this.ws.send(JSON.stringify({ type: "ForceEndpoint" }));
+  }
+  onTranscript(callback) {
+    this.callbacks.add(callback);
+    return () => {
+      this.callbacks.delete(callback);
+    };
+  }
+  async close() {
+    this.closing = true;
+    if (!this.ws) return;
+    try {
+      this.ws.send(JSON.stringify({ type: "Terminate" }));
+    } catch {
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.terminationResolve = null;
+        resolve();
+      }, TERMINATION_WAIT_TIMEOUT_MS);
+      this.terminationResolve = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+    });
+    try {
       this.ws.close();
-      this.ws = null;
+    } catch {
     }
+    this.ws = null;
   }
 };
 function averageConfidence(words) {
@@ -2227,7 +2564,8 @@ function averageConfidence(words) {
 }
 
 // src/stt/assemblyai.ts
-var STT5 = class extends AssemblyAISTT {
+var STT6 = class extends AssemblyAISTT {
+  static providerKey = "assemblyai";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.ASSEMBLYAI_API_KEY;
     if (!key) {
@@ -2289,7 +2627,8 @@ var ELEVENLABS_VOICE_ID_BY_NAME = {
   glinda: "z9fAnlkpzviPz146aGWa",
   giovanni: "zcAOhNBS3c14rBihAFp1",
   mimi: "zrHiDhphv9ZnVXBqCLjz",
-  alloy: "21m00Tcm4TlvDq8ikWAM"
+  sarah: "EXAVITQu4vr4xnSDxMaL",
+  alloy: "EXAVITQu4vr4xnSDxMaL"
 };
 var VOICE_ID_PATTERN = /^[A-Za-z0-9]{20}$/;
 function resolveVoiceId(voice) {
@@ -2297,14 +2636,78 @@ function resolveVoiceId(voice) {
   if (VOICE_ID_PATTERN.test(voice)) return voice;
   return ELEVENLABS_VOICE_ID_BY_NAME[voice.toLowerCase()] ?? voice;
 }
-var ElevenLabsTTS = class {
-  constructor(apiKey, voiceId = "21m00Tcm4TlvDq8ikWAM", modelId = "eleven_turbo_v2_5", outputFormat = "pcm_16000") {
+var ElevenLabsTTS = class _ElevenLabsTTS {
+  apiKey;
+  voiceId;
+  modelId;
+  outputFormat;
+  voiceSettings;
+  languageCode;
+  chunkSize;
+  constructor(apiKey, voiceIdOrOptions = "21m00Tcm4TlvDq8ikWAM", modelId = "eleven_flash_v2_5", outputFormat = "pcm_16000") {
     this.apiKey = apiKey;
-    this.modelId = modelId;
-    this.outputFormat = outputFormat;
-    this.voiceId = resolveVoiceId(voiceId);
+    if (typeof voiceIdOrOptions === "object") {
+      const o = voiceIdOrOptions;
+      this.voiceId = resolveVoiceId(o.voiceId ?? "21m00Tcm4TlvDq8ikWAM");
+      this.modelId = o.modelId ?? "eleven_flash_v2_5";
+      this.outputFormat = o.outputFormat ?? "pcm_16000";
+      this.voiceSettings = o.voiceSettings;
+      this.languageCode = o.languageCode;
+      this.chunkSize = o.chunkSize ?? 4096;
+    } else {
+      this.voiceId = resolveVoiceId(voiceIdOrOptions);
+      this.modelId = modelId;
+      this.outputFormat = outputFormat;
+      this.voiceSettings = void 0;
+      this.languageCode = void 0;
+      this.chunkSize = 4096;
+    }
+  }
+  /**
+   * Construct an instance pre-configured for Twilio Media Streams.
+   *
+   * Sets `outputFormat='ulaw_8000'` so ElevenLabs emits μ-law @ 8 kHz
+   * directly — the exact wire format Twilio's media stream uses — letting
+   * the SDK skip the 16 kHz→8 kHz resample and PCM→μ-law conversion in
+   * `TwilioAudioSender`. Saves ~30–80 ms first-byte and per-frame CPU,
+   * and removes a potential aliasing source.
+   *
+   * `voiceSettings` defaults to a low-bandwidth-friendly profile
+   * (speaker boost off, modest stability) which sounds cleaner at 8 kHz
+   * μ-law than the studio default. Pass an explicit object to override.
+   */
+  static forTwilio(apiKey, options = {}) {
+    const voiceSettings = options.voiceSettings ?? {
+      // Speaker boost adds high-frequency emphasis that aliases ugly over an
+      // 8 kHz μ-law line. Slightly higher stability tames the excursions
+      // that compander quantization noise can amplify.
+      stability: 0.6,
+      similarity_boost: 0.75,
+      use_speaker_boost: false
+    };
+    return new _ElevenLabsTTS(apiKey, {
+      ...options,
+      voiceSettings,
+      outputFormat: "ulaw_8000"
+    });
+  }
+  /**
+   * Construct an instance pre-configured for Telnyx bidirectional media.
+   *
+   * Telnyx's default media-streaming codec is L16 PCM @ 16 kHz, which
+   * matches our default Telnyx handler. We pick `pcm_16000` so the audio
+   * flows end-to-end with zero resampling or transcoding.
+   *
+   * Trade-off: if your Telnyx profile is pinned to PCMU/8000 (μ-law),
+   * construct `ElevenLabsTTS` directly with `outputFormat: 'ulaw_8000'`
+   * — Telnyx supports that natively too.
+   */
+  static forTelnyx(apiKey, options = {}) {
+    return new _ElevenLabsTTS(apiKey, {
+      ...options,
+      outputFormat: "pcm_16000"
+    });
   }
-  voiceId;
   /**
    * Synthesise text to speech and return the full audio as a single Buffer.
    *
@@ -2321,22 +2724,29 @@ var ElevenLabsTTS = class {
    * Synthesise text and yield audio chunks as they arrive (streaming).
    *
    * The yielded buffers are raw PCM at 16 kHz (or whatever `outputFormat` is
-   * configured to).
+   * configured to). `chunkSize` controls the maximum yield size — 512 is a
+   * good choice for low-latency telephony.
    */
   async *synthesizeStream(text) {
     const url = `${ELEVENLABS_BASE_URL}/text-to-speech/${encodeURIComponent(this.voiceId)}/stream?output_format=${encodeURIComponent(this.outputFormat)}`;
+    const body = {
+      text,
+      model_id: this.modelId
+    };
+    if (this.voiceSettings) body["voice_settings"] = this.voiceSettings;
+    if (this.languageCode) body["language_code"] = this.languageCode;
     const response = await fetch(url, {
       method: "POST",
       headers: {
         "xi-api-key": this.apiKey,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({ text, model_id: this.modelId }),
+      body: JSON.stringify(body),
       signal: AbortSignal.timeout(3e4)
     });
     if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`ElevenLabs TTS error ${response.status}: ${body}`);
+      const errBody = await response.text();
+      throw new Error(`ElevenLabs TTS error ${response.status}: ${errBody}`);
     }
     if (!response.body) {
       throw new Error("ElevenLabs TTS: no response body");
@@ -2346,8 +2756,10 @@ var ElevenLabsTTS = class {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        if (value && value.length > 0) {
-          yield Buffer.from(value);
+        if (!value || value.length === 0) continue;
+        const buf = Buffer.from(value);
+        for (let offset = 0; offset < buf.length; offset += this.chunkSize) {
+          yield buf.subarray(offset, Math.min(offset + this.chunkSize, buf.length));
         }
       }
     } finally {
@@ -2359,30 +2771,50 @@ var ElevenLabsTTS = class {
 };
 
 // src/tts/elevenlabs.ts
-var TTS = class extends ElevenLabsTTS {
-  constructor(opts = {}) {
-    const key = opts.apiKey ?? process.env.ELEVENLABS_API_KEY;
-    if (!key) {
-      throw new Error(
-        "ElevenLabs TTS requires an apiKey. Pass { apiKey: '...' } or set ELEVENLABS_API_KEY in the environment."
-      );
-    }
+function resolveApiKey(apiKey) {
+  const key = apiKey ?? process.env.ELEVENLABS_API_KEY;
+  if (!key) {
+    throw new Error(
+      "ElevenLabs TTS requires an apiKey. Pass { apiKey: '...' } or set ELEVENLABS_API_KEY in the environment."
+    );
+  }
+  return key;
+}
+var TTS = class _TTS extends ElevenLabsTTS {
+  static providerKey = "elevenlabs";
+  constructor(opts = {}) {
     super(
-      key,
-      opts.voiceId ?? "21m00Tcm4TlvDq8ikWAM",
-      opts.modelId ?? "eleven_turbo_v2_5",
+      resolveApiKey(opts.apiKey),
+      opts.voiceId ?? "EXAVITQu4vr4xnSDxMaL",
+      opts.modelId ?? "eleven_flash_v2_5",
       opts.outputFormat ?? "pcm_16000"
     );
   }
+  static forTwilio(arg1, arg2) {
+    const opts = typeof arg1 === "string" ? { apiKey: arg1, ...arg2 ?? {} } : arg1 ?? {};
+    return new _TTS({ ...opts, outputFormat: "ulaw_8000" });
+  }
+  static forTelnyx(arg1, arg2) {
+    const opts = typeof arg1 === "string" ? { apiKey: arg1, ...arg2 ?? {} } : arg1 ?? {};
+    return new _TTS({ ...opts, outputFormat: "pcm_16000" });
+  }
 };
 
 // src/providers/openai-tts.ts
 var OPENAI_TTS_URL = "https://api.openai.com/v1/audio/speech";
+var INSTRUCTIONS_PREFIX = "gpt-4o-mini-tts";
+var LPF_ALPHA = 0.78;
 var OpenAITTS = class _OpenAITTS {
-  constructor(apiKey, voice = "alloy", model = "tts-1") {
+  constructor(apiKey, voice = "alloy", model = "gpt-4o-mini-tts", instructions = null, speed = null, antiAlias = true) {
     this.apiKey = apiKey;
     this.voice = voice;
     this.model = model;
+    this.instructions = instructions;
+    this.speed = speed;
+    this.antiAlias = antiAlias;
+    if (speed !== null && speed !== void 0 && (speed < 0.25 || speed > 4)) {
+      throw new Error("OpenAITTS: speed must be in [0.25, 4.0]");
+    }
   }
   /**
    * Synthesise text to speech and return the full audio as a single Buffer.
@@ -2399,37 +2831,48 @@ var OpenAITTS = class _OpenAITTS {
   /**
    * Synthesise text and yield audio chunks as they arrive (streaming).
    *
-   * OpenAI returns 24 kHz PCM16; each chunk is resampled to 16 kHz before
-   * yielding so the output is ready for telephony pipelines.
+   * OpenAI returns 24 kHz PCM16; each chunk is lowpass-filtered then
+   * decimated 3:2 to 16 kHz before yielding so the output is ready for
+   * telephony pipelines.
    *
-   * The resampler carries state (buffered samples + odd trailing byte)
-   * between chunks — without that state cross-chunk sample alignment drifts
-   * and the caller hears pops / dropped audio (BUG #23, mirror of the
-   * Python `audioop.ratecv` fix).
+   * The resampler carries state (filter memory + buffered samples + odd
+   * trailing byte) between chunks so cross-chunk sample alignment and
+   * filter phase don't reset on every network read.
    */
   async *synthesizeStream(text) {
+    const body = {
+      model: this.model,
+      input: text,
+      voice: this.voice,
+      response_format: "pcm"
+    };
+    if (this.instructions !== null && this.model.startsWith(INSTRUCTIONS_PREFIX)) {
+      body.instructions = this.instructions;
+    }
+    if (this.speed !== null) {
+      body.speed = this.speed;
+    }
     const response = await fetch(OPENAI_TTS_URL, {
       method: "POST",
       headers: {
         "Authorization": `Bearer ${this.apiKey}`,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify({
-        model: this.model,
-        input: text,
-        voice: this.voice,
-        response_format: "pcm"
-      }),
-      signal: AbortSignal.timeout(3e4)
+      body: JSON.stringify(body)
     });
     if (!response.ok) {
-      const body = await response.text();
-      throw new Error(`OpenAI TTS error ${response.status}: ${body}`);
+      const errBody = await response.text();
+      throw new Error(`OpenAI TTS error ${response.status}: ${errBody}`);
     }
     if (!response.body) {
       throw new Error("OpenAI TTS: no response body");
     }
-    const ctx = { carryByte: null, leftover: [] };
+    const ctx = {
+      carryByte: null,
+      leftover: [],
+      lpfPrev: 0,
+      lpfEnabled: this.antiAlias
+    };
     const reader = response.body.getReader();
     try {
       while (true) {
@@ -2454,8 +2897,14 @@ var OpenAITTS = class _OpenAITTS {
     }
   }
   /**
-   * Streaming 24 kHz → 16 kHz resampler (PCM16-LE). Maintains cross-chunk
-   * state so the 3:2 pattern doesn't reset at every network read.
+   * Streaming 24 kHz → 16 kHz resampler (PCM16-LE). Applies a single-pole
+   * lowpass ahead of the 3:2 decimation and carries filter + sample state
+   * across chunks so the cadence doesn't reset at every network read.
+   *
+   * ``ctx.lpfEnabled`` (default true on the streaming path, false for the
+   * legacy static helper) controls whether the LPF is engaged — we keep
+   * the helper bit-exact for the downsample-only tests while the real
+   * streaming path gets anti-alias filtering.
    */
   static resampleStreaming(audio, ctx) {
     let buf;
@@ -2474,14 +2923,26 @@ var OpenAITTS = class _OpenAITTS {
     }
     const sampleCount = buf.length / 2;
     const samples = ctx.leftover.slice();
+    const lpf = ctx.lpfEnabled !== false;
+    let y = ctx.lpfPrev;
     for (let i2 = 0; i2 < sampleCount; i2++) {
-      samples.push(buf.readInt16LE(i2 * 2));
+      const x = buf.readInt16LE(i2 * 2);
+      if (lpf) {
+        y = LPF_ALPHA * x + (1 - LPF_ALPHA) * y;
+        let s = Math.round(y);
+        if (s > 32767) s = 32767;
+        else if (s < -32768) s = -32768;
+        samples.push(s);
+      } else {
+        samples.push(x);
+      }
     }
+    if (lpf) ctx.lpfPrev = y;
     const out = [];
     let i = 0;
     while (i + 2 < samples.length) {
       out.push(samples[i]);
-      out.push(Math.trunc((samples[i + 1] + samples[i + 2]) / 2));
+      out.push(Math.round((samples[i + 1] + samples[i + 2]) / 2));
       i += 3;
     }
     ctx.leftover = samples.slice(i);
@@ -2493,7 +2954,7 @@ var OpenAITTS = class _OpenAITTS {
   }
   /** @deprecated use {@link resampleStreaming} with persistent state. */
   static resample24kTo16k(audio) {
-    const ctx = { carryByte: null, leftover: [] };
+    const ctx = { carryByte: null, leftover: [], lpfPrev: 0, lpfEnabled: false };
     const out = _OpenAITTS.resampleStreaming(audio, ctx);
     if (ctx.leftover.length === 0) return out;
     const tail = Buffer.alloc(ctx.leftover.length * 2);
@@ -2506,6 +2967,7 @@ var OpenAITTS = class _OpenAITTS {
 
 // src/tts/openai.ts
 var TTS2 = class extends OpenAITTS {
+  static providerKey = "openai_tts";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
     if (!key) {
@@ -2513,15 +2975,22 @@ var TTS2 = class extends OpenAITTS {
         "OpenAI TTS requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
       );
     }
-    super(key, opts.voice ?? "alloy", opts.model ?? "tts-1");
+    super(
+      key,
+      opts.voice ?? "alloy",
+      opts.model ?? "gpt-4o-mini-tts",
+      opts.instructions ?? null,
+      opts.speed ?? null,
+      opts.antiAlias ?? false
+    );
   }
 };
 
 // src/providers/cartesia-tts.ts
 var CARTESIA_BASE_URL = "https://api.cartesia.ai";
-var CARTESIA_API_VERSION = "2024-11-13";
+var CARTESIA_API_VERSION = "2025-04-16";
 var CARTESIA_DEFAULT_VOICE_ID = "f786b574-daa5-4673-aa0c-cbe3e8534c02";
-var CartesiaTTS = class {
+var CartesiaTTS = class _CartesiaTTS {
   apiKey;
   model;
   voice;
@@ -2534,7 +3003,7 @@ var CartesiaTTS = class {
   apiVersion;
   constructor(apiKey, opts = {}) {
     this.apiKey = apiKey;
-    this.model = opts.model ?? "sonic-2";
+    this.model = opts.model ?? "sonic-3";
     this.voice = opts.voice ?? CARTESIA_DEFAULT_VOICE_ID;
     this.language = opts.language ?? "en";
     this.sampleRate = opts.sampleRate ?? 16e3;
@@ -2544,6 +3013,29 @@ var CartesiaTTS = class {
     this.baseUrl = opts.baseUrl ?? CARTESIA_BASE_URL;
     this.apiVersion = opts.apiVersion ?? CARTESIA_API_VERSION;
   }
+  /**
+   * Construct an instance pre-configured for Twilio Media Streams.
+   *
+   * Sets `sampleRate=8000` so Cartesia emits PCM_S16LE @ 8 kHz directly.
+   * Twilio's media stream uses μ-law @ 8 kHz so the SDK still does the
+   * PCM → μ-law transcode client-side, but the 16 kHz → 8 kHz resample
+   * step is skipped. Saves ~10–30 ms first-byte plus per-frame CPU and
+   * removes a potential aliasing source.
+   */
+  static forTwilio(apiKey, options = {}) {
+    return new _CartesiaTTS(apiKey, { ...options, sampleRate: 8e3 });
+  }
+  /**
+   * Construct an instance pre-configured for Telnyx bidirectional media.
+   *
+   * Sets `sampleRate=16000` to match Telnyx's L16/16000 default codec —
+   * audio flows end-to-end with zero resampling or transcoding. Same as
+   * the bare-constructor default; exists for API symmetry with
+   * {@link CartesiaTTS.forTwilio}.
+   */
+  static forTelnyx(apiKey, options = {}) {
+    return new _CartesiaTTS(apiKey, { ...options, sampleRate: 16e3 });
+  }
   /** Build the JSON payload for the Cartesia bytes endpoint. */
   buildPayload(text) {
     const payload = {
@@ -2616,18 +3108,31 @@ var CartesiaTTS = class {
 };
 
 // src/tts/cartesia.ts
-var TTS3 = class extends CartesiaTTS {
+function resolveApiKey2(apiKey) {
+  const key = apiKey ?? process.env.CARTESIA_API_KEY;
+  if (!key) {
+    throw new Error(
+      "Cartesia TTS requires an apiKey. Pass { apiKey: '...' } or set CARTESIA_API_KEY in the environment."
+    );
+  }
+  return key;
+}
+var TTS3 = class _TTS extends CartesiaTTS {
+  static providerKey = "cartesia_tts";
   constructor(opts = {}) {
-    const key = opts.apiKey ?? process.env.CARTESIA_API_KEY;
-    if (!key) {
-      throw new Error(
-        "Cartesia TTS requires an apiKey. Pass { apiKey: '...' } or set CARTESIA_API_KEY in the environment."
-      );
-    }
+    const key = resolveApiKey2(opts.apiKey);
     const { apiKey: _ignored, ...rest } = opts;
     void _ignored;
     super(key, rest);
   }
+  static forTwilio(arg1, arg2) {
+    const opts = typeof arg1 === "string" ? { apiKey: arg1, ...arg2 ?? {} } : arg1 ?? {};
+    return new _TTS({ ...opts, sampleRate: 8e3 });
+  }
+  static forTelnyx(arg1, arg2) {
+    const opts = typeof arg1 === "string" ? { apiKey: arg1, ...arg2 ?? {} } : arg1 ?? {};
+    return new _TTS({ ...opts, sampleRate: 16e3 });
+  }
 };
 
 // src/providers/rime-tts.ts
@@ -2759,6 +3264,7 @@ var RimeTTS = class {
 
 // src/tts/rime.ts
 var TTS4 = class extends RimeTTS {
+  static providerKey = "rime";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.RIME_API_KEY;
     if (!key) {
@@ -2852,6 +3358,7 @@ var LMNTTTS = class {
 
 // src/tts/lmnt.ts
 var TTS5 = class extends LMNTTTS {
+  static providerKey = "lmnt";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.LMNT_API_KEY;
     if (!key) {
@@ -2867,6 +3374,7 @@ var TTS5 = class extends LMNTTTS {
 
 // src/llm/openai.ts
 var LLM = class extends OpenAILLMProvider {
+  static providerKey = "openai";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
     if (!key) {
@@ -2874,15 +3382,27 @@ var LLM = class extends OpenAILLMProvider {
         "OpenAI LLM requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY."
       );
     }
-    super(key, opts.model ?? "gpt-4o-mini");
+    super(key, opts.model ?? "gpt-4o-mini", {
+      temperature: opts.temperature,
+      maxTokens: opts.maxTokens,
+      responseFormat: opts.responseFormat,
+      parallelToolCalls: opts.parallelToolCalls,
+      toolChoice: opts.toolChoice,
+      seed: opts.seed,
+      topP: opts.topP,
+      frequencyPenalty: opts.frequencyPenalty,
+      presencePenalty: opts.presencePenalty,
+      stop: opts.stop
+    });
   }
 };
 
 // src/providers/anthropic-llm.ts
 var DEFAULT_ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 var DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
-var DEFAULT_MODEL = "claude-3-5-sonnet-20241022";
+var DEFAULT_MODEL = "claude-haiku-4-5-20251001";
 var DEFAULT_MAX_TOKENS = 1024;
+var PROMPT_CACHING_BETA = "prompt-caching-2024-07-31";
 var AnthropicLLMProvider = class {
   apiKey;
   model;
@@ -2890,6 +3410,7 @@ var AnthropicLLMProvider = class {
   temperature;
   url;
   anthropicVersion;
+  promptCaching;
   constructor(options) {
     if (!options.apiKey) {
       throw new Error(
@@ -2902,6 +3423,7 @@ var AnthropicLLMProvider = class {
     this.temperature = options.temperature;
     this.url = options.baseUrl ?? DEFAULT_ANTHROPIC_URL;
     this.anthropicVersion = options.anthropicVersion ?? DEFAULT_ANTHROPIC_VERSION;
+    this.promptCaching = options.promptCaching ?? true;
   }
   async *stream(messages, tools) {
     const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
@@ -2912,16 +3434,44 @@ var AnthropicLLMProvider = class {
       max_tokens: this.maxTokens,
       stream: true
     };
-    if (system) body.system = system;
-    if (anthropicTools && anthropicTools.length > 0) body.tools = anthropicTools;
+    if (system) {
+      if (this.promptCaching) {
+        const block = {
+          type: "text",
+          text: system,
+          cache_control: { type: "ephemeral" }
+        };
+        body.system = [block];
+      } else {
+        body.system = system;
+      }
+    }
+    if (anthropicTools && anthropicTools.length > 0) {
+      if (this.promptCaching) {
+        const cachedTools = anthropicTools.map(
+          (t) => ({ ...t })
+        );
+        cachedTools[cachedTools.length - 1] = {
+          ...cachedTools[cachedTools.length - 1],
+          cache_control: { type: "ephemeral" }
+        };
+        body.tools = cachedTools;
+      } else {
+        body.tools = anthropicTools;
+      }
+    }
     if (this.temperature !== void 0) body.temperature = this.temperature;
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiKey,
+      "anthropic-version": this.anthropicVersion
+    };
+    if (this.promptCaching) {
+      headers["anthropic-beta"] = PROMPT_CACHING_BETA;
+    }
     const response = await fetch(this.url, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey,
-        "anthropic-version": this.anthropicVersion
-      },
+      headers,
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(3e4)
     });
@@ -3066,6 +3616,7 @@ function toAnthropicMessages(messages) {
 
 // src/llm/anthropic.ts
 var LLM2 = class extends AnthropicLLMProvider {
+  static providerKey = "anthropic";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.ANTHROPIC_API_KEY;
     if (!key) {
@@ -3079,11 +3630,15 @@ var LLM2 = class extends AnthropicLLMProvider {
       maxTokens: opts.maxTokens,
       temperature: opts.temperature,
       baseUrl: opts.baseUrl,
-      anthropicVersion: opts.anthropicVersion
+      anthropicVersion: opts.anthropicVersion,
+      promptCaching: opts.promptCaching
     });
   }
 };
 
+// src/version.ts
+var VERSION = "0.5.3";
+
 // src/providers/groq-llm.ts
 var GROQ_BASE_URL = "https://api.groq.com/openai/v1";
 var DEFAULT_MODEL2 = "llama-3.3-70b-versatile";
@@ -3091,6 +3646,16 @@ var GroqLLMProvider = class {
   apiKey;
   model;
   baseUrl;
+  temperature;
+  maxTokens;
+  responseFormat;
+  parallelToolCalls;
+  toolChoice;
+  seed;
+  topP;
+  frequencyPenalty;
+  presencePenalty;
+  stop;
   constructor(options) {
     if (!options.apiKey) {
       throw new Error(
@@ -3100,19 +3665,43 @@ var GroqLLMProvider = class {
     this.apiKey = options.apiKey;
     this.model = options.model ?? DEFAULT_MODEL2;
     this.baseUrl = options.baseUrl ?? GROQ_BASE_URL;
+    this.temperature = options.temperature;
+    this.maxTokens = options.maxTokens;
+    this.responseFormat = options.responseFormat;
+    this.parallelToolCalls = options.parallelToolCalls;
+    this.toolChoice = options.toolChoice;
+    this.seed = options.seed;
+    this.topP = options.topP;
+    this.frequencyPenalty = options.frequencyPenalty;
+    this.presencePenalty = options.presencePenalty;
+    this.stop = options.stop;
   }
   async *stream(messages, tools) {
     const body = {
       model: this.model,
       messages,
-      stream: true
+      stream: true,
+      stream_options: { include_usage: true }
     };
+    if (this.temperature !== void 0) body.temperature = this.temperature;
+    if (this.maxTokens !== void 0) {
+      body.max_completion_tokens = this.maxTokens;
+    }
+    if (this.responseFormat !== void 0) body.response_format = this.responseFormat;
+    if (this.parallelToolCalls !== void 0) body.parallel_tool_calls = this.parallelToolCalls;
+    if (this.toolChoice !== void 0) body.tool_choice = this.toolChoice;
+    if (this.seed !== void 0) body.seed = this.seed;
+    if (this.topP !== void 0) body.top_p = this.topP;
+    if (this.frequencyPenalty !== void 0) body.frequency_penalty = this.frequencyPenalty;
+    if (this.presencePenalty !== void 0) body.presence_penalty = this.presencePenalty;
+    if (this.stop !== void 0) body.stop = this.stop;
     if (tools) body.tools = tools;
     const response = await fetch(`${this.baseUrl}/chat/completions`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
+        Authorization: `Bearer ${this.apiKey}`,
+        "User-Agent": `getpatter/${VERSION}`
       },
       body: JSON.stringify(body),
       signal: AbortSignal.timeout(3e4)
@@ -3147,6 +3736,16 @@ async function* parseOpenAISseStream(response) {
       } 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) {
@@ -3169,6 +3768,7 @@ async function* parseOpenAISseStream(response) {
 
 // src/llm/groq.ts
 var LLM3 = class extends GroqLLMProvider {
+  static providerKey = "groq";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.GROQ_API_KEY;
     if (!key) {
@@ -3179,7 +3779,17 @@ var LLM3 = class extends GroqLLMProvider {
     super({
       apiKey: key,
       model: opts.model,
-      baseUrl: opts.baseUrl
+      baseUrl: opts.baseUrl,
+      temperature: opts.temperature,
+      maxTokens: opts.maxTokens,
+      responseFormat: opts.responseFormat,
+      parallelToolCalls: opts.parallelToolCalls,
+      toolChoice: opts.toolChoice,
+      seed: opts.seed,
+      topP: opts.topP,
+      frequencyPenalty: opts.frequencyPenalty,
+      presencePenalty: opts.presencePenalty,
+      stop: opts.stop
     });
   }
 };
@@ -3187,11 +3797,22 @@ var LLM3 = class extends GroqLLMProvider {
 // src/providers/cerebras-llm.ts
 var CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
 var DEFAULT_MODEL3 = "llama3.1-8b";
+var RETRY_BACKOFF_BASE_MS = 500;
 var CerebrasLLMProvider = class {
   apiKey;
   model;
   baseUrl;
   gzipCompression;
+  temperature;
+  maxTokens;
+  responseFormat;
+  parallelToolCalls;
+  toolChoice;
+  seed;
+  topP;
+  frequencyPenalty;
+  presencePenalty;
+  stop;
   constructor(options) {
     if (!options.apiKey) {
       throw new Error(
@@ -3201,18 +3822,43 @@ var CerebrasLLMProvider = class {
     this.apiKey = options.apiKey;
     this.model = options.model ?? DEFAULT_MODEL3;
     this.baseUrl = options.baseUrl ?? CEREBRAS_BASE_URL;
-    this.gzipCompression = options.gzipCompression ?? false;
+    this.gzipCompression = options.gzipCompression ?? true;
+    this.temperature = options.temperature;
+    this.maxTokens = options.maxTokens;
+    this.responseFormat = options.responseFormat;
+    this.parallelToolCalls = options.parallelToolCalls;
+    this.toolChoice = options.toolChoice;
+    this.seed = options.seed;
+    this.topP = options.topP;
+    this.frequencyPenalty = options.frequencyPenalty;
+    this.presencePenalty = options.presencePenalty;
+    this.stop = options.stop;
   }
   async *stream(messages, tools) {
     const body = {
       model: this.model,
       messages,
-      stream: true
+      stream: true,
+      stream_options: { include_usage: true }
     };
+    if (this.temperature !== void 0) body.temperature = this.temperature;
+    if (this.maxTokens !== void 0) {
+      body.max_completion_tokens = this.maxTokens;
+    }
+    if (this.responseFormat !== void 0) body.response_format = this.responseFormat;
+    if (this.parallelToolCalls !== void 0) body.parallel_tool_calls = this.parallelToolCalls;
+    if (this.toolChoice !== void 0) body.tool_choice = this.toolChoice;
+    if (this.seed !== void 0) body.seed = this.seed;
+    if (this.topP !== void 0) body.top_p = this.topP;
+    if (this.frequencyPenalty !== void 0) body.frequency_penalty = this.frequencyPenalty;
+    if (this.presencePenalty !== void 0) body.presence_penalty = this.presencePenalty;
+    if (this.stop !== void 0) body.stop = this.stop;
     if (tools) body.tools = tools;
     const headers = {
       "Content-Type": "application/json",
-      Authorization: `Bearer ${this.apiKey}`
+      Authorization: `Bearer ${this.apiKey}`,
+      // Identify the SDK in upstream logs/rate-limit attribution.
+      "User-Agent": `getpatter/${VERSION}`
     };
     let payload = JSON.stringify(body);
     if (this.gzipCompression) {
@@ -3222,18 +3868,43 @@ var CerebrasLLMProvider = class {
         headers["Content-Encoding"] = "gzip";
       }
     }
-    const response = await fetch(`${this.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers,
-      body: payload,
-      signal: AbortSignal.timeout(3e4)
-    });
-    if (!response.ok) {
-      const errText = await response.text();
-      getLogger().error(`Cerebras API error: ${response.status} ${errText}`);
-      return;
+    const maxAttempts = 2;
+    let lastErrText = "";
+    let lastStatus = 0;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: payload,
+        signal: AbortSignal.timeout(3e4)
+      });
+      if (response.ok) {
+        yield* parseOpenAISseStream(response);
+        return;
+      }
+      lastStatus = response.status;
+      lastErrText = await response.text().catch(() => "");
+      const isRetriable = response.status === 429 || response.status >= 500;
+      const isLastAttempt = attempt >= maxAttempts - 1;
+      if (!isRetriable || isLastAttempt) {
+        if (response.status === 404 && lastErrText.includes("model_not_found")) {
+          getLogger().error(
+            `Cerebras: model "${this.model}" not available on your tier. Override via \`new CerebrasLLM({ model: '<id>' })\` and list tier-available ids with \`GET ${this.baseUrl}/models\` (common: llama3.1-8b, qwen-3-235b-a22b-instruct-2507, llama-3.3-70b on paid). Raw response: ${lastErrText}`
+          );
+        } else {
+          getLogger().error(`Cerebras API error: ${response.status} ${lastErrText}`);
+        }
+        return;
+      }
+      const advisoryMs = parseRateLimitResetMs(response.headers);
+      const exponentialMs = RETRY_BACKOFF_BASE_MS * Math.pow(2, attempt);
+      const delayMs = 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));
     }
-    yield* parseOpenAISseStream(response);
+    throw new PatterError(`Cerebras API error ${lastStatus}: ${lastErrText || "request failed"}`);
   }
 };
 async function gzipEncode(data) {
@@ -3260,9 +3931,28 @@ async function gzipEncode(data) {
   }
   return out;
 }
+function parseRateLimitResetMs(headers) {
+  const candidates = [
+    headers.get("x-ratelimit-reset-tokens-minute"),
+    headers.get("x-ratelimit-reset-requests-minute"),
+    // Some upstreams send the standard ``retry-after`` (seconds).
+    headers.get("retry-after")
+  ];
+  let bestMs = 0;
+  for (const raw of candidates) {
+    if (!raw) continue;
+    const parsed = Number.parseFloat(raw);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      const ms = parsed * 1e3;
+      if (ms > bestMs) bestMs = ms;
+    }
+  }
+  return bestMs;
+}
 
 // src/llm/cerebras.ts
 var LLM4 = class extends CerebrasLLMProvider {
+  static providerKey = "cerebras";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.CEREBRAS_API_KEY;
     if (!key) {
@@ -3274,7 +3964,17 @@ var LLM4 = class extends CerebrasLLMProvider {
       apiKey: key,
       model: opts.model,
       baseUrl: opts.baseUrl,
-      gzipCompression: opts.gzipCompression
+      gzipCompression: opts.gzipCompression,
+      temperature: opts.temperature,
+      maxTokens: opts.maxTokens,
+      responseFormat: opts.responseFormat,
+      parallelToolCalls: opts.parallelToolCalls,
+      toolChoice: opts.toolChoice,
+      seed: opts.seed,
+      topP: opts.topP,
+      frequencyPenalty: opts.frequencyPenalty,
+      presencePenalty: opts.presencePenalty,
+      stop: opts.stop
     });
   }
 };
@@ -3330,6 +4030,7 @@ var GoogleLLMProvider = class {
     const decoder = new TextDecoder();
     let buffer = "";
     let nextIndex = 0;
+    let lastUsage;
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
@@ -3347,6 +4048,9 @@ var GoogleLLMProvider = class {
         } catch {
           continue;
         }
+        if (payload.usageMetadata) {
+          lastUsage = payload.usageMetadata;
+        }
         const candidate = payload.candidates?.[0];
         const parts = candidate?.content?.parts ?? [];
         for (const part of parts) {
@@ -3369,6 +4073,14 @@ var GoogleLLMProvider = class {
         }
       }
     }
+    if (lastUsage) {
+      yield {
+        type: "usage",
+        inputTokens: lastUsage.promptTokenCount,
+        outputTokens: lastUsage.candidatesTokenCount,
+        cacheReadInputTokens: lastUsage.cachedContentTokenCount ?? 0
+      };
+    }
     yield { type: "done" };
   }
 };
@@ -3458,6 +4170,7 @@ function toGeminiContents(messages) {
 
 // src/llm/google.ts
 var LLM5 = class extends GoogleLLMProvider {
+  static providerKey = "google";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.GEMINI_API_KEY ?? process.env.GOOGLE_API_KEY;
     if (!key) {
@@ -3475,6 +4188,279 @@ var LLM5 = class extends GoogleLLMProvider {
   }
 };
 
+// src/providers/silero-vad.ts
+import { createRequire } from "module";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var SUPPORTED_SAMPLE_RATES = [8e3, 16e3];
+function resolveModuleDir() {
+  try {
+    const cjsDir = new Function("return typeof __dirname !== 'undefined' ? __dirname : null")();
+    if (typeof cjsDir === "string") return cjsDir;
+  } catch {
+  }
+  try {
+    const url = import.meta.url;
+    if (url) return path.dirname(fileURLToPath(url));
+  } catch {
+  }
+  return process.cwd();
+}
+var MODULE_DIR = resolveModuleDir();
+function resolveDefaultModelPath() {
+  const candidates = [
+    path.join(MODULE_DIR, "resources", "silero_vad.onnx"),
+    path.join(MODULE_DIR, "..", "resources", "silero_vad.onnx")
+  ];
+  for (const c of candidates) if (fs.existsSync(c)) return c;
+  return candidates[0];
+}
+var DEFAULT_MODEL_PATH = resolveDefaultModelPath();
+async function loadOnnxRuntime() {
+  let firstErr;
+  try {
+    const mod = await import("./dist-YRCCJQ26.mjs");
+    return mod;
+  } catch (e) {
+    firstErr = e;
+  }
+  try {
+    const req = createRequire(path.join(process.cwd(), "package.json"));
+    return req("onnxruntime-node");
+  } catch (e) {
+    const detail = e?.message ?? String(e);
+    const original = firstErr?.message ?? String(firstErr);
+    throw new Error(
+      `
+SileroVAD requires the "onnxruntime-node" package, which could not be resolved.
+
+  Install:  npm install onnxruntime-node
+
+This is an optional peer dependency of getpatter (~210 MB) \u2014 it is only
+needed when you use SileroVAD in pipeline mode.
+
+  import() failed: ${original}
+  cwd-require failed: ${detail}
+`
+    );
+  }
+}
+var ExpFilter = class {
+  constructor(alpha) {
+    this.alpha = alpha;
+    if (!(alpha > 0 && alpha <= 1)) {
+      throw new Error("alpha must be in (0, 1].");
+    }
+  }
+  filtered = null;
+  apply(exp, sample) {
+    if (this.filtered === null) {
+      this.filtered = sample;
+    } else {
+      const a = Math.pow(this.alpha, exp);
+      this.filtered = a * this.filtered + (1 - a) * sample;
+    }
+    return this.filtered;
+  }
+  reset() {
+    this.filtered = null;
+  }
+};
+var OnnxModel = class {
+  constructor(runtime, session, sampleRate) {
+    this.runtime = runtime;
+    this.session = session;
+    if (!SUPPORTED_SAMPLE_RATES.includes(sampleRate)) {
+      throw new Error("Silero VAD only supports 8KHz and 16KHz sample rates");
+    }
+    this.sampleRate = sampleRate;
+    this.windowSizeSamples = sampleRate === 8e3 ? 256 : 512;
+    this.contextSize = sampleRate === 8e3 ? 32 : 64;
+    this.context = new Float32Array(this.contextSize);
+    this.rnnState = new Float32Array(2 * 1 * 128);
+    this.inputBuffer = new Float32Array(this.contextSize + this.windowSizeSamples);
+    this.sampleRateTensor = BigInt64Array.from([BigInt(sampleRate)]);
+  }
+  sampleRate;
+  windowSizeSamples;
+  contextSize;
+  context;
+  rnnState;
+  inputBuffer;
+  sampleRateTensor;
+  async run(window) {
+    if (window.length !== this.windowSizeSamples) {
+      throw new Error(
+        `window must have exactly ${this.windowSizeSamples} samples, got ${window.length}`
+      );
+    }
+    this.inputBuffer.set(this.context, 0);
+    this.inputBuffer.set(window, this.contextSize);
+    const { Tensor } = this.runtime;
+    const feeds = {
+      input: new Tensor("float32", this.inputBuffer, [1, this.inputBuffer.length]),
+      state: new Tensor("float32", this.rnnState, [2, 1, 128]),
+      sr: new Tensor("int64", this.sampleRateTensor, [])
+    };
+    const results = await this.session.run(feeds);
+    const outputKey = Object.keys(results).find((k) => k !== "stateN") ?? "output";
+    const stateKey = "stateN" in results ? "stateN" : Object.keys(results).find((k) => k !== outputKey);
+    const out = results[outputKey];
+    const newState = stateKey ? results[stateKey] : void 0;
+    if (newState && newState.data instanceof Float32Array) {
+      this.rnnState = Float32Array.from(newState.data);
+    }
+    this.context = this.inputBuffer.slice(-this.contextSize);
+    const data = out.data;
+    return data[0] ?? 0;
+  }
+};
+var SileroVAD = class _SileroVAD {
+  constructor(model, opts) {
+    this.model = model;
+    this.opts = opts;
+  }
+  pending = new Float32Array(0);
+  expFilter = new ExpFilter(0.35);
+  pubSpeaking = false;
+  speechThresholdDuration = 0;
+  silenceThresholdDuration = 0;
+  closed = false;
+  /**
+   * Load the Silero VAD model. Defaults match the LiveKit Silero plugin.
+   * Throws if `onnxruntime-node` is not installed.
+   */
+  static async load(options = {}) {
+    const sampleRate = options.sampleRate ?? 16e3;
+    if (!SUPPORTED_SAMPLE_RATES.includes(sampleRate)) {
+      throw new Error("Silero VAD only supports 8KHz and 16KHz sample rates");
+    }
+    const activationThreshold = options.activationThreshold ?? 0.5;
+    const deactivationThreshold = options.deactivationThreshold ?? Math.max(activationThreshold - 0.15, 0.01);
+    if (deactivationThreshold <= 0) {
+      throw new Error("deactivationThreshold must be greater than 0");
+    }
+    const runtime = await loadOnnxRuntime();
+    const modelPath = options.onnxFilePath ?? DEFAULT_MODEL_PATH;
+    const session = await runtime.InferenceSession.create(modelPath, {
+      interOpNumThreads: 1,
+      intraOpNumThreads: 1,
+      executionMode: "sequential",
+      executionProviders: options.forceCpu === false ? void 0 : ["cpu"]
+    });
+    const model = new OnnxModel(runtime, session, sampleRate);
+    return new _SileroVAD(model, {
+      minSpeechDuration: options.minSpeechDuration ?? 0.05,
+      minSilenceDuration: options.minSilenceDuration ?? 0.55,
+      prefixPaddingDuration: options.prefixPaddingDuration ?? 0.5,
+      activationThreshold,
+      deactivationThreshold,
+      sampleRate
+    });
+  }
+  /**
+   * Internal factory used by tests — bypasses onnxruntime-node loading.
+   * @internal
+   */
+  static fromOnnxModel(runtime, session, options) {
+    const model = new OnnxModel(runtime, session, options.sampleRate);
+    return new _SileroVAD(model, options);
+  }
+  get sampleRate() {
+    return this.opts.sampleRate;
+  }
+  /**
+   * Number of int16 PCM samples that must be provided per call to
+   * processFrame for the model to run one inference window.
+   *
+   * Constraint (ported from LiveKit Agents / Silero ONNX spec):
+   *   - 16 000 Hz → 512 samples (32 ms)
+   *   -  8 000 Hz → 256 samples (32 ms)
+   *
+   * Callers that feed raw audio in fixed-size chunks (e.g. WebSocket frames)
+   * should buffer incoming audio until at least numFramesRequired() int16
+   * samples are available before calling processFrame.  The provider
+   * internally buffers partial windows so smaller chunks are also safe, but
+   * passing exactly one window per call minimises heap allocation.
+   */
+  numFramesRequired() {
+    return this.opts.sampleRate === 8e3 ? 256 : 512;
+  }
+  async processFrame(pcmChunk, sampleRate) {
+    if (this.closed) {
+      throw new Error("SileroVAD is closed");
+    }
+    if (sampleRate !== this.opts.sampleRate) {
+      throw new Error(
+        `input sampleRate ${sampleRate} does not match model sampleRate ${this.opts.sampleRate}; resampling is not implemented in the Patter port`
+      );
+    }
+    if (pcmChunk.length === 0) {
+      return null;
+    }
+    const numSamples = Math.floor(pcmChunk.length / 2);
+    if (numSamples === 0) {
+      return null;
+    }
+    const samples = new Float32Array(numSamples);
+    for (let i = 0; i < numSamples; i++) {
+      samples[i] = pcmChunk.readInt16LE(i * 2) / 32767;
+    }
+    const merged = new Float32Array(this.pending.length + samples.length);
+    merged.set(this.pending, 0);
+    merged.set(samples, this.pending.length);
+    this.pending = merged;
+    const windowSize = this.model.windowSizeSamples;
+    let event = null;
+    while (this.pending.length >= windowSize) {
+      const window = this.pending.slice(0, windowSize);
+      this.pending = this.pending.slice(windowSize);
+      const rawP = await this.model.run(window);
+      const p = this.expFilter.apply(1, rawP);
+      const windowDuration = windowSize / this.opts.sampleRate;
+      const transition = this.advanceState(p, windowDuration);
+      if (transition !== null) {
+        event = transition;
+      }
+    }
+    return event;
+  }
+  advanceState(p, windowDuration) {
+    const opts = this.opts;
+    if (p >= opts.activationThreshold || this.pubSpeaking && p > opts.deactivationThreshold) {
+      this.speechThresholdDuration += windowDuration;
+      this.silenceThresholdDuration = 0;
+      if (!this.pubSpeaking) {
+        if (this.speechThresholdDuration >= opts.minSpeechDuration) {
+          this.pubSpeaking = true;
+          return {
+            type: "speech_start",
+            confidence: p,
+            durationMs: this.speechThresholdDuration * 1e3
+          };
+        }
+      }
+    } else {
+      this.silenceThresholdDuration += windowDuration;
+      this.speechThresholdDuration = 0;
+      if (this.pubSpeaking && this.silenceThresholdDuration >= opts.minSilenceDuration) {
+        this.pubSpeaking = false;
+        return {
+          type: "speech_end",
+          confidence: p,
+          durationMs: this.silenceThresholdDuration * 1e3
+        };
+      }
+    }
+    return null;
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+  }
+};
+
 // src/carriers/twilio.ts
 var Carrier = class {
   kind = "twilio";
@@ -3823,7 +4809,7 @@ var DebouncedCall = class {
     this.timer = setTimeout(() => {
       this.timer = null;
       Promise.resolve(this.callback()).catch((err) => {
-        console.error("IVR silence callback raised:", err);
+        getLogger().error("IVR silence callback raised:", err);
       });
     }, this.delayMs);
   }
@@ -3879,7 +4865,7 @@ var IVRActivity = class {
           try {
             await this.onLoopDetected();
           } catch (err) {
-            console.error("IVR onLoopDetected callback raised:", err);
+            getLogger().error("IVR onLoopDetected callback raised:", err);
           }
         }
       }
@@ -3917,7 +4903,7 @@ var IVRActivity = class {
       try {
         await this.onSilence();
       } catch (err) {
-        console.error("IVR onSilence callback raised:", err);
+        getLogger().error("IVR onSilence callback raised:", err);
       }
     }
   }
@@ -3967,9 +4953,9 @@ var IVRActivity = class {
 };
 
 // src/services/background-audio.ts
-import { promises as fs } from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
+import { promises as fs2 } from "fs";
+import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var BuiltinAudioClip = {
   CITY_AMBIENCE: "city-ambience.ogg",
   FOREST_AMBIENCE: "forest-ambience.ogg",
@@ -3981,8 +4967,8 @@ var BuiltinAudioClip = {
 };
 function builtinClipPath(clip) {
   const meta = typeof import.meta !== "undefined" ? import.meta : void 0;
-  const here = meta?.url ? path.dirname(fileURLToPath(meta.url)) : typeof __dirname !== "undefined" ? __dirname : process.cwd();
-  return path.resolve(here, "..", "resources", "audio", clip);
+  const here = meta?.url ? path2.dirname(fileURLToPath2(meta.url)) : typeof __dirname !== "undefined" ? __dirname : process.cwd();
+  return path2.resolve(here, "..", "resources", "audio", clip);
 }
 var INT16_MIN = -32768;
 var INT16_MAX = 32767;
@@ -4151,7 +5137,7 @@ var BackgroundAudioPlayer = class {
         return source.decode(source.path);
       case "builtin": {
         const p = builtinClipPath(source.clip);
-        const header = await fs.readFile(p, { flag: "r" }).then((buf) => buf.subarray(0, 4));
+        const header = await fs2.readFile(p, { flag: "r" }).then((buf) => buf.subarray(0, 4));
         if (header.toString("ascii") !== "OggS") {
           throw new Error(`Bundled clip ${source.clip} is not a valid Ogg file`);
         }
@@ -4181,15 +5167,264 @@ var BackgroundAudioPlayer = class {
 function isAudioConfig(value) {
   return typeof value === "object" && value !== null && "source" in value && typeof value.source === "object";
 }
+
+// src/providers/twilio-adapter.ts
+var TWILIO_API_BASE = "https://api.twilio.com/2010-04-01";
+var TwilioAdapter = class _TwilioAdapter {
+  accountSid;
+  region;
+  baseUrl;
+  authHeader;
+  constructor(accountSid, authToken, opts = {}) {
+    if (!accountSid) throw new Error("TwilioAdapter: accountSid is required");
+    if (!authToken) throw new Error("TwilioAdapter: authToken is required");
+    this.accountSid = accountSid;
+    this.region = opts.region;
+    this.baseUrl = opts.region ? `https://api.${opts.region}.twilio.com/2010-04-01` : TWILIO_API_BASE;
+    this.authHeader = `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`;
+  }
+  async request(method, path3, body) {
+    const url = `${this.baseUrl}/Accounts/${encodeURIComponent(this.accountSid)}${path3}`;
+    const headers = { Authorization: this.authHeader };
+    if (body) headers["Content-Type"] = "application/x-www-form-urlencoded";
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? body.toString() : void 0,
+      signal: AbortSignal.timeout(3e4)
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`Twilio ${method} ${path3} failed: ${response.status} ${text}`);
+    }
+    if (!text) return {};
+    try {
+      return JSON.parse(text);
+    } catch (e) {
+      throw new Error(`Twilio returned non-JSON response: ${String(e)}`);
+    }
+  }
+  /**
+   * Provision a local phone number in the given country.
+   *
+   * Lists available local numbers, then purchases the first match.
+   */
+  async provisionNumber(opts) {
+    const country = encodeURIComponent(opts.countryCode);
+    const queryParts = ["PageSize=1"];
+    if (opts.areaCode) queryParts.push(`AreaCode=${encodeURIComponent(opts.areaCode)}`);
+    const path3 = `/AvailablePhoneNumbers/${country}/Local.json?${queryParts.join("&")}`;
+    const available = await this.request("GET", path3);
+    const first = available.available_phone_numbers?.[0]?.phone_number;
+    if (!first) {
+      throw new Error(`TwilioAdapter: no numbers available for country ${opts.countryCode}`);
+    }
+    const body = new URLSearchParams({ PhoneNumber: first });
+    const purchased = await this.request(
+      "POST",
+      "/IncomingPhoneNumbers.json",
+      body
+    );
+    if (!purchased.sid || !purchased.phone_number) {
+      throw new Error("TwilioAdapter: malformed response from IncomingPhoneNumbers.create");
+    }
+    return { phoneNumber: purchased.phone_number, sid: purchased.sid };
+  }
+  /** Update an already-purchased number to point at our voice webhook. */
+  async configureNumber(phoneNumberSid, opts) {
+    if (!phoneNumberSid) throw new Error("TwilioAdapter: phoneNumberSid is required");
+    const body = new URLSearchParams({
+      VoiceUrl: opts.voiceUrl,
+      VoiceMethod: "POST"
+    });
+    if (opts.statusCallback) body.set("StatusCallback", opts.statusCallback);
+    await this.request(
+      "POST",
+      `/IncomingPhoneNumbers/${encodeURIComponent(phoneNumberSid)}.json`,
+      body
+    );
+  }
+  /** Place an outbound call. Returns the Twilio call SID. */
+  async initiateCall(opts) {
+    if (!opts.url && !opts.streamUrl) {
+      throw new Error("TwilioAdapter: initiateCall requires either url or streamUrl");
+    }
+    const body = new URLSearchParams({
+      From: opts.from,
+      To: opts.to
+    });
+    if (opts.url) {
+      body.set("Url", opts.url);
+    } else if (opts.streamUrl) {
+      body.set("Twiml", _TwilioAdapter.generateStreamTwiml(opts.streamUrl));
+    }
+    if (opts.statusCallback) body.set("StatusCallback", opts.statusCallback);
+    if (opts.machineDetection) body.set("MachineDetection", opts.machineDetection);
+    if (opts.extraParams) {
+      for (const [key, value] of Object.entries(opts.extraParams)) {
+        body.set(key, value);
+      }
+    }
+    const call = await this.request("POST", "/Calls.json", body);
+    if (!call.sid) {
+      throw new Error("TwilioAdapter: Calls.create returned no SID");
+    }
+    return { callSid: call.sid };
+  }
+  /**
+   * Build a minimal ``<Response><Connect><Stream url="..."/></Connect></Response>``
+   * TwiML document. Mirrors the Python adapter's ``generate_stream_twiml``.
+   */
+  static generateStreamTwiml(streamUrl) {
+    const escaped = streamUrl.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+    return `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${escaped}"/></Connect></Response>`;
+  }
+  /** Force-complete an in-progress call. */
+  async endCall(callSid) {
+    if (!callSid) throw new Error("TwilioAdapter: callSid is required");
+    const body = new URLSearchParams({ Status: "completed" });
+    try {
+      await this.request(
+        "POST",
+        `/Calls/${encodeURIComponent(callSid)}.json`,
+        body
+      );
+    } catch (err) {
+      getLogger().warn(`[TwilioAdapter] endCall failed for ${callSid}: ${String(err)}`);
+      throw err;
+    }
+  }
+};
+
+// src/providers/telnyx-adapter.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var TELNYX_API_BASE = "https://api.telnyx.com/v2";
+var TelnyxAdapter = class {
+  apiKey;
+  connectionId;
+  baseUrl = TELNYX_API_BASE;
+  constructor(apiKey, connectionId) {
+    if (!apiKey) throw new Error("TelnyxAdapter: apiKey is required");
+    this.apiKey = apiKey;
+    this.connectionId = connectionId;
+  }
+  async request(method, path3, body) {
+    const url = `${this.baseUrl}${path3}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`
+    };
+    if (body !== void 0) headers["Content-Type"] = "application/json";
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0,
+      signal: AbortSignal.timeout(3e4)
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`Telnyx ${method} ${path3} failed: ${response.status} ${text}`);
+    }
+    if (!text) return {};
+    try {
+      return JSON.parse(text);
+    } catch (e) {
+      throw new Error(`Telnyx returned non-JSON response: ${String(e)}`);
+    }
+  }
+  /**
+   * Search available numbers for ``countryCode`` and place an order for the
+   * first match. Returns both the reserved E.164 number and the order ID.
+   */
+  async provisionNumber(opts) {
+    const country = encodeURIComponent(opts.countryCode);
+    const searchPath = `/available_phone_numbers?filter[phone_number][country_code]=${country}&filter[limit]=1`;
+    const available = await this.request("GET", searchPath);
+    const chosen = available.data?.[0]?.phone_number;
+    if (!chosen) {
+      throw new Error(`TelnyxAdapter: no numbers available for ${opts.countryCode}`);
+    }
+    const orderBody = {
+      phone_numbers: [{ phone_number: chosen }]
+    };
+    if (this.connectionId) {
+      orderBody.connection_id = this.connectionId;
+    }
+    const order = await this.request(
+      "POST",
+      "/number_orders",
+      orderBody
+    );
+    const orderId = order.data?.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 }
+    );
+  }
+  /**
+   * Place an outbound call on the Call Control Application.
+   *
+   * Note: we intentionally do NOT pass ``stream_url`` here — audio streaming
+   * is configured on the Application itself (or started explicitly via a
+   * ``streaming_start`` command). Passing ``stream_url`` on dial is a
+   * deprecated code path that Telnyx rejects in newer API versions.
+   */
+  async initiateCall(opts) {
+    const connectionId = opts.connectionId ?? this.connectionId;
+    if (!connectionId) {
+      throw new Error("TelnyxAdapter: connectionId must be provided to initiateCall");
+    }
+    const payload = {
+      connection_id: connectionId,
+      from: opts.from,
+      to: opts.to
+    };
+    if (opts.clientState) {
+      payload.client_state = Buffer.from(opts.clientState, "utf-8").toString("base64");
+    }
+    const resp = await this.request("POST", "/calls", payload);
+    const callControlId = resp.data?.call_control_id;
+    if (!callControlId) {
+      throw new Error("TelnyxAdapter: /calls returned no call_control_id");
+    }
+    return { callControlId };
+  }
+  /** Hang up an in-progress call. */
+  async endCall(callControlId, opts = {}) {
+    if (!callControlId) throw new Error("TelnyxAdapter: callControlId is required");
+    const encoded = encodeURIComponent(callControlId);
+    const body = {
+      command_id: opts.commandId ?? randomUUID2()
+    };
+    try {
+      await this.request(
+        "POST",
+        `/calls/${encoded}/actions/hangup`,
+        body
+      );
+    } catch (err) {
+      getLogger().warn(
+        `[TelnyxAdapter] endCall failed for ${callControlId}: ${String(err)}`
+      );
+      throw err;
+    }
+  }
+};
 export {
   AllProvidersFailedError,
   LLM2 as AnthropicLLM,
-  STT5 as AssemblyAISTT,
+  STT6 as AssemblyAISTT,
   AuthenticationError,
   BackgroundAudioPlayer,
   BuiltinAudioClip,
   CallMetricsAccumulator,
-  STT3 as CartesiaSTT,
+  STT4 as CartesiaSTT,
   TTS3 as CartesiaTTS,
   LLM4 as CerebrasLLM,
   ChatContext,
@@ -4198,9 +5433,11 @@ export {
   DEFAULT_PRICING,
   DTMF_EVENTS,
   STT as DeepgramSTT,
+  DefaultToolExecutor,
   ConvAI as ElevenLabsConvAI,
   ElevenLabsConvAIAdapter,
   TTS as ElevenLabsTTS,
+  EventBus,
   FallbackLLMProvider,
   GEMINI_DEFAULT_INPUT_SR,
   GEMINI_DEFAULT_OUTPUT_SR,
@@ -4212,31 +5449,48 @@ export {
   LLMLoop,
   TTS5 as LMNTTTS,
   MetricsStore,
+  Ngrok,
   LLM as OpenAILLM,
   OpenAILLMProvider,
   Realtime as OpenAIRealtime,
   OpenAIRealtimeAdapter,
   TTS2 as OpenAITTS,
+  STT3 as OpenAITranscribeSTT,
   PartialStreamError,
   Patter,
   PatterConnectionError,
   PatterError,
+  PatterTool,
+  PcmCarry,
   PipelineHookExecutor,
   ProvisionError,
+  RateLimitError,
   RemoteMessageHandler,
   TTS4 as RimeTTS,
+  SPAN_BARGEIN,
+  SPAN_CALL,
+  SPAN_ENDPOINT,
+  SPAN_LLM,
+  SPAN_STT,
+  SPAN_TOOL,
+  SPAN_TTS,
   SentenceChunker,
-  STT4 as SonioxSTT,
+  SileroVAD,
+  STT5 as SonioxSTT,
+  StatefulResampler,
   Static as StaticTunnel,
   Carrier2 as Telnyx,
+  TelnyxAdapter,
   TestSession,
   TfidfLoopDetector,
   Tool,
   Carrier as Twilio,
+  TwilioAdapter,
   ULTRAVOX_DEFAULT_API_BASE,
   ULTRAVOX_DEFAULT_SR,
   UltravoxRealtimeAdapter,
   STT2 as WhisperSTT,
+  assemblyai,
   builtinClipPath,
   calculateRealtimeCost,
   calculateSttCost,
@@ -4244,6 +5498,10 @@ export {
   calculateTtsCost,
   callsToCsv,
   callsToJson,
+  cartesia,
+  createResampler16kTo8k,
+  createResampler24kTo16k,
+  createResampler8kTo16k,
   deepgram,
   defineTool,
   elevenlabs,
@@ -4251,10 +5509,14 @@ export {
   filterForTTS,
   filterMarkdown,
   formatDtmf,
+  geminiLive,
   getLogger,
   guardrail,
+  initTracing,
   isRemoteUrl,
+  isTracingEnabled,
   isWebSocketUrl,
+  lmnt,
   makeAuthMiddleware,
   mergePricing,
   mixPcm,
@@ -4268,12 +5530,17 @@ export {
   resample24kTo16k,
   resample8kTo16k,
   resamplePcm,
+  rime,
   scheduleCron,
   scheduleInterval,
   scheduleOnce,
   selectSoundFromList,
   setLogger,
+  soniox,
+  speechmatics,
+  startSpan,
   startTunnel,
   tool,
+  ultravox,
   whisper
 };