@code-yeongyu/senpi 2026.7.20 → 2026.7.22

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

@@ -73,6 +73,8 @@ import { DEFAULT_SMOOTH_FPS, StreamingRevealController } from "./streaming-revea
 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 { readToolProgress } from "./tool-progress.js";
+import { ToolResultRevealController } from "./tool-result-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";
@@ -87,6 +89,9 @@ 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;
@@ -103,6 +108,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 };
@@ -290,6 +296,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 = [];
@@ -339,6 +347,11 @@ export class InteractiveMode {
             getSmoothStreamingFps: () => this.settingsManager.getSmoothStreamingFps(),
             requestRender: () => this.ui.requestRender(),
         });
+        this.toolResultReveal = new ToolResultRevealController({
+            getSmoothStreaming: () => this.settingsManager.getSmoothStreaming(),
+            getSmoothStreamingFps: () => this.settingsManager.getSmoothStreamingFps(),
+            requestRender: () => this.ui.requestRender(),
+        });
         this.applySmoothStreamingRenderFps();
         this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
         this.headerContainer = new Container();
@@ -700,6 +713,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) {
@@ -1413,6 +1429,7 @@ export class InteractiveMode {
         this.compactionInFlightMessages = [];
         this.compactionTransferAbortControllers.clear();
         this.streamingReveal.stop();
+        this.toolResultReveal.stop();
         this.streamingComponent = undefined;
         this.streamingMessage = undefined;
         this.clearPendingTools();
@@ -1447,11 +1464,26 @@ export class InteractiveMode {
             signal: this.session.agent.signal,
             abort: () => this.session.abort(),
             hasPendingMessages: () => this.session.pendingMessageCount > 0,
+            requestReload: () => this.handleReloadCommand(),
+            isCompacting: () => this.session.isCompacting,
             shutdown: () => {
                 this.shutdownRequested = true;
             },
             getContextUsage: () => this.session.getContextUsage(),
             getCompactionSettings: () => this.settingsManager.getCompactionSettings(),
+            getLookAtSettings: () => {
+                const global = this.settingsManager.getGlobalSettings().lookAt;
+                const project = this.settingsManager.getProjectSettings().lookAt;
+                return {
+                    enabled: project?.enabled ?? global?.enabled ?? true,
+                    models: project?.models ?? global?.models,
+                };
+            },
+            getImageSettings: () => ({
+                autoResize: this.settingsManager.getImageAutoResize(),
+                blockImages: this.settingsManager.getBlockImages(),
+            }),
+            sessionSettings: extensionRunner.createContext().sessionSettings,
             compact: (options) => {
                 void (async () => {
                     try {
@@ -1587,6 +1619,12 @@ export class InteractiveMode {
         this.refreshWorkingLoaderMessage();
         this.applyTerminalTitle();
     }
+    stopChatToolAnimations() {
+        for (const child of this.chatContainer.children) {
+            if (child instanceof ToolExecutionComponent)
+                child.stopAnimation();
+        }
+    }
     clearPendingTools() {
         this.toolArgsReveal.flushAll();
         for (const component of this.pendingTools.values()) {
@@ -2726,7 +2764,18 @@ export class InteractiveMode {
             case "tool_execution_update": {
                 const component = this.pendingTools.get(event.toolCallId);
                 if (component) {
-                    component.updateResult({ ...event.partialResult, isError: false }, true);
+                    if (!this.toolResultReveal.update(event.toolCallId, component, event.partialResult)) {
+                        component.updateResult({ ...event.partialResult, isError: false }, true);
+                    }
+                    const activity = readToolProgress(event.partialResult.details)?.activity;
+                    if (activity) {
+                        const label = formatActiveToolWorkingLabel(event.toolName, { command: activity });
+                        this.activeToolExecutions.set(event.toolCallId, label);
+                        this.workingMessage = label;
+                        this.activeToolExecutionTerminalTitle = `${APP_TITLE} - ${label}`;
+                        this.refreshWorkingLoaderMessage();
+                        this.applyTerminalTitle();
+                    }
                     this.requestStreamingRender();
                 }
                 break;
@@ -2736,6 +2785,7 @@ export class InteractiveMode {
                 this.toolArgsReveal.finish(event.toolCallId);
                 const component = this.pendingTools.get(event.toolCallId);
                 if (component) {
+                    this.toolResultReveal.finish(event.toolCallId);
                     component.updateResult({ ...event.result, isError: event.isError });
                     this.pendingTools.delete(event.toolCallId);
                     this.ui.requestRender();
@@ -2750,6 +2800,7 @@ export class InteractiveMode {
                 this.clearActiveToolExecutionStatus();
                 this.clearToolHookStatuses();
                 this.streamingReveal.stop();
+                this.toolResultReveal.stop();
                 if (this.streamingComponent) {
                     this.chatContainer.removeChild(this.streamingComponent);
                     this.streamingComponent = undefined;
@@ -2808,8 +2859,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");
@@ -2830,21 +2889,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;
@@ -2860,6 +2972,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")
@@ -3847,6 +3963,7 @@ export class InteractiveMode {
                     this.settingsManager.setSmoothStreaming(enabled);
                     this.applySmoothStreamingRenderFps();
                     this.toolArgsReveal.refresh();
+                    this.toolResultReveal.refresh();
                     if (this.streamingMessage) {
                         this.streamingReveal.setTarget(this.streamingMessage);
                     }
@@ -3855,6 +3972,7 @@ export class InteractiveMode {
                 onSmoothStreamingFpsChange: (fps) => {
                     this.settingsManager.setSmoothStreamingFps(fps);
                     this.toolArgsReveal.refresh();
+                    this.toolResultReveal.refresh();
                     if (this.settingsManager.getSmoothStreaming()) {
                         this.applySmoothStreamingRenderFps();
                         if (this.streamingMessage) {
@@ -5436,11 +5554,13 @@ export class InteractiveMode {
     }
     stop() {
         this.streamingReveal.stop();
+        this.toolResultReveal.stop();
         if (this.settingsManager.getShowTerminalProgress()) {
             this.ui.terminal.setProgress(false);
         }
         this.clearStatusIndicator();
         this.clearPendingTools();
+        this.stopChatToolAnimations();
         this.clearActiveToolExecutionStatus();
         this.clearToolHookStatuses();
         this.themeController.disableAutoSync();