@banaxi/banana-code 1.2.0 → 1.4.0

package/package.json

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

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');
@@ -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

@@ -10,6 +10,7 @@ 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';
@@ -28,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:
@@ -51,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_cloud|ollama>`));
+                console.log(chalk.yellow(`Usage: /provider <gemini|claude|openai|mistral|ollama_cloud|ollama>`));
             }
             break;
         case '/model':
@@ -72,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') {
@@ -94,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' });
                     }
                     
@@ -381,7 +386,7 @@ async function handleSlashCommand(command) {
         case '/help':
             console.log(chalk.yellow(`
 Available commands:
-  /provider <name> - Switch AI provider (gemini, claude, openai, ollama_cloud, ollama)
+  /provider <name> - Switch AI provider (gemini, claude, openai, mistral, ollama_cloud, ollama)
   /model [name]    - Switch model within current provider (opens menu if name omitted)
   /chats           - List persistent chat sessions
   /clear           - Clear chat history

package/src/prompt.js

@@ -37,6 +37,19 @@ Always use tools when they would help. Be concise but thorough. `;
         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]

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

@@ -47,7 +47,7 @@ export class OllamaCloudProvider {
                         model: this.modelName,
                         messages: this.messages,
                         tools: this.tools.length > 0 ? this.tools : undefined,
-                        stream: false // Cloud API sometimes prefers non-streaming or different SSE formats
+                        stream: true
                     })
                 });
 
@@ -57,32 +57,61 @@ export class OllamaCloudProvider {
                     throw new Error(`HTTP ${response.status}: ${errorText}`);
                 }
 
-                const data = await response.json();
-                spinner.stop();
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let currentChunkResponse = '';
+                let lastMessageObj = null;
+
+                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() !== '');
+
+                    for (const line of lines) {
+                        try {
+                            const data = JSON.parse(line);
+                            if (data.message) {
+                                lastMessageObj = data.message;
+                                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) {
+                            // Ignore partial JSON chunks
+                        }
+                    }
+                }
 
-                const messageObj = data.message;
+                if (spinner.isSpinning) spinner.stop();
 
-                if (messageObj.content) {
-                    if (this.config.useMarkedTerminal) {
-                        printMarkdown(messageObj.content);
-                    } else {
-                        process.stdout.write(chalk.cyan(messageObj.content));
-                    }
-                    finalResponse += messageObj.content;
+                if (currentChunkResponse && this.config.useMarkedTerminal) {
+                    printMarkdown(currentChunkResponse);
+                }
+
+                if (!lastMessageObj) {
+                    throw new Error("Empty response from Ollama Cloud");
                 }
 
-                this.messages.push(messageObj);
+                this.messages.push(lastMessageObj);
 
-                if (!messageObj.tool_calls || messageObj.tool_calls.length === 0) {
+                if (!lastMessageObj.tool_calls || lastMessageObj.tool_calls.length === 0) {
                     console.log();
                     break;
                 }
 
-                for (const call of messageObj.tool_calls) {
+                for (const call of lastMessageObj.tool_calls) {
                     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/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

@@ -8,6 +8,7 @@ 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 = [
     {
@@ -145,6 +146,29 @@ export const TOOLS = [
             },
             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']
+        }
     }
 ];
 
@@ -157,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);
@@ -169,6 +193,7 @@ export async function executeTool(name, 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}`;
     }
 }