@zapier/zapier-sdk 0.108.0 → 0.109.0

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

@@ -1,10 +1,10 @@
 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';
-import { ListConnectionsQuerySchema as ListConnectionsQuerySchema$1, ConnectionSchema, ConnectionItemSchema } from '@zapier/zapier-sdk-core/v0/schemas/connections';
+import { ListConnectionsQuerySchema as ListConnectionsQuerySchema$1, ConnectionSchema, ConnectionsResponseSchema, ConnectionItemSchema } from '@zapier/zapier-sdk-core/v0/schemas/connections';
 import { ListClientCredentialsQuerySchema as ListClientCredentialsQuerySchema$1, ClientCredentialsItemSchema as ClientCredentialsItemSchema$1, CreateClientCredentialsRequestSchema, ClientCredentialsCreatedItemSchema as ClientCredentialsCreatedItemSchema$1 } from '@zapier/zapier-sdk-core/v0/schemas/client-credentials';
 
 // src/constants.ts
@@ -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;
@@ -862,8 +939,16 @@ var processResponse = async (response, successStatus, pendingStatus, isPending,
     };
   }
   if (response.status === successStatus) {
+    let resultJson;
+    try {
+      resultJson = await response.json();
+    } catch (error) {
+      throw new ZapierApiError("Poll response body was not valid JSON", {
+        statusCode: response.status,
+        cause: error
+      });
+    }
     try {
-      const resultJson = await response.json();
       if (isPending && isPending(resultJson)) {
         return {
           status: "continue" /* Continue */,
@@ -876,13 +961,7 @@ var processResponse = async (response, successStatus, pendingStatus, isPending,
         errorCount: 0
       };
     } catch (error) {
-      throw new ZapierApiError(
-        "Result extractor failed to parse successful response as JSON",
-        {
-          statusCode: response.status,
-          cause: error
-        }
-      );
+      return { status: "failed" /* Failed */, error, errorCount };
     }
   }
   if (response.status !== pendingStatus) {
@@ -955,13 +1034,10 @@ async function pollUntilComplete(options) {
       if (signal?.aborted) throw makeAbortError();
     }
     attempts++;
+    let terminalThrow;
     try {
       const response = await fetchPoll();
-      const {
-        result,
-        errorCount: newErrorCount,
-        status
-      } = await processResponse(
+      const pollResult = await processResponse(
         response,
         successStatus,
         pendingStatus,
@@ -969,15 +1045,18 @@ async function pollUntilComplete(options) {
         resultExtractor,
         errorCount
       );
-      errorCount = newErrorCount;
-      if (status === "success" /* Success */) {
-        return result;
-      }
-      if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
-        throw new ZapierApiError(
-          `Poll request failed: ${response.status} ${response.statusText}`,
-          { statusCode: response.status }
-        );
+      errorCount = pollResult.errorCount;
+      if (pollResult.status === "failed" /* Failed */) {
+        terminalThrow = { error: pollResult.error };
+      } else if (pollResult.status === "success" /* Success */) {
+        return pollResult.result;
+      } else if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
+        terminalThrow = {
+          error: new ZapierApiError(
+            `Poll request failed: ${response.status} ${response.statusText}`,
+            { statusCode: response.status }
+          )
+        };
       }
     } catch (error) {
       if (isAbortError(error)) throw error;
@@ -991,89 +1070,25 @@ async function pollUntilComplete(options) {
         );
       }
     }
+    if (terminalThrow) throw terminalThrow.error;
   }
 }
 
-// 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;
@@ -1159,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" }),
@@ -2875,7 +2797,7 @@ function logRouteOverride({
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.108.0" : 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:";
@@ -3894,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;
@@ -4062,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);
@@ -4073,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
@@ -4172,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,
@@ -4183,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.
@@ -8137,7 +8090,7 @@ var ListConnectionsQuerySchema = ListConnectionsQuerySchema$1.omit({
     "Include connections shared with you. By default, only your own connections are returned (owner=me). Set to true to also include shared connections."
   ),
   // Filters on connection expiry. Not a mirror of a server-side status
-  // field: the API expresses this as the is_expired filter, which we send as
+  // field: the API expresses this as the stale filter, which we send as
   // false for "active", true for "expired", and omit for "all".
   status: z.enum(["active", "expired", "all"]).optional().describe(
     "Filter connections by expiry: 'active' (default) returns only non-expired connections, 'expired' only expired ones, and 'all' returns both."
@@ -8154,7 +8107,11 @@ var ListConnectionsQuerySchema = ListConnectionsQuerySchema$1.omit({
     deprecated: true,
     deprecationMessage: "Use --status expired instead to show only expired connections, or --status all for both."
   }),
-  // Override pageSize to make optional
+  // Override pageSize to make optional, and deliberately leave it uncapped:
+  // the authentications endpoint accepts a `limit` well above 1000 (it sets
+  // no max_limit of its own), so a local ceiling would reject input the API
+  // takes. The description keeps hedging because the endpoint stays free to
+  // add one.
   pageSize: z.number().min(1).optional().describe(
     "Number of connections per page. The upstream API may cap this and reject values above its limit."
   ),
@@ -8163,13 +8120,86 @@ var ListConnectionsQuerySchema = ListConnectionsQuerySchema$1.omit({
   // SDK specific property for pagination/iterable helpers
   cursor: z.string().optional().describe("Cursor to start from")
 }).describe("List available connections with optional filtering");
-ConnectionSchema.extend({
+var RawConnectionSchema = ConnectionSchema.extend({
   is_stale: z.boolean().optional(),
   is_shared: z.boolean().optional(),
   members: z.array(z.record(z.string(), z.any())).optional(),
   customuser_id: z.number().nullable().optional(),
   customuser_public_id: z.string().nullable().optional()
 });
+var RawConnectionsResponseSchema = ConnectionsResponseSchema.extend({
+  results: z.array(RawConnectionSchema)
+});
+
+// src/normalizers/shared.ts
+function fastifyToString(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === null) {
+    return "";
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (value instanceof RegExp) {
+    return value.source;
+  }
+  try {
+    return String(value.toString());
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+// src/normalizers/connection.ts
+function normalizeConnectionItem({
+  connection,
+  appKey: providedAppKey,
+  appVersion: providedAppVersion,
+  adaptError
+}) {
+  let appKey = providedAppKey;
+  let appVersion = providedAppVersion;
+  if (connection.selected_api && typeof connection.selected_api === "string") {
+    const [extractedAppKey, extractedVersion] = splitVersionedKey(
+      connection.selected_api
+    );
+    if (!appKey) {
+      appKey = extractedAppKey;
+    }
+    if (!appVersion) {
+      appVersion = extractedVersion;
+    }
+  }
+  const {
+    selected_api: selectedApi,
+    customuser_id: profileId,
+    id,
+    account_id: accountId,
+    ...restOfConnection
+  } = connection;
+  const normalized = {
+    ...restOfConnection,
+    id: String(id),
+    account_id: String(accountId),
+    implementation_id: selectedApi,
+    title: connection.title || connection.label || void 0,
+    is_stale: fastifyToString(connection.is_stale),
+    is_expired: fastifyToString(connection.is_stale),
+    is_shared: fastifyToString(connection.is_shared),
+    members: fastifyToString(connection.members),
+    customuser_public_id: fastifyToString(connection.customuser_public_id),
+    expired_at: connection.marked_stale_at,
+    app_key: appKey,
+    app_version: appVersion,
+    profile_id: profileId != null ? String(profileId) : void 0
+  };
+  return createValidator(ConnectionItemSchema, { adaptError })(normalized);
+}
 function formatConnectionItem(item) {
   const details = [];
   const appKey = item.app_key ?? "unknown";
@@ -8210,7 +8240,8 @@ var listConnectionsPlugin = defineMethod({
     connectionsPluginRef,
     apiPluginRef,
     manifestPluginRef,
-    capabilitiesPluginRef
+    capabilitiesPluginRef,
+    coreOptionsPluginRef
   ],
   categories: ["connection"],
   itemType: "Connection",
@@ -8238,18 +8269,17 @@ var listConnectionsPlugin = defineMethod({
       await imports.capabilities.checkCapability("canIncludeSharedConnections");
     }
     const searchParams = {};
-    if (input.pageSize !== void 0) {
-      searchParams.page_size = input.pageSize.toString();
-    }
+    searchParams.limit = (input.pageSize ?? DEFAULT_PAGE_SIZE).toString();
     const appKey = input.app ?? input.appKey;
     if (appKey) {
       const implementationId = await getVersionedImplementationId(appKey);
       if (implementationId) {
         annotate({ selectedApi: implementationId });
         const [versionlessSelectedApi] = splitVersionedKey(implementationId);
-        searchParams.app_key = versionlessSelectedApi;
+        searchParams.versionless_selected_api = versionlessSelectedApi;
       } else {
-        searchParams.app_key = appKey;
+        const [versionlessAppKey] = splitVersionedKey(appKey);
+        searchParams.versionless_selected_api = versionlessAppKey;
       }
     }
     const connectionRefs = input.connections;
@@ -8263,15 +8293,14 @@ var listConnectionsPlugin = defineMethod({
           })
         )
       );
-      searchParams.connection_ids = resolvedIds.filter((id) => id != null).join(",");
+      searchParams.ids = resolvedIds.filter((id) => id != null).join(",");
     } else if (legacyConnectionIds && legacyConnectionIds.length > 0) {
-      searchParams.connection_ids = legacyConnectionIds.join(",");
+      searchParams.ids = legacyConnectionIds.join(",");
     }
     if (input.search) {
       searchParams.search = input.search;
-    }
-    if (input.title) {
-      searchParams.title = input.title;
+    } else if (input.title) {
+      searchParams.search = input.title;
     }
     const accountId = input.account ?? input.accountId;
     if (accountId) {
@@ -8294,18 +8323,31 @@ var listConnectionsPlugin = defineMethod({
     }
     const status = input.status ?? (expiredFilter ? "expired" : "active");
     if (status !== "all") {
-      searchParams.is_expired = (status === "expired").toString();
+      searchParams.stale = (status === "expired").toString();
     }
     if (input.cursor) {
       searchParams.offset = input.cursor;
     }
-    const response = await api.get(
-      "/api/v0/connections",
-      { searchParams, authRequired: true }
+    searchParams.ordering = "personal_first";
+    const rawResponse = await api.get("/zapier/api/v4/authentications", {
+      searchParams,
+      authRequired: true
+    });
+    const raw = createValidator(RawConnectionsResponseSchema, {
+      adaptError: imports.coreOptions?.adaptError
+    })(rawResponse);
+    let connections = raw.results.map(
+      (connection) => normalizeConnectionItem({
+        connection,
+        adaptError: imports.coreOptions?.adaptError
+      })
     );
+    if (input.title) {
+      connections = connections.filter((conn) => conn.title === input.title);
+    }
     return {
-      ...response,
-      data: response.data.map(transformConnectionItem)
+      data: connections.map(transformConnectionItem),
+      next: raw.next ?? null
     };
   }
 });
@@ -8481,76 +8523,6 @@ var getAppPlugin = defineMethod({
     throw new ZapierAppNotFoundError("App not found", { appKey });
   }
 });
-
-// src/normalizers/shared.ts
-function fastifyToString(value) {
-  if (value === void 0) {
-    return void 0;
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  if (value === null) {
-    return "";
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  if (value instanceof RegExp) {
-    return value.source;
-  }
-  try {
-    return String(value.toString());
-  } catch {
-    return "[unserializable]";
-  }
-}
-
-// src/normalizers/connection.ts
-function normalizeConnectionItem({
-  connection,
-  appKey: providedAppKey,
-  appVersion: providedAppVersion,
-  adaptError
-}) {
-  let appKey = providedAppKey;
-  let appVersion = providedAppVersion;
-  if (connection.selected_api && typeof connection.selected_api === "string") {
-    const [extractedAppKey, extractedVersion] = splitVersionedKey(
-      connection.selected_api
-    );
-    if (!appKey) {
-      appKey = extractedAppKey;
-    }
-    if (!appVersion) {
-      appVersion = extractedVersion;
-    }
-  }
-  const {
-    selected_api: selectedApi,
-    customuser_id: profileId,
-    id,
-    account_id: accountId,
-    ...restOfConnection
-  } = connection;
-  const normalized = {
-    ...restOfConnection,
-    id: String(id),
-    account_id: String(accountId),
-    implementation_id: selectedApi,
-    title: connection.title || connection.label || void 0,
-    is_stale: fastifyToString(connection.is_stale),
-    is_expired: fastifyToString(connection.is_stale),
-    is_shared: fastifyToString(connection.is_shared),
-    members: fastifyToString(connection.members),
-    customuser_public_id: fastifyToString(connection.customuser_public_id),
-    expired_at: connection.marked_stale_at,
-    app_key: appKey,
-    app_version: appVersion,
-    profile_id: profileId != null ? String(profileId) : void 0
-  };
-  return createValidator(ConnectionItemSchema, { adaptError })(normalized);
-}
 var GetConnectionDescription = "Get details for a specific connection";
 var GetConnectionSchema = z.object({
   connection: ConnectionPropertySchema
@@ -8945,7 +8917,7 @@ var WaitForNewConnectionSchema = z.object({
     "Delay before the first poll request, in ms. Default 3 seconds (3_000). Subsequent polling cadence is managed by the SDK's polling primitive (backoff with sane defaults)."
   ).meta({ deprecated: true })
 }).describe(
-  "Wait for a new connection to appear for the given app. Polls `/api/v0/connections` with server-side `ordering=-date` until the most recent matching row's `date` is at or after the started-at timestamp, then returns it. Pair with `get-connection-start-url` \u2014 that mints the URL the user opens, this waits for the resulting connection to land. Errors with a timeout after the configured timeout (default 5 min). Example (JS):\n\n```ts\nconst { data: { url, app, startedAt } } = await zapier.getConnectionStartUrl({ app: 'slack' });\n// show `url` to the user via the channel they're reading from\nconst { data: conn } = await zapier.waitForNewConnection({ app, startedAt });\n```"
+  "Wait for a new connection to appear for the given app. Polls the connections list newest-first until the most recent matching row's `date` is at or after the started-at timestamp, then returns it. Pair with `get-connection-start-url` \u2014 that mints the URL the user opens, this waits for the resulting connection to land. Errors with a timeout after the configured timeout (default 5 min). Example (JS):\n\n```ts\nconst { data: { url, app, startedAt } } = await zapier.getConnectionStartUrl({ app: 'slack' });\n// show `url` to the user via the channel they're reading from\nconst { data: conn } = await zapier.waitForNewConnection({ app, startedAt });\n```"
 );
 var WaitForNewConnectionItemSchema = z.object({
   id: z.string().describe(
@@ -8958,12 +8930,22 @@ var WaitForNewConnectionItemSchema = z.object({
     "Human-readable connection title set by the auth flow, when available."
   )
 }).describe("The new connection that was detected.");
+var WaitForNewConnectionRowSchema = z.object({
+  id: z.union([z.string(), z.number()]),
+  public_id: z.string().optional(),
+  date: z.string().optional(),
+  title: z.string().nullable().optional(),
+  label: z.string().nullable().optional()
+});
+var WaitForNewConnectionResponseSchema = z.object({
+  results: z.array(WaitForNewConnectionRowSchema)
+});
 
 // src/plugins/waitForNewConnection/index.ts
-var CONNECTIONS_PATH = "/api/v0/connections";
+var CONNECTIONS_PATH = "/zapier/api/v4/authentications";
 var waitForNewConnectionPlugin = defineMethod({
   name: "waitForNewConnection",
-  imports: [manifestPluginRef, apiPluginRef],
+  imports: [manifestPluginRef, apiPluginRef, coreOptionsPluginRef],
   categories: ["connection"],
   itemType: "Connection",
   inputSchema: WaitForNewConnectionSchema,
@@ -8974,27 +8956,31 @@ var waitForNewConnectionPlugin = defineMethod({
   run: async ({ imports, input, annotate }) => {
     const api = imports.api;
     const getVersionedImplementationId = imports.manifest.getVersionedImplementationId;
+    const validateConnectionsResponse = createValidator(
+      WaitForNewConnectionResponseSchema,
+      { adaptError: imports.coreOptions?.adaptError }
+    );
     const versionedKey = await getVersionedImplementationId(input.app);
-    const appKey = versionedKey ? versionedKey.split("@")[0] : input.app;
+    const [appKey] = splitVersionedKey(versionedKey ?? input.app);
     annotate({ selectedApi: appKey });
     try {
       const top = await api.poll(CONNECTIONS_PATH, {
         searchParams: {
-          app_key: appKey,
+          versionless_selected_api: appKey,
           // Scope to the current user's own connections. The connection we're
           // waiting on is by definition owned by the caller; without this the
           // one-row head-check could match a teammate's freshly created
           // connection for the same app.
           owner: "me",
-          is_expired: "false",
+          stale: "false",
           ordering: "-date",
-          page_size: "1"
+          limit: "1"
         },
         authRequired: true,
         timeoutMilliseconds: input.timeoutSeconds != null ? input.timeoutSeconds * 1e3 : input.timeoutMs ?? 3e5,
         initialDelayMilliseconds: input.pollIntervalMilliseconds ?? input.pollIntervalMs ?? 3e3,
         isPending: (body) => {
-          const rows = body.data ?? [];
+          const rows = validateConnectionsResponse(body).results;
           const head = rows[0];
           if (!head?.date) return true;
           const created = Math.floor(new Date(head.date).getTime() / 1e3);
@@ -9002,14 +8988,14 @@ var waitForNewConnectionPlugin = defineMethod({
         },
         resultExtractor: (body) => (
           // `isPending` guaranteed a fresh row at index 0 before this fires.
-          body.data[0]
+          validateConnectionsResponse(body).results[0]
         )
       });
       return {
         data: WaitForNewConnectionItemSchema.parse({
           id: String(top.public_id ?? top.id),
           app: appKey,
-          title: top.title ?? null
+          title: top.title || top.label || null
         })
       };
     } catch (err) {
@@ -10481,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({