obol-ai 0.3.6 → 0.3.7

package/CHANGELOG.md

@@ -1,3 +1,6 @@
+## 0.3.7
+- add impulse system, fix haiku context, enforce code block formatting
+
 ## 0.3.6
 - optimize routing: drop haiku probe, trim system prompt, add tool-need heuristic + bench prompts
 - split large files into focused modules

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "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/cache.js

@@ -31,4 +31,29 @@ function withCacheBreakpoints(messages) {
   return result;
 }
 
-module.exports = { withCacheBreakpoints, sanitizeMessages };
+function stripToolBlocks(messages) {
+  const result = [];
+  for (const msg of messages) {
+    let text = '';
+    if (typeof msg.content === 'string') {
+      text = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      text = msg.content
+        .filter(b => b.type === 'text' && b.text)
+        .map(b => b.text)
+        .join('\n');
+    }
+    if (!text.trim()) continue;
+    if (result.length > 0 && result[result.length - 1].role === msg.role) {
+      result[result.length - 1].content += '\n' + text;
+    } else {
+      result.push({ role: msg.role, content: text });
+    }
+  }
+  while (result.length > 0 && result[0].role !== 'user') {
+    result.shift();
+  }
+  return result;
+}
+
+module.exports = { withCacheBreakpoints, sanitizeMessages, stripToolBlocks };

package/src/claude/chat.js

@@ -5,7 +5,7 @@ const { createAnthropicClient, ensureFreshToken } = require('./client');
 const { routeMessage } = require('./router');
 const { buildSystemPrompt, buildSystemBlock, buildRuntimePrefix, withRuntimeContext } = require('./prompt');
 const { buildTools, buildRunnableTools, addToolCache } = require('./tool-registry');
-const { withCacheBreakpoints, sanitizeMessages } = require('./cache');
+const { withCacheBreakpoints, sanitizeMessages, stripToolBlocks } = require('./cache');
 const { getMaxToolIterations } = require('./constants');
 
 function createClaude(anthropicConfig, { personality, memory, selfMemory, userDir = OBOL_DIR, bridgeEnabled, botName }) {
@@ -126,7 +126,7 @@ function createClaude(anthropicConfig, { personality, memory, selfMemory, userDi
     }
 
     if (activeModel.includes('haiku')) {
-      const haikuMessages = withCacheBreakpoints(withRuntimeContext([...history], runtimePrefix));
+      const haikuMessages = withCacheBreakpoints(withRuntimeContext(stripToolBlocks([...history]), runtimePrefix));
       context._onPromptReady?.({ system: systemPrompt, messages: haikuMessages, model: activeModel, tools: [] });
 
       const haikuResponse = await client.messages.create({

package/src/claude/prompt.js

@@ -184,8 +184,7 @@ Structure tips:
 2\\. *LinkedIn* — Matthew Chittle wants to connect \`21:31\`
 3\\. *DeepLearning\\.AI* — AI Dev 26 × SF speakers \`13:20\`
 
-*Copyable values* (email addresses, URLs, API keys, commands) — wrap in backtick code spans:
-\`user@example.com\`, \`https://example.com\`, \`npm install foo\`
+*Copyable content* — drafts, emails, letters, templates, and anything meant to be copied must ALWAYS be in a \`\`\`code block\`\`\`. Never render copyable content as plain text or with formatting — code blocks make it easy to copy and clearly separate the draft from your commentary. Short values (email addresses, URLs, API keys, commands) use inline \`backticks\`.
 
 *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.
 `);

package/src/cli/prompt-debug.js

@@ -217,6 +217,7 @@ async function runChat(opts, config) {
   for (const msg of historyMessages) {
     claude.injectHistory(userId, msg.role, msg.content);
   }
+  claude.repairHistory(userId);
 
   console.log('\n\x1b[1m' + hr('═') + '\x1b[0m');
   console.log(`\x1b[1m  CHAT DEBUG — user ${userId}\x1b[0m`);

package/src/curiosity/impulse.js

@@ -0,0 +1,146 @@
+const Anthropic = require('@anthropic-ai/sdk');
+const { createSelfMemory } = require('../memory/self');
+const { getTenant } = require('../tenant');
+
+const IMPULSE_MODEL = 'claude-haiku-4-5-20251001';
+const COOLDOWN_MS = 24 * 60 * 60 * 1000;
+const MIN_DELAY_MS = 30_000;
+const MAX_DELAY_MS = 300_000;
+
+/** @type {Map<number, number>} */
+const _cooldowns = new Map();
+
+/** @type {ReturnType<typeof createSelfMemory> | null} */
+let _globalSelfMemory = null;
+
+async function getGlobalSelfMemory(supabaseConfig) {
+  if (!_globalSelfMemory) {
+    _globalSelfMemory = await createSelfMemory(supabaseConfig, 0);
+  }
+  return _globalSelfMemory;
+}
+
+function isOnCooldown(userId) {
+  const last = _cooldowns.get(userId);
+  return last && (Date.now() - last) < COOLDOWN_MS;
+}
+
+function getTimeContext(timezone) {
+  return new Date().toLocaleString('en-US', {
+    timeZone: timezone || 'UTC',
+    weekday: 'long',
+    hour: '2-digit',
+    minute: '2-digit',
+    hour12: true,
+  });
+}
+
+async function gatherContext(tenant, supabaseConfig, opts = {}) {
+  const parts = [];
+
+  parts.push(`Time: ${getTimeContext(opts.timezone)} (${opts.timezone || 'UTC'})`);
+
+  const [patterns, userMemories, selfFacts, globalFindings] = await Promise.all([
+    tenant.patterns?.format().catch(() => null),
+    tenant.memory?.recent({ limit: 5 }).catch(() => []),
+    tenant.selfMemory?.recent({ limit: 3 }).catch(() => []),
+    supabaseConfig ? getGlobalSelfMemory(supabaseConfig).then(sm => sm.recent({ limit: 5 })).catch(() => []) : [],
+  ]);
+
+  if (patterns) parts.push(`Patterns:\n${patterns}`);
+  if (userMemories?.length) parts.push(`What you know about them:\n${userMemories.map(m => `- ${m.content}`).join('\n')}`);
+  if (selfFacts?.length) parts.push(`Your notes about this relationship:\n${selfFacts.map(m => `- ${m.content}`).join('\n')}`);
+  if (globalFindings?.length) parts.push(`Your recent explorations:\n${globalFindings.map(m => `- ${m.content}`).join('\n')}`);
+
+  if (!opts.periodic && opts.lastUserMsg) {
+    const userSnip = opts.lastUserMsg.substring(0, 500);
+    const assistantSnip = opts.lastAssistantMsg?.substring(0, 500) || '';
+    parts.push(`Last exchange:\nThem: ${userSnip}\nYou: ${assistantSnip}`);
+  }
+
+  return { text: parts.join('\n\n'), hasSubstance: (globalFindings?.length > 0 || userMemories?.length > 0) };
+}
+
+async function checkImpulse(client, context) {
+  const response = await client.messages.create({
+    model: IMPULSE_MODEL,
+    max_tokens: 300,
+    system: `You know someone. Here's what's on your mind and what you know about them.
+Decide if you have something genuine to say — a check-in about something in their life,
+a thought from your own exploration, an observation you connected.
+Most of the time: no. Only when it would feel natural and welcome.
+Don't follow up on the conversation that just happened — that's not your job here.`,
+    messages: [{ role: 'user', content: context }],
+    tool_choice: { type: 'tool', name: 'impulse' },
+    tools: [{
+      name: 'impulse',
+      description: 'Decide whether to send a spontaneous message',
+      input_schema: {
+        type: 'object',
+        properties: {
+          act: { type: 'boolean', description: 'true if you have something genuine to say' },
+          thought: { type: 'string', description: 'The message to send, if acting' },
+          kind: { type: 'string', enum: ['curiosity', 'checkin', 'observation'] },
+        },
+        required: ['act'],
+      },
+    }],
+  });
+
+  const toolUse = response.content.find(b => b.type === 'tool_use');
+  return toolUse?.input || { act: false };
+}
+
+function sendImpulse(bot, chatId, thought, kind, userId) {
+  const delay = MIN_DELAY_MS + Math.random() * (MAX_DELAY_MS - MIN_DELAY_MS);
+  setTimeout(() => {
+    bot.api.sendMessage(chatId, thought).catch(() =>
+      bot.api.sendMessage(chatId, thought, { parse_mode: undefined }).catch(() => {})
+    );
+    console.log(`[impulse] Sent ${kind} to user ${userId}`);
+  }, delay);
+}
+
+async function maybeImpulse(bot, config, tenant, chatId, lastUserMsg, lastAssistantMsg) {
+  const userId = tenant.userId;
+  if (isOnCooldown(userId)) return;
+  if (!config.supabase) return;
+
+  const { text: context, hasSubstance } = await gatherContext(tenant, config.supabase, {
+    lastUserMsg,
+    lastAssistantMsg,
+    timezone: config.timezone,
+  });
+  if (!hasSubstance) return;
+
+  const client = new Anthropic({ apiKey: config.anthropic.apiKey });
+  const result = await checkImpulse(client, context);
+
+  if (!result.act || !result.thought) return;
+
+  _cooldowns.set(userId, Date.now());
+  sendImpulse(bot, chatId, result.thought, result.kind || 'observation', userId);
+}
+
+async function maybePeriodicImpulse(bot, config, userId) {
+  if (isOnCooldown(userId)) return;
+  if (!config.supabase) return;
+
+  const tenant = await getTenant(userId, config);
+
+  const { text: context, hasSubstance } = await gatherContext(tenant, config.supabase, {
+    periodic: true,
+    timezone: config.timezone,
+  });
+  if (!hasSubstance) return;
+
+  const client = new Anthropic({ apiKey: config.anthropic.apiKey });
+  const result = await checkImpulse(client, context);
+
+  if (!result.act || !result.thought) return;
+
+  _cooldowns.set(userId, Date.now());
+  sendImpulse(bot, userId, result.thought, result.kind || 'checkin', userId);
+}
+
+module.exports = { maybeImpulse, maybePeriodicImpulse };

package/src/runtime/heartbeat.js

@@ -7,11 +7,13 @@ const { runAnalysis } = require('../analysis');
 const { runCuriosity } = require('../curiosity');
 const { runCuriosityDispatch } = require('../curiosity/dispatch');
 const { runCuriosityHumor } = require('../curiosity/humor');
+const { maybePeriodicImpulse } = require('../curiosity/impulse');
 const { createSelfMemory } = require('../memory/self');
 
 
 const ANALYSIS_HOURS = new Set([4, 7, 10, 13, 16, 19, 22]);
 const CURIOSITY_HOURS = new Set([1, 7, 13, 19]);
+const IMPULSE_HOURS = new Set([4, 10, 16, 22]);
 
 const _evolutionRunning = new Set();
 let _curiosityRunning = false;
@@ -236,6 +238,19 @@ function setupHeartbeat(bot, config) {
       );
     });
     console.log(`  ✅ Curiosity cron running (every 6h ${config.timezone || 'UTC'})`);
+
+    cron.schedule('* * * * *', async () => {
+      const timezone = config.timezone || 'UTC';
+      const { hour, minute } = getLocalHour(timezone);
+      if (!IMPULSE_HOURS.has(hour) || minute !== 0) return;
+
+      for (const userId of allowedUsers) {
+        maybePeriodicImpulse(bot, config, userId).catch(e =>
+          console.error(`[impulse] Periodic error for user ${userId}:`, e.message)
+        );
+      }
+    });
+    console.log(`  ✅ Impulse cron running (every 6h ${config.timezone || 'UTC'})`);
   }
 
   console.log('  ✅ Heartbeat running (every 1min)');

package/src/telegram/handlers/text.js

@@ -44,9 +44,12 @@ function createVerboseBatcher(ctx) {
   const flush = () => {
     if (timer) { clearTimeout(timer); timer = null; }
     if (buffer.length === 0) return;
-    const combined = buffer.join('\n');
+    const raw = buffer.join('\n');
     buffer = [];
-    sendHtml(ctx, `<code>${combined}</code>`).catch(() => {});
+    const escaped = raw.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    ctx.reply(`<code>${escaped}</code>`, { parse_mode: 'HTML' }).catch(() =>
+      ctx.reply(raw).catch(() => {})
+    );
   };
 
   const notify = (/** @type {string} */ msg) => {
@@ -208,6 +211,9 @@ async function processTextMessage(ctx, fullMessage, { config, allowedUsers, bot,
 
     tenant.messageLog?.log(ctx.chat.id, 'assistant', response, { model, tokensIn: usage?.input_tokens, tokensOut: usage?.output_tokens });
 
+    const { maybeImpulse } = require('../../curiosity/impulse');
+    maybeImpulse(bot, config, tenant, ctx.chat.id, chatMessage, response).catch(() => {});
+
     stopTyping();
 
     if (response.length > 4096) {