obol-ai 0.2.18 → 0.2.20

package/.claude/settings.local.json

@@ -3,7 +3,8 @@
     "allow": [
       "Bash(*)",
       "mcp__context7__query-docs",
-      "mcp__context7__resolve-library-id"
+      "mcp__context7__resolve-library-id",
+      "Bash(gh repo clone:*)"
     ]
   }
-}
+}

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.2.20
+- increase tool iterations to 100 and max tokens to 128K
+- update changelog
+
+## 0.2.19
+- add location, venue, contact, poll message support
+- update changelog
+
 ## 0.2.18
 - remove evolution progress bar from status UI
 - bidirectional bridge with reply button + memory_remove tool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.2.18",
+  "version": "0.2.20",
   "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/chat.js

@@ -120,7 +120,7 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
       const toolDefs = runnableTools.map(({ run, ...def }) => def);
       const probe = await client.messages.create({
         model: activeModel,
-        max_tokens: 4096,
+        max_tokens: 131072,
         system: systemPrompt,
         messages: withCacheBreakpoints([...history]),
         tools: toolDefs,
@@ -141,7 +141,7 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
 
     const runner = client.beta.messages.toolRunner({
       model: activeModel,
-      max_tokens: 4096,
+      max_tokens: 131072,
       system: systemPrompt,
       messages: withCacheBreakpoints([...history]),
       tools: runnableTools.length > 0 ? runnableTools : undefined,
@@ -168,7 +168,7 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
         { type: 'text', text: 'You have used too many tool calls. Please provide a final response now based on what you have so far.' },
       ]);
       const bailoutResponse = await client.messages.create({
-        model: activeModel, max_tokens: 4096, system: systemPrompt, messages: withCacheBreakpoints([...histories.get(chatId)]),
+        model: activeModel, max_tokens: 131072, system: systemPrompt, messages: withCacheBreakpoints([...histories.get(chatId)]),
       }, { signal: abortController.signal });
       histories.pushAssistant(chatId, bailoutResponse.content);
       trackUsage(bailoutResponse.usage);
@@ -182,7 +182,7 @@ function createClaude(anthropicConfig, { personality, memory, userDir = OBOL_DIR
       vlog('[claude] No text in final response after tool use — forcing summary');
       histories.pushUser(chatId, 'Provide a concise response to the user based on the tool results above.');
       const summaryResponse = await client.messages.create({
-        model: activeModel, max_tokens: 4096, system: systemPrompt, messages: withCacheBreakpoints([...histories.get(chatId)]),
+        model: activeModel, max_tokens: 131072, system: systemPrompt, messages: withCacheBreakpoints([...histories.get(chatId)]),
       }, { signal: abortController.signal });
       histories.pushAssistant(chatId, summaryResponse.content);
       trackUsage(summaryResponse.usage);

package/src/claude/client.js

@@ -9,12 +9,17 @@ function createAnthropicClient(anthropicConfig, { useOAuth = true } = {}) {
       authToken: anthropicConfig.oauth.accessToken,
       defaultHeaders: {
         'anthropic-dangerous-direct-browser-access': 'true',
-        'anthropic-beta': 'claude-code-20250219,oauth-2025-04-20',
+        'anthropic-beta': 'claude-code-20250219,oauth-2025-04-20,output-128k-2025-02-19',
       },
     });
   }
   if (anthropicConfig.apiKey) {
-    return new Anthropic({ apiKey: anthropicConfig.apiKey });
+    return new Anthropic({
+      apiKey: anthropicConfig.apiKey,
+      defaultHeaders: {
+        'anthropic-beta': 'output-128k-2025-02-19',
+      },
+    });
   }
   throw new Error('No Anthropic credentials configured. Run: obol config');
 }

package/src/claude/constants.js

@@ -1,5 +1,5 @@
 const MAX_EXEC_TIMEOUT = 120;
-let MAX_TOOL_ITERATIONS = 10;
+let MAX_TOOL_ITERATIONS = 100;
 
 const OPTIONAL_TOOLS = {
   text_to_speech: {

package/src/telegram/bot.js

@@ -15,6 +15,7 @@ const secretsCommands = require('./commands/secrets');
 const toolsCommands = require('./commands/tools');
 const { registerTextHandler } = require('./handlers/text');
 const { registerMediaHandler } = require('./handlers/media');
+const { registerSpecialHandler } = require('./handlers/special');
 const { registerCallbackHandler } = require('./handlers/callbacks');
 
 function createBot(telegramConfig, config) {
@@ -107,6 +108,7 @@ function createBot(telegramConfig, config) {
   const deps = { config, allowedUsers, bot, createAsk };
   registerTextHandler(bot, deps);
   registerMediaHandler(bot, telegramConfig, deps);
+  registerSpecialHandler(bot, deps);
   registerCallbackHandler(bot, { config, pendingAsks, getTenant });
 
   bot.catch((err) => {

package/src/telegram/handlers/special.js

@@ -0,0 +1,165 @@
+const { getTenant } = require('../../tenant');
+const { describeToolCall } = require('../../status');
+const { sendHtml, startTyping, splitMessage } = require('../utils');
+const { createChatContext, createStatusTracker } = require('./text');
+
+/**
+ * @param {import('grammy').Context} ctx
+ * @returns {string}
+ */
+function buildLocationPrompt(ctx) {
+  const { latitude, longitude, live_period, heading, horizontal_accuracy } = ctx.message.location;
+  const parts = [`[User shared their location: lat ${latitude}, lng ${longitude}`];
+  if (live_period) parts.push(`live for ${live_period}s`);
+  if (heading !== undefined) parts.push(`heading ${heading}°`);
+  if (horizontal_accuracy !== undefined) parts.push(`accuracy ±${horizontal_accuracy}m`);
+  return parts.join(', ') + ']';
+}
+
+/**
+ * @param {import('grammy').Context} ctx
+ * @returns {string}
+ */
+function buildVenuePrompt(ctx) {
+  const { location, title, address, foursquare_id, google_place_id } = ctx.message.venue;
+  let prompt = `[User shared a venue: "${title}" at ${address} (${location.latitude}, ${location.longitude})`;
+  if (foursquare_id) prompt += `, Foursquare: ${foursquare_id}`;
+  if (google_place_id) prompt += `, Google: ${google_place_id}`;
+  return prompt + ']';
+}
+
+/**
+ * @param {import('grammy').Context} ctx
+ * @returns {string}
+ */
+function buildContactPrompt(ctx) {
+  const { phone_number, first_name, last_name, vcard } = ctx.message.contact;
+  const name = [first_name, last_name].filter(Boolean).join(' ');
+  let prompt = `[User shared a contact: ${name}, ${phone_number}`;
+  if (vcard) prompt += ` (vCard data included)`;
+  return prompt + ']';
+}
+
+/**
+ * @param {import('grammy').Context} ctx
+ * @returns {string}
+ */
+function buildPollPrompt(ctx) {
+  const { question, options, type, is_anonymous, allows_multiple_answers } = ctx.message.poll;
+  const opts = options.map((o, i) => `${i + 1}. ${o.text}`).join(', ');
+  let prompt = `[User shared a ${type || 'regular'} poll: "${question}" — Options: ${opts}`;
+  if (!is_anonymous) prompt += ', non-anonymous';
+  if (allows_multiple_answers) prompt += ', multiple answers allowed';
+  return prompt + ']';
+}
+
+/**
+ * @param {import('grammy').Context} ctx
+ * @returns {string | null}
+ */
+function buildSpecialPrompt(ctx) {
+  if (ctx.message.location && !ctx.message.venue) return buildLocationPrompt(ctx);
+  if (ctx.message.venue) return buildVenuePrompt(ctx);
+  if (ctx.message.contact) return buildContactPrompt(ctx);
+  if (ctx.message.poll) return buildPollPrompt(ctx);
+  return null;
+}
+
+/**
+ * @param {import('grammy').Context} ctx
+ * @param {string} prompt
+ * @param {{ config: object, allowedUsers: Set<number>, bot: import('grammy').Bot, createAsk: Function }} deps
+ */
+async function processSpecial(ctx, prompt, deps) {
+  if (!ctx.from) return;
+  const userId = ctx.from.id;
+  const stopTyping = startTyping(ctx);
+  const status = createStatusTracker(ctx);
+
+  try {
+    const tenant = await getTenant(userId, deps.config);
+    const chatCtx = createChatContext(ctx, tenant, deps.config, deps);
+
+    chatCtx._onRouteDecision = (info) => {
+      status.setRouteInfo(info);
+      status.start();
+    };
+    chatCtx._onRouteUpdate = (update) => {
+      const ri = status.routeInfo;
+      if (!ri) return;
+      if (update.memoryCount !== undefined) ri.memoryCount = update.memoryCount;
+      if (update.model) ri.model = update.model;
+    };
+    chatCtx._onToolStart = (toolName, inputSummary) => {
+      status.setStatusText('Processing');
+      describeToolCall(tenant.claude.client, toolName, inputSummary).then(desc => {
+        if (desc) status.setStatusText(desc);
+      });
+      status.start();
+    };
+
+    const { text: response, usage, model } = await tenant.claude.chat(prompt, chatCtx);
+
+    status.stopTimer();
+    status.updateFormatting();
+    stopTyping();
+
+    if (!response?.trim()) {
+      status.deleteMsg();
+      await ctx.reply('⏹ Stopped.').catch(() => {});
+      return;
+    }
+
+    tenant.messageLog?.log(ctx.chat.id, 'user', prompt);
+    tenant.messageLog?.log(ctx.chat.id, 'assistant', response, { model, tokensIn: usage?.input_tokens, tokensOut: usage?.output_tokens });
+
+    if (response.length > 4096) {
+      for (const chunk of splitMessage(response, 4096)) await sendHtml(ctx, chunk).catch(() => {});
+    } else {
+      await sendHtml(ctx, response).catch(() => {});
+    }
+
+    if (usage && model) {
+      const tag = model.includes('opus') ? 'opus' : model.includes('haiku') ? 'haiku' : 'sonnet';
+      const tokIn = usage.input_tokens >= 1000 ? `${(usage.input_tokens / 1000).toFixed(1)}k` : usage.input_tokens;
+      const tokOut = usage.output_tokens >= 1000 ? `${(usage.output_tokens / 1000).toFixed(1)}k` : usage.output_tokens;
+      const dur = status.statusStart ? ((Date.now() - status.statusStart) / 1000).toFixed(1) : null;
+      const parts = [`◈ ${tag}`, `${tokIn} in`, `${tokOut} out`];
+      if (dur) parts.push(`${dur}s`);
+      await ctx.reply(`<code>${parts.join(' ▪ ')}</code>`, { parse_mode: 'HTML' }).catch(() => {});
+    }
+
+    status.deleteMsg();
+  } catch (e) {
+    status.clear();
+    stopTyping();
+    console.error('Special message handling error:', e.message);
+    await ctx.reply('Failed to process that message. Check logs.').catch(() => {});
+  }
+}
+
+/**
+ * @param {import('grammy').Bot} bot
+ * @param {{ config: object, allowedUsers: Set<number>, bot: import('grammy').Bot, createAsk: Function }} deps
+ */
+function registerSpecialHandler(bot, deps) {
+  async function handleSpecial(ctx) {
+    if (!ctx.from) return;
+    const userId = ctx.from.id;
+    const { createRateLimiter } = require('../rate-limit');
+    if (!bot._rateLimiter) bot._rateLimiter = createRateLimiter();
+    if (bot._rateLimiter.check(userId)) return;
+
+    const prompt = buildSpecialPrompt(ctx);
+    if (!prompt) return;
+
+    await processSpecial(ctx, prompt, deps);
+  }
+
+  bot.on('message:location', handleSpecial);
+  bot.on('message:venue', handleSpecial);
+  bot.on('message:contact', handleSpecial);
+  bot.on('message:poll', handleSpecial);
+}
+
+module.exports = { registerSpecialHandler };