@evomap/evolver 1.89.19 → 1.90.0

package/src/proxy/mailbox/store.js

@@ -345,6 +345,7 @@ class MailboxStore {
       synced_at: null,
       expires_at: expiresAt || null,
       retry_count: 0,
+      next_retry_at: null,
       error: null,
     };
     this._appendMessage(msg);
@@ -372,6 +373,7 @@ class MailboxStore {
       synced_at: null,
       expires_at: expiresAt || null,
       retry_count: 0,
+      next_retry_at: null,
       error: null,
     };
     this._appendMessage(msg);
@@ -418,6 +420,7 @@ class MailboxStore {
       const msg = this._messages.get(id);
       if (!msg || msg.status !== 'pending') continue;
       if (msg.channel !== ch) continue;
+      if (Number.isFinite(Number(msg.next_retry_at)) && Number(msg.next_retry_at) > Date.now()) continue;
       candidates.push(msg);
     }
     candidates.sort((a, b) => {
@@ -450,7 +453,7 @@ class MailboxStore {
 
   updateStatus(id, status, { error, syncedAt } = {}) {
     const TERMINAL = new Set(['synced', 'delivered', 'failed', 'rejected']);
-    const fields = { status };
+    const fields = { status, next_retry_at: null };
     if (syncedAt) fields.synced_at = syncedAt;
     else if (status === 'synced') fields.synced_at = Date.now();
     if (error !== undefined) fields.error = error;
@@ -470,7 +473,16 @@ class MailboxStore {
   incrementRetry(id, error) {
     const msg = this._messages.get(id);
     const newCount = msg ? (msg.retry_count || 0) + 1 : 1;
-    this._appendUpdate(id, { retry_count: newCount, error: error || null });
+    this._appendUpdate(id, { retry_count: newCount, next_retry_at: null, error: error || null });
+  }
+
+  deferRetry(id, error, retryAfterMs) {
+    const delay = Math.max(1_000, Number.isFinite(Number(retryAfterMs)) ? Number(retryAfterMs) : 60_000);
+    this._appendUpdate(id, {
+      status: 'pending',
+      next_retry_at: Date.now() + delay,
+      error: error || null,
+    });
   }
 
   list({ type, direction, status, limit, offset } = {}) {

package/src/proxy/sync/outbound.js

@@ -120,6 +120,30 @@ function buildSizedOutboundBatch(senderId, messages, maxBodyBytes, hardMaxBodyBy
   return { selected, rejected, body, bodyBytes, maxBodyBytes };
 }
 
+function numberField(row, keys) {
+  for (const key of keys) {
+    if (!row || row[key] === undefined || row[key] === null || row[key] === '') continue;
+    const n = Number(row[key]);
+    if (Number.isFinite(n)) return n;
+  }
+  return null;
+}
+
+function resultRetryAfterMs(row) {
+  const ms = numberField(row, ['retryAfterMs', 'retry_after_ms']);
+  if (ms !== null) return Math.max(1_000, ms);
+  const seconds = numberField(row, ['retryAfter', 'retry_after']);
+  return seconds !== null ? Math.max(1_000, seconds * 1000) : null;
+}
+
+function resultIsRetryable(row) {
+  return row && (row.retryable === true || row.retryable === 'true' || row.terminal === false || row.terminal === 'false');
+}
+
+function resultIsTerminal(row) {
+  return row && (row.terminal === true || row.terminal === 'true');
+}
+
 class OutboundSync {
   constructor({ store, hubUrl, getHeaders, logger }) {
     this.store = store;
@@ -261,17 +285,33 @@ class OutboundSync {
 
       const updates = [];
       const inboundMessages = [];
+      let deferred = 0;
 
       for (const r of results) {
         if (r.status === 'accepted' || r.status === 'ok') {
           updates.push({ id: r.id, status: 'synced' });
         } else if (r.status === 'failed' || r.status === 'rejected') {
           const msg = pending.find(m => m.id === r.id);
-          const error = sanitizeHubErrorMessage(r.error || 'rejected by hub');
-          if (msg && msg.retry_count < MAX_RETRIES) {
+          const error = sanitizeHubErrorMessage(r.error || r.reason || 'rejected by hub');
+          const retryAfterMs = resultRetryAfterMs(r);
+          // A `terminal: true` hint from the Hub means "final, do not retry"
+          // and must win even when the same result also carries retryAfterMs
+          // or retryable (a contradictory but possible payload). Guard the
+          // defer branch with !resultIsTerminal so a terminal message is
+          // finalized as failed instead of being parked for retry and resent.
+          if (msg && !resultIsTerminal(r) && (retryAfterMs !== null || resultIsRetryable(r))) {
+            this.store.deferRetry(r.id, error, retryAfterMs || 60_000);
+            deferred++;
+          } else if (msg && !resultIsTerminal(r) && msg.retry_count < MAX_RETRIES) {
             this.store.incrementRetry(r.id, error);
           } else {
-            updates.push({ id: r.id, status: 'failed', error: sanitizeHubErrorMessage(r.error || 'max retries') });
+            // Reuse the already-sanitized `error` (r.error / r.reason, else
+            // 'rejected by hub'). Only label 'max retries' for the genuine
+            // retry-exhaustion path (non-terminal, no explicit Hub error) so a
+            // terminal rejection without an error/reason is not mislabeled as
+            // retry exhaustion (Bugbot PR #301 Low).
+            const exhausted = !resultIsTerminal(r) && !(r.error || r.reason);
+            updates.push({ id: r.id, status: 'failed', error: exhausted ? sanitizeHubErrorMessage('max retries') : error });
           }
         }
 
@@ -290,6 +330,7 @@ class OutboundSync {
 
       this.store.setState('last_sync_at', new Date().toISOString());
       const result = { sent: pending.length, synced: updates.length, responses: inboundMessages.length };
+      if (deferred > 0) result.deferred = deferred;
       if (dropped > 0) result.dropped = dropped;
       return result;
     } catch (err) {