neoagent 2.4.1-beta.34 → 2.4.1-beta.35

package/server/services/memory/ingestion_coverage.js

@@ -0,0 +1,129 @@
+'use strict';
+
+const { resolveAgentId } = require('../agents/manager');
+const {
+  buildCoverageForConnection,
+  sourceTypesForConnection,
+} = require('./ingestion_support');
+
+function listConnectionStatuses(service, userId, { agentId = null } = {}) {
+  const scopedAgentId = resolveAgentId(userId, agentId);
+  const connections = service.db.prepare(
+    `SELECT *
+     FROM integration_connections
+     WHERE user_id = ? AND agent_id = ?
+     ORDER BY updated_at DESC, id DESC`,
+  ).all(userId, scopedAgentId);
+  const jobs = service.memoryManager.listIngestionJobs(
+    userId,
+    { agentId: scopedAgentId, limit: 100 },
+  );
+  return connections.map((connection) => {
+    const latestJob = jobs.find(
+      (job) => Number(job.connectionId || 0) === Number(connection.id),
+    );
+    return {
+      connectionId: connection.id,
+      providerKey: connection.provider_key,
+      appKey: connection.app_key,
+      accountEmail: connection.account_email || null,
+      ...buildCoverageForConnection(connection, latestJob),
+    };
+  });
+}
+
+function decorateProviderSnapshot(service, snapshot, userId, agentId = null) {
+  if (!snapshot || typeof snapshot !== 'object') return snapshot;
+  const scopedAgentId = resolveAgentId(userId, agentId);
+  const connections = service.db.prepare(
+    `SELECT *
+     FROM integration_connections
+     WHERE user_id = ? AND agent_id = ? AND provider_key = ?`,
+  ).all(userId, scopedAgentId, snapshot.provider);
+  const jobs = service.memoryManager.listIngestionJobs(userId, {
+    agentId: scopedAgentId,
+    providerKey: snapshot.provider,
+    limit: 100,
+  });
+  const latestJobForConnection = (connectionId) =>
+    jobs.find((job) => Number(job.connectionId || 0) === Number(connectionId));
+
+  const connectionCoverage = connections.map((connection) => ({
+    connectionId: connection.id,
+    appKey: connection.app_key,
+    accountEmail: connection.account_email || null,
+    ...buildCoverageForConnection(connection, latestJobForConnection(connection.id)),
+  }));
+  const providerDomains = Array.from(
+    new Set(connectionCoverage.flatMap((item) => item.dataDomains || [])),
+  );
+  const providerJob = jobs[0] || null;
+  const decorated = {
+    ...snapshot,
+    memoryCoverage: {
+      supported: providerDomains.length > 0,
+      contributesToMemory: providerDomains.length > 0,
+      contributesToTaskExecution: Boolean(snapshot.connection?.connected),
+      status: providerJob?.status || (providerDomains.length > 0 ? 'ready' : 'not_supported'),
+      dataDomains: providerDomains,
+      documentCount: connectionCoverage.reduce(
+        (sum, item) => sum + Number(item.documentCount || 0),
+        0,
+      ),
+      lastRefreshAt: providerJob?.completedAt || providerJob?.updatedAt || null,
+      nextRefreshAt: providerJob?.nextSyncAt || null,
+      error: providerJob?.error || null,
+    },
+  };
+
+  decorated.apps = (snapshot.apps || []).map((app) => {
+    const appConnections = connectionCoverage.filter((item) => item.appKey === app.id);
+    const dataDomains = Array.from(new Set([
+      ...sourceTypesForConnection(snapshot.provider, app.id),
+      ...appConnections.flatMap((item) => item.dataDomains || []),
+    ]));
+    const latest = appConnections[0] || null;
+    return {
+      ...app,
+      memoryCoverage: {
+        supported: dataDomains.length > 0,
+        contributesToMemory: dataDomains.length > 0 && app.connection?.connected === true,
+        contributesToTaskExecution: app.connection?.connected === true,
+        status: latest?.status || (dataDomains.length > 0 ? 'ready' : 'not_supported'),
+        dataDomains,
+        documentCount: appConnections.reduce(
+          (sum, item) => sum + Number(item.documentCount || 0),
+          0,
+        ),
+        lastRefreshAt: latest?.lastRefreshAt || null,
+        nextRefreshAt: latest?.nextRefreshAt || null,
+        error: latest?.error || null,
+      },
+      accounts: (app.accounts || []).map((account) => {
+        const accountCoverage = appConnections.find(
+          (item) => Number(item.connectionId) === Number(account.connectionId),
+        );
+        return {
+          ...account,
+          memoryCoverage: accountCoverage || {
+            supported: dataDomains.length > 0,
+            contributesToMemory: false,
+            contributesToTaskExecution: app.connection?.connected === true,
+            status: dataDomains.length > 0 ? 'ready' : 'not_supported',
+            dataDomains,
+            documentCount: 0,
+            lastRefreshAt: null,
+            nextRefreshAt: null,
+            error: null,
+          },
+        };
+      }),
+    };
+  });
+  return decorated;
+}
+
+module.exports = {
+  decorateProviderSnapshot,
+  listConnectionStatuses,
+};

package/server/services/memory/ingestion_documents.js

@@ -0,0 +1,123 @@
+'use strict';
+
+const { v4: uuidv4 } = require('uuid');
+const { resolveAgentId } = require('../agents/manager');
+const {
+  SOURCE_MEMORY_CATEGORIES,
+  getFreshnessPolicy,
+  nextSyncFromPolicy,
+  normalizeDocument,
+  normalizeSourceType,
+  parseJsonObject,
+  safeTrim,
+} = require('./ingestion_support');
+
+async function ingestDocuments(service, userId, documents = [], options = {}) {
+  const agentId = resolveAgentId(userId, options.agentId || options.agent_id || null);
+  const normalizedDocs = (Array.isArray(documents) ? documents : [])
+    .map((document) => normalizeDocument(document, {
+      sourceType: options.sourceType,
+      providerKey: options.providerKey,
+      connectionId: options.connectionId,
+      sourceAccount: options.sourceAccount,
+    }));
+  const sourceType = normalizeSourceType(options.sourceType || normalizedDocs[0]?.sourceType);
+  const policy = getFreshnessPolicy(sourceType);
+  const jobId = uuidv4();
+  const connectionId = Number.isInteger(Number(options.connectionId))
+    ? Number(options.connectionId)
+    : 0;
+
+  service.memoryManager.recordIngestionJob(userId, {
+    id: jobId,
+    sourceType,
+    providerKey: safeTrim(options.providerKey, 80),
+    connectionId,
+    status: 'running',
+    freshnessPolicy: policy,
+    metadata: parseJsonObject(options.metadata, {}),
+    documentCount: 0,
+    nextSyncAt: nextSyncFromPolicy(policy),
+  }, { agentId });
+
+  const documentIds = [];
+  const memoryIds = [];
+  try {
+    for (const document of normalizedDocs) {
+      const documentId = service.memoryManager.upsertIngestionDocument(
+        userId,
+        document,
+        { agentId },
+      );
+      documentIds.push(documentId);
+      const memoryId = await service.memoryManager.saveMemory(
+        userId,
+        `${document.title}: ${document.summary || document.content}`,
+        SOURCE_MEMORY_CATEGORIES[document.normalizedType]
+          || SOURCE_MEMORY_CATEGORIES[document.sourceType]
+          || 'episodic',
+        document.salience,
+        {
+          agentId,
+          staleAfterDays: getFreshnessPolicy(document.sourceType).staleAfterDays,
+          sourceRef: {
+            sourceType: 'memory_ingestion',
+            sourceId: document.externalObjectId,
+            sourceLabel: document.title,
+          },
+          scope: {
+            scopeType: 'agent',
+            scopeId: agentId,
+          },
+          metadata: {
+            ingestionJobId: jobId,
+            ingestionDocumentId: documentId,
+            providerKey: document.providerKey || null,
+            connectionId: document.connectionId || null,
+            sourceType: document.sourceType,
+          },
+        },
+      );
+      if (memoryId) memoryIds.push(memoryId);
+    }
+
+    service.memoryManager.recordIngestionJob(userId, {
+      id: jobId,
+      sourceType,
+      providerKey: safeTrim(options.providerKey, 80),
+      connectionId,
+      status: 'completed',
+      freshnessPolicy: policy,
+      summary: { documentIds, memoryIds },
+      metadata: parseJsonObject(options.metadata, {}),
+      documentCount: documentIds.length,
+      completedAt: new Date().toISOString(),
+      nextSyncAt: nextSyncFromPolicy(policy),
+    }, { agentId });
+
+    const knowledgeViews = service.memoryManager.materializeKnowledgeViews(userId, { agentId });
+    return {
+      jobId,
+      status: 'completed',
+      documentIds,
+      memoryIds,
+      knowledgeViews,
+    };
+  } catch (err) {
+    service.memoryManager.recordIngestionJob(userId, {
+      id: jobId,
+      sourceType,
+      providerKey: safeTrim(options.providerKey, 80),
+      connectionId,
+      status: 'failed',
+      freshnessPolicy: policy,
+      documentCount: documentIds.length,
+      error: err.message,
+      completedAt: new Date().toISOString(),
+      nextSyncAt: nextSyncFromPolicy(policy),
+    }, { agentId });
+    throw err;
+  }
+}
+
+module.exports = { ingestDocuments };

package/server/services/memory/ingestion_support.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const { compactTextPayload } = require('../ai/preModelCompaction');
+
+const SOURCE_TYPES = Object.freeze([
+  'email',
+  'calendar',
+  'chat',
+  'docs',
+  'tickets',
+  'repos',
+  'files',
+  'crm',
+  'payments',
+  'notes',
+]);
+
+const FRESHNESS_POLICIES = Object.freeze({
+  email: Object.freeze({ intervalMinutes: 60, staleAfterDays: 14 }),
+  calendar: Object.freeze({ intervalMinutes: 180, staleAfterDays: 30 }),
+  chat: Object.freeze({ intervalMinutes: 60, staleAfterDays: 14 }),
+  docs: Object.freeze({ intervalMinutes: 360, staleAfterDays: 60 }),
+  tickets: Object.freeze({ intervalMinutes: 120, staleAfterDays: 30 }),
+  repos: Object.freeze({ intervalMinutes: 180, staleAfterDays: 45 }),
+  files: Object.freeze({ intervalMinutes: 360, staleAfterDays: 60 }),
+  crm: Object.freeze({ intervalMinutes: 240, staleAfterDays: 45 }),
+  payments: Object.freeze({ intervalMinutes: 360, staleAfterDays: 90 }),
+  notes: Object.freeze({ intervalMinutes: 360, staleAfterDays: 90 }),
+});
+
+const SOURCE_MEMORY_CATEGORIES = Object.freeze({
+  email: 'episodic',
+  calendar: 'events',
+  chat: 'episodic',
+  docs: 'projects',
+  tickets: 'tasks',
+  repos: 'projects',
+  files: 'episodic',
+  crm: 'contacts',
+  payments: 'events',
+  notes: 'episodic',
+});
+
+const INTEGRATION_SOURCE_TYPES = Object.freeze({
+  google_workspace: Object.freeze({
+    gmail: Object.freeze(['email']),
+    calendar: Object.freeze(['calendar']),
+    drive: Object.freeze(['files']),
+    docs: Object.freeze(['docs']),
+    sheets: Object.freeze(['docs', 'files']),
+  }),
+  microsoft_365: Object.freeze({
+    outlook: Object.freeze(['email']),
+    calendar: Object.freeze(['calendar']),
+    onedrive: Object.freeze(['files']),
+    teams: Object.freeze(['chat']),
+  }),
+  github: Object.freeze({
+    repos: Object.freeze(['repos', 'tickets']),
+  }),
+  slack: Object.freeze({
+    slack: Object.freeze(['chat']),
+  }),
+  whatsapp: Object.freeze({
+    personal: Object.freeze(['chat']),
+  }),
+  notion: Object.freeze({
+    notion: Object.freeze(['notes', 'docs']),
+  }),
+  trello: Object.freeze({
+    trello: Object.freeze(['tickets']),
+  }),
+});
+
+function safeTrim(value, maxLength = 240) {
+  return String(value || '').trim().slice(0, maxLength);
+}
+
+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 normalizeSourceType(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return SOURCE_TYPES.includes(normalized) ? normalized : 'notes';
+}
+
+function getFreshnessPolicy(sourceType) {
+  const normalized = normalizeSourceType(sourceType);
+  return { ...FRESHNESS_POLICIES[normalized] };
+}
+
+function nextSyncFromPolicy(policy, now = Date.now()) {
+  const intervalMinutes = Math.max(15, Number(policy?.intervalMinutes) || 360);
+  return new Date(now + intervalMinutes * 60 * 1000).toISOString();
+}
+
+function normalizeDocument(raw = {}, defaults = {}) {
+  const sourceType = normalizeSourceType(raw.sourceType || defaults.sourceType);
+  const externalObjectId = safeTrim(raw.externalObjectId || raw.id || raw.sourceId, 180);
+  const contentSource = raw.content ?? raw.text ?? raw.body ?? '';
+  const content = safeTrim(contentSource, 12000);
+  if (!externalObjectId || !content) {
+    throw new Error('Normalized memory documents require externalObjectId and content.');
+  }
+  const compacted = compactTextPayload(content, { maxChars: 2400, maxLines: 50 });
+  return {
+    sourceType,
+    normalizedType: normalizeSourceType(raw.normalizedType || raw.memoryType || sourceType),
+    providerKey: safeTrim(raw.providerKey || defaults.providerKey, 80),
+    connectionId: Number.isInteger(Number(raw.connectionId ?? defaults.connectionId))
+      ? Number(raw.connectionId ?? defaults.connectionId)
+      : 0,
+    externalObjectId,
+    sourceAccount: safeTrim(raw.sourceAccount || defaults.sourceAccount, 180),
+    title: safeTrim(raw.title || raw.subject || raw.name || externalObjectId, 220),
+    content,
+    summary: safeTrim(raw.summary || compacted.text, 1200),
+    salience: Math.max(1, Math.min(10, Number(raw.salience) || 5)),
+    sourceTimestamp: safeTrim(raw.sourceTimestamp || raw.updatedAt || raw.createdAt, 80) || null,
+    metadata: {
+      ...parseJsonObject(raw.metadata, {}),
+      compaction: compacted.metrics,
+    },
+    payload: parseJsonObject(raw.payload, {}),
+  };
+}
+
+function sourceTypesForConnection(providerKey, appKey) {
+  const providerMap = INTEGRATION_SOURCE_TYPES[String(providerKey || '').trim()] || {};
+  return Array.from(providerMap[String(appKey || '').trim()] || []);
+}
+
+function buildCoverageForConnection(connection, latestJob = null) {
+  const dataDomains = sourceTypesForConnection(connection.provider_key, connection.app_key);
+  const supported = dataDomains.length > 0;
+  return {
+    supported,
+    contributesToMemory: supported,
+    contributesToTaskExecution: String(connection.status || '') === 'connected',
+    status: latestJob?.status || (supported ? 'ready' : 'not_supported'),
+    dataDomains,
+    lastRefreshAt: latestJob?.completedAt || latestJob?.updatedAt || null,
+    nextRefreshAt: latestJob?.nextSyncAt || null,
+    documentCount: Number(latestJob?.documentCount || 0),
+    error: latestJob?.error || null,
+  };
+}
+
+module.exports = {
+  FRESHNESS_POLICIES,
+  SOURCE_MEMORY_CATEGORIES,
+  SOURCE_TYPES,
+  buildCoverageForConnection,
+  getFreshnessPolicy,
+  nextSyncFromPolicy,
+  normalizeDocument,
+  normalizeSourceType,
+  parseJsonObject,
+  safeTrim,
+  sourceTypesForConnection,
+};

package/server/services/messaging/automation.js

@@ -18,9 +18,12 @@ const {
   buildVoiceMessagingRunOptions,
   isVoiceLikeMessage,
 } = require('../voice/runtime');
+const { getErrorMessage } = require('../bootstrap_helpers');
+const { processInboundQueue } = require('./inbound_queue');
+const { startTypingKeepalive } = require('./typing_keepalive');
 
 function registerMessagingAutomation({ app, io, messagingManager, agentEngine }) {
-  const userQueues = {};
+  const userQueues = Object.create(null);
   app.locals.userQueues = userQueues;
 
   messagingManager.registerHandler(async (userId, msg) => {
@@ -100,62 +103,85 @@ function registerMessagingAutomation({ app, io, messagingManager, agentEngine })
       messagingManager,
       agentEngine,
       userId,
-      msg
+      msg,
+      onProcessingError: ({ error, runId, failedMessage }) => {
+        const errorMessage = getErrorMessage(error);
+        console.error(
+          `[MessagingAutomation] Agent run failed platform=${failedMessage.platform} user=${userId}:`,
+          errorMessage
+        );
+        io.to(`user:${userId}`).emit('messaging:error', {
+          error: `NeoAgent could not finish the ${failedMessage.platform} request. Check the run history for details.`,
+          platform: failedMessage.platform,
+          chatId: failedMessage.chatId,
+          runId
+        });
+      }
     });
   });
 }
 
 async function processQueuedMessage({
   userQueues,
+  messagingManager,
+  agentEngine,
+  userId,
+  msg,
+  onProcessingError = null
+}) {
+  return processInboundQueue({
+    userQueues,
+    userId,
+    msg,
+    executeMessage: (queuedMessage) =>
+      executeQueuedMessage({
+        messagingManager,
+        agentEngine,
+        userId,
+        msg: queuedMessage
+      }),
+    onProcessingError
+  });
+}
+
+async function executeQueuedMessage({
   messagingManager,
   agentEngine,
   userId,
   msg
 }) {
   const agentId = msg.agentId || null;
-  const queueKey = `${userId}:${agentId || 'main'}`;
-  if (!userQueues[queueKey]) {
-    userQueues[queueKey] = { running: false, pending: [], cancelRequested: false };
-  }
-  const queue = userQueues[queueKey];
+  const runId = randomUUID();
+  const reportSideEffectError = (operation, error) => {
+    console.warn(
+      `[MessagingAutomation] ${operation} failed platform=${msg.platform} user=${userId}:`,
+      getErrorMessage(error)
+    );
+  };
 
-  if (queue.cancelRequested && !queue.running) {
-    queue.pending = [];
-    queue.cancelRequested = false;
+  try {
+    await messagingManager.markRead(
+      userId,
+      msg.platform,
+      msg.chatId,
+      msg.messageId,
+      { agentId }
+    );
+  } catch (error) {
+    reportSideEffectError('mark read', error);
   }
 
-  if (queue.running) {
-    const last = queue.pending[queue.pending.length - 1];
-    if (
-      last
-      && last.platform === msg.platform
-      && last.chatId === msg.chatId
-      && String(last.sender || '') === String(msg.sender || '')
-    ) {
-      last.content += `\n${msg.content}`;
-      last.messageId = msg.messageId;
-    } else {
-      queue.pending.push({ ...msg });
-    }
-    return;
-  }
+  const stopTypingKeepalive = startTypingKeepalive({
+    messagingManager,
+    userId,
+    agentId,
+    runId,
+    platform: msg.platform,
+    chatId: msg.chatId,
+    onError: reportSideEffectError
+  });
 
-  queue.running = true;
-  let stopTypingKeepalive = async () => {};
   try {
-    const runId = randomUUID();
-    await messagingManager
-      .markRead(userId, msg.platform, msg.chatId, msg.messageId, { agentId })
-      .catch(() => {});
-    stopTypingKeepalive = startTypingKeepalive({
-      messagingManager,
-      userId,
-      agentId,
-      runId,
-      platform: msg.platform,
-      chatId: msg.chatId
-    });
-
     const prompt = buildIncomingPrompt(msg);
     const conversationId = ensureConversation(userId, msg);
     const runOptions = isVoiceLikeMessage(msg)
@@ -182,105 +208,15 @@ async function processQueuedMessage({
       ];
     }
 
-    await agentEngine.run(userId, prompt, runOptions);
+    const result = await agentEngine.run(userId, prompt, runOptions);
+    return { runId, result, error: null };
+  } catch (error) {
+    return { runId, result: null, error };
   } finally {
     await stopTypingKeepalive();
-    if (queue.cancelRequested) {
-      queue.pending = [];
-      queue.running = false;
-      queue.cancelRequested = false;
-      return;
-    }
-    queue.running = false;
-    if (queue.pending.length > 0) {
-      const next = queue.pending.shift();
-      await processQueuedMessage({
-        userQueues,
-        messagingManager,
-        agentEngine,
-        userId,
-        msg: next
-      });
-    }
   }
 }
 
-function startTypingKeepalive({
-  messagingManager,
-  userId,
-  agentId,
-  runId,
-  platform,
-  chatId,
-  intervalMs = 4000
-}) {
-  let stopped = false;
-  let timer = null;
-  let releaseWait = null;
-  let stopPromise = null;
-
-  const matchesRunDelivery = (event) => (
-    event?.runId
-    && runId
-    && event.runId === runId
-    && event.userId === userId
-    && event.platform === platform
-    && event.to === chatId
-  );
-
-  const onMessageSent = (event) => {
-    if (matchesRunDelivery(event) && event.deliveryKind !== 'interim') {
-      stop().catch(() => {});
-    }
-  };
-
-  if (typeof messagingManager?.on === 'function' && typeof messagingManager?.off === 'function') {
-    messagingManager.on('message_sent', onMessageSent);
-  }
-
-  const wait = () =>
-    new Promise((resolve) => {
-      releaseWait = resolve;
-      timer = setTimeout(resolve, intervalMs);
-    });
-
-  const loop = (async () => {
-    while (!stopped) {
-      await messagingManager
-        .sendTyping(userId, platform, chatId, true, { agentId })
-        .catch(() => {});
-
-      if (stopped) break;
-      await wait();
-    }
-  })();
-
-  const stop = async () => {
-    if (stopPromise) return stopPromise;
-    stopPromise = (async () => {
-      if (typeof messagingManager?.off === 'function') {
-        messagingManager.off('message_sent', onMessageSent);
-      }
-      stopped = true;
-      if (timer) {
-        clearTimeout(timer);
-        timer = null;
-      }
-      if (releaseWait) {
-        releaseWait();
-        releaseWait = null;
-      }
-      await loop.catch(() => {});
-      await messagingManager
-        .sendTyping(userId, platform, chatId, false, { agentId })
-        .catch(() => {});
-    })();
-    return stopPromise;
-  };
-
-  return stop;
-}
-
 function ensureConversation(userId, msg) {
   const agentId = msg.agentId || null;
   let conversation = db
@@ -419,6 +355,7 @@ function emitBlockedSenderSuggestion({ io, userId, msg }) {
 module.exports = {
   buildIncomingPrompt,
   buildSenderIdentityBlock,
+  executeQueuedMessage,
   isAllowedMessagingSender,
   processQueuedMessage,
   registerMessagingAutomation,