@zapier/zapier-sdk 0.108.1 → 0.109.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @zapier/zapier-sdk
 
+## 0.109.0
+
+### Minor Changes
+
+- f56765a: Deprecated `createZapierApi` and `getOrCreateApiClient` in favor of building an SDK with `createSdk` and accessing `apiPluginRef` with `resolvePlugin`. Both functions continue to work with a once-per-process warning.
+
+### Patch Changes
+
+- f56765a: `createZapierSdk({ cache })` now uses the caller-supplied cache for client-credentials access tokens instead of silently falling back to the default cache (the CLI's filesystem and keychain cache when installed, otherwise in-memory).
+
 ## 0.108.1
 
 ### Patch Changes

package/dist/{chunk-S7XDZGKJ.mjs → chunk-6QN54DRD.mjs}

@@ -1,6 +1,6 @@
 import { __require } from './chunk-Y6FXYEAI.mjs';
 import { z } from 'zod';
-import { withPositional, declareOptionalProperty, defineProperty, createDeprecationLogger, createAsyncContext, definePlugin, sendHttpRequestPlugin, retryHttpRequestPlugin, declareProperty, defineMethod, coreOptionsPluginRef, createValidator, defineFormatter, declareMethod, defineResolver, concatLists, openEnum, defineHook, getRegistryPlugin, paginate, toSnakeCase, isCoreError, toTitleCase, createSdk, RETRY_HTTP_REQUEST_OPTIONS_ID, CORE_ERROR_SYMBOL, CoreErrorCode, CORE_SIGNAL_SYMBOL, isCoreSignal, CORE_OPTIONS_ID } from '@zapier/kitcore';
+import { withPositional, createDeprecationLogger, createAsyncContext, declareOptionalProperty, defineProperty, definePlugin, sendHttpRequestPlugin, retryHttpRequestPlugin, declareProperty, defineMethod, coreOptionsPluginRef, createValidator, defineFormatter, declareMethod, defineResolver, concatLists, openEnum, defineHook, getRegistryPlugin, paginate, toSnakeCase, isCoreError, toTitleCase, CORE_ERROR_SYMBOL, CoreErrorCode, CORE_SIGNAL_SYMBOL, isCoreSignal, createSdk, CORE_OPTIONS_ID, resolvePlugin } from '@zapier/kitcore';
 export { CONTEXT, CORE_ERROR_SYMBOL, CORE_OPTIONS_ID, CORE_SIGNAL_SYMBOL, CoreCancelledSignal, CoreDisposeError, CoreErrorCode, CoreSignal, addPlugin, composePlugins, createController, createCorePlugin, createFunction, createPaginatedFunction, createPaginatedPluginMethod, createPluginMethod, createPluginStack, createSdk, declareMethod, declareOptionalProperty, declarePlugin, declareProperty, defineFormatter, defineLegacyMerge, defineMethod, defineMethodOverride, defineOverride, definePlugin, defineProperty, defineResolver, disposeSdk, fromFunctionPlugin, getContext, getCoreErrorCause, getCoreErrorCode, getNegatable, getRegistryPlugin, isCoreCancelledSignal, isCoreError, isCoreSignal, isPositional, omitExports, resolvePlugin, runInMethodScope, runWithTelemetryContext, selectExports, toSnakeCase, toTitleCase } from '@zapier/kitcore';
 import { buildHttpRequestContext, buildActionRunContext } from '@zapier/policy-context';
 import { ListAppsQuerySchema, AppItemSchema as AppItemSchema$1 } from '@zapier/zapier-sdk-core/v0/schemas/apps';
@@ -605,6 +605,83 @@ function extractUserIdsFromJwt(token) {
   };
 }
 
+// src/api/concurrency.ts
+var NO_OP_RELEASE = () => {
+};
+var NO_OP_SEMAPHORE = {
+  acquire: async () => NO_OP_RELEASE,
+  tryAcquire: () => NO_OP_RELEASE
+};
+function createSemaphore(maxPermits) {
+  if (maxPermits === Infinity) {
+    return NO_OP_SEMAPHORE;
+  }
+  if (!Number.isInteger(maxPermits) || maxPermits <= 0) {
+    throw new Error(
+      `maxPermits must be a positive integer or Infinity, got: ${maxPermits}`
+    );
+  }
+  let permits = maxPermits;
+  const waiters = [];
+  const release = () => {
+    const next = waiters.shift();
+    if (next) {
+      next.grant();
+    } else {
+      permits++;
+    }
+  };
+  const makeReleaseOnce = () => {
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      release();
+    };
+  };
+  return {
+    tryAcquire() {
+      if (permits > 0) {
+        permits--;
+        return makeReleaseOnce();
+      }
+      return null;
+    },
+    async acquire(signal) {
+      if (signal?.aborted) {
+        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+      }
+      if (permits > 0) {
+        permits--;
+        return makeReleaseOnce();
+      }
+      return new Promise((resolve2, reject) => {
+        const onAbort = () => {
+          const idx = waiters.indexOf(waiter);
+          if (idx !== -1) {
+            waiters.splice(idx, 1);
+            waiter.cancel(
+              signal?.reason ?? new DOMException("Aborted", "AbortError")
+            );
+          }
+        };
+        const waiter = {
+          grant: () => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve2(makeReleaseOnce());
+          },
+          cancel: (reason) => {
+            signal?.removeEventListener("abort", onAbort);
+            reject(reason);
+          }
+        };
+        signal?.addEventListener("abort", onAbort);
+        waiters.push(waiter);
+      });
+    }
+  };
+}
+
 // src/api/debug.ts
 var utilModule = null;
 var utilPromise = null;
@@ -997,86 +1074,21 @@ async function pollUntilComplete(options) {
   }
 }
 
-// src/api/concurrency.ts
-var NO_OP_RELEASE = () => {
-};
-var NO_OP_SEMAPHORE = {
-  acquire: async () => NO_OP_RELEASE,
-  tryAcquire: () => NO_OP_RELEASE
-};
-function createSemaphore(maxPermits) {
-  if (maxPermits === Infinity) {
-    return NO_OP_SEMAPHORE;
-  }
-  if (!Number.isInteger(maxPermits) || maxPermits <= 0) {
-    throw new Error(
-      `maxPermits must be a positive integer or Infinity, got: ${maxPermits}`
-    );
-  }
-  let permits = maxPermits;
-  const waiters = [];
-  const release = () => {
-    const next = waiters.shift();
-    if (next) {
-      next.grant();
-    } else {
-      permits++;
-    }
-  };
-  const makeReleaseOnce = () => {
-    let released = false;
-    return () => {
-      if (released) return;
-      released = true;
-      release();
-    };
-  };
-  return {
-    tryAcquire() {
-      if (permits > 0) {
-        permits--;
-        return makeReleaseOnce();
-      }
-      return null;
-    },
-    async acquire(signal) {
-      if (signal?.aborted) {
-        throw signal.reason ?? new DOMException("Aborted", "AbortError");
-      }
-      if (permits > 0) {
-        permits--;
-        return makeReleaseOnce();
-      }
-      return new Promise((resolve2, reject) => {
-        const onAbort = () => {
-          const idx = waiters.indexOf(waiter);
-          if (idx !== -1) {
-            waiters.splice(idx, 1);
-            waiter.cancel(
-              signal?.reason ?? new DOMException("Aborted", "AbortError")
-            );
-          }
-        };
-        const waiter = {
-          grant: () => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve2(makeReleaseOnce());
-          },
-          cancel: (reason) => {
-            signal?.removeEventListener("abort", onAbort);
-            reject(reason);
-          }
-        };
-        signal?.addEventListener("abort", onAbort);
-        waiters.push(waiter);
-      });
-    }
-  };
+// src/api/correlation.ts
+var CORRELATION_CALL_ID = Symbol(
+  "zapier.correlationCallId"
+);
+function resolveCorrelationId({
+  options,
+  callId
+}) {
+  return options?.correlationId || getZapierCorrelationId() || callId || void 0;
+}
+function resolveCausationId({
+  options
+}) {
+  return options?.causationId || getZapierCausationId();
 }
-var SDK_OPTIONS_ID = "zapier/sdkOptions";
-var sdkOptionsPluginRef = declareOptionalProperty({
-  id: SDK_OPTIONS_ID
-});
 
 // src/api/rate-limit.ts
 var EPOCH_THRESHOLD_SECONDS = 1e9;
@@ -1162,99 +1174,6 @@ function createRetryObserver({
     }
   };
 }
-
-// src/plugins/transport/options.ts
-var RETRYABLE_STATUSES = [429, 500, 502, 503, 504];
-var NON_IDEMPOTENT_RETRYABLE_STATUSES = [429];
-function resolveRetryHttpRequestOptions({
-  maxNetworkRetries,
-  maxNetworkRetryDelayMilliseconds,
-  onEvent
-}) {
-  const retries = maxNetworkRetries ?? ZAPIER_MAX_NETWORK_RETRIES;
-  return {
-    maxAttempts: retries + 1,
-    maxDelayMilliseconds: maxNetworkRetryDelayMilliseconds ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS,
-    retryStatuses: RETRYABLE_STATUSES,
-    nonIdempotentRetryStatuses: NON_IDEMPOTENT_RETRYABLE_STATUSES,
-    onRetry: createRetryObserver({ onEvent, maxNetworkRetries: retries })
-  };
-}
-function resolveNetworkRetryDelayMilliseconds({
-  maxNetworkRetryDelaySeconds,
-  maxNetworkRetryDelayMs
-}) {
-  return maxNetworkRetryDelaySeconds != null ? maxNetworkRetryDelaySeconds * 1e3 : maxNetworkRetryDelayMs;
-}
-function resolveTransportFetch({
-  fetch: customFetch,
-  debug = false
-}) {
-  const originalFetch = customFetch ?? ((input, init) => globalThis.fetch(input, init));
-  if (!debug) return originalFetch;
-  return createDebugFetch({
-    originalFetch,
-    debugLog: createDebugLogger(debug)
-  });
-}
-
-// src/plugins/transport/http-fetch.ts
-var httpFetchPlugin = defineProperty({
-  namespace: "kitcore",
-  name: "httpFetch",
-  imports: [sdkOptionsPluginRef],
-  setup: ({ imports }) => resolveTransportFetch({
-    fetch: imports.sdkOptions?.fetch,
-    debug: imports.sdkOptions?.debug
-  }),
-  get: ({ state }) => state
-});
-
-// src/plugins/transport/standalone.ts
-function createZapierSendHttpRequest({
-  fetch: customFetch,
-  debug,
-  maxNetworkRetries,
-  maxNetworkRetryDelayMilliseconds,
-  onEvent
-}) {
-  const sdk = createSdk(
-    definePlugin({
-      name: "zapierStandaloneHttpTransport",
-      imports: [sendHttpRequestPlugin, retryHttpRequestPlugin, httpFetchPlugin],
-      exports: [sendHttpRequestPlugin]
-    }),
-    {
-      configuration: {
-        [SDK_OPTIONS_ID]: { fetch: customFetch, debug },
-        // Filled by configuration rather than the graph's property plugin: the
-        // caller here holds client-shaped ms options, not SDK options.
-        [RETRY_HTTP_REQUEST_OPTIONS_ID]: resolveRetryHttpRequestOptions({
-          maxNetworkRetries,
-          maxNetworkRetryDelayMilliseconds,
-          onEvent
-        })
-      }
-    }
-  );
-  return sdk.sendHttpRequest;
-}
-
-// src/api/correlation.ts
-var CORRELATION_CALL_ID = Symbol(
-  "zapier.correlationCallId"
-);
-function resolveCorrelationId({
-  options,
-  callId
-}) {
-  return options?.correlationId || getZapierCorrelationId() || callId || void 0;
-}
-function resolveCausationId({
-  options
-}) {
-  return options?.causationId || getZapierCausationId();
-}
 var ClientCredentialsObjectSchema = z.object({
   type: z.enum(["client_credentials"]).optional().meta({ internal: true }),
   clientId: z.string().describe("OAuth client ID for authentication.").meta({ valueHint: "id" }),
@@ -2878,7 +2797,7 @@ function logRouteOverride({
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.108.1" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.109.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -3897,7 +3816,7 @@ var ZapierApiClient = class {
       }
       await openApproval(approval.approval_url);
     }
-    const timeoutMs = this.options.approvalTimeoutMilliseconds ?? this.options.approvalTimeoutMs ?? DEFAULT_APPROVAL_TIMEOUT_MILLISECONDS;
+    const timeoutMs = this.options.approvalTimeoutMilliseconds ?? DEFAULT_APPROVAL_TIMEOUT_MILLISECONDS;
     const approvalDeadline = Date.now() + timeoutMs;
     let streamAbortController;
     let streamPromise;
@@ -4065,7 +3984,7 @@ var ZapierApiClient = class {
     );
   }
 };
-var createZapierApi = (options) => {
+var createApiClient = (options) => {
   const { debug = false, fetch: originalFetch = globalThis.fetch } = options;
   const routingOptions = parseRoutingOptions({ options });
   const debugLog = createDebugLogger(debug);
@@ -4076,62 +3995,94 @@ var createZapierApi = (options) => {
     // The credential-exchange transport. Debug-wrapped here rather than in the
     // pipeline because `resolveAuthToken` is issued outside it.
     fetch: debugFetch,
-    // Built from the caller's own `fetch`, not `debugFetch`: the pipeline wraps
-    // for debug itself, and passing the wrapped one would log twice.
-    sendHttpRequest: options.sendHttpRequest ?? createZapierSendHttpRequest({
-      fetch: options.fetch,
-      debug,
-      onEvent: options.onEvent,
-      maxNetworkRetries: options.maxNetworkRetries,
-      maxNetworkRetryDelayMilliseconds: options.maxNetworkRetryDelayMilliseconds ?? options.maxNetworkRetryDelayMs
-    }),
+    sendHttpRequest: options.sendHttpRequest,
     debugLog,
     routingOptions
   });
 };
-
-// src/api/error-classification.ts
-function isPermanentHttpError(err) {
-  if (!isZapierError(err)) return false;
-  if (isZapierAuthenticationError(err) && err.statusCode === void 0) {
-    return true;
+var API_CLIENT_DURATIONS_ID = "zapier/apiClientDurations";
+var apiClientDurationsPluginRef = declareOptionalProperty({
+  id: API_CLIENT_DURATIONS_ID
+});
+function resolveNetworkRetryDelayMilliseconds({
+  apiClientDurations,
+  sdkOptions
+}) {
+  if (apiClientDurations?.maxNetworkRetryDelayMilliseconds != null) {
+    return apiClientDurations.maxNetworkRetryDelayMilliseconds;
   }
-  const { statusCode } = err;
-  return statusCode !== void 0 && statusCode >= 400 && statusCode < 500 && statusCode !== 429;
+  if (sdkOptions?.maxNetworkRetryDelaySeconds != null) {
+    return sdkOptions.maxNetworkRetryDelaySeconds * 1e3;
+  }
+  return sdkOptions?.maxNetworkRetryDelayMs;
 }
-
-// src/api/index.ts
-function getOrCreateApiClient(config) {
-  const {
-    baseUrl = ZAPIER_BASE_URL,
-    credentials,
-    token,
-    api: providedApi,
-    debug = false,
-    fetch: customFetch,
-    callerPackage
-  } = config;
-  if (providedApi) {
-    return providedApi;
+function resolveApprovalTimeoutMilliseconds({
+  apiClientDurations,
+  sdkOptions
+}) {
+  if (apiClientDurations?.approvalTimeoutMilliseconds != null) {
+    return apiClientDurations.approvalTimeoutMilliseconds;
   }
-  return createZapierApi({
-    baseUrl,
-    credentials,
-    token,
-    debug,
-    fetch: customFetch,
-    callerPackage
+  if (sdkOptions?.approvalTimeoutSeconds != null) {
+    return sdkOptions.approvalTimeoutSeconds * 1e3;
+  }
+  return sdkOptions?.approvalTimeoutMs;
+}
+var SDK_OPTIONS_ID = "zapier/sdkOptions";
+var sdkOptionsPluginRef = declareOptionalProperty({
+  id: SDK_OPTIONS_ID
+});
+
+// src/plugins/transport/options.ts
+var RETRYABLE_STATUSES = [429, 500, 502, 503, 504];
+var NON_IDEMPOTENT_RETRYABLE_STATUSES = [429];
+function resolveRetryHttpRequestOptions({
+  maxNetworkRetries,
+  maxNetworkRetryDelayMilliseconds,
+  onEvent
+}) {
+  const retries = maxNetworkRetries ?? ZAPIER_MAX_NETWORK_RETRIES;
+  return {
+    maxAttempts: retries + 1,
+    maxDelayMilliseconds: maxNetworkRetryDelayMilliseconds ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS,
+    retryStatuses: RETRYABLE_STATUSES,
+    nonIdempotentRetryStatuses: NON_IDEMPOTENT_RETRYABLE_STATUSES,
+    onRetry: createRetryObserver({ onEvent, maxNetworkRetries: retries })
+  };
+}
+function resolveTransportFetch({
+  fetch: customFetch,
+  debug = false
+}) {
+  const originalFetch = customFetch ?? ((input, init) => globalThis.fetch(input, init));
+  if (!debug) return originalFetch;
+  return createDebugFetch({
+    originalFetch,
+    debugLog: createDebugLogger(debug)
   });
 }
+
+// src/plugins/transport/http-fetch.ts
+var httpFetchPlugin = defineProperty({
+  namespace: "kitcore",
+  name: "httpFetch",
+  imports: [sdkOptionsPluginRef],
+  setup: ({ imports }) => resolveTransportFetch({
+    fetch: imports.sdkOptions?.fetch,
+    debug: imports.sdkOptions?.debug
+  }),
+  get: ({ state }) => state
+});
 var retryHttpRequestOptionsPlugin = defineProperty({
   namespace: "kitcore",
   name: "retryHttpRequestOptions",
-  imports: [sdkOptionsPluginRef],
+  imports: [sdkOptionsPluginRef, apiClientDurationsPluginRef],
   setup: ({ imports }) => resolveRetryHttpRequestOptions({
     maxNetworkRetries: imports.sdkOptions?.maxNetworkRetries,
-    maxNetworkRetryDelayMilliseconds: resolveNetworkRetryDelayMilliseconds(
-      imports.sdkOptions ?? {}
-    ),
+    maxNetworkRetryDelayMilliseconds: resolveNetworkRetryDelayMilliseconds({
+      apiClientDurations: imports.apiClientDurations,
+      sdkOptions: imports.sdkOptions
+    }),
     onEvent: imports.sdkOptions?.onEvent
   }),
   get: ({ state }) => state
@@ -4175,10 +4126,14 @@ function withCorrelationId({
 var apiPlugin = defineProperty({
   namespace: "zapier",
   name: "api",
-  // Import the aggregate so it also provides `kitcore/httpFetch`; importing
-  // `sendHttpRequestPlugin` alone would bypass `sdkOptions.fetch`.
-  imports: [sdkOptionsPluginRef, zapierHttpTransportPlugin],
+  // Import the aggregate so SDK options and host transport wraps are applied.
+  imports: [
+    sdkOptionsPluginRef,
+    apiClientDurationsPluginRef,
+    zapierHttpTransportPlugin
+  ],
   setup: ({ imports }) => {
+    const sdkOptions = imports.sdkOptions ?? {};
     const {
       fetch: customFetch = globalThis.fetch,
       baseUrl = ZAPIER_BASE_URL,
@@ -4186,38 +4141,33 @@ var apiPlugin = defineProperty({
       token,
       onEvent,
       debug = false,
-      maxNetworkRetries = ZAPIER_MAX_NETWORK_RETRIES,
-      maxNetworkRetryDelaySeconds,
-      maxNetworkRetryDelayMs,
       maxConcurrentRequests = ZAPIER_MAX_CONCURRENT_REQUESTS,
-      approvalTimeoutSeconds,
-      approvalTimeoutMs,
       maxApprovalRetries,
       approvalMode,
       openAutoModeApprovalsInBrowser,
       callerPackage,
+      cache,
       routeOverrides,
       correlationId,
       causationId
-    } = imports.sdkOptions ?? {};
-    return createZapierApi({
+    } = sdkOptions;
+    return createApiClient({
       baseUrl,
       credentials,
       token,
       debug,
       fetch: customFetch,
       onEvent,
-      maxNetworkRetries,
-      maxNetworkRetryDelayMilliseconds: resolveNetworkRetryDelayMilliseconds({
-        maxNetworkRetryDelaySeconds,
-        maxNetworkRetryDelayMs
-      }) ?? ZAPIER_MAX_NETWORK_RETRY_DELAY_MILLISECONDS,
       maxConcurrentRequests,
-      approvalTimeoutMilliseconds: approvalTimeoutSeconds != null ? approvalTimeoutSeconds * 1e3 : approvalTimeoutMs,
+      approvalTimeoutMilliseconds: resolveApprovalTimeoutMilliseconds({
+        apiClientDurations: imports.apiClientDurations,
+        sdkOptions
+      }),
       maxApprovalRetries,
       approvalMode,
       openAutoModeApprovalsInBrowser,
       callerPackage,
+      cache,
       routeOverrides,
       // Inject the graph-composed transport so host `dispatchHttpRequest` wraps
       // apply.
@@ -10517,6 +10467,112 @@ var drainTriggerInboxPlugin = defineMethod({
     });
   }
 });
+var apiClientRootPlugin = definePlugin({
+  namespace: "zapier",
+  name: "apiClientRoot",
+  imports: [apiPlugin],
+  exports: []
+});
+function hasStringUrl(request) {
+  return typeof request.url === "string";
+}
+function createApiClientGraphConfiguration(options) {
+  const {
+    maxNetworkRetryDelayMilliseconds,
+    maxNetworkRetryDelayMs,
+    approvalTimeoutMilliseconds,
+    approvalTimeoutMs,
+    sendHttpRequest: _sendHttpRequest,
+    ...sdkOptions
+  } = options;
+  return {
+    [SDK_OPTIONS_ID]: sdkOptions,
+    [API_CLIENT_DURATIONS_ID]: {
+      maxNetworkRetryDelayMilliseconds: maxNetworkRetryDelayMilliseconds ?? maxNetworkRetryDelayMs,
+      approvalTimeoutMilliseconds: approvalTimeoutMilliseconds ?? approvalTimeoutMs
+    }
+  };
+}
+function createApiClientFromSdkGraph(options) {
+  parseRoutingOptions({ options });
+  const configuration = createApiClientGraphConfiguration(options);
+  const { sendHttpRequest } = options;
+  if (!sendHttpRequest) {
+    const sdk2 = createSdk(apiClientRootPlugin, { configuration });
+    return resolvePlugin(sdk2, apiPluginRef);
+  }
+  const replaceSendHttpRequestPlugin = defineHook({
+    namespace: "zapier",
+    name: "replaceApiClientSendHttpRequest",
+    imports: [sendHttpRequestPlugin],
+    wrap: {
+      // Replaces the pipeline rather than wrapping it: `next` is deliberately
+      // unused. A transport supplied through `sendHttpRequest` owns its retry
+      // policy, so running the SDK's stages underneath would nest the caller's
+      // retry loop inside a second one. Dropping them is only safe because the
+      // SDK's retry hook wraps `attemptHttpRequest`, a stage below this seam,
+      // so replacing `sendHttpRequest` removes that loop instead of nesting
+      // inside it. The cost is that the SDK cannot observe retries the caller
+      // performs, and so reports a terminal 429 as zero.
+      sendHttpRequest: ({ input }) => sendHttpRequest(
+        hasStringUrl(input) ? input : { ...input, url: input.url.toString() }
+      )
+    }
+  });
+  const sdk = createSdk(
+    definePlugin({
+      namespace: "zapier",
+      name: "standaloneApiClientRoot",
+      imports: [apiPlugin, replaceSendHttpRequestPlugin],
+      exports: []
+    }),
+    { configuration }
+  );
+  return resolvePlugin(sdk, apiPluginRef);
+}
+
+// src/api/error-classification.ts
+function isPermanentHttpError(err) {
+  if (!isZapierError(err)) return false;
+  if (isZapierAuthenticationError(err) && err.statusCode === void 0) {
+    return true;
+  }
+  const { statusCode } = err;
+  return statusCode !== void 0 && statusCode >= 400 && statusCode < 500 && statusCode !== 429;
+}
+
+// src/api/index.ts
+function createZapierApi(options) {
+  logDeprecation(
+    "createZapierApi is deprecated and will be removed in a future release. Build an SDK with createSdk and access apiPluginRef with resolvePlugin instead."
+  );
+  return createApiClientFromSdkGraph(options);
+}
+function getOrCreateApiClient(config) {
+  logDeprecation(
+    "getOrCreateApiClient is deprecated and will be removed in a future release. Use a provided API client directly, or build an SDK with createSdk and access apiPluginRef with resolvePlugin."
+  );
+  const {
+    baseUrl = ZAPIER_BASE_URL,
+    credentials,
+    token,
+    api: providedApi,
+    debug = false,
+    fetch: customFetch,
+    callerPackage
+  } = config;
+  if (providedApi) {
+    return providedApi;
+  }
+  return createApiClientFromSdkGraph({
+    baseUrl,
+    credentials,
+    token,
+    debug,
+    fetch: customFetch,
+    callerPackage
+  });
+}
 
 // src/plugins/triggers/watchTriggerInbox/sse.ts
 async function* readInboxEvents({