gsd-pi 2.74.0 → 2.75.0-dev.fd2382b9f

package/packages/pi-coding-agent/dist/modes/interactive/controllers/chat-controller.js

@@ -10,6 +10,10 @@ let lastProcessedContentIndex = 0;
 // the assistant content array for a new provider sub-turn within one lifecycle.
 let lastContentLength = 0;
 let renderedSegments = [];
+// When providers reuse one assistant lifecycle across internal sub-turns,
+// a content[] shrink resets renderedSegments. Keep the displaced segments so
+// claude-code MCP pruning can remove stale provisional text later.
+let orphanedSegments = [];
 function hasVisibleAssistantContent(message) {
     return message.content.some((c) => (c.type === "text" && typeof c.text === "string" && c.text.trim().length > 0)
         || (c.type === "thinking" && typeof c.thinking === "string" && c.thinking.trim().length > 0));
@@ -17,11 +21,10 @@ function hasVisibleAssistantContent(message) {
 function hasAssistantToolBlocks(message) {
     return message.content.some((c) => c.type === "toolCall" || c.type === "serverToolUse");
 }
-// Pick the latest non-empty text block that appears strictly before the most
-// recent tool call. Text blocks that come after the last tool call are still
-// streaming live into the chat container, so mirroring them into the pinned
-// "Latest Output" zone would render the same tokens twice.
-export function findLatestPinnableText(contentBlocks) {
+// Pinnable text candidates: non-empty text blocks that appear strictly before
+// the most recent tool call, returned newest-first. Text blocks after the last
+// tool call are still streaming live into the chat container.
+export function findLatestPinnableCandidates(contentBlocks) {
     let lastToolIdx = -1;
     for (let i = contentBlocks.length - 1; i >= 0; i--) {
         const c = contentBlocks[i];
@@ -30,13 +33,38 @@ export function findLatestPinnableText(contentBlocks) {
             break;
         }
     }
+    const out = [];
     for (let i = lastToolIdx - 1; i >= 0; i--) {
         const c = contentBlocks[i];
         if (c?.type === "text" && typeof c.text === "string" && c.text.trim()) {
-            return c.text.trim();
+            out.push({ text: c.text.trim(), contentIndex: i });
+        }
+    }
+    return out;
+}
+export function findLatestPinnableText(contentBlocks) {
+    return findLatestPinnableCandidates(contentBlocks)[0]?.text ?? "";
+}
+// Sum rendered line counts of segments that appear strictly after the given
+// content-block index. Used to decide whether a pinnable text block has
+// scrolled out of the viewport and therefore warrants mirroring.
+function rowsRenderedAfterContentIndex(contentIndex, width) {
+    let rows = 0;
+    for (const seg of renderedSegments) {
+        try {
+            if (seg.kind === "text-run" && seg.startIndex > contentIndex) {
+                rows += seg.component.render(width).length;
+            }
+            else if (seg.kind === "tool" && seg.contentIndex > contentIndex) {
+                rows += seg.component.render(width).length;
+            }
+        }
+        catch {
+            // Defensive: a component that throws during measurement shouldn't
+            // destabilize pinned-zone logic. Skip it.
         }
     }
-    return "";
+    return rows;
 }
 // Tracks the latest assistant text for the pinned message zone
 let lastPinnedText = "";
@@ -51,6 +79,7 @@ export async function handleAgentEvent(host, event) {
         await host.init();
     }
     host.footer.invalidate();
+    const timestampFormat = host.settingsManager.getTimestampFormat();
     // Reset content index tracker and pinned state when a new assistant message starts
     if (event.type === "message_start" && event.message.role === "assistant") {
         lastProcessedContentIndex = 0;
@@ -58,6 +87,7 @@ export async function handleAgentEvent(host, event) {
         lastPinnedText = "";
         hasToolsInTurn = false;
         renderedSegments = [];
+        orphanedSegments = [];
         if (pinnedBorder)
             pinnedBorder.stopSpinner();
         pinnedBorder = undefined;
@@ -78,6 +108,7 @@ export async function handleAgentEvent(host, event) {
                     lastPinnedText = "";
                     hasToolsInTurn = false;
                     renderedSegments = [];
+                    orphanedSegments = [];
                     lastContentLength = 0;
                     if (pinnedBorder)
                         pinnedBorder.stopSpinner();
@@ -184,6 +215,10 @@ export async function handleAgentEvent(host, event) {
                 // content (#4144 regression). Prior sub-turn children stay in
                 // chatContainer as frozen history; new segments append after them.
                 if (contentBlocks.length < lastContentLength) {
+                    // Accumulate across successive shrinks — overwriting would drop
+                    // segments displaced by an earlier shrink, leaving them stranded
+                    // in chatContainer once the prune pass finally runs.
+                    orphanedSegments = [...orphanedSegments, ...renderedSegments];
                     renderedSegments = [];
                     lastPinnedText = "";
                     lastProcessedContentIndex = 0;
@@ -251,28 +286,119 @@ export async function handleAgentEvent(host, event) {
                 // Build desired segment plan from content[].
                 {
                     const blocks = host.streamingMessage.content;
+                    const isClaudeCodeProvider = host.streamingMessage.provider === "claude-code";
+                    const hasMcpToolBlock = blocks.some((b) => {
+                        if (b?.type === "toolCall") {
+                            return typeof b?.mcpServer === "string" || String(b?.name ?? "").startsWith("mcp__");
+                        }
+                        if (b?.type === "serverToolUse") {
+                            return typeof b?.mcpServer === "string" || String(b?.name ?? "").startsWith("mcp__");
+                        }
+                        return false;
+                    });
+                    const firstToolIdx = blocks.findIndex((b) => b.type === "toolCall" || b.type === "serverToolUse");
+                    const hasPostToolText = firstToolIdx >= 0
+                        && blocks.some((b, idx) => (idx > firstToolIdx
+                            && b?.type === "text"
+                            && typeof b?.text === "string"
+                            && b.text.trim().length > 0));
+                    // Only prune provisional pre-tool prose after post-tool prose exists,
+                    // so MCP tool-only windows do not blank the assistant content.
+                    const shouldDropPreToolProse = isClaudeCodeProvider && hasMcpToolBlock && hasPostToolText;
                     const desired = [];
                     let runStart = -1;
+                    let runEnd = -1;
+                    let runType;
+                    const closeRun = () => {
+                        if (runStart !== -1 && runType) {
+                            desired.push({ kind: "text-run", startIndex: runStart, endIndex: runEnd, contentType: runType });
+                            runStart = -1;
+                            runEnd = -1;
+                            runType = undefined;
+                        }
+                    };
                     for (let i = 0; i < blocks.length; i++) {
                         const b = blocks[i];
-                        const isText = b.type === "text" || b.type === "thinking";
+                        const blockType = b.type === "text" || b.type === "thinking" ? b.type : undefined;
+                        const isTextLike = blockType === "text" || blockType === "thinking";
                         const isTool = b.type === "toolCall" || b.type === "serverToolUse";
-                        if (isText) {
-                            if (runStart === -1)
+                        // For Claude Code MCP turns, prune only pre-tool prose, never thinking.
+                        const textValue = blockType === "text" && typeof b?.text === "string" ? b.text : "";
+                        const isLikelyQuestion = blockType === "text" && typeof textValue === "string" && /\?\s*$/.test(textValue.trim());
+                        const shouldSkipProse = shouldDropPreToolProse
+                            && firstToolIdx >= 0
+                            && i < firstToolIdx
+                            && blockType === "text"
+                            && !isLikelyQuestion;
+                        if (shouldSkipProse) {
+                            closeRun();
+                            continue;
+                        }
+                        if (isTextLike) {
+                            if (runStart === -1) {
                                 runStart = i;
+                                runEnd = i;
+                                runType = blockType;
+                            }
+                            else if (runType !== blockType) {
+                                closeRun();
+                                runStart = i;
+                                runEnd = i;
+                                runType = blockType;
+                            }
+                            else {
+                                runEnd = i;
+                            }
                         }
                         else {
-                            if (runStart !== -1) {
-                                desired.push({ kind: "text-run", startIndex: runStart, endIndex: i - 1 });
-                                runStart = -1;
-                            }
+                            closeRun();
                             if (isTool) {
                                 desired.push({ kind: "tool", contentIndex: i, toolId: b.id });
                             }
                         }
                     }
-                    if (runStart !== -1) {
-                        desired.push({ kind: "text-run", startIndex: runStart, endIndex: blocks.length - 1 });
+                    closeRun();
+                    // Claude Code MCP can emit provisional pre-tool prose that gets
+                    // superseded by post-tool output. Prune stale text-run segments so
+                    // the final assistant output remains below tool output.
+                    if (shouldDropPreToolProse && firstToolIdx >= 0) {
+                        if (orphanedSegments.length > 0) {
+                            const remainingOrphans = [];
+                            for (const orphan of orphanedSegments) {
+                                if (orphan.kind === "text-run" && orphan.contentType === "text") {
+                                    host.chatContainer.removeChild(orphan.component);
+                                    if (host.streamingComponent === orphan.component) {
+                                        host.streamingComponent = undefined;
+                                    }
+                                    continue;
+                                }
+                                remainingOrphans.push(orphan);
+                            }
+                            orphanedSegments = remainingOrphans;
+                        }
+                        const desiredTextKeys = new Set(desired
+                            .filter((seg) => seg.kind === "text-run")
+                            .map((seg) => `${seg.contentType}:${seg.startIndex}`));
+                        const desiredToolIndices = new Set(desired
+                            .filter((seg) => seg.kind === "tool")
+                            .map((seg) => seg.contentIndex));
+                        const nextRendered = [];
+                        for (const seg of renderedSegments) {
+                            if (seg.kind === "text-run"
+                                && seg.contentType === "text"
+                                && !desiredTextKeys.has(`${seg.contentType}:${seg.startIndex}`)) {
+                                host.chatContainer.removeChild(seg.component);
+                                if (host.streamingComponent === seg.component) {
+                                    host.streamingComponent = undefined;
+                                }
+                                continue;
+                            }
+                            if (seg.kind === "tool" && !desiredToolIndices.has(seg.contentIndex)) {
+                                continue;
+                            }
+                            nextRendered.push(seg);
+                        }
+                        renderedSegments = nextRendered;
                     }
                     // Append any newly needed segments (never reorder existing ones).
                     for (const seg of desired) {
@@ -289,11 +415,17 @@ export async function handleAgentEvent(host, event) {
                         }
                         else {
                             // text-run segment
-                            const existing = renderedSegments.find((s) => s.kind === "text-run" && s.startIndex === seg.startIndex);
+                            const existing = renderedSegments.find((s) => s.kind === "text-run" && s.startIndex === seg.startIndex && s.contentType === seg.contentType);
                             if (!existing) {
-                                const comp = new AssistantMessageComponent(undefined, host.hideThinkingBlock, host.getMarkdownThemeWithSettings(), host.settingsManager.getTimestampFormat(), { startIndex: seg.startIndex, endIndex: seg.endIndex });
+                                const comp = new AssistantMessageComponent(undefined, host.hideThinkingBlock, host.getMarkdownThemeWithSettings(), timestampFormat, { startIndex: seg.startIndex, endIndex: seg.endIndex });
                                 host.chatContainer.addChild(comp);
-                                renderedSegments.push({ kind: "text-run", startIndex: seg.startIndex, endIndex: seg.endIndex, component: comp });
+                                renderedSegments.push({
+                                    kind: "text-run",
+                                    startIndex: seg.startIndex,
+                                    endIndex: seg.endIndex,
+                                    contentType: seg.contentType,
+                                    component: comp,
+                                });
                                 host.streamingComponent = comp;
                             }
                         }
@@ -303,7 +435,7 @@ export async function handleAgentEvent(host, event) {
                     for (const seg of renderedSegments) {
                         if (seg.kind === "text-run") {
                             // Find corresponding desired segment to get current endIndex
-                            const d = desired.find((ds) => ds.kind === "text-run" && ds.startIndex === seg.startIndex);
+                            const d = desired.find((ds) => ds.kind === "text-run" && ds.startIndex === seg.startIndex && ds.contentType === seg.contentType);
                             if (d && d.kind === "text-run" && d.endIndex !== seg.endIndex) {
                                 seg.endIndex = d.endIndex;
                                 seg.component.setRange({ startIndex: seg.startIndex, endIndex: seg.endIndex });
@@ -329,36 +461,62 @@ export async function handleAgentEvent(host, event) {
                 if (hasTools)
                     hasToolsInTurn = true;
                 if (hasToolsInTurn) {
-                    const latestText = findLatestPinnableText(contentBlocks);
-                    if (latestText && latestText !== lastPinnedText) {
-                        lastPinnedText = latestText;
-                        if (!pinnedBorder) {
-                            // First time: create border + text component
-                            host.pinnedMessageContainer.clear();
-                            pinnedBorder = new DynamicBorder((str) => theme.fg("dim", str), "Working · Latest Output");
-                            pinnedBorder.startSpinner(host.ui, (str) => theme.fg("accent", str));
-                            host.pinnedMessageContainer.addChild(pinnedBorder);
-                            pinnedTextComponent = new Markdown(latestText, 1, 0, host.getMarkdownThemeWithSettings());
-                            // Cap pinned content to ~40% of terminal height so tall output
-                            // doesn't exceed the viewport and cause render flashing.
-                            pinnedTextComponent.maxLines = Math.max(3, Math.floor(host.ui.terminal.rows * 0.4));
-                            host.pinnedMessageContainer.addChild(pinnedTextComponent);
-                            // Hide the separate status loader — the pinned zone replaces it
-                            if (host.loadingAnimation) {
-                                host.loadingAnimation.stop();
-                                host.loadingAnimation = undefined;
-                            }
-                            host.statusContainer.clear();
+                    const candidates = findLatestPinnableCandidates(contentBlocks);
+                    const termRows = host.ui.terminal.rows;
+                    const termCols = host.ui.terminal.columns;
+                    const pinnedMax = Math.max(3, Math.floor(termRows * 0.4));
+                    // Reserve rows for pinned zone + its border + editor + footer chrome.
+                    // Anything below this row budget is still in the viewport.
+                    const offscreenThreshold = Math.max(1, termRows - pinnedMax - 8);
+                    // Walk candidates newest→oldest; pick the first whose following
+                    // segments have pushed enough rows to scroll it off-screen.
+                    let picked;
+                    for (const c of candidates) {
+                        if (rowsRenderedAfterContentIndex(c.contentIndex, termCols) >= offscreenThreshold) {
+                            picked = c;
+                            break;
                         }
-                        else {
-                            // Update existing markdown component in-place
-                            pinnedTextComponent?.setText(latestText);
-                            // Refresh maxLines in case terminal was resized
-                            if (pinnedTextComponent) {
-                                pinnedTextComponent.maxLines = Math.max(3, Math.floor(host.ui.terminal.rows * 0.4));
+                    }
+                    if (picked) {
+                        if (picked.text !== lastPinnedText) {
+                            lastPinnedText = picked.text;
+                            if (!pinnedBorder) {
+                                // First time: create border + text component
+                                host.pinnedMessageContainer.clear();
+                                pinnedBorder = new DynamicBorder((str) => theme.fg("dim", str), "Working · Latest Output");
+                                pinnedBorder.startSpinner(host.ui, (str) => theme.fg("accent", str));
+                                host.pinnedMessageContainer.addChild(pinnedBorder);
+                                pinnedTextComponent = new Markdown(picked.text, 1, 0, host.getMarkdownThemeWithSettings());
+                                // Cap pinned content to ~40% of terminal height so tall output
+                                // doesn't exceed the viewport and cause render flashing.
+                                pinnedTextComponent.maxLines = pinnedMax;
+                                host.pinnedMessageContainer.addChild(pinnedTextComponent);
+                                // Hide the separate status loader — the pinned zone replaces it
+                                if (host.loadingAnimation) {
+                                    host.loadingAnimation.stop();
+                                    host.loadingAnimation = undefined;
+                                }
+                                host.statusContainer.clear();
+                            }
+                            else {
+                                // Update existing markdown component in-place
+                                pinnedTextComponent?.setText(picked.text);
+                                // Refresh maxLines in case terminal was resized
+                                if (pinnedTextComponent) {
+                                    pinnedTextComponent.maxLines = pinnedMax;
+                                }
                             }
                         }
                     }
+                    else if (pinnedBorder) {
+                        // Every candidate is still visible in the chat scrollback —
+                        // tear down the pinned zone so we don't duplicate on-screen text.
+                        pinnedBorder.stopSpinner();
+                        pinnedBorder = undefined;
+                        pinnedTextComponent = undefined;
+                        host.pinnedMessageContainer.clear();
+                        lastPinnedText = "";
+                    }
                 }
                 host.ui.requestRender();
             }
@@ -379,8 +537,109 @@ export async function handleAgentEvent(host, event) {
                 const shouldRenderAssistant = hasVisibleAssistantContent(host.streamingMessage)
                     || ((host.streamingMessage.stopReason === "aborted" || host.streamingMessage.stopReason === "error")
                         && !hasAssistantToolBlocks(host.streamingMessage));
+                // The final message_end payload can contain additional text/thinking
+                // blocks that never arrived via message_update (e.g. SDK result
+                // aggregation). Rebuild this in-flight turn from final content so
+                // ranges/components don't keep stale partial indices.
+                if (renderedSegments.length > 0) {
+                    const finalBlocks = host.streamingMessage.content;
+                    const desired = [];
+                    let runStart = -1;
+                    let runEnd = -1;
+                    let runType;
+                    const closeRun = () => {
+                        if (runStart !== -1 && runType) {
+                            desired.push({ kind: "text-run", startIndex: runStart, endIndex: runEnd, contentType: runType });
+                            runStart = -1;
+                            runEnd = -1;
+                            runType = undefined;
+                        }
+                    };
+                    for (let i = 0; i < finalBlocks.length; i++) {
+                        const block = finalBlocks[i];
+                        const blockType = block?.type === "text" || block?.type === "thinking" ? block.type : undefined;
+                        const isTextLike = blockType === "text" || blockType === "thinking";
+                        const isTool = block?.type === "toolCall" || block?.type === "serverToolUse";
+                        if (isTextLike) {
+                            if (runStart === -1) {
+                                runStart = i;
+                                runEnd = i;
+                                runType = blockType;
+                            }
+                            else if (runType !== blockType) {
+                                closeRun();
+                                runStart = i;
+                                runEnd = i;
+                                runType = blockType;
+                            }
+                            else {
+                                runEnd = i;
+                            }
+                        }
+                        else {
+                            closeRun();
+                            if (isTool) {
+                                desired.push({ kind: "tool", contentIndex: i, toolId: block.id });
+                            }
+                        }
+                    }
+                    closeRun();
+                    const toolComponentsById = new Map();
+                    for (const [toolId, component] of host.pendingTools.entries()) {
+                        toolComponentsById.set(toolId, component);
+                    }
+                    for (const seg of renderedSegments) {
+                        host.chatContainer.removeChild(seg.component);
+                        if (seg.kind === "tool") {
+                            const priorBlocks = host.streamingMessage.content;
+                            const priorBlock = priorBlocks[seg.contentIndex];
+                            if (priorBlock?.id && !toolComponentsById.has(priorBlock.id)) {
+                                toolComponentsById.set(priorBlock.id, seg.component);
+                            }
+                        }
+                    }
+                    renderedSegments = [];
+                    host.streamingComponent = undefined;
+                    for (const seg of desired) {
+                        if (seg.kind === "tool") {
+                            const finalBlock = finalBlocks[seg.contentIndex];
+                            let component = toolComponentsById.get(seg.toolId);
+                            if (!component && finalBlock?.id) {
+                                component = host.pendingTools.get(finalBlock.id);
+                            }
+                            if (!component && finalBlock?.type === "toolCall") {
+                                component = new ToolExecutionComponent(finalBlock.name, finalBlock.arguments, { showImages: host.settingsManager.getShowImages() }, host.getRegisteredToolDefinition(finalBlock.name), host.ui);
+                                component.setExpanded(host.toolOutputExpanded);
+                                host.pendingTools.set(finalBlock.id, component);
+                                toolComponentsById.set(finalBlock.id, component);
+                            }
+                            else if (!component && finalBlock?.type === "serverToolUse") {
+                                component = new ToolExecutionComponent(finalBlock.name, finalBlock.input ?? {}, { showImages: host.settingsManager.getShowImages() }, undefined, host.ui);
+                                component.setExpanded(host.toolOutputExpanded);
+                                host.pendingTools.set(finalBlock.id, component);
+                                toolComponentsById.set(finalBlock.id, component);
+                            }
+                            if (component) {
+                                host.chatContainer.addChild(component);
+                                renderedSegments.push({ kind: "tool", contentIndex: seg.contentIndex, component });
+                            }
+                            continue;
+                        }
+                        const comp = new AssistantMessageComponent(undefined, host.hideThinkingBlock, host.getMarkdownThemeWithSettings(), timestampFormat, { startIndex: seg.startIndex, endIndex: seg.endIndex });
+                        comp.updateContent(host.streamingMessage);
+                        host.chatContainer.addChild(comp);
+                        renderedSegments.push({
+                            kind: "text-run",
+                            startIndex: seg.startIndex,
+                            endIndex: seg.endIndex,
+                            contentType: seg.contentType,
+                            component: comp,
+                        });
+                        host.streamingComponent = comp;
+                    }
+                }
                 if (!host.streamingComponent && shouldRenderAssistant) {
-                    host.streamingComponent = new AssistantMessageComponent(undefined, host.hideThinkingBlock, host.getMarkdownThemeWithSettings(), host.settingsManager.getTimestampFormat());
+                    host.streamingComponent = new AssistantMessageComponent(undefined, host.hideThinkingBlock, host.getMarkdownThemeWithSettings(), timestampFormat);
                     host.chatContainer.addChild(host.streamingComponent);
                 }
                 if (host.streamingComponent) {
@@ -409,6 +668,7 @@ export async function handleAgentEvent(host, event) {
                 host.streamingComponent = undefined;
                 host.streamingMessage = undefined;
                 renderedSegments = [];
+                orphanedSegments = [];
                 lastContentLength = 0;
                 // Clear pinned output once the message is finalized in the chat
                 // container — prevents duplicate display when the agent continues
@@ -456,11 +716,15 @@ export async function handleAgentEvent(host, event) {
                 host.loadingAnimation = undefined;
                 host.statusContainer.clear();
             }
-            if (host.streamingComponent) {
-                host.chatContainer.removeChild(host.streamingComponent);
-                host.streamingComponent = undefined;
-                host.streamingMessage = undefined;
+            if (host.streamingComponent && host.streamingMessage) {
+                host.streamingComponent.setShowMetadata(true);
+                host.streamingComponent.updateContent(host.streamingMessage);
             }
+            host.streamingComponent = undefined;
+            host.streamingMessage = undefined;
+            renderedSegments = [];
+            orphanedSegments = [];
+            lastContentLength = 0;
             host.pendingTools.clear();
             // Pinned output is only useful while work is actively streaming.
             // Keep chat history as the single source after completion.