getpatter 0.5.3 → 0.6.0

package/dist/index.mjs

@@ -1,9 +1,6 @@
-import {
-  notifyDashboard
-} from "./chunk-AFUYSNDH.mjs";
 import {
   startTunnel
-} from "./chunk-SEMKNPCD.mjs";
+} from "./chunk-XS45BAQL.mjs";
 import {
   AuthenticationError,
   CallMetricsAccumulator,
@@ -13,6 +10,7 @@ import {
   DefaultToolExecutor,
   ElevenLabsConvAIAdapter,
   EmbeddedServer,
+  ErrorCode,
   EventBus,
   LLMLoop,
   MetricsStore,
@@ -43,12 +41,14 @@ import {
   callsToJson,
   createResampler16kTo8k,
   createResampler24kTo16k,
+  createResampler24kTo8k,
   createResampler8kTo16k,
   initTracing,
   isRemoteUrl,
   isTracingEnabled,
   isWebSocketUrl,
   makeAuthMiddleware,
+  mergeAbortSignals,
   mergePricing,
   mountApi,
   mountDashboard,
@@ -57,20 +57,40 @@ import {
   resample16kTo8k,
   resample24kTo16k,
   resample8kTo16k,
+  resolveLogRoot,
   startSpan
-} from "./chunk-FIFIWBL7.mjs";
+} from "./chunk-JUQ5WQTQ.mjs";
 import {
   getLogger,
   setLogger
-} from "./chunk-VJVDG4V5.mjs";
-import "./chunk-QHHBUCMT.mjs";
+} from "./chunk-MVOQFAEO.mjs";
+import {
+  notifyDashboard
+} from "./chunk-6GR5MHHQ.mjs";
+import {
+  SileroVAD
+} from "./chunk-X3364LSI.mjs";
+import {
+  __dirname,
+  __require,
+  init_esm_shims
+} from "./chunk-N565J3CF.mjs";
+
+// src/index.ts
+init_esm_shims();
+
+// src/client.ts
+init_esm_shims();
 
 // src/engines/openai.ts
+init_esm_shims();
 var Realtime = class {
   kind = "openai_realtime";
   apiKey;
   model;
   voice;
+  reasoningEffort;
+  inputAudioTranscriptionModel;
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
     if (!key) {
@@ -81,10 +101,13 @@ var Realtime = class {
     this.apiKey = key;
     this.model = opts.model ?? "gpt-4o-mini-realtime-preview";
     this.voice = opts.voice ?? "alloy";
+    this.reasoningEffort = opts.reasoningEffort;
+    this.inputAudioTranscriptionModel = opts.inputAudioTranscriptionModel;
   }
 };
 
 // src/engines/elevenlabs.ts
+init_esm_shims();
 var ConvAI = class {
   kind = "elevenlabs_convai";
   apiKey;
@@ -100,7 +123,7 @@ var ConvAI = class {
     }
     if (!agent) {
       throw new Error(
-        "ElevenLabs ConvAI requires an agentId. Pass { agentId: 'agent_...' } or set ELEVENLABS_AGENT_ID in the environment."
+        "ElevenLabs ConvAI requires an agentId. Create one in the ElevenLabs dashboard (https://elevenlabs.io/app/conversational-ai) \u2014 the agent ID is per-deployed-agent and cannot be derived from the API key alone. Then either pass { agentId: 'agent_...' } at construction or set ELEVENLABS_AGENT_ID in the environment."
       );
     }
     this.apiKey = key;
@@ -110,6 +133,7 @@ var ConvAI = class {
 };
 
 // src/tunnels/index.ts
+init_esm_shims();
 var CloudflareTunnel = class {
   kind = "cloudflare";
 };
@@ -144,11 +168,448 @@ var Ngrok = class {
   }
 };
 
+// src/tools/schema-validation.ts
+init_esm_shims();
+var ToolSchemaError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolSchemaError";
+  }
+};
+function validateToolSchema(tool2) {
+  const params = tool2.parameters;
+  const tag = `tool '${tool2.name}'`;
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    throw new ToolSchemaError(
+      `${tag}: \`parameters\` must be a JSON Schema object (got ${typeof params}).`
+    );
+  }
+  if (params.type !== "object") {
+    throw new ToolSchemaError(
+      `${tag}: \`parameters.type\` must be "object" (got ${JSON.stringify(params.type)}). OpenAI function tools require an object root.`
+    );
+  }
+  if (params.properties !== void 0 && (typeof params.properties !== "object" || params.properties === null || Array.isArray(params.properties))) {
+    throw new ToolSchemaError(
+      `${tag}: \`parameters.properties\` must be an object map of field \u2192 JSON Schema.`
+    );
+  }
+  if (params.required !== void 0 && !Array.isArray(params.required)) {
+    throw new ToolSchemaError(
+      `${tag}: \`parameters.required\` must be an array of field names.`
+    );
+  }
+  if (Array.isArray(params.required) && params.properties) {
+    const props = params.properties;
+    for (const fieldName of params.required) {
+      if (typeof fieldName !== "string") {
+        throw new ToolSchemaError(
+          `${tag}: \`parameters.required\` entries must be strings (got ${typeof fieldName}).`
+        );
+      }
+      if (!(fieldName in props)) {
+        throw new ToolSchemaError(
+          `${tag}: \`parameters.required\` lists "${fieldName}" but it is not declared in \`parameters.properties\`.`
+        );
+      }
+    }
+  }
+  if (tool2.strict === true) {
+    validateStrictModeSchema(tool2.name, params);
+  }
+}
+function validateStrictModeSchema(toolName, schema, pathParts = []) {
+  const tag = `tool '${toolName}'`;
+  const here = pathParts.length === 0 ? "parameters" : `parameters.${pathParts.join(".")}`;
+  if (schema.type === "object") {
+    if (schema.additionalProperties !== false) {
+      throw new ToolSchemaError(
+        `${tag}: strict mode requires \`${here}.additionalProperties: false\` on every object \u2014 got ${JSON.stringify(schema.additionalProperties)}.`
+      );
+    }
+    const props = schema.properties ?? {};
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    for (const propName of Object.keys(props)) {
+      if (!required.includes(propName)) {
+        throw new ToolSchemaError(
+          `${tag}: strict mode requires every property to be listed in \`required\` \u2014 "${here}.${propName}" is missing. Use a nullable type (e.g. ["string", "null"]) instead of an optional field.`
+        );
+      }
+    }
+    for (const [propName, propSchema] of Object.entries(props)) {
+      if (propSchema && typeof propSchema === "object") {
+        validateStrictModeSchema(toolName, propSchema, [...pathParts, "properties", propName]);
+      }
+    }
+  } else if (schema.type === "array" && schema.items && typeof schema.items === "object") {
+    validateStrictModeSchema(toolName, schema.items, [...pathParts, "items"]);
+  }
+}
+function validateAllToolSchemas(tools) {
+  if (!tools) return;
+  for (const tool2 of tools) {
+    validateToolSchema(tool2);
+  }
+}
+
+// src/_speech-events.ts
+init_esm_shims();
+var logger = getLogger();
+var otelTrace = null;
+var otelLoaded = false;
+function loadOtel() {
+  if (otelLoaded) return otelTrace;
+  otelLoaded = true;
+  try {
+    const mod = __require("@opentelemetry/api");
+    otelTrace = mod.trace;
+  } catch {
+    otelTrace = null;
+  }
+  return otelTrace;
+}
+function recordSpanEvent(name, attrs) {
+  const trace = loadOtel();
+  if (trace === null) return;
+  try {
+    const span = trace.getActiveSpan?.();
+    if (!span || !span.isRecording()) return;
+    span.addEvent(name, attrs);
+  } catch (err) {
+    logger.debug?.(`Failed to record OTel span event ${name}: ${String(err)}`);
+  }
+}
+function nowMs() {
+  return Date.now();
+}
+var SpeechEvents = class {
+  // Public callback slots — any of them may be set by the user.
+  onUserSpeechStarted = null;
+  onUserSpeechEnded = null;
+  onUserSpeechEos = null;
+  onAgentSpeechStarted = null;
+  onAgentSpeechEnded = null;
+  onLlmToken = null;
+  onAudioOut = null;
+  // State machine — read via `conversationState`.
+  userState = "listening";
+  agentState = "initializing";
+  // Per-turn cursors. `turnIdxValue` increments on every committed EOU.
+  turnIdxValue = 0;
+  firstTokenForTurn = true;
+  firstAudioForTurn = true;
+  // Optional call start (ms since epoch) — used to compute `audioOffsetMs`
+  // payloads when the caller does not provide one.
+  callStartMs = null;
+  /** Snapshot of the current per-side state of the call. */
+  get conversationState() {
+    return { user: this.userState, agent: this.agentState };
+  }
+  /** Current 0-based turn index. Increments on every EOU commit. */
+  get turnIdx() {
+    return this.turnIdxValue;
+  }
+  /** Record the call-start wall-clock for ``audioOffsetMs`` math. */
+  markCallStarted(tsMs) {
+    this.callStartMs = tsMs ?? nowMs();
+    this.userState = "listening";
+    this.agentState = "idle";
+  }
+  /** Reset per-turn cursors. Called automatically on EOU commit. */
+  resetTurnState() {
+    this.firstTokenForTurn = true;
+    this.firstAudioForTurn = true;
+  }
+  // ---- User-side events -----------------------------------------------
+  /** Fire on the VAD positive edge of the inbound stream.
+   *
+   * Do not coalesce: the runner consumes positive→negative→positive
+   * transitions in order. For server-VAD engines (OpenAI Realtime, Telnyx
+   * Voice AI), forward the upstream signal directly — do not re-run a VAD
+   * layer on top.
+   */
+  async fireUserSpeechStarted(opts = {}) {
+    const tsMs = opts.timestampMs ?? nowMs();
+    const payload = { timestamp_ms: tsMs };
+    if (opts.vadConfidence !== void 0)
+      payload.vad_confidence = opts.vadConfidence;
+    const offset = this.resolveOffset(opts.audioOffsetMs, tsMs);
+    if (offset !== null) payload.audio_offset_ms = offset;
+    this.userState = "speaking";
+    await this.dispatch(this.onUserSpeechStarted, payload, {
+      spanEvent: "patter.event.user_speech_started",
+      spanAttrs: filterUndef({
+        "patter.audio.offset_ms": payload.audio_offset_ms,
+        "patter.vad.confidence": payload.vad_confidence
+      })
+    });
+  }
+  /** Fire on the VAD trailing edge (raw — *not* EOU).
+   *
+   * `speechDurationMs` is the length of the segment that just ended; the
+   * runner uses it to compute talk-ratio.
+   */
+  async fireUserSpeechEnded(opts) {
+    const tsMs = opts.timestampMs ?? nowMs();
+    const payload = {
+      timestamp_ms: tsMs,
+      speech_duration_ms: opts.speechDurationMs
+    };
+    if (opts.vadConfidence !== void 0)
+      payload.vad_confidence = opts.vadConfidence;
+    const offset = this.resolveOffset(opts.audioOffsetMs, tsMs);
+    if (offset !== null) payload.audio_offset_ms = offset;
+    this.userState = "listening";
+    await this.dispatch(this.onUserSpeechEnded, payload, {
+      spanEvent: "patter.event.user_speech_ended",
+      spanAttrs: { "patter.speech.duration_ms": opts.speechDurationMs }
+    });
+  }
+  /** Fire on the committed end-of-utterance.
+   *
+   * This is the canonical "user finished" signal — VAD edge + trailing
+   * silence + (optionally) a semantic turn-detector model agreement. The
+   * runner uses the timestamp of this event to compute
+   * `eos_to_first_token_ms` (Hamming AI threshold: <800 ms good, >1500 ms
+   * critical).
+   */
+  async fireUserSpeechEos(opts) {
+    const tsMs = opts.timestampMs ?? nowMs();
+    const payload = {
+      timestamp_ms: tsMs,
+      trigger: opts.trigger
+    };
+    if (opts.trailingSilenceMs !== void 0)
+      payload.trailing_silence_ms = opts.trailingSilenceMs;
+    if (opts.transcriptSoFar !== void 0)
+      payload.transcript_so_far = opts.transcriptSoFar;
+    this.turnIdxValue += 1;
+    this.resetTurnState();
+    this.userState = "listening";
+    this.agentState = "thinking";
+    await this.dispatch(this.onUserSpeechEos, payload, {
+      spanEvent: "patter.event.user_speech_eos",
+      spanAttrs: filterUndef({
+        "patter.eos.trigger": opts.trigger,
+        "patter.eos.trailing_silence_ms": opts.trailingSilenceMs
+      })
+    });
+  }
+  // ---- Agent-side events ----------------------------------------------
+  /** Fire on the FIRST audio chunk of the current agent turn that crosses
+   * to the wire (not the first chunk produced by TTS).
+   *
+   * The user hears the wire chunk, so this is the timestamp the runner
+   * anchors barge-in latency on.
+   */
+  async fireAgentSpeechStarted(opts = {}) {
+    const tsMs = opts.timestampMs ?? nowMs();
+    const payload = {
+      timestamp_ms: tsMs,
+      turn_idx: this.turnIdxValue
+    };
+    if (opts.ttsProvider !== void 0) payload.tts_provider = opts.ttsProvider;
+    if (opts.engine !== void 0) payload.engine = opts.engine;
+    this.agentState = "speaking";
+    await this.dispatch(this.onAgentSpeechStarted, payload, {
+      spanEvent: "patter.event.agent_speech_started",
+      spanAttrs: filterUndef({
+        "patter.turn.idx": this.turnIdxValue,
+        "patter.tts.provider": opts.ttsProvider,
+        "patter.engine": opts.engine
+      })
+    });
+  }
+  /** Fire on the LAST audio chunk of the current agent turn.
+   *
+   * `interrupted=true` marks the turn as cancelled by barge-in; the runner
+   * treats it as the `agent_speech_stopped` half of a barge-in pair.
+   */
+  async fireAgentSpeechEnded(opts) {
+    const tsMs = opts.timestampMs ?? nowMs();
+    const interrupted = opts.interrupted ?? false;
+    const payload = {
+      timestamp_ms: tsMs,
+      turn_idx: this.turnIdxValue,
+      speech_duration_ms: opts.speechDurationMs,
+      interrupted
+    };
+    this.agentState = "idle";
+    await this.dispatch(this.onAgentSpeechEnded, payload, {
+      spanEvent: "patter.event.agent_speech_ended",
+      spanAttrs: {
+        "patter.turn.idx": this.turnIdxValue,
+        "patter.speech.duration_ms": opts.speechDurationMs,
+        "patter.turn.interrupted": interrupted
+      }
+    });
+  }
+  // ---- LLM / TTS events -----------------------------------------------
+  /** Fire on the FIRST LLM token of the current turn (TTFT marker).
+   *
+   * Idempotent within a turn — guarded by `firstTokenForTurn`. Combined
+   * with `on_user_speech_eos.timestamp_ms` the runner computes
+   * `eos_to_first_token_ms`.
+   */
+  async fireLlmFirstToken(opts) {
+    if (!this.firstTokenForTurn) return;
+    this.firstTokenForTurn = false;
+    const tsMs = opts.timestampMs ?? nowMs();
+    const payload = {
+      timestamp_ms: tsMs,
+      turn_idx: this.turnIdxValue,
+      llm_provider: opts.llmProvider,
+      model: opts.model
+    };
+    await this.dispatch(this.onLlmToken, payload, {
+      spanEvent: "patter.event.llm_first_token",
+      spanAttrs: {
+        "gen_ai.request.model": opts.model,
+        "gen_ai.provider.name": opts.llmProvider,
+        "patter.turn.idx": this.turnIdxValue
+      }
+    });
+  }
+  /** Fire on the FIRST TTS audio chunk for the current turn.
+   *
+   * Distinct from `fireAgentSpeechStarted`: this is the agent-side buffer
+   * arrival (TTS warmup), not the wire-time chunk. Idempotent within a
+   * turn — guarded by `firstAudioForTurn`.
+   */
+  async fireAudioOut(opts) {
+    if (!this.firstAudioForTurn) return;
+    this.firstAudioForTurn = false;
+    const tsMs = opts.timestampMs ?? nowMs();
+    const payload = {
+      timestamp_ms: tsMs,
+      turn_idx: this.turnIdxValue,
+      tts_provider: opts.ttsProvider
+    };
+    await this.dispatch(this.onAudioOut, payload, {
+      spanEvent: "patter.event.tts_first_audio",
+      spanAttrs: {
+        "patter.turn.idx": this.turnIdxValue,
+        "patter.tts.provider": opts.ttsProvider
+      }
+    });
+  }
+  // ---- Internal -------------------------------------------------------
+  resolveOffset(given, tsMs) {
+    if (given !== void 0) return given;
+    if (this.callStartMs !== null) return Math.max(0, tsMs - this.callStartMs);
+    return null;
+  }
+  async dispatch(cb, payload, opts) {
+    recordSpanEvent(opts.spanEvent, opts.spanAttrs);
+    if (cb === null) return;
+    try {
+      await cb(payload);
+    } catch (err) {
+      logger.warn?.(
+        `Speech-event callback ${opts.spanEvent} raised: ${String(err)}`
+      );
+    }
+  }
+};
+function filterUndef(obj) {
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+
 // src/client.ts
+function resolvePersistRoot(persist) {
+  if (persist === false) return null;
+  if (persist === true) return resolveLogRoot("auto");
+  if (typeof persist === "string") return resolveLogRoot(persist);
+  return resolveLogRoot();
+}
 var Patter = class {
   localConfig;
   embeddedServer = null;
   tunnelHandle = null;
+  _tunnelReadyResolve;
+  _tunnelReadyReject;
+  _tunnelReady;
+  _readyResolve;
+  _readyReject;
+  _ready;
+  /**
+   * True iff ``localConfig.webhookUrl`` was populated by ``serve()`` from a
+   * freshly-started cloudflared tunnel (rather than by the constructor from
+   * an explicit ``webhookUrl`` / ``StaticTunnel`` config). ``disconnect()``
+   * uses this flag to clear ONLY the auto-assigned hostname so a subsequent
+   * ``serve()`` call (e.g. from a plugin's ``ensureServing`` cycle that
+   * disposes + restarts on agent-identity changes) does not throw
+   * ``Cannot use both tunnel: true and webhookUrl``.
+   */
+  tunnelOwnsWebhookUrl = false;
+  /**
+   * Speech-edge events for turn-taking instrumentation. Public surface: the
+   * seven `on*` proxy accessors below plus the `conversationState` snapshot.
+   * Defaults are no-ops — existing users who never set a callback see exactly
+   * the previous behaviour.
+   *
+   * See `src/_speech-events.ts` for the full event taxonomy and the
+   * industry-alignment table (LiveKit / Pipecat / OpenAI Realtime).
+   */
+  speechEvents = new SpeechEvents();
+  // ---- Speech-edge event callback proxies ------------------------------
+  // The seven `on*` properties below mirror the public APIs of LiveKit
+  // Agents, Pipecat and OpenAI Realtime. They proxy to `speechEvents` so
+  // the dispatcher remains the single source of truth (state + OTel).
+  get onUserSpeechStarted() {
+    return this.speechEvents.onUserSpeechStarted;
+  }
+  set onUserSpeechStarted(cb) {
+    this.speechEvents.onUserSpeechStarted = cb;
+  }
+  get onUserSpeechEnded() {
+    return this.speechEvents.onUserSpeechEnded;
+  }
+  set onUserSpeechEnded(cb) {
+    this.speechEvents.onUserSpeechEnded = cb;
+  }
+  get onUserSpeechEos() {
+    return this.speechEvents.onUserSpeechEos;
+  }
+  set onUserSpeechEos(cb) {
+    this.speechEvents.onUserSpeechEos = cb;
+  }
+  get onAgentSpeechStarted() {
+    return this.speechEvents.onAgentSpeechStarted;
+  }
+  set onAgentSpeechStarted(cb) {
+    this.speechEvents.onAgentSpeechStarted = cb;
+  }
+  get onAgentSpeechEnded() {
+    return this.speechEvents.onAgentSpeechEnded;
+  }
+  set onAgentSpeechEnded(cb) {
+    this.speechEvents.onAgentSpeechEnded = cb;
+  }
+  get onLlmToken() {
+    return this.speechEvents.onLlmToken;
+  }
+  set onLlmToken(cb) {
+    this.speechEvents.onLlmToken = cb;
+  }
+  get onAudioOut() {
+    return this.speechEvents.onAudioOut;
+  }
+  set onAudioOut(cb) {
+    this.speechEvents.onAudioOut = cb;
+  }
+  /**
+   * Snapshot of the current per-side state of the call.
+   * Mirrors LiveKit's `user_state_changed` / `agent_state_changed`
+   * payloads. Read-only and safe to call at any time.
+   */
+  get conversationState() {
+    return this.speechEvents.conversationState;
+  }
   /**
    * Live `MetricsStore` for the embedded server. Returns `null` before
    * `serve()` is called. Exposed so integrations like `PatterTool` can
@@ -158,6 +619,42 @@ var Patter = class {
   get metricsStore() {
     return this.embeddedServer?.metricsStore ?? null;
   }
+  /**
+   * Resolves to the public webhook hostname as soon as it is known —
+   * either statically configured or freshly minted by the tunnel.
+   *
+   * **Prefer `phone.ready` for outbound calls.** This promise resolves
+   * before the embedded HTTP / WebSocket server is in `listen` state, so
+   * a `phone.call` placed immediately afterwards can still race the
+   * Twilio Media Streams upgrade and produce a "11100 Invalid URL
+   * format" call drop on answer.
+   *
+   * Kept as a separate signal because some integrations (e.g. webhook
+   * registration) only need the hostname, not the WS server.
+   */
+  get tunnelReady() {
+    return this._tunnelReady;
+  }
+  /**
+   * Resolves to the public webhook hostname once the SDK is fully ready
+   * to handle carrier callbacks: tunnel resolved, carrier auto-config
+   * complete, and the embedded HTTP / WS server in `listen` state.
+   *
+   * Use this for outbound calls instead of guessing `setTimeout` after
+   * `void phone.serve(...)`:
+   *
+   * ```ts
+   * void phone.serve({ agent, tunnel: true });
+   * await phone.ready;
+   * await phone.call({ to: '+15550001234', agent });
+   * ```
+   *
+   * Rejects with the underlying exception if `serve()` fails before the
+   * server is listening.
+   */
+  get ready() {
+    return this._ready;
+  }
   constructor(options) {
     if (options.apiKey !== void 0) {
       throw new Error(
@@ -190,10 +687,27 @@ var Patter = class {
       phoneNumber: options.phoneNumber,
       webhookUrl: normalizedWebhook,
       tunnel: options.tunnel,
-      openaiKey: options.openaiKey
+      openaiKey: options.openaiKey,
+      persistRoot: resolvePersistRoot(options.persist)
     };
+    this._tunnelReady = new Promise((resolve, reject) => {
+      this._tunnelReadyResolve = resolve;
+      this._tunnelReadyReject = reject;
+    });
+    this._tunnelReady.catch(() => {
+    });
+    if (normalizedWebhook) {
+      this._tunnelReadyResolve(normalizedWebhook);
+    }
+    this._ready = new Promise((resolve, reject) => {
+      this._readyResolve = resolve;
+      this._readyReject = reject;
+    });
+    this._ready.catch(() => {
+    });
   }
   // === Agent definition ===
+  /** Resolve user-supplied agent options against engine defaults and return the merged config. */
   agent(opts) {
     let working = { ...opts };
     if (opts.engine) {
@@ -258,10 +772,23 @@ var Patter = class {
     if (working.variables !== void 0 && (typeof working.variables !== "object" || Array.isArray(working.variables))) {
       throw new TypeError("variables must be an object");
     }
+    if (working.tools) {
+      validateAllToolSchemas(working.tools);
+    }
     return working;
   }
   // === Serve / test / call ===
+  /** Boot the embedded HTTP/WebSocket server, configure the carrier webhook, and resolve `ready`. */
   async serve(opts) {
+    try {
+      await this._serveImpl(opts);
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      this._readyReject(e);
+      throw e;
+    }
+  }
+  async _serveImpl(opts) {
     if (!opts.agent || typeof opts.agent !== "object") {
       throw new TypeError("agent is required. Use phone.agent() to create one.");
     }
@@ -286,31 +813,44 @@ 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");
+    const { showBanner } = await import("./banner-UYW6UM3J.mjs");
     showBanner();
     if (wantsCloudflared) {
-      const { startTunnel: startTunnel2 } = await import("./tunnel-UVR3PPAU.mjs");
-      this.tunnelHandle = await startTunnel2(port);
-      webhookUrl = this.tunnelHandle.hostname;
-      this.localConfig = { ...this.localConfig, webhookUrl };
+      try {
+        const { startTunnel: startTunnel2 } = await import("./tunnel-43CHWPVQ.mjs");
+        this.tunnelHandle = await startTunnel2(port);
+        webhookUrl = this.tunnelHandle.hostname;
+        this.localConfig = { ...this.localConfig, webhookUrl };
+        this.tunnelOwnsWebhookUrl = true;
+        this._tunnelReadyResolve(webhookUrl);
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        this._tunnelReadyReject(e);
+        throw e;
+      }
     }
     if (!webhookUrl) {
-      throw new Error(
+      const err = new Error(
         "No webhookUrl configured. Either:\n  - Pass webhookUrl in the Patter constructor\n  - Use tunnel: true in serve() to auto-create a tunnel"
       );
+      this._tunnelReadyReject(err);
+      throw err;
     }
     const carrier = this.localConfig.carrier;
     const telephonyProvider = carrier.kind === "twilio" ? "twilio" : "telnyx";
-    const { autoConfigureCarrier } = await import("./carrier-config-33HQ2W4V.mjs");
-    await autoConfigureCarrier({
-      telephonyProvider,
-      twilioSid: carrier.kind === "twilio" ? carrier.accountSid : void 0,
-      twilioToken: carrier.kind === "twilio" ? carrier.authToken : void 0,
-      telnyxKey: carrier.kind === "telnyx" ? carrier.apiKey : void 0,
-      telnyxConnectionId: carrier.kind === "telnyx" ? carrier.connectionId : void 0,
-      phoneNumber: this.localConfig.phoneNumber,
-      webhookHost: webhookUrl
-    });
+    const wantsCarrierManagement = opts.manageWebhook !== false || wantsCloudflared;
+    if (wantsCarrierManagement) {
+      const { autoConfigureCarrier } = await import("./carrier-config-4ZKVYAWV.mjs");
+      await autoConfigureCarrier({
+        telephonyProvider,
+        twilioSid: carrier.kind === "twilio" ? carrier.accountSid : void 0,
+        twilioToken: carrier.kind === "twilio" ? carrier.authToken : void 0,
+        telnyxKey: carrier.kind === "telnyx" ? carrier.apiKey : void 0,
+        telnyxConnectionId: carrier.kind === "telnyx" ? carrier.connectionId : void 0,
+        phoneNumber: this.localConfig.phoneNumber,
+        webhookHost: webhookUrl
+      });
+    }
     this.embeddedServer = new EmbeddedServer(
       {
         twilioSid: carrier.kind === "twilio" ? carrier.accountSid : void 0,
@@ -321,7 +861,8 @@ var Patter = class {
         telephonyProvider,
         telnyxKey: carrier.kind === "telnyx" ? carrier.apiKey : void 0,
         telnyxConnectionId: carrier.kind === "telnyx" ? carrier.connectionId : void 0,
-        telnyxPublicKey: carrier.kind === "telnyx" ? carrier.publicKey : void 0
+        telnyxPublicKey: carrier.kind === "telnyx" ? carrier.publicKey : void 0,
+        persistRoot: this.localConfig.persistRoot
       },
       opts.agent,
       opts.onCallStart,
@@ -335,10 +876,21 @@ var Patter = class {
       opts.dashboard ?? true,
       opts.dashboardToken ?? ""
     );
-    await this.embeddedServer.start(port);
+    try {
+      await this.embeddedServer.start(port);
+      if (this.tunnelHandle) {
+        await waitForTunnelPubliclyReachable(webhookUrl);
+      }
+      this._readyResolve(webhookUrl);
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      this._readyReject(e);
+      throw e;
+    }
   }
+  /** Run the agent in interactive terminal-test mode (no real telephony). */
   async test(opts) {
-    const { TestSession: TestSession2 } = await import("./test-mode-MVJ3SKG4.mjs");
+    const { TestSession: TestSession2 } = await import("./test-mode-Y7YG5LFZ.mjs");
     const session = new TestSession2();
     await session.run({
       agent: opts.agent,
@@ -348,6 +900,7 @@ var Patter = class {
       onCallEnd: opts.onCallEnd
     });
   }
+  /** Place an outbound call via the configured carrier. */
   async call(options) {
     if (!options.to) {
       throw new Error("'to' phone number is required");
@@ -357,6 +910,10 @@ var Patter = class {
     }
     const { phoneNumber, webhookUrl, carrier } = this.localConfig;
     const effectiveRingTimeout = options.ringTimeout === void 0 ? 25 : options.ringTimeout;
+    const wantsAmd = options.machineDetection !== false || Boolean(options.voicemailMessage);
+    if (this.embeddedServer) {
+      this.embeddedServer.onMachineDetection = options.onMachineDetection;
+    }
     if (carrier.kind === "telnyx") {
       const telnyxKey = carrier.apiKey;
       const connectionId = carrier.connectionId;
@@ -365,6 +922,9 @@ var Patter = class {
         from: phoneNumber,
         to: options.to
       };
+      if (wantsAmd) {
+        telnyxPayload.answering_machine_detection = "greeting_end";
+      }
       if (effectiveRingTimeout !== null && effectiveRingTimeout !== void 0) {
         telnyxPayload.timeout_secs = Math.max(1, Math.floor(effectiveRingTimeout));
       }
@@ -407,12 +967,12 @@ var Patter = class {
       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"
+      StatusCallbackMethod: "POST"
     });
-    if (options.machineDetection) {
+    for (const evt of ["initiated", "ringing", "answered", "completed"]) {
+      params.append("StatusCallbackEvent", evt);
+    }
+    if (wantsAmd) {
       params.append("MachineDetection", "DetectMessageEnd");
       params.append("AsyncAmd", "true");
       params.append("AsyncAmdStatusCallback", `https://${webhookUrl}/webhooks/twilio/amd`);
@@ -445,11 +1005,22 @@ var Patter = class {
             callee: options.to,
             direction: "outbound"
           });
+          const notificationsPath = body.subresource_uris?.notifications;
+          if (notificationsPath) {
+            getLogger().info(
+              `Outbound call ${callSid} placed. Twilio notifications: https://api.twilio.com${notificationsPath} (check here if the call drops with no audio).`
+            );
+          }
         }
       } catch {
       }
     }
   }
+  /**
+   * Stop the embedded server and any running tunnel. Safe to call multiple
+   * times. Leaves the instance reusable: a subsequent ``serve()`` works as
+   * if the previous lifecycle never happened.
+   */
   async disconnect() {
     if (this.tunnelHandle) {
       this.tunnelHandle.stop();
@@ -459,10 +1030,116 @@ var Patter = class {
       await this.embeddedServer.stop();
       this.embeddedServer = null;
     }
+    if (this.tunnelOwnsWebhookUrl) {
+      this.localConfig = { ...this.localConfig, webhookUrl: void 0 };
+      this.tunnelOwnsWebhookUrl = false;
+    }
+    this._tunnelReady = new Promise((resolve, reject) => {
+      this._tunnelReadyResolve = resolve;
+      this._tunnelReadyReject = reject;
+    });
+    this._tunnelReady.catch(() => {
+    });
+    if (this.localConfig.webhookUrl) {
+      this._tunnelReadyResolve(this.localConfig.webhookUrl);
+    }
+    this._ready = new Promise((resolve, reject) => {
+      this._readyResolve = resolve;
+      this._readyReject = reject;
+    });
+    this._ready.catch(() => {
+    });
+  }
+  /**
+   * Terminate an active call on the configured carrier.
+   *
+   * Posts a hangup to the carrier (Twilio
+   * ``Calls(callSid).update({status:'completed'})`` or Telnyx
+   * ``/v2/calls/{callControlId}/actions/hangup``) so the bridge tears down
+   * gracefully — the SDK's WebSocket handler then fires ``onCallEnd`` with
+   * the final ``CallMetrics`` before the WS closes.
+   *
+   * Use this when the host application needs to end a call programmatically
+   * without going through the LLM tool-call path (e.g. an admin override,
+   * a watchdog, or an integration test runner).
+   *
+   * @param callSid - Carrier-issued call identifier (Twilio Call SID or
+   *   Telnyx call_control_id) returned from a previous ``call(...)`` or
+   *   captured in the ``onCallStart`` callback's payload.
+   * @throws Error when ``callSid`` is empty or no carrier is configured.
+   */
+  async endCall(callSid) {
+    if (!callSid) {
+      throw new Error("callSid must be a non-empty string");
+    }
+    const carrier = this.localConfig.carrier;
+    if (carrier.kind === "twilio") {
+      const auth = Buffer.from(`${carrier.accountSid}:${carrier.authToken}`).toString("base64");
+      const url = `https://api.twilio.com/2010-04-01/Accounts/${carrier.accountSid}/Calls/${callSid}.json`;
+      const body = new URLSearchParams({ Status: "completed" });
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Basic ${auth}`,
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body
+      });
+      if (!res.ok) {
+        throw new Error(`Twilio hangup failed: ${res.status} ${await res.text()}`);
+      }
+      return;
+    }
+    if (carrier.kind === "telnyx") {
+      const res = await fetch(`https://api.telnyx.com/v2/calls/${callSid}/actions/hangup`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${carrier.apiKey}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!res.ok) {
+        throw new Error(`Telnyx hangup failed: ${res.status} ${await res.text()}`);
+      }
+      return;
+    }
+    throw new Error(`endCall() requires a configured carrier; got kind=${carrier.kind}`);
   }
 };
+async function waitForTunnelPubliclyReachable(hostname, totalTimeoutMs = 6e4, graceMs = 5e3) {
+  const log = getLogger();
+  const { Resolver } = await import("dns/promises");
+  const resolver = new Resolver({ timeout: 1500, tries: 1 });
+  resolver.setServers(["1.1.1.1", "8.8.8.8"]);
+  const deadline = Date.now() + totalTimeoutMs;
+  let attempt = 0;
+  let lastErr;
+  while (Date.now() < deadline) {
+    attempt += 1;
+    try {
+      const records = await resolver.resolve4(hostname);
+      const first = records[0] ?? "<unknown>";
+      log.info(
+        "Tunnel DNS resolved \u2192 %s (attempt %d); waiting %d ms grace",
+        first,
+        attempt,
+        graceMs
+      );
+      await new Promise((r) => setTimeout(r, graceMs));
+      return;
+    } catch (err) {
+      lastErr = err;
+    }
+    const delay = Math.min(250 * Math.pow(1.6, attempt - 1), 2e3);
+    await new Promise((r) => setTimeout(r, delay));
+  }
+  throw new Error(
+    `Tunnel hostname ${hostname} did not resolve within ${totalTimeoutMs}ms. Last error: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`
+  );
+}
 
-// src/tool-decorator.ts
+// src/tools/tool-decorator.ts
+init_esm_shims();
 function defineTool(input) {
   const properties = {};
   const required = [];
@@ -492,6 +1169,7 @@ function defineTool(input) {
 }
 
 // src/text-transforms.ts
+init_esm_shims();
 function filterMarkdown(text) {
   let result = text;
   result = result.replace(/```[\s\S]*?```/g, (match) => {
@@ -524,6 +1202,7 @@ function filterForTTS(text) {
 }
 
 // src/providers.ts
+init_esm_shims();
 var STTConfigImpl = class {
   provider;
   apiKey;
@@ -581,10 +1260,8 @@ function openaiTts(opts) {
 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 speechmatics(opts) {
+  return new STTConfigImpl("speechmatics", opts.apiKey, opts.language ?? "en");
 }
 function assemblyai(opts) {
   return new STTConfigImpl("assemblyai", opts.apiKey, opts.language ?? "en");
@@ -620,6 +1297,7 @@ function geminiLive(opts) {
 }
 
 // src/fallback-provider.ts
+init_esm_shims();
 var AllProvidersFailedError = class extends Error {
   constructor(message) {
     super(message);
@@ -698,6 +1376,7 @@ var FallbackLLMProvider = class {
   // -----------------------------------------------------------------------
   // LLMProvider implementation
   // -----------------------------------------------------------------------
+  /** Streaming entry point — yields chunks from the first provider that succeeds. */
   async *stream(messages, tools) {
     const errors = [];
     const result = yield* this.tryProviders(
@@ -816,7 +1495,11 @@ var FallbackLLMProvider = class {
   }
 };
 
+// src/integrations/index.ts
+init_esm_shims();
+
 // src/integrations/patter-tool.ts
+init_esm_shims();
 import { EventEmitter } from "events";
 var PARAMETERS_SCHEMA = {
   type: "object",
@@ -970,6 +1653,7 @@ var PatterTool = class _PatterTool {
     this.started = false;
   }
   // --- Execution ----------------------------------------------------------
+  /** Place an outbound call and resolve once it ends with the transcript and metrics. */
   async execute(args) {
     if (!this.started) await this.start();
     if (!args || typeof args.to !== "string" || !args.to.startsWith("+")) {
@@ -1079,6 +1763,7 @@ var PatterTool = class _PatterTool {
 };
 
 // src/providers/gemini-live.ts
+init_esm_shims();
 var GEMINI_DEFAULT_INPUT_SR = 16e3;
 var GEMINI_DEFAULT_OUTPUT_SR = 24e3;
 var GeminiLiveAdapter = class {
@@ -1093,6 +1778,7 @@ var GeminiLiveAdapter = class {
     this.outputSampleRate = options.outputSampleRate ?? GEMINI_DEFAULT_OUTPUT_SR;
     this.temperature = options.temperature ?? 0.8;
   }
+  apiKey;
   model;
   voice;
   instructions;
@@ -1113,6 +1799,7 @@ var GeminiLiveAdapter = class {
    * not the call_id).
    */
   pendingToolCalls = /* @__PURE__ */ new Map();
+  /** Lazily import @google/genai, open a Live session, and start the receive loop. */
   async connect() {
     let genaiModule;
     try {
@@ -1160,6 +1847,7 @@ var GeminiLiveAdapter = class {
       getLogger().error(`Gemini Live receive loop error: ${String(err)}`);
     });
   }
+  /** Send a PCM audio chunk to Gemini as base64 inline data. */
   sendAudio(pcm) {
     if (!this.session || !this.running) return;
     const mime = `audio/pcm;rate=${this.inputSampleRate}`;
@@ -1173,6 +1861,7 @@ var GeminiLiveAdapter = class {
       );
     }
   }
+  /** Send a text turn to Gemini and mark the turn complete. */
   async sendText(text) {
     if (!this.session) return;
     const sess = this.session;
@@ -1181,6 +1870,7 @@ var GeminiLiveAdapter = class {
       turnComplete: true
     });
   }
+  /** Send a tool/function-call result back to Gemini. */
   async sendFunctionResult(callId, result) {
     if (!this.session) return;
     const sess = this.session;
@@ -1192,9 +1882,11 @@ var GeminiLiveAdapter = class {
       ]
     });
   }
+  /** No-op — Gemini Live barge-in is VAD-driven, not client-cancelled. */
   cancelResponse() {
     getLogger().debug("Gemini Live: cancelResponse is implicit via VAD");
   }
+  /** Register an event handler that receives every Gemini Live event. */
   onEvent(handler) {
     this.handlers.push(handler);
   }
@@ -1251,6 +1943,7 @@ var GeminiLiveAdapter = class {
       this.running = false;
     }
   }
+  /** Close the Gemini Live session and stop the receive loop. */
   async close() {
     this.running = false;
     if (this.session) {
@@ -1271,6 +1964,7 @@ var GeminiLiveAdapter = class {
 };
 
 // src/providers/ultravox-realtime.ts
+init_esm_shims();
 import WebSocket from "ws";
 var ULTRAVOX_DEFAULT_API_BASE = "https://api.ultravox.ai/api";
 var ULTRAVOX_DEFAULT_SR = 16e3;
@@ -1286,6 +1980,7 @@ var UltravoxRealtimeAdapter = class {
     this.sampleRate = options.sampleRate ?? ULTRAVOX_DEFAULT_SR;
     this.firstMessage = options.firstMessage ?? "";
   }
+  apiKey;
   model;
   voice;
   instructions;
@@ -1298,6 +1993,7 @@ var UltravoxRealtimeAdapter = class {
   handlers = [];
   /** Exposed for diagnostics — true while the underlying socket is open. */
   running = false;
+  /** Create the Ultravox call, fetch the joinUrl, and open the WebSocket. */
   async connect() {
     const body = {
       model: this.model,
@@ -1367,14 +2063,17 @@ var UltravoxRealtimeAdapter = class {
       this.running = false;
     });
   }
+  /** Send a binary PCM audio chunk to the Ultravox call. */
   sendAudio(pcm) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
     this.ws.send(pcm, { binary: true });
   }
+  /** Inject a user text message into the Ultravox conversation. */
   async sendText(text) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
     this.ws.send(JSON.stringify({ type: "input_text_message", text }));
   }
+  /** Send a tool/function-call result back to Ultravox. */
   async sendFunctionResult(callId, result) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
     this.ws.send(
@@ -1386,10 +2085,12 @@ var UltravoxRealtimeAdapter = class {
       })
     );
   }
+  /** Clear the playback buffer to interrupt the agent's current response. */
   cancelResponse() {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
     this.ws.send(JSON.stringify({ type: "playback_clear_buffer" }));
   }
+  /** Register an event handler that receives every Ultravox event. */
   onEvent(handler) {
     this.handlers.push(handler);
   }
@@ -1436,6 +2137,7 @@ var UltravoxRealtimeAdapter = class {
       await this.emit("speech_started", null);
     }
   }
+  /** Close the Ultravox WebSocket and mark the adapter idle. */
   async close() {
     this.running = false;
     if (this.ws) {
@@ -1461,6 +2163,7 @@ function toolParamsToUltravox(parameters) {
 }
 
 // src/scheduler.ts
+init_esm_shims();
 var cronModule = null;
 var loadError = null;
 async function loadCron() {
@@ -1469,7 +2172,7 @@ async function loadCron() {
   try {
     const imported = await import(
       /* @vite-ignore */
-      "./node-cron-6PRPSBG5.mjs"
+      "./node-cron-JFWQQRBU.mjs"
     );
     cronModule = imported && imported.default ? imported.default : imported;
     return cronModule;
@@ -1576,6 +2279,7 @@ function scheduleInterval(intervalOrOpts, callback) {
 }
 
 // src/stt/deepgram.ts
+init_esm_shims();
 var STT = class extends DeepgramSTT {
   static providerKey = "deepgram";
   constructor(opts = {}) {
@@ -1602,7 +2306,11 @@ var STT = class extends DeepgramSTT {
   }
 };
 
+// src/stt/whisper.ts
+init_esm_shims();
+
 // src/providers/whisper-stt.ts
+init_esm_shims();
 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"]);
@@ -1666,11 +2374,13 @@ var WhisperSTT = class _WhisperSTT {
   static forTwilio(apiKey, language = "en", model = "whisper-1") {
     return new _WhisperSTT(apiKey, language, model);
   }
+  /** Reset the audio buffer and arm the adapter for incoming chunks. */
   async connect() {
     this.running = true;
     this.chunks = [];
     this.bufferedBytes = 0;
   }
+  /** Buffer a PCM16 chunk; flushes to Whisper once `bufferSize` bytes are reached. */
   sendAudio(audio) {
     if (!this.running) return;
     this.chunks.push(audio);
@@ -1701,9 +2411,11 @@ var WhisperSTT = class _WhisperSTT {
   onTranscript(callback) {
     this.callbacks.add(callback);
   }
+  /** Remove a previously registered transcript listener. */
   offTranscript(callback) {
     this.callbacks.delete(callback);
   }
+  /** Flush any buffered audio, await pending transcriptions, and clear listeners. */
   async close() {
     this.running = false;
     if (this.bufferedBytes > 0) {
@@ -1781,7 +2493,11 @@ var STT2 = class extends WhisperSTT {
   }
 };
 
+// src/stt/openai-transcribe.ts
+init_esm_shims();
+
 // src/providers/openai-transcribe-stt.ts
+init_esm_shims();
 var ALLOWED_MODELS2 = /* @__PURE__ */ new Set(["gpt-4o-transcribe", "gpt-4o-mini-transcribe"]);
 var DEFAULT_BUFFER_SIZE2 = 16e3 * 2;
 var OpenAITranscribeSTT = class extends WhisperSTT {
@@ -1817,11 +2533,37 @@ var STT3 = class extends OpenAITranscribeSTT {
   }
 };
 
+// src/stt/cartesia.ts
+init_esm_shims();
+
 // src/providers/cartesia-stt.ts
+init_esm_shims();
 import WebSocket2 from "ws";
+var CartesiaSTTModel = {
+  INK_WHISPER: "ink-whisper"
+};
+var CartesiaSTTEncoding = {
+  PCM_S16LE: "pcm_s16le"
+};
+var CartesiaSTTSampleRate = {
+  HZ_8000: 8e3,
+  HZ_16000: 16e3,
+  HZ_24000: 24e3,
+  HZ_44100: 44100,
+  HZ_48000: 48e3
+};
+var CartesiaSTTServerEvent = {
+  TRANSCRIPT: "transcript",
+  FLUSH_DONE: "flush_done",
+  DONE: "done",
+  ERROR: "error"
+};
+var CartesiaSTTClientFrame = {
+  FINALIZE: "finalize"
+};
 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 USER_AGENT = "Patter/1.0";
 var KEEPALIVE_INTERVAL_MS = 3e4;
 var CONNECT_TIMEOUT_MS = 1e4;
 var CartesiaSTT = class {
@@ -1832,6 +2574,8 @@ var CartesiaSTT = class {
       throw new Error("CartesiaSTT requires a non-empty apiKey");
     }
   }
+  apiKey;
+  options;
   ws = null;
   callbacks = /* @__PURE__ */ new Set();
   keepaliveTimer = null;
@@ -1855,15 +2599,16 @@ var CartesiaSTT = class {
     }
     const language = opts.language ?? "en";
     const params = new URLSearchParams({
-      model: opts.model ?? "ink-whisper",
-      sample_rate: String(opts.sampleRate ?? 16e3),
-      encoding: opts.encoding ?? "pcm_s16le",
+      model: opts.model ?? CartesiaSTTModel.INK_WHISPER,
+      sample_rate: String(opts.sampleRate ?? CartesiaSTTSampleRate.HZ_16000),
+      encoding: opts.encoding ?? CartesiaSTTEncoding.PCM_S16LE,
       cartesia_version: API_VERSION,
       api_key: this.apiKey,
       language
     });
     return `${base}/stt/websocket?${params.toString()}`;
   }
+  /** Open the streaming WebSocket and arm message + keepalive handlers. */
   async connect() {
     const url = this.buildWsUrl();
     this.ws = new WebSocket2(url, {
@@ -1903,7 +2648,7 @@ var CartesiaSTT = class {
   }
   handleEvent(event) {
     const type = event.type;
-    if (type === "transcript") {
+    if (type === CartesiaSTTServerEvent.TRANSCRIPT) {
       const text = (event.text ?? "").trim();
       const isFinal = Boolean(event.is_final);
       if (!text && !isFinal) return;
@@ -1915,7 +2660,7 @@ var CartesiaSTT = class {
       this.emit({ text, isFinal, confidence });
       return;
     }
-    if (type === "error") {
+    if (type === CartesiaSTTServerEvent.ERROR) {
       getLogger().error(`Cartesia STT error: ${event.message ?? "unknown"}`);
       return;
     }
@@ -1925,10 +2670,12 @@ var CartesiaSTT = class {
       cb(transcript);
     }
   }
+  /** Send a binary PCM16-LE audio chunk to Cartesia for transcription. */
   sendAudio(audio) {
     if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) return;
     this.ws.send(audio);
   }
+  /** Register a transcript listener. */
   onTranscript(callback) {
     this.callbacks.add(callback);
   }
@@ -1951,7 +2698,7 @@ var CartesiaSTT = class {
     }
     if (this.ws) {
       try {
-        this.ws.send("finalize");
+        this.ws.send(CartesiaSTTClientFrame.FINALIZE);
       } catch {
       }
       this.ws.close();
@@ -1974,7 +2721,7 @@ var CartesiaSTT = class {
     if (ws.readyState === WebSocket2.OPEN) {
       try {
         await new Promise((resolve) => {
-          ws.send("finalize", (err) => {
+          ws.send(CartesiaSTTClientFrame.FINALIZE, (err) => {
             if (err) getLogger().warn(`CartesiaSTT finalize send failed: ${String(err)}`);
             resolve();
           });
@@ -2022,12 +2769,33 @@ var STT4 = class extends CartesiaSTT {
   }
 };
 
+// src/stt/soniox.ts
+init_esm_shims();
+
 // src/providers/soniox-stt.ts
+init_esm_shims();
 import WebSocket3 from "ws";
 var SONIOX_WS_URL = "wss://stt-rt.soniox.com/transcribe-websocket";
-var KEEPALIVE_MESSAGE = '{"type": "keepalive"}';
-var END_TOKEN = "<end>";
-var FINALIZED_TOKEN = "<fin>";
+var SonioxModel = {
+  STT_RT_V4: "stt-rt-v4",
+  STT_RT_V3: "stt-rt-v3",
+  STT_RT_V2: "stt-rt-v2"
+};
+var SonioxSampleRate = {
+  HZ_8000: 8e3,
+  HZ_16000: 16e3,
+  HZ_24000: 24e3
+};
+var SonioxClientFrame = {
+  KEEPALIVE: "keepalive"
+};
+var SonioxEndpointToken = {
+  END: "<end>",
+  FIN: "<fin>"
+};
+var KEEPALIVE_MESSAGE = JSON.stringify({ type: SonioxClientFrame.KEEPALIVE });
+var END_TOKEN = SonioxEndpointToken.END;
+var FINALIZED_TOKEN = SonioxEndpointToken.FIN;
 var KEEPALIVE_INTERVAL_MS2 = 5e3;
 function isEndToken(token) {
   return token.text === END_TOKEN || token.text === FINALIZED_TOKEN;
@@ -2082,10 +2850,10 @@ var SonioxSTT = class _SonioxSTT {
       throw new Error("maxEndpointDelayMs must be between 500 and 3000");
     }
     this.apiKey = apiKey;
-    this.model = options.model ?? "stt-rt-v4";
+    this.model = options.model ?? SonioxModel.STT_RT_V4;
     this.languageHints = options.languageHints;
     this.languageHintsStrict = options.languageHintsStrict ?? false;
-    this.sampleRate = options.sampleRate ?? 16e3;
+    this.sampleRate = options.sampleRate ?? SonioxSampleRate.HZ_16000;
     this.numChannels = options.numChannels ?? 1;
     this.enableSpeakerDiarization = options.enableSpeakerDiarization ?? false;
     this.enableLanguageIdentification = options.enableLanguageIdentification ?? true;
@@ -2095,7 +2863,10 @@ var SonioxSTT = class _SonioxSTT {
   }
   /** Factory for Twilio-style 8 kHz linear PCM. */
   static forTwilio(apiKey, languageHints) {
-    return new _SonioxSTT(apiKey, { sampleRate: 8e3, languageHints });
+    return new _SonioxSTT(apiKey, {
+      sampleRate: SonioxSampleRate.HZ_8000,
+      languageHints
+    });
   }
   buildConfig() {
     const config = {
@@ -2118,6 +2889,7 @@ var SonioxSTT = class _SonioxSTT {
     }
     return config;
   }
+  /** Open the streaming WebSocket and send the initial config payload. */
   async connect() {
     this.final.reset();
     this.ws = new WebSocket3(this.baseUrl);
@@ -2211,11 +2983,13 @@ var SonioxSTT = class _SonioxSTT {
       cb(transcript);
     }
   }
+  /** Send a binary PCM16-LE audio chunk to Soniox for transcription. */
   sendAudio(audio) {
     if (!this.ws || this.ws.readyState !== WebSocket3.OPEN) return;
     if (audio.length === 0) return;
     this.ws.send(audio);
   }
+  /** Register a transcript listener (max 10 concurrent listeners). */
   onTranscript(callback) {
     if (this.callbacks.length >= 10) {
       getLogger().warn(
@@ -2226,6 +3000,7 @@ var SonioxSTT = class _SonioxSTT {
     }
     this.callbacks.push(callback);
   }
+  /** Send the empty-frame stream terminator and close the WebSocket. */
   close() {
     this.clearKeepalive();
     if (this.ws) {
@@ -2258,8 +3033,41 @@ var STT5 = class extends SonioxSTT {
   }
 };
 
+// src/stt/assemblyai.ts
+init_esm_shims();
+
 // src/providers/assemblyai-stt.ts
+init_esm_shims();
 import WebSocket4 from "ws";
+var AssemblyAIEncoding = {
+  PCM_S16LE: "pcm_s16le",
+  PCM_MULAW: "pcm_mulaw"
+};
+var AssemblyAIModel = {
+  UNIVERSAL_STREAMING_ENGLISH: "universal-streaming-english",
+  UNIVERSAL_STREAMING_MULTILINGUAL: "universal-streaming-multilingual",
+  U3_RT_PRO: "u3-rt-pro",
+  WHISPER_RT: "whisper-rt"
+};
+var AssemblyAIDomain = {
+  GENERAL: "general",
+  MEDICAL_V1: "medical-v1"
+};
+var AssemblyAISampleRate = {
+  HZ_8000: 8e3,
+  HZ_16000: 16e3
+};
+var AssemblyAIEventType = {
+  BEGIN: "Begin",
+  TURN: "Turn",
+  SPEECH_STARTED: "SpeechStarted",
+  TERMINATION: "Termination"
+};
+var AssemblyAIClientFrame = {
+  UPDATE_CONFIGURATION: "UpdateConfiguration",
+  FORCE_ENDPOINT: "ForceEndpoint",
+  TERMINATE: "Terminate"
+};
 var DEFAULT_BASE_URL2 = "wss://streaming.assemblyai.com";
 var DEFAULT_MIN_TURN_SILENCE_MS = 400;
 var CONNECT_TIMEOUT_MS2 = 1e4;
@@ -2267,7 +3075,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 VALID_DOMAINS = /* @__PURE__ */ new Set([
+  AssemblyAIDomain.GENERAL,
+  AssemblyAIDomain.MEDICAL_V1
+]);
 var AssemblyAISTTNotConnectedError = class extends Error {
   constructor(message = "AssemblyAISTT is not connected") {
     super(message);
@@ -2290,38 +3101,56 @@ var AssemblyAISTT = class _AssemblyAISTT {
       );
     }
   }
+  apiKey;
+  options;
   ws = null;
   callbacks = /* @__PURE__ */ new Set();
   closing = false;
   reconnectAttempts = 0;
   terminationResolve = null;
-  /** AssemblyAI session id — set when the `Begin` message arrives. */
+  /**
+   * Coalescing buffer for inbound audio frames. AssemblyAI's v3
+   * streaming endpoint requires each ws frame to carry 50–1000 ms of
+   * audio (server emits error 3007 below 50 ms — observed in the
+   * field as a fully-billed call with zero transcripts). Twilio sends
+   * 20 ms frames, so the SDK must batch ~3 frames before forwarding.
+   *
+   * We accumulate raw bytes here until the cumulative duration crosses
+   * the configured target (default 60 ms — comfortably above the 50 ms
+   * floor with one frame of headroom against jitter), then flush in a
+   * single `ws.send()`.
+   */
+  chunkBuffer = [];
+  chunkBufferBytes = 0;
+  /** Target send size in bytes — recomputed lazily once encoding/sample-rate is known. */
+  chunkBufferTargetBytes = 0;
+  /** AssemblyAI session id — set when the `Begin` message arrives. */
   sessionId = null;
   /** Unix timestamp when the AssemblyAI session expires. */
   expiresAt = null;
   /** Factory for Twilio calls — mulaw 8 kHz. */
-  static forTwilio(apiKey, model = "universal-streaming-english") {
+  static forTwilio(apiKey, model = AssemblyAIModel.UNIVERSAL_STREAMING_ENGLISH) {
     return new _AssemblyAISTT(apiKey, {
       model,
-      encoding: "pcm_mulaw",
-      sampleRate: 8e3
+      encoding: AssemblyAIEncoding.PCM_MULAW,
+      sampleRate: AssemblyAISampleRate.HZ_8000
     });
   }
   buildUrl() {
     const opts = this.options;
-    const model = opts.model ?? "universal-streaming-english";
-    const encoding = opts.encoding ?? "pcm_s16le";
-    const sampleRate = opts.sampleRate ?? 16e3;
+    const model = opts.model ?? AssemblyAIModel.UNIVERSAL_STREAMING_ENGLISH;
+    const encoding = opts.encoding ?? AssemblyAIEncoding.PCM_S16LE;
+    const sampleRate = opts.sampleRate ?? AssemblyAISampleRate.HZ_16000;
     let minSilence;
     let maxSilence;
-    if (model === "u3-rt-pro") {
+    if (model === AssemblyAIModel.U3_RT_PRO) {
       minSilence = opts.minTurnSilence ?? 100;
       maxSilence = opts.maxTurnSilence ?? minSilence;
     } else {
       minSilence = opts.minTurnSilence ?? DEFAULT_MIN_TURN_SILENCE_MS;
       maxSilence = opts.maxTurnSilence;
     }
-    const languageDetection = opts.languageDetection ?? (model.includes("multilingual") || model === "u3-rt-pro");
+    const languageDetection = opts.languageDetection ?? (model.includes("multilingual") || model === AssemblyAIModel.U3_RT_PRO);
     const raw = {
       sample_rate: sampleRate,
       encoding,
@@ -2363,6 +3192,7 @@ var AssemblyAISTT = class _AssemblyAISTT {
     }
     return headers;
   }
+  /** Open the streaming WebSocket and arm message handlers. */
   async connect() {
     this.closing = false;
     const url = this.buildUrl();
@@ -2416,28 +3246,28 @@ var AssemblyAISTT = class _AssemblyAISTT {
   }
   handleEvent(event) {
     const type = event.type;
-    if (type === "Begin") {
+    if (type === AssemblyAIEventType.BEGIN) {
       this.sessionId = event.id ?? null;
       this.expiresAt = event.expires_at ?? null;
       return;
     }
-    if (type === "Termination") {
+    if (type === AssemblyAIEventType.TERMINATION) {
       if (this.terminationResolve) {
         this.terminationResolve();
         this.terminationResolve = null;
       }
       return;
     }
-    if (type === "SpeechStarted") {
+    if (type === AssemblyAIEventType.SPEECH_STARTED) {
       this.emit({
         text: "",
         isFinal: false,
         confidence: 0,
-        eventType: "SpeechStarted"
+        eventType: AssemblyAIEventType.SPEECH_STARTED
       });
       return;
     }
-    if (type !== "Turn") {
+    if (type !== AssemblyAIEventType.TURN) {
       return;
     }
     const endOfTurn = Boolean(event.end_of_turn);
@@ -2468,25 +3298,49 @@ var AssemblyAISTT = class _AssemblyAISTT {
       cb(transcript);
     }
   }
+  /** Send a binary PCM/mu-law audio chunk to AssemblyAI for transcription. */
   sendAudio(audio) {
     if (!this.ws || this.ws.readyState !== WebSocket4.OPEN) {
-      throw new AssemblyAISTTNotConnectedError(
-        "AssemblyAISTT.sendAudio: WebSocket is not open"
-      );
+      return;
     }
-    const durationMs = this.estimateChunkDurationMs(audio.length);
+    if (this.chunkBufferTargetBytes === 0) {
+      this.chunkBufferTargetBytes = this.computeTargetChunkBytes();
+    }
+    this.chunkBuffer.push(audio);
+    this.chunkBufferBytes += audio.length;
+    if (this.chunkBufferBytes < this.chunkBufferTargetBytes) {
+      return;
+    }
+    const merged = Buffer.concat(this.chunkBuffer, this.chunkBufferBytes);
+    this.chunkBuffer = [];
+    this.chunkBufferBytes = 0;
+    const durationMs = this.estimateChunkDurationMs(merged.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);
+    this.ws.send(merged);
+  }
+  /**
+   * Compute the byte count corresponding to ~60 ms of audio for the
+   * configured encoding / sample rate. Sits one Twilio frame (20 ms)
+   * above AssemblyAI's 50 ms floor so jitter never dips below.
+   */
+  computeTargetChunkBytes() {
+    const targetMs = 60;
+    const encoding = this.options.encoding ?? AssemblyAIEncoding.PCM_S16LE;
+    const sampleRate = this.options.sampleRate ?? AssemblyAISampleRate.HZ_16000;
+    if (encoding === AssemblyAIEncoding.PCM_MULAW) {
+      return Math.ceil(sampleRate * targetMs / 1e3);
+    }
+    return Math.ceil(sampleRate * targetMs / 1e3) * 2;
   }
   estimateChunkDurationMs(byteLength) {
     if (byteLength <= 0) return null;
-    const sampleRate = this.options.sampleRate ?? 16e3;
+    const sampleRate = this.options.sampleRate ?? AssemblyAISampleRate.HZ_16000;
     if (sampleRate <= 0) return null;
-    const bytesPerSample = (this.options.encoding ?? "pcm_s16le") === "pcm_s16le" ? 2 : 1;
+    const bytesPerSample = (this.options.encoding ?? AssemblyAIEncoding.PCM_S16LE) === AssemblyAIEncoding.PCM_S16LE ? 2 : 1;
     const samples = byteLength / bytesPerSample;
     return samples / sampleRate * 1e3;
   }
@@ -2500,7 +3354,9 @@ var AssemblyAISTT = class _AssemblyAISTT {
         "AssemblyAISTT.updateConfiguration: WebSocket is not open"
       );
     }
-    const payload = { type: "UpdateConfiguration" };
+    const payload = {
+      type: AssemblyAIClientFrame.UPDATE_CONFIGURATION
+    };
     if (params.keytermsPrompt !== void 0) {
       payload.keyterms_prompt = JSON.stringify(params.keytermsPrompt);
     }
@@ -2522,19 +3378,21 @@ var AssemblyAISTT = class _AssemblyAISTT {
         "AssemblyAISTT.forceEndpoint: WebSocket is not open"
       );
     }
-    this.ws.send(JSON.stringify({ type: "ForceEndpoint" }));
+    this.ws.send(JSON.stringify({ type: AssemblyAIClientFrame.FORCE_ENDPOINT }));
   }
+  /** Register a transcript listener. Returns an unsubscribe function. */
   onTranscript(callback) {
     this.callbacks.add(callback);
     return () => {
       this.callbacks.delete(callback);
     };
   }
+  /** Send a Terminate frame, wait briefly for ack, and close the socket. */
   async close() {
     this.closing = true;
     if (!this.ws) return;
     try {
-      this.ws.send(JSON.stringify({ type: "Terminate" }));
+      this.ws.send(JSON.stringify({ type: AssemblyAIClientFrame.TERMINATE }));
     } catch {
     }
     await new Promise((resolve) => {
@@ -2573,13 +3431,361 @@ var STT6 = class extends AssemblyAISTT {
         "AssemblyAI STT requires an apiKey. Pass { apiKey: '...' } or set ASSEMBLYAI_API_KEY in the environment."
       );
     }
-    const { apiKey: _ignored, ...rest } = opts;
+    const { apiKey: _ignored, language: _lang, ...rest } = opts;
     void _ignored;
+    void _lang;
     super(key, rest);
   }
 };
 
+// src/stt/speechmatics.ts
+init_esm_shims();
+
+// src/providers/speechmatics-stt.ts
+init_esm_shims();
+import WebSocket5 from "ws";
+var SPEECHMATICS_RT_URL = "wss://eu.rt.speechmatics.com/v2";
+var CONNECT_TIMEOUT_MS3 = 1e4;
+var TurnDetectionMode = {
+  EXTERNAL: "external",
+  FIXED: "fixed",
+  ADAPTIVE: "adaptive",
+  SMART_TURN: "smart_turn"
+};
+var SpeechmaticsSampleRate = {
+  HZ_8000: 8e3,
+  HZ_16000: 16e3,
+  HZ_44100: 44100
+};
+var SpeechmaticsAudioEncoding = {
+  PCM_S16LE: "pcm_s16le"
+};
+var SpeechmaticsOperatingPoint = {
+  ENHANCED: "enhanced",
+  STANDARD: "standard"
+};
+var SpeechmaticsServerMessage = {
+  RECOGNITION_STARTED: "RecognitionStarted",
+  ADD_PARTIAL_TRANSCRIPT: "AddPartialTranscript",
+  ADD_TRANSCRIPT: "AddTranscript",
+  END_OF_UTTERANCE: "EndOfUtterance",
+  END_OF_TRANSCRIPT: "EndOfTranscript",
+  AUDIO_ADDED: "AudioAdded",
+  INFO: "Info",
+  WARNING: "Warning",
+  ERROR: "Error"
+};
+var SpeechmaticsSTT = class {
+  ws = null;
+  transcriptCallbacks = /* @__PURE__ */ new Set();
+  errorCallbacks = /* @__PURE__ */ new Set();
+  running = false;
+  /** Sequence number of the last audio chunk acknowledged via `AudioAdded`. */
+  lastSeqNo = 0;
+  apiKey;
+  baseUrl;
+  language;
+  turnDetectionMode;
+  sampleRate;
+  enableDiarization;
+  maxDelay;
+  endOfUtteranceSilenceTrigger;
+  endOfUtteranceMaxDelay;
+  includePartials;
+  additionalVocab;
+  operatingPoint;
+  domain;
+  outputLocale;
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new Error("Speechmatics apiKey is required");
+    }
+    const eouSilence = options.endOfUtteranceSilenceTrigger;
+    const eouMax = options.endOfUtteranceMaxDelay;
+    const maxDelay = options.maxDelay;
+    if (eouSilence !== void 0 && !(eouSilence > 0 && eouSilence < 2)) {
+      throw new Error("endOfUtteranceSilenceTrigger must be between 0 and 2");
+    }
+    if (eouMax !== void 0 && eouSilence !== void 0 && eouMax <= eouSilence) {
+      throw new Error(
+        "endOfUtteranceMaxDelay must be greater than endOfUtteranceSilenceTrigger"
+      );
+    }
+    if (maxDelay !== void 0 && !(maxDelay >= 0.7 && maxDelay <= 4)) {
+      throw new Error("maxDelay must be between 0.7 and 4.0");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = options.baseUrl ?? SPEECHMATICS_RT_URL;
+    this.language = options.language ?? "en";
+    this.turnDetectionMode = options.turnDetectionMode ?? TurnDetectionMode.ADAPTIVE;
+    this.sampleRate = options.sampleRate ?? SpeechmaticsSampleRate.HZ_16000;
+    this.enableDiarization = options.enableDiarization ?? false;
+    this.maxDelay = maxDelay;
+    this.endOfUtteranceSilenceTrigger = eouSilence;
+    this.endOfUtteranceMaxDelay = eouMax;
+    this.includePartials = options.includePartials ?? true;
+    this.additionalVocab = options.additionalVocab ?? [];
+    this.operatingPoint = options.operatingPoint;
+    this.domain = options.domain;
+    this.outputLocale = options.outputLocale;
+  }
+  /** Build the JSON `StartRecognition` payload sent on connect. */
+  buildStartRecognition() {
+    const transcriptionConfig = {
+      language: this.language,
+      enable_partials: this.includePartials,
+      diarization: this.enableDiarization ? "speaker" : "none"
+    };
+    if (this.maxDelay !== void 0) transcriptionConfig.max_delay = this.maxDelay;
+    if (this.operatingPoint !== void 0) {
+      transcriptionConfig.operating_point = this.operatingPoint;
+    }
+    if (this.domain !== void 0) transcriptionConfig.domain = this.domain;
+    if (this.outputLocale !== void 0) {
+      transcriptionConfig.output_locale = this.outputLocale;
+    }
+    if (this.additionalVocab.length > 0) {
+      transcriptionConfig.additional_vocab = [...this.additionalVocab];
+    }
+    const conversationConfig = {
+      end_of_utterance_mode: this.turnDetectionMode
+    };
+    if (this.endOfUtteranceSilenceTrigger !== void 0) {
+      conversationConfig.end_of_utterance_silence_trigger = this.endOfUtteranceSilenceTrigger;
+    }
+    if (this.endOfUtteranceMaxDelay !== void 0) {
+      conversationConfig.end_of_utterance_max_delay = this.endOfUtteranceMaxDelay;
+    }
+    transcriptionConfig.conversation_config = conversationConfig;
+    return {
+      message: "StartRecognition",
+      audio_format: {
+        type: "raw",
+        encoding: SpeechmaticsAudioEncoding.PCM_S16LE,
+        sample_rate: this.sampleRate
+      },
+      transcription_config: transcriptionConfig
+    };
+  }
+  /** Open the streaming WebSocket and send the `StartRecognition` frame. */
+  async connect() {
+    if (this.ws !== null) return;
+    const ws = new WebSocket5(this.baseUrl, {
+      headers: { Authorization: `Bearer ${this.apiKey}` }
+    });
+    this.ws = ws;
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const settle = (fn) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        fn();
+      };
+      const timer = setTimeout(
+        () => settle(
+          () => reject(new PatterConnectionError("Speechmatics connect timeout"))
+        ),
+        CONNECT_TIMEOUT_MS3
+      );
+      ws.once("open", () => settle(resolve));
+      ws.once("error", (err) => settle(() => reject(err)));
+      ws.once("unexpected-response", (_req, res) => {
+        const status = res?.statusCode ?? 0;
+        settle(() => {
+          if (status === 401 || status === 403) {
+            reject(
+              new AuthenticationError(
+                `Speechmatics rejected the API key (HTTP ${status}).`
+              )
+            );
+            return;
+          }
+          if (status === 429) {
+            reject(
+              new RateLimitError("Speechmatics rate limit exceeded (HTTP 429).")
+            );
+            return;
+          }
+          reject(
+            new PatterConnectionError(
+              `Speechmatics WebSocket upgrade failed (HTTP ${status}).`
+            )
+          );
+        });
+      });
+    });
+    ws.on("message", (raw) => this.handleMessage(raw.toString()));
+    ws.on("close", () => this.handleClose());
+    ws.on("error", (err) => this.handleError(err));
+    try {
+      ws.send(JSON.stringify(this.buildStartRecognition()));
+    } catch (err) {
+      throw new PatterConnectionError(
+        `Speechmatics StartRecognition send failed: ${String(err)}`
+      );
+    }
+    this.running = true;
+  }
+  /** Send a binary PCM16-LE audio chunk to Speechmatics for transcription. */
+  sendAudio(audio) {
+    if (!this.ws || this.ws.readyState !== WebSocket5.OPEN) {
+      return;
+    }
+    if (audio.length === 0) {
+      return;
+    }
+    this.lastSeqNo += 1;
+    try {
+      this.ws.send(audio);
+    } catch (err) {
+      getLogger().error(`SpeechmaticsSTT sendAudio failed: ${String(err)}`);
+    }
+  }
+  /** Register a transcript listener. */
+  onTranscript(callback) {
+    this.transcriptCallbacks.add(callback);
+  }
+  /** Remove a previously registered transcript listener. */
+  offTranscript(callback) {
+    this.transcriptCallbacks.delete(callback);
+  }
+  /** Register an error listener for socket / API failures. */
+  onError(callback) {
+    this.errorCallbacks.add(callback);
+  }
+  /** Remove a previously registered error listener. */
+  offError(callback) {
+    this.errorCallbacks.delete(callback);
+  }
+  handleMessage(raw) {
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const event = data.message;
+    if (!event) return;
+    switch (event) {
+      case SpeechmaticsServerMessage.RECOGNITION_STARTED:
+      case SpeechmaticsServerMessage.AUDIO_ADDED:
+      case SpeechmaticsServerMessage.END_OF_UTTERANCE:
+      case SpeechmaticsServerMessage.END_OF_TRANSCRIPT:
+      case SpeechmaticsServerMessage.INFO:
+        return;
+      case SpeechmaticsServerMessage.WARNING:
+        getLogger().warn(`SpeechmaticsSTT warning: ${JSON.stringify(data)}`);
+        return;
+      case SpeechmaticsServerMessage.ERROR: {
+        const message = data.reason ?? data.type ?? "Speechmatics returned an Error frame";
+        getLogger().error(`SpeechmaticsSTT error: ${message}`);
+        this.emitError(new PatterConnectionError(`Speechmatics: ${message}`));
+        return;
+      }
+      case SpeechmaticsServerMessage.ADD_PARTIAL_TRANSCRIPT:
+      case SpeechmaticsServerMessage.ADD_TRANSCRIPT: {
+        const isFinal = event === SpeechmaticsServerMessage.ADD_TRANSCRIPT;
+        const transcript = this.toTranscript(data, isFinal);
+        if (transcript !== null) this.emitTranscript(transcript);
+        return;
+      }
+      default:
+        return;
+    }
+  }
+  /** Translate a Speechmatics transcript message into a Patter `Transcript`. */
+  toTranscript(message, isFinal) {
+    const rendered = (message.metadata?.transcript ?? "").trim();
+    const results = message.results ?? [];
+    let text = rendered;
+    const confidences = [];
+    for (const result of results) {
+      const best = result.alternatives?.[0];
+      if (!best) continue;
+      const content = best.content;
+      const confidence2 = best.confidence;
+      if (!rendered && typeof content === "string" && content.length > 0) {
+        text = text ? `${text} ${content}` : content;
+      }
+      if (typeof confidence2 === "number") {
+        confidences.push(confidence2);
+      }
+    }
+    text = text.trim();
+    if (!text) return null;
+    const confidence = confidences.length > 0 ? confidences.reduce((sum, c) => sum + c, 0) / confidences.length : 1;
+    return { text, isFinal, confidence };
+  }
+  emitTranscript(transcript) {
+    for (const cb of this.transcriptCallbacks) {
+      try {
+        cb(transcript);
+      } catch (err) {
+        getLogger().error(`SpeechmaticsSTT transcript callback threw: ${String(err)}`);
+      }
+    }
+  }
+  emitError(err) {
+    for (const cb of this.errorCallbacks) {
+      try {
+        cb(err);
+      } catch (cbErr) {
+        getLogger().error(`SpeechmaticsSTT error callback threw: ${String(cbErr)}`);
+      }
+    }
+  }
+  handleError(err) {
+    getLogger().error(`SpeechmaticsSTT WebSocket error: ${err.message}`);
+    this.emitError(err);
+  }
+  handleClose() {
+    if (!this.running) return;
+    this.running = false;
+  }
+  /** Send `EndOfStream` and close the WebSocket. Idempotent. */
+  close() {
+    this.running = false;
+    const ws = this.ws;
+    if (!ws) return;
+    this.ws = null;
+    const sendSafe = (payload) => {
+      if (ws.readyState === WebSocket5.OPEN) {
+        try {
+          ws.send(payload);
+        } catch {
+        }
+      }
+    };
+    sendSafe(
+      JSON.stringify({ message: "EndOfStream", last_seq_no: this.lastSeqNo })
+    );
+    try {
+      ws.close();
+    } catch {
+    }
+  }
+};
+
+// src/stt/speechmatics.ts
+var STT7 = class extends SpeechmaticsSTT {
+  static providerKey = "speechmatics";
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.SPEECHMATICS_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Speechmatics STT requires an apiKey. Pass { apiKey: 'sm_...' } or set SPEECHMATICS_API_KEY in the environment."
+      );
+    }
+    super(key, opts);
+  }
+};
+
+// src/tts/elevenlabs.ts
+init_esm_shims();
+
 // src/providers/elevenlabs-tts.ts
+init_esm_shims();
 var ELEVENLABS_BASE_URL = "https://api.elevenlabs.io/v1";
 var ELEVENLABS_VOICE_ID_BY_NAME = {
   rachel: "21m00Tcm4TlvDq8ikWAM",
@@ -2636,6 +3842,27 @@ function resolveVoiceId(voice) {
   if (VOICE_ID_PATTERN.test(voice)) return voice;
   return ELEVENLABS_VOICE_ID_BY_NAME[voice.toLowerCase()] ?? voice;
 }
+var ElevenLabsModel = {
+  V3: "eleven_v3",
+  FLASH_V2_5: "eleven_flash_v2_5",
+  TURBO_V2_5: "eleven_turbo_v2_5",
+  MULTILINGUAL_V2: "eleven_multilingual_v2",
+  MONOLINGUAL_V1: "eleven_monolingual_v1"
+};
+var ElevenLabsOutputFormat = {
+  MP3_22050_32: "mp3_22050_32",
+  MP3_44100_32: "mp3_44100_32",
+  MP3_44100_64: "mp3_44100_64",
+  MP3_44100_96: "mp3_44100_96",
+  MP3_44100_128: "mp3_44100_128",
+  MP3_44100_192: "mp3_44100_192",
+  PCM_8000: "pcm_8000",
+  PCM_16000: "pcm_16000",
+  PCM_22050: "pcm_22050",
+  PCM_24000: "pcm_24000",
+  PCM_44100: "pcm_44100",
+  ULAW_8000: "ulaw_8000"
+};
 var ElevenLabsTTS = class _ElevenLabsTTS {
   apiKey;
   voiceId;
@@ -2644,13 +3871,13 @@ var ElevenLabsTTS = class _ElevenLabsTTS {
   voiceSettings;
   languageCode;
   chunkSize;
-  constructor(apiKey, voiceIdOrOptions = "21m00Tcm4TlvDq8ikWAM", modelId = "eleven_flash_v2_5", outputFormat = "pcm_16000") {
+  constructor(apiKey, voiceIdOrOptions = "21m00Tcm4TlvDq8ikWAM", modelId = ElevenLabsModel.FLASH_V2_5, outputFormat = ElevenLabsOutputFormat.PCM_16000) {
     this.apiKey = apiKey;
     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.modelId = o.modelId ?? ElevenLabsModel.FLASH_V2_5;
+      this.outputFormat = o.outputFormat ?? ElevenLabsOutputFormat.PCM_16000;
       this.voiceSettings = o.voiceSettings;
       this.languageCode = o.languageCode;
       this.chunkSize = o.chunkSize ?? 4096;
@@ -2688,7 +3915,7 @@ var ElevenLabsTTS = class _ElevenLabsTTS {
     return new _ElevenLabsTTS(apiKey, {
       ...options,
       voiceSettings,
-      outputFormat: "ulaw_8000"
+      outputFormat: ElevenLabsOutputFormat.ULAW_8000
     });
   }
   /**
@@ -2705,7 +3932,7 @@ var ElevenLabsTTS = class _ElevenLabsTTS {
   static forTelnyx(apiKey, options = {}) {
     return new _ElevenLabsTTS(apiKey, {
       ...options,
-      outputFormat: "pcm_16000"
+      outputFormat: ElevenLabsOutputFormat.PCM_16000
     });
   }
   /**
@@ -2783,12 +4010,13 @@ function resolveApiKey(apiKey) {
 var TTS = class _TTS extends ElevenLabsTTS {
   static providerKey = "elevenlabs";
   constructor(opts = {}) {
-    super(
-      resolveApiKey(opts.apiKey),
-      opts.voiceId ?? "EXAVITQu4vr4xnSDxMaL",
-      opts.modelId ?? "eleven_flash_v2_5",
-      opts.outputFormat ?? "pcm_16000"
-    );
+    super(resolveApiKey(opts.apiKey), {
+      voiceId: opts.voiceId ?? "EXAVITQu4vr4xnSDxMaL",
+      modelId: opts.modelId ?? "eleven_flash_v2_5",
+      outputFormat: opts.outputFormat ?? "pcm_16000",
+      languageCode: opts.languageCode,
+      voiceSettings: opts.voiceSettings
+    });
   }
   static forTwilio(arg1, arg2) {
     const opts = typeof arg1 === "string" ? { apiKey: arg1, ...arg2 ?? {} } : arg1 ?? {};
@@ -2800,22 +4028,364 @@ var TTS = class _TTS extends ElevenLabsTTS {
   }
 };
 
+// src/tts/elevenlabs-ws.ts
+init_esm_shims();
+
+// src/providers/elevenlabs-ws-tts.ts
+init_esm_shims();
+import WebSocket6 from "ws";
+var WS_BASE = "wss://api.elevenlabs.io/v1/text-to-speech";
+var DEFAULT_INACTIVITY_TIMEOUT = 60;
+var DEFAULT_CHUNK_SIZE = 4096;
+var CONNECT_TIMEOUT_MS4 = 5e3;
+var FRAME_TIMEOUT_MS = 3e4;
+var MAX_AUDIO_B64_BYTES = 512 * 1024;
+var ElevenLabsTTSError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ElevenLabsTTSError";
+  }
+};
+var ElevenLabsPlanError = class extends ElevenLabsTTSError {
+  constructor(message) {
+    super(message);
+    this.name = "ElevenLabsPlanError";
+  }
+};
+var PLAN_REQUIRED_MSG = "ElevenLabs WS streaming requires a Pro plan or higher (the WS endpoint returned `payment_required`). Either upgrade at https://elevenlabs.io/pricing, or use the HTTP `ElevenLabsTTS` class which works on all plans (drop-in API).";
+function sanitiseLogStr(value, limit = 200) {
+  return String(value).replace(/[\r\n\x00]/g, " ").slice(0, limit);
+}
+var CARRIER_NATIVE_FORMAT = {
+  twilio: "ulaw_8000",
+  telnyx: "pcm_16000"
+};
+var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
+  static providerKey = "elevenlabs_ws";
+  apiKey;
+  voiceId;
+  modelId;
+  voiceSettings;
+  languageCode;
+  autoMode;
+  inactivityTimeout;
+  chunkLengthSchedule;
+  chunkSize;
+  /**
+   * The wire format requested over the ElevenLabs WS. Initially set from
+   * the constructor; ``setTelephonyCarrier`` may auto-flip it to the
+   * carrier's native codec when the caller did NOT pass ``outputFormat``
+   * explicitly.
+   */
+  _outputFormat;
+  _outputFormatExplicit;
+  /** Public read-only view of the (possibly auto-flipped) wire format. */
+  get outputFormat() {
+    return this._outputFormat;
+  }
+  constructor(opts) {
+    if (opts.modelId === "eleven_v3") {
+      throw new Error(
+        "eleven_v3 is not supported by the WebSocket stream-input endpoint \u2014 use the HTTP ElevenLabsTTS class instead."
+      );
+    }
+    this.apiKey = opts.apiKey;
+    this.voiceId = resolveVoiceId(opts.voiceId ?? "21m00Tcm4TlvDq8ikWAM");
+    this.modelId = opts.modelId ?? "eleven_flash_v2_5";
+    this._outputFormatExplicit = opts.outputFormat !== void 0;
+    this._outputFormat = opts.outputFormat ?? "pcm_16000";
+    this.voiceSettings = opts.voiceSettings;
+    this.languageCode = opts.languageCode;
+    this.autoMode = opts.autoMode ?? true;
+    this.inactivityTimeout = opts.inactivityTimeout ?? DEFAULT_INACTIVITY_TIMEOUT;
+    this.chunkLengthSchedule = opts.chunkLengthSchedule;
+    this.chunkSize = opts.chunkSize ?? DEFAULT_CHUNK_SIZE;
+  }
+  /**
+   * Hook called by ``StreamHandler`` to advise the carrier wire format.
+   *
+   * When the user did NOT pass an explicit ``outputFormat`` in the
+   * constructor options, this flips the format to the carrier's native
+   * wire codec — saving a client-side transcode step. Calling with an
+   * unknown carrier (``""`` / ``"custom"``) is a no-op.
+   *
+   * When ``outputFormat`` was explicitly passed (incl. via the
+   * ``forTwilio`` / ``forTelnyx`` factories), this method is a no-op —
+   * the user's choice always wins.
+   */
+  setTelephonyCarrier(carrier) {
+    if (this._outputFormatExplicit) return;
+    const native = CARRIER_NATIVE_FORMAT[carrier];
+    if (!native) return;
+    this._outputFormat = native;
+  }
+  /** Pre-configured for Twilio Media Streams (`ulaw_8000`). */
+  static forTwilio(opts) {
+    return new _ElevenLabsWebSocketTTS({
+      ...opts,
+      outputFormat: "ulaw_8000",
+      voiceSettings: opts.voiceSettings ?? {
+        stability: 0.6,
+        similarity_boost: 0.75,
+        use_speaker_boost: false
+      }
+    });
+  }
+  /** Pre-configured for Telnyx (`pcm_16000`). */
+  static forTelnyx(opts) {
+    return new _ElevenLabsWebSocketTTS({
+      ...opts,
+      outputFormat: "pcm_16000"
+    });
+  }
+  buildUrl() {
+    const params = new URLSearchParams({
+      model_id: this.modelId,
+      output_format: this.outputFormat,
+      inactivity_timeout: String(this.inactivityTimeout)
+    });
+    if (this.autoMode) params.set("auto_mode", "true");
+    if (this.languageCode) params.set("language_code", this.languageCode);
+    return `${WS_BASE}/${encodeURIComponent(this.voiceId)}/stream-input?${params.toString()}`;
+  }
+  /**
+   * Single-shot synthesis: open WS, send text, yield bytes, close.
+   *
+   * Resilience contract:
+   * - Connection bounded by ``CONNECT_TIMEOUT_MS`` (5s, was 15s).
+   * - Each idle wait bounded by ``FRAME_TIMEOUT_MS`` (30s) so a stalled
+   *   server cannot keep the generator alive indefinitely.
+   * - Permanent error handler attached BEFORE the open await — prevents
+   *   ``uncaughtException`` if an error fires after the once-listener
+   *   resolves.
+   * - All event listeners removed in ``finally`` (no closure leak past
+   *   socket close).
+   * - Server-reported ``error`` raises ``ElevenLabsTTSError``.
+   * - Per-frame audio payload capped at ``MAX_AUDIO_B64_BYTES``.
+   * - Best-effort EOS ``{"text":""}`` sent in finally (not immediately
+   *   after flush — auto_mode could otherwise truncate the tail audio).
+   */
+  async *synthesizeStream(text) {
+    const ws = new WebSocket6(this.buildUrl(), {
+      headers: { "xi-api-key": this.apiKey }
+    });
+    const queue = [];
+    let done = false;
+    let pendingError = null;
+    let resolveWaiter = null;
+    let connectTimer;
+    const wakeWaiter = () => {
+      const r = resolveWaiter;
+      resolveWaiter = null;
+      r?.();
+    };
+    const onMessage = (raw) => {
+      if (Buffer.isBuffer(raw) && !looksLikeJson(raw)) {
+        if (raw.length > MAX_AUDIO_B64_BYTES) {
+          getLogger().warn(
+            `ElevenLabs WS binary frame too large (${raw.length} bytes), skipping`
+          );
+          return;
+        }
+        queue.push(raw);
+        wakeWaiter();
+        return;
+      }
+      const txt = raw.toString("utf8");
+      let msg;
+      try {
+        msg = JSON.parse(txt);
+      } catch {
+        getLogger().warn("ElevenLabs WS sent non-JSON text frame");
+        return;
+      }
+      if (msg.error) {
+        const sanitised = sanitiseLogStr(msg.error);
+        getLogger().error("ElevenLabs WS reported error:", sanitised);
+        if (sanitised === "payment_required" || /payment[_ ]required/i.test(sanitised)) {
+          pendingError = new ElevenLabsPlanError(PLAN_REQUIRED_MSG);
+        } else {
+          pendingError = new ElevenLabsTTSError(`ElevenLabs WS error: ${sanitised}`);
+        }
+        done = true;
+        wakeWaiter();
+        return;
+      }
+      if (msg.audio) {
+        if (typeof msg.audio !== "string" || msg.audio.length > MAX_AUDIO_B64_BYTES) {
+          getLogger().warn("ElevenLabs WS audio frame too large or malformed, skipping");
+        } else {
+          try {
+            queue.push(Buffer.from(msg.audio, "base64"));
+          } catch {
+            getLogger().warn("ElevenLabs WS sent malformed base64 audio");
+          }
+        }
+      }
+      if (msg.isFinal) {
+        done = true;
+      }
+      wakeWaiter();
+    };
+    const onClose = () => {
+      done = true;
+      wakeWaiter();
+    };
+    const onError = (err) => {
+      pendingError = err;
+      done = true;
+      wakeWaiter();
+    };
+    ws.on("error", onError);
+    try {
+      await new Promise((resolve, reject) => {
+        connectTimer = setTimeout(
+          () => reject(new Error("ElevenLabs WS connect timeout")),
+          CONNECT_TIMEOUT_MS4
+        );
+        ws.once("open", () => {
+          if (connectTimer) clearTimeout(connectTimer);
+          connectTimer = void 0;
+          resolve();
+        });
+        ws.once("error", (err) => {
+          if (connectTimer) clearTimeout(connectTimer);
+          connectTimer = void 0;
+          reject(err);
+        });
+      });
+      const init = { text: " " };
+      if (this.voiceSettings) init["voice_settings"] = this.voiceSettings;
+      if (!this.autoMode && this.chunkLengthSchedule) {
+        init["generation_config"] = { chunk_length_schedule: this.chunkLengthSchedule };
+      }
+      ws.send(JSON.stringify(init));
+      ws.send(JSON.stringify({ text: text + " ", flush: true }));
+      ws.on("message", onMessage);
+      ws.on("close", onClose);
+      while (true) {
+        if (queue.length > 0) {
+          const buf = queue.shift();
+          for (let off = 0; off < buf.length; off += this.chunkSize) {
+            yield buf.subarray(off, Math.min(off + this.chunkSize, buf.length));
+          }
+          continue;
+        }
+        if (done) {
+          if (pendingError) throw pendingError;
+          return;
+        }
+        let frameTimer;
+        try {
+          await new Promise((res, rej) => {
+            resolveWaiter = res;
+            frameTimer = setTimeout(
+              () => rej(new ElevenLabsTTSError(`ElevenLabs WS no frame for ${FRAME_TIMEOUT_MS}ms`)),
+              FRAME_TIMEOUT_MS
+            );
+          });
+        } finally {
+          if (frameTimer) clearTimeout(frameTimer);
+        }
+      }
+    } finally {
+      if (connectTimer) clearTimeout(connectTimer);
+      try {
+        if (ws.readyState === WebSocket6.OPEN) {
+          ws.send(JSON.stringify({ text: "" }));
+        }
+      } catch {
+      }
+      try {
+        if (ws.readyState === WebSocket6.OPEN || ws.readyState === WebSocket6.CONNECTING) {
+          ws.close();
+        }
+      } catch {
+      }
+      ws.removeAllListeners();
+    }
+  }
+  /** No-op — connections are per-utterance and torn down inside synthesizeStream. */
+  async close() {
+  }
+};
+function looksLikeJson(buf) {
+  if (buf.length === 0) return false;
+  const b = buf[0];
+  return b === 123 || b === 91;
+}
+
+// src/tts/elevenlabs-ws.ts
+function resolveApiKey2(apiKey) {
+  const key = apiKey ?? process.env.ELEVENLABS_API_KEY;
+  if (!key) {
+    throw new Error(
+      "ElevenLabs WebSocket TTS requires an apiKey. Pass { apiKey: '...' } or set ELEVENLABS_API_KEY in the environment."
+    );
+  }
+  return key;
+}
+function buildOpts(opts) {
+  const out = {
+    apiKey: resolveApiKey2(opts.apiKey),
+    modelId: opts.modelId ?? "eleven_flash_v2_5",
+    outputFormat: opts.outputFormat ?? "pcm_16000",
+    autoMode: opts.autoMode ?? true
+  };
+  if (opts.voiceId !== void 0) out.voiceId = opts.voiceId;
+  if (opts.voiceSettings !== void 0) out.voiceSettings = opts.voiceSettings;
+  if (opts.languageCode !== void 0) out.languageCode = opts.languageCode;
+  if (opts.inactivityTimeout !== void 0) out.inactivityTimeout = opts.inactivityTimeout;
+  if (opts.chunkLengthSchedule !== void 0) out.chunkLengthSchedule = opts.chunkLengthSchedule;
+  return out;
+}
+var TTS2 = class _TTS extends ElevenLabsWebSocketTTS {
+  static providerKey = "elevenlabs_ws";
+  constructor(opts = {}) {
+    super(buildOpts(opts));
+  }
+  /** WebSocket TTS pre-configured for Twilio Media Streams (`ulaw_8000`). */
+  static forTwilio(opts = {}) {
+    return new _TTS({ ...opts, outputFormat: "ulaw_8000" });
+  }
+  /** WebSocket TTS pre-configured for Telnyx (`pcm_16000`). */
+  static forTelnyx(opts = {}) {
+    return new _TTS({ ...opts, outputFormat: "pcm_16000" });
+  }
+};
+
+// src/tts/openai.ts
+init_esm_shims();
+
 // src/providers/openai-tts.ts
+init_esm_shims();
 var OPENAI_TTS_URL = "https://api.openai.com/v1/audio/speech";
 var INSTRUCTIONS_PREFIX = "gpt-4o-mini-tts";
 var LPF_ALPHA = 0.78;
+var LPF_ALPHA_8K = 0.45;
 var OpenAITTS = class _OpenAITTS {
-  constructor(apiKey, voice = "alloy", model = "gpt-4o-mini-tts", instructions = null, speed = null, antiAlias = true) {
+  constructor(apiKey, voice = "alloy", model = "gpt-4o-mini-tts", instructions = null, speed = null, antiAlias = true, targetSampleRate = 16e3) {
     this.apiKey = apiKey;
     this.voice = voice;
     this.model = model;
     this.instructions = instructions;
     this.speed = speed;
     this.antiAlias = antiAlias;
+    this.targetSampleRate = targetSampleRate;
     if (speed !== null && speed !== void 0 && (speed < 0.25 || speed > 4)) {
       throw new Error("OpenAITTS: speed must be in [0.25, 4.0]");
     }
+    if (targetSampleRate !== 8e3 && targetSampleRate !== 16e3) {
+      throw new Error("OpenAITTS: targetSampleRate must be 8000 or 16000");
+    }
   }
+  apiKey;
+  voice;
+  model;
+  instructions;
+  speed;
+  antiAlias;
+  targetSampleRate;
   /**
    * Synthesise text to speech and return the full audio as a single Buffer.
    *
@@ -2871,7 +4441,8 @@ var OpenAITTS = class _OpenAITTS {
       carryByte: null,
       leftover: [],
       lpfPrev: 0,
-      lpfEnabled: this.antiAlias
+      lpfEnabled: this.antiAlias,
+      targetSampleRate: this.targetSampleRate
     };
     const reader = response.body.getReader();
     try {
@@ -2897,14 +4468,17 @@ var OpenAITTS = class _OpenAITTS {
     }
   }
   /**
-   * 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.
+   * Streaming 24 kHz → {16, 8} kHz resampler (PCM16-LE). Applies a single-pole
+   * lowpass ahead of the decimation and carries filter + sample state across
+   * chunks so the cadence doesn't reset at every network read.
+   *
+   * Output rate is selected by ``ctx.targetSampleRate``:
+   *   16000 → 3:2 decimation (sample 0 + mid(1,2))   [default]
+   *    8000 → 3:1 decimation (sample 0 only)         [fix #46]
    *
-   * ``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.
+   * ``ctx.lpfEnabled`` controls whether the LPF is engaged — kept disabled
+   * for the legacy static helper so the bit-exact downsample-only tests
+   * remain valid; the real streaming path always engages it.
    */
   static resampleStreaming(audio, ctx) {
     let buf;
@@ -2921,6 +4495,8 @@ var OpenAITTS = class _OpenAITTS {
     if (buf.length === 0 && ctx.leftover.length === 0) {
       return Buffer.alloc(0);
     }
+    const direct8k = ctx.targetSampleRate === 8e3;
+    const lpfAlpha = direct8k ? LPF_ALPHA_8K : LPF_ALPHA;
     const sampleCount = buf.length / 2;
     const samples = ctx.leftover.slice();
     const lpf = ctx.lpfEnabled !== false;
@@ -2928,7 +4504,7 @@ var OpenAITTS = class _OpenAITTS {
     for (let i2 = 0; i2 < sampleCount; i2++) {
       const x = buf.readInt16LE(i2 * 2);
       if (lpf) {
-        y = LPF_ALPHA * x + (1 - LPF_ALPHA) * y;
+        y = lpfAlpha * x + (1 - lpfAlpha) * y;
         let s = Math.round(y);
         if (s > 32767) s = 32767;
         else if (s < -32768) s = -32768;
@@ -2940,10 +4516,17 @@ var OpenAITTS = class _OpenAITTS {
     if (lpf) ctx.lpfPrev = y;
     const out = [];
     let i = 0;
-    while (i + 2 < samples.length) {
-      out.push(samples[i]);
-      out.push(Math.round((samples[i + 1] + samples[i + 2]) / 2));
-      i += 3;
+    if (direct8k) {
+      while (i + 2 < samples.length) {
+        out.push(samples[i]);
+        i += 3;
+      }
+    } else {
+      while (i + 2 < samples.length) {
+        out.push(samples[i]);
+        out.push(Math.round((samples[i + 1] + samples[i + 2]) / 2));
+        i += 3;
+      }
     }
     ctx.leftover = samples.slice(i);
     const buffer = Buffer.alloc(out.length * 2);
@@ -2954,7 +4537,13 @@ var OpenAITTS = class _OpenAITTS {
   }
   /** @deprecated use {@link resampleStreaming} with persistent state. */
   static resample24kTo16k(audio) {
-    const ctx = { carryByte: null, leftover: [], lpfPrev: 0, lpfEnabled: false };
+    const ctx = {
+      carryByte: null,
+      leftover: [],
+      lpfPrev: 0,
+      lpfEnabled: false,
+      targetSampleRate: 16e3
+    };
     const out = _OpenAITTS.resampleStreaming(audio, ctx);
     if (ctx.leftover.length === 0) return out;
     const tail = Buffer.alloc(ctx.leftover.length * 2);
@@ -2966,7 +4555,7 @@ var OpenAITTS = class _OpenAITTS {
 };
 
 // src/tts/openai.ts
-var TTS2 = class extends OpenAITTS {
+var TTS3 = class extends OpenAITTS {
   static providerKey = "openai_tts";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
@@ -2986,10 +4575,41 @@ var TTS2 = class extends OpenAITTS {
   }
 };
 
+// src/tts/cartesia.ts
+init_esm_shims();
+
 // src/providers/cartesia-tts.ts
+init_esm_shims();
 var CARTESIA_BASE_URL = "https://api.cartesia.ai";
 var CARTESIA_API_VERSION = "2025-04-16";
 var CARTESIA_DEFAULT_VOICE_ID = "f786b574-daa5-4673-aa0c-cbe3e8534c02";
+var CartesiaTTSModel = {
+  SONIC_3: "sonic-3",
+  SONIC_2: "sonic-2",
+  SONIC: "sonic"
+};
+var CartesiaTTSContainer = {
+  RAW: "raw",
+  WAV: "wav",
+  MP3: "mp3"
+};
+var CartesiaTTSEncoding = {
+  PCM_S16LE: "pcm_s16le",
+  PCM_F32LE: "pcm_f32le",
+  PCM_MULAW: "pcm_mulaw",
+  PCM_ALAW: "pcm_alaw"
+};
+var CartesiaTTSSampleRate = {
+  HZ_8000: 8e3,
+  HZ_16000: 16e3,
+  HZ_22050: 22050,
+  HZ_24000: 24e3,
+  HZ_44100: 44100
+};
+var CartesiaTTSVoiceMode = {
+  ID: "id",
+  EMBEDDING: "embedding"
+};
 var CartesiaTTS = class _CartesiaTTS {
   apiKey;
   model;
@@ -3003,10 +4623,10 @@ var CartesiaTTS = class _CartesiaTTS {
   apiVersion;
   constructor(apiKey, opts = {}) {
     this.apiKey = apiKey;
-    this.model = opts.model ?? "sonic-3";
+    this.model = opts.model ?? CartesiaTTSModel.SONIC_3;
     this.voice = opts.voice ?? CARTESIA_DEFAULT_VOICE_ID;
     this.language = opts.language ?? "en";
-    this.sampleRate = opts.sampleRate ?? 16e3;
+    this.sampleRate = opts.sampleRate ?? CartesiaTTSSampleRate.HZ_16000;
     this.speed = opts.speed;
     this.emotion = typeof opts.emotion === "string" ? [opts.emotion] : opts.emotion;
     this.volume = opts.volume;
@@ -3023,7 +4643,10 @@ var CartesiaTTS = class _CartesiaTTS {
    * removes a potential aliasing source.
    */
   static forTwilio(apiKey, options = {}) {
-    return new _CartesiaTTS(apiKey, { ...options, sampleRate: 8e3 });
+    return new _CartesiaTTS(apiKey, {
+      ...options,
+      sampleRate: CartesiaTTSSampleRate.HZ_8000
+    });
   }
   /**
    * Construct an instance pre-configured for Telnyx bidirectional media.
@@ -3034,17 +4657,20 @@ var CartesiaTTS = class _CartesiaTTS {
    * {@link CartesiaTTS.forTwilio}.
    */
   static forTelnyx(apiKey, options = {}) {
-    return new _CartesiaTTS(apiKey, { ...options, sampleRate: 16e3 });
+    return new _CartesiaTTS(apiKey, {
+      ...options,
+      sampleRate: CartesiaTTSSampleRate.HZ_16000
+    });
   }
   /** Build the JSON payload for the Cartesia bytes endpoint. */
   buildPayload(text) {
     const payload = {
       model_id: this.model,
-      voice: { mode: "id", id: this.voice },
+      voice: { mode: CartesiaTTSVoiceMode.ID, id: this.voice },
       transcript: text,
       output_format: {
-        container: "raw",
-        encoding: "pcm_s16le",
+        container: CartesiaTTSContainer.RAW,
+        encoding: CartesiaTTSEncoding.PCM_S16LE,
         sample_rate: this.sampleRate
       },
       language: this.language
@@ -3108,7 +4734,7 @@ var CartesiaTTS = class _CartesiaTTS {
 };
 
 // src/tts/cartesia.ts
-function resolveApiKey2(apiKey) {
+function resolveApiKey3(apiKey) {
   const key = apiKey ?? process.env.CARTESIA_API_KEY;
   if (!key) {
     throw new Error(
@@ -3117,10 +4743,10 @@ function resolveApiKey2(apiKey) {
   }
   return key;
 }
-var TTS3 = class _TTS extends CartesiaTTS {
+var TTS4 = class _TTS extends CartesiaTTS {
   static providerKey = "cartesia_tts";
   constructor(opts = {}) {
-    const key = resolveApiKey2(opts.apiKey);
+    const key = resolveApiKey3(opts.apiKey);
     const { apiKey: _ignored, ...rest } = opts;
     void _ignored;
     super(key, rest);
@@ -3135,15 +4761,30 @@ var TTS3 = class _TTS extends CartesiaTTS {
   }
 };
 
+// src/tts/rime.ts
+init_esm_shims();
+
 // src/providers/rime-tts.ts
+init_esm_shims();
 var RIME_BASE_URL = "https://users.rime.ai/v1/rime-tts";
+var RimeModel = {
+  ARCANA: "arcana",
+  MIST: "mist",
+  MIST_V2: "mistv2"
+};
+var RimeAudioFormat = {
+  PCM: "audio/pcm",
+  MP3: "audio/mp3",
+  WAV: "audio/wav",
+  MULAW: "audio/mulaw"
+};
 var ARCANA_MODEL_TIMEOUT_MS = 60 * 4 * 1e3;
 var MIST_MODEL_TIMEOUT_MS = 30 * 1e3;
 function isMistModel(model) {
-  return model.includes("mist");
+  return model.includes(RimeModel.MIST);
 }
 function timeoutForModel(model) {
-  if (model === "arcana") return ARCANA_MODEL_TIMEOUT_MS;
+  if (model === RimeModel.ARCANA) return ARCANA_MODEL_TIMEOUT_MS;
   return MIST_MODEL_TIMEOUT_MS;
 }
 var RimeTTS = class {
@@ -3164,7 +4805,7 @@ var RimeTTS = class {
   totalTimeoutMs;
   constructor(apiKey, opts = {}) {
     this.apiKey = apiKey;
-    this.model = opts.model ?? "arcana";
+    this.model = opts.model ?? RimeModel.ARCANA;
     const defaultSpeaker = isMistModel(this.model) ? "cove" : "astra";
     this.speaker = opts.speaker ?? defaultSpeaker;
     this.lang = opts.lang ?? "eng";
@@ -3186,7 +4827,7 @@ var RimeTTS = class {
       text,
       modelId: this.model
     };
-    if (this.model === "arcana") {
+    if (this.model === RimeModel.ARCANA) {
       if (this.repetitionPenalty !== void 0)
         payload.repetition_penalty = this.repetitionPenalty;
       if (this.temperature !== void 0) payload.temperature = this.temperature;
@@ -3198,7 +4839,7 @@ var RimeTTS = class {
       payload.lang = this.lang;
       payload.samplingRate = this.sampleRate;
       if (this.speedAlpha !== void 0) payload.speedAlpha = this.speedAlpha;
-      if (this.model === "mistv2" && this.reduceLatency !== void 0) {
+      if (this.model === RimeModel.MIST_V2 && this.reduceLatency !== void 0) {
         payload.reduceLatency = this.reduceLatency;
       }
       if (this.pauseBetweenBrackets !== void 0) {
@@ -3210,6 +4851,7 @@ var RimeTTS = class {
     }
     return payload;
   }
+  /** Synthesize text and return the concatenated audio buffer. */
   async synthesize(text) {
     const chunks = [];
     for await (const chunk of this.synthesizeStream(text)) {
@@ -3225,7 +4867,7 @@ var RimeTTS = class {
     const response = await fetch(this.baseUrl, {
       method: "POST",
       headers: {
-        accept: "audio/pcm",
+        accept: RimeAudioFormat.PCM,
         Authorization: `Bearer ${this.apiKey}`,
         "content-type": "application/json"
       },
@@ -3263,7 +4905,7 @@ var RimeTTS = class {
 };
 
 // src/tts/rime.ts
-var TTS4 = class extends RimeTTS {
+var TTS5 = class extends RimeTTS {
   static providerKey = "rime";
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.RIME_API_KEY;
@@ -3278,8 +4920,28 @@ var TTS4 = class extends RimeTTS {
   }
 };
 
+// src/tts/lmnt.ts
+init_esm_shims();
+
 // src/providers/lmnt-tts.ts
+init_esm_shims();
 var LMNT_BASE_URL = "https://api.lmnt.com/v1/ai/speech/bytes";
+var LMNTAudioFormat = {
+  AAC: "aac",
+  MP3: "mp3",
+  MULAW: "mulaw",
+  RAW: "raw",
+  WAV: "wav"
+};
+var LMNTModel = {
+  BLIZZARD: "blizzard",
+  AURORA: "aurora"
+};
+var LMNTSampleRate = {
+  HZ_8000: 8e3,
+  HZ_16000: 16e3,
+  HZ_24000: 24e3
+};
 var LMNTTTS = class {
   apiKey;
   model;
@@ -3292,11 +4954,11 @@ var LMNTTTS = class {
   baseUrl;
   constructor(apiKey, opts = {}) {
     this.apiKey = apiKey;
-    this.model = opts.model ?? "blizzard";
+    this.model = opts.model ?? LMNTModel.BLIZZARD;
     this.voice = opts.voice ?? "leah";
-    this.language = opts.language ?? (this.model === "blizzard" ? "auto" : "en");
-    this.format = opts.format ?? "raw";
-    this.sampleRate = opts.sampleRate ?? 16e3;
+    this.language = opts.language ?? (this.model === LMNTModel.BLIZZARD ? "auto" : "en");
+    this.format = opts.format ?? LMNTAudioFormat.RAW;
+    this.sampleRate = opts.sampleRate ?? LMNTSampleRate.HZ_16000;
     this.temperature = opts.temperature ?? 1;
     this.topP = opts.topP ?? 0.8;
     this.baseUrl = opts.baseUrl ?? LMNT_BASE_URL;
@@ -3313,6 +4975,131 @@ var LMNTTTS = class {
       top_p: this.topP
     };
   }
+  /** Synthesize text and return the concatenated audio buffer. */
+  async synthesize(text) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+  /** Yield audio chunks as they arrive — raw PCM_S16LE by default. */
+  async *synthesizeStream(text) {
+    const response = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": this.apiKey
+      },
+      body: JSON.stringify(this.buildPayload(text)),
+      signal: AbortSignal.timeout(3e4)
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`LMNT TTS error ${response.status}: ${body}`);
+    }
+    if (!response.body) {
+      throw new Error("LMNT TTS: no response body");
+    }
+    const reader = response.body.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value && value.length > 0) {
+          yield Buffer.from(value);
+        }
+      }
+    } finally {
+      if (typeof reader.cancel === "function")
+        await reader.cancel().catch(() => {
+        });
+      reader.releaseLock();
+    }
+  }
+};
+
+// src/tts/lmnt.ts
+var TTS6 = class extends LMNTTTS {
+  static providerKey = "lmnt";
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.LMNT_API_KEY;
+    if (!key) {
+      throw new Error(
+        "LMNT TTS requires an apiKey. Pass { apiKey: '...' } or set LMNT_API_KEY in the environment."
+      );
+    }
+    const { apiKey: _ignored, ...rest } = opts;
+    void _ignored;
+    super(key, rest);
+  }
+};
+
+// src/tts/inworld.ts
+init_esm_shims();
+
+// src/providers/inworld-tts.ts
+init_esm_shims();
+var INWORLD_BASE_URL = "https://api.inworld.ai/tts/v1/voice:stream";
+var InworldModel = {
+  TTS_2: "inworld-tts-2",
+  TTS_1_5_MAX: "inworld-tts-1.5-max",
+  TTS_1_5_MINI: "inworld-tts-1.5-mini",
+  TTS_1_MAX: "inworld-tts-1-max",
+  TTS_1: "inworld-tts-1"
+};
+var InworldAudioEncoding = {
+  PCM: "PCM",
+  LINEAR16: "LINEAR16",
+  OGG_OPUS: "OGG_OPUS",
+  MP3: "MP3"
+};
+var InworldTTS = class {
+  authToken;
+  model;
+  voice;
+  language;
+  audioEncoding;
+  sampleRate;
+  bitrate;
+  temperature;
+  speakingRate;
+  deliveryMode;
+  baseUrl;
+  constructor(authToken, opts = {}) {
+    if (!authToken) {
+      throw new Error("Inworld TTS: authToken is required");
+    }
+    this.authToken = authToken;
+    this.model = opts.model ?? InworldModel.TTS_2;
+    this.voice = opts.voice ?? "Ashley";
+    this.language = opts.language;
+    this.audioEncoding = opts.audioEncoding ?? InworldAudioEncoding.PCM;
+    this.sampleRate = opts.sampleRate ?? 16e3;
+    this.bitrate = opts.bitrate ?? 64e3;
+    this.temperature = opts.temperature;
+    this.speakingRate = opts.speakingRate ?? 1;
+    this.deliveryMode = opts.deliveryMode;
+    this.baseUrl = opts.baseUrl ?? INWORLD_BASE_URL;
+  }
+  buildPayload(text) {
+    const payload = {
+      text,
+      voiceId: this.voice,
+      modelId: this.model,
+      audioConfig: {
+        audioEncoding: this.audioEncoding,
+        bitrate: this.bitrate,
+        sampleRateHertz: this.sampleRate
+      },
+      speakingRate: this.speakingRate
+    };
+    if (this.language !== void 0) payload.language = this.language;
+    if (this.temperature !== void 0) payload.temperature = this.temperature;
+    if (this.deliveryMode !== void 0) payload.deliveryMode = this.deliveryMode;
+    return payload;
+  }
+  /** Synthesize text and return the concatenated audio buffer. */
   async synthesize(text) {
     const chunks = [];
     for await (const chunk of this.synthesizeStream(text)) {
@@ -3320,32 +5107,51 @@ var LMNTTTS = class {
     }
     return Buffer.concat(chunks);
   }
-  /** Yield audio chunks as they arrive — raw PCM_S16LE by default. */
+  /**
+   * Yield audio chunks as they arrive. With the default `audioEncoding=PCM`
+   * these are raw PCM_S16LE bytes at `sampleRate`.
+   */
   async *synthesizeStream(text) {
     const response = await fetch(this.baseUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
-        "X-API-Key": this.apiKey
+        Authorization: `Basic ${this.authToken}`
       },
       body: JSON.stringify(this.buildPayload(text)),
-      signal: AbortSignal.timeout(3e4)
+      signal: AbortSignal.timeout(6e4)
     });
     if (!response.ok) {
       const body = await response.text();
-      throw new Error(`LMNT TTS error ${response.status}: ${body}`);
+      throw new Error(`Inworld TTS error ${response.status}: ${body}`);
     }
     if (!response.body) {
-      throw new Error("LMNT TTS: no response body");
+      throw new Error("Inworld TTS: no response body");
     }
     const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buffered = "";
     try {
       while (true) {
         const { done, value } = await reader.read();
-        if (done) break;
-        if (value && value.length > 0) {
-          yield Buffer.from(value);
+        if (done) {
+          buffered += decoder.decode();
+          break;
         }
+        buffered += decoder.decode(value, { stream: true });
+        let newlineIdx;
+        while ((newlineIdx = buffered.indexOf("\n")) >= 0) {
+          const line = buffered.slice(0, newlineIdx).trim();
+          buffered = buffered.slice(newlineIdx + 1);
+          if (!line) continue;
+          const audio = decodeNdjsonLine(line);
+          if (audio && audio.length > 0) yield audio;
+        }
+      }
+      const tail = buffered.trim();
+      if (tail) {
+        const audio = decodeNdjsonLine(tail);
+        if (audio && audio.length > 0) yield audio;
       }
     } finally {
       if (typeof reader.cancel === "function")
@@ -3355,15 +5161,28 @@ var LMNTTTS = class {
     }
   }
 };
+function decodeNdjsonLine(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const result = parsed.result;
+  const audioB64 = result?.audioContent;
+  if (typeof audioB64 !== "string" || audioB64.length === 0) return null;
+  return Buffer.from(audioB64, "base64");
+}
 
-// src/tts/lmnt.ts
-var TTS5 = class extends LMNTTTS {
-  static providerKey = "lmnt";
+// src/tts/inworld.ts
+var TTS7 = class extends InworldTTS {
+  static providerKey = "inworld";
   constructor(opts = {}) {
-    const key = opts.apiKey ?? process.env.LMNT_API_KEY;
+    const key = opts.apiKey ?? process.env.INWORLD_API_KEY;
     if (!key) {
       throw new Error(
-        "LMNT TTS requires an apiKey. Pass { apiKey: '...' } or set LMNT_API_KEY in the environment."
+        "Inworld TTS requires an apiKey. Pass { apiKey: '...' } or set INWORLD_API_KEY in the environment."
       );
     }
     const { apiKey: _ignored, ...rest } = opts;
@@ -3373,6 +5192,7 @@ var TTS5 = class extends LMNTTTS {
 };
 
 // src/llm/openai.ts
+init_esm_shims();
 var LLM = class extends OpenAILLMProvider {
   static providerKey = "openai";
   constructor(opts = {}) {
@@ -3397,10 +5217,24 @@ var LLM = class extends OpenAILLMProvider {
   }
 };
 
+// src/llm/anthropic.ts
+init_esm_shims();
+
 // src/providers/anthropic-llm.ts
+init_esm_shims();
 var DEFAULT_ANTHROPIC_URL = "https://api.anthropic.com/v1/messages";
 var DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
-var DEFAULT_MODEL = "claude-haiku-4-5-20251001";
+var AnthropicModel = {
+  CLAUDE_HAIKU_4_5_ALIAS: "claude-haiku-4-5",
+  CLAUDE_SONNET_4_6_ALIAS: "claude-sonnet-4-6",
+  CLAUDE_OPUS_4_7_ALIAS: "claude-opus-4-7",
+  CLAUDE_3_5_SONNET_ALIAS: "claude-3-5-sonnet-latest",
+  CLAUDE_3_5_HAIKU_ALIAS: "claude-3-5-haiku-latest",
+  CLAUDE_HAIKU_4_5_20251001: "claude-haiku-4-5-20251001",
+  CLAUDE_3_5_SONNET_20241022: "claude-3-5-sonnet-20241022",
+  CLAUDE_3_5_HAIKU_20241022: "claude-3-5-haiku-20241022"
+};
+var DEFAULT_MODEL = AnthropicModel.CLAUDE_HAIKU_4_5_20251001;
 var DEFAULT_MAX_TOKENS = 1024;
 var PROMPT_CACHING_BETA = "prompt-caching-2024-07-31";
 var AnthropicLLMProvider = class {
@@ -3425,7 +5259,8 @@ var AnthropicLLMProvider = class {
     this.anthropicVersion = options.anthropicVersion ?? DEFAULT_ANTHROPIC_VERSION;
     this.promptCaching = options.promptCaching ?? true;
   }
-  async *stream(messages, tools) {
+  /** Stream Patter-format LLM chunks for the given OpenAI-style chat history. */
+  async *stream(messages, tools, opts) {
     const { system, messages: anthropicMessages } = toAnthropicMessages(messages);
     const anthropicTools = tools ? toAnthropicTools(tools) : null;
     const body = {
@@ -3473,7 +5308,7 @@ var AnthropicLLMProvider = class {
       method: "POST",
       headers,
       body: JSON.stringify(body),
-      signal: AbortSignal.timeout(3e4)
+      signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(3e4))
     });
     if (!response.ok) {
       const errText = await response.text();
@@ -3636,12 +5471,28 @@ var LLM2 = class extends AnthropicLLMProvider {
   }
 };
 
+// src/llm/groq.ts
+init_esm_shims();
+
+// src/providers/groq-llm.ts
+init_esm_shims();
+
 // src/version.ts
-var VERSION = "0.5.3";
+init_esm_shims();
+var VERSION = "0.5.5";
 
 // src/providers/groq-llm.ts
 var GROQ_BASE_URL = "https://api.groq.com/openai/v1";
-var DEFAULT_MODEL2 = "llama-3.3-70b-versatile";
+var GroqModel = {
+  LLAMA_3_3_70B_VERSATILE: "llama-3.3-70b-versatile",
+  LLAMA_3_1_8B_INSTANT: "llama-3.1-8b-instant",
+  LLAMA_3_3_70B_SPECDEC: "llama-3.3-70b-specdec",
+  LLAMA_3_70B: "llama3-70b-8192",
+  LLAMA_3_8B: "llama3-8b-8192",
+  MIXTRAL_8X7B: "mixtral-8x7b-32768",
+  GEMMA2_9B: "gemma2-9b-it"
+};
+var DEFAULT_MODEL2 = GroqModel.LLAMA_3_3_70B_VERSATILE;
 var GroqLLMProvider = class {
   apiKey;
   model;
@@ -3676,7 +5527,8 @@ var GroqLLMProvider = class {
     this.presencePenalty = options.presencePenalty;
     this.stop = options.stop;
   }
-  async *stream(messages, tools) {
+  /** Stream Patter-format LLM chunks from the Groq chat completions API. */
+  async *stream(messages, tools, opts) {
     const body = {
       model: this.model,
       messages,
@@ -3704,7 +5556,7 @@ var GroqLLMProvider = class {
         "User-Agent": `getpatter/${VERSION}`
       },
       body: JSON.stringify(body),
-      signal: AbortSignal.timeout(3e4)
+      signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(3e4))
     });
     if (!response.ok) {
       const errText = await response.text();
@@ -3794,9 +5646,20 @@ var LLM3 = class extends GroqLLMProvider {
   }
 };
 
+// src/llm/cerebras.ts
+init_esm_shims();
+
 // src/providers/cerebras-llm.ts
+init_esm_shims();
 var CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
-var DEFAULT_MODEL3 = "llama3.1-8b";
+var CerebrasModel = {
+  GPT_OSS_120B: "gpt-oss-120b",
+  LLAMA_3_1_8B: "llama3.1-8b",
+  LLAMA_3_3_70B: "llama-3.3-70b",
+  QWEN_3_235B_INSTRUCT: "qwen-3-235b-a22b-instruct-2507",
+  ZAI_GLM_4_7: "zai-glm-4.7"
+};
+var DEFAULT_MODEL3 = CerebrasModel.GPT_OSS_120B;
 var RETRY_BACKOFF_BASE_MS = 500;
 var CerebrasLLMProvider = class {
   apiKey;
@@ -3834,7 +5697,8 @@ var CerebrasLLMProvider = class {
     this.presencePenalty = options.presencePenalty;
     this.stop = options.stop;
   }
-  async *stream(messages, tools) {
+  /** Stream Patter-format LLM chunks from the Cerebras chat completions API. */
+  async *stream(messages, tools, opts) {
     const body = {
       model: this.model,
       messages,
@@ -3876,7 +5740,7 @@ var CerebrasLLMProvider = class {
         method: "POST",
         headers,
         body: payload,
-        signal: AbortSignal.timeout(3e4)
+        signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(3e4))
       });
       if (response.ok) {
         yield* parseOpenAISseStream(response);
@@ -3979,8 +5843,20 @@ var LLM4 = class extends CerebrasLLMProvider {
   }
 };
 
+// src/llm/google.ts
+init_esm_shims();
+
 // src/providers/google-llm.ts
-var DEFAULT_MODEL4 = "gemini-2.5-flash";
+init_esm_shims();
+var GoogleModel = {
+  GEMINI_2_5_FLASH: "gemini-2.5-flash",
+  GEMINI_2_5_PRO: "gemini-2.5-pro",
+  GEMINI_2_0_FLASH: "gemini-2.0-flash",
+  GEMINI_2_0_FLASH_LITE: "gemini-2.0-flash-lite",
+  GEMINI_1_5_FLASH: "gemini-1.5-flash",
+  GEMINI_1_5_PRO: "gemini-1.5-pro"
+};
+var DEFAULT_MODEL4 = GoogleModel.GEMINI_2_5_FLASH;
 var DEFAULT_BASE_URL3 = "https://generativelanguage.googleapis.com/v1beta";
 var GoogleLLMProvider = class {
   apiKey;
@@ -4000,7 +5876,8 @@ var GoogleLLMProvider = class {
     this.temperature = options.temperature;
     this.maxOutputTokens = options.maxOutputTokens;
   }
-  async *stream(messages, tools) {
+  /** Stream Patter-format LLM chunks from the Gemini SSE endpoint. */
+  async *stream(messages, tools, opts) {
     const { systemInstruction, contents } = toGeminiContents(messages);
     const geminiTools = tools ? toGeminiTools(tools) : null;
     const body = { contents };
@@ -4018,7 +5895,7 @@ var GoogleLLMProvider = class {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(body),
-      signal: AbortSignal.timeout(3e4)
+      signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(3e4))
     });
     if (!response.ok) {
       const errText = await response.text();
@@ -4188,280 +6065,8 @@ 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
+// src/telephony/twilio.ts
+init_esm_shims();
 var Carrier = class {
   kind = "twilio";
   accountSid;
@@ -4484,7 +6089,8 @@ var Carrier = class {
   }
 };
 
-// src/carriers/telnyx.ts
+// src/telephony/telnyx.ts
+init_esm_shims();
 var Carrier2 = class {
   kind = "telnyx";
   apiKey;
@@ -4511,6 +6117,7 @@ var Carrier2 = class {
 };
 
 // src/public-api.ts
+init_esm_shims();
 var DEFAULT_GUARDRAIL_REPLACEMENT = "I'm sorry, I can't respond to that.";
 var Guardrail = class {
   name;
@@ -4560,6 +6167,7 @@ function tool(opts) {
 }
 
 // src/chat-context.ts
+init_esm_shims();
 import { randomUUID } from "crypto";
 function generateId() {
   return randomUUID().replace(/-/g, "").slice(0, 12);
@@ -4585,21 +6193,25 @@ var ChatContext = class _ChatContext {
   // -------------------------------------------------------------------------
   // Add messages
   // -------------------------------------------------------------------------
+  /** Append a user message and return the created `ChatMessage`. */
   addUser(content) {
     const msg = createMessage("user", content);
     this.items = [...this.items, msg];
     return msg;
   }
+  /** Append an assistant message and return the created `ChatMessage`. */
   addAssistant(content) {
     const msg = createMessage("assistant", content);
     this.items = [...this.items, msg];
     return msg;
   }
+  /** Append a system message and return the created `ChatMessage`. */
   addSystem(content) {
     const msg = createMessage("system", content);
     this.items = [...this.items, msg];
     return msg;
   }
+  /** Append a tool-result message tied to a tool-call id. */
   addToolResult(content, toolCallId) {
     const msg = createMessage("tool", content, { toolCallId });
     this.items = [...this.items, msg];
@@ -4608,13 +6220,16 @@ var ChatContext = class _ChatContext {
   // -------------------------------------------------------------------------
   // Access
   // -------------------------------------------------------------------------
+  /** Return a snapshot of all messages currently in the context. */
   getMessages() {
     return [...this.items];
   }
+  /** Return the last `n` messages (or `[]` when `n <= 0`). */
   getLastN(n) {
     if (n <= 0) return [];
     return [...this.items.slice(-n)];
   }
+  /** Number of messages currently in the context. */
   get length() {
     return this.items.length;
   }
@@ -4641,6 +6256,7 @@ var ChatContext = class _ChatContext {
   // -------------------------------------------------------------------------
   // Provider format conversion
   // -------------------------------------------------------------------------
+  /** Convert the conversation to the OpenAI Chat Completions message format. */
   toOpenAI() {
     return this.items.map((msg) => {
       const result = {
@@ -4678,6 +6294,7 @@ var ChatContext = class _ChatContext {
   // -------------------------------------------------------------------------
   // Copy
   // -------------------------------------------------------------------------
+  /** Return a new `ChatContext` with the same messages (independent storage). */
   copy() {
     const ctx = new _ChatContext();
     ctx.items = this.items.map((msg) => ({ ...msg }));
@@ -4686,9 +6303,11 @@ var ChatContext = class _ChatContext {
   // -------------------------------------------------------------------------
   // Serialization
   // -------------------------------------------------------------------------
+  /** Serialize the context to a JSON-safe object. */
   toJSON() {
     return { messages: [...this.items] };
   }
+  /** Reconstruct a `ChatContext` from the result of `toJSON()`. */
   static fromJSON(data) {
     const ctx = new _ChatContext();
     ctx.items = (data.messages ?? []).map((msg) => Object.freeze({ ...msg }));
@@ -4697,6 +6316,7 @@ var ChatContext = class _ChatContext {
 };
 
 // src/services/ivr.ts
+init_esm_shims();
 var DTMF_EVENTS = [
   "0",
   "1",
@@ -4772,16 +6392,19 @@ var TfidfLoopDetector = class {
     this.similarityThreshold = similarityThreshold;
     this.consecutiveThreshold = consecutiveThreshold;
   }
+  /** Forget all previously observed chunks and reset the consecutive-hit counter. */
   reset() {
     this.chunks = [];
     this.consecutiveSimilar = 0;
   }
+  /** Record a new transcript chunk in the rolling window. */
   addChunk(text) {
     this.chunks.push({ text, vec: bagOfWords(text) });
     if (this.chunks.length > this.windowSize) {
       this.chunks = this.chunks.slice(-this.windowSize);
     }
   }
+  /** Returns true once the most recent chunks look like a repeated IVR prompt. */
   checkLoopDetection() {
     if (this.chunks.length < 2) return false;
     const last = this.chunks[this.chunks.length - 1];
@@ -4803,6 +6426,8 @@ var DebouncedCall = class {
     this.callback = callback;
     this.delayMs = delayMs;
   }
+  callback;
+  delayMs;
   timer = null;
   schedule() {
     this.cancel();
@@ -4848,13 +6473,16 @@ var IVRActivity = class {
       this.maxSilenceDurationMs
     );
   }
+  /** Begin tracking transcripts and silence; call once per call. */
   async start() {
     this.started = true;
   }
+  /** Stop tracking and cancel any pending silence timer. */
   async stop() {
     this.debouncedSilence.cancel();
     this.started = false;
   }
+  /** Feed a final user-side transcript chunk into the loop detector. */
   async onUserTranscribed(text) {
     if (!this.started || !text) return;
     if (this.loopDetector !== null) {
@@ -4871,14 +6499,17 @@ var IVRActivity = class {
       }
     }
   }
+  /** Record the current user-turn state (e.g. `"listening"`, `"away"`). */
   noteUserState(state) {
     this.currentUserState = state;
     this.scheduleSilenceCheck();
   }
+  /** Record the current agent-turn state (e.g. `"idle"`, `"listening"`). */
   noteAgentState(state) {
     this.currentAgentState = state;
     this.scheduleSilenceCheck();
   }
+  /** Tool definitions to expose to the LLM (currently only `send_dtmf_events`). */
   get tools() {
     return [this.buildSendDtmfTool()];
   }
@@ -4952,10 +6583,11 @@ var IVRActivity = class {
   }
 };
 
-// src/services/background-audio.ts
-import { promises as fs2 } from "fs";
-import path2 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+// src/audio/background-audio.ts
+init_esm_shims();
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
 var BuiltinAudioClip = {
   CITY_AMBIENCE: "city-ambience.ogg",
   FOREST_AMBIENCE: "forest-ambience.ogg",
@@ -4967,8 +6599,8 @@ var BuiltinAudioClip = {
 };
 function builtinClipPath(clip) {
   const meta = typeof import.meta !== "undefined" ? import.meta : void 0;
-  const here = meta?.url ? path2.dirname(fileURLToPath2(meta.url)) : typeof __dirname !== "undefined" ? __dirname : process.cwd();
-  return path2.resolve(here, "..", "resources", "audio", clip);
+  const here = meta?.url ? path.dirname(fileURLToPath(meta.url)) : typeof __dirname !== "undefined" ? __dirname : process.cwd();
+  return path.resolve(here, "..", "resources", "audio", clip);
 }
 var INT16_MIN = -32768;
 var INT16_MAX = 32767;
@@ -5137,7 +6769,7 @@ var BackgroundAudioPlayer = class {
         return source.decode(source.path);
       case "builtin": {
         const p = builtinClipPath(source.clip);
-        const header = await fs2.readFile(p, { flag: "r" }).then((buf) => buf.subarray(0, 4));
+        const header = await fs.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`);
         }
@@ -5169,6 +6801,7 @@ function isAudioConfig(value) {
 }
 
 // src/providers/twilio-adapter.ts
+init_esm_shims();
 var TWILIO_API_BASE = "https://api.twilio.com/2010-04-01";
 var TwilioAdapter = class _TwilioAdapter {
   accountSid;
@@ -5183,8 +6816,8 @@ var TwilioAdapter = class _TwilioAdapter {
     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}`;
+  async request(method, path2, body) {
+    const url = `${this.baseUrl}/Accounts/${encodeURIComponent(this.accountSid)}${path2}`;
     const headers = { Authorization: this.authHeader };
     if (body) headers["Content-Type"] = "application/x-www-form-urlencoded";
     const response = await fetch(url, {
@@ -5195,7 +6828,7 @@ var TwilioAdapter = class _TwilioAdapter {
     });
     const text = await response.text();
     if (!response.ok) {
-      throw new Error(`Twilio ${method} ${path3} failed: ${response.status} ${text}`);
+      throw new Error(`Twilio ${method} ${path2} failed: ${response.status} ${text}`);
     }
     if (!text) return {};
     try {
@@ -5213,8 +6846,8 @@ var TwilioAdapter = class _TwilioAdapter {
     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 path2 = `/AvailablePhoneNumbers/${country}/Local.json?${queryParts.join("&")}`;
+    const available = await this.request("GET", path2);
     const first = available.available_phone_numbers?.[0]?.phone_number;
     if (!first) {
       throw new Error(`TwilioAdapter: no numbers available for country ${opts.countryCode}`);
@@ -5297,6 +6930,7 @@ var TwilioAdapter = class _TwilioAdapter {
 };
 
 // src/providers/telnyx-adapter.ts
+init_esm_shims();
 import { randomUUID as randomUUID2 } from "crypto";
 var TELNYX_API_BASE = "https://api.telnyx.com/v2";
 var TelnyxAdapter = class {
@@ -5308,8 +6942,8 @@ var TelnyxAdapter = class {
     this.apiKey = apiKey;
     this.connectionId = connectionId;
   }
-  async request(method, path3, body) {
-    const url = `${this.baseUrl}${path3}`;
+  async request(method, path2, body) {
+    const url = `${this.baseUrl}${path2}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`
     };
@@ -5322,7 +6956,7 @@ var TelnyxAdapter = class {
     });
     const text = await response.text();
     if (!response.ok) {
-      throw new Error(`Telnyx ${method} ${path3} failed: ${response.status} ${text}`);
+      throw new Error(`Telnyx ${method} ${path2} failed: ${response.status} ${text}`);
     }
     if (!text) return {};
     try {
@@ -5416,6 +7050,245 @@ var TelnyxAdapter = class {
     }
   }
 };
+
+// src/providers/telnyx-stt.ts
+init_esm_shims();
+import WebSocket7 from "ws";
+var TelnyxSTTSampleRate = {
+  HZ_8000: 8e3,
+  HZ_16000: 16e3,
+  HZ_24000: 24e3
+};
+var TelnyxSTTInputFormat = {
+  WAV: "wav"
+};
+var TELNYX_STT_WS_URL = "wss://api.telnyx.com/v2/speech-to-text/transcription";
+var DEFAULT_SAMPLE_RATE = TelnyxSTTSampleRate.HZ_16000;
+var NUM_CHANNELS = 1;
+function createStreamingWavHeader(sampleRate, numChannels) {
+  const bytesPerSample = 2;
+  const byteRate = sampleRate * numChannels * bytesPerSample;
+  const blockAlign = numChannels * bytesPerSample;
+  const dataSize = 2147483647;
+  const fileSize = 36 + dataSize;
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(fileSize, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(numChannels, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(byteRate, 28);
+  header.writeUInt16LE(blockAlign, 32);
+  header.writeUInt16LE(16, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(dataSize, 40);
+  return header;
+}
+var TelnyxSTT = class {
+  constructor(apiKey, language = "en", transcriptionEngine = "telnyx", sampleRate = DEFAULT_SAMPLE_RATE, baseUrl = TELNYX_STT_WS_URL) {
+    this.apiKey = apiKey;
+    this.language = language;
+    this.transcriptionEngine = transcriptionEngine;
+    this.sampleRate = sampleRate;
+    this.baseUrl = baseUrl;
+  }
+  apiKey;
+  language;
+  transcriptionEngine;
+  sampleRate;
+  baseUrl;
+  ws = null;
+  callbacks = [];
+  headerSent = false;
+  /** Open the streaming WebSocket and arm message handlers. */
+  async connect() {
+    const params = new URLSearchParams({
+      transcription_engine: this.transcriptionEngine,
+      language: this.language,
+      input_format: "wav"
+    });
+    const url = `${this.baseUrl}?${params.toString()}`;
+    this.ws = new WebSocket7(url, {
+      headers: { Authorization: `Bearer ${this.apiKey}` }
+    });
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("Telnyx STT connect timeout")), 1e4);
+      this.ws.once("open", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      this.ws.once("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+    this.ws.on("message", (raw) => {
+      let data;
+      try {
+        data = JSON.parse(raw.toString());
+      } catch {
+        return;
+      }
+      const text = (data.transcript ?? "").trim();
+      if (!text) return;
+      const transcript = {
+        text,
+        isFinal: Boolean(data.is_final),
+        confidence: data.confidence ?? 0
+      };
+      for (const cb of this.callbacks) {
+        cb(transcript);
+      }
+    });
+    this.ws.on("error", (err) => {
+      getLogger().warn(`TelnyxSTT WebSocket error: ${String(err)}`);
+    });
+  }
+  /** Send a binary PCM16 audio chunk; emits the WAV header on the first call. */
+  sendAudio(audio) {
+    if (!this.ws || this.ws.readyState !== WebSocket7.OPEN) return;
+    if (!this.headerSent) {
+      const header = createStreamingWavHeader(this.sampleRate, NUM_CHANNELS);
+      this.ws.send(header);
+      this.headerSent = true;
+    }
+    this.ws.send(audio);
+  }
+  /** Register a transcript listener (max 10 concurrent listeners). */
+  onTranscript(callback) {
+    if (this.callbacks.length >= 10) {
+      getLogger().warn("TelnyxSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback.");
+      this.callbacks[this.callbacks.length - 1] = callback;
+      return;
+    }
+    this.callbacks.push(callback);
+  }
+  /** Close the streaming WebSocket. */
+  close() {
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+};
+
+// src/providers/telnyx-tts.ts
+init_esm_shims();
+import WebSocket8 from "ws";
+var TELNYX_TTS_WS_URL = "wss://api.telnyx.com/v2/text-to-speech/speech";
+var TelnyxTTSVoice = {
+  NATURAL_HD_ASTRA: "Telnyx.NaturalHD.astra",
+  NATURAL_HD_LUNA: "Telnyx.NaturalHD.luna",
+  NATURAL_HD_ATLAS: "Telnyx.NaturalHD.atlas",
+  NATURAL_HD_HERA: "Telnyx.NaturalHD.hera",
+  NATURAL_HD_ZEUS: "Telnyx.NaturalHD.zeus"
+};
+var TelnyxTTSSampleRate = {
+  HZ_8000: 8e3,
+  HZ_16000: 16e3,
+  HZ_24000: 24e3
+};
+var DEFAULT_VOICE = TelnyxTTSVoice.NATURAL_HD_ASTRA;
+var TelnyxTTS = class {
+  constructor(apiKey, voice = DEFAULT_VOICE, baseUrl = TELNYX_TTS_WS_URL) {
+    this.apiKey = apiKey;
+    this.voice = voice;
+    this.baseUrl = baseUrl;
+  }
+  apiKey;
+  voice;
+  baseUrl;
+  /** Collect every audio chunk into a single Buffer. */
+  async synthesize(text) {
+    const chunks = [];
+    for await (const chunk of this.synthesizeStream(text)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+  /**
+   * Stream MP3-encoded audio chunks as they arrive from Telnyx.
+   *
+   * The server sends JSON frames of the shape `{"audio": "<base64-mp3>"}`.
+   * Callers that need PCM must decode the MP3 bytes (e.g. via `ffmpeg`).
+   */
+  async *synthesizeStream(text) {
+    const url = `${this.baseUrl}?voice=${encodeURIComponent(this.voice)}`;
+    const ws = new WebSocket8(url, {
+      headers: { Authorization: `Bearer ${this.apiKey}` }
+    });
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("Telnyx TTS connect timeout")), 1e4);
+      ws.once("open", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      ws.once("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+    const queue = [];
+    const waiters = [];
+    function push(item) {
+      const w = waiters.shift();
+      if (w) {
+        w(item);
+      } else {
+        queue.push(item);
+      }
+    }
+    ws.on("message", (raw) => {
+      let data;
+      try {
+        data = JSON.parse(raw.toString());
+      } catch {
+        getLogger().warn("TelnyxTTS: received invalid JSON");
+        return;
+      }
+      const audioB64 = data.audio;
+      if (!audioB64) return;
+      try {
+        const audioBytes = Buffer.from(audioB64, "base64");
+        if (audioBytes.length > 0) {
+          push(audioBytes);
+        }
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      push(null);
+    });
+    ws.on("error", (err) => {
+      push({ error: err instanceof Error ? err : new Error(String(err)) });
+    });
+    ws.send(JSON.stringify({ text: " " }));
+    ws.send(JSON.stringify({ text }));
+    ws.send(JSON.stringify({ text: "" }));
+    try {
+      while (true) {
+        const item = queue.length > 0 ? queue.shift() : await new Promise((resolve) => waiters.push(resolve));
+        if (item === null) return;
+        if (typeof item === "object" && "error" in item) throw item.error;
+        yield item;
+      }
+    } finally {
+      try {
+        ws.close();
+      } catch {
+      }
+    }
+  }
+};
+
+// src/observability/index.ts
+init_esm_shims();
 export {
   AllProvidersFailedError,
   LLM2 as AnthropicLLM,
@@ -5425,7 +7298,7 @@ export {
   BuiltinAudioClip,
   CallMetricsAccumulator,
   STT4 as CartesiaSTT,
-  TTS3 as CartesiaTTS,
+  TTS4 as CartesiaTTS,
   LLM4 as CerebrasLLM,
   ChatContext,
   CloudflareTunnel,
@@ -5437,6 +7310,8 @@ export {
   ConvAI as ElevenLabsConvAI,
   ElevenLabsConvAIAdapter,
   TTS as ElevenLabsTTS,
+  TTS2 as ElevenLabsWebSocketTTS,
+  ErrorCode,
   EventBus,
   FallbackLLMProvider,
   GEMINI_DEFAULT_INPUT_SR,
@@ -5446,15 +7321,16 @@ export {
   LLM3 as GroqLLM,
   Guardrail,
   IVRActivity,
+  TTS7 as InworldTTS,
   LLMLoop,
-  TTS5 as LMNTTTS,
+  TTS6 as LMNTTTS,
   MetricsStore,
   Ngrok,
   LLM as OpenAILLM,
   OpenAILLMProvider,
   Realtime as OpenAIRealtime,
   OpenAIRealtimeAdapter,
-  TTS2 as OpenAITTS,
+  TTS3 as OpenAITTS,
   STT3 as OpenAITranscribeSTT,
   PartialStreamError,
   Patter,
@@ -5466,7 +7342,7 @@ export {
   ProvisionError,
   RateLimitError,
   RemoteMessageHandler,
-  TTS4 as RimeTTS,
+  TTS5 as RimeTTS,
   SPAN_BARGEIN,
   SPAN_CALL,
   SPAN_ENDPOINT,
@@ -5477,10 +7353,23 @@ export {
   SentenceChunker,
   SileroVAD,
   STT5 as SonioxSTT,
+  SpeechEvents,
+  SpeechmaticsAudioEncoding,
+  SpeechmaticsOperatingPoint,
+  STT7 as SpeechmaticsSTT,
+  SpeechmaticsSampleRate,
+  SpeechmaticsServerMessage,
+  TurnDetectionMode as SpeechmaticsTurnDetectionMode,
   StatefulResampler,
   Static as StaticTunnel,
   Carrier2 as Telnyx,
   TelnyxAdapter,
+  TelnyxSTT,
+  TelnyxSTTInputFormat,
+  TelnyxSTTSampleRate,
+  TelnyxTTS,
+  TelnyxTTSSampleRate,
+  TelnyxTTSVoice,
   TestSession,
   TfidfLoopDetector,
   Tool,
@@ -5501,6 +7390,7 @@ export {
   cartesia,
   createResampler16kTo8k,
   createResampler24kTo16k,
+  createResampler24kTo8k,
   createResampler8kTo16k,
   deepgram,
   defineTool,