neoagent 2.3.1-beta.62 → 2.3.1-beta.64

package/server/routes/agents.js

@@ -4,6 +4,7 @@ const db = require('../db/database');
 const { requireAuth } = require('../middleware/auth');
 const { sanitizeError } = require('../utils/security');
 const { getAgentIdFromRequest, resolveAgentId } = require('../services/agents/manager');
+const { listRunEvents } = require('../services/ai/runEvents');
 const { isInterimAssistantMetadata } = require('../services/ai/interim');
 const { buildAgentRunContext } = require('./_helpers/agentRunContext');
 
@@ -176,7 +177,7 @@ router.get('/:id/steps', (req, res) => {
     || run.final_response
     || null;
 
-  res.json({ run, steps, response });
+  res.json({ run, steps, events: listRunEvents(run.id), response });
 });
 
 // Abort a run

package/server/routes/memory.js

@@ -33,6 +33,59 @@ function findOwnedMemoryIds(db, userId, agentId, ids) {
   ).all(userId, agentId, ...ids).map((row) => row.id);
 }
 
+function parsePlainObject(input, fieldName) {
+  if (input == null) return null;
+  if (typeof input === 'string') {
+    try {
+      input = JSON.parse(input);
+    } catch {
+      throw new Error(`${fieldName} must be valid JSON.`);
+    }
+  }
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new Error(`${fieldName} must be an object.`);
+  }
+  return input;
+}
+
+function normalizeOptionalStringField(value, fieldName, maxLength, pattern = null) {
+  if (value == null || value === '') return null;
+  if (typeof value !== 'string') {
+    throw new Error(`${fieldName} must be a string.`);
+  }
+  const normalized = value.trim().slice(0, maxLength);
+  if (!normalized) return null;
+  if (pattern && !pattern.test(normalized)) {
+    throw new Error(`${fieldName} has an invalid format.`);
+  }
+  return normalized;
+}
+
+function normalizeSourceRef(input) {
+  const raw = parsePlainObject(input, 'sourceRef');
+  if (!raw) return undefined;
+  return {
+    sourceType: normalizeOptionalStringField(raw.sourceType ?? raw.type, 'sourceRef.sourceType', 48, /^[a-z0-9_:-]+$/i),
+    sourceId: normalizeOptionalStringField(raw.sourceId ?? raw.id, 'sourceRef.sourceId', 128),
+    sourceLabel: normalizeOptionalStringField(raw.sourceLabel ?? raw.label, 'sourceRef.sourceLabel', 160),
+  };
+}
+
+function normalizeScope(input) {
+  const raw = parsePlainObject(input, 'scope');
+  if (!raw) return undefined;
+  const scopeType = normalizeOptionalStringField(raw.scopeType ?? raw.type, 'scope.scopeType', 32, /^(agent|conversation|task|channel|shared)$/i);
+  return {
+    scopeType: scopeType ? scopeType.toLowerCase() : null,
+    scopeId: normalizeOptionalStringField(raw.scopeId ?? raw.id, 'scope.scopeId', 128),
+  };
+}
+
+function normalizeMetadata(input) {
+  const raw = parsePlainObject(input, 'metadata');
+  return raw == null ? undefined : raw;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Overview (for initial page load)
 // ─────────────────────────────────────────────────────────────────────────────
@@ -46,6 +99,7 @@ router.get('/', (req, res) => {
   res.json({
     agentId,
     assistantBehaviorNotes: mm.getAssistantBehaviorNotes(userId, { agentId }),
+    assistantSelfState: mm.getAssistantSelfState(userId, { agentId }),
     dailyLogs: mm.listDailyLogs(7, userId),
     apiKeys: Object.keys(mm.readApiKeys(userId)),
     coreMemory
@@ -81,13 +135,31 @@ router.post('/memories', async (req, res) => {
   const mm = req.app.locals.memoryManager;
   const userId = req.session.userId;
   const agentId = resolveAgentId(userId, getAgentIdFromRequest(req));
-  const { content, category = 'episodic', importance = 5 } = req.body;
+  const { content, category = 'episodic', importance = 5, sourceRef, scope, staleAfterDays, metadata } = req.body;
   if (!content || !content.trim()) return res.status(400).json({ error: 'content is required' });
   try {
-    const id = await mm.saveMemory(userId, content, category, importance, { agentId });
+    let normalizedStaleAfterDays;
+    if (staleAfterDays != null && staleAfterDays !== '') {
+      normalizedStaleAfterDays = Number.parseInt(staleAfterDays, 10);
+      if (!Number.isInteger(normalizedStaleAfterDays) || normalizedStaleAfterDays <= 0) {
+        return res.status(400).json({ error: 'staleAfterDays must be a positive integer.' });
+      }
+    }
+
+    const id = await mm.saveMemory(userId, content, category, importance, {
+      agentId,
+      sourceRef: normalizeSourceRef(sourceRef),
+      scope: normalizeScope(scope),
+      staleAfterDays: normalizedStaleAfterDays,
+      metadata: normalizeMetadata(metadata),
+    });
     res.json({ success: true, id });
   } catch (err) {
-    res.status(500).json({ error: sanitizeError(err) });
+    const message = sanitizeError(err);
+    if (/must be valid JSON|must be an object|must be a string|has an invalid format/i.test(message)) {
+      return res.status(400).json({ error: message });
+    }
+    res.status(500).json({ error: message });
   }
 });
 

package/server/routes/runtime.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const express = require('express');
+const { getAnalyticsConfig } = require('../config/analytics');
+
+const router = express.Router();
+
+router.get('/config', (req, res) => {
+  res.json({
+    analytics: getAnalyticsConfig(),
+  });
+});
+
+module.exports = router;

package/server/routes/widgets.js

@@ -78,7 +78,7 @@ router.delete('/:id', (req, res) => {
   }
 });
 
-router.post('/:id/refresh', (req, res) => {
+router.post('/:id/refresh', async (req, res) => {
   try {
     const service = widgetService(req);
     const taskRuntime = req.app?.locals?.taskRuntime;
@@ -89,10 +89,10 @@ router.post('/:id/refresh', (req, res) => {
     if (!widget) {
       return res.status(404).json({ error: 'Widget not found.' });
     }
-    if (!widget.scheduledTaskId) {
-      return res.status(400).json({ error: 'Widget is missing its refresh task.' });
+    if (widget.isSystem || !widget.scheduledTaskId) {
+      return res.json(await service.refreshWidget(req.session.userId, req.params.id));
     }
-    res.json(taskRuntime.runTaskNow(widget.scheduledTaskId, req.session.userId));
+    res.json(await taskRuntime.runTaskNow(widget.scheduledTaskId, req.session.userId));
   } catch (err) {
     res.status(400).json({ error: sanitizeError(err) });
   }

package/server/services/ai/engine.js

@@ -37,6 +37,7 @@ const {
   buildInterimSignature,
   normalizeInterimKind,
 } = require('./interim');
+const { recordRunEvent } = require('./runEvents');
 
 const MAX_CONSECUTIVE_TOOL_FAILURES = 5;
 const WIDGET_REFRESH_MAX_ITERATIONS = 30;
@@ -675,6 +676,22 @@ class AgentEngine {
       .run(JSON.stringify(next), runId);
   }
 
+  recordRunEvent(userId, runId, eventType, payload = {}, options = {}) {
+    try {
+      return recordRunEvent({
+        runId,
+        userId,
+        agentId: options.agentId || null,
+        eventType,
+        requestId: options.requestId || null,
+        stepId: options.stepId || null,
+        payload,
+      });
+    } catch {
+      return null;
+    }
+  }
+
   async publishInterimUpdate({
     userId,
     runId,
@@ -1533,6 +1550,12 @@ class AgentEngine {
       toolPids: new Set(),
     });
     this.emit(userId, 'run:start', { runId, agentId, title: runTitle, model, triggerType, triggerSource });
+    this.recordRunEvent(userId, runId, 'run_started', {
+      title: runTitle,
+      model,
+      triggerType,
+      triggerSource,
+    }, { agentId });
     console.info(
       `[Run ${shortenRunId(runId)}] started trigger=${triggerSource} type=${triggerType} model=${model} title=${summarizeForLog(runTitle, 120)}`
     );
@@ -1593,6 +1616,11 @@ class AgentEngine {
     if (threadStateMessage) {
       messages.push({ role: 'system', content: threadStateMessage });
     }
+    this.recordRunEvent(userId, runId, 'memory_injected', {
+      hasRecallContext: Boolean(recallMsg),
+      hasThreadState: Boolean(threadStateMessage),
+      recallPreview: recallMsg ? String(recallMsg).slice(0, 240) : '',
+    }, { agentId });
     messages.push(this.buildUserMessage(userMessage, options));
     messages = sanitizeConversationMessages(messages);
 
@@ -1746,6 +1774,10 @@ class AgentEngine {
         promptMetrics = this.mergePromptMetrics(promptMetrics, metrics, iteration, tools.length);
         this.persistPromptMetrics(runId, promptMetrics).catch(() => { });
         this.emit(userId, 'run:thinking', { runId, iteration });
+        this.recordRunEvent(userId, runId, 'model_turn_started', {
+          iteration,
+          toolCount: tools.length,
+        }, { agentId });
 
         let response;
         let responseModel = model;
@@ -1879,6 +1911,12 @@ class AgentEngine {
           }
         }
 
+        this.recordRunEvent(userId, runId, 'model_turn_completed', {
+          iteration,
+          toolCallCount: response.toolCalls?.length || 0,
+          contentPreview: String(lastContent || streamContent || '').slice(0, 240),
+        }, { agentId });
+
         const assistantMessage = { role: 'assistant', content: lastContent };
         if (response.toolCalls?.length) assistantMessage.tool_calls = response.toolCalls;
         if (response.providerContentBlocks?.length) assistantMessage.providerContentBlocks = response.providerContentBlocks;
@@ -1972,6 +2010,12 @@ class AgentEngine {
             runId, stepId, stepIndex, toolName, toolArgs,
             type: this.getStepType(toolName)
           });
+          this.recordRunEvent(userId, runId, 'tool_started', {
+            stepIndex,
+            toolName,
+            toolArgs,
+            type: this.getStepType(toolName),
+          }, { agentId, stepId });
           console.info(
             `[Run ${shortenRunId(runId)}] step=${stepIndex} start tool=${toolName} args=${summarizeForLog(toolArgs)}`
           );
@@ -2006,11 +2050,24 @@ class AgentEngine {
               .run(stepStatus, JSON.stringify(toolResult).slice(0, 20000), toolErrorMessage || null, screenshotPath, stepId);
             if (toolErrorMessage) {
               this.emit(userId, 'run:tool_end', { runId, stepId, toolName, error: toolErrorMessage, result: toolResult, screenshotPath, status: stepStatus });
+              this.recordRunEvent(userId, runId, 'tool_failed', {
+                toolName,
+                status: stepStatus,
+                error: toolErrorMessage,
+                durationMs: Date.now() - stepStartedAt,
+                resultPreview: summarizeForLog(toolResult),
+              }, { agentId, stepId });
               console.warn(
                 `[Run ${shortenRunId(runId)}] step=${stepIndex} failed tool=${toolName} durationMs=${Date.now() - stepStartedAt} error=${summarizeForLog(toolErrorMessage, 160)}`
               );
             } else {
               this.emit(userId, 'run:tool_end', { runId, stepId, toolName, result: toolResult, screenshotPath, status: stepStatus });
+              this.recordRunEvent(userId, runId, 'tool_completed', {
+                toolName,
+                status: stepStatus,
+                durationMs: Date.now() - stepStartedAt,
+                resultPreview: summarizeForLog(toolResult),
+              }, { agentId, stepId });
               console.info(
                 `[Run ${shortenRunId(runId)}] step=${stepIndex} done tool=${toolName} status=${stepStatus} durationMs=${Date.now() - stepStartedAt} result=${summarizeForLog(toolResult)}`
               );
@@ -2023,6 +2080,12 @@ class AgentEngine {
             db.prepare('UPDATE agent_steps SET status = ?, error = ?, completed_at = datetime(\'now\') WHERE id = ?')
               .run('failed', err.message, stepId);
             this.emit(userId, 'run:tool_end', { runId, stepId, toolName, error: err.message, status: 'failed' });
+            this.recordRunEvent(userId, runId, 'tool_failed', {
+              toolName,
+              status: 'failed',
+              error: err.message,
+              durationMs: Date.now() - stepStartedAt,
+            }, { agentId, stepId });
             console.warn(
               `[Run ${shortenRunId(runId)}] step=${stepIndex} failed tool=${toolName} durationMs=${Date.now() - stepStartedAt} error=${summarizeForLog(err.message, 160)}`
             );
@@ -2134,6 +2197,11 @@ class AgentEngine {
         );
         this.activeRuns.delete(runId);
         this.emit(userId, 'run:stopped', { runId, triggerSource });
+        this.recordRunEvent(userId, runId, 'run_stopped', {
+          triggerSource,
+          totalTokens,
+          iterations: iteration,
+        }, { agentId });
         return { runId, content: '', totalTokens, iterations: iteration, status: 'stopped' };
       }
 
@@ -2337,6 +2405,14 @@ class AgentEngine {
         executionMode: analysis?.mode || 'execute',
         verificationStatus: verification?.status || 'skipped',
       });
+      this.recordRunEvent(userId, runId, 'run_completed', {
+        contentPreview: String(finalResponseText || lastContent || '').slice(0, 240),
+        totalTokens,
+        iterations: iteration,
+        triggerSource,
+        executionMode: analysis?.mode || 'execute',
+        verificationStatus: verification?.status || 'skipped',
+      }, { agentId });
 
       return { runId, content: lastContent, totalTokens, iterations: iteration, status: 'completed' };
     } catch (err) {
@@ -2349,6 +2425,11 @@ class AgentEngine {
         this.cleanupSubagentsForRun(runId, { cancelRunning: true });
         this.activeRuns.delete(runId);
         this.emit(userId, 'run:stopped', { runId, triggerSource });
+        this.recordRunEvent(userId, runId, 'run_stopped', {
+          triggerSource,
+          totalTokens,
+          iterations: iteration,
+        }, { agentId });
         return { runId, content: '', totalTokens, iterations: iteration, status: 'stopped' };
       }
 
@@ -2478,6 +2559,11 @@ class AgentEngine {
       this.cleanupSubagentsForRun(runId, { cancelRunning: true });
       this.activeRuns.delete(runId);
       this.emit(userId, 'run:error', { runId, error: err.message });
+      this.recordRunEvent(userId, runId, 'run_failed', {
+        error: err.message,
+        totalTokens,
+        iterations: iteration,
+      }, { agentId });
 
       if (messagingFailureContent) {
         return {

package/server/services/ai/runEvents.js

@@ -0,0 +1,100 @@
+'use strict';
+
+const db = require('../../db/database');
+
+function parseJsonObject(value, fallback = {}) {
+  if (!value) return { ...fallback };
+  if (typeof value === 'object' && !Array.isArray(value)) return { ...value };
+  try {
+    const parsed = JSON.parse(String(value));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed
+      : { ...fallback };
+  } catch {
+    return { ...fallback };
+  }
+}
+
+function recordRunEvent({
+  runId,
+  userId,
+  agentId = null,
+  eventType,
+  requestId = null,
+  stepId = null,
+  sequenceIndex = null,
+  payload = {},
+}) {
+  if (!runId || !userId || !eventType) return null;
+  const payloadJson = JSON.stringify(
+    payload && typeof payload === 'object' && !Array.isArray(payload) ? payload : {},
+  );
+  const row = db.transaction(() => {
+    const resolvedSequence = Number.isInteger(sequenceIndex) && sequenceIndex > 0
+      ? sequenceIndex
+      : Number(
+        db.prepare(
+          'SELECT COALESCE(MAX(sequence_index), 0) AS max_sequence FROM agent_run_events WHERE run_id = ?'
+        ).get(runId)?.max_sequence || 0,
+      ) + 1;
+    const result = db.prepare(
+      `INSERT INTO agent_run_events (
+        run_id, user_id, agent_id, event_type, request_id, step_id, sequence_index, payload_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      runId,
+      userId,
+      agentId || null,
+      eventType,
+      requestId || null,
+      stepId || null,
+      resolvedSequence,
+      payloadJson,
+    );
+    return db.prepare(
+      `SELECT id, run_id, user_id, agent_id, event_type, request_id, step_id, sequence_index, payload_json, created_at
+       FROM agent_run_events
+       WHERE id = ?`
+    ).get(result.lastInsertRowid);
+  })();
+
+  return row ? {
+    id: Number(row.id),
+    runId: row.run_id,
+    userId: row.user_id,
+    agentId: row.agent_id || null,
+    eventType: row.event_type,
+    requestId: row.request_id || null,
+    stepId: row.step_id || null,
+    sequenceIndex: Number(row.sequence_index || 0),
+    payload: parseJsonObject(row.payload_json, {}),
+    createdAt: row.created_at,
+  } : null;
+}
+
+function listRunEvents(runId) {
+  if (!runId) return [];
+  const rows = db.prepare(
+    `SELECT id, run_id, user_id, agent_id, event_type, request_id, step_id, sequence_index, payload_json, created_at
+     FROM agent_run_events
+     WHERE run_id = ?
+     ORDER BY sequence_index ASC, id ASC`
+  ).all(runId);
+  return rows.map((row) => ({
+    id: Number(row.id),
+    runId: row.run_id,
+    userId: row.user_id,
+    agentId: row.agent_id || null,
+    eventType: row.event_type,
+    requestId: row.request_id || null,
+    stepId: row.step_id || null,
+    sequenceIndex: Number(row.sequence_index || 0),
+    payload: parseJsonObject(row.payload_json, {}),
+    createdAt: row.created_at,
+  }));
+}
+
+module.exports = {
+  recordRunEvent,
+  listRunEvents,
+};