@openeryc/pi-coding-agent 0.75.55 → 0.75.57

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";
@@ -1966,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());
@@ -2014,7 +2014,7 @@ export class InteractiveMode {
             await fn();
         };
         this.commands.set("/settings", noArg(() => this.showSettingsSelector()));
-        this.commands.set("/scoped-models", noArg(() => this.showModelsSelector()));
+        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("");
@@ -3348,7 +3348,7 @@ export class InteractiveMode {
     }
     async handleModelCommand(searchTerm) {
         if (!searchTerm) {
-            this.showModelSelector();
+            this.showModelHub("select");
             return;
         }
         const model = await this.findExactModelMatch(searchTerm);
@@ -3366,7 +3366,7 @@ export class InteractiveMode {
             }
             return;
         }
-        this.showModelSelector(searchTerm);
+        this.showModelHub("select", searchTerm);
     }
     async findExactModelMatch(searchTerm) {
         const models = await this.getModelCandidates();
@@ -3418,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() {
@@ -3865,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 {
@@ -3884,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.`;
                     }
                 }
             }
@@ -3959,12 +3967,59 @@ 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;
+                }
+                existing = {
+                    providerId: options.providerId,
+                    baseUrl: listed.baseUrl ?? "",
+                    apiKey: listed.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);
@@ -3976,45 +4031,168 @@ export class InteractiveMode {
             this.ui.requestRender();
         };
         try {
-            const baseUrl = (await dialog.showPrompt("Enter base URL:", "http://localhost:11434/v1")).trim();
+            const rawName = (await dialog.showPrompt(isEdit ? "Provider name/id:" : "Provider name/id (e.g. ollama, agnes):", existing?.providerId ?? "ollama")).trim();
+            const 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"
+                ? isEdit
+                    ? "API key (literal/env/!command; blank keeps current):"
+                    : "API key (literal, env var name, or !command; blank = not-needed):"
+                : isEdit
+                    ? "API key (blank keeps current; type not-needed for local):"
+                    : "Enter API key (or leave blank for local endpoints):";
+            const apiKey = (await dialog.showPrompt(apiKeyPrompt, existing?.apiKey === "not-needed" ? "" : (existing?.apiKey ?? ""))).trim();
+            // Blank on edit keeps the existing apiKey (models.json and openai_compatible).
+            const effectiveApiKey = apiKey ? apiKey : isEdit ? 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 ?? (isEdit && existing?.apiKey ? existing.apiKey : "not-needed");
+                // Rename: drop old id if the name changed
+                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 {
+                const writeConfig = {
+                    baseUrl,
+                    ...(effectiveApiKey !== undefined ? { apiKey: effectiveApiKey } : {}),
+                    api: "openai-completions",
+                    models: models.map((m) => ({
+                        id: m.id,
+                        name: m.name,
+                        reasoning: false,
+                        input: ["text"],
+                    })),
+                };
+                if (isEdit && existing && existing.providerId !== providerId) {
+                    this.session.modelRegistry.renameProviderInModelsJson(existing.providerId, providerId, writeConfig);
+                }
+                else {
+                    this.session.modelRegistry.upsertProviderInModelsJson(providerId, writeConfig);
+                }
+                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}`);
             }
         }
     }