@zapier/zapier-sdk 0.69.2 → 0.70.0

package/dist/plugins/triggers/drainTriggerInbox/index.js

@@ -8,6 +8,30 @@ import { resolveTriggerInboxId } from "../utils";
 import { triggersDefaults } from "../shared";
 import { isAbortError } from "../../../utils/abort-utils";
 export { ZapierAbortDrainSignal, ZapierReleaseTriggerMessageSignal, } from "./schemas";
+/**
+ * Drain errors that must NOT be retried, by error identity: a fail-fast handler
+ * error (the user's own failure — retrying would re-run a handler that already
+ * chose to stop) and an `initialization_failure` (a permanent inbox setup
+ * problem). The watch loop retries transient infrastructure errors but consults
+ * this set to leave these fatal. A WeakSet rather than a marker property because
+ * handler errors are the user's own values and must reach their catch
+ * unmodified. `markNonRetryableDrainError` no-ops on a non-object throw (it
+ * can't be weakly held), but that case is still fatal without this set: the
+ * watch loop classifies any non-object thrown value as non-retryable on its own,
+ * since the API client only ever throws Error objects, so a primitive can only
+ * be a user fail-fast throw. Permanent HTTP errors are non-retryable too, but
+ * the caller classifies those by status code, not via this set.
+ */
+const nonRetryableDrainErrors = new WeakSet();
+export function markNonRetryableDrainError(err) {
+    if (typeof err === "object" && err !== null) {
+        nonRetryableDrainErrors.add(err);
+    }
+    return err;
+}
+export function isNonRetryableDrainError(err) {
+    return (typeof err === "object" && err !== null && nonRetryableDrainErrors.has(err));
+}
 /**
  * Server returns 400 lease_expired when a UUIDv7 timestamp is in the
  * past. The API atomically quarantines messages that have hit
@@ -23,13 +47,17 @@ function isLeaseExpiredError(err) {
 /**
  * One drain pass through `runBatchedDrainPipeline`. Used directly by
  * `drainTriggerInbox` (single pass) and as the inner loop body of
- * `watchTriggerInbox` (called repeatedly with poll backoff between
- * empty passes).
+ * `watchTriggerInbox` (called once per drain request, with bounded error
+ * backoff between passes that fail with a transient error).
  */
 export async function runDrainPass(options) {
     const { sdk, inboxId, onMessage, concurrency, leaseLimit, leaseSeconds, maxMessages, releaseOnError, continueOnError, onError, signal, } = options;
     let firstFetch = options.firstFetch;
     let abortedFromCallback = false;
+    // A boolean rather than a `firstHandlerError !== undefined` sentinel so a
+    // handler that throws a falsy value (`throw undefined` / `throw null`) is still
+    // captured and surfaced as fatal, not silently swallowed.
+    let handlerErrorCaptured = false;
     let firstHandlerError = undefined;
     const outcomes = await runBatchedDrainPipeline({
         concurrency,
@@ -59,7 +87,7 @@ export async function runDrainPass(options) {
             if (lease.results.length === 0) {
                 if (firstFetch &&
                     lease.inbox_attributes.status === "initialization_failure") {
-                    throw new ZapierApiError(`Trigger inbox ${inboxId} is in initialization_failure state — inspect via getTriggerInbox.`);
+                    throw markNonRetryableDrainError(new ZapierApiError(`Trigger inbox ${inboxId} is in initialization_failure state — inspect via getTriggerInbox.`));
                 }
                 firstFetch = false;
                 return "exhausted";
@@ -108,8 +136,10 @@ export async function runDrainPass(options) {
                 // Fail-fast: capture the first real error and tell the
                 // pipeline to abort. continueOnError keeps it running.
                 if (!continueOnError && !(err instanceof ZapierSignal)) {
-                    if (firstHandlerError === undefined)
+                    if (!handlerErrorCaptured) {
                         firstHandlerError = err;
+                        handlerErrorCaptured = true;
+                    }
                     abort = true;
                 }
                 return { value: message, action, abort };
@@ -142,8 +172,11 @@ export async function runDrainPass(options) {
             }
         },
     });
-    if (firstHandlerError !== undefined)
-        throw firstHandlerError;
+    // Mark so the watch loop treats this as fatal and never retries it (a
+    // fail-fast handler error means the user already chose to stop).
+    if (handlerErrorCaptured) {
+        throw markNonRetryableDrainError(firstHandlerError);
+    }
     return { abortedFromCallback, processed: outcomes.length };
 }
 /**

package/dist/plugins/triggers/watchTriggerInbox/index.d.ts

@@ -26,8 +26,10 @@ export declare function createDrainLatch(): DrainLatch;
  * `maxDrainIntervalSeconds` seconds (default: 300) to guarantee
  * forward progress if SSE events are missed or the connection drops
  * undetected. Resolves cleanly on `signal` abort or when a callback
- * throws `ZapierAbortDrainSignal`; rejects on a fatal error or a
- * fail-fast handler error.
+ * throws `ZapierAbortDrainSignal`. Transient drain failures (5xx, 429,
+ * network blips) are retried indefinitely with bounded backoff until they
+ * succeed or the watch is aborted; it rejects only on a fail-fast handler
+ * error, an `initialization_failure`, or a permanent HTTP error.
  */
 export declare const watchTriggerInboxPlugin: (sdk: {
     context: {

package/dist/plugins/triggers/watchTriggerInbox/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/watchTriggerInbox/index.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,8BAA8B,CAAC;AAetC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AA2BzD,MAAM,WAAW,UAAU;IACzB,8EAA8E;IAC9E,OAAO,IAAI,IAAI,CAAC;IAChB,sEAAsE;IACtE,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,IAAI,UAAU,CA2B7C;AAoLD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAMnB;QAAE,OAAO,EAAE,cAAc,CAAA;KAAE;;;;;;iCAI7B,wBAAwB,KAChC,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiHnB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,UAAU,CACtD,OAAO,uBAAuB,CAC/B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/watchTriggerInbox/index.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,8BAA8B,CAAC;AAoBtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAoCzD,MAAM,WAAW,UAAU;IACzB,8EAA8E;IAC9E,OAAO,IAAI,IAAI,CAAC;IAChB,sEAAsE;IACtE,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,IAAI,UAAU,CA2B7C;AAqQD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAMnB;QAAE,OAAO,EAAE,cAAc,CAAA;KAAE;;;;;;iCAI7B,wBAAwB,KAChC,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuHnB,CAAC;AAEF,MAAM,MAAM,+BAA+B,GAAG,UAAU,CACtD,OAAO,uBAAuB,CAC/B,CAAC"}

package/dist/plugins/triggers/watchTriggerInbox/index.js

@@ -1,11 +1,11 @@
 import { definePlugin } from "kitcore";
 import { WatchTriggerInboxSchema, } from "../drainTriggerInbox/schemas";
-import { requireOnMessage, resolveConcurrencyAndLease, runDrainPass, } from "../drainTriggerInbox";
+import { requireOnMessage, resolveConcurrencyAndLease, runDrainPass, isNonRetryableDrainError, } from "../drainTriggerInbox";
 import { resolveTriggerInboxId } from "../utils";
 import { triggerInboxResolver } from "../../../resolvers";
 import { triggersDefaults } from "../shared";
 import { isAbortError, combineAbortSignals } from "../../../utils/abort-utils";
-import { sleep } from "../../../utils/retry-utils";
+import { sleep, calculateErrorBackoffMs, BASE_ERROR_BACKOFF_MS, } from "../../../utils/retry-utils";
 import { isPermanentHttpError } from "../../../api";
 import { ZapierError } from "../../../types/errors";
 import { readInboxEvents } from "./sse";
@@ -22,6 +22,14 @@ const DEFAULT_SAFETY_DRAIN_INTERVAL_MS = 300000; // 5 minutes
 // recovery from routine server-side cycling (e.g. JWT expiry); a stream that
 // closes sooner is treated as unstable and escalates like any other.
 const SSE_HEALTHY_CONNECTION_MS = 5000;
+// Consecutive transient drain failures escalate the backoff via
+// calculateErrorBackoffMs, whose error term saturates at errorCount 4 (capped at
+// 2x the base interval). Past that the delay no longer grows, so we cap the
+// counter that feeds the backoff there, holding the steady-state ~3.5 s retry
+// cadence. (The separate, intentionally uncapped errorAttempts counter in
+// drainRunner is what the diagnostics report; its unbounded growth is harmless
+// since it only feeds a log string, never the backoff math.)
+const ERROR_BACKOFF_CAP = 4;
 /**
  * Coalescing wake latch between the drain producers (SSE connect, SSE frames,
  * the safety timer, abort) and the single drain consumer. A `request()` that
@@ -61,11 +69,29 @@ export function createDrainLatch() {
 /**
  * Sole caller of `runDrainPass`, so drains are serial and never overlap. Waits
  * for a request, drains the inbox to empty, repeats. The first pass carries
- * `firstFetch: true` (preserving the initialization_failure check). Returns how
- * the watch ended so the caller can resolve or re-throw.
+ * `firstFetch: true` (preserving the initialization_failure check).
+ *
+ * Transient infrastructure failures (5xx, 429, network blips on lease / ack /
+ * release) are retried indefinitely with bounded backoff until they succeed or
+ * the watch is aborted — a watch is a "consume until aborted" loop, so a blip (or
+ * even a multi-minute outage) must not kill it, mirroring the SSE loop's
+ * resilience. The backoff escalates with consecutive failures and resets on the
+ * first success. Once retries saturate the backoff, a single warning prints to
+ * stderr (re-armed on the next success), mirroring the SSE loop's degraded-state
+ * notice; per-retry diagnostics print only under `debug`. A fail-fast handler
+ * error, an `initialization_failure`, or a permanent HTTP error is fatal
+ * immediately. Returns how the watch ended so the caller can resolve or re-throw.
  */
-async function drainRunner({ drainOptions, drainRequest, signal, }) {
+async function drainRunner({ drainOptions, drainRequest, signal, inboxId, debug, }) {
     let firstFetch = true;
+    let consecutiveErrors = 0;
+    // Uncapped, unlike consecutiveErrors: reports the true consecutive-failure count
+    // in diagnostics so a long outage doesn't freeze the logged attempt at the
+    // backoff cap. Reset on a successful pass.
+    let errorAttempts = 0;
+    // Mirrors the SSE loop's `degraded`: warn once when retries saturate the
+    // backoff, re-armed (silently) on the first successful pass.
+    let drainDegraded = false;
     while (!signal.aborted) {
         await drainRequest.waitForRequest();
         if (signal.aborted)
@@ -78,19 +104,69 @@ async function drainRunner({ drainOptions, drainRequest, signal, }) {
             }));
         }
         catch (error) {
-            return { kind: "error", error };
+            // Abort is intent, not failure — surface it as a clean stop, uncounted.
+            // `signal.aborted` alone is the predicate: every abort of THIS watch has
+            // set it by the time the catch runs, so an abort-shaped error arriving
+            // without it can only be someone else's (e.g. the user's onMessage leaking
+            // its own aborted fetch) — that's a fail-fast handler error and must
+            // reject below, not resolve the watch as a clean stop.
+            if (signal.aborted)
+                return { kind: "aborted" };
+            // Fatal, never retried: fail-fast handler errors and initialization_failure
+            // are tagged non-retryable; permanent HTTP (4xx — auth / permission /
+            // not-found) won't fix itself; and a non-object thrown value can only be a
+            // user onMessage fail-fast throw (the API client only throws Error objects),
+            // which is the user's own failure. Everything else (5xx, 429, network blip)
+            // is transient and retried below.
+            const isNonObjectThrow = typeof error !== "object" || error === null;
+            if (isNonObjectThrow ||
+                isNonRetryableDrainError(error) ||
+                isPermanentHttpError(error)) {
+                return { kind: "error", error };
+            }
+            // Transient: retry indefinitely (a watch runs until aborted). The counter
+            // only escalates the backoff and is capped where the backoff saturates, so
+            // a long outage can't grow it unbounded; a successful pass resets it below.
+            consecutiveErrors = Math.min(consecutiveErrors + 1, ERROR_BACKOFF_CAP);
+            errorAttempts += 1;
+            const delay = calculateErrorBackoffMs(BASE_ERROR_BACKOFF_MS, consecutiveErrors);
+            const statusCode = errorStatusCode(error);
+            const httpPart = statusCode !== undefined ? ` (HTTP ${statusCode})` : "";
+            // Once retries saturate the backoff the watch is making no forward
+            // progress, so surface it once on stderr even without `debug` (re-armed on
+            // recovery), mirroring how the SSE loop warns when real-time wake-ups pause.
+            if (!drainDegraded && consecutiveErrors >= ERROR_BACKOFF_CAP) {
+                console.warn(`[zapier-sdk] Draining inbox ${inboxId}${httpPart} is failing ` +
+                    `repeatedly: ${errorMessage(error)}. Continuing to retry with backoff.`);
+                drainDegraded = true;
+            }
+            if (debug) {
+                console.error(`[zapier-sdk] Retrying drain for inbox ${inboxId} ` +
+                    `(attempt ${errorAttempts}, retry in ${delay}ms)${httpPart}: ${errorMessage(error)}`);
+            }
+            await sleep(delay, signal);
+            if (signal.aborted)
+                return { kind: "aborted" };
+            // Re-arm the latch so the loop drains again even without an external
+            // wake-up (SSE frame / safety timer). firstFetch stays set so a retry of
+            // the first pass still runs the initialization_failure check.
+            drainRequest.request();
+            continue;
         }
         firstFetch = false;
+        consecutiveErrors = 0;
+        errorAttempts = 0;
+        drainDegraded = false;
         if (abortedFromCallback)
             return { kind: "abortedFromCallback" };
     }
     return { kind: "aborted" };
 }
 /** statusCode off any ZapierError (ZapierApiError, ZapierApprovalError, …). */
-function sseErrorStatusCode(err) {
+function errorStatusCode(err) {
     return err instanceof ZapierError ? err.statusCode : undefined;
 }
-function sseErrorMessage(err) {
+function errorMessage(err) {
     return err instanceof Error ? err.message : String(err);
 }
 /**
@@ -152,8 +228,8 @@ async function sseLoop({ api, inboxId, drainRequest, safetyDrainMs, signal, debu
                 return;
             if (isPermanentHttpError(err)) {
                 if (!degraded) {
-                    const statusCode = sseErrorStatusCode(err);
-                    const errorMsg = sseErrorMessage(err);
+                    const statusCode = errorStatusCode(err);
+                    const errorMsg = errorMessage(err);
                     const httpPart = statusCode !== undefined ? ` (HTTP ${statusCode})` : "";
                     console.warn(`[zapier-sdk] Real-time wake-ups for inbox ${inboxId}${httpPart} ` +
                         `paused: ${errorMsg}. Falling back to the periodic safety drain.`);
@@ -176,8 +252,8 @@ async function sseLoop({ api, inboxId, drainRequest, safetyDrainMs, signal, debu
         const delay = SSE_RECONNECT_BACKOFF_MS[Math.min(attempt, SSE_RECONNECT_BACKOFF_MS.length - 1)];
         attempt = Math.min(attempt + 1, SSE_RECONNECT_BACKOFF_MS.length - 1);
         if (transientError !== undefined && debug) {
-            const statusCode = sseErrorStatusCode(transientError);
-            const errorMsg = sseErrorMessage(transientError);
+            const statusCode = errorStatusCode(transientError);
+            const errorMsg = errorMessage(transientError);
             const httpPart = statusCode !== undefined ? ` (HTTP ${statusCode})` : "";
             console.error(`[zapier-sdk] Reconnecting real-time wake-ups for inbox ${inboxId} ` +
                 `(attempt ${attempt}, retry in ${delay}ms)${httpPart}: ${errorMsg}`);
@@ -209,8 +285,10 @@ async function safetyTimerLoop({ safetyDrainMs, drainRequest, signal, }) {
  * `maxDrainIntervalSeconds` seconds (default: 300) to guarantee
  * forward progress if SSE events are missed or the connection drops
  * undetected. Resolves cleanly on `signal` abort or when a callback
- * throws `ZapierAbortDrainSignal`; rejects on a fatal error or a
- * fail-fast handler error.
+ * throws `ZapierAbortDrainSignal`. Transient drain failures (5xx, 429,
+ * network blips) are retried indefinitely with bounded backoff until they
+ * succeed or the watch is aborted; it rejects only on a fail-fast handler
+ * error, an `initialization_failure`, or a permanent HTTP error.
  */
 export const watchTriggerInboxPlugin = definePlugin((sdk) => {
     async function watchTriggerInbox(options) {
@@ -265,7 +343,13 @@ export const watchTriggerInboxPlugin = definePlugin((sdk) => {
         // in the inbox even if SSE never connects (e.g. a permanent 4xx). SSE and
         // the safety timer then layer on additional catch-up drains.
         drainRequest.request();
-        const runnerDone = drainRunner({ drainOptions, drainRequest, signal });
+        const runnerDone = drainRunner({
+            drainOptions,
+            drainRequest,
+            signal,
+            inboxId,
+            debug,
+        });
         const sseDone = sseLoop({
             api: sdk.context.api,
             inboxId,
@@ -300,7 +384,7 @@ export const watchTriggerInboxPlugin = definePlugin((sdk) => {
                 watchTriggerInbox: {
                     ...triggersDefaults,
                     type: "create",
-                    description: "Continuously consume a trigger inbox: drain currently-available messages via onMessage, then subscribe to SSE notifications for new arrivals until aborted. A periodic safety drain runs every maxDrainIntervalSeconds (default: 300) to guarantee forward progress if SSE events are missed. Resolves cleanly on signal abort or ZapierAbortDrainSignal from a handler; rejects on fatal SDK errors or fail-fast handler errors. Real-time wake-up health is reported on stderr: a warning when wake-ups pause and the watch falls back to the safety drain, plus (with debug) transient reconnect notices.",
+                    description: "Continuously consume a trigger inbox: drain currently-available messages via onMessage, then subscribe to SSE notifications for new arrivals until aborted. A periodic safety drain runs every maxDrainIntervalSeconds (default: 300) to guarantee forward progress if SSE events are missed. Resolves cleanly on signal abort or ZapierAbortDrainSignal from a handler. Transient drain failures (5xx, 429, network blips) retry indefinitely with bounded backoff until they succeed or the watch is aborted; it rejects on a fail-fast handler error, an initialization_failure, or a permanent HTTP error. Real-time wake-up health is reported on stderr: a warning when wake-ups pause and the watch falls back to the safety drain, plus (with debug) transient reconnect notices. Persistent drain failures likewise warn once on stderr while bounded-backoff retries continue.",
                     itemType: "void",
                     // See drainTriggerInbox: override the doc generator's default
                     // suffix so the rendered return type is Promise<void>, not

package/dist/plugins/triggers/watchTriggerInbox/sse.d.ts

@@ -5,9 +5,10 @@ interface InboxSseEvent {
 }
 /**
  * Streams the trigger inbox events endpoint and yields the notification frames
- * for this inbox. The transport (SSE connection, parsing, reconnect-able error
- * mapping, abort/cleanup) lives in `api.fetchStream`; this only adds the inbox
- * URL and the `inbox_id` filter.
+ * for this inbox. The transport (SSE connection, JSON parsing, reconnect-able
+ * error mapping, abort/cleanup) lives in `api.fetchJsonStream`; this only adds
+ * the inbox URL and the `inbox_id` filter, skipping any frame whose data was
+ * not valid JSON.
  *
  * `onOpen` fires once the connection is live (response ok, body present) and
  * before the first frame. The endpoint is edge-triggered with no replay, so a
@@ -16,9 +17,10 @@ interface InboxSseEvent {
  *
  * The generator returns (without throwing) when the signal is aborted, when
  * the server closes the connection (JWT expiry, clean shutdown), or when the
- * body is empty. For a non-ok response `api.fetchStream` throws a `ZapierError`
- * carrying the HTTP `statusCode`; `isPermanentHttpError` classifies it so the
- * caller can tell permanent (4xx) failures from transient ones.
+ * body is empty. For a non-ok response `api.fetchJsonStream` throws a
+ * `ZapierError` carrying the HTTP `statusCode`; `isPermanentHttpError`
+ * classifies it so the caller can tell permanent (4xx) failures from transient
+ * ones.
  */
 export declare function readInboxEvents({ api, inboxId, signal, onOpen, }: {
     api: ApiClient;

package/dist/plugins/triggers/watchTriggerInbox/sse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/watchTriggerInbox/sse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IAIjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAuB,eAAe,CAAC,EACrC,GAAG,EACH,OAAO,EACP,MAAM,EACN,MAAM,GACP,EAAE;IACD,GAAG,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB,GAAG,cAAc,CAAC,aAAa,CAAC,CAyBhC"}
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../../src/plugins/triggers/watchTriggerInbox/sse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,UAAU,aAAa;IACrB,QAAQ,EAAE,MAAM,CAAC;IAIjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAuB,eAAe,CAAC,EACrC,GAAG,EACH,OAAO,EACP,MAAM,EACN,MAAM,GACP,EAAE;IACD,GAAG,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;CACrB,GAAG,cAAc,CAAC,aAAa,CAAC,CAqBhC"}

package/dist/plugins/triggers/watchTriggerInbox/sse.js

@@ -1,8 +1,9 @@
 /**
  * Streams the trigger inbox events endpoint and yields the notification frames
- * for this inbox. The transport (SSE connection, parsing, reconnect-able error
- * mapping, abort/cleanup) lives in `api.fetchStream`; this only adds the inbox
- * URL and the `inbox_id` filter.
+ * for this inbox. The transport (SSE connection, JSON parsing, reconnect-able
+ * error mapping, abort/cleanup) lives in `api.fetchJsonStream`; this only adds
+ * the inbox URL and the `inbox_id` filter, skipping any frame whose data was
+ * not valid JSON.
  *
  * `onOpen` fires once the connection is live (response ok, body present) and
  * before the first frame. The endpoint is edge-triggered with no replay, so a
@@ -11,19 +12,16 @@
  *
  * The generator returns (without throwing) when the signal is aborted, when
  * the server closes the connection (JWT expiry, clean shutdown), or when the
- * body is empty. For a non-ok response `api.fetchStream` throws a `ZapierError`
- * carrying the HTTP `statusCode`; `isPermanentHttpError` classifies it so the
- * caller can tell permanent (4xx) failures from transient ones.
+ * body is empty. For a non-ok response `api.fetchJsonStream` throws a
+ * `ZapierError` carrying the HTTP `statusCode`; `isPermanentHttpError`
+ * classifies it so the caller can tell permanent (4xx) failures from transient
+ * ones.
  */
 export async function* readInboxEvents({ api, inboxId, signal, onOpen, }) {
-    for await (const message of api.fetchStream(`/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/events`, { method: "GET", signal, authRequired: true, onOpen })) {
-        let parsed;
-        try {
-            parsed = JSON.parse(message.data);
-        }
-        catch {
+    for await (const message of api.fetchJsonStream(`/trigger-inbox/api/v1/inboxes/${encodeURIComponent(inboxId)}/events`, { method: "GET", signal, authRequired: true, onOpen })) {
+        if (!message.parsed)
             continue;
-        }
+        const parsed = message.data;
         if (typeof parsed === "object" &&
             parsed !== null &&
             typeof parsed.inbox_id === "string" &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zapier/zapier-sdk",
-  "version": "0.69.2",
+  "version": "0.70.0",
   "description": "Complete Zapier SDK - combines all Zapier SDK packages",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",