getpatter 0.6.3 → 0.6.5

package/dist/index.js

@@ -49,7 +49,7 @@ var init_cjs_shims = __esm({
 });
 
 // src/errors.ts
-var ErrorCode, PatterError, PatterConnectionError, AuthenticationError, ProvisionError, RateLimitError;
+var ErrorCode, PatterError, PatterConfigError, PatterConnectionError, AuthenticationError, ProvisionError, RateLimitError;
 var init_errors = __esm({
   "src/errors.ts"() {
     "use strict";
@@ -85,6 +85,12 @@ var init_errors = __esm({
         this.code = options?.code ?? ErrorCode.INTERNAL;
       }
     };
+    PatterConfigError = class extends PatterError {
+      constructor(message, options) {
+        super(message, { code: options?.code ?? ErrorCode.CONFIG });
+        this.name = "PatterConfigError";
+      }
+    };
     PatterConnectionError = class extends PatterError {
       constructor(message, options) {
         super(message, { code: options?.code ?? ErrorCode.CONNECTION });
@@ -136,6 +142,45 @@ var init_logger = __esm({
 });
 
 // src/providers/openai-realtime.ts
+function validateRealtimeTurnDetection(td) {
+  if (td === void 0) return;
+  if (td.type !== void 0 && td.type !== "server_vad" && td.type !== "semantic_vad") {
+    throw new Error(
+      `RealtimeTurnDetection.type must be 'server_vad' or 'semantic_vad', got ${JSON.stringify(td.type)}`
+    );
+  }
+  if (td.eagerness !== void 0 && td.eagerness !== "low" && td.eagerness !== "medium" && td.eagerness !== "high" && td.eagerness !== "auto") {
+    throw new Error(
+      `RealtimeTurnDetection.eagerness must be one of low|medium|high|auto, got ${JSON.stringify(td.eagerness)}`
+    );
+  }
+  if (td.eagerness !== void 0 && td.type !== "semantic_vad") {
+    throw new Error(
+      "RealtimeTurnDetection.eagerness is only valid when type='semantic_vad'"
+    );
+  }
+}
+function buildTurnDetection(td, opts) {
+  validateRealtimeTurnDetection(td);
+  let detection;
+  if (td?.type === "semantic_vad") {
+    detection = { type: "semantic_vad" };
+    if (td.eagerness !== void 0) detection.eagerness = td.eagerness;
+  } else {
+    detection = {
+      type: td?.type ?? opts.defaultType,
+      threshold: td?.threshold ?? 0.5,
+      prefix_padding_ms: td?.prefixPaddingMs ?? 300,
+      silence_duration_ms: td?.silenceDurationMs ?? opts.defaultSilenceMs
+    };
+  }
+  if (opts.includeResponseGating) {
+    const serverManaged = !(opts.gateResponseOnTranscript ?? false);
+    detection.create_response = serverManaged;
+    detection.interrupt_response = serverManaged;
+  }
+  return detection;
+}
 function estimateAudioMs(chunk, format) {
   if (chunk.length === 0) return 0;
   if (format === OpenAIRealtimeAudioFormat.G711_ULAW || format === OpenAIRealtimeAudioFormat.G711_ALAW)
@@ -196,6 +241,7 @@ var init_openai_realtime = __esm({
         this.tools = tools;
         this.audioFormat = audioFormat;
         this.options = options;
+        this.gateResponseOnTranscript = options.gateResponseOnTranscript ?? false;
       }
       apiKey;
       model;
@@ -225,6 +271,23 @@ var init_openai_realtime = __esm({
       // could have produced, which is what the user actually heard.
       currentResponseFirstAudioAt = null;
       options;
+      // When true, the stream handler waits for the Whisper ``transcript_input``
+      // event before requesting the model response (legacy behavior). When false
+      // (default) the response is requested on ``speech_stopped`` and the
+      // transcript is display-only. Read by the stream handler via
+      // ``getGateResponseOnTranscript()``.
+      gateResponseOnTranscript;
+      /**
+       * Whether the stream handler should gate the model response on the Whisper
+       * transcript (legacy) or fire it on `speech_stopped` (default, decoupled).
+       *
+       * `false` (default) — the response is requested on `speech_stopped`,
+       * independently of Whisper. `true` — the response is requested only after
+       * `transcript_input` passes the hallucination filter.
+       */
+      getGateResponseOnTranscript() {
+        return this.gateResponseOnTranscript;
+      }
       /**
        * Build the production session.update body. Mirrors the body sent
        * inside `connect()` so warmup can apply identical configuration to
@@ -236,16 +299,26 @@ var init_openai_realtime = __esm({
           output_audio_format: this.audioFormat,
           voice: this.voice,
           instructions: this.instructions || "You are a helpful voice assistant. Be concise.",
-          turn_detection: {
-            type: this.options.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
-            threshold: 0.5,
-            prefix_padding_ms: 300,
-            silence_duration_ms: this.options.silenceDurationMs ?? 300
-          },
+          // v1 turn_detection carries NO create_response / interrupt_response
+          // keys. The v1 server defaults (`create_response: true`,
+          // `interrupt_response: true`) ARE the server-managed behaviour we want by
+          // default, so omitting them is equivalent to sending `true` — gating
+          // disabled here. `gateResponseOnTranscript` is still threaded through for
+          // symmetry with the GA builder, but has no wire effect while
+          // includeResponseGating is false.
+          turn_detection: buildTurnDetection(this.options.turnDetection, {
+            defaultType: this.options.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
+            defaultSilenceMs: this.options.silenceDurationMs ?? 300,
+            includeResponseGating: false,
+            gateResponseOnTranscript: this.gateResponseOnTranscript
+          }),
           input_audio_transcription: {
             model: this.options.inputAudioTranscriptionModel ?? OpenAITranscriptionModel.WHISPER_1
           }
         };
+        if (this.options.noiseReduction !== void 0) {
+          config2.input_audio_noise_reduction = { type: this.options.noiseReduction };
+        }
         if (this.options.temperature !== void 0) config2.temperature = this.options.temperature;
         if (this.options.maxResponseOutputTokens !== void 0) {
           config2.max_response_output_tokens = this.options.maxResponseOutputTokens;
@@ -509,6 +582,10 @@ var init_openai_realtime = __esm({
           };
           const timer = setTimeout(() => {
             cleanup();
+            try {
+              ws.close();
+            } catch {
+            }
             reject(new Error("OpenAI Realtime park connect timeout"));
           }, 8e3);
           ws.on("message", onMessage);
@@ -603,20 +680,33 @@ var init_openai_realtime = __esm({
           dispatch("error", { type: "socket_error", message: err?.message ?? String(err) });
         });
       }
-      /** Truncate the in-flight assistant turn and cancel the active response.
+      /** Truncate the in-flight assistant turn's playback offset on the server.
+       *
+       * Sends ONLY ``conversation.item.truncate`` — no ``response.cancel``. This
+       * is the half of barge-in handling that a WebSocket transport MUST always
+       * perform: per OpenAI's docs, the GA server auto-truncates on barge-in only
+       * over WebRTC / SIP; on the WebSocket transport the client is responsible
+       * for telling the server how much of the assistant turn was actually heard.
+       * In server-managed mode (``interrupt_response: true``) the server already
+       * cancels the response itself, so issuing ``response.cancel`` here would be
+       * redundant / rejected — call this method, not {@link cancelResponse}.
        *
        * ``audio_end_ms`` MUST reflect what the caller actually heard, not what
        * the server generated. OpenAI streams audio at 5-10x real-time, so the
        * byte-derived counter overstates playback whenever the consumer cleared
-       * its playout buffer (e.g. ``send_clear``) before the audio reached the
+       * its playout buffer (e.g. ``sendClear``) before the audio reached the
        * speaker. We bound the truncate point by wall-clock time since the first
        * chunk of this response — that's the physical maximum a 1x real-time
        * playback could have produced. Without this cap, OpenAI keeps the full
        * generated assistant text on the transcript, and the model replays /
        * resumes from it on the next turn — manifesting as re-greetings and
        * mid-sentence fragments after a barge-in storm.
+       *
+       * No-op when no response is in flight, keeping it idempotent across stale
+       * callers. Resets per-response tracking so post-truncate late frames and
+       * the next response start clean.
        */
-      cancelResponse() {
+      truncate() {
         if (!this.ws) return;
         if (!this.currentResponseItemId) {
           return;
@@ -636,11 +726,31 @@ var init_openai_realtime = __esm({
         } catch (err) {
           getLogger().debug?.(`conversation.item.truncate failed: ${String(err)}`);
         }
-        this.ws.send(JSON.stringify({ type: "response.cancel" }));
         this.currentResponseItemId = null;
         this.currentResponseAudioMs = 0;
         this.currentResponseFirstAudioAt = null;
       }
+      /** Truncate the in-flight assistant turn AND cancel the active response.
+       *
+       * Sends BOTH ``conversation.item.truncate`` (the played-offset bookkeeping)
+       * AND ``response.cancel``. Use this on the LEGACY client-managed barge-in
+       * path (``gateResponseOnTranscript`` true → ``interrupt_response: false``,
+       * so the server does NOT cancel for us) and for explicit cancels driven by
+       * Patter (e.g. on transfer / hangup). In server-managed mode call
+       * {@link truncate} instead — the server already cancels the response, and an
+       * extra ``response.cancel`` would be redundant / rejected.
+       *
+       * Truncation bounding semantics are identical to {@link truncate}; see its
+       * doc comment for the ``audio_end_ms`` wall-clock cap rationale.
+       */
+      cancelResponse() {
+        if (!this.ws) return;
+        if (!this.currentResponseItemId) {
+          return;
+        }
+        this.truncate();
+        this.ws.send(JSON.stringify({ type: "response.cancel" }));
+      }
       /** Inject a user text turn and request a new response. */
       async sendText(text) {
         this.ws?.send(JSON.stringify({
@@ -685,6 +795,32 @@ var init_openai_realtime = __esm({
           }
         }));
       }
+      /**
+       * Speak a short reassurance filler WITHOUT injecting a `role:user` turn.
+       *
+       * Same no-fake-turn shape as {@link sendFirstMessage}: a bare
+       * `response.create` carrying explicit `instructions`, so the filler is the
+       * assistant's own in-band audio. The reassurance scheduler in the
+       * stream-handler routes here instead of {@link sendText} — which would emit
+       * a `conversation.item.create` with `role:'user'` and falsely show the
+       * caller saying "One moment." in the transcript. Fillers must not imply
+       * success or failure.
+       *
+       * Uses `modalities: ['audio', 'text']` (v1-beta shape). The GA subclass
+       * {@link OpenAIRealtime2Adapter} overrides this with `output_modalities`
+       * and re-injects `audio.output.voice` so the GA endpoint does not reject
+       * the request. Mirrors Python `OpenAIRealtimeAdapter.send_reassurance` in
+       * `providers/openai_realtime.py`.
+       */
+      async sendReassurance(text) {
+        this.ws?.send(JSON.stringify({
+          type: "response.create",
+          response: {
+            modalities: ["audio", "text"],
+            instructions: `Say exactly this and nothing else: "${text}"`
+          }
+        }));
+      }
       /** Submit a tool/function-call result and request the next response. */
       async sendFunctionResult(callId, result) {
         this.ws?.send(JSON.stringify({
@@ -925,7 +1061,12 @@ var init_transcoding = __esm({
        * Resets all state after flushing.
        */
       flush() {
-        this.carry.flush();
+        const carryTail = this.carry.flush();
+        if (carryTail.length > 0) {
+          getLogger().warn(
+            "[patter] StatefulResampler.flush: trailing odd byte discarded \u2014 upstream produced odd-length PCM stream"
+          );
+        }
         if (this.srcRate === 16e3 && this.dstRate === 8e3 && this.firPendingSample !== null) {
           const s = this.firPendingSample;
           const tmp = Buffer.alloc(4);
@@ -1165,44 +1306,46 @@ var init_openai_realtime_2 = __esm({
       buildGASessionConfig() {
         const opts = this.options;
         const fmt = { type: "audio/pcm", rate: 24e3 };
+        const audioInput = {
+          format: fmt,
+          transcription: {
+            model: opts.inputAudioTranscriptionModel ?? OpenAITranscriptionModel.WHISPER_1
+          },
+          // Response creation + barge-in cancellation (issue #154 — hand
+          // turn-taking to the server by default):
+          //  - DEFAULT (`gateResponseOnTranscript` false → SERVER-MANAGED):
+          //    `create_response: true` lets the SERVER auto-create the response
+          //    when it commits the user's audio buffer
+          //    (`input_audio_buffer.committed`). `interrupt_response: true` lets the
+          //    SERVER cancel the in-flight response on its own VAD `speech_started`.
+          //    The e2e model replies immediately, in parallel with the Whisper
+          //    transcript — no transcript wait (~500 ms reclaimed), no client-side
+          //    race. On a WebSocket transport the client STILL must clear the
+          //    carrier buffer (`sendClear`) and `conversation.item.truncate` the
+          //    played offset on barge-in (the server only auto-truncates on
+          //    WebRTC/SIP), but it does NOT send `response.cancel`. Whisper is
+          //    display-only — it can never trigger / gate / cancel the response.
+          //  - LEGACY (`gateResponseOnTranscript` true → CLIENT-MANAGED opt-out):
+          //    `create_response: false` + `interrupt_response: false` so the stream
+          //    handler drives `response.create` (after the hallucination filter)
+          //    and `response.cancel` (on barge-in) itself. Escape hatch for no-AEC
+          //    PSTN self-interruption. Both keys are tied to the same switch inside
+          //    `buildTurnDetection`.
+          turn_detection: buildTurnDetection(opts.turnDetection, {
+            defaultType: opts.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
+            defaultSilenceMs: opts.silenceDurationMs ?? 300,
+            includeResponseGating: true,
+            gateResponseOnTranscript: this.getGateResponseOnTranscript()
+          })
+        };
+        if (opts.noiseReduction !== void 0) {
+          audioInput.noise_reduction = { type: opts.noiseReduction };
+        }
         const config2 = {
           type: "realtime",
           output_modalities: opts.modalities ?? ["audio"],
           audio: {
-            input: {
-              format: fmt,
-              transcription: {
-                model: opts.inputAudioTranscriptionModel ?? OpenAITranscriptionModel.WHISPER_1
-              },
-              // VAD threshold raised back to the OpenAI default (0.5) on
-              // 2026-05-22. The earlier 0.1 tuning (motivated by the
-              // upsampled telephony-band loss in high frequencies) made the
-              // server VAD trigger on the carrier-loopback echo of the
-              // agent's OWN outbound audio in PSTN no-AEC scenarios.
-              // Combined with the default ``turn_detection.create_response:
-              // true``, every phantom ``speech_started`` ended a turn early
-              // and auto-created a new response that the agent immediately
-              // spoke over, leading to a runaway loop where the first
-              // message was repeatedly cut and re-generated.
-              turn_detection: {
-                type: opts.vadType ?? OpenAIRealtimeVADType.SERVER_VAD,
-                threshold: 0.5,
-                prefix_padding_ms: 300,
-                silence_duration_ms: opts.silenceDurationMs ?? 500,
-                // Defer ``response.create`` to the application: when OpenAI's
-                // server VAD commits an ``input_audio_buffer.committed`` segment
-                // that turns out to be a Whisper hallucination on silence/echo,
-                // auto-creating a response would generate a phantom turn (the
-                // model reads the hallucinated text as user input). Patter
-                // triggers ``response.create`` explicitly in the Realtime
-                // stream-handler AFTER validating ``transcript_input`` against
-                // the hallucination filter. Pair with ``interrupt_response:
-                // false`` so server VAD also leaves in-flight responses alone —
-                // barge-in is gated client-side.
-                create_response: false,
-                interrupt_response: false
-              }
-            },
+            input: audioInput,
             output: {
               format: fmt,
               voice: this.voice
@@ -1255,14 +1398,7 @@ var init_openai_realtime_2 = __esm({
               if (t && t in GA_TO_V1_EVENT_NAMES) {
                 const newType = GA_TO_V1_EVENT_NAMES[t];
                 if (t === "response.output_audio.delta" && typeof parsed.delta === "string") {
-                  const mulaw = this.transcodeOutboundPcm24ToMulaw8Buffer(parsed.delta);
-                  const FRAME_BYTES = 160;
-                  if (mulaw.length === 0) return;
-                  for (let off = 0; off < mulaw.length; off += FRAME_BYTES) {
-                    const slice = mulaw.subarray(off, Math.min(off + FRAME_BYTES, mulaw.length));
-                    const frame = { ...parsed, type: newType, delta: slice.toString("base64") };
-                    handler(Buffer.from(JSON.stringify(frame)), ...rest);
-                  }
+                  this.translateGaAudioDelta(parsed, handler, rest);
                   return;
                 }
                 parsed.type = newType;
@@ -1291,6 +1427,7 @@ var init_openai_realtime_2 = __esm({
               sessionCreated = true;
               ws.send(JSON.stringify({ type: "session.update", session: this.buildGASessionConfig() }));
             } else if (msg.type === "session.updated") {
+              this.warnIfOutputFormatUnexpected(msg);
               cleanup();
               resolve2();
             } else if (msg.type === "error") {
@@ -1396,6 +1533,10 @@ var init_openai_realtime_2 = __esm({
           };
           const timer = setTimeout(() => {
             cleanup();
+            try {
+              ws.close();
+            } catch {
+            }
             reject(new Error("OpenAI Realtime 2 park connect timeout"));
           }, 8e3);
           ws.on("message", onMessage);
@@ -1443,8 +1584,12 @@ var init_openai_realtime_2 = __esm({
               const parsed = JSON.parse(text);
               const t = parsed.type;
               if (t && Object.prototype.hasOwnProperty.call(GA_TO_V1_EVENT_NAMES, t)) {
+                if (t === "response.output_audio.delta" && typeof parsed.delta === "string") {
+                  this.translateGaAudioDelta(parsed, handler, rest);
+                  return;
+                }
                 parsed.type = GA_TO_V1_EVENT_NAMES[t];
-                handler(JSON.stringify(parsed), ...rest);
+                handler(Buffer.from(JSON.stringify(parsed)), ...rest);
                 return;
               }
             } catch {
@@ -1529,6 +1674,55 @@ var init_openai_realtime_2 = __esm({
         }
         return out;
       }
+      /**
+       * Log-only safety net for issue #154. The GA server echoes the *effective*
+       * session config in `session.updated`; we request `audio/pcm` @ 24 kHz and
+       * transcode PCM24→mulaw8 ourselves (see
+       * `transcodeOutboundPcm24ToMulaw8Buffer`). If a future GA schema change ever
+       * made the server return a different output format, that transcode — which
+       * assumes PCM16-LE @ 24 kHz — would silently corrupt audio, exactly the
+       * v1-beta failure mode #154 fixed. Warn so the drift surfaces in logs instead
+       * of as static. Never gates audio.
+       */
+      warnIfOutputFormatUnexpected(msg) {
+        const fmt = msg?.session?.audio?.output?.format;
+        if (!fmt || typeof fmt !== "object") return;
+        if (fmt.type !== "audio/pcm" || fmt.rate != null && fmt.rate !== 24e3) {
+          getLogger().warn(
+            `OpenAI Realtime 2: server-echoed output format ${JSON.stringify(fmt)} differs from the requested audio/pcm@24000 \u2014 the outbound PCM24\u2192mulaw8 transcode assumes PCM16-LE 24 kHz, so carrier audio may be garbled (issue #154). Informational only; audio is not gated on this.`
+          );
+        }
+      }
+      /**
+       * Shared audio-delta translation helper. Transcodes a GA
+       * `response.output_audio.delta` payload (base64 PCM-16-LE 24 kHz)
+       * into mulaw 8 kHz and splits the result into 160-byte (20 ms) frames,
+       * dispatching one synthetic `response.audio.delta` event per frame.
+       *
+       * Called from BOTH the `connect()` shim and the `adoptWebSocket()` shim
+       * so that warm-path (prewarm/adopted) calls receive identical transcoding
+       * to cold-path calls. Without this, adopted sockets forwarded raw PCM-24
+       * to Twilio/Telnyx, producing garbled or silent audio on every warm call.
+       *
+       * @param parsed  - The parsed GA event object (type already checked to be
+       *                  `response.output_audio.delta` with a string `delta`).
+       * @param handler - The downstream message listener to dispatch each frame to.
+       * @param rest    - Extra arguments forwarded from the original `message` event.
+       * @returns `true` if frames were dispatched (caller should return early),
+       *          `false` if the resampler is still warming up (zero output bytes).
+       */
+      translateGaAudioDelta(parsed, handler, rest) {
+        const newType = GA_TO_V1_EVENT_NAMES["response.output_audio.delta"];
+        const mulaw = this.transcodeOutboundPcm24ToMulaw8Buffer(parsed.delta);
+        const FRAME_BYTES = 160;
+        if (mulaw.length === 0) return false;
+        for (let off = 0; off < mulaw.length; off += FRAME_BYTES) {
+          const slice = mulaw.subarray(off, Math.min(off + FRAME_BYTES, mulaw.length));
+          const frame = { ...parsed, type: newType, delta: slice.toString("base64") };
+          handler(Buffer.from(JSON.stringify(frame)), ...rest);
+        }
+        return true;
+      }
       /**
        * Base64 PCM-16-LE 24 kHz → Base64 mulaw 8 kHz. Used by the WS
        * translation shim on each `response.output_audio.delta`. The stateful
@@ -1558,6 +1752,34 @@ var init_openai_realtime_2 = __esm({
         }
         this.ws?.send(JSON.stringify({ type: "response.create", response: responseBody }));
       }
+      /**
+       * Speak a short reassurance filler WITHOUT injecting a `role:user` turn.
+       *
+       * GA-shape sibling of {@link sendFirstMessage} (and override of the base v1
+       * {@link OpenAIRealtimeAdapter.sendReassurance}): a bare `response.create`
+       * carrying explicit `instructions` so the filler is the assistant's own
+       * in-band audio. No `conversation.item.create` with `role:"user"` is
+       * emitted, so the transcript shows no phantom caller line. The GA endpoint
+       * rejects `response.modalities` and does not inherit `audio.output.voice`
+       * for an explicit `response.create`, so — exactly as in
+       * {@link sendFirstMessage} — we send `output_modalities` and re-inject the
+       * voice. Fillers must not imply success or failure.
+       *
+       * Mirrors Python `OpenAIRealtime2Adapter.send_reassurance` in
+       * `providers/openai_realtime_2.py`.
+       */
+      async sendReassurance(text) {
+        if (!this.ws) return;
+        const responseBody = {
+          output_modalities: ["audio"],
+          audio: { output: { voice: this.voice } },
+          instructions: `Say exactly this and nothing else: "${text}"`
+        };
+        if (this.options.reasoningEffort !== void 0) {
+          responseBody.reasoning = { effort: this.options.reasoningEffort };
+        }
+        this.ws.send(JSON.stringify({ type: "response.create", response: responseBody }));
+      }
     };
   }
 });
@@ -2345,11 +2567,25 @@ function calculateRealtimeCachedSavings(usage, pricing, model) {
   const rates = resolveProviderRates(pricing.openai_realtime, model);
   if (rates.unit !== "token") return 0;
   const input = usage.input_token_details ?? {};
-  const cached2 = input.cached_tokens_details ?? {};
   const cachedAudioRate = rates.cached_audio_input_per_token ?? rates.audio_input_per_token ?? 0;
   const cachedTextRate = rates.cached_text_input_per_token ?? rates.text_input_per_token ?? 0;
-  const cachedAudio = Math.min(cached2.audio_tokens ?? 0, input.audio_tokens ?? 0);
-  const cachedText = Math.min(cached2.text_tokens ?? 0, input.text_tokens ?? 0);
+  const totalAudio = input.audio_tokens ?? 0;
+  const totalText = input.text_tokens ?? 0;
+  let cachedAudio;
+  let cachedText;
+  const details = input.cached_tokens_details;
+  if (details && (details.audio_tokens !== void 0 || details.text_tokens !== void 0)) {
+    cachedAudio = Math.min(details.audio_tokens ?? 0, totalAudio);
+    cachedText = Math.min(details.text_tokens ?? 0, totalText);
+  } else if (input.cached_tokens && input.cached_tokens > 0) {
+    const totalIn = totalAudio + totalText;
+    const ratio = totalIn > 0 ? input.cached_tokens / totalIn : 0;
+    cachedAudio = Math.min(Math.round(totalAudio * ratio), totalAudio);
+    cachedText = Math.min(Math.round(totalText * ratio), totalText);
+  } else {
+    cachedAudio = 0;
+    cachedText = 0;
+  }
   const fullAudio = cachedAudio * (rates.audio_input_per_token ?? 0);
   const fullText = cachedText * (rates.text_input_per_token ?? 0);
   const discountedAudio = cachedAudio * cachedAudioRate;
@@ -2797,8 +3033,8 @@ function loadTranscriptJsonl(filePath) {
       } catch {
         continue;
       }
-      const tsIso = typeof row.ts === "string" ? Date.parse(row.ts) : NaN;
-      const tsNumeric = typeof row.timestamp === "number" ? row.timestamp * 1e3 : NaN;
+      const tsIso = typeof row.ts === "string" ? Date.parse(row.ts) / 1e3 : NaN;
+      const tsNumeric = typeof row.timestamp === "number" ? row.timestamp : NaN;
       const timestamp = Number.isFinite(tsIso) ? tsIso : Number.isFinite(tsNumeric) ? tsNumeric : 0;
       const userText = typeof row.user_text === "string" ? row.user_text : "";
       const agentText = typeof row.agent_text === "string" ? row.agent_text : "";
@@ -2956,14 +3192,49 @@ var init_store = __esm({
         } else {
           for (let i = this.calls.length - 1; i >= 0; i--) {
             if (this.calls[i].call_id === callId) {
-              this.calls[i].status = status;
-              Object.assign(this.calls[i], extra);
+              this.calls[i] = { ...this.calls[i], status, ...extra };
               break;
             }
           }
         }
         this.publish("call_status", { call_id: callId, status, ...extra });
       }
+      /**
+       * Record a single transcript line (user/assistant) as it becomes known.
+       *
+       * FIX-5 (issue #154): the live forward path for the dashboard transcript.
+       * The Realtime stream handler calls this the moment each line is known — the
+       * user line right after the hallucination filter accepts it, the assistant
+       * line when its turn flushes — keyed by the monotonic ``turnIndex`` reserved
+       * at turn-open (``reserveTurnIndex``). Each line is appended to the active
+       * call's ``transcript`` array and broadcast over SSE as a ``transcript_line``
+       * event so the dashboard can render lines as they arrive and re-sort by
+       * ``(turnIndex, user<assistant)`` — making a late-arriving user line land
+       * ABOVE its agent line. ``recordTurn`` de-dups against the lines pushed here
+       * by ``(turnIndex, role)`` so the metrics path never double-pushes the same
+       * text. Parity with Python ``record_transcript_line``.
+       */
+      recordTranscriptLine(data) {
+        const callId = data.call_id || "";
+        const { role, text, turnIndex } = data;
+        if (!callId || role !== "user" && role !== "assistant" || !text) return;
+        const active = this.activeCalls.get(callId);
+        if (active) {
+          if (!active.transcript) active.transcript = [];
+          active.transcript.push({
+            role,
+            text,
+            timestamp: Date.now() / 1e3,
+            turnIndex
+          });
+        }
+        this.publish("transcript_line", {
+          call_id: callId,
+          turnIndex,
+          role,
+          text
+        });
+      }
       /** Append a single conversation turn to an active call and broadcast it via SSE. */
       recordTurn(data) {
         const callId = data.call_id || "";
@@ -2978,14 +3249,19 @@ var init_store = __esm({
           const userText = typeof turnRecord.user_text === "string" ? turnRecord.user_text : "";
           const agentText = typeof turnRecord.agent_text === "string" ? turnRecord.agent_text : "";
           const ts = typeof turnRecord.timestamp === "number" ? turnRecord.timestamp : Date.now() / 1e3;
-          if (userText.length > 0) {
-            active.transcript.push({ role: "user", text: userText, timestamp: ts });
+          const turnIndex = typeof turnRecord.turn_index === "number" ? turnRecord.turn_index : void 0;
+          const alreadyLive = (role) => turnIndex !== void 0 && (active.transcript ?? []).some(
+            (e) => e.turnIndex === turnIndex && e.role === role
+          );
+          if (userText.length > 0 && !alreadyLive("user")) {
+            active.transcript.push({ role: "user", text: userText, timestamp: ts, turnIndex });
           }
-          if (agentText.length > 0 && agentText !== "[interrupted]") {
+          if (agentText.length > 0 && agentText !== "[interrupted]" && !alreadyLive("assistant")) {
             active.transcript.push({
               role: "assistant",
               text: agentText,
-              timestamp: ts
+              timestamp: ts,
+              turnIndex
             });
           }
         }
@@ -3058,7 +3334,7 @@ var init_store = __esm({
       getCall(callId) {
         if (this.deletedCallIds.has(callId)) return null;
         for (let i = this.calls.length - 1; i >= 0; i--) {
-          if (this.calls[i].call_id === callId) return this.calls[i];
+          if (this.calls[i].call_id === callId) return { ...this.calls[i] };
         }
         return null;
       }
@@ -3100,7 +3376,9 @@ var init_store = __esm({
         }
         if (accepted.length === 0) return [];
         accepted.sort();
-        this.persistDeletedIds();
+        this.persistDeletedIds().catch(
+          (err) => getLogger().debug(`MetricsStore.deleteCalls: persistDeletedIds failed: ${String(err)}`)
+        );
         this.publish("calls_deleted", { call_ids: accepted });
         return accepted;
       }
@@ -3112,19 +3390,19 @@ var init_store = __esm({
       getDeletedCallIds() {
         return Array.from(this.deletedCallIds).sort();
       }
-      /** Atomically persist the deleted-ids set to disk. Best-effort. */
-      persistDeletedIds() {
+      /** Atomically persist the deleted-ids set to disk. Best-effort async. */
+      async persistDeletedIds() {
         if (this.deletedIdsPath === null) return;
         try {
           const dir = path2.dirname(this.deletedIdsPath);
-          fs2.mkdirSync(dir, { recursive: true });
+          await fs2.promises.mkdir(dir, { recursive: true });
           const tmp = this.deletedIdsPath + ".tmp";
           const payload = {
             version: 1,
             deleted_call_ids: Array.from(this.deletedCallIds).sort()
           };
-          fs2.writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf8");
-          fs2.renameSync(tmp, this.deletedIdsPath);
+          await fs2.promises.writeFile(tmp, JSON.stringify(payload, null, 2), "utf8");
+          await fs2.promises.rename(tmp, this.deletedIdsPath);
         } catch (err) {
           getLogger().debug(
             `MetricsStore.persistDeletedIds: ${String(err)}`
@@ -3133,7 +3411,8 @@ var init_store = __esm({
       }
       /** Look up an active call by id (returns undefined if not active or unknown). */
       getActive(callId) {
-        return this.activeCalls.get(callId);
+        const rec = this.activeCalls.get(callId);
+        return rec !== void 0 ? { ...rec } : void 0;
       }
       /** Return all currently active (not yet ended) calls. */
       getActiveCalls() {
@@ -3460,8 +3739,8 @@ function mountDashboard(app, store, token = "") {
     res.type("text/html").send(DASHBOARD_HTML);
   });
   app.get("/api/dashboard/calls", auth2, (req, res) => {
-    const limit = Math.min(parseInt(req.query.limit || "50", 10) || 50, 1e3);
-    const offset = parseInt(req.query.offset || "0", 10) || 0;
+    const limit = Math.min(Math.max(0, parseInt(req.query.limit || "50", 10) || 50), 1e3);
+    const offset = Math.max(0, parseInt(req.query.offset || "0", 10) || 0);
     res.json(store.getCalls(limit, offset));
   });
   app.get("/api/dashboard/calls/:callId", auth2, (req, res) => {
@@ -3551,8 +3830,8 @@ data: ${data}
 function mountApi(app, store, token = "") {
   const auth2 = makeAuthMiddleware(token);
   app.get("/api/v1/calls", auth2, (req, res) => {
-    const limit = Math.min(parseInt(req.query.limit || "50", 10) || 50, 1e3);
-    const offset = parseInt(req.query.offset || "0", 10) || 0;
+    const limit = Math.min(Math.max(0, parseInt(req.query.limit || "50", 10) || 50), 1e3);
+    const offset = Math.max(0, parseInt(req.query.offset || "0", 10) || 0);
     const calls = store.getCalls(limit, offset);
     res.json({
       data: calls,
@@ -3831,14 +4110,31 @@ var init_remote_message = __esm({
           while (chunks.length > 0) {
             yield chunks.shift();
           }
+          const READ_TIMEOUT_MS = 3e4;
           while (!done && !error2) {
-            const text = await new Promise((resolve2) => {
+            const messagePromise = new Promise((resolve2) => {
               if (chunks.length > 0) {
                 resolve2(chunks.shift());
               } else {
                 resolveNext = resolve2;
               }
             });
+            let timeoutHandle;
+            const timeoutPromise = new Promise((_, reject) => {
+              timeoutHandle = setTimeout(
+                () => reject(new Error("WebSocket read timeout: no frame received within 30 s")),
+                READ_TIMEOUT_MS
+              );
+            });
+            let text;
+            try {
+              text = await Promise.race([messagePromise, timeoutPromise]);
+            } catch (timeoutErr) {
+              resolveNext = null;
+              throw timeoutErr;
+            } finally {
+              clearTimeout(timeoutHandle);
+            }
             if (text === null) break;
             yield text;
           }
@@ -4080,18 +4376,6 @@ var init_deepgram_stt = __esm({
         } catch {
           return;
         }
-        const dataType = String(data.type ?? "unknown");
-        if (dataType === "Results") {
-          const transcript2 = (data.channel?.alternatives?.[0]?.transcript ?? "").trim();
-          const isFinal = Boolean(data.is_final);
-          const speechFinal2 = Boolean(data.speech_final);
-          const fromFinalize = Boolean(data.from_finalize);
-          getLogger().info(
-            `[DIAG] DG Results text=${JSON.stringify(transcript2.slice(0, 60))} isFinal=${isFinal} speechFinal=${speechFinal2} fromFinalize=${fromFinalize}`
-          );
-        } else if (dataType !== "Metadata") {
-          getLogger().info(`[DIAG] DG event type=${dataType}`);
-        }
         if (data.type === "Metadata" && data.request_id) {
           this.requestId = data.request_id;
           return;
@@ -4181,7 +4465,7 @@ var init_deepgram_stt = __esm({
         if (!this.ws || this.ws.readyState !== import_ws4.default.OPEN) {
           this.audioDroppedCount++;
           if (this.audioDroppedCount === 1 || this.audioDroppedCount % 50 === 0) {
-            getLogger().info(
+            getLogger().debug(
               `[DIAG] DeepgramSTT.sendAudio dropped (ws state=${this.ws?.readyState ?? "null"}) \u2014 total dropped=${this.audioDroppedCount}`
             );
           }
@@ -4190,7 +4474,7 @@ var init_deepgram_stt = __esm({
         if (audio.length === 0) return;
         this.audioSentCount++;
         if (this.audioSentCount === 1 || this.audioSentCount % 100 === 0) {
-          getLogger().info(
+          getLogger().debug(
             `[DIAG] DeepgramSTT.sendAudio: total chunks sent=${this.audioSentCount} (last=${audio.length} bytes)`
           );
         }
@@ -4228,16 +4512,16 @@ var init_deepgram_stt = __esm({
       finalize() {
         const ws = this.ws;
         if (!ws || ws.readyState !== import_ws4.default.OPEN) {
-          getLogger().info(
+          getLogger().debug(
             `[DIAG] DeepgramSTT.finalize SKIPPED (ws state=${ws?.readyState ?? "null"})`
           );
           return;
         }
         try {
           ws.send(JSON.stringify({ type: "Finalize" }));
-          getLogger().info("[DIAG] DeepgramSTT.finalize sent {type:Finalize}");
+          getLogger().debug("[DIAG] DeepgramSTT.finalize sent {type:Finalize}");
         } catch (err) {
-          getLogger().info(`[DIAG] DeepgramSTT.finalize send failed: ${String(err)}`);
+          getLogger().debug(`[DIAG] DeepgramSTT.finalize send failed: ${String(err)}`);
         }
       }
       /** Send Finalize, briefly drain trailing transcripts, then close the socket. */
@@ -4317,6 +4601,7 @@ var init_metrics = __esm({
       _pricing;
       _callStart;
       _turns = [];
+      // mutable internal array; immutable when exposed via TurnMetrics[] → readonly TurnMetrics[]
       // Per-turn timing state
       _turnStart = null;
       _sttComplete = null;
@@ -4403,6 +4688,16 @@ var init_metrics = __esm({
        * (the common cause of missing endpoint signals).
        */
       _endpointSignalMissingCount = 0;
+      /**
+       * Monotonic per-call turn counter. Reserved at turn OPEN
+       * (``onAdapterSpeechStopped`` / ``speech_stopped``) via
+       * ``reserveTurnIndex()`` and threaded through the buffering pipeline into
+       * ``recordTurnComplete`` / ``recordTurnInterrupted`` as ``preReservedIndex``.
+       * This makes ``turn_index`` stable under drops / interrupts (previously it
+       * was assigned at completion as ``this._turns.length``, which shifted when a
+       * turn was dropped). Parity with Python ``_next_turn_index``.
+       */
+      _nextTurnIndex = 0;
       constructor(opts) {
         this.callId = opts.callId;
         this.providerMode = opts.providerMode;
@@ -4451,12 +4746,27 @@ var init_metrics = __esm({
         this._turnUserText = "";
         this._turnSttAudioSeconds = 0;
         this._turnAlreadyClosed = false;
+        this._initialTtfbEmitted = false;
         this._vadStoppedAt = null;
         this._sttFinalAt = null;
         this._turnCommittedAt = null;
         this._onUserTurnCompletedDelayMs = null;
         this._eventBus?.emit("turn_started", { callId: this.callId });
       }
+      /**
+       * Reserve and return the next monotonic turn index.
+       *
+       * Called once per turn at the moment the turn OPENS (Realtime:
+       * ``onAdapterSpeechStopped``). The returned index is threaded through the
+       * buffering pipeline and handed back to ``recordTurnComplete`` /
+       * ``recordTurnInterrupted`` as ``preReservedIndex`` so the emitted
+       * ``turn_index`` matches the live per-line transcript ordering even when a
+       * turn is dropped or interrupted between open and close. Parity with Python
+       * ``reserve_turn_index``.
+       */
+      reserveTurnIndex() {
+        return this._nextTurnIndex++;
+      }
       /**
        * Start a new turn only if no turn is currently open.
        * Use this at inbound-audio ingestion points so the turn timer begins
@@ -4494,6 +4804,7 @@ var init_metrics = __esm({
       anchorUserSpeechStart() {
         if (this._turnCommittedMono !== null) return;
         this._turnStart = hrTimeMs();
+        this._turnAlreadyClosed = false;
         this._endpointSignalAt = null;
         this._vadStoppedAt = null;
         this._sttFinalAt = null;
@@ -4617,11 +4928,14 @@ var init_metrics = __esm({
        * ``user_text=''``. The caller treats ``null`` as "nothing to emit";
        * ``emitTurnMetrics`` is already null-safe.
        */
-      recordTurnComplete(agentText) {
+      recordTurnComplete(agentText, preReservedIndex) {
         if (this._turnAlreadyClosed) return null;
         const latency = this._computeTurnLatency();
         const turn = {
-          turn_index: this._turns.length,
+          // Use the pre-reserved index (stable across drops/interrupts) when the
+          // caller threaded one through; otherwise fall back to the append
+          // position for back-compat with callers that never reserved.
+          turn_index: preReservedIndex ?? this._turns.length,
           user_text: this._turnUserText,
           agent_text: agentText,
           latency,
@@ -4630,10 +4944,10 @@ var init_metrics = __esm({
           timestamp: Date.now() / 1e3
         };
         this._turns.push(turn);
-        this._resetTurnState();
-        this._turnAlreadyClosed = true;
         this._eventBus?.emit("turn_ended", { callId: this.callId, turn });
         this._eventBus?.emit("metrics_collected", { callId: this.callId, turn });
+        this._resetTurnState();
+        this._turnAlreadyClosed = true;
         return turn;
       }
       /**
@@ -4645,12 +4959,12 @@ var init_metrics = __esm({
        * a future refactor that reorders the bargein + LLM-unwind paths)
        * from overwriting a turn that the complete path already emitted.
        */
-      recordTurnInterrupted() {
+      recordTurnInterrupted(preReservedIndex) {
         if (this._turnStart === null) return null;
         if (this._turnAlreadyClosed) return null;
         const latency = this._computeTurnLatency();
         const turn = {
-          turn_index: this._turns.length,
+          turn_index: preReservedIndex ?? this._turns.length,
           user_text: this._turnUserText,
           agent_text: "[interrupted]",
           latency,
@@ -4702,8 +5016,10 @@ var init_metrics = __esm({
       }
       /**
        * Record the delta (ms) between turn-committed and when on_user_turn_completed
-       * pipeline hook finished.  Stored for inclusion in the next ``emitEouMetrics``
-       * call (or an explicit re-emit if desired).
+       * pipeline hook finished. Does NOT re-emit: like Python's
+       * ``record_on_user_turn_completed_delay``, this only stores the value; the
+       * single EOU emission happens on ``recordTurnCommitted`` (3-timestamp guard,
+       * delay defaults to 0 if not yet recorded).
        */
       recordOnUserTurnCompletedDelay(delayMs) {
         this._onUserTurnCompletedDelayMs = delayMs;
@@ -4716,7 +5032,7 @@ var init_metrics = __esm({
        * ``transcriptionDelay``       = turnCommitted − vadStopped  (ms)
        * ``onUserTurnCompletedDelay`` = caller-supplied delta (ms) or 0
        */
-      /** Emit `EOUMetrics` once VAD-stop, STT-final, and turn-committed timestamps are all known. */
+      /** Emit `EOUMetrics` once VAD-stop, STT-final, turn-committed, and on_user_turn_completed delay are all known. */
       emitEouMetrics() {
         if (this._vadStoppedAt === null || this._sttFinalAt === null || this._turnCommittedAt === null) {
           return;
@@ -5265,10 +5581,13 @@ var init_circuit_breaker = __esm({
         if (s.state === CircuitBreakerState.OPEN) {
           if (this.clock() - s.openedAt >= this.cooldownMs) {
             s.state = CircuitBreakerState.HALF_OPEN;
+            s.probeInFlight = true;
             return true;
           }
           return false;
         }
+        if (s.probeInFlight) return false;
+        s.probeInFlight = true;
         return true;
       }
       /** Mark a successful execution. Resets the breaker to CLOSED. */
@@ -5278,19 +5597,21 @@ var init_circuit_breaker = __esm({
         s.state = CircuitBreakerState.CLOSED;
         s.consecutiveFailures = 0;
         s.openedAt = 0;
+        s.probeInFlight = false;
       }
       /** Mark a failed execution; trips OPEN once threshold is reached. */
       recordFailure(toolName) {
         if (this.threshold <= 0) return;
         let s = this.state.get(toolName);
         if (!s) {
-          s = { state: CircuitBreakerState.CLOSED, consecutiveFailures: 0, openedAt: 0 };
+          s = { state: CircuitBreakerState.CLOSED, consecutiveFailures: 0, openedAt: 0, probeInFlight: false };
           this.state.set(toolName, s);
         }
         s.consecutiveFailures += 1;
         if (s.consecutiveFailures >= this.threshold) {
           s.state = CircuitBreakerState.OPEN;
           s.openedAt = this.clock();
+          s.probeInFlight = false;
         }
       }
       /**
@@ -5314,6 +5635,10 @@ var init_circuit_breaker = __esm({
 });
 
 // src/llm-loop.ts
+function resolveToolTimeoutMs(toolTimeoutMs, defaultMs) {
+  if (toolTimeoutMs === void 0) return defaultMs;
+  return Math.max(100, Math.min(toolTimeoutMs, MAX_TOOL_TIMEOUT_MS));
+}
 async function invokeHandler(handler, args, callContext, onProgress) {
   const invoked = handler(args, callContext);
   if (invoked && typeof invoked === "object" && typeof invoked[Symbol.asyncIterator] === "function" && typeof invoked.next === "function") {
@@ -5372,7 +5697,7 @@ function mergeAbortSignals(...signals) {
   }
   return controller.signal;
 }
-var DEFAULT_TOOL_MAX_RETRIES, DEFAULT_TOOL_RETRY_DELAY_MS, DEFAULT_TOOL_TIMEOUT_MS, TOOL_MAX_RESPONSE_BYTES, DefaultToolExecutor, OpenAILLMProvider, DEFAULT_PHONE_PREAMBLE, LLMLoop;
+var DEFAULT_TOOL_MAX_RETRIES, DEFAULT_TOOL_RETRY_DELAY_MS, DEFAULT_TOOL_TIMEOUT_MS, MAX_TOOL_TIMEOUT_MS, TOOL_MAX_RESPONSE_BYTES, ToolTimeoutError, DefaultToolExecutor, OpenAILLMProvider, DEFAULT_PHONE_PREAMBLE, LLMLoop;
 var init_llm_loop = __esm({
   "src/llm-loop.ts"() {
     "use strict";
@@ -5385,7 +5710,14 @@ var init_llm_loop = __esm({
     DEFAULT_TOOL_MAX_RETRIES = 2;
     DEFAULT_TOOL_RETRY_DELAY_MS = 500;
     DEFAULT_TOOL_TIMEOUT_MS = 1e4;
+    MAX_TOOL_TIMEOUT_MS = 3e5;
     TOOL_MAX_RESPONSE_BYTES = 1 * 1024 * 1024;
+    ToolTimeoutError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "ToolTimeoutError";
+      }
+    };
     DefaultToolExecutor = class {
       maxRetries;
       retryDelayMs;
@@ -5411,15 +5743,41 @@ var init_llm_loop = __esm({
             retry_after_ms: cooldown
           });
         }
+        const effectiveTimeoutMs = resolveToolTimeoutMs(
+          toolDef.timeoutMs,
+          this.requestTimeoutMs
+        );
         if (toolDef.handler) {
           const totalAttempts = this.maxRetries + 1;
           let lastErr = null;
           for (let attempt = 0; attempt < totalAttempts; attempt++) {
+            let timeoutTimer;
             try {
-              const result = await invokeHandler(toolDef.handler, args, callContext, onProgress);
+              const handlerPromise = invokeHandler(toolDef.handler, args, callContext, onProgress);
+              const result = await Promise.race([
+                handlerPromise,
+                new Promise((_, reject) => {
+                  timeoutTimer = setTimeout(
+                    () => reject(
+                      new ToolTimeoutError(
+                        `Tool handler '${toolDef.name}' timed out after ${effectiveTimeoutMs}ms`
+                      )
+                    ),
+                    effectiveTimeoutMs
+                  );
+                })
+              ]);
               this.breaker.recordSuccess(toolDef.name);
               return result;
             } catch (e) {
+              if (e instanceof ToolTimeoutError) {
+                getLogger().error(String(e));
+                this.breaker.recordFailure(toolDef.name);
+                return JSON.stringify({
+                  error: String(e),
+                  fallback: true
+                });
+              }
               lastErr = e;
               if (attempt < totalAttempts - 1) {
                 getLogger().warn(
@@ -5427,6 +5785,8 @@ var init_llm_loop = __esm({
                 );
                 await new Promise((r) => setTimeout(r, backoffDelayMs(this.retryDelayMs, attempt)));
               }
+            } finally {
+              if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
             }
           }
           this.breaker.recordFailure(toolDef.name);
@@ -5463,7 +5823,10 @@ var init_llm_loop = __esm({
                       ...callContext,
                       attempt: attempt + 1
                     }),
-                    signal: AbortSignal.timeout(this.requestTimeoutMs)
+                    // Use per-tool timeout when set, otherwise fall back to
+                    // the executor-level default. Mirrors Python's per-request
+                    // ``timeout=`` override on httpx.AsyncClient.post().
+                    signal: AbortSignal.timeout(effectiveTimeoutMs)
                   });
                   if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
                   const result = JSON.stringify(await resp.json());
@@ -5589,7 +5952,7 @@ var init_llm_loop = __esm({
           body.tools = tools;
         }
         const signal = mergeAbortSignals(opts?.signal, AbortSignal.timeout(3e4));
-        const response = await fetch("https://api.openai.com/v1/chat/completions", {
+        const response = await fetch(`${this.baseUrl}/chat/completions`, {
           method: "POST",
           headers: {
             "Content-Type": "application/json",
@@ -5609,50 +5972,55 @@ var init_llm_loop = __esm({
         if (!reader) return;
         const decoder = new TextDecoder();
         let buffer = "";
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || !trimmed.startsWith("data: ")) continue;
-            const data = trimmed.slice(6);
-            if (data === "[DONE]") continue;
-            let chunk;
-            try {
-              chunk = JSON.parse(data);
-            } catch {
-              continue;
-            }
-            if (chunk.usage) {
-              const cached2 = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
-              const uncachedInput = Math.max(0, (chunk.usage.prompt_tokens ?? 0) - cached2);
-              yield {
-                type: "usage",
-                inputTokens: uncachedInput,
-                outputTokens: chunk.usage.completion_tokens,
-                cacheReadInputTokens: cached2
-              };
-            }
-            const delta = chunk.choices?.[0]?.delta;
-            if (!delta) continue;
-            if (delta.content) {
-              yield { type: "text", content: delta.content };
-            }
-            if (delta.tool_calls) {
-              for (const tc of delta.tool_calls) {
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              const trimmed = line.trim();
+              if (!trimmed || !trimmed.startsWith("data: ")) continue;
+              const data = trimmed.slice(6);
+              if (data === "[DONE]") continue;
+              let chunk;
+              try {
+                chunk = JSON.parse(data);
+              } catch {
+                continue;
+              }
+              if (chunk.usage) {
+                const cached2 = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
+                const uncachedInput = Math.max(0, (chunk.usage.prompt_tokens ?? 0) - cached2);
                 yield {
-                  type: "tool_call",
-                  index: tc.index,
-                  id: tc.id,
-                  name: tc.function?.name,
-                  arguments: tc.function?.arguments
+                  type: "usage",
+                  inputTokens: uncachedInput,
+                  outputTokens: chunk.usage.completion_tokens,
+                  cacheReadInputTokens: cached2
                 };
               }
+              const delta = chunk.choices?.[0]?.delta;
+              if (!delta) continue;
+              if (delta.content) {
+                yield { type: "text", content: delta.content };
+              }
+              if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                  yield {
+                    type: "tool_call",
+                    index: tc.index,
+                    id: tc.id,
+                    name: tc.function?.name,
+                    arguments: tc.function?.arguments
+                  };
+                }
+              }
             }
           }
+        } finally {
+          reader.cancel().catch(() => {
+          });
         }
       }
     };
@@ -5763,12 +6131,14 @@ ${systemPrompt}` : DEFAULT_PHONE_PREAMBLE;
         const hasAfterLlmResponse = Boolean(hookExecutor?.hasAfterLlmResponse() && hookCtx);
         const hasAfterLlmChunk = Boolean(hookExecutor?.hasAfterLlmChunk());
         const allEmittedText = [];
+        const callId = callContext.call_id;
+        const streamOpts = typeof callId === "string" && callId.length > 0 ? { ...opts, callId } : opts;
         for (let iter = 0; iter < maxIterations; iter++) {
           const toolCallsAccumulated = /* @__PURE__ */ new Map();
           const textParts = [];
           let hasToolCalls = false;
           let usageChunkReceived = false;
-          for await (const chunk of this.provider.stream(messages, this.openaiTools, opts)) {
+          for await (const chunk of this.provider.stream(messages, this.openaiTools, streamOpts)) {
             if (chunk.type === "text" && chunk.content) {
               const content = hasAfterLlmChunk && hookExecutor ? hookExecutor.runAfterLlmChunk(chunk.content) : chunk.content;
               textParts.push(content);
@@ -5786,7 +6156,7 @@ ${systemPrompt}` : DEFAULT_PHONE_PREAMBLE;
                 chunk.inputTokens ?? 0,
                 chunk.outputTokens ?? 0,
                 chunk.cacheReadInputTokens ?? 0,
-                chunk.cacheCreationInputTokens ?? 0
+                chunk.cacheWriteInputTokens ?? 0
               );
             } else if (chunk.type === "tool_call") {
               hasToolCalls = true;
@@ -6180,8 +6550,8 @@ function getElementAtPath(obj, path6) {
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
-  return Promise.all(promises).then((results) => {
+  const promises2 = keys.map((key) => promisesObj[key]);
+  return Promise.all(promises2).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
       resolvedObj[keys[i]] = results[i];
@@ -23972,6 +24342,8 @@ var init_mcp_client = __esm({
     "use strict";
     init_cjs_shims();
     init_logger();
+    init_server();
+    init_version();
     MCPManager = class {
       configs;
       connected = [];
@@ -23997,10 +24369,16 @@ var init_mcp_client = __esm({
         }
         const aggregatedTools = [];
         for (const cfg of this.configs) {
+          try {
+            validateWebhookUrl(cfg.url);
+          } catch (e) {
+            getLogger().error(`MCP server '${cfg.name}' (${cfg.url}) rejected by SSRF guard: ${String(e)}`);
+            continue;
+          }
           const transport = new transportModule.StreamableHTTPClientTransport(new URL(cfg.url), {
             requestInit: { headers: cfg.headers }
           });
-          const client = new mcpModule.Client({ name: "patter", version: "0.6.0" });
+          const client = new mcpModule.Client({ name: "patter", version: VERSION });
           try {
             await client.connect(transport);
           } catch (e) {
@@ -24074,6 +24452,276 @@ var init_mcp_client = __esm({
   }
 });
 
+// src/consult.ts
+function isLoopbackOrPrivateHost(baseUrl) {
+  let host;
+  try {
+    host = new URL(baseUrl).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
+  if (host === "localhost" || host === "0.0.0.0" || host === "::1") return true;
+  if (host.endsWith(".local")) return true;
+  if (/^127\./.test(host) || /^10\./.test(host) || /^192\.168\./.test(host)) return true;
+  if (/^169\.254\./.test(host)) return true;
+  const m = host.match(/^172\.(\d+)\./);
+  if (m) {
+    const octet = Number(m[1]);
+    if (octet >= 16 && octet <= 31) return true;
+  }
+  if (host.includes(":") && (/^f[cd][0-9a-f]{2}:/.test(host) || /^fe[89ab][0-9a-f]:/.test(host))) {
+    return true;
+  }
+  return false;
+}
+function openclawConsult(agent, opts = {}) {
+  if (!agent || !OPENCLAW_AGENT_RE.test(agent)) {
+    throw new Error(
+      "OpenClaw agent must be a non-empty id of letters, digits, and ._:/- only"
+    );
+  }
+  const baseUrl = opts.baseUrl ?? OPENCLAW_DEFAULT_BASE_URL;
+  const model = agent.includes("/") || agent.includes(":") ? agent : `openclaw/${agent}`;
+  return {
+    openaiCompatible: {
+      baseUrl,
+      model,
+      apiKey: opts.apiKey,
+      apiKeyEnv: OPENCLAW_API_KEY_ENV,
+      sessionHeader: OPENCLAW_SESSION_HEADER
+    },
+    timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    toolName: opts.toolName ?? DEFAULT_TOOL_NAME,
+    description: opts.description ?? OPENCLAW_DESCRIPTION,
+    reassurance: opts.reassurance ?? OPENCLAW_REASSURANCE,
+    headers: opts.headers,
+    allowLoopback: opts.allowLoopback ?? isLoopbackOrPrivateHost(baseUrl)
+  };
+}
+function buildConsultTool(config2) {
+  const hasUrl = config2.url != null;
+  const hasOpenAI = config2.openaiCompatible != null;
+  if (hasUrl === hasOpenAI) {
+    throw new Error("ConsultConfig requires exactly one of url or openaiCompatible");
+  }
+  const timeoutMs = config2.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const baseHeaders = {
+    ...config2.headers ?? {},
+    "Content-Type": "application/json"
+  };
+  const handler = hasOpenAI ? buildOpenAIHandler(config2.openaiCompatible, baseHeaders, timeoutMs, config2.allowLoopback ?? false) : buildWebhookHandler(config2.url, baseHeaders, timeoutMs, config2.allowLoopback ?? false);
+  const tool2 = {
+    name: config2.toolName ?? DEFAULT_TOOL_NAME,
+    description: config2.description ?? DEFAULT_DESCRIPTION,
+    parameters: PARAMETERS,
+    handler
+  };
+  return config2.reassurance != null ? { ...tool2, reassurance: config2.reassurance } : tool2;
+}
+function buildWebhookHandler(url2, headers, timeoutMs, allowLoopback) {
+  validateWebhookUrl(url2, allowLoopback);
+  return async (args, context) => {
+    const requestText = typeof args?.request === "string" ? args.request : "";
+    const payload = {
+      request: requestText,
+      call_id: context?.call_id ?? "",
+      caller: context?.caller ?? "",
+      callee: context?.callee ?? ""
+    };
+    let body;
+    try {
+      const resp = await fetch(url2, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!resp.ok) {
+        getLogger().warn(`consult tool: orchestrator returned HTTP ${resp.status}`);
+        return GRACEFUL_FALLBACK;
+      }
+      body = (await resp.text()).slice(0, MAX_RESPONSE_CHARS);
+    } catch (e) {
+      getLogger().warn(
+        `consult tool: orchestrator call failed: ${e instanceof Error ? e.name : "error"}`
+      );
+      return GRACEFUL_FALLBACK;
+    }
+    try {
+      const data = JSON.parse(body);
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        const obj = data;
+        for (const key of REPLY_KEYS) {
+          if (typeof obj[key] === "string") return obj[key];
+        }
+      }
+      return JSON.stringify(data);
+    } catch {
+      return body;
+    }
+  };
+}
+function buildOpenAIHandler(oc, baseHeaders, timeoutMs, allowLoopback) {
+  const endpoint = oc.baseUrl.replace(/\/+$/, "") + "/chat/completions";
+  validateWebhookUrl(endpoint, allowLoopback);
+  const apiKey = oc.apiKey ?? (oc.apiKeyEnv ? process.env[oc.apiKeyEnv] : void 0);
+  const headers = { ...baseHeaders };
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+  const sessionHeader = oc.sessionHeader;
+  const model = oc.model;
+  return async (args, context) => {
+    const requestText = typeof args?.request === "string" ? args.request : "";
+    const callId = context?.call_id ?? "";
+    const caller = context?.caller ?? "";
+    const callee = context?.callee ?? "";
+    const contextLines = ["You are answering an inbound phone call relayed by a voice agent."];
+    if (caller) contextLines.push(`Caller: ${caller}`);
+    if (callee) contextLines.push(`Line dialed: ${callee}`);
+    contextLines.push(
+      "Reply concisely in a spoken, conversational style \u2014 it is read aloud to the caller."
+    );
+    const reqHeaders = { ...headers };
+    if (sessionHeader && callId) reqHeaders[sessionHeader] = callId;
+    const payload = {
+      model,
+      messages: [
+        { role: "system", content: contextLines.join("\n") },
+        { role: "user", content: requestText }
+      ],
+      stream: false
+    };
+    if (callId) payload.user = callId;
+    try {
+      const resp = await fetch(endpoint, {
+        method: "POST",
+        headers: reqHeaders,
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (resp.status === 404) {
+        getLogger().warn(
+          "consult tool: OpenAI-compatible endpoint returned 404 \u2014 is it enabled? (OpenClaw: set gateway.http.endpoints.chatCompletions.enabled = true)"
+        );
+        return GRACEFUL_FALLBACK;
+      }
+      if (!resp.ok) {
+        getLogger().warn(`consult tool: openai-compatible returned HTTP ${resp.status}`);
+        return GRACEFUL_FALLBACK;
+      }
+      const data = await resp.json();
+      const content = data?.choices?.[0]?.message?.content;
+      if (typeof content === "string" && content.trim()) {
+        return content.trim().slice(0, MAX_RESPONSE_CHARS);
+      }
+      getLogger().warn("consult tool: response missing choices[0].message.content");
+      return GRACEFUL_FALLBACK;
+    } catch (e) {
+      getLogger().warn(
+        `consult tool: openai-compatible call failed: ${e instanceof Error ? e.name : "error"}`
+      );
+      return GRACEFUL_FALLBACK;
+    }
+  };
+}
+function buildPostCallRecord(data, includeTranscript) {
+  const lines = [];
+  const caller = data.caller;
+  const callee = data.callee;
+  if (caller) lines.push(`Caller: ${caller}`);
+  if (callee) lines.push(`Line dialed: ${callee}`);
+  const metrics = data.metrics;
+  const duration3 = metrics?.durationSeconds ?? metrics?.duration_seconds;
+  if (typeof duration3 === "number") lines.push(`Duration: ${Math.round(duration3)}s`);
+  if (includeTranscript) {
+    const entries = data.transcript ?? [];
+    const rendered = entries.filter((e) => e && typeof e === "object").map((e) => `${e.role ?? "?"}: ${e.text ?? ""}`).join("\n");
+    if (rendered) lines.push("Transcript:\n" + rendered.slice(0, POSTCALL_MAX_TRANSCRIPT_CHARS));
+  }
+  return lines.length ? lines.join("\n") : "(no call details available)";
+}
+function openclawPostCallNotifier(agent, opts = {}) {
+  const cfg = openclawConsult(agent, {
+    baseUrl: opts.baseUrl,
+    apiKey: opts.apiKey,
+    timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    allowLoopback: opts.allowLoopback
+  });
+  const oc = cfg.openaiCompatible;
+  const endpoint = oc.baseUrl.replace(/\/+$/, "") + "/chat/completions";
+  validateWebhookUrl(endpoint, cfg.allowLoopback ?? false);
+  const apiKey = oc.apiKey ?? (oc.apiKeyEnv ? process.env[oc.apiKeyEnv] : void 0);
+  const sessionHeader = oc.sessionHeader;
+  const model = oc.model;
+  const timeoutMs = cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const includeTranscript = opts.includeTranscript ?? true;
+  const instruction = opts.instruction ?? POSTCALL_INSTRUCTION;
+  return async (data) => {
+    const callId = (data ?? {}).call_id ?? "";
+    const record2 = buildPostCallRecord(data ?? {}, includeTranscript);
+    const headers = { "Content-Type": "application/json" };
+    if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
+    if (sessionHeader && callId) headers[sessionHeader] = callId;
+    const payload = {
+      model,
+      messages: [
+        { role: "system", content: instruction },
+        { role: "user", content: record2 }
+      ],
+      stream: false
+    };
+    if (callId) payload.user = callId;
+    try {
+      const resp = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      if (!resp.ok) {
+        getLogger().warn(`openclaw post-call notify: HTTP ${resp.status}`);
+      }
+    } catch (e) {
+      getLogger().warn(
+        `openclaw post-call notify failed: ${e instanceof Error ? e.name : "error"}`
+      );
+    }
+  };
+}
+var DEFAULT_TIMEOUT_MS, DEFAULT_TOOL_NAME, DEFAULT_DESCRIPTION, MAX_RESPONSE_CHARS, REPLY_KEYS, GRACEFUL_FALLBACK, OPENCLAW_DEFAULT_BASE_URL, OPENCLAW_API_KEY_ENV, OPENCLAW_SESSION_HEADER, OPENCLAW_DESCRIPTION, OPENCLAW_REASSURANCE, OPENCLAW_AGENT_RE, PARAMETERS, POSTCALL_INSTRUCTION, POSTCALL_MAX_TRANSCRIPT_CHARS;
+var init_consult = __esm({
+  "src/consult.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_logger();
+    init_server();
+    DEFAULT_TIMEOUT_MS = 3e4;
+    DEFAULT_TOOL_NAME = "consult_agent";
+    DEFAULT_DESCRIPTION = "Consult your back-office agent for deeper reasoning, fresh information, or actions beyond this call. Use when the caller asks something you cannot answer directly.";
+    MAX_RESPONSE_CHARS = 1e6;
+    REPLY_KEYS = ["reply", "response", "text", "result", "answer", "message"];
+    GRACEFUL_FALLBACK = "I wasn't able to reach the system to get that answer right now.";
+    OPENCLAW_DEFAULT_BASE_URL = "http://127.0.0.1:18789/v1";
+    OPENCLAW_API_KEY_ENV = "OPENCLAW_API_KEY";
+    OPENCLAW_SESSION_HEADER = "x-openclaw-session-key";
+    OPENCLAW_DESCRIPTION = "Consult your OpenClaw agent for anything account-specific \u2014 appointments, customer records, schedules, or actions in the back-office system. NEVER state an appointment time, customer detail, or schedule fact from your own memory; ALWAYS call this tool for those and read back what it returns.";
+    OPENCLAW_REASSURANCE = "Let me check on that for you, one moment.";
+    OPENCLAW_AGENT_RE = /^[A-Za-z0-9._:/-]+$/;
+    PARAMETERS = {
+      type: "object",
+      properties: {
+        request: {
+          type: "string",
+          description: "The question or task to send to your back-office agent for deeper reasoning, fresh information, or an action beyond this call. State it self-containedly \u2014 the dialog history is not forwarded with the consult."
+        }
+      },
+      required: ["request"]
+    };
+    POSTCALL_INSTRUCTION = "A phone call handled by the voice agent has just ended. Here is the record of the call. Log it and follow up if anything needs action.";
+    POSTCALL_MAX_TRANSCRIPT_CHARS = 12e3;
+  }
+});
+
 // src/sentence-chunker.ts
 function splitSentences(text, minSentenceLen = DEFAULT_MIN_SENTENCE_LEN) {
   const alphabets = "([A-Za-z])";
@@ -26616,6 +27264,8 @@ var init_silero_vad = __esm({
       speechThresholdDuration = 0;
       silenceThresholdDuration = 0;
       closed = false;
+      /** Transitions produced in the current processFrame call but not yet returned. */
+      eventQueue = [];
       /**
        * Load the Silero VAD model.
        * Throws if `onnxruntime-node` is not installed.
@@ -26741,22 +27391,21 @@ var init_silero_vad = __esm({
           );
         }
         if (pcmChunk.length === 0) {
-          return null;
+          return this.eventQueue.shift() ?? null;
         }
         const numSamples = Math.floor(pcmChunk.length / 2);
         if (numSamples === 0) {
-          return null;
+          return this.eventQueue.shift() ?? null;
         }
         const samples = new Float32Array(numSamples);
         for (let i = 0; i < numSamples; i++) {
-          samples[i] = pcmChunk.readInt16LE(i * 2) / 32767;
+          samples[i] = pcmChunk.readInt16LE(i * 2) / 32768;
         }
         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);
@@ -26765,10 +27414,10 @@ var init_silero_vad = __esm({
           const windowDuration = windowSize / this.opts.sampleRate;
           const transition = this.advanceState(p, windowDuration);
           if (transition !== null) {
-            event = transition;
+            this.eventQueue.push(transition);
           }
         }
-        return event;
+        return this.eventQueue.shift() ?? null;
       }
       advanceState(p, windowDuration) {
         const opts = this.opts;
@@ -26823,6 +27472,7 @@ var init_silero_vad = __esm({
         this.pubSpeaking = false;
         this.speechThresholdDuration = 0;
         this.silenceThresholdDuration = 0;
+        this.eventQueue = [];
         this.expFilter.reset();
         this.model.reset();
       }
@@ -27063,6 +27713,13 @@ var init_aec = __esm({
 });
 
 // src/stream-handler.ts
+function applyToolCallPreambles(prompt, knob) {
+  if (!knob) return prompt;
+  const block = typeof knob === "string" ? knob : DEFAULT_TOOL_CALL_PREAMBLE_BLOCK;
+  return prompt ? `${block}
+
+${prompt}` : block;
+}
 function checkGuardrails(text, guardrails) {
   if (!guardrails) return null;
   for (const guard of guardrails) {
@@ -27119,6 +27776,13 @@ function augmentWithBuiltinHandoffTools(userTools, callbacks) {
   }
   return out;
 }
+function isSttHallucination(text) {
+  const stripped = text.trim().toLowerCase().replace(/[.,!?;:…。！？\s]+$/u, "").trim();
+  if (stripped === "") return true;
+  if (HALLUCINATIONS.has(stripped)) return true;
+  const pieces = stripped.split(/[.!?…。！？]+/u).map((p) => p.trim()).filter((p) => p.length > 0);
+  return pieces.length > 1 && pieces.every((p) => HALLUCINATIONS.has(p));
+}
 async function queryDeepgramCost(metricsAcc, deepgramKey, deepgramRequestId) {
   try {
     const projResp = await fetch("https://api.deepgram.com/v1/projects", {
@@ -27149,7 +27813,7 @@ async function queryDeepgramCost(metricsAcc, deepgramKey, deepgramRequestId) {
   } catch {
   }
 }
-var HALLUCINATIONS, StreamHandler;
+var DEFAULT_TOOL_CALL_PREAMBLE_BLOCK, HALLUCINATIONS, StreamHandler;
 var init_stream_handler = __esm({
   "src/stream-handler.ts"() {
     "use strict";
@@ -27167,39 +27831,96 @@ var init_stream_handler = __esm({
     init_mcp_client();
     init_logger();
     init_server();
+    init_consult();
     init_sentence_chunker();
     init_pipeline_hooks();
     init_event_bus();
     init_tracing();
+    DEFAULT_TOOL_CALL_PREAMBLE_BLOCK = `# Preambles
+
+Use short preambles only when they help the user understand that work is happening. A preamble is one short spoken update describing the action you are about to take \u2014 not hidden reasoning, and never a claim about the result.
+
+## When to use a preamble
+Use a preamble when:
+- you are about to call a tool that may take noticeable time;
+- you need to reason through a multi-step request;
+- you are checking records, availability, account state, or policy details;
+- you are preparing an escalation or handoff;
+- silence would make the assistant feel unresponsive.
+
+When a preamble is needed, output it immediately before the reasoning or tool call.
+
+## When to NOT use a preamble
+Do not use a preamble when:
+- the answer is direct and can be given immediately;
+- the user is only confirming, correcting, or declining something;
+- the audio is unclear and you need clarification instead;
+- the tool call is lightweight and the user would not benefit from an update.
+
+## Style
+- Keep it to one short sentence (two only before a high-impact action).
+- Vary the wording across turns; do not reuse the same opener.
+- Describe the action, not the internal reasoning.
+- Never imply success or failure before the tool returns.
+
+Prefer:
+- "I'll check that order now."
+- "I'll look up your appointment details."
+- "I'll verify that before we make any changes."
+- "I'll check the policy and then give you the next step."
+- "I'll pull that up so we can make sure it's the right account."
+
+Avoid:
+- "Let me think about that for a second."
+- "Please wait while I process your request."
+- "I'm going to use my tools now."
+- "Hmm..." / "One moment while I process that..."`;
     HALLUCINATIONS = /* @__PURE__ */ new Set([
-      "you",
-      "thank you",
-      "thanks",
-      "yeah",
-      "yes",
-      "no",
-      "okay",
-      "ok",
-      "uh",
-      "um",
-      "mmm",
-      "hmm",
-      ".",
-      "bye",
-      "right",
-      "cool",
-      // Whisper YouTube-caption hallucinations
+      // Issue #154: the hallucination filter is now DISPLAY-ONLY — it no longer
+      // gates response creation (the server drives the response on
+      // ``input_audio_buffer.committed`` by default). Dropping a phrase here
+      // therefore deletes the user's transcript line (recordSttComplete never
+      // fires → empty user_text → dashboard skips the user line). So this set is
+      // restricted to genuine NON-SPEECH artefacts that Whisper emits on
+      // silence / TTS echo, NOT real conversational words. Standalone words like
+      // 'yes', 'no', 'okay', 'right', 'you', 'thanks' were REMOVED — they are
+      // legitimate user replies and must reach the transcript. Parity with
+      // Python ``_STT_HALLUCINATIONS``.
+      //
+      // Whisper caption / training-set hallucinations. Whisper was trained heavily
+      // on captioned video, so on silence / PSTN echo it falls back to the most
+      // common caption credits + sign-offs. Curated from widely-reported
+      // Whisper-on-silence outputs across the open-source ASR community.
       "thank you for watching",
       "thanks for watching",
       "thank you for watching!",
       "thanks for watching!",
       "thank you so much for watching",
+      "thank you for watching please subscribe",
+      "thanks for watching please subscribe",
       "thanks for listening",
+      "we'll see you next time",
+      "see you next time",
+      "bye bye",
       "please subscribe",
+      "please subscribe to my channel",
+      "don't forget to subscribe",
+      "like and subscribe",
       "subscribe",
+      "subtitles by the amara.org community",
+      "subtitles by the amara org community",
+      "subtitles by",
+      "transcribed by",
+      "transcription by castingwords",
+      "the end",
+      // Music / sound markers.
       "music",
       "[music]",
+      "piano music",
+      "applause",
+      "[applause]",
       "\u266A",
+      // Silence markers.
       "[no audio]",
       "[silence]",
       "[blank_audio]",
@@ -27503,7 +28224,14 @@ var init_stream_handler = __esm({
        * barge-in armed during the audible tail. Tunable via env.
        */
       endSpeakingWithGrace() {
-        const grace = Number(process.env.PATTER_TTS_TAIL_GRACE_MS ?? 1500);
+        const rawGrace = process.env.PATTER_TTS_TAIL_GRACE_MS;
+        const parsedGrace = rawGrace !== void 0 ? Number(rawGrace) : NaN;
+        const grace = rawGrace !== void 0 && Number.isFinite(parsedGrace) ? parsedGrace : 1500;
+        if (rawGrace !== void 0 && !Number.isFinite(parsedGrace)) {
+          getLogger().warn(
+            `PATTER_TTS_TAIL_GRACE_MS="${rawGrace}" is not a valid number \u2014 using default 1500ms`
+          );
+        }
         if (grace > 0) {
           const gen = this.speakingGeneration;
           this.clearGraceTimer();
@@ -27597,6 +28325,14 @@ var init_stream_handler = __esm({
           `[DIAG] Flushed ${replayed} pre-barge-in frame(s) (~${replayed * 20} ms) to STT`
         );
       }
+      /**
+       * Per-call resolved tool list. Starts as ``null`` (falls back to
+       * ``deps.agent.tools``). Populated by ``initMcpTools`` when MCP servers
+       * are configured so discovered tools are merged in without mutating the
+       * shared ``AgentOptions`` object. Code that needs the effective tool list
+       * should read ``this.resolvedTools ?? this.deps.agent.tools``.
+       */
+      resolvedTools = null;
       llmLoop = null;
       /**
        * Per-call tool executor — provides retry-with-exponential-backoff and a
@@ -27640,6 +28376,17 @@ var init_stream_handler = __esm({
       userTranscriptPending = false;
       pendingAssistantTurn = null;
       pendingAssistantTimer = null;
+      /**
+       * Reserved monotonic turn index for the in-flight Realtime turn (issue
+       * #154, fix 5/6). Reserved in ``onAdapterSpeechStopped`` via
+       * ``metricsAcc.reserveTurnIndex()`` the moment the turn OPENS, then threaded
+       * through to the live per-line transcript events (``recordTranscriptLine``)
+       * and into ``recordTurnComplete`` / ``recordTurnInterrupted`` so the
+       * dashboard can sort a late-arriving user line ABOVE its agent line by
+       * ``(turnIndex, role)``. ``null`` until the first turn opens. Parity with
+       * Python ``_current_turn_index``.
+       */
+      currentTurnIndex = null;
       /**
        * Hard cap on how long we wait for the user transcript before flushing
        * the buffered assistant turn alone. 3 s covers OpenAI Whisper's typical
@@ -27721,6 +28468,23 @@ var init_stream_handler = __esm({
        * streaming/regular LLM, WebSocket remote, Realtime response_done) so the
        * payload shape lives in one place.
        */
+      /**
+       * Emit a live per-line transcript event to the dashboard store (issue #154,
+       * fix 5). Routed through a single helper so the call shape lives in one
+       * place. ``recordTranscriptLine`` appends the line to the active call's
+       * transcript and publishes a ``transcript_line`` SSE event; the dashboard
+       * sorts by (turnIndex, user<assistant) so a late user line lands above its
+       * agent line. No-op when no turn index has been reserved yet.
+       */
+      emitTranscriptLine(role, text) {
+        if (this.currentTurnIndex === null) return;
+        this.deps.metricsStore.recordTranscriptLine({
+          call_id: this.callId,
+          turnIndex: this.currentTurnIndex,
+          role,
+          text
+        });
+      }
       async emitTurnMetrics(turn) {
         if (turn == null) return;
         this.deps.metricsStore.recordTurn({ call_id: this.callId, turn });
@@ -27827,7 +28591,7 @@ var init_stream_handler = __esm({
         if (customParams.callee && !this.callee) this.callee = customParams.callee;
         const mode = this.deps.agent.engine ? `engine=${this.deps.agent.engine.kind ?? "unknown"}` : "pipeline";
         getLogger().info(
-          `Call started: ${callId} (${this.deps.bridge.label}, ${mode}, ${sanitizeLogValue(this.caller || "?")} \u2192 ${sanitizeLogValue(this.callee || "?")})`
+          `Call started: ${callId} (${this.deps.bridge.label}, ${mode}, ${maskPhoneNumber(this.caller || "?")} \u2192 ${maskPhoneNumber(this.callee || "?")})`
         );
         if (Object.keys(customParams).length > 0) {
           getLogger().debug(`Custom params: ${sanitizeLogValue(JSON.stringify(customParams))}`);
@@ -27872,10 +28636,13 @@ var init_stream_handler = __esm({
         const resolvedPrompt = Object.keys(allVars).length > 0 ? this.deps.resolveVariables(this.deps.agent.systemPrompt, allVars) : this.deps.agent.systemPrompt;
         const provider2 = this.deps.agent.provider ?? "openai_realtime";
         await this.initMcpTools();
+        this.injectConsultTool();
         if (provider2 === "pipeline") {
           await this.initPipeline(resolvedPrompt);
         } else {
-          await this.initRealtimeAdapter(resolvedPrompt);
+          await this.initRealtimeAdapter(
+            applyToolCallPreambles(resolvedPrompt, this.deps.agent.toolCallPreambles)
+          );
         }
       }
       /**
@@ -27900,10 +28667,25 @@ var init_stream_handler = __esm({
         }
         if (discovered.length === 0) return;
         MCPManager.assertNoConflicts(this.deps.agent.tools, discovered);
-        const mutableAgent = this.deps.agent;
-        mutableAgent.tools = [...mutableAgent.tools ?? [], ...discovered];
+        this.resolvedTools = [...this.deps.agent.tools ?? [], ...discovered];
         getLogger().info(`MCP: merged ${discovered.length} tool(s) into agent`);
       }
+      /**
+       * Merge the built-in ``consult`` tool into the per-call tool list when
+       * ``agent.consult`` is set, mirroring {@link initMcpTools}: the shared
+       * ``deps.agent`` is NOT mutated; the merged list is stored on
+       * ``this.resolvedTools`` so ``buildAIAdapter`` (Realtime) and the pipeline
+       * ``LLMLoop`` both see it. Idempotent — a no-op if a tool with the same name
+       * is already present.
+       */
+      injectConsultTool() {
+        const consult = this.deps.agent.consult;
+        if (!consult) return;
+        const consultTool = buildConsultTool(consult);
+        const base = this.resolvedTools ?? (this.deps.agent.tools ?? []);
+        if (base.some((t) => t.name === consultTool.name)) return;
+        this.resolvedTools = [...base, consultTool];
+      }
       /** Set the stream SID (Twilio only, called after parsing 'start' event). */
       /** Set the carrier-side stream id (Twilio `streamSid` / Telnyx stream identifier). */
       setStreamSid(sid) {
@@ -27923,8 +28705,12 @@ var init_stream_handler = __esm({
           if (activeVad && !this.vadDisabled) {
             try {
               const vadPromise = activeVad.processFrame(pcm16k, 16e3);
-              const timeoutPromise = new Promise((resolve2) => setTimeout(() => resolve2(null), 25));
+              let vadTimeoutId;
+              const timeoutPromise = new Promise((resolve2) => {
+                vadTimeoutId = setTimeout(() => resolve2(null), 25);
+              });
               const evt = await Promise.race([vadPromise, timeoutPromise]);
+              clearTimeout(vadTimeoutId);
               if (evt) {
                 getLogger().info(
                   `[VAD] ${evt.type}  agentSpeaking=${this.isSpeaking}`
@@ -27997,7 +28783,7 @@ var init_stream_handler = __esm({
             if ((this.deps.agent.bargeInThresholdMs ?? 300) === 0) return;
           }
           const hooks = this.deps.agent.hooks;
-          if (hooks) {
+          if (hooks?.beforeSendToStt) {
             const hookExecutor = new PipelineHookExecutor(hooks);
             const hookCtx = this.buildHookContext();
             const processed = await hookExecutor.runBeforeSendToStt(pcm16k, hookCtx);
@@ -28423,7 +29209,7 @@ var init_stream_handler = __esm({
           }
           const providerModel = this.deps.agent.llm?.model ?? "";
           const augmentedTools = augmentWithBuiltinHandoffTools(
-            this.deps.agent.tools,
+            this.resolvedTools ?? this.deps.agent.tools,
             {
               transferCall: (number4) => this.deps.bridge.transferCall(this.callId, number4),
               endCall: () => this.deps.bridge.endCall(this.callId, this.ws)
@@ -28447,7 +29233,7 @@ var init_stream_handler = __esm({
           let llmModel = this.deps.agent.model || "gpt-4o-mini";
           if (llmModel.includes("realtime")) llmModel = "gpt-4o-mini";
           const augmentedTools = augmentWithBuiltinHandoffTools(
-            this.deps.agent.tools,
+            this.resolvedTools ?? this.deps.agent.tools,
             {
               transferCall: (number4) => this.deps.bridge.transferCall(this.callId, number4),
               endCall: () => this.deps.bridge.endCall(this.callId, this.ws)
@@ -28871,6 +29657,14 @@ var init_stream_handler = __esm({
               chunker.reset();
               getLogger().error(`LLM loop error (${label}):`, e);
               this.metricsAcc.recordTurnInterrupted();
+              const fallback = this.deps.agent.llmErrorMessage;
+              if (fallback && !ttsFirstByteSent.value && this.isSpeaking) {
+                try {
+                  await this.synthesizeSentence(fallback, hookExecutor, hookCtx, ttsFirstByteSent);
+                } catch (err) {
+                  getLogger().error(`llmErrorMessage fallback synthesis failed (${label}):`, err);
+                }
+              }
             }
           }
           this.metricsAcc.recordLlmComplete();
@@ -28971,7 +29765,7 @@ var init_stream_handler = __esm({
       // ---------------------------------------------------------------------------
       async initRealtimeAdapter(resolvedPrompt) {
         const label = this.deps.bridge.label;
-        this.adapter = this.deps.buildAIAdapter(resolvedPrompt);
+        this.adapter = this.deps.buildAIAdapter(resolvedPrompt, this.resolvedTools ?? void 0);
         let parked;
         if (typeof this.deps.popPrewarmedConnections === "function") {
           try {
@@ -29044,6 +29838,7 @@ var init_stream_handler = __esm({
         response_done: async (eventData) => this.onAdapterResponseDone(eventData),
         speech_started: async () => this.onAdapterSpeechInterrupt(),
         interruption: async () => this.onAdapterSpeechInterrupt(),
+        error: async (eventData) => this.onAdapterError(eventData),
         function_call: async (eventData) => {
           if (this.adapter instanceof OpenAIRealtimeAdapter) {
             await this.handleFunctionCall(eventData);
@@ -29130,21 +29925,31 @@ var init_stream_handler = __esm({
         if (!this.metricsAcc.turnActive) this.metricsAcc.startTurn();
         this.currentAgentText = "";
         this.responseAudioStarted = false;
+        this.currentTurnIndex = this.metricsAcc.reserveTurnIndex();
         this.userTranscriptPending = true;
         await this.emitUserSpeechEnded();
       }
       async onAdapterTranscriptInput(inputText) {
-        const stripped = inputText.trim().toLowerCase();
-        if (HALLUCINATIONS.has(stripped) || stripped === "") {
+        if (isSttHallucination(inputText)) {
           getLogger().debug(
             `Realtime transcript_input dropped (likely Whisper hallucination on silence/echo): ${sanitizeLogValue(inputText.slice(0, 60))}`
           );
           this.userTranscriptPending = false;
+          if (this.pendingAssistantTurn !== null) {
+            const buffered = this.pendingAssistantTurn;
+            this.pendingAssistantTurn = null;
+            if (this.pendingAssistantTimer) {
+              clearTimeout(this.pendingAssistantTimer);
+              this.pendingAssistantTimer = null;
+            }
+            await this.flushAssistantTurn(buffered);
+          }
           return;
         }
         getLogger().debug(`User (${this.deps.bridge.label}): ${sanitizeLogValue(inputText)}`);
         this.history.push({ role: "user", text: inputText, timestamp: Date.now() });
-        if (this.adapter instanceof OpenAIRealtimeAdapter) {
+        this.emitTranscriptLine("user", inputText);
+        if (this.adapter instanceof OpenAIRealtimeAdapter && this.adapter.getGateResponseOnTranscript()) {
           void this.adapter.requestResponse().catch(
             (err) => getLogger().debug(`Realtime requestResponse failed: ${String(err)}`)
           );
@@ -29191,8 +29996,12 @@ var init_stream_handler = __esm({
             history: [...this.history.entries]
           });
         }
+        const reservedIndex = this.currentTurnIndex;
+        this.emitTranscriptLine("assistant", text);
         this.responseAudioStarted = false;
-        await this.emitTurnMetrics(this.metricsAcc.recordTurnComplete(text));
+        await this.emitTurnMetrics(
+          this.metricsAcc.recordTurnComplete(text, reservedIndex ?? void 0)
+        );
       }
       /**
        * Push an assistant turn into history and fire `onTranscript` so host
@@ -29291,7 +30100,9 @@ var init_stream_handler = __esm({
             this.pendingAssistantTimer = null;
             this.userTranscriptPending = false;
             if (buffered !== null) {
-              void this.flushAssistantTurn(buffered);
+              this.flushAssistantTurn(buffered).catch(
+                (err) => getLogger().error("flushAssistantTurn (fallback timer) failed:", err)
+              );
             }
           }, _StreamHandler.REALTIME_USER_TRANSCRIPT_WAIT_MS);
           this.responseAudioStarted = false;
@@ -29300,7 +30111,9 @@ var init_stream_handler = __esm({
         await this.flushAssistantTurn(text);
       }
       async onAdapterSpeechInterrupt() {
-        if (this.adapter instanceof OpenAIRealtimeAdapter) {
+        const isEngine = this.adapter instanceof OpenAIRealtimeAdapter;
+        const clientManaged = isEngine && this.adapter.getGateResponseOnTranscript();
+        if (clientManaged) {
           const startedAt = this.adapter.currentResponseFirstAudioAt;
           if (startedAt !== null) {
             const elapsedMs = Date.now() - startedAt;
@@ -29313,12 +30126,20 @@ var init_stream_handler = __esm({
           }
         }
         this.deps.bridge.sendClear(this.ws, this.streamSid);
-        if (this.adapter instanceof OpenAIRealtimeAdapter) this.adapter.cancelResponse();
+        if (clientManaged) {
+          this.metricsAcc.recordBargeinDetected();
+          this.adapter.cancelResponse();
+        } else if (isEngine) {
+          this.adapter.truncate();
+        }
         this.metricsAcc.recordTurnInterrupted();
         if (this.responseAudioStarted) {
           await this.emitAgentSpeechEnded(true);
         }
         await this.emitUserSpeechStarted();
+        if (clientManaged) {
+          this.metricsAcc.anchorUserSpeechStart();
+        }
         this.currentAgentText = "";
         this.responseAudioStarted = false;
         this.pendingAssistantTurn = null;
@@ -29328,6 +30149,28 @@ var init_stream_handler = __esm({
         }
         this.userTranscriptPending = false;
       }
+      /**
+       * Handle a Realtime ``error`` event (issue #154, fix 4).
+       *
+       * Both Realtime providers dispatch ``('error', …)`` for server-side errors,
+       * non-normal socket closes, and socket errors, but the stream handler
+       * previously had no entry for it in the dispatch table so these were
+       * silently swallowed. We surface them at WARN level with ONLY the error
+       * envelope fields (``type`` / ``code`` / ``message``) — never any audio or
+       * transcript body, to avoid logging PII. The call is NOT terminated: the
+       * provider decides whether to recover, and many of these (e.g. a transient
+       * ``input_audio_buffer_commit_empty``) are non-fatal. Parity with the
+       * Python ``elif ev_type == 'error'`` branches.
+       */
+      async onAdapterError(eventData) {
+        const err = eventData ?? {};
+        const type = typeof err.type === "string" ? err.type : "unknown";
+        const code = typeof err.code === "string" ? err.code : "";
+        const message = typeof err.message === "string" ? err.message : "";
+        getLogger().warn(
+          `Realtime error (${this.deps.bridge.label}) type=${type} code=${code} message=${sanitizeLogValue(message)}`
+        );
+      }
       /**
        * Emit a tool-invocation event into the transcript timeline. Pushes a
        * `role=tool` entry into `history` (so it appears in the dashboard
@@ -29395,7 +30238,8 @@ var init_stream_handler = __esm({
           }
           return;
         }
-        const toolDef = this.deps.agent.tools?.find((t) => t.name === fc.name);
+        const effectiveTools = this.resolvedTools ?? this.deps.agent.tools;
+        const toolDef = effectiveTools?.find((t) => t.name === fc.name);
         if (!toolDef) {
           getLogger().warn(`Realtime tool '${fc.name}' not found in agent.tools \u2014 skipping`);
           const result2 = JSON.stringify({ error: `Tool '${fc.name}' not registered`, fallback: true });
@@ -29418,7 +30262,8 @@ var init_stream_handler = __esm({
           if (msg && this.adapter instanceof OpenAIRealtimeAdapter) {
             const realtimeAdapter = this.adapter;
             reassuranceTimer = setTimeout(() => {
-              realtimeAdapter.sendText(msg).catch((e) => {
+              const fire = typeof realtimeAdapter.sendReassurance === "function" ? realtimeAdapter.sendReassurance(msg) : realtimeAdapter.sendText(msg);
+              fire.catch((e) => {
                 getLogger().warn(`Reassurance message failed for tool '${fc.name}': ${String(e)}`);
               });
             }, afterMs);
@@ -29438,7 +30283,8 @@ var init_stream_handler = __esm({
             parsedArgs,
             {
               call_id: this.callId,
-              caller: this.caller
+              caller: this.caller,
+              callee: this.callee
             },
             onProgress
           );
@@ -29588,21 +30434,21 @@ async function appendJsonl(filePath, record2) {
   await import_node_fs2.promises.mkdir(path4.dirname(filePath), { recursive: true });
   await import_node_fs2.promises.appendFile(filePath, JSON.stringify(record2) + "\n", { encoding: "utf8" });
 }
-function rmTree(target) {
+async function rmTreeAsync(target) {
   try {
-    for (const child of fs4.readdirSync(target)) {
+    for (const child of await import_node_fs2.promises.readdir(target)) {
       const childPath = path4.join(target, child);
-      const stat = fs4.lstatSync(childPath);
+      const stat = await import_node_fs2.promises.lstat(childPath);
       if (stat.isDirectory()) {
-        rmTree(childPath);
+        await rmTreeAsync(childPath);
       } else {
         try {
-          fs4.unlinkSync(childPath);
+          await import_node_fs2.promises.unlink(childPath);
         } catch {
         }
       }
     }
-    fs4.rmdirSync(target);
+    await import_node_fs2.promises.rmdir(target);
   } catch {
   }
 }
@@ -29684,7 +30530,9 @@ var init_call_log = __esm({
           getLogger().warn(`call_log write failed (${sanitizeLogValue(callId)}): ${sanitizeLogValue(String(err))}`);
         }
         if (crypto5.randomBytes(1)[0] < 5) {
-          this.sweepOldDays();
+          void this.sweepOldDays().catch(
+            (e) => getLogger().debug(`call_log sweep failed: ${sanitizeLogValue(String(e))}`)
+          );
         }
       }
       /** Append a single turn record to the call's `transcript.jsonl`. */
@@ -29759,23 +30607,27 @@ var init_call_log = __esm({
         }
       }
       // --- Retention ---------------------------------------------------------
-      sweepOldDays() {
+      async sweepOldDays() {
         if (this.root === null) return;
         const days = retentionDays();
         if (days === 0) return;
         const cutoff = Date.now() / 1e3 - days * 86400;
         const callsRoot = path4.join(this.root, "calls");
-        if (!fs4.existsSync(callsRoot)) return;
         try {
-          for (const yearName of fs4.readdirSync(callsRoot)) {
+          await import_node_fs2.promises.access(callsRoot);
+        } catch {
+          return;
+        }
+        try {
+          for (const yearName of await import_node_fs2.promises.readdir(callsRoot)) {
             if (!/^\d+$/.test(yearName)) continue;
             const yearDir = path4.join(callsRoot, yearName);
-            if (!fs4.statSync(yearDir).isDirectory()) continue;
-            for (const monthName of fs4.readdirSync(yearDir)) {
+            if (!(await import_node_fs2.promises.stat(yearDir)).isDirectory()) continue;
+            for (const monthName of await import_node_fs2.promises.readdir(yearDir)) {
               if (!/^\d+$/.test(monthName)) continue;
               const monthDir = path4.join(yearDir, monthName);
-              if (!fs4.statSync(monthDir).isDirectory()) continue;
-              for (const dayName of fs4.readdirSync(monthDir)) {
+              if (!(await import_node_fs2.promises.stat(monthDir)).isDirectory()) continue;
+              for (const dayName of await import_node_fs2.promises.readdir(monthDir)) {
                 if (!/^\d+$/.test(dayName)) continue;
                 const dayDir = path4.join(monthDir, dayName);
                 const y = Number.parseInt(yearName, 10);
@@ -29783,16 +30635,16 @@ var init_call_log = __esm({
                 const d = Number.parseInt(dayName, 10);
                 const ts = Date.UTC(y, m - 1, d) / 1e3;
                 if (ts < cutoff) {
-                  rmTree(dayDir);
+                  await rmTreeAsync(dayDir);
                 }
               }
               try {
-                if (fs4.readdirSync(monthDir).length === 0) fs4.rmdirSync(monthDir);
+                if ((await import_node_fs2.promises.readdir(monthDir)).length === 0) await import_node_fs2.promises.rmdir(monthDir);
               } catch {
               }
             }
             try {
-              if (fs4.readdirSync(yearDir).length === 0) fs4.rmdirSync(yearDir);
+              if ((await import_node_fs2.promises.readdir(yearDir)).length === 0) await import_node_fs2.promises.rmdir(yearDir);
             } catch {
             }
           }
@@ -29833,13 +30685,16 @@ function telnyxHangupOutcome(cause) {
   if (c === "call_rejected" || c === "rejected" || c === "destination_out_of_order") return "failed";
   return null;
 }
-function validateWebhookUrl(url2) {
+function validateWebhookUrl(url2, allowLoopback = false) {
   const parsed = new URL(url2);
   if (!["http:", "https:"].includes(parsed.protocol)) {
     throw new Error(`Invalid webhook URL scheme: ${parsed.protocol}`);
   }
   const rawHost = parsed.hostname;
   const host = rawHost.replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
+  if (allowLoopback) {
+    return;
+  }
   const BLOCKED_HOSTNAMES = /* @__PURE__ */ new Set([
     "localhost",
     "ip6-localhost",
@@ -29881,6 +30736,34 @@ function validateWebhookUrl(url2) {
     }
   }
 }
+function extractHost(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  let host = trimmed.replace(/^[a-z]+:\/\//i, "").replace(/\/.*$/, "");
+  if (host.startsWith("[")) {
+    return host.slice(1).split("]", 1)[0].toLowerCase();
+  }
+  if (!host.includes("::")) {
+    const lastColon = host.lastIndexOf(":");
+    if (lastColon !== -1 && /^\d+$/.test(host.slice(lastColon + 1))) {
+      host = host.slice(0, lastColon);
+    }
+  }
+  return host.toLowerCase();
+}
+function isLoopbackHost(value) {
+  const host = extractHost(value);
+  if (!host) return false;
+  if (host === "localhost" || host === "ip6-localhost" || host === "ip6-loopback") {
+    return true;
+  }
+  if (host === "::1" || host === "::ffff:127.0.0.1") return true;
+  const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (v4) {
+    return parseInt(v4[1], 10) === 127;
+  }
+  return false;
+}
 function validateTelnyxSignature(rawBody, signature, timestamp, publicKey, toleranceSec = 300) {
   try {
     const ts = parseInt(timestamp, 10);
@@ -29944,7 +30827,7 @@ function resolveVariables(template, variables) {
   }
   return result;
 }
-function buildAIAdapter(config2, agent, resolvedPrompt) {
+function buildAIAdapter(config2, agent, resolvedPrompt, toolsOverride) {
   const engine = agent.engine;
   if (agent.provider === "elevenlabs_convai") {
     if (!engine || engine.kind !== "elevenlabs_convai") {
@@ -29959,12 +30842,24 @@ function buildAIAdapter(config2, agent, resolvedPrompt) {
       agent.firstMessage ?? ""
     );
   }
-  const agentTools = agent.tools?.map((t) => ({
-    name: t.name,
-    description: t.description,
-    parameters: t.parameters,
-    strict: t.strict
-  })) ?? [];
+  const preamblesOn = Boolean(agent.toolCallPreambles);
+  const agentTools = (toolsOverride ?? agent.tools)?.map((t) => {
+    let description = t.description;
+    const reassurance = t.reassurance;
+    const sample = typeof reassurance === "string" ? reassurance : void 0;
+    if (preamblesOn && sample) {
+      description = `${description}
+
+Preamble sample phrases:
+- ${sample}`;
+    }
+    return {
+      name: t.name,
+      description,
+      parameters: t.parameters,
+      strict: t.strict
+    };
+  }) ?? [];
   const tools = [...agentTools, TRANSFER_CALL_TOOL, END_CALL_TOOL];
   const isOpenAIEngine = engine && (engine.kind === "openai_realtime" || engine.kind === "openai_realtime_2");
   const openaiKey = isOpenAIEngine ? engine.apiKey : config2.openaiKey ?? "";
@@ -29976,8 +30871,27 @@ function buildAIAdapter(config2, agent, resolvedPrompt) {
     if (engine.inputAudioTranscriptionModel !== void 0) {
       adapterOptions.inputAudioTranscriptionModel = engine.inputAudioTranscriptionModel;
     }
+    if (engine.noiseReduction !== void 0) {
+      adapterOptions.noiseReduction = engine.noiseReduction;
+    }
+    if (engine.turnDetection !== void 0) {
+      adapterOptions.turnDetection = engine.turnDetection;
+    }
+    if (engine.gateResponseOnTranscript !== void 0) {
+      adapterOptions.gateResponseOnTranscript = engine.gateResponseOnTranscript;
+    }
+  }
+  const agentOpts = agent;
+  if (agentOpts.openaiRealtimeNoiseReduction !== void 0) {
+    adapterOptions.noiseReduction = agentOpts.openaiRealtimeNoiseReduction;
+  }
+  if (agentOpts.realtimeTurnDetection !== void 0) {
+    adapterOptions.turnDetection = agentOpts.realtimeTurnDetection;
   }
-  const AdapterCtor = engine && engine.kind === "openai_realtime_2" ? OpenAIRealtime2Adapter : OpenAIRealtimeAdapter;
+  if (agentOpts.openaiRealtimeGateResponseOnTranscript !== void 0) {
+    adapterOptions.gateResponseOnTranscript = agentOpts.openaiRealtimeGateResponseOnTranscript;
+  }
+  const AdapterCtor = OpenAIRealtime2Adapter;
   return new AdapterCtor(
     openaiKey,
     agent.model,
@@ -30006,7 +30920,6 @@ var init_server = __esm({
     import_express = __toESM(require("express"));
     import_http = require("http");
     import_ws5 = require("ws");
-    init_openai_realtime();
     init_openai_realtime_2();
     init_elevenlabs_convai();
     init_plivo_adapter();
@@ -30069,6 +30982,11 @@ var init_server = __esm({
             getLogger().warn(`TwilioBridge.transferCall rejected: invalid CallSid ${JSON.stringify(callId)}`);
             return;
           }
+          const E164_RE = /^\+[1-9]\d{6,14}$/;
+          if (!E164_RE.test(toNumber)) {
+            getLogger().warn(`TwilioBridge.transferCall rejected: invalid target ${JSON.stringify(toNumber)}`);
+            return;
+          }
           const transferUrl = `https://api.twilio.com/2010-04-01/Accounts/${this.config.twilioSid}/Calls/${callId}.json`;
           await fetch(transferUrl, {
             method: "POST",
@@ -30275,7 +31193,7 @@ var init_server = __esm({
     };
     GRACEFUL_SHUTDOWN_TIMEOUT_MS = 1e4;
     EmbeddedServer = class {
-      constructor(config2, agent, onCallStart, onCallEnd, onTranscript, onMessage, recording = false, voicemailMessage = "", onMetrics, pricingOverrides, dashboard = true, dashboardToken = "") {
+      constructor(config2, agent, onCallStart, onCallEnd, onTranscript, onMessage, recording = false, voicemailMessage = "", onMetrics, pricingOverrides, dashboard = true, dashboardToken = "", allowInsecureDashboard = false) {
         this.config = config2;
         this.agent = agent;
         this.onCallStart = onCallStart;
@@ -30287,6 +31205,7 @@ var init_server = __esm({
         this.onMetrics = onMetrics;
         this.dashboard = dashboard;
         this.dashboardToken = dashboardToken;
+        this.allowInsecureDashboard = allowInsecureDashboard;
         this.metricsStore = new MetricsStore();
         this.pricing = mergePricing(pricingOverrides);
         const logRoot = config2.persistRoot === void 0 ? resolveLogRoot() : config2.persistRoot;
@@ -30313,8 +31232,31 @@ var init_server = __esm({
       onMetrics;
       dashboard;
       dashboardToken;
+      allowInsecureDashboard;
       server = null;
       wss = null;
+      /**
+       * Whether the dashboard + ``/api/*`` routes were mounted in ``start()``.
+       * The dashboard is now ALWAYS mounted when enabled (it never 404s): an
+       * exposed, token-less bind is protected with an auto-generated token
+       * rather than refused. This flag is therefore ``true`` whenever the
+       * dashboard is enabled — kept so the startup banner can gate on it.
+       */
+      dashboardMounted = false;
+      /**
+       * The token actually in effect for the dashboard + ``/api/*`` routes,
+       * resolved in ``start()``. One of: the explicit ``dashboardToken`` if set;
+       * a freshly generated UUID when the bind is exposed and
+       * ``allowInsecureDashboard`` is ``false``; or ``''`` (OPEN) for loopback
+       * local dev and for an exposed bind with ``allowInsecureDashboard=true``.
+       * Read by the startup banner (to print the ready URL with ``?token=``) and
+       * by authentic tests (to authenticate).
+       */
+      effectiveDashboardToken = "";
+      /** The token in effect for the dashboard, resolved at ``start()``. Empty string = served OPEN. */
+      get resolvedDashboardToken() {
+        return this.effectiveDashboardToken;
+      }
       twilioTokenWarningLogged = false;
       telnyxSigWarningLogged = false;
       metricsStore;
@@ -30332,12 +31274,14 @@ var init_server = __esm({
       activeConnections = /* @__PURE__ */ new Set();
       activeCallIds = /* @__PURE__ */ new Map();
       /**
-       * Per-call AMD result callback set by ``Patter.call()`` for the most
-       * recent outbound call. Public so ``client.ts`` can populate it after
-       * server start. Cleared after firing once per call to avoid leaking
-       * across calls.
+       * Per-call AMD result callbacks keyed by CallSid / call_control_id.
+       * Public so ``client.ts`` can register a callback per outbound call.
+       * The Map slot is deleted after the callback fires once — preventing
+       * cross-call misfires when multiple concurrent outbound calls are in
+       * flight (single-slot was a race condition: the last registered callback
+       * would win for every in-flight AMD result).
        */
-      onMachineDetection;
+      onMachineDetectionByCallSid = /* @__PURE__ */ new Map();
       /**
        * Pre-warm first-message audio accessor wired by ``Patter.serve()``.
        * The per-call StreamHandler invokes this with its ``callId`` at the
@@ -30458,6 +31402,42 @@ var init_server = __esm({
         this.completions.clear();
         this.amdClass.clear();
       }
+      /**
+       * Decide whether this server is reachable beyond loopback (127.0.0.1).
+       *
+       * The dashboard serves call transcripts and metadata (PII), so before
+       * mounting it unauthenticated we must know whether anyone off-host can
+       * reach the port. Signals (in order):
+       *
+       *   (a)+(b) — a public webhook URL. ``client.ts`` resolves
+       *       ``config.webhookUrl`` to the live hostname for every serve path:
+       *       a cloudflared quick-tunnel host, a {@link StaticTunnel} hostname,
+       *       or an explicit ``webhookUrl``. A tunnel directive (signal a) and a
+       *       public webhook URL (signal b) therefore both surface here as a
+       *       non-loopback, non-private webhook host. This is the case that
+       *       matters for tunnels — the whole port (dashboard included) is
+       *       published on a public ``*.trycloudflare.com`` URL.
+       *
+       *   (c) — an EXPLICIT non-loopback bind override via ``PATTER_BIND_HOST``.
+       *       Node's ``http.Server.listen(port, host)`` defaults to 127.0.0.1
+       *       here (see ``start()``), so plain local dev is never flagged; only
+       *       an operator who set ``PATTER_BIND_HOST`` to e.g. ``0.0.0.0`` is.
+       *
+       * Only loopback webhook hosts (127.0.0.0/8, localhost, ::1) are treated as
+       * not-exposed. RFC1918 / LAN hosts ARE exposure — they are reachable by
+       * other machines on the network — matching the Python SDK's gate.
+       */
+      isExposed() {
+        const bindOverride = process.env.PATTER_BIND_HOST;
+        if (bindOverride && !isLoopbackHost(bindOverride)) {
+          return true;
+        }
+        const host = extractHost(this.config.webhookUrl ?? "");
+        if (host && !isLoopbackHost(host)) {
+          return true;
+        }
+        return false;
+      }
       /** Bind HTTP + WebSocket listeners on `port`, mount carrier webhooks and dashboard routes. */
       async start(port = 8e3) {
         const webhookUrlPattern = /^[a-zA-Z0-9][a-zA-Z0-9.\-]+[a-zA-Z0-9]$/;
@@ -30493,6 +31473,9 @@ var init_server = __esm({
               }
               next();
             });
+            req.on("error", (err) => {
+              next(err);
+            });
           } else {
             next();
           }
@@ -30503,8 +31486,25 @@ var init_server = __esm({
           res.json({ status: "ok", mode: "local" });
         });
         if (this.dashboard) {
-          mountDashboard(app, this.metricsStore, this.dashboardToken);
-          mountApi(app, this.metricsStore, this.dashboardToken);
+          const exposed = this.isExposed();
+          if (this.dashboardToken) {
+            this.effectiveDashboardToken = this.dashboardToken;
+          } else if (exposed && !this.allowInsecureDashboard) {
+            this.effectiveDashboardToken = import_node_crypto4.default.randomUUID();
+            getLogger().warn(
+              `Dashboard is reachable beyond 127.0.0.1 without a configured token; protecting it with an auto-generated token. Open: http://127.0.0.1:${port}/?token=${this.effectiveDashboardToken}  Set dashboardToken for a stable token, or allowInsecureDashboard=true to serve it open.`
+            );
+          } else if (exposed && this.allowInsecureDashboard) {
+            this.effectiveDashboardToken = "";
+            getLogger().warn(
+              "Dashboard served WITHOUT authentication on a publicly-reachable bind (allowInsecureDashboard=true). Call transcripts and metadata are exposed to anyone who can reach this URL."
+            );
+          } else {
+            this.effectiveDashboardToken = "";
+          }
+          mountDashboard(app, this.metricsStore, this.effectiveDashboardToken);
+          mountApi(app, this.metricsStore, this.effectiveDashboardToken);
+          this.dashboardMounted = true;
         }
         app.post("/webhooks/twilio/status", (req, res) => {
           if (this.config.twilioToken) {
@@ -30590,8 +31590,9 @@ var init_server = __esm({
           if (callSid) {
             this.amdClass.set(callSid, classifyTwilioAmd(answeredBy));
           }
-          const cb = this.onMachineDetection;
+          const cb = callSid ? this.onMachineDetectionByCallSid.get(callSid) : void 0;
           if (cb && callSid) {
+            this.onMachineDetectionByCallSid.delete(callSid);
             try {
               await cb({
                 call_id: callSid,
@@ -30718,8 +31719,9 @@ var init_server = __esm({
             if (amdCallId) {
               this.amdClass.set(amdCallId, classifyTelnyxAmd(amdResult));
             }
-            const cbTx = this.onMachineDetection;
+            const cbTx = amdCallId ? this.onMachineDetectionByCallSid.get(amdCallId) : void 0;
             if (cbTx && amdCallId) {
+              this.onMachineDetectionByCallSid.delete(amdCallId);
               try {
                 await cbTx({
                   call_id: amdCallId,
@@ -30887,8 +31889,13 @@ var init_server = __esm({
           getLogger().info(`AMD result for ${sanitizeLogValue(callUuid)}: ${sanitizeLogValue(amdRaw)}`);
           const classification = classifyPlivoAmd(amdRaw);
           if (callUuid) this.amdClass.set(callUuid, classification);
-          const cb = this.onMachineDetection;
+          let cbKey = callUuid && this.onMachineDetectionByCallSid.has(callUuid) ? callUuid : void 0;
+          if (cbKey === void 0 && this.onMachineDetectionByCallSid.size === 1) {
+            cbKey = this.onMachineDetectionByCallSid.keys().next().value;
+          }
+          const cb = cbKey !== void 0 ? this.onMachineDetectionByCallSid.get(cbKey) : void 0;
           if (cb && callUuid) {
+            if (cbKey !== void 0) this.onMachineDetectionByCallSid.delete(cbKey);
             try {
               await cb({
                 call_id: callUuid,
@@ -30969,27 +31976,34 @@ var init_server = __esm({
             this.handleTwilioStream(ws, url2);
           }
         });
-        await new Promise((resolve2) => {
+        await new Promise((resolve2, reject) => {
           const bindHost = process.env.PATTER_BIND_HOST ?? "127.0.0.1";
+          this.server.once("error", reject);
           this.server.listen(port, bindHost, () => {
+            this.server.off("error", reject);
             getLogger().info(`Server on port ${port}`);
             getLogger().info(`Webhook: https://${this.config.webhookUrl}`);
             getLogger().info(`Phone:   ${this.config.phoneNumber}`);
             const model = this.agent.model ?? "";
-            if (model && model !== "gpt-4o-mini-realtime-preview" && model.includes("realtime")) {
+            const calibrated = ["gpt-realtime-mini", "gpt-4o-mini-realtime-preview"];
+            if (model && !calibrated.includes(model) && model.includes("realtime")) {
               getLogger().warn(
-                `Agent uses "${sanitizeLogValue(model)}" but DEFAULT_PRICING.openai_realtime is calibrated for "gpt-4o-mini-realtime-preview". Pass Patter({ pricing: { openai_realtime: {...} } }) to set rates for this model, otherwise the dashboard cost display will under-report.`
+                `Agent uses "${sanitizeLogValue(model)}" but DEFAULT_PRICING.openai_realtime is calibrated for the default Realtime models (gpt-realtime-mini / gpt-4o-mini-realtime-preview). Pass Patter({ pricing: { openai_realtime: {...} } }) to set rates for this model, otherwise the dashboard cost display will under-report.`
               );
             }
-            if (this.dashboard) {
-              console.log("\n\u2500\u2500\u2500\u2500 Dashboard \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-              getLogger().info(`URL: http://127.0.0.1:${port}/`);
-              if (!this.dashboardToken) {
+            if (this.dashboard && this.dashboardMounted) {
+              getLogger().info("\u2500\u2500\u2500\u2500 Dashboard \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+              if (this.effectiveDashboardToken) {
+                getLogger().info(
+                  `URL: http://127.0.0.1:${port}/?token=${this.effectiveDashboardToken}`
+                );
+              } else {
+                getLogger().info(`URL: http://127.0.0.1:${port}/`);
                 getLogger().warn(
                   "Dashboard is enabled without authentication. Set dashboardToken to protect call data. This is safe for local development but should not be exposed on a public network."
                 );
               }
-              console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n");
+              getLogger().info("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
             }
             resolve2();
           });
@@ -31065,7 +32079,7 @@ var init_server = __esm({
           onMessage: this.onMessage,
           onMetrics: wrappedMetrics,
           recording: this.recording,
-          buildAIAdapter: (resolvedPrompt) => buildAIAdapter(this.config, this.agent, resolvedPrompt),
+          buildAIAdapter: (resolvedPrompt, toolsOverride) => buildAIAdapter(this.config, this.agent, resolvedPrompt, toolsOverride),
           sanitizeVariables,
           resolveVariables,
           popPrewarmAudio: this.popPrewarmAudio,
@@ -31339,17 +32353,18 @@ var init_server = __esm({
         }
         if (this.activeConnections.size > 0) {
           getLogger().info(`Waiting for ${this.activeConnections.size} active connection(s) to close...`);
-          await Promise.race([
-            new Promise((resolve2) => {
-              const checkInterval = setInterval(() => {
-                if (this.activeConnections.size === 0) {
-                  clearInterval(checkInterval);
-                  resolve2();
-                }
-              }, 100);
-            }),
-            new Promise((resolve2) => setTimeout(resolve2, GRACEFUL_SHUTDOWN_TIMEOUT_MS))
-          ]);
+          let checkInterval;
+          const drainPromise = new Promise((resolve2) => {
+            checkInterval = setInterval(() => {
+              if (this.activeConnections.size === 0) {
+                clearInterval(checkInterval);
+                resolve2();
+              }
+            }, 100);
+          });
+          const timeoutPromise = new Promise((resolve2) => setTimeout(resolve2, GRACEFUL_SHUTDOWN_TIMEOUT_MS));
+          await Promise.race([drainPromise, timeoutPromise]);
+          clearInterval(checkInterval);
         }
         if (this.activeConnections.size > 0) {
           getLogger().info(`Force-closing ${this.activeConnections.size} remaining connection(s)`);
@@ -31478,6 +32493,9 @@ __export(carrier_config_exports, {
   configureTelnyxNumber: () => configureTelnyxNumber,
   configureTwilioNumber: () => configureTwilioNumber
 });
+function redactPhone2(n) {
+  return n.slice(0, 3) + "***" + n.slice(-4);
+}
 async function configureTwilioNumber(accountSid, authToken, phoneNumber, voiceUrl) {
   const auth2 = `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`;
   const listUrl = `${TWILIO_API_BASE}/Accounts/${accountSid}/IncomingPhoneNumbers.json?PhoneNumber=${encodeURIComponent(phoneNumber)}`;
@@ -31493,7 +32511,7 @@ async function configureTwilioNumber(accountSid, authToken, phoneNumber, voiceUr
   const body = await listResp.json();
   const match = body.incoming_phone_numbers?.[0];
   if (!match) {
-    throw new Error(`Twilio number ${phoneNumber} not found on account ${accountSid}`);
+    throw new Error(`Twilio number ${redactPhone2(phoneNumber)} not found on account ${accountSid}`);
   }
   const updateUrl = `${TWILIO_API_BASE}/Accounts/${accountSid}/IncomingPhoneNumbers/${match.sid}.json`;
   const form = new URLSearchParams({ VoiceUrl: voiceUrl, VoiceMethod: "POST" });
@@ -31512,17 +32530,20 @@ async function configureTwilioNumber(accountSid, authToken, phoneNumber, voiceUr
   }
 }
 async function configureTelnyxNumber(apiKey, connectionId, phoneNumber) {
-  const resp = await fetch(`${TELNYX_API_BASE}/phone_numbers/${encodeURIComponent(phoneNumber)}`, {
-    method: "PATCH",
-    headers: {
-      Authorization: `Bearer ${apiKey}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ connection_id: connectionId })
-  });
+  const resp = await fetch(
+    `${TELNYX_API_BASE}/phone_numbers/${encodeURIComponent(phoneNumber)}/voice`,
+    {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ connection_id: connectionId, tech_prefix_enabled: false })
+    }
+  );
   if (!resp.ok) {
     throw new Error(
-      `Telnyx PATCH /phone_numbers/${phoneNumber} failed: ${resp.status} ${await resp.text()}`
+      `Telnyx PATCH /phone_numbers/${redactPhone2(phoneNumber)}/voice failed: ${resp.status} ${await resp.text()}`
     );
   }
 }
@@ -31572,7 +32593,7 @@ async function autoConfigureCarrier(params) {
   if (provider2 === "telnyx" && params.telnyxKey && params.telnyxConnectionId) {
     try {
       await configureTelnyxNumber(params.telnyxKey, params.telnyxConnectionId, params.phoneNumber);
-      log3.info("Telnyx number %s associated with connection %s", params.phoneNumber, params.telnyxConnectionId);
+      log3.info("Telnyx number ***%s associated with connection %s", params.phoneNumber.slice(-4), params.telnyxConnectionId);
     } catch (err) {
       log3.warn("Could not auto-configure Telnyx number: %s", err instanceof Error ? err.message : String(err));
     }
@@ -31722,12 +32743,12 @@ var init_test_mode = __esm({
               }
               continue;
             }
-            conversationHistory.push({
-              role: "user",
-              text: userInput,
-              timestamp: Date.now()
-            });
             if (onMessage) {
+              conversationHistory.push({
+                role: "user",
+                text: userInput,
+                timestamp: Date.now()
+              });
               try {
                 const responseText = await onMessage({
                   text: userInput,
@@ -31757,6 +32778,11 @@ var init_test_mode = __esm({
               }
               log3.info("");
               const responseText = parts.join("");
+              conversationHistory.push({
+                role: "user",
+                text: userInput,
+                timestamp: Date.now()
+              });
               if (responseText) {
                 conversationHistory.push({
                   role: "assistant",
@@ -33189,6 +34215,7 @@ __export(index_exports, {
   GoogleLLM: () => LLM5,
   GroqLLM: () => LLM3,
   Guardrail: () => Guardrail,
+  HermesLLM: () => LLM7,
   IVRActivity: () => IVRActivity,
   InworldTTS: () => TTS7,
   KrispFrameDuration: () => KrispFrameDuration,
@@ -33199,6 +34226,8 @@ __export(index_exports, {
   MetricsStore: () => MetricsStore,
   MinWordsStrategy: () => MinWordsStrategy,
   Ngrok: () => Ngrok,
+  OpenAICompatibleLLM: () => LLM6,
+  OpenAICompatibleLLMProvider: () => OpenAICompatibleLLMProvider,
   OpenAILLM: () => LLM,
   OpenAILLMProvider: () => OpenAILLMProvider,
   OpenAIRealtime: () => Realtime,
@@ -33212,10 +34241,12 @@ __export(index_exports, {
   OpenAITranscribeSTT: () => STT3,
   OpenAITranscriptionModel: () => OpenAITranscriptionModel,
   OpenAIVoice: () => OpenAIVoice,
+  OpenClawLLM: () => LLM8,
   PRICING_LAST_UPDATED: () => PRICING_LAST_UPDATED,
   PRICING_VERSION: () => PRICING_VERSION,
   PartialStreamError: () => PartialStreamError,
   Patter: () => Patter,
+  PatterConfigError: () => PatterConfigError,
   PatterConnectionError: () => PatterConnectionError,
   PatterError: () => PatterError,
   PatterTool: () => PatterTool,
@@ -33303,6 +34334,8 @@ __export(index_exports, {
   mulawToPcm16: () => mulawToPcm16,
   notifyDashboard: () => notifyDashboard,
   openaiTts: () => openaiTts,
+  openclawConsult: () => openclawConsult,
+  openclawPostCallNotifier: () => openclawPostCallNotifier,
   pcm16ToMulaw: () => pcm16ToMulaw,
   resample16kTo8k: () => resample16kTo8k,
   resample24kTo16k: () => resample24kTo16k,
@@ -33333,6 +34366,7 @@ init_server();
 
 // src/engines/openai.ts
 init_cjs_shims();
+init_openai_realtime();
 var Realtime = class {
   kind = "openai_realtime";
   apiKey;
@@ -33340,6 +34374,9 @@ var Realtime = class {
   voice;
   reasoningEffort;
   inputAudioTranscriptionModel;
+  noiseReduction;
+  turnDetection;
+  gateResponseOnTranscript;
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
     if (!key) {
@@ -33347,16 +34384,26 @@ var Realtime = class {
         "OpenAI Realtime requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
       );
     }
+    if (opts.noiseReduction !== void 0 && opts.noiseReduction !== "near_field" && opts.noiseReduction !== "far_field") {
+      throw new Error(
+        `noiseReduction must be 'near_field' or 'far_field', got ${JSON.stringify(opts.noiseReduction)}`
+      );
+    }
+    validateRealtimeTurnDetection(opts.turnDetection);
     this.apiKey = key;
     this.model = opts.model ?? "gpt-realtime-mini";
     this.voice = opts.voice ?? "alloy";
     this.reasoningEffort = opts.reasoningEffort;
     this.inputAudioTranscriptionModel = opts.inputAudioTranscriptionModel;
+    this.noiseReduction = opts.noiseReduction;
+    this.turnDetection = opts.turnDetection;
+    this.gateResponseOnTranscript = opts.gateResponseOnTranscript;
   }
 };
 
 // src/engines/openai-2.ts
 init_cjs_shims();
+init_openai_realtime();
 var Realtime2 = class {
   kind = "openai_realtime_2";
   apiKey;
@@ -33364,6 +34411,9 @@ var Realtime2 = class {
   voice;
   reasoningEffort;
   inputAudioTranscriptionModel;
+  noiseReduction;
+  turnDetection;
+  gateResponseOnTranscript;
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
     if (!key) {
@@ -33371,11 +34421,20 @@ var Realtime2 = class {
         "OpenAI Realtime 2 requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
       );
     }
+    if (opts.noiseReduction !== void 0 && opts.noiseReduction !== "near_field" && opts.noiseReduction !== "far_field") {
+      throw new Error(
+        `noiseReduction must be 'near_field' or 'far_field', got ${JSON.stringify(opts.noiseReduction)}`
+      );
+    }
+    validateRealtimeTurnDetection(opts.turnDetection);
     this.apiKey = key;
     this.model = opts.model ?? "gpt-realtime-2";
     this.voice = opts.voice ?? "alloy";
     this.reasoningEffort = opts.reasoningEffort;
     this.inputAudioTranscriptionModel = opts.inputAudioTranscriptionModel;
+    this.noiseReduction = opts.noiseReduction;
+    this.turnDetection = opts.turnDetection;
+    this.gateResponseOnTranscript = opts.gateResponseOnTranscript;
   }
 };
 
@@ -33809,7 +34868,7 @@ function resolvePersistRoot(persist) {
   if (typeof persist === "string") return resolveLogRoot(persist);
   const envRoot = resolveLogRoot();
   if (envRoot !== null) return envRoot;
-  return resolveLogRoot("auto");
+  return null;
 }
 function closeParkedConnections(slot) {
   if (slot.stt) {
@@ -34093,7 +35152,12 @@ var Patter = class {
           ...working,
           provider: "openai_realtime",
           model: working.model ?? engine.model,
-          voice: working.voice ?? engine.voice
+          voice: working.voice ?? engine.voice,
+          // Explicit agent() kwargs win over the engine marker value
+          // (same precedence as Python: explicit kwarg > engine > default).
+          openaiRealtimeNoiseReduction: working.openaiRealtimeNoiseReduction ?? engine.noiseReduction,
+          realtimeTurnDetection: working.realtimeTurnDetection ?? engine.turnDetection,
+          openaiRealtimeGateResponseOnTranscript: working.openaiRealtimeGateResponseOnTranscript ?? engine.gateResponseOnTranscript
         };
         if (!this.localConfig.openaiKey) {
           this.localConfig = { ...this.localConfig, openaiKey: engine.apiKey };
@@ -34118,6 +35182,11 @@ var Patter = class {
         throw new Error(`provider must be one of: ${valid.join(", ")}. Got: '${working.provider}'`);
       }
     }
+    if (working.consult && working.provider === "elevenlabs_convai") {
+      getLogger().warn(
+        "consult is set but provider is ElevenLabs ConvAI; the consult tool is only injected in Realtime and Pipeline modes and will be ignored for this agent."
+      );
+    }
     if (working.llm !== void 0) {
       const llm = working.llm;
       if (!llm || typeof llm.stream !== "function") {
@@ -34256,7 +35325,8 @@ var Patter = class {
       opts.onMetrics,
       opts.pricing,
       opts.dashboard ?? true,
-      opts.dashboardToken ?? ""
+      opts.dashboardToken ?? "",
+      opts.allowInsecureDashboard ?? false
     );
     this.embeddedServer.popPrewarmAudio = this.popPrewarmAudio;
     this.embeddedServer.popPrewarmedConnections = this.popPrewarmedConnections;
@@ -34668,8 +35738,8 @@ var Patter = class {
     if (!options.to) {
       throw new Error("'to' phone number is required");
     }
-    if (!options.to.startsWith("+")) {
-      throw new Error(`'to' must be in E.164 format (e.g., '+1234567890'). Got: '${options.to}'`);
+    if (!/^\+[1-9]\d{6,14}$/.test(options.to)) {
+      throw new Error("'to' must be E.164 format (+<country><digits>). Got value with invalid format.");
     }
     if (options.wait && !this.embeddedServer) {
       throw new PatterConnectionError(
@@ -34680,9 +35750,6 @@ var Patter = class {
     let callId = "";
     const effectiveRingTimeout = options.ringTimeout === void 0 ? 25 : options.ringTimeout;
     const wantsAmd = options.machineDetection !== false || Boolean(options.voicemailMessage);
-    if (this.embeddedServer) {
-      this.embeddedServer.onMachineDetection = options.onMachineDetection;
-    }
     if (options.agent.prewarm !== false) {
       this.spawnProviderWarmup(options.agent);
     }
@@ -34727,6 +35794,12 @@ var Patter = class {
         };
         if (this.embeddedServer) {
           this.embeddedServer.metricsStore.recordCallInitiated(initiatedPayload);
+          if (options.onMachineDetection) {
+            this.embeddedServer.onMachineDetectionByCallSid.set(
+              telnyxCallId,
+              options.onMachineDetection
+            );
+          }
         }
         try {
           const { notifyDashboard: notifyDashboard2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
@@ -34792,6 +35865,12 @@ var Patter = class {
         };
         if (this.embeddedServer) {
           this.embeddedServer.metricsStore.recordCallInitiated(initiatedPayload);
+          if (options.onMachineDetection) {
+            this.embeddedServer.onMachineDetectionByCallSid.set(
+              plivoCallId,
+              options.onMachineDetection
+            );
+          }
         }
         try {
           const { notifyDashboard: notifyDashboard2 } = await Promise.resolve().then(() => (init_persistence(), persistence_exports));
@@ -34861,6 +35940,12 @@ var Patter = class {
       };
       if (this.embeddedServer) {
         this.embeddedServer.metricsStore.recordCallInitiated(initiatedPayload);
+        if (options.onMachineDetection) {
+          this.embeddedServer.onMachineDetectionByCallSid.set(
+            twilioCallSid,
+            options.onMachineDetection
+          );
+        }
         if (twilioNotificationsPath) {
           getLogger().info(
             `Outbound call ${twilioCallSid} placed. Twilio notifications: https://api.twilio.com${twilioNotificationsPath} (check here if the call drops with no audio).`
@@ -35144,6 +36229,7 @@ function defineTool(input) {
 }
 
 // src/index.ts
+init_consult();
 init_logger();
 init_sentence_chunker();
 init_pipeline_hooks();
@@ -35361,8 +36447,8 @@ var FallbackLLMProvider = class {
    * markers are filtered out so callers can concatenate the yielded strings
    * directly.
    */
-  async *completeStream(messages, tools) {
-    for await (const chunk of this.stream(messages, tools)) {
+  async *completeStream(messages, tools, opts) {
+    for await (const chunk of this.stream(messages, tools, opts)) {
       if (chunk.type === "text") {
         yield chunk.content ?? "";
       }
@@ -35372,14 +36458,15 @@ var FallbackLLMProvider = class {
   // LLMProvider implementation
   // -----------------------------------------------------------------------
   /** Streaming entry point — yields chunks from the first provider that succeeds. */
-  async *stream(messages, tools) {
+  async *stream(messages, tools, opts) {
     const errors = [];
     const result = yield* this.tryProviders(
       messages,
       tools,
       /* availableOnly */
       true,
-      errors
+      errors,
+      opts
     );
     if (result === "done") return;
     getLogger().warn(
@@ -35390,7 +36477,8 @@ var FallbackLLMProvider = class {
       tools,
       /* availableOnly */
       false,
-      errors
+      errors,
+      opts
     );
     if (retryResult === "done") return;
     throw new AllProvidersFailedError(
@@ -35400,7 +36488,7 @@ var FallbackLLMProvider = class {
   // -----------------------------------------------------------------------
   // Internals
   // -----------------------------------------------------------------------
-  async *tryProviders(messages, tools, availableOnly, errors) {
+  async *tryProviders(messages, tools, availableOnly, errors, opts) {
     for (let i = 0; i < this.providers.length; i++) {
       if (availableOnly && !this.availability[i]) continue;
       for (let attempt = 0; attempt < this.maxRetryPerProvider; attempt++) {
@@ -35409,7 +36497,7 @@ var FallbackLLMProvider = class {
             `FallbackLLMProvider: trying provider ${i}${attempt > 0 ? ` (retry ${attempt})` : ""}`
           );
           let yieldedTokens = false;
-          const gen = this.providers[i].stream(messages, tools);
+          const gen = this.providers[i].stream(messages, tools, opts);
           while (true) {
             let iterResult;
             try {
@@ -35523,7 +36611,7 @@ var PARAMETERS_SCHEMA = {
   required: ["to"]
 };
 var DEFAULT_NAME = "make_phone_call";
-var DEFAULT_DESCRIPTION = "Place a real outbound phone call. Returns a JSON object with the full transcript, call status, duration in seconds, and cost. Use this when the user asks you to call someone, schedule appointments by phone, or otherwise reach a human via voice.";
+var DEFAULT_DESCRIPTION2 = "Place a real outbound phone call. Returns a JSON object with the full transcript, call status, duration in seconds, and cost. Use this when the user asks you to call someone, schedule appointments by phone, or otherwise reach a human via voice.";
 var PatterTool = class {
   name;
   description;
@@ -35532,6 +36620,11 @@ var PatterTool = class {
   maxDurationSec;
   recording;
   started = false;
+  /** Cached in-progress (or completed) start promise so concurrent execute()
+   *  callers all await the same boot sequence instead of each racing into
+   *  phone.serve(). Reset to null on failure so callers can retry after a
+   *  transient error. */
+  startPromise = null;
   constructor(opts) {
     if (!opts.phone) {
       throw new Error("PatterTool: `phone` (a Patter instance) is required.");
@@ -35539,7 +36632,7 @@ var PatterTool = class {
     this.phone = opts.phone;
     this.agent = opts.agent;
     this.name = opts.name ?? DEFAULT_NAME;
-    this.description = opts.description ?? DEFAULT_DESCRIPTION;
+    this.description = opts.description ?? DEFAULT_DESCRIPTION2;
     this.maxDurationSec = Math.max(5, Math.min(1800, opts.maxDurationSec ?? 180));
     this.recording = opts.recording ?? false;
   }
@@ -35583,8 +36676,21 @@ var PatterTool = class {
    * `serve()` provides here. No `onCallEnd` callback is wired: the SDK's own
    * per-callId completion registry resolves the result, so the user's
    * `onCallEnd` slot is left free.
+   *
+   * Idempotent and concurrency-safe: concurrent callers all await the same
+   * in-progress boot instead of each racing into `phone.serve()`.
    */
   async start() {
+    if (this.startPromise) return this.startPromise;
+    this.startPromise = this._doStart();
+    try {
+      await this.startPromise;
+    } catch (err) {
+      this.startPromise = null;
+      throw err;
+    }
+  }
+  async _doStart() {
     if (this.started) return;
     if (!this.agent) {
       throw new Error(
@@ -35610,6 +36716,7 @@ var PatterTool = class {
       }
     }
     this.started = false;
+    this.startPromise = null;
   }
   // --- Execution ----------------------------------------------------------
   /**
@@ -35981,7 +37088,8 @@ var UltravoxRealtimeAdapter = class {
         "X-API-Key": this.apiKey,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15e3)
     });
     if (!resp.ok) {
       const text = await resp.text().catch(() => "");
@@ -35992,12 +37100,36 @@ var UltravoxRealtimeAdapter = class {
     this.ws = new import_ws6.default(call.joinUrl);
     await new Promise((resolve2, reject) => {
       const ws = this.ws;
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        ws.off("open", onOpen);
+        ws.off("error", onError);
+        this.ws = null;
+        try {
+          ws.close();
+        } catch {
+        }
+        reject(new Error("Ultravox WS connect timeout"));
+      }, 15e3);
       const onOpen = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
         ws.off("error", onError);
         resolve2();
       };
       const onError = (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
         ws.off("open", onOpen);
+        this.ws = null;
+        try {
+          ws.close();
+        } catch {
+        }
         reject(err);
       };
       ws.once("open", onOpen);
@@ -36845,7 +37977,7 @@ var STT = class extends DeepgramSTT {
       {
         endpointingMs: opts.endpointingMs ?? 150,
         utteranceEndMs: opts.utteranceEndMs === null ? null : opts.utteranceEndMs ?? 1e3,
-        smartFormat: opts.smartFormat ?? true,
+        smartFormat: opts.smartFormat ?? false,
         interimResults: opts.interimResults ?? true,
         ...opts.vadEvents !== void 0 ? { vadEvents: opts.vadEvents } : {}
       }
@@ -37165,7 +38297,7 @@ var CartesiaSTT = class {
       });
       ws.once("error", (err) => {
         clearTimeout(timer);
-        reject(err);
+        reject(new Error(`Cartesia STT park connect failed: ${describeWarmupError(err)}`));
       });
     });
     return ws;
@@ -37521,7 +38653,7 @@ var SonioxSTT = class _SonioxSTT {
   /** Stable pricing/dashboard key — read by stream-handler/metrics. */
   static providerKey = "soniox";
   ws = null;
-  callbacks = [];
+  callbacks = /* @__PURE__ */ new Set();
   final = new TokenAccumulator();
   keepaliveTimer = null;
   apiKey;
@@ -37683,16 +38815,13 @@ var SonioxSTT = class _SonioxSTT {
     if (audio.length === 0) return;
     this.ws.send(audio);
   }
-  /** Register a transcript listener (max 10 concurrent listeners). */
+  /** Register a transcript listener. */
   onTranscript(callback) {
-    if (this.callbacks.length >= 10) {
-      getLogger().warn(
-        "SonioxSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback."
-      );
-      this.callbacks[this.callbacks.length - 1] = callback;
-      return;
-    }
-    this.callbacks.push(callback);
+    this.callbacks.add(callback);
+  }
+  /** Unregister a previously registered transcript listener. */
+  offTranscript(callback) {
+    this.callbacks.delete(callback);
   }
   /** Send the empty-frame stream terminator and close the WebSocket. */
   close() {
@@ -37774,12 +38903,6 @@ var VALID_DOMAINS = /* @__PURE__ */ new Set([
   AssemblyAIDomain.GENERAL,
   AssemblyAIDomain.MEDICAL_V1
 ]);
-var AssemblyAISTTNotConnectedError = class extends Error {
-  constructor(message = "AssemblyAISTT is not connected") {
-    super(message);
-    this.name = "AssemblyAISTTNotConnectedError";
-  }
-};
 var AssemblyAISTT = class _AssemblyAISTT {
   constructor(apiKey, options = {}) {
     this.apiKey = apiKey;
@@ -38103,9 +39226,10 @@ var AssemblyAISTT = class _AssemblyAISTT {
    */
   updateConfiguration(params) {
     if (!this.ws || this.ws.readyState !== import_ws9.default.OPEN) {
-      throw new AssemblyAISTTNotConnectedError(
-        "AssemblyAISTT.updateConfiguration: WebSocket is not open"
+      getLogger().debug(
+        "AssemblyAISTT.updateConfiguration: WebSocket is not open \u2014 dropping update (call teardown)."
       );
+      return;
     }
     const payload = {
       type: AssemblyAIClientFrame.UPDATE_CONFIGURATION
@@ -38127,9 +39251,10 @@ var AssemblyAISTT = class _AssemblyAISTT {
   /** Force the server to finalize the current turn (for barge-in). */
   forceEndpoint() {
     if (!this.ws || this.ws.readyState !== import_ws9.default.OPEN) {
-      throw new AssemblyAISTTNotConnectedError(
-        "AssemblyAISTT.forceEndpoint: WebSocket is not open"
+      getLogger().debug(
+        "AssemblyAISTT.forceEndpoint: WebSocket is not open \u2014 dropping request (call teardown)."
       );
+      return;
     }
     this.ws.send(JSON.stringify({ type: AssemblyAIClientFrame.FORCE_ENDPOINT }));
   }
@@ -38144,6 +39269,14 @@ var AssemblyAISTT = class _AssemblyAISTT {
   async close() {
     this.closing = true;
     if (!this.ws) return;
+    if (this.chunkBufferBytes > 0 && this.ws.readyState === import_ws9.default.OPEN) {
+      try {
+        this.ws.send(Buffer.concat(this.chunkBuffer, this.chunkBufferBytes));
+      } catch {
+      }
+      this.chunkBuffer = [];
+      this.chunkBufferBytes = 0;
+    }
     try {
       this.ws.send(JSON.stringify({ type: AssemblyAIClientFrame.TERMINATE }));
     } catch {
@@ -39350,7 +40483,7 @@ var TTS3 = class extends OpenAITTS {
       opts.model ?? "gpt-4o-mini-tts",
       opts.instructions ?? null,
       opts.speed ?? null,
-      opts.antiAlias ?? false
+      opts.antiAlias ?? true
     );
   }
 };
@@ -39525,7 +40658,6 @@ init_cjs_shims();
 init_cjs_shims();
 init_logger();
 var INWORLD_BASE_URL = "https://api.inworld.ai/tts/v1/voice:stream";
-var INWORLD_VOICES_URL = "https://api.inworld.ai/tts/v1/voices";
 var InworldModel = {
   TTS_2: "inworld-tts-2",
   TTS_1_5_MAX: "inworld-tts-1.5-max",
@@ -39614,7 +40746,8 @@ var InworldTTS = class {
    */
   async warmup() {
     try {
-      await fetch(INWORLD_VOICES_URL, {
+      const voicesUrl = new URL(this.baseUrl).origin + "/tts/v1/voices";
+      await fetch(voicesUrl, {
         method: "GET",
         headers: {
           Authorization: `Basic ${this.authToken}`
@@ -39874,58 +41007,87 @@ var AnthropicLLMProvider = class {
     const toolIndexByBlock = /* @__PURE__ */ new Map();
     const toolIdByBlock = /* @__PURE__ */ new Map();
     let nextIndex = 0;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data: ")) continue;
-        const data = trimmed.slice(6);
-        if (!data || data === "[DONE]") continue;
-        let event;
-        try {
-          event = JSON.parse(data);
-        } catch {
-          continue;
-        }
-        if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
-          const blockIdx = event.index ?? 0;
-          const toolId = event.content_block.id ?? "";
-          const toolName = event.content_block.name ?? "";
-          const patterIndex = nextIndex++;
-          toolIndexByBlock.set(blockIdx, patterIndex);
-          toolIdByBlock.set(blockIdx, toolId);
-          yield {
-            type: "tool_call",
-            index: patterIndex,
-            id: toolId,
-            name: toolName,
-            arguments: ""
-          };
-          continue;
-        }
-        if (event.type === "content_block_delta") {
-          if (event.delta?.type === "text_delta" && event.delta.text) {
-            yield { type: "text", content: event.delta.text };
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (!data || data === "[DONE]") continue;
+          let event;
+          try {
+            event = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          if (event.type === "message_start" && event.message?.usage) {
+            const u = event.message.usage;
+            if (u.input_tokens) inputTokens = u.input_tokens;
+            if (u.cache_creation_input_tokens) cacheWriteTokens = u.cache_creation_input_tokens;
+            if (u.cache_read_input_tokens) cacheReadTokens = u.cache_read_input_tokens;
+            continue;
+          }
+          if (event.type === "message_delta" && event.usage?.output_tokens) {
+            outputTokens = event.usage.output_tokens;
             continue;
           }
-          if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+          if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
             const blockIdx = event.index ?? 0;
-            const patterIndex = toolIndexByBlock.get(blockIdx);
-            if (patterIndex !== void 0) {
-              yield {
-                type: "tool_call",
-                index: patterIndex,
-                id: toolIdByBlock.get(blockIdx),
-                arguments: event.delta.partial_json
-              };
+            const toolId = event.content_block.id ?? "";
+            const toolName = event.content_block.name ?? "";
+            const patterIndex = nextIndex++;
+            toolIndexByBlock.set(blockIdx, patterIndex);
+            toolIdByBlock.set(blockIdx, toolId);
+            yield {
+              type: "tool_call",
+              index: patterIndex,
+              id: toolId,
+              name: toolName,
+              arguments: ""
+            };
+            continue;
+          }
+          if (event.type === "content_block_delta") {
+            if (event.delta?.type === "text_delta" && event.delta.text) {
+              yield { type: "text", content: event.delta.text };
+              continue;
+            }
+            if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+              const blockIdx = event.index ?? 0;
+              const patterIndex = toolIndexByBlock.get(blockIdx);
+              if (patterIndex !== void 0) {
+                yield {
+                  type: "tool_call",
+                  index: patterIndex,
+                  id: toolIdByBlock.get(blockIdx),
+                  arguments: event.delta.partial_json
+                };
+              }
             }
           }
         }
       }
+    } finally {
+      reader.cancel().catch(() => {
+      });
+    }
+    if (inputTokens > 0 || outputTokens > 0 || cacheReadTokens > 0 || cacheWriteTokens > 0) {
+      yield {
+        type: "usage",
+        inputTokens,
+        outputTokens,
+        cacheReadInputTokens: cacheReadTokens,
+        cacheWriteInputTokens: cacheWriteTokens
+      };
     }
     yield { type: "done" };
   }
@@ -39985,16 +41147,17 @@ function toAnthropicMessages(messages) {
     }
     if (role === "tool") {
       const contentStr = typeof rawMsg.content === "string" ? rawMsg.content : JSON.stringify(rawMsg.content);
-      out.push({
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: rawMsg.tool_call_id ?? "",
-            content: contentStr
-          }
-        ]
-      });
+      const toolResultBlock = {
+        type: "tool_result",
+        tool_use_id: rawMsg.tool_call_id ?? "",
+        content: contentStr
+      };
+      const prev = out.length > 0 ? out[out.length - 1] : void 0;
+      if (prev && prev.role === "user" && Array.isArray(prev.content) && prev.content.length > 0 && prev.content.every((b) => b["type"] === "tool_result")) {
+        prev.content.push(toolResultBlock);
+      } else {
+        out.push({ role: "user", content: [toolResultBlock] });
+      }
       continue;
     }
   }
@@ -40137,50 +41300,55 @@ async function* parseOpenAISseStream(response) {
   if (!reader) return;
   const decoder = new TextDecoder();
   let buffer = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || !trimmed.startsWith("data: ")) continue;
-      const data = trimmed.slice(6);
-      if (data === "[DONE]") continue;
-      let chunk;
-      try {
-        chunk = JSON.parse(data);
-      } catch {
-        continue;
-      }
-      const usage = chunk.usage ?? chunk.x_groq?.usage;
-      if (usage) {
-        const cached2 = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
-        yield {
-          type: "usage",
-          inputTokens: usage.prompt_tokens,
-          outputTokens: usage.completion_tokens,
-          cacheReadInputTokens: cached2
-        };
-      }
-      const delta = chunk.choices?.[0]?.delta;
-      if (!delta) continue;
-      if (delta.content) {
-        yield { type: "text", content: delta.content };
-      }
-      if (delta.tool_calls) {
-        for (const tc of delta.tool_calls) {
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data: ")) continue;
+        const data = trimmed.slice(6);
+        if (data === "[DONE]") continue;
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        const usage = chunk.usage ?? chunk.x_groq?.usage;
+        if (usage) {
+          const cached2 = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
           yield {
-            type: "tool_call",
-            index: tc.index,
-            id: tc.id,
-            name: tc.function?.name,
-            arguments: tc.function?.arguments
+            type: "usage",
+            inputTokens: usage.prompt_tokens,
+            outputTokens: usage.completion_tokens,
+            cacheReadInputTokens: cached2
           };
         }
+        const delta = chunk.choices?.[0]?.delta;
+        if (!delta) continue;
+        if (delta.content) {
+          yield { type: "text", content: delta.content };
+        }
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            yield {
+              type: "tool_call",
+              index: tc.index,
+              id: tc.id,
+              name: tc.function?.name,
+              arguments: tc.function?.arguments
+            };
+          }
+        }
       }
     }
+  } finally {
+    reader.cancel().catch(() => {
+    });
   }
 }
 
@@ -40349,11 +41517,21 @@ var CerebrasLLMProvider = class {
       }
       const advisoryMs = parseRateLimitResetMs(response.headers);
       const exponentialMs = RETRY_BACKOFF_BASE_MS * Math.pow(2, attempt);
-      const delayMs = Math.max(advisoryMs, exponentialMs);
+      const delayMs = Math.min(5e3, Math.max(advisoryMs, exponentialMs));
       getLogger().warn(
         `Cerebras API ${response.status} (attempt ${attempt + 1}/${maxAttempts}); retrying after ${delayMs}ms`
       );
-      await new Promise((r) => setTimeout(r, delayMs));
+      await new Promise((resolve2, reject) => {
+        const t = setTimeout(resolve2, delayMs);
+        opts?.signal?.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(t);
+            reject(opts.signal.reason);
+          },
+          { once: true }
+        );
+      });
     }
     throw new PatterError(`Cerebras API error ${lastStatus}: ${lastErrText || "request failed"}`);
   }
@@ -40516,47 +41694,52 @@ var GoogleLLMProvider = class {
     let buffer = "";
     let nextIndex = 0;
     let lastUsage;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data: ")) continue;
-        const data = trimmed.slice(6);
-        if (!data) continue;
-        let payload;
-        try {
-          payload = JSON.parse(data);
-        } catch {
-          continue;
-        }
-        if (payload.usageMetadata) {
-          lastUsage = payload.usageMetadata;
-        }
-        const candidate = payload.candidates?.[0];
-        const parts = candidate?.content?.parts ?? [];
-        for (const part of parts) {
-          if (part.functionCall) {
-            const args = part.functionCall.args ?? {};
-            const callId = part.functionCall.id ?? `gemini_call_${nextIndex}`;
-            yield {
-              type: "tool_call",
-              index: nextIndex,
-              id: callId,
-              name: part.functionCall.name ?? "",
-              arguments: JSON.stringify(args)
-            };
-            nextIndex++;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (!data) continue;
+          let payload;
+          try {
+            payload = JSON.parse(data);
+          } catch {
             continue;
           }
-          if (part.text) {
-            yield { type: "text", content: part.text };
+          if (payload.usageMetadata) {
+            lastUsage = payload.usageMetadata;
+          }
+          const candidate = payload.candidates?.[0];
+          const parts = candidate?.content?.parts ?? [];
+          for (const part of parts) {
+            if (part.functionCall) {
+              const args = part.functionCall.args ?? {};
+              const callId = part.functionCall.id ?? `gemini_call_${nextIndex}`;
+              yield {
+                type: "tool_call",
+                index: nextIndex,
+                id: callId,
+                name: part.functionCall.name ?? "",
+                arguments: JSON.stringify(args)
+              };
+              nextIndex++;
+              continue;
+            }
+            if (part.text) {
+              yield { type: "text", content: part.text };
+            }
           }
         }
       }
+    } finally {
+      reader.cancel().catch(() => {
+      });
     }
     if (lastUsage) {
       yield {
@@ -40650,7 +41833,17 @@ function toGeminiContents(messages) {
       continue;
     }
   }
-  return { systemInstruction: systemParts.join("\n\n"), contents };
+  const merged = [];
+  for (const entry of contents) {
+    const prev = merged[merged.length - 1];
+    const isFunctionResponseOnly = (c) => c.role === "user" && c.parts.every((p) => p.functionResponse !== void 0);
+    if (prev && isFunctionResponseOnly(prev) && isFunctionResponseOnly(entry)) {
+      prev.parts.push(...entry.parts);
+    } else {
+      merged.push(entry);
+    }
+  }
+  return { systemInstruction: systemParts.join("\n\n"), contents: merged };
 }
 
 // src/llm/google.ts
@@ -40673,13 +41866,270 @@ var LLM5 = class extends GoogleLLMProvider {
   }
 };
 
+// src/llm/openai-compatible.ts
+init_cjs_shims();
+init_llm_loop();
+init_errors();
+init_logger();
+init_version();
+var DEFAULT_TIMEOUT_S = 60;
+var OpenAICompatibleLLMProvider = class {
+  /**
+   * Stable pricing/dashboard key — read by stream-handler/metrics. Typed as
+   * ``string`` (not the narrowed literal) so the Hermes / OpenClaw presets can
+   * override it with their own key while still extending this class.
+   */
+  static providerKey = "openai_compatible";
+  /** Resolved bearer; undefined for keyless gateways. */
+  apiKey;
+  model;
+  baseUrl;
+  timeoutMs;
+  extraHeaders;
+  sessionUserPrefix;
+  sessionIdHeader;
+  sessionIdPrefix;
+  sessionKeyHeader;
+  sessionKey;
+  temperature;
+  maxTokens;
+  responseFormat;
+  parallelToolCalls;
+  toolChoice;
+  seed;
+  topP;
+  frequencyPenalty;
+  presencePenalty;
+  stop;
+  constructor(options) {
+    if (!options.baseUrl) {
+      throw new Error(
+        'OpenAICompatibleLLMProvider requires a baseUrl (e.g. "http://127.0.0.1:11434/v1").'
+      );
+    }
+    if (!options.model) {
+      throw new Error("OpenAICompatibleLLMProvider requires a model.");
+    }
+    this.apiKey = options.apiKey ?? (options.apiKeyEnv ? process.env[options.apiKeyEnv] : void 0);
+    this.model = options.model;
+    this.baseUrl = options.baseUrl;
+    this.timeoutMs = (options.timeout ?? DEFAULT_TIMEOUT_S) * 1e3;
+    this.extraHeaders = options.extraHeaders;
+    this.sessionUserPrefix = options.sessionUserPrefix;
+    this.sessionIdHeader = options.sessionIdHeader;
+    this.sessionIdPrefix = options.sessionIdPrefix;
+    this.sessionKeyHeader = options.sessionKeyHeader;
+    this.sessionKey = options.sessionKey;
+    this.temperature = options.temperature;
+    this.maxTokens = options.maxTokens;
+    this.responseFormat = options.responseFormat;
+    this.parallelToolCalls = options.parallelToolCalls;
+    this.toolChoice = options.toolChoice;
+    this.seed = options.seed;
+    this.topP = options.topP;
+    this.frequencyPenalty = options.frequencyPenalty;
+    this.presencePenalty = options.presencePenalty;
+    this.stop = options.stop;
+  }
+  /**
+   * Assemble the request headers. ``User-Agent`` is set first so any
+   * ``extraHeaders`` (and the per-call session headers) layer on top without
+   * silently dropping the SDK attribution, and the ``Authorization`` header is
+   * only added when a key is present (keyless gateways omit it).
+   *
+   * The two session headers are emitted INDEPENDENTLY, each gated on its own
+   * config (decoupled from ``sessionUserPrefix`` and from each other):
+   *  - ``sessionIdHeader`` (+ ``callId``) → ``` `${sessionIdPrefix}${callId}` ```
+   *  - ``sessionKeyHeader`` (+ ``sessionKey``) → the static ``sessionKey`` value.
+   * ``sessionKey`` is a credential-grade memory scope and is never logged.
+   */
+  buildHeaders(callId) {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": `getpatter/${VERSION}`,
+      ...this.extraHeaders ?? {}
+    };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    if (this.sessionIdHeader && callId) {
+      headers[this.sessionIdHeader] = `${this.sessionIdPrefix ?? ""}${callId}`;
+    }
+    if (this.sessionKeyHeader && this.sessionKey) {
+      headers[this.sessionKeyHeader] = this.sessionKey;
+    }
+    return headers;
+  }
+  /**
+   * Pre-call DNS / TLS warmup for the configured endpoint. Best-effort:
+   * 5 s timeout, all exceptions swallowed at debug level. The ``Authorization``
+   * header is only sent when a key is present so the operator-grade bearer is
+   * never echoed for keyless gateways (and the key is never logged).
+   */
+  async warmup() {
+    try {
+      const headers = {};
+      if (this.apiKey) headers.Authorization = `Bearer ${this.apiKey}`;
+      await fetch(`${this.baseUrl}/models`, {
+        method: "GET",
+        headers,
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch (err) {
+      getLogger().debug(
+        `OpenAI-compatible LLM warmup failed (best-effort): ${String(err)}`
+      );
+    }
+  }
+  /**
+   * Build the request body. Mirrors the base OpenAI provider's sampling-kwarg
+   * assembly and additionally sets ``user`` for session continuity when
+   * ``sessionUserPrefix`` is set AND a ``callId`` is available — so the default
+   * (prefix unset) behaviour is byte-identical to the base provider.
+   */
+  buildBody(messages, tools, callId) {
+    const body = {
+      model: this.model,
+      messages,
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    if (this.temperature !== void 0) body.temperature = this.temperature;
+    if (this.maxTokens !== void 0) body.max_completion_tokens = this.maxTokens;
+    if (this.responseFormat !== void 0) body.response_format = this.responseFormat;
+    if (this.parallelToolCalls !== void 0) body.parallel_tool_calls = this.parallelToolCalls;
+    if (this.toolChoice !== void 0) body.tool_choice = this.toolChoice;
+    if (this.seed !== void 0) body.seed = this.seed;
+    if (this.topP !== void 0) body.top_p = this.topP;
+    if (this.frequencyPenalty !== void 0) body.frequency_penalty = this.frequencyPenalty;
+    if (this.presencePenalty !== void 0) body.presence_penalty = this.presencePenalty;
+    if (this.stop !== void 0) body.stop = this.stop;
+    if (tools) body.tools = tools;
+    if (this.sessionUserPrefix !== void 0 && callId) {
+      body.user = `${this.sessionUserPrefix}${callId}`;
+    }
+    return body;
+  }
+  /** Stream Patter-format LLM chunks from the configured chat completions API. */
+  async *stream(messages, tools, opts) {
+    const callId = opts?.callId;
+    const body = this.buildBody(messages, tools, callId);
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: this.buildHeaders(callId),
+      body: JSON.stringify(body),
+      signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(this.timeoutMs))
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      getLogger().error(
+        `OpenAI-compatible API error: ${response.status} ${errText}`
+      );
+      throw new PatterConnectionError(
+        `LLM API returned ${response.status}: ${errText.slice(0, 200)}`
+      );
+    }
+    yield* parseOpenAISseStream(response);
+  }
+};
+var LLM6 = class extends OpenAICompatibleLLMProvider {
+  static providerKey = "openai_compatible";
+};
+
+// src/llm/hermes.ts
+init_cjs_shims();
+var BASE_URL = "http://127.0.0.1:8642/v1";
+var DEFAULT_MODEL5 = "hermes-agent";
+var API_KEY_ENV = "API_SERVER_KEY";
+var MODEL_ENV = "API_SERVER_MODEL_NAME";
+var SESSION_USER_PREFIX = "patter-call-";
+var SESSION_ID_HEADER = "X-Hermes-Session-Id";
+var SESSION_ID_PREFIX = "patter-call-";
+var SESSION_KEY_HEADER = "X-Hermes-Session-Key";
+var DEFAULT_TIMEOUT_S2 = 120;
+var LLM7 = class extends OpenAICompatibleLLMProvider {
+  static providerKey = "hermes";
+  constructor(opts = {}) {
+    const model = opts.model ?? process.env[MODEL_ENV] ?? DEFAULT_MODEL5;
+    const options = {
+      apiKey: opts.apiKey,
+      apiKeyEnv: API_KEY_ENV,
+      baseUrl: opts.baseUrl ?? BASE_URL,
+      model,
+      timeout: opts.timeout ?? DEFAULT_TIMEOUT_S2,
+      sessionUserPrefix: SESSION_USER_PREFIX,
+      sessionIdHeader: SESSION_ID_HEADER,
+      sessionIdPrefix: SESSION_ID_PREFIX,
+      sessionKeyHeader: SESSION_KEY_HEADER,
+      sessionKey: opts.sessionKey,
+      extraHeaders: opts.extraHeaders,
+      temperature: opts.temperature,
+      maxTokens: opts.maxTokens,
+      responseFormat: opts.responseFormat,
+      parallelToolCalls: opts.parallelToolCalls,
+      toolChoice: opts.toolChoice,
+      seed: opts.seed,
+      topP: opts.topP,
+      frequencyPenalty: opts.frequencyPenalty,
+      presencePenalty: opts.presencePenalty,
+      stop: opts.stop
+    };
+    super(options);
+  }
+};
+
+// src/llm/openclaw.ts
+init_cjs_shims();
+var BASE_URL2 = "http://127.0.0.1:18789/v1";
+var API_KEY_ENV2 = "OPENCLAW_API_KEY";
+var SESSION_HEADER = "x-openclaw-session-key";
+var SESSION_USER_PREFIX2 = "patter-call-";
+var DEFAULT_TIMEOUT_S3 = 120;
+var OPENCLAW_AGENT_RE2 = /^[A-Za-z0-9._:/-]+$/;
+var LLM8 = class extends OpenAICompatibleLLMProvider {
+  static providerKey = "openclaw";
+  constructor(opts) {
+    const agent = opts?.agent;
+    if (!agent || !OPENCLAW_AGENT_RE2.test(agent)) {
+      throw new Error(
+        `Invalid OpenClaw agent id: ${JSON.stringify(agent)}. Allowed characters: letters, digits, dot, underscore, colon, slash, dash.`
+      );
+    }
+    const model = agent.includes("/") || agent.includes(":") ? agent : `openclaw/${agent}`;
+    const options = {
+      apiKey: opts.apiKey,
+      apiKeyEnv: API_KEY_ENV2,
+      baseUrl: opts.baseUrl ?? BASE_URL2,
+      model,
+      timeout: opts.timeout ?? DEFAULT_TIMEOUT_S3,
+      sessionUserPrefix: SESSION_USER_PREFIX2,
+      // Wire-identical to the prior behaviour: header value is the raw call id
+      // (empty prefix), and OpenClaw's gateway also derives the session from
+      // the ``user`` field above. No separate memory-scope header.
+      sessionIdHeader: SESSION_HEADER,
+      sessionIdPrefix: "",
+      extraHeaders: opts.extraHeaders,
+      temperature: opts.temperature,
+      maxTokens: opts.maxTokens,
+      responseFormat: opts.responseFormat,
+      parallelToolCalls: opts.parallelToolCalls,
+      toolChoice: opts.toolChoice,
+      seed: opts.seed,
+      topP: opts.topP,
+      frequencyPenalty: opts.frequencyPenalty,
+      presencePenalty: opts.presencePenalty,
+      stop: opts.stop
+    };
+    super(options);
+  }
+};
+
 // src/index.ts
 init_silero_vad();
 
 // src/providers/deepfilternet-filter.ts
 init_cjs_shims();
 init_logger();
-init_transcoding();
 function log2() {
   return getLogger();
 }
@@ -40709,6 +42159,57 @@ function float32ToPcm16(samples) {
   }
   return out;
 }
+var ArbitraryResampler = class {
+  srcRate;
+  dstRate;
+  phase = 0;
+  // fractional position into the current chunk
+  lastSample = 0;
+  // last input sample from the previous chunk
+  hasHistory = false;
+  constructor(srcRate, dstRate) {
+    this.srcRate = srcRate;
+    this.dstRate = dstRate;
+  }
+  /** Process a chunk of PCM16-LE mono audio and return resampled PCM16-LE. */
+  process(pcm) {
+    const sampleCount = Math.floor(pcm.length / 2);
+    if (sampleCount === 0) return Buffer.alloc(0);
+    const step = this.srcRate / this.dstRate;
+    const outArr = [];
+    let phase = this.phase;
+    while (true) {
+      const idx = Math.floor(phase);
+      if (idx >= sampleCount) break;
+      const frac = phase - idx;
+      let s0;
+      let s1;
+      if (idx < 0) {
+        s0 = this.hasHistory ? this.lastSample : 0;
+        s1 = pcm.readInt16LE(0);
+      } else {
+        s0 = pcm.readInt16LE(idx * 2);
+        s1 = idx + 1 < sampleCount ? pcm.readInt16LE((idx + 1) * 2) : s0;
+      }
+      const interp = Math.round(s0 + (s1 - s0) * frac);
+      outArr.push(Math.max(-32768, Math.min(32767, interp)));
+      phase += step;
+    }
+    this.lastSample = pcm.readInt16LE((sampleCount - 1) * 2);
+    this.hasHistory = true;
+    this.phase = phase - sampleCount;
+    const out = Buffer.alloc(outArr.length * 2);
+    for (let j = 0; j < outArr.length; j++) out.writeInt16LE(outArr[j], j * 2);
+    return out;
+  }
+  /** Flush any buffered state and reset. Returns any remaining tail output. */
+  flush() {
+    this.phase = 0;
+    this.lastSample = 0;
+    this.hasHistory = false;
+    return Buffer.alloc(0);
+  }
+};
 var DeepFilterNetFilter = class {
   modelPath;
   silenceWarnings;
@@ -40716,8 +42217,9 @@ var DeepFilterNetFilter = class {
   ort = null;
   warned = false;
   closed = false;
-  // Fix 5: stateful resamplers for src_sr↔48k conversions so chunk-boundary
+  // Stateful resamplers for src_sr↔48k conversions so chunk-boundary
   // samples are not discarded. Lazy-created and torn down on rate change.
+  // Uses ArbitraryResampler which supports any integer rate pair.
   _resamplerSrcRate = null;
   _upsamplerInst = null;
   _downsamplerInst = null;
@@ -40775,8 +42277,8 @@ var DeepFilterNetFilter = class {
     try {
       if (this._resamplerSrcRate !== sampleRate) {
         this._resamplerSrcRate = sampleRate;
-        this._upsamplerInst = new StatefulResampler({ srcRate: sampleRate, dstRate: DEEPFILTERNET_SR });
-        this._downsamplerInst = new StatefulResampler({ srcRate: DEEPFILTERNET_SR, dstRate: sampleRate });
+        this._upsamplerInst = new ArbitraryResampler(sampleRate, DEEPFILTERNET_SR);
+        this._downsamplerInst = new ArbitraryResampler(DEEPFILTERNET_SR, sampleRate);
       }
       const samples = pcm16ToFloat32(pcmChunk);
       const pcm16Up = this._upsamplerInst.process(float32ToPcm16(new Float32Array(samples)));
@@ -40940,6 +42442,17 @@ var Tool = class {
   parameters;
   handler;
   webhookUrl;
+  reassurance;
+  /**
+   * Per-tool execution timeout in milliseconds. `undefined` uses the
+   * executor default (10 000 ms). Mirrors Python `timeout_s`.
+   */
+  timeoutMs;
+  /**
+   * Enable OpenAI strict mode for this tool's function schema. Off by
+   * default. Mirrors Python `strict` on `Tool`.
+   */
+  strict;
   constructor(opts) {
     if (!opts.name) {
       throw new Error("Tool requires a non-empty name.");
@@ -40957,6 +42470,9 @@ var Tool = class {
     this.parameters = opts.parameters ?? { type: "object", properties: {} };
     if (hasHandler) this.handler = opts.handler;
     if (hasWebhook) this.webhookUrl = opts.webhookUrl;
+    if (opts.reassurance !== void 0) this.reassurance = opts.reassurance;
+    if (opts.timeoutMs !== void 0) this.timeoutMs = opts.timeoutMs;
+    if (opts.strict !== void 0) this.strict = opts.strict;
   }
 };
 function tool(opts) {
@@ -41120,7 +42636,6 @@ var ChatContext = class _ChatContext {
 init_cjs_shims();
 init_logger();
 var DTMF_EVENTS = [
-  "0",
   "1",
   "2",
   "3",
@@ -41130,6 +42645,7 @@ var DTMF_EVENTS = [
   "7",
   "8",
   "9",
+  "0",
   "*",
   "#",
   "A",
@@ -41809,18 +43325,24 @@ var TelnyxAdapter = class {
       "/number_orders",
       orderBody
     );
-    const orderId = order.data?.id ?? "";
+    const orderId = order.data?.id;
+    if (!orderId) throw new Error("TelnyxAdapter: /number_orders returned no order id");
     return { phoneNumber: chosen, orderId };
   }
   /** Attach a number to a Call Control Application. */
   async configureNumber(phoneNumber, opts) {
     if (!phoneNumber) throw new Error("TelnyxAdapter: phoneNumber is required");
     if (!opts.connectionId) throw new Error("TelnyxAdapter: connectionId is required");
-    await this.request(
-      "PATCH",
-      `/phone_numbers/${encodeURIComponent(phoneNumber)}/voice`,
-      { connection_id: opts.connectionId, tech_prefix_enabled: false }
-    );
+    try {
+      await this.request(
+        "PATCH",
+        `/phone_numbers/${encodeURIComponent(phoneNumber)}/voice`,
+        { connection_id: opts.connectionId, tech_prefix_enabled: false }
+      );
+    } catch (err) {
+      const status = err instanceof Error ? err.message.replace(/\+\d{7,15}/g, "[REDACTED]") : String(err);
+      throw new Error(`TelnyxAdapter: configureNumber failed: ${status}`);
+    }
   }
   /**
    * Place an outbound call on the Call Control Application.
@@ -41928,7 +43450,7 @@ var TelnyxSTT = class {
   /** Stable pricing/dashboard key — read by stream-handler/metrics. */
   static providerKey = "telnyx_stt";
   ws = null;
-  callbacks = [];
+  callbacks = /* @__PURE__ */ new Set();
   headerSent = false;
   /** Open the streaming WebSocket and arm message handlers. */
   async connect() {
@@ -41984,14 +43506,13 @@ var TelnyxSTT = class {
     }
     this.ws.send(audio);
   }
-  /** Register a transcript listener (max 10 concurrent listeners). */
+  /** Register a transcript listener. */
   onTranscript(callback) {
-    if (this.callbacks.length >= 10) {
-      getLogger().warn("TelnyxSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback.");
-      this.callbacks[this.callbacks.length - 1] = callback;
-      return;
-    }
-    this.callbacks.push(callback);
+    this.callbacks.add(callback);
+  }
+  /** Unregister a previously-registered transcript listener. */
+  offTranscript(callback) {
+    this.callbacks.delete(callback);
   }
   /** Close the streaming WebSocket. */
   close() {
@@ -42002,6 +43523,7 @@ var TelnyxSTT = class {
       }
       this.ws = null;
     }
+    this.headerSent = false;
   }
 };
 
@@ -42023,6 +43545,7 @@ var TelnyxTTSSampleRate = {
   HZ_24000: 24e3
 };
 var DEFAULT_VOICE = TelnyxTTSVoice.NATURAL_HD_ASTRA;
+var FRAME_TIMEOUT_MS2 = 3e4;
 var TelnyxTTS = class {
   constructor(apiKey, voice = DEFAULT_VOICE, baseUrl = TELNYX_TTS_WS_URL) {
     this.apiKey = apiKey;
@@ -42050,69 +43573,83 @@ var TelnyxTTS = class {
    */
   async *synthesizeStream(text) {
     const url2 = `${this.baseUrl}?voice=${encodeURIComponent(this.voice)}`;
-    const ws = new import_ws13.default(url2, {
-      headers: { Authorization: `Bearer ${this.apiKey}` }
-    });
-    await new Promise((resolve2, reject) => {
-      const timer = setTimeout(() => reject(new Error("Telnyx TTS connect timeout")), 1e4);
-      ws.once("open", () => {
-        clearTimeout(timer);
-        resolve2();
+    let ws = null;
+    try {
+      let push2 = function(item) {
+        const w = waiters.shift();
+        if (w) {
+          w(item);
+        } else {
+          queue.push(item);
+        }
+      };
+      var push = push2;
+      ws = new import_ws13.default(url2, {
+        headers: { Authorization: `Bearer ${this.apiKey}` }
       });
-      ws.once("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
+      await new Promise((resolve2, reject) => {
+        const timer = setTimeout(() => reject(new Error("Telnyx TTS connect timeout")), 1e4);
+        ws.once("open", () => {
+          clearTimeout(timer);
+          resolve2();
+        });
+        ws.once("error", (err) => {
+          clearTimeout(timer);
+          reject(err);
+        });
       });
-    });
-    const queue = [];
-    const waiters = [];
-    function push(item) {
-      const w = waiters.shift();
-      if (w) {
-        w(item);
-      } else {
-        queue.push(item);
-      }
-    }
-    ws.on("message", (raw) => {
-      let data;
-      try {
-        data = JSON.parse(raw.toString());
-      } catch {
-        getLogger().warn("TelnyxTTS: received invalid JSON");
-        return;
-      }
-      const audioB64 = data.audio;
-      if (!audioB64) return;
-      try {
-        const audioBytes = Buffer.from(audioB64, "base64");
-        if (audioBytes.length > 0) {
-          push(audioBytes);
+      const queue = [];
+      const waiters = [];
+      ws.on("message", (raw) => {
+        let data;
+        try {
+          data = JSON.parse(raw.toString());
+        } catch {
+          getLogger().warn("TelnyxTTS: received invalid JSON");
+          return;
         }
-      } catch {
-      }
-    });
-    ws.on("close", () => {
-      push(null);
-    });
-    ws.on("error", (err) => {
-      push({ error: err instanceof Error ? err : new Error(String(err)) });
-    });
-    ws.send(JSON.stringify({ text: " " }));
-    ws.send(JSON.stringify({ text }));
-    ws.send(JSON.stringify({ text: "" }));
-    try {
+        const audioB64 = data.audio;
+        if (!audioB64) return;
+        try {
+          const audioBytes = Buffer.from(audioB64, "base64");
+          if (audioBytes.length > 0) {
+            push2(audioBytes);
+          }
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        push2(null);
+      });
+      ws.on("error", (err) => {
+        push2({ error: err instanceof Error ? err : new Error(String(err)) });
+      });
+      ws.send(JSON.stringify({ text: " " }));
+      ws.send(JSON.stringify({ text }));
+      ws.send(JSON.stringify({ text: "" }));
       while (true) {
-        const item = queue.length > 0 ? queue.shift() : await new Promise((resolve2) => waiters.push(resolve2));
+        let frameTimer;
+        const item = queue.length > 0 ? queue.shift() : await Promise.race([
+          new Promise((resolve2) => waiters.push(resolve2)),
+          new Promise((_, reject) => {
+            frameTimer = setTimeout(
+              () => reject(new Error("Telnyx TTS frame timeout")),
+              FRAME_TIMEOUT_MS2
+            );
+          })
+        ]).finally(() => {
+          if (frameTimer !== void 0) clearTimeout(frameTimer);
+        });
         if (item === null) return;
         if (typeof item === "object" && "error" in item) throw item.error;
         yield item;
       }
     } finally {
       try {
-        ws.close();
+        ws?.close();
       } catch {
       }
+      ws?.removeAllListeners();
     }
   }
 };
@@ -42160,6 +43697,7 @@ init_event_bus();
   GoogleLLM,
   GroqLLM,
   Guardrail,
+  HermesLLM,
   IVRActivity,
   InworldTTS,
   KrispFrameDuration,
@@ -42170,6 +43708,8 @@ init_event_bus();
   MetricsStore,
   MinWordsStrategy,
   Ngrok,
+  OpenAICompatibleLLM,
+  OpenAICompatibleLLMProvider,
   OpenAILLM,
   OpenAILLMProvider,
   OpenAIRealtime,
@@ -42183,10 +43723,12 @@ init_event_bus();
   OpenAITranscribeSTT,
   OpenAITranscriptionModel,
   OpenAIVoice,
+  OpenClawLLM,
   PRICING_LAST_UPDATED,
   PRICING_VERSION,
   PartialStreamError,
   Patter,
+  PatterConfigError,
   PatterConnectionError,
   PatterError,
   PatterTool,
@@ -42274,6 +43816,8 @@ init_event_bus();
   mulawToPcm16,
   notifyDashboard,
   openaiTts,
+  openclawConsult,
+  openclawPostCallNotifier,
   pcm16ToMulaw,
   resample16kTo8k,
   resample24kTo16k,