getpatter 0.5.4 → 0.6.1

package/dist/chunk-D4424JZR.mjs

@@ -0,0 +1,71 @@
+import {
+  getLogger
+} from "./chunk-MVOQFAEO.mjs";
+import {
+  init_esm_shims
+} from "./chunk-N565J3CF.mjs";
+
+// src/services/barge-in-strategies.ts
+init_esm_shims();
+var MinWordsStrategy = class {
+  minWords;
+  useInterim;
+  constructor(options) {
+    if (!Number.isFinite(options.minWords) || options.minWords < 1) {
+      throw new Error(
+        `minWords must be >= 1 (got ${String(options.minWords)})`
+      );
+    }
+    this.minWords = Math.floor(options.minWords);
+    this.useInterim = options.useInterim ?? true;
+  }
+  evaluate(ctx) {
+    if (ctx.isInterim && !this.useInterim) {
+      return false;
+    }
+    const threshold = ctx.agentSpeaking ? this.minWords : 1;
+    const wordCount = (ctx.transcript ?? "").trim().split(/\s+/).filter(Boolean).length;
+    return wordCount >= threshold;
+  }
+  async reset() {
+  }
+};
+async function evaluateStrategies(strategies, ctx) {
+  if (!strategies || strategies.length === 0) {
+    return false;
+  }
+  const safeCtx = {
+    transcript: ctx.transcript ?? "",
+    isInterim: ctx.isInterim,
+    agentSpeaking: ctx.agentSpeaking
+  };
+  for (const strategy of strategies) {
+    try {
+      const result = await strategy.evaluate(safeCtx);
+      if (result === true) return true;
+    } catch (err) {
+      getLogger().warn(
+        `BargeInStrategy ${strategy.constructor?.name ?? "unknown"} threw; treating as 'do not confirm': ${String(err)}`
+      );
+    }
+  }
+  return false;
+}
+async function resetStrategies(strategies) {
+  for (const strategy of strategies) {
+    if (typeof strategy.reset !== "function") continue;
+    try {
+      await strategy.reset();
+    } catch (err) {
+      getLogger().debug(
+        `BargeInStrategy ${strategy.constructor?.name ?? "unknown"}.reset() threw: ${String(err)}`
+      );
+    }
+  }
+}
+
+export {
+  MinWordsStrategy,
+  evaluateStrategies,
+  resetStrategies
+};

package/dist/{chunk-VJVDG4V5.mjs → chunk-MVOQFAEO.mjs}

@@ -1,4 +1,9 @@
+import {
+  init_esm_shims
+} from "./chunk-N565J3CF.mjs";
+
 // src/logger.ts
+init_esm_shims();
 var defaultLogger = {
   info: (msg, ...args) => console.info(`[PATTER] ${msg}`, ...args),
   warn: (msg, ...args) => console.warn(`[PATTER] WARNING: ${msg}`, ...args),

package/dist/chunk-N565J3CF.mjs

@@ -0,0 +1,69 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __glob = (map) => (path2) => {
+  var fn = map[path2];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path2);
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname, __filename;
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
+    __filename = /* @__PURE__ */ getFilename();
+  }
+});
+
+export {
+  __require,
+  __glob,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __dirname,
+  __filename,
+  init_esm_shims
+};

package/dist/chunk-RV7APPYE.mjs

@@ -0,0 +1,397 @@
+import {
+  init_esm_shims
+} from "./chunk-N565J3CF.mjs";
+
+// src/providers/silero-vad.ts
+init_esm_shims();
+import { createRequire } from "module";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var SUPPORTED_SAMPLE_RATES = [8e3, 16e3];
+function resolveModuleDirs() {
+  const candidates = [];
+  try {
+    const cjsDir = new Function("return typeof __dirname !== 'undefined' ? __dirname : null")();
+    if (typeof cjsDir === "string") candidates.push(cjsDir);
+  } catch {
+  }
+  try {
+    const url = import.meta.url;
+    if (url) candidates.push(path.dirname(fileURLToPath(url)));
+  } catch {
+  }
+  try {
+    const url = import.meta.url;
+    if (url) {
+      const req = createRequire(url);
+      candidates.push(path.dirname(req.resolve("getpatter/package.json")));
+    }
+  } catch {
+  }
+  try {
+    const req = createRequire(path.join(process.cwd(), "package.json"));
+    candidates.push(path.dirname(req.resolve("getpatter/package.json")));
+  } catch {
+  }
+  candidates.push(process.cwd());
+  return candidates;
+}
+var MODULE_DIRS = resolveModuleDirs();
+function resolveDefaultModelPath() {
+  for (const dir of MODULE_DIRS) {
+    const candidates = [
+      path.join(dir, "resources", "silero_vad.onnx"),
+      path.join(dir, "..", "resources", "silero_vad.onnx"),
+      path.join(dir, "dist", "resources", "silero_vad.onnx")
+    ];
+    for (const c of candidates) if (fs.existsSync(c)) return c;
+  }
+  return path.join(MODULE_DIRS[0] ?? process.cwd(), "resources", "silero_vad.onnx");
+}
+var DEFAULT_MODEL_PATH = resolveDefaultModelPath();
+function classifyOnnxError(err) {
+  const msg = err?.message ?? String(err);
+  if (/Cannot find module ['"]?onnxruntime-node['"]?$/m.test(msg)) return "missing";
+  if (/onnxruntime_binding\.node|napi-v\d/.test(msg)) return "binding";
+  if (/listSupportedBackends|backend_\d/.test(msg)) return "api-drift";
+  return "unknown";
+}
+async function loadOnnxRuntime() {
+  let firstErr;
+  try {
+    const mod = await import("./dist-RYMPCILF.mjs");
+    return mod;
+  } catch (e) {
+    firstErr = e;
+  }
+  try {
+    const req = createRequire(path.join(process.cwd(), "package.json"));
+    return req("onnxruntime-node");
+  } catch (secondErr) {
+    const importClass = classifyOnnxError(firstErr);
+    const requireClass = classifyOnnxError(secondErr);
+    const original = firstErr?.message ?? String(firstErr);
+    const detail = secondErr?.message ?? String(secondErr);
+    let header;
+    let remedy;
+    if (importClass === "missing" && requireClass === "missing") {
+      header = 'SileroVAD requires the "onnxruntime-node" package \u2014 it is not installed.';
+      remedy = "  Install:  npm install onnxruntime-node@~1.18.0\n\n  (~210 MB. Only needed when you actually use SileroVAD in pipeline mode.)";
+    } else if (importClass === "api-drift" || requireClass === "api-drift") {
+      header = "SileroVAD found onnxruntime-node but the installed version uses an API the SDK does not support.";
+      remedy = "  Patter is currently tested against onnxruntime-node 1.18.x.\n\n  Fix:  npm install onnxruntime-node@~1.18.0\n\n  Versions 1.24+ removed `listSupportedBackends` from the public surface \u2014 track\n  https://github.com/PatterAI/Patter/issues for the SDK update that targets 1.24.";
+    } else if (importClass === "binding" || requireClass === "binding") {
+      header = "SileroVAD found onnxruntime-node but the native binding for this platform is missing.";
+      remedy = "  Common cause on macOS x86_64: the prebuilt bin/ layout drifted between releases.\n\n  Fix:  npm install onnxruntime-node@~1.18.0\n\n  Or rebuild from source:  npm rebuild onnxruntime-node";
+    } else {
+      header = 'SileroVAD requires the "onnxruntime-node" package, which could not be resolved.';
+      remedy = "  Install:  npm install onnxruntime-node@~1.18.0\n\n  This is an optional peer dependency of getpatter (~210 MB).";
+    }
+    const err = new Error(
+      `
+${header}
+
+${remedy}
+
+  import() failed:     ${original}
+  cwd-require failed:  ${detail}
+`
+    );
+    err.cause = secondErr ?? firstErr;
+    throw err;
+  }
+}
+var ExpFilter = class {
+  constructor(alpha) {
+    this.alpha = alpha;
+    if (!(alpha > 0 && alpha <= 1)) {
+      throw new Error("alpha must be in (0, 1].");
+    }
+  }
+  alpha;
+  filtered = null;
+  apply(exp, sample) {
+    if (this.filtered === null) {
+      this.filtered = sample;
+    } else {
+      const a = Math.pow(this.alpha, exp);
+      this.filtered = a * this.filtered + (1 - a) * sample;
+    }
+    return this.filtered;
+  }
+  reset() {
+    this.filtered = null;
+  }
+};
+var OnnxModel = class {
+  constructor(runtime, session, sampleRate) {
+    this.runtime = runtime;
+    this.session = session;
+    if (!SUPPORTED_SAMPLE_RATES.includes(sampleRate)) {
+      throw new Error("Silero VAD only supports 8KHz and 16KHz sample rates");
+    }
+    this.sampleRate = sampleRate;
+    this.windowSizeSamples = sampleRate === 8e3 ? 256 : 512;
+    this.contextSize = sampleRate === 8e3 ? 32 : 64;
+    this.context = new Float32Array(this.contextSize);
+    this.rnnState = new Float32Array(2 * 1 * 128);
+    this.inputBuffer = new Float32Array(this.contextSize + this.windowSizeSamples);
+    this.sampleRateTensor = BigInt64Array.from([BigInt(sampleRate)]);
+  }
+  runtime;
+  session;
+  sampleRate;
+  windowSizeSamples;
+  contextSize;
+  context;
+  rnnState;
+  inputBuffer;
+  sampleRateTensor;
+  async run(window) {
+    if (window.length !== this.windowSizeSamples) {
+      throw new Error(
+        `window must have exactly ${this.windowSizeSamples} samples, got ${window.length}`
+      );
+    }
+    this.inputBuffer.set(this.context, 0);
+    this.inputBuffer.set(window, this.contextSize);
+    const { Tensor } = this.runtime;
+    const feeds = {
+      input: new Tensor("float32", this.inputBuffer, [1, this.inputBuffer.length]),
+      state: new Tensor("float32", this.rnnState, [2, 1, 128]),
+      sr: new Tensor("int64", this.sampleRateTensor, [])
+    };
+    const results = await this.session.run(feeds);
+    const outputKey = Object.keys(results).find((k) => k !== "stateN") ?? "output";
+    const stateKey = "stateN" in results ? "stateN" : Object.keys(results).find((k) => k !== outputKey);
+    const out = results[outputKey];
+    const newState = stateKey ? results[stateKey] : void 0;
+    if (newState && newState.data instanceof Float32Array) {
+      this.rnnState = Float32Array.from(newState.data);
+    }
+    this.context = this.inputBuffer.slice(-this.contextSize);
+    const data = out.data;
+    return data[0] ?? 0;
+  }
+  /** Reset the RNN hidden state + rolling context to a fresh inference. */
+  reset() {
+    this.context = new Float32Array(this.contextSize);
+    this.rnnState = new Float32Array(2 * 1 * 128);
+  }
+};
+var SileroVAD = class _SileroVAD {
+  constructor(model, opts) {
+    this.model = model;
+    this.opts = opts;
+  }
+  model;
+  opts;
+  pending = new Float32Array(0);
+  expFilter = new ExpFilter(0.35);
+  pubSpeaking = false;
+  speechThresholdDuration = 0;
+  silenceThresholdDuration = 0;
+  closed = false;
+  /**
+   * Load the Silero VAD model.
+   * Throws if `onnxruntime-node` is not installed.
+   */
+  static async load(options = {}) {
+    const sampleRate = options.sampleRate ?? 16e3;
+    if (!SUPPORTED_SAMPLE_RATES.includes(sampleRate)) {
+      throw new Error("Silero VAD only supports 8KHz and 16KHz sample rates");
+    }
+    const activationThreshold = options.activationThreshold ?? 0.5;
+    const deactivationThreshold = options.deactivationThreshold ?? Math.max(activationThreshold - 0.15, 0.01);
+    if (deactivationThreshold <= 0) {
+      throw new Error("deactivationThreshold must be greater than 0");
+    }
+    const runtime = await loadOnnxRuntime();
+    const modelPath = options.onnxFilePath ?? DEFAULT_MODEL_PATH;
+    const session = await runtime.InferenceSession.create(modelPath, {
+      interOpNumThreads: 1,
+      intraOpNumThreads: 1,
+      executionMode: "sequential",
+      executionProviders: options.forceCpu === false ? void 0 : ["cpu"]
+    });
+    const model = new OnnxModel(runtime, session, sampleRate);
+    return new _SileroVAD(model, {
+      minSpeechDuration: options.minSpeechDuration ?? 0.25,
+      // Bumped 0.1 -> 0.4s after round 10f confirmed VAD speech_end fired on
+      // natural inter-sentence pauses < 250ms, causing double-talk dispatch.
+      // 400ms is the industry default for telephony and matches the new
+      // inter_utterance_gap_ms debounce in stream-handler.ts.
+      minSilenceDuration: options.minSilenceDuration ?? 0.4,
+      prefixPaddingDuration: options.prefixPaddingDuration ?? 0.03,
+      activationThreshold,
+      deactivationThreshold,
+      sampleRate
+    });
+  }
+  /**
+   * Convenience factory for telephony pipelines.
+   *
+   * Identical to {@link SileroVAD.load} but pins `sampleRate` to 16000 Hz
+   * — the only sample rate Patter's pipeline-mode audio bus uses (8 kHz
+   * mulaw from Twilio is upsampled to 16 kHz PCM before reaching the
+   * VAD). Every other parameter mirrors the upstream Silero VAD
+   * defaults from `snakers4/silero-vad` (`get_speech_timestamps` /
+   * `VADIterator`):
+   *
+   *   - `activationThreshold = 0.5` — upstream `threshold`
+   *   - `deactivationThreshold = 0.35` — upstream `neg_threshold = threshold - 0.15`
+   *   - `minSpeechDuration = 0.25` — upstream `min_speech_duration_ms = 250`
+   *   - `minSilenceDuration = 0.4` — telephony default (was 0.1, bumped after
+   *     round 10f found speech_end firing on inter-sentence pauses < 250 ms,
+   *     causing double-talk dispatch). 400 ms matches the industry telephony
+   *     default and the inter_utterance_gap_ms debounce in stream-handler.ts.
+   *   - `prefixPaddingDuration = 0.03` — upstream `speech_pad_ms = 30`
+   *
+   * Override any field by passing `options`. Deployments that experience
+   * truncation on natural pauses can raise `minSilenceDuration` (e.g.
+   * 0.5–1.0 s) per call site rather than as a global default.
+   *
+   * @example
+   * ```ts
+   * const vad = await SileroVAD.forPhoneCall();
+   * // or, if natural-pause truncation is observed:
+   * const vad = await SileroVAD.forPhoneCall({ minSilenceDuration: 0.5 });
+   * ```
+   */
+  static forPhoneCall(options = {}) {
+    return _SileroVAD.load({
+      sampleRate: 16e3,
+      ...options
+    });
+  }
+  /**
+   * Internal factory used by tests — bypasses onnxruntime-node loading.
+   * @internal
+   */
+  static fromOnnxModel(runtime, session, options) {
+    const model = new OnnxModel(runtime, session, options.sampleRate);
+    return new _SileroVAD(model, options);
+  }
+  /** Sample rate (Hz) the underlying ONNX model was loaded with. */
+  get sampleRate() {
+    return this.opts.sampleRate;
+  }
+  /**
+   * Number of int16 PCM samples that must be provided per call to
+   * processFrame for the model to run one inference window.
+   *
+   * Constraint (Silero ONNX spec):
+   *   - 16 000 Hz → 512 samples (32 ms)
+   *   -  8 000 Hz → 256 samples (32 ms)
+   *
+   * Callers that feed raw audio in fixed-size chunks (e.g. WebSocket frames)
+   * should buffer incoming audio until at least numFramesRequired() int16
+   * samples are available before calling processFrame.  The provider
+   * internally buffers partial windows so smaller chunks are also safe, but
+   * passing exactly one window per call minimises heap allocation.
+   */
+  numFramesRequired() {
+    return this.opts.sampleRate === 8e3 ? 256 : 512;
+  }
+  /** Run VAD on a PCM16 chunk; returns a transition event or null if no change. */
+  async processFrame(pcmChunk, sampleRate) {
+    if (this.closed) {
+      throw new Error("SileroVAD is closed");
+    }
+    if (sampleRate !== this.opts.sampleRate) {
+      throw new Error(
+        `input sampleRate ${sampleRate} does not match model sampleRate ${this.opts.sampleRate}; resampling is not implemented in the Patter port`
+      );
+    }
+    if (pcmChunk.length === 0) {
+      return null;
+    }
+    const numSamples = Math.floor(pcmChunk.length / 2);
+    if (numSamples === 0) {
+      return null;
+    }
+    const samples = new Float32Array(numSamples);
+    for (let i = 0; i < numSamples; i++) {
+      samples[i] = pcmChunk.readInt16LE(i * 2) / 32767;
+    }
+    const merged = new Float32Array(this.pending.length + samples.length);
+    merged.set(this.pending, 0);
+    merged.set(samples, this.pending.length);
+    this.pending = merged;
+    const windowSize = this.model.windowSizeSamples;
+    let event = null;
+    while (this.pending.length >= windowSize) {
+      const window = this.pending.slice(0, windowSize);
+      this.pending = this.pending.slice(windowSize);
+      const rawP = await this.model.run(window);
+      const p = this.expFilter.apply(1, rawP);
+      const windowDuration = windowSize / this.opts.sampleRate;
+      const transition = this.advanceState(p, windowDuration);
+      if (transition !== null) {
+        event = transition;
+      }
+    }
+    return event;
+  }
+  advanceState(p, windowDuration) {
+    const opts = this.opts;
+    if (p >= opts.activationThreshold || this.pubSpeaking && p > opts.deactivationThreshold) {
+      this.speechThresholdDuration += windowDuration;
+      this.silenceThresholdDuration = 0;
+      if (!this.pubSpeaking) {
+        if (this.speechThresholdDuration >= opts.minSpeechDuration) {
+          this.pubSpeaking = true;
+          return {
+            type: "speech_start",
+            confidence: p,
+            durationMs: this.speechThresholdDuration * 1e3
+          };
+        }
+      }
+    } else {
+      this.silenceThresholdDuration += windowDuration;
+      this.speechThresholdDuration = 0;
+      if (this.pubSpeaking && this.silenceThresholdDuration >= opts.minSilenceDuration) {
+        this.pubSpeaking = false;
+        return {
+          type: "speech_end",
+          confidence: p,
+          durationMs: this.silenceThresholdDuration * 1e3
+        };
+      }
+    }
+    return null;
+  }
+  /** Mark the VAD as closed; subsequent processFrame calls throw. */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+  }
+  /**
+   * Reset all per-utterance state so the next ``processFrame`` starts from
+   * a clean SILENCE state.
+   *
+   * Called by the stream handler between agent turns to prevent a "stuck
+   * SPEECH" condition where PSTN echo / loopback kept the detector's
+   * probability above ``deactivationThreshold`` for the entire agent turn.
+   * Without this reset the next user utterance would never trigger a
+   * SILENCE→SPEECH transition and barge-in would feel "one-shot" (works
+   * once, then never again until the call ends).
+   *
+   * Safe to call any time including on a closed instance (no-op).
+   */
+  reset() {
+    if (this.closed) return;
+    this.pending = new Float32Array(0);
+    this.pubSpeaking = false;
+    this.speechThresholdDuration = 0;
+    this.silenceThresholdDuration = 0;
+    this.expFilter.reset();
+    this.model.reset();
+  }
+};
+
+export {
+  SileroVAD
+};