@banaxi/banana-code 1.1.0 → 1.3.0

package/README.md

@@ -41,14 +41,22 @@ Banana Code is a high-performance, terminal-based AI pair programmer. It combine
                                              #S#SSSSSS%%%?%%%%S
 ```
 
+## 🤔 Why Banana Code?
+While tools like Cursor provide great GUI experiences, Banana Code is built for developers who live in the terminal and want maximum flexibility. 
+- **No Vendor Lock-in**: Switch instantly between the best proprietary models (Gemini, Claude, OpenAI) and high-performance open-source models (Ollama Local, Ollama Cloud) mid-conversation.
+- **True Autonomy**: With Plan & Execute mode and Self-Healing Error Loops, Banana Code doesn't just suggest code; it tries, fails, reads the errors, and fixes its own mistakes automatically.
+- **Terminal Native**: It brings the power of full workspace awareness, web search, and surgical file patching directly to your CLI without forcing you to change your IDE.
+
 ## ✨ Key Features
 
-- **Multi-Provider Support**: Switch between **Google Gemini**, **Anthropic Claude**, **OpenAI**, and **Ollama (Local)** effortlessly.
-- **Interactive TUI**: A beautiful, minimal terminal interface with real-time feedback and progress indicators.
+- **Multi-Provider Support**: Switch between **Google Gemini**, **Anthropic Claude**, **OpenAI**, **Ollama Cloud**, and **Ollama (Local)** effortlessly.
+- **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.
+- **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`).
+- **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.
-- **Robust Tool System**: Banana Code can execute shell commands, read/write files, fetch URLs, and search your workspace.
-- **Security First**: A dedicated permission model ensures no tool is executed without your explicit approval.
-- **Keyless Playground**: Integration with OpenAI Codex for seamless, keyless access to GPT-4o and beyond.
+- **Syntax Highlighting**: Beautiful, readable markdown output with syntax coloring directly in your terminal.
 
 ## 🚀 Installation
 
@@ -96,6 +104,28 @@ Banana Code can assist you by:
 - **`search_files`**: Performing regex searches across your project.
 - **`list_directory`**: Exploring folder structures.
 
+### 🧠 Agent Skills
+Banana Code supports custom Agent Skills. Skills are like "onboarding guides" that teach the AI how to do specific tasks, use certain APIs, or follow your company's coding standards. 
+
+When the AI detects a task that matches a skill's description, it automatically activates the skill and loads its specialized instructions.
+
+**How to create a Skill:**
+1. Create a folder in your config directory: `~/.config/banana-code/skills/my-react-skill/`
+2. Create a `SKILL.md` file inside that folder using this exact format:
+
+```markdown
+---
+name: my-react-skill
+description: Use this skill whenever you are asked to build or edit a React component.
+---
+
+# React Guidelines
+- Always use functional components.
+- Always use Tailwind CSS for styling.
+- Do not use default exports.
+```
+3. Type `/skills` in Banana Code to verify it loaded. The AI will now follow these rules automatically!
+
 ## 🔐 Privacy & Security
 
 Banana Code is built with transparency in mind:

package/package.json

@@ -1,7 +1,19 @@
 {
     "name": "@banaxi/banana-code",
-    "version": "1.1.0",
+    "version": "1.3.0",
     "description": "🍌 BananaCode",
+    "keywords": [
+        "banana",
+        "ai",
+        "cli",
+        "agent",
+        "coding-assistant",
+        "terminal",
+        "gemini",
+        "claude",
+        "openai",
+        "ollama"
+    ],
     "type": "module",
     "license": "GPL-3.0-or-later",
     "bin": {

package/src/config.js

@@ -6,7 +6,7 @@ import { execSync } from 'child_process';
 import fsSync from 'fs';
 import chalk from 'chalk';
 
-import { GEMINI_MODELS, CLAUDE_MODELS, OPENAI_MODELS, CODEX_MODELS, OLLAMA_CLOUD_MODELS } from './constants.js';
+import { GEMINI_MODELS, CLAUDE_MODELS, OPENAI_MODELS, CODEX_MODELS, OLLAMA_CLOUD_MODELS, MISTRAL_MODELS } from './constants.js';
 
 const CONFIG_DIR = path.join(os.homedir(), '.config', 'banana-code');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
@@ -41,10 +41,10 @@ export async function setupProvider(provider, config = {}) {
             default: config.apiKey
         });
         config.model = await select({
-            message: 'Select a model:',
-            choices: OPENAI_MODELS
+            message: 'Select a Gemini model:',
+            choices: GEMINI_MODELS
         });
-        } else if (provider === 'ollama_cloud') {
+    } else if (provider === 'ollama_cloud') {
             config.apiKey = await input({
                 message: 'Enter your OLLAMA_API_KEY (from ollama.com):',
                 default: config.apiKey
@@ -65,7 +65,7 @@ export async function setupProvider(provider, config = {}) {
                 });
             }
             config.model = selectedModel;
-        } else if (provider === 'ollama') {
+        } else if (provider === 'claude') {
         config.apiKey = await input({
             message: 'Enter your ANTHROPIC_API_KEY:',
             default: config.apiKey
@@ -74,6 +74,27 @@ export async function setupProvider(provider, config = {}) {
             message: 'Select a Claude model:',
             choices: CLAUDE_MODELS
         });
+    } else if (provider === 'mistral') {
+        config.apiKey = await input({
+            message: 'Enter your MISTRAL_API_KEY (from console.mistral.ai):',
+            default: config.apiKey
+        });
+        
+        const choices = [...MISTRAL_MODELS, { name: chalk.magenta('✎ Enter custom model ID...'), value: 'CUSTOM_ID' }];
+        let selectedModel = await select({
+            message: 'Select a Mistral model:',
+            choices,
+            loop: false,
+            pageSize: Math.max(choices.length, 15)
+        });
+
+        if (selectedModel === 'CUSTOM_ID') {
+            selectedModel = await input({
+                message: 'Enter the exact Mistral model ID (e.g., mistral-large-latest):',
+                validate: (v) => v.trim().length > 0 || 'Model ID cannot be empty'
+            });
+        }
+        config.model = selectedModel;
     } else if (provider === 'openai') {
         const authMethod = await select({
             message: 'How would you like to authenticate with OpenAI?',
@@ -158,6 +179,7 @@ async function runSetupWizard() {
             { name: 'Google Gemini', value: 'gemini' },
             { name: 'Anthropic Claude', value: 'claude' },
             { name: 'OpenAI', value: 'openai' },
+            { name: 'Mistral AI', value: 'mistral' },
             { name: 'Ollama Cloud', value: 'ollama_cloud' },
             { name: 'Ollama (Local)', value: 'ollama' }
         ]

package/src/constants.js

@@ -30,6 +30,15 @@ export const OLLAMA_CLOUD_MODELS = [
     { name: 'Llama 3.1 405B (Cloud)', value: 'llama3.1:405b-cloud' }
 ];
 
+export const MISTRAL_MODELS = [
+    { name: 'Mistral Large (Latest)', value: 'mistral-large-latest' },
+    { name: 'Mistral Medium (Latest)', value: 'mistral-medium-latest' },
+    { name: 'Mistral Small (Latest)', value: 'mistral-small-latest' },
+    { name: 'Codestral (Latest)', value: 'codestral-latest' },
+    { name: 'Mistral Nemo', value: 'open-mistral-nemo' },
+    { name: 'Pixtral 12B', value: 'pixtral-12b-2409' }
+];
+
 export const CODEX_MODELS = [
     { name: 'GPT-5.4 (Newest)', value: 'gpt-5.4' },
     { name: 'GPT-5.3 Codex', value: 'gpt-5.3-codex' },

package/src/index.js

@@ -1,5 +1,6 @@
 import readline from 'readline';
 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';
@@ -9,9 +10,11 @@ import { ClaudeProvider } from './providers/claude.js';
 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 { loadSession, saveSession, generateSessionId, getLatestSessionId, listSessions } from './sessions.js';
 import { printMarkdown } from './utils/markdown.js';
+import { estimateConversationTokens } from './utils/tokens.js';
 
 let config;
 let providerInstance;
@@ -26,6 +29,7 @@ function createProvider(overrideConfig = null) {
         case 'gemini': return new GeminiProvider(activeConfig);
         case 'claude': return new ClaudeProvider(activeConfig);
         case 'openai': return new OpenAIProvider(activeConfig);
+        case 'mistral': return new MistralProvider(activeConfig);
         case 'ollama_cloud': return new OllamaCloudProvider(activeConfig);
         case 'ollama': return new OllamaProvider(activeConfig);
         default:
@@ -49,20 +53,21 @@ async function handleSlashCommand(command) {
                         { name: 'Google Gemini', value: 'gemini' },
                         { name: 'Anthropic Claude', value: 'claude' },
                         { name: 'OpenAI', value: 'openai' },
+                        { name: 'Mistral AI', value: 'mistral' },
                         { name: 'Ollama Cloud', value: 'ollama_cloud' },
                         { name: 'Ollama (Local)', value: 'ollama' }
                     ]
                 });
             }
 
-            if (['gemini', 'claude', 'openai', 'ollama_cloud', 'ollama'].includes(newProv)) {
+            if (['gemini', 'claude', 'openai', 'mistral', '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|ollama>`));
+                console.log(chalk.yellow(`Usage: /provider <gemini|claude|openai|ollama_cloud|ollama>`));
             }
             break;
         case '/model':
@@ -70,13 +75,15 @@ async function handleSlashCommand(command) {
             if (!newModel) {
                 // Interactive selection
                 const { select } = await import('@inquirer/prompts');
-                const { GEMINI_MODELS, CLAUDE_MODELS, OPENAI_MODELS, CODEX_MODELS, OLLAMA_CLOUD_MODELS } = await import('./constants.js');
+                const { GEMINI_MODELS, CLAUDE_MODELS, OPENAI_MODELS, CODEX_MODELS, OLLAMA_CLOUD_MODELS, MISTRAL_MODELS } = await import('./constants.js');
 
                 let choices = [];
                 if (config.provider === 'gemini') choices = GEMINI_MODELS;
                 else if (config.provider === 'claude') choices = CLAUDE_MODELS;
                 else if (config.provider === 'openai') {
                     choices = config.authType === 'oauth' ? CODEX_MODELS : OPENAI_MODELS;
+                } else if (config.provider === 'mistral') {
+                    choices = MISTRAL_MODELS;
                 } else if (config.provider === 'ollama_cloud') {
                     choices = OLLAMA_CLOUD_MODELS;
                 } else if (config.provider === 'ollama') {
@@ -92,7 +99,7 @@ async function handleSlashCommand(command) {
 
                 if (choices.length > 0) {
                     const finalChoices = [...choices];
-                    if (config.provider === 'ollama_cloud') {
+                    if (config.provider === 'ollama_cloud' || config.provider === 'mistral') {
                         finalChoices.push({ name: chalk.magenta('✎ Enter custom model ID...'), value: 'CUSTOM_ID' });
                     }
                     
@@ -130,11 +137,86 @@ async function handleSlashCommand(command) {
             providerInstance = createProvider(); // fresh instance = clear history
             console.log(chalk.green('Chat history cleared.'));
             break;
+        case '/clean':
+            if (!config.betaTools || !config.betaTools.includes('clean_command')) {
+                console.log(chalk.yellow("The /clean command is a beta feature. You need to enable it in the /beta menu first."));
+                break;
+            }
+            const msgCount = providerInstance.messages ? providerInstance.messages.length : 0;
+            if (msgCount <= 2) {
+                console.log(chalk.yellow("Not enough history to summarize."));
+                break;
+            }
+            
+            console.log(chalk.cyan("Summarizing context to save tokens..."));
+            const summarySpinner = ora({ text: 'Compressing history...', color: 'yellow', stream: process.stdout }).start();
+            
+            try {
+                // Temporarily disable terminal formatting for the summary request
+                const originalUseMarked = config.useMarkedTerminal;
+                config.useMarkedTerminal = false;
+                
+                // Create a temporary prompt asking for a summary
+                const summaryPrompt = "SYSTEM INSTRUCTION: Please provide a highly concise summary of our entire conversation so far. Focus ONLY on the overall goal, the current state of the project, any important decisions made, and what we were about to do next. Do not include pleasantries. This summary will be used as your memory going forward.";
+                
+                // Ask the AI to summarize
+                const summary = await providerInstance.sendMessage(summaryPrompt);
+                
+                // Restore settings
+                config.useMarkedTerminal = originalUseMarked;
+                summarySpinner.stop();
+                
+                // Re-initialize the provider to wipe old history
+                providerInstance = createProvider();
+                
+                // Inject the summary as the first message after the system prompt
+                const summaryMemory = `[PREVIOUS CONVERSATION SUMMARY]\n${summary}`;
+                
+                if (config.provider === 'gemini') {
+                    providerInstance.messages.push({ role: 'user', parts: [{ text: summaryMemory }] });
+                    providerInstance.messages.push({ role: 'model', parts: [{ text: "I have stored the summary of our previous conversation in my memory." }] });
+                } else if (config.provider === 'claude') {
+                    providerInstance.messages.push({ role: 'user', content: summaryMemory });
+                    providerInstance.messages.push({ role: 'assistant', content: "I have stored the summary of our previous conversation in my memory." });
+                } else {
+                    providerInstance.messages.push({ role: 'user', content: summaryMemory });
+                    providerInstance.messages.push({ role: 'assistant', content: "I have stored the summary of our previous conversation in my memory." });
+                }
+                
+                console.log(chalk.green(`\nContext successfully compressed!`));
+                if (config.debug) {
+                    console.log(chalk.gray(`\n[Saved Summary]:\n${summary}\n`));
+                }
+                
+                await saveSession(currentSessionId, {
+                    provider: config.provider,
+                    model: config.model || providerInstance.modelName,
+                    messages: providerInstance.messages
+                });
+                
+            } catch (err) {
+                summarySpinner.stop();
+                console.log(chalk.red(`Failed to compress context: ${err.message}`));
+            }
+            break;
         case '/context':
             let length = 0;
-            if (providerInstance.messages) length = providerInstance.messages.length;
-            else if (providerInstance.chat) length = (await providerInstance.chat.getHistory()).length;
-            console.log(chalk.cyan(`Current context contains approximately ${length} messages.`));
+            let messagesForEstimation = [];
+            
+            if (providerInstance.messages) {
+                length = providerInstance.messages.length;
+                messagesForEstimation = providerInstance.messages;
+            } else if (providerInstance.chat) {
+                messagesForEstimation = await providerInstance.chat.getHistory();
+                length = messagesForEstimation.length;
+            }
+            
+            const { estimateConversationTokens } = await import('./utils/tokens.js');
+            const estimatedTokens = estimateConversationTokens(messagesForEstimation);
+            
+            console.log(chalk.cyan(`Current context:`));
+            console.log(chalk.cyan(`- Messages: ${length}`));
+            console.log(chalk.cyan(`- Estimated Tokens: ~${estimatedTokens.toLocaleString()}`));
             break;
         case '/permissions':
             const perms = getSessionPermissions();
@@ -149,18 +231,27 @@ async function handleSlashCommand(command) {
             const { TOOLS } = await import('./tools/registry.js');
             const betaTools = TOOLS.filter(t => t.beta);
 
-            if (betaTools.length === 0) {
-                console.log(chalk.yellow("No beta tools available."));
+            let choices = betaTools.map(t => ({
+                name: t.label || t.name,
+                value: t.name,
+                checked: (config.betaTools || []).includes(t.name)
+            }));
+            
+            // Add beta commands that aren't tools
+            choices.push({
+                name: '/clean command (Context Compression)',
+                value: 'clean_command',
+                checked: (config.betaTools || []).includes('clean_command')
+            });
+
+            if (choices.length === 0) {
+                console.log(chalk.yellow("No beta features available."));
                 break;
             }
 
             const enabledBetaTools = await checkbox({
-                message: 'Select beta tools to activate (Space to toggle, Enter to confirm):',
-                choices: betaTools.map(t => ({
-                    name: t.label || t.name,
-                    value: t.name,
-                    checked: (config.betaTools || []).includes(t.name)
-                }))
+                message: 'Select beta features to activate (Space to toggle, Enter to confirm):',
+                choices: choices
             });
 
             if (enabledBetaTools.includes('duck_duck_go_scrape') && !(config.betaTools || []).includes('duck_duck_go_scrape')) {
@@ -182,7 +273,13 @@ async function handleSlashCommand(command) {
 
             config.betaTools = enabledBetaTools;
             await saveConfig(config);
-            providerInstance = createProvider(); // Re-init to update tools
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider(); // Re-init to update tools
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
             console.log(chalk.green(`Beta tools updated: ${enabledBetaTools.join(', ') || 'none'}`));
             break;
         case '/settings':
@@ -199,22 +296,80 @@ async function handleSlashCommand(command) {
                         name: 'Use syntax highlighting for AI output (requires waiting for full response)',
                         value: 'useMarkedTerminal',
                         checked: config.useMarkedTerminal || false
+                    },
+                    {
+                        name: 'Always show current token count in status bar',
+                        value: 'showTokenCount',
+                        checked: config.showTokenCount || false
                     }
                 ]
             });
             
             config.autoFeedWorkspace = enabledSettings.includes('autoFeedWorkspace');
             config.useMarkedTerminal = enabledSettings.includes('useMarkedTerminal');
+            config.showTokenCount = enabledSettings.includes('showTokenCount');
             await saveConfig(config);
-            providerInstance = createProvider(); // Re-init to update tools/config
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider(); // Re-init to update tools/config
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
             console.log(chalk.green(`Settings updated.`));
             break;
         case '/debug':
             config.debug = !config.debug;
             await saveConfig(config);
-            providerInstance = createProvider(); // Re-init to pass debug flag
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider(); // Re-init to pass debug flag
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
             console.log(chalk.magenta(`Debug mode ${config.debug ? 'enabled' : 'disabled'}.`));
             break;
+        case '/skills':
+            const { getAvailableSkills } = await import('./utils/skills.js');
+            const skills = getAvailableSkills();
+            if (skills.length === 0) {
+                console.log(chalk.yellow("No skills found."));
+                const os = await import('os');
+                const path = await import('path');
+                const skillsDir = path.join(os.homedir(), '.config', 'banana-code', 'skills');
+                console.log(chalk.gray(`Create skill directories with a SKILL.md file in ${skillsDir}`));
+            } else {
+                console.log(chalk.cyan.bold("\nLoaded Skills:"));
+                skills.forEach(skill => {
+                    console.log(chalk.green(`- ${skill.id}`) + `: ${skill.description}`);
+                });
+            }
+            break;
+        case '/plan':
+            config.planMode = true;
+            await saveConfig(config);
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider();
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
+            console.log(chalk.magenta(`Plan mode enabled. For significant changes, the AI will now propose an implementation plan before writing code.`));
+            break;
+        case '/agent':
+            config.planMode = false;
+            await saveConfig(config);
+            if (providerInstance) {
+                const savedMessages = providerInstance.messages;
+                providerInstance = createProvider();
+                providerInstance.messages = savedMessages;
+            } else {
+                providerInstance = createProvider();
+            }
+            console.log(chalk.green(`Agent mode enabled. The AI will make changes directly.`));
+            break;
         case '/chats':
             const sessions = await listSessions();
             if (sessions.length === 0) {
@@ -231,14 +386,18 @@ async function handleSlashCommand(command) {
         case '/help':
             console.log(chalk.yellow(`
 Available commands:
-  /provider <name> - Switch AI provider (gemini, claude, openai, ollama)
+  /provider <name> - Switch AI provider (gemini, claude, openai, ollama_cloud, ollama)
   /model [name]    - Switch model within current provider (opens menu if name omitted)
   /chats           - List persistent chat sessions
   /clear           - Clear chat history
+  /clean           - Compress chat history into a summary to save tokens
   /context         - Show current context window size
   /permissions     - List session-approved permissions
   /beta            - Manage beta features and tools
   /settings        - Manage app settings (workspace auto-feed, etc)
+  /skills          - List loaded agent skills
+  /plan            - Enable Plan Mode (AI proposes a plan for big changes)
+  /agent           - Enable Agent Mode (default, AI edits directly)
   /debug           - Toggle debug mode (show tool results)
   /help            - Show all commands
   /exit            - Quit Banana Code
@@ -278,7 +437,7 @@ function drawPromptBox(inputText, cursorPos) {
     const placeholder = 'Type your message or @path/to/file';
     const prefix = ' > ';
 
-    const visibleText = (inputText.length === 0) ? (prefix + chalk.gray(placeholder)) : (prefix + inputText);
+    const visibleText = (inputText.length === 0) ? (prefix + chalk.gray(placeholder)) : (prefix + chalk.white(inputText));
     const totalChars = (prefix.length + Math.max(inputText.length, placeholder.length));
     const rows = Math.ceil(totalChars / width) || 1;
 
@@ -298,8 +457,26 @@ 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 leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)}`;
-    const rightText = '? for shortcuts ';
+    const modeDisplay = config.planMode ? chalk.magenta('PLAN MODE') : chalk.green('AGENT MODE');
+    
+    let tokenDisplay = '';
+    if (config.showTokenCount && providerInstance) {
+        let msgs = providerInstance.messages || [];
+        // Support for Ollama chat history format if different
+        if (!providerInstance.messages && typeof providerInstance.chat?.getHistory === 'function') {
+            msgs = providerInstance.chat.getHistory(); // Note: this is async normally, but we use an approximation here or just skip it if it's strictly async. For now, assume providerInstance.messages is the standard.
+        }
+        const tokens = estimateConversationTokens(msgs);
+        let color = chalk.green;
+        if (tokens >= 128000) color = chalk.red;
+        else if (tokens >= 86000) color = chalk.hex('#FFA500'); // Orange
+        else if (tokens >= 64000) color = chalk.yellow;
+        
+        tokenDisplay = ` / Tokens: ${color(tokens.toLocaleString())}`;
+    }
+    
+    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)} / ${modeDisplay}${tokenDisplay}`;
+    const rightText = '/help for shortcuts ';
     const leftStripped = leftText.replace(/\x1b\[[0-9;]*m/g, '');
     const midPad = Math.max(0, width - leftStripped.length - rightText.length);
     const statusLine = chalk.gray(leftText + ' '.repeat(midPad) + rightText);
@@ -325,7 +502,7 @@ function drawPromptBoxInitial(inputText) {
     const placeholder = 'Type your message or @path/to/file';
     const prefix = ' > ';
 
-    const visibleText = (inputText.length === 0) ? (prefix + chalk.gray(placeholder)) : (prefix + inputText);
+    const visibleText = (inputText.length === 0) ? (prefix + chalk.gray(placeholder)) : (prefix + chalk.white(inputText));
     const totalChars = (prefix.length + Math.max(inputText.length, placeholder.length));
     const rows = Math.ceil(totalChars / width) || 1;
 
@@ -338,11 +515,29 @@ function drawPromptBoxInitial(inputText) {
         process.stdout.write(userBg(padLine(lineText, width)) + '\n');
     }
 
-    // Status bar: Current Provider / Model + right-aligned "? for shortcuts"
+    // Status bar: Current Provider / Model + right-aligned "/help for shortcuts"
     const modelDisplay = providerInstance ? providerInstance.modelName : (config.model || 'unknown');
     const providerDisplay = config.provider.toUpperCase();
-    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)}`;
-    const rightText = '? for shortcuts ';
+    const modeDisplay = config.planMode ? chalk.magenta('PLAN MODE') : chalk.green('AGENT MODE');
+    
+    let tokenDisplay = '';
+    if (config.showTokenCount && providerInstance) {
+        let msgs = providerInstance.messages || [];
+        // Support for Ollama chat history format if different
+        if (!providerInstance.messages && typeof providerInstance.chat?.getHistory === 'function') {
+            msgs = providerInstance.chat.getHistory(); // Note: this is async normally, but we use an approximation here or just skip it if it's strictly async. For now, assume providerInstance.messages is the standard.
+        }
+        const tokens = estimateConversationTokens(msgs);
+        let color = chalk.green;
+        if (tokens >= 128000) color = chalk.red;
+        else if (tokens >= 86000) color = chalk.hex('#FFA500'); // Orange
+        else if (tokens >= 64000) color = chalk.yellow;
+        
+        tokenDisplay = ` / Tokens: ${color(tokens.toLocaleString())}`;
+    }
+    
+    const leftText = ` Provider: ${chalk.cyan(providerDisplay)} / Model: ${chalk.yellow(modelDisplay)} / ${modeDisplay}${tokenDisplay}`;
+    const rightText = '/help for shortcuts ';
 
     const leftStripped = leftText.replace(/\x1b\[[0-9;]*m/g, '');
     const midPad = Math.max(0, width - leftStripped.length - rightText.length);

package/src/prompt.js

@@ -1,5 +1,6 @@
 import os from 'os';
 import { getAvailableTools } from './tools/registry.js';
+import { getAvailableSkills } from './utils/skills.js';
 
 export function getSystemPrompt(config = {}) {
     const platform = os.platform();
@@ -16,6 +17,7 @@ export function getSystemPrompt(config = {}) {
     const availableToolsList = getAvailableTools(config);
     const availableToolsNames = availableToolsList.map(t => t.name).join(', ');
     const hasPatchTool = availableToolsList.some(t => t.name === 'patch_file');
+    const skills = getAvailableSkills();
 
     let prompt = `You are Banana Code, a terminal-based AI coding assistant running on ${osDescription}. You help users write, debug, and understand code. You have access to tools: ${availableToolsNames}. 
 
@@ -27,6 +29,39 @@ SAFETY RULES:
 
 Always use tools when they would help. Be concise but thorough. `;
 
+    if (skills && skills.length > 0) {
+        prompt += `\n\n# Available Agent Skills\n\nYou have access to the following specialized skills. To activate a skill and receive its detailed instructions, call the \`activate_skill\` tool with the skill's name.\n\n<available_skills>\n`;
+        for (const skill of skills) {
+            prompt += `  <skill>\n    <name>${skill.id}</name>\n    <description>${skill.description}</description>\n  </skill>\n`;
+        }
+        prompt += `</available_skills>\n\nOnce a skill is activated, its instructions and resources are returned wrapped in <activated_skill> tags. You MUST treat the content within <instructions> as expert procedural guidance for the duration of the task.\n`;
+    }
+
+    const hasDelegateTool = availableToolsList.some(t => t.name === 'delegate_task');
+    if (hasDelegateTool) {
+        prompt += `
+\n# Sub-Agent Delegation
+You have the ability to spawn specialized sub-agents to handle complex sub-tasks using the \`delegate_task\` tool.
+- Use **researcher** for deep codebase exploration or fact-finding.
+- Use **coder** for implementing specific features or complex bug fixes.
+- Use **reviewer** for analyzing code quality or security.
+- Use **generalist** for any other multi-step sub-task.
+Delegation is highly recommended for tasks that would otherwise bloat your current conversation context. The results of the sub-agent will be returned to you as a summary.
+`;
+    }
+
+    if (config.planMode) {
+        prompt += `
+[PLAN MODE ENABLED]
+The user is operating in "Plan Mode".
+- For very small, trivial changes (like fixing a typo or a one-line bug), you may execute the change directly using your tools.
+- For ANY change that has a significant impact, modifies multiple areas, or adds a new feature, you MUST NOT write or patch code immediately.
+- Instead, you MUST output a detailed "Implementation Plan" outlining the files you will change and the specific steps you will take.
+- Stop and ask the user: "Does this plan look good, or would you like to make any changes?"
+- ONLY proceed to use the 'write_file' or 'patch_file' tools AFTER the user has explicitly approved the plan.
+`;
+    }
+
     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/claude.js

@@ -114,7 +114,7 @@ export class ClaudeProvider {
                 const toolResultContent = [];
                 for (const call of toolCalls) {
                     console.log(chalk.yellow(`\n[Banana Calling Tool: ${call.name}]`));
-                    const res = await executeTool(call.name, call.input);
+                    const res = await executeTool(call.name, call.input, this.config);
                     if (this.config.debug) {
                         console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                     }

package/src/providers/gemini.js

@@ -135,7 +135,7 @@ export class GeminiProvider {
                         hasToolCalls = true;
                         const call = part.functionCall;
                         console.log(chalk.yellow(`\n[Banana Calling Tool: ${call.name}]`));
-                        const res = await executeTool(call.name, call.args);
+                        const res = await executeTool(call.name, call.args, this.config);
                         if (this.config.debug) {
                             console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                         }

package/src/providers/mistral.js

@@ -0,0 +1,141 @@
+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 MistralProvider {
+    constructor(config) {
+        this.config = config;
+        this.openai = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: 'https://api.mistral.ai/v1'
+        });
+        this.modelName = config.model || 'mistral-large-latest';
+        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.length > 0 ? this.tools : undefined,
+                        stream: true
+                    });
+                } catch (e) {
+                    spinner.stop();
+                    console.error(chalk.red(`Mistral Request Error: ${e.message}`));
+                    return `Error: ${e.message}`;
+                }
+
+                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) {
+                            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?.arguments) {
+                                toolCalls[tc.index].function.arguments += tc.function.arguments;
+                                // Visual feedback for streaming tool 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) {
+                    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.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(`Mistral Runtime Error: ${err.message}`));
+            return `Error: ${err.message}`;
+        }
+    }
+}

package/src/providers/ollamaCloud.js

@@ -82,7 +82,7 @@ export class OllamaCloudProvider {
                     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)}`));
                     }

package/src/providers/openai.js

@@ -121,7 +121,7 @@ export class OpenAIProvider {
                         args = JSON.parse(call.function.arguments);
                     } catch (e) { }
 
-                    const res = await executeTool(call.function.name, args);
+                    const res = await executeTool(call.function.name, args, this.config);
                     if (this.config.debug) {
                         console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                     }
@@ -371,7 +371,7 @@ export class OpenAIProvider {
                         args = JSON.parse(call.function.arguments);
                     } catch (e) { }
 
-                    const res = await executeTool(call.function.name, args);
+                    const res = await executeTool(call.function.name, args, this.config);
                     if (this.config.debug) {
                         console.log(chalk.gray(`[DEBUG] Tool Result: ${typeof res === 'string' ? res : JSON.stringify(res, null, 2)}`));
                     }

package/src/tools/activateSkill.js

@@ -0,0 +1,22 @@
+import { getAvailableSkills } from '../utils/skills.js';
+
+export async function activateSkill({ skillName }) {
+    const skills = getAvailableSkills();
+    // Match by ID or Name
+    const skill = skills.find(s => s.id === skillName || s.name === skillName);
+    
+    if (!skill) {
+        return `Error: Skill '${skillName}' not found. Available skills: ${skills.map(s => s.name).join(', ')}`;
+    }
+    
+    // The format expected by the AI agent
+    let output = `<activated_skill>\n`;
+    output += `<instructions>\n${skill.instructions}\n</instructions>\n`;
+    output += `<available_resources>\n`;
+    output += `- location: ${skill.path}\n`;
+    output += `  (Use list_directory and read_file to access bundled scripts, references, or assets)\n`;
+    output += `</available_resources>\n`;
+    output += `</activated_skill>`;
+    
+    return output;
+}

package/src/tools/delegateTask.js

@@ -0,0 +1,100 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getAvailableTools, executeTool } from './registry.js';
+import { getSystemPrompt } from '../prompt.js';
+import { requestPermission } from '../permissions.js';
+
+// Specialist prompts to guide sub-agents
+const SPECIALIST_PROMPTS = {
+    researcher: "You are a Research Specialist. Your goal is to explore the codebase, find information, and answer specific questions. Do not make any file changes. Use tools like search_files, list_directory, and read_file to gather facts.",
+    coder: "You are a Coding Specialist. Your goal is to implement specific logic or fix bugs as requested. Focus on writing high-quality, idiomatic code using patch_file and write_file.",
+    reviewer: "You are a Code Reviewer. Your goal is to analyze provided code for bugs, security vulnerabilities, or style issues. Provide a detailed report of your findings.",
+    generalist: "You are a Generalist Sub-Agent. Complete the assigned task as efficiently as possible using all available tools."
+};
+
+/**
+ * Tool that allows the main agent to delegate a sub-task to a specialized agent.
+ */
+export async function delegateTask({ task, agentType = 'generalist', contextFiles = [] }, mainConfig) {
+    const perm = await requestPermission('Delegate Task', `${agentType} specialist: ${task}`);
+    if (!perm.allowed) {
+        return `User denied permission to delegate task to ${agentType} specialist.`;
+    }
+
+    const spinner = ora({ 
+        text: `Delegating to ${chalk.magenta(agentType)} specialist...`, 
+        color: 'magenta', 
+        stream: process.stdout 
+    }).start();
+
+    try {
+        // 1. Setup the sub-agent config (inherit from main, but could be customized)
+        const subConfig = { ...mainConfig };
+        
+        // Use a dynamic import to avoid circular dependency with index.js if needed,
+        // but here we can just manually create the provider based on current config.
+        const { GeminiProvider } = await import('../providers/gemini.js');
+        const { ClaudeProvider } = await import('../providers/claude.js');
+        const { OpenAIProvider } = await import('../providers/openai.js');
+        const { MistralProvider } = await import('../providers/mistral.js');
+        const { OllamaProvider } = await import('../providers/ollama.js');
+        const { OllamaCloudProvider } = await import('../providers/ollamaCloud.js');
+
+        const createSubProvider = (cfg) => {
+            switch (cfg.provider) {
+                case 'gemini': return new GeminiProvider(cfg);
+                case 'claude': return new ClaudeProvider(cfg);
+                case 'openai': return new OpenAIProvider(cfg);
+                case 'mistral': return new MistralProvider(cfg);
+                case 'ollama_cloud': return new OllamaCloudProvider(cfg);
+                case 'ollama': return new OllamaProvider(cfg);
+                default: return new OllamaProvider(cfg);
+            }
+        };
+
+        const subProvider = createSubProvider(subConfig);
+        
+        // 2. Customize the system prompt for the specialist
+        const basePrompt = getSystemPrompt(subConfig);
+        const specialistInstruction = SPECIALIST_PROMPTS[agentType] || SPECIALIST_PROMPTS.generalist;
+        
+        // Inject specialist instructions at the start
+        subProvider.updateSystemPrompt(`${specialistInstruction}\n\n${basePrompt}`);
+
+        // 3. Prepare initial message with context
+        let initialMessage = `TASK: ${task}`;
+        if (contextFiles.length > 0) {
+            const fs = await import('fs');
+            initialMessage += "\n\nCONTEXT FILES:";
+            for (const file of contextFiles) {
+                try {
+                    const content = fs.readFileSync(file, 'utf8');
+                    initialMessage += `\n\n--- ${file} ---\n${content}`;
+                } catch (e) {
+                    initialMessage += `\n\n(Error reading context file ${file}: ${e.message})`;
+                }
+            }
+        }
+
+        // 4. Run the sub-agent message loop
+        // We'll give it a limit of 5 turns to prevent infinite loops between agents
+        let turns = 0;
+        let finalResponse = '';
+        
+        spinner.text = `Sub-agent (${agentType}) is working on the task...`;
+        
+        // For the sub-agent, we want to capture its sendMessage result
+        // Note: Sub-agents run silently (their output isn't printed unless debug is on)
+        // to prevent terminal clutter.
+        finalResponse = await subProvider.sendMessage(initialMessage);
+
+        spinner.stop();
+        console.log(chalk.magenta(`[Sub-Agent ${agentType} task complete]`));
+
+        return `SUB-AGENT RESULT:\n${finalResponse}`;
+
+    } catch (err) {
+        if (spinner.isSpinning) spinner.stop();
+        return `Error in delegation: ${err.message}`;
+    }
+}

package/src/tools/registry.js

@@ -7,6 +7,8 @@ import { listDirectory } from './listDirectory.js';
 import { duckDuckGo } from './duckDuckGo.js';
 import { duckDuckGoScrape } from './duckDuckGoScrape.js';
 import { patchFile } from './patchFile.js';
+import { activateSkill } from './activateSkill.js';
+import { delegateTask } from './delegateTask.js';
 
 export const TOOLS = [
     {
@@ -133,6 +135,40 @@ export const TOOLS = [
             },
             required: ['filepath', 'edits']
         }
+    },
+    {
+        name: 'activate_skill',
+        description: 'Activates a specialized agent skill by name. Returns the skill\'s instructions wrapped in <activated_skill> tags. These provide specialized guidance for the current task.',
+        parameters: {
+            type: 'object',
+            properties: {
+                skillName: { type: 'string', description: 'The name or ID of the skill to activate.' }
+            },
+            required: ['skillName']
+        }
+    },
+    {
+        name: 'delegate_task',
+        label: 'Sub-Agent Delegation (Beta)',
+        description: 'Spawns a specialized sub-agent to handle a specific sub-task. Use this for complex research, big code changes, or detailed reviews to keep the main context clean.',
+        beta: true,
+        parameters: {
+            type: 'object',
+            properties: {
+                task: { type: 'string', description: 'The specific, detailed instruction for the sub-agent.' },
+                agentType: { 
+                    type: 'string', 
+                    description: 'The type of specialist to spawn.',
+                    enum: ['researcher', 'coder', 'reviewer', 'generalist']
+                },
+                contextFiles: {
+                    type: 'array',
+                    description: 'Optional list of file paths to provide as initial context to the sub-agent.',
+                    items: { type: 'string' }
+                }
+            },
+            required: ['task']
+        }
     }
 ];
 
@@ -145,7 +181,7 @@ export function getAvailableTools(config = {}) {
     });
 }
 
-export async function executeTool(name, args) {
+export async function executeTool(name, args, config) {
     switch (name) {
         case 'execute_command': return await execCommand(args);
         case 'read_file': return await readFile(args);
@@ -156,6 +192,8 @@ export async function executeTool(name, args) {
         case 'duck_duck_go': return await duckDuckGo(args);
         case 'duck_duck_go_scrape': return await duckDuckGoScrape(args);
         case 'patch_file': return await patchFile(args);
+        case 'activate_skill': return await activateSkill(args);
+        case 'delegate_task': return await delegateTask(args, config);
         default: return `Unknown tool: ${name}`;
     }
 }

package/src/utils/skills.js

@@ -0,0 +1,61 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const SKILLS_DIR = path.join(os.homedir(), '.config', 'banana-code', 'skills');
+
+/**
+ * Scans the skills directory and parses SKILL.md files.
+ * @returns {Array} List of discovered skills.
+ */
+export function getAvailableSkills() {
+    try {
+        if (!fs.existsSync(SKILLS_DIR)) {
+            fs.mkdirSync(SKILLS_DIR, { recursive: true });
+        }
+    } catch (e) {
+        return [];
+    }
+
+    let skills = [];
+    try {
+        const entries = fs.readdirSync(SKILLS_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const skillPath = path.join(SKILLS_DIR, entry.name);
+                const mdPath = path.join(skillPath, 'SKILL.md');
+                
+                if (fs.existsSync(mdPath)) {
+                    try {
+                        const content = fs.readFileSync(mdPath, 'utf8');
+                        // Match YAML frontmatter between --- and ---
+                        const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+                        
+                        if (match) {
+                            const frontmatter = match[1];
+                            const body = content.slice(match[0].length).trim();
+                            
+                            // Simple YAML parsing via regex
+                            const nameMatch = frontmatter.match(/name:\s*['"]?([^'"\n]+)['"]?/);
+                            const descMatch = frontmatter.match(/description:\s*['"]?([^'"\n]+)['"]?/);
+                            
+                            if (nameMatch && descMatch) {
+                                skills.push({
+                                    id: entry.name,
+                                    name: nameMatch[1].trim(),
+                                    description: descMatch[1].trim(),
+                                    instructions: body,
+                                    path: skillPath
+                                });
+                            }
+                        }
+                    } catch (err) {
+                        // Skip corrupted or unreadable skills
+                    }
+                }
+            }
+        }
+    } catch (e) {}
+    
+    return skills;
+}

package/src/utils/tokens.js

@@ -0,0 +1,44 @@
+/**
+ * Estimates the number of tokens in a given string.
+ * This is a rough approximation (1 token ≈ 4 characters or ~0.75 words) 
+ * used to provide a quick estimate without needing heavy, provider-specific tokenizer libraries.
+ * 
+ * @param {string} text - The input text to estimate tokens for.
+ * @returns {number} The estimated token count.
+ */
+export function estimateTokens(text) {
+    if (!text || typeof text !== 'string') return 0;
+    
+    // A common heuristic: 1 token is roughly 4 English characters.
+    // For code, it can be denser, but this provides a reasonable ballpark.
+    return Math.ceil(text.length / 4);
+}
+
+/**
+ * Calculates the estimated token count for the entire conversation history.
+ * 
+ * @param {Array} messages - The array of message objects.
+ * @returns {number} The estimated total tokens.
+ */
+export function estimateConversationTokens(messages) {
+    if (!Array.isArray(messages)) return 0;
+    
+    let totalString = '';
+    
+    // Stringify the entire message array to get a representation of its "weight"
+    // This includes system prompts, tool calls, and results.
+    try {
+        totalString = JSON.stringify(messages);
+    } catch (e) {
+        // Fallback if there are circular references (unlikely in simple message arrays)
+        messages.forEach(msg => {
+            if (typeof msg === 'string') totalString += msg;
+            else if (msg && typeof msg === 'object') {
+                if (msg.content) totalString += typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content);
+                if (msg.parts) totalString += JSON.stringify(msg.parts);
+            }
+        });
+    }
+
+    return estimateTokens(totalString);
+}