@caupulican/pi-adaptative 0.81.5 → 0.81.7

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

@@ -297,7 +297,12 @@ export class InteractiveMode {
                 widgetContainerBelow: this.widgetContainerBelow,
                 getEditor: () => this.editor,
                 setEditor: (editor) => {
+                    const previousEditor = this.editor;
                     this.editor = editor;
+                    if (previousEditor !== editor && previousEditor !== this.defaultEditor) {
+                        const disposableEditor = previousEditor;
+                        disposableEditor.dispose?.();
+                    }
                 },
                 getBuiltInHeader: () => this.builtInHeader,
                 getAutocompleteProvider: () => this.autocompleteProvider,
@@ -485,9 +490,7 @@ export class InteractiveMode {
         // Initialize extensions first so resources are shown before messages
         await this.rebindCurrentSession();
         // Register extensions-changed listener for live reload UI refresh
-        this.unsubscribeExtensionsChanged = this.session.onExtensionsChanged(() => {
-            this.refreshUIAfterExtensionsChanged();
-        });
+        this.subscribeToExtensionsChanged();
         // Render initial messages AFTER showing loaded resources
         await this.renderInitialMessages();
         this.renderProjectTrustWarningIfNeeded();
@@ -954,10 +957,17 @@ export class InteractiveMode {
         this.applyRuntimeSettings();
         await this.bindCurrentSessionExtensions();
         this.subscribeToAgent();
+        this.subscribeToExtensionsChanged();
         await this.updateAvailableProviderCount();
         this.updateEditorBorderColor();
         this.updateTerminalTitle();
     }
+    subscribeToExtensionsChanged() {
+        this.unsubscribeExtensionsChanged?.();
+        this.unsubscribeExtensionsChanged = this.session.onExtensionsChanged(() => {
+            this.refreshUIAfterExtensionsChanged();
+        });
+    }
     async handleFatalRuntimeError(prefix, error) {
         const message = error instanceof Error ? error.message : String(error);
         this.showError(`${prefix}: ${message}`);
@@ -2053,107 +2063,113 @@ export class InteractiveMode {
      * @param options.populateHistory Add user messages to editor history
      */
     renderGeneration = 0;
+    renderQueue;
     async renderSessionContext(sessionContext, options = {}) {
-        // Build long history offscreen, then atomically swap it into the visible
-        // chat container. This keeps the TUI responsive without flashing blank or
-        // partial transcript frames during resume/reload/compaction rebuilds.
-        const generation = ++this.renderGeneration;
-        let processed = 0;
-        let committed = false;
-        const visibleChatContainer = this.chatContainer;
-        const previousLiveHistoryHiddenNotice = this.liveHistoryHiddenNotice;
-        const previousLiveHistoryHiddenComponents = this.liveHistoryHiddenComponents;
-        const previousLastStatusSpacer = this.lastStatusSpacer;
-        const previousLastStatusText = this.lastStatusText;
-        const stagingChatContainer = new Container();
-        this.chatContainer = stagingChatContainer;
-        this.resetLiveTuiHistoryTrim();
-        this.clearRenderedToolPanelState();
-        const renderedPendingTools = new Map();
-        try {
-            if (options.updateFooter) {
-                this.footer.invalidate();
-                this.updateEditorBorderColor();
-            }
-            const tuiHistory = this.messagesForTuiHistoryReload(sessionContext.messages);
-            if (tuiHistory.omittedMessages > 0) {
-                this.appendStatusToChat(`Showing last ~${historyReloadMath.TUI_HISTORY_RELOAD_MAX_LINES} TUI history lines; omitted ${tuiHistory.omittedMessages} older message${tuiHistory.omittedMessages === 1 ? "" : "s"}. Full session remains available to the model.`, { requestRender: false });
-            }
-            for (const message of tuiHistory.messages) {
-                if (processed > 0 && processed % TUI_HISTORY_RELOAD_CHUNK_SIZE === 0) {
-                    await new Promise((resolve) => setImmediate(resolve));
-                    if (generation !== this.renderGeneration)
-                        return;
+        const run = async () => {
+            // Build long history offscreen, then atomically swap it into the visible
+            // chat container. This keeps the TUI responsive without flashing blank or
+            // partial transcript frames during resume/reload/compaction rebuilds.
+            this.renderGeneration = (this.renderGeneration ?? 0) + 1;
+            const generation = this.renderGeneration;
+            let processed = 0;
+            let committed = false;
+            const visibleChatContainer = this.chatContainer;
+            const previousLiveHistoryHiddenNotice = this.liveHistoryHiddenNotice;
+            const previousLiveHistoryHiddenComponents = this.liveHistoryHiddenComponents;
+            const previousLastStatusSpacer = this.lastStatusSpacer;
+            const previousLastStatusText = this.lastStatusText;
+            const stagingChatContainer = new Container();
+            this.chatContainer = stagingChatContainer;
+            this.resetLiveTuiHistoryTrim();
+            this.clearRenderedToolPanelState();
+            const renderedPendingTools = new Map();
+            try {
+                if (options.updateFooter) {
+                    this.footer.invalidate();
+                    this.updateEditorBorderColor();
                 }
-                processed++;
-                // Assistant messages need special handling for tool calls
-                if (message.role === "assistant") {
-                    this.addMessageToChat(message);
-                    // Render tool call components
-                    for (const content of message.content) {
-                        if (content.type === "toolCall") {
-                            const component = this.attachToolExecutionComponent(content.name, content.id, content.arguments);
-                            if (message.stopReason === "aborted" || message.stopReason === "error") {
-                                let errorMessage;
-                                if (message.stopReason === "aborted") {
-                                    const retryAttempt = this.session.retryAttempt;
-                                    errorMessage =
-                                        retryAttempt > 0
-                                            ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
-                                            : "Operation aborted";
+                const tuiHistory = this.messagesForTuiHistoryReload(sessionContext.messages);
+                if (tuiHistory.omittedMessages > 0) {
+                    this.appendStatusToChat(`Showing last ~${historyReloadMath.TUI_HISTORY_RELOAD_MAX_LINES} TUI history lines; omitted ${tuiHistory.omittedMessages} older message${tuiHistory.omittedMessages === 1 ? "" : "s"}. Full session remains available to the model.`, { requestRender: false });
+                }
+                for (const message of tuiHistory.messages) {
+                    if (processed > 0 && processed % TUI_HISTORY_RELOAD_CHUNK_SIZE === 0) {
+                        await new Promise((resolve) => setImmediate(resolve));
+                        if (generation !== this.renderGeneration)
+                            return;
+                    }
+                    processed++;
+                    // Assistant messages need special handling for tool calls
+                    if (message.role === "assistant") {
+                        this.addMessageToChat(message);
+                        // Render tool call components
+                        for (const content of message.content) {
+                            if (content.type === "toolCall") {
+                                const component = this.attachToolExecutionComponent(content.name, content.id, content.arguments);
+                                if (message.stopReason === "aborted" || message.stopReason === "error") {
+                                    let errorMessage;
+                                    if (message.stopReason === "aborted") {
+                                        const retryAttempt = this.session.retryAttempt;
+                                        errorMessage =
+                                            retryAttempt > 0
+                                                ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+                                                : "Operation aborted";
+                                    }
+                                    else {
+                                        errorMessage = message.errorMessage || "Error";
+                                    }
+                                    component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
+                                    this.toolPanels.finish(content.id);
                                 }
                                 else {
-                                    errorMessage = message.errorMessage || "Error";
+                                    renderedPendingTools.set(content.id, component);
                                 }
-                                component.updateResult({ content: [{ type: "text", text: errorMessage }], isError: true });
-                                this.toolPanels.finish(content.id);
-                            }
-                            else {
-                                renderedPendingTools.set(content.id, component);
                             }
                         }
                     }
-                }
-                else if (message.role === "toolResult") {
-                    // Match tool results to pending tool components
-                    const component = renderedPendingTools.get(message.toolCallId);
-                    if (component) {
-                        component.updateResult(message);
-                        renderedPendingTools.delete(message.toolCallId);
-                        this.toolPanels.finish(message.toolCallId);
+                    else if (message.role === "toolResult") {
+                        // Match tool results to pending tool components
+                        const component = renderedPendingTools.get(message.toolCallId);
+                        if (component) {
+                            component.updateResult(message);
+                            renderedPendingTools.delete(message.toolCallId);
+                            this.toolPanels.finish(message.toolCallId);
+                        }
+                    }
+                    else {
+                        // All other messages use standard rendering
+                        this.addMessageToChat(message, options);
                     }
                 }
+                if (generation !== this.renderGeneration)
+                    return;
+                visibleChatContainer.children = stagingChatContainer.children;
+                committed = true;
+            }
+            finally {
+                const stagedLiveHistoryHiddenNotice = this.liveHistoryHiddenNotice;
+                const stagedLiveHistoryHiddenComponents = this.liveHistoryHiddenComponents;
+                const stagedLastStatusSpacer = this.lastStatusSpacer;
+                const stagedLastStatusText = this.lastStatusText;
+                this.chatContainer = visibleChatContainer;
+                if (committed) {
+                    this.liveHistoryHiddenNotice = stagedLiveHistoryHiddenNotice;
+                    this.liveHistoryHiddenComponents = stagedLiveHistoryHiddenComponents;
+                    this.lastStatusSpacer = stagedLastStatusSpacer;
+                    this.lastStatusText = stagedLastStatusText;
+                }
                 else {
-                    // All other messages use standard rendering
-                    this.addMessageToChat(message, options);
+                    this.liveHistoryHiddenNotice = previousLiveHistoryHiddenNotice;
+                    this.liveHistoryHiddenComponents = previousLiveHistoryHiddenComponents;
+                    this.lastStatusSpacer = previousLastStatusSpacer;
+                    this.lastStatusText = previousLastStatusText;
                 }
             }
-            if (generation !== this.renderGeneration)
-                return;
-            visibleChatContainer.children = stagingChatContainer.children;
-            committed = true;
-        }
-        finally {
-            const stagedLiveHistoryHiddenNotice = this.liveHistoryHiddenNotice;
-            const stagedLiveHistoryHiddenComponents = this.liveHistoryHiddenComponents;
-            const stagedLastStatusSpacer = this.lastStatusSpacer;
-            const stagedLastStatusText = this.lastStatusText;
-            this.chatContainer = visibleChatContainer;
-            if (committed) {
-                this.liveHistoryHiddenNotice = stagedLiveHistoryHiddenNotice;
-                this.liveHistoryHiddenComponents = stagedLiveHistoryHiddenComponents;
-                this.lastStatusSpacer = stagedLastStatusSpacer;
-                this.lastStatusText = stagedLastStatusText;
-            }
-            else {
-                this.liveHistoryHiddenNotice = previousLiveHistoryHiddenNotice;
-                this.liveHistoryHiddenComponents = previousLiveHistoryHiddenComponents;
-                this.lastStatusSpacer = previousLastStatusSpacer;
-                this.lastStatusText = previousLastStatusText;
-            }
-        }
-        if (committed)
-            this.ui.requestRender();
+            if (committed)
+                this.ui.requestRender();
+        };
+        this.renderQueue = (this.renderQueue ?? Promise.resolve()).then(run, run);
+        return this.renderQueue;
     }
     async renderInitialMessages(options = {}) {
         if (!options.forceHistoryLoad) {