obol-ai 0.2.2 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Self-evolving AI assistant that learns, remembers, and acts on its own. Persistent vector memory, self-rewriting personality, proactive heartbeats.",
   "main": "src/index.js",
   "bin": {

package/src/claude.js

@@ -7,7 +7,7 @@ const { saveConfig, loadConfig, OBOL_DIR } = require('./config');
 const { execAsync, isAllowedUrl } = require('./sanitize');
 
 const MAX_EXEC_TIMEOUT = 120;
-const MAX_TOOL_ITERATIONS = 15;
+let MAX_TOOL_ITERATIONS = 100;
 
 const BLOCKED_EXEC_PATTERNS = [
   /\brm\s+(-[a-zA-Z]*f|-[a-zA-Z]*r|--force|--recursive)\b/,
@@ -124,6 +124,24 @@ async function ensureFreshToken(anthropicConfig) {
   }
 }
 
+function repairHistory(history) {
+  for (let i = 0; i < history.length; i++) {
+    const msg = history[i];
+    if (msg.role !== 'assistant' || !Array.isArray(msg.content)) continue;
+    const toolUseIds = msg.content.filter(b => b.type === 'tool_use').map(b => b.id);
+    if (toolUseIds.length === 0) continue;
+    const next = history[i + 1];
+    const hasResults = next?.role === 'user' && Array.isArray(next.content) &&
+      toolUseIds.every(id => next.content.some(b => b.type === 'tool_result' && b.tool_use_id === id));
+    if (!hasResults) {
+      const fakeResults = toolUseIds.map(id => ({
+        type: 'tool_result', tool_use_id: id, content: '[interrupted]',
+      }));
+      history.splice(i + 1, 0, { role: 'user', content: fakeResults });
+    }
+  }
+}
+
 function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR, bridgeEnabled }) {
   let client = createAnthropicClient(anthropicConfig);
 
@@ -151,7 +169,10 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
     if (!histories.has(chatId)) histories.set(chatId, []);
     const history = histories.get(chatId);
 
-    // Ask Haiku if we need memory for this message
+    const verbose = context.verbose || false;
+    if (verbose) context.verboseLog = [];
+    const vlog = (msg) => { if (verbose) context.verboseLog.push(msg); };
+
     let memoryContext = '';
     if (memory) {
       try {
@@ -179,7 +200,8 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
           if (jsonStr) decision = JSON.parse(jsonStr);
         } catch {}
 
-        // Set model based on Haiku's decision
+        vlog(`[router] model=${decision.model || 'sonnet'} memory=${decision.need_memory || false}${decision.search_query ? ` query="${decision.search_query}"` : ''}`);
+
         if (decision.model === 'opus') {
           context._model = 'claude-opus-4-6';
         }
@@ -187,11 +209,9 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
         if (decision.need_memory) {
           const query = decision.search_query || userMessage;
 
-          // Today's context + semantic search
           const todayMemories = await memory.byDate('today', { limit: 3 });
           const semanticMemories = await memory.search(query, { limit: 3, threshold: 0.5 });
 
-          // Dedupe by ID
           const seen = new Set();
           const combined = [];
           for (const m of [...todayMemories, ...semanticMemories]) {
@@ -201,6 +221,8 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
             }
           }
 
+          vlog(`[memory] ${combined.length} memories found (${todayMemories.length} today, ${semanticMemories.length} semantic)`);
+
           if (combined.length > 0) {
             memoryContext = '\n\n[Relevant memories]\n' +
               combined.map(m => `- [${m.category}] ${m.content}`).join('\n');
@@ -208,6 +230,7 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
         }
       } catch (e) {
         console.error('[router] Memory/routing decision failed:', e.message);
+        vlog(`[router] ERROR: ${e.message}`);
       }
     }
 
@@ -227,6 +250,7 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
       }
       break;
     }
+    repairHistory(history);
 
     // Add user message with memory context
     const enrichedMessage = memoryContext
@@ -241,8 +265,8 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
       history.push({ role: 'user', content: enrichedMessage });
     }
 
-    // Call Claude — Haiku picks the model
     const model = context._model || 'claude-sonnet-4-6';
+    vlog(`[model] ${model} | history=${history.length} msgs`);
     const systemPrompt = baseSystemPrompt + `\nCurrent time: ${new Date().toISOString()}`;
     let response = await client.messages.create({
       model,
@@ -256,8 +280,15 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
     while (response.stop_reason === 'tool_use') {
       toolIterations++;
       if (toolIterations > MAX_TOOL_ITERATIONS) {
-        history.push({ role: 'assistant', content: response.content });
-        history.push({ role: 'user', content: 'You have used too many tool calls. Please provide a final response now based on what you have so far.' });
+        const bailoutContent = response.content;
+        history.push({ role: 'assistant', content: bailoutContent });
+        const bailoutResults = bailoutContent
+          .filter(b => b.type === 'tool_use')
+          .map(b => ({ type: 'tool_result', tool_use_id: b.id, content: '[max tool iterations reached]' }));
+        history.push({ role: 'user', content: [
+          ...bailoutResults,
+          { type: 'text', text: 'You have used too many tool calls. Please provide a final response now based on what you have so far.' },
+        ] });
         response = await client.messages.create({
           model,
           max_tokens: 4096,
@@ -273,6 +304,15 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
       const toolResults = [];
       for (const block of assistantContent) {
         if (block.type === 'tool_use') {
+          const inputSummary = block.name === 'exec' ? block.input.command :
+            block.name === 'write_file' ? block.input.path :
+            block.name === 'read_file' ? block.input.path :
+            block.name === 'memory_search' ? block.input.query :
+            block.name === 'memory_add' ? `[${block.input.category || 'fact'}]` :
+            block.name === 'web_fetch' ? block.input.url :
+            block.name === 'background_task' ? block.input.task?.substring(0, 60) :
+            JSON.stringify(block.input).substring(0, 80);
+          vlog(`[tool] ${block.name}: ${inputSummary}`);
           const result = await executeToolCall(block, memory, context);
           toolResults.push({
             type: 'tool_result',
@@ -293,11 +333,13 @@ Model: Use "sonnet" for most things (chat, simple questions, quick tasks, single
       });
     }
 
-    // Extract text response
     const textBlocks = response.content.filter(b => b.type === 'text');
     const replyText = textBlocks.map(b => b.text).join('\n');
 
-    // Add assistant response to history
+    if (response.usage) {
+      vlog(`[tokens] in=${response.usage.input_tokens} out=${response.usage.output_tokens}`);
+    }
+
     history.push({ role: 'assistant', content: response.content });
 
     return replyText;
@@ -618,6 +660,20 @@ function buildTools(memory, opts = {}) {
     },
   });
 
+  tools.push({
+    name: 'telegram_ask',
+    description: 'Send a message to the user with inline keyboard buttons and wait for their tap. Use for human-in-the-loop decisions: confirmations, approvals, action selection. Returns the label of the button the user pressed, or "timeout" if they don\'t respond within the timeout.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        message: { type: 'string', description: 'Question or prompt to show the user' },
+        options: { type: 'array', items: { type: 'string' }, description: 'Button labels (2-6 options, keep each label short)' },
+        timeout: { type: 'number', description: 'Seconds to wait for response (default 60)' },
+      },
+      required: ['message', 'options'],
+    },
+  });
+
   if (opts.bridgeEnabled) {
     const { buildBridgeTool, buildBridgeTellTool } = require('./bridge');
     tools.push(buildBridgeTool());
@@ -832,6 +888,11 @@ async function executeToolCall(toolUse, memory, context = {}) {
         return `Sent: ${path.basename(filePath)}`;
       }
 
+      case 'telegram_ask': {
+        if (!context.telegramAsk) return 'telegram_ask not available in this context.';
+        return await context.telegramAsk(input.message, input.options || [], input.timeout);
+      }
+
       case 'bridge_ask': {
         const { bridgeAsk } = require('./bridge');
         return await bridgeAsk(input.question, context.userId, context.config, context._notifyFn, input.partner_id);
@@ -850,4 +911,7 @@ async function executeToolCall(toolUse, memory, context = {}) {
   }
 }
 
-module.exports = { createClaude, createAnthropicClient };
+function getMaxToolIterations() { return MAX_TOOL_ITERATIONS; }
+function setMaxToolIterations(n) { MAX_TOOL_ITERATIONS = n; }
+
+module.exports = { createClaude, createAnthropicClient, getMaxToolIterations, setMaxToolIterations };

package/src/defaults/AGENTS.md

@@ -44,6 +44,16 @@ Users can also manage secrets via Telegram: `/secret set <key> <value>` (message
 ### Send File (`send_file`)
 Send a file back to the user via Telegram. Use after generating PDFs, images, documents, or any file the user requested.
 
+### Ask User (`telegram_ask`)
+Send a message with inline keyboard buttons and wait for the user to tap one. Use for human-in-the-loop decisions before taking action.
+
+Examples:
+- After listing emails: `telegram_ask({message: "Open any of these?", options: ["#1 Google", "#2 LinkedIn", "#3 DeepLearning", "None"]})`
+- Before sending a reply: `telegram_ask({message: "Send this reply?", options: ["Send it", "Edit first", "Cancel"]})`
+- Before an irreversible action: `telegram_ask({message: "Archive all read emails?", options: ["Yes", "No"]})`
+
+Returns the tapped button label, or `"timeout"` if the user doesn't respond within the timeout (default 60s).
+
 ### Bridge (`bridge_ask`, `bridge_tell`)
 Only available if bridge is enabled. Communicate with partner's AI agent.
 
@@ -138,6 +148,29 @@ Use `background_task` when a request will take multiple steps:
 
 Pattern: acknowledge immediately ("On it"), spawn the task, let it work in the background.
 
+## Telegram Formatting
+
+You communicate via Telegram. Format responses for mobile readability.
+
+**Never use markdown tables** — pipe-syntax tables do not render in Telegram. Use numbered lists instead.
+
+**Email/inbox lists** — use this pattern:
+```
+📬 *Inbox (10)*
+
+1\. *Google* — Security alert `22:58`
+2\. *LinkedIn* — Matthew Chittle wants to connect `21:31`
+3\. *DeepLearning\.AI* — AI Dev 26 × SF speakers `13:20`
+4\. *LinkedIn Jobs* — Project Manager / TPM roles `17:32`
+```
+
+**Copyable values** (email addresses, URLs, API keys, commands) — wrap in backtick code spans:
+`user@example.com`, `https://example.com`, `npm install foo`
+
+**Human-in-the-loop** — after listing emails or before acting, use `telegram_ask` to offer inline buttons rather than asking the user to type a reply.
+
+**Keep lines short** — Telegram wraps long lines poorly on mobile. Break at natural points.
+
 ## Communication Style
 
 - Be direct and helpful

package/src/telegram.js

@@ -1,11 +1,12 @@
 const path = require('path');
-const { Bot, GrammyError, HttpError } = require('grammy');
+const { Bot, GrammyError, HttpError, InlineKeyboard } = require('grammy');
 const { loadConfig } = require('./config');
 const { evolve, loadEvolutionState } = require('./evolve');
 const { getTenant } = require('./tenant');
 const { loadTraits, saveTraits, DEFAULT_TRAITS } = require('./personality');
 const media = require('./media');
 const credentials = require('./credentials');
+const { getMaxToolIterations, setMaxToolIterations } = require('./claude');
 
 const RATE_LIMIT_MS = 3000;
 const SPAM_THRESHOLD = 5;
@@ -23,6 +24,31 @@ function createBot(telegramConfig, config) {
   const bot = new Bot(telegramConfig.token);
   const allowedUsers = new Set(telegramConfig.allowedUsers || []);
   const rateLimits = new Map();
+  const pendingAsks = new Map();
+  let askIdCounter = 0;
+
+  function createAsk(ctx, message, options, timeoutSecs = 60) {
+    return new Promise((resolve) => {
+      const askId = ++askIdCounter;
+      const keyboard = new InlineKeyboard();
+      options.forEach((opt, i) => {
+        keyboard.text(opt, `ask:${askId}:${i}`);
+        if ((i + 1) % 3 === 0 && i < options.length - 1) keyboard.row();
+      });
+      const timer = setTimeout(() => {
+        if (pendingAsks.has(askId)) {
+          pendingAsks.delete(askId);
+          resolve('timeout');
+        }
+      }, timeoutSecs * 1000);
+      pendingAsks.set(askId, { resolve, options, timer });
+      ctx.reply(message, { parse_mode: 'Markdown', reply_markup: keyboard }).catch(() => {
+        clearTimeout(timer);
+        pendingAsks.delete(askId);
+        resolve('error');
+      });
+    });
+  }
 
   const _rateLimitCleanup = setInterval(() => {
     const now = Date.now();
@@ -51,6 +77,8 @@ function createBot(telegramConfig, config) {
     { command: 'traits', description: 'View or adjust personality traits' },
     { command: 'secret', description: 'Manage per-user secrets' },
     { command: 'evolution', description: 'Evolution progress' },
+    { command: 'verbose', description: 'Toggle verbose mode on/off' },
+    { command: 'toolimit', description: 'View or set max tool iterations per message' },
     { command: 'help', description: 'Show available commands' },
   ]).catch(() => {});
 
@@ -102,6 +130,7 @@ function createBot(telegramConfig, config) {
     text += `⏱️ Uptime: ${h}h ${m}m\n`;
     text += `💾 Memory: ${mem}MB\n`;
     text += `⚡ Tasks: ${running.length} running\n`;
+    text += `🔧 Tool limit: ${getMaxToolIterations()}\n`;
 
     if (tenant.memory) {
       const stats = await tenant.memory.stats().catch(() => null);
@@ -338,9 +367,38 @@ Your message is deleted immediately when using /secret set to keep credentials o
 /status — Bot status and uptime
 /backup — Trigger GitHub backup
 /clean — Audit workspace
+/verbose — Toggle verbose mode on/off
+/toolimit — View or set max tool iterations
 /help — This message`);
   });
 
+  bot.command('verbose', async (ctx) => {
+    if (!ctx.from) return;
+    const tenant = await getTenant(ctx.from.id, config);
+    tenant.verbose = !tenant.verbose;
+    await ctx.reply(tenant.verbose ? '🔍 Verbose mode ON' : '🔇 Verbose mode OFF');
+  });
+
+  bot.command('toolimit', async (ctx) => {
+    if (!ctx.from) return;
+    const args = ctx.message.text.split(' ').slice(1);
+    const current = getMaxToolIterations();
+
+    if (!args[0]) {
+      await ctx.reply(`🔧 Max tool iterations: ${current}\n\nThis limits how many tool calls OBOL can make per message. Higher = more complex tasks, but slower responses.\n\nSet: /toolimit <number>\nExample: /toolimit 50`);
+      return;
+    }
+
+    const value = parseInt(args[0], 10);
+    if (isNaN(value) || value < 1 || value > 500) {
+      await ctx.reply(`Invalid value: "${args[0]}"\n\nMust be a number between 1 and 500.\nCurrent: ${current}\n\nExample: /toolimit 50`);
+      return;
+    }
+
+    setMaxToolIterations(value);
+    await ctx.reply(`🔧 Max tool iterations set to ${value}`);
+  });
+
   function checkRateLimit(userId) {
     const now = Date.now();
     const userLimit = rateLimits.get(userId) || { lastMessage: 0, spamCount: 0, cooldownUntil: 0 };
@@ -392,7 +450,7 @@ Your message is deleted immediately when using /secret set to keep credentials o
     try {
       tenant.messageLog?.log(ctx.chat.id, 'user', userMessage);
 
-      const response = await tenant.claude.chat(userMessage, {
+      const chatContext = {
         userId,
         userName,
         chatId: ctx.chat.id,
@@ -400,14 +458,24 @@ Your message is deleted immediately when using /secret set to keep credentials o
         ctx,
         claude: tenant.claude,
         config,
+        verbose: tenant.verbose,
+        telegramAsk: (message, options, timeout) => createAsk(ctx, message, options, timeout),
         _notifyFn: (targetUserId, message) => {
           if (!allowedUsers.has(targetUserId)) throw new Error('Cannot notify user outside allowed list');
           return bot.api.sendMessage(targetUserId, message);
         },
-      });
+      };
+      const response = await tenant.claude.chat(userMessage, chatContext);
 
       tenant.messageLog?.log(ctx.chat.id, 'assistant', response);
 
+      if (tenant.verbose && chatContext.verboseLog?.length) {
+        const verboseText = '```\n' + chatContext.verboseLog.join('\n') + '\n```';
+        await ctx.reply(verboseText, { parse_mode: 'Markdown' }).catch(() =>
+          ctx.reply(verboseText).catch(() => {})
+        );
+      }
+
       if (tenant.messageLog?._evolutionReady) {
         tenant.messageLog._evolutionReady = false;
         setImmediate(async () => {
@@ -525,7 +593,7 @@ Your message is deleted immediately when using /secret set to keep credentials o
       if (media.isImage(fileInfo)) {
         const imageBlock = media.bufferToImageBlock(buffer, fileInfo.mimeType);
         const prompt = caption || 'The user sent this image. Describe what you see and respond naturally.';
-        const response = await tenant.claude.chat(prompt, {
+        const mediaChatCtx = {
           userId,
           userName: ctx.from.first_name || 'User',
           chatId: ctx.chat.id,
@@ -533,16 +601,23 @@ Your message is deleted immediately when using /secret set to keep credentials o
           ctx,
           claude: tenant.claude,
           config,
+          verbose: tenant.verbose,
           images: [imageBlock],
           _notifyFn: (targetUserId, message) => {
             if (!allowedUsers.has(targetUserId)) throw new Error('Cannot notify user outside allowed list');
             return bot.api.sendMessage(targetUserId, message);
           },
-        });
+        };
+        const response = await tenant.claude.chat(prompt, mediaChatCtx);
 
         tenant.messageLog?.log(ctx.chat.id, 'user', `[${fileInfo.mediaType}] ${caption || filename}`);
         tenant.messageLog?.log(ctx.chat.id, 'assistant', response);
 
+        if (tenant.verbose && mediaChatCtx.verboseLog?.length) {
+          const verboseText = '```\n' + mediaChatCtx.verboseLog.join('\n') + '\n```';
+          await ctx.reply(verboseText, { parse_mode: 'Markdown' }).catch(() => ctx.reply(verboseText).catch(() => {}));
+        }
+
         stopTyping();
         if (response.length > 4096) {
           for (const chunk of splitMessage(response, 4096)) {
@@ -553,7 +628,7 @@ Your message is deleted immediately when using /secret set to keep credentials o
         }
       } else if (caption) {
         const contextMsg = `[User sent a ${fileInfo.mediaType}: ${filename}] ${caption}`;
-        const response = await tenant.claude.chat(contextMsg, {
+        const mediaCaptionCtx = {
           userId,
           userName: ctx.from.first_name || 'User',
           chatId: ctx.chat.id,
@@ -561,15 +636,22 @@ Your message is deleted immediately when using /secret set to keep credentials o
           ctx,
           claude: tenant.claude,
           config,
+          verbose: tenant.verbose,
           _notifyFn: (targetUserId, message) => {
             if (!allowedUsers.has(targetUserId)) throw new Error('Cannot notify user outside allowed list');
             return bot.api.sendMessage(targetUserId, message);
           },
-        });
+        };
+        const response = await tenant.claude.chat(contextMsg, mediaCaptionCtx);
 
         tenant.messageLog?.log(ctx.chat.id, 'user', contextMsg);
         tenant.messageLog?.log(ctx.chat.id, 'assistant', response);
 
+        if (tenant.verbose && mediaCaptionCtx.verboseLog?.length) {
+          const verboseText = '```\n' + mediaCaptionCtx.verboseLog.join('\n') + '\n```';
+          await ctx.reply(verboseText, { parse_mode: 'Markdown' }).catch(() => ctx.reply(verboseText).catch(() => {}));
+        }
+
         stopTyping();
         if (response.length > 4096) {
           for (const chunk of splitMessage(response, 4096)) {
@@ -598,6 +680,22 @@ Your message is deleted immediately when using /secret set to keep credentials o
   bot.on('message:animation', handleMedia);
   bot.on('message:video_note', handleMedia);
 
+  bot.on('callback_query:data', async (ctx) => {
+    const data = ctx.callbackQuery.data;
+    if (!data.startsWith('ask:')) return ctx.answerCallbackQuery();
+    const parts = data.split(':');
+    const askId = parseInt(parts[1]);
+    const optIdx = parseInt(parts[2]);
+    const pending = pendingAsks.get(askId);
+    if (!pending) return ctx.answerCallbackQuery({ text: 'Expired' });
+    const selected = pending.options[optIdx];
+    clearTimeout(pending.timer);
+    pendingAsks.delete(askId);
+    await ctx.editMessageText(`${ctx.callbackQuery.message.text}\n\n✓ _${selected}_`, { parse_mode: 'Markdown' }).catch(() => {});
+    await ctx.answerCallbackQuery({ text: selected });
+    pending.resolve(selected);
+  });
+
   bot.catch((err) => {
     const ctx = err.ctx;
     const e = err.error;

package/src/tenant.js

@@ -43,6 +43,7 @@ async function createTenant(userId, config) {
 
   return {
     claude, memory, messageLog, personality, bg, userDir, userId,
+    verbose: false,
     _personalityLoadedAt: Date.now(),
     _personalityMtime: personalityMtime,
   };