@zapier/zapier-sdk 0.94.1 → 0.96.0

package/dist/{chunk-7NCOFRA6.cjs → chunk-MGWFLOHA.cjs}

@@ -1541,6 +1541,11 @@ function declareOptionalProperty(config) {
     // import binding is still typed `TValue | undefined` from the descriptor.
   };
 }
+function declareDefault({
+  plugin
+}) {
+  return { ...plugin, defaultSource: plugin };
+}
 function defineHook(config) {
   const deps = normalizeImports(config.imports);
   return {
@@ -4210,6 +4215,321 @@ function createCorePlugin(options) {
     }
   });
 }
+function describeUnclaimedConnection(connection) {
+  const delimiterIndex = connection.indexOf(":");
+  if (delimiterIndex === -1) {
+    return 'no auth provider claimed this connection, and it carries no "scheme:" prefix';
+  }
+  return `no auth provider claimed the "${connection.slice(0, delimiterIndex)}" connection scheme`;
+}
+var authorizeHttpRequestPlugin = defineMethod({
+  name: "authorizeHttpRequest",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => {
+    const { connection } = input.request;
+    if (connection != null) {
+      throw createCoreError({
+        code: CoreErrorCode.Unknown,
+        message: `authorizeHttpRequest: ${describeUnclaimedConnection(connection)}, so the request was not sent.`
+      });
+    }
+    return input.request;
+  }
+});
+function toFetchInput(request) {
+  const init = { ...request };
+  const { url } = request;
+  delete init.url;
+  delete init.connection;
+  return { url, init };
+}
+var dispatchHttpRequestPlugin = defineMethod({
+  name: "dispatchHttpRequest",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => {
+    const { url, init } = toFetchInput(input.request);
+    return fetch(url, init);
+  }
+});
+var prepareHttpRequestPlugin = defineMethod({
+  name: "prepareHttpRequest",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => input.request
+});
+var receiveHttpResponsePlugin = defineMethod({
+  name: "receiveHttpResponse",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => input.response
+});
+var attemptHttpRequestPlugin = defineMethod({
+  name: "attemptHttpRequest",
+  namespace: "kitcore",
+  imports: [
+    declareDefault({ plugin: prepareHttpRequestPlugin }),
+    declareDefault({ plugin: authorizeHttpRequestPlugin }),
+    declareDefault({ plugin: dispatchHttpRequestPlugin }),
+    declareDefault({ plugin: receiveHttpResponsePlugin })
+  ],
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input, imports }) => {
+    const { attempt } = input;
+    const preparedRequest = await imports.prepareHttpRequest({
+      request: input.request,
+      attempt
+    });
+    const authorizedRequest = await imports.authorizeHttpRequest({
+      request: preparedRequest,
+      attempt
+    });
+    const response = await imports.dispatchHttpRequest({
+      request: authorizedRequest,
+      attempt
+    });
+    return imports.receiveHttpResponse({
+      request: authorizedRequest,
+      response,
+      attempt
+    });
+  }
+});
+function isReplayableBody(body) {
+  if (body == null || typeof body !== "object") return true;
+  return typeof Blob !== "undefined" && body instanceof Blob || // File extends Blob
+  typeof FormData !== "undefined" && body instanceof FormData || typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams || body instanceof ArrayBuffer || ArrayBuffer.isView(body);
+}
+function withStringUrl(request) {
+  return typeof request.url === "string" ? request : { ...request, url: String(request.url) };
+}
+var initializeHttpRequestPlugin = defineMethod({
+  name: "initializeHttpRequest",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input }) => {
+    const request = withStringUrl(input.request);
+    return {
+      ...input.operation,
+      request,
+      replayable: isReplayableBody(request.body)
+    };
+  }
+});
+var RETRY_HTTP_REQUEST_OPTIONS_ID = "kitcore/retryHttpRequestOptions";
+var retryHttpRequestOptionsPluginRef = declareOptionalProperty({ id: RETRY_HTTP_REQUEST_OPTIONS_ID });
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_MAX_DELAY_MILLISECONDS = 6e4;
+var DEFAULT_RETRY_STATUSES = [429, 500, 502, 503, 504];
+var DEFAULT_NON_IDEMPOTENT_RETRY_STATUSES = [429];
+var DEFAULT_IDEMPOTENT_METHODS = [
+  "GET",
+  "HEAD",
+  "PUT",
+  "DELETE",
+  "OPTIONS",
+  "TRACE"
+];
+var BASE_BACKOFF_MILLISECONDS = 1e3;
+var JITTER_FACTOR = 0.5;
+function directedDelayMilliseconds(response) {
+  const retryAfter = response.headers.get("retry-after");
+  if (retryAfter) {
+    const seconds = Number.parseInt(retryAfter, 10);
+    if (!Number.isNaN(seconds)) return Math.max(0, seconds * 1e3);
+    const date = Date.parse(retryAfter);
+    if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  }
+  const reset = response.headers.get("x-ratelimit-reset");
+  if (reset) {
+    const resetSeconds = Number.parseInt(reset, 10);
+    if (!Number.isNaN(resetSeconds)) {
+      return Math.max(0, resetSeconds * 1e3 - Date.now());
+    }
+  }
+  return void 0;
+}
+function backoffMilliseconds(attemptNumber) {
+  const base = BASE_BACKOFF_MILLISECONDS * 2 ** (attemptNumber - 1);
+  return base + Math.random() * JITTER_FACTOR * base;
+}
+function abortReason(signal) {
+  const reason = signal?.reason;
+  return reason ?? new Error("The request was aborted.");
+}
+function sleep(milliseconds, signal) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(finish, milliseconds);
+    function finish() {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", cancel);
+      resolve2();
+    }
+    function cancel() {
+      clearTimeout(timer);
+      reject(abortReason(signal));
+    }
+    if (signal?.aborted) return cancel();
+    signal?.addEventListener("abort", cancel, { once: true });
+  });
+}
+function isIdempotent(request, idempotentMethods) {
+  const method = (request.method ?? "GET").toUpperCase();
+  return idempotentMethods.includes(method);
+}
+defineHook({
+  name: "retryHttpRequest",
+  imports: [attemptHttpRequestPlugin, retryHttpRequestOptionsPluginRef],
+  wrap: {
+    attemptHttpRequest: async ({ input, imports, next }) => {
+      const options = imports.retryHttpRequestOptions ?? {};
+      const maxAttempts = options.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+      const maxDelayMilliseconds = options.maxDelayMilliseconds ?? DEFAULT_MAX_DELAY_MILLISECONDS;
+      const idempotentMethods = options.idempotentMethods ?? DEFAULT_IDEMPOTENT_METHODS;
+      const statuses = isIdempotent(input.request, idempotentMethods) ? options.retryStatuses ?? DEFAULT_RETRY_STATUSES : options.nonIdempotentRetryStatuses ?? DEFAULT_NON_IDEMPOTENT_RETRY_STATUSES;
+      for (let attemptNumber = 1; ; attemptNumber++) {
+        const attempt = {
+          ...input.attempt,
+          attemptNumber,
+          // Per-attempt scratch: a cross-stage handoff from a previous attempt
+          // describes a request that is no longer in flight. `operation` rides
+          // through unchanged, so the id and the caller's original request are
+          // the same for every attempt.
+          state: {}
+        };
+        let response;
+        try {
+          response = await next({ ...input, attempt });
+        } catch (error) {
+          if (!options.retryOnError || !canRetry(
+            attemptNumber,
+            maxAttempts,
+            input.attempt.operation.replayable
+          )) {
+            throw error;
+          }
+          await sleep(
+            Math.min(backoffMilliseconds(attemptNumber), maxDelayMilliseconds),
+            attempt.signal
+          );
+          continue;
+        }
+        if (!statuses.includes(response.status) || !canRetry(
+          attemptNumber,
+          maxAttempts,
+          input.attempt.operation.replayable
+        )) {
+          return response;
+        }
+        const directed = directedDelayMilliseconds(response);
+        if (directed != null && directed > maxDelayMilliseconds)
+          return response;
+        const delay = Math.min(
+          directed ?? backoffMilliseconds(attemptNumber),
+          maxDelayMilliseconds
+        );
+        await response.body?.cancel().catch(() => {
+        });
+        await sleep(delay, attempt.signal);
+      }
+    }
+  }
+});
+function canRetry(attemptNumber, maxAttempts, replayable) {
+  return attemptNumber < maxAttempts && replayable;
+}
+function createOperationId() {
+  return globalThis.crypto?.randomUUID?.() ?? `http-${Date.now()}`;
+}
+var sendHttpRequestPlugin = defineMethod({
+  name: "sendHttpRequest",
+  namespace: "kitcore",
+  imports: [
+    declareDefault({ plugin: initializeHttpRequestPlugin }),
+    declareDefault({ plugin: attemptHttpRequestPlugin })
+  ],
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: async ({ input, imports }) => {
+    const start2 = {
+      operationId: createOperationId(),
+      signal: input.signal
+    };
+    const operation = await imports.initializeHttpRequest({
+      request: input,
+      operation: start2
+    });
+    return imports.attemptHttpRequest({
+      request: operation.request,
+      attempt: {
+        attemptNumber: 1,
+        operation,
+        signal: operation.signal,
+        state: {}
+      }
+    });
+  }
+});
+defineMethod({
+  name: "fetch",
+  namespace: "kitcore",
+  imports: [declareDefault({ plugin: sendHttpRequestPlugin })],
+  positional: ["url", "init"],
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: ({ input, imports }) => {
+    const { url, init } = input;
+    return imports.sendHttpRequest({ url, ...init });
+  }
+});
+var defaultConnectionSchemePlugin = defineMethod({
+  name: "defaultConnectionScheme",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: () => void 0
+});
+defineMethod({
+  name: "normalizeConnection",
+  namespace: "kitcore",
+  imports: [declareDefault({ plugin: defaultConnectionSchemePlugin })],
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: ({ input, imports }) => {
+    const { connection } = input;
+    if (connection == null) {
+      return void 0;
+    }
+    const delimiterIndex = connection.indexOf(":");
+    if (delimiterIndex !== -1) {
+      return {
+        connection,
+        scheme: connection.slice(0, delimiterIndex),
+        value: connection.slice(delimiterIndex + 1)
+      };
+    }
+    const scheme = imports.defaultConnectionScheme({ connection });
+    return {
+      connection,
+      scheme,
+      value: connection
+    };
+  }
+});
+defineMethod({
+  name: "resolveConnection",
+  namespace: "kitcore",
+  inputSchema: zod.z.custom(),
+  skipInputValidation: true,
+  run: ({ input }) => input.connection
+});
 
 // src/constants.ts
 var ZAPIER_BASE_URL = globalThis.process?.env?.ZAPIER_BASE_URL || "https://zapier.com";
@@ -4914,9 +5234,9 @@ function createDebugFetch(options) {
 var MAX_CONSECUTIVE_ERRORS = 3;
 var BASE_ERROR_BACKOFF_MILLISECONDS = 1e3;
 var BASE_EXPONENTIAL_BACKOFF_MILLISECONDS = 1e3;
-var JITTER_FACTOR = 0.5;
+var JITTER_FACTOR2 = 0.5;
 function calculateErrorBackoffMs(baseInterval, errorCount) {
-  const jitter = Math.random() * JITTER_FACTOR * baseInterval;
+  const jitter = Math.random() * JITTER_FACTOR2 * baseInterval;
   const errorBackoff = Math.min(
     BASE_ERROR_BACKOFF_MILLISECONDS * (errorCount / 2),
     baseInterval * 2
@@ -4926,10 +5246,10 @@ function calculateErrorBackoffMs(baseInterval, errorCount) {
 }
 function calculateExponentialBackoffMs(attempt, baseDelayMs = BASE_EXPONENTIAL_BACKOFF_MILLISECONDS) {
   const baseDelay = baseDelayMs * Math.pow(2, attempt - 1);
-  const jitter = Math.random() * JITTER_FACTOR * baseDelay;
+  const jitter = Math.random() * JITTER_FACTOR2 * baseDelay;
   return Math.floor(baseDelay + jitter);
 }
-function sleep(ms, signal) {
+function sleep2(ms, signal) {
   if (!signal) {
     return new Promise((resolve2) => setTimeout(resolve2, ms));
   }
@@ -5141,7 +5461,7 @@ async function pollUntilComplete(options) {
   let attempts = 0;
   let errorCount = 0;
   if (initialDelay > 0) {
-    await sleep(initialDelay, signal);
+    await sleep2(initialDelay, signal);
     if (signal?.aborted) throw makeAbortError();
   }
   while (true) {
@@ -5159,7 +5479,7 @@ async function pollUntilComplete(options) {
       const interval = getPollingInterval(elapsedTime);
       const waitTime = calculateErrorBackoffMs(interval, errorCount);
       const cappedWaitTime = maxPollingIntervalMs === void 0 ? waitTime : Math.min(waitTime, maxPollingIntervalMs);
-      await sleep(cappedWaitTime, signal);
+      await sleep2(cappedWaitTime, signal);
       if (signal?.aborted) throw makeAbortError();
     }
     attempts++;
@@ -6194,7 +6514,7 @@ function parseDeprecationDate(value) {
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.94.1" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.96.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -6303,7 +6623,11 @@ var PollApprovalResponseSchema = zod.z.object({
   status: ApprovalStatusSchema,
   approval_id: zod.z.string().optional(),
   mode: ApprovalModeSchema.optional(),
-  reason: zod.z.string().optional()
+  reason: zod.z.string().optional(),
+  // Present when an auto-mode agent escalated the approval to a human reviewer.
+  // The SDK uses review_status to detect escalation and approval_url to open the browser.
+  review_status: zod.z.enum(["in_review", "escalated"]).optional(),
+  approval_url: zod.z.string().optional()
 });
 var APPROVAL_MAX_POLLING_INTERVAL_MILLISECONDS = 5e3;
 function validateSdkPath(path) {
@@ -6424,6 +6748,15 @@ var pathConfig = {
   "/code-substrate-workflows": {
     authHeader: "Authorization",
     pathPrefix: "/api/v0/sdk/code-substrate-workflows"
+  },
+  // e.g. /forms/v0/forms -> https://api.zapier.com/forms/v0/forms
+  // The Forms API is registered on the Public API Gateway and has no sdkapi
+  // proxy route, so it goes straight to the gateway. Its governance metadata
+  // rewrites /forms/v0/... to the backend's /api/forms/v0/..., which is why no
+  // pathPrefix is applied here.
+  "/forms": {
+    authHeader: "Authorization",
+    subdomain: "api"
   }
 };
 var ZapierApiClient = class {
@@ -6486,7 +6819,7 @@ var ZapierApiClient = class {
           method: init?.method ?? "GET",
           rateLimit: rateLimitInfo
         });
-        await sleep(delayMs, init?.signal ?? void 0);
+        await sleep2(delayMs, init?.signal ?? void 0);
       }
     };
     /**
@@ -6964,7 +7297,8 @@ var ZapierApiClient = class {
     const zapierBaseUrl = getZapierBaseUrl(this.options.baseUrl);
     if (zapierBaseUrl === this.options.baseUrl.replace(/\/$/, "")) {
       const originalBaseUrl = new URL(this.options.baseUrl);
-      const finalBaseUrl = `https://sdkapi.${originalBaseUrl.hostname}`;
+      const subdomain = routingMatch?.config.subdomain ?? "sdkapi";
+      const finalBaseUrl = `https://${subdomain}.${originalBaseUrl.hostname}`;
       const url2 = new URL(finalPath, finalBaseUrl);
       return buildResult(url2);
     }
@@ -7313,6 +7647,7 @@ var ZapierApiClient = class {
       await openApproval(approval.approval_url);
     }
     const timeoutMs = this.options.approvalTimeoutMilliseconds ?? this.options.approvalTimeoutMs ?? DEFAULT_APPROVAL_TIMEOUT_MILLISECONDS;
+    const approvalDeadline = Date.now() + timeoutMs;
     let streamAbortController;
     let streamPromise;
     let removeStreamAbortListener;
@@ -7334,75 +7669,87 @@ var ZapierApiClient = class {
         emitEvent: (type, payload) => this.emitEvent(type, payload)
       });
     }
-    let rawPollResult;
-    try {
-      rawPollResult = await pollUntilComplete({
-        // poll_url is an absolute URL supplied by the server, so we use
-        // rawFetchUrl directly (skipping path resolution) but still share
-        // auth + interactive-header + 429-retry with the rest of the SDK.
-        // Each individual poll request goes through the concurrency
-        // semaphore — but we deliberately do not hold a slot across the
-        // sleep between polls or across the human-approval wait.
-        fetchPoll: () => this.withSemaphore(
-          { url: approval.poll_url, method: "GET", signal },
-          () => this.rawFetchUrl(approval.poll_url, {
-            method: "GET",
-            headers: { Accept: "application/json" },
-            signal
-          })
-        ),
-        timeoutMs,
-        maxPollingIntervalMs: APPROVAL_MAX_POLLING_INTERVAL_MILLISECONDS,
-        signal,
-        isPending: (body2) => {
-          const parsed = PollApprovalResponseSchema.safeParse(body2);
-          return parsed.success && parsed.data.status === "pending_approval";
-        }
-      });
-    } catch (err) {
-      if (!isZapierTimeoutError(err)) {
-        this.emitEvent("approval:error", {
-          approvalId: approval.id,
-          message: err instanceof Error ? err.message : String(err)
+    const fetchApprovalPoll = () => this.withSemaphore(
+      { url: approval.poll_url, method: "GET", signal },
+      () => this.rawFetchUrl(approval.poll_url, {
+        method: "GET",
+        headers: { Accept: "application/json" },
+        signal
+      })
+    );
+    const pollApprovalUntilComplete = async (isPending, deadlineMs = approvalDeadline) => {
+      try {
+        return await pollUntilComplete({
+          fetchPoll: fetchApprovalPoll,
+          timeoutMs: Math.max(1, deadlineMs - Date.now()),
+          maxPollingIntervalMs: APPROVAL_MAX_POLLING_INTERVAL_MILLISECONDS,
+          signal,
+          isPending
         });
-        throw err;
+      } catch (err) {
+        if (!isZapierTimeoutError(err)) {
+          this.emitEvent("approval:error", {
+            approvalId: approval.id,
+            message: err instanceof Error ? err.message : String(err)
+          });
+          throw err;
+        }
+        this.emitEvent("approval:timeout", { approvalId: approval.id });
+        throw new ZapierApprovalError(
+          `Approval timed out after ${timeoutMs / 1e3} seconds`,
+          {
+            approvalId: approval.id,
+            approvalUrl: approval.approval_url,
+            pollUrl: approval.poll_url,
+            streamUrl: approval.stream_url,
+            status: "timeout",
+            cause: err
+          }
+        );
       }
-      this.emitEvent("approval:timeout", {
-        approvalId: approval.id
+    };
+    let rawPollResult;
+    try {
+      rawPollResult = await pollApprovalUntilComplete((body2) => {
+        const parsed = PollApprovalResponseSchema.safeParse(body2);
+        if (!parsed.success) return false;
+        if (parsed.data.review_status === "escalated") return false;
+        return parsed.data.status === "pending_approval";
       });
-      throw new ZapierApprovalError(
-        `Approval timed out after ${timeoutMs / 1e3} seconds`,
-        {
-          approvalId: approval.id,
-          approvalUrl: approval.approval_url,
-          pollUrl: approval.poll_url,
-          streamUrl: approval.stream_url,
-          status: "timeout",
-          cause: err
-        }
-      );
     } finally {
       removeStreamAbortListener?.();
       streamAbortController?.abort();
       await streamPromise;
     }
-    const pollParse = PollApprovalResponseSchema.safeParse(rawPollResult);
-    if (!pollParse.success) {
-      const bodyPreview = typeof rawPollResult === "string" ? rawPollResult : JSON.stringify(rawPollResult);
-      this.emitEvent("approval:error", {
+    const parsePollResult = (raw) => {
+      const parsed = PollApprovalResponseSchema.safeParse(raw);
+      if (!parsed.success) {
+        const bodyPreview = typeof raw === "string" ? raw : JSON.stringify(raw);
+        this.emitEvent("approval:error", {
+          approvalId: approval.id,
+          message: `Failed to parse approval poll response: ${bodyPreview}`
+        });
+        throw new ZapierApiError(
+          `Failed to parse approval poll response: ${bodyPreview}`,
+          { statusCode: 0, cause: parsed.error, response: raw }
+        );
+      }
+      return parsed.data;
+    };
+    const pollResult = parsePollResult(rawPollResult);
+    if (pollResult.review_status === "escalated") {
+      const escalationUrl = pollResult.approval_url ?? approval.approval_url;
+      this.emitEvent("approval:escalated", {
         approvalId: approval.id,
-        message: `Failed to parse approval poll response: ${bodyPreview}`
+        approvalUrl: escalationUrl
       });
-      throw new ZapierApiError(
-        `Failed to parse approval poll response: ${bodyPreview}`,
-        {
-          statusCode: 0,
-          cause: pollParse.error,
-          response: rawPollResult
-        }
-      );
+      await openApproval(escalationUrl);
+      const humanRaw = await pollApprovalUntilComplete((body2) => {
+        const parsed = PollApprovalResponseSchema.safeParse(body2);
+        return parsed.success && parsed.data.status === "pending_approval";
+      });
+      Object.assign(pollResult, parsePollResult(humanRaw));
     }
-    const pollResult = pollParse.data;
     if (pollResult.status === "denied") {
       this.emitEvent("approval:denied", {
         approvalId: approval.id,
@@ -8356,7 +8703,7 @@ function buildAbortHandle({
   return combineAbortSignals({ handles });
 }
 var FetchInitSdkValidationSchema = zod.z.looseObject(FetchInitZapierFieldsSchema.shape).optional();
-var fetchPlugin = defineMethod({
+var fetchPlugin2 = defineMethod({
   name: "fetch",
   imports: [coreOptionsPluginRef, connectionsPluginRef, apiPluginRef],
   output: "raw",
@@ -10688,7 +11035,7 @@ function createAppsProxy(imports) {
 }
 var appsPlugin = defineProperty({
   name: "apps",
-  imports: [fetchPlugin, runActionPlugin],
+  imports: [fetchPlugin2, runActionPlugin],
   // Build the proxy once from the imported methods (stable callables).
   setup: ({ imports }) => (
     // Cast: ZapierSdkApps is augmented by user-generated .d.ts files to give
@@ -12042,7 +12389,7 @@ var RelayFetchSchema = RelayRequestSchema;
 // src/plugins/request/index.ts
 var requestPlugin = defineMethod({
   name: "request",
-  imports: [fetchPlugin, coreOptionsPluginRef],
+  imports: [fetchPlugin2, coreOptionsPluginRef],
   output: "raw",
   inputSchema: RelayRequestSchema,
   skipInputValidation: true,
@@ -13867,7 +14214,7 @@ async function drainRunner({
           `[zapier-sdk] Retrying drain for inbox ${inboxId} (attempt ${errorAttempts}, retry in ${delay}ms)${httpPart}: ${errorMessage(error)}`
         );
       }
-      await sleep(delay, signal);
+      await sleep2(delay, signal);
       if (signal.aborted) return { kind: "aborted" };
       drainRequest.request();
       continue;
@@ -13934,7 +14281,7 @@ async function sseLoop({
         }
         attempt = 0;
         if (signal.aborted) return;
-        await sleep(safetyDrainMs, signal);
+        await sleep2(safetyDrainMs, signal);
         continue;
       }
       if (connected) attempt = 0;
@@ -13954,7 +14301,7 @@ async function sseLoop({
         `[zapier-sdk] Reconnecting real-time wake-ups for inbox ${inboxId} (attempt ${attempt}, retry in ${delay}ms)${httpPart}: ${errorMsg}`
       );
     }
-    await sleep(delay, signal);
+    await sleep2(delay, signal);
   }
 }
 async function safetyTimerLoop({
@@ -13963,7 +14310,7 @@ async function safetyTimerLoop({
   signal
 }) {
   while (!signal.aborted) {
-    await sleep(safetyDrainMs, signal);
+    await sleep2(safetyDrainMs, signal);
     if (signal.aborted) return;
     drainRequest.request();
   }
@@ -15845,7 +16192,7 @@ var zapierSdkPlugin = definePlugin({
     createActionRunPlugin,
     getActionRunPlugin,
     runActionPlugin,
-    fetchPlugin,
+    fetchPlugin2,
     requestPlugin,
     appsPlugin,
     // Triggers. `list*` plugins are exported before their `get*` / mutation
@@ -15929,7 +16276,7 @@ async function batch(tasks, options = {}) {
     try {
       let result;
       if (taskTimeoutMs !== void 0) {
-        const timeoutPromise = sleep(taskTimeoutMs).then(() => {
+        const timeoutPromise = sleep2(taskTimeoutMs).then(() => {
           throw new ZapierTimeoutError(
             `Task timed out after ${taskTimeoutMs}ms`
           );
@@ -15944,7 +16291,7 @@ async function batch(tasks, options = {}) {
       const isTimeout = isZapierTimeoutError(error);
       if (retry && !isTimeout && newErrorCount < MAX_CONSECUTIVE_ERRORS) {
         const waitTime = calculateErrorBackoffMs(1e3, newErrorCount);
-        await sleep(waitTime);
+        await sleep2(waitTime);
         taskQueue.push({
           index,
           task,
@@ -15967,7 +16314,7 @@ async function batch(tasks, options = {}) {
       if (!taskState) break;
       await executeTask(taskState);
       if (taskQueue.length > 0 && batchDelay > 0) {
-        await sleep(batchDelay);
+        await sleep2(batchDelay);
       }
     }
   }
@@ -15976,7 +16323,7 @@ async function batch(tasks, options = {}) {
   for (let i = 0; i < workerCount; i++) {
     workers.push(worker());
     if (i < workerCount - 1 && batchDelay > 0) {
-      await sleep(batchDelay / 10);
+      await sleep2(batchDelay / 10);
     }
   }
   await Promise.all(workers);
@@ -16211,7 +16558,7 @@ exports.eventEmissionHookPlugin = eventEmissionHookPlugin;
 exports.eventEmissionPlugin = eventEmissionPlugin;
 exports.eventEmissionPluginRef = eventEmissionPluginRef;
 exports.extractErrorDetail = extractErrorDetail;
-exports.fetchPlugin = fetchPlugin;
+exports.fetchPlugin = fetchPlugin2;
 exports.findFirstConnectionPlugin = findFirstConnectionPlugin;
 exports.findManifestEntry = findManifestEntry;
 exports.findUniqueConnectionPlugin = findUniqueConnectionPlugin;