coder-agent 2.9.11 → 2.9.13

package/dist/agent.js

@@ -3,6 +3,7 @@ import * as path from "path";
 import * as fs from "fs/promises";
 import { TOOL_DEFINITIONS, dispatchTool } from "./tools.js";
 import { Memory, getAgentMemoryEntrypoint } from "./memory.js";
+import { getProviderApiKey } from "./config.js";
 // ─── Loading Spinner ──────────────────────────────────────────────────────────
 let spinnerTimer = null;
 let currentFrame = 0;
@@ -405,21 +406,110 @@ function extractTextToolCalls(content) {
     return calls;
 }
 // ─── Gemini API client with Auto-Rotation Fallback ────────────────────────────
-async function callGeminiAPIWithRotation(apiKey, params, maxRetries = 3, initialDelayMs = 1500, signal, silent = false) {
-    const rotationList = [
-        "gemini-2.0-flash",
-        "gemini-2.0-pro-exp",
+const lastRequestTimestamps = {};
+function getProviderAndModel(modelName) {
+    const lowercase = modelName.toLowerCase();
+    if (lowercase.startsWith("groq/")) {
+        return { provider: "groq", model: modelName.slice(5) };
+    }
+    if (lowercase.startsWith("mistral/")) {
+        return { provider: "mistral", model: modelName.slice(8) };
+    }
+    if (lowercase.startsWith("openrouter/")) {
+        return { provider: "openrouter", model: modelName.slice(11) };
+    }
+    if (lowercase.startsWith("nvidia/")) {
+        return { provider: "nvidia", model: modelName.slice(7) };
+    }
+    if (lowercase.startsWith("github/")) {
+        return { provider: "github", model: modelName.slice(7) };
+    }
+    return { provider: "gemini", model: modelName };
+}
+function getProviderEndpoint(provider) {
+    switch (provider) {
+        case "gemini":
+            return "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions";
+        case "groq":
+            return "https://api.groq.com/openai/v1/chat/completions";
+        case "mistral":
+            return "https://api.mistral.ai/v1/chat/completions";
+        case "openrouter":
+            return "https://openrouter.ai/api/v1/chat/completions";
+        case "nvidia":
+            return "https://integrate.api.nvidia.com/v1/chat/completions";
+        case "github":
+            return "https://models.inference.ai.azure.com/chat/completions";
+    }
+    return "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions";
+}
+function getRequiredDelayMs(provider, model) {
+    const lowercaseModel = model.toLowerCase();
+    switch (provider) {
+        case "gemini":
+            if (lowercaseModel.includes("pro")) {
+                return 30000; // 30s for Pro (2 RPM)
+            }
+            return 4000; // 4s for Flash (15 RPM)
+        case "groq":
+            return 2000; // 2s (30 RPM)
+        case "mistral":
+            return 1500; // 1.5s (1 request/second + buffer)
+        case "openrouter":
+            return 5000; // 5s for free/shared queue
+        case "nvidia":
+            return 2000; // 2s (40 RPM)
+        case "github":
+            if (lowercaseModel.includes("sonnet") || lowercaseModel.includes("gpt-4o")) {
+                return 30000; // 30s for flagship (50 RPD)
+            }
+            return 6000; // 6s for open-weights (150 RPD)
+    }
+    return 2000; // default fallback
+}
+const DEFAULT_ROTATION_MAP = {
+    gemini: [
         "gemini-2.5-flash",
         "gemini-2.5-pro",
         "gemini-3.5-flash",
         "gemini-3.1-flash-lite",
         "gemma-4-31b-it",
-        "gemma-4-26b-a4b-it"
-    ];
+        "gemma-4-26b-a4b-it",
+        "gemini-2.0-flash",
+        "gemini-2.0-pro-exp"
+    ],
+    groq: [
+        "groq/llama-3.3-70b-specdec",
+        "groq/gemma-2-9b-it"
+    ],
+    mistral: [
+        "mistral/codestral",
+        "mistral/mistral-large-latest"
+    ],
+    openrouter: [
+        "openrouter/qwen/qwen-2.5-coder-32b-instruct:free",
+        "openrouter/deepseek/deepseek-r1:free",
+        "openrouter/meta-llama/llama-3.3-70b-instruct:free"
+    ],
+    nvidia: [
+        "nvidia/qwen-2.5-coder-32b-instruct",
+        "nvidia/deepseek-r1",
+        "nvidia/meta/llama-3.3-70b-instruct"
+    ],
+    github: [
+        "github/claude-3.5-sonnet",
+        "github/gpt-4o",
+        "github/meta-llama-3.3-70b-instruct"
+    ]
+};
+async function callAPIWithRotationAndThrottling(defaultApiKey, params, maxRetries = 3, initialDelayMs = 1500, signal, silent = false) {
+    const { provider: initialProvider } = getProviderAndModel(params.model);
+    let rotationList = DEFAULT_ROTATION_MAP[initialProvider] || DEFAULT_ROTATION_MAP.gemini;
     let currentModel = params.model;
     let modelIndex = rotationList.indexOf(currentModel);
     if (modelIndex === -1) {
-        modelIndex = 0; // Default if not in list
+        rotationList = [currentModel, ...rotationList];
+        modelIndex = 0;
     }
     let attempts = 0;
     while (attempts < maxRetries) {
@@ -428,19 +518,53 @@ async function callGeminiAPIWithRotation(apiKey, params, maxRetries = 3, initial
             abortErr.name = "AbortError";
             throw abortErr;
         }
+        const { provider, model: actualModelName } = getProviderAndModel(currentModel);
+        const providerKey = await getProviderApiKey(provider) || defaultApiKey;
+        if (!providerKey) {
+            throw new Error(`API key for provider '${provider}' is missing. Please set it using: /key ${provider} <api_key>`);
+        }
+        // Apply rate-limiting throttle cooldown
+        const requiredDelay = getRequiredDelayMs(provider, actualModelName);
+        const lastRequestTime = lastRequestTimestamps[provider] || 0;
+        const elapsed = Date.now() - lastRequestTime;
+        if (elapsed < requiredDelay) {
+            const waitMs = requiredDelay - elapsed;
+            if (!silent) {
+                updateSpinner("thinking...");
+            }
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(resolve, waitMs);
+                if (signal) {
+                    const onAbort = () => {
+                        clearTimeout(timer);
+                        const abortErr = new Error("The user aborted a request.");
+                        abortErr.name = "AbortError";
+                        reject(abortErr);
+                    };
+                    signal.addEventListener("abort", onAbort);
+                }
+            });
+        }
+        lastRequestTimestamps[provider] = Date.now();
         try {
-            const res = await fetch("https://generativelanguage.googleapis.com/v1beta/openai/chat/completions", {
+            const endpoint = getProviderEndpoint(provider);
+            const headers = {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${providerKey}`
+            };
+            if (provider === "openrouter") {
+                headers["HTTP-Referer"] = "https://github.com/google/antigravity";
+                headers["X-Title"] = "Coder Agent";
+            }
+            const res = await fetch(endpoint, {
                 method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    "Authorization": `Bearer ${apiKey}`
-                },
-                body: JSON.stringify({ ...params, model: currentModel }),
+                headers,
+                body: JSON.stringify({ ...params, model: actualModelName }),
                 signal
             });
             if (!res.ok) {
                 const errText = await res.text();
-                const err = new Error(`Gemini API error (${res.status}): ${errText}`);
+                const err = new Error(`${provider.toUpperCase()} API error (${res.status}): ${errText}`);
                 err.status = res.status;
                 throw err;
             }
@@ -609,7 +733,6 @@ async function callGeminiAPIWithRotation(apiKey, params, maxRetries = 3, initial
             const isRetryableError = status === 429 || status === 503 || (status >= 500 && status < 600) || !status;
             const isModelError = status === 404 || status === 400;
             if (isRetryableError || isModelError) {
-                // Rotate model immediately if rate limit or model error occurred
                 if (modelIndex + 1 < rotationList.length) {
                     modelIndex++;
                     const nextModel = rotationList[modelIndex];
@@ -843,7 +966,7 @@ export class Agent {
                 }
                 iterations++;
                 updateSpinner("thinking...");
-                const responseObj = await callGeminiAPIWithRotation(this.apiKey, {
+                const responseObj = await callAPIWithRotationAndThrottling(this.apiKey, {
                     model: this.model,
                     messages: this.memory.getAll(),
                     tools: TOOL_DEFINITIONS,
@@ -1062,7 +1185,7 @@ Instructions:
 3. Integrate these new learnings and file catalog updates into the existing memory structure. Keep existing useful learnings/preferences, but clean up duplicates or obsolete info.
 4. Keep the content concise, clean, and formatted in Markdown.
 5. If there are no new learnings, setup details, file updates, or instructions in the conversation, output EXACTLY the existing memory content. Do not add conversational text, just output the updated/existing markdown content.`;
-            const responseObj = await callGeminiAPIWithRotation(this.apiKey, {
+            const responseObj = await callAPIWithRotationAndThrottling(this.apiKey, {
                 model: this.model,
                 messages: [{ role: "user", content: prompt }],
                 temperature: 0.1,

package/dist/config.js

@@ -53,15 +53,57 @@ async function writeConfig(config) {
         console.error(`\n  ⚠️  Failed to save config to ${CONFIG_FILE}: ${err.message}`);
     }
 }
-export async function getStoredApiKey() {
+export async function getStoredApiKey(provider) {
     const config = await readConfig();
-    return config.geminiApiKey;
+    const p = provider?.toLowerCase();
+    if (!p || p === "gemini")
+        return config.geminiApiKey;
+    if (p === "groq")
+        return config.groqApiKey;
+    if (p === "mistral")
+        return config.mistralApiKey;
+    if (p === "openrouter")
+        return config.openrouterApiKey;
+    if (p === "nvidia")
+        return config.nvidiaApiKey;
+    if (p === "github")
+        return config.githubApiKey;
+    return undefined;
 }
-export async function saveApiKey(apiKey) {
+export async function saveApiKey(apiKey, provider) {
     const config = await readConfig();
-    config.geminiApiKey = apiKey.trim();
+    const trimmed = apiKey.trim();
+    const p = provider?.toLowerCase();
+    if (!p || p === "gemini")
+        config.geminiApiKey = trimmed;
+    else if (p === "groq")
+        config.groqApiKey = trimmed;
+    else if (p === "mistral")
+        config.mistralApiKey = trimmed;
+    else if (p === "openrouter")
+        config.openrouterApiKey = trimmed;
+    else if (p === "nvidia")
+        config.nvidiaApiKey = trimmed;
+    else if (p === "github")
+        config.githubApiKey = trimmed;
     await writeConfig(config);
 }
+export async function getProviderApiKey(provider) {
+    const p = provider.toLowerCase();
+    if (p === "gemini")
+        return process.env.GEMINI_API_KEY || await getStoredApiKey("gemini");
+    if (p === "groq")
+        return process.env.GROQ_API_KEY || await getStoredApiKey("groq");
+    if (p === "mistral")
+        return process.env.MISTRAL_API_KEY || await getStoredApiKey("mistral");
+    if (p === "openrouter")
+        return process.env.OPENROUTER_API_KEY || await getStoredApiKey("openrouter");
+    if (p === "nvidia")
+        return process.env.NVIDIA_API_KEY || await getStoredApiKey("nvidia");
+    if (p === "github")
+        return process.env.GITHUB_API_KEY || process.env.GITHUB_TOKEN || await getStoredApiKey("github");
+    return undefined;
+}
 export async function getStoredModel() {
     const config = await readConfig();
     return config.defaultModel;
@@ -72,13 +114,10 @@ export async function saveModel(model) {
     await writeConfig(config);
 }
 export async function getStoredGeminiApiKey() {
-    const config = await readConfig();
-    return config.geminiApiKey;
+    return getStoredApiKey("gemini");
 }
 export async function saveGeminiApiKey(geminiApiKey) {
-    const config = await readConfig();
-    config.geminiApiKey = geminiApiKey.trim();
-    await writeConfig(config);
+    await saveApiKey(geminiApiKey, "gemini");
 }
 export async function getLastUsedInfo() {
     const config = await readConfig();

package/dist/index.js

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
+import { createRequire } from "module";
 import * as readline from "readline";
 import chalk from "chalk";
 import figlet from "figlet";
 import { Agent } from "./agent.js";
-import { getStoredApiKey, saveApiKey, getStoredModel, saveModel, getLastUsedInfo, saveLastUsedInfo } from "./config.js";
-const CURRENT_VERSION = "2.7.3";
+import { getStoredApiKey, saveApiKey, getStoredModel, saveModel, getLastUsedInfo, saveLastUsedInfo, getProviderApiKey } from "./config.js";
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
+const CURRENT_VERSION = packageJson.version;
 const VALID_MODELS = [
     "gemini-2.5-flash",
     "gemini-2.5-pro",
@@ -15,6 +18,12 @@ const VALID_MODELS = [
     "gemma-4-31b-it",
     "gemma-4-26b-a4b-it"
 ];
+function isValidModel(modelName) {
+    if (VALID_MODELS.includes(modelName))
+        return true;
+    const prefixes = ["groq/", "mistral/", "openrouter/", "nvidia/", "github/"];
+    return prefixes.some(prefix => modelName.toLowerCase().startsWith(prefix));
+}
 function printBanner(modelName) {
     console.clear();
     console.log('');
@@ -80,6 +89,14 @@ function printHelp() {
     console.log(chalk.white("    gemini-2.0-flash               — (Deprecated) Ultra-fast, lightweight"));
     console.log(chalk.white("    gemini-2.0-pro-exp             — (Deprecated) Experimental reasoning"));
     console.log("");
+    console.log(chalk.gray("  Popular Multi-Provider Models (prefixed with provider/):"));
+    console.log(chalk.white("    groq/llama-3.3-70b-specdec     — Groq Llama 3.3 70B (extremely fast)"));
+    console.log(chalk.white("    mistral/codestral              — Mistral Codestral (highly rated coding model)"));
+    console.log(chalk.white("    openrouter/qwen/qwen-2.5-coder-32b-instruct:free — OpenRouter Qwen 2.5 Coder Free"));
+    console.log(chalk.white("    openrouter/deepseek/deepseek-r1:free             — OpenRouter DeepSeek R1 Free"));
+    console.log(chalk.white("    nvidia/qwen-2.5-coder-32b-instruct              — NVIDIA NIM Qwen 2.5 Coder 32B"));
+    console.log(chalk.white("    github/claude-3.5-sonnet       — GitHub Claude 3.5 Sonnet (requires GitHub token)"));
+    console.log("");
 }
 // ─── API Key Bootstrap ────────────────────────────────────────────────────────
 async function promptApiKey() {
@@ -168,12 +185,12 @@ async function main() {
     }
     const storedModel = await getStoredModel();
     let defaultModel = "gemini-2.5-flash";
-    if (storedModel && VALID_MODELS.includes(storedModel)) {
+    if (storedModel && isValidModel(storedModel)) {
         defaultModel = storedModel;
     }
-    if (tempModel && !VALID_MODELS.includes(tempModel)) {
+    if (tempModel && !isValidModel(tempModel)) {
         console.log(chalk.hex('#ff453a')('✕ error'));
-        console.log(chalk.dim(`  Invalid model: ${tempModel}. Choose one of: ${VALID_MODELS.join(", ")}`));
+        console.log(chalk.dim(`  Invalid model: ${tempModel}. Choose one of: ${VALID_MODELS.join(", ")} or prefix with groq/, mistral/, openrouter/, nvidia/, github/`));
         process.exit(1);
     }
     const modelToUse = tempModel || defaultModel;
@@ -319,7 +336,7 @@ async function main() {
                 console.log();
                 console.log(chalk.dim("  Available Commands:"));
                 console.log(`  ${chalk.hex('#0a84ff')('/model')} ${chalk.gray('[name]')} ${chalk.dim('— View active model or switch to [name]')}`);
-                console.log(`  ${chalk.hex('#0a84ff')('/key')}   ${chalk.gray('[api_key]')} ${chalk.dim('— Set/save your Gemini API Key globally')}`);
+                console.log(`  ${chalk.hex('#0a84ff')('/key')}   ${chalk.gray('[provider] [api_key]')} ${chalk.dim('— Set/save API keys globally')}`);
                 console.log(`  ${chalk.hex('#0a84ff')('/clear')}        ${chalk.dim('— Wipe conversation memory')}`);
                 console.log(`  ${chalk.hex('#0a84ff')('/status')}       ${chalk.dim('— Show active model and memory usage')}`);
                 console.log(`  ${chalk.hex('#0a84ff')('/help')}         ${chalk.dim('— Show help screen')}`);
@@ -375,17 +392,17 @@ async function main() {
             const parts = trimmed.split(/\s+/);
             if (parts.length === 1) {
                 console.log(chalk.dim(`model   `) + chalk.gray(agent.getModel()));
-                console.log(chalk.gray(`options `) + chalk.gray(VALID_MODELS.join(" · ")));
+                console.log(chalk.gray(`options `) + chalk.gray(VALID_MODELS.join(" · ") + " · groq/... · mistral/... · openrouter/... · nvidia/... · github/..."));
             }
             else {
                 const newModel = parts[1];
-                if (VALID_MODELS.includes(newModel)) {
+                if (isValidModel(newModel)) {
                     agent.setModel(newModel);
                     console.log(chalk.hex('#30d158')('✓') + ' ' + chalk.gray(`Switched model to: ${newModel}`));
                 }
                 else {
                     console.log(chalk.hex('#ff453a')('✕ error'));
-                    console.log(chalk.dim(`  Model must be one of: ${VALID_MODELS.join(" · ")}`));
+                    console.log(chalk.dim(`  Model must be one of: ${VALID_MODELS.join(" · ")} or prefixed with groq/, mistral/, openrouter/, nvidia/, github/`));
                 }
             }
             if (!isRlClosed) {
@@ -400,26 +417,47 @@ async function main() {
         if (trimmed.startsWith("/key")) {
             const parts = trimmed.split(/\s+/);
             if (parts.length === 1) {
-                const keyToCheck = agent.getApiKey();
-                if (keyToCheck) {
-                    const masked = keyToCheck.slice(0, 7) + "..." + keyToCheck.slice(-4);
-                    console.log(chalk.dim(`  Gemini API Key is set: `) + chalk.gray(masked));
-                }
-                else {
-                    console.log(chalk.hex('#ff453a')('✕ error') + chalk.dim(' — Gemini API Key is missing. Set it using: /key <your_api_key>'));
+                const providers = ["gemini", "groq", "mistral", "openrouter", "nvidia", "github"];
+                console.log(chalk.white.bold("\n  Stored API Keys:"));
+                for (const p of providers) {
+                    const keyToCheck = await getProviderApiKey(p);
+                    if (keyToCheck) {
+                        const masked = keyToCheck.slice(0, 7) + "..." + keyToCheck.slice(-4);
+                        console.log(`    ${chalk.dim(p.toUpperCase().padEnd(10))} : ${chalk.gray(masked)}`);
+                    }
+                    else {
+                        console.log(`    ${chalk.dim(p.toUpperCase().padEnd(10))} : ${chalk.hex('#ff453a')('missing')}`);
+                    }
                 }
+                console.log(chalk.dim("\n  To set a key, use: /key <provider> <api_key> (e.g. /key groq gsk_...)"));
+                console.log(chalk.dim("  Or set it in environment (e.g. GEMINI_API_KEY, GROQ_API_KEY, etc.)\n"));
             }
-            else {
+            else if (parts.length === 2) {
                 const newKey = parts[1].trim();
                 if (!newKey) {
                     console.log(chalk.hex('#ff453a')('✕ error') + chalk.dim(' — API Key cannot be empty.'));
                 }
                 else {
-                    await saveApiKey(newKey);
+                    await saveApiKey(newKey, "gemini");
                     agent.setApiKey(newKey);
                     console.log(chalk.hex('#30d158')('✓') + ' ' + chalk.gray('Gemini API Key saved and set successfully.'));
                 }
             }
+            else {
+                const provider = parts[1].toLowerCase();
+                const newKey = parts[2].trim();
+                const validProviders = ["gemini", "groq", "mistral", "openrouter", "nvidia", "github"];
+                if (!validProviders.includes(provider)) {
+                    console.log(chalk.hex('#ff453a')('✕ error') + chalk.dim(` — Invalid provider. Choose one of: ${validProviders.join(", ")}`));
+                }
+                else {
+                    await saveApiKey(newKey, provider);
+                    if (provider === "gemini") {
+                        agent.setApiKey(newKey);
+                    }
+                    console.log(chalk.hex('#30d158')('✓') + ' ' + chalk.gray(`${provider.toUpperCase()} API Key saved and set successfully.`));
+                }
+            }
             if (!isRlClosed) {
                 try {
                     rl.resume();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coder-agent",
-  "version": "2.9.11",
+  "version": "2.9.13",
   "description": "CLI coding agent powered by Google Gemini",
   "type": "module",
   "main": "dist/index.js",