@eshal-bot/chat-widget 0.2.7 → 0.2.9

package/dist/chat-widget.esm.js

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

package/dist/chat-widget.js

@@ -8372,7 +8372,7 @@
       stale: s.stale
     })).filter(s => s.source_id || s.url || s.source_type === 'database') : [];
   };
-  const processStream = async (stream, setMessages) => {
+  const processStream = async (stream, setMessages, onTerminal) => {
     const updateMessage = createMessageUpdater(setMessages);
     const reader = stream.getReader();
     const decoder = new TextDecoder();
@@ -8388,6 +8388,35 @@
     // closes without one, the connection dropped mid-response and we
     // throw IncompleteStreamError so the caller can retry.
     let streamCompleted = false;
+    // The id of THIS turn's assistant bubble, captured when the terminal
+    // event finalizes it. Used to address the trailing chips chunk below:
+    // once the composer unlocks at `complete`, "the last message" may
+    // already belong to a NEWER turn.
+    let turnAssistantId = null;
+
+    // EV-2872 completion: the backend emits `complete` WITHOUT waiting for
+    // chip generation, precisely so the composer can unlock at last-token
+    // time - then keeps the stream open for the trailing
+    // {type:'follow_up_prompts'} chunk and [DONE]. Measured on dev
+    // 2026-09-18, that tail runs 5.9-7.5s (budgeted up to 15s by
+    // RAG_AUTO_PROMPT_TIMEOUT_S), and the widget spent all of it with the
+    // composer disabled because the caller only cleared isLoading when the
+    // HTTP body closed. Firing here hands the caller the real unlock point
+    // while the reader keeps draining the chips in the background. Fires
+    // at most ONCE per stream, from whichever terminal event arrives first.
+    const markTerminal = () => {
+      if (streamCompleted) return;
+      streamCompleted = true;
+      if (typeof onTerminal === 'function') {
+        try {
+          onTerminal();
+        } catch (cbErr) {
+          // A caller-side throw must never turn a delivered answer into a
+          // dropped stream (the catch below would surface it as a retry).
+          console.warn('[chat] onTerminal callback threw:', cbErr);
+        }
+      }
+    };
     try {
       while (true) {
         const {
@@ -8460,7 +8489,7 @@
             // would retry-send the message 3× and render an error bubble). The
             // human agent's reply arrives via the SSE EventSource instead.
             if (parsed.type === 'human_handoff') {
-              streamCompleted = true;
+              markTerminal();
               continue;
             }
 
@@ -8474,7 +8503,7 @@
             // just get suppressed again). Mirrors packages/frontend/src/
             // services/ChatService.ts's handling of this event.
             if (parsed.type === 'duplicate_suppressed') {
-              streamCompleted = true;
+              markTerminal();
               continue;
             }
 
@@ -8494,14 +8523,25 @@
                 setMessages(prev => {
                   const updated = [...(prev || [])];
                   const lastMsg = updated[updated.length - 1];
-                  if (lastMsg && lastMsg.role === 'assistant') {
-                    // Same storage shape updateFinalMessage uses on the
-                    // complete chunk: message.prompts, normalized.
-                    updated[updated.length - 1] = {
-                      ...lastMsg,
-                      prompts: normalizePrompts(latePrompts)
-                    };
+                  if (!lastMsg || lastMsg.role !== 'assistant') return prev;
+                  // The composer now unlocks at `complete`, so by the time this
+                  // chunk lands the user may already have asked the NEXT
+                  // question - in which case the last message belongs to that
+                  // turn, and writing our chips onto it would caption a new
+                  // answer with the old one's follow-ups. Worse, sendMessage
+                  // deliberately clears prior chips on every send (EV-3080:
+                  // stale chips must never look current), so this write would
+                  // undo that. Land the chips only while this turn's bubble is
+                  // still the one in front of the user; otherwise drop them.
+                  if (turnAssistantId != null && lastMsg.id !== turnAssistantId) {
+                    return prev;
                   }
+                  // Same storage shape updateFinalMessage uses on the
+                  // complete chunk: message.prompts, normalized.
+                  updated[updated.length - 1] = {
+                    ...lastMsg,
+                    prompts: normalizePrompts(latePrompts)
+                  };
                   return updated;
                 });
               }
@@ -8570,7 +8610,6 @@
 
             // Handle complete events
             if (parsed.type === 'complete') {
-              streamCompleted = true;
               // Normalize Sources from stream. citation_indices are
               // preserved so <CitationPill> resolves [N] markers past the
               // inline-cite filter; database "Data used" entries keep their
@@ -8614,6 +8653,13 @@
               setMessages(prev => {
                 const updatedMessages = [...(prev || [])];
                 const lastMessage = updatedMessages[updatedMessages.length - 1];
+                if (lastMessage?.role === 'assistant') {
+                  // Remember which bubble this turn owns, before the composer
+                  // unlocks below and a newer turn can append past it. The
+                  // assignment is idempotent (same id every call), so a
+                  // StrictMode double-invoke is harmless.
+                  turnAssistantId = lastMessage.id ?? null;
+                }
                 if (lastMessage?.role === 'assistant' && (sources.length > 0 || lastMessage.sourcesPreliminary)) {
                   const {
                     sourcesPreliminary,
@@ -8629,6 +8675,11 @@
                 }
                 return updatedMessages;
               });
+
+              // Answer + citations are committed - release the composer now
+              // rather than after the trailing chips chunk and [DONE]. The
+              // reader keeps draining below.
+              markTerminal();
               continue;
             }
 
@@ -8679,11 +8730,19 @@
 
           // Handle finish_reason (stream complete)
           if (parsed.choices?.[0]?.finish_reason && parsed.choices[0].finish_reason !== null) {
-            streamCompleted = true;
             const metadata = {
               prompts: parsed.prompts
             };
             updateFinalMessage(setMessages, accumulatedText.current, metadata);
+            // Same bubble capture the `complete` branch does, so this terminal
+            // shape gets the same late-chip targeting. Read-only: returning
+            // `prev` unchanged makes React bail out of the re-render.
+            setMessages(prev => {
+              const last = (prev || [])[(prev || []).length - 1];
+              if (last?.role === 'assistant') turnAssistantId = last.id ?? null;
+              return prev;
+            });
+            markTerminal();
           }
         }
       }
@@ -12041,6 +12100,15 @@
     // call before any state mutation runs.
     const isSendingRef = reactExports.useRef(false);
 
+    // Monotonic id for each sendMessage call. Since the composer now unlocks at
+    // the stream's `complete` event rather than when the HTTP body closes, turn
+    // N's stream is still draining its trailing chips chunk while turn N+1 may
+    // already be in flight - so turn N's `finally` would otherwise clear the
+    // loading state that belongs to turn N+1 and unlock the composer mid-answer.
+    // Every release is stamped with the send it came from and ignored when a
+    // newer send has taken over.
+    const sendSeqRef = reactExports.useRef(0);
+
     // Bidi/Voice state
     const [isConversationLoading, setIsConversationLoading] = reactExports.useState(false);
     const [isVoiceSessionActive, setIsVoiceSessionActive] = reactExports.useState(false);
@@ -12603,6 +12671,13 @@
         };
       }
       isSendingRef.current = true;
+      const mySendSeq = sendSeqRef.current += 1;
+      // Idempotent, and a no-op once a newer send owns the composer.
+      const releaseComposer = () => {
+        if (sendSeqRef.current !== mySendSeq) return;
+        setIsLoading(false);
+        isSendingRef.current = false;
+      };
       if (trimmed === HANDOFF_TRIGGER) {
         const fireWidgetHandoff = async () => {
           if (apiBaseUrl && bidiSessionId) {
@@ -12877,7 +12952,15 @@
               // exactly the attempt that is streaming.
               streamAbortRef.current = new AbortController();
               const stream = await sendStreamingRequest(chatRequest, apiBaseUrl, getAuthToken, streamAbortRef.current.signal);
-              await processStream(stream, setMessages);
+              // EV-2872 completion: unlock the composer on the stream's
+              // terminal event (`complete`), not when the body closes. The
+              // backend holds the stream open after `complete` for the
+              // trailing suggestion-chip chunk - measured at 5.9-7.5s on dev
+              // 2026-09-18, budgeted up to 15s - and the customer spent all of
+              // it unable to type their next question. Retries are unaffected:
+              // IncompleteStreamError is only thrown when NO terminal event
+              // arrived, so nothing that reaches this callback is ever retried.
+              await processStream(stream, setMessages, releaseComposer);
               setUserMessageStatus(sentUserMessageId, "sent");
               updateActivity(organizationId);
               return {
@@ -12956,9 +13039,14 @@
         // input until the next regular message ran. setIsLoading(false) is
         // a no-op when it's already false, so widening the condition can't
         // regress the inquiry/complaint/technical path.
-        setIsLoading(false);
-        // UX-M09: release the concurrency guard so the next send can proceed.
-        isSendingRef.current = false;
+        //
+        // Still the ONLY release for every non-streaming path (onboarding,
+        // handoff, the error branches above) and the backstop for a stream
+        // that ends without a terminal event. Streaming turns have usually
+        // released already, at `complete`; this call is then a no-op. It is
+        // sequence-guarded so a turn whose chips are still draining cannot
+        // unlock the composer out from under the turn that followed it.
+        releaseComposer();
       }
     }, [apiBaseUrl, apiKey, getNextMessageId, getAuthToken, messages, bidiSessionId, routingChoice, widgetFilter, provideCitations]);
 
@@ -20893,7 +20981,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.7';
+  const WIDGET_VERSION = '0.2.9';
 
   /**
    * API utility functions