@eshal-bot/chat-widget 0.2.41 → 0.2.42

package/dist/chat-widget.esm.js

@@ -1 +1 @@
-export{S as default}from"./chat-widget-index-i7Tp1iNw.esm.js";import"react";import"react-dom/client";import"react/jsx-runtime";import"react-dom";
+export{S as default}from"./chat-widget-index-LsKr3paz.esm.js";import"react";import"react-dom/client";import"react/jsx-runtime";import"react-dom";

package/dist/chat-widget.js

@@ -8948,8 +8948,9 @@
    * is a small energy-based state machine between the mic and the socket: it
    * forwards audio ONLY inside a confirmed speech turn.
    *
-   *   - idle -> speech needs sustained voiced energy (`speechStartMs`), so a
-   *     click, breath or keyboard tap never arms a turn;
+   *   - idle -> speech needs `speechStartMs` of voiced energy inside the last
+   *     `speechWindowMs`, so a click, breath or keyboard tap never arms a turn,
+   *     while a quiet frame inside a short word does not throw the onset away;
    *   - on open it fires `onSpeechStart` (barge-in: stop assistant TTS), then
    *     flushes `preRollMs` of buffered audio so the first word is not clipped;
    *   - while speaking it forwards every frame, including short pauses;
@@ -8965,8 +8966,18 @@
     // RMS energy (0..1) at/above which a frame counts as voiced. Speech is
     // typically 0.05-0.3; quiet room tone sits well under 0.02.
     energyThreshold: 0.025,
-    // Continuous voiced audio (ms) required to OPEN a turn - rejects coughs/clicks.
-    speechStartMs: 200,
+    // Voiced audio (ms) inside `speechWindowMs` required to OPEN a turn -
+    // rejects coughs/clicks. EV-4952: this was 200 ms of strictly continuous
+    // voiced frames, and on dev (4 Nov 2026) short answers like "yes" and
+    // "hello" often never opened the gate: at 8 ms frames one quiet frame
+    // between syllables reset the run, so the caller had to repeat themselves.
+    speechStartMs: 120,
+    // Sliding window (ms) the voiced audio above is counted over.
+    speechWindowMs: 200,
+    // Continuous quiet (ms) that abandons a half-built onset. A dip shorter
+    // than this (a plosive, the gap inside "hel-lo") is tolerated; anything
+    // longer is a real pause, so isolated pops cannot add up over time.
+    onsetGapMs: 40,
     // Continuous silence (ms) after speech that CLOSES the turn.
     hangoverMs: 1000,
     // Audio (ms) preceding turn-open to retain and flush.
@@ -8998,12 +9009,18 @@
       sampleRate: config.sampleRate,
       energyThreshold: pick(config.energyThreshold, DEFAULT_SPEECH_GATE_CONFIG.energyThreshold),
       speechStartMs: pick(config.speechStartMs, DEFAULT_SPEECH_GATE_CONFIG.speechStartMs),
+      speechWindowMs: pick(config.speechWindowMs, DEFAULT_SPEECH_GATE_CONFIG.speechWindowMs),
+      onsetGapMs: pick(config.onsetGapMs, DEFAULT_SPEECH_GATE_CONFIG.onsetGapMs),
       hangoverMs: pick(config.hangoverMs, DEFAULT_SPEECH_GATE_CONFIG.hangoverMs),
       preRollMs: pick(config.preRollMs, DEFAULT_SPEECH_GATE_CONFIG.preRollMs)
     };
     let speaking = false;
-    // While idle: how much consecutive voiced audio has been seen (to open).
-    let voicedRunMs = 0;
+    // While idle: recent frames ({ durationMs, voiced }) covering the last
+    // `speechWindowMs`, with their voiced total, plus the current quiet run.
+    let onset = [];
+    let onsetMs = 0;
+    let voicedMs = 0;
+    let quietRunMs = 0;
     // While speaking: how much consecutive silence has been seen (to close).
     let silenceRunMs = 0;
     // Ring of recent frames kept only while idle, for pre-roll on open.
@@ -9014,9 +9031,15 @@
     const frameDurationMs = function (pcm) {
       return pcm.byteLength / 2 / cfg.sampleRate * 1000;
     };
+    const clearOnset = function () {
+      onset = [];
+      onsetMs = 0;
+      voicedMs = 0;
+      quietRunMs = 0;
+    };
     const reset = function () {
       speaking = false;
-      voicedRunMs = 0;
+      clearOnset();
       silenceRunMs = 0;
       preRoll = [];
       preRollMsBuffered = 0;
@@ -9036,22 +9059,35 @@
           const dropped = preRoll.shift();
           preRollMsBuffered -= dropped ? dropped.durationMs : 0;
         }
+        onset.push({
+          durationMs: durationMs,
+          voiced: voiced
+        });
+        onsetMs += durationMs;
+        if (voiced) voicedMs += durationMs;
+        while (onsetMs > cfg.speechWindowMs && onset.length > 1) {
+          const old = onset.shift();
+          onsetMs -= old.durationMs;
+          if (old.voiced) voicedMs -= old.durationMs;
+        }
         if (voiced) {
-          voicedRunMs += durationMs;
-          if (voicedRunMs >= cfg.speechStartMs) {
+          quietRunMs = 0;
+          if (voicedMs >= cfg.speechStartMs) {
             // Confirmed speech: open the turn. onSpeechStart first so the
             // caller can barge in, then flush the pre-roll and go live.
             speaking = true;
             silenceRunMs = 0;
+            clearOnset();
             if (typeof callbacks.onSpeechStart === 'function') callbacks.onSpeechStart();
             for (let i = 0; i < preRoll.length; i += 1) callbacks.onVoiceFrame(preRoll[i].pcm);
             preRoll = [];
             preRollMsBuffered = 0;
           }
         } else {
-          // Sustained energy only: any silent frame resets the run so a brief
-          // transient cannot accumulate its way over the threshold.
-          voicedRunMs = 0;
+          // A brief dip is tolerated; a real pause abandons the onset so a
+          // stray transient cannot accumulate its way over the threshold.
+          quietRunMs += durationMs;
+          if (quietRunMs >= cfg.onsetGapMs) clearOnset();
         }
         return;
       }
@@ -9065,7 +9101,7 @@
         silenceRunMs += durationMs;
         if (silenceRunMs >= cfg.hangoverMs) {
           speaking = false;
-          voicedRunMs = 0;
+          clearOnset();
           silenceRunMs = 0;
           callbacks.onSpeechEnd();
         }
@@ -12278,6 +12314,54 @@
     return "voiceUnavailable";
   }
 
+  /**
+   * The spoken greeting voice-runtime sends as soon as a call connects (EV-4952).
+   *
+   * The server sends `{"greeting": {"text": "..."}}` once, before the greeting
+   * audio, then the audio frames as usual, then `turnComplete`. Until now the
+   * widget dropped every bot reply before the user had spoken, so on the dev
+   * call UR-0016 (Aurelia org org_1793698095653_c341070ff1, 4 Nov 2026) the
+   * caller sat in silence until they spoke first. The marker is what lets the
+   * client tell the greeting apart from a stray reply and play it.
+   *
+   * A client that never gets the marker behaves exactly as before. Mirrors
+   * packages/frontend/src/components/chatbot-preview/voiceGreeting.ts.
+   */
+
+  /** The greeting text if the event is the greeting marker, else null. */
+  function voiceGreetingText(event) {
+    const text = event?.greeting?.text;
+    if (typeof text !== "string") return null;
+    const trimmed = text.trim();
+    return trimmed === "" ? null : trimmed;
+  }
+
+  /**
+   * The bubbles after the greeting arrives.
+   *
+   * - The static welcome this call added (`welcomeId`) is replaced by the
+   *   greeting, so the call does not show both.
+   * - A bubble already on screen with the same text (a welcome shown before the
+   *   call started, in either list) is kept and no duplicate is added.
+   * - Otherwise the greeting is appended as the bot's bubble.
+   */
+  function applyVoiceGreeting(prev, text, welcomeId, others, makeBubble) {
+    if (welcomeId) {
+      const at = prev.findIndex(m => m.id === welcomeId);
+      if (at >= 0) {
+        const next = [...prev];
+        next[at] = {
+          ...next[at],
+          content: text
+        };
+        return next;
+      }
+    }
+    const shown = [...prev, ...(others || [])].some(m => m.role === "assistant" && typeof m.content === "string" && m.content.trim() === text);
+    if (shown) return prev;
+    return [...prev, makeBubble(text)];
+  }
+
   /**
    * Replies the widget never streamed itself.
    *
@@ -13267,6 +13351,14 @@
     const lastProcessedAssistantContentRef = reactExports.useRef(null); // Track last processed content to prevent duplicates
     const userHasSpokenRef = reactExports.useRef(false); // Track if user has sent first message - prevents automatic greetings
     const turnHasTranscriptionRef = reactExports.useRef(false); // True when outputTranscription received this turn - skip content.parts text
+    // EV-4952: true from the server's greeting marker until its turnComplete
+    // (or a barge-in), so the greeting audio plays before the user has spoken.
+    const greetingActiveRef = reactExports.useRef(false);
+    const voiceWelcomeIdRef = reactExports.useRef(null); // the static welcome bubble this voice call added, if any
+    // The text-mode bubbles, read by the greeting de-dup without re-binding the
+    // socket handler on every message.
+    const voiceTextMessagesRef = reactExports.useRef(messages);
+    voiceTextMessagesRef.current = messages;
     const stopVoiceSessionRef = reactExports.useRef(null); // Ref to avoid referencing stopVoiceSession before it is defined in handleBidiEvent
     const pendingVoiceSourcesRef = reactExports.useRef(null); // Hold sources until the assistant bubble for this turn exists
     // Anonymous browser fingerprint from @eshal-tracker/sdk. Resolved
@@ -14998,6 +15090,7 @@
       currentAssistantMessageIdRef.current = null;
       currentInputMessageIdRef.current = null;
       turnHasTranscriptionRef.current = false; // reset for next turn
+      greetingActiveRef.current = false; // the greeting turn, if any, is over
       pendingVoiceSourcesRef.current = null;
     }, []);
     const handleInterrupted = reactExports.useCallback(() => {
@@ -15009,6 +15102,7 @@
       }
       currentAssistantMessageIdRef.current = null;
       currentInputMessageIdRef.current = null;
+      greetingActiveRef.current = false; // a barge-in over the greeting ends it
       pendingVoiceSourcesRef.current = null;
       setBidiMessages(prev => prev.map(message => message.metadata?.source === "bidi" ? {
         ...message,
@@ -15226,6 +15320,35 @@
         return;
       }
 
+      // EV-4952: voice-runtime greets the caller as soon as the call connects
+      // and marks it with {"greeting": {"text"}} before the audio. Show the
+      // text as the bot's bubble now (replacing this call's static welcome,
+      // never duplicating one already on screen) and let the audio that
+      // follows play until turnComplete, even though the user has not spoken.
+      const greetingText = voiceGreetingText(event);
+      if (greetingText) {
+        greetingActiveRef.current = true;
+        setBidiMessages(prev => applyVoiceGreeting(prev, greetingText, voiceWelcomeIdRef.current, voiceTextMessagesRef.current, text => createMessage({
+          id: `bidi-greeting-${Date.now()}`,
+          role: "assistant",
+          content: text,
+          metadata: {
+            source: "bidi"
+          }
+        })));
+        return;
+      }
+      if (greetingActiveRef.current && !userHasSpokenRef.current) {
+        // The greeting's text is already on screen: play its audio only.
+        if (event.content?.parts) {
+          handleContentParts(event.content.parts, Boolean(event.content?.finished || event.finished), true);
+        }
+        if (event.turnComplete) {
+          handleTurnComplete();
+        }
+        return;
+      }
+
       // CRITICAL: Ignore assistant responses until user has spoken
       // This prevents automatic greetings from appearing before user's first message
       if (!userHasSpokenRef.current) {
@@ -15523,6 +15646,8 @@
 
       // Reset userHasSpoken flag when starting new session
       userHasSpokenRef.current = false;
+      greetingActiveRef.current = false;
+      voiceWelcomeIdRef.current = null;
       setBidiMessages(prev => {
         // Don't add welcome message if there are already any messages (either bidi or text)
         // This prevents showing welcome message when turning voice on again after a conversation
@@ -15543,6 +15668,8 @@
             source: "bidi"
           }
         });
+        // Remembered so a spoken greeting (EV-4952) replaces it, not doubles it.
+        voiceWelcomeIdRef.current = welcomeMsg.id;
         return [welcomeMsg];
       });
       connectWebsocket();
@@ -23285,7 +23412,7 @@
    * value by its own test (that constant sat at 0.1.113 while this package was
    * at 0.2.2 precisely because nothing enforced it - EV-2431).
    */
-  const WIDGET_VERSION = '0.2.41';
+  const WIDGET_VERSION = '0.2.42';
 
   /**
    * API utility functions