neoagent 2.3.1-beta.63 → 2.3.1-beta.65

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/browser.js

@@ -13,20 +13,7 @@ async function getBrowserController(req) {
       return runtimeController;
     }
   }
-  const resolver = req.app?.locals?.getBrowserControllerForUser;
-  const userId = req.session?.userId;
-  let controller;
-  if (typeof resolver === "function") {
-    controller = await resolver(userId);
-  } else {
-    controller = req.app?.locals?.browserController;
-  }
-
-  if (!controller) {
-    throw new Error(`getBrowserController: missing browser controller for userId=${userId ?? 'unknown'}`);
-  }
-
-  return controller;
+  throw new Error('Browser controller is unavailable. VM runtime is required.');
 }
 
 // Get browser status

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/settings.js

@@ -144,11 +144,7 @@ function getBrowserController(req) {
   if (runtimeManager && typeof runtimeManager.getBrowserProviderForUser === 'function') {
     return runtimeManager.getBrowserProviderForUser(req.session?.userId);
   }
-  const resolver = req.app?.locals?.getBrowserControllerForUser;
-  if (typeof resolver === 'function') {
-    return resolver(req.session?.userId);
-  }
-  return req.app?.locals?.browserController;
+  throw new Error('Browser controller is unavailable. VM runtime is required.');
 }
 
 function applyHeadlessSetting(req, value) {

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/capabilityHealth.js

@@ -78,16 +78,7 @@ async function getBrowserHealth(userId, app, engine) {
   }
 
   if (!controller) {
-    try {
-      const resolver = app?.locals?.getBrowserControllerForUser;
-      controller = await Promise.resolve(
-        typeof resolver === 'function'
-          ? resolver(userId)
-          : (app?.locals?.browserController || engine?.browserController || null)
-      );
-    } catch (err) {
-      resolutionError = resolutionError || err;
-    }
+    resolutionError = resolutionError || new Error('Browser provider is unavailable. VM runtime is required.');
   }
 
   if (!controller && resolutionError) {

package/server/services/ai/deliverables/artifact_helpers.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { normalizeArtifactContract } = require('./contracts');
+
+const FILE_EXTENSION_TO_KIND = {
+  '.ppt': 'slides',
+  '.pptx': 'slides',
+  '.key': 'slides',
+  '.pdf': 'document',
+  '.doc': 'document',
+  '.docx': 'document',
+  '.md': 'document',
+  '.txt': 'document',
+  '.html': 'document',
+  '.htm': 'document',
+  '.csv': 'data',
+  '.tsv': 'data',
+  '.xlsx': 'data',
+  '.xls': 'data',
+  '.json': 'data',
+  '.png': 'image',
+  '.jpg': 'image',
+  '.jpeg': 'image',
+  '.gif': 'image',
+  '.webp': 'image',
+  '.svg': 'image',
+  '.mp4': 'video',
+  '.mov': 'video',
+  '.m4v': 'video',
+  '.webm': 'video',
+};
+
+const FILE_EXTENSION_TO_MIME = {
+  '.ppt': 'application/vnd.ms-powerpoint',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  '.pdf': 'application/pdf',
+  '.doc': 'application/msword',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.md': 'text/markdown',
+  '.txt': 'text/plain',
+  '.html': 'text/html',
+  '.htm': 'text/html',
+  '.csv': 'text/csv',
+  '.tsv': 'text/tab-separated-values',
+  '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  '.xls': 'application/vnd.ms-excel',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.mp4': 'video/mp4',
+  '.mov': 'video/quicktime',
+  '.m4v': 'video/x-m4v',
+  '.webm': 'video/webm',
+};
+
+const CANDIDATE_KEYS = [
+  'path',
+  'paths',
+  'file',
+  'files',
+  'filePath',
+  'filePaths',
+  'fullPath',
+  'fullPaths',
+  'mediaPath',
+  'mediaPaths',
+  'screenshotPath',
+  'uiDumpPath',
+  'url',
+  'urls',
+];
+
+function inferExtension(candidate = '') {
+  return path.extname(String(candidate || '').split('?')[0]).toLowerCase();
+}
+
+function inferArtifactKind(candidate = '', fallback = 'artifact') {
+  const extension = inferExtension(candidate);
+  if (FILE_EXTENSION_TO_KIND[extension]) return FILE_EXTENSION_TO_KIND[extension];
+  const normalized = String(candidate || '').toLowerCase();
+  if (normalized.includes('image')) return 'image';
+  if (normalized.includes('video')) return 'video';
+  if (normalized.includes('slide') || normalized.includes('ppt')) return 'slides';
+  if (normalized.includes('doc') || normalized.includes('pdf')) return 'document';
+  if (normalized.includes('data') || normalized.includes('chart') || normalized.includes('csv')) return 'data';
+  return fallback;
+}
+
+function inferMimeType(candidate = '') {
+  const extension = inferExtension(candidate);
+  return FILE_EXTENSION_TO_MIME[extension] || null;
+}
+
+function normalizePathOrUri(value) {
+  const text = String(value || '').trim();
+  if (!text) return null;
+  if (text.startsWith('/api/artifacts/')) return { uri: text, path: null };
+  if (/^https?:\/\//i.test(text)) return { uri: text, path: null };
+  if (/^[A-Za-z]:\\/.test(text)) return { path: text, uri: null };
+  if (path.isAbsolute(text)) return { path: text, uri: null };
+  return null;
+}
+
+async function buildArtifactFromCandidate(candidate, fallbackKind = 'artifact') {
+  const normalized = normalizePathOrUri(candidate);
+  if (!normalized) return null;
+  const source = normalized.path || normalized.uri || '';
+  const artifact = normalizeArtifactContract({
+    kind: inferArtifactKind(source, fallbackKind),
+    path: normalized.path,
+    uri: normalized.uri,
+    label: path.basename(String(source).split('?')[0]) || null,
+    mimeType: inferMimeType(source),
+  });
+  if (artifact.path) {
+    try {
+      artifact.size = (await fs.promises.stat(artifact.path)).size;
+    } catch (error) {
+      console.warn('[deliverables] Failed to stat artifact candidate:', artifact.path, error?.message || error);
+    }
+  }
+  return artifact.path || artifact.uri ? artifact : null;
+}
+
+function scanStringForCandidates(text) {
+  const input = String(text || '');
+  const matches = [];
+  const regexes = [
+    /\/api\/artifacts\/[A-Za-z0-9%_-]+\/content/g,
+    /\/[^\s"'`]+?\.(?:pptx?|pdf|docx?|md|txt|html?|csv|tsv|xlsx?|json|png|jpe?g|gif|webp|svg|mp4|mov|m4v|webm)\b/g,
+    /[A-Za-z]:\\[^\s"'`]+?\.(?:pptx?|pdf|docx?|md|txt|html?|csv|tsv|xlsx?|json|png|jpe?g|gif|webp|svg|mp4|mov|m4v|webm)\b/g,
+    /https?:\/\/[^\s"'`]+?\.(?:pptx?|pdf|docx?|md|txt|html?|csv|tsv|xlsx?|json|png|jpe?g|gif|webp|svg|mp4|mov|m4v|webm)\b/g,
+  ];
+  for (const regex of regexes) {
+    const found = input.match(regex);
+    if (found) matches.push(...found);
+  }
+  return matches;
+}
+
+async function extractArtifactsFromResult(toolName, result) {
+  const artifacts = [];
+  const seen = new Set();
+  const fallbackKind = inferArtifactKind(toolName, 'artifact');
+
+  async function pushCandidate(candidate) {
+    const artifact = await buildArtifactFromCandidate(candidate, fallbackKind);
+    if (!artifact) return;
+    const key = `${artifact.kind}:${artifact.path || artifact.uri}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    artifacts.push(artifact);
+  }
+
+  async function visit(value, keyHint = '') {
+    if (value == null) return;
+    if (typeof value === 'string') {
+      if (CANDIDATE_KEYS.includes(keyHint)) await pushCandidate(value);
+      for (const candidate of scanStringForCandidates(value)) {
+        await pushCandidate(candidate);
+      }
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) await visit(item, keyHint);
+      return;
+    }
+    if (typeof value === 'object') {
+      for (const [key, nested] of Object.entries(value)) {
+        await visit(nested, key);
+      }
+    }
+  }
+
+  await visit(result);
+  return artifacts;
+}
+
+module.exports = {
+  extractArtifactsFromResult,
+  inferArtifactKind,
+  inferMimeType,
+  normalizePathOrUri,
+};

package/server/services/ai/deliverables/contracts.js

@@ -0,0 +1,113 @@
+'use strict';
+
+const DELIVERABLE_TYPES = [
+  'slides',
+  'document',
+  'research_report',
+  'data_analysis',
+  'image',
+  'video',
+];
+
+const DELIVERABLE_SELECTION_STATUSES = ['selected', 'standard'];
+const DELIVERABLE_VALIDATION_STATUSES = ['passed', 'failed'];
+
+function clampText(value, maxLength = 240) {
+  return String(value || '').trim().slice(0, maxLength);
+}
+
+function normalizeDeliverableType(value) {
+  const normalized = clampText(value, 48).toLowerCase();
+  return DELIVERABLE_TYPES.includes(normalized) ? normalized : null;
+}
+
+function normalizeStringList(value, limit = 8, maxLength = 120) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => clampText(item, maxLength))
+    .filter(Boolean)
+    .slice(0, limit);
+}
+
+function normalizeArtifactContract(raw = {}) {
+  const source = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+  return {
+    kind: clampText(source.kind, 48) || 'artifact',
+    path: clampText(source.path || source.fullPath, 500) || null,
+    uri: clampText(source.uri || source.url, 500) || null,
+    label: clampText(source.label, 120) || null,
+    mimeType: clampText(source.mimeType || source.contentType, 120) || null,
+    size: Number.isFinite(Number(source.size ?? source.byteSize))
+      ? Number(source.size ?? source.byteSize)
+      : null,
+    preview: source.preview && typeof source.preview === 'object' && !Array.isArray(source.preview)
+      ? { ...source.preview }
+      : {},
+  };
+}
+
+function normalizeDeliverableSelection(raw = {}) {
+  const source = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+  const type = normalizeDeliverableType(source.type);
+  const confidence = Math.max(0, Math.min(1, Number(source.confidence) || 0));
+  const status = DELIVERABLE_SELECTION_STATUSES.includes(String(source.status || '').trim().toLowerCase())
+    ? String(source.status).trim().toLowerCase()
+    : (type ? 'selected' : 'standard');
+
+  return {
+    status,
+    type,
+    confidence,
+    goal: clampText(source.goal, 240),
+    requestedOutputs: normalizeStringList(source.requested_outputs || source.requestedOutputs, 8, 120),
+    supportingCapabilities: normalizeStringList(source.supporting_capabilities || source.supportingCapabilities, 8, 64),
+  };
+}
+
+function normalizeDeliverableValidationResult(raw = {}) {
+  const source = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+  const status = DELIVERABLE_VALIDATION_STATUSES.includes(String(source.status || '').trim().toLowerCase())
+    ? String(source.status).trim().toLowerCase()
+    : 'failed';
+  const artifacts = Array.isArray(source.artifacts)
+    ? source.artifacts.map(normalizeArtifactContract).filter((artifact) => artifact.path || artifact.uri)
+    : [];
+
+  return {
+    status,
+    summary: clampText(source.summary, 320),
+    errors: normalizeStringList(source.errors, 8, 220),
+    warnings: normalizeStringList(source.warnings, 8, 220),
+    artifacts,
+    metrics: source.metrics && typeof source.metrics === 'object' && !Array.isArray(source.metrics)
+      ? { ...source.metrics }
+      : {},
+  };
+}
+
+function normalizeDeliverableResult(raw = {}) {
+  const source = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+  return {
+    type: normalizeDeliverableType(source.type),
+    status: clampText(source.status, 32) || 'unknown',
+    summary: clampText(source.summary, 320),
+    artifacts: Array.isArray(source.artifacts)
+      ? source.artifacts.map(normalizeArtifactContract).filter((artifact) => artifact.path || artifact.uri)
+      : [],
+    validation: normalizeDeliverableValidationResult(source.validation),
+    metadata: source.metadata && typeof source.metadata === 'object' && !Array.isArray(source.metadata)
+      ? { ...source.metadata }
+      : {},
+  };
+}
+
+module.exports = {
+  DELIVERABLE_TYPES,
+  clampText,
+  normalizeArtifactContract,
+  normalizeDeliverableResult,
+  normalizeDeliverableSelection,
+  normalizeDeliverableType,
+  normalizeDeliverableValidationResult,
+  normalizeStringList,
+};

package/server/services/ai/deliverables/deliverables.test.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const { extractArtifactsFromResult } = require('./artifact_helpers');
+const { getDeliverableWorkflow } = require('./workflows');
+const { validateDeliverableExecution } = require('./validator');
+
+test('extractArtifactsFromResult collects artifact urls and local file paths', async () => {
+  const artifacts = await extractArtifactsFromResult('generate_image', {
+    paths: ['/tmp/launch-visual.png'],
+    previewUrl: '/api/artifacts/123/content',
+  });
+
+  assert.equal(artifacts.length, 2);
+  assert.equal(artifacts[0].kind, 'image');
+  assert.equal(artifacts[0].path, '/tmp/launch-visual.png');
+  assert.ok(!artifacts[0].uri);
+  assert.equal(artifacts[1].kind, 'image');
+  assert.equal(artifacts[1].uri, '/api/artifacts/123/content');
+  assert.ok(!artifacts[1].path);
+});
+
+test('slides workflow passes when a matching presentation artifact exists', async () => {
+  const workflow = getDeliverableWorkflow('slides');
+  const request = workflow.normalizeRequest({
+    goal: 'Create the board deck',
+    requestedOutputs: ['pptx deck'],
+  });
+  const plan = workflow.buildExecutionPlan(request);
+
+  const result = await validateDeliverableExecution({
+    workflow,
+    request,
+    plan,
+    finalReply: 'The presentation is ready at /tmp/board-deck.pptx.',
+    artifacts: [
+      {
+        kind: 'slides',
+        path: '/tmp/board-deck.pptx',
+        label: 'board-deck.pptx',
+        mimeType:
+          'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+      },
+    ],
+    toolExecutions: [],
+    runId: 'run-1',
+  });
+
+  assert.equal(result.validation.status, 'passed');
+  assert.equal(result.result.type, 'slides');
+  assert.equal(result.result.artifacts.length, 1);
+});
+
+test('video workflow fails when no video artifact was produced', async () => {
+  const workflow = getDeliverableWorkflow('video');
+  const request = workflow.normalizeRequest({
+    goal: 'Create a launch trailer',
+    requestedOutputs: ['launch video'],
+  });
+  const plan = workflow.buildExecutionPlan(request);
+
+  const result = await validateDeliverableExecution({
+    workflow,
+    request,
+    plan,
+    finalReply: 'I finished the video.',
+    artifacts: [],
+    toolExecutions: [],
+    runId: 'run-2',
+  });
+
+  assert.equal(result.validation.status, 'failed');
+  assert.match(result.validation.summary, /validation failed/i);
+});

package/server/services/ai/deliverables/index.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { selectDeliverableWorkflow } = require('./selector');
+const {
+  buildDeliverableWorkflowGuidance,
+  getDeliverableWorkflow,
+  listDeliverableWorkflows,
+} = require('./workflows');
+const { extractArtifactsFromResult } = require('./artifact_helpers');
+const { DeliverableValidationError, validateDeliverableExecution } = require('./validator');
+
+module.exports = {
+  buildDeliverableWorkflowGuidance,
+  DeliverableValidationError,
+  extractArtifactsFromResult,
+  getDeliverableWorkflow,
+  listDeliverableWorkflows,
+  selectDeliverableWorkflow,
+  validateDeliverableExecution,
+};