iosm-cli 0.2.1 → 0.2.2

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

@@ -15,7 +15,9 @@ import { parseSkillBlock } from "../../core/agent-session.js";
 import { FooterDataProvider } from "../../core/footer-data-provider.js";
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { createCompactionSummaryMessage, INTERNAL_UI_META_CUSTOM_TYPE, isInternalUiMetaDetails, } from "../../core/messages.js";
+import { loadModelsDevProviderCatalog, } from "../../core/models-dev-provider-catalog.js";
 import { ModelRegistry } from "../../core/model-registry.js";
+import { MODELS_DEV_PROVIDERS } from "../../core/models-dev-providers.js";
 import { resolveModelScope } from "../../core/model-resolver.js";
 import { getMcpCommandHelp, parseMcpAddCommand, parseMcpTargetCommand, } from "../../core/mcp/index.js";
 import { addMemoryEntry, getMemoryFilePath, readMemoryEntries, removeMemoryEntry, updateMemoryEntry, } from "../../core/memory.js";
@@ -272,6 +274,41 @@ function resolveDoctorCliToolStatuses() {
     });
 }
 const OPENROUTER_PROVIDER_ID = "openrouter";
+const PROVIDER_DISPLAY_NAME_OVERRIDES = {
+    "azure-openai-responses": "Azure OpenAI Responses",
+    "google-antigravity": "Google Antigravity",
+    "google-gemini-cli": "Google Gemini CLI",
+    "kimi-coding": "Kimi Coding",
+    "openai-codex": "OpenAI Codex",
+    "opencode-go": "OpenCode Go",
+    "vercel-ai-gateway": "Vercel AI Gateway",
+};
+function toProviderDisplayName(providerId) {
+    const override = PROVIDER_DISPLAY_NAME_OVERRIDES[providerId];
+    if (override)
+        return override;
+    return providerId
+        .split(/[-_]/g)
+        .map((part) => {
+        const lower = part.toLowerCase();
+        if (lower === "ai")
+            return "AI";
+        if (lower === "api")
+            return "API";
+        if (lower === "gpt")
+            return "GPT";
+        if (lower === "aws")
+            return "AWS";
+        if (lower === "ui")
+            return "UI";
+        if (lower === "llm")
+            return "LLM";
+        if (lower === "id")
+            return "ID";
+        return part.charAt(0).toUpperCase() + part.slice(1);
+    })
+        .join(" ");
+}
 function isAbortLikeMessage(message) {
     const normalized = message.trim().toLowerCase();
     return normalized.includes("aborted") || normalized.includes("cancelled");
@@ -421,6 +458,17 @@ export class InteractiveMode {
         this.builtInHeader = undefined;
         // ASCII logo component for startup screen
         this.asciiLogo = undefined;
+        // API-key provider labels cached for /login and status messages.
+        this.apiKeyProviderDisplayNames = new Map();
+        this.modelsDevProviderCatalog = MODELS_DEV_PROVIDERS;
+        this.modelsDevProviderCatalogById = new Map(MODELS_DEV_PROVIDERS.map((provider) => [
+            provider.id,
+            {
+                ...provider,
+                models: [],
+            },
+        ]));
+        this.modelsDevProviderCatalogRefreshPromise = undefined;
         // Custom header from extension (undefined = use built-in header)
         this.customHeader = undefined;
         /**
@@ -1275,6 +1323,8 @@ export class InteractiveMode {
         this.footerDataProvider.onBranchChange(() => {
             this.ui.requestRender();
         });
+        // Refresh provider catalog from models.dev in background once per startup.
+        void this.refreshModelsDevProviderCatalog();
         // Initialize available provider count for footer display
         await this.updateAvailableProviderCount();
     }
@@ -3870,7 +3920,7 @@ export class InteractiveMode {
                 this.updateEditorBorderColor();
                 this.refreshBuiltInHeader();
                 const thinkingStr = result.model.reasoning && result.thinkingLevel !== "off" ? ` (thinking: ${result.thinkingLevel})` : "";
-                this.showStatus(`Switched to ${result.model.name || result.model.id}${thinkingStr}`);
+                this.showStatus(`Switched to ${result.model.provider}/${result.model.id}${thinkingStr}`);
             }
         }
         catch (error) {
@@ -4910,7 +4960,7 @@ export class InteractiveMode {
                 this.footer.invalidate();
                 this.updateEditorBorderColor();
                 this.refreshBuiltInHeader();
-                this.showStatus(`Model: ${model.id}`);
+                this.showStatus(`Model: ${model.provider}/${model.id}`);
                 this.checkDaxnutsEasterEgg(model);
             }
             catch (error) {
@@ -4921,6 +4971,7 @@ export class InteractiveMode {
         this.showModelSelector(searchTerm);
     }
     async showModelProviderSelector(preferredProvider) {
+        await this.hydrateMissingProviderModelsForSavedAuth();
         this.session.modelRegistry.refresh();
         let models = [];
         try {
@@ -5032,7 +5083,7 @@ export class InteractiveMode {
                     this.updateEditorBorderColor();
                     this.refreshBuiltInHeader();
                     done();
-                    this.showStatus(`Model: ${model.id}`);
+                    this.showStatus(`Model: ${model.provider}/${model.id}`);
                     this.checkDaxnutsEasterEgg(model);
                 }
                 catch (error) {
@@ -5341,22 +5392,29 @@ export class InteractiveMode {
                 return;
             }
         }
+        await this.refreshModelsDevProviderCatalog();
+        const apiKeyProviders = this.getApiKeyLoginProviders(this.modelsDevProviderCatalog);
         this.showSelector((done) => {
-            const selector = new OAuthSelectorComponent(mode, this.session.modelRegistry.authStorage, async (providerId) => {
+            const selector = new OAuthSelectorComponent(mode, this.session.modelRegistry.authStorage, async (provider) => {
                 done();
                 if (mode === "login") {
-                    if (providerId === OPENROUTER_PROVIDER_ID) {
-                        await this.handleOpenRouterApiKeyLogin();
+                    if (provider.kind === "api_key") {
+                        if (provider.id === OPENROUTER_PROVIDER_ID) {
+                            await this.handleOpenRouterApiKeyLogin();
+                        }
+                        else {
+                            await this.handleApiKeyLogin(provider.id, { providerName: provider.name });
+                        }
                     }
                     else {
-                        await this.showLoginDialog(providerId);
+                        await this.showLoginDialog(provider.id);
                     }
                 }
                 else {
                     // Logout flow
-                    const providerName = this.getProviderDisplayName(providerId);
+                    const providerName = this.getProviderDisplayName(provider.id);
                     try {
-                        this.session.modelRegistry.authStorage.logout(providerId);
+                        this.session.modelRegistry.authStorage.logout(provider.id);
                         this.session.modelRegistry.refresh();
                         await this.updateAvailableProviderCount();
                         this.showStatus(`Logged out of ${providerName}`);
@@ -5368,21 +5426,156 @@ export class InteractiveMode {
             }, () => {
                 done();
                 this.ui.requestRender();
-            });
+            }, apiKeyProviders);
             return { component: selector, focus: selector };
         });
     }
+    async refreshModelsDevProviderCatalog() {
+        if (this.modelsDevProviderCatalogRefreshPromise) {
+            await this.modelsDevProviderCatalogRefreshPromise;
+            return;
+        }
+        this.modelsDevProviderCatalogRefreshPromise = (async () => {
+            const catalog = await loadModelsDevProviderCatalog();
+            this.modelsDevProviderCatalogById = catalog;
+            this.modelsDevProviderCatalog = Array.from(catalog.values())
+                .map((provider) => ({
+                id: provider.id,
+                name: provider.name,
+                env: provider.env,
+            }))
+                .sort((a, b) => a.name.localeCompare(b.name, "en") || a.id.localeCompare(b.id, "en"));
+        })()
+            .catch(() => {
+            this.modelsDevProviderCatalog = MODELS_DEV_PROVIDERS;
+            this.modelsDevProviderCatalogById = new Map(MODELS_DEV_PROVIDERS.map((provider) => [
+                provider.id,
+                {
+                    ...provider,
+                    models: [],
+                },
+            ]));
+        })
+            .finally(() => {
+            this.modelsDevProviderCatalogRefreshPromise = undefined;
+        });
+        await this.modelsDevProviderCatalogRefreshPromise;
+    }
+    resolveModelsDevApi(modelNpm) {
+        const npm = modelNpm?.toLowerCase() ?? "";
+        if (npm.includes("anthropic"))
+            return "anthropic-messages";
+        if (npm.includes("google-vertex"))
+            return "google-vertex";
+        if (npm.includes("google"))
+            return "google-generative-ai";
+        if (npm.includes("amazon-bedrock"))
+            return "bedrock-converse-stream";
+        if (npm.includes("mistral"))
+            return "mistral-conversations";
+        if (npm.includes("@ai-sdk/openai") && !npm.includes("compatible"))
+            return "openai-responses";
+        return "openai-completions";
+    }
+    buildModelsDevProviderConfig(providerInfo) {
+        const baseUrl = providerInfo.api ?? providerInfo.models.find((model) => !!model.api)?.api;
+        if (!baseUrl)
+            return undefined;
+        if (providerInfo.models.length === 0)
+            return undefined;
+        const models = providerInfo.models.map((model) => ({
+            id: model.id,
+            name: model.name,
+            api: this.resolveModelsDevApi(model.npm ?? providerInfo.npm),
+            reasoning: model.reasoning,
+            input: [...model.input],
+            cost: model.cost,
+            contextWindow: model.contextWindow,
+            maxTokens: model.maxTokens,
+            headers: Object.keys(model.headers).length > 0 ? model.headers : undefined,
+        }));
+        return {
+            baseUrl,
+            models,
+        };
+    }
+    hasRegisteredProviderModels(providerId) {
+        const registry = this.session.modelRegistry;
+        if (typeof registry.getAll !== "function")
+            return true;
+        return registry.getAll().some((model) => model.provider === providerId);
+    }
+    async hydrateProviderModelsFromModelsDev(providerId) {
+        if (this.hasRegisteredProviderModels(providerId))
+            return true;
+        await this.refreshModelsDevProviderCatalog();
+        const providerInfo = this.modelsDevProviderCatalogById.get(providerId);
+        if (!providerInfo)
+            return false;
+        const config = this.buildModelsDevProviderConfig(providerInfo);
+        if (!config)
+            return false;
+        try {
+            this.session.modelRegistry.registerProvider(providerId, config);
+            return this.hasRegisteredProviderModels(providerId);
+        }
+        catch {
+            return false;
+        }
+    }
+    async hydrateMissingProviderModelsForSavedAuth() {
+        const savedProviders = this.session.modelRegistry.authStorage.list();
+        if (savedProviders.length === 0)
+            return;
+        for (const providerId of savedProviders) {
+            if (this.hasRegisteredProviderModels(providerId))
+                continue;
+            await this.hydrateProviderModelsFromModelsDev(providerId);
+        }
+    }
+    getApiKeyLoginProviders(modelsDevProviders) {
+        const providerNames = new Map();
+        this.apiKeyProviderDisplayNames.clear();
+        for (const model of this.session.modelRegistry.getAll()) {
+            if (!providerNames.has(model.provider)) {
+                providerNames.set(model.provider, toProviderDisplayName(model.provider));
+            }
+        }
+        for (const provider of modelsDevProviders) {
+            const fallbackName = toProviderDisplayName(provider.id);
+            const current = providerNames.get(provider.id);
+            if (!current || current === fallbackName) {
+                providerNames.set(provider.id, provider.name || fallbackName);
+            }
+        }
+        for (const providerId of this.session.modelRegistry.authStorage.list()) {
+            if (!providerNames.has(providerId)) {
+                providerNames.set(providerId, toProviderDisplayName(providerId));
+            }
+        }
+        const oauthProviderIds = new Set(this.session.modelRegistry.authStorage.getOAuthProviders().map((provider) => provider.id));
+        const providers = [];
+        for (const [id, name] of providerNames.entries()) {
+            if (oauthProviderIds.has(id))
+                continue;
+            this.apiKeyProviderDisplayNames.set(id, name);
+            providers.push({ id, name, kind: "api_key" });
+        }
+        providers.sort((a, b) => a.name.localeCompare(b.name));
+        return providers;
+    }
     getProviderDisplayName(providerId) {
-        if (providerId === OPENROUTER_PROVIDER_ID) {
-            return "OpenRouter";
+        const apiKeyName = this.apiKeyProviderDisplayNames.get(providerId);
+        if (apiKeyName) {
+            return apiKeyName;
         }
         const providerInfo = this.session.modelRegistry.authStorage.getOAuthProviders().find((p) => p.id === providerId);
-        return providerInfo?.name || providerId;
+        return providerInfo?.name || toProviderDisplayName(providerId);
     }
-    async handleOpenRouterApiKeyLogin(options) {
+    async handleApiKeyLogin(providerId, options) {
+        const providerName = options?.providerName || this.getProviderDisplayName(providerId);
         const openModelSelector = options?.openModelSelector ?? true;
-        const providerName = this.getProviderDisplayName(OPENROUTER_PROVIDER_ID);
-        const existingCredential = this.session.modelRegistry.authStorage.get(OPENROUTER_PROVIDER_ID);
+        const existingCredential = this.session.modelRegistry.authStorage.get(providerId);
         if (existingCredential) {
             const overwrite = await this.showExtensionConfirm(`${providerName}: replace existing credentials?`, `Stored at ${getAuthPath()}`);
             if (!overwrite) {
@@ -5390,7 +5583,11 @@ export class InteractiveMode {
                 return;
             }
         }
-        const keyInput = await this.showExtensionInput(`${providerName} API key\nCreate key: https://openrouter.ai/keys`, "sk-or-v1-...");
+        const promptLines = [`${providerName} API key`];
+        if (options?.createKeyUrl) {
+            promptLines.push(`Create key: ${options.createKeyUrl}`);
+        }
+        const keyInput = await this.showExtensionInput(promptLines.join("\n"), options?.placeholder ?? "api-key");
         if (keyInput === undefined) {
             this.showStatus(`${providerName} login cancelled.`);
             return;
@@ -5400,13 +5597,28 @@ export class InteractiveMode {
             this.showWarning(`${providerName} API key cannot be empty.`);
             return;
         }
-        this.session.modelRegistry.authStorage.set(OPENROUTER_PROVIDER_ID, { type: "api_key", key: apiKey });
+        this.session.modelRegistry.authStorage.set(providerId, { type: "api_key", key: apiKey });
+        let hasProviderModels = this.hasRegisteredProviderModels(providerId);
+        if (!hasProviderModels) {
+            hasProviderModels = await this.hydrateProviderModelsFromModelsDev(providerId);
+        }
         await this.updateAvailableProviderCount();
         this.showStatus(`${providerName} API key saved to ${getAuthPath()}`);
-        if (openModelSelector) {
-            await this.showModelProviderSelector(OPENROUTER_PROVIDER_ID);
+        if (openModelSelector && hasProviderModels) {
+            await this.showModelProviderSelector(providerId);
+        }
+        else if (openModelSelector) {
+            this.showWarning(`${providerName} configured, but no models are available yet. Run /model after network is available.`);
         }
     }
+    async handleOpenRouterApiKeyLogin(options) {
+        await this.handleApiKeyLogin(OPENROUTER_PROVIDER_ID, {
+            providerName: "OpenRouter",
+            openModelSelector: options?.openModelSelector,
+            createKeyUrl: "https://openrouter.ai/keys",
+            placeholder: "sk-or-v1-...",
+        });
+    }
     async showLoginDialog(providerId) {
         const providerInfo = this.session.modelRegistry.authStorage.getOAuthProviders().find((p) => p.id === providerId);
         const providerName = this.getProviderDisplayName(providerId);