obol-ai 0.3.52 → 0.3.53

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.3.53
+- revert memory to conditional retrieval with router-generated queries
+- skip haiku compress, pass raw dated facts to sonnet + recency scoring
+- unified router: always-on hybrid retrieval + haiku compress in single call
+- lower memory threshold to 0.3 and tighten budget to 20/30 for 75% recall
+- use concatenated conversation context for richer memory retrieval queries
+- fix scheduled agentic events to use full tool pipeline instead of bare API call
+- use conversation history for memory retrieval instead of router-generated queries
+
 ## 0.3.47
 - fix elapsed scope bug in background task completion
 - fix TTS summary to speak in first person

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obol-ai",
-  "version": "0.3.52",
+  "version": "0.3.53",
   "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/router.js

@@ -1,18 +1,4 @@
-const STOPWORDS = new Set([
-  'i', 'me', 'my', 'we', 'our', 'you', 'your', 'he', 'she', 'it', 'they', 'them',
-  'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
-  'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should',
-  'can', 'may', 'might', 'shall', 'must',
-  'and', 'but', 'or', 'nor', 'not', 'no', 'so', 'if', 'then', 'than',
-  'of', 'in', 'on', 'at', 'to', 'for', 'with', 'from', 'by', 'about', 'into',
-  'that', 'this', 'these', 'those', 'what', 'which', 'who', 'whom', 'whose',
-  'when', 'where', 'how', 'why', 'all', 'any', 'some', 'just', 'also',
-  'up', 'out', 'off', 'over', 'there', 'here', 'very', 'much', 'more',
-  'know', 'think', 'tell', 'say', 'said', 'remember', 'talk', 'talked',
-  'yes', 'no', 'ok', 'sure', 'yeah', 'oh', 'still', 'yet',
-  'did', 'does', 'doing', 'done', 'going', 'went', 'come', 'came',
-  'last', 'new', 'currently', 'working',
-]);
+const { formatMemoryBlock } = require('./prompt');
 
 function buildRouterMessages(recentHistory, userMessage) {
   const context = recentHistory.slice(-20).map(m => ({
@@ -28,27 +14,6 @@ function buildRouterMessages(recentHistory, userMessage) {
   return [...trimmed, { role: 'user', content: userMessage }];
 }
 
-function buildConversationQueries(recentHistory, userMessage, count = 5) {
-  const userMsgs = recentHistory
-    .filter(m => m.role === 'user')
-    .map(m => typeof m.content === 'string'
-      ? m.content
-      : m.content.filter(b => b.type === 'text').map(b => b.text).join(''))
-    .filter(Boolean)
-    .slice(-count);
-
-  const queries = [userMessage];
-  if (userMsgs.length > 0) {
-    queries.push([...userMsgs, userMessage].join('\n'));
-  }
-  return queries;
-}
-
-function extractKeywords(text) {
-  return text.toLowerCase().split(/\W+/)
-    .filter(w => w.length > 1 && !STOPWORDS.has(w));
-}
-
 function tokenize(s) {
   return new Set(s.toLowerCase().split(/\W+/).filter(Boolean));
 }
@@ -59,129 +24,101 @@ function jaccardFromSets(setA, setB) {
   return inter / (setA.size + setB.size - inter);
 }
 
-function dedup(memories, threshold) {
-  for (const m of memories) m._tokens = tokenize(m.content);
-  const kept = [];
-  for (const m of memories) {
-    const isDup = kept.some(k => jaccardFromSets(k._tokens, m._tokens) > threshold);
-    if (!isDup) kept.push(m);
-  }
-  return kept;
-}
+async function routeMessage(client, memory, userMessage, { vlog, onRouteDecision, onRouteUpdate, recentHistory = [], selfMemory = null }) {
+  let memoryBlock = null;
+  let model = null;
 
-async function retrieveMemories(memory, userMessage, recentHistory) {
-  const conversationQueries = buildConversationQueries(recentHistory, userMessage);
-  const conversationText = [...recentHistory.filter(m => m.role === 'user').map(m =>
-    typeof m.content === 'string' ? m.content : m.content.filter(b => b.type === 'text').map(b => b.text).join('')
-  ), userMessage].join(' ');
-
-  const keywords = extractKeywords(conversationText);
-
-  const semanticP = Promise.all(
-    conversationQueries.map(q => memory.search(q, { limit: 30, threshold: 0.3 }))
-  );
-
-  const keywordP = keywords.length > 0
-    ? Promise.all(
-        keywords.slice(0, 3).map(kw =>
-          memory.query({ limit: 10, filters: { content: `ilike.*${kw}*` }, order: 'importance.desc' })
-        )
-      )
-    : Promise.resolve([]);
-
-  const [semanticResults, keywordResults] = await Promise.all([semanticP, keywordP]);
-
-  const semanticFlat = semanticResults.flat();
-  const keywordFlat = (keywordResults || []).flat();
-  for (const m of keywordFlat) m.similarity = m.similarity || 0.5;
-
-  let fallback = [];
-  if (semanticFlat.length < 5 && keywordFlat.length < 3) {
-    const categories = ['person', 'preference', 'project', 'fact'];
-    const catResults = await Promise.all(
-      categories.map(cat => memory.query({ limit: 3, category: cat, order: 'importance.desc' }))
-    );
-    fallback = catResults.flat();
-    for (const m of fallback) m.similarity = m.similarity || 0.3;
-  }
+  try {
+    const routerDecision = await client.messages.create({
+      model: 'claude-haiku-4-5',
+      max_tokens: 200,
+      system: `You are a router. Analyze the conversation and decide:
 
-  const all = [...semanticFlat, ...keywordFlat, ...fallback];
-  const seen = new Set();
-  const combined = [];
-  const now = Date.now();
-  for (const m of all) {
-    if (!seen.has(m.id)) {
-      seen.add(m.id);
-      const ageDays = m.created_at ? (now - new Date(m.created_at).getTime()) / 86400000 : 30;
-      const recency = 1 / (1 + ageDays * 0.05);
-      const accessBoost = Math.log((m.access_count || 0) + 1) * 0.05;
-      m._score = (m.similarity || 0.5) * 0.55 + (m.importance || 0.5) * 0.20 + recency * 0.15 + accessBoost;
-      combined.push(m);
-    }
-  }
-  combined.sort((a, b) => b._score - a._score);
+1. Does it need memory context? (past conversations, facts, preferences, people, events)
+2. What model complexity does it need?
 
-  return dedup(combined, 0.7).slice(0, 25);
-}
+Reply with ONLY a JSON object:
+{"need_memory": true/false, "search_queries": ["query1", "query2"], "model": "sonnet|opus"}
 
-function formatFacts(pool) {
-  if (pool.length === 0) return null;
-  const now = Date.now();
-  const lines = pool.map(m => {
-    const age = m.created_at ? Math.round((now - new Date(m.created_at).getTime()) / 86400000) : null;
-    const dateTag = age !== null ? (age === 0 ? 'today' : age === 1 ? 'yesterday' : `${age}d ago`) : '';
-    return `- [${m.category}${dateTag ? '|' + dateTag : ''}] ${m.content}`;
-  });
-  return `## Memory recall\n${lines.join('\n')}`;
-}
+search_queries: 1-5 optimized search queries based on the full conversation context. Cover distinct topics, people, entities, time periods, or projects referenced. Single-topic messages need just one query. Use more queries when the message references multiple people, projects, or threads.
 
-async function routeMessage(client, memory, userMessage, { vlog, onRouteDecision, onRouteUpdate, recentHistory = [], selfMemory = null }) {
-  let memoryBlock = null;
-  let model = null;
+Memory: casual messages (greetings, jokes, simple questions) → false. References to past, people, projects, preferences → true.
 
-  try {
-    const [pool, routerResult] = await Promise.all([
-      memory ? retrieveMemories(memory, userMessage, recentHistory) : [],
-      client.messages.create({
-        model: 'claude-haiku-4-5',
-        max_tokens: 20,
-        system: `You are a model router. Reply with ONLY a JSON object: {"model": "sonnet|opus"}
-sonnet: general conversation, code generation, content creation, explanations, tool use, most exchanges
-opus: professional software engineering, complex multi-step reasoning, advanced coding, architecture decisions
-If recent context shows ongoing opus-level work, keep using opus for follow-ups.`,
-        messages: buildRouterMessages(recentHistory, userMessage),
-      }),
-    ]);
-
-    vlog(`[memory] retrieved ${pool.length} facts`);
-    memoryBlock = formatFacts(pool);
-
-    const text = routerResult.content[0]?.text || '';
+Model: Default to "sonnet". Use "sonnet" for: general conversation, code generation, data analysis, content creation, explanations, creative writing, agentic tool use, questions, opinions, advice, memory-dependent questions, and most exchanges. Use "opus" for: professional software engineering tasks, advanced multi-step agent work, complex reasoning, scientific or mathematical problems, tasks requiring nuanced understanding, advanced coding challenges, in-depth research, and architecture or design decisions.
+
+If recent context shows an ongoing task (sonnet/opus was just used, multi-step work in progress), bias toward that model even for short follow-up messages.`,
+      messages: buildRouterMessages(recentHistory, userMessage),
+    });
+
+    const decisionText = routerDecision.content[0]?.text || '';
     let decision = {};
     try {
-      const jsonStr = text.match(/\{[\s\S]*\}/)?.[0];
+      const jsonStr = decisionText.match(/\{[\s\S]*\}/)?.[0];
       if (jsonStr) decision = JSON.parse(jsonStr);
     } catch {}
 
+    const queries = Array.isArray(decision.search_queries) && decision.search_queries.length > 0
+      ? decision.search_queries.slice(0, 3)
+      : decision.search_query ? [decision.search_query] : [];
+
     if (decision.model !== 'sonnet' && decision.model !== 'opus') {
       decision.model = 'sonnet';
     }
 
-    if (decision.model === 'opus') {
-      model = 'claude-opus-4-6';
-    }
-
-    vlog(`[router] model=${decision.model} memory=${pool.length} facts`);
+    vlog(`[router] model=${decision.model} memory=${decision.need_memory || false}${queries.length ? ` queries=${JSON.stringify(queries)}` : ''}`);
 
     onRouteDecision?.({
       model: decision.model,
-      needMemory: pool.length > 0,
-      memoryCount: pool.length,
+      needMemory: decision.need_memory || false,
+      memoryCount: 0,
     });
-    onRouteUpdate?.({ memoryCount: pool.length });
 
+    if (decision.model === 'opus') {
+      model = 'claude-opus-4-6';
+    }
+
+    if (decision.need_memory && memory) {
+      const budget = decision.model === 'opus' ? 60 : 40;
+      const poolPerQuery = decision.model === 'opus' ? 25 : 20;
+      const searchQueries = queries.length > 0 ? queries : [userMessage];
+
+      const recentMemories = await memory.byDate('7d', { limit: Math.ceil(budget / 3) });
+
+      const semanticResults = await Promise.all(
+        searchQueries.map(q => memory.search(q, { limit: poolPerQuery, threshold: 0.4 }))
+      );
+      const semanticMemories = semanticResults.flat();
+
+      const seen = new Set();
+      const combined = [];
+      for (const m of [...recentMemories, ...semanticMemories]) {
+        if (!seen.has(m.id)) {
+          seen.add(m.id);
+          const ageDays = m.created_at ? (Date.now() - new Date(m.created_at).getTime()) / 86400000 : 7;
+          const recencyBonus = Math.max(0, 1 - ageDays / 7) * 0.3;
+          m._score = (m.similarity || 0.5) * 0.5 + (m.importance || 0.5) * 0.2 + recencyBonus;
+          combined.push(m);
+        }
+      }
+
+      combined.sort((a, b) => b._score - a._score);
+
+      for (const m of combined) m._tokens = tokenize(m.content);
+
+      const topFacts = [];
+      for (const m of combined) {
+        if (topFacts.length >= budget) break;
+        const isDup = topFacts.some(kept => jaccardFromSets(kept._tokens, m._tokens) > 0.7);
+        if (!isDup) topFacts.push(m);
+      }
+
+      vlog(`[memory] ${topFacts.length} facts (${recentMemories.length} recent, ${semanticMemories.length} semantic, budget=${budget})`);
+      onRouteUpdate?.({ memoryCount: topFacts.length });
+
+      memoryBlock = formatMemoryBlock(topFacts);
+    }
   } catch (e) {
-    console.error('[router] Route/memory failed:', e.message);
+    console.error('[router] Memory/routing decision failed:', e.message);
     vlog(`[router] ERROR: ${e.message}`);
   }