neoagent 3.2.1-beta.1 → 3.2.1-beta.11

package/server/services/messaging/inbound_queue.js

@@ -2,89 +2,203 @@
 
 const { getErrorMessage } = require('../bootstrap_helpers');
 
+function completionResult(outcome, cancelled = false) {
+  return {
+    runId: outcome?.runId || null,
+    result: outcome?.result || null,
+    error: outcome?.error || null,
+    cancelled,
+  };
+}
+
+function settleWaiters(item, result) {
+  for (const resolve of item?.waiters || []) resolve(result);
+  if (item?.waiters) item.waiters = [];
+}
+
+function cancelPending(queue) {
+  const result = completionResult(null, true);
+  for (const item of queue.pending.splice(0)) settleWaiters(item, result);
+}
+
+function queueKeyForMessage(userId, msg) {
+  return [
+    String(userId),
+    String(msg.agentId || 'main'),
+    String(msg.platform || ''),
+    String(msg.chatId || ''),
+  ].join(':');
+}
+
+function batchEntry(msg) {
+  return {
+    sender: msg.sender || null,
+    senderName: msg.senderDisplayName || msg.senderName || msg.senderUsername || null,
+    content: String(msg.content || ''),
+    messageId: msg.messageId || null,
+    timestamp: msg.timestamp || null,
+    wasMentioned: msg.wasMentioned === true,
+    repliedToAgent: msg.repliedToAgent === true,
+  };
+}
+
+function mergeMessage(target, msg) {
+  const existingBatch = Array.isArray(target.message.messageBatch)
+    ? target.message.messageBatch
+    : [batchEntry(target.message)];
+  const nextBatch = [...existingBatch, batchEntry(msg)];
+  target.message.messageBatch = nextBatch;
+  target.message.content = target.message.isGroup
+    ? nextBatch.map((entry) => (
+      `[${entry.senderName || entry.sender || 'participant'}]: ${entry.content}`
+    )).join('\n')
+    : nextBatch.map((entry) => entry.content).join('\n');
+  target.message.messageId = msg.messageId || target.message.messageId;
+  target.message.timestamp = msg.timestamp || target.message.timestamp;
+  target.message.wasMentioned = target.message.wasMentioned === true || msg.wasMentioned === true;
+  target.message.repliedToAgent = target.message.repliedToAgent === true || msg.repliedToAgent === true;
+  target.message.behaviorTurnEpoch = Math.max(
+    Number(target.message.behaviorTurnEpoch || 0),
+    Number(msg.behaviorTurnEpoch || 0),
+  );
+  target.message.inboundJobIds = Array.from(new Set([
+    ...(target.message.inboundJobIds || []),
+    target.message.inboundJobId,
+    ...(msg.inboundJobIds || []),
+    msg.inboundJobId,
+  ].filter(Boolean)));
+}
+
+function queuedResult(queue, msg) {
+  let resolveCompletion;
+  const completion = new Promise((resolve) => {
+    resolveCompletion = resolve;
+  });
+  const last = queue.collecting && queue.activeItem
+    ? queue.activeItem
+    : queue.pending[queue.pending.length - 1];
+  if (
+    last
+    && last.message.platform === msg.platform
+    && last.message.chatId === msg.chatId
+    && (
+      last.message.isGroup === true
+      || String(last.message.sender || '') === String(msg.sender || '')
+    )
+  ) {
+    mergeMessage(last, msg);
+    last.waiters.push(resolveCompletion);
+  } else {
+    queue.pending.push({
+      message: { ...msg },
+      waiters: [resolveCompletion],
+    });
+  }
+  const result = { queued: true };
+  Object.defineProperty(result, 'completion', { value: completion });
+  return result;
+}
+
 async function processInboundQueue({
   userQueues,
   userId,
   msg,
   executeMessage,
-  onProcessingError = null
+  onProcessingError = null,
+  batchWindowMs = 0,
 }) {
-  const agentId = msg.agentId || null;
-  const queueKey = `${userId}:${agentId || 'main'}`;
+  const queueKey = queueKeyForMessage(userId, msg);
   if (!userQueues[queueKey]) {
-    userQueues[queueKey] = { running: false, pending: [], cancelRequested: false };
+    userQueues[queueKey] = {
+      running: false,
+      pending: [],
+      activeItem: null,
+      collecting: false,
+      cancelRequested: false,
+      cancelPending() {
+        cancelPending(this);
+      },
+    };
   }
   const queue = userQueues[queueKey];
 
   if (queue.cancelRequested && !queue.running) {
-    queue.pending = [];
+    cancelPending(queue);
     queue.cancelRequested = false;
   }
 
   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 { queued: true };
+    return queuedResult(queue, msg);
   }
 
   queue.running = true;
-  let currentMessage = msg;
+  let currentItem = { message: msg, waiters: [] };
   let processedCount = 0;
   let failedCount = 0;
   let cancelled = false;
+  let initialOutcome = null;
 
   try {
-    while (currentMessage) {
+    while (currentItem) {
+      queue.activeItem = currentItem;
+      const delayMs = currentItem.message.isGroup
+        ? Math.max(0, Math.min(5000, Number(batchWindowMs) || 0))
+        : 0;
+      if (delayMs > 0) {
+        queue.collecting = true;
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        queue.collecting = false;
+      }
       let outcome;
       try {
-        outcome = await executeMessage(currentMessage);
+        outcome = await executeMessage(currentItem.message);
       } catch (error) {
         outcome = { runId: null, result: null, error };
       }
       processedCount += 1;
+      const itemCancelled = queue.cancelRequested;
+      const itemResult = completionResult(outcome, itemCancelled);
+      if (!initialOutcome) initialOutcome = itemResult;
+      settleWaiters(currentItem, itemResult);
 
-      if (outcome?.error) {
+      if (outcome?.error && !queue.cancelRequested) {
         failedCount += 1;
         await notifyProcessingError(onProcessingError, {
           error: outcome.error,
           runId: outcome.runId,
           userId,
-          failedMessage: currentMessage
+          failedMessage: currentItem.message
         });
       }
 
       if (queue.cancelRequested) {
-        queue.pending = [];
+        cancelPending(queue);
         cancelled = true;
         break;
       }
 
-      currentMessage = queue.pending.shift() || null;
+      currentItem = queue.pending.shift() || null;
     }
   } finally {
     queue.running = false;
-    queue.pending = [];
+    queue.collecting = false;
+    queue.activeItem = null;
+    cancelPending(queue);
     queue.cancelRequested = false;
     if (userQueues[queueKey] === queue) {
       delete userQueues[queueKey];
     }
   }
 
-  return {
+  const result = {
     processedCount,
     failedCount,
     cancelled
   };
+  Object.defineProperty(result, 'outcome', {
+    value: initialOutcome || completionResult(null, cancelled),
+  });
+  return result;
 }
 
 async function notifyProcessingError(handler, details) {
@@ -107,5 +221,6 @@ async function notifyProcessingError(handler, details) {
 }
 
 module.exports = {
-  processInboundQueue
+  processInboundQueue,
+  queueKeyForMessage,
 };

package/server/services/messaging/inbound_store.js

@@ -0,0 +1,257 @@
+'use strict';
+
+const { randomUUID } = require('node:crypto');
+const db = require('../../db/database');
+
+const MAX_INBOUND_PAYLOAD_BYTES = 1024 * 1024;
+const JOB_STATUSES = new Set(['pending', 'processing', 'completed', 'failed']);
+
+function encodePayload(payload) {
+  const encoded = JSON.stringify(payload);
+  if (Buffer.byteLength(encoded, 'utf8') > MAX_INBOUND_PAYLOAD_BYTES) {
+    const error = new Error('Inbound messaging payload exceeds the 1 MiB durability limit.');
+    error.code = 'MESSAGING_INBOUND_PAYLOAD_TOO_LARGE';
+    throw error;
+  }
+  return encoded;
+}
+
+function decodePayload(value) {
+  try {
+    const payload = JSON.parse(String(value || ''));
+    return payload && typeof payload === 'object' && !Array.isArray(payload)
+      ? payload
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function getJobByMessageId(messageId) {
+  return db.prepare(
+    'SELECT * FROM messaging_inbound_jobs WHERE message_id = ?',
+  ).get(messageId) || null;
+}
+
+function enqueueInboundMessage({
+  userId,
+  agentId,
+  platform,
+  platformMessageId,
+  chatId,
+  content,
+  metadata,
+  createdAt,
+  payload,
+}) {
+  return db.transaction(() => {
+    if (platformMessageId) {
+      const existing = db.prepare(
+        `SELECT id
+         FROM messages
+         WHERE user_id = ? AND platform = ? AND platform_msg_id = ? AND role = 'user'
+         LIMIT 1`,
+      ).get(userId, platform, platformMessageId);
+      if (existing) {
+        return {
+          created: false,
+          job: getJobByMessageId(existing.id),
+          messageId: existing.id,
+        };
+      }
+    }
+
+    const jobId = randomUUID();
+    const durablePayload = {
+      ...payload,
+      inboundJobId: jobId,
+      inboundJobIds: [jobId],
+    };
+    const insert = db.prepare(
+      `INSERT INTO messages (
+        user_id, agent_id, role, content, platform, platform_msg_id,
+        platform_chat_id, metadata, created_at
+      ) VALUES (?, ?, 'user', ?, ?, ?, ?, ?, ?)`,
+    ).run(
+      userId,
+      agentId,
+      content,
+      platform,
+      platformMessageId || null,
+      chatId,
+      metadata ? JSON.stringify(metadata) : null,
+      createdAt || new Date().toISOString(),
+    );
+    const messageId = Number(insert.lastInsertRowid);
+    db.prepare(
+      `INSERT INTO messaging_inbound_jobs (
+        id, message_id, user_id, agent_id, platform, platform_msg_id,
+        platform_chat_id, payload_json, status
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending')`,
+    ).run(
+      jobId,
+      messageId,
+      userId,
+      agentId,
+      platform,
+      platformMessageId || null,
+      chatId,
+      encodePayload(durablePayload),
+    );
+    return {
+      created: true,
+      job: getJobByMessageId(messageId),
+      messageId,
+      payload: durablePayload,
+    };
+  })();
+}
+
+function claimInboundJob(jobId) {
+  const result = db.prepare(
+    `UPDATE messaging_inbound_jobs
+     SET status = 'processing',
+         attempts = attempts + 1,
+         last_error = NULL,
+         updated_at = datetime('now')
+     WHERE id = ? AND status = 'pending'`,
+  ).run(jobId);
+  return result.changes === 1;
+}
+
+function settleInboundJob(jobId, status, error = null) {
+  if (!JOB_STATUSES.has(status) || status === 'processing') {
+    throw new Error(`Invalid inbound messaging job status: ${status}`);
+  }
+  db.prepare(
+    `UPDATE messaging_inbound_jobs
+     SET status = ?,
+         last_error = ?,
+         completed_at = CASE WHEN ? IN ('completed', 'failed') THEN datetime('now') ELSE NULL END,
+         updated_at = datetime('now')
+     WHERE id = ?`,
+  ).run(
+    status,
+    error ? String(error).slice(0, 4000) : null,
+    status,
+    jobId,
+  );
+}
+
+function attachRunToInboundJobs(jobIds, runId) {
+  const ids = Array.from(new Set(
+    (Array.isArray(jobIds) ? jobIds : [jobIds])
+      .map((value) => String(value || '').trim())
+      .filter(Boolean),
+  ));
+  if (!ids.length || !runId) return 0;
+  const update = db.prepare(
+    `UPDATE messaging_inbound_jobs
+     SET run_id = ?, updated_at = datetime('now')
+     WHERE id = ? AND status = 'processing'`,
+  );
+  return db.transaction(() => ids.reduce(
+    (count, id) => count + update.run(runId, id).changes,
+    0,
+  ))();
+}
+
+function annotateInboundJobs(jobIds, annotation) {
+  const ids = Array.from(new Set(
+    (Array.isArray(jobIds) ? jobIds : [jobIds])
+      .map((value) => String(value || '').trim())
+      .filter(Boolean),
+  ));
+  if (!ids.length) return 0;
+  const read = db.prepare(
+    `SELECT messages.id, messages.metadata
+     FROM messaging_inbound_jobs
+     JOIN messages ON messages.id = messaging_inbound_jobs.message_id
+     WHERE messaging_inbound_jobs.id = ?`,
+  );
+  const update = db.prepare('UPDATE messages SET metadata = ? WHERE id = ?');
+  return db.transaction(() => {
+    let count = 0;
+    for (const id of ids) {
+      const row = read.get(id);
+      if (!row) continue;
+      let metadata = {};
+      try {
+        metadata = row.metadata ? JSON.parse(row.metadata) : {};
+      } catch {
+        metadata = {};
+      }
+      update.run(JSON.stringify({ ...metadata, ...annotation }), row.id);
+      count += 1;
+    }
+    return count;
+  })();
+}
+
+function reconcileInterruptedInboundJobs() {
+  return db.transaction(() => {
+    const completed = db.prepare(
+      `UPDATE messaging_inbound_jobs
+       SET status = 'completed', completed_at = datetime('now'), updated_at = datetime('now')
+       WHERE status = 'processing'
+         AND run_id IN (SELECT id FROM agent_runs WHERE status = 'completed')`,
+    ).run().changes;
+    const failed = db.prepare(
+      `UPDATE messaging_inbound_jobs
+       SET status = 'failed',
+           last_error = COALESCE(last_error, 'The server restarted after this agent run began; it will not be replayed automatically.'),
+           completed_at = datetime('now'),
+           updated_at = datetime('now')
+       WHERE status = 'processing'
+         AND run_id IN (SELECT id FROM agent_runs)`,
+    ).run().changes;
+    const pending = db.prepare(
+      `UPDATE messaging_inbound_jobs
+       SET status = 'pending',
+           last_error = NULL,
+           updated_at = datetime('now')
+       WHERE status = 'processing'
+         AND (run_id IS NULL OR run_id NOT IN (SELECT id FROM agent_runs))`,
+    ).run().changes;
+    return { completed, failed, pending };
+  })();
+}
+
+function listPendingInboundJobs(filters = {}) {
+  const clauses = ["status = 'pending'"];
+  const values = [];
+  for (const [column, value] of [
+    ['user_id', filters.userId],
+    ['agent_id', filters.agentId],
+    ['platform', filters.platform],
+  ]) {
+    if (value === undefined) continue;
+    if (value === null) clauses.push(`${column} IS NULL`);
+    else {
+      clauses.push(`${column} = ?`);
+      values.push(value);
+    }
+  }
+  const limit = Math.max(1, Math.min(500, Number(filters.limit) || 100));
+  return db.prepare(
+    `SELECT * FROM messaging_inbound_jobs
+     WHERE ${clauses.join(' AND ')}
+     ORDER BY created_at ASC, id ASC
+     LIMIT ?`,
+  ).all(...values, limit);
+}
+
+function payloadForInboundJob(job) {
+  return decodePayload(job?.payload_json);
+}
+
+module.exports = {
+  annotateInboundJobs,
+  attachRunToInboundJobs,
+  claimInboundJob,
+  enqueueInboundMessage,
+  listPendingInboundJobs,
+  payloadForInboundJob,
+  reconcileInterruptedInboundJobs,
+  settleInboundJob,
+};