@code-yeongyu/senpi 2026.7.17 → 2026.7.20-2

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

@@ -69,8 +69,10 @@ import { UserMessageSelectorComponent } from "./components/user-message-selector
 import { restoreInteractiveStderr, takeOverInteractiveStderr } from "./interactive-stderr-guard.js";
 import { getModelSearchText } from "./model-search.js";
 import { resolveStartupToolPaths } from "./startup-tools.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";
+import { ToolArgsRevealController } from "./tool-args-reveal.js";
 import { blendWorkingStatusShimmerRgbColor, formatActiveToolWorkingLabel, formatToolHookStatusMessageFrame, formatWorkingStatusMessageFrame, sanitizeWorkingStatusPlainText, } from "./working-status.js";
 function isExpandable(obj) {
     return typeof obj === "object" && obj !== null && "setExpanded" in obj && typeof obj.setExpanded === "function";
@@ -85,6 +87,14 @@ class ExpandableText extends Text {
         this.setText(expanded ? this.getExpandedText() : this.getCollapsedText());
     }
 }
+export function shouldShowRetryIndicator(delayMs, fallbackApplied) {
+    return delayMs !== 0 || !fallbackApplied;
+}
+function getStreamingToolCallPartialJson(content) {
+    if (typeof content !== "object" || content === null || !("partialJson" in content))
+        return undefined;
+    return typeof content.partialJson === "string" ? content.partialJson : undefined;
+}
 function formatToolHookTerminalTitle(event) {
     const hookName = sanitizeWorkingStatusPlainText(event.hookName) || "hook";
     const statusMessage = sanitizeWorkingStatusPlainText(event.statusMessage);
@@ -96,6 +106,7 @@ function isCustomSessionEntry(item) {
 const DEAD_TERMINAL_ERROR_CODES = new Set(["EIO", "EPIPE", "ENOTCONN"]);
 const DEFAULT_WORKING_STATUS_REFRESH_INTERVAL_MS = 600;
 const DEFAULT_WORKING_STATUS_MESSAGE_ANIMATION_INTERVAL_MS = 32;
+const FALLBACK_STATUS_KEY = "fallback";
 const RGB_FOREGROUND_PATTERN = /\x1b\[38;2;(\d+);(\d+);(\d+)m/;
 const DARK_DEFAULT_WORKING_TEXT_RGB = { r: 229, g: 229, b: 231 };
 const LIGHT_DEFAULT_WORKING_TEXT_RGB = { r: 17, g: 17, b: 17 };
@@ -219,6 +230,12 @@ export class InteractiveMode {
     requestStreamingRender() {
         this.ui.requestRender();
     }
+    applySmoothStreamingRenderFps() {
+        const fps = this.settingsManager.getSmoothStreaming()
+            ? this.settingsManager.getSmoothStreamingFps()
+            : DEFAULT_SMOOTH_FPS;
+        this.ui.setMaxRenderFps(fps);
+    }
     // Convenience accessors
     get session() {
         return this.runtimeHost.session;
@@ -277,6 +294,8 @@ export class InteractiveMode {
         // Track pending bash components (shown in pending area, moved to chat on submit)
         this.pendingBashComponents = [];
         this.autoCompactionProgressText = "";
+        this.fallbackAppliedBeforeRetryStart = false;
+        this.pendingZeroDelayRetryIndicator = undefined;
         // Messages queued while compaction is running
         this.compactionQueuedMessages = [];
         this.compactionInFlightMessages = [];
@@ -315,6 +334,18 @@ export class InteractiveMode {
         });
         this.version = VERSION;
         this.ui = new TUI(new ProcessTerminal({ onExternalStdoutWrite: appendHiddenTuiStdout }), this.settingsManager.getShowHardwareCursor());
+        this.streamingReveal = new StreamingRevealController({
+            getSmoothStreaming: () => this.settingsManager.getSmoothStreaming(),
+            getSmoothStreamingFps: () => this.settingsManager.getSmoothStreamingFps(),
+            getHideThinkingBlock: () => this.hideThinkingBlock,
+            requestRender: () => this.ui.requestRender(),
+        });
+        this.toolArgsReveal = new ToolArgsRevealController({
+            getSmoothStreaming: () => this.settingsManager.getSmoothStreaming(),
+            getSmoothStreamingFps: () => this.settingsManager.getSmoothStreamingFps(),
+            requestRender: () => this.ui.requestRender(),
+        });
+        this.applySmoothStreamingRenderFps();
         this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
         this.headerContainer = new Container();
         this.loadedResourcesContainer = new Container();
@@ -675,6 +706,9 @@ export class InteractiveMode {
         if (modelFallbackMessage) {
             this.showWarning(modelFallbackMessage);
         }
+        for (const warning of this.session.fallbackValidationWarnings) {
+            this.showWarning(warning);
+        }
         void this.maybeWarnAboutAnthropicSubscriptionAuth();
         // Process initial messages
         if (initialMessage) {
@@ -1123,7 +1157,10 @@ export class InteractiveMode {
         const promptsResult = this.session.resourceLoader.getPrompts();
         const themesResult = this.session.resourceLoader.getThemes();
         const extensions = options?.extensions ??
-            this.session.resourceLoader.getExtensions().extensions.map((extension) => ({
+            this.session.resourceLoader
+                .getExtensions()
+                .extensions.filter((extension) => !extension.hidden)
+                .map((extension) => ({
                 path: extension.path,
                 sourceInfo: extension.sourceInfo,
             }));
@@ -1333,6 +1370,7 @@ export class InteractiveMode {
         this.footerDataProvider.setCwd(this.sessionManager.getCwd());
         this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
         this.outputPad = this.settingsManager.getOutputPad();
+        this.applySmoothStreamingRenderFps();
         this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
         const clearOnShrink = this.settingsManager.getClearOnShrink();
         this.ui.setClearOnShrink(clearOnShrink);
@@ -1383,6 +1421,7 @@ export class InteractiveMode {
         this.compactionQueuedMessages = [];
         this.compactionInFlightMessages = [];
         this.compactionTransferAbortControllers.clear();
+        this.streamingReveal.stop();
         this.streamingComponent = undefined;
         this.streamingMessage = undefined;
         this.clearPendingTools();
@@ -1422,6 +1461,7 @@ export class InteractiveMode {
             },
             getContextUsage: () => this.session.getContextUsage(),
             getCompactionSettings: () => this.settingsManager.getCompactionSettings(),
+            sessionSettings: extensionRunner.createContext().sessionSettings,
             compact: (options) => {
                 void (async () => {
                     try {
@@ -1558,6 +1598,7 @@ export class InteractiveMode {
         this.applyTerminalTitle();
     }
     clearPendingTools() {
+        this.toolArgsReveal.flushAll();
         for (const component of this.pendingTools.values()) {
             component.stopAnimation();
         }
@@ -2591,18 +2632,19 @@ export class InteractiveMode {
                     this.streamingComponent.setExpanded(this.toolOutputExpanded);
                     this.streamingMessage = event.message;
                     this.chatContainer.addChild(this.streamingComponent);
-                    this.streamingComponent.updateContent(this.streamingMessage);
+                    this.streamingReveal.begin(this.streamingComponent, this.streamingMessage);
                     this.requestStreamingRender();
                 }
                 break;
             case "message_update":
                 if (this.streamingComponent && event.message.role === "assistant") {
                     this.streamingMessage = event.message;
-                    this.streamingComponent.updateContent(this.streamingMessage);
+                    this.streamingReveal.setTarget(this.streamingMessage);
                     for (const content of this.streamingMessage.content) {
                         if (content.type === "toolCall") {
-                            if (!this.pendingTools.has(content.id)) {
-                                const component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
+                            let component = this.pendingTools.get(content.id);
+                            if (!component) {
+                                component = new ToolExecutionComponent(content.name, content.id, content.arguments, {
                                     showImages: this.settingsManager.getShowImages(),
                                     imageWidthCells: this.settingsManager.getImageWidthCells(),
                                 }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
@@ -2610,11 +2652,13 @@ export class InteractiveMode {
                                 this.chatContainer.addChild(component);
                                 this.pendingTools.set(content.id, component);
                             }
+                            const partialJson = getStreamingToolCallPartialJson(content);
+                            if (partialJson && this.settingsManager.getSmoothStreaming()) {
+                                this.toolArgsReveal.update(content.id, component, partialJson);
+                            }
                             else {
-                                const component = this.pendingTools.get(content.id);
-                                if (component) {
-                                    component.updateArgs(content.arguments);
-                                }
+                                this.toolArgsReveal.finish(content.id);
+                                component.updateArgs(content.arguments);
                             }
                         }
                     }
@@ -2626,6 +2670,16 @@ export class InteractiveMode {
                     break;
                 if (this.streamingComponent && event.message.role === "assistant") {
                     this.streamingMessage = event.message;
+                    this.streamingReveal.stop();
+                    for (const content of this.streamingMessage.content) {
+                        if (content.type !== "toolCall")
+                            continue;
+                        const component = this.pendingTools.get(content.id);
+                        if (component && !this.toolArgsReveal.flush(content.id, content.arguments)) {
+                            component.updateArgs(content.arguments);
+                        }
+                    }
+                    this.toolArgsReveal.flushAll();
                     let errorMessage;
                     if (this.streamingMessage.stopReason === "aborted") {
                         errorMessage = abortedErrorLabel(undefined, this.session.retryAttempt);
@@ -2669,6 +2723,9 @@ export class InteractiveMode {
                     this.chatContainer.addChild(component);
                     this.pendingTools.set(event.toolCallId, component);
                 }
+                if (!this.toolArgsReveal.flush(event.toolCallId, event.args)) {
+                    component.updateArgs(event.args);
+                }
                 component.markExecutionStarted();
                 this.ui.requestRender();
                 break;
@@ -2686,6 +2743,7 @@ export class InteractiveMode {
             }
             case "tool_execution_end": {
                 this.handleToolExecutionEnd(event);
+                this.toolArgsReveal.finish(event.toolCallId);
                 const component = this.pendingTools.get(event.toolCallId);
                 if (component) {
                     component.updateResult({ ...event.result, isError: event.isError });
@@ -2701,6 +2759,7 @@ export class InteractiveMode {
                 this.clearStatusIndicator("working");
                 this.clearActiveToolExecutionStatus();
                 this.clearToolHookStatuses();
+                this.streamingReveal.stop();
                 if (this.streamingComponent) {
                     this.chatContainer.removeChild(this.streamingComponent);
                     this.streamingComponent = undefined;
@@ -2759,8 +2818,16 @@ export class InteractiveMode {
                 this.clearStatusIndicator("compaction");
                 this.autoCompactionProgressText = "";
                 if (event.aborted) {
+                    // Prefer the extension-provided reason over the generic "cancelled"
+                    // label so per-turn-cap / circuit-breaker / provider-error cancels are
+                    // no longer indistinguishable from a user-triggered abort.
+                    const cancelMessage = event.errorMessage ?? "Compaction cancelled";
                     if (event.reason === "manual") {
-                        this.showError("Compaction cancelled");
+                        this.showError(cancelMessage);
+                    }
+                    else if (event.errorMessage) {
+                        this.chatContainer.addChild(new Spacer(1));
+                        this.chatContainer.addChild(new Text(theme.fg("error", event.errorMessage), 1, 0));
                     }
                     else {
                         this.showStatus("Auto-compaction cancelled");
@@ -2781,21 +2848,74 @@ export class InteractiveMode {
                         this.chatContainer.addChild(new Text(theme.fg("error", event.errorMessage), 1, 0));
                     }
                 }
+                else if (event.accepted === false) {
+                    // Exhaustive fallback per plan Section 1: compaction_end must never fall
+                    // through silently. Rejection events without an errorMessage still name
+                    // the rejectionCause so the user knows /compact did nothing on purpose.
+                    const cause = event.rejectionCause ?? "unknown";
+                    const message = `Compaction failed (no result); cause: ${cause}`;
+                    if (event.reason === "manual") {
+                        this.showError(message);
+                    }
+                    else {
+                        this.chatContainer.addChild(new Spacer(1));
+                        this.chatContainer.addChild(new Text(theme.fg("error", message), 1, 0));
+                    }
+                }
                 void this.flushCompactionQueue({ willRetry: event.willRetry });
                 this.ui.requestRender();
                 break;
             }
+            case "retry_fallback_applied": {
+                if (this.pendingZeroDelayRetryIndicator) {
+                    this.pendingZeroDelayRetryIndicator.fallbackApplied = true;
+                }
+                else {
+                    this.fallbackAppliedBeforeRetryStart = true;
+                }
+                this.showWarning(`Model fallback: ${event.from} -> ${event.to} (${event.reason})`);
+                this.setExtensionStatus(FALLBACK_STATUS_KEY, `fallback: ${event.to}`);
+                break;
+            }
+            case "retry_fallback_succeeded":
+                this.showStatus(`Fallback model ${event.model} responded`);
+                break;
+            case "retry_fallback_reverted":
+                this.showStatus(`Reverted to ${event.to}`);
+                this.setExtensionStatus(FALLBACK_STATUS_KEY, undefined);
+                break;
+            case "retry_fallback_exhausted":
+                this.showError(`Fallback chain exhausted for ${event.chainKey}: ${event.lastError}`);
+                this.setExtensionStatus(FALLBACK_STATUS_KEY, undefined);
+                break;
             case "auto_retry_start": {
                 // During retry waits, isStreaming flips false between attempts. The main Esc handler
                 // keys off both isStreaming and retryAttempt so we keep the same close-out path here;
                 // no separate retry-only handler is installed (the prior one only called
                 // session.abortRetry() and left queued steering messages stranded).
                 this.retryEscapeHandler = undefined;
-                this.showStatusIndicator(new RetryStatusIndicator(this.ui, event.attempt, event.maxAttempts, event.delayMs));
-                this.ui.requestRender();
+                const fallbackApplied = this.fallbackAppliedBeforeRetryStart;
+                this.fallbackAppliedBeforeRetryStart = false;
+                if (event.delayMs === 0) {
+                    const pending = { fallbackApplied };
+                    this.pendingZeroDelayRetryIndicator = pending;
+                    queueMicrotask(() => {
+                        if (this.pendingZeroDelayRetryIndicator !== pending)
+                            return;
+                        this.pendingZeroDelayRetryIndicator = undefined;
+                        if (shouldShowRetryIndicator(event.delayMs, pending.fallbackApplied)) {
+                            this.showRetryStatusIndicator(event);
+                        }
+                    });
+                }
+                else {
+                    this.showRetryStatusIndicator(event);
+                }
                 break;
             }
             case "auto_retry_end": {
+                this.pendingZeroDelayRetryIndicator = undefined;
+                this.fallbackAppliedBeforeRetryStart = false;
                 // Restore escape handler
                 if (this.retryEscapeHandler) {
                     this.defaultEditor.onEscape = this.retryEscapeHandler;
@@ -2811,6 +2931,10 @@ export class InteractiveMode {
             }
         }
     }
+    showRetryStatusIndicator(event) {
+        this.showStatusIndicator(new RetryStatusIndicator(this.ui, event.attempt, event.maxAttempts, event.delayMs));
+        this.ui.requestRender();
+    }
     /** Extract text content from a user message */
     getUserMessageText(message) {
         if (message.role !== "user")
@@ -3382,7 +3506,7 @@ export class InteractiveMode {
         // If streaming, re-add the streaming component with updated visibility and re-render
         if (this.streamingComponent && this.streamingMessage) {
             this.streamingComponent.setHideThinkingBlock(this.hideThinkingBlock);
-            this.streamingComponent.updateContent(this.streamingMessage);
+            this.streamingReveal.resyncVisibility();
             this.chatContainer.addChild(this.streamingComponent);
         }
         this.showStatus(`Thinking blocks: ${this.hideThinkingBlock ? "hidden" : "visible"}`);
@@ -3704,6 +3828,8 @@ export class InteractiveMode {
                 terminalTheme: this.themeController.getTerminalTheme(),
                 availableThemes: getAvailableThemes(),
                 hideThinkingBlock: this.hideThinkingBlock,
+                smoothStreaming: this.settingsManager.getSmoothStreaming(),
+                smoothStreamingFps: this.settingsManager.getSmoothStreamingFps(),
                 collapseChangelog: this.settingsManager.getCollapseChangelog(),
                 enableInstallTelemetry: this.settingsManager.getEnableInstallTelemetry(),
                 doubleEscapeAction: this.settingsManager.getDoubleEscapeAction(),
@@ -3785,6 +3911,31 @@ export class InteractiveMode {
                     }
                     this.chatContainer.clear();
                     this.rebuildChatFromMessages();
+                    if (this.streamingComponent && this.streamingMessage) {
+                        this.streamingComponent.setHideThinkingBlock(hidden);
+                        this.streamingReveal.resyncVisibility();
+                        this.chatContainer.addChild(this.streamingComponent);
+                    }
+                    this.ui.requestRender();
+                },
+                onSmoothStreamingChange: (enabled) => {
+                    this.settingsManager.setSmoothStreaming(enabled);
+                    this.applySmoothStreamingRenderFps();
+                    this.toolArgsReveal.refresh();
+                    if (this.streamingMessage) {
+                        this.streamingReveal.setTarget(this.streamingMessage);
+                    }
+                    this.ui.requestRender();
+                },
+                onSmoothStreamingFpsChange: (fps) => {
+                    this.settingsManager.setSmoothStreamingFps(fps);
+                    this.toolArgsReveal.refresh();
+                    if (this.settingsManager.getSmoothStreaming()) {
+                        this.applySmoothStreamingRenderFps();
+                        if (this.streamingMessage) {
+                            this.streamingReveal.setTarget(this.streamingMessage);
+                        }
+                    }
                 },
                 onShowCacheMissNoticesChange: (shown) => {
                     this.settingsManager.setShowCacheMissNotices(shown);
@@ -5359,6 +5510,7 @@ export class InteractiveMode {
         }
     }
     stop() {
+        this.streamingReveal.stop();
         if (this.settingsManager.getShowTerminalProgress()) {
             this.ui.terminal.setProgress(false);
         }