@zapier/zapier-sdk 0.122.2 → 0.124.0

package/dist/{chunk-3WRZWB3X.mjs → chunk-EWFUUFGE.mjs}

@@ -1,7 +1,7 @@
 import { __require } from './chunk-Y6FXYEAI.mjs';
 import { z } from 'zod';
-import { withPositional, createDeprecationLogger, createStabilityNoticeLogger, 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, STABILITY_LEVELS, STABILITY_TITLES, addPlugin, applyStabilityLabel, createController, createSdk, declareMethod, declareOptionalProperty, declarePlugin, declareProperty, defineFormatter, defineMethod, defineMethodOverride, defineOverride, definePlugin, defineProperty, defineResolver, disposeSdk, getContext, getCoreErrorCause, getCoreErrorCode, getNegatable, getRegistry, getRegistryPlugin, isCoreCancelledSignal, isCoreError, isCoreSignal, isPositional, omitExports, resolvePlugin, runInMethodScope, runWithTelemetryContext, selectExports, toSnakeCase, toTitleCase } from '@zapier/kitcore';
+import { withPositional, createDeprecationLogger, createStabilityNoticeLogger, createAsyncContext, declareOptionalProperty, defineHook, prepareHttpRequestPlugin, receiveHttpResponsePlugin, defineProperty, definePlugin, sendHttpRequestPlugin, retryHttpRequestPlugin, declareProperty, defineMethod, coreOptionsPluginRef, createValidator, defineFormatter, declareMethod, defineResolver, concatLists, openEnum, declareDefault, getRegistryPlugin, paginate, toSnakeCase, isCoreError, toTitleCase, CoreErrorCode, CORE_ERROR_SYMBOL, CORE_SIGNAL_SYMBOL, isCoreSignal, createSdk, resolvePlugin } from '@zapier/kitcore';
+export { CONTEXT, CORE_ERROR_SYMBOL, CORE_OPTIONS_ID, CORE_SIGNAL_SYMBOL, CoreCancelledSignal, CoreDisposeError, CoreErrorCode, CoreSignal, STABILITY_LEVELS, STABILITY_TITLES, addPlugin, applyStabilityLabel, coreOptionsPluginRef, createController, createSdk, declareMethod, declareOptionalProperty, declarePlugin, declareProperty, defineFormatter, defineMethod, defineMethodOverride, defineOverride, definePlugin, defineProperty, defineResolver, disposeSdk, getContext, getCoreErrorCause, getCoreErrorCode, getNegatable, getRegistry, getRegistryPlugin, isCoreCancelledSignal, isCoreError, isCoreSignal, isPositional, omitExports, resolvePlugin, runInMethodScope, runWithTelemetryContext, selectExports, toSnakeCase, toTitleCase } from '@zapier/kitcore';
 import { ConnectionItemSchema as ConnectionItemSchema$1, ConnectionSchema, ConnectionsResponseSchema, ListConnectionsQuerySchema as ListConnectionsQuerySchema$1 } from '@zapier/zapier-sdk-core/v0/schemas/connections';
 import { buildHttpRequestContext, buildActionRunContext } from '@zapier/policy-context';
 import { ListAppsQuerySchema, AppItemSchema as AppItemSchema$1 } from '@zapier/zapier-sdk-core/v0/schemas/apps';
@@ -1241,15 +1241,12 @@ var { logDeprecation, resetDeprecationWarnings } = createDeprecationLogger("zapi
 var { logStabilityNotice, resetStabilityNotices } = createStabilityNoticeLogger("zapier-sdk");
 
 // src/utils/url-utils.ts
-function withSearchParams({
-  url,
-  searchParams
-}) {
-  const result = new URL(url);
-  for (const [key, value] of Object.entries(searchParams ?? {})) {
-    result.searchParams.set(key, value);
+function validateSdkPath(path) {
+  if (!path.startsWith("/") || path.startsWith("//")) {
+    throw new ZapierValidationError(
+      `fetch expects a path starting with a single '/', got: ${path}`
+    );
   }
-  return result.toString();
 }
 function getZapierBaseUrl(baseUrl) {
   if (!baseUrl) {
@@ -2069,58 +2066,6 @@ function parseApprovalReviewStreamPayload(parsed, toolNames) {
     }
   }
 }
-
-// src/api/deprecation.ts
-var DEPRECATION_MESSAGE_HEADER = "zapier-sdk-deprecation-message";
-var DEPRECATION_ID_HEADER = "zapier-sdk-deprecation-id";
-var DEPRECATION_NOTICE_EVENT = "api:deprecation_notice";
-var displayedNoticeIds = /* @__PURE__ */ new Set();
-function handleDeprecationNotice({
-  response,
-  canSendDeprecationMessaging,
-  onEvent
-}) {
-  try {
-    sniffDeprecationNotice({ response, canSendDeprecationMessaging, onEvent });
-  } catch {
-  }
-}
-function sniffDeprecationNotice({
-  response,
-  canSendDeprecationMessaging,
-  onEvent
-}) {
-  if (!canSendDeprecationMessaging) return;
-  const message = response.headers?.get(DEPRECATION_MESSAGE_HEADER);
-  if (!message) return;
-  const id = response.headers.get(DEPRECATION_ID_HEADER) ?? message;
-  if (!displayedNoticeIds.has(id)) {
-    displayedNoticeIds.add(id);
-    console.warn(`[zapier-sdk] Deprecation: ${message}`);
-  }
-  if (onEvent) {
-    const payload = { id, message };
-    const deprecation = parseDeprecationDate(
-      response.headers.get("deprecation")
-    );
-    if (deprecation !== void 0) payload.deprecation = deprecation;
-    const maybePromise = onEvent({
-      type: DEPRECATION_NOTICE_EVENT,
-      payload: { ...payload },
-      timestamp: Date.now()
-    });
-    if (isPromiseLike(maybePromise)) {
-      void Promise.resolve(maybePromise).catch(() => {
-      });
-    }
-  }
-}
-function parseDeprecationDate(value) {
-  if (!value) return void 0;
-  const match = /^@(-?\d+)$/.exec(value.trim());
-  if (!match) return void 0;
-  return Number(match[1]) * 1e3;
-}
 var RELAY_ERROR_HEADER = "x-relay-error";
 var RELAY_TIMEOUT_HEADER = "x-relay-extended-timeout";
 var SDK_CORRELATION_HEADER = "zapier-correlation-id";
@@ -2451,36 +2396,14 @@ function buildRouteOverrideMap({
   }
   return routeOverrideMap;
 }
-function collectRouteOverrideSources({
-  routingOptions,
-  environment,
-  routingConfig: routingConfig2
-}) {
-  try {
-    const optionEntries = routingOptions?.routeOverrideEntries ?? [];
-    const environmentEntries = readEnvironmentRouteOverrideEntries({
-      environment,
-      routingConfig: routingConfig2
-    });
-    if (optionEntries.length === 0 && environmentEntries.length === 0) {
-      return void 0;
-    }
-    return { optionEntries, environmentEntries };
-  } catch (error) {
-    if (isZapierError(error) && error.code === "ZAPIER_CONFIGURATION_ERROR") {
-      throw error;
-    }
-    return void 0;
-  }
-}
 function findRouteOverrideMatch({
   path,
-  routeOverrideMap,
+  routeOverrideEntries,
   routingConfig: routingConfig2
 }) {
   let bestMatch;
   const { pathname } = splitPathReference({ path });
-  for (const override of routeOverrideMap.values()) {
+  for (const override of routeOverrideEntries) {
     const { route } = override;
     for (const candidate of getRouteCandidates({
       route,
@@ -2524,16 +2447,18 @@ function deriveDirectPath({
   if (!pathPrefix) {
     return path;
   }
-  const remainingPath = path.slice(matchedPrefix.length) || "/";
+  const { pathname, search, hash } = splitPathReference({ path });
+  const remainingPath = pathname.slice(matchedPrefix.length) || "/";
   const override = routeConfig.override;
   const pathPrefixMode = override?.enabled === false ? "strip" : override?.pathPrefixMode ?? "strip";
-  return pathPrefixMode === "preserve" ? `${pathPrefix}${remainingPath}` : remainingPath;
+  const directPathname = pathPrefixMode === "preserve" ? `${pathPrefix}${remainingPath}` : remainingPath;
+  return `${directPathname}${search}${hash}`;
 }
 function readEnvironmentRouteOverrideEntries({
-  environment,
   routingConfig: routingConfig2
 }) {
   const entries = [];
+  const environment = globalThis.process?.env;
   if (!environment) {
     return entries;
   }
@@ -2797,33 +2722,52 @@ function parseRoutingOptions({
     });
   }
 }
+function withEnvironmentRouteOverrides({
+  routingOptions
+}) {
+  let environmentEntries;
+  try {
+    environmentEntries = readEnvironmentRouteOverrideEntries({ routingConfig });
+  } catch (error) {
+    if (isZapierError(error) && error.code === "ZAPIER_CONFIGURATION_ERROR") {
+      throw error;
+    }
+    return routingOptions;
+  }
+  if (environmentEntries.length === 0) {
+    return routingOptions;
+  }
+  const routeOverrideMap = buildRouteOverrideMap({
+    environmentEntries,
+    optionEntries: routingOptions.routeOverrideEntries
+  });
+  return { routeOverrideEntries: [...routeOverrideMap.values()] };
+}
 function resolveRoute({
   path,
   baseUrl,
   routingOptions = { routeOverrideEntries: [] },
-  environment,
   debugLog
 }) {
-  const overrideSources = collectRouteOverrideSources({
-    routingOptions,
-    environment,
-    routingConfig
-  });
-  if (!overrideSources) {
-    return resolveDefaultRoute({ path, baseUrl });
-  }
-  const routeOverrideMap = buildRouteOverrideMap(overrideSources);
   const overrideMatch = findRouteOverrideMatch({
     path,
-    routeOverrideMap,
+    routeOverrideEntries: routingOptions.routeOverrideEntries,
     routingConfig
   });
   if (overrideMatch) {
-    const resolved = resolveOverrideRoute({ overrideMatch, path });
-    logRouteOverride({ path, resolved, overrideMatch, debugLog });
+    const resolved2 = resolveOverrideRoute({ overrideMatch, path });
+    logRouteOverride({ path, resolved: resolved2, overrideMatch, debugLog });
+    return resolved2;
+  }
+  const { pathname, search, hash } = splitPathReference({ path });
+  const resolved = resolveDefaultRoute({ path: pathname, baseUrl });
+  if (!search && !hash) {
     return resolved;
   }
-  return resolveDefaultRoute({ path, baseUrl });
+  const url = new URL(resolved.url);
+  url.search = search;
+  url.hash = hash;
+  return { ...resolved, url };
 }
 function logRouteOverride({
   path,
@@ -2842,7 +2786,7 @@ function logRouteOverride({
 }
 
 // src/sdk-version.ts
-var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.122.2" : void 0) || "unknown";
+var SDK_VERSION = (typeof process !== "undefined" && process.env ? "0.124.0" : void 0) || "unknown";
 
 // src/utils/open-url.ts
 var nodePrefix = "node:";
@@ -2969,24 +2913,37 @@ var PollApprovalResponseSchema = z.object({
   approval_url: z.string().optional()
 });
 var APPROVAL_MAX_POLLING_INTERVAL_MILLISECONDS = 5e3;
-function validateSdkPath(path) {
-  if (!path.startsWith("/") || path.startsWith("//")) {
-    throw new ZapierValidationError(
-      `fetch expects a path starting with a single '/', got: ${path}`
-    );
+function mergeSearchParams({
+  path,
+  searchParams
+}) {
+  const { pathname, search, hash } = splitPathReference({ path });
+  if (!searchParams || Object.keys(searchParams).length === 0) {
+    return `${pathname}${search}${hash}`;
+  }
+  const query = new URLSearchParams(search);
+  for (const [key, value] of Object.entries(searchParams)) {
+    query.set(key, value);
   }
+  const queryString = query.toString();
+  return `${pathname}${queryString ? `?${queryString}` : ""}${hash}`;
 }
 var ZapierApiClient = class {
   constructor(options) {
     this.options = options;
     /**
-     * Perform a request against an already-resolved URL.
+     * Perform a request given a destination: either an already
+     * resolved absolute URL, or a Zapier logical path (plus its query string,
+     * since there is no separate `searchParams` slot once a request enters the
+     * pipeline). `zapierRouteHttpRequestPlugin`'s `prepareHttpRequest` wrap
+     * resolves a logical path against `pathConfig` before dispatch; an
+     * absolute URL passes through that wrap untouched.
      *
      * Does auth and header merging, and converts a terminal 429 into
      * `ZapierRateLimitError` — the cross-cutting concerns that every
      * Zapier-bound HTTP call needs and that the transport does not own. Callers
      * that have a path (e.g. `/relay/...`) should use `rawFetch` instead, which
-     * does path → URL resolution and delegates here.
+     * merges `searchParams` into the path and delegates here.
      *
      * Exposed as a separate helper so call sites with a server-supplied
      * absolute URL (e.g. an approval poll URL) can still share the same
@@ -3102,10 +3059,13 @@ var ZapierApiClient = class {
      */
     this.rawFetch = async (path, init) => {
       validateSdkPath(path);
-      const { url, resolvedRoute } = this.buildUrl(path, init?.searchParams);
+      const { url, resolvedRoute, requestPath } = this.buildUrl(
+        path,
+        init?.searchParams
+      );
       return this.withSemaphore(
         { url, method: init?.method ?? "GET", signal: init?.signal },
-        () => this.rawFetchUrl(url, init, resolvedRoute)
+        () => this.rawFetchUrl(requestPath, init, resolvedRoute)
       );
     };
     this.runApprovalFetchLoop = async ({
@@ -3210,10 +3170,6 @@ var ZapierApiClient = class {
     this.fetch = async (path, init) => {
       validateSdkPath(path);
       const maxRetries = this.options.maxApprovalRetries ?? DEFAULT_MAX_APPROVAL_RETRIES;
-      const { canSendDeprecationMessaging } = this.buildUrl(
-        path,
-        init?.searchParams
-      );
       const approvalMode = this.options.approvalMode ?? getZapierApprovalMode() ?? getZapierDefaultApprovalMode();
       const approvalContext = init?.approvalContext;
       const { response, approvalRoundError } = await this.runApprovalFetchLoop({
@@ -3223,11 +3179,6 @@ var ZapierApiClient = class {
         approvalMode,
         approvalContext
       });
-      handleDeprecationNotice({
-        response,
-        canSendDeprecationMessaging,
-        onEvent: this.options.onEvent
-      });
       if (response.status !== 403) {
         return response;
       }
@@ -3536,23 +3487,28 @@ var ZapierApiClient = class {
       return { message: fallbackMessage };
     }
   }
-  // Apply any special routing logic for configured paths.
-  applyPathConfiguration(path) {
-    return resolveRoute({
-      path,
+  /**
+   * Build the path `rawFetch` hands the pipeline, alongside the route it
+   * resolves to. The resolution is the client's own: it supplies the
+   * auth-header name, the Relay header transforms, and the URL the
+   * concurrency events report. The transport resolves the same path
+   * independently to pick the destination, so both go through `resolveRoute`
+   * with the same overrides — a path that routed one way here and another way
+   * there would authenticate against the wrong host.
+   *
+   * No `debugLog`: the transport's resolution logs the override decision.
+   * Passing one here would print every route override twice.
+   */
+  buildUrl(path, searchParams) {
+    const requestPath = mergeSearchParams({ path, searchParams });
+    const resolvedRoute = resolveRoute({
+      path: requestPath,
       baseUrl: this.options.baseUrl,
-      routingOptions: this.options.routingOptions,
-      environment: globalThis.process?.env,
-      debugLog: this.options.debugLog
+      routingOptions: withEnvironmentRouteOverrides({
+        routingOptions: this.options.routingOptions
+      })
     });
-  }
-  buildUrl(path, searchParams) {
-    const resolvedRoute = this.applyPathConfiguration(path);
-    return {
-      url: withSearchParams({ url: resolvedRoute.url, searchParams }),
-      resolvedRoute,
-      canSendDeprecationMessaging: resolvedRoute.canSendDeprecationMessaging
-    };
+    return { url: resolvedRoute.url.toString(), resolvedRoute, requestPath };
   }
   // Helper to build headers
   async buildHeaders(options = {}, pathConfig2) {
@@ -4192,9 +4148,124 @@ function resolveApprovalTimeoutMilliseconds({
   }
   return sdkOptions?.approvalTimeoutMs;
 }
-var SDK_OPTIONS_ID = "zapier/sdkOptions";
-var sdkOptionsPluginRef = declareOptionalProperty({
-  id: SDK_OPTIONS_ID
+var sdkOptionsPluginRef = declareOptionalProperty({ id: "zapier/sdkOptions" });
+var SDK_OPTIONS_ID = sdkOptionsPluginRef.id;
+
+// src/api/deprecation.ts
+var DEPRECATION_MESSAGE_HEADER = "zapier-sdk-deprecation-message";
+var DEPRECATION_ID_HEADER = "zapier-sdk-deprecation-id";
+var DEPRECATION_NOTICE_EVENT = "api:deprecation_notice";
+var displayedNoticeIds = /* @__PURE__ */ new Set();
+function handleDeprecationNotice({
+  response,
+  canSendDeprecationMessaging,
+  onEvent
+}) {
+  try {
+    sniffDeprecationNotice({ response, canSendDeprecationMessaging, onEvent });
+  } catch {
+  }
+}
+function sniffDeprecationNotice({
+  response,
+  canSendDeprecationMessaging,
+  onEvent
+}) {
+  if (!canSendDeprecationMessaging) return;
+  const message = response.headers?.get(DEPRECATION_MESSAGE_HEADER);
+  if (!message) return;
+  const id = response.headers.get(DEPRECATION_ID_HEADER) ?? message;
+  if (!displayedNoticeIds.has(id)) {
+    displayedNoticeIds.add(id);
+    console.warn(`[zapier-sdk] Deprecation: ${message}`);
+  }
+  if (onEvent) {
+    const payload = { id, message };
+    const deprecation = parseDeprecationDate(
+      response.headers.get("deprecation")
+    );
+    if (deprecation !== void 0) payload.deprecation = deprecation;
+    const maybePromise = onEvent({
+      type: DEPRECATION_NOTICE_EVENT,
+      payload: { ...payload },
+      timestamp: Date.now()
+    });
+    if (isPromiseLike(maybePromise)) {
+      void Promise.resolve(maybePromise).catch(() => {
+      });
+    }
+  }
+}
+function parseDeprecationDate(value) {
+  if (!value) return void 0;
+  const match = /^@(-?\d+)$/.exec(value.trim());
+  if (!match) return void 0;
+  return Number(match[1]) * 1e3;
+}
+var ZAPIER_RESOLVED_ROUTE_STATE = Symbol("zapierResolvedRoute");
+function isAbsoluteUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var zapierRouteHttpRequestPlugin = defineHook({
+  name: "routeHttpRequest",
+  namespace: "zapier",
+  imports: [prepareHttpRequestPlugin, sdkOptionsPluginRef],
+  setup: ({ imports }) => {
+    const sdkOptions = imports.sdkOptions ?? {};
+    return {
+      baseUrl: sdkOptions.baseUrl ?? ZAPIER_BASE_URL,
+      routingOptions: parseRoutingOptions({ options: sdkOptions }),
+      debugLog: createDebugLogger(sdkOptions.debug ?? false)
+    };
+  },
+  wrap: {
+    prepareHttpRequest: ({ input, state, next }) => {
+      const { url } = input.request;
+      if (isAbsoluteUrl(url)) {
+        return next(input);
+      }
+      validateSdkPath(url);
+      const resolvedRoute = resolveRoute({
+        path: url,
+        baseUrl: state.baseUrl,
+        routingOptions: withEnvironmentRouteOverrides({
+          routingOptions: state.routingOptions
+        }),
+        debugLog: state.debugLog
+      });
+      input.attempt.state[ZAPIER_RESOLVED_ROUTE_STATE] = resolvedRoute;
+      return next({
+        ...input,
+        request: { ...input.request, url: resolvedRoute.url.toString() }
+      });
+    }
+  }
+});
+
+// src/plugins/transport/deprecation.ts
+var zapierDeprecationHttpResponsePlugin = defineHook({
+  name: "deprecationHttpResponse",
+  namespace: "zapier",
+  imports: [receiveHttpResponsePlugin, sdkOptionsPluginRef],
+  wrap: {
+    receiveHttpResponse: async ({ input, imports, next }) => {
+      const resolvedRoute = input.attempt.state[ZAPIER_RESOLVED_ROUTE_STATE];
+      const response = await next(input);
+      if (resolvedRoute) {
+        handleDeprecationNotice({
+          response,
+          canSendDeprecationMessaging: resolvedRoute.canSendDeprecationMessaging,
+          onEvent: imports.sdkOptions?.onEvent
+        });
+      }
+      return response;
+    }
+  }
 });
 
 // src/plugins/transport/options.ts
@@ -4260,16 +4331,18 @@ var zapierHttpTransportPlugin = definePlugin({
     sendHttpRequestPlugin,
     retryHttpRequestPlugin,
     retryHttpRequestOptionsPlugin,
-    httpFetchPlugin
+    httpFetchPlugin,
+    zapierRouteHttpRequestPlugin,
+    zapierDeprecationHttpResponsePlugin
   ],
   exports: [sendHttpRequestPlugin]
 });
 
 // src/plugins/api/index.ts
-var API_ID = "zapier/api";
 var apiPluginRef = declareProperty({
-  id: API_ID
+  id: "zapier/api"
 });
+var API_ID = apiPluginRef.id;
 function withCorrelationId({
   client,
   callId
@@ -4345,8 +4418,8 @@ var apiPlugin = defineProperty({
   },
   get: ({ state, callContext }) => callContext?.callId ? withCorrelationId({ client: state, callId: callContext.callId }) : state
 });
-var RESOLVE_CREDENTIALS_ID = "zapier/resolveCredentials";
-var resolveCredentialsPluginRef = declareProperty({ id: RESOLVE_CREDENTIALS_ID });
+var resolveCredentialsPluginRef = declareProperty({ id: "zapier/resolveCredentials" });
+var RESOLVE_CREDENTIALS_ID = resolveCredentialsPluginRef.id;
 var resolveCredentialsPlugin = defineProperty({
   namespace: "zapier",
   name: "resolveCredentials",
@@ -5035,8 +5108,8 @@ async function resolveAppKeys({
   });
   return slugResolvedLocators.filter(isResolvedAppLocator);
 }
-var MANIFEST_ID = "zapier/manifest";
-var manifestPluginRef = declareProperty({ id: MANIFEST_ID });
+var manifestPluginRef = declareProperty({ id: "zapier/manifest" });
+var MANIFEST_ID = manifestPluginRef.id;
 var manifestPlugin = defineProperty({
   namespace: "zapier",
   name: "manifest",
@@ -5163,8 +5236,8 @@ var manifestPlugin = defineProperty({
 });
 
 // src/plugins/connections/index.ts
-var CONNECTIONS_ID = "zapier/connections";
-var connectionsPluginRef = declareProperty({ id: CONNECTIONS_ID });
+var connectionsPluginRef = declareProperty({ id: "zapier/connections" });
+var CONNECTIONS_ID = connectionsPluginRef.id;
 var connectionsPlugin = defineProperty({
   namespace: "zapier",
   name: "connections",
@@ -9486,6 +9559,9 @@ var zapierCoreOptions = {
     );
   }
 };
+var zapierCoreOptionsPlugin = declareDefault({
+  plugin: defineProperty(coreOptionsPluginRef, { value: zapierCoreOptions })
+});
 var GetConnectionStartUrlSchema = z.object({
   app: AppPropertySchema
 }).describe(
@@ -11124,21 +11200,17 @@ var apiClientRootPlugin = definePlugin({
   imports: [apiPlugin],
   exports: []
 });
-function hasStringUrl(request) {
-  return typeof request.url === "string";
-}
-function createApiClientGraphConfiguration(options) {
+function splitApiClientOptions(options) {
   const {
     maxNetworkRetryDelayMilliseconds,
     maxNetworkRetryDelayMs,
     approvalTimeoutMilliseconds,
     approvalTimeoutMs,
-    sendHttpRequest: _sendHttpRequest,
     ...sdkOptions
   } = options;
   return {
-    [SDK_OPTIONS_ID]: sdkOptions,
-    [API_CLIENT_DURATIONS_ID]: {
+    sdkOptions,
+    durations: {
       maxNetworkRetryDelayMilliseconds: maxNetworkRetryDelayMilliseconds ?? maxNetworkRetryDelayMs,
       approvalTimeoutMilliseconds: approvalTimeoutMilliseconds ?? approvalTimeoutMs
     }
@@ -11146,39 +11218,13 @@ function createApiClientGraphConfiguration(options) {
 }
 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 { sdkOptions, durations } = splitApiClientOptions(options);
+  const sdk = createSdk(apiClientRootPlugin, {
+    imports: [
+      defineProperty(sdkOptionsPluginRef, { value: sdkOptions }),
+      defineProperty(apiClientDurationsPluginRef, { value: durations })
+    ]
   });
-  const sdk = createSdk(
-    definePlugin({
-      namespace: "zapier",
-      name: "standaloneApiClientRoot",
-      imports: [apiPlugin, replaceSendHttpRequestPlugin],
-      exports: []
-    }),
-    { configuration }
-  );
   return resolvePlugin(sdk, apiPluginRef);
 }
 
@@ -13220,8 +13266,8 @@ function createEventEmitter(options) {
     };
   }
 }
-var EVENT_EMISSION_ID = "zapier/eventEmission";
-var eventEmissionPluginRef = declareProperty({ id: EVENT_EMISSION_ID });
+var eventEmissionPluginRef = declareProperty({ id: "zapier/eventEmission" });
+var EVENT_EMISSION_ID = eventEmissionPluginRef.id;
 var eventEmissionPlugin = defineProperty({
   namespace: "zapier",
   name: "eventEmission",
@@ -13263,12 +13309,14 @@ var zapierSdkPlugin = definePlugin({
   name: "sdk",
   // Foundation providers are internal imports (not surfaced exports): module
   // plugins resolve `apiPluginRef` etc. to them; each BUILDS its value from
-  // the injected options (and sibling providers). `sdkOptions` has no
-  // provider: importing the stand-in declares the configurable id, and each
-  // factory injects the caller's options under it via `createSdk`'s
-  // `configuration`.
+  // the provided options (and sibling providers). `sdkOptions` has no
+  // provider here: importing the stand-in declares the configurable id, and
+  // each factory provides the caller's options in `createSdk`'s `imports`
+  // with `defineProperty(sdkOptionsPluginRef, { value })`. Core options have a
+  // default provider that a factory can outrank with its own.
   imports: [
     sdkOptionsPluginRef,
+    zapierCoreOptionsPlugin,
     apiPlugin,
     resolveCredentialsPlugin,
     manifestPlugin,
@@ -13355,10 +13403,7 @@ var zapierSdkPlugin = definePlugin({
 });
 function createZapierSdk(options = {}) {
   return createSdk(zapierSdkPlugin, {
-    configuration: {
-      [SDK_OPTIONS_ID]: options,
-      [CORE_OPTIONS_ID]: zapierCoreOptions
-    }
+    imports: [defineProperty(sdkOptionsPluginRef, { value: options })]
   });
 }