@banaxi/banana-code 1.7.0 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@banaxi/banana-code",
-    "version": "1.7.0",
+    "version": "1.8.0",
     "description": "🍌 BananaCode",
     "keywords": [
         "banana",

package/src/config.js

@@ -146,6 +146,63 @@ export async function setupProvider(provider, config = {}) {
                 choices: OPENAI_MODELS
             });
         }
+    } else if (provider === 'openrouter') {
+        config.apiKey = await input({
+            message: 'Enter your OPENROUTER_API_KEY (from openrouter.ai/keys):',
+            default: config.apiKey
+        });
+
+        let modelAccepted = false;
+        while (!modelAccepted) {
+            const modelId = await input({
+                message: 'Enter the OpenRouter model ID (e.g., nvidia/nemotron-3-super-120b-a12b:free):',
+                default: config.model || '',
+                validate: (v) => v.trim().length > 0 || 'Model ID cannot be empty'
+            });
+
+            console.log(chalk.cyan(`\nValidating model "${modelId}" on OpenRouter...`));
+            try {
+                const res = await fetch('https://openrouter.ai/api/v1/models');
+                const data = await res.json();
+                const found = data.data?.find(m => m.id === modelId.trim());
+
+                if (!found) {
+                    console.log(chalk.red(`Model "${modelId}" was not found on OpenRouter.`));
+                    console.log(chalk.yellow('Browse available models at: https://openrouter.ai/models'));
+                    const retry = await input({ message: 'Try a different model ID? (y/n):', default: 'y' });
+                    if (retry.toLowerCase() !== 'y') {
+                        config.model = modelId.trim();
+                        modelAccepted = true;
+                        console.log(chalk.yellow('Proceeding anyway — tool calling may not work.'));
+                    }
+                    continue;
+                }
+
+                const supported = found.supported_parameters || [];
+                const hasToolCalling = supported.includes('tools') || supported.includes('tool_choice');
+
+                if (hasToolCalling) {
+                    console.log(chalk.green(`✔ "${modelId}" supports tool calling. Good to go!`));
+                    config.model = modelId.trim();
+                    modelAccepted = true;
+                } else {
+                    console.log(chalk.red(`✘ "${modelId}" does NOT support tool calling.`));
+                    console.log(chalk.gray(`   Supported parameters: ${supported.join(', ') || 'none listed'}`));
+                    console.log(chalk.yellow('Banana Code requires tool calling to function correctly.'));
+                    const retry = await input({ message: 'Choose a different model? (y/n):', default: 'y' });
+                    if (retry.toLowerCase() !== 'y') {
+                        config.model = modelId.trim();
+                        modelAccepted = true;
+                        console.log(chalk.yellow('Proceeding anyway — tool calling will likely fail.'));
+                    }
+                }
+            } catch (err) {
+                console.log(chalk.red(`Could not reach OpenRouter API: ${err.message}`));
+                console.log(chalk.yellow('Skipping validation and using the model ID as-is.'));
+                config.model = modelId.trim();
+                modelAccepted = true;
+            }
+        }
     } else if (provider === 'ollama') {
         console.log(chalk.cyan("Detecting running Ollama models..."));
         try {
@@ -180,6 +237,7 @@ async function runSetupWizard() {
             { name: 'Anthropic Claude', value: 'claude' },
             { name: 'OpenAI', value: 'openai' },
             { name: 'Mistral AI', value: 'mistral' },
+            { name: 'OpenRouter (Any Model)', value: 'openrouter' },
             { name: 'Ollama Cloud', value: 'ollama_cloud' },
             { name: 'Ollama (Local)', value: 'ollama' }
         ]

package/src/constants.js

@@ -7,9 +7,9 @@ export const GEMINI_MODELS = [
 ];
 
 export const CLAUDE_MODELS = [
-    { name: 'Claude Opus 4.6 (Flagship)', value: 'claude-4-6-opus-20260205' },
-    { name: 'Claude Sonnet 4.6 (Fast & Smart)', value: 'claude-4-6-sonnet-20260217' },
-    { name: 'Claude Haiku 4.5', value: 'claude-4-5-haiku-20251015' }
+    { name: 'Claude Opus 4.6 (Flagship)', value: 'claude-opus-4-6' },
+    { name: 'Claude Sonnet 4.6 (Fast & Smart)', value: 'claude-sonnet-4-6' },
+    { name: 'Claude Haiku 4.5', value: 'claude-haiku-4-5' }
 ];
 
 export const OPENAI_MODELS = [

package/src/index.js

@@ -11,6 +11,7 @@ import { OpenAIProvider } from './providers/openai.js';
 import { OllamaProvider } from './providers/ollama.js';
 import { OllamaCloudProvider } from './providers/ollamaCloud.js';
 import { MistralProvider } from './providers/mistral.js';
+import { OpenRouterProvider } from './providers/openrouter.js';
 
 import { loadSession, saveSession, generateSessionId, getLatestSessionId, listSessions } from './sessions.js';
 import { printMarkdown } from './utils/markdown.js';
@@ -33,6 +34,7 @@ function createProvider(overrideConfig = null) {
         case 'claude': return new ClaudeProvider(activeConfig);
         case 'openai': return new OpenAIProvider(activeConfig);
         case 'mistral': return new MistralProvider(activeConfig);
+        case 'openrouter': return new OpenRouterProvider(activeConfig);
         case 'ollama_cloud': return new OllamaCloudProvider(activeConfig);
         case 'ollama': return new OllamaProvider(activeConfig);
         default:
@@ -57,20 +59,21 @@ async function handleSlashCommand(command) {
                         { name: 'Anthropic Claude', value: 'claude' },
                         { name: 'OpenAI', value: 'openai' },
                         { name: 'Mistral AI', value: 'mistral' },
+                        { name: 'OpenRouter (Any Model)', value: 'openrouter' },
                         { name: 'Ollama Cloud', value: 'ollama_cloud' },
                         { name: 'Ollama (Local)', value: 'ollama' }
                     ]
                 });
             }
 
-            if (['gemini', 'claude', 'openai', 'mistral', 'ollama_cloud', 'ollama'].includes(newProv)) {
+            if (['gemini', 'claude', 'openai', 'mistral', 'openrouter', 'ollama_cloud', 'ollama'].includes(newProv)) {
                 // Use the shared setup logic to get keys/models
                 config = await setupProvider(newProv, config);
                 await saveConfig(config);
                 providerInstance = createProvider();
                 console.log(chalk.green(`Switched provider to ${newProv} (${config.model}).`));
             } else {
-                console.log(chalk.yellow(`Usage: /provider <gemini|claude|openai|mistral|ollama_cloud|ollama>`));
+                console.log(chalk.yellow(`Usage: /provider <gemini|claude|openai|mistral|openrouter|ollama_cloud|ollama>`));
             }
             break;
         case '/model':
@@ -87,6 +90,13 @@ async function handleSlashCommand(command) {
                     choices = config.authType === 'oauth' ? CODEX_MODELS : OPENAI_MODELS;
                 } else if (config.provider === 'mistral') {
                     choices = MISTRAL_MODELS;
+                } else if (config.provider === 'openrouter') {
+                    // Re-run setup flow so the user gets full validation
+                    config = await setupProvider('openrouter', config);
+                    await saveConfig(config);
+                    providerInstance = createProvider();
+                    console.log(chalk.green(`Switched OpenRouter model to ${config.model}.`));
+                    break;
                 } else if (config.provider === 'ollama_cloud') {
                     choices = OLLAMA_CLOUD_MODELS;
                 } else if (config.provider === 'ollama') {
@@ -124,6 +134,29 @@ async function handleSlashCommand(command) {
             }
 
             if (newModel) {
+                if (config.provider === 'openrouter') {
+                    // Validate tool calling support before switching
+                    console.log(chalk.cyan(`Validating "${newModel}" on OpenRouter...`));
+                    try {
+                        const res = await fetch('https://openrouter.ai/api/v1/models');
+                        const data = await res.json();
+                        const found = data.data?.find(m => m.id === newModel);
+                        if (!found) {
+                            console.log(chalk.yellow(`Model "${newModel}" not found on OpenRouter — proceeding anyway.`));
+                        } else {
+                            const supported = found.supported_parameters || [];
+                            const hasToolCalling = supported.includes('tools') || supported.includes('tool_choice');
+                            if (hasToolCalling) {
+                                console.log(chalk.green(`✔ "${newModel}" supports tool calling.`));
+                            } else {
+                                console.log(chalk.red(`✘ "${newModel}" does NOT support tool calling. Banana Code may not work correctly.`));
+                                console.log(chalk.gray(`   Supported parameters: ${supported.join(', ') || 'none listed'}`));
+                            }
+                        }
+                    } catch (err) {
+                        console.log(chalk.yellow(`Could not validate on OpenRouter: ${err.message}`));
+                    }
+                }
                 config.model = newModel;
                 await saveConfig(config);
                 if (providerInstance) {
@@ -571,7 +604,7 @@ async function handleSlashCommand(command) {
         case '/help':
             console.log(chalk.yellow(`
 Available commands:
-  /provider <name> - Switch AI provider (gemini, claude, openai, mistral, ollama_cloud, ollama)
+  /provider <name> - Switch AI provider (gemini, claude, openai, mistral, openrouter, ollama_cloud, ollama)
   /model [name]    - Switch model within current provider (opens menu if name omitted)
   /chats           - List persistent chat sessions
   /clear           - Clear chat history

package/src/providers/openrouter.js

@@ -0,0 +1,169 @@
+import OpenAI from 'openai';
+import { getAvailableTools, executeTool } from '../tools/registry.js';
+import chalk from 'chalk';
+import ora from 'ora';
+import { getSystemPrompt } from '../prompt.js';
+import { printMarkdown } from '../utils/markdown.js';
+
+export class OpenRouterProvider {
+    constructor(config) {
+        this.config = config;
+        this.openai = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: 'https://openrouter.ai/api/v1',
+            defaultHeaders: {
+                'HTTP-Referer': 'https://github.com/Banaxi-Tech/Banana-Code',
+                'X-Title': 'Banana Code'
+            }
+        });
+        this.modelName = config.model;
+        this.systemPrompt = getSystemPrompt(config);
+        this.messages = [{ role: 'system', content: this.systemPrompt }];
+        this.tools = getAvailableTools(config).map(t => ({
+            type: 'function',
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters
+            }
+        }));
+    }
+
+    updateSystemPrompt(newPrompt) {
+        this.systemPrompt = newPrompt;
+        if (this.messages.length > 0 && this.messages[0].role === 'system') {
+            this.messages[0].content = newPrompt;
+        }
+    }
+
+    async sendMessage(message) {
+        this.messages.push({ role: 'user', content: message });
+
+        let spinner = ora({ text: 'Thinking...', color: 'yellow', stream: process.stdout }).start();
+        let finalResponse = '';
+
+        try {
+            while (true) {
+                let stream = null;
+                try {
+                    stream = await this.openai.chat.completions.create({
+                        model: this.modelName,
+                        messages: this.messages,
+                        tools: this.tools,
+                        stream: true
+                    });
+                } catch (e) {
+                    spinner.stop();
+                    let errMsg = e.message;
+                    if (e.error && e.error.message) {
+                        errMsg += ` - ${e.error.message}`;
+                    } else if (e.response && e.response.data) {
+                        try {
+                            errMsg += ` - ${JSON.stringify(e.response.data)}`;
+                        } catch(err){}
+                    } else if (e.error && typeof e.error === 'object') {
+                        try {
+                            errMsg += ` - ${JSON.stringify(e.error)}`;
+                        } catch(err){}
+                    }
+                    console.error(chalk.red(`OpenRouter Request Error: ${errMsg}`));
+                    return `Error: ${errMsg}`;
+                }
+
+                let chunkResponse = '';
+                let toolCalls = [];
+
+                for await (const chunk of stream) {
+                    const delta = chunk.choices[0]?.delta;
+
+                    if (delta?.content) {
+                        if (spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
+                        if (!this.config.useMarkedTerminal) {
+                            if (this.config.isApiMode && this.onChunk) {
+                                this.onChunk(delta.content);
+                            } else {
+                                process.stdout.write(chalk.cyan(delta.content));
+                            }
+                        }
+                        chunkResponse += delta.content;
+                        finalResponse += delta.content;
+                    }
+
+                    if (delta?.tool_calls) {
+                        if (spinner.isSpinning) spinner.stop();
+                        for (const tc of delta.tool_calls) {
+                            if (tc.index === undefined) continue;
+                            if (!toolCalls[tc.index]) {
+                                toolCalls[tc.index] = { id: tc.id, type: 'function', function: { name: tc.function?.name || '', arguments: '' } };
+                            }
+                            if (tc.function?.name && !toolCalls[tc.index].function.name) {
+                                toolCalls[tc.index].function.name = tc.function.name;
+                            }
+                            if (tc.function?.arguments) {
+                                toolCalls[tc.index].function.arguments += tc.function.arguments;
+                                if (!spinner.isSpinning) {
+                                    spinner = ora({ text: `Generating ${chalk.yellow(toolCalls[tc.index].function.name)} (${toolCalls[tc.index].function.arguments.length} bytes)...`, color: 'yellow', stream: process.stdout }).start();
+                                } else {
+                                    spinner.text = `Generating ${chalk.yellow(toolCalls[tc.index].function.name)} (${toolCalls[tc.index].function.arguments.length} bytes)...`;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (spinner.isSpinning) spinner.stop();
+
+                if (chunkResponse) {
+                    if (this.config.useMarkedTerminal) printMarkdown(chunkResponse);
+                    this.messages.push({ role: 'assistant', content: chunkResponse });
+                }
+
+                toolCalls = toolCalls.filter(Boolean);
+
+                if (toolCalls.length === 0) {
+                    console.log();
+                    break;
+                }
+
+                this.messages.push({
+                    role: 'assistant',
+                    tool_calls: toolCalls,
+                    content: chunkResponse || null
+                });
+
+                for (const call of toolCalls) {
+                    if (this.config.isApiMode && this.onToolStart) {
+                        this.onToolStart(call.function.name);
+                    }
+                    console.log(chalk.yellow(`\n[Banana Calling Tool: ${call.function.name}]`));
+                    let args = {};
+                    try {
+                        args = JSON.parse(call.function.arguments);
+                    } catch (e) { }
+
+                    const res = await executeTool(call.function.name, args, this.config);
+                    if (this.config.isApiMode && this.onToolEnd) {
+                        this.onToolEnd(res);
+                    }
+                    if (this.config.debug) {
+                        console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
+                    }
+                    console.log(chalk.yellow(`[Tool Result Received]\n`));
+
+                    this.messages.push({
+                        role: 'tool',
+                        tool_call_id: call.id,
+                        content: typeof res === 'string' ? res : JSON.stringify(res)
+                    });
+                }
+
+                spinner = ora({ text: 'Processing tool results...', color: 'yellow', stream: process.stdout }).start();
+            }
+
+            return finalResponse;
+        } catch (err) {
+            if (spinner && spinner.isSpinning) spinner.stop();
+            console.error(chalk.red(`OpenRouter Runtime Error: ${err.message}`));
+            return `Error: ${err.message}`;
+        }
+    }
+}