@code-yeongyu/senpi 2026.8.21 → 2026.8.22

package/dist/modes/interactive/interactive-mode.js

@@ -91,7 +91,6 @@ import { applyKeybindingsFileEdit, seedKeybindingsFile } from "./keybindings-com
 import { refreshModelCatalogs } from "./model-catalog-refresh.js";
 import { getModelSearchText } from "./model-search.js";
 import { isRiskyMainModel, RISKY_MAIN_MODEL_WARNING } from "./risky-main-model-warning.js";
-import { splitTrailingAssistantContent } from "./split-trailing-assistant-text.js";
 import { DEFAULT_SMOOTH_FPS, StreamingRevealController } from "./streaming-reveal.js";
 import { getAvailableThemes, getAvailableThemesWithPaths, getEditorTheme, getMarkdownTheme, getThemeByName, onThemeChange, setRegisteredThemes, stopThemeWatcher, Theme, theme, } from "./theme/theme.js";
 import { InteractiveThemeController } from "./theme/theme-controller.js";
@@ -286,6 +285,17 @@ function formatLoginProviderCompletionDescription(provider) {
     const authTypes = provider.authTypes.map(formatAuthSelectorProviderType).join("/");
     return provider.name === provider.id ? authTypes : `${provider.name} · ${authTypes}`;
 }
+/**
+ * Content the streaming component owns: everything through the FIRST toolCall.
+ * Text painted between tool cards lives in persistent per-segment components
+ * below the cards (regression 1064), so the head must never reabsorb it.
+ */
+function assistantStreamingHeadMessage(message) {
+    const firstToolIndex = message.content.findIndex((block) => block.type === "toolCall");
+    if (firstToolIndex === -1)
+        return message;
+    return { ...message, content: message.content.slice(0, firstToolIndex + 1) };
+}
 /** Coordinates render-only user echoes with AgentSession's canonical input lifecycle. */
 export class OptimisticUserEchoController {
     constructor(render) {
@@ -308,10 +318,14 @@ export class OptimisticUserEchoController {
                 const record = this.pending.find((candidate) => candidate.id === id);
                 if (!record)
                     return;
-                if (disposition === "handled")
-                    this.reject(id);
-                else
+                // Only a prompt that actually STARTED keeps its optimistic echo; queued
+                // (steer/follow-up) input must render as the pending-queue waiting state,
+                // matching upstream pi where user messages appear only at canonical
+                // message_start and queued text lives in the pending display.
+                if (disposition === "started")
                     record.eligibleForCanonicalStart = true;
+                else
+                    this.reject(id);
             },
         };
     }
@@ -518,7 +532,7 @@ export class InteractiveMode {
         this.managedToolStatusStarted = false;
         // Streaming message tracking
         this.streamingComponent = undefined;
-        this.trailingAssistantComponent = undefined;
+        this.assistantTextSegments = new Map();
         this.streamingMessage = undefined;
         // Tool execution tracking: toolCallId -> component
         this.pendingTools = new Map();
@@ -1976,6 +1990,7 @@ export class InteractiveMode {
         this.toolResultReveal.stop();
         this.streamingComponent = undefined;
         this.streamingMessage = undefined;
+        this.assistantTextSegments.clear();
         this.clearPendingTools();
         this.clearToolHookStatuses();
         this.renderInitialMessages();
@@ -3470,17 +3485,14 @@ export class InteractiveMode {
                     this.streamingComponent.setExpanded(this.toolOutputExpanded);
                     this.streamingMessage = event.message;
                     this.chatContainer.addChild(this.streamingComponent);
-                    this.streamingReveal.begin(this.streamingComponent, this.streamingMessage);
+                    this.streamingReveal.begin(this.streamingComponent, assistantStreamingHeadMessage(this.streamingMessage));
                     this.requestStreamingRender();
                 }
                 break;
             case "message_update":
                 if (this.streamingComponent && event.message.role === "assistant") {
                     this.streamingMessage = event.message;
-                    {
-                        const { head } = splitTrailingAssistantContent(event.message.content);
-                        this.streamingReveal.setTarget({ ...event.message, content: head });
-                    }
+                    this.streamingReveal.setTarget(assistantStreamingHeadMessage(event.message));
                     for (const content of this.streamingMessage.content) {
                         if (content.type === "toolCall") {
                             let component = this.pendingTools.get(content.id);
@@ -3525,7 +3537,7 @@ export class InteractiveMode {
                         this.streamingMessage.errorMessage = errorMessage;
                     }
                     this.syncTrailingAssistantText(this.streamingMessage);
-                    this.trailingAssistantComponent = undefined;
+                    this.assistantTextSegments.clear();
                     this.addContinuityNotice(this.streamingMessage);
                     if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
                         if (!errorMessage) {
@@ -3625,6 +3637,7 @@ export class InteractiveMode {
                     this.streamingComponent = undefined;
                     this.streamingMessage = undefined;
                 }
+                this.detachAssistantTextSegments();
                 this.clearPendingTools();
                 this.ui.requestRender();
                 break;
@@ -4109,25 +4122,57 @@ export class InteractiveMode {
     syncTrailingAssistantText(message) {
         if (!this.streamingComponent)
             return;
-        const { head, tail } = splitTrailingAssistantContent(message.content);
-        this.streamingComponent.updateContent({ ...message, content: head }, true);
-        if (tail.length === 0) {
-            if (this.trailingAssistantComponent) {
-                this.chatContainer.detachChild(this.trailingAssistantComponent);
-                this.trailingAssistantComponent = undefined;
-            }
+        this.streamingComponent.updateContent(assistantStreamingHeadMessage(message), true);
+        const content = message.content;
+        const firstToolIndex = content.findIndex((block) => block.type === "toolCall");
+        if (firstToolIndex === -1) {
+            this.detachAssistantTextSegments();
             return;
         }
-        const tailMessage = { ...message, content: tail };
-        if (!this.trailingAssistantComponent) {
-            this.trailingAssistantComponent = new AssistantMessageComponent(tailMessage, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel, this.outputPad, this.getMarkdownTransformers());
-            this.trailingAssistantComponent.setExpanded(this.toolOutputExpanded);
-            this.chatContainer.addChild(this.trailingAssistantComponent);
-            return;
+        let index = firstToolIndex + 1;
+        while (index < content.length) {
+            if (content[index]?.type === "toolCall") {
+                index += 1;
+                continue;
+            }
+            const runStart = index;
+            const runBlocks = [];
+            while (index < content.length && content[index]?.type !== "toolCall") {
+                const runBlock = content[index];
+                if (runBlock)
+                    runBlocks.push(runBlock);
+                index += 1;
+            }
+            const runMessage = { ...message, content: runBlocks };
+            const existing = this.assistantTextSegments.get(runStart);
+            if (existing) {
+                existing.updateContent(runMessage, true);
+                continue;
+            }
+            const segment = new AssistantMessageComponent(runMessage, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel, this.outputPad, this.getMarkdownTransformers());
+            segment.setExpanded(this.toolOutputExpanded);
+            this.assistantTextSegments.set(runStart, segment);
+            const followingToolCall = content.slice(index).find((block) => block.type === "toolCall");
+            const followingToolCallId = followingToolCall?.type === "toolCall" ? followingToolCall.id : undefined;
+            const followingToolComponent = followingToolCallId ? this.pendingTools.get(followingToolCallId) : undefined;
+            const anchorIndex = followingToolComponent ? this.chatContainer.children.indexOf(followingToolComponent) : -1;
+            if (anchorIndex >= 0)
+                this.chatContainer.children.splice(anchorIndex, 0, segment);
+            else
+                this.chatContainer.addChild(segment);
+        }
+        for (const [runStart, segment] of this.assistantTextSegments) {
+            if (runStart >= content.length || content[runStart]?.type === "toolCall") {
+                this.chatContainer.detachChild(segment);
+                this.assistantTextSegments.delete(runStart);
+            }
+        }
+    }
+    detachAssistantTextSegments() {
+        for (const segment of this.assistantTextSegments.values()) {
+            this.chatContainer.detachChild(segment);
         }
-        this.trailingAssistantComponent.updateContent(tailMessage, true);
-        this.chatContainer.detachChild(this.trailingAssistantComponent);
-        this.chatContainer.addChild(this.trailingAssistantComponent);
+        this.assistantTextSegments.clear();
     }
     createToolExecutionComponent(toolName, toolCallId, args) {
         if (this.chrome) {
@@ -4906,12 +4951,12 @@ export class InteractiveMode {
         return allQueued.length;
     }
     queueCompactionMessage(text, mode, droppedImageCount = 0) {
-        const pendingEchoId = this.optimisticUserEchoes.begin(text);
+        // No optimistic echo here: compaction-queued input is waiting state and must
+        // render only in the pending-messages display until it is actually delivered.
         this.compactionQueuedMessages.push({
             text,
             mode,
             enqueueOrder: this.session.reserveQueuedInputOrder(),
-            pendingEchoId,
         });
         this.getSessionLogger().debug("compaction_queue_enqueue", {
             mode,
@@ -5384,11 +5429,15 @@ export class InteractiveMode {
         return findExactModelReferenceMatch(searchTerm, [...this.session.modelRuntime.getAvailableSnapshot()]);
     }
     async selectModelFromUi(model, done) {
+        // The selector overlay is already disposed on Enter, so releasing it only
+        // after setModel resolves leaves a stale frozen frame for the whole provider
+        // auth round trip. Release and repaint first, then apply the switch.
+        done?.();
+        this.ui?.requestRender();
         try {
             const systemPromptChange = await this.session.setModel(model);
             this.footer.invalidate();
             this.updateEditorBorderColor();
-            done?.();
             const systemPromptStr = systemPromptChange?.systemPromptName
                 ? ` (optimized system prompt applied: ${systemPromptChange.systemPromptName})`
                 : "";
@@ -5398,7 +5447,6 @@ export class InteractiveMode {
             this.checkDaxnutsEasterEgg(model);
         }
         catch (error) {
-            done?.();
             this.showError(error instanceof Error ? error.message : String(error));
         }
     }