@newhomestar/sdk 0.7.7 → 0.7.9

package/dist/events.js

@@ -31,6 +31,7 @@
 //  NOVA_SERVICE_SLUG        — Stamped as source_service on every event
 // =====================================================================
 import dotenv from 'dotenv';
+import { Agent as UndiciAgent } from 'undici';
 // Load .env.local in dev if NOVA_EVENTS_SERVICE_URL not already set
 if (!process.env.NOVA_EVENTS_SERVICE_URL) {
     dotenv.config({ path: '.env.local', override: false });
@@ -774,6 +775,17 @@ export function startInboundConsumer(db, options) {
             reader.releaseLock();
         }
     }
+    // Dedicated undici Agent for SSE connections.
+    // Node.js's built-in fetch (undici) has a default bodyTimeout of 300s (5 minutes)
+    // which kills long-lived SSE streams as if the response body "stalled".
+    // Setting bodyTimeout: 0 disables this limit for the stream connection.
+    // headersTimeout: 30_000 still guards against slow initial connection.
+    const sseAgent = new UndiciAgent({
+        bodyTimeout: 0,
+        headersTimeout: 30_000,
+        keepAliveTimeout: 120_000,
+        keepAliveMaxTimeout: 600_000,
+    });
     /** Main loop: connect, consume, reconnect */
     async function _connect() {
         while (!abort.signal.aborted) {
@@ -784,6 +796,10 @@ export function startInboundConsumer(db, options) {
                 const response = await fetch(streamUrl, {
                     headers: { 'Authorization': `Bearer ${serviceToken}`, 'Accept': 'text/event-stream' },
                     signal: abort.signal,
+                    // @ts-ignore — undici-specific dispatcher: disables the 5-minute bodyTimeout
+                    // that kills SSE streams. Standard fetch API does not expose this option,
+                    // but Node.js's undici-powered fetch accepts it.
+                    dispatcher: sseAgent,
                 });
                 if (!response.ok) {
                     const text = await response.text().catch(() => '');
@@ -792,12 +808,33 @@ export function startInboundConsumer(db, options) {
                 // Successfully connected — reset reconnect counter
                 reconnectAttempt = 0;
                 console.log(`[nova/events] SSE consumer connected to queue "${queueName}"`);
-                await _consumeStream(response);
+                // Consume the stream; catch stream-level errors separately from
+                // connection-level errors so they don't trigger exponential backoff.
+                // A stream dying mid-flight (e.g. proxy timeout) is a normal lifecycle
+                // event — reconnect immediately with a short fixed delay.
+                try {
+                    await _consumeStream(response);
+                }
+                catch (streamErr) {
+                    if (abort.signal.aborted)
+                        return;
+                    const isAbortError = streamErr?.name === 'AbortError' || streamErr?.code === 20;
+                    if (isAbortError)
+                        return;
+                    console.error(`[nova/events] SSE stream error for queue "${queueName}":`, String(streamErr).slice(0, 300));
+                }
                 if (abort.signal.aborted) {
                     console.log(`[nova/events] SSE consumer for queue "${queueName}" shut down gracefully`);
                     return;
                 }
-                console.log(`[nova/events] SSE stream for queue "${queueName}" closed — reconnecting…`);
+                // Stream ended (normal close OR proxy timeout). The connection WAS
+                // established, so no exponential backoff — reconnect in a fixed 1s.
+                console.log(`[nova/events] SSE stream for queue "${queueName}" closed — reconnecting in 1000ms…`);
+                await new Promise((resolve) => {
+                    const t = setTimeout(resolve, 1_000);
+                    abort.signal.addEventListener('abort', () => { clearTimeout(t); resolve(); }, { once: true });
+                });
+                continue; // skip exponential backoff below
             }
             catch (err) {
                 if (abort.signal.aborted) {
@@ -809,7 +846,8 @@ export function startInboundConsumer(db, options) {
                     return;
                 console.error(`[nova/events] SSE connection error for queue "${queueName}":`, String(err).slice(0, 300));
             }
-            // Exponential backoff: 1s, 2s, 4s, 8s, ... capped at maxReconnectDelay
+            // Exponential backoff only for connection-level failures (fetch threw or
+            // server returned non-200). Stream-level drops use the fixed 1s above.
             const delayMs = Math.min(1_000 * Math.pow(2, reconnectAttempt), maxReconnectDelay);
             reconnectAttempt++;
             console.log(`[nova/events] Reconnecting queue "${queueName}" in ${delayMs}ms…`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newhomestar/sdk",
-  "version": "0.7.7",
+  "version": "0.7.9",
   "description": "Type-safe SDK for building Nova pipelines (workers & functions)",
   "homepage": "https://github.com/newhomestar/nova-node-sdk#readme",
   "bugs": {
@@ -44,6 +44,7 @@
     "dotenv": "^16.4.3",
     "express": "^4.18.2",
     "express-oauth2-jwt-bearer": "^1.7.4",
+    "undici": "^7.24.4",
     "yaml": "^2.7.1"
   },
   "peerDependencies": {