@agent-native/core 0.95.0 → 0.95.1

package/dist/client/AssistantChat.js

@@ -18,6 +18,7 @@ import { repoHasAssistantMessage, getRepoMessages, getRepoMessage, shouldImportS
 import { BuilderSetupContent, LoopLimitContinueCard, RunErrorRecoveryCard, PlanModeCallout, getLoopLimitMetadata, getRunErrorMetadata, getRequestModeMetadata, } from "./chat/run-recovery.js";
 import { createAgentChatRuntimeAdapter, } from "./chat/runtime.js";
 import { ChatRunningContext, ApprovalContext, ReconnectStreamMessage, } from "./chat/tool-call-display.js";
+import { useReconnectReaderOwner } from "./chat/use-reconnect-reader-owner.js";
 import { MessageScroller, MessageScrollerButton, MessageScrollerContent, MessageScrollerItem, MessageScrollerProvider, MessageScrollerViewport, } from "./components/ui/message-scroller.js";
 import { Popover, PopoverContent, PopoverTrigger, } from "./components/ui/popover.js";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger, } from "./components/ui/tooltip.js";
@@ -396,6 +397,17 @@ function toolCallNameFromContentPart(part) {
 function toolCallIdsRepresentSameLocalCall(renderedId, reconnectId) {
     return renderedId === reconnectId || renderedId.endsWith(`:${reconnectId}`);
 }
+function toolCallIdIsReaderLocal(id) {
+    return (/^tc_\d+$/.test(id) ||
+        /:tc_\d+$/.test(id) ||
+        id.startsWith("reconnect-activity:"));
+}
+function toolCallReaderLocalKey(id) {
+    const counterMatch = id.match(/(?:^|:)(tc_\d+)$/);
+    if (counterMatch?.[1])
+        return counterMatch[1];
+    return id.startsWith("reconnect-activity:") ? id : null;
+}
 function collectRenderedToolCallStates(messages) {
     const byId = new Map();
     for (const message of messages) {
@@ -470,7 +482,7 @@ function latestRenderedAssistantText(messages) {
     return assistantTextFromContent(latestMessage.content);
 }
 function dedupePendingToolCallReplaysWithinContent(content) {
-    const seenLaterFingerprints = new Set();
+    const laterStatesByFingerprint = new Map();
     let changed = false;
     const nextReversed = [];
     for (let i = content.length - 1; i >= 0; i -= 1) {
@@ -478,44 +490,134 @@ function dedupePendingToolCallReplaysWithinContent(content) {
         if (!part)
             continue;
         const fingerprint = toolCallFingerprintFromContentPart(part);
-        if (fingerprint &&
-            !toolCallPartHasResult(part) &&
-            seenLaterFingerprints.has(fingerprint)) {
+        const laterState = fingerprint
+            ? laterStatesByFingerprint.get(fingerprint)
+            : undefined;
+        const id = toolCallIdFromContentPart(part);
+        const readerLocalKey = id ? toolCallReaderLocalKey(id) : null;
+        const isReaderReplay = Boolean(id &&
+            laterState &&
+            (laterState.ids.has(id) ||
+                (readerLocalKey && laterState.readerLocalKeys.has(readerLocalKey)) ||
+                (toolCallIdIsReaderLocal(id) && laterState.hasStableId)));
+        if (fingerprint && !toolCallPartHasResult(part) && isReaderReplay) {
             changed = true;
             continue;
         }
-        if (fingerprint)
-            seenLaterFingerprints.add(fingerprint);
+        if (fingerprint) {
+            const state = laterState ?? {
+                ids: new Set(),
+                readerLocalKeys: new Set(),
+                hasStableId: false,
+            };
+            if (id) {
+                state.ids.add(id);
+                const key = toolCallReaderLocalKey(id);
+                if (key)
+                    state.readerLocalKeys.add(key);
+                else
+                    state.hasStableId = true;
+            }
+            laterStatesByFingerprint.set(fingerprint, state);
+        }
         nextReversed.push(part);
     }
     return changed ? nextReversed.reverse() : content;
 }
-function trimReconnectTextAlreadyRendered(content, renderedAssistantText) {
+function pendingToolCallCountsByName(content) {
+    const counts = new Map();
+    for (const part of content) {
+        const name = toolCallNameFromContentPart(part);
+        if (!name || toolCallProgressRank(part) >= 4)
+            continue;
+        counts.set(name, (counts.get(name) ?? 0) + 1);
+    }
+    return counts;
+}
+/**
+ * Linear-time longest overlap where a suffix of `renderedText` equals a prefix
+ * of `reconnectText`. The reconnect overlay is recalculated during render on
+ * every stream tick, so a descending slice/endsWith scan becomes quadratic on
+ * large repeated output.
+ */
+function longestSuffixPrefixOverlap(renderedText, reconnectText) {
+    const maxOverlap = Math.min(renderedText.length, reconnectText.length);
+    if (maxOverlap === 0)
+        return 0;
+    const pattern = reconnectText.slice(0, maxOverlap);
+    const prefixLengths = new Array(pattern.length).fill(0);
+    for (let index = 1; index < pattern.length; index += 1) {
+        let matched = prefixLengths[index - 1] ?? 0;
+        while (matched > 0 && pattern[index] !== pattern[matched]) {
+            matched = prefixLengths[matched - 1] ?? 0;
+        }
+        if (pattern[index] === pattern[matched])
+            matched += 1;
+        prefixLengths[index] = matched;
+    }
+    let matched = 0;
+    const renderedStart = renderedText.length - maxOverlap;
+    for (let index = renderedStart; index < renderedText.length; index += 1) {
+        const character = renderedText[index];
+        while (matched > 0 && character !== pattern[matched]) {
+            matched = prefixLengths[matched - 1] ?? 0;
+        }
+        if (character === pattern[matched])
+            matched += 1;
+        if (matched === pattern.length && index < renderedText.length - 1) {
+            matched = prefixLengths[matched - 1] ?? 0;
+        }
+    }
+    return matched;
+}
+function trimReconnectTextAlreadyRendered(content, renderedAssistantText, options) {
     if (!renderedAssistantText)
         return content;
-    let remainingOverlap = renderedAssistantText;
+    const reconnectText = assistantTextFromContent(content);
+    if (!reconnectText)
+        return content;
+    let overlapLength = 0;
+    if (reconnectText.startsWith(renderedAssistantText)) {
+        overlapLength = renderedAssistantText.length;
+    }
+    else if (renderedAssistantText.startsWith(reconnectText)) {
+        overlapLength = reconnectText.length;
+    }
+    else if (options?.trimTailOverlap) {
+        const tailOverlap = longestSuffixPrefixOverlap(renderedAssistantText, reconnectText);
+        if (tailOverlap > 0) {
+            // Tail reconnects begin after the last remembered event, so their first
+            // text can be the final suffix of a thread snapshot imported in parallel.
+            // For a partial overlap, require a whole word/phrase boundary so a
+            // coincidental shared character at the join cannot eat legitimate text.
+            const renderedBeforeOverlap = renderedAssistantText[renderedAssistantText.length - tailOverlap - 1];
+            const reconnectAfterOverlap = reconnectText[tailOverlap];
+            const isWordCharacter = (value) => value ? /[\p{L}\p{N}_]/u.test(value) : false;
+            const isWholeBoundary = !isWordCharacter(renderedBeforeOverlap) &&
+                !isWordCharacter(reconnectAfterOverlap);
+            if (tailOverlap === reconnectText.length || isWholeBoundary) {
+                overlapLength = tailOverlap;
+            }
+        }
+    }
+    if (overlapLength === 0)
+        return content;
+    let remainingOverlap = overlapLength;
     let changed = false;
     const next = [];
     for (const part of content) {
-        if (part.type !== "text" || remainingOverlap.length === 0) {
+        if (part.type !== "text" || remainingOverlap === 0) {
             next.push(part);
             continue;
         }
-        if (remainingOverlap.startsWith(part.text)) {
-            remainingOverlap = remainingOverlap.slice(part.text.length);
-            changed = true;
-            continue;
-        }
-        if (part.text.startsWith(remainingOverlap)) {
-            const text = part.text.slice(remainingOverlap.length);
-            remainingOverlap = "";
+        if (part.text.length <= remainingOverlap) {
+            remainingOverlap -= part.text.length;
             changed = true;
-            if (text)
-                next.push({ ...part, text });
             continue;
         }
-        remainingOverlap = "";
-        next.push(part);
+        next.push({ ...part, text: part.text.slice(remainingOverlap) });
+        remainingOverlap = 0;
+        changed = true;
     }
     return changed ? next : content;
 }
@@ -523,6 +625,7 @@ export function dedupeReconnectContentAgainstMessages(content, messages, options
     if (content.length === 0)
         return content;
     const snapshotDeduped = dedupePendingToolCallReplaysWithinContent(content);
+    const reconnectPendingCounts = pendingToolCallCountsByName(snapshotDeduped);
     let changed = snapshotDeduped !== content;
     if (messages.length === 0)
         return changed ? snapshotDeduped : content;
@@ -595,6 +698,25 @@ export function dedupeReconnectContentAgainstMessages(content, messages, options
                 const latestByName = name
                     ? latestAssistantByName.get(name)
                     : undefined;
+                const reconnectPendingCount = name
+                    ? (reconnectPendingCounts.get(name) ?? 0)
+                    : 0;
+                const hasReaderLocalIdentity = Boolean((id && toolCallIdIsReaderLocal(id)) ||
+                    (latestByName &&
+                        Array.from(latestByName.pendingIds).some(toolCallIdIsReaderLocal)));
+                if (options?.suppressToolRepeats &&
+                    latestByName &&
+                    latestByName.pendingIds.size === 1 &&
+                    reconnectPendingCount === 1 &&
+                    hasReaderLocalIdentity &&
+                    latestByName.pendingRank >= reconnectRank) {
+                    // During reconnect -> live-adapter handoff both accumulators own
+                    // the same run. Their pre-tool-start activity cards can have
+                    // unrelated reader-local ids and no args fingerprint, so name +
+                    // pending progress is the only stable identity available.
+                    changed = true;
+                    return false;
+                }
                 const matchesRenderedLocalId = id && latestByName
                     ? Array.from(latestByName.ids).some((renderedId) => toolCallIdsRepresentSameLocalCall(renderedId, id))
                     : false;
@@ -612,7 +734,7 @@ export function dedupeReconnectContentAgainstMessages(content, messages, options
             return true;
         })
         : snapshotDeduped;
-    const textDeduped = trimReconnectTextAlreadyRendered(filtered, renderedAssistantText);
+    const textDeduped = trimReconnectTextAlreadyRendered(filtered, renderedAssistantText, { trimTailOverlap: options?.trimTailTextOverlap });
     if (textDeduped !== filtered)
         changed = true;
     return changed ? textDeduped : content;
@@ -687,16 +809,45 @@ function contentHasVisibleReasoning(content) {
             candidate.text.trim().length > 0);
     });
 }
-export function shouldShowGlobalRunningStatus({ showRunningInUI, runningActivityLabel, latestMessage, reconnectContent, }) {
+function contentHasUnresolvedToolCall(content, toolName) {
+    if (!Array.isArray(content))
+        return false;
+    return content.some((part) => {
+        if (!part || typeof part !== "object")
+            return false;
+        const candidate = part;
+        return (candidate.type === "tool-call" &&
+            candidate.result === undefined &&
+            (!toolName || candidate.toolName === toolName));
+    });
+}
+export function shouldShowGlobalRunningStatus({ showRunningInUI, runningActivityLabel, runningActivityTool, latestMessage, reconnectContent, }) {
     if (!showRunningInUI)
         return false;
-    if (runningActivityLabel)
-        return true;
     const message = latestMessage && typeof latestMessage === "object"
         ? latestMessage
         : null;
     const latestMessageHasReasoning = message?.role === "assistant" &&
         contentHasVisibleReasoning(message.content);
+    const latestMessageHasUnresolvedTool = message?.role === "assistant" &&
+        contentHasUnresolvedToolCall(message.content);
+    const matchingActivityToolIsVisible = Boolean(runningActivityTool &&
+        ((message?.role === "assistant" &&
+            contentHasUnresolvedToolCall(message.content, runningActivityTool)) ||
+            contentHasUnresolvedToolCall(reconnectContent, runningActivityTool)));
+    // A pending card for the same tool is already the running indicator.
+    // Rendering its global activity label as well shows the logical call twice
+    // (for example, `generate design` plus `Writing generate design...`).
+    if (runningActivityLabel && matchingActivityToolIsVisible) {
+        return false;
+    }
+    if (!runningActivityLabel &&
+        (latestMessageHasUnresolvedTool ||
+            contentHasUnresolvedToolCall(reconnectContent))) {
+        return false;
+    }
+    if (runningActivityLabel)
+        return true;
     return (!latestMessageHasReasoning && !contentHasVisibleReasoning(reconnectContent));
 }
 function AssistantChatUserMessageItem() {
@@ -1198,6 +1349,7 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
     const reconnectCanMaterializeRef = useRef(false);
     const reconnectAbortRef = useRef(null);
     const reconnectAutoRecoveryCountRef = useRef(0);
+    const reconnectOwnerMountedRef = useReconnectReaderOwner(reconnectRunIdRef, reconnectAbortRef);
     const [pendingReconnectRecovery, setPendingReconnectRecovery] = useState(null);
     // Nuclear stop: user clicked stop. Clears the stop button/indicator AND
     // lets new submissions go through immediately — prevents the "stuck
@@ -1494,7 +1646,8 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
             (!stopped.runId || !runId || stopped.runId === runId));
     }, []);
     const startReconnectToRun = useCallback((runInfo) => {
-        if (!threadId ||
+        if (!reconnectOwnerMountedRef.current ||
+            !threadId ||
             !runInfo.runId ||
             (runInfo.status !== "running" && !isReplayableTerminalRun(runInfo))) {
             return false;
@@ -1687,6 +1840,10 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
                         rafPending = true;
                         requestAnimationFrame(() => {
                             rafPending = false;
+                            if (!reconnectOwnerMountedRef.current ||
+                                reconnectRunIdRef.current !== runId) {
+                                return;
+                            }
                             setReconnectContent(latestSnapshot);
                         });
                     };
@@ -1745,6 +1902,11 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
                 clearInterval(watchdog);
                 clearInterval(idleCheck);
             }
+            // A newer reader, live adapter, stop action, or component unmount took
+            // ownership while this async loop was unwinding. Do not let the stale
+            // generation refresh/import or update reconnect state afterwards.
+            if (reconnectRunIdRef.current !== runId)
+                return;
             if (noProgressDuringReconnect && reconnectRunIdRef.current === runId) {
                 const reconnectErrorCode = reconnectTerminalReason === "run_timeout"
                     ? "run_timeout"
@@ -2656,6 +2818,7 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
         }
         const stillNeeded = dedupeReconnectContentAgainstMessages(reconnectContent, messages, {
             suppressToolRepeats: true,
+            trimTailTextOverlap: true,
         }).length > 0;
         if (!stillNeeded) {
             setReconnectContent([]);
@@ -3139,7 +3302,10 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
     // Do not memoize this on `messages` identity. assistant-ui can update the
     // live assistant message content in place while streaming, and the reconnect
     // overlay must hide as soon as that live message has caught up.
-    const visibleReconnectContent = dedupeReconnectContentAgainstMessages(reconnectContent, messages, { suppressToolRepeats: adapterHandoffPending });
+    const visibleReconnectContent = dedupeReconnectContentAgainstMessages(reconnectContent, messages, {
+        suppressToolRepeats: adapterHandoffPending,
+        trimTailTextOverlap: adapterHandoffPending || reconnectTailOnlyRef.current,
+    });
     const chatScrollResetKey = `${tabId ?? ""}:${threadId ?? ""}`;
     const { isDevMode: cpDevMode } = useDevMode(apiUrl);
     const checkpointCtx = useMemo(() => ({ apiUrl, devMode: cpDevMode, threadId }), [apiUrl, cpDevMode, threadId]);
@@ -3159,11 +3325,17 @@ const AssistantChatInner = forwardRef(function AssistantChatInner({ emptyStateTe
     const lastUserText = useMemo(() => latestNonRecoveryUserMessageText(messages), [messages]);
     const latestMessage = messages[messages.length - 1];
     const latestMessageRole = latestMessage?.role;
+    const reconnectStatusContent = visibleReconnectContent.length > 0
+        ? visibleReconnectContent
+        : reconnectContent.length === 0
+            ? reconnectActivityContent
+            : [];
     const showGlobalRunningStatus = shouldShowGlobalRunningStatus({
         showRunningInUI,
         runningActivityLabel,
+        runningActivityTool,
         latestMessage,
-        reconnectContent: visibleReconnectContent,
+        reconnectContent: reconnectStatusContent,
     });
     const latestAssistantWasPlan = latestMessageRole === "assistant" &&
         getRequestModeMetadata(latestMessage) === "plan";