neoagent 1.4.0 → 1.4.3

package/server/services/memory/manager.js

@@ -9,8 +9,41 @@ const {
   deserializeEmbedding,
   keywordSimilarity
 } = require('./embeddings');
+const { AGENT_DATA_DIR } = require('../../../runtime/paths');
+
+/**
+ * Derive the active AI provider name from user settings so the right
+ * embedding model is selected automatically (e.g. Gemini when using Google).
+ */
+function getActiveProvider(userId) {
+  try {
+    const { SUPPORTED_MODELS } = require('../ai/models');
+    const rows = db.prepare('SELECT key, value FROM user_settings WHERE user_id = ? AND key IN (?, ?)')
+      .all(userId || 1, 'default_chat_model', 'enabled_models');
+
+    let defaultChatModel = null;
+    let enabledIds = null;
+    for (const row of rows) {
+      try {
+        const v = JSON.parse(row.value);
+        if (row.key === 'default_chat_model') defaultChatModel = v;
+        if (row.key === 'enabled_models') enabledIds = v;
+      } catch { }
+    }
 
-const DATA_DIR = path.join(__dirname, '../../../agent-data');
+    const modelId = defaultChatModel && defaultChatModel !== 'auto'
+      ? defaultChatModel
+      : (Array.isArray(enabledIds) && enabledIds.length > 0 ? enabledIds[0] : null);
+
+    if (modelId) {
+      const def = SUPPORTED_MODELS.find(m => m.id === modelId);
+      if (def) return def.provider;
+    }
+  } catch { }
+  return null;
+}
+
+const DATA_DIR = AGENT_DATA_DIR;
 const SOUL_FILE = path.join(DATA_DIR, 'SOUL.md');
 const API_KEYS_FILE = path.join(DATA_DIR, 'API_KEYS.json');
 const DAILY_DIR = path.join(DATA_DIR, 'daily');
@@ -32,6 +65,33 @@ const CATEGORIES = ['user_fact', 'preference', 'personality', 'episodic'];
 // Core memory keys (always injected into every prompt)
 const CORE_KEYS = ['user_profile', 'preferences', 'ai_personality', 'active_context'];
 
+function buildFtsQuery(query) {
+  const tokens = String(query || '')
+    .match(/[\p{L}\p{N}_-]{2,}/gu) || [];
+  if (!tokens.length) return null;
+  return tokens.map((token) => `${token.replace(/"/g, '')}*`).join(' AND ');
+}
+
+function stripHighlight(text) {
+  return String(text || '').replace(/<\/?mark>/g, '');
+}
+
+function buildExcerpt(text, query) {
+  const raw = stripHighlight(text);
+  const needle = String(query || '').trim().toLowerCase();
+  if (!raw) return '';
+  if (!needle) return raw.slice(0, 220);
+
+  const pos = raw.toLowerCase().indexOf(needle);
+  if (pos === -1) return raw.slice(0, 220);
+
+  const start = Math.max(0, pos - 80);
+  const end = Math.min(raw.length, pos + needle.length + 140);
+  const prefix = start > 0 ? '...' : '';
+  const suffix = end < raw.length ? '...' : '';
+  return `${prefix}${raw.slice(start, end)}${suffix}`;
+}
+
 class MemoryManager {
   constructor() {
     this._ensureDirs();
@@ -41,7 +101,7 @@ class MemoryManager {
     for (const dir of [DATA_DIR, DAILY_DIR, MEMORY_DIR, SKILLS_DIR]) {
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
     }
-    if (!fs.existsSync(SOUL_FILE))     fs.writeFileSync(SOUL_FILE, DEFAULT_SOUL, 'utf-8');
+    if (!fs.existsSync(SOUL_FILE)) fs.writeFileSync(SOUL_FILE, DEFAULT_SOUL, 'utf-8');
     if (!fs.existsSync(API_KEYS_FILE)) fs.writeFileSync(API_KEYS_FILE, '{}', 'utf-8');
   }
 
@@ -58,7 +118,7 @@ class MemoryManager {
     category = CATEGORIES.includes(category) ? category : 'episodic';
     importance = Math.max(1, Math.min(10, Number(importance) || 5));
 
-    const embedding = await getEmbedding(content);
+    const embedding = await getEmbedding(content, getActiveProvider(userId));
 
     // Dedup check: compare against existing non-archived memories for this user
     const existing = db.prepare(
@@ -111,7 +171,7 @@ class MemoryManager {
 
     if (!all.length) return [];
 
-    const queryVec = await getEmbedding(query);
+    const queryVec = await getEmbedding(query, getActiveProvider(userId));
 
     const scored = all.map(mem => {
       let score = 0;
@@ -169,13 +229,13 @@ class MemoryManager {
     const mem = db.prepare(`SELECT * FROM memories WHERE id = ?`).get(id);
     if (!mem) return null;
 
-    const newContent   = content   ?? mem.content;
+    const newContent = content ?? mem.content;
     const newImportance = importance != null ? Math.max(1, Math.min(10, Number(importance))) : mem.importance;
-    const newCategory  = (category && CATEGORIES.includes(category)) ? category : mem.category;
+    const newCategory = (category && CATEGORIES.includes(category)) ? category : mem.category;
 
     let newEmbed = mem.embedding;
     if (content && content !== mem.content) {
-      const vec = await getEmbedding(newContent);
+      const vec = await getEmbedding(newContent, getActiveProvider(null));
       newEmbed = vec ? serializeEmbedding(vec) : mem.embedding;
     }
 
@@ -321,19 +381,153 @@ class MemoryManager {
   }
 
   getRecentConversations(userId, limit = 20) {
-    return db.prepare(`
-      SELECT ch.*, ar.task FROM conversation_history ch
-      JOIN agent_runs ar ON ch.agent_run_id = ar.id
-      WHERE ch.user_id = ? ORDER BY ch.created_at DESC LIMIT ?
+    const rows = db.prepare(`
+      SELECT
+        ar.id AS run_id,
+        ar.title,
+        ar.created_at,
+        ar.completed_at,
+        ar.status,
+        (
+          SELECT content
+          FROM conversation_history ch
+          WHERE ch.agent_run_id = ar.id
+          ORDER BY ch.created_at DESC
+          LIMIT 1
+        ) AS latest_content
+      FROM agent_runs ar
+      WHERE ar.user_id = ?
+      ORDER BY COALESCE(ar.completed_at, ar.created_at) DESC
+      LIMIT ?
     `).all(userId, limit);
+
+    return rows.map((row) => ({
+      runId: row.run_id,
+      title: row.title || 'Untitled run',
+      createdAt: row.created_at,
+      completedAt: row.completed_at,
+      status: row.status,
+      excerpt: buildExcerpt(row.latest_content, '')
+    }));
   }
 
-  searchConversations(userId, query) {
-    return db.prepare(`
-      SELECT ch.*, ar.task FROM conversation_history ch
-      JOIN agent_runs ar ON ch.agent_run_id = ar.id
-      WHERE ch.user_id = ? AND ch.content LIKE ? ORDER BY ch.created_at DESC LIMIT 50
-    `).all(userId, `%${query}%`);
+  searchConversations(userId, query, options = {}) {
+    const ftsQuery = buildFtsQuery(query);
+    const maxHits = Math.max(6, Math.min(Number(options.limit) || 24, 60));
+    if (!ftsQuery) return [];
+
+    let webHits = [];
+    let messageHits = [];
+    try {
+      webHits = db.prepare(`
+        SELECT
+          'web' AS source,
+          ch.id AS message_id,
+          COALESCE(ch.agent_run_id, 'web:' || ch.id) AS session_id,
+          COALESCE(ar.title, 'Web chat') AS title,
+          ch.role,
+          ch.created_at,
+          snippet(conversation_history_fts, 0, '<mark>', '</mark>', ' ... ', 16) AS snippet,
+          bm25(conversation_history_fts) AS score
+        FROM conversation_history_fts
+        JOIN conversation_history ch ON ch.id = conversation_history_fts.rowid
+        LEFT JOIN agent_runs ar ON ar.id = ch.agent_run_id
+        WHERE conversation_history_fts MATCH ? AND ch.user_id = ?
+        ORDER BY score
+        LIMIT ?
+      `).all(ftsQuery, userId, maxHits);
+
+      messageHits = db.prepare(`
+        SELECT
+          'message' AS source,
+          m.id AS message_id,
+          COALESCE(m.run_id, m.platform || ':' || COALESCE(m.platform_chat_id, m.id)) AS session_id,
+          COALESCE(ar.title, json_extract(m.metadata, '$.senderName'), m.platform_chat_id, m.platform, 'Message thread') AS title,
+          m.role,
+          m.created_at,
+          m.platform,
+          snippet(messages_fts, 0, '<mark>', '</mark>', ' ... ', 16) AS snippet,
+          bm25(messages_fts) AS score
+        FROM messages_fts
+        JOIN messages m ON m.id = messages_fts.rowid
+        LEFT JOIN agent_runs ar ON ar.id = m.run_id
+        WHERE messages_fts MATCH ? AND m.user_id = ?
+        ORDER BY score
+        LIMIT ?
+      `).all(ftsQuery, userId, maxHits);
+    } catch {
+      const likeQuery = `%${String(query || '').trim()}%`;
+      webHits = db.prepare(`
+        SELECT
+          'web' AS source,
+          ch.id AS message_id,
+          COALESCE(ch.agent_run_id, 'web:' || ch.id) AS session_id,
+          COALESCE(ar.title, 'Web chat') AS title,
+          ch.role,
+          ch.created_at,
+          ch.content AS snippet,
+          0 AS score
+        FROM conversation_history ch
+        LEFT JOIN agent_runs ar ON ar.id = ch.agent_run_id
+        WHERE ch.user_id = ? AND ch.content LIKE ?
+        ORDER BY ch.created_at DESC
+        LIMIT ?
+      `).all(userId, likeQuery, maxHits);
+
+      messageHits = db.prepare(`
+        SELECT
+          'message' AS source,
+          m.id AS message_id,
+          COALESCE(m.run_id, m.platform || ':' || COALESCE(m.platform_chat_id, m.id)) AS session_id,
+          COALESCE(ar.title, json_extract(m.metadata, '$.senderName'), m.platform_chat_id, m.platform, 'Message thread') AS title,
+          m.role,
+          m.created_at,
+          m.platform,
+          m.content AS snippet,
+          0 AS score
+        FROM messages m
+        LEFT JOIN agent_runs ar ON ar.id = m.run_id
+        WHERE m.user_id = ? AND m.content LIKE ?
+        ORDER BY m.created_at DESC
+        LIMIT ?
+      `).all(userId, likeQuery, maxHits);
+    }
+
+    const grouped = new Map();
+    for (const hit of [...webHits, ...messageHits]) {
+      const key = `${hit.source}:${hit.session_id}`;
+      if (!grouped.has(key)) {
+        grouped.set(key, {
+          sessionId: hit.session_id,
+          source: hit.source,
+          title: hit.title || 'Untitled session',
+          platform: hit.platform || 'web',
+          createdAt: hit.created_at,
+          score: Number(hit.score || 0),
+          matches: []
+        });
+      }
+
+      const group = grouped.get(key);
+      group.score = Math.min(group.score, Number(hit.score || 0));
+      group.createdAt = hit.created_at > group.createdAt ? hit.created_at : group.createdAt;
+      if (group.matches.length < 3) {
+        group.matches.push({
+          role: hit.role,
+          createdAt: hit.created_at,
+          excerpt: buildExcerpt(hit.snippet, query)
+        });
+      }
+    }
+
+    return Array.from(grouped.values())
+      .sort((a, b) => a.score - b.score || String(b.createdAt).localeCompare(String(a.createdAt)))
+      .slice(0, Math.max(1, Math.min(Number(options.sessions) || 8, 12)))
+      .map((session) => ({
+        ...session,
+        matchCount: session.matches.length,
+        summary: session.matches.map((match) => `${match.role}: ${match.excerpt}`).join('\n')
+      }));
   }
 
   // ─────────────────────────────────────────────────────────────────────────

package/server/services/messaging/telnyx.js

@@ -5,8 +5,9 @@ const path = require('path');
 const fs = require('fs');
 const https = require('https');
 const { OpenAI } = require('openai');
+const { DATA_DIR, AGENT_DATA_DIR } = require('../../../runtime/paths');
 
-const AUDIO_DIR = path.join(__dirname, '..', '..', '..', 'data', 'telnyx-audio');
+const AUDIO_DIR = path.join(DATA_DIR, 'telnyx-audio');
 const RECORDING_TURN_LIMIT_MS = 4000; // auto-stop recording after 4 s of silence
 
 class TelnyxVoicePlatform extends BasePlatform {
@@ -57,7 +58,7 @@ class TelnyxVoicePlatform extends BasePlatform {
     let openAiKey = process.env.OPENAI_API_KEY;
     if (!openAiKey) {
       try {
-        const keysPath = path.join(__dirname, '..', '..', '..', 'agent-data', 'API_KEYS.json');
+        const keysPath = path.join(AGENT_DATA_DIR, 'API_KEYS.json');
         const keys = JSON.parse(fs.readFileSync(keysPath, 'utf8'));
         openAiKey = keys.OPENAI_API_KEY || keys.openai_api_key || keys.openai || null;
       } catch { /* file missing or unreadable — fine */ }

package/server/services/messaging/whatsapp.js

@@ -2,8 +2,9 @@ const { BasePlatform } = require('./base');
 const path = require('path');
 const fs = require('fs');
 const { toWhatsAppJid } = require('../../utils/whatsapp');
+const { DATA_DIR } = require('../../../runtime/paths');
 
-const AUTH_DIR = path.join(__dirname, '..', '..', '..', 'data', 'whatsapp-auth');
+const AUTH_DIR = path.join(DATA_DIR, 'whatsapp-auth');
 
 class WhatsAppPlatform extends BasePlatform {
   constructor(config = {}) {
@@ -137,7 +138,7 @@ class WhatsAppPlatform extends BasePlatform {
         if (mediaType && mediaType !== 'sticker') {
           try {
             const { downloadMediaMessage } = require('baileys');
-            const MEDIA_DIR = path.join(__dirname, '..', '..', '..', 'data', 'media');
+            const MEDIA_DIR = path.join(DATA_DIR, 'media');
             if (!fs.existsSync(MEDIA_DIR)) fs.mkdirSync(MEDIA_DIR, { recursive: true });
             const buffer = await downloadMediaMessage(msg, 'buffer', {}, {
               logger: this._logger,

package/server/services/scheduler/cron.js

@@ -3,9 +3,10 @@ const crypto = require('crypto');
 const db = require('../../db/database');
 
 class Scheduler {
-  constructor(io, agentEngine) {
+  constructor(io, agentEngine, app = null) {
     this.io = io;
     this.agentEngine = agentEngine;
+    this.app = app;
     this.jobs = new Map();
     this.heartbeatJob = null;
   }
@@ -95,7 +96,9 @@ class Scheduler {
           const convId = this._getMessagingConversation(user.id);
 
           await this.agentEngine.run(user.id, (prompt?.value || defaultPrompt) + platformHint, {
+            triggerType: 'heartbeat',
             triggerSource: 'heartbeat',
+            app: this.app,
             ...(convId ? { conversationId: convId } : {}),
           });
         }
@@ -246,7 +249,9 @@ class Scheduler {
         const convId = this._getMessagingConversation(userId);
 
         const result = await this.agentEngine.run(userId, config.prompt + notifyHint, {
+          triggerType: 'scheduler',
           triggerSource: 'scheduler',
+          app: this.app,
           ...(convId ? { conversationId: convId } : {}),
           taskId,
         });

package/server/services/websocket.js

@@ -1,5 +1,8 @@
 const db = require('../db/database');
 const { sanitizeError } = require('../utils/security');
+const { getProviderForUser } = require('./ai/engine');
+const { ensureDefaultAiSettings, getAiSettings } = require('./ai/settings');
+const { getWebChatContext, refreshWebChatSummary, clearWebChatSummary } = require('./ai/history');
 
 function setupWebSocket(io, services) {
   const { agentEngine, messagingManager, mcpClient, scheduler, memoryManager } = services;
@@ -31,6 +34,7 @@ function setupWebSocket(io, services) {
             case 'new':
             case 'clear':
               db.prepare('DELETE FROM conversation_history WHERE user_id = ?').run(userId);
+              clearWebChatSummary(userId);
               socket.emit('chat:cleared');
               {
                 const resetResult = await agentEngine.run(userId, 'context was just cleared. say something very brief (1-2 sentences max) acknowledging the fresh start, in your own style. no tools needed.', {});
@@ -61,17 +65,26 @@ function setupWebSocket(io, services) {
         db.prepare('INSERT INTO conversation_history (user_id, role, content, metadata) VALUES (?, ?, ?, ?)')
           .run(userId, 'user', task, JSON.stringify({ platform: 'web' }));
 
-        const priorMessages = db.prepare(
-          'SELECT role, content FROM conversation_history WHERE user_id = ? ORDER BY created_at DESC LIMIT 30'
-        ).all(userId).reverse();
-        const prior = priorMessages.filter(m => !(m.role === 'user' && m.content === task)).slice(-29);
+        ensureDefaultAiSettings(userId);
+        const aiSettings = getAiSettings(userId);
+        const webContext = getWebChatContext(userId, aiSettings.chat_history_window);
+        const prior = webContext.recentMessages.filter((m) => !(m.role === 'user' && m.content === task)).slice(-aiSettings.chat_history_window);
 
-        const result = await agentEngine.run(userId, task, { ...options, priorMessages: prior });
+        const result = await agentEngine.run(userId, task, {
+          ...options,
+          priorMessages: prior,
+          priorSummary: webContext.summary
+        });
 
         if (result?.content) {
           db.prepare('INSERT INTO conversation_history (user_id, agent_run_id, role, content, metadata) VALUES (?, ?, ?, ?, ?)')
             .run(userId, result.runId, 'assistant', result.content, JSON.stringify({ tokens: result.totalTokens }));
         }
+
+        const { provider, model } = getProviderForUser(userId, task, false, options?.model || null);
+        refreshWebChatSummary(userId, provider, model, aiSettings.chat_history_window).catch((summaryErr) => {
+          console.error('[WS] Web summary refresh failed:', summaryErr.message);
+        });
       } catch (err) {
         socket.emit('run:error', { error: sanitizeError(err) });
       }
@@ -102,7 +115,7 @@ function setupWebSocket(io, services) {
     socket.on('agent:run_detail', (data) => {
       try {
         const run = db.prepare('SELECT * FROM agent_runs WHERE id = ? AND user_id = ?').get(data.runId, userId);
-        const steps = db.prepare('SELECT * FROM agent_steps WHERE run_id = ? ORDER BY step_number ASC').all(data.runId);
+        const steps = db.prepare('SELECT * FROM agent_steps WHERE run_id = ? ORDER BY step_index ASC').all(data.runId);
         const history = db.prepare('SELECT * FROM conversation_history WHERE agent_run_id = ? ORDER BY created_at ASC').all(data.runId);
         socket.emit('agent:run_detail', { run, steps, history });
       } catch (err) {