getpatter 0.6.6 → 0.6.8

package/dist/{aec-PJJMUM5E.mjs → aec-ZZ5HGKS3.mjs}

@@ -11,7 +11,7 @@ var DEFAULT_WARMUP_SECONDS = 0.5;
 var DEFAULT_LEAKAGE = 0.9999;
 var DEFAULT_DOUBLE_TALK_RHO = 0.6;
 var FAR_END_BUFFER_SECONDS = 0.5;
-var NlmsEchoCanceller = class {
+var NlmsEchoCanceller = class _NlmsEchoCanceller {
   taps;
   step;
   warmupStep;
@@ -88,8 +88,12 @@ var NlmsEchoCanceller = class {
    * rate — same shape as what we hand off to the audio sender before the
    * carrier-specific transcode.
    */
+  /** Far-end staleness window (ms): beyond this, processNearEnd passes through. */
+  static FAR_STALE_MS = 250;
+  lastFarPushAt = null;
   pushFarEnd(pcm) {
     if (pcm.length === 0) return;
+    this.lastFarPushAt = Date.now();
     const samples = int16BufferToFloat32(pcm);
     const n = samples.length;
     const bufLen = this.farBuf.length;
@@ -120,6 +124,9 @@ var NlmsEchoCanceller = class {
   processNearEnd(pcm) {
     if (pcm.length === 0) return pcm;
     if (this.farFilled < this.taps) return pcm;
+    if (this.lastFarPushAt === null || Date.now() - this.lastFarPushAt > _NlmsEchoCanceller.FAR_STALE_MS) {
+      return pcm;
+    }
     const near = int16BufferToFloat32(pcm);
     const cleaned = this.blockNlms(near);
     this.framesProcessed += 1;
@@ -177,7 +184,8 @@ var NlmsEchoCanceller = class {
       const a = Math.abs(near[i]);
       if (a > nearMax) nearMax = a;
     }
-    const doubleTalk = farMax > 1e-6 ? nearMax > this.rho * farMax : false;
+    if (farMax <= 1e-3) return near;
+    const doubleTalk = nearMax > this.rho * farMax;
     if (doubleTalk) this.doubleTalkFrames += 1;
     const out = new Float32Array(near.length);
     const w = this.w;

package/dist/{carrier-config-7YGNRBPO.mjs → carrier-config-6L5NND7B.mjs}

@@ -47,15 +47,29 @@ async function configureTwilioNumber(accountSid, authToken, phoneNumber, voiceUr
   }
 }
 async function configureTelnyxNumber(apiKey, connectionId, phoneNumber) {
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    "Content-Type": "application/json"
+  };
+  const assoc = await fetch(
+    `${TELNYX_API_BASE}/phone_numbers/${encodeURIComponent(phoneNumber)}`,
+    {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify({ connection_id: connectionId })
+    }
+  );
+  if (!assoc.ok) {
+    throw new Error(
+      `Telnyx PATCH /phone_numbers/${redactPhone(phoneNumber)} failed: ${assoc.status} ${await assoc.text()}`
+    );
+  }
   const resp = await fetch(
     `${TELNYX_API_BASE}/phone_numbers/${encodeURIComponent(phoneNumber)}/voice`,
     {
       method: "PATCH",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ connection_id: connectionId, tech_prefix_enabled: false })
+      headers,
+      body: JSON.stringify({ tech_prefix_enabled: false })
     }
   );
   if (!resp.ok) {

package/dist/chunk-3JNVSNLV.mjs

@@ -0,0 +1,428 @@
+import {
+  ErrorCode,
+  MetricsStore,
+  PatterConfigError,
+  PatterError,
+  RemoteMessageHandler,
+  StreamHandler,
+  resolveVariables,
+  sanitizeVariables
+} from "./chunk-YJ4HKJL6.mjs";
+import {
+  getLogger
+} from "./chunk-MVOQFAEO.mjs";
+import {
+  init_esm_shims
+} from "./chunk-N565J3CF.mjs";
+
+// src/evals/session.ts
+init_esm_shims();
+import { randomUUID } from "crypto";
+
+// src/evals/fakes.ts
+init_esm_shims();
+function makeFakeCarrierWs() {
+  const noop = () => void 0;
+  return {
+    send: noop,
+    close: noop,
+    on: noop,
+    once: noop,
+    removeListener: noop,
+    addEventListener: noop,
+    removeEventListener: noop,
+    readyState: 1,
+    OPEN: 1
+  };
+}
+var FakeAudioSender = class {
+  label = "Eval";
+  // The metrics/dashboard tag for the faked carrier — mirrors Python's
+  // ``telephony_provider="eval"``. No pricing row exists for 'eval', so
+  // telephony cost is always 0. The cast is deliberate: CarrierKind
+  // enumerates real carriers and the harness is not one.
+  telephonyProvider = "eval";
+  inputWireFormat = "pcm_16000";
+  sentAudio = [];
+  marks = [];
+  endedCalls = [];
+  transfers = [];
+  clears = 0;
+  handler = null;
+  sttFactory = null;
+  /** Wire the auto-ack loopback for ``sendMark`` → ``onMark``. */
+  attachHandler(handler) {
+    this.handler = handler;
+  }
+  /** Wire the STT instance ``createStt`` should hand to the handler. */
+  attachSttFactory(factory) {
+    this.sttFactory = factory;
+  }
+  sendAudio(_ws, audioBase64, _streamSid) {
+    this.sentAudio.push(Buffer.from(audioBase64, "base64"));
+  }
+  sendMark(_ws, markName, _streamSid) {
+    this.marks.push(markName);
+    if (this.handler !== null) {
+      void this.handler.onMark(markName).catch((err) => {
+        getLogger().debug(`FakeAudioSender mark ack failed: ${String(err)}`);
+      });
+    }
+  }
+  sendClear(_ws, _streamSid) {
+    this.clears += 1;
+  }
+  async transferCall(callId, toNumber, _options) {
+    this.transfers.push({ callId, toNumber });
+  }
+  async endCall(callId, _ws) {
+    this.endedCalls.push(callId);
+  }
+  async createStt(_agent) {
+    return this.sttFactory ? this.sttFactory() : null;
+  }
+  async queryTelephonyCost() {
+  }
+};
+var FakeSTT = class {
+  sentAudio = [];
+  connected = false;
+  closed = false;
+  callback = null;
+  async connect() {
+    this.connected = true;
+  }
+  sendAudio(pcm) {
+    this.sentAudio.push(pcm);
+  }
+  onTranscript(cb) {
+    this.callback = cb;
+  }
+  /** Inject one final transcript through the handler's real receive path. */
+  async pushFinal(text) {
+    if (this.closed) {
+      throw new PatterError(
+        "FakeSTT is closed \u2014 the EvalSession was already cleaned up",
+        { code: ErrorCode.CONFIG }
+      );
+    }
+    if (this.callback === null) {
+      throw new PatterError(
+        "FakeSTT has no transcript consumer \u2014 the handler is not started",
+        { code: ErrorCode.CONFIG }
+      );
+    }
+    await this.callback({ text, isFinal: true, confidence: 1 });
+  }
+  async close() {
+    this.closed = true;
+  }
+};
+var FakeTTS = class {
+  spoken = [];
+  closed = false;
+  chunk;
+  constructor(chunk = Buffer.alloc(320)) {
+    this.chunk = chunk;
+  }
+  async *synthesizeStream(text) {
+    this.spoken.push(text);
+    yield this.chunk;
+  }
+  /** Invoked by the handler's real teardown (``handleStop``). */
+  cancelActiveStream() {
+    this.closed = true;
+  }
+};
+var NoopVad = class {
+  async processFrame(_pcmChunk, _sampleRate) {
+    return null;
+  }
+  reset() {
+  }
+  async close() {
+  }
+};
+
+// src/evals/session.ts
+function historyTranscript(history) {
+  return history.map((entry) => ({
+    role: entry.role === "assistant" ? "agent" : String(entry.role ?? "user"),
+    text: String(entry.text ?? "")
+  }));
+}
+async function awaitWithTimeout(promise, timeoutMs) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise.then(() => "ok"),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve("timeout"), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+var EvalSession = class _EvalSession {
+  callId;
+  caller;
+  callee;
+  /** The faked carrier boundary — records audio / clears / marks. */
+  audioSender = new FakeAudioSender();
+  /** The faked STT boundary — inject transcripts via the session, not directly. */
+  stt = new FakeSTT();
+  /** The faked TTS boundary — ``spoken`` records every synthesised sentence. */
+  tts = new FakeTTS();
+  /**
+   * Every payload the handler fired through ``onTranscript`` — user /
+   * assistant / tool events, in emission order.
+   */
+  transcriptEvents = [];
+  sourceAgent;
+  llmProvider;
+  openaiKey;
+  customParams;
+  turnTimeoutS;
+  streamHandler = null;
+  toolCalls = [];
+  metricsTurns = [];
+  interruptedTurns = 0;
+  offTurnEnded = null;
+  started = false;
+  closed = false;
+  constructor(options) {
+    if (!options || !options.agent) {
+      throw new PatterConfigError("EvalSession requires an agent");
+    }
+    this.sourceAgent = options.agent;
+    this.llmProvider = options.llmProvider;
+    this.openaiKey = options.openaiKey ?? "";
+    this.callId = options.callId ?? `eval_${randomUUID().replace(/-/g, "").slice(0, 12)}`;
+    this.caller = options.caller ?? "+15550000001";
+    this.callee = options.callee ?? "+15550000002";
+    this.customParams = options.customParams;
+    this.turnTimeoutS = options.turnTimeoutS ?? 60;
+  }
+  /** Build AND start a session — the canonical entry point. */
+  static async create(options) {
+    const session = new _EvalSession(options);
+    await session.start();
+    return session;
+  }
+  // -- lifecycle ------------------------------------------------------------
+  /** Build and start the real handler (idempotent). */
+  async start() {
+    if (this.started) return;
+    const evalAgent = this.buildEvalAgent();
+    if (evalAgent.llm == null && !this.openaiKey) {
+      throw new PatterConfigError(
+        "EvalSession needs an LLM: pass llmProvider (e.g. a ScriptedLLMProvider for CI), set agent.llm, or supply openaiKey for the built-in OpenAI provider."
+      );
+    }
+    this.audioSender.attachSttFactory(() => this.stt);
+    const deps = {
+      config: this.openaiKey ? { openaiKey: this.openaiKey } : {},
+      agent: evalAgent,
+      bridge: this.audioSender,
+      metricsStore: new MetricsStore(),
+      pricing: null,
+      remoteHandler: new RemoteMessageHandler(),
+      recording: false,
+      onTranscript: async (data) => {
+        this.transcriptEvents.push(data);
+      },
+      onMetrics: async (data) => {
+        const turn = data.turn;
+        if (turn != null) this.metricsTurns.push(turn);
+      },
+      // Pipeline mode never builds a Realtime/ConvAI adapter; loud guard in
+      // case a future refactor routes the eval agent elsewhere.
+      buildAIAdapter: () => {
+        throw new PatterConfigError("EvalSession supports pipeline mode only");
+      },
+      sanitizeVariables,
+      resolveVariables
+    };
+    const handler = new StreamHandler(deps, makeFakeCarrierWs(), this.caller, this.callee);
+    const internals = handler;
+    this.audioSender.attachHandler(handler);
+    handler.setStreamSid("eval");
+    this.offTurnEnded = handler.addObserver((payload) => {
+      if (payload?.turn?.agent_text === "[interrupted]") this.interruptedTurns += 1;
+    }, "turn_ended");
+    this.streamHandler = handler;
+    try {
+      await handler.handleCallStart(this.callId, { ...this.customParams ?? {} });
+      if (internals.firstMessageTask) await internals.firstMessageTask;
+      if (internals.llmLoop == null) {
+        throw new PatterConfigError(
+          "EvalSession could not build the LLM loop \u2014 the agent has onMessage-style wiring or no usable LLM provider."
+        );
+      }
+      internals.llmLoop.setOnToolCall(async (name, args, result) => {
+        await internals.recordToolCall(name, args, result);
+        this.toolCalls.push({ name, arguments: { ...args ?? {} }, result });
+      });
+    } catch (err) {
+      try {
+        await handler.handleStop();
+      } catch {
+      }
+      this.offTurnEnded?.();
+      this.offTurnEnded = null;
+      this.streamHandler = null;
+      throw err;
+    }
+    this.started = true;
+  }
+  /** Run the handler's real teardown (``handleStop``). Idempotent. */
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.offTurnEnded?.();
+    this.offTurnEnded = null;
+    const handler = this.streamHandler;
+    if (handler === null) return;
+    await handler.handleStop();
+  }
+  // -- turn driving -----------------------------------------------------------
+  /**
+   * Inject one final user transcript and await the full agent turn.
+   *
+   * The transcript flows through the handler's real receive path — barge-in
+   * handling, dedup/hallucination filtering, hooks, the LLM loop with real
+   * tool execution, guardrails, sentence chunking, and TTS — exactly as on
+   * a live call. Returns once the turn's dispatch task settles.
+   *
+   * Throws:
+   * - ``PatterError`` (``INPUT_VALIDATION``) — the REAL pipeline dropped
+   *   the transcript (duplicate within the 2 s throttle window, known STT
+   *   hallucination, or empty text) — same behaviour as a live call.
+   * - ``PatterError`` (``TIMEOUT``) — the turn did not settle within
+   *   ``timeoutS`` (default: the session's ``turnTimeoutS``).
+   */
+  async userSays(text, options = {}) {
+    if (!this.started || this.streamHandler === null) {
+      throw new PatterError(
+        "EvalSession is not started \u2014 use `await EvalSession.create(...)`",
+        { code: ErrorCode.CONFIG }
+      );
+    }
+    if (this.closed) {
+      throw new PatterError("EvalSession is closed", { code: ErrorCode.CONFIG });
+    }
+    const timeoutS = options.timeoutS ?? this.turnTimeoutS;
+    const timeoutMs = timeoutS * 1e3;
+    const internals = this.streamHandler;
+    const historyLen = internals.history.entries.length;
+    const toolsLen = this.toolCalls.length;
+    const spokenLen = this.tts.spoken.length;
+    const turnsLen = this.metricsTurns.length;
+    const interruptedLen = this.interruptedTurns;
+    const commitTextBefore = internals.lastCommitText;
+    const commitAtBefore = internals.lastCommitAt;
+    const consumed = await awaitWithTimeout(this.stt.pushFinal(text), timeoutMs);
+    if (consumed === "timeout") {
+      throw new PatterError(
+        `user turn ${JSON.stringify(text)} was not consumed by the STT transcript loop within ${timeoutS}s \u2014 a hook or the previous turn may be hung (check logs)`,
+        { code: ErrorCode.TIMEOUT }
+      );
+    }
+    const committed = internals.lastCommitText !== commitTextBefore || internals.lastCommitAt !== commitAtBefore;
+    if (!committed) {
+      throw new PatterError(
+        `user turn ${JSON.stringify(text)} was dropped by the pipeline's commit filter (duplicate within 2s, known STT hallucination, or empty) \u2014 exactly as it would be on a live call. Vary the text between turns or split the case.`,
+        { code: ErrorCode.INPUT_VALIDATION }
+      );
+    }
+    const dispatch = internals.dispatchTask;
+    if (dispatch !== null) {
+      const settled = await awaitWithTimeout(dispatch, timeoutMs);
+      if (settled === "timeout") {
+        try {
+          internals.llmAbort?.abort();
+        } catch {
+        }
+        await Promise.race([
+          dispatch.catch(() => void 0),
+          new Promise((resolve) => setTimeout(resolve, 1e3))
+        ]);
+        throw new PatterError(
+          `agent turn for ${JSON.stringify(text)} did not settle within ${timeoutS}s`,
+          { code: ErrorCode.TIMEOUT }
+        );
+      }
+    }
+    return this.buildTurnResult(text, { historyLen, toolsLen, spokenLen, turnsLen, interruptedLen });
+  }
+  // -- convenience accessors ----------------------------------------------------
+  /** The live {@link StreamHandler} (``null`` before ``start``). */
+  get handler() {
+    return this.streamHandler;
+  }
+  /** Current conversation history (shallow copies of the entries). */
+  get history() {
+    if (this.streamHandler === null) return [];
+    const internals = this.streamHandler;
+    return internals.history.entries.map((e) => ({ ...e }));
+  }
+  /** Full-session transcript in the judge shape (assistant → agent). */
+  transcript() {
+    return historyTranscript(this.history);
+  }
+  // -- internals --------------------------------------------------------------
+  /** Return the agent reshaped for harness execution. */
+  buildEvalAgent() {
+    const agent = this.sourceAgent;
+    const overrides = {};
+    if (agent.provider !== "pipeline") {
+      overrides.provider = "pipeline";
+    }
+    if (agent.engine !== void 0) {
+      getLogger().info("EvalSession: agent.engine ignored \u2014 the harness runs pipeline mode");
+      overrides.engine = void 0;
+    }
+    if (agent.stt !== void 0) {
+      getLogger().info(
+        "EvalSession: agent.stt config ignored \u2014 transcripts are injected directly"
+      );
+    }
+    overrides.stt = void 0;
+    if (agent.tts !== void 0) {
+      getLogger().info("EvalSession: agent.tts config replaced by FakeTTS");
+    }
+    overrides.tts = this.tts;
+    if (this.llmProvider !== void 0) {
+      overrides.llm = this.llmProvider;
+    }
+    if (agent.vad === void 0) {
+      overrides.vad = new NoopVad();
+    }
+    return { ...agent, ...overrides };
+  }
+  buildTurnResult(userText, snapshot) {
+    const internals = this.streamHandler;
+    const spoken = this.tts.spoken.slice(snapshot.spokenLen);
+    const fullHistory = internals.history.entries.map((e) => ({ ...e }));
+    const newHistory = fullHistory.slice(snapshot.historyLen);
+    const agentText = spoken.length > 0 ? spoken.join(" ") : newHistory.filter((e) => e.role === "assistant").map((e) => e.text).join(" ");
+    const newTurns = this.metricsTurns.slice(snapshot.turnsLen);
+    return {
+      userText,
+      agentText,
+      toolCalls: this.toolCalls.slice(snapshot.toolsLen),
+      historySnapshot: fullHistory,
+      interrupted: this.interruptedTurns > snapshot.interruptedLen,
+      metricsTurn: newTurns.length > 0 ? newTurns[newTurns.length - 1] : null
+    };
+  }
+};
+
+export {
+  FakeAudioSender,
+  FakeSTT,
+  FakeTTS,
+  historyTranscript,
+  EvalSession
+};

package/dist/{chunk-3VVATR6A.mjs → chunk-C2LWB42T.mjs}

@@ -57,7 +57,7 @@ function classifyOnnxError(err) {
   if (/listSupportedBackends|backend_\d/.test(msg)) return "api-drift";
   return "unknown";
 }
-async function loadOnnxRuntime() {
+async function loadOnnxRuntime(feature = "SileroVAD") {
   let firstErr;
   try {
     const mod = await import("./dist-RYMPCILF.mjs");
@@ -76,16 +76,18 @@ async function loadOnnxRuntime() {
     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.)";
+      header = `${feature} requires the "onnxruntime-node" package \u2014 it is not installed.`;
+      remedy = `  Install:  npm install onnxruntime-node@~1.18.0
+
+  (~210 MB. Only needed when you actually use ${feature} 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.";
+      header = `${feature} 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.";
+      header = `${feature} 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.';
+      header = `${feature} 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(
@@ -408,5 +410,6 @@ var SileroVAD = class _SileroVAD {
 };
 
 export {
+  loadOnnxRuntime,
   SileroVAD
 };