@tenex-chat/backend 0.9.4 → 0.9.6

package/src/llm/utils/ProviderConfigUI.ts

@@ -1,8 +1,8 @@
 import { PROVIDER_IDS } from "@/llm/providers/provider-ids";
-import { resolveApiKey, hasApiKey } from "@/llm/providers/key-manager";
+import { hasApiKey } from "@/llm/providers/key-manager";
 import type { TenexLLMs } from "@/services/config/types";
 import chalk from "chalk";
-import inquirer from "inquirer";
+import * as display from "@/commands/setup/display";
 
 /**
  * Extended type for editor use - includes providers
@@ -13,165 +13,34 @@ type TenexLLMsWithProviders = TenexLLMs & {
 
 /**
  * UI utilities for provider configuration
- * Extracted from LLMConfigEditor to separate concerns
  */
 export class ProviderConfigUI {
-    /**
-     * Get provider display names
-     */
     static getProviderDisplayName(provider: string): string {
         const names: Record<string, string> = {
             [PROVIDER_IDS.OPENROUTER]: "OpenRouter (300+ models)",
             [PROVIDER_IDS.ANTHROPIC]: "Anthropic (Claude)",
             [PROVIDER_IDS.OPENAI]: "OpenAI (GPT)",
             [PROVIDER_IDS.OLLAMA]: "Ollama (Local models)",
-            [PROVIDER_IDS.CLAUDE_CODE]: "Claude Code",
             [PROVIDER_IDS.CODEX_APP_SERVER]: "Codex App Server (GPT-5.1/5.2)",
         };
         return names[provider] || provider;
     }
 
-    /**
-     * Configure a specific provider interactively
-     */
-    static async configureProvider(
-        provider: string,
-        currentProviders?: Record<string, { apiKey: string | string[] }>
-    ): Promise<{ apiKey: string | string[] }> {
-        if (provider === PROVIDER_IDS.CLAUDE_CODE || provider === PROVIDER_IDS.CODEX_APP_SERVER) {
-            // Agent providers don't require an API key
-            console.log(
-                chalk.green(
-                    `✓ ${ProviderConfigUI.getProviderDisplayName(provider)} provider configured (no API key required)`
-                )
-            );
-            return { apiKey: "none" }; // Doesn't use API keys
-        }
-        if (provider === PROVIDER_IDS.OLLAMA) {
-            // For Ollama, ask for base URL instead of API key
-            const currentUrl = resolveApiKey(currentProviders?.[provider]?.apiKey) || "local";
-            const { ollamaConfig } = await inquirer.prompt([
-                {
-                    type: "select",
-                    name: "ollamaConfig",
-                    message: "Ollama configuration:",
-                    choices: [
-                        { name: "Use local Ollama (http://localhost:11434)", value: "local" },
-                        { name: "Use custom Ollama URL", value: "custom" },
-                    ],
-                    default: currentUrl === "local" ? "local" : "custom",
-                },
-            ]);
-
-            let baseUrl = "local";
-            if (ollamaConfig === "custom") {
-                const { customUrl } = await inquirer.prompt([
-                    {
-                        type: "input",
-                        name: "customUrl",
-                        message: "Enter Ollama base URL:",
-                        default: currentUrl !== "local" ? currentUrl : "http://localhost:11434",
-                        validate: (input: string) => {
-                            if (!input.trim()) return "URL is required";
-                            try {
-                                new URL(input);
-                                return true;
-                            } catch {
-                                return "Please enter a valid URL";
-                            }
-                        },
-                    },
-                ]);
-                baseUrl = customUrl;
-            }
-
-            return { apiKey: baseUrl };
-        }
-        // For other providers, ask for API key
-        const existingKey = currentProviders?.[provider]?.apiKey;
-
-        // If the provider already has a multi-key array, preserve it
-        if (Array.isArray(existingKey) && existingKey.length > 1) {
-            console.log(
-                chalk.cyan(
-                    `  ℹ  ${ProviderConfigUI.getProviderDisplayName(provider)} has ${existingKey.length} API keys configured (multi-key rotation).`
-                )
-            );
-            console.log(
-                chalk.gray(
-                    "     To edit multi-key configs, modify providers.json directly."
-                )
-            );
-            const { keep } = await inquirer.prompt([
-                {
-                    type: "confirm",
-                    name: "keep",
-                    message: "Keep existing multi-key configuration?",
-                    default: true,
-                },
-            ]);
-            if (keep) {
-                return { apiKey: existingKey };
-            }
-        }
-
-        const currentKey = resolveApiKey(existingKey);
-        const { apiKey } = await inquirer.prompt([
-            {
-                type: "password",
-                name: "apiKey",
-                message: `Enter API key for ${ProviderConfigUI.getProviderDisplayName(provider)} (press Enter to keep existing):`,
-                default: currentKey,
-                mask: "*",
-                validate: (input: string) => {
-                    // Allow empty input if there's an existing key
-                    if (!input.trim() && !currentKey) return "API key is required";
-                    return true;
-                },
-            },
-        ]);
-
-        return { apiKey: apiKey || currentKey || "" };
-    }
-
-    /**
-     * Display current configuration status
-     */
-    static displayCurrentConfig(llmsConfig: TenexLLMsWithProviders): void {
-        console.log(chalk.bold("Configured Providers:"));
+    static displayProviders(llmsConfig: TenexLLMsWithProviders): void {
+        display.context("Configured Providers");
         const providers = Object.keys(llmsConfig.providers).filter(
-            (p) => hasApiKey(llmsConfig.providers[p]?.apiKey)
+            (p) => {
+                const key = llmsConfig.providers[p]?.apiKey;
+                return hasApiKey(key) || key === "none";
+            },
         );
         if (providers.length === 0) {
             console.log(chalk.gray("  None configured"));
         } else {
             for (const p of providers) {
-                console.log(chalk.green(`  ✓ ${ProviderConfigUI.getProviderDisplayName(p)}`));
-            }
-        }
-
-        console.log(chalk.bold("\nConfigurations:"));
-        const configNames = Object.keys(llmsConfig.configurations);
-        if (configNames.length === 0) {
-            console.log(chalk.gray("  None"));
-        } else {
-            for (const name of configNames) {
-                const config = llmsConfig.configurations[name];
-                const isDefault = name === llmsConfig.default;
-                const isSummarization = name === llmsConfig.summarization;
-                const marker = isDefault || isSummarization ? chalk.cyan("• ") : "  ";
-
-                const tags: string[] = [];
-                if (isDefault) tags.push("default");
-                if (isSummarization) tags.push("summarization");
-                const tagStr = tags.length > 0 ? chalk.gray(` (${tags.join(", ")})`) : "";
-
-                // Handle meta models differently - they don't have a single model
-                const configDisplay = config.provider === "meta"
-                    ? `meta (${Object.keys((config as { variants: Record<string, unknown> }).variants).length} variants)`
-                    : `${config.provider}:${"model" in config ? config.model : "unknown"}`;
-                console.log(`  ${marker}${name}${tagStr}: ${configDisplay}`);
+                display.success(ProviderConfigUI.getProviderDisplayName(p));
             }
         }
+        display.blank();
     }
 }

package/src/llm/utils/models-dev-cache.ts

@@ -24,6 +24,17 @@ export interface ModelLimits {
     output: number;
 }
 
+/**
+ * Full model info from models.dev
+ */
+export interface ModelsDevModel {
+    id: string;
+    name: string;
+    cost?: { input: number; output: number };
+    limit?: { context?: number; output?: number };
+    last_updated?: string;
+}
+
 /**
  * models.dev API response structure
  */
@@ -31,10 +42,14 @@ interface ModelsDevResponse {
     [provider: string]: {
         models: {
             [modelId: string]: {
+                id?: string;
+                name?: string;
+                cost?: { input: number; output: number };
                 limit?: {
                     context?: number;
                     output?: number;
                 };
+                last_updated?: string;
             };
         };
     };
@@ -213,51 +228,115 @@ export async function refreshCache(): Promise<void> {
 }
 
 /**
- * Get model limits for a specific provider and model
+ * Resolve the raw model data entry from the cache.
  *
- * @param provider Our provider ID (e.g., "anthropic", "openai", "openrouter")
- * @param model Model ID (e.g., "claude-opus-4-5-20251101", "gpt-4o")
- * @returns Model limits or undefined if not found/unsupported
+ * Lookup order:
+ * 1. Direct: cache[mappedProvider].models[model]
+ * 2. Vendor split: for "vendor/bare" IDs, try cache[vendor].models[bare]
+ * 3. Global scan: search all providers for a matching model ID
+ *
+ * Steps 2–3 handle proxied providers (OpenRouter, Codex App Server) whose
+ * model IDs originate from upstream providers (OpenAI, Anthropic, etc.).
  */
-export function getModelLimits(provider: string, model: string): ModelLimits | undefined {
-    if (!cache) {
-        return undefined;
-    }
+function resolveModelData(provider: string, model: string): { modelId: string; data: ModelsDevResponse[string]["models"][string] } | undefined {
+    if (!cache) return undefined;
 
-    // Map our provider ID to models.dev provider ID
+    // 1. Direct lookup in the mapped provider section
     const modelsDevProvider = PROVIDER_MAPPING[provider];
-    if (modelsDevProvider === null || modelsDevProvider === undefined) {
-        // Provider not supported by models.dev
-        return undefined;
+    if (modelsDevProvider !== null && modelsDevProvider !== undefined) {
+        const providerData = cache[modelsDevProvider];
+        if (providerData?.models?.[model]) {
+            return { modelId: model, data: providerData.models[model] };
+        }
     }
 
-    const providerData = cache[modelsDevProvider];
-    if (!providerData?.models) {
-        return undefined;
+    // 2. If the model ID contains "vendor/bare", try the vendor's section
+    if (model.includes("/")) {
+        const slashIndex = model.indexOf("/");
+        const vendor = model.slice(0, slashIndex);
+        const bareModel = model.slice(slashIndex + 1);
+        const vendorData = cache[vendor];
+        if (vendorData?.models?.[bareModel]) {
+            return { modelId: bareModel, data: vendorData.models[bareModel] };
+        }
     }
 
-    const modelData = providerData.models[model];
-    if (!modelData?.limit) {
-        return undefined;
+    // 3. Global scan: search every provider for a matching model ID
+    for (const section of Object.values(cache)) {
+        if (section?.models?.[model]) {
+            return { modelId: model, data: section.models[model] };
+        }
     }
 
-    const { context, output } = modelData.limit;
-    if (context === undefined || output === undefined) {
-        return undefined;
-    }
+    return undefined;
+}
+
+/**
+ * Get model limits for a specific provider and model
+ *
+ * @param provider Our provider ID (e.g., "anthropic", "openai", "openrouter")
+ * @param model Model ID (e.g., "claude-opus-4-5-20251101", "gpt-4o")
+ * @returns Model limits or undefined if not found/unsupported
+ */
+export function getModelLimits(provider: string, model: string): ModelLimits | undefined {
+    const resolved = resolveModelData(provider, model);
+    if (!resolved?.data?.limit) return undefined;
+
+    const { context, output } = resolved.data.limit;
+    if (context === undefined || output === undefined) return undefined;
 
     return { context, output };
 }
 
+/**
+ * Get full model info from models.dev for a specific provider and model.
+ * Returns cost, limits, name, etc. for use in scoring/display.
+ */
+export function getModelInfo(provider: string, model: string): ModelsDevModel | undefined {
+    const resolved = resolveModelData(provider, model);
+    if (!resolved) return undefined;
+
+    const { modelId, data } = resolved;
+    return {
+        id: data.id ?? modelId,
+        name: data.name ?? modelId,
+        cost: data.cost,
+        limit: data.limit,
+        last_updated: data.last_updated,
+    };
+}
+
 /**
  * Get just the context window for a model
- * Convenience function for backwards compatibility with context-window-cache
  */
 export function getContextWindowFromModelsdev(provider: string, model: string): number | undefined {
     const limits = getModelLimits(provider, model);
     return limits?.context;
 }
 
+/**
+ * Get all models for a provider, sorted by last_updated descending
+ */
+export function getProviderModels(provider: string): ModelsDevModel[] {
+    if (!cache) return [];
+
+    const modelsDevProvider = PROVIDER_MAPPING[provider];
+    if (modelsDevProvider === null || modelsDevProvider === undefined) return [];
+
+    const providerData = cache[modelsDevProvider];
+    if (!providerData?.models) return [];
+
+    return Object.entries(providerData.models)
+        .map(([modelId, data]) => ({
+            id: data.id ?? modelId,
+            name: data.name ?? modelId,
+            cost: data.cost,
+            limit: data.limit,
+            last_updated: data.last_updated,
+        }))
+        .sort((a, b) => (b.last_updated ?? "").localeCompare(a.last_updated ?? ""));
+}
+
 /**
  * Clear in-memory cache (for testing)
  */

package/src/llm/utils/provider-select-prompt.ts

@@ -0,0 +1,284 @@
+import {
+    createPrompt,
+    useState,
+    useKeypress,
+    usePrefix,
+    useMemo,
+    isUpKey,
+    isDownKey,
+    isSpaceKey,
+    isEnterKey,
+    makeTheme,
+    type Theme,
+    type KeypressEvent,
+} from "@inquirer/core";
+import type { PartialDeep } from "@inquirer/type";
+import { cursorHide } from "@inquirer/ansi";
+import chalk from "chalk";
+import type { ProviderCredentials } from "@/services/config/types";
+import { PROVIDER_IDS } from "@/llm/providers/provider-ids";
+import { ProviderConfigUI } from "@/llm/utils/ProviderConfigUI";
+import * as display from "@/commands/setup/display";
+
+// --- Public types ---
+
+export type PromptState = {
+    providers: Record<string, ProviderCredentials>;
+    stash: Record<string, ProviderCredentials>;
+    active: number;
+    mode: "browse" | "keys";
+    keysTarget: string | null;
+    keysActive: number;
+};
+
+export type PromptResult =
+    | { action: "done"; providers: Record<string, ProviderCredentials> }
+    | { action: "add-key"; providerId: string; returnTo: "browse" | "keys"; state: PromptState };
+
+export type ProviderSelectConfig = {
+    message: string;
+    providerIds: string[];
+    initialProviders: Record<string, ProviderCredentials>;
+    providerHints?: Record<string, string>;
+    resumeState?: PromptState;
+    theme?: PartialDeep<Theme>;
+};
+
+// --- Helpers ---
+
+type Mode = "browse" | "keys";
+
+export function getKeys(apiKey: string | string[] | undefined): string[] {
+    if (!apiKey) return [];
+    if (Array.isArray(apiKey)) return apiKey.filter((k) => k.length > 0);
+    return apiKey.length > 0 && apiKey !== "none" ? [apiKey] : [];
+}
+
+function needsApiKey(providerId: string): boolean {
+    return providerId !== PROVIDER_IDS.CODEX_APP_SERVER;
+}
+
+export function isOllama(providerId: string): boolean {
+    return providerId === PROVIDER_IDS.OLLAMA;
+}
+
+function formatKeyInfo(apiKey: string | string[] | undefined): string {
+    const count = getKeys(apiKey).length;
+    if (count === 0) return "";
+    return chalk.gray(` [${count} key${count !== 1 ? "s" : ""}]`);
+}
+
+function maskKey(providerId: string, key: string): string {
+    if (isOllama(providerId)) return key;
+    if (key.length <= 4) return "*".repeat(key.length);
+    return "*".repeat(key.length - 4) + key.slice(-4);
+}
+
+const CURSOR = chalk.hex("#FFC107")("›");
+const RULE_WIDTH = 30;
+
+// --- Prompt ---
+
+export default createPrompt<PromptResult, ProviderSelectConfig>((config, done) => {
+    const { providerIds, message, resumeState } = config;
+    const theme = makeTheme(config.theme);
+    const prefix = usePrefix({ status: "idle", theme });
+    const doneIndex = providerIds.length;
+
+    const [active, setActive] = useState(resumeState?.active ?? 0);
+    const [providers, setProviders] = useState<Record<string, ProviderCredentials>>(
+        () => resumeState?.providers ?? { ...config.initialProviders },
+    );
+    const [stash, setStash] = useState<Record<string, ProviderCredentials>>(
+        () => resumeState?.stash ?? {},
+    );
+    const [mode, setMode] = useState<Mode>(resumeState?.mode ?? "browse");
+    const [keysTarget, setKeysTarget] = useState<string | null>(resumeState?.keysTarget ?? null);
+    const [keysActive, setKeysActive] = useState(resumeState?.keysActive ?? 0);
+
+    const activeProviderId = useMemo(
+        () => (active < providerIds.length ? providerIds[active] : null),
+        [active],
+    );
+
+    function currentState(): PromptState {
+        return { providers, stash, active, mode, keysTarget, keysActive };
+    }
+
+    function requestAddKey(providerId: string, returnTo: "browse" | "keys") {
+        done({ action: "add-key", providerId, returnTo, state: currentState() });
+    }
+
+    // --- Keypress handlers ---
+
+    useKeypress((key, rl) => {
+        rl.clearLine(0);
+        if (mode === "browse") {
+            handleBrowse(key);
+        } else {
+            handleKeys(key);
+        }
+    });
+
+    function handleBrowse(key: KeypressEvent) {
+        if (isUpKey(key)) {
+            setActive(Math.max(0, active - 1));
+        } else if (isDownKey(key)) {
+            setActive(Math.min(doneIndex, active + 1));
+        } else if (isSpaceKey(key) && activeProviderId) {
+            toggleProvider(activeProviderId);
+        } else if (isEnterKey(key)) {
+            if (active === doneIndex) {
+                done({ action: "done", providers });
+            } else if (activeProviderId && activeProviderId in providers && needsApiKey(activeProviderId)) {
+                enterKeysMode(activeProviderId);
+            }
+        }
+    }
+
+    function toggleProvider(pid: string) {
+        const enabled = pid in providers;
+        if (enabled) {
+            const updated = { ...providers };
+            const newStash = { ...stash };
+            newStash[pid] = updated[pid]!;
+            delete updated[pid];
+            setProviders(updated);
+            setStash(newStash);
+        } else if (!needsApiKey(pid)) {
+            setProviders({ ...providers, [pid]: { apiKey: "none" } });
+        } else if (stash[pid]) {
+            const newStash = { ...stash };
+            const restored = newStash[pid]!;
+            delete newStash[pid];
+            setProviders({ ...providers, [pid]: restored });
+            setStash(newStash);
+        } else {
+            requestAddKey(pid, "browse");
+        }
+    }
+
+    function enterKeysMode(pid: string) {
+        setMode("keys");
+        setKeysTarget(pid);
+        setKeysActive(0);
+    }
+
+    function exitKeysMode() {
+        setMode("browse");
+        setKeysTarget(null);
+        setKeysActive(0);
+    }
+
+    function handleKeys(key: KeypressEvent) {
+        if (!keysTarget) return;
+
+        const keys = getKeys(providers[keysTarget]?.apiKey);
+        const addIndex = keys.length;
+        const backIndex = keys.length + 1;
+
+        if (isUpKey(key)) {
+            setKeysActive(Math.max(0, keysActive - 1));
+        } else if (isDownKey(key)) {
+            setKeysActive(Math.min(backIndex, keysActive + 1));
+        } else if (key.name === "d" && keysActive < keys.length) {
+            deleteKey(keysTarget, keysActive, keys);
+        } else if (isEnterKey(key)) {
+            if (keysActive === addIndex) {
+                requestAddKey(keysTarget, "keys");
+            } else if (keysActive === backIndex) {
+                exitKeysMode();
+            }
+        } else if (key.name === "escape") {
+            exitKeysMode();
+        }
+    }
+
+    function deleteKey(pid: string, index: number, keys: string[]) {
+        const remaining = keys.filter((_, i) => i !== index);
+        if (remaining.length === 0) {
+            const updated = { ...providers };
+            delete updated[pid];
+            setProviders(updated);
+            exitKeysMode();
+        } else {
+            setProviders({
+                ...providers,
+                [pid]: { ...providers[pid], apiKey: remaining.length === 1 ? remaining[0]! : remaining },
+            });
+            setKeysActive(Math.min(keysActive, remaining.length - 1));
+        }
+    }
+
+    // --- Rendering ---
+
+    const styledMessage = theme.style.message(message, "idle");
+    const lines: string[] = [`${prefix} ${styledMessage}`];
+
+    if (mode === "keys" && keysTarget) {
+        renderKeysView(lines, keysTarget);
+    } else {
+        renderBrowseView(lines);
+    }
+
+    return `${lines.join("\n")}${cursorHide}`;
+
+    function renderBrowseView(out: string[]) {
+        for (let i = 0; i < providerIds.length; i++) {
+            const pid = providerIds[i]!;
+            const name = ProviderConfigUI.getProviderDisplayName(pid);
+            const pfx = i === active ? `${CURSOR} ` : "  ";
+            const enabled = pid in providers;
+            const hint = config.providerHints?.[pid];
+
+            if (enabled) {
+                const keyInfo = formatKeyInfo(providers[pid]?.apiKey);
+                out.push(`${pfx}${display.providerCheck(name)}${keyInfo}`);
+            } else {
+                const hintSuffix = hint ? chalk.dim(` — ${hint}`) : "";
+                out.push(`${pfx}${display.providerUncheck(name)}${hintSuffix}`);
+            }
+        }
+
+        const donePfx = active === doneIndex ? `${CURSOR} ` : "  ";
+        out.push(`${donePfx}${display.doneLabel()}`);
+
+        const help = [
+            `${chalk.bold("↑↓")} ${chalk.dim("navigate")}`,
+            `${chalk.bold("space")} ${chalk.dim("toggle")}`,
+            `${chalk.bold("⏎")} ${chalk.dim("manage keys / done")}`,
+        ];
+        out.push(chalk.dim(`  ${help.join(chalk.dim(" • "))}`));
+    }
+
+    function renderKeysView(out: string[], pid: string) {
+        const name = ProviderConfigUI.getProviderDisplayName(pid);
+        const keys = getKeys(providers[pid]?.apiKey);
+        const addIndex = keys.length;
+        const backIndex = keys.length + 1;
+
+        out.push(`  ${chalk.bold(name)} ${chalk.dim("— API Keys")}`);
+        out.push(`  ${chalk.dim("─".repeat(RULE_WIDTH))}`);
+
+        for (let i = 0; i < keys.length; i++) {
+            const pfx = keysActive === i ? `${CURSOR} ` : "  ";
+            const masked = maskKey(pid, keys[i]!);
+            const deleteHint = keysActive === i ? chalk.dim("  d delete") : "";
+            out.push(`${pfx}${masked}${deleteHint}`);
+        }
+
+        const addPfx = keysActive === addIndex ? `${CURSOR} ` : "  ";
+        out.push(`${addPfx}${chalk.dim("+ Add another key")}`);
+
+        const backPfx = keysActive === backIndex ? `${CURSOR} ` : "  ";
+        out.push(`${backPfx}${chalk.dim("← Back")}`);
+
+        const help = [
+            `${chalk.bold("↑↓")} ${chalk.dim("navigate")}`,
+            `${chalk.bold("d")} ${chalk.dim("delete key")}`,
+            `${chalk.bold("⏎")} ${chalk.dim("select")}`,
+            `${chalk.bold("esc")} ${chalk.dim("back")}`,
+        ];
+        out.push(chalk.dim(`  ${help.join(chalk.dim(" • "))}`));
+    }
+});