neoagent 2.3.1-beta.98 → 2.4.0

package/server/services/integrations/google/provider.js

@@ -248,6 +248,81 @@ async function executeGoogleWorkspaceTool(toolName, args, connection) {
   return { result, credentials: auth.credentials };
 }
 
+async function collectGoogleMemoryDocuments({ connection, sourceTypes = [] }) {
+  const appKey = String(connection?.app_key || '').trim();
+  const documents = [];
+  const collectedAt = new Date().toISOString();
+
+  if (appKey === 'gmail' && sourceTypes.includes('email')) {
+    const { result } = await executeGoogleWorkspaceTool(
+      'google_workspace_gmail_search_threads',
+      { query: 'newer_than:7d', max_results: 8 },
+      connection,
+    );
+    for (const thread of Array.isArray(result?.threads) ? result.threads : []) {
+      const subject = String(thread.subject || 'Gmail thread').trim();
+      documents.push({
+        externalObjectId: thread.id,
+        sourceType: 'email',
+        normalizedType: 'email',
+        title: subject,
+        content: [
+          subject,
+          thread.from ? `From: ${thread.from}` : '',
+          thread.date ? `Date: ${thread.date}` : '',
+          thread.snippet || '',
+        ].filter(Boolean).join('\n'),
+        summary: thread.snippet || subject,
+        sourceTimestamp: thread.date || collectedAt,
+        salience: Array.isArray(thread.labelIds) && thread.labelIds.includes('IMPORTANT') ? 8 : 5,
+        payload: thread,
+      });
+    }
+  }
+
+  if (appKey === 'calendar' && sourceTypes.includes('calendar')) {
+    const timeMin = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+    const timeMax = new Date(Date.now() + 14 * 24 * 60 * 60 * 1000).toISOString();
+    const { result } = await executeGoogleWorkspaceTool(
+      'google_workspace_calendar_list_events',
+      { time_min: timeMin, time_max: timeMax, max_results: 12 },
+      connection,
+    );
+    for (const event of Array.isArray(result?.events) ? result.events : []) {
+      const title = String(event.summary || 'Calendar event').trim();
+      documents.push({
+        externalObjectId: event.id,
+        sourceType: 'calendar',
+        normalizedType: 'calendar',
+        title,
+        content: [
+          title,
+          event.start ? `Start: ${event.start}` : '',
+          event.end ? `End: ${event.end}` : '',
+          event.location ? `Location: ${event.location}` : '',
+          event.description || '',
+          Array.isArray(event.attendees) && event.attendees.length
+            ? `Attendees: ${event.attendees.join(', ')}`
+            : '',
+        ].filter(Boolean).join('\n'),
+        summary: [event.start, event.location, event.description].filter(Boolean).join(' | ') || title,
+        sourceTimestamp: event.start || collectedAt,
+        salience: 6,
+        payload: event,
+      });
+    }
+  }
+
+  return {
+    documents,
+    cursor: {
+      collectedAt,
+      appKey,
+      sourceTypes,
+    },
+  };
+}
+
 function buildConnectedAppSummary(appSnapshots) {
   return appSnapshots
     .filter((app) => app.connection.connected)
@@ -456,6 +531,9 @@ function createGoogleWorkspaceProvider() {
     async executeTool(toolName, args, connectionRow) {
       return executeGoogleWorkspaceTool(toolName, args, connectionRow);
     },
+    async collectMemoryDocuments(options) {
+      return collectGoogleMemoryDocuments(options);
+    },
     summarizeConnection(connectionRows) {
       const snapshot = this.buildSnapshot(connectionRows);
       if (!snapshot.connection.connected) {

package/server/services/integrations/manager.js

@@ -182,7 +182,7 @@ class IntegrationManager {
       rowsByProvider.get(providerKey).push(row);
     }
 
-    return this.registry
+    const snapshots = this.registry
       .list()
       .map((provider) =>
         provider.buildSnapshot(rowsByProvider.get(provider.key) || [], {
@@ -190,6 +190,13 @@ class IntegrationManager {
           agentId: scopedAgentId,
         }),
       );
+    const ingestionService = this.app?.locals?.memoryIngestionService || null;
+    if (!ingestionService || typeof ingestionService.decorateProviderSnapshot !== 'function') {
+      return snapshots;
+    }
+    return snapshots.map((snapshot) =>
+      ingestionService.decorateProviderSnapshot(snapshot, userId, scopedAgentId),
+    );
   }
 
   async beginOAuth(userId, providerKey, options = {}) {
@@ -705,15 +712,20 @@ class IntegrationManager {
   }
 
   summarizeConnectedProviders(userId, agentId = null) {
+    const scopedAgentId = resolveAgentId(userId, agentId);
+    const ingestionService = this.app?.locals?.memoryIngestionService || null;
     const providers = this.registry.list().map((provider) => ({
       provider,
-      snapshot: provider.buildSnapshot(
-        this.listConnections(userId, provider.key, agentId),
-        {
-          userId,
-          agentId,
-        },
-      ),
+      snapshot: (() => {
+        const snapshot = provider.buildSnapshot(
+          this.listConnections(userId, provider.key, scopedAgentId),
+          {
+            userId,
+            agentId: scopedAgentId,
+          },
+        );
+        return ingestionService?.decorateProviderSnapshot?.(snapshot, userId, scopedAgentId) || snapshot;
+      })(),
     }));
 
     if (providers.length === 0) {
@@ -722,22 +734,26 @@ class IntegrationManager {
 
     return providers
       .map(({ provider, snapshot }) => {
+        const memoryCoverage = snapshot.memoryCoverage?.supported
+          ? ` Memory ingestion: ${snapshot.memoryCoverage.status}; domains: ${(snapshot.memoryCoverage.dataDomains || []).join(', ') || 'none'}; documents: ${snapshot.memoryCoverage.documentCount || 0}.`
+          : '';
+
         if (typeof provider.summarizeForModel === 'function') {
-          return provider.summarizeForModel(snapshot);
+          return `${provider.summarizeForModel(snapshot)}${memoryCoverage}`;
         }
 
         if (!snapshot?.env?.configured) {
           if (snapshot?.env?.setupMode === 'user') {
-            return `${provider.label}: setup is not complete for this user yet. If the user wants to use it, tell them to finish setup in Official Integrations first.`;
+            return `${provider.label}: setup is not complete for this user yet. If the user wants to use it, tell them to finish setup in Official Integrations first.${memoryCoverage}`;
           }
-          return `${provider.label}: available but not configured on the server yet. If the user wants to use it, tell them to finish setup in Official Integrations first.`;
+          return `${provider.label}: available but not configured on the server yet. If the user wants to use it, tell them to finish setup in Official Integrations first.${memoryCoverage}`;
         }
 
         if (!snapshot.connection?.connected) {
-          return `${provider.label}: server setup is ready, but no accounts are connected. If the user wants to use it, tell them to connect an account in Official Integrations first.`;
+          return `${provider.label}: server setup is ready, but no accounts are connected. If the user wants to use it, tell them to connect an account in Official Integrations first.${memoryCoverage}`;
         }
 
-        return `${provider.label}: native built-in access is connected in this run.`;
+        return `${provider.label}: native built-in access is connected in this run.${memoryCoverage}`;
       })
       .join('\n');
   }

package/server/services/manager.js

@@ -17,6 +17,7 @@ const { SocialVideoService } = require('./social_video');
 const { VoiceRuntimeManager } = require('./voice/runtimeManager');
 const { AuthProviderManager } = require('./account/auth_provider_manager');
 const { IntegrationManager } = require('./integrations/manager');
+const { MemoryIngestionService } = require('./memory/ingestion');
 const { ArtifactStore } = require('./artifacts/store');
 const { RuntimeManager } = require('./runtime/manager');
 const { WorkspaceManager } = require('./workspace/manager');
@@ -104,6 +105,20 @@ function createIntegrationManager(app) {
   return integrationManager;
 }
 
+function createMemoryIngestionService(app, { memoryManager, integrationManager }) {
+  const memoryIngestionService = registerLocal(
+    app,
+    'memoryIngestionService',
+    new MemoryIngestionService({
+      memoryManager,
+      integrationManager,
+    }),
+  );
+  memoryIngestionService.start();
+  logServiceReady('Memory ingestion service started');
+  return memoryIngestionService;
+}
+
 function createAuthProviderManager(app) {
   const authProviderManager = registerLocal(
     app,
@@ -447,6 +462,7 @@ async function startServices(app, io) {
     const mcpClient = createMcpClient(app);
     createAuthProviderManager(app);
     const integrationManager = createIntegrationManager(app);
+    createMemoryIngestionService(app, { memoryManager, integrationManager });
     const browserController = createBrowserController(app, artifactStore);
     const runtimeManager = createRuntimeManager(app);
     const runtimeValidation = getRuntimeValidation(runtimeManager);
@@ -525,6 +541,15 @@ async function stopServices(app) {
     }
   }
 
+  if (app.locals.memoryIngestionService) {
+    try {
+      app.locals.memoryIngestionService.stop();
+      logServiceReady('Memory ingestion service stopped');
+    } catch (err) {
+      console.error('[MemoryIngestion] Stop error:', getErrorMessage(err));
+    }
+  }
+
   if (app.locals.mcpClient) {
     tasks.push(
       app.locals.mcpClient.shutdown().catch((err) => {