@banaxi/banana-code 1.4.0 → 1.5.0

package/README.md

@@ -49,13 +49,15 @@ While tools like Cursor provide great GUI experiences, Banana Code is built for
 
 ## ✨ Key Features
 
-- **Multi-Provider Support**: Switch between **Google Gemini**, **Anthropic Claude**, **OpenAI**, **Ollama Cloud**, and **Ollama (Local)** effortlessly.
+- **Multi-Provider Support**: Switch between **Google Gemini**, **Anthropic Claude**, **OpenAI**, **Mistral AI**, **Ollama Cloud**, and **Ollama (Local)** effortlessly.
+- **Model Context Protocol (MCP)**: Connect Banana Code to any community-built MCP server (like SQLite, GitHub, Google Maps) to give your AI infinite new superpowers via `/beta`.
 - **Plan & Agent Modes**: Use `/agent` for instant execution, or `/plan` to make the AI draft a step-by-step implementation plan for your approval before it touches any code.
+- **Hierarchical Sub-Agents**: The main AI can spawn specialized "sub-agents" (Researchers, Coders, Reviewers) to handle complex tasks without polluting your main chat history.
 - **Self-Healing Loop**: If the AI runs a command (like running tests) and it fails, Banana Code automatically feeds the error trace back to the AI so it can fix its own code.
 - **Agent Skills**: Teach your AI specialized workflows. Drop a `SKILL.md` file in your config folder, and the AI will automatically activate it when relevant.
-- **Smart Context**: Use `@file/path.js` to instantly inject file contents into your prompt, or use `/settings` to auto-feed your entire workspace structure (respecting `.gitignore`).
+- **Smart Context & Pruning**: Use `@file/path.js` to instantly inject file contents, auto-feed your workspace, and use `/clean` to instantly compress long chat histories to save tokens.
 - **Web Research**: Deep integration with DuckDuckGo APIs and Scrapers to give the AI real-time access to the internet.
-- **Persistent Sessions**: All chats are saved to `~/.config/banana-code/chats/`. Resume any session with a single command.
+- **Persistent Sessions**: All chats are auto-titled and saved. Use `/chats` for a fully interactive menu to resume any past session.
 - **Syntax Highlighting**: Beautiful, readable markdown output with syntax coloring directly in your terminal.
 
 ## 🚀 Installation
@@ -91,7 +93,14 @@ banana --resume <uuid>
 
 ### In-App Commands
 While in a chat, use these special commands:
+- `/provider`: Switch AI provider (gemini, claude, openai, mistral, ollama_cloud, ollama).
 - `/model`: Switch the active AI model on the fly.
+- `/chats`: Open an interactive menu to view and resume past auto-titled chat sessions.
+- `/clean`: Compress your current chat history into a dense summary to save tokens.
+- `/context`: View your current message count and estimated token usage.
+- `/settings`: Toggle UI features like syntax highlighting and auto-workspace feeding.
+- `/plan` & `/agent`: Toggle between Plan & Execute mode and standard Agent mode.
+- `/beta`: Enable experimental features like MCP Support and Sub-Agents.
 - `/clear`: Clear the current chat history.
 - `/exit` or `CTRL+D`: Save and exit the session.
 
@@ -126,6 +135,26 @@ description: Use this skill whenever you are asked to build or edit a React comp
 ```
 3. Type `/skills` in Banana Code to verify it loaded. The AI will now follow these rules automatically!
 
+### 🔌 Model Context Protocol (MCP) Support
+Banana Code supports the open standard [Model Context Protocol](https://modelcontextprotocol.io/), allowing you to plug in community-built servers to give your AI access to your databases, GitHub, Slack, Google Maps, and more.
+
+1. Enable **MCP Support** in the `/beta` menu.
+2. Create a configuration file at `~/.config/banana-code/mcp.json`.
+3. Add your servers. For example, to add the "fetch" and "math" tools using the test server:
+
+```json
+{
+  "mcpServers": {
+    "everything": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-everything"]
+    }
+  }
+}
+```
+
+Restart Banana Code, and the AI will instantly know how to use these new tools natively!
+
 ## 🔐 Privacy & Security
 
 Banana Code is built with transparency in mind:

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@banaxi/banana-code",
-    "version": "1.4.0",
+    "version": "1.5.0",
     "description": "🍌 BananaCode",
     "keywords": [
         "banana",
@@ -29,6 +29,7 @@
         "@anthropic-ai/sdk": "^0.36.1",
         "@google/generative-ai": "^0.21.0",
         "@inquirer/prompts": "^7.2.3",
+        "@modelcontextprotocol/sdk": "^1.28.0",
         "@openai/codex": "^0.117.0",
         "chalk": "^5.4.1",
         "diff": "^8.0.4",

package/src/config.js

@@ -85,7 +85,7 @@ export async function setupProvider(provider, config = {}) {
             message: 'Select a Mistral model:',
             choices,
             loop: false,
-            pageSize: Math.max(choices.length, 15)
+            pageSize: 10
         });
 
         if (selectedModel === 'CUSTOM_ID') {

package/src/index.js

@@ -15,10 +15,12 @@ import { MistralProvider } from './providers/mistral.js';
 import { loadSession, saveSession, generateSessionId, getLatestSessionId, listSessions } from './sessions.js';
 import { printMarkdown } from './utils/markdown.js';
 import { estimateConversationTokens } from './utils/tokens.js';
+import { mcpManager } from './utils/mcp.js';
 
 let config;
 let providerInstance;
 let currentSessionId;
+let currentSessionTitle = null;
 const commandHistory = [];
 let historyIndex = -1;
 let currentInputSaved = '';
@@ -107,7 +109,7 @@ async function handleSlashCommand(command) {
                         message: 'Select a model:',
                         choices: finalChoices,
                         loop: false,
-                        pageSize: Math.max(finalChoices.length, 15)
+                        pageSize: 10
                     });
 
                     if (newModel === 'CUSTOM_ID') {
@@ -244,6 +246,12 @@ async function handleSlashCommand(command) {
                 checked: (config.betaTools || []).includes('clean_command')
             });
 
+            choices.push({
+                name: 'MCP Support (Model Context Protocol)',
+                value: 'mcp_support',
+                checked: (config.betaTools || []).includes('mcp_support')
+            });
+
             if (choices.length === 0) {
                 console.log(chalk.yellow("No beta features available."));
                 break;
@@ -271,6 +279,12 @@ async function handleSlashCommand(command) {
                 }
             }
 
+            if (enabledBetaTools.includes('mcp_support') && !(config.betaTools || []).includes('mcp_support')) {
+                await mcpManager.init();
+            } else if (!enabledBetaTools.includes('mcp_support') && (config.betaTools || []).includes('mcp_support')) {
+                await mcpManager.cleanup();
+            }
+
             config.betaTools = enabledBetaTools;
             await saveConfig(config);
             if (providerInstance) {
@@ -375,12 +389,39 @@ async function handleSlashCommand(command) {
             if (sessions.length === 0) {
                 console.log(chalk.yellow("No saved chat sessions found."));
             } else {
-                console.log(chalk.cyan.bold("\nRecent Chat Sessions:"));
-                sessions.forEach((s, i) => {
-                    const active = s.uuid === currentSessionId ? chalk.green(' (active)') : '';
-                    console.log(chalk.gray(`${i + 1}. [${s.updatedAt}] ${s.uuid.slice(0, 8)}... (${s.provider}/${s.model})${active}`));
+                const { select: chatSelect } = await import('@inquirer/prompts');
+                const choices = sessions.map(s => {
+                    const active = s.uuid === currentSessionId ? ' (active)' : '';
+                    const date = new Date(s.updatedAt).toLocaleString();
+                    const titleText = s.title ? `"${s.title}"` : s.uuid.slice(0, 8) + '...';
+                    return {
+                        name: `${titleText} - ${date} (${s.provider}/${s.model})${active}`,
+                        value: s.uuid
+                    };
+                });
+                
+                const selectedSessionId = await chatSelect({
+                    message: 'Select a chat session to resume:',
+                    choices: choices,
+                    pageSize: 10,
+                    loop: false
                 });
-                console.log(chalk.gray("\nTo resume a chat, restart with: banana --resume <uuid>\n"));
+
+                if (selectedSessionId && selectedSessionId !== currentSessionId) {
+                    const session = await loadSession(selectedSessionId);
+                    if (session) {
+                        currentSessionId = session.uuid;
+                        currentSessionTitle = session.title || null;
+                        config.provider = session.provider;
+                        config.model = session.model;
+                        providerInstance = createProvider();
+                        if (providerInstance.messages !== undefined) {
+                            providerInstance.messages = session.messages;
+                        }
+                        playHistory(session);
+                        console.log(chalk.green(`Resumed session: ${currentSessionTitle || currentSessionId} (${session.provider}/${session.model})\n`));
+                    }
+                }
             }
             break;
         case '/help':
@@ -430,6 +471,75 @@ function padLine(text, width) {
     return text + ' '.repeat(pad);
 }
 
+function playHistory(session) {
+    process.stdout.write('\x1bc'); // Clear screen
+    console.log(chalk.yellow.bold("🍌 Banana Code — Peeling the project..."));
+    console.log(chalk.gray("-------------------------------------------"));
+    for (const msg of session.messages) {
+        if (msg.role === 'system') continue;
+
+        if (session.provider === 'gemini') {
+            if (msg.role === 'user') {
+                if (msg.parts[0]?.text) console.log(`${chalk.yellow('🍌 >')} ${msg.parts[0].text}`);
+                else if (msg.parts[0]?.functionResponse) {
+                    console.log(chalk.yellow(`[Tool Result Received]`));
+                }
+            } else if (msg.role === 'model') {
+                msg.parts.forEach(p => {
+                    if (p.text) {
+                        if (config.useMarkedTerminal) printMarkdown(p.text);
+                        else process.stdout.write(chalk.cyan(p.text));
+                    }
+                    if (p.functionCall) console.log(chalk.yellow(`\n[Banana Calling Tool: ${p.functionCall.name}]`));
+                });
+                console.log();
+            }
+        } else if (session.provider === 'claude') {
+            if (msg.role === 'user') {
+                if (typeof msg.content === 'string') console.log(`${chalk.yellow('🍌 >')} ${msg.content}`);
+                else {
+                    msg.content.forEach(c => {
+                        if (c.type === 'tool_result') console.log(chalk.yellow(`[Tool Result Received]`));
+                    });
+                }
+            } else if (msg.role === 'assistant') {
+                if (typeof msg.content === 'string') {
+                    if (config.useMarkedTerminal) printMarkdown(msg.content);
+                    else process.stdout.write(chalk.cyan(msg.content));
+                } else {
+                    msg.content.forEach(c => {
+                        if (c.type === 'text') {
+                            if (config.useMarkedTerminal) printMarkdown(c.text);
+                            else process.stdout.write(chalk.cyan(c.text));
+                        }
+                        if (c.type === 'tool_use') console.log(chalk.yellow(`\n[Banana Calling Tool: ${c.name}]`));
+                    });
+                }
+                console.log();
+            }
+        } else {
+            // OpenAI, Ollama, Mistral
+            if (msg.role === 'user') {
+                console.log(`${chalk.yellow('🍌 >')} ${msg.content}`);
+            } else if (msg.role === 'assistant' || msg.role === 'output_text') {
+                if (msg.content) {
+                    if (config.useMarkedTerminal) printMarkdown(msg.content);
+                    else process.stdout.write(chalk.cyan(msg.content));
+                }
+                if (msg.tool_calls) {
+                    msg.tool_calls.forEach(tc => {
+                        const name = tc.function ? tc.function.name : tc.name;
+                        console.log(chalk.yellow(`\n[Banana Calling Tool: ${name}]`));
+                    });
+                }
+                console.log();
+            } else if (msg.role === 'tool') {
+                console.log(chalk.yellow(`[Tool Result Received]`));
+            }
+        }
+    }
+}
+
 let lastPromptRows = 1;
 
 function drawPromptBox(inputText, cursorPos) {
@@ -598,6 +708,7 @@ function promptUser() {
                 process.stdout.write(`\x1b[${moveDown}B\x1b[2K\x1b[1B\x1b[2K\x1b[1G\n`);
                 console.log(chalk.yellow(`\nTo resume this session: node bin/banana.js --resume ${currentSessionId}`));
                 console.log(chalk.yellow("🍌 Bye BananaCode. See ya!"));
+                mcpManager.cleanup();
                 process.exit(0);
             }
         };
@@ -714,6 +825,10 @@ async function main() {
         config = await loadConfig();
         await runStartup();
 
+        if (config.betaTools && config.betaTools.includes('mcp_support')) {
+            await mcpManager.init();
+        }
+
         const resumeIdx = process.argv.indexOf('--resume');
         if (resumeIdx !== -1) {
             let resumeId = process.argv[resumeIdx + 1];
@@ -725,78 +840,15 @@ async function main() {
                 const session = await loadSession(resumeId);
                 if (session) {
                     currentSessionId = session.uuid;
+                    currentSessionTitle = session.title || null;
                     config.provider = session.provider;
                     config.model = session.model;
                     providerInstance = createProvider();
                     if (providerInstance.messages !== undefined) {
                         providerInstance.messages = session.messages;
                     }
-                    console.log(chalk.green(`Resumed session: ${currentSessionId} (${session.provider}/${session.model})\n`));
-
-                    // Playback history
-                    for (const msg of session.messages) {
-                        if (msg.role === 'system') continue;
-
-                        if (config.provider === 'gemini') {
-                            if (msg.role === 'user') {
-                                if (msg.parts[0]?.text) console.log(`${chalk.yellow('🍌 >')} ${msg.parts[0].text}`);
-                                else if (msg.parts[0]?.functionResponse) {
-                                    console.log(chalk.yellow(`[Tool Result Received]`));
-                                }
-                            } else if (msg.role === 'model') {
-                                msg.parts.forEach(p => {
-                                    if (p.text) {
-                                        if (config.useMarkedTerminal) printMarkdown(p.text);
-                                        else process.stdout.write(chalk.cyan(p.text));
-                                    }
-                                    if (p.functionCall) console.log(chalk.yellow(`\n[Banana Calling Tool: ${p.functionCall.name}]`));
-                                });
-                                console.log();
-                            }
-                        } else if (config.provider === 'claude') {
-                            if (msg.role === 'user') {
-                                if (typeof msg.content === 'string') console.log(`${chalk.yellow('🍌 >')} ${msg.content}`);
-                                else {
-                                    msg.content.forEach(c => {
-                                        if (c.type === 'tool_result') console.log(chalk.yellow(`[Tool Result Received]`));
-                                    });
-                                }
-                            } else if (msg.role === 'assistant') {
-                                if (typeof msg.content === 'string') {
-                                    if (config.useMarkedTerminal) printMarkdown(msg.content);
-                                    else process.stdout.write(chalk.cyan(msg.content));
-                                } else {
-                                    msg.content.forEach(c => {
-                                        if (c.type === 'text') {
-                                            if (config.useMarkedTerminal) printMarkdown(c.text);
-                                            else process.stdout.write(chalk.cyan(c.text));
-                                        }
-                                        if (c.type === 'tool_use') console.log(chalk.yellow(`\n[Banana Calling Tool: ${c.name}]`));
-                                    });
-                                }
-                                console.log();
-                            }
-                        } else {
-                            // OpenAI, Ollama
-                            if (msg.role === 'user') {
-                                console.log(`${chalk.yellow('🍌 >')} ${msg.content}`);
-                            } else if (msg.role === 'assistant' || msg.role === 'output_text') {
-                                if (msg.content) {
-                                    if (config.useMarkedTerminal) printMarkdown(msg.content);
-                                    else process.stdout.write(chalk.cyan(msg.content));
-                                }
-                                if (msg.tool_calls) {
-                                    msg.tool_calls.forEach(tc => {
-                                        const name = tc.function ? tc.function.name : tc.name;
-                                        console.log(chalk.yellow(`\n[Banana Calling Tool: ${name}]`));
-                                    });
-                                }
-                                console.log();
-                            } else if (msg.role === 'tool') {
-                                console.log(chalk.yellow(`[Tool Result Received]`));
-                            }
-                        }
-                    }
+                    playHistory(session);
+                    console.log(chalk.green(`Resumed session: ${currentSessionTitle || currentSessionId} (${session.provider}/${session.model})\n`));
                 } else {
                     console.log(chalk.red(`Could not find session ${resumeId}. Starting fresh.`));
                 }
@@ -867,11 +919,53 @@ async function main() {
                 process.stdout.write(chalk.cyan('✦ '));
                 await providerInstance.sendMessage(finalInput);
                 console.log(); // Extra newline after AI response
+
+                // Auto-generate title every 10 messages (or on the 3rd message)
+                const msgLen = providerInstance.messages ? providerInstance.messages.length : 0;
+                if (!currentSessionTitle && msgLen >= 3 || msgLen > 0 && msgLen % 10 === 0) {
+                    const titleSpinner = ora({ text: 'Generating chat title...', color: 'gray', stream: process.stdout }).start();
+                    try {
+                        // Temporarily disable terminal formatting and debug for the title request
+                        const originalUseMarked = config.useMarkedTerminal;
+                        const originalDebug = config.debug;
+                        config.useMarkedTerminal = false;
+                        config.debug = false;
+                        
+                        // Temporarily silence stdout so the model's streaming text doesn't bleed into the terminal
+                        const originalStdoutWrite = process.stdout.write;
+                        process.stdout.write = () => {};
+
+                        const titlePrompt = "SYSTEM: You are a title generator. Based on this conversation, provide a VERY SHORT (2-5 words) title. Reply ONLY with the title string, no quotes or formatting.";
+                        
+                        // Use a temporary provider instance so we never pollute the main history array
+                        const titleProvider = createProvider();
+                        // Deep copy messages so the AI knows the context, but modifications don't leak back
+                        titleProvider.messages = JSON.parse(JSON.stringify(providerInstance.messages));
+                        
+                        let title = '';
+                        try {
+                            title = await titleProvider.sendMessage(titlePrompt);
+                        } finally {
+                            // Always restore stdout even if it crashes
+                            process.stdout.write = originalStdoutWrite;
+                        }
+                        
+                        currentSessionTitle = title.replace(/['"]/g, '').trim();
+
+                        config.useMarkedTerminal = originalUseMarked;
+                        config.debug = originalDebug;
+                    } catch (e) {
+                        // ignore title gen errors
+                    }
+                    titleSpinner.stop();
+                }
+
                 // Save session after AI message
                 await saveSession(currentSessionId, {
                     provider: config.provider,
                     model: config.model || providerInstance.modelName,
-                    messages: providerInstance.messages
+                    messages: providerInstance.messages,
+                    title: currentSessionTitle
                 });
             }
         }

package/src/providers/gemini.js

@@ -1,4 +1,4 @@
-import { getAvailableTools, executeTool } from '../tools/registry.js';
+import { getAvailableTools, executeTool, sanitizeSchemaForStrictAPIs } from '../tools/registry.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import { getSystemPrompt } from '../prompt.js';
@@ -13,7 +13,7 @@ export class GeminiProvider {
         this.tools = getAvailableTools(config).map(t => ({
             name: t.name,
             description: t.description,
-            parameters: t.parameters
+            parameters: sanitizeSchemaForStrictAPIs(t.parameters)
         }));
         this.systemPrompt = getSystemPrompt(config);
     }

package/src/providers/ollama.js

@@ -1,4 +1,4 @@
-import { getAvailableTools, executeTool } from '../tools/registry.js';
+import { getAvailableTools, executeTool, sanitizeSchemaForStrictAPIs } from '../tools/registry.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import { getSystemPrompt } from '../prompt.js';
@@ -15,7 +15,7 @@ export class OllamaProvider {
             function: {
                 name: t.name,
                 description: t.description,
-                parameters: t.parameters
+                parameters: sanitizeSchemaForStrictAPIs(t.parameters)
             }
         }));
         this.URL = 'http://localhost:11434/api/chat';
@@ -42,13 +42,14 @@ export class OllamaProvider {
                     body: JSON.stringify({
                         model: this.modelName,
                         messages: this.messages,
-                        tools: this.tools,
+                        tools: this.tools.length > 0 ? this.tools : undefined,
                         stream: false
                     })
                 });
 
                 if (!response.ok) {
-                    throw new Error(`HTTP error! status: ${response.status}`);
+                    const errorText = await response.text();
+                    throw new Error(`HTTP error! status: ${response.status}, details: ${errorText}`);
                 }
 
                 const data = await response.json();
@@ -76,7 +77,7 @@ export class OllamaProvider {
                     const fn = call.function;
                     console.log(chalk.yellow(`\n[Banana Calling Tool: ${fn.name}]`));
 
-                    let res = await executeTool(fn.name, fn.arguments);
+                    let res = await executeTool(fn.name, fn.arguments, this.config);
                     if (this.config.debug) {
                         console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                     }
@@ -84,6 +85,7 @@ export class OllamaProvider {
 
                     this.messages.push({
                         role: 'tool',
+                        tool_call_id: call.id || 'mcp_call',
                         content: typeof res === 'string' ? res : JSON.stringify(res)
                     });
                 }

package/src/providers/ollamaCloud.js

@@ -1,4 +1,4 @@
-import { getAvailableTools, executeTool } from '../tools/registry.js';
+import { getAvailableTools, executeTool, sanitizeSchemaForStrictAPIs } from '../tools/registry.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import { getSystemPrompt } from '../prompt.js';
@@ -16,7 +16,7 @@ export class OllamaCloudProvider {
             function: {
                 name: t.name,
                 description: t.description,
-                parameters: t.parameters
+                parameters: sanitizeSchemaForStrictAPIs(t.parameters)
             }
         }));
         this.URL = 'https://ollama.com/api/chat';
@@ -60,20 +60,26 @@ export class OllamaCloudProvider {
                 const reader = response.body.getReader();
                 const decoder = new TextDecoder();
                 let currentChunkResponse = '';
-                let lastMessageObj = null;
+                let lastMessageObj = { role: 'assistant', content: '' };
+                let lineBuffer = '';
 
                 while (true) {
                     const { done, value } = await reader.read();
                     if (done) break;
 
                     const chunk = decoder.decode(value, { stream: true });
-                    const lines = chunk.split('\n').filter(l => l.trim() !== '');
+                    lineBuffer += chunk;
+                    const lines = lineBuffer.split('\n');
+                    lineBuffer = lines.pop(); // Keep partial line
 
                     for (const line of lines) {
+                        if (!line.trim()) continue;
                         try {
                             const data = JSON.parse(line);
                             if (data.message) {
-                                lastMessageObj = data.message;
+                                if (data.message.tool_calls) {
+                                    lastMessageObj.tool_calls = data.message.tool_calls;
+                                }
                                 if (data.message.content) {
                                     const content = data.message.content;
                                     if (spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
@@ -84,22 +90,37 @@ export class OllamaCloudProvider {
                                     finalResponse += content;
                                 }
                             }
-                        } catch (e) {
-                            // Ignore partial JSON chunks
-                        }
+                        } catch (e) { }
                     }
                 }
 
+                if (lineBuffer.trim()) {
+                    try {
+                        const data = JSON.parse(lineBuffer);
+                        if (data.message) {
+                            if (data.message.tool_calls) {
+                                lastMessageObj.tool_calls = data.message.tool_calls;
+                            }
+                            if (data.message.content) {
+                                const content = data.message.content;
+                                if (spinner.isSpinning && !this.config.useMarkedTerminal) spinner.stop();
+                                if (!this.config.useMarkedTerminal) {
+                                    process.stdout.write(chalk.cyan(content));
+                                }
+                                currentChunkResponse += content;
+                                finalResponse += content;
+                            }
+                        }
+                    } catch (e) { }
+                }
+
                 if (spinner.isSpinning) spinner.stop();
 
                 if (currentChunkResponse && this.config.useMarkedTerminal) {
                     printMarkdown(currentChunkResponse);
                 }
 
-                if (!lastMessageObj) {
-                    throw new Error("Empty response from Ollama Cloud");
-                }
-
+                lastMessageObj.content = currentChunkResponse || '';
                 this.messages.push(lastMessageObj);
 
                 if (!lastMessageObj.tool_calls || lastMessageObj.tool_calls.length === 0) {
@@ -119,6 +140,7 @@ export class OllamaCloudProvider {
 
                     this.messages.push({
                         role: 'tool',
+                        tool_call_id: call.id || 'mcp_call', // Use ID from call if available
                         content: typeof res === 'string' ? res : JSON.stringify(res)
                     });
                 }

package/src/sessions.js

@@ -21,6 +21,7 @@ export async function saveSession(uuid, data) {
     const filePath = path.join(CHATS_DIR, `${uuid}.json`);
     const sessionData = {
         uuid,
+        title: data.title || null,
         updatedAt: new Date().toISOString(),
         provider: data.provider,
         model: data.model,

package/src/tools/registry.js

@@ -9,6 +9,7 @@ import { duckDuckGoScrape } from './duckDuckGoScrape.js';
 import { patchFile } from './patchFile.js';
 import { activateSkill } from './activateSkill.js';
 import { delegateTask } from './delegateTask.js';
+import { mcpManager } from '../utils/mcp.js';
 
 export const TOOLS = [
     {
@@ -173,15 +174,61 @@ export const TOOLS = [
 ];
 
 export function getAvailableTools(config = {}) {
-    return TOOLS.filter(tool => {
+    let available = TOOLS.filter(tool => {
         if (tool.beta) {
             return config.betaTools && config.betaTools.includes(tool.name);
         }
         return true;
     });
+
+    // Add MCP tools if enabled in beta
+    if (config.betaTools && config.betaTools.includes('mcp_support')) {
+        const mcpTools = mcpManager.getTools().map(t => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.inputSchema,
+            isMcp: true
+        }));
+        available = available.concat(mcpTools);
+    }
+
+    return available;
+}
+
+/**
+ * Some providers (Gemini, Ollama) are extremely strict about JSON Schema.
+ * They will throw a 400 if they see "additionalProperties", "$schema", or other unknown fields.
+ */
+export function sanitizeSchemaForStrictAPIs(schema) {
+    if (!schema || typeof schema !== 'object') return schema;
+
+    const sanitized = Array.isArray(schema) ? [] : {};
+
+    for (const [key, value] of Object.entries(schema)) {
+        // Skip keys that strict APIs don't support
+        if (key === 'additionalProperties' || key === '$schema' || key === 'const') {
+            continue;
+        }
+
+        if (typeof value === 'object' && value !== null) {
+            sanitized[key] = sanitizeSchemaForStrictAPIs(value);
+        } else {
+            sanitized[key] = value;
+        }
+    }
+
+    return sanitized;
 }
 
 export async function executeTool(name, args, config) {
+    // Check if it's an MCP tool first
+    if (config.betaTools && config.betaTools.includes('mcp_support')) {
+        const mcpTools = mcpManager.getTools();
+        if (mcpTools.some(t => t.name === name)) {
+            return await mcpManager.callTool(name, args);
+        }
+    }
+
     switch (name) {
         case 'execute_command': return await execCommand(args);
         case 'read_file': return await readFile(args);

package/src/utils/mcp.js

@@ -0,0 +1,96 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import chalk from 'chalk';
+
+const MCP_CONFIG_FILE = path.join(os.homedir(), '.config', 'banana-code', 'mcp.json');
+
+class MCPManager {
+    constructor() {
+        this.clients = new Map();
+        this.tools = [];
+    }
+
+    async init() {
+        try {
+            const configData = await fs.readFile(MCP_CONFIG_FILE, 'utf-8');
+            const config = JSON.parse(configData);
+            
+            if (!config.mcpServers) return;
+
+            console.log(chalk.cyan("\nInitializing MCP Servers..."));
+
+            for (const [serverName, serverConfig] of Object.entries(config.mcpServers)) {
+                try {
+                    const transport = new StdioClientTransport({
+                        command: serverConfig.command,
+                        args: serverConfig.args || [],
+                        env: { ...process.env, ...serverConfig.env }
+                    });
+
+                    const client = new Client(
+                        { name: "banana-code-client", version: "1.0.0" },
+                        { capabilities: { tools: {} } }
+                    );
+
+                    await client.connect(transport);
+                    this.clients.set(serverName, client);
+
+                    const response = await client.listTools();
+                    
+                    // Map MCP tools to our internal format
+                    const mappedTools = response.tools.map(tool => ({
+                        ...tool,
+                        serverName, // Track which server this belongs to
+                        isMcp: true
+                    }));
+
+                    this.tools.push(...mappedTools);
+                    console.log(chalk.green(`  ✔ Connected to ${serverName} (${response.tools.length} tools discovered)`));
+                } catch (err) {
+                    console.log(chalk.red(`  ✘ Failed to connect to ${serverName}: ${err.message}`));
+                }
+            }
+        } catch (err) {
+            if (err.code !== 'ENOENT') {
+                console.log(chalk.red(`Error loading MCP config: ${err.message}`));
+            } else {
+                // Create default empty config if not found
+                await fs.writeFile(MCP_CONFIG_FILE, JSON.stringify({ mcpServers: {} }, null, 2));
+            }
+        }
+    }
+
+    getTools() {
+        return this.tools;
+    }
+
+    async callTool(name, args) {
+        // Find which server has this tool
+        const tool = this.tools.find(t => t.name === name);
+        if (!tool) throw new Error(`MCP Tool ${name} not found`);
+
+        const client = this.clients.get(tool.serverName);
+        if (!client) throw new Error(`MCP Client for ${tool.serverName} not found`);
+
+        const result = await client.callTool({
+            name: name,
+            arguments: args
+        });
+
+        // MCP returns content array, we usually want the text from the first item
+        return result.content.map(c => c.text).join('\n');
+    }
+
+    async cleanup() {
+        for (const [name, client] of this.clients) {
+            try {
+                await client.close();
+            } catch (e) {}
+        }
+    }
+}
+
+export const mcpManager = new MCPManager();