@banaxi/banana-code 1.6.0 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@banaxi/banana-code",
-    "version": "1.6.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,12 +237,14 @@ 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' }
         ]
     });
 
     const config = await setupProvider(provider);
+    config.useMemory = true;
 
     await saveConfig(config);
     console.log(chalk.yellow.bold("\nYou're all peeled and ready. Type your first message!\n"));

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 = [
@@ -24,10 +24,11 @@ export const OLLAMA_CLOUD_MODELS = [
     { name: 'Kimi K2.5 (Cloud)', value: 'kimi-k2.5:cloud' },
     { name: 'Qwen 3.5 397B (Cloud)', value: 'qwen3.5:397b-cloud' },
     { name: 'DeepSeek V3.2 (Cloud)', value: 'deepseek-v3.2:cloud' },
-    { name: 'GLM-5 (Cloud)', value: 'glm-5:cloud' },
+    { name: 'GLM-5.1 (Cloud)', value: 'glm-5.1:cloud' },
     { name: 'MiniMax M2.7 (Cloud)', value: 'minimax-m2.7:cloud' },
     { name: 'Llama 3.3 70B (Cloud)', value: 'llama3.3:cloud' },
-    { name: 'Llama 3.1 405B (Cloud)', value: 'llama3.1:405b-cloud' }
+    { name: 'Llama 3.1 405B (Cloud)', value: 'llama3.1:405b-cloud' },
+    { name: 'Gemma 4 31B (Cheapest, Very Good Code)', value: 'gemma4:31b-cloud' }
 ];
 
 export const MISTRAL_MODELS = [

package/src/index.js

@@ -3,7 +3,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { loadConfig, saveConfig, setupProvider } from './config.js';
 import { runStartup } from './startup.js';
-import { getSessionPermissions } from './permissions.js';
+import { getSessionPermissions, setYoloMode } from './permissions.js';
 
 import { GeminiProvider } from './providers/gemini.js';
 import { ClaudeProvider } from './providers/claude.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) {
@@ -325,7 +358,7 @@ async function handleSlashCommand(command) {
                     {
                         name: 'Enable Global AI Memory (Allows AI to save facts persistently)',
                         value: 'useMemory',
-                        checked: config.useMemory || false
+                        checked: config.useMemory !== false
                     }
                 ]
             });
@@ -375,6 +408,8 @@ async function handleSlashCommand(command) {
             break;
         case '/plan':
             config.planMode = true;
+            config.askMode = false;
+            config.securityMode = false;
             await saveConfig(config);
             if (providerInstance) {
                 const savedMessages = providerInstance.messages;
@@ -385,8 +420,52 @@ async function handleSlashCommand(command) {
             }
             console.log(chalk.magenta(`Plan mode enabled. For significant changes, the AI will now propose an implementation plan before writing code.`));
             break;
+        case '/ask':
+            config.askMode = true;
+            config.planMode = false;
+            config.securityMode = false;
+            await saveConfig(config);
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider();
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
+            console.log(chalk.blue(`Ask mode enabled. The AI will only answer questions and cannot edit files.`));
+            break;
+        case '/security':
+            config.securityMode = true;
+            config.askMode = false;
+            config.planMode = false;
+            await saveConfig(config);
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider();
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
+            console.log(chalk.red(`Security mode enabled. The AI will look for and help fix vulnerabilities.`));
+            console.log(chalk.yellow(`Disclaimer: Please only use this mode for defensive purposes to secure your own code, and do not use the identified vulnerabilities maliciously.`));
+            break;
+        case '/yolo':
+            config.yolo = !config.yolo;
+            setYoloMode(config.yolo);
+            await saveConfig(config);
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider();
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
+            console.log(config.yolo ? chalk.bgRed.white.bold('\n ⚠️ YOLO MODE ENABLED - All permission requests will be auto-accepted! \n') : chalk.green('\nYOLO mode disabled.\n'));
+            break;
         case '/agent':
             config.planMode = false;
+            config.askMode = false;
+            config.securityMode = false;
             await saveConfig(config);
             if (providerInstance) {
                 const savedMessages = providerInstance.messages;
@@ -438,7 +517,7 @@ async function handleSlashCommand(command) {
             }
             break;
         case '/memory':
-            if (!config.useMemory) {
+            if (config.useMemory === false) {
                 console.log(chalk.yellow("Global AI Memory is disabled. Enable it in /settings first."));
                 break;
             }
@@ -525,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
@@ -539,6 +618,7 @@ Available commands:
   /init            - Generate a BANANA.md project summary file
   /plan            - Enable Plan Mode (AI proposes a plan for big changes)
   /agent           - Enable Agent Mode (default, AI edits directly)
+  /yolo            - Toggle YOLO mode (skip all permission requests)
   /debug           - Toggle debug mode (show tool results)
   /help            - Show all commands
   /exit            - Quit Banana Code
@@ -667,7 +747,10 @@ function drawPromptBox(inputText, cursorPos) {
     // Redraw status bar and separator (they are always below the prompt)
     const modelDisplay = providerInstance ? providerInstance.modelName : (config.model || 'unknown');
     const providerDisplay = config.provider.toUpperCase();
-    const modeDisplay = config.planMode ? chalk.magenta('PLAN MODE') : chalk.green('AGENT MODE');
+    let modeDisplay = chalk.green('AGENT MODE');
+    if (config.askMode) modeDisplay = chalk.blue('ASK MODE');
+    else if (config.securityMode) modeDisplay = chalk.red('SECURITY MODE');
+    else if (config.planMode) modeDisplay = chalk.magenta('PLAN MODE');
     
     let tokenDisplay = '';
     if (config.showTokenCount && providerInstance) {
@@ -685,7 +768,8 @@ function drawPromptBox(inputText, cursorPos) {
         tokenDisplay = ` / Tokens: ${color(tokens.toLocaleString())}`;
     }
     
-    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)} / ${modeDisplay}${tokenDisplay}`;
+    const yoloDisplay = config.yolo ? chalk.bgRed.white.bold(' ⚠️ YOLO ') : '';
+    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)} / ${modeDisplay}${tokenDisplay}${yoloDisplay ? ' / ' + yoloDisplay : ''}`;
     const rightText = '/help for shortcuts ';
     const leftStripped = leftText.replace(/\x1b\[[0-9;]*m/g, '');
     const midPad = Math.max(0, width - leftStripped.length - rightText.length);
@@ -728,7 +812,10 @@ function drawPromptBoxInitial(inputText) {
     // Status bar: Current Provider / Model + right-aligned "/help for shortcuts"
     const modelDisplay = providerInstance ? providerInstance.modelName : (config.model || 'unknown');
     const providerDisplay = config.provider.toUpperCase();
-    const modeDisplay = config.planMode ? chalk.magenta('PLAN MODE') : chalk.green('AGENT MODE');
+    let modeDisplay = chalk.green('AGENT MODE');
+    if (config.askMode) modeDisplay = chalk.blue('ASK MODE');
+    else if (config.securityMode) modeDisplay = chalk.red('SECURITY MODE');
+    else if (config.planMode) modeDisplay = chalk.magenta('PLAN MODE');
     
     let tokenDisplay = '';
     if (config.showTokenCount && providerInstance) {
@@ -746,7 +833,8 @@ function drawPromptBoxInitial(inputText) {
         tokenDisplay = ` / Tokens: ${color(tokens.toLocaleString())}`;
     }
     
-    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)} / ${modeDisplay}${tokenDisplay}`;
+    const yoloDisplay = config.yolo ? chalk.bgRed.white.bold(' ⚠️ YOLO ') : '';
+    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)} / ${modeDisplay}${tokenDisplay}${yoloDisplay ? ' / ' + yoloDisplay : ''}`;
     const rightText = '/help for shortcuts ';
 
     const leftStripped = leftText.replace(/\x1b\[[0-9;]*m/g, '');
@@ -923,6 +1011,12 @@ function promptUser() {
 async function main() {
     try {
         config = await loadConfig();
+
+        if (process.argv.includes('--yolo')) {
+            config.yolo = true;
+        }
+        setYoloMode(config.yolo);
+
         await runStartup();
 
         if (config.betaTools && config.betaTools.includes('mcp_support')) {
@@ -933,7 +1027,16 @@ async function main() {
         if (apiIdx !== -1) {
             const portStr = process.argv[apiIdx + 1];
             const port = portStr && !portStr.startsWith('-') ? parseInt(portStr) : 3000;
-            await startApiServer(port, createProvider);
+
+            let host = '127.0.0.1';
+            const hostIdx = process.argv.indexOf('--host');
+            if (hostIdx !== -1 && process.argv[hostIdx + 1] && !process.argv[hostIdx + 1].startsWith('-')) {
+                host = process.argv[hostIdx + 1];
+            } else if (process.argv.includes('--expose')) {
+                host = '0.0.0.0';
+            }
+
+            await startApiServer(port, createProvider, host);
             return;
         }
 

package/src/permissions.js

@@ -4,6 +4,10 @@ import crypto from 'crypto';
 
 const sessionPermissions = new Set();
 
+export function setYoloMode(enabled) {
+    global.bananaYoloMode = !!enabled;
+}
+
 function wrapText(text, width) {
     const lines = [];
     for (let i = 0; i < text.length; i += width) {
@@ -13,6 +17,10 @@ function wrapText(text, width) {
 }
 
 export async function requestPermission(actionType, details) {
+    if (global.bananaYoloMode || process.argv.includes('--yolo')) {
+        return { allowed: true };
+    }
+
     const permKey = `allow_session_${actionType}`;
 
     if (sessionPermissions.has(permKey)) {

package/src/prompt.js

@@ -41,7 +41,7 @@ Always use tools when they would help. Be concise but thorough. `;
     } catch (e) {}
 
     // Load Global Memory
-    if (config.useMemory) {
+    if (config.useMemory !== false) {
         prompt += `\n\n# Global AI Memory\nYou have the ability to remember facts across ALL sessions and projects using the \`save_memory\` tool. If the user tells you their name, personal preferences, coding rules, or other information they might want to persist, feel free to use the \`save_memory\` tool so you can remember it in the future.\n`;
         
         try {
@@ -92,6 +92,26 @@ The user is operating in "Plan Mode".
 `;
     }
 
+    if (config.askMode) {
+        prompt += `
+[ASK MODE ENABLED]
+The user is operating in "Ask Mode".
+- You are strictly restricted to answering questions, explaining code, and providing information.
+- You MUST NOT make any changes to the codebase. Do NOT use tools that modify files or execute shell commands that change state (e.g. creating/deleting files, installing packages).
+- Use read-only tools like search_files, list_directory, read_file, and read-only execute_command (like running a test or git status) to gather information to answer the user's questions.
+`;
+    }
+
+    if (config.securityMode) {
+        prompt += `
+[SECURITY MODE ENABLED]
+The user is operating in "Security Mode".
+- Your primary objective is to find security vulnerabilities, misconfigurations, and bad practices in the codebase.
+- Act as a red-team auditor. Search for OWASP Top 10 vulnerabilities, leaked API keys, unsafe inputs, injection flaws, etc.
+- Provide detailed reports of any vulnerabilities found, including the file path, the affected lines, and suggestions for remediation.
+`;
+    }
+
     if (hasPatchTool) {
         prompt += `
 When editing existing files, PREFER using the 'patch_file' tool for surgical, targeted changes instead of 'write_file', especially for large files. This prevents accidental truncation and is much more efficient. Only use 'write_file' when creating new files or when making very extensive changes to a small file.`;

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}`;
+        }
+    }
+}

package/src/server.js

@@ -6,7 +6,7 @@ import chalk from 'chalk';
 import { loadConfig } from './config.js';
 import { listSessions, loadSession } from './sessions.js';
 
-export async function startApiServer(port = 3000, createProvider) {
+export async function startApiServer(port = 3000, createProvider, host = '127.0.0.1') {
     const app = express();
     const server = http.createServer(app);
     const wss = new WebSocketServer({ server });
@@ -140,8 +140,8 @@ export async function startApiServer(port = 3000, createProvider) {
         res.json({ status: 'running', provider: config.provider, model: config.model });
     });
 
-    server.listen(port, () => {
-        console.log(chalk.green.bold(`\n🍌 Banana Code API Server running at http://localhost:${port}`));
+    server.listen(port, host, () => {
+        console.log(chalk.green.bold(`\n🍌 Banana Code API Server running at http://${host}:${port}`));
         console.log(chalk.gray(`WebSocket streaming enabled on the same port.\n`));
     });
 }

package/src/tools/readManyFiles.js

@@ -0,0 +1,32 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { requestPermission } from '../permissions.js';
+
+export async function readManyFiles({ filepaths }) {
+    if (!Array.isArray(filepaths)) {
+        return 'Error: filepaths must be an array of strings.';
+    }
+
+    let results = [];
+    
+    // Request permission for all files. You could ask for them individually or batch them.
+    // Here we'll request them individually but sequentially.
+    for (const filepath of filepaths) {
+        const absPath = path.resolve(process.cwd(), filepath);
+        const perm = await requestPermission('Read File', filepath);
+        
+        if (!perm.allowed) {
+            results.push(`--- File: ${filepath} ---\nUser denied permission to read: ${filepath}\n`);
+            continue;
+        }
+
+        try {
+            const content = await fs.readFile(absPath, 'utf8');
+            results.push(`--- File: ${filepath} ---\n${content}\n`);
+        } catch (err) {
+            results.push(`--- File: ${filepath} ---\nError reading file: ${err.message}\n`);
+        }
+    }
+
+    return results.join('\n');
+}

package/src/tools/registry.js

@@ -1,5 +1,6 @@
 import { execCommand } from './execCommand.js';
 import { readFile } from './readFile.js';
+import { readManyFiles } from './readManyFiles.js';
 import { writeFile } from './writeFile.js';
 import { fetchUrl } from './fetchUrl.js';
 import { searchFiles } from './searchFiles.js';
@@ -36,6 +37,21 @@ export const TOOLS = [
             required: ['filepath']
         }
     },
+    {
+        name: 'read_many_files',
+        description: 'Read the contents of multiple files at once.',
+        parameters: {
+            type: 'object',
+            properties: {
+                filepaths: {
+                    type: 'array',
+                    description: 'List of file paths to read',
+                    items: { type: 'string' }
+                }
+            },
+            required: ['filepaths']
+        }
+    },
     {
         name: 'write_file',
         description: 'Write content to a file. Overwrites existing content.',
@@ -210,11 +226,15 @@ export const TOOLS = [
 
 export function getAvailableTools(config = {}) {
     let available = TOOLS.filter(tool => {
+        if (config.askMode) {
+            const forbiddenInAskMode = ['write_file', 'patch_file'];
+            if (forbiddenInAskMode.includes(tool.name)) return false;
+        }
         if (tool.beta) {
             return config.betaTools && config.betaTools.includes(tool.name);
         }
         if (tool.memoryFeature) {
-            return config.useMemory === true;
+            return config.useMemory !== false;
         }
         if (tool.settingsFeature) {
             // Default to true if not explicitly set to false
@@ -274,6 +294,7 @@ export async function executeTool(name, args, config) {
     switch (name) {
         case 'execute_command': return await execCommand(args);
         case 'read_file': return await readFile(args);
+        case 'read_many_files': return await readManyFiles(args);
         case 'write_file': return await writeFile(args);
         case 'fetch_url': return await fetchUrl(args);
         case 'search_files': return await searchFiles(args);