getpatter 0.6.6 → 0.6.8

package/dist/index.mjs

@@ -2,6 +2,17 @@ import {
   startTunnel
 } from "./chunk-XS45BAQL.mjs";
 import {
+  TestSession
+} from "./chunk-OV252D2V.mjs";
+import {
+  EvalSession,
+  FakeAudioSender,
+  FakeSTT,
+  FakeTTS,
+  historyTranscript
+} from "./chunk-3JNVSNLV.mjs";
+import {
+  AGENT_BACKLOG_CAP_S,
   AuthenticationError,
   CallMetricsAccumulator,
   Carrier,
@@ -10,11 +21,14 @@ import {
   DeepgramModel,
   DeepgramSTT,
   DefaultToolExecutor,
+  ENV_FLAG,
   ElevenLabsConvAIAdapter,
   EmbeddedServer,
   ErrorCode,
   EventBus,
   LLMLoop,
+  LLM_STREAM_IDLE_TIMEOUT_MS,
+  LocalCallRecorder,
   MetricsStore,
   OpenAILLMProvider,
   PRICING_LAST_UPDATED,
@@ -26,6 +40,7 @@ import {
   PlivoAdapter,
   PricingUnit,
   ProvisionError,
+  RECORDING_SAMPLE_RATE,
   RateLimitError,
   RemoteMessageHandler,
   SPAN_BARGEIN,
@@ -36,7 +51,7 @@ import {
   SPAN_TOOL,
   SPAN_TTS,
   SentenceChunker,
-  TestSession,
+  TwilioAdapter,
   VERSION,
   calculateRealtimeCost,
   calculateSttCost,
@@ -44,6 +59,7 @@ import {
   calculateTtsCost,
   callsToCsv,
   callsToJson,
+  createStreamIdleWatchdog,
   initTracing,
   isRemoteUrl,
   isTracingEnabled,
@@ -56,8 +72,10 @@ import {
   openclawConsult,
   openclawPostCallNotifier,
   resolveLogRoot,
-  startSpan
-} from "./chunk-YJX2EKON.mjs";
+  shutdownTracing,
+  startSpan,
+  withSpan
+} from "./chunk-YJ4HKJL6.mjs";
 import {
   OpenAIRealtime2Adapter,
   OpenAIRealtimeAdapter,
@@ -78,7 +96,7 @@ import {
   resample24kTo16k,
   resample8kTo16k,
   validateRealtimeTurnDetection
-} from "./chunk-BO227NTF.mjs";
+} from "./chunk-I56S5MDJ.mjs";
 import {
   MinWordsStrategy,
   evaluateStrategies,
@@ -92,8 +110,9 @@ import {
   notifyDashboard
 } from "./chunk-6GR5MHHQ.mjs";
 import {
-  SileroVAD
-} from "./chunk-3VVATR6A.mjs";
+  SileroVAD,
+  loadOnnxRuntime
+} from "./chunk-C2LWB42T.mjs";
 import {
   __dirname,
   __require,
@@ -432,10 +451,20 @@ var cachedInstallId = null;
 function runId() {
   return RUN_ID;
 }
+function stateDir() {
+  const override = process.env.PATTER_TELEMETRY_STATE_DIR;
+  if (override && override.length > 0) return override;
+  const xdg = process.env.XDG_STATE_HOME;
+  if (xdg && xdg.length > 0) return path.join(xdg, "getpatter");
+  return path.join(os.homedir(), ".getpatter");
+}
+function legacyStateDir() {
+  if (process.env.PATTER_TELEMETRY_STATE_DIR) return null;
+  const xdg = process.env.XDG_STATE_HOME;
+  return xdg && xdg.length > 0 ? xdg : null;
+}
 function statePath() {
-  const base = process.env.PATTER_TELEMETRY_STATE_DIR || process.env.XDG_STATE_HOME;
-  const root = base && base.length > 0 ? base : path.join(os.homedir(), ".getpatter");
-  return path.join(root, "install-id");
+  return path.join(stateDir(), "install-id");
 }
 function installId() {
   if (cachedInstallId !== null) return cachedInstallId;
@@ -448,6 +477,27 @@ function installId() {
     }
   } catch {
   }
+  const legacyDir = legacyStateDir();
+  if (legacyDir !== null) {
+    const legacy = path.join(legacyDir, "install-id");
+    let existing = "";
+    try {
+      existing = fs.readFileSync(legacy, "utf8").trim();
+    } catch {
+      existing = "";
+    }
+    if (HEX32.test(existing)) {
+      try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, existing, "utf8");
+        const stat = fs.statSync(legacy);
+        fs.utimesSync(p, stat.atime, stat.mtime);
+      } catch {
+      }
+      cachedInstallId = existing;
+      return cachedInstallId;
+    }
+  }
   const newId = randomUUID().replace(/-/g, "");
   try {
     fs.mkdirSync(path.dirname(p), { recursive: true });
@@ -469,6 +519,16 @@ function previousVersion(current) {
   } catch {
     prev = "";
   }
+  if (prev === "") {
+    const legacyDir = legacyStateDir();
+    if (legacyDir !== null) {
+      try {
+        prev = fs.readFileSync(path.join(legacyDir, "version"), "utf8").trim();
+      } catch {
+        prev = "";
+      }
+    }
+  }
   try {
     fs.mkdirSync(path.dirname(p), { recursive: true });
     fs.writeFileSync(p, current, "utf8");
@@ -499,6 +559,14 @@ function isFirstRun() {
   } catch {
     return false;
   }
+  const legacyDir = legacyStateDir();
+  if (legacyDir !== null) {
+    try {
+      if (fs.existsSync(path.join(legacyDir, "first-run"))) return false;
+    } catch {
+      return false;
+    }
+  }
   try {
     fs.mkdirSync(path.dirname(p), { recursive: true });
     fs.writeFileSync(p, "1", "utf8");
@@ -512,7 +580,13 @@ function optOutPath() {
 }
 function isOptedOut() {
   try {
-    return fs.existsSync(optOutPath());
+    if (fs.existsSync(optOutPath())) return true;
+  } catch {
+  }
+  const legacyDir = legacyStateDir();
+  if (legacyDir === null) return false;
+  try {
+    return fs.existsSync(path.join(legacyDir, "telemetry-disabled"));
   } catch {
     return false;
   }
@@ -603,7 +677,7 @@ function stackDimensions(stt, tts, llm) {
 }
 
 // src/telemetry/events.ts
-var SCHEMA_VERSION = 5;
+var SCHEMA_VERSION = 7;
 var EVENT_SDK_INITIALIZED = "sdk_initialized";
 var EVENT_FIRST_RUN = "first_run";
 var EVENT_CLI_COMMAND = "cli_command";
@@ -643,7 +717,7 @@ var DIMENSION_VALUES = {
   // call_started / call_completed: inbound vs outbound — a core usage split.
   direction: /* @__PURE__ */ new Set(["inbound", "outbound", "none"]),
   // cli_command: which CLI subcommand was invoked (never args/flags values).
-  cli_command: /* @__PURE__ */ new Set(["dashboard", "eval", "telemetry", "none", "other"]),
+  cli_command: /* @__PURE__ */ new Set(["dashboard", "eval", "hermes", "openclaw", "telemetry", "none", "other"]),
   // call_completed: the call's terminal outcome
   outcome: /* @__PURE__ */ new Set(["completed", "error", "no_answer", "busy", "failed"]),
   // call_completed: terminal error code (mirrors ErrorCode, plus "other"). Never
@@ -698,11 +772,14 @@ var BOOL_DIMENSIONS = /* @__PURE__ */ new Set([
   "per_tool_timeouts_set",
   "llm_fallback_configured"
 ]);
+var ID_RE = /^[0-9a-f]{32}$/;
+var ID_DIMENSIONS = /* @__PURE__ */ new Set(["call_uid"]);
 var ALLOWED_DIMENSIONS = /* @__PURE__ */ new Set([
   ...Object.keys(DIMENSION_VALUES),
   ...NUMERIC_DIMENSIONS,
   ...STRING_DIMENSIONS,
-  ...BOOL_DIMENSIONS
+  ...BOOL_DIMENSIONS,
+  ...ID_DIMENSIONS
 ]);
 function osFamily() {
   const p = os2.platform();
@@ -748,8 +825,14 @@ function buildEvent(name, opts) {
       if (!(typeof value === "string" && MODEL_TOKEN_RE.test(value))) {
         continue;
       }
+    } else if (ID_DIMENSIONS.has(key)) {
+      if (!(typeof value === "string" && ID_RE.test(value))) {
+        continue;
+      }
     } else if (BOOL_DIMENSIONS.has(key) && typeof value !== "boolean") {
       continue;
+    } else if (NUMERIC_DIMENSIONS.has(key) && typeof value !== "number") {
+      continue;
     }
     if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
       event[key] = value;
@@ -762,14 +845,16 @@ function buildEvent(name, opts) {
 var DEFAULT_ENDPOINT = "https://telemetry.getpatter.com/v1/ingest";
 var TIMEOUT_MS = 3e3;
 var BUFFER_MAX = 256;
+var MAX_EVENTS_PER_POST = 64;
 var noticeShown = false;
 var liveClients = /* @__PURE__ */ new Set();
 var exitHookRegistered = false;
+var pendingFlush = /* @__PURE__ */ new Set();
 function showNoticeOnce() {
   if (noticeShown) return;
   noticeShown = true;
   getLogger().info(
-    "Anonymous usage telemetry is on (no PII, no call content). Collected: a random anonymous install id, SDK version, language, OS family, runtime version, coarse feature flags, the composed stack (provider + model per layer), tool counts, integration category, and per-call duration, latency, cost, and error codes (no call content, no message text). Disable with PATTER_TELEMETRY_DISABLED=1, DO_NOT_TRACK=1, or telemetry: false. Details: https://docs.getpatter.com/telemetry"
+    "Anonymous usage telemetry is on (no PII, no call content). Collected: a random anonymous install id, SDK version, language, OS family, runtime version, coarse feature flags, the composed stack (provider + model per layer), tool counts, integration category, a random per-call correlation id, and per-call duration, latency, cost, and error codes (no call content, no message text). Disable with PATTER_TELEMETRY_DISABLED=1, DO_NOT_TRACK=1, or telemetry: false. Details: https://docs.getpatter.com/telemetry"
   );
 }
 function registerExitHook() {
@@ -789,7 +874,7 @@ var TelemetryClient = class {
   endpoint;
   debug;
   buffer = [];
-  flushing = false;
+  inflight = null;
   closed = false;
   selfRef = new WeakRef(this);
   constructor(options) {
@@ -827,6 +912,7 @@ var TelemetryClient = class {
     try {
       if (this.buffer.length >= BUFFER_MAX) this.buffer.shift();
       this.buffer.push(event);
+      pendingFlush.add(this);
       this.scheduleFlush();
     } catch (err) {
       getLogger().debug("telemetry enqueue failed", err);
@@ -845,42 +931,68 @@ var TelemetryClient = class {
       getLogger().debug("telemetry flushPending failed", err);
     }
   }
+  /**
+   * Flush buffered events and wait for delivery. Unlike `close()` the client
+   * stays usable afterwards — for teardown paths that may serve again
+   * (`Patter.disconnect()`). Bounded by the flush's own per-POST abort timer.
+   * Mirrors Python's `drain()`.
+   */
+  async drain() {
+    if (!this.enabledFlag || this.debug || this.closed) return;
+    try {
+      if (this.inflight) await this.inflight;
+      if (this.buffer.length > 0) await this.flush();
+    } catch (err) {
+      getLogger().debug("telemetry drain failed", err);
+    }
+  }
   /** Flush remaining events (graceful shutdown). Never throws. */
   async close() {
     if (this.closed) return;
     this.closed = true;
     liveClients.delete(this.selfRef);
-    if (!this.enabledFlag || this.debug) return;
+    if (!this.enabledFlag || this.debug) {
+      pendingFlush.delete(this);
+      return;
+    }
     try {
+      if (this.inflight) await this.inflight;
       await this.flush();
     } catch (err) {
       getLogger().debug("telemetry close flush failed", err);
     }
+    pendingFlush.delete(this);
   }
   scheduleFlush() {
-    if (this.flushing) return;
-    this.flushing = true;
-    void this.flush().finally(() => {
-      this.flushing = false;
+    if (this.inflight) return;
+    this.inflight = this.flush().finally(() => {
+      this.inflight = null;
+      if (this.buffer.length > 0 && !this.closed) this.scheduleFlush();
     });
+    void this.inflight;
   }
   async flush() {
     if (this.buffer.length === 0) return;
     const events = this.buffer.splice(0, this.buffer.length);
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
-    timer.unref?.();
+    pendingFlush.delete(this);
     try {
-      await fetch(this.endpoint, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify(events),
-        signal: controller.signal
-      });
+      for (let start = 0; start < events.length; start += MAX_EVENTS_PER_POST) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+        timer.unref?.();
+        try {
+          await fetch(this.endpoint, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(events.slice(start, start + MAX_EVENTS_PER_POST)),
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timer);
+        }
+      }
     } catch (err) {
       getLogger().debug("telemetry flush failed", err);
-    } finally {
-      clearTimeout(timer);
     }
   }
 };
@@ -1212,7 +1324,7 @@ function resolvePersistRoot(persist) {
   if (typeof persist === "string") return resolveLogRoot(persist);
   const envRoot = resolveLogRoot();
   if (envRoot !== null) return envRoot;
-  return null;
+  return resolveLogRoot("auto");
 }
 function closeParkedConnections(slot) {
   if (slot.stt) {
@@ -1552,7 +1664,10 @@ var Patter = class {
     const initDims = {
       carrier: carrierFamily(carrier),
       tunnel: tunnel instanceof Static ? "static" : options.tunnel ? "configured" : "none",
-      ...telemetryEnvironmentDims()
+      // Environment dims only when telemetry is ENABLED: the helper's
+      // previousVersion probe writes ~/.getpatter/version, violating the
+      // documented invariant that opting out never touches the filesystem.
+      ...this.telemetry.enabled ? telemetryEnvironmentDims() : {}
     };
     if (this.telemetry.enabled) {
       try {
@@ -1561,8 +1676,8 @@ var Patter = class {
       }
     }
     this.telemetry.record("sdk_initialized", initDims);
-    this._tunnelReady = new Promise((resolve, reject) => {
-      this._tunnelReadyResolve = resolve;
+    this._tunnelReady = new Promise((resolve2, reject) => {
+      this._tunnelReadyResolve = resolve2;
       this._tunnelReadyReject = reject;
     });
     this._tunnelReady.catch(() => {
@@ -1570,8 +1685,8 @@ var Patter = class {
     if (normalizedWebhook) {
       this._tunnelReadyResolve(normalizedWebhook);
     }
-    this._ready = new Promise((resolve, reject) => {
-      this._readyResolve = resolve;
+    this._ready = new Promise((resolve2, reject) => {
+      this._readyResolve = resolve2;
       this._readyReject = reject;
     });
     this._ready.catch(() => {
@@ -1581,7 +1696,17 @@ var Patter = class {
   /** Resolve user-supplied agent options against engine defaults and return the merged config. */
   agent(opts) {
     const family = telemetryEngineFamily(opts);
-    const stack = stackDimensions(opts.stt, opts.tts, opts.llm);
+    let stack = { ...stackDimensions(opts.stt, opts.tts, opts.llm) };
+    if (family === "realtime") {
+      const engineModel = opts.engine?.model;
+      stack = {
+        ...stack,
+        llm_model: modelToken(
+          "openai",
+          opts.model ?? engineModel ?? "gpt-realtime-mini"
+        )
+      };
+    }
     const featureKey = family + "|" + Object.entries(stack).sort().map(([k, v]) => `${k}=${v}`).join(",");
     if (!this.telemetrySeenEngines.has(featureKey)) {
       this.telemetrySeenEngines.add(featureKey);
@@ -1672,11 +1797,45 @@ var Patter = class {
         throw new Error(`provider must be one of: ${valid.join(", ")}. Got: '${working.provider}'`);
       }
     }
+    if (working.provider === "openai_realtime" && !working.engine && !this.localConfig.openaiKey) {
+      const envKey = process.env.OPENAI_API_KEY;
+      if (envKey) {
+        this.localConfig = { ...this.localConfig, openaiKey: envKey };
+      } else {
+        throw new Error(
+          "OpenAI Realtime mode requires an OpenAI API key. Pass engine: new OpenAIRealtime({ apiKey: 'sk-...' }) or set OPENAI_API_KEY in the environment."
+        );
+      }
+    }
     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.handoffs !== void 0) {
+      if (typeof working.handoffs !== "object" || working.handoffs === null || Array.isArray(working.handoffs)) {
+        throw new TypeError(
+          `handoffs must be an object of { name: agentOptions }, got ${Array.isArray(working.handoffs) ? "array" : typeof working.handoffs}.`
+        );
+      }
+      for (const [hName, hAgent] of Object.entries(working.handoffs)) {
+        if (!hName) {
+          throw new Error(
+            "handoffs keys must be non-empty strings (the names the LLM passes to handoff_to)."
+          );
+        }
+        if (typeof hAgent !== "object" || hAgent === null || Array.isArray(hAgent)) {
+          throw new TypeError(
+            `handoffs['${hName}'] must be an agent options object (build with phone.agent({...})), got ${Array.isArray(hAgent) ? "array" : typeof hAgent}.`
+          );
+        }
+      }
+      if (working.provider === "elevenlabs_convai") {
+        getLogger().warn(
+          "handoffs is set but provider is ElevenLabs ConvAI; the handoff_to 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") {
@@ -1727,7 +1886,7 @@ var Patter = class {
     }
     if (opts.agent.echoCancellation) {
       try {
-        await import("./aec-PJJMUM5E.mjs");
+        await import("./aec-ZZ5HGKS3.mjs");
       } catch (err) {
         getLogger().debug(`AEC pre-import failed at serve(): ${String(err)}`);
       }
@@ -1777,7 +1936,7 @@ var Patter = class {
     const telephonyProvider = carrier.kind;
     const wantsCarrierManagement = opts.manageWebhook !== false || wantsCloudflared;
     if (wantsCarrierManagement) {
-      const { autoConfigureCarrier } = await import("./carrier-config-7YGNRBPO.mjs");
+      const { autoConfigureCarrier } = await import("./carrier-config-6L5NND7B.mjs");
       await autoConfigureCarrier({
         telephonyProvider,
         twilioSid: carrier.kind === "twilio" ? carrier.accountSid : void 0,
@@ -1816,11 +1975,14 @@ var Patter = class {
       opts.pricing,
       opts.dashboard ?? true,
       opts.dashboardToken ?? "",
-      opts.allowInsecureDashboard ?? false
+      opts.allowInsecureDashboard ?? false,
+      opts.localRecording ?? false
     );
     this.embeddedServer.telemetry = this.telemetry;
     this.embeddedServer.popPrewarmAudio = this.popPrewarmAudio;
     this.embeddedServer.popPrewarmedConnections = this.popPrewarmedConnections;
+    this.embeddedServer.aliasPrewarm = this.aliasPrewarm;
+    this.embeddedServer.speechEvents = this.speechEvents;
     this.embeddedServer.recordPrewarmWaste = this.recordPrewarmWaste;
     try {
       await this.embeddedServer.start(port);
@@ -1837,7 +1999,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-XFOADUNE.mjs");
+    const { TestSession: TestSession2 } = await import("./test-mode-5CNXC447.mjs");
     const session = new TestSession2();
     await session.run({
       agent: opts.agent,
@@ -1915,6 +2077,25 @@ var Patter = class {
    * carrier ``start`` event instead of opening fresh ones — saving
    * ~150-900 ms of cold-start handshake on the first turn.
    */
+  /**
+   * Re-key prewarm caches from a dial-time id to the live carrier id.
+   * Plivo issues ``request_uuid`` at dial time but the media stream and
+   * webhooks carry ``CallUUID`` — without re-keying, prewarmed first-message
+   * audio and parked provider sockets never matched and always TTL-evicted
+   * as "wasted". Mirrors Python ``_alias_prewarm``.
+   */
+  aliasPrewarm = (oldId, newId) => {
+    if (!oldId || !newId || oldId === newId) return;
+    const rekey = (map) => {
+      const v = map.get(oldId);
+      if (v !== void 0 && !map.has(newId)) map.set(newId, v);
+      map.delete(oldId);
+    };
+    rekey(this.prewarmAudio);
+    rekey(this.prewarmTtlTimers);
+    rekey(this.prewarmedConnections);
+    rekey(this.prewarmedConnTimers);
+  };
   popPrewarmedConnections = (callId) => {
     const slot = this.prewarmedConnections.get(callId);
     if (slot === void 0) return void 0;
@@ -2016,7 +2197,7 @@ var Patter = class {
     }
     if (wantsRealtimePark) {
       tasks.push((async () => {
-        const { OpenAIRealtime2Adapter: OpenAIRealtime2Adapter2 } = await import("./openai-realtime-2-L5EKAAUH.mjs");
+        const { OpenAIRealtime2Adapter: OpenAIRealtime2Adapter2 } = await import("./openai-realtime-2-O4DP3LXN.mjs");
         const apiKey = process.env.OPENAI_API_KEY ?? "";
         if (!apiKey) {
           getLogger().debug(`Park OpenAI Realtime skipped for ${callId}: no OPENAI_API_KEY`);
@@ -2230,6 +2411,12 @@ var Patter = class {
     if (!options.to) {
       throw new Error("'to' phone number is required");
     }
+    if (options.firstMessage) {
+      options = {
+        ...options,
+        agent: { ...options.agent, firstMessage: options.firstMessage }
+      };
+    }
     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.");
     }
@@ -2374,6 +2561,9 @@ var Patter = class {
           this.parkProviderConnections(options.agent, plivoCallId);
         }
       }
+      if (plivoCallId) {
+        return this.maybeAwaitCompletion(options, plivoCallId, effectiveRingTimeout);
+      }
       return;
     }
     const twilioSid = carrier.accountSid;
@@ -2511,7 +2701,7 @@ var Patter = class {
    * entries leak across ``serve`` / ``disconnect`` cycles. See FIX #93.
    */
   async disconnect() {
-    this.telemetry.flushPending();
+    await this.telemetry.drain();
     for (const handle of this.prewarmTtlTimers.values()) {
       clearTimeout(handle);
     }
@@ -2519,7 +2709,7 @@ var Patter = class {
     if (this.prewarmTasks.size > 0) {
       const drain = Promise.allSettled(Array.from(this.prewarmTasks));
       const timer = new Promise(
-        (resolve) => setTimeout(resolve, 1e3).unref?.()
+        (resolve2) => setTimeout(resolve2, 1e3).unref?.()
       );
       await Promise.race([drain, timer]);
     }
@@ -2551,8 +2741,8 @@ var Patter = class {
       this.localConfig = { ...this.localConfig, webhookUrl: void 0 };
       this.tunnelOwnsWebhookUrl = false;
     }
-    this._tunnelReady = new Promise((resolve, reject) => {
-      this._tunnelReadyResolve = resolve;
+    this._tunnelReady = new Promise((resolve2, reject) => {
+      this._tunnelReadyResolve = resolve2;
       this._tunnelReadyReject = reject;
     });
     this._tunnelReady.catch(() => {
@@ -2560,8 +2750,8 @@ var Patter = class {
     if (this.localConfig.webhookUrl) {
       this._tunnelReadyResolve(this.localConfig.webhookUrl);
     }
-    this._ready = new Promise((resolve, reject) => {
-      this._readyResolve = resolve;
+    this._ready = new Promise((resolve2, reject) => {
+      this._readyResolve = resolve2;
       this._readyReject = reject;
     });
     this._ready.catch(() => {
@@ -3298,134 +3488,426 @@ function resultFromCallResult(result) {
 
 // src/providers/gemini-live.ts
 init_esm_shims();
-var GEMINI_DEFAULT_INPUT_SR = 16e3;
-var GEMINI_DEFAULT_OUTPUT_SR = 24e3;
-var GeminiLiveAdapter = class {
-  constructor(apiKey, options = {}) {
-    this.apiKey = apiKey;
-    this.model = options.model ?? "gemini-2.5-flash-native-audio-preview-09-2025";
-    this.voice = options.voice ?? "Puck";
-    this.instructions = options.instructions ?? "";
-    this.language = options.language ?? "en-US";
-    this.tools = options.tools;
-    this.inputSampleRate = options.inputSampleRate ?? GEMINI_DEFAULT_INPUT_SR;
-    this.outputSampleRate = options.outputSampleRate ?? GEMINI_DEFAULT_OUTPUT_SR;
-    this.temperature = options.temperature ?? 0.8;
-  }
+
+// src/providers/google-llm.ts
+init_esm_shims();
+var GoogleModel = {
+  GEMINI_2_5_FLASH: "gemini-2.5-flash",
+  GEMINI_2_5_PRO: "gemini-2.5-pro",
+  GEMINI_2_0_FLASH: "gemini-2.0-flash",
+  GEMINI_2_0_FLASH_LITE: "gemini-2.0-flash-lite",
+  GEMINI_1_5_FLASH: "gemini-1.5-flash",
+  GEMINI_1_5_PRO: "gemini-1.5-pro"
+};
+var DEFAULT_MODEL = GoogleModel.GEMINI_2_5_FLASH;
+var DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+var GoogleLLMProvider = class {
+  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
+  static providerKey = "google";
   apiKey;
   model;
-  voice;
-  instructions;
-  language;
-  tools;
-  inputSampleRate;
-  /** Output sample rate — exposed so callers can configure downstream transcoding. */
-  outputSampleRate;
+  baseUrl;
   temperature;
-  client = null;
-  session = null;
-  receiveLoop = null;
-  handlers = [];
-  running = false;
-  /**
-   * Tracks call_id -> function name so tool responses can be sent back with
-   * the correct `name` field (Gemini expects the original function name,
-   * not the call_id).
-   */
-  pendingToolCalls = /* @__PURE__ */ new Map();
-  /** Lazily import @google/genai, open a Live session, and start the receive loop. */
-  async connect() {
-    let genaiModule;
-    try {
-      const modName = "@google/genai";
-      genaiModule = await import(modName);
-    } catch {
+  maxOutputTokens;
+  constructor(options) {
+    if (!options.apiKey) {
       throw new Error(
-        '\nGemini Live requires the "@google/genai" package, which is not installed.\n\n  Install:  npm install @google/genai\n\nThis is an optional peer dependency of getpatter \u2014 it is only needed when\nyou use GeminiLive as an agent engine. Other LLM/engine providers do not\nrequire it.\n'
+        "Google API key is required. Pass it via { apiKey } or read GOOGLE_API_KEY from the environment."
       );
     }
-    const { GoogleGenAI } = genaiModule;
-    this.client = new GoogleGenAI({
-      apiKey: this.apiKey,
-      httpOptions: { apiVersion: "v1alpha" }
-    });
-    const config = {
-      responseModalities: ["AUDIO"],
-      speechConfig: {
-        voiceConfig: { prebuiltVoiceConfig: { voiceName: this.voice } },
-        languageCode: this.language
-      },
-      temperature: this.temperature
-    };
-    if (this.instructions) {
-      config.systemInstruction = { parts: [{ text: this.instructions }] };
-    }
-    if (this.tools?.length) {
-      config.tools = [
-        {
-          functionDeclarations: this.tools.map((t) => ({
-            name: t.name,
-            description: t.description,
-            parameters: t.parameters
-          }))
-        }
-      ];
-    }
-    const liveApi = this.client.live;
-    if (!liveApi?.connect) {
-      throw new Error("@google/genai: live.connect is not available in this version");
+    this.apiKey = options.apiKey;
+    this.model = options.model ?? DEFAULT_MODEL;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.temperature = options.temperature;
+    this.maxOutputTokens = options.maxOutputTokens;
+  }
+  /**
+   * Pre-call DNS / TLS warmup for the Gemini API.
+   * Issues a lightweight ``GET ${baseUrl}/models?key=...`` so DNS, TLS
+   * and HTTP/2 are already up by the time the first
+   * ``streamGenerateContent`` call lands. Best-effort: 5 s timeout, all
+   * exceptions swallowed at debug level.
+   */
+  async warmup() {
+    try {
+      await fetch(`${this.baseUrl}/models?key=${encodeURIComponent(this.apiKey)}`, {
+        method: "GET",
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch (err) {
+      getLogger().debug(`Google LLM warmup failed (best-effort): ${String(err)}`);
     }
-    this.session = await liveApi.connect({ model: this.model, config });
-    this.running = true;
-    this.receiveLoop = this.pumpReceive().catch((err) => {
-      getLogger().error(`Gemini Live receive loop error: ${String(err)}`);
-    });
   }
-  /** Send a PCM audio chunk to Gemini as base64 inline data. */
-  sendAudio(pcm) {
-    if (!this.session || !this.running) return;
-    const mime = `audio/pcm;rate=${this.inputSampleRate}`;
-    const sess = this.session;
-    const result = sess.sendRealtimeInput?.({
-      media: { data: pcm.toString("base64"), mimeType: mime }
+  /** Stream Patter-format LLM chunks from the Gemini SSE endpoint. */
+  async *stream(messages, tools, opts) {
+    const { systemInstruction, contents } = toGeminiContents(messages);
+    const geminiTools = tools ? toGeminiTools(tools) : null;
+    const body = { contents };
+    if (systemInstruction) {
+      body.systemInstruction = { role: "system", parts: [{ text: systemInstruction }] };
+    }
+    if (geminiTools) body.tools = geminiTools;
+    const generationConfig = {};
+    if (this.temperature !== void 0) generationConfig.temperature = this.temperature;
+    if (this.maxOutputTokens !== void 0)
+      generationConfig.maxOutputTokens = this.maxOutputTokens;
+    if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
+    const url = `${this.baseUrl}/models/${encodeURIComponent(this.model)}:streamGenerateContent?alt=sse&key=${encodeURIComponent(this.apiKey)}`;
+    const idle = createStreamIdleWatchdog();
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal: mergeAbortSignals(opts?.signal, idle.signal)
     });
-    if (result instanceof Promise) {
-      void result.catch(
-        (err) => getLogger().warn(`Gemini Live sendAudio error: ${String(err)}`)
+    if (!response.ok) {
+      const errText = await response.text();
+      getLogger().error(`Gemini API error: ${response.status} ${errText.slice(0, 200)}`);
+      throw new PatterConnectionError(
+        `Gemini API returned ${response.status}: ${errText.slice(0, 200)}`
       );
     }
-  }
-  /** Send a text turn to Gemini and mark the turn complete. */
-  async sendText(text) {
-    if (!this.session) return;
-    const sess = this.session;
-    await sess.sendClientContent?.({
-      turns: { role: "user", parts: [{ text }] },
-      turnComplete: true
-    });
-  }
-  /** Send a tool/function-call result back to Gemini. */
-  async sendFunctionResult(callId, result) {
-    if (!this.session) return;
-    const sess = this.session;
-    const name = this.pendingToolCalls.get(callId) ?? callId;
-    this.pendingToolCalls.delete(callId);
-    await sess.sendToolResponse?.({
-      functionResponses: [
-        { id: callId, name, response: { result } }
-      ]
-    });
-  }
-  /** No-op — Gemini Live barge-in is VAD-driven, not client-cancelled. */
-  cancelResponse() {
-    getLogger().debug("Gemini Live: cancelResponse is implicit via VAD");
-  }
-  /** Register an event handler that receives every Gemini Live event. */
-  onEvent(handler) {
-    this.handlers.push(handler);
-  }
-  async emit(type, data) {
-    for (const h of this.handlers) {
+    const reader = response.body?.getReader();
+    if (!reader) return;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let nextIndex = 0;
+    let lastUsage;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        idle.touch();
+        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++;
+              continue;
+            }
+            if (part.text) {
+              yield { type: "text", content: part.text };
+            }
+          }
+        }
+      }
+    } catch (err) {
+      if (idle.fired && !opts?.signal?.aborted) {
+        throw new PatterConnectionError(
+          `Gemini stream idle timeout \u2014 no data for ${LLM_STREAM_IDLE_TIMEOUT_MS / 1e3}s`
+        );
+      }
+      throw err;
+    } finally {
+      idle.clear();
+      reader.cancel().catch(() => {
+      });
+    }
+    if (lastUsage) {
+      const cached = lastUsage.cachedContentTokenCount ?? 0;
+      yield {
+        type: "usage",
+        inputTokens: Math.max(0, (lastUsage.promptTokenCount ?? 0) - cached),
+        outputTokens: lastUsage.candidatesTokenCount,
+        cacheReadInputTokens: cached
+      };
+    }
+    yield { type: "done" };
+  }
+};
+var GEMINI_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "description",
+  "properties",
+  "items",
+  "enum",
+  "required",
+  "nullable",
+  "format",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "pattern",
+  "anyOf",
+  "default",
+  "title"
+]);
+function sanitizeGeminiSchema(schema) {
+  if (Array.isArray(schema)) return schema.map(sanitizeGeminiSchema);
+  if (schema !== null && typeof schema === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(schema)) {
+      if (GEMINI_SCHEMA_KEYS.has(k)) out[k] = sanitizeGeminiSchema(v);
+    }
+    return out;
+  }
+  return schema;
+}
+function toGeminiTools(tools) {
+  const functionDeclarations = tools.map((t) => {
+    const fn = t.function ?? t;
+    return {
+      name: String(fn.name ?? ""),
+      description: String(fn.description ?? ""),
+      parameters: sanitizeGeminiSchema(fn.parameters ?? { type: "object", properties: {} })
+    };
+  });
+  if (functionDeclarations.length === 0) return [];
+  return [{ functionDeclarations }];
+}
+function toGeminiContents(messages) {
+  const systemParts = [];
+  const contents = [];
+  const fnNameByCallId = /* @__PURE__ */ new Map();
+  for (const rawMsg of messages) {
+    const role = rawMsg.role;
+    if (role === "system") {
+      if (typeof rawMsg.content === "string" && rawMsg.content) {
+        systemParts.push(rawMsg.content);
+      }
+      continue;
+    }
+    if (role === "user") {
+      if (typeof rawMsg.content === "string" && rawMsg.content) {
+        contents.push({ role: "user", parts: [{ text: rawMsg.content }] });
+      }
+      continue;
+    }
+    if (role === "assistant") {
+      const parts = [];
+      if (typeof rawMsg.content === "string" && rawMsg.content) {
+        parts.push({ text: rawMsg.content });
+      }
+      for (const tc of rawMsg.tool_calls ?? []) {
+        let args = {};
+        try {
+          const parsed = JSON.parse(tc.function?.arguments ?? "{}");
+          if (parsed && typeof parsed === "object") args = parsed;
+        } catch {
+          args = {};
+        }
+        if (tc.id && tc.function?.name) fnNameByCallId.set(tc.id, tc.function.name);
+        parts.push({
+          functionCall: {
+            name: tc.function?.name ?? "",
+            args,
+            id: tc.id
+          }
+        });
+      }
+      if (parts.length > 0) contents.push({ role: "model", parts });
+      continue;
+    }
+    if (role === "tool") {
+      const raw = rawMsg.content;
+      let response;
+      if (typeof raw === "string") {
+        try {
+          const parsed = JSON.parse(raw);
+          response = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : { result: parsed };
+        } catch {
+          response = { result: raw };
+        }
+      } else {
+        response = raw ?? {};
+      }
+      contents.push({
+        role: "user",
+        parts: [
+          {
+            functionResponse: {
+              name: rawMsg.name ?? fnNameByCallId.get(rawMsg.tool_call_id ?? "") ?? rawMsg.tool_call_id ?? "",
+              response,
+              id: rawMsg.tool_call_id
+            }
+          }
+        ]
+      });
+      continue;
+    }
+  }
+  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);
+    }
+  }
+  if (merged.length > 0 && merged[0].role === "model") {
+    merged.unshift({ role: "user", parts: [{ text: "(call connected)" }] });
+  }
+  return { systemInstruction: systemParts.join("\n\n"), contents: merged };
+}
+
+// src/providers/gemini-live.ts
+var GEMINI_DEFAULT_INPUT_SR = 16e3;
+var GEMINI_DEFAULT_OUTPUT_SR = 24e3;
+var GeminiLiveAdapter = class {
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.model = options.model ?? "gemini-2.5-flash-native-audio-preview-09-2025";
+    this.voice = options.voice ?? "Puck";
+    this.instructions = options.instructions ?? "";
+    this.language = options.language ?? "en-US";
+    this.tools = options.tools;
+    this.inputSampleRate = options.inputSampleRate ?? GEMINI_DEFAULT_INPUT_SR;
+    this.outputSampleRate = options.outputSampleRate ?? GEMINI_DEFAULT_OUTPUT_SR;
+    this.temperature = options.temperature ?? 0.8;
+  }
+  apiKey;
+  model;
+  voice;
+  instructions;
+  language;
+  tools;
+  inputSampleRate;
+  /** Output sample rate — exposed so callers can configure downstream transcoding. */
+  outputSampleRate;
+  temperature;
+  client = null;
+  session = null;
+  receiveLoop = null;
+  handlers = [];
+  running = false;
+  /**
+   * Tracks call_id -> function name so tool responses can be sent back with
+   * the correct `name` field (Gemini expects the original function name,
+   * not the call_id).
+   */
+  pendingToolCalls = /* @__PURE__ */ new Map();
+  /** Lazily import @google/genai, open a Live session, and start the receive loop. */
+  async connect() {
+    let genaiModule;
+    try {
+      const modName = "@google/genai";
+      genaiModule = await import(modName);
+    } catch {
+      throw new Error(
+        '\nGemini Live requires the "@google/genai" package, which is not installed.\n\n  Install:  npm install @google/genai\n\nThis is an optional peer dependency of getpatter \u2014 it is only needed when\nyou use GeminiLive as an agent engine. Other LLM/engine providers do not\nrequire it.\n'
+      );
+    }
+    const { GoogleGenAI } = genaiModule;
+    this.client = new GoogleGenAI({
+      apiKey: this.apiKey,
+      httpOptions: { apiVersion: "v1alpha" }
+    });
+    const config = {
+      responseModalities: ["AUDIO"],
+      speechConfig: {
+        voiceConfig: { prebuiltVoiceConfig: { voiceName: this.voice } },
+        languageCode: this.language
+      },
+      temperature: this.temperature,
+      // Without these, native-audio sessions produced NO user transcript
+      // ever and no assistant transcript in AUDIO modality — logs/history/
+      // metrics got nothing for Gemini Live calls. Mirrors Python.
+      inputAudioTranscription: {},
+      outputAudioTranscription: {}
+    };
+    if (this.instructions) {
+      config.systemInstruction = { parts: [{ text: this.instructions }] };
+    }
+    if (this.tools?.length) {
+      config.tools = [
+        {
+          functionDeclarations: this.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            // Strip JSON-Schema keys the Live API's proto Schema rejects
+            // ($schema, additionalProperties — strict-mode and zod-derived
+            // MCP tools): one such tool 400'd the whole session.
+            parameters: sanitizeGeminiSchema(t.parameters)
+          }))
+        }
+      ];
+    }
+    const liveApi = this.client.live;
+    if (!liveApi?.connect) {
+      throw new Error("@google/genai: live.connect is not available in this version");
+    }
+    this.session = await liveApi.connect({ model: this.model, config });
+    this.running = true;
+    this.receiveLoop = this.pumpReceive().catch((err) => {
+      getLogger().error(`Gemini Live receive loop error: ${String(err)}`);
+    });
+  }
+  /** Send a PCM audio chunk to Gemini as base64 inline data. */
+  sendAudio(pcm) {
+    if (!this.session || !this.running) return;
+    const mime = `audio/pcm;rate=${this.inputSampleRate}`;
+    const sess = this.session;
+    const result = sess.sendRealtimeInput?.({
+      media: { data: pcm.toString("base64"), mimeType: mime }
+    });
+    if (result instanceof Promise) {
+      void result.catch(
+        (err) => getLogger().warn(`Gemini Live sendAudio error: ${String(err)}`)
+      );
+    }
+  }
+  /** Send a text turn to Gemini and mark the turn complete. */
+  async sendText(text) {
+    if (!this.session) return;
+    const sess = this.session;
+    await sess.sendClientContent?.({
+      turns: { role: "user", parts: [{ text }] },
+      turnComplete: true
+    });
+  }
+  /** Send a tool/function-call result back to Gemini. */
+  async sendFunctionResult(callId, result) {
+    if (!this.session) return;
+    const sess = this.session;
+    const name = this.pendingToolCalls.get(callId) ?? callId;
+    this.pendingToolCalls.delete(callId);
+    await sess.sendToolResponse?.({
+      functionResponses: [
+        { id: callId, name, response: { result } }
+      ]
+    });
+  }
+  /** No-op — Gemini Live barge-in is VAD-driven, not client-cancelled. */
+  cancelResponse() {
+    getLogger().debug("Gemini Live: cancelResponse is implicit via VAD");
+  }
+  /** Register an event handler that receives every Gemini Live event. */
+  onEvent(handler) {
+    this.handlers.push(handler);
+  }
+  async emit(type, data) {
+    for (const h of this.handlers) {
       try {
         await h(type, data);
       } catch (err) {
@@ -3452,9 +3934,20 @@ var GeminiLiveAdapter = class {
             }
             if (part.text) await this.emit("transcript_output", part.text);
           }
+          if (sc.inputTranscription?.text) {
+            await this.emit("transcript_input", sc.inputTranscription.text);
+          }
+          if (sc.outputTranscription?.text) {
+            await this.emit("transcript_output", sc.outputTranscription.text);
+          }
           if (sc.turnComplete) await this.emit("response_done", null);
           if (sc.interrupted) await this.emit("speech_started", null);
         }
+        if (r.goAway) {
+          getLogger().warn(
+            `Gemini Live goAway received \u2014 session ends in ${r.goAway.timeLeft ?? "unknown"}`
+          );
+        }
         if (r.toolCall) {
           for (const fn of r.toolCall.functionCalls ?? []) {
             const args = fn.args ?? {};
@@ -3524,6 +4017,10 @@ var UltravoxRealtimeAdapter = class {
   sampleRate;
   firstMessage;
   ws = null;
+  /** Last Ultravox state string (turn-end transition detection). */
+  lastUltravoxState = "";
+  /** Whether the current agent turn streamed delta frames (dedupe finals). */
+  agentStreamedDeltas = false;
   handlers = [];
   /** Exposed for diagnostics — true while the underlying socket is open. */
   running = false;
@@ -3575,7 +4072,7 @@ var UltravoxRealtimeAdapter = class {
     const call = await resp.json();
     if (!call.joinUrl) throw new Error("Ultravox response missing joinUrl");
     this.ws = new WebSocket(call.joinUrl);
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const ws = this.ws;
       let settled = false;
       const timer = setTimeout(() => {
@@ -3595,7 +4092,7 @@ var UltravoxRealtimeAdapter = class {
         settled = true;
         clearTimeout(timer);
         ws.off("error", onError);
-        resolve();
+        resolve2();
       };
       const onError = (err) => {
         if (settled) return;
@@ -3678,10 +4175,20 @@ var UltravoxRealtimeAdapter = class {
     const etype = event.type ?? "";
     if (etype === "transcript") {
       const role = event.role;
-      const text = event.text ?? event.delta ?? "";
+      const delta = event.delta ?? "";
+      const fullText = event.text ?? "";
       const isFinal = Boolean(event.final);
-      if (role === "user" && isFinal && text) await this.emit("transcript_input", text);
-      else if (role === "agent" && text) await this.emit("transcript_output", text);
+      if (role === "user" && isFinal && (fullText || delta)) {
+        await this.emit("transcript_input", fullText || delta);
+      } else if (role === "agent") {
+        if (delta) {
+          await this.emit("transcript_output", delta);
+          this.agentStreamedDeltas = true;
+        } else if (isFinal && fullText && !this.agentStreamedDeltas) {
+          await this.emit("transcript_output", fullText);
+        }
+        if (isFinal) this.agentStreamedDeltas = false;
+      }
     } else if (etype === "client_tool_invocation") {
       await this.emit("function_call", {
         call_id: event.invocationId ?? "",
@@ -3690,8 +4197,13 @@ var UltravoxRealtimeAdapter = class {
       });
     } else if (etype === "state") {
       const state = event.state;
-      if (state === "listening") await this.emit("speech_started", null);
-      else if (state === "idle") await this.emit("response_done", null);
+      const prev = this.lastUltravoxState;
+      this.lastUltravoxState = state ?? "";
+      if (state === "listening" && prev === "speaking") {
+        await this.emit("response_done", null);
+      } else if (state === "idle") {
+        await this.emit("response_done", null);
+      }
     } else if (etype === "playback_clear_buffer") {
       await this.emit("speech_started", null);
     }
@@ -3789,14 +4301,23 @@ function scheduleCron(cron, callback) {
   };
 }
 function scheduleOnce(at, callback) {
-  const delayMs = at.getTime() - Date.now();
   let cancelled = false;
   let done = false;
-  const timer = setTimeout(() => {
-    if (cancelled) return;
-    done = true;
-    wrapCallback(callback)();
-  }, Math.max(0, delayMs));
+  const MAX_TIMEOUT_MS = 2147483647;
+  let timer;
+  const arm = () => {
+    const remaining = at.getTime() - Date.now();
+    if (remaining > MAX_TIMEOUT_MS) {
+      timer = setTimeout(arm, MAX_TIMEOUT_MS);
+      return;
+    }
+    timer = setTimeout(() => {
+      if (cancelled) return;
+      done = true;
+      wrapCallback(callback)();
+    }, Math.max(0, remaining));
+  };
+  arm();
   return {
     jobId: `once-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
     cancel() {
@@ -3892,7 +4413,9 @@ var ELEVENLABS_VOICE_ID_BY_NAME = {
 var VOICE_ID_PATTERN = /^[A-Za-z0-9]{20}$/;
 var CARRIER_NATIVE_FORMAT = {
   twilio: "ulaw_8000",
-  telnyx: "pcm_16000",
+  // The SDK's streaming_start pins the Telnyx wire to PCMU/μ-law @ 8 kHz —
+  // 'pcm_16000' here shipped raw PCM16 onto a μ-law wire (static).
+  telnyx: "ulaw_8000",
   // Plivo streams mulaw 8 kHz (we pin contentType in the answer XML).
   plivo: "ulaw_8000"
 };
@@ -4018,18 +4541,14 @@ var ElevenLabsTTS = class _ElevenLabsTTS {
   /**
    * Construct an instance pre-configured for Telnyx bidirectional media.
    *
-   * Telnyx's default media-streaming codec is L16 PCM @ 16 kHz, which
-   * matches our default Telnyx handler. We pick `pcm_16000` so the audio
-   * flows end-to-end with zero resampling or transcoding.
-   *
-   * Trade-off: if your Telnyx profile is pinned to PCMU/8000 (μ-law),
-   * construct `ElevenLabsTTS` directly with `outputFormat: 'ulaw_8000'`
-   * — Telnyx supports that natively too.
+   * The SDK's ``streaming_start`` pins the Telnyx wire to PCMU/μ-law @
+   * 8 kHz (stream_bidirectional_codec=PCMU), so μ-law output flows
+   * end-to-end with zero resampling or transcoding.
    */
   static forTelnyx(apiKey, options = {}) {
     return new _ElevenLabsTTS(apiKey, {
       ...options,
-      outputFormat: ElevenLabsOutputFormat.PCM_16000
+      outputFormat: ElevenLabsOutputFormat.ULAW_8000
     });
   }
   /**
@@ -4163,7 +4682,7 @@ var CartesiaTTS = class _CartesiaTTS {
   static forTwilio(apiKey, options = {}) {
     return new _CartesiaTTS(apiKey, {
       ...options,
-      sampleRate: CartesiaTTSSampleRate.HZ_8000
+      sampleRate: CartesiaTTSSampleRate.HZ_16000
     });
   }
   /**
@@ -4507,7 +5026,10 @@ var WhisperSTT = class _WhisperSTT {
    * ``(apiKey, model, language, bufferSize, responseFormat)`` — callers using
    * the old order will need to swap ``language`` and ``model``.
    */
+  /** Construction args replayed by clone(). */
+  patterCtorArgs;
   constructor(apiKey, language, model = "whisper-1", bufferSize = DEFAULT_BUFFER_SIZE, responseFormat = "json") {
+    this.patterCtorArgs = [apiKey, language, model, bufferSize, responseFormat];
     if (!ALLOWED_MODELS.has(model)) {
       throw new Error(
         `WhisperSTT: unsupported model "${model}". Expected one of ${[...ALLOWED_MODELS].join(", ")}.`
@@ -4524,6 +5046,15 @@ var WhisperSTT = class _WhisperSTT {
     return new _WhisperSTT(apiKey, language, model);
   }
   /** Reset the audio buffer and arm the adapter for incoming chunks. */
+  /**
+   * Fresh adapter built with this instance's construction arguments —
+   * called per call by the stream handler so concurrent calls never share
+   * connection state (sockets/queues; cross-call transcript bleed).
+   */
+  clone() {
+    const ctor = this.constructor;
+    return new ctor(...this.patterCtorArgs);
+  }
   async connect() {
     this.running = true;
     this.chunks = [];
@@ -4666,6 +5197,11 @@ var OpenAITranscribeSTT = class extends WhisperSTT {
         `OpenAITranscribeSTT: unsupported model "${model}". Expected one of ${[...ALLOWED_MODELS2].join(", ")}. For "whisper-1", use WhisperSTT instead.`
       );
     }
+    if (responseFormat === "verbose_json") {
+      throw new Error(
+        `OpenAITranscribeSTT: responseFormat "verbose_json" is only supported by whisper-1 (use WhisperSTT). "${model}" accepts "json".`
+      );
+    }
     super(apiKey, language, model, bufferSize, responseFormat);
   }
 };
@@ -4712,7 +5248,7 @@ var CartesiaSTTServerEvent = {
 var CartesiaSTTClientFrame = {
   FINALIZE: "finalize"
 };
-var DEFAULT_BASE_URL = "https://api.cartesia.ai";
+var DEFAULT_BASE_URL2 = "https://api.cartesia.ai";
 var API_VERSION = "2025-04-16";
 var USER_AGENT = "Patter/1.0";
 var KEEPALIVE_INTERVAL_MS = 3e4;
@@ -4721,6 +5257,7 @@ var CartesiaSTT = class {
   constructor(apiKey, options = {}) {
     this.apiKey = apiKey;
     this.options = options;
+    this.patterCtorArgs = [apiKey, options];
     if (!apiKey) {
       throw new Error("CartesiaSTT requires a non-empty apiKey");
     }
@@ -4737,6 +5274,8 @@ var CartesiaSTT = class {
    * `null` until the first transcript event arrives (matches Python's `None`).
    */
   requestId = null;
+  /** Construction args replayed by clone(). */
+  patterCtorArgs;
   /**
    * Open a fresh WebSocket without arming any message / keepalive handlers
    * and without taking ownership on `this.ws`. Returns the OPEN socket so
@@ -4752,14 +5291,14 @@ var CartesiaSTT = class {
     const ws = new WebSocket2(url, {
       headers: { "User-Agent": USER_AGENT }
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(
         () => reject(new Error("Cartesia STT park connect timeout")),
         CONNECT_TIMEOUT_MS
       );
       ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       ws.once("error", (err) => {
         clearTimeout(timer);
@@ -4770,7 +5309,7 @@ var CartesiaSTT = class {
   }
   buildWsUrl() {
     const opts = this.options;
-    const rawBase = opts.baseUrl ?? DEFAULT_BASE_URL;
+    const rawBase = opts.baseUrl ?? DEFAULT_BASE_URL2;
     let base;
     if (rawBase.startsWith("http://")) {
       base = `ws://${rawBase.slice("http://".length)}`;
@@ -4809,7 +5348,7 @@ var CartesiaSTT = class {
     const url = this.buildWsUrl();
     let ws = null;
     try {
-      ws = await new Promise((resolve, reject) => {
+      ws = await new Promise((resolve2, reject) => {
         const sock = new WebSocket2(url, {
           headers: { "User-Agent": USER_AGENT }
         });
@@ -4822,7 +5361,7 @@ var CartesiaSTT = class {
         }, 5e3);
         sock.once("open", () => {
           clearTimeout(timer);
-          resolve(sock);
+          resolve2(sock);
         });
         sock.once("error", (err) => {
           clearTimeout(timer);
@@ -4844,19 +5383,28 @@ var CartesiaSTT = class {
     }
   }
   /** Open the streaming WebSocket and arm message + keepalive handlers. */
+  /**
+   * Fresh adapter built with this instance's construction arguments —
+   * called per call by the stream handler so concurrent calls never share
+   * connection state (sockets/queues; cross-call transcript bleed).
+   */
+  clone() {
+    const ctor = this.constructor;
+    return new ctor(...this.patterCtorArgs);
+  }
   async connect() {
     const url = this.buildWsUrl();
     this.ws = new WebSocket2(url, {
       headers: { "User-Agent": USER_AGENT }
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(
         () => reject(new Error("Cartesia STT connect timeout")),
         CONNECT_TIMEOUT_MS
       );
       this.ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       this.ws.once("error", (err) => {
         clearTimeout(timer);
@@ -4920,7 +5468,13 @@ var CartesiaSTT = class {
   }
   emit(transcript) {
     for (const cb of this.callbacks) {
-      cb(transcript);
+      try {
+        Promise.resolve(cb(transcript)).catch(
+          (err) => getLogger().error(`STT transcript callback failed: ${String(err)}`)
+        );
+      } catch (err) {
+        getLogger().error(`STT transcript callback threw: ${String(err)}`);
+      }
     }
   }
   /** Send a binary PCM16-LE audio chunk to Cartesia for transcription. */
@@ -4944,12 +5498,12 @@ var CartesiaSTT = class {
    */
   async finalize() {
     if (!this.ws || this.ws.readyState !== WebSocket2.OPEN) return;
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       this.ws.send(CartesiaSTTClientFrame.FINALIZE, (err) => {
         if (err) {
           getLogger().debug(`Cartesia finalize send failed: ${String(err)}`);
         }
-        resolve();
+        resolve2();
       });
     });
   }
@@ -4998,10 +5552,10 @@ var CartesiaSTT = class {
     if (!ws) return;
     if (ws.readyState === WebSocket2.OPEN) {
       try {
-        await new Promise((resolve) => {
+        await new Promise((resolve2) => {
           ws.send(CartesiaSTTClientFrame.FINALIZE, (err) => {
             if (err) getLogger().warn(`CartesiaSTT finalize send failed: ${String(err)}`);
-            resolve();
+            resolve2();
           });
         });
       } catch (err) {
@@ -5009,18 +5563,18 @@ var CartesiaSTT = class {
       }
     }
     if (ws.readyState === WebSocket2.OPEN || ws.readyState === WebSocket2.CONNECTING) {
-      await new Promise((resolve) => {
+      await new Promise((resolve2) => {
         const done = () => {
           ws.off("close", done);
           ws.off("error", done);
-          resolve();
+          resolve2();
         };
         ws.once("close", done);
         ws.once("error", done);
         try {
           ws.close();
         } catch {
-          resolve();
+          resolve2();
         }
       });
     }
@@ -5120,6 +5674,7 @@ var SonioxSTT = class _SonioxSTT {
   ws = null;
   callbacks = /* @__PURE__ */ new Set();
   final = new TokenAccumulator();
+  lastInterimText = "";
   keepaliveTimer = null;
   apiKey;
   model;
@@ -5132,7 +5687,10 @@ var SonioxSTT = class _SonioxSTT {
   maxEndpointDelayMs;
   clientReferenceId;
   baseUrl;
+  /** Construction args replayed by clone(). */
+  patterCtorArgs;
   constructor(apiKey, options = {}) {
+    this.patterCtorArgs = [apiKey, options];
     if (!apiKey) {
       throw new Error("Soniox apiKey is required");
     }
@@ -5181,14 +5739,23 @@ var SonioxSTT = class _SonioxSTT {
     return config;
   }
   /** Open the streaming WebSocket and send the initial config payload. */
+  /**
+   * Fresh adapter built with this instance's construction arguments —
+   * called per call by the stream handler so concurrent calls never share
+   * connection state (sockets/queues; cross-call transcript bleed).
+   */
+  clone() {
+    const ctor = this.constructor;
+    return new ctor(...this.patterCtorArgs);
+  }
   async connect() {
     this.final.reset();
     this.ws = new WebSocket3(this.baseUrl);
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(() => reject(new Error("Soniox connect timeout")), 1e4);
       this.ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       this.ws.once("error", (err) => {
         clearTimeout(timer);
@@ -5252,7 +5819,8 @@ var SonioxSTT = class _SonioxSTT {
     }
     if (!emittedFinalThisMsg) {
       const text = (this.final.text + nonFinal.text).trim();
-      if (text) {
+      if (text && text !== this.lastInterimText) {
+        this.lastInterimText = text;
         const { sum: fSum, count: fCount } = this.final.raw;
         const { sum: nSum, count: nCount } = nonFinal.raw;
         const total = fCount + nCount;
@@ -5271,7 +5839,13 @@ var SonioxSTT = class _SonioxSTT {
   }
   emit(transcript) {
     for (const cb of this.callbacks) {
-      cb(transcript);
+      try {
+        Promise.resolve(cb(transcript)).catch(
+          (err) => getLogger().error(`STT transcript callback failed: ${String(err)}`)
+        );
+      } catch (err) {
+        getLogger().error(`STT transcript callback threw: ${String(err)}`);
+      }
     }
   }
   /** Send a binary PCM16-LE audio chunk to Soniox for transcription. */
@@ -5280,6 +5854,19 @@ var SonioxSTT = class _SonioxSTT {
     if (audio.length === 0) return;
     this.ws.send(audio);
   }
+  /**
+   * Ask Soniox to finalize buffered audio immediately. The pipeline's VAD
+   * ``speech_end`` fast-path duck-types ``stt.finalize`` — without this
+   * every Soniox turn waited out the full endpointing delay. Mirrors Python.
+   */
+  finalize() {
+    if (!this.ws || this.ws.readyState !== WebSocket3.OPEN) return;
+    try {
+      this.ws.send(JSON.stringify({ type: "finalize" }));
+    } catch (err) {
+      getLogger().debug(`Soniox finalize failed: ${String(err)}`);
+    }
+  }
   /** Register a transcript listener. */
   onTranscript(callback) {
     this.callbacks.add(callback);
@@ -5356,7 +5943,7 @@ var AssemblyAIClientFrame = {
   FORCE_ENDPOINT: "ForceEndpoint",
   TERMINATE: "Terminate"
 };
-var DEFAULT_BASE_URL2 = "wss://streaming.assemblyai.com";
+var DEFAULT_BASE_URL3 = "wss://streaming.assemblyai.com";
 var DEFAULT_MIN_TURN_SILENCE_MS = 400;
 var CONNECT_TIMEOUT_MS2 = 1e4;
 var TERMINATION_WAIT_TIMEOUT_MS = 500;
@@ -5371,6 +5958,7 @@ var AssemblyAISTT = class _AssemblyAISTT {
   constructor(apiKey, options = {}) {
     this.apiKey = apiKey;
     this.options = options;
+    this.patterCtorArgs = [apiKey, options];
     if (!apiKey) {
       throw new Error("AssemblyAISTT requires a non-empty apiKey");
     }
@@ -5412,6 +6000,8 @@ var AssemblyAISTT = class _AssemblyAISTT {
   sessionId = null;
   /** Unix timestamp when the AssemblyAI session expires. */
   expiresAt = null;
+  /** Construction args replayed by clone(). */
+  patterCtorArgs;
   /** Factory for Twilio calls — mulaw 8 kHz. */
   static forTwilio(apiKey, model = AssemblyAIModel.UNIVERSAL_STREAMING_ENGLISH) {
     return new _AssemblyAISTT(apiKey, {
@@ -5463,7 +6053,7 @@ var AssemblyAISTT = class _AssemblyAISTT {
         params.set(key, String(value));
       }
     }
-    const base = opts.baseUrl ?? DEFAULT_BASE_URL2;
+    const base = opts.baseUrl ?? DEFAULT_BASE_URL3;
     return `${base}/v3/ws?${params.toString()}`;
   }
   buildHeaders() {
@@ -5496,7 +6086,7 @@ var AssemblyAISTT = class _AssemblyAISTT {
     const headers = this.buildHeaders();
     let ws = null;
     try {
-      ws = await new Promise((resolve, reject) => {
+      ws = await new Promise((resolve2, reject) => {
         const sock = new WebSocket4(url, { headers });
         const timer = setTimeout(() => {
           try {
@@ -5507,7 +6097,7 @@ var AssemblyAISTT = class _AssemblyAISTT {
         }, 5e3);
         sock.once("open", () => {
           clearTimeout(timer);
-          resolve(sock);
+          resolve2(sock);
         });
         sock.once("error", (err) => {
           clearTimeout(timer);
@@ -5533,6 +6123,15 @@ var AssemblyAISTT = class _AssemblyAISTT {
     }
   }
   /** Open the streaming WebSocket and arm message handlers. */
+  /**
+   * Fresh adapter built with this instance's construction arguments —
+   * called per call by the stream handler so concurrent calls never share
+   * connection state (sockets/queues; cross-call transcript bleed).
+   */
+  clone() {
+    const ctor = this.constructor;
+    return new ctor(...this.patterCtorArgs);
+  }
   async connect() {
     this.closing = false;
     const url = this.buildUrl();
@@ -5541,14 +6140,14 @@ var AssemblyAISTT = class _AssemblyAISTT {
     this.attachHandlers(this.ws);
   }
   async awaitOpen(ws) {
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(
         () => reject(new Error("AssemblyAI connect timeout")),
         CONNECT_TIMEOUT_MS2
       );
       ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       ws.once("error", (err) => {
         clearTimeout(timer);
@@ -5635,7 +6234,13 @@ var AssemblyAISTT = class _AssemblyAISTT {
   }
   emit(transcript) {
     for (const cb of this.callbacks) {
-      cb(transcript);
+      try {
+        Promise.resolve(cb(transcript)).catch(
+          (err) => getLogger().error(`STT transcript callback failed: ${String(err)}`)
+        );
+      } catch (err) {
+        getLogger().error(`STT transcript callback threw: ${String(err)}`);
+      }
     }
   }
   /** Send a binary PCM/mu-law audio chunk to AssemblyAI for transcription. */
@@ -5745,14 +6350,14 @@ var AssemblyAISTT = class _AssemblyAISTT {
       this.ws.send(JSON.stringify({ type: AssemblyAIClientFrame.TERMINATE }));
     } catch {
     }
-    await new Promise((resolve) => {
+    await new Promise((resolve2) => {
       const timer = setTimeout(() => {
         this.terminationResolve = null;
-        resolve();
+        resolve2();
       }, TERMINATION_WAIT_TIMEOUT_MS);
       this.terminationResolve = () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       };
     });
     try {
@@ -5859,7 +6464,10 @@ var SpeechmaticsSTT = class {
   operatingPoint;
   domain;
   outputLocale;
+  /** Construction args replayed by clone(). */
+  patterCtorArgs;
   constructor(apiKey, options = {}) {
+    this.patterCtorArgs = [apiKey, options];
     if (!apiKey) {
       throw new Error("Speechmatics apiKey is required");
     }
@@ -5931,13 +6539,22 @@ var SpeechmaticsSTT = class {
     };
   }
   /** Open the streaming WebSocket and send the `StartRecognition` frame. */
+  /**
+   * Fresh adapter built with this instance's construction arguments —
+   * called per call by the stream handler so concurrent calls never share
+   * connection state (sockets/queues; cross-call transcript bleed).
+   */
+  clone() {
+    const ctor = this.constructor;
+    return new ctor(...this.patterCtorArgs);
+  }
   async connect() {
     if (this.ws !== null) return;
     const ws = new WebSocket5(this.baseUrl, {
       headers: { Authorization: `Bearer ${this.apiKey}` }
     });
     this.ws = ws;
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       let settled = false;
       const settle = (fn) => {
         if (settled) return;
@@ -5951,7 +6568,7 @@ var SpeechmaticsSTT = class {
         ),
         CONNECT_TIMEOUT_MS3
       );
-      ws.once("open", () => settle(resolve));
+      ws.once("open", () => settle(resolve2));
       ws.once("error", (err) => settle(() => reject(err)));
       ws.once("unexpected-response", (_req, res) => {
         const status = res?.statusCode ?? 0;
@@ -6083,7 +6700,9 @@ var SpeechmaticsSTT = class {
   emitTranscript(transcript) {
     for (const cb of this.transcriptCallbacks) {
       try {
-        cb(transcript);
+        Promise.resolve(cb(transcript)).catch(
+          (err) => getLogger().error(`SpeechmaticsSTT transcript callback failed: ${String(err)}`)
+        );
       } catch (err) {
         getLogger().error(`SpeechmaticsSTT transcript callback threw: ${String(err)}`);
       }
@@ -6206,7 +6825,9 @@ function sanitiseLogStr(value, limit = 200) {
 }
 var CARRIER_NATIVE_FORMAT2 = {
   twilio: "ulaw_8000",
-  telnyx: "pcm_16000",
+  // The SDK's streaming_start pins the Telnyx wire to PCMU/μ-law @ 8 kHz —
+  // 'pcm_16000' here shipped raw PCM16 onto a μ-law wire (static).
+  telnyx: "ulaw_8000",
   // Plivo streams mulaw 8 kHz (we pin contentType in the answer XML).
   plivo: "ulaw_8000"
 };
@@ -6334,11 +6955,11 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
       }
     });
   }
-  /** Pre-configured for Telnyx (`pcm_16000`). */
+  /** Pre-configured for Telnyx (μ-law 8 kHz wire). */
   static forTelnyx(opts) {
     return new _ElevenLabsWebSocketTTS({
       ...opts,
-      outputFormat: "pcm_16000"
+      outputFormat: "ulaw_8000"
     });
   }
   buildUrl() {
@@ -6478,7 +7099,7 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
     ws.on("error", onError);
     try {
       if (!adopted) {
-        await new Promise((resolve, reject) => {
+        await new Promise((resolve2, reject) => {
           connectTimer = setTimeout(
             () => reject(new Error("ElevenLabs WS connect timeout")),
             CONNECT_TIMEOUT_MS4
@@ -6486,7 +7107,7 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
           ws.once("open", () => {
             if (connectTimer) clearTimeout(connectTimer);
             connectTimer = void 0;
-            resolve();
+            resolve2();
           });
           ws.once("error", (err) => {
             if (connectTimer) clearTimeout(connectTimer);
@@ -6571,14 +7192,14 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
       headers: { "xi-api-key": this.apiKey }
     });
     try {
-      await new Promise((resolve, reject) => {
+      await new Promise((resolve2, reject) => {
         const timer = setTimeout(
           () => reject(new Error("ElevenLabs WS TTS warmup connect timeout")),
           CONNECT_TIMEOUT_MS4
         );
         ws.once("open", () => {
           clearTimeout(timer);
-          resolve();
+          resolve2();
         });
         ws.once("error", (err) => {
           clearTimeout(timer);
@@ -6622,14 +7243,14 @@ var ElevenLabsWebSocketTTS = class _ElevenLabsWebSocketTTS {
     const ws = new WebSocket6(this.buildUrl(), {
       headers: { "xi-api-key": this.apiKey }
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(
         () => reject(new Error("ElevenLabs WS park connect timeout")),
         CONNECT_TIMEOUT_MS4
       );
       ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       ws.once("error", (err) => {
         clearTimeout(timer);
@@ -6970,7 +7591,7 @@ var TTS4 = class _TTS extends CartesiaTTS {
   }
   static forTwilio(arg1, arg2) {
     const opts = typeof arg1 === "string" ? { apiKey: arg1, ...arg2 ?? {} } : arg1 ?? {};
-    return new _TTS({ ...opts, sampleRate: 8e3 });
+    return new _TTS({ ...opts, sampleRate: 16e3 });
   }
   static forTelnyx(arg1, arg2) {
     const opts = typeof arg1 === "string" ? { apiKey: arg1, ...arg2 ?? {} } : arg1 ?? {};
@@ -7353,7 +7974,7 @@ var AnthropicModel = {
   CLAUDE_3_5_SONNET_20241022: "claude-3-5-sonnet-20241022",
   CLAUDE_3_5_HAIKU_20241022: "claude-3-5-haiku-20241022"
 };
-var DEFAULT_MODEL = AnthropicModel.CLAUDE_HAIKU_4_5_20251001;
+var DEFAULT_MODEL2 = AnthropicModel.CLAUDE_HAIKU_4_5_20251001;
 var DEFAULT_MAX_TOKENS = 1024;
 var PROMPT_CACHING_BETA = "prompt-caching-2024-07-31";
 var AnthropicLLMProvider = class {
@@ -7373,7 +7994,7 @@ var AnthropicLLMProvider = class {
       );
     }
     this.apiKey = options.apiKey;
-    this.model = options.model ?? DEFAULT_MODEL;
+    this.model = options.model ?? DEFAULT_MODEL2;
     this.maxTokens = options.maxTokens ?? DEFAULT_MAX_TOKENS;
     this.temperature = options.temperature;
     this.url = options.baseUrl ?? DEFAULT_ANTHROPIC_URL;
@@ -7446,16 +8067,19 @@ var AnthropicLLMProvider = class {
     if (this.promptCaching) {
       headers["anthropic-beta"] = PROMPT_CACHING_BETA;
     }
+    const idle = createStreamIdleWatchdog();
     const response = await fetch(this.url, {
       method: "POST",
       headers,
       body: JSON.stringify(body),
-      signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(3e4))
+      signal: mergeAbortSignals(opts?.signal, idle.signal)
     });
     if (!response.ok) {
       const errText = await response.text();
-      getLogger().error(`Anthropic API error: ${response.status} ${errText}`);
-      return;
+      getLogger().error(`Anthropic API error: ${response.status} ${errText.slice(0, 200)}`);
+      throw new PatterConnectionError(
+        `Anthropic API returned ${response.status}: ${errText.slice(0, 200)}`
+      );
     }
     const reader = response.body?.getReader();
     if (!reader) return;
@@ -7471,6 +8095,7 @@ var AnthropicLLMProvider = class {
     try {
       while (true) {
         const { done, value } = await reader.read();
+        idle.touch();
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -7486,6 +8111,15 @@ var AnthropicLLMProvider = class {
           } catch {
             continue;
           }
+          if (event.type === "error") {
+            const errPayload = event.error;
+            const detail = `${errPayload?.type ?? "unknown"}: ${errPayload?.message ?? ""}`.slice(
+              0,
+              200
+            );
+            getLogger().error(`Anthropic in-stream error event: ${detail}`);
+            throw new PatterConnectionError(`Anthropic stream error \u2014 ${detail}`);
+          }
           if (event.type === "message_start" && event.message?.usage) {
             const u = event.message.usage;
             if (u.input_tokens) inputTokens = u.input_tokens;
@@ -7533,7 +8167,15 @@ var AnthropicLLMProvider = class {
           }
         }
       }
+    } catch (err) {
+      if (idle.fired && !opts?.signal?.aborted) {
+        throw new PatterConnectionError(
+          `Anthropic stream idle timeout \u2014 no data for ${LLM_STREAM_IDLE_TIMEOUT_MS / 1e3}s`
+        );
+      }
+      throw err;
     } finally {
+      idle.clear();
       reader.cancel().catch(() => {
       });
     }
@@ -7618,6 +8260,9 @@ function toAnthropicMessages(messages) {
       continue;
     }
   }
+  if (out.length > 0 && out[0].role === "assistant") {
+    out.unshift({ role: "user", content: "(call connected)" });
+  }
   return { system: systemParts.join("\n\n"), messages: out };
 }
 
@@ -7658,7 +8303,7 @@ var GroqModel = {
   MIXTRAL_8X7B: "mixtral-8x7b-32768",
   GEMMA2_9B: "gemma2-9b-it"
 };
-var DEFAULT_MODEL2 = GroqModel.LLAMA_3_3_70B_VERSATILE;
+var DEFAULT_MODEL3 = GroqModel.LLAMA_3_3_70B_VERSATILE;
 var GroqLLMProvider = class {
   /** Stable pricing/dashboard key — read by stream-handler/metrics. */
   static providerKey = "groq";
@@ -7682,7 +8327,7 @@ var GroqLLMProvider = class {
       );
     }
     this.apiKey = options.apiKey;
-    this.model = options.model ?? DEFAULT_MODEL2;
+    this.model = options.model ?? DEFAULT_MODEL3;
     this.baseUrl = options.baseUrl ?? GROQ_BASE_URL;
     this.temperature = options.temperature;
     this.maxTokens = options.maxTokens;
@@ -7731,6 +8376,7 @@ var GroqLLMProvider = class {
     if (this.presencePenalty !== void 0) body.presence_penalty = this.presencePenalty;
     if (this.stop !== void 0) body.stop = this.stop;
     if (tools) body.tools = tools;
+    const idle = createStreamIdleWatchdog();
     const response = await fetch(`${this.baseUrl}/chat/completions`, {
       method: "POST",
       headers: {
@@ -7739,17 +8385,30 @@ var GroqLLMProvider = class {
         "User-Agent": `getpatter/${VERSION}`
       },
       body: JSON.stringify(body),
-      signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(3e4))
+      signal: mergeAbortSignals(opts?.signal, idle.signal)
     });
     if (!response.ok) {
       const errText = await response.text();
-      getLogger().error(`Groq API error: ${response.status} ${errText}`);
-      return;
+      getLogger().error(`Groq API error: ${response.status} ${errText.slice(0, 200)}`);
+      throw new PatterConnectionError(
+        `Groq API returned ${response.status}: ${errText.slice(0, 200)}`
+      );
+    }
+    try {
+      yield* parseOpenAISseStream(response, idle.touch);
+    } catch (err) {
+      if (idle.fired && !opts?.signal?.aborted) {
+        throw new PatterConnectionError(
+          `Groq stream idle timeout \u2014 no data for ${LLM_STREAM_IDLE_TIMEOUT_MS / 1e3}s`
+        );
+      }
+      throw err;
+    } finally {
+      idle.clear();
     }
-    yield* parseOpenAISseStream(response);
   }
 };
-async function* parseOpenAISseStream(response) {
+async function* parseOpenAISseStream(response, onRead) {
   const reader = response.body?.getReader();
   if (!reader) return;
   const decoder = new TextDecoder();
@@ -7757,6 +8416,7 @@ async function* parseOpenAISseStream(response) {
   try {
     while (true) {
       const { done, value } = await reader.read();
+      onRead?.();
       if (done) break;
       buffer += decoder.decode(value, { stream: true });
       const lines = buffer.split("\n");
@@ -7777,7 +8437,7 @@ async function* parseOpenAISseStream(response) {
           const cached = chunk.usage?.prompt_tokens_details?.cached_tokens ?? 0;
           yield {
             type: "usage",
-            inputTokens: usage.prompt_tokens,
+            inputTokens: Math.max(0, (usage.prompt_tokens ?? 0) - cached),
             outputTokens: usage.completion_tokens,
             cacheReadInputTokens: cached
           };
@@ -7833,468 +8493,248 @@ var LLM3 = class extends GroqLLMProvider {
     });
   }
 };
-
-// src/llm/cerebras.ts
-init_esm_shims();
-
-// src/providers/cerebras-llm.ts
-init_esm_shims();
-var CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
-var CerebrasModel = {
-  GPT_OSS_120B: "gpt-oss-120b",
-  LLAMA_3_1_8B: "llama3.1-8b",
-  LLAMA_3_3_70B: "llama-3.3-70b",
-  QWEN_3_235B_INSTRUCT: "qwen-3-235b-a22b-instruct-2507",
-  ZAI_GLM_4_7: "zai-glm-4.7"
-};
-var DEFAULT_MODEL3 = CerebrasModel.GPT_OSS_120B;
-var RETRY_BACKOFF_BASE_MS = 500;
-var CerebrasLLMProvider = class {
-  /** Stable pricing/dashboard key — read by stream-handler/metrics. */
-  static providerKey = "cerebras";
-  apiKey;
-  model;
-  baseUrl;
-  gzipCompression;
-  temperature;
-  maxTokens;
-  responseFormat;
-  parallelToolCalls;
-  toolChoice;
-  seed;
-  topP;
-  frequencyPenalty;
-  presencePenalty;
-  stop;
-  constructor(options) {
-    if (!options.apiKey) {
-      throw new Error(
-        "Cerebras API key is required. Pass it via { apiKey } or read CEREBRAS_API_KEY from the environment."
-      );
-    }
-    this.apiKey = options.apiKey;
-    this.model = options.model ?? DEFAULT_MODEL3;
-    this.baseUrl = options.baseUrl ?? CEREBRAS_BASE_URL;
-    this.gzipCompression = options.gzipCompression ?? true;
-    this.temperature = options.temperature;
-    this.maxTokens = options.maxTokens;
-    this.responseFormat = options.responseFormat;
-    this.parallelToolCalls = options.parallelToolCalls;
-    this.toolChoice = options.toolChoice;
-    this.seed = options.seed;
-    this.topP = options.topP;
-    this.frequencyPenalty = options.frequencyPenalty;
-    this.presencePenalty = options.presencePenalty;
-    this.stop = options.stop;
-  }
-  /**
-   * Pre-call DNS / TLS warmup for the Cerebras inference endpoint.
-   * Best-effort: 5 s timeout, all exceptions swallowed at debug level.
-   */
-  async warmup() {
-    try {
-      await fetch(`${this.baseUrl}/models`, {
-        method: "GET",
-        headers: { Authorization: `Bearer ${this.apiKey}` },
-        signal: AbortSignal.timeout(5e3)
-      });
-    } catch (err) {
-      getLogger().debug(`Cerebras LLM warmup failed (best-effort): ${String(err)}`);
-    }
-  }
-  /** Stream Patter-format LLM chunks from the Cerebras chat completions API. */
-  async *stream(messages, tools, opts) {
-    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;
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.apiKey}`,
-      // Identify the SDK in upstream logs/rate-limit attribution.
-      "User-Agent": `getpatter/${VERSION}`
-    };
-    let payload = JSON.stringify(body);
-    if (this.gzipCompression) {
-      const compressed = await gzipEncode(payload);
-      if (compressed) {
-        payload = compressed;
-        headers["Content-Encoding"] = "gzip";
-      }
-    }
-    const maxAttempts = 2;
-    let lastErrText = "";
-    let lastStatus = 0;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      const response = await fetch(`${this.baseUrl}/chat/completions`, {
-        method: "POST",
-        headers,
-        body: payload,
-        signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(3e4))
-      });
-      if (response.ok) {
-        yield* parseOpenAISseStream(response);
-        return;
-      }
-      lastStatus = response.status;
-      lastErrText = await response.text().catch(() => "");
-      const isRetriable = response.status === 429 || response.status >= 500;
-      const isLastAttempt = attempt >= maxAttempts - 1;
-      if (!isRetriable || isLastAttempt) {
-        if (response.status === 404 && lastErrText.includes("model_not_found")) {
-          getLogger().error(
-            `Cerebras: model "${this.model}" not available on your tier. Override via \`new CerebrasLLM({ model: '<id>' })\` and list tier-available ids with \`GET ${this.baseUrl}/models\` (common: llama3.1-8b, qwen-3-235b-a22b-instruct-2507, llama-3.3-70b on paid). Raw response: ${lastErrText}`
-          );
-        } else {
-          getLogger().error(`Cerebras API error: ${response.status} ${lastErrText}`);
-        }
-        return;
-      }
-      const advisoryMs = parseRateLimitResetMs(response.headers);
-      const exponentialMs = RETRY_BACKOFF_BASE_MS * Math.pow(2, attempt);
-      const delayMs = Math.min(5e3, Math.max(advisoryMs, exponentialMs));
-      getLogger().warn(
-        `Cerebras API ${response.status} (attempt ${attempt + 1}/${maxAttempts}); retrying after ${delayMs}ms`
-      );
-      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"}`);
-  }
-};
-async function gzipEncode(data) {
-  const CompressionCtor = globalThis.CompressionStream;
-  if (!CompressionCtor) return null;
-  const stream = new CompressionCtor("gzip");
-  const writer = stream.writable.getWriter();
-  const encoder = new TextEncoder();
-  await writer.write(encoder.encode(data));
-  await writer.close();
-  const chunks = [];
-  const reader = stream.readable.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    if (value) chunks.push(value);
-  }
-  const total = chunks.reduce((n, c) => n + c.length, 0);
-  const out = new Uint8Array(total);
-  let offset = 0;
-  for (const c of chunks) {
-    out.set(c, offset);
-    offset += c.length;
-  }
-  return out;
-}
-function parseRateLimitResetMs(headers) {
-  const candidates = [
-    headers.get("x-ratelimit-reset-tokens-minute"),
-    headers.get("x-ratelimit-reset-requests-minute"),
-    // Some upstreams send the standard ``retry-after`` (seconds).
-    headers.get("retry-after")
-  ];
-  let bestMs = 0;
-  for (const raw of candidates) {
-    if (!raw) continue;
-    const parsed = Number.parseFloat(raw);
-    if (Number.isFinite(parsed) && parsed > 0) {
-      const ms = parsed * 1e3;
-      if (ms > bestMs) bestMs = ms;
-    }
-  }
-  return bestMs;
-}
-
-// src/llm/cerebras.ts
-var LLM4 = class extends CerebrasLLMProvider {
-  static providerKey = "cerebras";
-  constructor(opts = {}) {
-    const key = opts.apiKey ?? process.env.CEREBRAS_API_KEY;
-    if (!key) {
-      throw new Error(
-        "Cerebras LLM requires an apiKey. Pass { apiKey: 'csk-...' } or set CEREBRAS_API_KEY."
-      );
-    }
-    super({
-      apiKey: key,
-      model: opts.model,
-      baseUrl: opts.baseUrl,
-      gzipCompression: opts.gzipCompression,
-      temperature: opts.temperature,
-      maxTokens: opts.maxTokens,
-      responseFormat: opts.responseFormat,
-      parallelToolCalls: opts.parallelToolCalls,
-      toolChoice: opts.toolChoice,
-      seed: opts.seed,
-      topP: opts.topP,
-      frequencyPenalty: opts.frequencyPenalty,
-      presencePenalty: opts.presencePenalty,
-      stop: opts.stop
-    });
-  }
-};
-
-// src/llm/google.ts
-init_esm_shims();
-
-// src/providers/google-llm.ts
-init_esm_shims();
-var GoogleModel = {
-  GEMINI_2_5_FLASH: "gemini-2.5-flash",
-  GEMINI_2_5_PRO: "gemini-2.5-pro",
-  GEMINI_2_0_FLASH: "gemini-2.0-flash",
-  GEMINI_2_0_FLASH_LITE: "gemini-2.0-flash-lite",
-  GEMINI_1_5_FLASH: "gemini-1.5-flash",
-  GEMINI_1_5_PRO: "gemini-1.5-pro"
+
+// src/llm/cerebras.ts
+init_esm_shims();
+
+// src/providers/cerebras-llm.ts
+init_esm_shims();
+var CEREBRAS_BASE_URL = "https://api.cerebras.ai/v1";
+var CerebrasModel = {
+  GPT_OSS_120B: "gpt-oss-120b",
+  LLAMA_3_1_8B: "llama3.1-8b",
+  LLAMA_3_3_70B: "llama-3.3-70b",
+  QWEN_3_235B_INSTRUCT: "qwen-3-235b-a22b-instruct-2507",
+  ZAI_GLM_4_7: "zai-glm-4.7"
 };
-var DEFAULT_MODEL4 = GoogleModel.GEMINI_2_5_FLASH;
-var DEFAULT_BASE_URL3 = "https://generativelanguage.googleapis.com/v1beta";
-var GoogleLLMProvider = class {
+var DEFAULT_MODEL4 = CerebrasModel.GPT_OSS_120B;
+var RETRY_BACKOFF_BASE_MS = 500;
+var CerebrasLLMProvider = class {
   /** Stable pricing/dashboard key — read by stream-handler/metrics. */
-  static providerKey = "google";
+  static providerKey = "cerebras";
   apiKey;
   model;
   baseUrl;
+  gzipCompression;
   temperature;
-  maxOutputTokens;
+  maxTokens;
+  responseFormat;
+  parallelToolCalls;
+  toolChoice;
+  seed;
+  topP;
+  frequencyPenalty;
+  presencePenalty;
+  stop;
   constructor(options) {
     if (!options.apiKey) {
       throw new Error(
-        "Google API key is required. Pass it via { apiKey } or read GOOGLE_API_KEY from the environment."
+        "Cerebras API key is required. Pass it via { apiKey } or read CEREBRAS_API_KEY from the environment."
       );
     }
     this.apiKey = options.apiKey;
     this.model = options.model ?? DEFAULT_MODEL4;
-    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL3;
+    this.baseUrl = options.baseUrl ?? CEREBRAS_BASE_URL;
+    this.gzipCompression = options.gzipCompression ?? true;
     this.temperature = options.temperature;
-    this.maxOutputTokens = options.maxOutputTokens;
+    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;
   }
   /**
-   * Pre-call DNS / TLS warmup for the Gemini API.
-   * Issues a lightweight ``GET ${baseUrl}/models?key=...`` so DNS, TLS
-   * and HTTP/2 are already up by the time the first
-   * ``streamGenerateContent`` call lands. Best-effort: 5 s timeout, all
-   * exceptions swallowed at debug level.
+   * Pre-call DNS / TLS warmup for the Cerebras inference endpoint.
+   * Best-effort: 5 s timeout, all exceptions swallowed at debug level.
    */
   async warmup() {
     try {
-      await fetch(`${this.baseUrl}/models?key=${encodeURIComponent(this.apiKey)}`, {
+      await fetch(`${this.baseUrl}/models`, {
         method: "GET",
+        headers: { Authorization: `Bearer ${this.apiKey}` },
         signal: AbortSignal.timeout(5e3)
       });
     } catch (err) {
-      getLogger().debug(`Google LLM warmup failed (best-effort): ${String(err)}`);
+      getLogger().debug(`Cerebras LLM warmup failed (best-effort): ${String(err)}`);
     }
   }
-  /** Stream Patter-format LLM chunks from the Gemini SSE endpoint. */
+  /** Stream Patter-format LLM chunks from the Cerebras chat completions API. */
   async *stream(messages, tools, opts) {
-    const { systemInstruction, contents } = toGeminiContents(messages);
-    const geminiTools = tools ? toGeminiTools(tools) : null;
-    const body = { contents };
-    if (systemInstruction) {
-      body.systemInstruction = { role: "system", parts: [{ text: systemInstruction }] };
-    }
-    if (geminiTools) body.tools = geminiTools;
-    const generationConfig = {};
-    if (this.temperature !== void 0) generationConfig.temperature = this.temperature;
-    if (this.maxOutputTokens !== void 0)
-      generationConfig.maxOutputTokens = this.maxOutputTokens;
-    if (Object.keys(generationConfig).length > 0) body.generationConfig = generationConfig;
-    const url = `${this.baseUrl}/models/${encodeURIComponent(this.model)}:streamGenerateContent?alt=sse&key=${encodeURIComponent(this.apiKey)}`;
-    const response = await fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body),
-      signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(3e4))
-    });
-    if (!response.ok) {
-      const errText = await response.text();
-      getLogger().error(`Gemini API error: ${response.status} ${errText}`);
-      return;
-    }
-    const reader = response.body?.getReader();
-    if (!reader) return;
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let nextIndex = 0;
-    let lastUsage;
-    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 (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 {
-        type: "usage",
-        inputTokens: lastUsage.promptTokenCount,
-        outputTokens: lastUsage.candidatesTokenCount,
-        cacheReadInputTokens: lastUsage.cachedContentTokenCount ?? 0
-      };
-    }
-    yield { type: "done" };
-  }
-};
-function toGeminiTools(tools) {
-  const functionDeclarations = tools.map((t) => {
-    const fn = t.function ?? t;
-    return {
-      name: String(fn.name ?? ""),
-      description: String(fn.description ?? ""),
-      parameters: fn.parameters ?? { type: "object", properties: {} }
+    const body = {
+      model: this.model,
+      messages,
+      stream: true,
+      stream_options: { include_usage: true }
     };
-  });
-  if (functionDeclarations.length === 0) return [];
-  return [{ functionDeclarations }];
-}
-function toGeminiContents(messages) {
-  const systemParts = [];
-  const contents = [];
-  for (const rawMsg of messages) {
-    const role = rawMsg.role;
-    if (role === "system") {
-      if (typeof rawMsg.content === "string" && rawMsg.content) {
-        systemParts.push(rawMsg.content);
-      }
-      continue;
+    if (this.temperature !== void 0) body.temperature = this.temperature;
+    if (this.maxTokens !== void 0) {
+      body.max_completion_tokens = this.maxTokens;
     }
-    if (role === "user") {
-      if (typeof rawMsg.content === "string" && rawMsg.content) {
-        contents.push({ role: "user", parts: [{ text: rawMsg.content }] });
+    if (this.responseFormat !== void 0) body.response_format = this.responseFormat;
+    if (this.parallelToolCalls !== void 0) body.parallel_tool_calls = this.parallelToolCalls;
+    if (this.toolChoice !== void 0) body.tool_choice = this.toolChoice;
+    if (this.seed !== void 0) body.seed = this.seed;
+    if (this.topP !== void 0) body.top_p = this.topP;
+    if (this.frequencyPenalty !== void 0) body.frequency_penalty = this.frequencyPenalty;
+    if (this.presencePenalty !== void 0) body.presence_penalty = this.presencePenalty;
+    if (this.stop !== void 0) body.stop = this.stop;
+    if (tools) body.tools = tools;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      // Identify the SDK in upstream logs/rate-limit attribution.
+      "User-Agent": `getpatter/${VERSION}`
+    };
+    let payload = JSON.stringify(body);
+    if (this.gzipCompression) {
+      const compressed = await gzipEncode(payload);
+      if (compressed) {
+        payload = compressed;
+        headers["Content-Encoding"] = "gzip";
       }
-      continue;
     }
-    if (role === "assistant") {
-      const parts = [];
-      if (typeof rawMsg.content === "string" && rawMsg.content) {
-        parts.push({ text: rawMsg.content });
-      }
-      for (const tc of rawMsg.tool_calls ?? []) {
-        let args = {};
+    const maxAttempts = 2;
+    let lastErrText = "";
+    let lastStatus = 0;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const idle = createStreamIdleWatchdog();
+      const response = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers,
+        body: payload,
+        signal: mergeAbortSignals(opts?.signal, idle.signal)
+      });
+      if (response.ok) {
         try {
-          const parsed = JSON.parse(tc.function?.arguments ?? "{}");
-          if (parsed && typeof parsed === "object") args = parsed;
-        } catch {
-          args = {};
-        }
-        parts.push({
-          functionCall: {
-            name: tc.function?.name ?? "",
-            args,
-            id: tc.id
+          yield* parseOpenAISseStream(response, idle.touch);
+        } catch (err) {
+          if (idle.fired && !opts?.signal?.aborted) {
+            throw new PatterConnectionError(
+              `Cerebras stream idle timeout \u2014 no data for ${LLM_STREAM_IDLE_TIMEOUT_MS / 1e3}s`
+            );
           }
-        });
-      }
-      if (parts.length > 0) contents.push({ role: "model", parts });
-      continue;
-    }
-    if (role === "tool") {
-      const raw = rawMsg.content;
-      let response;
-      if (typeof raw === "string") {
-        try {
-          const parsed = JSON.parse(raw);
-          response = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : { result: parsed };
-        } catch {
-          response = { result: raw };
+          throw err;
+        } finally {
+          idle.clear();
         }
-      } else {
-        response = raw ?? {};
+        return;
       }
-      contents.push({
-        role: "user",
-        parts: [
-          {
-            functionResponse: {
-              name: rawMsg.name ?? rawMsg.tool_call_id ?? "",
-              response,
-              id: rawMsg.tool_call_id
-            }
-          }
-        ]
+      idle.clear();
+      lastStatus = response.status;
+      lastErrText = await response.text().catch(() => "");
+      const isRetriable = response.status === 429 || response.status >= 500;
+      const isLastAttempt = attempt >= maxAttempts - 1;
+      if (!isRetriable || isLastAttempt) {
+        if (response.status === 404 && lastErrText.includes("model_not_found")) {
+          getLogger().error(
+            `Cerebras: model "${this.model}" not available on your tier. Override via \`new CerebrasLLM({ model: '<id>' })\` and list tier-available ids with \`GET ${this.baseUrl}/models\` (common: llama3.1-8b, qwen-3-235b-a22b-instruct-2507, llama-3.3-70b on paid). Raw response: ${lastErrText.slice(0, 200)}`
+          );
+        } else {
+          getLogger().error(`Cerebras API error: ${response.status} ${lastErrText.slice(0, 200)}`);
+        }
+        throw new PatterConnectionError(
+          `Cerebras API returned ${response.status}: ${lastErrText.slice(0, 200)}`
+        );
+      }
+      const advisoryMs = parseRateLimitResetMs(response.headers);
+      const exponentialMs = RETRY_BACKOFF_BASE_MS * Math.pow(2, attempt);
+      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((resolve2, reject) => {
+        const t = setTimeout(resolve2, delayMs);
+        opts?.signal?.addEventListener(
+          "abort",
+          () => {
+            clearTimeout(t);
+            reject(opts.signal.reason);
+          },
+          { once: true }
+        );
       });
-      continue;
     }
+    throw new PatterError(`Cerebras API error ${lastStatus}: ${lastErrText || "request failed"}`);
   }
-  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);
+};
+async function gzipEncode(data) {
+  const CompressionCtor = globalThis.CompressionStream;
+  if (!CompressionCtor) return null;
+  const stream = new CompressionCtor("gzip");
+  const writer = stream.writable.getWriter();
+  const encoder = new TextEncoder();
+  await writer.write(encoder.encode(data));
+  await writer.close();
+  const chunks = [];
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) chunks.push(value);
+  }
+  const total = chunks.reduce((n, c) => n + c.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.length;
+  }
+  return out;
+}
+function parseRateLimitResetMs(headers) {
+  const candidates = [
+    headers.get("x-ratelimit-reset-tokens-minute"),
+    headers.get("x-ratelimit-reset-requests-minute"),
+    // Some upstreams send the standard ``retry-after`` (seconds).
+    headers.get("retry-after")
+  ];
+  let bestMs = 0;
+  for (const raw of candidates) {
+    if (!raw) continue;
+    const parsed = Number.parseFloat(raw);
+    if (Number.isFinite(parsed) && parsed > 0) {
+      const ms = parsed * 1e3;
+      if (ms > bestMs) bestMs = ms;
     }
   }
-  return { systemInstruction: systemParts.join("\n\n"), contents: merged };
+  return bestMs;
 }
 
+// src/llm/cerebras.ts
+var LLM4 = class extends CerebrasLLMProvider {
+  static providerKey = "cerebras";
+  constructor(opts = {}) {
+    const key = opts.apiKey ?? process.env.CEREBRAS_API_KEY;
+    if (!key) {
+      throw new Error(
+        "Cerebras LLM requires an apiKey. Pass { apiKey: 'csk-...' } or set CEREBRAS_API_KEY."
+      );
+    }
+    super({
+      apiKey: key,
+      model: opts.model,
+      baseUrl: opts.baseUrl,
+      gzipCompression: opts.gzipCompression,
+      temperature: opts.temperature,
+      maxTokens: opts.maxTokens,
+      responseFormat: opts.responseFormat,
+      parallelToolCalls: opts.parallelToolCalls,
+      toolChoice: opts.toolChoice,
+      seed: opts.seed,
+      topP: opts.topP,
+      frequencyPenalty: opts.frequencyPenalty,
+      presencePenalty: opts.presencePenalty,
+      stop: opts.stop
+    });
+  }
+};
+
 // src/llm/google.ts
+init_esm_shims();
 var LLM5 = class extends GoogleLLMProvider {
   static providerKey = "google";
   constructor(opts = {}) {
@@ -8499,11 +8939,12 @@ var OpenAICompatibleLLMProvider = class {
     const caller = opts?.caller;
     const callee = opts?.callee;
     const body = this.buildBody(messages, tools, callId);
+    const idle = createStreamIdleWatchdog(this.timeoutMs);
     const response = await fetch(`${this.baseUrl}/chat/completions`, {
       method: "POST",
       headers: this.buildHeaders(callId, caller, callee),
       body: JSON.stringify(body),
-      signal: mergeAbortSignals(opts?.signal, AbortSignal.timeout(this.timeoutMs))
+      signal: mergeAbortSignals(opts?.signal, idle.signal)
     });
     if (!response.ok) {
       const errText = await response.text();
@@ -8514,7 +8955,18 @@ var OpenAICompatibleLLMProvider = class {
         `LLM API returned ${response.status}: ${errText.slice(0, 200)}`
       );
     }
-    yield* parseOpenAISseStream(response);
+    try {
+      yield* parseOpenAISseStream(response, idle.touch);
+    } catch (err) {
+      if (idle.fired && !opts?.signal?.aborted) {
+        throw new PatterConnectionError(
+          `LLM stream idle timeout \u2014 no data for ${Math.round(this.timeoutMs / 1e3)}s`
+        );
+      }
+      throw err;
+    } finally {
+      idle.clear();
+    }
   }
 };
 var LLM6 = class extends OpenAICompatibleLLMProvider {
@@ -8618,13 +9070,437 @@ var LLM9 = class extends OpenAICompatibleLLMProvider {
   }
 };
 
+// src/providers/smart-turn.ts
+init_esm_shims();
+import * as fs3 from "fs";
+import * as path2 from "path";
+var SMART_TURN_MODEL_ENV_VAR = "PATTER_SMART_TURN_MODEL";
+var SMART_TURN_SAMPLE_RATE = 16e3;
+var SMART_TURN_MAX_SECONDS = 8;
+var SMART_TURN_MAX_SAMPLES = SMART_TURN_SAMPLE_RATE * SMART_TURN_MAX_SECONDS;
+var DEFAULT_SMART_TURN_THRESHOLD = 0.5;
+var N_FFT = 400;
+var HOP_LENGTH = 160;
+var N_MELS = 80;
+var N_FRAMES = 800;
+var MEL_FLOOR = 1e-10;
+var NORM_EPS = 1e-7;
+var DOWNLOAD_HINT = `Download a smart-turn-v3 ONNX file from https://huggingface.co/pipecat-ai/smart-turn-v3 and either set the ${SMART_TURN_MODEL_ENV_VAR} environment variable to its path or pass modelPath to SmartTurnDetector.load(). The model is not bundled with the SDK (~30 MB).`;
+function resolveSmartTurnModelPath(modelPath) {
+  let resolved = modelPath;
+  if (!resolved) {
+    resolved = (process.env[SMART_TURN_MODEL_ENV_VAR] ?? "").trim();
+    if (!resolved) {
+      throw new Error(
+        `SmartTurnDetector has no model file configured. ${DOWNLOAD_HINT}`
+      );
+    }
+  }
+  if (!fs3.existsSync(resolved)) {
+    throw new Error(`Smart-turn model file not found: ${resolved}. ${DOWNLOAD_HINT}`);
+  }
+  if (!fs3.statSync(resolved).isFile()) {
+    throw new Error(`Smart-turn model path is not a file: ${resolved}. ${DOWNLOAD_HINT}`);
+  }
+  return path2.resolve(resolved);
+}
+function hertzToMelSlaney(freq) {
+  const minLogHertz = 1e3;
+  const minLogMel = 15;
+  const logstep = 27 / Math.log(6.4);
+  if (freq >= minLogHertz) {
+    return minLogMel + Math.log(freq / minLogHertz) * logstep;
+  }
+  return 3 * freq / 200;
+}
+function melToHertzSlaney(mels) {
+  const minLogHertz = 1e3;
+  const minLogMel = 15;
+  const logstep = Math.log(6.4) / 27;
+  if (mels >= minLogMel) {
+    return minLogHertz * Math.exp(logstep * (mels - minLogMel));
+  }
+  return 200 * mels / 3;
+}
+var melFilterbankCache = null;
+function melFilterbank() {
+  if (melFilterbankCache) return melFilterbankCache;
+  const numBins = 1 + N_FFT / 2;
+  const fftFreqs = new Float64Array(numBins);
+  for (let k = 0; k < numBins; k++) {
+    fftFreqs[k] = k * (SMART_TURN_SAMPLE_RATE / 2) / (numBins - 1);
+  }
+  const melMin = hertzToMelSlaney(0);
+  const melMax = hertzToMelSlaney(SMART_TURN_SAMPLE_RATE / 2);
+  const filterFreqs = new Float64Array(N_MELS + 2);
+  for (let i = 0; i < N_MELS + 2; i++) {
+    filterFreqs[i] = melToHertzSlaney(melMin + (melMax - melMin) * i / (N_MELS + 1));
+  }
+  const filters = [];
+  for (let m = 0; m < N_MELS; m++) {
+    const lower = filterFreqs[m];
+    const center = filterFreqs[m + 1];
+    const upper = filterFreqs[m + 2];
+    const enorm = 2 / (upper - lower);
+    const dense = new Float64Array(numBins);
+    let startBin = -1;
+    let endBin = -1;
+    for (let k = 0; k < numBins; k++) {
+      const down = (fftFreqs[k] - lower) / (center - lower);
+      const up = (upper - fftFreqs[k]) / (upper - center);
+      const w = Math.max(0, Math.min(down, up)) * enorm;
+      dense[k] = w;
+      if (w > 0) {
+        if (startBin === -1) startBin = k;
+        endBin = k;
+      }
+    }
+    if (startBin === -1) {
+      filters.push({ startBin: 0, weights: new Float64Array(0) });
+    } else {
+      filters.push({ startBin, weights: dense.slice(startBin, endBin + 1) });
+    }
+  }
+  melFilterbankCache = filters;
+  return filters;
+}
+var hannWindowCache = null;
+function hannWindow() {
+  if (!hannWindowCache) {
+    const w = new Float64Array(N_FFT);
+    for (let n = 0; n < N_FFT; n++) {
+      w[n] = 0.5 - 0.5 * Math.cos(2 * Math.PI * n / N_FFT);
+    }
+    hannWindowCache = w;
+  }
+  return hannWindowCache;
+}
+var dft25Cos = null;
+var dft25Sin = null;
+function dft25Tables() {
+  if (!dft25Cos || !dft25Sin) {
+    dft25Cos = new Float64Array(25 * 25);
+    dft25Sin = new Float64Array(25 * 25);
+    for (let k = 0; k < 25; k++) {
+      for (let j = 0; j < 25; j++) {
+        const angle = -2 * Math.PI * k * j / 25;
+        dft25Cos[k * 25 + j] = Math.cos(angle);
+        dft25Sin[k * 25 + j] = Math.sin(angle);
+      }
+    }
+  }
+  return { cos: dft25Cos, sin: dft25Sin };
+}
+var fftTwiddleCos = /* @__PURE__ */ new Map();
+var fftTwiddleSin = /* @__PURE__ */ new Map();
+var fftScratch = /* @__PURE__ */ new Map();
+function fftTables(n) {
+  let cos = fftTwiddleCos.get(n);
+  let sin = fftTwiddleSin.get(n);
+  if (!cos || !sin) {
+    const half = n / 2;
+    cos = new Float64Array(half);
+    sin = new Float64Array(half);
+    for (let k = 0; k < half; k++) {
+      const angle = -2 * Math.PI * k / n;
+      cos[k] = Math.cos(angle);
+      sin[k] = Math.sin(angle);
+    }
+    fftTwiddleCos.set(n, cos);
+    fftTwiddleSin.set(n, sin);
+  }
+  return { cos, sin };
+}
+function fftScratchFor(n) {
+  let bufs = fftScratch.get(n);
+  if (!bufs) {
+    bufs = [
+      new Float64Array(n),
+      new Float64Array(n),
+      new Float64Array(n),
+      new Float64Array(n)
+    ];
+    fftScratch.set(n, bufs);
+  }
+  return bufs;
+}
+var dft25OutRe = new Float64Array(25);
+var dft25OutIm = new Float64Array(25);
+function fftComplex(re, im) {
+  const n = re.length;
+  if (n === 25) {
+    const { cos: cos2, sin: sin2 } = dft25Tables();
+    for (let k = 0; k < 25; k++) {
+      let sumRe = 0;
+      let sumIm = 0;
+      const row = k * 25;
+      for (let j = 0; j < 25; j++) {
+        const c = cos2[row + j];
+        const s = sin2[row + j];
+        sumRe += re[j] * c - im[j] * s;
+        sumIm += re[j] * s + im[j] * c;
+      }
+      dft25OutRe[k] = sumRe;
+      dft25OutIm[k] = sumIm;
+    }
+    re.set(dft25OutRe);
+    im.set(dft25OutIm);
+    return;
+  }
+  if (n === 1) return;
+  const half = n / 2;
+  const [evenRe, evenIm, oddRe, oddIm] = fftScratchFor(half);
+  for (let i = 0; i < half; i++) {
+    evenRe[i] = re[2 * i];
+    evenIm[i] = im[2 * i];
+    oddRe[i] = re[2 * i + 1];
+    oddIm[i] = im[2 * i + 1];
+  }
+  fftComplex(evenRe.subarray(0, half), evenIm.subarray(0, half));
+  fftComplex(oddRe.subarray(0, half), oddIm.subarray(0, half));
+  const { cos, sin } = fftTables(n);
+  for (let k = 0; k < half; k++) {
+    const wr = cos[k];
+    const wi = sin[k];
+    const tr = wr * oddRe[k] - wi * oddIm[k];
+    const ti = wr * oddIm[k] + wi * oddRe[k];
+    re[k] = evenRe[k] + tr;
+    im[k] = evenIm[k] + ti;
+    re[k + half] = evenRe[k] - tr;
+    im[k + half] = evenIm[k] - ti;
+  }
+}
+function prepareInputWindow(samples) {
+  const out = new Float64Array(SMART_TURN_MAX_SAMPLES);
+  const n = samples.length;
+  if (n >= SMART_TURN_MAX_SAMPLES) {
+    const offset = n - SMART_TURN_MAX_SAMPLES;
+    for (let i = 0; i < SMART_TURN_MAX_SAMPLES; i++) out[i] = samples[offset + i];
+  } else {
+    const padding = SMART_TURN_MAX_SAMPLES - n;
+    for (let i = 0; i < n; i++) out[padding + i] = samples[i];
+  }
+  let mean = 0;
+  for (let i = 0; i < SMART_TURN_MAX_SAMPLES; i++) mean += out[i];
+  mean /= SMART_TURN_MAX_SAMPLES;
+  let variance = 0;
+  for (let i = 0; i < SMART_TURN_MAX_SAMPLES; i++) {
+    const d = out[i] - mean;
+    variance += d * d;
+  }
+  variance /= SMART_TURN_MAX_SAMPLES;
+  const scale = 1 / Math.sqrt(variance + NORM_EPS);
+  for (let i = 0; i < SMART_TURN_MAX_SAMPLES; i++) out[i] = (out[i] - mean) * scale;
+  return out;
+}
+async function computeWhisperLogMelFeatures(window) {
+  if (window.length !== SMART_TURN_MAX_SAMPLES) {
+    throw new Error(
+      `expected ${SMART_TURN_MAX_SAMPLES} samples, got ${window.length}; run prepareInputWindow() first`
+    );
+  }
+  const half = N_FFT / 2;
+  const paddedLen = SMART_TURN_MAX_SAMPLES + N_FFT;
+  const numBins = 1 + N_FFT / 2;
+  const padded = new Float64Array(paddedLen);
+  for (let i = 0; i < half; i++) padded[i] = window[half - i];
+  padded.set(window, half);
+  for (let i = 0; i < half; i++) {
+    padded[half + SMART_TURN_MAX_SAMPLES + i] = window[SMART_TURN_MAX_SAMPLES - 2 - i];
+  }
+  const hann = hannWindow();
+  const filters = melFilterbank();
+  const totalFrames = 1 + Math.floor((paddedLen - N_FFT) / HOP_LENGTH);
+  const logSpec = new Float64Array(N_MELS * N_FRAMES);
+  const re = new Float64Array(N_FFT);
+  const im = new Float64Array(N_FFT);
+  const power = new Float64Array(numBins);
+  let maxLog = -Infinity;
+  for (let t = 0; t < totalFrames - 1; t++) {
+    const start = t * HOP_LENGTH;
+    for (let j = 0; j < N_FFT; j++) {
+      re[j] = padded[start + j] * hann[j];
+      im[j] = 0;
+    }
+    fftComplex(re, im);
+    for (let k = 0; k < numBins; k++) {
+      power[k] = re[k] * re[k] + im[k] * im[k];
+    }
+    for (let m = 0; m < N_MELS; m++) {
+      const { startBin, weights } = filters[m];
+      let acc = 0;
+      for (let j = 0; j < weights.length; j++) {
+        acc += power[startBin + j] * weights[j];
+      }
+      const v = Math.log10(Math.max(acc, MEL_FLOOR));
+      logSpec[m * N_FRAMES + t] = v;
+      if (v > maxLog) maxLog = v;
+    }
+    if ((t & 127) === 127) {
+      await new Promise((resolve2) => setImmediate(resolve2));
+    }
+  }
+  const floor = maxLog - 8;
+  const out = new Float32Array(N_MELS * N_FRAMES);
+  for (let i = 0; i < logSpec.length; i++) {
+    out[i] = (Math.max(logSpec[i], floor) + 4) / 4;
+  }
+  return out;
+}
+async function featuresFromPcm16(pcm16Window) {
+  const numSamples = Math.floor(pcm16Window.length / 2);
+  const samples = new Float64Array(numSamples);
+  for (let i = 0; i < numSamples; i++) {
+    samples[i] = pcm16Window.readInt16LE(i * 2) / 32768;
+  }
+  return computeWhisperLogMelFeatures(prepareInputWindow(samples));
+}
+var SmartTurnDetector = class _SmartTurnDetector {
+  constructor(runtime, session, thresholdValue) {
+    this.runtime = runtime;
+    this.session = session;
+    this.thresholdValue = thresholdValue;
+  }
+  runtime;
+  session;
+  thresholdValue;
+  closed = false;
+  /**
+   * Load the smart-turn v3 ONNX model and return a ready detector.
+   * Throws with download instructions when no model file is configured
+   * (see {@link SMART_TURN_MODEL_ENV_VAR}), and with install instructions
+   * when `onnxruntime-node` is missing.
+   */
+  static async load(options = {}) {
+    const threshold = options.threshold ?? DEFAULT_SMART_TURN_THRESHOLD;
+    if (!(threshold >= 0 && threshold <= 1)) {
+      throw new Error("threshold must be within [0.0, 1.0]");
+    }
+    const modelPath = resolveSmartTurnModelPath(options.modelPath);
+    const runtime = await loadOnnxRuntime("SmartTurnDetector");
+    const session = await runtime.InferenceSession.create(modelPath, {
+      interOpNumThreads: 1,
+      intraOpNumThreads: 1,
+      executionMode: "sequential",
+      graphOptimizationLevel: "all",
+      executionProviders: options.forceCpu === false ? void 0 : ["cpu"]
+    });
+    return new _SmartTurnDetector(runtime, session, threshold);
+  }
+  /**
+   * Like {@link load}, but degrade instead of throw.
+   *
+   * Resolves to `undefined` — after a single clear warning — when semantic
+   * turn detection is not provisioned: the optional `onnxruntime-node`
+   * dependency is missing, no model file is configured, or the configured
+   * file cannot be loaded. Intended for deployments where the detector is
+   * a soft upgrade:
+   *
+   * ```ts
+   * const agent = phone.agent({
+   *   ...,
+   *   turnDetector: await SmartTurnDetector.maybeLoad(),
+   * });
+   * ```
+   *
+   * `turnDetector: undefined` keeps the plain VAD-silence endpointing, so
+   * the agent starts (and the call behaves) exactly as if the feature were
+   * never enabled — it never crashes the app.
+   *
+   * An out-of-range `threshold` still throws: that is a configuration bug,
+   * not a provisioning gap. Mirror of the Python
+   * `SmartTurnDetector.maybe_load`.
+   */
+  static async maybeLoad(options = {}) {
+    const threshold = options.threshold ?? DEFAULT_SMART_TURN_THRESHOLD;
+    if (!(threshold >= 0 && threshold <= 1)) {
+      throw new Error("threshold must be within [0.0, 1.0]");
+    }
+    try {
+      return await _SmartTurnDetector.load(options);
+    } catch (err) {
+      getLogger().warn(
+        `Semantic turn detection unavailable \u2014 falling back to plain VAD-silence endpointing: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Internal factory used by tests — bypasses onnxruntime-node loading.
+   * @internal
+   */
+  static fromOnnxSession(runtime, session, options = {}) {
+    return new _SmartTurnDetector(
+      runtime,
+      session,
+      options.threshold ?? DEFAULT_SMART_TURN_THRESHOLD
+    );
+  }
+  /** Identifier of the underlying model (`smart-turn-v3`). */
+  get model() {
+    return "smart-turn-v3";
+  }
+  /** Identifier of the runtime backend (`ONNX`). */
+  get provider() {
+    return "ONNX";
+  }
+  /** Input sample rate the model expects (16 000 Hz). */
+  get sampleRate() {
+    return SMART_TURN_SAMPLE_RATE;
+  }
+  /** Maximum audio context the model consumes per prediction (8 s). */
+  get maxWindowSeconds() {
+    return SMART_TURN_MAX_SECONDS;
+  }
+  /** End-of-turn probability at/above which the turn is complete. */
+  get threshold() {
+    return this.thresholdValue;
+  }
+  /**
+   * End-of-turn probability for the given recent-audio window.
+   *
+   * @param pcm16Window Mono int16 little-endian PCM at 16 kHz — ideally
+   *   the full audio of the caller's current turn, up to 8 s (the
+   *   handler keeps a rolling 8 s buffer). Longer input is truncated to
+   *   the most recent 8 s; shorter input is left-padded with silence,
+   *   matching the reference preprocessing exactly.
+   * @returns Probability in `[0, 1]` that the turn is COMPLETE (the
+   *   graph applies the sigmoid internally). Returns 0 for an empty
+   *   window.
+   */
+  async predict(pcm16Window) {
+    if (this.closed || this.session === null) {
+      throw new Error("SmartTurnDetector is closed");
+    }
+    if (pcm16Window.length < 2) {
+      return 0;
+    }
+    const features = await featuresFromPcm16(pcm16Window);
+    const { Tensor } = this.runtime;
+    const feeds = {
+      input_features: new Tensor("float32", features, [1, N_MELS, N_FRAMES])
+    };
+    const results = await this.session.run(feeds);
+    const first = Object.values(results)[0];
+    const data = first?.data;
+    const probability = data?.[0] ?? 0;
+    return Math.min(1, Math.max(0, probability));
+  }
+  /** Release the ONNX session. Idempotent. */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.session = null;
+  }
+};
+
 // src/providers/deepfilternet-filter.ts
 init_esm_shims();
 function log() {
   return getLogger();
 }
 var DEEPFILTERNET_SR = 48e3;
-async function loadOnnxRuntime() {
+async function loadOnnxRuntime2() {
   try {
     const specifier = "onnxruntime-node";
     const mod = await import(specifier);
@@ -8731,7 +9607,7 @@ var DeepFilterNetFilter = class {
       return null;
     }
     if (this.ort === null) {
-      this.ort = await loadOnnxRuntime();
+      this.ort = await loadOnnxRuntime2();
     }
     if (this.ort === null) {
       if (!this.warned && !this.silenceWarnings) {
@@ -9000,6 +9876,10 @@ var ChatContext = class _ChatContext {
     } else {
       this.items = maxMessages > 0 ? [...this.items.slice(-maxMessages)] : [];
     }
+    const start = this.items.length > 0 && this.items[0].role === "system" ? 1 : 0;
+    while (this.items.length > start && this.items[start].role === "tool") {
+      this.items.splice(start, 1);
+    }
   }
   // -------------------------------------------------------------------------
   // Provider format conversion
@@ -9035,6 +9915,10 @@ var ChatContext = class _ChatContext {
         }
         continue;
       }
+      if (msg.role === "tool") {
+        messages.push({ role: "user", content: `[tool result] ${msg.content}` });
+        continue;
+      }
       messages.push({ role: msg.role, content: msg.content });
     }
     return { system, messages };
@@ -9249,11 +10133,13 @@ var IVRActivity = class {
   }
   /** Record the current user-turn state (e.g. `"listening"`, `"away"`). */
   noteUserState(state) {
+    if (!this.started) return;
     this.currentUserState = state;
     this.scheduleSilenceCheck();
   }
   /** Record the current agent-turn state (e.g. `"idle"`, `"listening"`). */
   noteAgentState(state) {
+    if (!this.started) return;
     this.currentAgentState = state;
     this.scheduleSilenceCheck();
   }
@@ -9333,8 +10219,8 @@ var IVRActivity = class {
 
 // src/audio/background-audio.ts
 init_esm_shims();
-import { promises as fs3 } from "fs";
-import path2 from "path";
+import { promises as fs4 } from "fs";
+import path3 from "path";
 import { fileURLToPath } from "url";
 var BuiltinAudioClip = {
   CITY_AMBIENCE: "city-ambience.ogg",
@@ -9347,8 +10233,8 @@ var BuiltinAudioClip = {
 };
 function builtinClipPath(clip) {
   const meta = typeof import.meta !== "undefined" ? import.meta : void 0;
-  const here = meta?.url ? path2.dirname(fileURLToPath(meta.url)) : typeof __dirname !== "undefined" ? __dirname : process.cwd();
-  return path2.resolve(here, "..", "resources", "audio", clip);
+  const here = meta?.url ? path3.dirname(fileURLToPath(meta.url)) : typeof __dirname !== "undefined" ? __dirname : process.cwd();
+  return path3.resolve(here, "..", "resources", "audio", clip);
 }
 var INT16_MIN = -32768;
 var INT16_MAX = 32767;
@@ -9517,7 +10403,7 @@ var BackgroundAudioPlayer = class {
         return source.decode(source.path);
       case "builtin": {
         const p = builtinClipPath(source.clip);
-        const header = await fs3.readFile(p, { flag: "r" }).then((buf) => buf.subarray(0, 4));
+        const header = await fs4.readFile(p, { flag: "r" }).then((buf) => buf.subarray(0, 4));
         if (header.toString("ascii") !== "OggS") {
           throw new Error(`Bundled clip ${source.clip} is not a valid Ogg file`);
         }
@@ -9528,170 +10414,25 @@ var BackgroundAudioPlayer = class {
   applyGain(pcm, gain) {
     if (gain === 1) return pcm;
     const n = pcm.length >> 1;
-    const out = Buffer.allocUnsafe(pcm.length);
-    for (let i = 0; i < n; i++) {
-      out.writeInt16LE(clipInt16(Math.round(pcm.readInt16LE(i * 2) * gain)), i * 2);
-    }
-    return out;
-  }
-  resampleTo(dstSr) {
-    if (this.pcm === null) return Buffer.alloc(0);
-    if (dstSr === this.sourceSr) return this.pcm;
-    const cached = this.resampleCache.get(dstSr);
-    if (cached) return cached;
-    const resampled = resamplePcm(this.pcm, this.sourceSr, dstSr);
-    this.resampleCache.set(dstSr, resampled);
-    return resampled;
-  }
-};
-function isAudioConfig(value) {
-  return typeof value === "object" && value !== null && "source" in value && typeof value.source === "object";
-}
-
-// src/providers/twilio-adapter.ts
-init_esm_shims();
-var TWILIO_API_BASE = "https://api.twilio.com/2010-04-01";
-var TwilioAdapter = class _TwilioAdapter {
-  accountSid;
-  region;
-  baseUrl;
-  authHeader;
-  constructor(accountSid, authToken, opts = {}) {
-    if (!accountSid) throw new Error("TwilioAdapter: accountSid is required");
-    if (!authToken) throw new Error("TwilioAdapter: authToken is required");
-    this.accountSid = accountSid;
-    this.region = opts.region;
-    this.baseUrl = opts.region ? `https://api.${opts.region}.twilio.com/2010-04-01` : TWILIO_API_BASE;
-    this.authHeader = `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`;
-  }
-  async request(method, path3, body) {
-    const url = `${this.baseUrl}/Accounts/${encodeURIComponent(this.accountSid)}${path3}`;
-    const headers = { Authorization: this.authHeader };
-    if (body) headers["Content-Type"] = "application/x-www-form-urlencoded";
-    const response = await fetch(url, {
-      method,
-      headers,
-      body: body ? body.toString() : void 0,
-      signal: AbortSignal.timeout(3e4)
-    });
-    const text = await response.text();
-    if (!response.ok) {
-      throw new Error(`Twilio ${method} ${path3} failed: ${response.status} ${text}`);
-    }
-    if (!text) return {};
-    try {
-      return JSON.parse(text);
-    } catch (e) {
-      throw new Error(`Twilio returned non-JSON response: ${String(e)}`);
-    }
-  }
-  /**
-   * Provision a local phone number in the given country.
-   *
-   * Lists available local numbers, then purchases the first match.
-   */
-  async provisionNumber(opts) {
-    const country = encodeURIComponent(opts.countryCode);
-    const queryParts = ["PageSize=1"];
-    if (opts.areaCode) queryParts.push(`AreaCode=${encodeURIComponent(opts.areaCode)}`);
-    const path3 = `/AvailablePhoneNumbers/${country}/Local.json?${queryParts.join("&")}`;
-    const available = await this.request("GET", path3);
-    const first = available.available_phone_numbers?.[0]?.phone_number;
-    if (!first) {
-      throw new Error(`TwilioAdapter: no numbers available for country ${opts.countryCode}`);
-    }
-    const body = new URLSearchParams({ PhoneNumber: first });
-    const purchased = await this.request(
-      "POST",
-      "/IncomingPhoneNumbers.json",
-      body
-    );
-    if (!purchased.sid || !purchased.phone_number) {
-      throw new Error("TwilioAdapter: malformed response from IncomingPhoneNumbers.create");
-    }
-    return { phoneNumber: purchased.phone_number, sid: purchased.sid };
-  }
-  /** Update an already-purchased number to point at our voice webhook. */
-  async configureNumber(phoneNumberSid, opts) {
-    if (!phoneNumberSid) throw new Error("TwilioAdapter: phoneNumberSid is required");
-    const body = new URLSearchParams({
-      VoiceUrl: opts.voiceUrl,
-      VoiceMethod: "POST"
-    });
-    if (opts.statusCallback) body.set("StatusCallback", opts.statusCallback);
-    await this.request(
-      "POST",
-      `/IncomingPhoneNumbers/${encodeURIComponent(phoneNumberSid)}.json`,
-      body
-    );
-  }
-  /** Place an outbound call. Returns the Twilio call SID. */
-  async initiateCall(opts) {
-    if (!opts.url && !opts.streamUrl) {
-      throw new Error("TwilioAdapter: initiateCall requires either url or streamUrl");
-    }
-    const body = new URLSearchParams({
-      From: opts.from,
-      To: opts.to
-    });
-    if (opts.url) {
-      body.set("Url", opts.url);
-    } else if (opts.streamUrl) {
-      body.set("Twiml", _TwilioAdapter.generateStreamTwiml(opts.streamUrl));
-    }
-    if (opts.statusCallback) body.set("StatusCallback", opts.statusCallback);
-    if (opts.machineDetection) body.set("MachineDetection", opts.machineDetection);
-    if (opts.extraParams) {
-      for (const [key, value] of Object.entries(opts.extraParams)) {
-        body.set(key, value);
-      }
-    }
-    const call = await this.request("POST", "/Calls.json", body);
-    if (!call.sid) {
-      throw new Error("TwilioAdapter: Calls.create returned no SID");
-    }
-    return { callSid: call.sid };
-  }
-  /**
-   * Build a ``<Response><Connect><Stream url="...">`` TwiML document.
-   *
-   * ``parameters`` is forwarded as ``<Parameter name="..." value="..."/>``
-   * children of ``<Stream>``. Twilio Media Streams strips query-string params
-   * from the ``<Stream url=...>`` before the WS handshake, so
-   * ``<Parameter>`` tags are the supported way to pre-populate
-   * ``start.customParameters`` on the WS ``start`` frame. Used by the
-   * inbound path to carry caller / callee through to the bridge.
-   *
-   * Mirrors the Python adapter's ``generate_stream_twiml``.
-   */
-  static generateStreamTwiml(streamUrl, parameters) {
-    const esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-    const escapedUrl = esc(streamUrl);
-    let paramTags = "";
-    if (parameters) {
-      for (const [name, value] of Object.entries(parameters)) {
-        if (value == null) continue;
-        paramTags += `<Parameter name="${esc(name)}" value="${esc(String(value))}"/>`;
-      }
+    const out = Buffer.allocUnsafe(pcm.length);
+    for (let i = 0; i < n; i++) {
+      out.writeInt16LE(clipInt16(Math.round(pcm.readInt16LE(i * 2) * gain)), i * 2);
     }
-    return `<?xml version="1.0" encoding="UTF-8"?><Response><Connect><Stream url="${escapedUrl}">${paramTags}</Stream></Connect></Response>`;
+    return out;
   }
-  /** Force-complete an in-progress call. */
-  async endCall(callSid) {
-    if (!callSid) throw new Error("TwilioAdapter: callSid is required");
-    const body = new URLSearchParams({ Status: "completed" });
-    try {
-      await this.request(
-        "POST",
-        `/Calls/${encodeURIComponent(callSid)}.json`,
-        body
-      );
-    } catch (err) {
-      getLogger().warn(`[TwilioAdapter] endCall failed for ${callSid}: ${String(err)}`);
-      throw err;
-    }
+  resampleTo(dstSr) {
+    if (this.pcm === null) return Buffer.alloc(0);
+    if (dstSr === this.sourceSr) return this.pcm;
+    const cached = this.resampleCache.get(dstSr);
+    if (cached) return cached;
+    const resampled = resamplePcm(this.pcm, this.sourceSr, dstSr);
+    this.resampleCache.set(dstSr, resampled);
+    return resampled;
   }
 };
+function isAudioConfig(value) {
+  return typeof value === "object" && value !== null && "source" in value && typeof value.source === "object";
+}
 
 // src/providers/telnyx-adapter.ts
 init_esm_shims();
@@ -9706,8 +10447,8 @@ var TelnyxAdapter = class {
     this.apiKey = apiKey;
     this.connectionId = connectionId;
   }
-  async request(method, path3, body) {
-    const url = `${this.baseUrl}${path3}`;
+  async request(method, path4, body) {
+    const url = `${this.baseUrl}${path4}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`
     };
@@ -9720,7 +10461,7 @@ var TelnyxAdapter = class {
     });
     const text = await response.text();
     if (!response.ok) {
-      throw new Error(`Telnyx ${method} ${path3} failed: ${response.status} ${text}`);
+      throw new Error(`Telnyx ${method} ${path4} failed: ${response.status} ${text}`);
     }
     if (!text) return {};
     try {
@@ -9761,10 +10502,15 @@ var TelnyxAdapter = class {
     if (!phoneNumber) throw new Error("TelnyxAdapter: phoneNumber is required");
     if (!opts.connectionId) throw new Error("TelnyxAdapter: connectionId is required");
     try {
+      await this.request(
+        "PATCH",
+        `/phone_numbers/${encodeURIComponent(phoneNumber)}`,
+        { connection_id: opts.connectionId }
+      );
       await this.request(
         "PATCH",
         `/phone_numbers/${encodeURIComponent(phoneNumber)}/voice`,
-        { connection_id: opts.connectionId, tech_prefix_enabled: false }
+        { tech_prefix_enabled: false }
       );
     } catch (err) {
       const status = err instanceof Error ? err.message.replace(/\+\d{7,15}/g, "[REDACTED]") : String(err);
@@ -9864,6 +10610,7 @@ var TelnyxSTT = class {
     this.transcriptionEngine = transcriptionEngine;
     this.sampleRate = sampleRate;
     this.baseUrl = baseUrl;
+    this.patterCtorArgs = [apiKey, language, transcriptionEngine, sampleRate, baseUrl];
   }
   apiKey;
   language;
@@ -9875,6 +10622,17 @@ var TelnyxSTT = class {
   ws = null;
   callbacks = /* @__PURE__ */ new Set();
   headerSent = false;
+  /** Construction args replayed by clone(). */
+  patterCtorArgs;
+  /**
+   * Fresh adapter built with this instance's construction arguments —
+   * called per call by the stream handler so concurrent calls never share
+   * connection state (sockets/queues; cross-call transcript bleed).
+   */
+  clone() {
+    const ctor = this.constructor;
+    return new ctor(...this.patterCtorArgs);
+  }
   /** Open the streaming WebSocket and arm message handlers. */
   async connect() {
     const params = new URLSearchParams({
@@ -9886,11 +10644,11 @@ var TelnyxSTT = class {
     this.ws = new WebSocket7(url, {
       headers: { Authorization: `Bearer ${this.apiKey}` }
     });
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       const timer = setTimeout(() => reject(new Error("Telnyx STT connect timeout")), 1e4);
       this.ws.once("open", () => {
         clearTimeout(timer);
-        resolve();
+        resolve2();
       });
       this.ws.once("error", (err) => {
         clearTimeout(timer);
@@ -9912,7 +10670,13 @@ var TelnyxSTT = class {
         confidence: data.confidence ?? 0
       };
       for (const cb of this.callbacks) {
-        cb(transcript);
+        try {
+          Promise.resolve(cb(transcript)).catch(
+            (err) => getLogger().error(`STT transcript callback failed: ${String(err)}`)
+          );
+        } catch (err) {
+          getLogger().error(`STT transcript callback threw: ${String(err)}`);
+        }
       }
     });
     this.ws.on("error", (err) => {
@@ -10009,11 +10773,11 @@ var TelnyxTTS = class {
       ws = new WebSocket8(url, {
         headers: { Authorization: `Bearer ${this.apiKey}` }
       });
-      await new Promise((resolve, reject) => {
+      await new Promise((resolve2, reject) => {
         const timer = setTimeout(() => reject(new Error("Telnyx TTS connect timeout")), 1e4);
         ws.once("open", () => {
           clearTimeout(timer);
-          resolve();
+          resolve2();
         });
         ws.once("error", (err) => {
           clearTimeout(timer);
@@ -10052,7 +10816,7 @@ var TelnyxTTS = class {
       while (true) {
         let frameTimer;
         const item = queue.length > 0 ? queue.shift() : await Promise.race([
-          new Promise((resolve) => waiters.push(resolve)),
+          new Promise((resolve2) => waiters.push(resolve2)),
           new Promise((_, reject) => {
             frameTimer = setTimeout(
               () => reject(new Error("Telnyx TTS frame timeout")),
@@ -10076,15 +10840,682 @@ var TelnyxTTS = class {
   }
 };
 
+// src/evals/index.ts
+init_esm_shims();
+
+// src/evals/case.ts
+init_esm_shims();
+function evalResultToDict(result) {
+  return {
+    case: result.caseName,
+    score: result.judge.score,
+    passed: result.judge.passed,
+    reasoning: result.judge.reasoning,
+    transcript: result.transcript.map((t) => ({ role: t.role, text: t.text })),
+    duration_s: Math.round(result.durationS * 1e3) / 1e3,
+    error: result.error
+  };
+}
+
+// src/evals/llm-judge.ts
+init_esm_shims();
+var JUDGE_SYSTEM = 'You are a strict but fair evaluator of voice-AI agents. You will be given: (1) the expected behavior for the agent, (2) a rubric, (3) a transcript of the conversation. Return a JSON object with exactly three keys:\n  - "score": float between 0.0 and 1.0\n  - "passed": boolean (true when score >= threshold)\n  - "reasoning": short string explaining the score\nDo not return any text outside the JSON object.';
+var LLMJudge = class {
+  model;
+  passThreshold;
+  apiKey;
+  backend;
+  constructor(options = {}) {
+    this.model = options.model ?? "gpt-4o-mini";
+    this.apiKey = options.apiKey;
+    this.passThreshold = options.passThreshold ?? 0.7;
+    this.backend = options.backend;
+  }
+  /** Return a {@link JudgeResult} for the given transcript. */
+  async judgeCase(evalCase, transcript) {
+    const prompt = this.buildPrompt(evalCase, transcript);
+    const raw = this.backend ? await this.backend.judge(prompt) : await this.callOpenAI(prompt);
+    return this.parse(raw);
+  }
+  buildPrompt(evalCase, transcript) {
+    const lines = [
+      `EXPECTED BEHAVIOR: ${evalCase.expectedBehavior}`,
+      `RUBRIC: ${evalCase.rubric}`,
+      `PASS THRESHOLD: ${this.passThreshold}`,
+      "TRANSCRIPT:"
+    ];
+    for (const turn of transcript) {
+      lines.push(`  ${turn.role || "?"}: ${turn.text ?? ""}`);
+    }
+    return lines.join("\n");
+  }
+  /** Call OpenAI chat completions directly over fetch (no SDK dependency). */
+  async callOpenAI(prompt) {
+    const apiKey = this.apiKey || process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "LLMJudge requires an OpenAI API key. Set OPENAI_API_KEY or pass apiKey to the LLMJudge constructor."
+      );
+    }
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages: [
+          { role: "system", content: JUDGE_SYSTEM },
+          { role: "user", content: prompt }
+        ],
+        response_format: { type: "json_object" },
+        temperature: 0
+      })
+    });
+    if (!response.ok) {
+      const errText = await response.text();
+      throw new Error(`LLMJudge OpenAI call failed: ${response.status} ${errText.slice(0, 200)}`);
+    }
+    const data = await response.json();
+    const content = data.choices?.[0]?.message?.content;
+    if (!content) {
+      throw new Error(
+        `LLMJudge response had no choices/content: ${JSON.stringify(data).slice(0, 200)}`
+      );
+    }
+    return content;
+  }
+  /** Parse the judge's JSON — tolerant of extra whitespace / code fences. */
+  parse(raw) {
+    let text = raw.trim();
+    if (text.startsWith("```")) {
+      text = text.replace(/^```(?:json)?\s*/, "").replace(/\s*```$/, "");
+    }
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      getLogger().warn(`LLMJudge: invalid JSON, defaulting to fail: ${JSON.stringify(raw)}`);
+      return {
+        score: 0,
+        passed: false,
+        reasoning: `Judge returned invalid JSON: ${raw.slice(0, 200)}`
+      };
+    }
+    const scoreRaw = Number(data.score ?? 0);
+    let score = Number.isFinite(scoreRaw) ? scoreRaw : 0;
+    score = Math.max(0, Math.min(1, score));
+    const passed = score >= this.passThreshold;
+    const reasoning = String(data.reasoning ?? "");
+    return { score, passed, reasoning };
+  }
+};
+
+// src/evals/runner.ts
+init_esm_shims();
+import { readFile } from "fs/promises";
+import { extname, basename } from "path";
+var EvalRunner = class {
+  judge;
+  constructor(options = {}) {
+    this.judge = options.judge ?? new LLMJudge();
+  }
+  /**
+   * Run every case in ``suite`` sequentially.
+   *
+   * ``agentFactory`` is required only for cases that do NOT carry their own
+   * ``agent`` (the legacy ``reply()`` path).
+   */
+  async run(suite, agentFactory) {
+    const results = [];
+    for (const evalCase of suite.cases) {
+      results.push(await this.runCase(evalCase, agentFactory));
+    }
+    return results;
+  }
+  /**
+   * Run a single case and return its {@link EvalResult}.
+   *
+   * Routes through the real-pipeline {@link EvalSession} when
+   * ``evalCase.agent`` is set; otherwise uses the legacy ``reply()``-callable
+   * ``agentFactory`` (unchanged behaviour).
+   */
+  async runCase(evalCase, agentFactory) {
+    const start = Date.now();
+    const transcript = [];
+    let error = null;
+    try {
+      if (evalCase.agent !== void 0) {
+        await this.runTurnsWithSession(evalCase, transcript);
+      } else {
+        if (agentFactory === void 0) {
+          throw new Error(
+            `case ${JSON.stringify(evalCase.name)} has no agent and no agentFactory was supplied`
+          );
+        }
+        await this.runTurnsWithReply(evalCase, agentFactory, transcript);
+      }
+    } catch (exc) {
+      error = formatError(exc);
+      getLogger().error(`eval case=${JSON.stringify(evalCase.name)} raised: ${error}`);
+    }
+    if (error !== null && transcript.length === 0) {
+      return {
+        caseName: evalCase.name,
+        transcript,
+        judge: { score: 0, passed: false, reasoning: error },
+        durationS: (Date.now() - start) / 1e3,
+        error
+      };
+    }
+    let judgeResult;
+    try {
+      judgeResult = await this.judge.judgeCase(evalCase, transcript);
+    } catch (exc) {
+      const judgeError = `judge error: ${exc instanceof Error ? exc.message : String(exc)}`;
+      return {
+        caseName: evalCase.name,
+        transcript,
+        judge: { score: 0, passed: false, reasoning: judgeError },
+        durationS: (Date.now() - start) / 1e3,
+        error: judgeError
+      };
+    }
+    return {
+      caseName: evalCase.name,
+      transcript,
+      judge: judgeResult,
+      durationS: (Date.now() - start) / 1e3,
+      error
+    };
+  }
+  /**
+   * Legacy path — drives the case against a ``reply()`` callable.
+   *
+   * Appends into ``transcript`` in place so a mid-case exception still
+   * leaves the partial transcript for the judge (existing semantics).
+   */
+  async runTurnsWithReply(evalCase, agentFactory, transcript) {
+    const agent = await agentFactory();
+    if (evalCase.firstMessage) {
+      transcript.push({ role: "agent", text: evalCase.firstMessage });
+    }
+    for (const turn of evalCase.turns) {
+      transcript.push({ role: "user", text: turn.user });
+      const reply = typeof agent === "function" ? await agent(turn.user) : "";
+      transcript.push({ role: "agent", text: reply || "" });
+      logMissingExpected(evalCase, turn, reply || "");
+    }
+  }
+  /**
+   * Real-pipeline path — drives the case through {@link EvalSession}.
+   *
+   * The agent's REAL handler emits its own ``firstMessage`` (a
+   * ``evalCase.firstMessage`` overrides the agent's), tools/hooks/guardrails
+   * run for real, and the transcript mirrors what the pipeline actually
+   * said. Appends into ``transcript`` in place (partial-on-error, same as
+   * the legacy path).
+   */
+  async runTurnsWithSession(evalCase, transcript) {
+    const { EvalSession: EvalSession2 } = await import("./session-N3CBCYYN.mjs");
+    if (!evalCase.agent) {
+      throw new Error(`case ${JSON.stringify(evalCase.name)} has no agent \u2014 use the reply-factory path`);
+    }
+    let agent = evalCase.agent;
+    if (evalCase.firstMessage) {
+      agent = { ...agent, firstMessage: evalCase.firstMessage };
+    }
+    const session = await EvalSession2.create({
+      agent,
+      llmProvider: evalCase.llmProvider
+    });
+    try {
+      if (agent.firstMessage) {
+        transcript.push({ role: "agent", text: agent.firstMessage });
+      }
+      for (const turn of evalCase.turns) {
+        transcript.push({ role: "user", text: turn.user });
+        const result = await session.userSays(turn.user);
+        transcript.push({ role: "agent", text: result.agentText });
+        logMissingExpected(evalCase, turn, result.agentText);
+      }
+    } finally {
+      await session.close();
+    }
+  }
+  /** Render a JSON report suitable for CI artefacts. */
+  report(suite, results) {
+    const total = results.length;
+    const passed = results.filter((r) => r.judge.passed).length;
+    const payload = {
+      suite: suite.name,
+      total,
+      passed,
+      failed: total - passed,
+      pass_rate: total > 0 ? passed / total : 0,
+      cases: results.map((r) => evalResultToDict(r))
+    };
+    return JSON.stringify(payload, null, 2);
+  }
+};
+function formatError(exc) {
+  if (exc instanceof Error) {
+    return `${exc.name}: ${exc.message}`;
+  }
+  return String(exc);
+}
+function logMissingExpected(evalCase, turn, reply) {
+  for (const needle of turn.expectedContains ?? []) {
+    if (!reply.toLowerCase().includes(needle.toLowerCase())) {
+      getLogger().info(
+        `case=${JSON.stringify(evalCase.name)} expectedContains=${JSON.stringify(needle)} missing in reply`
+      );
+    }
+  }
+}
+async function loadSuite(path4) {
+  const text = await readFile(path4, "utf-8");
+  const ext = extname(path4).toLowerCase();
+  let data;
+  if (ext === ".yaml" || ext === ".yml") {
+    let yaml;
+    try {
+      const moduleName = "yaml";
+      yaml = await import(moduleName);
+    } catch {
+      throw new Error(
+        "Loading YAML suites requires the optional 'yaml' package. Install with: npm install yaml \u2014 or use a JSON suite file."
+      );
+    }
+    data = yaml.parse(text);
+  } else {
+    data = JSON.parse(text);
+  }
+  if (data === null || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error(`Eval suite ${path4} must be a mapping, got ${typeOf(data)}`);
+  }
+  const record = data;
+  const casesRaw = record.cases ?? [];
+  if (!Array.isArray(casesRaw)) {
+    throw new Error(`Eval suite ${path4}: 'cases' must be a list`);
+  }
+  const cases = casesRaw.map((c, i) => {
+    if (c === null || typeof c !== "object" || Array.isArray(c)) {
+      throw new Error(`Eval suite ${path4}: case ${i} must be a mapping`);
+    }
+    const caseRecord = c;
+    const turnsRaw = caseRecord.turns ?? [];
+    const turns = (Array.isArray(turnsRaw) ? turnsRaw : []).filter((t) => t !== null && typeof t === "object").map((t) => ({
+      user: String(t.user ?? ""),
+      expectedContains: toStringArray(t.expected_contains ?? t.expectedContains)
+    }));
+    return {
+      name: String(caseRecord.name ?? `case_${i}`),
+      turns,
+      expectedBehavior: String(caseRecord.expected_behavior ?? caseRecord.expectedBehavior ?? ""),
+      rubric: String(caseRecord.rubric ?? ""),
+      tags: toStringArray(caseRecord.tags),
+      firstMessage: String(caseRecord.first_message ?? caseRecord.firstMessage ?? "")
+    };
+  });
+  return {
+    name: String(record.name ?? basename(path4, extname(path4))),
+    cases,
+    metadata: record.metadata ?? {}
+  };
+}
+function toStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((v) => String(v));
+}
+function typeOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+
+// src/evals/scripted-llm.ts
+init_esm_shims();
+function textTurn(text, options = {}) {
+  return [
+    { type: "text", content: text },
+    {
+      type: "usage",
+      inputTokens: options.inputTokens ?? 8,
+      outputTokens: options.outputTokens ?? 8
+    }
+  ];
+}
+function toolCallTurn(name, args, options = {}) {
+  return [
+    {
+      type: "tool_call",
+      index: 0,
+      id: options.callId ?? "call_1",
+      name,
+      arguments: JSON.stringify(args ?? {})
+    },
+    { type: "usage", inputTokens: 8, outputTokens: 4 }
+  ];
+}
+var ScriptedLLMProvider = class {
+  /** Stable pricing/dashboard key (no real pricing entry — cost is 0). */
+  static providerKey = "scripted";
+  calls = [];
+  scripts;
+  constructor(turns) {
+    this.scripts = (turns ?? []).map((chunks) => chunks.map((c) => ({ ...c })));
+  }
+  /** Append another scripted turn (chunk list) to the script queue. */
+  addTurn(chunks) {
+    this.scripts.push(chunks.map((c) => ({ ...c })));
+  }
+  async *stream(messages, tools, opts) {
+    this.calls.push({
+      messages: messages.map((m) => ({ ...m })),
+      tools: tools ? tools.map((t) => ({ ...t })) : null,
+      callId: opts?.callId ?? null
+    });
+    const script = this.scripts.shift();
+    if (script === void 0) {
+      yield { type: "done" };
+      return;
+    }
+    for (const chunk of script) {
+      if (opts?.signal?.aborted) return;
+      yield { ...chunk };
+    }
+  }
+};
+
+// src/evals/assertions.ts
+init_esm_shims();
+import { AssertionError } from "assert";
+function expect(result) {
+  return new TurnExpectation(result);
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+  }
+  if (a !== null && b !== null && typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b)) {
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    return ak.length === bk.length && ak.every(
+      (k) => deepEqual(a[k], b[k])
+    );
+  }
+  return false;
+}
+function isSubset(subset, actual) {
+  if (subset !== null && typeof subset === "object" && !Array.isArray(subset)) {
+    if (actual === null || typeof actual !== "object" || Array.isArray(actual)) {
+      return false;
+    }
+    const actualRecord = actual;
+    return Object.entries(subset).every(
+      ([key, value]) => key in actualRecord && isSubset(value, actualRecord[key])
+    );
+  }
+  return deepEqual(subset, actual);
+}
+var TurnExpectation = class {
+  turnResult;
+  constructor(result) {
+    this.turnResult = result;
+  }
+  /** The wrapped {@link TurnResult} (escape hatch for ad-hoc asserts). */
+  get result() {
+    return this.turnResult;
+  }
+  // -- tools -----------------------------------------------------------------
+  /**
+   * Assert that tool ``name`` ran this turn.
+   *
+   * ``argsSubset`` (optional) must be recursively contained in the args of
+   * at least one matching invocation — extra argument keys are allowed,
+   * listed keys must match exactly.
+   */
+  toolCalled(name, argsSubset) {
+    const matches = this.turnResult.toolCalls.filter((tc) => tc.name === name);
+    if (matches.length === 0) {
+      const called = this.turnResult.toolCalls.map((tc) => tc.name);
+      throw new AssertionError({
+        message: `expected tool ${JSON.stringify(name)} to be called this turn; tools called: ${called.length > 0 ? JSON.stringify(called) : "none"}`
+      });
+    }
+    if (argsSubset !== void 0 && !matches.some((tc) => isSubset(argsSubset, tc.arguments))) {
+      throw new AssertionError({
+        message: `tool ${JSON.stringify(name)} was called, but no invocation matched argsSubset=${JSON.stringify(argsSubset)}; observed args: ` + JSON.stringify(matches.map((tc) => tc.arguments))
+      });
+    }
+    return this;
+  }
+  /** Assert that no tool ran this turn (or that ``name`` did not). */
+  noToolCalled(name) {
+    if (name === void 0) {
+      if (this.turnResult.toolCalls.length > 0) {
+        throw new AssertionError({
+          message: "expected no tool calls this turn; tools called: " + JSON.stringify(this.turnResult.toolCalls.map((tc) => tc.name))
+        });
+      }
+      return this;
+    }
+    const offenders = this.turnResult.toolCalls.filter((tc) => tc.name === name);
+    if (offenders.length > 0) {
+      throw new AssertionError({
+        message: `expected tool ${JSON.stringify(name)} NOT to be called this turn; it ran ${offenders.length} time(s) with args ` + JSON.stringify(offenders.map((tc) => tc.arguments))
+      });
+    }
+    return this;
+  }
+  agentTextContains(first, ...rest) {
+    let needles;
+    let caseSensitive = false;
+    if (Array.isArray(first)) {
+      needles = [...first];
+      const options = rest[0];
+      caseSensitive = options?.caseSensitive ?? false;
+    } else {
+      needles = [first, ...rest].filter(
+        (n) => typeof n === "string"
+      );
+    }
+    const haystack = this.turnResult.agentText;
+    const cmpHaystack = caseSensitive ? haystack : haystack.toLowerCase();
+    const missing = needles.filter(
+      (n) => !cmpHaystack.includes(caseSensitive ? n : n.toLowerCase())
+    );
+    if (missing.length > 0) {
+      throw new AssertionError({
+        message: `agent text is missing ${JSON.stringify(missing)}; agent said: ` + JSON.stringify(haystack)
+      });
+    }
+    return this;
+  }
+  // -- semantic judge ----------------------------------------------------------
+  /**
+   * Score this turn against ``intent`` with the LLM judge.
+   *
+   * Builds a synthetic {@link EvalCase} whose ``expectedBehavior`` is
+   * ``intent`` and judges the turn's full history snapshot. Throws
+   * ``AssertionError`` when the judge fails the turn; returns the
+   * {@link JudgeResult} otherwise (chain-ending, async).
+   */
+  async judge(llmJudge, options) {
+    const { intent, rubric } = options;
+    const evalCase = {
+      name: "inline-judge",
+      turns: [],
+      expectedBehavior: intent,
+      rubric: rubric ?? `Pass when the agent's behavior matches: ${intent}`
+    };
+    const transcript = historyTranscript(this.turnResult.historySnapshot);
+    const verdict = await llmJudge.judgeCase(evalCase, transcript);
+    getLogger().info(
+      `judge intent=${JSON.stringify(intent)} score=${verdict.score.toFixed(2)} passed=${verdict.passed}`
+    );
+    if (!verdict.passed) {
+      throw new AssertionError({
+        message: `LLM judge failed the turn (score=${verdict.score.toFixed(2)}): ${verdict.reasoning} \u2014 intent was ${JSON.stringify(intent)}; agent said ` + JSON.stringify(this.turnResult.agentText)
+      });
+    }
+    return verdict;
+  }
+};
+
 // src/observability/index.ts
 init_esm_shims();
 
+// src/observability/attributes.ts
+init_esm_shims();
+var DEFAULT_SIDE = "uut";
+var _scopeStack = [];
+function _currentScope() {
+  return _scopeStack.length > 0 ? _scopeStack[_scopeStack.length - 1] : null;
+}
+function _tryLoadOtelApi() {
+  try {
+    return __require("@opentelemetry/api");
+  } catch {
+    return null;
+  }
+}
+function recordPatterAttrs(attrs) {
+  if (!isTracingEnabled()) return;
+  const scope = _currentScope();
+  if (scope === null) return;
+  const api = _tryLoadOtelApi();
+  if (!api) return;
+  const full = { ...attrs };
+  if (full["patter.call_id"] === void 0) full["patter.call_id"] = scope.callId;
+  if (full["patter.side"] === void 0) full["patter.side"] = scope.side;
+  try {
+    const active = api.trace.getActiveSpan?.() ?? null;
+    if (active && (active.isRecording === void 0 || active.isRecording())) {
+      for (const [k, v] of Object.entries(full)) {
+        try {
+          active.setAttribute(k, v);
+        } catch {
+        }
+      }
+      return;
+    }
+  } catch {
+  }
+  try {
+    const tracer = api.trace.getTracer("getpatter.observability");
+    const span = tracer.startSpan("patter.billable", { attributes: full });
+    try {
+      span.end();
+    } catch {
+    }
+  } catch {
+  }
+}
+async function patterCallScope(options, fn) {
+  if (!options.callId) {
+    throw new Error("patterCallScope requires non-empty callId");
+  }
+  const frame = {
+    callId: options.callId,
+    side: options.side ?? DEFAULT_SIDE
+  };
+  _scopeStack.push(frame);
+  try {
+    return await fn();
+  } finally {
+    const idx = _scopeStack.lastIndexOf(frame);
+    if (idx >= 0) _scopeStack.splice(idx, 1);
+  }
+}
+function attachSpanExporter(patterInstance, exporter, options = {}) {
+  const side = options.side ?? DEFAULT_SIDE;
+  patterInstance._patterSide = side;
+  if (!isTracingEnabled()) {
+    getLogger().debug(
+      `attachSpanExporter: ${ENV_FLAG} not enabled or tracer unavailable; only side= stored`
+    );
+    return;
+  }
+  let sdkTraceBase = null;
+  let sdkTraceNode = null;
+  try {
+    sdkTraceBase = __require("@opentelemetry/sdk-trace-base");
+  } catch {
+    sdkTraceBase = null;
+  }
+  try {
+    sdkTraceNode = __require("@opentelemetry/sdk-trace-node");
+  } catch {
+    sdkTraceNode = null;
+  }
+  if (!sdkTraceBase) {
+    getLogger().warn(
+      "attachSpanExporter: @opentelemetry/sdk-trace-base is not installed; spans will not be exported. Install @opentelemetry/sdk-trace-base + @opentelemetry/sdk-trace-node."
+    );
+    return;
+  }
+  const api = _tryLoadOtelApi();
+  if (!api) return;
+  let provider = null;
+  try {
+    const tracerApi = api.trace;
+    const existing = tracerApi.getTracerProvider?.() ?? null;
+    if (existing && typeof existing.addSpanProcessor === "function") {
+      provider = existing;
+    }
+  } catch {
+    provider = null;
+  }
+  if (!provider) {
+    if (!sdkTraceNode) {
+      getLogger().warn(
+        "attachSpanExporter: no SDK TracerProvider registered and @opentelemetry/sdk-trace-node is not installed; cannot wire exporter."
+      );
+      return;
+    }
+    try {
+      provider = new sdkTraceNode.NodeTracerProvider();
+      const trace = api.trace;
+      trace.setGlobalTracerProvider?.(provider);
+    } catch (e) {
+      getLogger().debug(
+        `attachSpanExporter: failed to construct NodeTracerProvider: ${String(
+          e?.message ?? e
+        )}`
+      );
+      return;
+    }
+  }
+  let seen = provider._patterAttachedExporters;
+  if (!seen) {
+    seen = /* @__PURE__ */ new Set();
+    provider._patterAttachedExporters = seen;
+  }
+  if (seen.has(exporter)) return;
+  try {
+    const processor = new sdkTraceBase.SimpleSpanProcessor(exporter);
+    provider.addSpanProcessor?.(processor);
+    seen.add(exporter);
+  } catch (e) {
+    getLogger().debug(
+      `attachSpanExporter: failed to register exporter: ${String(
+        e?.message ?? e
+      )}`
+    );
+  }
+}
+
 // src/index.ts
 var hermes = Object.freeze({ LLM: LLM8 });
 var openclaw = Object.freeze({ LLM: LLM9 });
 var openaiCompatible = Object.freeze({ LLM: LLM6 });
 var custom = Object.freeze({ LLM: LLM7 });
 export {
+  AGENT_BACKLOG_CAP_S,
   AllProvidersFailedError,
   LLM2 as AnthropicLLM,
   STT6 as AssemblyAISTT,
@@ -10115,7 +11546,12 @@ export {
   TTS as ElevenLabsTTS,
   TTS2 as ElevenLabsWebSocketTTS,
   ErrorCode,
+  EvalRunner,
+  EvalSession,
   EventBus,
+  FakeAudioSender,
+  FakeSTT,
+  FakeTTS,
   FallbackLLMProvider,
   GEMINI_DEFAULT_INPUT_SR,
   GEMINI_DEFAULT_OUTPUT_SR,
@@ -10129,8 +11565,10 @@ export {
   KrispFrameDuration,
   KrispSampleRate,
   KrispVivaFilter,
+  LLMJudge,
   LLMLoop,
   TTS6 as LMNTTTS,
+  LocalCallRecorder,
   MetricsStore,
   MinWordsStrategy,
   Ngrok,
@@ -10164,11 +11602,13 @@ export {
   PlivoAdapter,
   PricingUnit,
   ProvisionError,
+  RECORDING_SAMPLE_RATE,
   RateLimitError,
   RemoteMessageHandler,
   RimeAudioFormat,
   RimeModel,
   TTS5 as RimeTTS,
+  SMART_TURN_MODEL_ENV_VAR,
   SPAN_BARGEIN,
   SPAN_CALL,
   SPAN_ENDPOINT,
@@ -10176,8 +11616,10 @@ export {
   SPAN_STT,
   SPAN_TOOL,
   SPAN_TTS,
+  ScriptedLLMProvider,
   SentenceChunker,
   SileroVAD,
+  SmartTurnDetector,
   STT5 as SonioxSTT,
   SpeechEvents,
   SpeechmaticsAudioEncoding,
@@ -10199,6 +11641,7 @@ export {
   TestSession,
   TfidfLoopDetector,
   Tool,
+  TurnExpectation,
   Carrier2 as Twilio,
   TwilioAdapter,
   ULTRAVOX_DEFAULT_API_BASE,
@@ -10206,6 +11649,7 @@ export {
   UltravoxRealtimeAdapter,
   STT2 as WhisperSTT,
   assemblyai,
+  attachSpanExporter,
   builtinClipPath,
   calculateRealtimeCost,
   calculateSttCost,
@@ -10222,7 +11666,9 @@ export {
   deepgram,
   defineTool,
   elevenlabs,
+  evalResultToDict,
   evaluateStrategies as evaluateBargeInStrategies,
+  expect,
   filterEmoji,
   filterForTTS,
   filterMarkdown,
@@ -10232,11 +11678,13 @@ export {
   guardrail,
   hashCaller,
   hermes,
+  historyTranscript,
   initTracing,
   isRemoteUrl,
   isTracingEnabled,
   isWebSocketUrl,
   lmnt,
+  loadSuite,
   makeAuthMiddleware,
   mergePricing,
   mixPcm,
@@ -10249,7 +11697,9 @@ export {
   openclaw,
   openclawConsult,
   openclawPostCallNotifier,
+  patterCallScope,
   pcm16ToMulaw,
+  recordPatterAttrs,
   resample16kTo8k,
   resample24kTo16k,
   resample8kTo16k,
@@ -10261,11 +11711,15 @@ export {
   scheduleOnce,
   selectSoundFromList,
   setLogger,
+  shutdownTracing,
   soniox,
   speechmatics,
   startSpan,
   startTunnel,
+  textTurn,
   tool,
+  toolCallTurn,
   ultravox,
-  whisper
+  whisper,
+  withSpan
 };