getpatter 0.6.3 → 0.6.5

package/dist/index.mjs

@@ -19,6 +19,7 @@ import {
   OpenAILLMProvider,
   PRICING_LAST_UPDATED,
   PRICING_VERSION,
+  PatterConfigError,
   PatterConnectionError,
   PatterError,
   PipelineHookExecutor,
@@ -52,9 +53,11 @@ import {
   mergePricing,
   mountApi,
   mountDashboard,
+  openclawConsult,
+  openclawPostCallNotifier,
   resolveLogRoot,
   startSpan
-} from "./chunk-Z6W5XFWS.mjs";
+} from "./chunk-CRPJLVHB.mjs";
 import {
   OpenAIRealtime2Adapter,
   OpenAIRealtimeAdapter,
@@ -73,8 +76,9 @@ import {
   pcm16ToMulaw,
   resample16kTo8k,
   resample24kTo16k,
-  resample8kTo16k
-} from "./chunk-CL2U3YET.mjs";
+  resample8kTo16k,
+  validateRealtimeTurnDetection
+} from "./chunk-BO227NTF.mjs";
 import {
   MinWordsStrategy,
   evaluateStrategies,
@@ -89,7 +93,7 @@ import {
 } from "./chunk-6GR5MHHQ.mjs";
 import {
   SileroVAD
-} from "./chunk-R2T4JABZ.mjs";
+} from "./chunk-3VVATR6A.mjs";
 import {
   __dirname,
   __require,
@@ -111,6 +115,9 @@ var Realtime = class {
   voice;
   reasoningEffort;
   inputAudioTranscriptionModel;
+  noiseReduction;
+  turnDetection;
+  gateResponseOnTranscript;
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
     if (!key) {
@@ -118,11 +125,20 @@ var Realtime = class {
         "OpenAI Realtime requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
       );
     }
+    if (opts.noiseReduction !== void 0 && opts.noiseReduction !== "near_field" && opts.noiseReduction !== "far_field") {
+      throw new Error(
+        `noiseReduction must be 'near_field' or 'far_field', got ${JSON.stringify(opts.noiseReduction)}`
+      );
+    }
+    validateRealtimeTurnDetection(opts.turnDetection);
     this.apiKey = key;
     this.model = opts.model ?? "gpt-realtime-mini";
     this.voice = opts.voice ?? "alloy";
     this.reasoningEffort = opts.reasoningEffort;
     this.inputAudioTranscriptionModel = opts.inputAudioTranscriptionModel;
+    this.noiseReduction = opts.noiseReduction;
+    this.turnDetection = opts.turnDetection;
+    this.gateResponseOnTranscript = opts.gateResponseOnTranscript;
   }
 };
 
@@ -135,6 +151,9 @@ var Realtime2 = class {
   voice;
   reasoningEffort;
   inputAudioTranscriptionModel;
+  noiseReduction;
+  turnDetection;
+  gateResponseOnTranscript;
   constructor(opts = {}) {
     const key = opts.apiKey ?? process.env.OPENAI_API_KEY;
     if (!key) {
@@ -142,11 +161,20 @@ var Realtime2 = class {
         "OpenAI Realtime 2 requires an apiKey. Pass { apiKey: 'sk-...' } or set OPENAI_API_KEY in the environment."
       );
     }
+    if (opts.noiseReduction !== void 0 && opts.noiseReduction !== "near_field" && opts.noiseReduction !== "far_field") {
+      throw new Error(
+        `noiseReduction must be 'near_field' or 'far_field', got ${JSON.stringify(opts.noiseReduction)}`
+      );
+    }
+    validateRealtimeTurnDetection(opts.turnDetection);
     this.apiKey = key;
     this.model = opts.model ?? "gpt-realtime-2";
     this.voice = opts.voice ?? "alloy";
     this.reasoningEffort = opts.reasoningEffort;
     this.inputAudioTranscriptionModel = opts.inputAudioTranscriptionModel;
+    this.noiseReduction = opts.noiseReduction;
+    this.turnDetection = opts.turnDetection;
+    this.gateResponseOnTranscript = opts.gateResponseOnTranscript;
   }
 };
 
@@ -573,7 +601,7 @@ function resolvePersistRoot(persist) {
   if (typeof persist === "string") return resolveLogRoot(persist);
   const envRoot = resolveLogRoot();
   if (envRoot !== null) return envRoot;
-  return resolveLogRoot("auto");
+  return null;
 }
 function closeParkedConnections(slot) {
   if (slot.stt) {
@@ -857,7 +885,12 @@ var Patter = class {
           ...working,
           provider: "openai_realtime",
           model: working.model ?? engine.model,
-          voice: working.voice ?? engine.voice
+          voice: working.voice ?? engine.voice,
+          // Explicit agent() kwargs win over the engine marker value
+          // (same precedence as Python: explicit kwarg > engine > default).
+          openaiRealtimeNoiseReduction: working.openaiRealtimeNoiseReduction ?? engine.noiseReduction,
+          realtimeTurnDetection: working.realtimeTurnDetection ?? engine.turnDetection,
+          openaiRealtimeGateResponseOnTranscript: working.openaiRealtimeGateResponseOnTranscript ?? engine.gateResponseOnTranscript
         };
         if (!this.localConfig.openaiKey) {
           this.localConfig = { ...this.localConfig, openaiKey: engine.apiKey };
@@ -882,6 +915,11 @@ var Patter = class {
         throw new Error(`provider must be one of: ${valid.join(", ")}. Got: '${working.provider}'`);
       }
     }
+    if (working.consult && working.provider === "elevenlabs_convai") {
+      getLogger().warn(
+        "consult is set but provider is ElevenLabs ConvAI; the consult tool is only injected in Realtime and Pipeline modes and will be ignored for this agent."
+      );
+    }
     if (working.llm !== void 0) {
       const llm = working.llm;
       if (!llm || typeof llm.stream !== "function") {
@@ -982,7 +1020,7 @@ var Patter = class {
     const telephonyProvider = carrier.kind;
     const wantsCarrierManagement = opts.manageWebhook !== false || wantsCloudflared;
     if (wantsCarrierManagement) {
-      const { autoConfigureCarrier } = await import("./carrier-config-3WDQXP5J.mjs");
+      const { autoConfigureCarrier } = await import("./carrier-config-7YGNRBPO.mjs");
       await autoConfigureCarrier({
         telephonyProvider,
         twilioSid: carrier.kind === "twilio" ? carrier.accountSid : void 0,
@@ -1020,7 +1058,8 @@ var Patter = class {
       opts.onMetrics,
       opts.pricing,
       opts.dashboard ?? true,
-      opts.dashboardToken ?? ""
+      opts.dashboardToken ?? "",
+      opts.allowInsecureDashboard ?? false
     );
     this.embeddedServer.popPrewarmAudio = this.popPrewarmAudio;
     this.embeddedServer.popPrewarmedConnections = this.popPrewarmedConnections;
@@ -1039,7 +1078,7 @@ var Patter = class {
   }
   /** Run the agent in interactive terminal-test mode (no real telephony). */
   async test(opts) {
-    const { TestSession: TestSession2 } = await import("./test-mode-MDBQ4ECE.mjs");
+    const { TestSession: TestSession2 } = await import("./test-mode-HGHI2AUV.mjs");
     const session = new TestSession2();
     await session.run({
       agent: opts.agent,
@@ -1218,7 +1257,7 @@ var Patter = class {
     }
     if (wantsRealtimePark) {
       tasks.push((async () => {
-        const { OpenAIRealtime2Adapter: OpenAIRealtime2Adapter2 } = await import("./openai-realtime-2-CNFARP25.mjs");
+        const { OpenAIRealtime2Adapter: OpenAIRealtime2Adapter2 } = await import("./openai-realtime-2-L5EKAAUH.mjs");
         const apiKey = process.env.OPENAI_API_KEY ?? "";
         if (!apiKey) {
           getLogger().debug(`Park OpenAI Realtime skipped for ${callId}: no OPENAI_API_KEY`);
@@ -1432,8 +1471,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(
@@ -1444,9 +1483,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);
     }
@@ -1491,6 +1527,12 @@ var Patter = class {
         };
         if (this.embeddedServer) {
           this.embeddedServer.metricsStore.recordCallInitiated(initiatedPayload);
+          if (options.onMachineDetection) {
+            this.embeddedServer.onMachineDetectionByCallSid.set(
+              telnyxCallId,
+              options.onMachineDetection
+            );
+          }
         }
         try {
           const { notifyDashboard: notifyDashboard2 } = await import("./persistence-LVIAHESK.mjs");
@@ -1556,6 +1598,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 import("./persistence-LVIAHESK.mjs");
@@ -1625,6 +1673,12 @@ var Patter = class {
       };
       if (this.embeddedServer) {
         this.embeddedServer.metricsStore.recordCallInitiated(initiatedPayload);
+        if (options.onMachineDetection) {
+          this.embeddedServer.onMachineDetectionByCallSid.set(
+            twilioCallSid,
+            options.onMachineDetection
+          );
+        }
         if (twilioNotificationsPath) {
           getLogger().info(
             `Outbound call ${twilioCallSid} placed. Twilio notifications: https://api.twilio.com${twilioNotificationsPath} (check here if the call drops with no audio).`
@@ -2105,8 +2159,8 @@ var FallbackLLMProvider = class {
    * markers are filtered out so callers can concatenate the yielded strings
    * directly.
    */
-  async *completeStream(messages, tools) {
-    for await (const chunk of this.stream(messages, tools)) {
+  async *completeStream(messages, tools, opts) {
+    for await (const chunk of this.stream(messages, tools, opts)) {
       if (chunk.type === "text") {
         yield chunk.content ?? "";
       }
@@ -2116,14 +2170,15 @@ var FallbackLLMProvider = class {
   // LLMProvider implementation
   // -----------------------------------------------------------------------
   /** Streaming entry point — yields chunks from the first provider that succeeds. */
-  async *stream(messages, tools) {
+  async *stream(messages, tools, opts) {
     const errors = [];
     const result = yield* this.tryProviders(
       messages,
       tools,
       /* availableOnly */
       true,
-      errors
+      errors,
+      opts
     );
     if (result === "done") return;
     getLogger().warn(
@@ -2134,7 +2189,8 @@ var FallbackLLMProvider = class {
       tools,
       /* availableOnly */
       false,
-      errors
+      errors,
+      opts
     );
     if (retryResult === "done") return;
     throw new AllProvidersFailedError(
@@ -2144,7 +2200,7 @@ var FallbackLLMProvider = class {
   // -----------------------------------------------------------------------
   // Internals
   // -----------------------------------------------------------------------
-  async *tryProviders(messages, tools, availableOnly, errors) {
+  async *tryProviders(messages, tools, availableOnly, errors, opts) {
     for (let i = 0; i < this.providers.length; i++) {
       if (availableOnly && !this.availability[i]) continue;
       for (let attempt = 0; attempt < this.maxRetryPerProvider; attempt++) {
@@ -2153,7 +2209,7 @@ var FallbackLLMProvider = class {
             `FallbackLLMProvider: trying provider ${i}${attempt > 0 ? ` (retry ${attempt})` : ""}`
           );
           let yieldedTokens = false;
-          const gen = this.providers[i].stream(messages, tools);
+          const gen = this.providers[i].stream(messages, tools, opts);
           while (true) {
             let iterResult;
             try {
@@ -2273,6 +2329,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.");
@@ -2324,8 +2385,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(
@@ -2351,6 +2425,7 @@ var PatterTool = class {
       }
     }
     this.started = false;
+    this.startPromise = null;
   }
   // --- Execution ----------------------------------------------------------
   /**
@@ -2715,7 +2790,8 @@ var UltravoxRealtimeAdapter = class {
         "X-API-Key": this.apiKey,
         "Content-Type": "application/json"
       },
-      body: JSON.stringify(body)
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15e3)
     });
     if (!resp.ok) {
       const text = await resp.text().catch(() => "");
@@ -2726,12 +2802,36 @@ var UltravoxRealtimeAdapter = class {
     this.ws = new WebSocket(call.joinUrl);
     await new Promise((resolve, reject) => {
       const ws = this.ws;
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        ws.off("open", onOpen);
+        ws.off("error", onError);
+        this.ws = null;
+        try {
+          ws.close();
+        } catch {
+        }
+        reject(new Error("Ultravox WS connect timeout"));
+      }, 15e3);
       const onOpen = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
         ws.off("error", onError);
         resolve();
       };
       const onError = (err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
         ws.off("open", onOpen);
+        this.ws = null;
+        try {
+          ws.close();
+        } catch {
+        }
         reject(err);
       };
       ws.once("open", onOpen);
@@ -3570,7 +3670,7 @@ var STT = class extends DeepgramSTT {
       {
         endpointingMs: opts.endpointingMs ?? 150,
         utteranceEndMs: opts.utteranceEndMs === null ? null : opts.utteranceEndMs ?? 1e3,
-        smartFormat: opts.smartFormat ?? true,
+        smartFormat: opts.smartFormat ?? false,
         interimResults: opts.interimResults ?? true,
         ...opts.vadEvents !== void 0 ? { vadEvents: opts.vadEvents } : {}
       }
@@ -3888,7 +3988,7 @@ var CartesiaSTT = class {
       });
       ws.once("error", (err) => {
         clearTimeout(timer);
-        reject(err);
+        reject(new Error(`Cartesia STT park connect failed: ${describeWarmupError(err)}`));
       });
     });
     return ws;
@@ -4243,7 +4343,7 @@ var SonioxSTT = class _SonioxSTT {
   /** Stable pricing/dashboard key — read by stream-handler/metrics. */
   static providerKey = "soniox";
   ws = null;
-  callbacks = [];
+  callbacks = /* @__PURE__ */ new Set();
   final = new TokenAccumulator();
   keepaliveTimer = null;
   apiKey;
@@ -4405,16 +4505,13 @@ var SonioxSTT = class _SonioxSTT {
     if (audio.length === 0) return;
     this.ws.send(audio);
   }
-  /** Register a transcript listener (max 10 concurrent listeners). */
+  /** Register a transcript listener. */
   onTranscript(callback) {
-    if (this.callbacks.length >= 10) {
-      getLogger().warn(
-        "SonioxSTT: maximum of 10 onTranscript callbacks reached; replacing the last callback."
-      );
-      this.callbacks[this.callbacks.length - 1] = callback;
-      return;
-    }
-    this.callbacks.push(callback);
+    this.callbacks.add(callback);
+  }
+  /** Unregister a previously registered transcript listener. */
+  offTranscript(callback) {
+    this.callbacks.delete(callback);
   }
   /** Send the empty-frame stream terminator and close the WebSocket. */
   close() {
@@ -4495,12 +4592,6 @@ var VALID_DOMAINS = /* @__PURE__ */ new Set([
   AssemblyAIDomain.GENERAL,
   AssemblyAIDomain.MEDICAL_V1
 ]);
-var AssemblyAISTTNotConnectedError = class extends Error {
-  constructor(message = "AssemblyAISTT is not connected") {
-    super(message);
-    this.name = "AssemblyAISTTNotConnectedError";
-  }
-};
 var AssemblyAISTT = class _AssemblyAISTT {
   constructor(apiKey, options = {}) {
     this.apiKey = apiKey;
@@ -4824,9 +4915,10 @@ var AssemblyAISTT = class _AssemblyAISTT {
    */
   updateConfiguration(params) {
     if (!this.ws || this.ws.readyState !== WebSocket4.OPEN) {
-      throw new AssemblyAISTTNotConnectedError(
-        "AssemblyAISTT.updateConfiguration: WebSocket is not open"
+      getLogger().debug(
+        "AssemblyAISTT.updateConfiguration: WebSocket is not open \u2014 dropping update (call teardown)."
       );
+      return;
     }
     const payload = {
       type: AssemblyAIClientFrame.UPDATE_CONFIGURATION
@@ -4848,9 +4940,10 @@ var AssemblyAISTT = class _AssemblyAISTT {
   /** Force the server to finalize the current turn (for barge-in). */
   forceEndpoint() {
     if (!this.ws || this.ws.readyState !== WebSocket4.OPEN) {
-      throw new AssemblyAISTTNotConnectedError(
-        "AssemblyAISTT.forceEndpoint: WebSocket is not open"
+      getLogger().debug(
+        "AssemblyAISTT.forceEndpoint: WebSocket is not open \u2014 dropping request (call teardown)."
       );
+      return;
     }
     this.ws.send(JSON.stringify({ type: AssemblyAIClientFrame.FORCE_ENDPOINT }));
   }
@@ -4865,6 +4958,14 @@ var AssemblyAISTT = class _AssemblyAISTT {
   async close() {
     this.closing = true;
     if (!this.ws) return;
+    if (this.chunkBufferBytes > 0 && this.ws.readyState === WebSocket4.OPEN) {
+      try {
+        this.ws.send(Buffer.concat(this.chunkBuffer, this.chunkBufferBytes));
+      } catch {
+      }
+      this.chunkBuffer = [];
+      this.chunkBufferBytes = 0;
+    }
     try {
       this.ws.send(JSON.stringify({ type: AssemblyAIClientFrame.TERMINATE }));
     } catch {
@@ -6068,7 +6169,7 @@ var TTS3 = class extends OpenAITTS {
       opts.model ?? "gpt-4o-mini-tts",
       opts.instructions ?? null,
       opts.speed ?? null,
-      opts.antiAlias ?? false
+      opts.antiAlias ?? true
     );
   }
 };
@@ -6242,7 +6343,6 @@ init_esm_shims();
 // src/providers/inworld-tts.ts
 init_esm_shims();
 var INWORLD_BASE_URL = "https://api.inworld.ai/tts/v1/voice:stream";
-var INWORLD_VOICES_URL = "https://api.inworld.ai/tts/v1/voices";
 var InworldModel = {
   TTS_2: "inworld-tts-2",
   TTS_1_5_MAX: "inworld-tts-1.5-max",
@@ -6331,7 +6431,8 @@ var InworldTTS = class {
    */
   async warmup() {
     try {
-      await fetch(INWORLD_VOICES_URL, {
+      const voicesUrl = new URL(this.baseUrl).origin + "/tts/v1/voices";
+      await fetch(voicesUrl, {
         method: "GET",
         headers: {
           Authorization: `Basic ${this.authToken}`
@@ -6588,58 +6689,87 @@ var AnthropicLLMProvider = class {
     const toolIndexByBlock = /* @__PURE__ */ new Map();
     const toolIdByBlock = /* @__PURE__ */ new Map();
     let nextIndex = 0;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data: ")) continue;
-        const data = trimmed.slice(6);
-        if (!data || data === "[DONE]") continue;
-        let event;
-        try {
-          event = JSON.parse(data);
-        } catch {
-          continue;
-        }
-        if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
-          const blockIdx = event.index ?? 0;
-          const toolId = event.content_block.id ?? "";
-          const toolName = event.content_block.name ?? "";
-          const patterIndex = nextIndex++;
-          toolIndexByBlock.set(blockIdx, patterIndex);
-          toolIdByBlock.set(blockIdx, toolId);
-          yield {
-            type: "tool_call",
-            index: patterIndex,
-            id: toolId,
-            name: toolName,
-            arguments: ""
-          };
-          continue;
-        }
-        if (event.type === "content_block_delta") {
-          if (event.delta?.type === "text_delta" && event.delta.text) {
-            yield { type: "text", content: event.delta.text };
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheWriteTokens = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (!data || data === "[DONE]") continue;
+          let event;
+          try {
+            event = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          if (event.type === "message_start" && event.message?.usage) {
+            const u = event.message.usage;
+            if (u.input_tokens) inputTokens = u.input_tokens;
+            if (u.cache_creation_input_tokens) cacheWriteTokens = u.cache_creation_input_tokens;
+            if (u.cache_read_input_tokens) cacheReadTokens = u.cache_read_input_tokens;
             continue;
           }
-          if (event.delta?.type === "input_json_delta" && event.delta.partial_json) {
+          if (event.type === "message_delta" && event.usage?.output_tokens) {
+            outputTokens = event.usage.output_tokens;
+            continue;
+          }
+          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" };
   }
@@ -6699,16 +6829,17 @@ function toAnthropicMessages(messages) {
     }
     if (role === "tool") {
       const contentStr = typeof rawMsg.content === "string" ? rawMsg.content : JSON.stringify(rawMsg.content);
-      out.push({
-        role: "user",
-        content: [
-          {
-            type: "tool_result",
-            tool_use_id: rawMsg.tool_call_id ?? "",
-            content: contentStr
-          }
-        ]
-      });
+      const toolResultBlock = {
+        type: "tool_result",
+        tool_use_id: rawMsg.tool_call_id ?? "",
+        content: contentStr
+      };
+      const prev = out.length > 0 ? out[out.length - 1] : void 0;
+      if (prev && prev.role === "user" && Array.isArray(prev.content) && prev.content.length > 0 && prev.content.every((b) => b["type"] === "tool_result")) {
+        prev.content.push(toolResultBlock);
+      } else {
+        out.push({ role: "user", content: [toolResultBlock] });
+      }
       continue;
     }
   }
@@ -6848,50 +6979,55 @@ async function* parseOpenAISseStream(response) {
   if (!reader) return;
   const decoder = new TextDecoder();
   let buffer = "";
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() || "";
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || !trimmed.startsWith("data: ")) continue;
-      const data = trimmed.slice(6);
-      if (data === "[DONE]") continue;
-      let chunk;
-      try {
-        chunk = JSON.parse(data);
-      } catch {
-        continue;
-      }
-      const usage = chunk.usage ?? chunk.x_groq?.usage;
-      if (usage) {
-        const cached = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
-        yield {
-          type: "usage",
-          inputTokens: usage.prompt_tokens,
-          outputTokens: usage.completion_tokens,
-          cacheReadInputTokens: cached
-        };
-      }
-      const delta = chunk.choices?.[0]?.delta;
-      if (!delta) continue;
-      if (delta.content) {
-        yield { type: "text", content: delta.content };
-      }
-      if (delta.tool_calls) {
-        for (const tc of delta.tool_calls) {
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith("data: ")) continue;
+        const data = trimmed.slice(6);
+        if (data === "[DONE]") continue;
+        let chunk;
+        try {
+          chunk = JSON.parse(data);
+        } catch {
+          continue;
+        }
+        const usage = chunk.usage ?? chunk.x_groq?.usage;
+        if (usage) {
+          const cached = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
           yield {
-            type: "tool_call",
-            index: tc.index,
-            id: tc.id,
-            name: tc.function?.name,
-            arguments: tc.function?.arguments
+            type: "usage",
+            inputTokens: usage.prompt_tokens,
+            outputTokens: usage.completion_tokens,
+            cacheReadInputTokens: cached
           };
         }
+        const delta = chunk.choices?.[0]?.delta;
+        if (!delta) continue;
+        if (delta.content) {
+          yield { type: "text", content: delta.content };
+        }
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            yield {
+              type: "tool_call",
+              index: tc.index,
+              id: tc.id,
+              name: tc.function?.name,
+              arguments: tc.function?.arguments
+            };
+          }
+        }
       }
     }
+  } finally {
+    reader.cancel().catch(() => {
+    });
   }
 }
 
@@ -7056,11 +7192,21 @@ var CerebrasLLMProvider = class {
       }
       const advisoryMs = parseRateLimitResetMs(response.headers);
       const exponentialMs = RETRY_BACKOFF_BASE_MS * Math.pow(2, attempt);
-      const delayMs = Math.max(advisoryMs, exponentialMs);
+      const delayMs = Math.min(5e3, Math.max(advisoryMs, exponentialMs));
       getLogger().warn(
         `Cerebras API ${response.status} (attempt ${attempt + 1}/${maxAttempts}); retrying after ${delayMs}ms`
       );
-      await new Promise((r) => setTimeout(r, delayMs));
+      await new Promise((resolve, reject) => {
+        const t = setTimeout(resolve, delayMs);
+        opts?.signal?.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(t);
+            reject(opts.signal.reason);
+          },
+          { once: true }
+        );
+      });
     }
     throw new PatterError(`Cerebras API error ${lastStatus}: ${lastErrText || "request failed"}`);
   }
@@ -7221,47 +7367,52 @@ var GoogleLLMProvider = class {
     let buffer = "";
     let nextIndex = 0;
     let lastUsage;
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed.startsWith("data: ")) continue;
-        const data = trimmed.slice(6);
-        if (!data) continue;
-        let payload;
-        try {
-          payload = JSON.parse(data);
-        } catch {
-          continue;
-        }
-        if (payload.usageMetadata) {
-          lastUsage = payload.usageMetadata;
-        }
-        const candidate = payload.candidates?.[0];
-        const parts = candidate?.content?.parts ?? [];
-        for (const part of parts) {
-          if (part.functionCall) {
-            const args = part.functionCall.args ?? {};
-            const callId = part.functionCall.id ?? `gemini_call_${nextIndex}`;
-            yield {
-              type: "tool_call",
-              index: nextIndex,
-              id: callId,
-              name: part.functionCall.name ?? "",
-              arguments: JSON.stringify(args)
-            };
-            nextIndex++;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data: ")) continue;
+          const data = trimmed.slice(6);
+          if (!data) continue;
+          let payload;
+          try {
+            payload = JSON.parse(data);
+          } catch {
             continue;
           }
-          if (part.text) {
-            yield { type: "text", content: part.text };
+          if (payload.usageMetadata) {
+            lastUsage = payload.usageMetadata;
+          }
+          const candidate = payload.candidates?.[0];
+          const parts = candidate?.content?.parts ?? [];
+          for (const part of parts) {
+            if (part.functionCall) {
+              const args = part.functionCall.args ?? {};
+              const callId = part.functionCall.id ?? `gemini_call_${nextIndex}`;
+              yield {
+                type: "tool_call",
+                index: nextIndex,
+                id: callId,
+                name: part.functionCall.name ?? "",
+                arguments: JSON.stringify(args)
+              };
+              nextIndex++;
+              continue;
+            }
+            if (part.text) {
+              yield { type: "text", content: part.text };
+            }
           }
         }
       }
+    } finally {
+      reader.cancel().catch(() => {
+      });
     }
     if (lastUsage) {
       yield {
@@ -7355,7 +7506,17 @@ function toGeminiContents(messages) {
       continue;
     }
   }
-  return { systemInstruction: systemParts.join("\n\n"), contents };
+  const merged = [];
+  for (const entry of contents) {
+    const prev = merged[merged.length - 1];
+    const isFunctionResponseOnly = (c) => c.role === "user" && c.parts.every((p) => p.functionResponse !== void 0);
+    if (prev && isFunctionResponseOnly(prev) && isFunctionResponseOnly(entry)) {
+      prev.parts.push(...entry.parts);
+    } else {
+      merged.push(entry);
+    }
+  }
+  return { systemInstruction: systemParts.join("\n\n"), contents: merged };
 }
 
 // src/llm/google.ts
@@ -7378,6 +7539,260 @@ var LLM5 = class extends GoogleLLMProvider {
   }
 };
 
+// src/llm/openai-compatible.ts
+init_esm_shims();
+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_esm_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_esm_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_RE = /^[A-Za-z0-9._:/-]+$/;
+var LLM8 = class extends OpenAICompatibleLLMProvider {
+  static providerKey = "openclaw";
+  constructor(opts) {
+    const agent = opts?.agent;
+    if (!agent || !OPENCLAW_AGENT_RE.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/providers/deepfilternet-filter.ts
 init_esm_shims();
 function log() {
@@ -7409,6 +7824,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;
@@ -7416,8 +7882,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;
@@ -7475,8 +7942,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)));
@@ -7636,6 +8103,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.");
@@ -7653,6 +8131,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) {
@@ -7811,7 +8292,6 @@ var ChatContext = class _ChatContext {
 // src/services/ivr.ts
 init_esm_shims();
 var DTMF_EVENTS = [
-  "0",
   "1",
   "2",
   "3",
@@ -7821,6 +8301,7 @@ var DTMF_EVENTS = [
   "7",
   "8",
   "9",
+  "0",
   "*",
   "#",
   "A",
@@ -8497,18 +8978,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.
@@ -8612,7 +9099,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() {
@@ -8668,14 +9155,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() {
@@ -8686,6 +9172,7 @@ var TelnyxSTT = class {
       }
       this.ws = null;
     }
+    this.headerSent = false;
   }
 };
 
@@ -8706,6 +9193,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;
@@ -8733,69 +9221,83 @@ var TelnyxTTS = class {
    */
   async *synthesizeStream(text) {
     const url = `${this.baseUrl}?voice=${encodeURIComponent(this.voice)}`;
-    const ws = new WebSocket8(url, {
-      headers: { Authorization: `Bearer ${this.apiKey}` }
-    });
-    await new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error("Telnyx TTS connect timeout")), 1e4);
-      ws.once("open", () => {
-        clearTimeout(timer);
-        resolve();
+    let ws = null;
+    try {
+      let push2 = function(item) {
+        const w = waiters.shift();
+        if (w) {
+          w(item);
+        } else {
+          queue.push(item);
+        }
+      };
+      var push = push2;
+      ws = new WebSocket8(url, {
+        headers: { Authorization: `Bearer ${this.apiKey}` }
       });
-      ws.once("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
+      await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("Telnyx TTS connect timeout")), 1e4);
+        ws.once("open", () => {
+          clearTimeout(timer);
+          resolve();
+        });
+        ws.once("error", (err) => {
+          clearTimeout(timer);
+          reject(err);
+        });
       });
-    });
-    const queue = [];
-    const waiters = [];
-    function push(item) {
-      const w = waiters.shift();
-      if (w) {
-        w(item);
-      } else {
-        queue.push(item);
-      }
-    }
-    ws.on("message", (raw) => {
-      let data;
-      try {
-        data = JSON.parse(raw.toString());
-      } catch {
-        getLogger().warn("TelnyxTTS: received invalid JSON");
-        return;
-      }
-      const audioB64 = data.audio;
-      if (!audioB64) return;
-      try {
-        const audioBytes = Buffer.from(audioB64, "base64");
-        if (audioBytes.length > 0) {
-          push(audioBytes);
+      const queue = [];
+      const waiters = [];
+      ws.on("message", (raw) => {
+        let data;
+        try {
+          data = JSON.parse(raw.toString());
+        } catch {
+          getLogger().warn("TelnyxTTS: received invalid JSON");
+          return;
         }
-      } catch {
-      }
-    });
-    ws.on("close", () => {
-      push(null);
-    });
-    ws.on("error", (err) => {
-      push({ error: err instanceof Error ? err : new Error(String(err)) });
-    });
-    ws.send(JSON.stringify({ text: " " }));
-    ws.send(JSON.stringify({ text }));
-    ws.send(JSON.stringify({ text: "" }));
-    try {
+        const audioB64 = data.audio;
+        if (!audioB64) return;
+        try {
+          const audioBytes = Buffer.from(audioB64, "base64");
+          if (audioBytes.length > 0) {
+            push2(audioBytes);
+          }
+        } catch {
+        }
+      });
+      ws.on("close", () => {
+        push2(null);
+      });
+      ws.on("error", (err) => {
+        push2({ error: err instanceof Error ? err : new Error(String(err)) });
+      });
+      ws.send(JSON.stringify({ text: " " }));
+      ws.send(JSON.stringify({ text }));
+      ws.send(JSON.stringify({ text: "" }));
       while (true) {
-        const item = queue.length > 0 ? queue.shift() : await new Promise((resolve) => waiters.push(resolve));
+        let frameTimer;
+        const item = queue.length > 0 ? queue.shift() : await Promise.race([
+          new Promise((resolve) => waiters.push(resolve)),
+          new Promise((_, reject) => {
+            frameTimer = setTimeout(
+              () => reject(new Error("Telnyx TTS frame timeout")),
+              FRAME_TIMEOUT_MS2
+            );
+          })
+        ]).finally(() => {
+          if (frameTimer !== void 0) clearTimeout(frameTimer);
+        });
         if (item === null) return;
         if (typeof item === "object" && "error" in item) throw item.error;
         yield item;
       }
     } finally {
       try {
-        ws.close();
+        ws?.close();
       } catch {
       }
+      ws?.removeAllListeners();
     }
   }
 };
@@ -8840,6 +9342,7 @@ export {
   LLM5 as GoogleLLM,
   LLM3 as GroqLLM,
   Guardrail,
+  LLM7 as HermesLLM,
   IVRActivity,
   TTS7 as InworldTTS,
   KrispFrameDuration,
@@ -8850,6 +9353,8 @@ export {
   MetricsStore,
   MinWordsStrategy,
   Ngrok,
+  LLM6 as OpenAICompatibleLLM,
+  OpenAICompatibleLLMProvider,
   LLM as OpenAILLM,
   OpenAILLMProvider,
   Realtime as OpenAIRealtime,
@@ -8863,10 +9368,12 @@ export {
   STT3 as OpenAITranscribeSTT,
   OpenAITranscriptionModel,
   OpenAIVoice,
+  LLM8 as OpenClawLLM,
   PRICING_LAST_UPDATED,
   PRICING_VERSION,
   PartialStreamError,
   Patter,
+  PatterConfigError,
   PatterConnectionError,
   PatterError,
   PatterTool,
@@ -8954,6 +9461,8 @@ export {
   mulawToPcm16,
   notifyDashboard,
   openaiTts,
+  openclawConsult,
+  openclawPostCallNotifier,
   pcm16ToMulaw,
   resample16kTo8k,
   resample24kTo16k,