kernelbot 1.0.25 → 1.0.26

package/README.md

@@ -219,11 +219,12 @@ conversation:
 
 ## Telegram Commands
 
-| Command    | Description                        |
-| ---------- | ---------------------------------- |
-| `/clean`   | Clear conversation and start fresh |
-| `/history` | Show message count in memory       |
-| `/help`    | Show help message                  |
+| Command    | Description                                    |
+| ---------- | ---------------------------------------------- |
+| `/brain`   | Show current AI model and switch provider/model |
+| `/clean`   | Clear conversation and start fresh             |
+| `/history` | Show message count in memory                   |
+| `/help`    | Show help message                              |
 
 ## Security
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",

package/src/agent.js

@@ -1,8 +1,12 @@
-import { createProvider } from './providers/index.js';
+import { createProvider, PROVIDERS } from './providers/index.js';
 import { toolDefinitions, executeTool, checkConfirmation } from './tools/index.js';
+import { selectToolsForMessage, expandToolsForUsed } from './tools/categories.js';
 import { getSystemPrompt } from './prompts/system.js';
 import { getLogger } from './utils/logger.js';
-import { getMissingCredential, saveCredential } from './utils/config.js';
+import { getMissingCredential, saveCredential, saveProviderToYaml } from './utils/config.js';
+
+const MAX_RESULT_LENGTH = 3000;
+const LARGE_FIELDS = ['stdout', 'stderr', 'content', 'diff', 'output', 'body', 'html', 'text', 'log', 'logs'];
 
 export class Agent {
   constructor({ config, conversationManager }) {
@@ -13,6 +17,89 @@ export class Agent {
     this._pending = new Map(); // chatId -> pending state
   }
 
+  /** Return current brain info for display. */
+  getBrainInfo() {
+    const { provider, model } = this.config.brain;
+    const providerDef = PROVIDERS[provider];
+    const providerName = providerDef ? providerDef.name : provider;
+    const modelEntry = providerDef?.models.find((m) => m.id === model);
+    const modelLabel = modelEntry ? modelEntry.label : model;
+    return { provider, providerName, model, modelLabel };
+  }
+
+  /**
+   * Switch to a different provider/model at runtime.
+   * Resolves the API key from process.env automatically.
+   * Returns null on success, or an error string if the key is missing.
+   */
+  switchBrain(providerKey, modelId) {
+    const logger = getLogger();
+    const providerDef = PROVIDERS[providerKey];
+    if (!providerDef) return `Unknown provider: ${providerKey}`;
+
+    const envKey = providerDef.envKey;
+    const apiKey = process.env[envKey];
+    if (!apiKey) {
+      return envKey; // caller handles prompting
+    }
+
+    this.config.brain.provider = providerKey;
+    this.config.brain.model = modelId;
+    this.config.brain.api_key = apiKey;
+
+    // Recreate the provider instance
+    this.provider = createProvider(this.config);
+
+    // Persist to config.yaml
+    saveProviderToYaml(providerKey, modelId);
+
+    logger.info(`Brain switched to ${providerDef.name} / ${modelId}`);
+    return null;
+  }
+
+  /**
+   * Finalize brain switch after API key was provided via chat.
+   */
+  switchBrainWithKey(providerKey, modelId, apiKey) {
+    const logger = getLogger();
+    const providerDef = PROVIDERS[providerKey];
+
+    // Save the key
+    saveCredential(this.config, providerDef.envKey, apiKey);
+
+    this.config.brain.provider = providerKey;
+    this.config.brain.model = modelId;
+    this.config.brain.api_key = apiKey;
+
+    this.provider = createProvider(this.config);
+    saveProviderToYaml(providerKey, modelId);
+
+    logger.info(`Brain switched to ${providerDef.name} / ${modelId} (new key saved)`);
+  }
+
+  /**
+   * Truncate a tool result to stay within token budget.
+   */
+  _truncateResult(name, result) {
+    let str = JSON.stringify(result);
+    if (str.length <= MAX_RESULT_LENGTH) return str;
+
+    // Try truncating known large fields first
+    if (result && typeof result === 'object') {
+      const truncated = { ...result };
+      for (const field of LARGE_FIELDS) {
+        if (typeof truncated[field] === 'string' && truncated[field].length > 500) {
+          truncated[field] = truncated[field].slice(0, 500) + `\n... [truncated ${truncated[field].length - 500} chars]`;
+        }
+      }
+      str = JSON.stringify(truncated);
+      if (str.length <= MAX_RESULT_LENGTH) return str;
+    }
+
+    // Hard truncate
+    return str.slice(0, MAX_RESULT_LENGTH) + `\n... [truncated, total ${str.length} chars]`;
+  }
+
   async processMessage(chatId, userMessage, user, onUpdate, sendPhoto) {
     const logger = getLogger();
 
@@ -38,10 +125,14 @@ export class Agent {
     // Add user message to persistent history
     this.conversationManager.addMessage(chatId, 'user', userMessage);
 
-    // Build working messages from history
-    const messages = [...this.conversationManager.getHistory(chatId)];
+    // Build working messages from compressed history
+    const messages = [...this.conversationManager.getSummarizedHistory(chatId)];
 
-    return await this._runLoop(chatId, messages, user, 0, max_tool_depth);
+    // Select relevant tools based on user message
+    const tools = selectToolsForMessage(userMessage, toolDefinitions);
+    logger.debug(`Selected ${tools.length}/${toolDefinitions.length} tools for message`);
+
+    return await this._runLoop(chatId, messages, user, 0, max_tool_depth, tools);
   }
 
   _formatToolSummary(name, input) {
@@ -92,7 +183,7 @@ export class Agent {
       pending.toolResults.push({
         type: 'tool_result',
         tool_use_id: pending.block.id,
-        content: JSON.stringify({ error: `${pending.credential.label} not provided. Operation skipped.` }),
+        content: this._truncateResult(pending.block.name, { error: `${pending.credential.label} not provided. Operation skipped.` }),
       });
       return await this._resumeAfterPause(chatId, user, pending);
     }
@@ -112,7 +203,7 @@ export class Agent {
     pending.toolResults.push({
       type: 'tool_result',
       tool_use_id: pending.block.id,
-      content: JSON.stringify(result),
+      content: this._truncateResult(pending.block.name, result),
     });
 
     return await this._resumeAfterPause(chatId, user, pending);
@@ -129,14 +220,14 @@ export class Agent {
       pending.toolResults.push({
         type: 'tool_result',
         tool_use_id: pending.block.id,
-        content: JSON.stringify(result),
+        content: this._truncateResult(pending.block.name, result),
       });
     } else {
       logger.info(`User denied dangerous tool: ${pending.block.name}`);
       pending.toolResults.push({
         type: 'tool_result',
         tool_use_id: pending.block.id,
-        content: JSON.stringify({ error: 'User denied this operation.' }),
+        content: this._truncateResult(pending.block.name, { error: 'User denied this operation.' }),
       });
     }
 
@@ -155,13 +246,13 @@ export class Agent {
       pending.toolResults.push({
         type: 'tool_result',
         tool_use_id: block.id,
-        content: JSON.stringify(r),
+        content: this._truncateResult(block.name, r),
       });
     }
 
     pending.messages.push({ role: 'user', content: pending.toolResults });
     const { max_tool_depth } = this.config.brain;
-    return await this._runLoop(chatId, pending.messages, user, 0, max_tool_depth);
+    return await this._runLoop(chatId, pending.messages, user, 0, max_tool_depth, pending.tools || toolDefinitions);
   }
 
   _checkPause(chatId, block, user, toolResults, remainingBlocks, messages) {
@@ -201,8 +292,9 @@ export class Agent {
     return null;
   }
 
-  async _runLoop(chatId, messages, user, startDepth, maxDepth) {
+  async _runLoop(chatId, messages, user, startDepth, maxDepth, tools) {
     const logger = getLogger();
+    let currentTools = tools || toolDefinitions;
 
     for (let depth = startDepth; depth < maxDepth; depth++) {
       logger.debug(`Agent loop iteration ${depth + 1}/${maxDepth}`);
@@ -210,7 +302,7 @@ export class Agent {
       const response = await this.provider.chat({
         system: this.systemPrompt,
         messages,
-        tools: toolDefinitions,
+        tools: currentTools,
       });
 
       if (response.stopReason === 'end_turn') {
@@ -229,6 +321,7 @@ export class Agent {
         }
 
         const toolResults = [];
+        const usedToolNames = [];
 
         for (let i = 0; i < response.toolCalls.length; i++) {
           const block = response.toolCalls[i];
@@ -254,13 +347,18 @@ export class Agent {
             sendPhoto: this._sendPhoto,
           });
 
+          usedToolNames.push(block.name);
+
           toolResults.push({
             type: 'tool_result',
             tool_use_id: block.id,
-            content: JSON.stringify(result),
+            content: this._truncateResult(block.name, result),
           });
         }
 
+        // Expand tools based on what was actually used
+        currentTools = expandToolsForUsed(usedToolNames, currentTools, toolDefinitions);
+
         messages.push({ role: 'user', content: toolResults });
         continue;
       }

package/src/bot.js

@@ -2,6 +2,7 @@ import TelegramBot from 'node-telegram-bot-api';
 import { createReadStream } from 'fs';
 import { isAllowedUser, getUnauthorizedMessage } from './security/auth.js';
 import { getLogger } from './utils/logger.js';
+import { PROVIDERS } from './providers/models.js';
 
 function splitMessage(text, maxLength = 4096) {
   if (text.length <= maxLength) return [text];
@@ -22,9 +23,32 @@ function splitMessage(text, maxLength = 4096) {
   return chunks;
 }
 
+/**
+ * Simple per-chat queue to serialize agent processing.
+ * Each chat gets its own promise chain so messages are processed in order.
+ */
+class ChatQueue {
+  constructor() {
+    this.queues = new Map();
+  }
+
+  enqueue(chatId, fn) {
+    const key = String(chatId);
+    const prev = this.queues.get(key) || Promise.resolve();
+    const next = prev.then(() => fn()).catch(() => {});
+    this.queues.set(key, next);
+    return next;
+  }
+}
+
 export function startBot(config, agent, conversationManager) {
   const logger = getLogger();
   const bot = new TelegramBot(config.telegram.bot_token, { polling: true });
+  const chatQueue = new ChatQueue();
+  const batchWindowMs = config.telegram.batch_window_ms || 3000;
+
+  // Per-chat message batching: chatId -> { messages[], timer, resolve }
+  const chatBatches = new Map();
 
   // Load previous conversations from disk
   const loaded = conversationManager.load();
@@ -34,6 +58,124 @@ export function startBot(config, agent, conversationManager) {
 
   logger.info('Telegram bot started with polling');
 
+  // Track pending brain API key input: chatId -> { providerKey, modelId }
+  const pendingBrainKey = new Map();
+
+  // Handle inline keyboard callbacks for /brain
+  bot.on('callback_query', async (query) => {
+    const chatId = query.message.chat.id;
+    const data = query.data;
+
+    if (!isAllowedUser(query.from.id, config)) {
+      await bot.answerCallbackQuery(query.id, { text: 'Unauthorized' });
+      return;
+    }
+
+    try {
+      if (data.startsWith('brain_provider:')) {
+        // User picked a provider — show model list
+        const providerKey = data.split(':')[1];
+        const providerDef = PROVIDERS[providerKey];
+        if (!providerDef) {
+          await bot.answerCallbackQuery(query.id, { text: 'Unknown provider' });
+          return;
+        }
+
+        const modelButtons = providerDef.models.map((m) => ([{
+          text: m.label,
+          callback_data: `brain_model:${providerKey}:${m.id}`,
+        }]));
+        modelButtons.push([{ text: 'Cancel', callback_data: 'brain_cancel' }]);
+
+        await bot.editMessageText(`Select a *${providerDef.name}* model:`, {
+          chat_id: chatId,
+          message_id: query.message.message_id,
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: modelButtons },
+        });
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data.startsWith('brain_model:')) {
+        // User picked a model — attempt switch
+        const [, providerKey, modelId] = data.split(':');
+        const providerDef = PROVIDERS[providerKey];
+        const modelEntry = providerDef?.models.find((m) => m.id === modelId);
+        const modelLabel = modelEntry ? modelEntry.label : modelId;
+
+        const missing = agent.switchBrain(providerKey, modelId);
+        if (missing) {
+          // API key missing — ask for it
+          pendingBrainKey.set(chatId, { providerKey, modelId });
+          await bot.editMessageText(
+            `🔑 *${providerDef.name}* API key is required.\n\nPlease send your \`${missing}\` now.\n\nOr send *cancel* to abort.`,
+            {
+              chat_id: chatId,
+              message_id: query.message.message_id,
+              parse_mode: 'Markdown',
+            },
+          );
+        } else {
+          const info = agent.getBrainInfo();
+          await bot.editMessageText(
+            `🧠 Brain switched to *${info.providerName}* / *${info.modelLabel}*`,
+            {
+              chat_id: chatId,
+              message_id: query.message.message_id,
+              parse_mode: 'Markdown',
+            },
+          );
+        }
+        await bot.answerCallbackQuery(query.id);
+
+      } else if (data === 'brain_cancel') {
+        pendingBrainKey.delete(chatId);
+        await bot.editMessageText('Brain change cancelled.', {
+          chat_id: chatId,
+          message_id: query.message.message_id,
+        });
+        await bot.answerCallbackQuery(query.id);
+      }
+    } catch (err) {
+      logger.error(`Callback query error: ${err.message}`);
+      await bot.answerCallbackQuery(query.id, { text: 'Error' });
+    }
+  });
+
+  /**
+   * Batch messages for a chat. Returns the merged text for the first message,
+   * or null for subsequent messages (they get merged into the first).
+   */
+  function batchMessage(chatId, text) {
+    return new Promise((resolve) => {
+      const key = String(chatId);
+      let batch = chatBatches.get(key);
+
+      if (!batch) {
+        batch = { messages: [], timer: null, resolvers: [] };
+        chatBatches.set(key, batch);
+      }
+
+      batch.messages.push(text);
+      batch.resolvers.push(resolve);
+
+      // Reset timer on each new message
+      if (batch.timer) clearTimeout(batch.timer);
+
+      batch.timer = setTimeout(() => {
+        chatBatches.delete(key);
+        const merged = batch.messages.length === 1
+          ? batch.messages[0]
+          : batch.messages.map((m, i) => `[${i + 1}]: ${m}`).join('\n\n');
+
+        // First resolver gets the merged text, rest get null (skip)
+        batch.resolvers[0](merged);
+        for (let i = 1; i < batch.resolvers.length; i++) {
+          batch.resolvers[i](null);
+        }
+      }, batchWindowMs);
+    });
+  }
+
   bot.on('message', async (msg) => {
     if (!msg.text) return; // ignore non-text
 
@@ -50,7 +192,47 @@ export function startBot(config, agent, conversationManager) {
 
     let text = msg.text.trim();
 
-    // Handle commands
+    // Handle pending brain API key input
+    if (pendingBrainKey.has(chatId)) {
+      const pending = pendingBrainKey.get(chatId);
+      pendingBrainKey.delete(chatId);
+
+      if (text.toLowerCase() === 'cancel') {
+        await bot.sendMessage(chatId, 'Brain change cancelled.');
+        return;
+      }
+
+      agent.switchBrainWithKey(pending.providerKey, pending.modelId, text);
+      const info = agent.getBrainInfo();
+      await bot.sendMessage(
+        chatId,
+        `🧠 Brain switched to *${info.providerName}* / *${info.modelLabel}*\n\nAPI key saved.`,
+        { parse_mode: 'Markdown' },
+      );
+      return;
+    }
+
+    // Handle commands — these bypass batching entirely
+    if (text === '/brain') {
+      const info = agent.getBrainInfo();
+      const providerKeys = Object.keys(PROVIDERS);
+      const buttons = providerKeys.map((key) => ([{
+        text: `${PROVIDERS[key].name}${key === info.provider ? ' ✓' : ''}`,
+        callback_data: `brain_provider:${key}`,
+      }]));
+      buttons.push([{ text: 'Cancel', callback_data: 'brain_cancel' }]);
+
+      await bot.sendMessage(
+        chatId,
+        `🧠 *Current brain:* ${info.providerName} / ${info.modelLabel}\n\nSelect a provider to switch:`,
+        {
+          parse_mode: 'Markdown',
+          reply_markup: { inline_keyboard: buttons },
+        },
+      );
+      return;
+    }
+
     if (text === '/clean' || text === '/clear' || text === '/reset') {
       conversationManager.clear(chatId);
       logger.info(`Conversation cleared for chat ${chatId} by ${username}`);
@@ -68,6 +250,7 @@ export function startBot(config, agent, conversationManager) {
       await bot.sendMessage(chatId, [
         '*KernelBot Commands*',
         '',
+        '/brain — Show current AI model and switch provider/model',
         '/clean — Clear conversation and start fresh',
         '/history — Show message count in memory',
         '/browse <url> — Browse a website and get a summary',
@@ -106,91 +289,101 @@ export function startBot(config, agent, conversationManager) {
       text = `Extract content from ${extractUrl} using the CSS selector: ${extractSelector}`;
     }
 
-    logger.info(`Message from ${username} (${userId}): ${text.slice(0, 100)}`);
+    // Batch messages — wait for the batch window to close
+    const mergedText = await batchMessage(chatId, text);
+    if (mergedText === null) {
+      // This message was merged into another batch — skip
+      return;
+    }
+
+    logger.info(`Message from ${username} (${userId}): ${mergedText.slice(0, 100)}`);
 
-    // Show typing and keep refreshing it
-    const typingInterval = setInterval(() => {
+    // Enqueue into per-chat queue for serialized processing
+    chatQueue.enqueue(chatId, async () => {
+      // Show typing and keep refreshing it
+      const typingInterval = setInterval(() => {
+        bot.sendChatAction(chatId, 'typing').catch(() => {});
+      }, 4000);
       bot.sendChatAction(chatId, 'typing').catch(() => {});
-    }, 4000);
-    bot.sendChatAction(chatId, 'typing').catch(() => {});
 
-    try {
-      const onUpdate = async (update, opts = {}) => {
-        // Edit an existing message instead of sending a new one
-        if (opts.editMessageId) {
-          try {
-            const edited = await bot.editMessageText(update, {
-              chat_id: chatId,
-              message_id: opts.editMessageId,
-              parse_mode: 'Markdown',
-            });
-            return edited.message_id;
-          } catch {
+      try {
+        const onUpdate = async (update, opts = {}) => {
+          // Edit an existing message instead of sending a new one
+          if (opts.editMessageId) {
             try {
               const edited = await bot.editMessageText(update, {
                 chat_id: chatId,
                 message_id: opts.editMessageId,
+                parse_mode: 'Markdown',
               });
               return edited.message_id;
             } catch {
-              return opts.editMessageId;
+              try {
+                const edited = await bot.editMessageText(update, {
+                  chat_id: chatId,
+                  message_id: opts.editMessageId,
+                });
+                return edited.message_id;
+              } catch {
+                return opts.editMessageId;
+              }
             }
           }
-        }
 
-        // Send new message(s)
-        const parts = splitMessage(update);
-        let lastMsgId = null;
-        for (const part of parts) {
-          try {
-            const sent = await bot.sendMessage(chatId, part, { parse_mode: 'Markdown' });
-            lastMsgId = sent.message_id;
-          } catch {
-            const sent = await bot.sendMessage(chatId, part);
-            lastMsgId = sent.message_id;
+          // Send new message(s)
+          const parts = splitMessage(update);
+          let lastMsgId = null;
+          for (const part of parts) {
+            try {
+              const sent = await bot.sendMessage(chatId, part, { parse_mode: 'Markdown' });
+              lastMsgId = sent.message_id;
+            } catch {
+              const sent = await bot.sendMessage(chatId, part);
+              lastMsgId = sent.message_id;
+            }
           }
-        }
-        return lastMsgId;
-      };
-
-      const sendPhoto = async (filePath, caption) => {
-        try {
-          await bot.sendPhoto(chatId, createReadStream(filePath), {
-            caption: caption || '',
-            parse_mode: 'Markdown',
-          });
-        } catch {
+          return lastMsgId;
+        };
+
+        const sendPhoto = async (filePath, caption) => {
           try {
             await bot.sendPhoto(chatId, createReadStream(filePath), {
               caption: caption || '',
+              parse_mode: 'Markdown',
             });
-          } catch (err) {
-            logger.error(`Failed to send photo: ${err.message}`);
+          } catch {
+            try {
+              await bot.sendPhoto(chatId, createReadStream(filePath), {
+                caption: caption || '',
+              });
+            } catch (err) {
+              logger.error(`Failed to send photo: ${err.message}`);
+            }
+          }
+        };
+
+        const reply = await agent.processMessage(chatId, mergedText, {
+          id: userId,
+          username,
+        }, onUpdate, sendPhoto);
+
+        clearInterval(typingInterval);
+
+        const chunks = splitMessage(reply || 'Done.');
+        for (const chunk of chunks) {
+          try {
+            await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' });
+          } catch {
+            // Fallback to plain text if Markdown fails
+            await bot.sendMessage(chatId, chunk);
           }
         }
-      };
-
-      const reply = await agent.processMessage(chatId, text, {
-        id: userId,
-        username,
-      }, onUpdate, sendPhoto);
-
-      clearInterval(typingInterval);
-
-      const chunks = splitMessage(reply || 'Done.');
-      for (const chunk of chunks) {
-        try {
-          await bot.sendMessage(chatId, chunk, { parse_mode: 'Markdown' });
-        } catch {
-          // Fallback to plain text if Markdown fails
-          await bot.sendMessage(chatId, chunk);
-        }
+      } catch (err) {
+        clearInterval(typingInterval);
+        logger.error(`Error processing message: ${err.message}`);
+        await bot.sendMessage(chatId, `Error: ${err.message}`);
       }
-    } catch (err) {
-      clearInterval(typingInterval);
-      logger.error(`Error processing message: ${err.message}`);
-      await bot.sendMessage(chatId, `Error: ${err.message}`);
-    }
+    });
   });
 
   bot.on('polling_error', (err) => {

package/src/conversation.js

@@ -11,6 +11,7 @@ function getConversationsPath() {
 export class ConversationManager {
   constructor(config) {
     this.maxHistory = config.conversation.max_history;
+    this.recentWindow = config.conversation.recent_window || 10;
     this.conversations = new Map();
     this.filePath = getConversationsPath();
   }
@@ -49,6 +50,41 @@ export class ConversationManager {
     return this.conversations.get(key);
   }
 
+  /**
+   * Get history with older messages compressed into a summary.
+   * Keeps the last `recentWindow` messages verbatim and summarizes older ones.
+   */
+  getSummarizedHistory(chatId) {
+    const history = this.getHistory(chatId);
+
+    if (history.length <= this.recentWindow) {
+      return [...history];
+    }
+
+    const olderMessages = history.slice(0, history.length - this.recentWindow);
+    const recentMessages = history.slice(history.length - this.recentWindow);
+
+    // Compress older messages into a single summary
+    const summaryLines = olderMessages.map((msg) => {
+      const content = typeof msg.content === 'string'
+        ? msg.content.slice(0, 200)
+        : JSON.stringify(msg.content).slice(0, 200);
+      return `[${msg.role}]: ${content}`;
+    });
+
+    const summaryMessage = {
+      role: 'user',
+      content: `[CONVERSATION SUMMARY - ${olderMessages.length} earlier messages]\n${summaryLines.join('\n')}`,
+    };
+
+    // Ensure result starts with user role
+    const result = [summaryMessage, ...recentMessages];
+
+    // If the first real message after summary is assistant, that's fine since
+    // our summary is role:user. But ensure recent starts correctly.
+    return result;
+  }
+
   addMessage(chatId, role, content) {
     const history = this.getHistory(chatId);
     history.push({ role, content });

package/src/prompts/system.js

@@ -1,46 +1,32 @@
-import { toolDefinitions } from '../tools/index.js';
-
 export function getSystemPrompt(config) {
-  const toolList = toolDefinitions.map((t) => `- ${t.name}: ${t.description}`).join('\n');
-
-  return `You are ${config.bot.name}, a senior software engineer and sysadmin AI agent.
-You talk to the user via Telegram. You are confident, concise, and effective.
-
-You have full access to the operating system through your tools:
-${toolList}
-
-## Coding Tasks (writing code, fixing bugs, reviewing code, scaffolding projects)
-IMPORTANT: You MUST NOT write code yourself using read_file/write_file. ALWAYS delegate coding to Claude Code.
-1. Use git tools to clone the repo and create a branch
-2. Use spawn_claude_code to do the actual coding work inside the repo — give it a clear, detailed prompt describing exactly what to build or fix
-3. After Claude Code finishes, use git tools to commit and push
-4. Use GitHub tools to create the PR
-5. Report back with the PR link
-
-## Web Browsing Tasks (researching, scraping, reading documentation, taking screenshots)
-- Use browse_website to read and summarize web pages
-- Use screenshot_website to capture visual snapshots of pages — the screenshot is automatically sent to the chat
-- Use extract_content to pull specific data from pages using CSS selectors
-- Use interact_with_page for pages that need clicking, typing, or scrolling to reveal content
-- Use send_image to send any image file directly to the Telegram chat (screenshots, generated images, etc.)
-- When a user sends /browse <url>, use browse_website on that URL
-- When a user sends /screenshot <url>, use screenshot_website on that URL
-- When a user sends /extract <url> <selector>, use extract_content with that URL and selector
-
-You are the orchestrator. Claude Code is the coder. Never use read_file + write_file to modify source code — that's Claude Code's job. You handle git, GitHub, and infrastructure. Claude Code handles all code changes.
-
-
-## Non-Coding Tasks (monitoring, deploying, restarting services, checking status)
-- Use OS, Docker, process, network, and monitoring tools directly
-- No need to spawn Claude Code for these
+  return `You are ${config.bot.name}, a senior software engineer and sysadmin AI agent on Telegram. Be concise — this is chat, not documentation.
+
+## Coding Tasks
+NEVER write code yourself with read_file/write_file. ALWAYS use spawn_claude_code.
+1. Clone repo + create branch (git tools)
+2. spawn_claude_code with a clear, detailed prompt
+3. Commit + push (git tools)
+4. Create PR (GitHub tools) and report the link
+
+## Web Browsing
+- browse_website: read/summarize pages
+- screenshot_website: visual snapshots (auto-sent to chat)
+- extract_content: pull data via CSS selectors
+- interact_with_page: click/type/scroll on pages
+- send_image: send any image file to chat
+
+## Non-Coding Tasks
+Use OS, Docker, process, network, and monitoring tools directly. No need for Claude Code.
+
+## Efficiency Rules
+- Chain shell commands with && in execute_command instead of multiple calls
+- Read multiple files with one execute_command("cat file1 file2") instead of multiple read_file calls
+- Plan first, gather info in one step, then act
+- Keep responses under 500 words unless asked for details
 
 ## Guidelines
-- Use tools proactively to complete tasks. Don't just describe what you would do — do it.
-- When a task requires multiple steps, execute them in sequence using tools.
-- If a command fails, analyze the error and try an alternative approach.
-- Be concise — you're talking on Telegram, not writing essays.
-- For destructive operations (rm, kill, service stop, force push), confirm with the user first.
-- Never expose API keys, tokens, or secrets in your responses.
-- If a task will take a while, tell the user upfront.
-- If something fails, explain what went wrong and suggest a fix.`;
+- Use tools proactively — don't describe what you'd do, just do it.
+- If a command fails, analyze and try an alternative.
+- For destructive ops (rm, kill, force push), confirm with the user first.
+- Never expose secrets in responses.`;
 }

package/src/tools/categories.js

@@ -0,0 +1,101 @@
+/**
+ * Smart tool filtering — send only relevant tools per request to save tokens.
+ */
+
+export const TOOL_CATEGORIES = {
+  core: ['execute_command', 'read_file', 'write_file', 'list_directory'],
+  git: ['git_clone', 'git_checkout', 'git_commit', 'git_push', 'git_diff'],
+  github: ['github_create_pr', 'github_get_pr_diff', 'github_post_review', 'github_create_repo', 'github_list_prs'],
+  coding: ['spawn_claude_code'],
+  docker: ['docker_ps', 'docker_logs', 'docker_exec', 'docker_compose'],
+  process: ['process_list', 'kill_process', 'service_control'],
+  monitor: ['disk_usage', 'memory_usage', 'cpu_usage', 'system_logs'],
+  network: ['check_port', 'curl_url', 'nginx_reload'],
+  browser: ['browse_website', 'screenshot_website', 'extract_content', 'send_image', 'interact_with_page'],
+  jira: ['jira_get_ticket', 'jira_search_tickets', 'jira_list_my_tickets', 'jira_get_project_tickets'],
+};
+
+const CATEGORY_KEYWORDS = {
+  coding: ['code', 'fix', 'bug', 'implement', 'refactor', 'build', 'feature', 'develop', 'program', 'write code', 'add feature', 'change', 'update', 'modify', 'create app', 'scaffold', 'debug', 'patch', 'review'],
+  git: ['git', 'commit', 'branch', 'merge', 'clone', 'pull', 'push', 'diff', 'stash', 'rebase', 'checkout', 'repo'],
+  github: ['pr', 'pull request', 'github', 'review', 'merge request'],
+  docker: ['docker', 'container', 'compose', 'image', 'kubernetes', 'k8s'],
+  process: ['process', 'kill', 'restart', 'service', 'daemon', 'systemctl', 'pid'],
+  monitor: ['disk', 'memory', 'cpu', 'usage', 'monitor', 'logs', 'status', 'health', 'space'],
+  network: ['port', 'curl', 'http', 'nginx', 'network', 'api', 'endpoint', 'request', 'url', 'fetch'],
+  browser: ['browse', 'screenshot', 'scrape', 'website', 'web page', 'webpage', 'extract content', 'html', 'css selector'],
+  jira: ['jira', 'ticket', 'issue', 'sprint', 'backlog', 'story', 'epic'],
+};
+
+// Categories that imply other categories
+const CATEGORY_DEPS = {
+  coding: ['git', 'github'],
+  github: ['git'],
+};
+
+/**
+ * Select relevant tools for a user message based on keyword matching.
+ * Always includes 'core' tools. Falls back to ALL tools if nothing specific matched.
+ */
+export function selectToolsForMessage(userMessage, allTools) {
+  const lower = userMessage.toLowerCase();
+  const matched = new Set(['core']);
+
+  for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+    for (const kw of keywords) {
+      if (lower.includes(kw)) {
+        matched.add(category);
+        // Add dependencies
+        const deps = CATEGORY_DEPS[category];
+        if (deps) deps.forEach((d) => matched.add(d));
+        break;
+      }
+    }
+  }
+
+  // Fallback: if only core matched, the request is ambiguous — send all tools
+  if (matched.size === 1) {
+    return allTools;
+  }
+
+  // Build the filtered tool name set
+  const toolNames = new Set();
+  for (const cat of matched) {
+    const names = TOOL_CATEGORIES[cat];
+    if (names) names.forEach((n) => toolNames.add(n));
+  }
+
+  return allTools.filter((t) => toolNames.has(t.name));
+}
+
+/**
+ * After a tool is used, expand the tool set to include related categories
+ * so the model can use follow-up tools it might need.
+ */
+export function expandToolsForUsed(usedToolNames, currentTools, allTools) {
+  const currentNames = new Set(currentTools.map((t) => t.name));
+  const needed = new Set();
+
+  for (const name of usedToolNames) {
+    // Find which category this tool belongs to
+    for (const [cat, tools] of Object.entries(TOOL_CATEGORIES)) {
+      if (tools.includes(name)) {
+        // Add deps for that category
+        const deps = CATEGORY_DEPS[cat];
+        if (deps) {
+          for (const dep of deps) {
+            for (const t of TOOL_CATEGORIES[dep]) {
+              if (!currentNames.has(t)) needed.add(t);
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  if (needed.size === 0) return currentTools;
+
+  const extra = allTools.filter((t) => needed.has(t.name));
+  return [...currentTools, ...extra];
+}

package/src/utils/config.js

@@ -15,12 +15,13 @@ const DEFAULTS = {
   brain: {
     provider: 'anthropic',
     model: 'claude-sonnet-4-20250514',
-    max_tokens: 8192,
+    max_tokens: 4096,
     temperature: 0.3,
-    max_tool_depth: 25,
+    max_tool_depth: 12,
   },
   telegram: {
     allowed_users: [],
+    batch_window_ms: 3000,
   },
   claude_code: {
     model: 'claude-opus-4-6',
@@ -46,6 +47,7 @@ const DEFAULTS = {
   },
   conversation: {
     max_history: 50,
+    recent_window: 10,
   },
 };