@zapier/zapier-sdk 0.41.1 → 0.42.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @zapier/zapier-sdk
 
+## 0.42.0
+
+### Minor Changes
+
+- 55e8330: Support maxTime for SDK fetch & CLI curl - Relay extended timeout
+
+## 0.41.2
+
+### Patch Changes
+
+- 3cf1a98: Fix connection resolution for no-auth apps
+
 ## 0.41.1
 
 ### Patch Changes

package/README.md

@@ -971,6 +971,7 @@ Make authenticated HTTP requests to any API through Zapier. Pass a connectionId
 | ↳ `body`        | `string, custom, record` | ❌       | —       | —                                                          | Request body — plain objects and JSON strings are auto-detected and Content-Type is set accordingly                          |
 | ↳ `connection`  | `string, number`         | ❌       | —       | —                                                          | Connection alias (string) or numeric connectionId. Strings are resolved from the connections map; numbers are used directly. |
 | ↳ `callbackUrl` | `string`                 | ❌       | —       | —                                                          | URL to send async response to (makes request async)                                                                          |
+| ↳ `maxTime`     | `number`                 | ❌       | —       | —                                                          | Maximum seconds to wait for a response. Honored on a best-effort basis; the server may silently enforce a lower ceiling.     |
 
 **Returns:** `Promise<Response>`
 

package/dist/index.cjs

@@ -544,6 +544,20 @@ var appsPlugin = ({ sdk }) => {
 var FetchUrlSchema = zod.z.union([zod.z.string(), zod.z.instanceof(URL)]).describe(
   "The full URL of the API endpoint to call (proxied through Zapier's Relay service)"
 );
+var FetchInitZapierFieldsSchema = zod.z.object({
+  connectionId: ConnectionIdPropertySchema.optional().meta({
+    deprecated: true
+  }),
+  connection: ConnectionPropertySchema.optional(),
+  /** @deprecated Use connection instead */
+  authenticationId: AuthenticationIdPropertySchema.optional().meta({
+    deprecated: true
+  }),
+  callbackUrl: zod.z.string().optional().describe("URL to send async response to (makes request async)"),
+  maxTime: zod.z.number().int().positive().optional().describe(
+    "Maximum seconds to wait for a response. Honored on a best-effort basis; the server may silently enforce a lower ceiling."
+  )
+});
 var FetchInitSchema = zod.z.object({
   method: zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional().describe("HTTP method for the request (defaults to GET)"),
   headers: zod.z.record(zod.z.string(), zod.z.string()).optional().describe("HTTP headers to include in the request"),
@@ -554,17 +568,8 @@ var FetchInitSchema = zod.z.object({
     zod.z.record(zod.z.string(), zod.z.unknown())
   ]).optional().describe(
     "Request body \u2014 plain objects and JSON strings are auto-detected and Content-Type is set accordingly"
-  ),
-  connectionId: ConnectionIdPropertySchema.optional().meta({
-    deprecated: true
-  }),
-  connection: ConnectionPropertySchema.optional(),
-  /** @deprecated Use connection instead */
-  authenticationId: AuthenticationIdPropertySchema.optional().meta({
-    deprecated: true
-  }),
-  callbackUrl: zod.z.string().optional().describe("URL to send async response to (makes request async)")
-}).optional().describe(
+  )
+}).extend(FetchInitZapierFieldsSchema.shape).optional().describe(
   "Request options including method, headers, body, and authentication"
 ).meta({
   aliases: { connectionId: "connection", authenticationId: "connection" }
@@ -717,6 +722,82 @@ function isResolvedAppLocator(appLocator) {
   return !!appLocator.implementationName;
 }
 
+// src/utils/abort-utils.ts
+function getAbortSignalApi() {
+  const api = AbortSignal;
+  return { any: api.any };
+}
+function createTimeoutError(timeoutMs) {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException(
+      `The operation timed out after ${timeoutMs}ms`,
+      "TimeoutError"
+    );
+  }
+  const error = new Error(`The operation timed out after ${timeoutMs}ms`);
+  error.name = "TimeoutError";
+  return error;
+}
+function createTimeoutAbortSignal({
+  timeoutMs
+}) {
+  const controller = new AbortController();
+  let timer = setTimeout(() => {
+    timer = void 0;
+    controller.abort(createTimeoutError(timeoutMs));
+  }, timeoutMs);
+  const maybeUnref = timer.unref;
+  if (typeof maybeUnref === "function") {
+    maybeUnref.call(timer);
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
+function combineAbortSignals({
+  handles,
+  abortSignalApi = getAbortSignalApi()
+}) {
+  if (handles.length === 0) return void 0;
+  if (handles.length === 1) return handles[0];
+  const disposeInputs = () => {
+    for (const handle of handles) handle.dispose();
+  };
+  if (abortSignalApi.any) {
+    return {
+      signal: abortSignalApi.any(handles.map((h) => h.signal)),
+      dispose: disposeInputs
+    };
+  }
+  const controller = new AbortController();
+  const listeners = [];
+  for (const { signal: source } of handles) {
+    if (source.aborted) {
+      controller.abort(source.reason);
+      return { signal: controller.signal, dispose: disposeInputs };
+    }
+    const handler = () => controller.abort(source.reason);
+    source.addEventListener("abort", handler, { once: true });
+    listeners.push({ source, handler });
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      for (const { source, handler } of listeners) {
+        source.removeEventListener("abort", handler);
+      }
+      listeners.length = 0;
+      disposeInputs();
+    }
+  };
+}
+
 // src/utils/type-guard-utils.ts
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -752,6 +833,34 @@ function getMethodMetadata() {
   return telemetryStore.getStore()?.methodMetadata;
 }
 
+// src/utils/validation.ts
+var validate = (schema, input) => {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const errorMessages = result.error.issues.map((error) => {
+      const path = error.path.length > 0 ? error.path.join(".") : "input";
+      return `${path}: ${error.message}`;
+    });
+    const message = `Validation failed:
+  ${errorMessages.join("\n  ")}`;
+    throw new ZapierValidationError(message, {
+      details: {
+        zodErrors: result.error.issues,
+        input
+      }
+    });
+  }
+  return result.data;
+};
+function createValidator(schema) {
+  return function validateFn(input) {
+    return validate(schema, input);
+  };
+}
+var validateOptions = (schema, options) => {
+  return validate(schema, options);
+};
+
 // src/plugins/fetch/index.ts
 function transformUrlToRelayPath(url) {
   const targetUrl = new URL(url);
@@ -789,6 +898,35 @@ function inferContentType(body) {
   }
   return void 0;
 }
+function rewrapIfMaxTimeTimeout({
+  error,
+  abortSignal,
+  maxTimeSeconds
+}) {
+  if (maxTimeSeconds === void 0 || !abortSignal?.aborted) return error;
+  const reason = abortSignal.reason;
+  if (!reason || reason.name !== "TimeoutError") return error;
+  return new ZapierTimeoutError(
+    `fetch timed out after ${maxTimeSeconds}s (maxTime)`,
+    { cause: error }
+  );
+}
+function buildAbortHandle({
+  maxTimeSeconds,
+  callerSignal
+}) {
+  const handles = [];
+  if (callerSignal) handles.push({ signal: callerSignal, dispose: () => {
+  } });
+  if (maxTimeSeconds !== void 0) {
+    handles.push(
+      createTimeoutAbortSignal({ timeoutMs: maxTimeSeconds * 1e3 })
+    );
+  }
+  return combineAbortSignals({ handles });
+}
+var FetchInitSdkValidationSchema = zod.z.looseObject(FetchInitZapierFieldsSchema.shape).optional();
+var validateFetchInit = createValidator(FetchInitSdkValidationSchema);
 var fetchPlugin = ({ context }) => {
   return {
     fetch: async function fetch2(url, init) {
@@ -797,11 +935,15 @@ var fetchPlugin = ({ context }) => {
         const startTime = Date.now();
         const isNested = isTelemetryNested();
         try {
+          if (init) {
+            validateFetchInit(init);
+          }
           const {
             connectionId,
             connection,
             authenticationId,
             callbackUrl,
+            maxTime,
             ...fetchInit
           } = init || {};
           const resolvedConnectionId = await resolveConnectionId({
@@ -832,32 +974,49 @@ var fetchPlugin = ({ context }) => {
           if (callbackUrl) {
             headers["X-Relay-Callback-Url"] = callbackUrl;
           }
-          const result = await api.fetch(relayPath, {
-            method: fetchInit.method ?? "GET",
-            body: fetchInit.body,
-            headers,
-            redirect: fetchInit.redirect,
-            signal: fetchInit.signal,
-            authRequired: true
+          if (maxTime !== void 0) {
+            headers["X-Zapier-Sdk-Max-Time"] = String(maxTime);
+          }
+          const abortHandle = buildAbortHandle({
+            maxTimeSeconds: maxTime,
+            callerSignal: fetchInit.signal
           });
-          const relayError = result.headers.get("x-relay-error");
-          if (relayError) {
-            throw new ZapierRelayError(relayError, {
-              statusCode: result.status
+          try {
+            const result = await api.fetch(relayPath, {
+              method: fetchInit.method ?? "GET",
+              body: fetchInit.body,
+              headers,
+              redirect: fetchInit.redirect,
+              signal: abortHandle?.signal,
+              authRequired: true
             });
-          }
-          if (!isNested) {
-            context.eventEmission.emitMethodCalled({
-              method_name: "fetch",
-              execution_duration_ms: Date.now() - startTime,
-              success_flag: true,
-              error_message: null,
-              error_type: null,
-              argument_count: init ? 2 : 1,
-              is_paginated: false
+            const relayError = result.headers.get("x-relay-error");
+            if (relayError) {
+              throw new ZapierRelayError(relayError, {
+                statusCode: result.status
+              });
+            }
+            if (!isNested) {
+              context.eventEmission.emitMethodCalled({
+                method_name: "fetch",
+                execution_duration_ms: Date.now() - startTime,
+                success_flag: true,
+                error_message: null,
+                error_type: null,
+                argument_count: init ? 2 : 1,
+                is_paginated: false
+              });
+            }
+            return result;
+          } catch (error) {
+            throw rewrapIfMaxTimeTimeout({
+              error,
+              abortSignal: abortHandle?.signal,
+              maxTimeSeconds: maxTime
             });
+          } finally {
+            abortHandle?.dispose();
           }
-          return result;
         } catch (error) {
           if (!isNested) {
             context.eventEmission.emitMethodCalled({
@@ -1145,34 +1304,6 @@ function toIterable(source) {
   return { [Symbol.asyncIterator]: () => source[Symbol.asyncIterator]() };
 }
 
-// src/utils/validation.ts
-var validate = (schema, input) => {
-  const result = schema.safeParse(input);
-  if (!result.success) {
-    const errorMessages = result.error.issues.map((error) => {
-      const path = error.path.length > 0 ? error.path.join(".") : "input";
-      return `${path}: ${error.message}`;
-    });
-    const message = `Validation failed:
-  ${errorMessages.join("\n  ")}`;
-    throw new ZapierValidationError(message, {
-      details: {
-        zodErrors: result.error.issues,
-        input
-      }
-    });
-  }
-  return result.data;
-};
-function createValidator(schema) {
-  return function validateFn(input) {
-    return validate(schema, input);
-  };
-}
-var validateOptions = (schema, options) => {
-  return validate(schema, options);
-};
-
 // src/utils/function-utils.ts
 function extractCursor(data) {
   if (!data?.next) {
@@ -1970,7 +2101,7 @@ var connectionIdResolver = {
     try {
       const app = await sdk.getApp({ app: params.app });
       if (!app.data.auth_type) {
-        return { resolvedValue: null };
+        return { resolvedValue: void 0 };
       }
     } catch {
     }

package/dist/index.d.mts

@@ -1597,15 +1597,18 @@ interface ConnectionsPluginProvides {
 }
 declare const connectionsPlugin: Plugin<{}, ManifestPluginProvides["context"], ConnectionsPluginProvides>;
 
+interface ZapierFetchInitOptions extends RequestInit {
+    /** @deprecated Use `connection` instead. */
+    connectionId?: string | number;
+    connection?: string | number;
+    /** @deprecated Use `connection` instead. */
+    authenticationId?: string | number;
+    callbackUrl?: string;
+    /** Maximum seconds to wait for a response, subject to a server-side limit. */
+    maxTime?: number;
+}
 interface FetchPluginProvides {
-    fetch: (url: string | URL, init?: RequestInit & {
-        /** @deprecated Use `connection` instead. */
-        connectionId?: string | number;
-        connection?: string | number;
-        /** @deprecated Use `connection` instead. */
-        authenticationId?: string | number;
-        callbackUrl?: string;
-    }) => Promise<Response>;
+    fetch: (url: string | URL, init?: ZapierFetchInitOptions) => Promise<Response>;
     context: {
         meta: {
             fetch: {
@@ -1631,14 +1634,6 @@ declare const fetchPlugin: Plugin<{}, // no SDK dependencies
     api: ApiClient;
 } & ConnectionsPluginProvides["context"] & EventEmissionContext, // requires api, connections, and eventEmission in context
 FetchPluginProvides>;
-type ZapierFetchInitOptions = RequestInit & {
-    /** @deprecated Use `connection` instead. */
-    connectionId?: string | number;
-    connection?: string | number;
-    /** @deprecated Use `connection` instead. */
-    authenticationId?: string | number;
-    callbackUrl?: string;
-};
 
 declare const RunActionSchema: z.ZodObject<{
     app: z.ZodString & {

package/dist/index.mjs

@@ -542,6 +542,20 @@ var appsPlugin = ({ sdk }) => {
 var FetchUrlSchema = z.union([z.string(), z.instanceof(URL)]).describe(
   "The full URL of the API endpoint to call (proxied through Zapier's Relay service)"
 );
+var FetchInitZapierFieldsSchema = z.object({
+  connectionId: ConnectionIdPropertySchema.optional().meta({
+    deprecated: true
+  }),
+  connection: ConnectionPropertySchema.optional(),
+  /** @deprecated Use connection instead */
+  authenticationId: AuthenticationIdPropertySchema.optional().meta({
+    deprecated: true
+  }),
+  callbackUrl: z.string().optional().describe("URL to send async response to (makes request async)"),
+  maxTime: z.number().int().positive().optional().describe(
+    "Maximum seconds to wait for a response. Honored on a best-effort basis; the server may silently enforce a lower ceiling."
+  )
+});
 var FetchInitSchema = z.object({
   method: z.enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]).optional().describe("HTTP method for the request (defaults to GET)"),
   headers: z.record(z.string(), z.string()).optional().describe("HTTP headers to include in the request"),
@@ -552,17 +566,8 @@ var FetchInitSchema = z.object({
     z.record(z.string(), z.unknown())
   ]).optional().describe(
     "Request body \u2014 plain objects and JSON strings are auto-detected and Content-Type is set accordingly"
-  ),
-  connectionId: ConnectionIdPropertySchema.optional().meta({
-    deprecated: true
-  }),
-  connection: ConnectionPropertySchema.optional(),
-  /** @deprecated Use connection instead */
-  authenticationId: AuthenticationIdPropertySchema.optional().meta({
-    deprecated: true
-  }),
-  callbackUrl: z.string().optional().describe("URL to send async response to (makes request async)")
-}).optional().describe(
+  )
+}).extend(FetchInitZapierFieldsSchema.shape).optional().describe(
   "Request options including method, headers, body, and authentication"
 ).meta({
   aliases: { connectionId: "connection", authenticationId: "connection" }
@@ -715,6 +720,82 @@ function isResolvedAppLocator(appLocator) {
   return !!appLocator.implementationName;
 }
 
+// src/utils/abort-utils.ts
+function getAbortSignalApi() {
+  const api = AbortSignal;
+  return { any: api.any };
+}
+function createTimeoutError(timeoutMs) {
+  if (typeof DOMException !== "undefined") {
+    return new DOMException(
+      `The operation timed out after ${timeoutMs}ms`,
+      "TimeoutError"
+    );
+  }
+  const error = new Error(`The operation timed out after ${timeoutMs}ms`);
+  error.name = "TimeoutError";
+  return error;
+}
+function createTimeoutAbortSignal({
+  timeoutMs
+}) {
+  const controller = new AbortController();
+  let timer = setTimeout(() => {
+    timer = void 0;
+    controller.abort(createTimeoutError(timeoutMs));
+  }, timeoutMs);
+  const maybeUnref = timer.unref;
+  if (typeof maybeUnref === "function") {
+    maybeUnref.call(timer);
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      if (timer !== void 0) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+    }
+  };
+}
+function combineAbortSignals({
+  handles,
+  abortSignalApi = getAbortSignalApi()
+}) {
+  if (handles.length === 0) return void 0;
+  if (handles.length === 1) return handles[0];
+  const disposeInputs = () => {
+    for (const handle of handles) handle.dispose();
+  };
+  if (abortSignalApi.any) {
+    return {
+      signal: abortSignalApi.any(handles.map((h) => h.signal)),
+      dispose: disposeInputs
+    };
+  }
+  const controller = new AbortController();
+  const listeners = [];
+  for (const { signal: source } of handles) {
+    if (source.aborted) {
+      controller.abort(source.reason);
+      return { signal: controller.signal, dispose: disposeInputs };
+    }
+    const handler = () => controller.abort(source.reason);
+    source.addEventListener("abort", handler, { once: true });
+    listeners.push({ source, handler });
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      for (const { source, handler } of listeners) {
+        source.removeEventListener("abort", handler);
+      }
+      listeners.length = 0;
+      disposeInputs();
+    }
+  };
+}
+
 // src/utils/type-guard-utils.ts
 function isPlainObject(value) {
   if (typeof value !== "object" || value === null) return false;
@@ -750,6 +831,34 @@ function getMethodMetadata() {
   return telemetryStore.getStore()?.methodMetadata;
 }
 
+// src/utils/validation.ts
+var validate = (schema, input) => {
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const errorMessages = result.error.issues.map((error) => {
+      const path = error.path.length > 0 ? error.path.join(".") : "input";
+      return `${path}: ${error.message}`;
+    });
+    const message = `Validation failed:
+  ${errorMessages.join("\n  ")}`;
+    throw new ZapierValidationError(message, {
+      details: {
+        zodErrors: result.error.issues,
+        input
+      }
+    });
+  }
+  return result.data;
+};
+function createValidator(schema) {
+  return function validateFn(input) {
+    return validate(schema, input);
+  };
+}
+var validateOptions = (schema, options) => {
+  return validate(schema, options);
+};
+
 // src/plugins/fetch/index.ts
 function transformUrlToRelayPath(url) {
   const targetUrl = new URL(url);
@@ -787,6 +896,35 @@ function inferContentType(body) {
   }
   return void 0;
 }
+function rewrapIfMaxTimeTimeout({
+  error,
+  abortSignal,
+  maxTimeSeconds
+}) {
+  if (maxTimeSeconds === void 0 || !abortSignal?.aborted) return error;
+  const reason = abortSignal.reason;
+  if (!reason || reason.name !== "TimeoutError") return error;
+  return new ZapierTimeoutError(
+    `fetch timed out after ${maxTimeSeconds}s (maxTime)`,
+    { cause: error }
+  );
+}
+function buildAbortHandle({
+  maxTimeSeconds,
+  callerSignal
+}) {
+  const handles = [];
+  if (callerSignal) handles.push({ signal: callerSignal, dispose: () => {
+  } });
+  if (maxTimeSeconds !== void 0) {
+    handles.push(
+      createTimeoutAbortSignal({ timeoutMs: maxTimeSeconds * 1e3 })
+    );
+  }
+  return combineAbortSignals({ handles });
+}
+var FetchInitSdkValidationSchema = z.looseObject(FetchInitZapierFieldsSchema.shape).optional();
+var validateFetchInit = createValidator(FetchInitSdkValidationSchema);
 var fetchPlugin = ({ context }) => {
   return {
     fetch: async function fetch2(url, init) {
@@ -795,11 +933,15 @@ var fetchPlugin = ({ context }) => {
         const startTime = Date.now();
         const isNested = isTelemetryNested();
         try {
+          if (init) {
+            validateFetchInit(init);
+          }
           const {
             connectionId,
             connection,
             authenticationId,
             callbackUrl,
+            maxTime,
             ...fetchInit
           } = init || {};
           const resolvedConnectionId = await resolveConnectionId({
@@ -830,32 +972,49 @@ var fetchPlugin = ({ context }) => {
           if (callbackUrl) {
             headers["X-Relay-Callback-Url"] = callbackUrl;
           }
-          const result = await api.fetch(relayPath, {
-            method: fetchInit.method ?? "GET",
-            body: fetchInit.body,
-            headers,
-            redirect: fetchInit.redirect,
-            signal: fetchInit.signal,
-            authRequired: true
+          if (maxTime !== void 0) {
+            headers["X-Zapier-Sdk-Max-Time"] = String(maxTime);
+          }
+          const abortHandle = buildAbortHandle({
+            maxTimeSeconds: maxTime,
+            callerSignal: fetchInit.signal
           });
-          const relayError = result.headers.get("x-relay-error");
-          if (relayError) {
-            throw new ZapierRelayError(relayError, {
-              statusCode: result.status
+          try {
+            const result = await api.fetch(relayPath, {
+              method: fetchInit.method ?? "GET",
+              body: fetchInit.body,
+              headers,
+              redirect: fetchInit.redirect,
+              signal: abortHandle?.signal,
+              authRequired: true
             });
-          }
-          if (!isNested) {
-            context.eventEmission.emitMethodCalled({
-              method_name: "fetch",
-              execution_duration_ms: Date.now() - startTime,
-              success_flag: true,
-              error_message: null,
-              error_type: null,
-              argument_count: init ? 2 : 1,
-              is_paginated: false
+            const relayError = result.headers.get("x-relay-error");
+            if (relayError) {
+              throw new ZapierRelayError(relayError, {
+                statusCode: result.status
+              });
+            }
+            if (!isNested) {
+              context.eventEmission.emitMethodCalled({
+                method_name: "fetch",
+                execution_duration_ms: Date.now() - startTime,
+                success_flag: true,
+                error_message: null,
+                error_type: null,
+                argument_count: init ? 2 : 1,
+                is_paginated: false
+              });
+            }
+            return result;
+          } catch (error) {
+            throw rewrapIfMaxTimeTimeout({
+              error,
+              abortSignal: abortHandle?.signal,
+              maxTimeSeconds: maxTime
             });
+          } finally {
+            abortHandle?.dispose();
           }
-          return result;
         } catch (error) {
           if (!isNested) {
             context.eventEmission.emitMethodCalled({
@@ -1143,34 +1302,6 @@ function toIterable(source) {
   return { [Symbol.asyncIterator]: () => source[Symbol.asyncIterator]() };
 }
 
-// src/utils/validation.ts
-var validate = (schema, input) => {
-  const result = schema.safeParse(input);
-  if (!result.success) {
-    const errorMessages = result.error.issues.map((error) => {
-      const path = error.path.length > 0 ? error.path.join(".") : "input";
-      return `${path}: ${error.message}`;
-    });
-    const message = `Validation failed:
-  ${errorMessages.join("\n  ")}`;
-    throw new ZapierValidationError(message, {
-      details: {
-        zodErrors: result.error.issues,
-        input
-      }
-    });
-  }
-  return result.data;
-};
-function createValidator(schema) {
-  return function validateFn(input) {
-    return validate(schema, input);
-  };
-}
-var validateOptions = (schema, options) => {
-  return validate(schema, options);
-};
-
 // src/utils/function-utils.ts
 function extractCursor(data) {
   if (!data?.next) {
@@ -1968,7 +2099,7 @@ var connectionIdResolver = {
     try {
       const app = await sdk.getApp({ app: params.app });
       if (!app.data.auth_type) {
-        return { resolvedValue: null };
+        return { resolvedValue: void 0 };
       }
     } catch {
     }

package/dist/plugins/fetch/index.d.ts

@@ -1,17 +1,20 @@
 import type { Plugin } from "../../types/plugin";
 import type { ApiClient } from "../../api";
 import type { ConnectionsPluginProvides } from "../connections";
-import type { z } from "zod";
+import { z } from "zod";
 import type { EventEmissionContext } from "../eventEmission";
+export interface ZapierFetchInitOptions extends RequestInit {
+    /** @deprecated Use `connection` instead. */
+    connectionId?: string | number;
+    connection?: string | number;
+    /** @deprecated Use `connection` instead. */
+    authenticationId?: string | number;
+    callbackUrl?: string;
+    /** Maximum seconds to wait for a response, subject to a server-side limit. */
+    maxTime?: number;
+}
 export interface FetchPluginProvides {
-    fetch: (url: string | URL, init?: RequestInit & {
-        /** @deprecated Use `connection` instead. */
-        connectionId?: string | number;
-        connection?: string | number;
-        /** @deprecated Use `connection` instead. */
-        authenticationId?: string | number;
-        callbackUrl?: string;
-    }) => Promise<Response>;
+    fetch: (url: string | URL, init?: ZapierFetchInitOptions) => Promise<Response>;
     context: {
         meta: {
             fetch: {
@@ -37,12 +40,4 @@ export declare const fetchPlugin: Plugin<{}, // no SDK dependencies
     api: ApiClient;
 } & ConnectionsPluginProvides["context"] & EventEmissionContext, // requires api, connections, and eventEmission in context
 FetchPluginProvides>;
-export type ZapierFetchInitOptions = RequestInit & {
-    /** @deprecated Use `connection` instead. */
-    connectionId?: string | number;
-    connection?: string | number;
-    /** @deprecated Use `connection` instead. */
-    authenticationId?: string | number;
-    callbackUrl?: string;
-};
 //# sourceMappingURL=index.d.ts.map

package/dist/plugins/fetch/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAEhE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAoE7D,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,CACL,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,IAAI,CAAC,EAAE,WAAW,GAAG;QACnB,4CAA4C;QAC5C,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAC/B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QAC7B,4CAA4C;QAC5C,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;QACnC,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,KACE,OAAO,CAAC,QAAQ,CAAC,CAAC;IACvB,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,KAAK,EAAE;gBACL,WAAW,EAAE,MAAM,CAAC;gBACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;gBACnB,UAAU,EAAE,MAAM,EAAE,CAAC;gBACrB,UAAU,EAAE,MAAM,CAAC;gBACnB,eAAe,EAAE,KAAK,CAAC;oBAAE,IAAI,EAAE,MAAM,CAAC;oBAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAA;iBAAE,CAAC,CAAC;aAC/D,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAC9B,EAAE,EAAE,sBAAsB;AAC1B,AADI,sBAAsB;AAC1B;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,yBAAyB,CAAC,SAAS,CAAC,GACvD,oBAAoB,EAAE,0DAA0D;AAClF,mBAAmB,CAiIpB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG,WAAW,GAAG;IACjD,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,4CAA4C;IAC5C,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAMhE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAgB7D,MAAM,WAAW,sBAAuB,SAAQ,WAAW;IACzD,4CAA4C;IAC5C,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC7B,4CAA4C;IAC5C,gBAAgB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AA4GD,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,CACL,GAAG,EAAE,MAAM,GAAG,GAAG,EACjB,IAAI,CAAC,EAAE,sBAAsB,KAC1B,OAAO,CAAC,QAAQ,CAAC,CAAC;IACvB,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,KAAK,EAAE;gBACL,WAAW,EAAE,MAAM,CAAC;gBACpB,QAAQ,EAAE,MAAM,EAAE,CAAC;gBACnB,UAAU,EAAE,MAAM,EAAE,CAAC;gBACrB,UAAU,EAAE,MAAM,CAAC;gBACnB,eAAe,EAAE,KAAK,CAAC;oBAAE,IAAI,EAAE,MAAM,CAAC;oBAAC,MAAM,EAAE,CAAC,CAAC,SAAS,CAAA;iBAAE,CAAC,CAAC;aAC/D,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAQD;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,MAAM,CAC9B,EAAE,EAAE,sBAAsB;AAC1B,AADI,sBAAsB;AAC1B;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,GAAG,yBAAyB,CAAC,SAAS,CAAC,GACvD,oBAAoB,EAAE,0DAA0D;AAClF,mBAAmB,CAiJpB,CAAC"}

package/dist/plugins/fetch/index.js

@@ -1,11 +1,14 @@
-import { ZapierRelayError } from "../../types/errors";
-import { FetchUrlSchema, FetchInitSchema } from "./schemas";
+import { ZapierRelayError, ZapierTimeoutError } from "../../types/errors";
+import { FetchUrlSchema, FetchInitSchema, FetchInitZapierFieldsSchema, } from "./schemas";
+import { z } from "zod";
 import { resolveConnectionId } from "../../utils/domain-utils";
+import { combineAbortSignals, createTimeoutAbortSignal, } from "../../utils/abort-utils";
 import { isPlainObject } from "../../utils/type-guard-utils";
 // fetch() doesn't use createFunction/createPaginatedFunction (its signature
 // doesn't fit the single-options-object pattern), so we wire up telemetry
 // context tracking manually.
 import { isTelemetryNested, runWithTelemetryContext, } from "../../utils/telemetry-context";
+import { createValidator } from "../../utils/validation";
 /**
  * Transforms full URLs into Relay format: /relay/{domain}/{path}
  */
@@ -53,6 +56,41 @@ function inferContentType(body) {
     }
     return undefined;
 }
+/**
+ * If the request aborted because the client-side `maxTime` timer fired, rewrap the
+ * underlying error as a `ZapierTimeoutError` so callers (and telemetry) can
+ * distinguish it from a caller-triggered abort or an unrelated network
+ * cancellation. The original error is preserved as `cause`.
+ *
+ * Caller-triggered aborts are left unwrapped so the caller's own abort
+ * semantics (reason, name) propagate.
+ */
+function rewrapIfMaxTimeTimeout({ error, abortSignal, maxTimeSeconds, }) {
+    if (maxTimeSeconds === undefined || !abortSignal?.aborted)
+        return error;
+    const reason = abortSignal.reason;
+    if (!reason || reason.name !== "TimeoutError")
+        return error;
+    return new ZapierTimeoutError(`fetch timed out after ${maxTimeSeconds}s (maxTime)`, { cause: error });
+}
+/**
+ * Builds an AbortSignal (and a dispose callback) from the optional maxTime
+ * timeout and an optional caller-provided signal. Callers must invoke
+ * `dispose()` when the request completes to release timers and listeners.
+ */
+function buildAbortHandle({ maxTimeSeconds, callerSignal, }) {
+    const handles = [];
+    if (callerSignal)
+        handles.push({ signal: callerSignal, dispose: () => { } });
+    if (maxTimeSeconds !== undefined) {
+        handles.push(createTimeoutAbortSignal({ timeoutMs: maxTimeSeconds * 1000 }));
+    }
+    return combineAbortSignals({ handles });
+}
+const FetchInitSdkValidationSchema = z
+    .looseObject(FetchInitZapierFieldsSchema.shape)
+    .optional();
+const validateFetchInit = createValidator(FetchInitSdkValidationSchema);
 /**
  * Fetch plugin — the primary way to make authenticated HTTP requests through Zapier's Relay service.
  * Mirrors the native fetch(url, init?) signature with additional Zapier-specific options.
@@ -65,7 +103,10 @@ export const fetchPlugin = ({ context }) => {
                 const startTime = Date.now();
                 const isNested = isTelemetryNested();
                 try {
-                    const { connectionId, connection, authenticationId, callbackUrl, ...fetchInit } = init || {};
+                    if (init) {
+                        validateFetchInit(init);
+                    }
+                    const { connectionId, connection, authenticationId, callbackUrl, maxTime, ...fetchInit } = init || {};
                     const resolvedConnectionId = await resolveConnectionId({
                         connectionId,
                         connection,
@@ -88,32 +129,51 @@ export const fetchPlugin = ({ context }) => {
                     if (callbackUrl) {
                         headers["X-Relay-Callback-Url"] = callbackUrl;
                     }
-                    const result = await api.fetch(relayPath, {
-                        method: fetchInit.method ?? "GET",
-                        body: fetchInit.body,
-                        headers,
-                        redirect: fetchInit.redirect,
-                        signal: fetchInit.signal,
-                        authRequired: true,
+                    if (maxTime !== undefined) {
+                        headers["X-Zapier-Sdk-Max-Time"] = String(maxTime);
+                    }
+                    const abortHandle = buildAbortHandle({
+                        maxTimeSeconds: maxTime,
+                        callerSignal: fetchInit.signal,
                     });
-                    const relayError = result.headers.get("x-relay-error");
-                    if (relayError) {
-                        throw new ZapierRelayError(relayError, {
-                            statusCode: result.status,
+                    try {
+                        const result = await api.fetch(relayPath, {
+                            method: fetchInit.method ?? "GET",
+                            body: fetchInit.body,
+                            headers,
+                            redirect: fetchInit.redirect,
+                            signal: abortHandle?.signal,
+                            authRequired: true,
                         });
+                        const relayError = result.headers.get("x-relay-error");
+                        if (relayError) {
+                            throw new ZapierRelayError(relayError, {
+                                statusCode: result.status,
+                            });
+                        }
+                        if (!isNested) {
+                            context.eventEmission.emitMethodCalled({
+                                method_name: "fetch",
+                                execution_duration_ms: Date.now() - startTime,
+                                success_flag: true,
+                                error_message: null,
+                                error_type: null,
+                                argument_count: init ? 2 : 1,
+                                is_paginated: false,
+                            });
+                        }
+                        return result;
                     }
-                    if (!isNested) {
-                        context.eventEmission.emitMethodCalled({
-                            method_name: "fetch",
-                            execution_duration_ms: Date.now() - startTime,
-                            success_flag: true,
-                            error_message: null,
-                            error_type: null,
-                            argument_count: init ? 2 : 1,
-                            is_paginated: false,
+                    catch (error) {
+                        throw rewrapIfMaxTimeTimeout({
+                            error,
+                            abortSignal: abortHandle?.signal,
+                            maxTimeSeconds: maxTime,
                         });
                     }
-                    return result;
+                    finally {
+                        abortHandle?.dispose();
+                    }
                 }
                 catch (error) {
                     if (!isNested) {

package/dist/plugins/fetch/schemas.d.ts

@@ -1,5 +1,12 @@
 import { z } from "zod";
 export declare const FetchUrlSchema: z.ZodUnion<readonly [z.ZodString, z.ZodCustom<URL, URL>]>;
+export declare const FetchInitZapierFieldsSchema: z.ZodObject<{
+    connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+    callbackUrl: z.ZodOptional<z.ZodString>;
+    maxTime: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 export declare const FetchInitSchema: z.ZodOptional<z.ZodObject<{
     method: z.ZodOptional<z.ZodEnum<{
         POST: "POST";
@@ -16,5 +23,6 @@ export declare const FetchInitSchema: z.ZodOptional<z.ZodObject<{
     connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     callbackUrl: z.ZodOptional<z.ZodString>;
+    maxTime: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/fetch/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,cAAc,2DAIxB,CAAC;AAEJ,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;kBAwCxB,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/fetch/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,cAAc,2DAIxB,CAAC;AAEJ,eAAO,MAAM,2BAA2B;;;;;;iBAqBtC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;kBA6BxB,CAAC"}

package/dist/plugins/fetch/schemas.js

@@ -4,6 +4,26 @@ import { ConnectionIdPropertySchema, ConnectionPropertySchema, AuthenticationIdP
 export const FetchUrlSchema = z
     .union([z.string(), z.instanceof(URL)])
     .describe("The full URL of the API endpoint to call (proxied through Zapier's Relay service)");
+export const FetchInitZapierFieldsSchema = z.object({
+    connectionId: ConnectionIdPropertySchema.optional().meta({
+        deprecated: true,
+    }),
+    connection: ConnectionPropertySchema.optional(),
+    /** @deprecated Use connection instead */
+    authenticationId: AuthenticationIdPropertySchema.optional().meta({
+        deprecated: true,
+    }),
+    callbackUrl: z
+        .string()
+        .optional()
+        .describe("URL to send async response to (makes request async)"),
+    maxTime: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Maximum seconds to wait for a response. Honored on a best-effort basis; the server may silently enforce a lower ceiling."),
+});
 export const FetchInitSchema = z
     .object({
     method: z
@@ -23,19 +43,8 @@ export const FetchInitSchema = z
     ])
         .optional()
         .describe("Request body — plain objects and JSON strings are auto-detected and Content-Type is set accordingly"),
-    connectionId: ConnectionIdPropertySchema.optional().meta({
-        deprecated: true,
-    }),
-    connection: ConnectionPropertySchema.optional(),
-    /** @deprecated Use connection instead */
-    authenticationId: AuthenticationIdPropertySchema.optional().meta({
-        deprecated: true,
-    }),
-    callbackUrl: z
-        .string()
-        .optional()
-        .describe("URL to send async response to (makes request async)"),
 })
+    .extend(FetchInitZapierFieldsSchema.shape)
     .optional()
     .describe("Request options including method, headers, body, and authentication")
     .meta({

package/dist/resolvers/connectionId.js

@@ -30,7 +30,7 @@ export const connectionIdResolver = {
         try {
             const app = await sdk.getApp({ app: params.app });
             if (!app.data.auth_type) {
-                return { resolvedValue: null };
+                return { resolvedValue: undefined };
             }
         }
         catch {

package/dist/utils/abort-utils.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Wraps the subset of `AbortSignal` static methods that `combineAbortSignals`
+ * needs. Serves two real uses:
+ *
+ *   1. Runtime feature detection. `AbortSignal.any()` isn't present on every
+ *      platform we support (Node <19, older browsers, some sandboxed
+ *      runtimes), so `combineAbortSignals` checks `any` at call time and
+ *      falls back to manual listener wiring when it's missing.
+ *   2. Test injection. Tests pass a fake `abortSignalApi` to force a
+ *      specific branch (native vs. fallback) regardless of what the current
+ *      runtime actually supports.
+ *
+ * By default, `combineAbortSignals` reads the real globals via
+ * `getAbortSignalApi()`; callers rarely need to pass this explicitly.
+ */
+export interface AbortSignalApi {
+    any?: (signals: AbortSignal[]) => AbortSignal;
+}
+export interface DisposableAbortSignal {
+    signal: AbortSignal;
+    /**
+     * Release the resources backing this signal (timers, event listeners).
+     * Safe to call multiple times.
+     */
+    dispose: () => void;
+}
+export declare function createTimeoutError(timeoutMs: number): Error;
+/**
+ * Creates an AbortSignal that fires after `timeoutMs` using a cancellable
+ * `AbortController` + `setTimeout`. We intentionally don't delegate to the
+ * native `AbortSignal.timeout()` — its returned signal has no way to cancel
+ * the underlying timer, which would make `dispose()` a lie on that path and
+ * give us divergent abort-reason messages across runtimes.
+ *
+ * On Node-like runtimes we `unref()` the timer so a pending timeout doesn't
+ * keep the process alive. In browsers `.unref` is absent and the guard is a
+ * harmless no-op.
+ *
+ * The signal's abort reason is a `DOMException` with `name: "TimeoutError"`
+ * so callers can distinguish timeout-driven aborts from caller-driven ones.
+ *
+ * Always call `dispose()` when the signal is no longer needed to clear the
+ * pending timer.
+ */
+export declare function createTimeoutAbortSignal({ timeoutMs, }: {
+    timeoutMs: number;
+}): DisposableAbortSignal;
+/**
+ * Combines multiple disposable abort handles so the result aborts when *any*
+ * source does. Uses native `AbortSignal.any()` when available; otherwise wires
+ * up listeners manually.
+ *
+ * Returns `undefined` when the array is empty, or passes through a single
+ * handle without wrapping it.
+ *
+ * Always call `dispose()` on the result when it is no longer needed. This
+ * removes event listeners from source signals and calls `dispose()` on every
+ * input handle (releasing timers, etc).
+ */
+export declare function combineAbortSignals({ handles, abortSignalApi, }: {
+    handles: DisposableAbortSignal[];
+    abortSignalApi?: AbortSignalApi;
+}): DisposableAbortSignal | undefined;
+//# sourceMappingURL=abort-utils.d.ts.map

package/dist/utils/abort-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abort-utils.d.ts","sourceRoot":"","sources":["../../src/utils/abort-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,CAAC;CAC/C;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,WAAW,CAAC;IACpB;;;OAGG;IACH,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAOD,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,CAW3D;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,EACvC,SAAS,GACV,EAAE;IACD,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,qBAAqB,CAuBxB;AAMD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,OAAO,EACP,cAAoC,GACrC,EAAE;IACD,OAAO,EAAE,qBAAqB,EAAE,CAAC;IACjC,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC,GAAG,qBAAqB,GAAG,SAAS,CAwCpC"}

package/dist/utils/abort-utils.js

@@ -0,0 +1,107 @@
+function getAbortSignalApi() {
+    const api = AbortSignal;
+    return { any: api.any };
+}
+export function createTimeoutError(timeoutMs) {
+    if (typeof DOMException !== "undefined") {
+        return new DOMException(`The operation timed out after ${timeoutMs}ms`, "TimeoutError");
+    }
+    const error = new Error(`The operation timed out after ${timeoutMs}ms`);
+    error.name = "TimeoutError";
+    return error;
+}
+// ---------------------------------------------------------------------------
+// createTimeoutAbortSignal
+// ---------------------------------------------------------------------------
+/**
+ * Creates an AbortSignal that fires after `timeoutMs` using a cancellable
+ * `AbortController` + `setTimeout`. We intentionally don't delegate to the
+ * native `AbortSignal.timeout()` — its returned signal has no way to cancel
+ * the underlying timer, which would make `dispose()` a lie on that path and
+ * give us divergent abort-reason messages across runtimes.
+ *
+ * On Node-like runtimes we `unref()` the timer so a pending timeout doesn't
+ * keep the process alive. In browsers `.unref` is absent and the guard is a
+ * harmless no-op.
+ *
+ * The signal's abort reason is a `DOMException` with `name: "TimeoutError"`
+ * so callers can distinguish timeout-driven aborts from caller-driven ones.
+ *
+ * Always call `dispose()` when the signal is no longer needed to clear the
+ * pending timer.
+ */
+export function createTimeoutAbortSignal({ timeoutMs, }) {
+    const controller = new AbortController();
+    let timer = setTimeout(() => {
+        timer = undefined;
+        controller.abort(createTimeoutError(timeoutMs));
+    }, timeoutMs);
+    // Node (and Bun/Deno): don't let a pending timeout block process exit.
+    // Browsers: `unref` is undefined on the numeric handle; this is a no-op.
+    const maybeUnref = timer.unref;
+    if (typeof maybeUnref === "function") {
+        maybeUnref.call(timer);
+    }
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// combineAbortSignals
+// ---------------------------------------------------------------------------
+/**
+ * Combines multiple disposable abort handles so the result aborts when *any*
+ * source does. Uses native `AbortSignal.any()` when available; otherwise wires
+ * up listeners manually.
+ *
+ * Returns `undefined` when the array is empty, or passes through a single
+ * handle without wrapping it.
+ *
+ * Always call `dispose()` on the result when it is no longer needed. This
+ * removes event listeners from source signals and calls `dispose()` on every
+ * input handle (releasing timers, etc).
+ */
+export function combineAbortSignals({ handles, abortSignalApi = getAbortSignalApi(), }) {
+    if (handles.length === 0)
+        return undefined;
+    if (handles.length === 1)
+        return handles[0];
+    const disposeInputs = () => {
+        for (const handle of handles)
+            handle.dispose();
+    };
+    if (abortSignalApi.any) {
+        return {
+            signal: abortSignalApi.any(handles.map((h) => h.signal)),
+            dispose: disposeInputs,
+        };
+    }
+    // Fallback: wire up listeners manually.
+    const controller = new AbortController();
+    const listeners = [];
+    for (const { signal: source } of handles) {
+        if (source.aborted) {
+            controller.abort(source.reason);
+            return { signal: controller.signal, dispose: disposeInputs };
+        }
+        const handler = () => controller.abort(source.reason);
+        source.addEventListener("abort", handler, { once: true });
+        listeners.push({ source, handler });
+    }
+    return {
+        signal: controller.signal,
+        dispose: () => {
+            for (const { source, handler } of listeners) {
+                source.removeEventListener("abort", handler);
+            }
+            listeners.length = 0;
+            disposeInputs();
+        },
+    };
+}

package/package.json

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