@absolutejs/voice 0.0.22-beta.612 → 0.0.22-beta.614

package/dist/core/bargeInDetector.d.ts

@@ -15,27 +15,37 @@ export type VoiceBargeInVerdict = {
     shouldCancel: boolean;
     /** Diagnostic label, surfaced on the barge_in / barge_in_suppressed trace. */
     reason?: string;
+    /**
+     * The acoustic measurements the decision used, surfaced on the trace for
+     * tuning against real audio. Omitted when no audio was judged.
+     */
+    metrics?: {
+        voicedMs: number;
+        rms: number;
+    };
 };
 export type VoiceBargeInDetector = {
     evaluate: (input: VoiceBargeInInput) => Promise<VoiceBargeInVerdict> | VoiceBargeInVerdict;
 };
 export type CreateAcousticBargeInDetectorOptions = {
-    /** Speech sustained this long (ms) is a real interruption regardless of text/energy. */
+    /** Voiced speech sustained this long (ms) is a real interruption — cancel. */
     sustainedMs?: number;
-    /** RMS (0-1) at/above this is an emphatic onset ("Wait!") — cancel even if short. */
-    emphaticRms?: number;
-    /** Below this RMS (0-1) a short burst is incidental noise — keep talking. */
-    noiseFloorRms?: number;
+    /**
+     * Leading words that mark an interruption ("wait", "hold on", "sorry"). A
+     * short utterance starting with one cancels immediately instead of holding.
+     * Extends (does not replace) the defaults.
+     */
+    interruptionCues?: string[];
 };
 /**
- * A model-free acoustic backchannel-vs-barge-in classifier. Combines the user's
- * speech duration + onset energy with the text backchannel signal:
- *   - sustained speech            → real interruption (cancel)
- *   - known cue word, stayed short → backchannel (keep talking)
- *   - short but loud/sharp onset   → emphatic interruption like "Wait!" (cancel)
- *   - short + quiet                → incidental noise (keep talking)
- *   - short + moderate, real words → ambiguous, default to cancel (don't strand
- *                                    a genuine short interruption)
+ * A model-free backchannel-vs-barge-in classifier driven by TEXT + PERSISTENCE
+ * (energy was measured to not discriminate on normalized speech):
+ *   - voiced speech past `sustainedMs`  → real interruption (cancel)
+ *   - known backchannel cue, still short → backchannel (keep talking)
+ *   - starts with an interruption cue     → caller took the floor (cancel)
+ *   - otherwise short + ambiguous         → HOLD: keep talking; a continuing
+ *                                           utterance cancels itself once its
+ *                                           voiced duration crosses sustainedMs
  * Runs in-process on raw arithmetic — no model, no sidecar.
  */
 export declare const createAcousticBargeInDetector: (options?: CreateAcousticBargeInDetectorOptions) => VoiceBargeInDetector;

package/dist/index.js

@@ -5287,12 +5287,17 @@ var createVoiceSession = (options) => {
             partialText: triggeringText,
             wordCount,
             ...getTurnAudioForDetector()
-          })) : { reason: undefined, shouldCancel: !isBackchannelByText };
+          })) : {
+            metrics: undefined,
+            reason: undefined,
+            shouldCancel: !isBackchannelByText
+          };
           const reason = verdict.reason ?? (verdict.shouldCancel ? "stt_partial" : "backchannel");
           if (verdict.shouldCancel) {
             backchannelSuppressedAt = null;
             appendTurnLatencyStage({
               metadata: {
+                ...verdict.metrics,
                 partial: triggeringText.slice(0, 200),
                 source: reason,
                 wordCount
@@ -5305,6 +5310,7 @@ var createVoiceSession = (options) => {
             backchannelSuppressedAt = Date.now();
             appendTurnLatencyStage({
               metadata: {
+                ...verdict.metrics,
                 partial: triggeringText.slice(0, 200),
                 reason,
                 wordCount
@@ -25348,6 +25354,7 @@ var createTwilioMediaStreamBridge = (socket, options) => {
       sttFallback: resolveSTTFallbackConfig(options.sttFallback),
       sttLifecycle: options.sttLifecycle ?? runtimePreset.sttLifecycle,
       ...options.semanticTurnDetector ? { semanticTurnDetector: options.semanticTurnDetector } : {},
+      ...options.bargeInDetector ? { bargeInDetector: options.bargeInDetector } : {},
       ...options.fillerPhrases ? { fillerPhrases: options.fillerPhrases } : {},
       ...options.fillerDelayMs !== undefined ? { fillerDelayMs: options.fillerDelayMs } : {},
       ...options.bargeInMinPartialWords !== undefined ? { bargeInMinPartialWords: options.bargeInMinPartialWords } : {},
@@ -42001,6 +42008,28 @@ var createRegexSemanticTurnDetector = (options) => {
   };
 };
 // src/core/bargeInDetector.ts
+var DEFAULT_INTERRUPTION_CUES = [
+  "wait",
+  "hold on",
+  "hold up",
+  "hang on",
+  "stop",
+  "sorry",
+  "excuse me",
+  "actually",
+  "one sec",
+  "one second",
+  "quick question",
+  "question",
+  "can i",
+  "let me",
+  "no no"
+];
+var normalize = (text) => text.toLowerCase().replace(/[^a-z\s]/g, " ").replace(/\s+/g, " ").trim();
+var startsWithCue = (text, cues) => {
+  const norm = normalize(text);
+  return cues.some((cue) => norm === cue || norm.startsWith(`${cue} `));
+};
 var VOICED_FLOOR = 0.02;
 var measureTurnAudio = (chunks, format) => {
   const channels = format.channels ?? 1;
@@ -42019,37 +42048,44 @@ var measureTurnAudio = (chunks, format) => {
     }
   }
   if (voicedSamples === 0) {
-    return { durationMs: 0, rms: 0 };
+    return { rms: 0, voicedMs: 0 };
   }
   return {
-    durationMs: voicedSamples / channels / sampleRate * 1000,
-    rms: Math.sqrt(sumSquares / voicedSamples)
+    rms: Math.sqrt(sumSquares / voicedSamples),
+    voicedMs: voicedSamples / channels / sampleRate * 1000
   };
 };
 var createAcousticBargeInDetector = (options = {}) => {
-  const sustainedMs = options.sustainedMs ?? 700;
-  const emphaticRms = options.emphaticRms ?? 0.16;
-  const noiseFloorRms = options.noiseFloorRms ?? 0.035;
+  const sustainedMs = options.sustainedMs ?? 600;
+  const interruptionCues = [
+    ...DEFAULT_INTERRUPTION_CUES,
+    ...options.interruptionCues ?? []
+  ];
   return {
     evaluate: (input) => {
+      const isInterruptionCue = startsWithCue(input.partialText, interruptionCues);
       const { turnAudio, turnAudioFormat } = input;
       if (!turnAudio || turnAudio.length === 0 || !turnAudioFormat) {
-        return input.isBackchannelByText ? { reason: "text_backchannel", shouldCancel: false } : { reason: "text_only", shouldCancel: true };
+        if (input.isBackchannelByText) {
+          return { reason: "text_backchannel", shouldCancel: false };
+        }
+        return {
+          reason: isInterruptionCue ? "text_interruption" : "text_only",
+          shouldCancel: true
+        };
       }
-      const { durationMs, rms } = measureTurnAudio(turnAudio, turnAudioFormat);
-      if (durationMs >= sustainedMs) {
-        return { reason: "acoustic_sustained", shouldCancel: true };
+      const metrics = measureTurnAudio(turnAudio, turnAudioFormat);
+      metrics.voicedMs = Math.round(metrics.voicedMs);
+      if (metrics.voicedMs >= sustainedMs) {
+        return { metrics, reason: "acoustic_sustained", shouldCancel: true };
       }
       if (input.isBackchannelByText) {
-        return { reason: "acoustic_backchannel", shouldCancel: false };
-      }
-      if (rms >= emphaticRms) {
-        return { reason: "acoustic_emphatic", shouldCancel: true };
+        return { metrics, reason: "acoustic_backchannel", shouldCancel: false };
       }
-      if (rms <= noiseFloorRms) {
-        return { reason: "acoustic_noise_floor", shouldCancel: false };
+      if (isInterruptionCue) {
+        return { metrics, reason: "acoustic_interruption", shouldCancel: true };
       }
-      return { reason: "acoustic_ambiguous", shouldCancel: true };
+      return { metrics, reason: "acoustic_hold", shouldCancel: false };
     }
   };
 };
@@ -51778,7 +51814,7 @@ var buildVoiceAgentPerformanceReport = (input) => {
   };
 };
 // src/core/scorecardCalibration.ts
-var normalize = (raw, scaleMax) => scaleMax === 0 ? 0 : raw / scaleMax;
+var normalize2 = (raw, scaleMax) => scaleMax === 0 ? 0 : raw / scaleMax;
 var correlation = (xs, ys) => {
   if (xs.length === 0 || xs.length !== ys.length)
     return 0;
@@ -51837,8 +51873,8 @@ var computeVoiceScorecardCalibration = (pairs, options = {}) => {
       const l = llmByCriterion.get(criterionId);
       if (!h || !l)
         continue;
-      const hn = normalize(h.score, pair.human.scaleMax);
-      const ln = normalize(l.score, pair.llm.scaleMax);
+      const hn = normalize2(h.score, pair.human.scaleMax);
+      const ln = normalize2(l.score, pair.llm.scaleMax);
       const gap = Math.abs(hn - ln);
       allGaps.push(gap);
       divergences.push({

package/dist/telephony/twilio.d.ts

@@ -133,6 +133,7 @@ export type TwilioMediaStreamBridgeOptions<TContext = unknown, TSession extends
      * snappy responses on clear-cut answers. See VoiceSemanticTurnDetector.
      */
     semanticTurnDetector?: import("../core/semanticTurn").VoiceSemanticTurnDetector;
+    bargeInDetector?: import("../core/bargeInDetector").VoiceBargeInDetector;
     /**
      * Pre-rendered filler phrases ("Hmm.", "Got it.", "Let me think.") played
      * in the gap between user-turn-commit and real assistant audio. Boardy's

package/dist/testing/index.js

@@ -7514,12 +7514,17 @@ var createVoiceSession = (options) => {
             partialText: triggeringText,
             wordCount,
             ...getTurnAudioForDetector()
-          })) : { reason: undefined, shouldCancel: !isBackchannelByText };
+          })) : {
+            metrics: undefined,
+            reason: undefined,
+            shouldCancel: !isBackchannelByText
+          };
           const reason = verdict.reason ?? (verdict.shouldCancel ? "stt_partial" : "backchannel");
           if (verdict.shouldCancel) {
             backchannelSuppressedAt = null;
             appendTurnLatencyStage({
               metadata: {
+                ...verdict.metrics,
                 partial: triggeringText.slice(0, 200),
                 source: reason,
                 wordCount
@@ -7532,6 +7537,7 @@ var createVoiceSession = (options) => {
             backchannelSuppressedAt = Date.now();
             appendTurnLatencyStage({
               metadata: {
+                ...verdict.metrics,
                 partial: triggeringText.slice(0, 200),
                 reason,
                 wordCount
@@ -14238,6 +14244,7 @@ var createTwilioMediaStreamBridge = (socket, options) => {
       sttFallback: resolveSTTFallbackConfig(options.sttFallback),
       sttLifecycle: options.sttLifecycle ?? runtimePreset.sttLifecycle,
       ...options.semanticTurnDetector ? { semanticTurnDetector: options.semanticTurnDetector } : {},
+      ...options.bargeInDetector ? { bargeInDetector: options.bargeInDetector } : {},
       ...options.fillerPhrases ? { fillerPhrases: options.fillerPhrases } : {},
       ...options.fillerDelayMs !== undefined ? { fillerDelayMs: options.fillerDelayMs } : {},
       ...options.bargeInMinPartialWords !== undefined ? { bargeInMinPartialWords: options.bargeInMinPartialWords } : {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@absolutejs/voice",
-  "version": "0.0.22-beta.612",
+  "version": "0.0.22-beta.614",
   "description": "Voice primitives and Elysia plugin for AbsoluteJS",
   "repository": {
     "type": "git",