@meistrari/chat-nuxt 3.16.0-rc.0 → 3.16.0-rc.1

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@meistrari/chat-nuxt",
   "configKey": "chatNuxt",
-  "version": "3.16.0-rc.0",
+  "version": "3.16.0-rc.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/messages/components/chat-message-bubble.vue

@@ -180,13 +180,12 @@ const hasDetectedFiles = computed(() => contentSegments.value.some((s) => s.type
 
         <template v-else>
             <!--
-                A live stream normally owns the pending state, so this block stays
-                out of its way. Stand-in steps are the exception: until the run
-                emits anything the stream has nothing to show, and that silence is
-                exactly what they cover.
+                Mounted for the whole pending turn so activity remains visible
+                while the current streamed chunk is empty between assistant
+                messages or tool phases.
             -->
             <ChatReasoningThought
-                v-if="hasReasoning || preparingSteps?.length && !message.content || isPending && !streamActive"
+                v-if="hasReasoning || isPending"
                 :reasoning-data="message.reasoningData ?? []"
                 :completed="!isPending"
                 :preparing-steps="preparingSteps"

package/dist/runtime/messages/composables/chat.js

@@ -207,12 +207,10 @@ export function useChat(options = {}) {
   );
   const reasoningCache = createReasoningCache();
   const processedMessages = computed(() => {
-    const resolved = resolveReasoningDisplayMessages(messages.value, reasoningCache);
     const messageId = streamingMessageId.value;
     const content = directStream.streamingText.value;
-    if (!messageId || !content)
-      return resolved;
-    return resolved.map((message) => message.id === messageId && (message.status === "pending" || pendingStreamReconciliationIds.value.has(message.id)) ? { ...message, content: resolveStreamingContent(message.content, content) } : message);
+    const overlaid = !messageId || content === null ? messages.value : messages.value.map((message) => message.id === messageId && (message.status === "pending" || pendingStreamReconciliationIds.value.has(message.id)) ? { ...message, content } : message);
+    return resolveReasoningDisplayMessages(overlaid, reasoningCache);
   });
   const stopCondition = computed(
     () => !hasPendingMessage.value && pendingStreamReconciliationIds.value.size === 0
@@ -529,9 +527,9 @@ export function useChat(options = {}) {
           agentSessionExecutable.value = false;
           agentSessionRewakeable.value = false;
         }
+        startPolling();
       };
       let response;
-      let acceptedByStream = false;
       try {
         response = await directStream.connectMessage(
           chatApi.path(`/conversations/${currentConversation.value.id}/messages/stream`),
@@ -542,7 +540,6 @@ export function useChat(options = {}) {
           }),
           acceptMessagePair
         );
-        acceptedByStream = true;
       } catch (streamError) {
         const statusCode = getChatApiErrorStatus(streamError);
         if (statusCode !== null && statusCode >= 400 && statusCode < 500)
@@ -565,8 +562,6 @@ export function useChat(options = {}) {
           "user"
         );
       }
-      if (!acceptedByStream)
-        startPolling();
       return response.userMessage;
     } catch (err) {
       const code = getChatApiErrorCode(err);

package/dist/runtime/messages/composables/use-direct-stream.js

@@ -115,7 +115,7 @@ function reviveMessagePair(input) {
 }
 export function useDirectStream(options = {}) {
   const activity = ref("idle");
-  const streamingText = ref("");
+  const streamingText = ref(null);
   const streamingThinking = ref("");
   const activeRunId = ref(null);
   let accumulator = createMessagePartsAccumulator();
@@ -123,7 +123,7 @@ export function useDirectStream(options = {}) {
   function resetAccumulator(runId = null) {
     accumulator = createMessagePartsAccumulator(runId);
     activeRunId.value = runId;
-    streamingText.value = "";
+    streamingText.value = null;
     streamingThinking.value = "";
   }
   function beginMessage() {
@@ -199,7 +199,7 @@ export function useDirectStream(options = {}) {
       if (status === "completed" || status === "waiting_messages") {
         const result = {
           status,
-          text: streamingText.value
+          text: streamingText.value ?? ""
         };
         if (!optimisticResultReported) {
           optimisticResultReported = true;
@@ -287,11 +287,11 @@ export function useDirectStream(options = {}) {
             if (event.kind !== "message-parts" || typeof event.runId !== "string" || typeof event.deltaSeq !== "number" || !Number.isInteger(event.deltaSeq) || event.deltaSeq < 0 || !isRecord(event.event)) {
               continue;
             }
-            const accumulated = applyMessagePartsEvent(accumulator, event);
+            const current = applyMessagePartsEvent(accumulator, event);
             activeRunId.value = accumulator.runId;
-            if (accumulated.changed) {
-              streamingText.value = accumulated.text;
-              streamingThinking.value = accumulated.thinking;
+            if (current.changed) {
+              streamingText.value = current.text;
+              streamingThinking.value = current.thinking;
             }
           }
         }

package/dist/runtime/messages/message-reasoning.d.ts

@@ -1,11 +1,18 @@
 import type { Message } from '../types/schemas/chat/conversations.js';
 import type { ReasoningStep } from './reasoning.js';
+type ParsedReasoning = {
+    steps: ReasoningStep[];
+    thinkingTexts: Set<string>;
+    currentAnswerParts: string[];
+    currentAnswerStepTexts: Set<string>;
+};
 export type ReasoningCache = {
-    bySignature: Map<string, ReasoningStep[]>;
+    bySignature: Map<string, ParsedReasoning>;
     byReference: WeakMap<unknown[], {
         messageId: string;
-        parsedSteps: ReasoningStep[];
+        parsed: ParsedReasoning;
     }>;
 };
 export declare function createReasoningCache(): ReasoningCache;
 export declare function resolveReasoningDisplayMessages(messages: Message[], cache?: ReasoningCache): Message[];
+export {};

package/dist/runtime/messages/message-reasoning.js

@@ -46,27 +46,30 @@ function groupReasoningSteps(parsedSteps) {
 function getReasoningCacheKey(messageId, reasoningData) {
   return `${messageId}:${JSON.stringify(reasoningData)}`;
 }
-function getParsedReasoningSteps(cache, messageId, reasoningData) {
+function getParsedReasoning(cache, messageId, reasoningData) {
   const referenceHit = cache.byReference.get(reasoningData);
   if (referenceHit?.messageId === messageId)
-    return referenceHit.parsedSteps;
+    return referenceHit.parsed;
   const cacheKey = getReasoningCacheKey(messageId, reasoningData);
-  let parsedSteps = cache.bySignature.get(cacheKey);
-  if (!parsedSteps) {
-    parsedSteps = parseReasoningFromPolling(reasoningData);
+  let parsed = cache.bySignature.get(cacheKey);
+  if (!parsed) {
+    parsed = parseReasoningFromPolling(reasoningData);
     for (const staleKey of cache.bySignature.keys()) {
       if (staleKey.startsWith(`${messageId}:`))
         cache.bySignature.delete(staleKey);
     }
-    cache.bySignature.set(cacheKey, parsedSteps);
+    cache.bySignature.set(cacheKey, parsed);
   }
-  cache.byReference.set(reasoningData, { messageId, parsedSteps });
-  return parsedSteps;
+  cache.byReference.set(reasoningData, { messageId, parsed });
+  return parsed;
 }
 function parseReasoningFromPolling(reasoning) {
   const allSteps = [];
   const seenContentIds = /* @__PURE__ */ new Set();
   const seenTexts = /* @__PURE__ */ new Set();
+  const thinkingTexts = /* @__PURE__ */ new Set();
+  let currentAnswerParts = [];
+  let currentAnswerStepTexts = /* @__PURE__ */ new Set();
   for (const item of reasoning) {
     if (!item || typeof item !== "object")
       continue;
@@ -98,15 +101,23 @@ function parseReasoningFromPolling(reasoning) {
       const message = itemObj.message;
       if (!Array.isArray(message.content))
         continue;
+      const answerParts = [];
+      const answerStepTexts = /* @__PURE__ */ new Set();
       for (const contentPart of message.content) {
         if (!contentPart || typeof contentPart !== "object")
           continue;
         const part = contentPart;
-        if (part.type === "text" && typeof part.text === "string") {
+        if ((part.type === "text" || part.type === "thinking") && typeof part.text === "string") {
+          if (part.type === "text")
+            answerParts.push(part.text);
+          if (part.type === "thinking")
+            thinkingTexts.add(part.text);
           if (seenTexts.has(part.text))
             continue;
           seenTexts.add(part.text);
           allSteps.push(part.text);
+          if (part.type === "text")
+            answerStepTexts.add(part.text);
         } else if (part.type === "tool_use" && part.id && part.name) {
           const toolId = part.id;
           if (seenContentIds.has(`tool_use:${toolId}`))
@@ -130,6 +141,10 @@ function parseReasoningFromPolling(reasoning) {
           });
         }
       }
+      if (!itemObj.parent_tool_use_id && answerParts.length > 0) {
+        currentAnswerParts = answerParts;
+        currentAnswerStepTexts = answerStepTexts;
+      }
     } else if (itemObj.type === "text" && typeof itemObj.text === "string") {
       if (seenTexts.has(itemObj.text))
         continue;
@@ -158,21 +173,23 @@ function parseReasoningFromPolling(reasoning) {
       });
     }
   }
-  return groupReasoningSteps(allSteps);
+  return { steps: groupReasoningSteps(allSteps), thinkingTexts, currentAnswerParts, currentAnswerStepTexts };
 }
 export function resolveReasoningDisplayMessages(messages, cache = createReasoningCache()) {
   const renderedSteps = /* @__PURE__ */ new Set();
   return messages.map((message) => {
     if (message.role !== "assistant" || !message.reasoningData || !Array.isArray(message.reasoningData))
       return message;
-    const parsedSteps = getParsedReasoningSteps(cache, message.id, message.reasoningData);
+    const parsed = getParsedReasoning(cache, message.id, message.reasoningData);
     const displaySteps = [];
-    for (const step of parsedSteps) {
+    const currentAnswerMatches = message.content === parsed.currentAnswerParts.join("");
+    for (const step of parsed.steps) {
       const key = getReasoningStepKey(step);
       if (renderedSteps.has(key))
         continue;
-      if (typeof step === "string" && message.content && step === message.content)
+      if (typeof step === "string" && currentAnswerMatches && parsed.currentAnswerStepTexts.has(step) && !parsed.thinkingTexts.has(step)) {
         continue;
+      }
       renderedSteps.add(key);
       displaySteps.push(step);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meistrari/chat-nuxt",
-  "version": "3.16.0-rc.0",
+  "version": "3.16.0-rc.1",
   "type": "module",
   "exports": {
     ".": {