neoagent 2.2.1-beta.6 → 2.2.1-beta.7

package/server/services/tasks/adapters/outlook_email_received.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const {
+  ensureOwnedIntegrationConnection,
+  normalizeBoolean,
+  normalizeTrimmedText,
+} = require('../security');
+
+module.exports = {
+  type: 'outlook_email_received',
+  label: 'Outlook Email Received',
+  providerKey: 'microsoft_365',
+  appKey: 'outlook',
+  async validateConfig(config = {}, context = {}) {
+    const connection = ensureOwnedIntegrationConnection(context.integrationManager, {
+      userId: context.userId,
+      agentId: context.agentId,
+      connectionId: config.connectionId || config.connection_id,
+      providerKey: 'microsoft_365',
+      appKey: 'outlook',
+    });
+    return {
+      connectionId: connection.id,
+      accountEmail: connection.account_email || null,
+      folderId: normalizeTrimmedText(config.folderId || config.folder_id, 160),
+      query: normalizeTrimmedText(config.query, 500),
+      unreadOnly: normalizeBoolean(config.unreadOnly ?? config.unread_only, false),
+    };
+  },
+  summarize(config = {}) {
+    const parts = ['Outlook'];
+    if (config.accountEmail) parts.push(config.accountEmail);
+    if (config.folderId) parts.push(`folder: ${config.folderId}`);
+    if (config.query) parts.push(`query: ${config.query}`);
+    if (config.unreadOnly) parts.push('unread only');
+    return parts.join(' · ');
+  },
+};

package/server/services/tasks/adapters/schedule.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const cron = require('node-cron');
+const { findNextRun } = require('../schedule_utils');
+
+function normalizeRunAt(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error('A valid runAt datetime is required.');
+  }
+  return date.toISOString();
+}
+
+module.exports = {
+  type: 'schedule',
+  label: 'Schedule',
+  async validateConfig(config = {}) {
+    const mode = String(config.mode || '').trim() || ((config.runAt || config.run_at) ? 'one_time' : 'recurring');
+    if (!['recurring', 'one_time'].includes(mode)) {
+      throw new Error('Schedule trigger mode must be "recurring" or "one_time".');
+    }
+    if (mode === 'one_time') {
+      const runAt = normalizeRunAt(config.runAt || config.run_at);
+      if (!runAt) {
+        throw new Error('one_time schedule requires runAt');
+      }
+      return {
+        mode,
+        runAt,
+      };
+    }
+
+    const cronExpression = String(config.cronExpression || config.cron_expression || '').trim();
+    if (!cronExpression || !cron.validate(cronExpression)) {
+      throw new Error('A valid cron expression is required.');
+    }
+    return {
+      mode,
+      cronExpression,
+    };
+  },
+  summarize(config = {}) {
+    if (config.mode === 'one_time') {
+      return config.runAt ? `One-time at ${config.runAt}` : 'One-time';
+    }
+    return String(config.cronExpression || '').trim() || 'Recurring schedule';
+  },
+  nextRun(config = {}) {
+    if (config.mode === 'one_time') return config.runAt || null;
+    try {
+      return findNextRun(config.cronExpression)?.toISOString() || null;
+    } catch {
+      return null;
+    }
+  },
+};

package/server/services/tasks/adapters/slack_message_received.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const {
+  ensureOwnedIntegrationConnection,
+  normalizeTrimmedText,
+} = require('../security');
+
+module.exports = {
+  type: 'slack_message_received',
+  label: 'Slack Message Received',
+  providerKey: 'slack',
+  appKey: 'slack',
+  async validateConfig(config = {}, context = {}) {
+    const connection = ensureOwnedIntegrationConnection(context.integrationManager, {
+      userId: context.userId,
+      agentId: context.agentId,
+      connectionId: config.connectionId || config.connection_id,
+      providerKey: 'slack',
+      appKey: 'slack',
+    });
+    const channel = normalizeTrimmedText(config.channel, 160);
+    if (!channel) {
+      throw new Error('Slack channel is required.');
+    }
+    return {
+      connectionId: connection.id,
+      accountEmail: connection.account_email || null,
+      channel,
+      sender: normalizeTrimmedText(config.sender, 160),
+    };
+  },
+  summarize(config = {}) {
+    const parts = ['Slack'];
+    if (config.accountEmail) parts.push(config.accountEmail);
+    if (config.channel) parts.push(config.channel);
+    if (config.sender) parts.push(`sender: ${config.sender}`);
+    return parts.join(' · ');
+  },
+};

package/server/services/tasks/adapters/teams_message_received.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const {
+  ensureOwnedIntegrationConnection,
+  normalizeTrimmedText,
+} = require('../security');
+
+module.exports = {
+  type: 'teams_message_received',
+  label: 'Teams Message Received',
+  providerKey: 'microsoft_365',
+  appKey: 'teams',
+  async validateConfig(config = {}, context = {}) {
+    const connection = ensureOwnedIntegrationConnection(context.integrationManager, {
+      userId: context.userId,
+      agentId: context.agentId,
+      connectionId: config.connectionId || config.connection_id,
+      providerKey: 'microsoft_365',
+      appKey: 'teams',
+    });
+    const chatId = normalizeTrimmedText(config.chatId || config.chat_id, 200);
+    if (!chatId) {
+      throw new Error('Teams chat ID is required.');
+    }
+    return {
+      connectionId: connection.id,
+      accountEmail: connection.account_email || null,
+      chatId,
+      sender: normalizeTrimmedText(config.sender, 200),
+    };
+  },
+  summarize(config = {}) {
+    const parts = ['Teams'];
+    if (config.accountEmail) parts.push(config.accountEmail);
+    if (config.chatId) parts.push(`chat: ${config.chatId}`);
+    if (config.sender) parts.push(`sender: ${config.sender}`);
+    return parts.join(' · ');
+  },
+};

package/server/services/tasks/adapters/whatsapp_personal_message_received.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const {
+  ensureOwnedIntegrationConnection,
+  normalizeBoolean,
+  normalizeTrimmedText,
+} = require('../security');
+
+module.exports = {
+  type: 'whatsapp_personal_message_received',
+  label: 'WhatsApp Personal Message Received',
+  providerKey: 'whatsapp_personal',
+  appKey: 'personal',
+  async validateConfig(config = {}, context = {}) {
+    const connection = ensureOwnedIntegrationConnection(context.integrationManager, {
+      userId: context.userId,
+      agentId: context.agentId,
+      connectionId: config.connectionId || config.connection_id,
+      providerKey: 'whatsapp_personal',
+      appKey: 'personal',
+    });
+    const chatId = normalizeTrimmedText(config.chatId || config.chat_id, 200);
+    if (!chatId) {
+      throw new Error('WhatsApp chat ID is required.');
+    }
+    return {
+      connectionId: connection.id,
+      accountEmail: connection.account_email || null,
+      chatId,
+      sender: normalizeTrimmedText(config.sender, 200),
+      ignoreGroups: normalizeBoolean(config.ignoreGroups ?? config.ignore_groups, false),
+    };
+  },
+  summarize(config = {}) {
+    const parts = ['WhatsApp Personal'];
+    if (config.accountEmail) parts.push(config.accountEmail);
+    if (config.chatId) parts.push(config.chatId);
+    if (config.sender) parts.push(`sender: ${config.sender}`);
+    if (config.ignoreGroups) parts.push('ignore groups');
+    return parts.join(' · ');
+  },
+};

package/server/services/tasks/integration_runtime.js

@@ -0,0 +1,260 @@
+'use strict';
+
+const { resolveAgentId } = require('../agents/manager');
+const { normalizeJsonObject } = require('./utils');
+
+const POLLED_TRIGGER_TYPES = Object.freeze([
+  'gmail_message_received',
+  'outlook_email_received',
+  'slack_message_received',
+  'teams_message_received',
+  'whatsapp_personal_message_received',
+]);
+
+function sortByTimestamp(left, right) {
+  return String(left.timestamp).localeCompare(String(right.timestamp));
+}
+
+async function fetchTriggerRows({ integrationManager, userId, agentId, triggerType, config }) {
+  if (!integrationManager) return [];
+  const scopedAgentId = resolveAgentId(userId, agentId);
+  const connectionArg = {
+    connection_id: config.connectionId,
+    account_email: config.accountEmail || undefined,
+  };
+
+  if (triggerType === 'gmail_message_received') {
+    const queryParts = [];
+    if (config.query) queryParts.push(config.query);
+    if (config.unreadOnly) queryParts.push('is:unread');
+    const result = await integrationManager.executeTool(userId, 'google_workspace_gmail_api_request', {
+      ...connectionArg,
+      method: 'GET',
+      path: '/gmail/v1/users/me/messages',
+      query: {
+        maxResults: 20,
+        q: queryParts.join(' ').trim() || undefined,
+      },
+    }, scopedAgentId);
+    const messages = Array.isArray(result?.messages) ? result.messages : [];
+    return messages
+      .map((item) => ({
+        fingerprint: `gmail:${config.connectionId}:${item.id}`,
+        timestamp: new Date().toISOString(),
+        context: { triggerEvent: { provider: 'gmail', messageId: item.id, threadId: item.threadId || null } },
+      }))
+      .sort((left, right) => left.fingerprint.localeCompare(right.fingerprint));
+  }
+
+  if (triggerType === 'outlook_email_received') {
+    const filters = [];
+    const escapedQuery = String(config.query || '').replace(/"/g, '\\"');
+    if (config.unreadOnly) filters.push('isRead eq false');
+    const result = await integrationManager.executeTool(userId, 'microsoft_365_outlook_graph_request', {
+      ...connectionArg,
+      method: 'GET',
+      path: config.folderId
+        ? `/v1.0/me/mailFolders/${encodeURIComponent(config.folderId)}/messages`
+        : '/v1.0/me/messages',
+      query: {
+        '$top': 20,
+        ...(filters.length ? { '$filter': filters.join(' and ') } : {}),
+        ...(escapedQuery ? { '$search': `"${escapedQuery}"` } : {}),
+      },
+    }, scopedAgentId);
+    const messages = Array.isArray(result?.value) ? result.value : [];
+    return messages
+      .map((item) => ({
+        fingerprint: `outlook:${config.connectionId}:${item.id}`,
+        timestamp: item.receivedDateTime || new Date().toISOString(),
+        context: {
+          triggerEvent: {
+            provider: 'outlook',
+            messageId: item.id,
+            subject: item.subject || '',
+            from: item.from?.emailAddress?.address || null,
+          },
+        },
+      }))
+      .sort(sortByTimestamp);
+  }
+
+  if (triggerType === 'slack_message_received') {
+    const result = await integrationManager.executeTool(userId, 'slack_get_conversation_history', {
+      ...connectionArg,
+      channel: config.channel,
+      limit: 20,
+    }, scopedAgentId);
+    const messages = Array.isArray(result?.result?.messages)
+      ? result.result.messages
+      : Array.isArray(result?.messages)
+      ? result.messages
+      : [];
+    return messages
+      .filter((item) => !config.sender || String(item.user || '') === String(config.sender))
+      .map((item) => ({
+        fingerprint: `slack:${config.connectionId}:${config.channel}:${item.ts}`,
+        timestamp: item.ts || new Date().toISOString(),
+        context: {
+          triggerEvent: {
+            provider: 'slack',
+            channel: config.channel,
+            sender: item.user || null,
+            messageId: item.client_msg_id || item.ts,
+            content: item.text || '',
+          },
+        },
+      }))
+      .sort(sortByTimestamp);
+  }
+
+  if (triggerType === 'teams_message_received') {
+    const result = await integrationManager.executeTool(userId, 'microsoft_365_teams_graph_request', {
+      ...connectionArg,
+      method: 'GET',
+      path: `/v1.0/me/chats/${encodeURIComponent(config.chatId)}/messages`,
+      query: { '$top': 20 },
+    }, scopedAgentId);
+    const messages = Array.isArray(result?.value) ? result.value : [];
+    return messages
+      .filter((item) => {
+        const sender = item.from?.user?.id || item.from?.application?.id || '';
+        return !config.sender || String(sender) === String(config.sender);
+      })
+      .map((item) => ({
+        fingerprint: `teams:${config.connectionId}:${config.chatId}:${item.id}`,
+        timestamp: item.createdDateTime || new Date().toISOString(),
+        context: {
+          triggerEvent: {
+            provider: 'teams',
+            chatId: config.chatId,
+            messageId: item.id,
+            sender: item.from?.user?.id || null,
+            content: item.body?.content || '',
+          },
+        },
+      }))
+      .sort(sortByTimestamp);
+  }
+
+  if (triggerType === 'whatsapp_personal_message_received') {
+    const result = await integrationManager.executeTool(userId, 'whatsapp_personal_get_messages', {
+      ...connectionArg,
+      chat_id: config.chatId,
+      limit: 25,
+    }, scopedAgentId);
+    const messages = Array.isArray(result?.messages) ? result.messages : [];
+    return messages
+      .filter((item) => item && item.fromMe !== true)
+      .filter((item) => !config.sender || String(item.senderTag || item.sender || '') === String(config.sender))
+      .filter((item) => !(config.ignoreGroups && String(item.chatId || '').endsWith('@g.us')))
+      .map((item) => ({
+        fingerprint: `whatsapp:${config.connectionId}:${item.id}`,
+        timestamp: item.timestamp || new Date().toISOString(),
+        context: {
+          triggerEvent: {
+            provider: 'whatsapp_personal',
+            chatId: item.chatId,
+            messageId: item.id,
+            sender: item.sender || null,
+            senderTag: item.senderTag || null,
+            content: item.text || '',
+            isGroup: String(item.chatId || '').endsWith('@g.us'),
+          },
+        },
+      }))
+      .sort(sortByTimestamp);
+  }
+
+  return [];
+}
+
+async function pollIntegrationTask(runtime, task) {
+  const config = normalizeJsonObject(task.trigger_config);
+  const rows = await fetchTriggerRows({
+    integrationManager: runtime.integrationManager,
+    userId: task.user_id,
+    agentId: task.agent_id,
+    triggerType: task.trigger_type,
+    config,
+  });
+  if (!rows.length) return;
+
+  const existingFingerprint = String(task.last_trigger_fingerprint || '');
+  const latestFingerprint = rows[rows.length - 1].fingerprint;
+  if (!existingFingerprint) {
+    runtime.taskRepository.markTaskTriggerCheckpoint(task.id, latestFingerprint);
+    return;
+  }
+
+  const startIndex = rows.findIndex((row) => row.fingerprint === existingFingerprint);
+  const pending = startIndex >= 0 ? rows.slice(startIndex + 1) : rows.slice(-1);
+  for (const row of pending) {
+    await runtime.fireTaskFromTrigger(task.id, task.user_id, row);
+  }
+}
+
+function createWhatsappTriggerPayload(event) {
+  return {
+    fingerprint: `whatsapp:${event.connectionId}:${event.messageId}`,
+    timestamp: event.timestamp,
+    context: {
+      triggerEvent: {
+        provider: 'whatsapp_personal',
+        chatId: event.chatId,
+        sender: event.sender,
+        senderTag: event.senderTag || null,
+        messageId: event.messageId,
+        content: event.text || '',
+        isGroup: event.isGroup === true,
+      },
+    },
+  };
+}
+
+function matchesWhatsappTaskEvent(task, event) {
+  const config = normalizeJsonObject(task.trigger_config);
+  if (String(config.connectionId || '') !== String(event.connectionId || '')) return false;
+  if (config.chatId && String(config.chatId) !== String(event.chatId)) return false;
+  if (config.sender && String(config.sender) !== String(event.senderTag || event.sender || '')) return false;
+  if (config.ignoreGroups && event.isGroup) return false;
+  return true;
+}
+
+function attachIntegrationEventSources(runtime) {
+  const cleanups = [];
+  const provider = runtime.integrationManager?.getProvider?.('whatsapp_personal');
+  if (provider && typeof provider.on === 'function') {
+    const listener = async (event) => {
+      const tasks = runtime.taskRepository.listEnabledWhatsappEventTasks(event.userId, event.agentId);
+      for (const task of tasks) {
+        if (!matchesWhatsappTaskEvent(task, event)) continue;
+        await runtime.fireTaskFromTrigger(task.id, task.user_id, createWhatsappTriggerPayload(event)).catch((error) => {
+          const logger = runtime.logger?.error || console.error;
+          logger('[Tasks] Failed to fire WhatsApp task trigger', {
+            taskId: task.id,
+            userId: task.user_id,
+            agentId: event.agentId,
+            error: error?.message || String(error),
+          });
+        });
+      }
+    };
+    provider.on('message', listener);
+    cleanups.push(() => {
+      if (typeof provider.off === 'function') {
+        provider.off('message', listener);
+      } else if (typeof provider.removeListener === 'function') {
+        provider.removeListener('message', listener);
+      }
+    });
+  }
+  return cleanups;
+}
+
+module.exports = {
+  POLLED_TRIGGER_TYPES,
+  attachIntegrationEventSources,
+  fetchTriggerRows,
+  pollIntegrationTask,
+};