@helpai/elements 0.50.7 → 0.51.0

package/web-component.mjs

@@ -1794,7 +1794,7 @@ function createAuth(opts) {
 }
 
 // src/core/version.ts
-var ELEMENTS_VERSION = true ? "0.50.7" : "0.0.0-dev";
+var ELEMENTS_VERSION = true ? "0.51.0" : "0.0.0-dev";
 var ELEMENTS_VERSION_PARAM = "_ev";
 
 // src/stream/types.ts
@@ -2071,6 +2071,13 @@ var AgentTransport = class {
     // (visitor, conversation) pair.
     __publicField(this, "visitorId");
     __publicField(this, "conversationId");
+    /**
+     * Outcome of the most recent `resumeStream()` once it found NO replayable SSE — drives the App's
+     * dangling-turn recovery. `live` = a stream was replayed; otherwise the server's JSON recovery status.
+     * `needs-generation` means a durable user turn has no reply (e.g. a fast send→refresh aborted the
+     * deferred LLM run) → the App re-sends to generate it. Reset at the start of each `resumeStream()`.
+     */
+    __publicField(this, "resumeStatus");
     // Host-asserted context (sanitised `userContext` / `pageContext`), refreshed via
     // `setContext` and carried as the envelope's optional `context` so the backend
     // always sees the visitor's latest context as they navigate.
@@ -2427,6 +2434,7 @@ var AgentTransport = class {
   resumeStream() {
     const ctrl = new AbortController();
     const seenIds = /* @__PURE__ */ new Set();
+    this.resumeStatus = void 0;
     const iter = this.resumeStreamGen(ctrl, seenIds, true);
     return { iter, cancel: () => ctrl.abort() };
   }
@@ -2481,6 +2489,15 @@ var AgentTransport = class {
         log5.debug("resume \u2192 no in-flight stream", { status: res.status });
         return;
       }
+      const contentType = res.headers.get("content-type") ?? "";
+      if (!contentType.includes("text/event-stream")) {
+        const status = await res.json().then((body) => body.status).catch(() => void 0);
+        log5.debug("resume \u2192 no live stream (status response)", { status, attempt });
+        if (status === "pending" && attempt < MAX_RESUME_ATTEMPTS) continue;
+        this.resumeStatus = status === "needs-generation" ? "needs-generation" : "completed";
+        return;
+      }
+      this.resumeStatus = "live";
       const before = seenIds.size;
       if (yield* this.drain(parseChatStream(res, ctrl.signal), seenIds, ctrl)) return;
       if (seenIds.size === before) {
@@ -2700,6 +2717,7 @@ function toReactive(m) {
     role: m.role,
     createdAt: m.createdAt,
     status: m.status,
+    canceled: m.canceled,
     errorText: m.errorText,
     finishReason: m.finishReason,
     serverMessageId: m.serverMessageId,
@@ -2763,7 +2781,11 @@ function fromWireMessage(w) {
     // Real send time when the backend provides it; otherwise fall back to now
     // (older backends) so the timestamp + day divider still render.
     createdAt: parseWireDate(w.createdAt) ?? Date.now(),
-    status: "complete",
+    // Map the persisted terminal status onto the bubble's render state: `failed` → an error bubble;
+    // `canceled` → `complete` + the `canceled` flag (an empty canceled turn is hidden on render — see
+    // `message-bubble`); everything else is a normal completed turn.
+    status: w.status === "failed" ? "error" : "complete",
+    canceled: w.status === "canceled",
     partsSig: signal(parts)
   };
 }
@@ -2773,6 +2795,7 @@ function fromReactive(m) {
     role: m.role,
     createdAt: m.createdAt,
     status: m.status,
+    canceled: m.canceled,
     errorText: m.errorText,
     finishReason: m.finishReason,
     serverMessageId: m.serverMessageId,
@@ -2788,11 +2811,16 @@ function assistantText(m) {
   }
   return out;
 }
-function isEmptyAssistantReply(m) {
-  if (m.role !== "assistant" || m.status === "streaming") return false;
+function hasNoVisibleAnswer(m) {
   if (assistantText(m).trim() !== "") return false;
   return !m.partsSig.value.some((p36) => p36.kind === "tool" || p36.kind === "file" || p36.kind === "source");
 }
+function isEmptyAssistantReply(m) {
+  return m.role === "assistant" && m.status !== "streaming" && hasNoVisibleAnswer(m);
+}
+function isHiddenCanceledTurn(m) {
+  return m.canceled === true && isEmptyAssistantReply(m);
+}
 function partToReactive(p36) {
   if (p36.kind === "text" || p36.kind === "reasoning") {
     return { kind: p36.kind, id: p36.id, textSig: signal(p36.text), doneSig: signal(p36.done) };
@@ -2952,6 +2980,8 @@ var StreamReducer = class {
         return;
       case "data-notification":
         return;
+      case "data-conversation-rebind":
+        return;
       default: {
         const _exhaustive = chunk;
         void _exhaustive;
@@ -5664,6 +5694,7 @@ function MessageBubble({
   const parts = useComputed5(() => message.partsSig.value);
   const partList = parts.value;
   const emptyReply = useComputed5(() => isEmptyAssistantReply(message));
+  const hideCanceledHusk = useComputed5(() => isHiddenCanceledTurn(message));
   const hasAnswerText = useComputed5(
     () => message.partsSig.value.some((part) => part.kind === "text" && part.textSig.value.length > 0)
   );
@@ -5674,6 +5705,7 @@ function MessageBubble({
   const bufferedHold = responseMode === "buffered" && streaming;
   const working = streaming && !hasAnswerText.value;
   const showStreamDots = streaming && !bufferedHold && !(reasoningVisible.value && working);
+  if (hideCanceledHusk.value) return null;
   const stamp = formatStamp(message.createdAt);
   return /* @__PURE__ */ jsx18("div", { class: `${p17}-bubble-row`, "data-role": message.role, "data-testid": tid(TID.messageBubble, message.id), children: /* @__PURE__ */ jsxs15("div", { class: `${p17}-bubble-col`, children: [
     /* @__PURE__ */ jsxs15("div", { class: `${p17}-bubble`, children: [
@@ -6016,6 +6048,7 @@ function MessageList({
     }
   };
   for (const m of messages.value) {
+    if (m.role === "assistant" && m.id !== lastId && isEmptyAssistantReply(m)) continue;
     flushMarkersBefore(m.createdAt);
     const day = dayKey(m.createdAt);
     if (day && day !== prevDay) {
@@ -7473,6 +7506,9 @@ function allToolPartsSettled(msg) {
     return s === "output-available" || s === "output-error" || s === "output-denied" || s === "approval-responded";
   });
 }
+function isAbortError(error) {
+  return error instanceof DOMException ? error.name === "AbortError" : error?.name === "AbortError";
+}
 function App({ options, hostElement, bus }) {
   const [persistence] = useState14(
     () => createPersistence(options.widgetId, options.storage, options.aiAgentDeploymentId)
@@ -7615,6 +7651,8 @@ function App({ options, hostElement, bus }) {
   const homeNavSeeded = useRef9(false);
   const resumeActiveRef = useRef9(false);
   const resumeBubbleRef = useRef9(null);
+  const regenerateDanglingRef = useRef9(null);
+  const regenInFlightRef = useRef9(false);
   useEffect16(() => {
     if (!conversationReady || homeNavSeeded.current) return;
     homeNavSeeded.current = true;
@@ -7684,6 +7722,7 @@ function App({ options, hostElement, bus }) {
         } else {
           messagesSig.value = withWelcomeRows([], markers);
         }
+        if (transport.resumeStatus === "needs-generation") regenerateDanglingRef.current?.();
       } catch (err) {
         if (isStale()) return;
         log16.warn("loadThread failed; resetting conversationId", { err, conversationId });
@@ -7813,11 +7852,28 @@ function App({ options, hostElement, bus }) {
   useEffect16(() => {
     if (effectiveLocale !== activeLocale) setActiveLocale(effectiveLocale);
   }, [effectiveLocale, activeLocale]);
+  const adoptConversationRebind = useCallback6(
+    (chunk) => {
+      if (chunk.type !== "data-conversation-rebind") return false;
+      const next = chunk.data?.conversationId;
+      if (next && next !== conversationIdSig.value) {
+        const previous = conversationIdSig.value;
+        conversationIdSig.value = next;
+        persistence.saveConversationId(next);
+        transport.primeIdentity(void 0, next);
+        log16.info("conversation rebound (in-stream)", { previous, current: next });
+        if (previous) bus.emit("conversationRebound", { previous, current: next, reason: next });
+      }
+      return true;
+    },
+    [conversationIdSig, persistence, transport, bus]
+  );
   const runResume = useCallback6(
     async (handle) => {
       let bubble = null;
       try {
         for await (const evt of handle.iter) {
+          if (adoptConversationRebind(evt.chunk)) continue;
           if (!bubble) {
             bubble = makeAssistantMessage();
             resumeBubbleRef.current = bubble;
@@ -7861,7 +7917,7 @@ function App({ options, hostElement, bus }) {
         }
       }
     },
-    [reducer, messagesSig, feedback, bus, options, homeNav]
+    [reducer, messagesSig, feedback, bus, options, homeNav, adoptConversationRebind]
   );
   const resumeHandleRef = useRef9(null);
   useEffect16(() => {
@@ -7886,16 +7942,22 @@ function App({ options, hostElement, bus }) {
         setFormsReady(true);
       }
     })();
-    if (pendingThreadRef.current) {
-      pendingThreadRef.current = false;
-      const persisted = conversationIdSig.value;
-      if (persisted) void loadThread(persisted);
-    }
-    if (conversationIdSig.value) {
-      const handle = transport.resumeStream();
-      resumeHandleRef.current = handle;
-      void runResume(handle);
-    }
+    void (async () => {
+      const tasks = [];
+      if (pendingThreadRef.current) {
+        pendingThreadRef.current = false;
+        const persisted = conversationIdSig.value;
+        if (persisted) tasks.push(loadThread(persisted));
+      }
+      if (conversationIdSig.value) {
+        const handle = transport.resumeStream();
+        resumeHandleRef.current = handle;
+        tasks.push(runResume(handle));
+      }
+      if (tasks.length === 0) return;
+      await Promise.allSettled(tasks);
+      if (transport.resumeStatus === "needs-generation") regenerateDanglingRef.current?.();
+    })();
   }, [activated]);
   const formsLocaleRef = useRef9(null);
   useEffect16(() => {
@@ -7968,6 +8030,7 @@ function App({ options, hostElement, bus }) {
       setActiveCancel(() => handle.cancel);
       try {
         for await (const evt of handle.iter) {
+          if (adoptConversationRebind(evt.chunk)) continue;
           reducer.apply(evt.chunk);
           if (evt.chunk.type === "finish" && evt.chunk.canContinue === false) {
             setCanSend(false);
@@ -7988,11 +8051,19 @@ function App({ options, hostElement, bus }) {
           emitMessage(bus, options, "assistant", assistantText(assistantMsg));
         }
       } catch (error) {
-        assistantMsg.status = "error";
-        assistantMsg.errorText = errorMessageFor(error, options.strings);
-        feedback.play("error");
-        bus.emit("error", error);
-        options.onError?.(error);
+        if (isAbortError(error)) {
+          if (hasNoVisibleAnswer(assistantMsg)) {
+            messagesSig.value = messagesSig.value.filter((m) => m !== assistantMsg);
+          } else {
+            assistantMsg.status = "complete";
+          }
+        } else {
+          assistantMsg.status = "error";
+          assistantMsg.errorText = errorMessageFor(error, options.strings);
+          feedback.play("error");
+          bus.emit("error", error);
+          options.onError?.(error);
+        }
       } finally {
         reducer.detach();
         setStreaming(false);
@@ -8000,8 +8071,35 @@ function App({ options, hostElement, bus }) {
         messagesSig.value = [...messagesSig.value];
       }
     },
-    [transport, reducer, messagesSig, conversationIdSig, options, bus, feedback, persistence, visitorId]
+    [
+      transport,
+      reducer,
+      messagesSig,
+      conversationIdSig,
+      options,
+      bus,
+      feedback,
+      persistence,
+      visitorId,
+      adoptConversationRebind
+    ]
   );
+  const regenerateDanglingTurn = useCallback6(() => {
+    if (streaming || regenInFlightRef.current || resumeBubbleRef.current) return;
+    const last = messagesSig.value.filter((m) => !m.ephemeral).at(-1);
+    if (last?.role !== "user") return;
+    regenInFlightRef.current = true;
+    log16.info("regenerating dangling user turn (needs-generation)");
+    const assistantMsg = makeAssistantMessage();
+    messagesSig.value = [...messagesSig.value, assistantMsg];
+    reducer.attach(assistantMsg);
+    void streamAssistant(assistantMsg, { continueExisting: false }).finally(() => {
+      regenInFlightRef.current = false;
+    });
+  }, [streaming, messagesSig, reducer, streamAssistant]);
+  useEffect16(() => {
+    regenerateDanglingRef.current = regenerateDanglingTurn;
+  }, [regenerateDanglingTurn]);
   const decideTool = useCallback6(
     (toolCallId, mutate) => {
       if (streaming) return;