@newhomestar/sdk 0.7.6 → 0.7.8

package/dist/events.d.ts

@@ -305,7 +305,7 @@ export declare function withInboundEvent(db: any, msg: InboundMessage, handler:
  *
  * ## Connection lifecycle
  *
- * - Opens `GET /events/queue/stream?queue_name={queueName}` (SSE)
+ * - Opens `GET /events/queue/stream?queue={queueName}` (SSE)
  * - On message: routes → withInboundEvent() → ACK (or NACK on failure)
  * - On keepalive (`: keepalive`): no action needed
  * - On close/error: reconnects with exponential backoff (1s → 2s → 4s → ... → max)

package/dist/events.js

@@ -610,7 +610,7 @@ export async function withInboundEvent(db, msg, handler) {
  *
  * ## Connection lifecycle
  *
- * - Opens `GET /events/queue/stream?queue_name={queueName}` (SSE)
+ * - Opens `GET /events/queue/stream?queue={queueName}` (SSE)
  * - On message: routes → withInboundEvent() → ACK (or NACK on failure)
  * - On keepalive (`: keepalive`): no action needed
  * - On close/error: reconnects with exponential backoff (1s → 2s → 4s → ... → max)
@@ -777,7 +777,7 @@ export function startInboundConsumer(db, options) {
     /** Main loop: connect, consume, reconnect */
     async function _connect() {
         while (!abort.signal.aborted) {
-            const streamUrl = `${eventsUrl}/events/queue/stream?queue_name=${encodeURIComponent(queueName)}&vt=${vt}`;
+            const streamUrl = `${eventsUrl}/events/queue/stream?queue=${encodeURIComponent(queueName)}&vt=${vt}`;
             try {
                 console.log(`[nova/events] Connecting to SSE queue "${queueName}" ` +
                     `(attempt ${reconnectAttempt + 1})…`);
@@ -792,12 +792,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 +830,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.6",
+  "version": "0.7.8",
   "description": "Type-safe SDK for building Nova pipelines (workers & functions)",
   "homepage": "https://github.com/newhomestar/nova-node-sdk#readme",
   "bugs": {