kernelbot 1.0.24 → 1.0.26

package/src/agent.js

@@ -1,18 +1,105 @@
-import Anthropic from '@anthropic-ai/sdk';
+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 }) {
     this.config = config;
     this.conversationManager = conversationManager;
-    this.client = new Anthropic({ apiKey: config.anthropic.api_key });
+    this.provider = createProvider(config);
     this.systemPrompt = getSystemPrompt(config);
     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();
 
@@ -33,15 +120,19 @@ export class Agent {
       }
     }
 
-    const { max_tool_depth } = this.config.anthropic;
+    const { max_tool_depth } = this.config.brain;
 
     // 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.anthropic;
-    return await this._runLoop(chatId, pending.messages, user, 0, max_tool_depth);
+    const { max_tool_depth } = this.config.brain;
+    return await this._runLoop(chatId, pending.messages, user, 0, max_tool_depth, pending.tools || toolDefinitions);
   }
 
   _checkPause(chatId, block, user, toolResults, remainingBlocks, messages) {
@@ -201,58 +292,48 @@ export class Agent {
     return null;
   }
 
-  async _runLoop(chatId, messages, user, startDepth, maxDepth) {
+  async _runLoop(chatId, messages, user, startDepth, maxDepth, tools) {
     const logger = getLogger();
-    const { model, max_tokens, temperature } = this.config.anthropic;
+    let currentTools = tools || toolDefinitions;
 
     for (let depth = startDepth; depth < maxDepth; depth++) {
       logger.debug(`Agent loop iteration ${depth + 1}/${maxDepth}`);
 
-      const response = await this.client.messages.create({
-        model,
-        max_tokens,
-        temperature,
+      const response = await this.provider.chat({
         system: this.systemPrompt,
-        tools: toolDefinitions,
         messages,
+        tools: currentTools,
       });
 
-      if (response.stop_reason === 'end_turn') {
-        const textBlocks = response.content
-          .filter((b) => b.type === 'text')
-          .map((b) => b.text);
-        const reply = textBlocks.join('\n');
-
+      if (response.stopReason === 'end_turn') {
+        const reply = response.text || '';
         this.conversationManager.addMessage(chatId, 'assistant', reply);
         return reply;
       }
 
-      if (response.stop_reason === 'tool_use') {
-        messages.push({ role: 'assistant', content: response.content });
+      if (response.stopReason === 'tool_use') {
+        messages.push({ role: 'assistant', content: response.rawContent });
 
-        // Send Claude's thinking text to the user
-        const thinkingBlocks = response.content.filter((b) => b.type === 'text' && b.text.trim());
-        if (thinkingBlocks.length > 0) {
-          const thinking = thinkingBlocks.map((b) => b.text).join('\n');
-          logger.info(`Agent thinking: ${thinking.slice(0, 200)}`);
-          await this._sendUpdate(`💭 ${thinking}`);
+        // Send thinking text to the user
+        if (response.text && response.text.trim()) {
+          logger.info(`Agent thinking: ${response.text.slice(0, 200)}`);
+          await this._sendUpdate(`💭 ${response.text}`);
         }
 
-        const toolUseBlocks = response.content.filter((b) => b.type === 'tool_use');
         const toolResults = [];
+        const usedToolNames = [];
 
-        for (let i = 0; i < toolUseBlocks.length; i++) {
-          const block = toolUseBlocks[i];
+        for (let i = 0; i < response.toolCalls.length; i++) {
+          const block = response.toolCalls[i];
+
+          // Build a block-like object for _checkPause (needs .type for remainingBlocks filter)
+          const blockObj = { type: 'tool_use', id: block.id, name: block.name, input: block.input };
 
           // Check if we need to pause (missing cred or dangerous action)
-          const pauseMsg = this._checkPause(
-            chatId,
-            block,
-            user,
-            toolResults,
-            toolUseBlocks.slice(i + 1),
-            messages,
-          );
+          const remaining = response.toolCalls.slice(i + 1).map((tc) => ({
+            type: 'tool_use', id: tc.id, name: tc.name, input: tc.input,
+          }));
+          const pauseMsg = this._checkPause(chatId, blockObj, user, toolResults, remaining, messages);
           if (pauseMsg) return pauseMsg;
 
           const summary = this._formatToolSummary(block.name, block.input);
@@ -266,26 +347,27 @@ 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;
       }
 
       // Unexpected stop reason
-      logger.warn(`Unexpected stop_reason: ${response.stop_reason}`);
-      const fallbackText = response.content
-        .filter((b) => b.type === 'text')
-        .map((b) => b.text)
-        .join('\n');
-      if (fallbackText) {
-        this.conversationManager.addMessage(chatId, 'assistant', fallbackText);
-        return fallbackText;
+      logger.warn(`Unexpected stopReason: ${response.stopReason}`);
+      if (response.text) {
+        this.conversationManager.addMessage(chatId, 'assistant', response.text);
+        return response.text;
       }
       return 'Something went wrong — unexpected response from the model.';
     }

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) => {