@openeryc/pi-coding-agent 0.75.54 → 0.75.56

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

@@ -12,6 +12,7 @@ import { spawn, spawnSync } from "child_process";
 import { APP_NAME, APP_TITLE, getAgentDir, getAuthPath, getDebugLogPath, getDocsPath, getSelfUpdateCommand, getShareViewerUrl, PACKAGE_NAME, VERSION, } from "../../config.js";
 import { parseSkillBlock } from "../../core/agent-session.js";
 import { SessionImportFileNotFoundError } from "../../core/agent-session-runtime.js";
+import { fetchOpenAICompatibleModels, slugifyProviderId } from "../../core/fetch-openai-models.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { configureHttpDispatcher, formatHttpIdleTimeoutMs } from "../../core/http-dispatcher.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
@@ -52,9 +53,8 @@ import { FooterComponent } from "./components/footer.js";
 import { formatKeyText, keyDisplayText, keyHint, keyText, rawKeyHint } from "./components/keybinding-hints.js";
 import { LoginDialogComponent } from "./components/login-dialog.js";
 import { McpSelectorComponent } from "./components/mcp-selector.js";
-import { ModelSelectorComponent } from "./components/model-selector.js";
+import { ModelHubComponent } from "./components/model-hub.js";
 import { OAuthSelectorComponent } from "./components/oauth-selector.js";
-import { ScopedModelsSelectorComponent } from "./components/scoped-models-selector.js";
 import { SessionSelectorComponent } from "./components/session-selector.js";
 import { SettingsSelectorComponent } from "./components/settings-selector.js";
 import { SkillInvocationMessageComponent } from "./components/skill-invocation-message.js";
@@ -153,6 +153,8 @@ export class InteractiveMode {
     hideThinkingBlock = false;
     // Skill commands: command name -> skill file path
     skillCommands = new Map();
+    /** Slash command dispatch map */
+    commands = new Map();
     // Agent subscription unsubscribe function
     unsubscribe;
     signalCleanupHandlers = [];
@@ -478,6 +480,7 @@ export class InteractiveMode {
         this.ui.setFocus(this.editor);
         this.setupKeyHandlers();
         this.setupEditorSubmitHandler();
+        this.initCommands();
         // Start the UI before initializing extensions so session_start handlers can use interactive dialogs
         this.ui.start();
         this.isInitialized = true;
@@ -528,23 +531,29 @@ export class InteractiveMode {
             await this.goalRunnerContinuationLoop(resumedGoal);
         }
         // Start version check asynchronously
-        checkForNewPiVersion(this.version).then((newRelease) => {
+        checkForNewPiVersion(this.version)
+            .then((newRelease) => {
             if (newRelease) {
                 this.showNewVersionNotification(newRelease);
             }
-        });
+        })
+            .catch(() => { });
         // Start package update check asynchronously
-        this.checkForPackageUpdates().then((updates) => {
+        this.checkForPackageUpdates()
+            .then((updates) => {
             if (updates.length > 0) {
                 this.showPackageUpdateNotification(updates);
             }
-        });
+        })
+            .catch(() => { });
         // Check tmux keyboard setup asynchronously
-        this.checkTmuxKeyboardSetup().then((warning) => {
+        this.checkTmuxKeyboardSetup()
+            .then((warning) => {
             if (warning) {
                 this.showWarning(warning);
             }
-        });
+        })
+            .catch(() => { });
         // Show startup warnings
         const { migratedProviders, modelFallbackMessage, initialMessage, initialImages, initialMessages } = this.options;
         if (migratedProviders && migratedProviders.length > 0) {
@@ -1957,7 +1966,7 @@ export class InteractiveMode {
         this.defaultEditor.onAction("app.model.cycleBackward", () => this.cycleModel("backward"));
         // Global debug handler on TUI (works regardless of focus)
         this.ui.onDebug = () => this.handleDebugCommand();
-        this.defaultEditor.onAction("app.model.select", () => this.showModelSelector());
+        this.defaultEditor.onAction("app.model.select", () => this.showModelHub("select"));
         this.defaultEditor.onAction("app.tools.expand", () => this.toggleToolOutputExpansion());
         this.defaultEditor.onAction("app.thinking.toggle", () => this.toggleThinkingBlockVisibility());
         this.defaultEditor.onAction("app.editor.external", () => this.openExternalEditor());
@@ -1999,6 +2008,60 @@ export class InteractiveMode {
             // Silently ignore clipboard errors (may not have permission, etc.)
         }
     }
+    initCommands() {
+        const noArg = (fn) => async (_text) => {
+            this.editor.setText("");
+            await fn();
+        };
+        this.commands.set("/settings", noArg(() => this.showSettingsSelector()));
+        this.commands.set("/scoped-models", noArg(() => this.showModelHub("cycle")));
+        this.commands.set("/model", async (text) => {
+            const s = text.startsWith("/model ") ? text.slice(7).trim() : undefined;
+            this.editor.setText("");
+            await this.handleModelCommand(s);
+        });
+        this.commands.set("/export", async (text) => {
+            await this.handleExportCommand(text);
+            this.editor.setText("");
+        });
+        this.commands.set("/import", async (text) => {
+            await this.handleImportCommand(text);
+            this.editor.setText("");
+        });
+        this.commands.set("/share", noArg(() => this.handleShareCommand()));
+        this.commands.set("/copy", noArg(() => this.handleCopyCommand()));
+        this.commands.set("/name", async (text) => {
+            this.handleNameCommand(text);
+            this.editor.setText("");
+        });
+        this.commands.set("/session", noArg(() => this.handleSessionCommand()));
+        this.commands.set("/mcp", noArg(() => this.showMcpSelector()));
+        this.commands.set("/skills", noArg(() => this.showSkillsSelector()));
+        this.commands.set("/usage", noArg(() => this.handleUsageCommand()));
+        this.commands.set("/memory", noArg(() => this.handleMemoryCommand()));
+        this.commands.set("/changelog", noArg(() => this.handleChangelogCommand()));
+        this.commands.set("/hotkeys", noArg(() => this.handleHotkeysCommand()));
+        this.commands.set("/fork", noArg(() => this.showUserMessageSelector()));
+        this.commands.set("/clone", noArg(() => this.handleCloneCommand()));
+        this.commands.set("/tree", noArg(() => this.showTreeSelector()));
+        this.commands.set("/login", noArg(() => this.showOAuthSelector("login")));
+        this.commands.set("/logout", noArg(() => this.showOAuthSelector("logout")));
+        this.commands.set("/new", noArg(() => this.handleClearCommand()));
+        this.commands.set("/compact", async (text) => {
+            const ci = text.startsWith("/compact ") ? text.slice(9).trim() : undefined;
+            this.editor.setText("");
+            await this.handleCompactCommand(ci);
+        });
+        this.commands.set("/cleanup", noArg(() => this.handleCleanupCommand()));
+        this.commands.set("/reload", noArg(() => this.handleReloadCommand()));
+        this.commands.set("/debug", noArg(() => this.handleDebugCommand()));
+        this.commands.set("/arminsayshi", noArg(() => this.handleArminSaysHi()));
+        this.commands.set("/dementedelves", noArg(() => this.handleDementedDelves()));
+        this.commands.set("/daxnuts", noArg(() => this.handleDaxnuts()));
+        this.commands.set("/resume", noArg(() => this.showSessionSelector()));
+        this.commands.set("/update", noArg(() => this.handleUpdateCommand()));
+        this.commands.set("/quit", noArg(() => this.shutdown()));
+    }
     setupEditorSubmitHandler() {
         this.defaultEditor.onSubmit = async (text) => {
             text = text.trim();
@@ -2006,171 +2069,22 @@ export class InteractiveMode {
                 return;
             // Add to history before handling (so up/down can recall commands too)
             this.editor.addToHistory?.(text);
-            // Handle commands
-            if (text === "/settings") {
-                this.showSettingsSelector();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/scoped-models") {
-                this.editor.setText("");
-                await this.showModelsSelector();
-                return;
-            }
-            if (text === "/model" || text.startsWith("/model ")) {
-                const searchTerm = text.startsWith("/model ") ? text.slice(7).trim() : undefined;
-                this.editor.setText("");
-                await this.handleModelCommand(searchTerm);
-                return;
-            }
-            if (text === "/export" || text.startsWith("/export ")) {
-                await this.handleExportCommand(text);
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/import" || text.startsWith("/import ")) {
-                await this.handleImportCommand(text);
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/share") {
-                await this.handleShareCommand();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/copy") {
-                await this.handleCopyCommand();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/name" || text.startsWith("/name ")) {
-                this.handleNameCommand(text);
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/goal" || text.startsWith("/goal ")) {
+            // Handle commands (with special case for /goal which continues to submit)
+            if (text.startsWith("/goal")) {
                 const goal = text.replace(/^\/goal\s*/, "").trim();
                 this.handleGoalCommand(text);
-                if (goal)
-                    text = goal; // Submit goal text as the user message, not /goal prefix
-                // Don't return — let the normal submit flow run so the agent starts working
-            }
-            if (text === "/session") {
-                this.handleSessionCommand();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/mcp") {
-                this.editor.setText("");
-                this.showMcpSelector();
-                return;
-            }
-            if (text.startsWith("/mcp ")) {
-                const name = text.slice(5).trim();
-                this.editor.setText("");
-                this.showMcpSelector(name);
-                return;
-            }
-            if (text === "/skills") {
-                this.editor.setText("");
-                this.showSkillsSelector();
-                return;
-            }
-            if (text === "/usage") {
-                this.editor.setText("");
-                await this.handleUsageCommand();
-                return;
-            }
-            if (text === "/memory") {
-                this.handleMemoryCommand();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/changelog") {
-                this.handleChangelogCommand();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/hotkeys") {
-                this.handleHotkeysCommand();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/fork") {
-                this.showUserMessageSelector();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/clone") {
-                this.editor.setText("");
-                await this.handleCloneCommand();
-                return;
-            }
-            if (text === "/tree") {
-                this.showTreeSelector();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/login") {
-                this.showOAuthSelector("login");
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/logout") {
-                this.showOAuthSelector("logout");
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/new") {
                 this.editor.setText("");
-                await this.handleClearCommand();
-                return;
-            }
-            if (text === "/compact" || text.startsWith("/compact ")) {
-                const customInstructions = text.startsWith("/compact ") ? text.slice(9).trim() : undefined;
-                this.editor.setText("");
-                await this.handleCompactCommand(customInstructions);
-                return;
-            }
-            if (text === "/cleanup") {
-                this.editor.setText("");
-                await this.handleCleanupCommand();
-                return;
-            }
-            if (text === "/reload") {
-                this.editor.setText("");
-                await this.handleReloadCommand();
-                return;
-            }
-            if (text === "/debug") {
-                this.handleDebugCommand();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/arminsayshi") {
-                this.handleArminSaysHi();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/dementedelves") {
-                this.handleDementedDelves();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/resume") {
-                this.showSessionSelector();
-                this.editor.setText("");
-                return;
-            }
-            if (text === "/update") {
-                this.editor.setText("");
-                await this.handleUpdateCommand();
-                return;
+                if (goal)
+                    text = goal;
             }
-            if (text === "/quit") {
-                this.editor.setText("");
-                await this.shutdown();
-                return;
+            else {
+                const spaceIdx = text.indexOf(" ");
+                const cmd = spaceIdx === -1 ? text : text.slice(0, spaceIdx);
+                const handler = this.commands.get(cmd);
+                if (handler) {
+                    await handler(text);
+                    return;
+                }
             }
             // Handle bash command (! for normal, !! for excluded from context)
             if (text.startsWith("!")) {
@@ -2232,280 +2146,299 @@ export class InteractiveMode {
         this.footer.invalidate();
         switch (event.type) {
             case "agent_start":
-                this.pendingTools.clear();
-                if (this.settingsManager.getShowTerminalProgress()) {
-                    this.ui.terminal.setProgress(true);
-                }
-                // Restore main escape handler if retry handler is still active
-                // (retry success event fires later, but we need main handler now)
-                if (this.retryEscapeHandler) {
-                    this.defaultEditor.onEscape = this.retryEscapeHandler;
-                    this.retryEscapeHandler = undefined;
-                }
-                if (this.retryCountdown) {
-                    this.retryCountdown.dispose();
-                    this.retryCountdown = undefined;
-                }
-                if (this.retryLoader) {
-                    this.retryLoader.stop();
-                    this.retryLoader = undefined;
-                }
-                this.stopWorkingLoader();
-                if (this.workingVisible) {
-                    this.loadingAnimation = this.createWorkingLoader();
-                    this.statusContainer.addChild(this.loadingAnimation);
-                }
-                this.ui.requestRender();
+                this._handleAgentStart();
                 break;
             case "queue_update":
-                this.updatePendingMessagesDisplay();
-                this.ui.requestRender();
+                this._handleQueueUpdate();
                 break;
             case "session_info_changed":
-                this.updateTerminalTitle();
-                this.footer.invalidate();
-                this.ui.requestRender();
+                this._handleSessionInfoChanged();
                 break;
             case "thinking_level_changed":
-                this.footer.invalidate();
-                this.updateEditorBorderColor();
+                this._handleThinkingLevelChanged();
                 break;
             case "message_start":
-                if (event.message.role === "custom") {
-                    this.addMessageToChat(event.message);
-                    this.ui.requestRender();
-                }
-                else if (event.message.role === "user") {
-                    this.addMessageToChat(event.message);
-                    this.updatePendingMessagesDisplay();
-                    this.ui.requestRender();
-                }
-                else if (event.message.role === "assistant") {
-                    this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
-                    this.streamingMessage = event.message;
-                    this.chatContainer.addChild(this.streamingComponent);
-                    this.streamingComponent.updateContent(this.streamingMessage);
-                    this.ui.requestRender();
-                }
+                this._handleMessageStart(event);
                 break;
             case "message_update":
-                if (this.streamingComponent && event.message.role === "assistant") {
-                    this.streamingMessage = event.message;
-                    this.streamingComponent.updateContent(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, {
-                                    showImages: this.settingsManager.getShowImages(),
-                                    imageWidthCells: this.settingsManager.getImageWidthCells(),
-                                }, this.getRegisteredToolDefinition(content.name), this.ui, this.sessionManager.getCwd());
-                                component.setExpanded(this.toolOutputExpanded);
-                                this.chatContainer.addChild(component);
-                                this.pendingTools.set(content.id, component);
-                            }
-                            else {
-                                const component = this.pendingTools.get(content.id);
-                                if (component) {
-                                    component.updateArgs(content.arguments);
-                                }
-                            }
-                        }
-                    }
-                    this.ui.requestRender();
-                }
+                this._handleMessageUpdate(event);
                 break;
             case "message_end":
-                if (event.message.role === "user")
-                    break;
-                if (this.streamingComponent && event.message.role === "assistant") {
-                    this.streamingMessage = event.message;
-                    let errorMessage;
-                    if (this.streamingMessage.stopReason === "aborted") {
-                        const retryAttempt = this.session.retryAttempt;
-                        errorMessage =
-                            retryAttempt > 0
-                                ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
-                                : "Operation aborted";
-                        this.streamingMessage.errorMessage = errorMessage;
-                    }
-                    this.streamingComponent.updateContent(this.streamingMessage);
-                    if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
-                        if (!errorMessage) {
-                            errorMessage = this.streamingMessage.errorMessage || "Error";
-                        }
-                        for (const [, component] of this.pendingTools.entries()) {
-                            component.updateResult({
-                                content: [{ type: "text", text: errorMessage }],
-                                isError: true,
-                            });
-                        }
-                        this.pendingTools.clear();
-                    }
-                    else {
-                        // Args are now complete - trigger diff computation for edit tools
-                        for (const [, component] of this.pendingTools.entries()) {
-                            component.setArgsComplete();
-                        }
-                    }
-                    this.streamingComponent = undefined;
-                    this.streamingMessage = undefined;
-                    this.footer.invalidate();
-                }
-                this.ui.requestRender();
+                this._handleMessageEnd(event);
                 break;
-            case "tool_execution_start": {
-                let component = this.pendingTools.get(event.toolCallId);
-                if (!component) {
-                    component = new ToolExecutionComponent(event.toolName, event.toolCallId, event.args, {
-                        showImages: this.settingsManager.getShowImages(),
-                        imageWidthCells: this.settingsManager.getImageWidthCells(),
-                    }, this.getRegisteredToolDefinition(event.toolName), this.ui, this.sessionManager.getCwd());
-                    component.setExpanded(this.toolOutputExpanded);
-                    this.chatContainer.addChild(component);
-                    this.pendingTools.set(event.toolCallId, component);
-                }
-                component.markExecutionStarted();
-                this.ui.requestRender();
+            case "tool_execution_start":
+                this._handleToolExecutionStart(event);
                 break;
-            }
-            case "tool_execution_update": {
-                const component = this.pendingTools.get(event.toolCallId);
-                if (component) {
-                    component.updateResult({ ...event.partialResult, isError: false }, true);
-                    this.ui.requestRender();
-                }
+            case "tool_execution_update":
+                this._handleToolExecutionUpdate(event);
                 break;
-            }
-            case "tool_execution_end": {
-                const component = this.pendingTools.get(event.toolCallId);
-                if (component) {
-                    component.updateResult({ ...event.result, isError: event.isError });
-                    this.pendingTools.delete(event.toolCallId);
-                    this.ui.requestRender();
-                }
+            case "tool_execution_end":
+                this._handleToolExecutionEnd(event);
                 break;
-            }
             case "agent_end":
-                if (this.settingsManager.getShowTerminalProgress()) {
-                    this.ui.terminal.setProgress(false);
-                }
-                if (this.loadingAnimation) {
-                    this.loadingAnimation.stop();
-                    this.loadingAnimation = undefined;
-                    this.statusContainer.clear();
-                }
-                if (this.streamingComponent) {
-                    this.chatContainer.removeChild(this.streamingComponent);
-                    this.streamingComponent = undefined;
-                    this.streamingMessage = undefined;
-                }
-                this.pendingTools.clear();
-                await this.checkShutdownRequested();
-                this.ui.requestRender();
+                await this._handleAgentEnd();
                 break;
-            case "compaction_start": {
-                if (this.settingsManager.getShowTerminalProgress()) {
-                    this.ui.terminal.setProgress(true);
-                }
-                // Keep editor active; submissions are queued during compaction.
-                this.autoCompactionEscapeHandler = this.defaultEditor.onEscape;
-                this.defaultEditor.onEscape = () => {
-                    this.session.abortCompaction();
-                };
-                this.statusContainer.clear();
-                const cancelHint = `(${keyText("app.interrupt")} to cancel)`;
-                const label = event.reason === "manual"
-                    ? `Compacting context... ${cancelHint}`
-                    : `${event.reason === "overflow" ? "Context overflow detected, " : ""}Auto-compacting... ${cancelHint}`;
-                this.autoCompactionLoader = new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), label);
-                this.statusContainer.addChild(this.autoCompactionLoader);
-                this.ui.requestRender();
+            case "compaction_start":
+                this._handleCompactionStart(event);
                 break;
-            }
-            case "compaction_end": {
-                if (this.settingsManager.getShowTerminalProgress()) {
-                    this.ui.terminal.setProgress(false);
-                }
-                if (this.autoCompactionEscapeHandler) {
-                    this.defaultEditor.onEscape = this.autoCompactionEscapeHandler;
-                    this.autoCompactionEscapeHandler = undefined;
-                }
-                if (this.autoCompactionLoader) {
-                    this.autoCompactionLoader.stop();
-                    this.autoCompactionLoader = undefined;
-                    this.statusContainer.clear();
-                }
-                if (event.aborted) {
-                    if (event.reason === "manual") {
-                        this.showError("Compaction cancelled");
-                    }
-                    else {
-                        this.showStatus("Auto-compaction cancelled");
-                    }
-                }
-                else if (event.result) {
-                    this.chatContainer.clear();
-                    this.rebuildChatFromMessages();
-                    this.addMessageToChat(createCompactionSummaryMessage(event.result.summary, event.result.tokensBefore, new Date().toISOString()));
-                    this.footer.invalidate();
-                }
-                else if (event.errorMessage) {
-                    if (event.reason === "manual") {
-                        this.showError(event.errorMessage);
-                    }
-                    else {
-                        this.chatContainer.addChild(new Spacer(1));
-                        this.chatContainer.addChild(new Text(theme.fg("error", event.errorMessage), 1, 0));
-                    }
-                }
-                void this.flushCompactionQueue({ willRetry: event.willRetry });
-                this.ui.requestRender();
+            case "compaction_end":
+                this._handleCompactionEnd(event);
                 break;
-            }
-            case "auto_retry_start": {
-                // Set up escape to abort retry
-                this.retryEscapeHandler = this.defaultEditor.onEscape;
-                this.defaultEditor.onEscape = () => {
-                    this.session.abortRetry();
-                };
-                // Show retry indicator
-                this.statusContainer.clear();
-                this.retryCountdown?.dispose();
-                const retryMessage = (seconds) => `Retrying (${event.attempt}/${event.maxAttempts}) in ${seconds}s... (${keyText("app.interrupt")} to cancel)`;
-                this.retryLoader = new Loader(this.ui, (spinner) => theme.fg("warning", spinner), (text) => theme.fg("muted", text), retryMessage(Math.ceil(event.delayMs / 1000)));
-                this.retryCountdown = new CountdownTimer(event.delayMs, this.ui, (seconds) => {
-                    this.retryLoader?.setMessage(retryMessage(seconds));
-                }, () => {
-                    this.retryCountdown = undefined;
-                });
-                this.statusContainer.addChild(this.retryLoader);
-                this.ui.requestRender();
+            case "auto_retry_start":
+                this._handleAutoRetryStart(event);
                 break;
-            }
-            case "auto_retry_end": {
-                // Restore escape handler
-                if (this.retryEscapeHandler) {
-                    this.defaultEditor.onEscape = this.retryEscapeHandler;
-                    this.retryEscapeHandler = undefined;
-                }
-                if (this.retryCountdown) {
-                    this.retryCountdown.dispose();
-                    this.retryCountdown = undefined;
-                }
-                // Stop loader
-                if (this.retryLoader) {
-                    this.retryLoader.stop();
-                    this.retryLoader = undefined;
-                    this.statusContainer.clear();
-                }
-                // Show error only on final failure (success shows normal response)
-                if (!event.success) {
-                    this.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`);
-                }
-                this.ui.requestRender();
+            case "auto_retry_end":
+                this._handleAutoRetryEnd(event);
                 break;
+        }
+    }
+    _handleAgentStart() {
+        this.pendingTools.clear();
+        if (this.settingsManager.getShowTerminalProgress()) {
+            this.ui.terminal.setProgress(true);
+        }
+        if (this.retryEscapeHandler) {
+            this.defaultEditor.onEscape = this.retryEscapeHandler;
+            this.retryEscapeHandler = undefined;
+        }
+        if (this.retryCountdown) {
+            this.retryCountdown.dispose();
+            this.retryCountdown = undefined;
+        }
+        if (this.retryLoader) {
+            this.retryLoader.stop();
+            this.retryLoader = undefined;
+        }
+        this.stopWorkingLoader();
+        if (this.workingVisible) {
+            this.loadingAnimation = this.createWorkingLoader();
+            this.statusContainer.addChild(this.loadingAnimation);
+        }
+        this.ui.requestRender();
+    }
+    _handleQueueUpdate() {
+        this.updatePendingMessagesDisplay();
+        this.ui.requestRender();
+    }
+    _handleSessionInfoChanged() {
+        this.updateTerminalTitle();
+        this.footer.invalidate();
+        this.ui.requestRender();
+    }
+    _handleThinkingLevelChanged() {
+        this.footer.invalidate();
+        this.updateEditorBorderColor();
+    }
+    _handleMessageStart(event) {
+        if (event.message.role === "custom") {
+            this.addMessageToChat(event.message);
+            this.ui.requestRender();
+        }
+        else if (event.message.role === "user") {
+            this.addMessageToChat(event.message);
+            this.updatePendingMessagesDisplay();
+            this.ui.requestRender();
+        }
+        else if (event.message.role === "assistant") {
+            this.streamingComponent = new AssistantMessageComponent(undefined, this.hideThinkingBlock, this.getMarkdownThemeWithSettings(), this.hiddenThinkingLabel);
+            this.streamingMessage = event.message;
+            this.chatContainer.addChild(this.streamingComponent);
+            this.streamingComponent.updateContent(this.streamingMessage);
+            this.ui.requestRender();
+        }
+    }
+    _handleMessageUpdate(event) {
+        if (!this.streamingComponent || event.message.role !== "assistant")
+            return;
+        this.streamingMessage = event.message;
+        this.streamingComponent.updateContent(this.streamingMessage);
+        for (const content of this.streamingMessage.content) {
+            if (content.type !== "toolCall")
+                continue;
+            if (!this.pendingTools.has(content.id)) {
+                const 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());
+                component.setExpanded(this.toolOutputExpanded);
+                this.chatContainer.addChild(component);
+                this.pendingTools.set(content.id, component);
+            }
+            else {
+                this.pendingTools.get(content.id)?.updateArgs(content.arguments);
+            }
+        }
+        this.ui.requestRender();
+    }
+    _handleMessageEnd(event) {
+        if (event.message.role === "user")
+            return;
+        if (!this.streamingComponent || event.message.role !== "assistant")
+            return;
+        this.streamingMessage = event.message;
+        let errorMessage;
+        if (this.streamingMessage.stopReason === "aborted") {
+            const retryAttempt = this.session.retryAttempt;
+            errorMessage =
+                retryAttempt > 0
+                    ? `Aborted after ${retryAttempt} retry attempt${retryAttempt > 1 ? "s" : ""}`
+                    : "Operation aborted";
+            this.streamingMessage.errorMessage = errorMessage;
+        }
+        this.streamingComponent.updateContent(this.streamingMessage);
+        if (this.streamingMessage.stopReason === "aborted" || this.streamingMessage.stopReason === "error") {
+            const msg = errorMessage || this.streamingMessage.errorMessage || "Error";
+            for (const [, component] of this.pendingTools.entries()) {
+                component.updateResult({ content: [{ type: "text", text: msg }], isError: true });
+            }
+            this.pendingTools.clear();
+        }
+        else {
+            for (const [, component] of this.pendingTools.entries()) {
+                component.setArgsComplete();
+            }
+        }
+        this.streamingComponent = undefined;
+        this.streamingMessage = undefined;
+        this.footer.invalidate();
+        this.ui.requestRender();
+    }
+    _handleToolExecutionStart(event) {
+        let component = this.pendingTools.get(event.toolCallId);
+        if (!component) {
+            component = new ToolExecutionComponent(event.toolName, event.toolCallId, event.args, {
+                showImages: this.settingsManager.getShowImages(),
+                imageWidthCells: this.settingsManager.getImageWidthCells(),
+            }, this.getRegisteredToolDefinition(event.toolName), this.ui, this.sessionManager.getCwd());
+            component.setExpanded(this.toolOutputExpanded);
+            this.chatContainer.addChild(component);
+            this.pendingTools.set(event.toolCallId, component);
+        }
+        component.markExecutionStarted();
+        this.ui.requestRender();
+    }
+    _handleToolExecutionUpdate(event) {
+        const component = this.pendingTools.get(event.toolCallId);
+        if (component) {
+            component.updateResult({ ...event.partialResult, isError: false }, true);
+            this.ui.requestRender();
+        }
+    }
+    _handleToolExecutionEnd(event) {
+        const component = this.pendingTools.get(event.toolCallId);
+        if (component) {
+            component.updateResult({ ...event.result, isError: event.isError });
+            this.pendingTools.delete(event.toolCallId);
+            this.ui.requestRender();
+        }
+    }
+    async _handleAgentEnd() {
+        if (this.settingsManager.getShowTerminalProgress()) {
+            this.ui.terminal.setProgress(false);
+        }
+        if (this.loadingAnimation) {
+            this.loadingAnimation.stop();
+            this.loadingAnimation = undefined;
+            this.statusContainer.clear();
+        }
+        if (this.streamingComponent) {
+            this.chatContainer.removeChild(this.streamingComponent);
+            this.streamingComponent = undefined;
+            this.streamingMessage = undefined;
+        }
+        this.pendingTools.clear();
+        await this.checkShutdownRequested();
+        this.ui.requestRender();
+    }
+    _handleCompactionStart(event) {
+        if (this.settingsManager.getShowTerminalProgress()) {
+            this.ui.terminal.setProgress(true);
+        }
+        this.autoCompactionEscapeHandler = this.defaultEditor.onEscape;
+        this.defaultEditor.onEscape = () => {
+            this.session.abortCompaction();
+        };
+        this.statusContainer.clear();
+        const cancelHint = `(${keyText("app.interrupt")} to cancel)`;
+        const label = event.reason === "manual"
+            ? `Compacting context... ${cancelHint}`
+            : `${event.reason === "overflow" ? "Context overflow detected, " : ""}Auto-compacting... ${cancelHint}`;
+        this.autoCompactionLoader = new Loader(this.ui, (spinner) => theme.fg("accent", spinner), (text) => theme.fg("muted", text), label);
+        this.statusContainer.addChild(this.autoCompactionLoader);
+        this.ui.requestRender();
+    }
+    _handleCompactionEnd(event) {
+        if (this.settingsManager.getShowTerminalProgress()) {
+            this.ui.terminal.setProgress(false);
+        }
+        if (this.autoCompactionEscapeHandler) {
+            this.defaultEditor.onEscape = this.autoCompactionEscapeHandler;
+            this.autoCompactionEscapeHandler = undefined;
+        }
+        if (this.autoCompactionLoader) {
+            this.autoCompactionLoader.stop();
+            this.autoCompactionLoader = undefined;
+            this.statusContainer.clear();
+        }
+        if (event.aborted) {
+            if (event.reason === "manual") {
+                this.showError("Compaction cancelled");
+            }
+            else {
+                this.showStatus("Auto-compaction cancelled");
+            }
+        }
+        else if (event.result) {
+            this.chatContainer.clear();
+            this.rebuildChatFromMessages();
+            this.addMessageToChat(createCompactionSummaryMessage(event.result.summary, event.result.tokensBefore, new Date().toISOString()));
+            this.footer.invalidate();
+        }
+        else if (event.errorMessage) {
+            if (event.reason === "manual") {
+                this.showError(event.errorMessage);
+            }
+            else {
+                this.chatContainer.addChild(new Spacer(1));
+                this.chatContainer.addChild(new Text(theme.fg("error", event.errorMessage), 1, 0));
             }
         }
+        void this.flushCompactionQueue({ willRetry: event.willRetry });
+        this.ui.requestRender();
+    }
+    _handleAutoRetryStart(event) {
+        this.retryEscapeHandler = this.defaultEditor.onEscape;
+        this.defaultEditor.onEscape = () => {
+            this.session.abortRetry();
+        };
+        this.statusContainer.clear();
+        this.retryCountdown?.dispose();
+        const retryMessage = (seconds) => `Retrying (${event.attempt}/${event.maxAttempts}) in ${seconds}s... (${keyText("app.interrupt")} to cancel)`;
+        this.retryLoader = new Loader(this.ui, (spinner) => theme.fg("warning", spinner), (text) => theme.fg("muted", text), retryMessage(Math.ceil(event.delayMs / 1000)));
+        this.retryCountdown = new CountdownTimer(event.delayMs, this.ui, (seconds) => this.retryLoader?.setMessage(retryMessage(seconds)), () => {
+            this.retryCountdown = undefined;
+        });
+        this.statusContainer.addChild(this.retryLoader);
+        this.ui.requestRender();
+    }
+    _handleAutoRetryEnd(event) {
+        if (this.retryEscapeHandler) {
+            this.defaultEditor.onEscape = this.retryEscapeHandler;
+            this.retryEscapeHandler = undefined;
+        }
+        if (this.retryCountdown) {
+            this.retryCountdown.dispose();
+            this.retryCountdown = undefined;
+        }
+        if (this.retryLoader) {
+            this.retryLoader.stop();
+            this.retryLoader = undefined;
+            this.statusContainer.clear();
+        }
+        if (!event.success) {
+            this.showError(`Retry failed after ${event.attempt} attempts: ${event.finalError || "Unknown error"}`);
+        }
+        this.ui.requestRender();
     }
     /** Extract text content from a user message */
     getUserMessageText(message) {
@@ -3415,7 +3348,7 @@ export class InteractiveMode {
     }
     async handleModelCommand(searchTerm) {
         if (!searchTerm) {
-            this.showModelSelector();
+            this.showModelHub("select");
             return;
         }
         const model = await this.findExactModelMatch(searchTerm);
@@ -3433,7 +3366,7 @@ export class InteractiveMode {
             }
             return;
         }
-        this.showModelSelector(searchTerm);
+        this.showModelHub("select", searchTerm);
     }
     async findExactModelMatch(searchTerm) {
         const models = await this.getModelCandidates();
@@ -3485,93 +3418,100 @@ export class InteractiveMode {
             // Ignore auth lookup failures for warning-only checks.
         }
     }
-    showModelSelector(initialSearchInput) {
-        this.showSelector((done) => {
-            const selector = new ModelSelectorComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, this.session.scopedModels, async (model) => {
-                try {
-                    await this.session.setModel(model);
-                    this.footer.invalidate();
-                    this.updateEditorBorderColor();
-                    done();
-                    this.showStatus(`Model: ${model.id}`);
-                    void this.maybeWarnAboutAnthropicSubscriptionAuth(model);
-                    this.checkDaxnutsEasterEgg(model);
-                }
-                catch (error) {
-                    done();
-                    this.showError(error instanceof Error ? error.message : String(error));
-                }
-            }, () => {
-                done();
-                this.ui.requestRender();
-            }, initialSearchInput);
-            return { component: selector, focus: selector };
-        });
+    async resolveEnabledModelIds() {
+        const sessionScopedModels = this.session.scopedModels;
+        if (sessionScopedModels.length > 0) {
+            return sessionScopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
+        }
+        const patterns = this.settingsManager.getEnabledModels();
+        if (patterns !== undefined && patterns.length > 0) {
+            const scopedModels = await resolveModelScope(patterns, this.session.modelRegistry);
+            return scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
+        }
+        return null;
     }
-    async showModelsSelector() {
-        // Get all available models
-        this.session.modelRegistry.refresh();
+    async applyCycleEnabledIds(enabledIds) {
         const allModels = this.session.modelRegistry.getAvailable();
-        if (allModels.length === 0) {
-            this.showStatus("No models available");
-            return;
-        }
-        // Check if session has scoped models (from previous session-only changes or CLI --models)
-        const sessionScopedModels = this.session.scopedModels;
-        const hasSessionScope = sessionScopedModels.length > 0;
-        // Build enabled model IDs from session state or settings
-        let currentEnabledIds = null;
-        if (hasSessionScope) {
-            // Use current session's scoped models
-            currentEnabledIds = sessionScopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
+        if (enabledIds && enabledIds.length > 0 && enabledIds.length < allModels.length) {
+            const newScopedModels = await resolveModelScope(enabledIds, this.session.modelRegistry);
+            this.session.setScopedModels(newScopedModels.map((sm) => ({
+                model: sm.model,
+                thinkingLevel: sm.thinkingLevel,
+            })));
         }
         else {
-            // Fall back to settings
-            const patterns = this.settingsManager.getEnabledModels();
-            if (patterns !== undefined && patterns.length > 0) {
-                const scopedModels = await resolveModelScope(patterns, this.session.modelRegistry);
-                currentEnabledIds = scopedModels.map((scoped) => `${scoped.model.provider}/${scoped.model.id}`);
-            }
-        }
-        // Helper to update session's scoped models (session-only, no persist)
-        const updateSessionModels = async (enabledIds) => {
-            currentEnabledIds = enabledIds === null ? null : [...enabledIds];
-            if (enabledIds && enabledIds.length > 0 && enabledIds.length < allModels.length) {
-                const newScopedModels = await resolveModelScope(enabledIds, this.session.modelRegistry);
-                this.session.setScopedModels(newScopedModels.map((sm) => ({
-                    model: sm.model,
-                    thinkingLevel: sm.thinkingLevel,
-                })));
-            }
-            else {
-                // All enabled or none enabled = no filter
-                this.session.setScopedModels([]);
-            }
-            await this.updateAvailableProviderCount();
-            this.ui.requestRender();
-        };
-        this.showSelector((done) => {
-            const selector = new ScopedModelsSelectorComponent({
-                allModels,
-                enabledModelIds: currentEnabledIds,
-            }, {
-                onChange: async (enabledIds) => {
-                    await updateSessionModels(enabledIds);
-                },
-                onPersist: (enabledIds) => {
-                    // Persist to settings
-                    const newPatterns = enabledIds === null || enabledIds.length === allModels.length
-                        ? undefined // All enabled = clear filter
-                        : enabledIds;
-                    this.settingsManager.setEnabledModels(newPatterns ? [...newPatterns] : undefined);
-                    this.showStatus("Model selection saved to settings");
-                },
-                onCancel: () => {
-                    done();
-                    this.ui.requestRender();
-                },
+            this.session.setScopedModels([]);
+        }
+        await this.updateAvailableProviderCount();
+        this.ui.requestRender();
+    }
+    showModelHub(initialTab = "select", initialSearchInput) {
+        void this.resolveEnabledModelIds().then((enabledModelIds) => {
+            this.showSelector((done) => {
+                const hub = new ModelHubComponent(this.ui, this.session.model, this.settingsManager, this.session.modelRegistry, this.session.scopedModels, enabledModelIds, {
+                    onSelectModel: async (model) => {
+                        try {
+                            await this.session.setModel(model);
+                            this.footer.invalidate();
+                            this.updateEditorBorderColor();
+                            done();
+                            this.showStatus(`Model: ${model.id}`);
+                            void this.maybeWarnAboutAnthropicSubscriptionAuth(model);
+                            this.checkDaxnutsEasterEgg(model);
+                        }
+                        catch (error) {
+                            done();
+                            this.showError(error instanceof Error ? error.message : String(error));
+                        }
+                    },
+                    onCancel: () => {
+                        done();
+                        this.ui.requestRender();
+                    },
+                    onCycleChange: async (ids) => {
+                        await this.applyCycleEnabledIds(ids);
+                    },
+                    onCyclePersist: async (ids) => {
+                        const allModels = this.session.modelRegistry.getAvailable();
+                        const newPatterns = ids === null || ids.length === allModels.length ? undefined : ids;
+                        this.settingsManager.setEnabledModels(newPatterns ? [...newPatterns] : undefined);
+                        this.showStatus("Model selection saved to settings");
+                    },
+                    onManageAdd: async () => {
+                        done();
+                        await this.showCustomProviderWizard({ mode: "add", target: "models_json" });
+                    },
+                    onManageEdit: async (source, providerId) => {
+                        done();
+                        await this.showCustomProviderWizard({ mode: "edit", target: source, providerId });
+                    },
+                    onManageRemove: async (source, providerId) => {
+                        done();
+                        const confirmed = await this.showExtensionConfirm("Remove provider", `Remove "${providerId}" from ${source === "models_json" ? "models.json" : "auth.json"}?`);
+                        if (!confirmed) {
+                            this.showModelHub("manage");
+                            return;
+                        }
+                        try {
+                            if (source === "models_json") {
+                                this.session.modelRegistry.removeProviderFromModelsJson(providerId);
+                            }
+                            else {
+                                this.session.modelRegistry.authStorage.remove(providerId);
+                                this.session.modelRegistry.refresh();
+                            }
+                            await this.updateAvailableProviderCount();
+                            this.showStatus(`Removed provider ${providerId}`);
+                            this.showModelHub("manage");
+                        }
+                        catch (error) {
+                            this.showError(error instanceof Error ? error.message : String(error));
+                            this.showModelHub("manage");
+                        }
+                    },
+                }, { initialTab, initialSearchInput });
+                return { component: hub, focus: hub };
             });
-            return { component: selector, focus: selector };
         });
     }
     showUserMessageSelector() {
@@ -3932,17 +3872,18 @@ export class InteractiveMode {
         if (isUnknownModel(previousModel)) {
             const availableModels = this.session.modelRegistry.getAvailable();
             const providerModels = availableModels.filter((model) => model.provider === providerId);
-            if (!hasDefaultModelProvider(providerId)) {
-                selectionError = `${actionLabel}, but no default model is configured for provider "${providerId}". Use /model to select a model.`;
-            }
-            else if (providerModels.length === 0) {
+            if (providerModels.length === 0) {
                 selectionError = `${actionLabel}, but no models are available for that provider. Use /model to select a model.`;
             }
             else {
-                const defaultModelId = defaultModelPerProvider[providerId];
-                selectedModel = providerModels.find((model) => model.id === defaultModelId);
+                const defaultModelId = hasDefaultModelProvider(providerId)
+                    ? defaultModelPerProvider[providerId]
+                    : undefined;
+                selectedModel =
+                    (defaultModelId ? providerModels.find((model) => model.id === defaultModelId) : undefined) ??
+                        providerModels[0];
                 if (!selectedModel) {
-                    selectionError = `${actionLabel}, but its default model "${defaultModelId}" is not available. Use /model to select a model.`;
+                    selectionError = `${actionLabel}, but no model could be selected. Use /model to select a model.`;
                 }
                 else {
                     try {
@@ -3951,7 +3892,7 @@ export class InteractiveMode {
                     catch (error) {
                         selectedModel = undefined;
                         const errorMessage = error instanceof Error ? error.message : String(error);
-                        selectionError = `${actionLabel}, but selecting its default model failed: ${errorMessage}. Use /model to select a model.`;
+                        selectionError = `${actionLabel}, but selecting model failed: ${errorMessage}. Use /model to select a model.`;
                     }
                 }
             }
@@ -4026,12 +3967,60 @@ export class InteractiveMode {
         }
     }
     async showOpenAICompatibleLoginDialog() {
+        await this.showCustomProviderWizard({ mode: "add", target: "openai_compatible" });
+    }
+    /**
+     * Interactive wizard to add/edit a custom OpenAI-compatible provider.
+     * - target models_json: writes ~/.pi/agent/models.json (Manage tab default)
+     * - target openai_compatible: writes auth.json ( /login path )
+     */
+    async showCustomProviderWizard(options) {
         const previousModel = this.session.model;
-        const providerId = `openai-compatible-${crypto.randomUUID().slice(0, 8)}`;
-        const providerName = "OpenAI Compatible";
-        const dialog = new LoginDialogComponent(this.ui, providerId, (_success, _message) => {
-            // Completion handled below
-        }, providerName, "Configure OpenAI Compatible Provider");
+        const isEdit = options.mode === "edit" && !!options.providerId;
+        let existing;
+        if (isEdit && options.providerId) {
+            if (options.target === "openai_compatible") {
+                const all = this.session.modelRegistry.authStorage.getOpenAICompatibleProviders();
+                const info = all[options.providerId];
+                if (!info) {
+                    this.showError(`Provider "${options.providerId}" not found in auth.json`);
+                    this.showModelHub("manage");
+                    return;
+                }
+                existing = {
+                    providerId: options.providerId,
+                    baseUrl: info.baseUrl,
+                    apiKey: info.key,
+                    models: info.models,
+                };
+            }
+            else {
+                const listed = this.session.modelRegistry
+                    .listModelsJsonProviders()
+                    .find((p) => p.name === options.providerId);
+                if (!listed) {
+                    this.showError(`Provider "${options.providerId}" not found in models.json`);
+                    this.showModelHub("manage");
+                    return;
+                }
+                // models.json apiKey is opaque (env/command/literal); do not surface the raw value
+                existing = {
+                    providerId: options.providerId,
+                    baseUrl: listed.baseUrl ?? "",
+                    apiKey: "",
+                    models: listed.modelIds.map((id) => ({ id, name: id })),
+                };
+            }
+        }
+        const dialogProviderId = existing?.providerId ?? "custom-provider";
+        const title = options.target === "models_json"
+            ? isEdit
+                ? `Edit models.json provider (${existing?.providerId})`
+                : "Add custom provider (models.json)"
+            : isEdit
+                ? `Edit OpenAI Compatible (${existing?.providerId})`
+                : "Configure OpenAI Compatible Provider";
+        const dialog = new LoginDialogComponent(this.ui, dialogProviderId, (_success, _message) => { }, existing?.providerId ?? "Custom Provider", title);
         this.editorContainer.clear();
         this.editorContainer.addChild(dialog);
         this.ui.setFocus(dialog);
@@ -4043,45 +4032,165 @@ export class InteractiveMode {
             this.ui.requestRender();
         };
         try {
-            const baseUrl = (await dialog.showPrompt("Enter base URL:", "http://localhost:11434/v1")).trim();
+            let providerId = existing?.providerId ?? "";
+            if (!isEdit) {
+                const rawName = (await dialog.showPrompt("Provider name/id (e.g. ollama, agnes):", existing?.providerId ?? "ollama")).trim();
+                providerId = slugifyProviderId(rawName);
+                if (!providerId) {
+                    throw new Error("Provider name cannot be empty.");
+                }
+                if (BUILT_IN_MODEL_PROVIDERS.has(providerId) && options.target === "openai_compatible") {
+                    throw new Error(`"${providerId}" is a built-in provider. Use a different name, or add it via Manage → models.json override.`);
+                }
+            }
+            const baseUrl = (await dialog.showPrompt("Enter base URL:", existing?.baseUrl || "http://localhost:11434/v1")).trim();
             if (!baseUrl) {
                 throw new Error("Base URL cannot be empty.");
             }
-            const apiKey = (await dialog.showPrompt("Enter API key (or leave blank for local endpoints):")).trim();
-            const modelNames = (await dialog.showPrompt("Enter model name(s) (comma-separated):", "llama3.1")).trim();
-            if (!modelNames) {
-                throw new Error("At least one model name is required.");
-            }
-            const models = modelNames
-                .split(",")
-                .map((s) => s.trim())
-                .filter((s) => s.length > 0)
-                .map((id) => ({
-                id,
-                name: id,
-            }));
-            const effectiveApiKey = apiKey || "not-needed";
-            // Immediately register the provider so models are available
-            this.session.modelRegistry.configureOpenAICompatibleProvider(providerId, {
-                baseUrl,
-                apiKey: effectiveApiKey,
-                models,
-            });
-            // Persist to auth.json so it survives restarts
-            this.session.modelRegistry.authStorage.set(providerId, {
-                type: "openai_compatible",
-                key: effectiveApiKey,
-                baseUrl,
-                models,
-            });
-            restoreEditor();
-            await this.completeProviderAuthentication(providerId, `${baseUrl}`, "api_key", previousModel);
+            const apiKeyPrompt = options.target === "models_json"
+                ? "API key (literal, env var name, or !command; blank = not-needed):"
+                : "Enter API key (or leave blank for local endpoints):";
+            const apiKey = (await dialog.showPrompt(apiKeyPrompt, existing?.apiKey === "not-needed" ? "" : (existing?.apiKey ?? ""))).trim();
+            // On models.json edit, blank keeps the existing apiKey field (not rewritten).
+            const effectiveApiKey = apiKey
+                ? apiKey
+                : isEdit && options.target === "models_json"
+                    ? undefined
+                    : "not-needed";
+            dialog.showInfo([theme.fg("muted", "Discovering models from /models ...")]);
+            this.ui.requestRender();
+            const discovered = await fetchOpenAICompatibleModels(baseUrl, effectiveApiKey);
+            let models;
+            if (discovered.ok && discovered.models.length > 0) {
+                // Offer: use all discovered, or hand-edit
+                const useAllLabel = `Use all ${discovered.models.length} discovered models`;
+                const manualLabel = "Enter model ids manually";
+                const preview = discovered.models
+                    .slice(0, 8)
+                    .map((m) => m.id)
+                    .join(", ");
+                const more = discovered.models.length > 8 ? ` (+${discovered.models.length - 8} more)` : "";
+                dialog.showInfo([
+                    theme.fg("success", `Found ${discovered.models.length} models`),
+                    theme.fg("muted", `${preview}${more}`),
+                ]);
+                this.ui.requestRender();
+                const choice = await new Promise((resolve) => {
+                    const restoreDialog = () => {
+                        this.editorContainer.clear();
+                        this.editorContainer.addChild(dialog);
+                        this.ui.setFocus(dialog);
+                        this.ui.requestRender();
+                    };
+                    const selector = new ExtensionSelectorComponent("Discovered models", [useAllLabel, manualLabel], (option) => {
+                        restoreDialog();
+                        resolve(option);
+                    }, () => {
+                        restoreDialog();
+                        resolve(undefined);
+                    });
+                    this.editorContainer.clear();
+                    this.editorContainer.addChild(selector);
+                    this.ui.setFocus(selector);
+                    this.ui.requestRender();
+                });
+                if (!choice) {
+                    throw new Error("Login cancelled");
+                }
+                if (choice === useAllLabel) {
+                    models = discovered.models.map((m) => ({ id: m.id, name: m.name }));
+                }
+                else {
+                    const defaultIds = existing?.models.map((m) => m.id).join(", ") ||
+                        discovered.models
+                            .slice(0, 5)
+                            .map((m) => m.id)
+                            .join(", ");
+                    const modelNames = (await dialog.showPrompt("Model id(s), comma-separated:", defaultIds)).trim();
+                    if (!modelNames)
+                        throw new Error("At least one model name is required.");
+                    models = modelNames
+                        .split(",")
+                        .map((s) => s.trim())
+                        .filter((s) => s.length > 0)
+                        .map((id) => ({ id, name: id }));
+                }
+            }
+            else {
+                dialog.showInfo([
+                    theme.fg("warning", `Auto-discover failed: ${discovered.ok ? "no models" : discovered.error}`),
+                    theme.fg("muted", "Falling back to manual model entry."),
+                ]);
+                this.ui.requestRender();
+                const defaultIds = existing?.models.map((m) => m.id).join(", ") || "llama3.1";
+                const modelNames = (await dialog.showPrompt("Enter model name(s) (comma-separated):", defaultIds)).trim();
+                if (!modelNames) {
+                    throw new Error("At least one model name is required.");
+                }
+                models = modelNames
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter((s) => s.length > 0)
+                    .map((id) => ({ id, name: id }));
+            }
+            if (options.target === "openai_compatible") {
+                const storedKey = effectiveApiKey ?? "not-needed";
+                // Replace previous id if renaming isn't supported (edit keeps id)
+                if (isEdit && existing && existing.providerId !== providerId) {
+                    this.session.modelRegistry.authStorage.remove(existing.providerId);
+                }
+                this.session.modelRegistry.configureOpenAICompatibleProvider(providerId, {
+                    baseUrl,
+                    apiKey: storedKey,
+                    models,
+                });
+                this.session.modelRegistry.authStorage.set(providerId, {
+                    type: "openai_compatible",
+                    key: storedKey,
+                    baseUrl,
+                    models,
+                });
+                // refresh so getAvailable sees it
+                this.session.modelRegistry.refresh();
+                restoreEditor();
+                await this.completeProviderAuthentication(providerId, baseUrl, "api_key", previousModel);
+            }
+            else {
+                this.session.modelRegistry.upsertProviderInModelsJson(providerId, {
+                    baseUrl,
+                    ...(effectiveApiKey !== undefined ? { apiKey: effectiveApiKey } : {}),
+                    api: "openai-completions",
+                    models: models.map((m) => ({
+                        id: m.id,
+                        name: m.name,
+                        reasoning: false,
+                        input: ["text"],
+                    })),
+                });
+                restoreEditor();
+                await this.updateAvailableProviderCount();
+                // Prefer selecting first model if no real model yet
+                if (isUnknownModel(previousModel)) {
+                    const available = this.session.modelRegistry.getAvailable().filter((m) => m.provider === providerId);
+                    if (available[0]) {
+                        try {
+                            await this.session.setModel(available[0]);
+                            this.footer.invalidate();
+                            this.updateEditorBorderColor();
+                        }
+                        catch {
+                            // ignore
+                        }
+                    }
+                }
+                this.showStatus(`Saved provider "${providerId}" to models.json (${models.length} model${models.length === 1 ? "" : "s"}). Comments/trailing commas in that file are not preserved.`);
+            }
         }
         catch (error) {
             restoreEditor();
             const errorMsg = error instanceof Error ? error.message : String(error);
             if (errorMsg !== "Login cancelled") {
-                this.showError(`Failed to configure OpenAI Compatible provider: ${errorMsg}`);
+                this.showError(`Failed to configure provider: ${errorMsg}`);
             }
         }
     }
@@ -4612,7 +4721,7 @@ export class InteractiveMode {
         this.chatContainer.addChild(new Text(info, 1, 0));
         this.ui.requestRender();
     }
-    showMcpSelector(highlightServer) {
+    async showMcpSelector(highlightServer) {
         const buildItems = () => {
             // Fetch fresh config each time so toggle reflects immediately
             const configured = this.settingsManager.getMcpServers();
@@ -4635,22 +4744,22 @@ export class InteractiveMode {
                 };
             });
         };
-        const items = buildItems();
-        if (items.length === 0) {
-            this.chatContainer.addChild(new Spacer(1));
-            this.chatContainer.addChild(new Text(`${theme.bold("MCP Servers")}\n\n${theme.fg("dim", "No MCP servers configured. Add 'mcpServers' to settings.json.")}`, 1, 0));
-            this.ui.requestRender();
-            return;
-        }
         if (highlightServer) {
             const configured = this.settingsManager.getMcpServers();
             const server = configured?.[highlightServer];
             if (server) {
                 const currentEnabled = server.enabled !== false;
                 this.settingsManager.setMcpServerEnabled(highlightServer, !currentEnabled);
-                this.session.reloadMcp(highlightServer);
+                await this.session.reloadMcp(highlightServer);
             }
         }
+        const items = buildItems();
+        if (items.length === 0) {
+            this.chatContainer.addChild(new Spacer(1));
+            this.chatContainer.addChild(new Text(`${theme.bold("MCP Servers")}\n\n${theme.fg("dim", "No MCP servers configured. Add 'mcpServers' to settings.json.")}`, 1, 0));
+            this.ui.requestRender();
+            return;
+        }
         this.showSelector((done) => {
             const selector = new McpSelectorComponent("MCP Servers", items, async (name) => {
                 const cur = this.settingsManager.getMcpServers();