@evomap/evolver 1.89.17 → 1.89.18

package/src/proxy/sync/outbound.js

@@ -12,9 +12,107 @@ const {
   sanitizeHubResponseForLog,
   throwIfHubUnreachableResponse,
 } = require('../../gep/hubFetch');
+const { redactString } = require('../../gep/sanitize');
 
 const MAX_BATCH = 50;
 const MAX_RETRIES = 10;
+const DEFAULT_MAX_OUTBOUND_BODY_BYTES = 4 * 1024 * 1024;
+const MIN_ADAPTIVE_OUTBOUND_BODY_BYTES = 16 * 1024;
+const OUTBOUND_BODY_BYTES_STATE_KEY = 'outbound_sync_max_body_bytes';
+
+function sanitizeHubErrorMessage(value) {
+  if (typeof sanitizeHubResponseForLog === 'function') {
+    return sanitizeHubResponseForLog(value);
+  }
+
+  let text;
+  if (typeof value === 'string') {
+    text = value;
+  } else if (value && typeof value.message === 'string') {
+    text = value.message;
+  } else {
+    try { text = JSON.stringify(value); } catch { text = String(value || ''); }
+  }
+  return redactString(String(text || ''));
+}
+
+function resolveHardOutboundBodyBytes(env = process.env) {
+  const raw = Number(env.EVOMAP_OUTBOUND_SYNC_MAX_BODY_BYTES || env.EVOMAP_MAILBOX_OUTBOUND_MAX_BODY_BYTES);
+  const max = Number.isFinite(raw) && raw > 0
+    ? Math.floor(raw)
+    : DEFAULT_MAX_OUTBOUND_BODY_BYTES;
+  return Math.max(1, max);
+}
+
+function resolveMaxOutboundBodyBytes(env = process.env, store = null) {
+  let max = resolveHardOutboundBodyBytes(env);
+  try {
+    const adaptive = Number(store && typeof store.getState === 'function'
+      ? store.getState(OUTBOUND_BODY_BYTES_STATE_KEY)
+      : null);
+    if (Number.isFinite(adaptive) && adaptive > 0) max = Math.min(max, Math.floor(adaptive));
+  } catch { /* adaptive state is best-effort */ }
+  return Math.max(1, max);
+}
+
+function hubMessage(m) {
+  return {
+    id: m.id,
+    type: m.type,
+    payload: m.payload,
+    priority: m.priority,
+    ref_id: m.ref_id,
+    created_at: m.created_at,
+  };
+}
+
+function serializeOutboundBody(senderId, messages) {
+  return JSON.stringify({
+    sender_id: senderId,
+    proxy_protocol_version: PROXY_PROTOCOL_VERSION,
+    messages: messages.map(hubMessage),
+  });
+}
+
+function outboundBodyBytes(senderId, messages) {
+  return Buffer.byteLength(serializeOutboundBody(senderId, messages), 'utf8');
+}
+
+function buildSizedOutboundBatch(senderId, messages, maxBodyBytes, hardMaxBodyBytes = maxBodyBytes) {
+  const selected = [];
+  const rejected = [];
+  let body = serializeOutboundBody(senderId, selected);
+  let bodyBytes = Buffer.byteLength(body, 'utf8');
+
+  for (const m of messages) {
+    const singleBytes = outboundBodyBytes(senderId, [m]);
+    if (singleBytes > hardMaxBodyBytes) {
+      rejected.push({
+        id: m.id,
+        status: 'rejected',
+        error: `outbound message exceeds max body bytes (${singleBytes} > ${hardMaxBodyBytes})`,
+      });
+      continue;
+    }
+    if (selected.length === 0 && singleBytes > maxBodyBytes) {
+      selected.push(m);
+      body = serializeOutboundBody(senderId, selected);
+      bodyBytes = Buffer.byteLength(body, 'utf8');
+      break;
+    }
+
+    const candidate = selected.concat(m);
+    const candidateBody = serializeOutboundBody(senderId, candidate);
+    const candidateBytes = Buffer.byteLength(candidateBody, 'utf8');
+    if (candidateBytes > maxBodyBytes) break;
+
+    selected.push(m);
+    body = candidateBody;
+    bodyBytes = candidateBytes;
+  }
+
+  return { selected, rejected, body, bodyBytes, maxBodyBytes };
+}
 
 class OutboundSync {
   constructor({ store, hubUrl, getHeaders, logger }) {
@@ -81,41 +179,76 @@ class OutboundSync {
       pending = pendingBatch.filter(m => !rejectedIds.has(m.id));
       if (pending.length === 0) return { sent: 0, dropped: rejectedTraceUploads.length };
     }
-    const dropped = rejectedTraceUploads.length;
+    let dropped = rejectedTraceUploads.length;
 
     const endpoint = `${this.hubUrl}/a2a/mailbox/outbound`;
 
     try {
       const senderId = this.store.getState('node_id');
+      const prepared = buildSizedOutboundBatch(
+        senderId,
+        pending,
+        resolveMaxOutboundBodyBytes(process.env, this.store),
+        resolveHardOutboundBodyBytes(process.env)
+      );
+      if (prepared.rejected.length > 0) {
+        this.store.updateStatusBatch(prepared.rejected);
+        dropped += prepared.rejected.length;
+      }
+      pending = prepared.selected;
+      if (pending.length === 0) return { sent: 0, dropped };
+
       const res = await hubFetch(endpoint, {
         method: 'POST',
         headers: this.getHeaders(),
-        body: JSON.stringify({
-          sender_id: senderId,
-          proxy_protocol_version: PROXY_PROTOCOL_VERSION,
-          messages: pending.map(m => ({
-            id: m.id,
-            type: m.type,
-            payload: m.payload,
-            priority: m.priority,
-            ref_id: m.ref_id,
-            created_at: m.created_at,
-          })),
-        }),
+        body: prepared.body,
         signal: AbortSignal.timeout(30_000),
       });
 
+      if (res.status === 413) {
+        const errText = sanitizeHubErrorMessage(
+          await readHubResponseText(res).catch(() => 'request entity too large')
+        );
+        const error = `Hub 413 outbound payload too large: ${errText}`;
+        if (pending.length <= 1) {
+          this.store.updateStatusBatch(pending.map(m => ({
+            id: m.id,
+            status: 'rejected',
+            error,
+          })));
+          const result = {
+            sent: 0,
+            error: 'hub_payload_too_large',
+            payloadTooLarge: true,
+            dropped: dropped + pending.length,
+          };
+          return result;
+        }
+        const currentCeiling = Math.min(prepared.maxBodyBytes, Math.max(1, prepared.bodyBytes - 1));
+        const nextMax = currentCeiling > MIN_ADAPTIVE_OUTBOUND_BODY_BYTES
+          ? Math.max(MIN_ADAPTIVE_OUTBOUND_BODY_BYTES, Math.floor(currentCeiling / 2))
+          : Math.max(1, Math.floor(currentCeiling / 2));
+        try { this.store.setState(OUTBOUND_BODY_BYTES_STATE_KEY, nextMax); } catch { /* best effort */ }
+        this.logger.warn?.(
+          `[outbound] Hub 413 for ${pending.length} messages (${prepared.bodyBytes} bytes); ` +
+            `reducing outbound batch budget to ${nextMax} bytes`
+        );
+        const result = { sent: 0, error: 'hub_payload_too_large', payloadTooLarge: true };
+        if (dropped > 0) result.dropped = dropped;
+        return result;
+      }
+
       await throwIfHubUnreachableResponse(res, 'outbound flush');
       this._recordHubReachable();
 
       if (res.status === 403 || res.status === 401) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new AuthError(`Hub ${res.status}: ${sanitizeHubResponseForLog(errText)}`, res.status);
+        const errText = sanitizeHubErrorMessage(await readHubResponseText(res).catch(() => 'unknown'));
+        throw new AuthError(`Hub ${res.status}: ${errText}`, res.status);
       }
 
       if (!res.ok) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new Error(`Hub returned ${res.status}: ${sanitizeHubResponseForLog(errText)}`);
+        const errText = sanitizeHubErrorMessage(await readHubResponseText(res).catch(() => 'unknown'));
+        throw new Error(`Hub returned ${res.status}: ${errText}`);
       }
 
       const data = await readHubResponseJson(res);
@@ -129,10 +262,11 @@ class OutboundSync {
           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) {
-            this.store.incrementRetry(r.id, r.error || 'rejected by hub');
+            this.store.incrementRetry(r.id, error);
           } else {
-            updates.push({ id: r.id, status: 'failed', error: r.error || 'max retries' });
+            updates.push({ id: r.id, status: 'failed', error: sanitizeHubErrorMessage(r.error || 'max retries') });
           }
         }
 
@@ -166,11 +300,12 @@ class OutboundSync {
         if (dropped > 0) result.dropped = dropped;
         return result;
       }
-      this.logger.error(`[outbound] flush failed: ${err.message}`);
+      const errMessage = sanitizeHubErrorMessage(err);
+      this.logger.error(`[outbound] flush failed: ${errMessage}`);
       for (const m of pending) {
-        this.store.incrementRetry(m.id, err.message);
+        this.store.incrementRetry(m.id, errMessage);
       }
-      const result = { sent: 0, error: err.message };
+      const result = { sent: 0, error: errMessage };
       if (dropped > 0) result.dropped = dropped;
       return result;
     }