@pentoshi/clai 3.11.1 → 3.11.3

package/dist/agent/runner.js

@@ -168,6 +168,37 @@ export async function runAgentTurn(prompt, options = {}) {
     // the normal tool path already surfaced, which would render it twice. Reset
     // at the top of every loop iteration.
     let visibleCommitted = false;
+    let interruptedVisible = "";
+    const trimExactContinuationOverlap = (previous, current, minLength = 32) => {
+        if (previous.length > 0 && current.startsWith(previous)) {
+            return current.slice(previous.length);
+        }
+        const maxLength = Math.min(previous.length, current.length);
+        if (maxLength < minLength)
+            return current;
+        const pattern = current.slice(0, maxLength);
+        const fallback = new Uint32Array(maxLength);
+        for (let index = 1, matched = 0; index < maxLength; index += 1) {
+            while (matched > 0 && pattern[index] !== pattern[matched]) {
+                matched = fallback[matched - 1];
+            }
+            if (pattern[index] === pattern[matched])
+                matched += 1;
+            fallback[index] = matched;
+        }
+        let matched = 0;
+        for (let index = previous.length - maxLength; index < previous.length; index += 1) {
+            while (matched > 0 && previous[index] !== pattern[matched]) {
+                matched = fallback[matched - 1];
+            }
+            if (previous[index] === pattern[matched])
+                matched += 1;
+            if (matched === maxLength && index < previous.length - 1) {
+                matched = fallback[matched - 1];
+            }
+        }
+        return matched >= minLength ? current.slice(matched) : current;
+    };
     const noopSpinner = {
         setLabel: () => { },
         bumpReasoning: () => { },
@@ -331,7 +362,7 @@ export async function runAgentTurn(prompt, options = {}) {
             jobManager.releaseResponderNotificationClaim(notificationId);
         }
     };
-    const finishTurn = (answer, steps, status = "succeeded", remainingCriteria = [], reason) => {
+    const finishTurn = (answer, steps, status = "succeeded", remainingCriteria = [], reason, displayAnswer) => {
         releaseUnreadResponderClaims();
         const outcome = createTurnOutcome(normalizeTurnOutcomeInput({
             status,
@@ -340,13 +371,22 @@ export async function runAgentTurn(prompt, options = {}) {
             remainingCriteria,
             reason,
         }));
-        const rendered = renderTurnOutcome(outcome, {
+        const renderOptions = {
             diagnostics: !suppressOutcomeDiagnostics,
-        });
-        writeAssistantMessage(rendered);
+        };
+        const rendered = renderTurnOutcome(outcome, renderOptions);
+        const displayRendered = displayAnswer === undefined
+            ? rendered
+            : renderTurnOutcome({ ...outcome, answer: displayAnswer }, renderOptions);
+        if (displayRendered.trim()) {
+            writeAssistantMessage(displayRendered);
+        }
+        else if (!writesDirectly) {
+            emit({ type: "assistant-message", text: "" });
+        }
         if (options.onMessages) {
             try {
-                options.onMessages(buildTurnHistory(liveMessages, rendered));
+                options.onMessages(buildTurnHistory(liveMessages, displayRendered));
             }
             catch {
                 // Persisting history must never break the turn.
@@ -3006,6 +3046,7 @@ export async function runAgentTurn(prompt, options = {}) {
             options.signal?.throwIfAborted();
             let call;
             let assistantText;
+            let canonicalAssistantVisible = "";
             let recoveredFromBareJson = false;
             if (pendingCalls.length > 0) {
                 call = pendingCalls.shift();
@@ -3311,15 +3352,16 @@ export async function runAgentTurn(prompt, options = {}) {
                             deltaParser?.finish();
                             const partial = rememberThinkingFromText(accumulatedText);
                             const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
-                            const partialVisible = textBeforeToolCall(stripThinking(collapseRepeatedText(accumulatedText)).visible).trim();
+                            const rawPartialVisible = textBeforeToolCall(stripThinking(collapseRepeatedText(accumulatedText)).visible);
+                            const normalizedPartialVisible = trimExactContinuationOverlap(interruptedVisible, rawPartialVisible);
+                            const partialVisible = normalizedPartialVisible.trim();
                             if (partialVisible) {
-                                if (!hasShownToolCall) {
-                                    writeAssistantMessage(partialVisible);
-                                }
+                                writeAssistantMessage(partialVisible);
                                 pushAssistantHistory(partialVisible);
+                                interruptedVisible += normalizedPartialVisible;
                             }
-                            else if (!writesDirectly && !hasShownToolCall) {
-                                emit({ type: "assistant-message", text: partial.visible });
+                            else if (!writesDirectly) {
+                                emit({ type: "assistant-message", text: "" });
                             }
                             if (partial.hasThinking && !hasShownToolCall) {
                                 writeThinkingBlock(partial.thinkContent);
@@ -3412,11 +3454,16 @@ export async function runAgentTurn(prompt, options = {}) {
                 const usedNativeProtocol = Boolean(completion.toolCalls?.length) ||
                     (toolsAttached && !isTextOnlyModel(provider, model));
                 const assistantTextResult = rememberThinkingFromText(completion.text);
-                assistantText = assistantTextResult;
+                const continuedVisible = trimExactContinuationOverlap(interruptedVisible, assistantTextResult.visible);
+                canonicalAssistantVisible = interruptedVisible + continuedVisible;
+                assistantText = {
+                    ...assistantTextResult,
+                    visible: continuedVisible,
+                };
                 const commitAssistantRetry = (historyText) => {
                     const hasShownToolCall = deferredToolCalls.some((entry) => entry.shown);
                     if (!hasShownToolCall) {
-                        const displayText = textBeforeToolCall(stripThinking(collapseRepeatedText(completion.text)).visible).trim();
+                        const displayText = textBeforeToolCall(collapseRepeatedText(assistantText.visible)).trim();
                         if (displayText) {
                             writeAssistantMessage(displayText);
                         }
@@ -3431,6 +3478,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                     }
                     pushAssistantHistory(historyText);
+                    interruptedVisible = "";
                 };
                 // Only emit a thinking-block event when the classic renderer is
                 // active (writesDirectly / no deltaParser).  In TUI v2 the
@@ -3600,7 +3648,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                     }
                 }
-                if (!assistantText.visible.trim() && !call) {
+                if (!canonicalAssistantVisible.trim() && !call) {
                     emptyVisibleRetries += 1;
                     if (emptyVisibleRetries <= 3) {
                         if (assistantText.hasThinking) {
@@ -3611,7 +3659,7 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                         if (assistantText.hasThinking)
                             retryWithoutThinking = true;
-                        commitAssistantRetry(stripThinking(collapseRepeatedText(completion.text)).visible);
+                        commitAssistantRetry(assistantText.visible);
                         // Keep nudges SHORT — cheap models lose the key instruction in long text.
                         const buildNudge = freshWebSearchRequired && !sawFreshWebSearch
                             ? toolsAttached
@@ -3817,7 +3865,8 @@ export async function runAgentTurn(prompt, options = {}) {
                         }
                         // Exhausted retries — fall through to the normal path.
                     }
-                    const cleaned = collapseRepeatedText(stripSentinelTokens(assistantText.visible));
+                    const displayCleaned = collapseRepeatedText(stripSentinelTokens(assistantText.visible));
+                    const cleaned = collapseRepeatedText(stripSentinelTokens(canonicalAssistantVisible));
                     const narratedAction = looksLikeActionNarration(cleaned);
                     const narratedWebAction = looksLikeWebActionNarration(cleaned);
                     const reconciledPlanAtCompletion = await reconcileOpenTaskBeforeFinalizing();
@@ -4089,13 +4138,12 @@ export async function runAgentTurn(prompt, options = {}) {
                         outcomeStatus,
                         remainingCriteria,
                     });
-                    writeAssistantMessage(cleaned);
                     lastAnswer = cleaned;
                     return finishTurn(lastAnswer, step + 1, outcomeStatus, remainingCriteria, outcomeStatus === "failed"
                         ? "One or more required plan tasks failed."
                         : outcomeStatus === "partial"
                             ? "Required outcome criteria remain unsupported by current evidence."
-                            : undefined);
+                            : undefined, displayCleaned);
                 }
                 // A valid primary tool call exists for this fresh model turn. Show any
                 // prose / thinking that preceded it, record the assistant message ONCE.
@@ -4104,10 +4152,13 @@ export async function runAgentTurn(prompt, options = {}) {
                     : nativeToolCalls.length
                         ? assistantText.visible.trim()
                         : textBeforeToolCall(assistantText.visible);
-                if (beforeTool &&
-                    !deferredToolCalls.some((entry) => entry.shown)) {
+                if (beforeTool) {
                     writeAssistantMessage(beforeTool);
                 }
+                else if (deltaParser) {
+                    emit({ type: "assistant-message", text: "" });
+                }
+                interruptedVisible = "";
                 let bound = [];
                 if (nativeToolCalls.length) {
                     bound = nativeToolCalls.map((tc, index) => {