@zapier/zapier-sdk 0.8.2 → 0.9.0

package/dist/index.cjs

@@ -1,8 +1,7 @@
 'use strict';
 
 var zod = require('zod');
-var fs = require('fs');
-var path = require('path');
+var promises = require('timers/promises');
 
 // src/types/properties.ts
 function withFormatter(schema, formatMeta) {
@@ -653,16 +652,6 @@ function splitVersionedKey(versionedKey) {
   }
   return [versionedKey, void 0];
 }
-function normalizeImplementationToAppItem(implementation) {
-  const [selectedApi, appVersion] = implementation.selected_api ? splitVersionedKey(implementation.selected_api) : [implementation.selected_api || "", void 0];
-  return {
-    title: implementation.name || selectedApi,
-    key: selectedApi,
-    current_implementation_id: implementation.selected_api || "",
-    version: appVersion
-    // Extract version separately
-  };
-}
 function normalizeImplementationMetaToAppItem(implementationMeta) {
   const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
   return {
@@ -724,50 +713,8 @@ function normalizeActionItem(action) {
     type: "action"
   };
 }
-function groupVersionedAppKeysByType(appKeys) {
-  const result = {
-    selectedApi: [],
-    slug: []
-  };
-  const seenSelectedApi = /* @__PURE__ */ new Set();
-  const seenSlugs = /* @__PURE__ */ new Set();
-  for (const key of appKeys) {
-    const [keyWithoutVersion, version] = splitVersionedKey(key);
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    if (uuidRegex.test(keyWithoutVersion)) {
-      throw new Error(
-        `UUID app keys are not supported. Use app slug or implementation ID instead of: ${key}`
-      );
-    }
-    if (isSnakeCasedSlug(keyWithoutVersion)) {
-      const dashified = dashifySnakeCasedSlug(keyWithoutVersion);
-      const slugWithVersion = version ? `${dashified}@${version}` : dashified;
-      if (!seenSlugs.has(slugWithVersion)) {
-        seenSlugs.add(slugWithVersion);
-        result.slug.push(slugWithVersion);
-      }
-      continue;
-    }
-    if (keyWithoutVersion.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/)) {
-      seenSlugs.add(key);
-      result.slug.push(key);
-      continue;
-    }
-    if (!seenSelectedApi.has(key)) {
-      seenSelectedApi.add(key);
-      result.selectedApi.push(key);
-    }
-  }
-  return result;
-}
-function groupAppKeysByType(appKeys) {
-  const grouped = groupVersionedAppKeysByType(appKeys);
-  return {
-    selectedApi: [
-      ...new Set(grouped.selectedApi.map((key) => key.split("@")[0]))
-    ],
-    slug: [...new Set(grouped.slug.map((key) => key.split("@")[0]))]
-  };
+function isSlug(slug) {
+  return !!slug.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
 }
 function isSnakeCasedSlug(slug) {
   if (slug.match(/^_[0-9]/)) {
@@ -784,15 +731,54 @@ function dashifySnakeCasedSlug(slug) {
   }
   return slug.replace(/_/g, "-");
 }
+function isUuid(appKey) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+    appKey
+  );
+}
+function toAppLocator(appKey) {
+  const [appKeyWithoutVersion, version] = splitVersionedKey(appKey);
+  if (isUuid(appKeyWithoutVersion)) {
+    throw new Error(
+      `UUID app keys are not supported. Use app slug or implementation ID instead of: ${appKey}`
+    );
+  }
+  const slug = isSlug(appKeyWithoutVersion) ? appKeyWithoutVersion : isSnakeCasedSlug(appKeyWithoutVersion) ? dashifySnakeCasedSlug(appKeyWithoutVersion) : void 0;
+  return {
+    lookupAppKey: appKeyWithoutVersion,
+    slug,
+    implementationName: slug ? void 0 : appKeyWithoutVersion,
+    version
+  };
+}
+function isResolvedAppLocator(appLocator) {
+  return !!appLocator.implementationName;
+}
+function toImplementationId(appLocator) {
+  return `${appLocator.implementationName}@${appLocator.version || "latest"}`;
+}
 
 // src/plugins/listApps/index.ts
 var listAppsPlugin = ({ context }) => {
   const listApps = createPaginatedFunction(async function listAppsPage(options) {
     const api = context.api;
     const opts = options;
-    const appKeys = [...opts.appKeys ?? []].map(
-      (key) => splitVersionedKey(key)[0]
-    );
+    const appLocators = await context.resolveAppKeys({
+      appKeys: [...opts.appKeys ?? []]
+    });
+    const implementationNameToLocator = {};
+    for (const locator of appLocators) {
+      implementationNameToLocator[locator.implementationName] = [
+        ...implementationNameToLocator[locator.implementationName] ?? [],
+        locator
+      ];
+    }
+    const duplicatedLookupAppKeys = Object.keys(implementationNameToLocator).filter((key) => implementationNameToLocator[key].length > 1).map((key) => implementationNameToLocator[key]).flat().map((locator) => locator.lookupAppKey);
+    if (duplicatedLookupAppKeys.length > 0) {
+      throw new Error(
+        `Duplicate lookup app keys found: ${duplicatedLookupAppKeys.join(", ")}`
+      );
+    }
     if (opts.search) {
       const searchParams2 = {};
       searchParams2.term = opts.search;
@@ -805,11 +791,17 @@ var listAppsPlugin = ({ context }) => {
       const implementations = searchEnvelope.results.map(
         normalizeImplementationMetaToAppItem
       );
-      const appKeysSet = new Set(appKeys);
+      const implementationNameSet = new Set(
+        appLocators.map((locator) => locator.implementationName)
+      );
       for (const implementation of implementations) {
-        if (!appKeysSet.has(implementation.key)) {
-          appKeysSet.add(implementation.key);
-          appKeys.push(implementation.key);
+        const [implementationName] = splitVersionedKey(implementation.key);
+        if (!implementationNameSet.has(implementationName)) {
+          implementationNameSet.add(implementationName);
+          appLocators.push({
+            ...toAppLocator(implementation.key),
+            implementationName
+          });
         }
       }
     }
@@ -817,19 +809,13 @@ var listAppsPlugin = ({ context }) => {
     if (opts.pageSize) {
       searchParams.limit = opts.pageSize.toString();
     }
-    searchParams.latest_only = "true";
+    if (appLocators.length === 0) {
+      searchParams.latest_only = "true";
+    }
     if (opts.cursor) {
       searchParams.offset = opts.cursor;
     }
-    if (appKeys.length > 0) {
-      const groupedAppKeys = groupAppKeysByType(appKeys);
-      if (groupedAppKeys.selectedApi.length > 0) {
-        searchParams.selected_apis = groupedAppKeys.selectedApi.join(",");
-      }
-      if (groupedAppKeys.slug.length > 0) {
-        searchParams.slugs = groupedAppKeys.slug.join(",");
-      }
-    }
+    searchParams.selected_apis = appLocators.map((locator) => toImplementationId(locator)).join(",");
     const implementationsEnvelope = await api.get(
       "/api/v4/implementations-meta/lookup/",
       {
@@ -1476,6 +1462,7 @@ var ListAuthenticationsSchema = zod.z.object({
   appKey: AppKeyPropertySchema.optional().describe(
     "App key of authentications to list (e.g., 'SlackCLIAPI')"
   ),
+  authenticationIds: zod.z.array(zod.z.string()).optional().describe("List of authentication IDs to filter by"),
   search: zod.z.string().optional().describe("Search term to filter authentications by title"),
   title: zod.z.string().optional().describe("Filter authentications by exact title match"),
   accountId: zod.z.string().optional().describe("Filter by account ID"),
@@ -1499,6 +1486,9 @@ var listAuthenticationsPlugin = ({ context }) => {
           searchParams.versionless_selected_api = versionlessSelectedApi;
         }
       }
+      if (options.authenticationIds && options.authenticationIds.length > 0) {
+        searchParams.ids = options.authenticationIds.join(",");
+      }
       if (options.search) {
         searchParams.search = options.search;
       } else if (options.title) {
@@ -1571,17 +1561,17 @@ var GetAppSchema = withOutputSchema(
 );
 
 // src/plugins/getApp/index.ts
-var getAppPlugin = ({ context }) => {
+var getAppPlugin = ({ sdk }) => {
   const getApp = createFunction(async function getApp2(options) {
-    const app = await context.getImplementation(options.appKey);
-    if (!app) {
-      throw new ZapierAppNotFoundError("App not found", {
-        appKey: options.appKey
-      });
+    const appsIterator = sdk.listApps({ appKeys: [options.appKey] }).items();
+    for await (const app of appsIterator) {
+      return {
+        data: app
+      };
     }
-    return {
-      data: app
-    };
+    throw new ZapierAppNotFoundError("App not found", {
+      appKey: options.appKey
+    });
   }, GetAppSchema);
   return {
     getApp,
@@ -1947,6 +1937,67 @@ var requestPlugin = ({ context }) => {
     }
   };
 };
+
+// src/utils/file-utils.ts
+var inMemoryFiles = {};
+var fsPromises = null;
+var pathModule = null;
+async function loadFsPromises() {
+  if (fsPromises) return fsPromises;
+  try {
+    fsPromises = await import('fs/promises');
+    return fsPromises;
+  } catch {
+    return null;
+  }
+}
+async function loadPathModule() {
+  if (pathModule) return pathModule;
+  try {
+    pathModule = await import('path');
+    return pathModule;
+  } catch {
+    return null;
+  }
+}
+async function resolve(path, basePath = "/") {
+  const pathModule2 = await loadPathModule();
+  if (pathModule2) {
+    return pathModule2.resolve(path);
+  }
+  if (path.startsWith("/")) {
+    return path;
+  }
+  if (path.startsWith("./")) {
+    const cleanPath = path.slice(2);
+    return basePath.endsWith("/") ? basePath + cleanPath : basePath + "/" + cleanPath;
+  }
+  if (path.startsWith("../")) {
+    const cleanPath = path.replace(/^(\.\.\/)+/, "");
+    return basePath.endsWith("/") ? basePath + cleanPath : basePath + "/" + cleanPath;
+  }
+  return basePath.endsWith("/") ? basePath + path : basePath + "/" + path;
+}
+async function writeFile(filePath, content) {
+  const fs = await loadFsPromises();
+  if (fs) {
+    await fs.writeFile(filePath, content, "utf8");
+    return;
+  }
+  inMemoryFiles[filePath] = content;
+}
+async function readFile(filePath) {
+  const fs = await loadFsPromises();
+  if (fs) {
+    return await fs.readFile(filePath, "utf8");
+  }
+  const content = inMemoryFiles[filePath];
+  if (content !== void 0) {
+    return content;
+  }
+  throw new Error(`File not found: ${filePath}`);
+}
+var DEFAULT_CONFIG_PATH = ".zapierrc";
 var ManifestSchema = zod.z.object({
   apps: zod.z.record(
     zod.z.string(),
@@ -1969,6 +2020,15 @@ zod.z.object({
   ).optional().describe("Direct manifest object")
 });
 
+// src/utils/array-utils.ts
+async function toArrayFromAsync(asyncIterable) {
+  const result = [];
+  for await (const item of asyncIterable) {
+    result.push(item);
+  }
+  return result;
+}
+
 // src/plugins/manifest/index.ts
 function parseManifestContent(content, source) {
   try {
@@ -1986,169 +2046,235 @@ function parseManifestContent(content, source) {
     return null;
   }
 }
-function loadManifestFromFile(filePath) {
+async function readManifestFromFile(filePath) {
   try {
-    const resolvedPath = path.resolve(filePath);
-    const content = fs.readFileSync(resolvedPath, "utf8");
+    const resolvedPath = await resolve(filePath);
+    const content = await readFile(resolvedPath);
     return parseManifestContent(content, resolvedPath);
   } catch {
-    console.warn(`\u26A0\uFE0F Failed to load manifest from ${filePath}`);
+    console.warn(`\u26A0\uFE0F Failed to read manifest from ${filePath}`);
     return null;
   }
 }
-var emitWarning = (appKey) => {
-  console.warn(
-    `
-${"\u26A0\uFE0F".padEnd(3)} ${"WARNING".padEnd(8)} No manifest version found for '${appKey}'`
-  );
-  console.warn(
-    `   ${"\u21B3".padEnd(3)} Using a manifest ensures version locking and prevents unexpected behavior due to version changes.`
+async function writeManifestToFile(manifest, filePath) {
+  const resolvedPath = await resolve(filePath);
+  await writeFile(resolvedPath, JSON.stringify(manifest, null, 2));
+}
+async function getPreferredManifestEntryKey({
+  appKey,
+  api
+}) {
+  const locator = toAppLocator(appKey);
+  if (locator.slug) {
+    return locator.slug;
+  }
+  if (locator.implementationName) {
+    try {
+      const implementationsEnvelope = await api.get(`/api/v4/implementations-meta/lookup/`, {
+        searchParams: {
+          selected_apis: locator.implementationName
+        }
+      });
+      if (implementationsEnvelope.results.length > 0 && implementationsEnvelope.results[0].slug) {
+        return implementationsEnvelope.results[0].slug;
+      }
+    } catch {
+    }
+    return locator.implementationName;
+  }
+  return locator.lookupAppKey;
+}
+async function listAppsForSlugsPage({
+  slugs,
+  cursor,
+  api
+}) {
+  const searchParams = {};
+  if (slugs.length > 0) {
+    searchParams.slugs = slugs.join(",");
+  }
+  if (cursor) {
+    searchParams.offset = cursor;
+  }
+  const implementationsEnvelope = await api.get(
+    "/api/v4/implementations-meta/lookup/",
+    {
+      searchParams
+    }
   );
-  console.warn(
-    `   ${"\u21B3".padEnd(3)} Generate/update the manifest with: \`zapier-sdk lock-version ${appKey}\`
-`
+  return {
+    data: implementationsEnvelope.results.map(
+      normalizeImplementationMetaToAppItem
+    ),
+    nextCursor: extractCursor(implementationsEnvelope)
+  };
+}
+function findManifestEntry({
+  appKey,
+  manifest
+}) {
+  const [appKeyWithoutVersion] = splitVersionedKey(appKey);
+  if (manifest.apps[appKeyWithoutVersion]) {
+    return [appKeyWithoutVersion, manifest.apps[appKeyWithoutVersion]];
+  }
+  if (isSnakeCasedSlug(appKey)) {
+    const slug = dashifySnakeCasedSlug(appKey);
+    if (manifest.apps[slug]) {
+      return [slug, manifest.apps[slug]];
+    }
+  }
+  for (const [key, entry] of Object.entries(manifest.apps)) {
+    if (entry.implementationName === appKeyWithoutVersion) {
+      return [key, entry];
+    }
+  }
+  return null;
+}
+async function resolveAppKeys({
+  appKeys,
+  api,
+  manifest
+}) {
+  const locators = appKeys.map(toAppLocator);
+  const locatorsWithManifest = locators.map((locator) => {
+    const manifestEntryResult = findManifestEntry({
+      appKey: locator.lookupAppKey,
+      manifest
+    });
+    if (manifestEntryResult) {
+      const [, manifestEntry] = manifestEntryResult;
+      const resolvedVersion = locator.version || manifestEntry.version;
+      const resolvedLocator = {
+        ...locator,
+        implementationName: manifestEntry.implementationName,
+        version: resolvedVersion
+      };
+      return resolvedLocator;
+    }
+    return locator;
+  });
+  const unresolvedLocators = locatorsWithManifest.filter(
+    (locator) => !isResolvedAppLocator(locator)
   );
-};
+  const slugsToResolve = unresolvedLocators.map((locator) => locator.slug).filter((slug) => !!slug).filter((slug, index, array) => array.indexOf(slug) === index);
+  if (slugsToResolve.length === 0) {
+    return locatorsWithManifest.filter(isResolvedAppLocator);
+  }
+  const iterator = paginate(listAppsForSlugsPage, {
+    slugs: slugsToResolve,
+    api
+  });
+  const pages = await toArrayFromAsync(iterator);
+  const apps = pages.flatMap((page) => page.data);
+  const slugToAppData = /* @__PURE__ */ new Map();
+  for (const app of apps) {
+    if (app.slug) {
+      slugToAppData.set(app.slug, app);
+    }
+  }
+  const slugResolvedLocators = locatorsWithManifest.map((locator) => {
+    if (isResolvedAppLocator(locator)) {
+      return locator;
+    }
+    if (locator.slug) {
+      const appData = slugToAppData.get(locator.slug);
+      if (appData) {
+        const manifestEntryByImplementationName = findManifestEntry({
+          appKey: appData.key,
+          // appData.key is the implementation name
+          manifest
+        });
+        let version = locator.version;
+        if (!version) {
+          version = manifestEntryByImplementationName ? manifestEntryByImplementationName[1].version || appData.version : appData.version;
+        }
+        return {
+          ...locator,
+          implementationName: appData.key,
+          version
+        };
+      }
+    }
+    return locator;
+  });
+  return slugResolvedLocators.filter(isResolvedAppLocator);
+}
 var manifestPlugin = (params) => {
-  const { sdk, context } = params;
+  const { context } = params;
   const { api, options } = context;
-  const { manifestPath = ".zapierrc", manifest } = options || {};
+  const { manifestPath = DEFAULT_CONFIG_PATH, manifest } = options || {};
   let resolvedManifest;
-  function resolveManifest() {
+  async function resolveManifest() {
     if (manifest) {
       return manifest;
     }
     if (manifestPath) {
-      return loadManifestFromFile(manifestPath);
+      return await readManifestFromFile(manifestPath);
     }
     return null;
   }
-  const getResolvedManifest = () => {
+  const getResolvedManifest = async () => {
     if (typeof resolvedManifest === "undefined") {
-      resolvedManifest = resolveManifest() ?? null;
+      resolvedManifest = await resolveManifest() ?? null;
     }
     return resolvedManifest;
   };
-  const getManifestEntry = (appKey) => {
-    return getResolvedManifest()?.apps?.[appKey] || null;
+  const getVersionedImplementationId = async (appKey) => {
+    const resolvedApps = await resolveAppKeys({
+      appKeys: [appKey],
+      api,
+      manifest: await getResolvedManifest() ?? { apps: {} }
+    });
+    const resolvedApp = resolvedApps[0];
+    if (!resolvedApp) return null;
+    return `${resolvedApp.implementationName}@${resolvedApp.version || "latest"}`;
   };
-  const getImplementation = async (appKey) => {
-    let selectedApi = null;
-    const manifestImplementation = getResolvedManifest()?.apps?.[appKey];
-    const [versionlessAppKey, version] = splitVersionedKey(appKey);
-    if (version) {
-      selectedApi = `${versionlessAppKey}@${version}`;
-    } else if (manifestImplementation) {
-      selectedApi = `${manifestImplementation.implementationName}@${manifestImplementation.version || "latest"}`;
-    }
-    if (selectedApi) {
-      const searchParams = {
-        selected_apis: selectedApi
-      };
-      const implementationData = await api.get(
-        "/api/v4/implementations/",
-        {
-          searchParams
+  const updateManifestEntry = async (appKey, entry, configPath = DEFAULT_CONFIG_PATH) => {
+    const manifest2 = await readManifestFromFile(configPath) || { apps: {} };
+    let existingEntry = findManifestEntry({
+      appKey,
+      manifest: manifest2
+    });
+    if (!existingEntry) {
+      try {
+        const resolvedApps = await resolveAppKeys({
+          appKeys: [appKey],
+          api,
+          manifest: manifest2
+        });
+        if (resolvedApps.length > 0) {
+          const resolvedImplementationName = resolvedApps[0].implementationName;
+          existingEntry = findManifestEntry({
+            appKey: resolvedImplementationName,
+            manifest: manifest2
+          });
         }
-      );
-      const implementationResults = implementationData.results[0];
-      if (!implementationResults) return null;
-      return normalizeImplementationToAppItem(implementationResults);
-    }
-    emitWarning(appKey);
-    const appsIterator = sdk.listApps({ appKeys: [appKey] }).items();
-    const apps = [];
-    for await (const app2 of appsIterator) {
-      apps.push(app2);
-      break;
-    }
-    if (apps.length === 0) {
-      return null;
-    }
-    const app = apps[0];
-    return app;
-  };
-  const getVersionedImplementationId = async (appKey) => {
-    const manifestEntry = getManifestEntry(appKey);
-    if (manifestEntry) {
-      return `${manifestEntry.implementationName}@${manifestEntry.version || "latest"}`;
+      } catch {
+      }
     }
-    const implementation = await getImplementation(appKey);
-    if (!implementation) return null;
-    return implementation.current_implementation_id;
-  };
-  return {
-    context: {
-      getVersionedImplementationId,
-      getManifestEntry,
-      getImplementation
+    let manifestKey;
+    if (existingEntry) {
+      manifestKey = existingEntry[0];
+    } else {
+      manifestKey = await getPreferredManifestEntryKey({
+        appKey,
+        api
+      });
     }
+    manifest2.apps[manifestKey] = entry;
+    await writeManifestToFile(manifest2, configPath);
+    resolvedManifest = void 0;
+    return [manifestKey, entry];
   };
-};
-var LockVersionSchema = zod.z.object({
-  appKey: zod.z.string().describe("The app key to lock version for (e.g., 'slack', 'gmail')")
-});
-var lockVersionPlugin = ({ sdk }) => {
-  const lockVersion = createFunction(
-    async function lockVersion2(options) {
-      const { appKey, configPath = ".zapierrc" } = options;
-      const resolvedPath = path.resolve(configPath);
-      const appsIterator = sdk.listApps({ appKeys: [appKey] }).items();
-      const apps = [];
-      for await (const app2 of appsIterator) {
-        apps.push(app2);
-        break;
-      }
-      const app = apps[0];
-      const currentImplementationId = app.current_implementation_id;
-      const [implementationName, version] = currentImplementationId.split("@");
-      if (!implementationName || !version) {
-        throw new Error(
-          `Invalid implementation ID format: ${currentImplementationId}. Expected format: <implementationName>@<version>`
-        );
-      }
-      let config = { apps: {} };
-      if (fs.existsSync(resolvedPath)) {
-        try {
-          const configContent = fs.readFileSync(resolvedPath, "utf8");
-          config = JSON.parse(configContent);
-          if (!config.apps) {
-            config.apps = {};
-          }
-        } catch (error) {
-          console.warn(
-            `\u26A0\uFE0F Failed to parse existing config file, creating new one: ${error}`
-          );
-          config = { apps: {} };
-        }
-      }
-      config.apps[appKey] = {
-        implementationName,
-        version
-      };
-      fs.writeFileSync(resolvedPath, JSON.stringify(config, null, 2));
-      return {
-        data: {
-          ...app,
-          implementationName,
-          version
-        },
-        configPath: resolvedPath
-      };
-    },
-    LockVersionSchema.extend({
-      configPath: zod.z.string().optional().describe("Path to .zapierrc file (defaults to '.zapierrc')")
-    })
-  );
   return {
-    lockVersion,
     context: {
-      meta: {
-        lockVersion: {
-          categories: ["utility"],
-          inputSchema: LockVersionSchema
-        }
-      }
+      getVersionedImplementationId,
+      resolveAppKeys: async ({ appKeys }) => resolveAppKeys({
+        appKeys,
+        api,
+        manifest: await getResolvedManifest() ?? { apps: {} }
+      }),
+      updateManifestEntry
     }
   };
 };
@@ -2277,52 +2403,162 @@ function createDebugFetch(options) {
     }
   };
 }
-
-// src/api/polling.ts
+var DEFAULT_TIMEOUT_MS = 18e4;
+var DEFAULT_SUCCESS_STATUS = 200;
+var DEFAULT_PENDING_STATUS = 202;
+var DEFAULT_INITIAL_DELAY_MS = 50;
+var DEFAULT_MAX_POLLING_INTERVAL_MS = 1e4;
+var MAX_CONSECUTIVE_ERRORS = 3;
+var MAX_TIMEOUT_BUFFER_MS = 1e4;
+var BASE_ERROR_BACKOFF_MS = 1e3;
+var JITTER_FACTOR = 0.5;
+var DEFAULT_POLLING_STAGES = [
+  [125, 125],
+  // Up to 125ms: poll every 125ms
+  [375, 250],
+  // Up to 375ms: poll every 250ms
+  [875, 500],
+  // Up to 875ms: poll every 500ms
+  [1e4, 1e3],
+  // Up to 10s: poll every 1s
+  [3e4, 2500],
+  // Up to 30s: poll every 2.5s
+  [6e4, 5e3]
+  // Up to 60s: poll every 5s
+];
+var calculateWaitTime = (baseInterval, errorCount) => {
+  const jitter = Math.random() * JITTER_FACTOR * baseInterval;
+  const errorBackoff = Math.min(
+    BASE_ERROR_BACKOFF_MS * (errorCount / 2),
+    baseInterval * 2
+    // Cap error backoff at 2x the base interval
+  );
+  return Math.floor(baseInterval + jitter + errorBackoff);
+};
+var processResponse = async (response, successStatus, pendingStatus, resultExtractor, errorCount) => {
+  if (!response.ok) {
+    return {
+      status: "continue" /* Continue */,
+      // If for some reason the status is pending, we don't want to increment the error count
+      errorCount: response.status === pendingStatus ? errorCount : errorCount + 1
+    };
+  }
+  if (response.status === successStatus) {
+    try {
+      const resultJson = await response.json();
+      return {
+        result: resultExtractor(resultJson),
+        status: "success" /* Success */,
+        errorCount: 0
+      };
+    } catch (error) {
+      throw new ZapierApiError(
+        "Result extractor failed to parse successful response as JSON",
+        {
+          statusCode: response.status,
+          cause: error
+        }
+      );
+    }
+  }
+  if (response.status !== pendingStatus) {
+    throw new ZapierApiError(
+      `Unexpected response status during polling: ${response.status}`,
+      {
+        statusCode: response.status
+      }
+    );
+  }
+  return {
+    status: "continue" /* Continue */,
+    errorCount: 0
+  };
+};
 async function pollUntilComplete(options) {
   const {
     fetchPoll,
-    maxAttempts = 30,
-    initialDelay = 50,
-    maxDelay = 1e3,
-    successStatus = 200,
-    pendingStatus = 202,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    initialDelay = DEFAULT_INITIAL_DELAY_MS,
+    successStatus = DEFAULT_SUCCESS_STATUS,
+    pendingStatus = DEFAULT_PENDING_STATUS,
     resultExtractor = (response) => response
   } = options;
-  let delay = initialDelay;
+  if (timeoutMs <= 0) {
+    throw new ZapierValidationError("Timeout must be greater than 0", {
+      details: { timeoutMs }
+    });
+  }
+  if (initialDelay < 0) {
+    throw new ZapierValidationError("Initial delay must be non-negative", {
+      details: { initialDelay }
+    });
+  }
+  const startTime = Date.now();
+  let attempts = 0;
   let errorCount = 0;
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    const response = await fetchPoll();
-    if (response.status === successStatus) {
-      errorCount = 0;
-      const result = await response.json();
-      return resultExtractor(result);
-    } else if (response.status === pendingStatus) {
-      errorCount = 0;
-      if (attempt < maxAttempts - 1) {
-        await new Promise((resolve3) => setTimeout(resolve3, delay));
-        delay = Math.min(delay * 2, maxDelay);
-        continue;
+  const pollingStages = [
+    ...DEFAULT_POLLING_STAGES,
+    [timeoutMs + MAX_TIMEOUT_BUFFER_MS, DEFAULT_MAX_POLLING_INTERVAL_MS]
+    // Up to timeout + 10s: poll every 10s
+  ];
+  if (initialDelay > 0) {
+    await promises.setTimeout(initialDelay);
+  }
+  while (true) {
+    attempts++;
+    const elapsedTime = Date.now() - startTime;
+    const pollingInterval = pollingStages.find(
+      ([maxTimeForStage, _interval]) => {
+        return elapsedTime < maxTimeForStage;
       }
-    } else {
-      errorCount++;
-      if (errorCount >= 3) {
+    );
+    if (!pollingInterval) {
+      throw new ZapierTimeoutError(
+        `Operation timed out after ${Math.floor(elapsedTime / 1e3)}s (${attempts} attempts)`,
+        {
+          attempts
+        }
+      );
+    }
+    if (attempts > 1) {
+      const waitTime = calculateWaitTime(pollingInterval[1], errorCount);
+      await promises.setTimeout(waitTime);
+    }
+    try {
+      const response = await fetchPoll();
+      const {
+        result,
+        errorCount: newErrorCount,
+        status
+      } = await processResponse(
+        response,
+        successStatus,
+        pendingStatus,
+        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 }
         );
       }
-      if (attempt < maxAttempts - 1) {
-        await new Promise((resolve3) => setTimeout(resolve3, delay));
-        delay = Math.min(delay * 2, maxDelay);
-        continue;
+    } catch (error) {
+      errorCount++;
+      if (errorCount >= MAX_CONSECUTIVE_ERRORS) {
+        throw new ZapierApiError(
+          `Failed to poll after ${errorCount} consecutive errors: ${error instanceof Error ? error.message : String(error)}`,
+          {
+            cause: error
+          }
+        );
       }
     }
   }
-  throw new ZapierTimeoutError(
-    `Operation timed out after ${maxAttempts} attempts`,
-    { attempts: maxAttempts, maxAttempts }
-  );
 }
 
 // src/auth.ts
@@ -2377,9 +2613,8 @@ var ZapierApiClient = class {
           searchParams: options.searchParams,
           authRequired: options.authRequired
         }),
-        maxAttempts: options.maxAttempts,
         initialDelay: options.initialDelay,
-        maxDelay: options.maxDelay,
+        timeoutMs: options.timeoutMs,
         successStatus: options.successStatus,
         pendingStatus: options.pendingStatus,
         resultExtractor: options.resultExtractor
@@ -3087,7 +3322,7 @@ function createSdk(options = {}, initialSdk = {}, initialContext = { meta: {} })
   };
 }
 function createZapierSdkWithoutRegistry(options = {}) {
-  return createSdk(options).addPlugin(apiPlugin).addPlugin(listAppsPlugin).addPlugin(manifestPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(listInputFieldChoicesPlugin).addPlugin(runActionPlugin).addPlugin(lockVersionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
+  return createSdk(options).addPlugin(apiPlugin).addPlugin(manifestPlugin).addPlugin(listAppsPlugin).addPlugin(getAppPlugin).addPlugin(listActionsPlugin).addPlugin(getActionPlugin).addPlugin(listInputFieldsPlugin).addPlugin(listInputFieldChoicesPlugin).addPlugin(runActionPlugin).addPlugin(listAuthenticationsPlugin).addPlugin(getAuthenticationPlugin).addPlugin(findFirstAuthenticationPlugin).addPlugin(findUniqueAuthenticationPlugin).addPlugin(requestPlugin).addPlugin(fetchPlugin).addPlugin(appsPlugin).addPlugin(getProfilePlugin);
 }
 function createZapierSdk(options = {}) {
   return createZapierSdkWithoutRegistry(options).addPlugin(registryPlugin);
@@ -3097,6 +3332,7 @@ exports.ActionKeyPropertySchema = ActionKeyPropertySchema;
 exports.ActionTypePropertySchema = ActionTypePropertySchema;
 exports.AppKeyPropertySchema = AppKeyPropertySchema;
 exports.AuthenticationIdPropertySchema = AuthenticationIdPropertySchema;
+exports.DEFAULT_CONFIG_PATH = DEFAULT_CONFIG_PATH;
 exports.DebugPropertySchema = DebugPropertySchema;
 exports.InputsPropertySchema = InputsPropertySchema;
 exports.LimitPropertySchema = LimitPropertySchema;
@@ -3129,11 +3365,13 @@ exports.createZapierSdk = createZapierSdk;
 exports.createZapierSdkWithoutRegistry = createZapierSdkWithoutRegistry;
 exports.fetchPlugin = fetchPlugin;
 exports.findFirstAuthenticationPlugin = findFirstAuthenticationPlugin;
+exports.findManifestEntry = findManifestEntry;
 exports.findUniqueAuthenticationPlugin = findUniqueAuthenticationPlugin;
 exports.formatErrorMessage = formatErrorMessage;
 exports.getActionPlugin = getActionPlugin;
 exports.getAppPlugin = getAppPlugin;
 exports.getAuthenticationPlugin = getAuthenticationPlugin;
+exports.getPreferredManifestEntryKey = getPreferredManifestEntryKey;
 exports.getProfilePlugin = getProfilePlugin;
 exports.getResolutionOrder = getResolutionOrder;
 exports.getResolutionOrderForParams = getResolutionOrderForParams;
@@ -3150,9 +3388,8 @@ exports.listActionsPlugin = listActionsPlugin;
 exports.listAppsPlugin = listAppsPlugin;
 exports.listAuthenticationsPlugin = listAuthenticationsPlugin;
 exports.listInputFieldsPlugin = listInputFieldsPlugin;
-exports.loadManifestFromFile = loadManifestFromFile;
-exports.lockVersionPlugin = lockVersionPlugin;
 exports.manifestPlugin = manifestPlugin;
+exports.readManifestFromFile = readManifestFromFile;
 exports.registryPlugin = registryPlugin;
 exports.requestPlugin = requestPlugin;
 exports.resolverRegistry = resolverRegistry;