rlm-cli 0.2.3 → 0.2.5

package/dist/interactive.js

@@ -91,16 +91,97 @@ function resolveModel(modelId) {
     }
     return undefined;
 }
+// Provider → env var mapping for well-known providers
+const PROVIDER_KEYS = {
+    anthropic: "ANTHROPIC_API_KEY",
+    openai: "OPENAI_API_KEY",
+    google: "GOOGLE_API_KEY",
+    "google-gemini-cli": "GOOGLE_API_KEY",
+    "google-vertex": "GOOGLE_VERTEX_API_KEY",
+    groq: "GROQ_API_KEY",
+    xai: "XAI_API_KEY",
+    mistral: "MISTRAL_API_KEY",
+    openrouter: "OPENROUTER_API_KEY",
+    huggingface: "HUGGINGFACE_API_KEY",
+    cerebras: "CEREBRAS_API_KEY",
+};
+// User-facing provider list for setup & /provider command
+const SETUP_PROVIDERS = [
+    { name: "Anthropic", label: "Claude", env: "ANTHROPIC_API_KEY", piProvider: "anthropic" },
+    { name: "OpenAI", label: "GPT", env: "OPENAI_API_KEY", piProvider: "openai" },
+    { name: "Google", label: "Gemini", env: "GOOGLE_API_KEY", piProvider: "google" },
+    { name: "Groq", label: "Groq", env: "GROQ_API_KEY", piProvider: "groq" },
+    { name: "xAI", label: "Grok", env: "XAI_API_KEY", piProvider: "xai" },
+    { name: "Mistral", label: "Mistral", env: "MISTRAL_API_KEY", piProvider: "mistral" },
+    { name: "OpenRouter", label: "OpenRouter", env: "OPENROUTER_API_KEY", piProvider: "openrouter" },
+];
+function providerEnvKey(provider) {
+    return PROVIDER_KEYS[provider] || `${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+}
 function detectProvider() {
-    if (process.env.ANTHROPIC_API_KEY)
-        return "anthropic";
-    if (process.env.OPENAI_API_KEY) {
-        if (process.env.OPENAI_BASE_URL?.includes("openrouter"))
-            return "openrouter";
-        return "openai";
+    for (const provider of Object.keys(PROVIDER_KEYS)) {
+        if (process.env[PROVIDER_KEYS[provider]])
+            return provider;
     }
     return "unknown";
 }
+function hasAnyApiKey() {
+    return detectProvider() !== "unknown";
+}
+/** Returns the pi-ai provider name + model for a given model ID, searching all providers.
+ *  Prioritises SETUP_PROVIDERS so e.g. "gpt-4o" resolves to "openai" not "azure-openai-responses". */
+function resolveModelWithProvider(modelId) {
+    // First pass: check well-known (setup) providers
+    const knownNames = new Set(SETUP_PROVIDERS.map((p) => p.piProvider));
+    for (const provider of getProviders()) {
+        if (!knownNames.has(provider))
+            continue;
+        for (const m of getModels(provider)) {
+            if (m.id === modelId)
+                return { model: m, provider };
+        }
+    }
+    // Second pass: all remaining providers
+    for (const provider of getProviders()) {
+        if (knownNames.has(provider))
+            continue;
+        for (const m of getModels(provider)) {
+            if (m.id === modelId)
+                return { model: m, provider };
+        }
+    }
+    return undefined;
+}
+/** Returns the first model ID from a given pi-ai provider. */
+function getDefaultModelForProvider(provider) {
+    const models = getModels(provider);
+    return models.length > 0 ? models[0].id : undefined;
+}
+/** Prompt user for a provider's API key if not already set. Returns true if key is available. */
+async function promptForProviderKey(rlInstance, providerInfo) {
+    if (process.env[providerInfo.env])
+        return true;
+    const key = await new Promise((resolve) => rlInstance.question(`  ${c.cyan}${providerInfo.env}:${c.reset} `, (a) => resolve(a.trim())));
+    if (!key)
+        return false;
+    process.env[providerInfo.env] = key;
+    // Save to shell profile
+    const shellRc = process.env.SHELL?.includes("zsh") ? "~/.zshrc" : "~/.bashrc";
+    const rcPath = shellRc.replace("~", process.env.HOME || "~");
+    try {
+        fs.appendFileSync(rcPath, `\nexport ${providerInfo.env}=${key}\n`);
+        console.log(`\n  ${c.green}✓${c.reset} ${providerInfo.name} key saved to ${c.dim}${shellRc}${c.reset}`);
+    }
+    catch {
+        console.log(`\n  ${c.yellow}!${c.reset} Could not write to ${shellRc}. Add manually:`);
+        console.log(`    ${c.yellow}export ${providerInfo.env}=${key}${c.reset}`);
+    }
+    return true;
+}
+/** Find the SETUP_PROVIDERS entry that owns a given pi-ai provider name. */
+function findSetupProvider(piProvider) {
+    return SETUP_PROVIDERS.find((p) => p.piProvider === piProvider);
+}
 // ── Paste detection ─────────────────────────────────────────────────────────
 function isMultiLineInput(input) {
     return input.includes("\n");
@@ -160,8 +241,9 @@ ${c.bold}Context${c.reset}
   ${c.cyan}/clear-context${c.reset}       Unload context
 
 ${c.bold}Model${c.reset}
-  ${c.cyan}/model${c.reset}               List available models
+  ${c.cyan}/model${c.reset}               List models for current provider
   ${c.cyan}/model${c.reset} <#|id>         Switch model by number or ID
+  ${c.cyan}/provider${c.reset}            Switch provider
 
 ${c.bold}Tools${c.reset}
   ${c.cyan}/trajectories${c.reset}        List saved runs
@@ -362,8 +444,20 @@ function displaySubQueryResult(info) {
 function getAvailableModels() {
     const items = [];
     for (const provider of getProviders()) {
-        const providerKey = `${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`;
-        if (!process.env[providerKey] && provider !== detectProvider())
+        const key = providerEnvKey(provider);
+        if (!process.env[key] && provider !== detectProvider())
+            continue;
+        for (const m of getModels(provider)) {
+            items.push({ id: m.id, provider });
+        }
+    }
+    return items;
+}
+/** Get models for a specific provider (matching by pi-ai provider name or SETUP_PROVIDERS piProvider). */
+function getModelsForProvider(providerName) {
+    const items = [];
+    for (const provider of getProviders()) {
+        if (provider !== providerName)
             continue;
         for (const m of getModels(provider)) {
             items.push({ id: m.id, provider });
@@ -611,15 +705,37 @@ async function detectAndLoadUrl(input) {
 // ── Main interactive loop ───────────────────────────────────────────────────
 async function interactive() {
     // Validate env
-    const hasApiKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
-    if (!hasApiKey) {
+    if (!hasAnyApiKey()) {
         printBanner();
         console.log(`  ${c.red}No API key found.${c.reset}\n`);
-        console.log(`  Set one of these environment variables:\n`);
-        console.log(`    ${c.yellow}export ANTHROPIC_API_KEY=sk-ant-...${c.reset}    ${c.dim}# Anthropic (Claude)${c.reset}`);
-        console.log(`    ${c.yellow}export OPENAI_API_KEY=sk-...${c.reset}           ${c.dim}# OpenAI (GPT)${c.reset}\n`);
-        console.log(`  ${c.dim}Add to your shell profile (~/.zshrc or ~/.bashrc) to persist across sessions.${c.reset}\n`);
-        process.exit(0);
+        console.log(`  ${c.bold}Select your provider:${c.reset}\n`);
+        for (let i = 0; i < SETUP_PROVIDERS.length; i++) {
+            console.log(`  ${c.dim}${i + 1}${c.reset}  ${SETUP_PROVIDERS[i].name} ${c.dim}(${SETUP_PROVIDERS[i].label})${c.reset}`);
+        }
+        console.log();
+        const setupRl = readline.createInterface({ input: stdin, output: stdout, terminal: true });
+        const ask = (prompt) => new Promise((resolve) => setupRl.question(prompt, (a) => resolve(a.trim())));
+        const choice = await ask(`  ${c.cyan}Provider [1-${SETUP_PROVIDERS.length}]:${c.reset} `);
+        const idx = parseInt(choice, 10) - 1;
+        if (isNaN(idx) || idx < 0 || idx >= SETUP_PROVIDERS.length) {
+            console.log(`\n  ${c.dim}Invalid choice. Exiting.${c.reset}\n`);
+            setupRl.close();
+            process.exit(0);
+        }
+        const provider = SETUP_PROVIDERS[idx];
+        const gotKey = await promptForProviderKey(setupRl, provider);
+        setupRl.close();
+        if (!gotKey) {
+            console.log(`\n  ${c.dim}No key provided. Exiting.${c.reset}\n`);
+            process.exit(0);
+        }
+        // Auto-select default model for chosen provider
+        const defaultModel = getDefaultModelForProvider(provider.piProvider);
+        if (defaultModel) {
+            currentModelId = defaultModel;
+            console.log(`  ${c.green}✓${c.reset} Default model: ${c.bold}${currentModelId}${c.reset}`);
+        }
+        console.log();
     }
     // Resolve model
     currentModel = resolveModel(currentModelId);
@@ -714,27 +830,55 @@ async function interactive() {
                     break;
                 case "model":
                 case "m": {
-                    const available = getAvailableModels();
+                    const curProvider = detectProvider();
                     if (arg) {
-                        // Accept a number or a model ID
-                        const pick = /^\d+$/.test(arg) ? available[parseInt(arg, 10) - 1]?.id : arg;
-                        const newModel = pick ? resolveModel(pick) : undefined;
-                        if (newModel && pick) {
-                            currentModelId = pick;
-                            currentModel = newModel;
-                            console.log(`  ${c.green}✓${c.reset} Switched to ${c.bold}${currentModelId}${c.reset}`);
-                            console.log();
-                            printStatusLine();
+                        // Accept a number (from current provider list) or a model ID
+                        const curModels = getModelsForProvider(curProvider);
+                        let pick;
+                        if (/^\d+$/.test(arg)) {
+                            pick = curModels[parseInt(arg, 10) - 1]?.id;
                         }
                         else {
+                            pick = arg;
+                        }
+                        if (!pick) {
+                            console.log(`  ${c.red}Invalid selection.${c.reset} Use ${c.cyan}/model${c.reset} to list available models.`);
+                            break;
+                        }
+                        // Check if this model belongs to a different provider
+                        const resolved = resolveModelWithProvider(pick);
+                        if (!resolved) {
                             console.log(`  ${c.red}Model "${arg}" not found.${c.reset} Use ${c.cyan}/model${c.reset} to list available models.`);
+                            break;
+                        }
+                        if (resolved.provider !== curProvider) {
+                            // Cross-provider switch
+                            const setupInfo = findSetupProvider(resolved.provider);
+                            const envVar = setupInfo?.env || providerEnvKey(resolved.provider);
+                            const provName = setupInfo?.name || resolved.provider;
+                            if (!process.env[envVar]) {
+                                console.log(`  ${c.yellow}That model requires ${provName}.${c.reset}`);
+                                const gotKey = await promptForProviderKey(rl, { name: provName, env: envVar });
+                                if (!gotKey) {
+                                    console.log(`  ${c.dim}Cancelled.${c.reset}`);
+                                    break;
+                                }
+                            }
                         }
+                        currentModelId = pick;
+                        currentModel = resolved.model;
+                        console.log(`  ${c.green}✓${c.reset} Switched to ${c.bold}${currentModelId}${c.reset}`);
+                        console.log();
+                        printStatusLine();
                     }
                     else {
-                        console.log(`\n  ${c.bold}Current model:${c.reset} ${c.cyan}${currentModelId}${c.reset}\n`);
-                        const pad = String(available.length).length;
-                        for (let i = 0; i < available.length; i++) {
-                            const m = available[i];
+                        // List models for current provider
+                        const models = getModelsForProvider(curProvider);
+                        const provLabel = findSetupProvider(curProvider)?.name || curProvider;
+                        console.log(`\n  ${c.bold}Current model:${c.reset} ${c.cyan}${currentModelId}${c.reset} ${c.dim}(${provLabel})${c.reset}\n`);
+                        const pad = String(models.length).length;
+                        for (let i = 0; i < models.length; i++) {
+                            const m = models[i];
                             const num = String(i + 1).padStart(pad);
                             const dot = m.id === currentModelId ? `${c.green}●${c.reset}` : ` `;
                             const label = m.id === currentModelId
@@ -742,8 +886,52 @@ async function interactive() {
                                 : `${c.dim}${m.id}${c.reset}`;
                             console.log(`  ${c.dim}${num}${c.reset} ${dot} ${label}`);
                         }
-                        console.log(`\n  ${c.dim}${available.length} models · scroll up to see full list.${c.reset}`);
+                        console.log(`\n  ${c.dim}${models.length} models · scroll up to see full list.${c.reset}`);
                         console.log(`  ${c.dim}Type${c.reset} ${c.cyan}/model <number>${c.reset} ${c.dim}or${c.reset} ${c.cyan}/model <id>${c.reset} ${c.dim}to switch.${c.reset}`);
+                        console.log(`  ${c.dim}Type${c.reset} ${c.cyan}/provider${c.reset} ${c.dim}to switch provider.${c.reset}`);
+                    }
+                    break;
+                }
+                case "provider":
+                case "prov": {
+                    const curProvider = detectProvider();
+                    const curLabel = findSetupProvider(curProvider)?.name || curProvider;
+                    console.log(`\n  ${c.bold}Current provider:${c.reset} ${c.cyan}${curLabel}${c.reset}\n`);
+                    for (let i = 0; i < SETUP_PROVIDERS.length; i++) {
+                        const p = SETUP_PROVIDERS[i];
+                        const isCurrent = p.piProvider === curProvider;
+                        const dot = isCurrent ? `${c.green}●${c.reset}` : ` `;
+                        const hasKey = process.env[p.env] ? `${c.green}✓${c.reset}` : ` `;
+                        const label = isCurrent
+                            ? `${c.cyan}${p.name}${c.reset} ${c.dim}(${p.label})${c.reset}`
+                            : `${p.name} ${c.dim}(${p.label})${c.reset}`;
+                        console.log(`  ${c.dim}${i + 1}${c.reset} ${dot}${hasKey} ${label}`);
+                    }
+                    console.log();
+                    const provChoice = await new Promise((resolve) => rl.question(`  ${c.cyan}Provider [1-${SETUP_PROVIDERS.length}]:${c.reset} `, (a) => resolve(a.trim())));
+                    const idx = parseInt(provChoice, 10) - 1;
+                    if (isNaN(idx) || idx < 0 || idx >= SETUP_PROVIDERS.length) {
+                        console.log(`  ${c.dim}Cancelled.${c.reset}`);
+                        break;
+                    }
+                    const chosen = SETUP_PROVIDERS[idx];
+                    const gotKey = await promptForProviderKey(rl, chosen);
+                    if (!gotKey) {
+                        console.log(`  ${c.dim}Cancelled.${c.reset}`);
+                        break;
+                    }
+                    // Auto-select first model from new provider
+                    const defaultModel = getDefaultModelForProvider(chosen.piProvider);
+                    if (defaultModel) {
+                        currentModelId = defaultModel;
+                        currentModel = resolveModel(currentModelId);
+                        console.log(`  ${c.green}✓${c.reset} Switched to ${c.bold}${chosen.name}${c.reset}`);
+                        console.log(`  ${c.green}✓${c.reset} Default model: ${c.bold}${currentModelId}${c.reset}`);
+                        console.log();
+                        printStatusLine();
+                    }
+                    else {
+                        console.log(`  ${c.red}No models available for ${chosen.name}.${c.reset}`);
                     }
                     break;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rlm-cli",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Standalone CLI for Recursive Language Models (RLMs) — implements Algorithm 1 from arXiv:2512.24601",
   "type": "module",
   "bin": {