@zapier/zapier-sdk 0.18.3 → 0.19.0

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var zod = require('zod');
+var apps = require('@zapier/zapier-sdk-core/v0/schemas/apps');
 var authentications = require('@zapier/zapier-sdk-core/v0/schemas/authentications');
 var promises = require('timers/promises');
 var os = require('os');
@@ -57,6 +58,14 @@ function isPositional(schema) {
 // src/constants.ts
 var ZAPIER_BASE_URL = process.env.ZAPIER_BASE_URL || "https://zapier.com";
 var MAX_PAGE_LIMIT = 1e4;
+var ZAPIER_CREDENTIALS = process.env.ZAPIER_CREDENTIALS;
+var ZAPIER_CREDENTIALS_CLIENT_ID = process.env.ZAPIER_CREDENTIALS_CLIENT_ID;
+var ZAPIER_CREDENTIALS_CLIENT_SECRET = process.env.ZAPIER_CREDENTIALS_CLIENT_SECRET;
+var ZAPIER_CREDENTIALS_BASE_URL = process.env.ZAPIER_CREDENTIALS_BASE_URL;
+var ZAPIER_CREDENTIALS_SCOPE = process.env.ZAPIER_CREDENTIALS_SCOPE;
+var ZAPIER_TOKEN = process.env.ZAPIER_TOKEN;
+var ZAPIER_AUTH_BASE_URL = process.env.ZAPIER_AUTH_BASE_URL;
+var ZAPIER_AUTH_CLIENT_ID = process.env.ZAPIER_AUTH_CLIENT_ID;
 
 // src/types/properties.ts
 var AppKeyPropertySchema = withPositional(
@@ -817,105 +826,230 @@ function createPaginatedFunction(coreFn, schema, telemetry, explicitFunctionName
   };
   return namedFunctions[functionName];
 }
-var ImplementationMetaSchema = zod.z.object({
-  id: zod.z.string(),
-  name: zod.z.string(),
-  slug: zod.z.string(),
-  age_in_days: zod.z.number().optional(),
-  auth_type: zod.z.string().optional(),
-  banner: zod.z.string().optional(),
-  categories: zod.z.array(
-    zod.z.object({
-      id: zod.z.number(),
-      name: zod.z.string(),
-      slug: zod.z.string()
-    })
-  ).optional(),
-  images: zod.z.object({
-    url_16x16: zod.z.string().optional(),
-    url_32x32: zod.z.string().optional(),
-    url_64x64: zod.z.string().optional(),
-    url_128x128: zod.z.string().optional()
-  }).optional(),
-  popularity: zod.z.number().optional(),
-  has_filters: zod.z.boolean().optional(),
-  has_reads: zod.z.boolean().optional(),
-  has_searches: zod.z.boolean().optional(),
-  has_searches_or_writes: zod.z.boolean().optional(),
-  has_upfront_fields: zod.z.boolean().optional(),
-  has_writes: zod.z.boolean().optional(),
-  is_beta: zod.z.boolean().optional(),
-  is_built_in: zod.z.boolean().optional(),
-  is_deprecated: zod.z.boolean().optional(),
-  is_featured: zod.z.boolean().optional(),
-  is_hidden: zod.z.boolean().optional(),
-  is_invite: zod.z.boolean().optional(),
-  is_premium: zod.z.boolean().optional(),
-  is_public: zod.z.boolean().optional(),
-  is_upcoming: zod.z.boolean().optional(),
-  version: zod.z.string().optional(),
-  visibility: zod.z.string().optional(),
-  actions: zod.z.object({
-    read: zod.z.number().optional(),
-    read_bulk: zod.z.number().optional(),
-    write: zod.z.number().optional(),
-    search: zod.z.number().optional(),
-    search_or_write: zod.z.number().optional(),
-    search_and_write: zod.z.number().optional(),
-    filter: zod.z.number().optional()
-  }).optional(),
-  description: zod.z.string().optional(),
-  primary_color: zod.z.string().optional(),
-  secondary_color: zod.z.string().optional(),
-  classification: zod.z.string().optional(),
-  api_docs_url: zod.z.string().optional(),
-  image: zod.z.string().optional()
-});
-zod.z.object({
-  count: zod.z.number(),
-  next: zod.z.string().nullable().optional(),
-  previous: zod.z.string().nullable().optional(),
-  results: zod.z.array(ImplementationMetaSchema)
-});
-
-// src/temporary-internal-core/schemas/apps/index.ts
-var ListAppsOptionsSchema = zod.z.object({
+var ListAppsSchema = apps.ListAppsQuerySchema.omit({
+  offset: true
+}).extend({
+  // Override appKeys to be an array instead of comma-separated string
   appKeys: zod.z.array(zod.z.string()).optional().describe(
     "Filter apps by app keys (e.g., 'SlackCLIAPI' or slug like 'github')"
   ),
-  search: zod.z.string().optional().describe("Search for apps by name"),
+  // Override pageSize to make optional (base has default value)
   pageSize: zod.z.number().min(1).optional().describe("Number of apps per page"),
+  // SDK specific property for pagination/iterator helpers
   maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  // SDK specific property for pagination/iterator helpers
   cursor: zod.z.string().optional().describe("Cursor to start from")
 }).merge(TelemetryMarkerSchema).describe("List all available apps with optional filtering");
-var AppItemSchema = ImplementationMetaSchema.omit({
-  name: true,
-  id: true
-}).extend({
-  title: zod.z.string(),
-  key: zod.z.string(),
-  implementation_id: zod.z.string(),
-  version: zod.z.string().optional()
-});
-zod.z.object({
-  data: zod.z.array(AppItemSchema),
-  nextCursor: zod.z.string().optional()
+
+// src/utils/string-utils.ts
+function toTitleCase(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+function toSnakeCase(input) {
+  let result = input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s\-]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase();
+  if (/^[0-9]/.test(result)) {
+    result = "_" + result;
+  }
+  return result;
+}
+function stripPageSuffix(functionName) {
+  return functionName.replace(/Page$/, "");
+}
+
+// src/schemas/App.ts
+var AppItemSchema = withFormatter(apps.AppItemSchema, {
+  format: (item) => {
+    const additionalKeys = [];
+    if (item.slug && item.slug !== item.key) {
+      additionalKeys.push(item.slug);
+      const snakeCaseSlug = toSnakeCase(item.slug);
+      if (snakeCaseSlug !== item.slug && snakeCaseSlug !== item.key) {
+        additionalKeys.push(snakeCaseSlug);
+      }
+    }
+    return {
+      title: item.title,
+      key: item.key,
+      keys: [item.key, ...additionalKeys],
+      description: item.description,
+      details: []
+    };
+  }
 });
-var ListAppsHandlerRequestSchema = zod.z.object({
-  implementationIds: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional().describe(
-    "Pre-resolved implementation IDs - array or comma-separated string"
+
+// src/utils/telemetry-utils.ts
+function createTelemetryCallback(emitMethodCalled, methodName) {
+  return {
+    onMethodCalled: (data) => {
+      emitMethodCalled({
+        method_name: methodName,
+        execution_duration_ms: data.durationMs,
+        success_flag: data.success,
+        error_message: data.error?.message ?? null,
+        error_type: data.error?.constructor.name ?? null,
+        argument_count: data.argumentCount,
+        is_paginated: data.isPaginated
+      });
+    }
+  };
+}
+
+// src/plugins/listApps/index.ts
+var listAppsPlugin = ({ context }) => {
+  async function listAppsPage(options) {
+    const { api, resolveAppKeys: resolveAppKeys2 } = context;
+    const appKeys = options.appKeys ?? [];
+    const appLocators = await resolveAppKeys2({
+      appKeys: [...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 (appKeys.length > 0 && appLocators.length === 0 && !options.search) {
+      return {
+        data: [],
+        links: { next: null },
+        meta: { count: 0, limit: 0, offset: 0 }
+      };
+    }
+    const implementationIds = appLocators.map((locator) => {
+      const version = locator.version || "latest";
+      return `${locator.implementationName}@${version}`;
+    });
+    return await api.get("/api/v0/apps", {
+      searchParams: {
+        appKeys: implementationIds.join(","),
+        ...options.search && { search: options.search },
+        pageSize: options.pageSize.toString(),
+        ...options.cursor && { offset: options.cursor }
+      }
+    });
+  }
+  const methodName = stripPageSuffix(listAppsPage.name);
+  const listAppsDefinition = createPaginatedFunction(
+    listAppsPage,
+    ListAppsSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
+  );
+  return {
+    listApps: listAppsDefinition,
+    context: {
+      meta: {
+        listApps: {
+          categories: ["app"],
+          type: "list",
+          itemType: "App",
+          inputSchema: ListAppsSchema,
+          outputSchema: AppItemSchema
+        }
+      }
+    }
+  };
+};
+
+// src/utils/domain-utils.ts
+function splitVersionedKey(versionedKey) {
+  const parts = versionedKey.split("@");
+  if (parts.length >= 2) {
+    const baseKey = parts[0];
+    const version = parts.slice(1).join("@");
+    return [baseKey, version];
+  }
+  return [versionedKey, void 0];
+}
+function normalizeImplementationMetaToAppItem(implementationMeta) {
+  const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
+  const { id, name, ...restOfImplementationMeta } = implementationMeta;
+  return {
+    ...restOfImplementationMeta,
+    title: name,
+    key: selectedApi,
+    implementation_id: id,
+    version: appVersion
+  };
+}
+function normalizeActionItem(action) {
+  const { name, type, selected_api: selectedApi } = action;
+  const [appKey, appVersion] = selectedApi ? splitVersionedKey(selectedApi) : ["", void 0];
+  return {
+    // Only include the fields we want - explicitly list them
+    id: action.id,
+    key: action.key,
+    description: action.description,
+    is_important: action.is_important,
+    is_hidden: action.is_hidden,
+    // Transformed fields
+    app_key: appKey,
+    app_version: appVersion,
+    action_type: type,
+    title: name,
+    // Map name to title
+    type: "action"
+  };
+}
+function isSlug(slug) {
+  return !!slug.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+}
+function isSnakeCasedSlug(slug) {
+  if (slug.match(/^_[0-9]/)) {
+    slug = slug.slice(1);
+  }
+  return !!slug.match(/^[a-z0-9]+(?:_[a-z0-9]+)*$/);
+}
+function dashifySnakeCasedSlug(slug) {
+  if (!isSnakeCasedSlug(slug)) {
+    return slug;
+  }
+  if (slug.startsWith("_")) {
+    slug = slug.slice(1);
+  }
+  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;
+}
+var ListActionsSchema = zod.z.object({
+  appKey: AppKeyPropertySchema.describe(
+    "App key of actions to list (e.g., 'SlackCLIAPI' or slug like 'github')"
+  ),
+  actionType: ActionTypePropertySchema.optional().describe(
+    "Filter actions by type"
   ),
-  search: zod.z.string().optional().describe("Optional search term to augment results"),
-  pageSize: zod.z.union([zod.z.string(), zod.z.number()]).optional().describe("Number of apps per page"),
-  cursor: zod.z.string().optional().describe("Pagination cursor")
-}).transform((data) => ({
-  // Normalize implementationIds to array
-  implementationIds: typeof data.implementationIds === "string" ? data.implementationIds === "" ? [] : data.implementationIds.split(",") : data.implementationIds ?? [],
-  search: data.search,
-  // Normalize pageSize to number
-  pageSize: typeof data.pageSize === "string" ? parseInt(data.pageSize, 10) : data.pageSize,
-  cursor: data.cursor
-}));
+  pageSize: zod.z.number().min(1).optional().describe("Number of actions per page"),
+  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages"),
+  cursor: zod.z.string().optional().describe("Cursor to start from")
+}).merge(TelemetryMarkerSchema).describe("List all actions for a specific app");
 var NeedChoicesSchema = zod.z.object({
   key: zod.z.string().optional(),
   label: zod.z.string().optional(),
@@ -1114,384 +1248,106 @@ zod.z.object({
   popularity: zod.z.number(),
   primary_color: zod.z.string(),
   request_count: zod.z.string().optional(),
-  slug: zod.z.string(),
-  zap_usage_count: zod.z.number().nullable().optional()
-});
-var ServiceSchema = zod.z.object({
-  id: zod.z.number().optional(),
-  canonical_id: zod.z.string().optional(),
-  current_implementation_id: zod.z.string(),
-  name: zod.z.string(),
-  slug: zod.z.string(),
-  app_url: zod.z.string().optional(),
-  learn_more_url: zod.z.string().optional(),
-  description: zod.z.string(),
-  primary_color: zod.z.string(),
-  popularity: zod.z.number(),
-  image: zod.z.string().optional(),
-  images: zod.z.string().optional()
-});
-zod.z.object({
-  results: zod.z.array(ServiceSchema),
-  next: zod.z.string().nullable().optional(),
-  previous: zod.z.string().nullable().optional()
-});
-zod.z.object({
-  selected_api: zod.z.string(),
-  action: zod.z.string(),
-  type_of: zod.z.string(),
-  authentication_id: zod.z.number().optional(),
-  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-});
-zod.z.object({
-  success: zod.z.boolean(),
-  needs: zod.z.array(NeedSchema).optional(),
-  errors: zod.z.array(zod.z.string()).optional(),
-  last_fetched_at: zod.z.string().optional(),
-  schema: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-});
-var ImplementationSchema = zod.z.object({
-  selected_api: zod.z.string(),
-  app_id: zod.z.number().optional(),
-  auth_type: zod.z.string().optional(),
-  auth_fields: zod.z.string().optional(),
-  actions: zod.z.array(ActionSchema).optional(),
-  is_deprecated: zod.z.boolean().optional(),
-  is_private_only: zod.z.boolean().optional(),
-  is_invite_only: zod.z.boolean().optional(),
-  is_beta: zod.z.boolean().optional().default(false),
-  is_premium: zod.z.boolean().optional().default(false),
-  is_hidden: zod.z.string().optional(),
-  name: zod.z.string().optional(),
-  slug: zod.z.string().optional(),
-  images: zod.z.record(zod.z.string(), zod.z.string().nullable()).optional(),
-  primary_color: zod.z.string().optional(),
-  secondary_color: zod.z.string().optional(),
-  current_implementation: zod.z.string().optional(),
-  other_implementations: zod.z.string().optional()
-});
-zod.z.object({
-  count: zod.z.number(),
-  next: zod.z.string().nullable().optional(),
-  previous: zod.z.string().nullable().optional(),
-  results: zod.z.array(ImplementationSchema)
-});
-var ImplementationMetaSchema2 = zod.z.object({
-  id: zod.z.string(),
-  // e.g. "100HiresCLIAPI@1.2.1"
-  name: zod.z.string(),
-  slug: zod.z.string(),
-  age_in_days: zod.z.number().optional(),
-  auth_type: zod.z.string().optional(),
-  banner: zod.z.string().optional(),
-  categories: zod.z.array(
-    zod.z.object({
-      id: zod.z.number(),
-      name: zod.z.string(),
-      slug: zod.z.string()
-    })
-  ).optional(),
-  images: zod.z.object({
-    url_16x16: zod.z.string().optional(),
-    url_32x32: zod.z.string().optional(),
-    url_64x64: zod.z.string().optional(),
-    url_128x128: zod.z.string().optional()
-  }).optional(),
-  popularity: zod.z.number().optional(),
-  has_filters: zod.z.boolean().optional(),
-  has_reads: zod.z.boolean().optional(),
-  has_searches: zod.z.boolean().optional(),
-  has_searches_or_writes: zod.z.boolean().optional(),
-  has_upfront_fields: zod.z.boolean().optional(),
-  has_writes: zod.z.boolean().optional(),
-  is_beta: zod.z.boolean().optional(),
-  is_built_in: zod.z.boolean().optional(),
-  is_deprecated: zod.z.boolean().optional(),
-  is_featured: zod.z.boolean().optional(),
-  is_hidden: zod.z.boolean().optional(),
-  is_invite: zod.z.boolean().optional(),
-  is_premium: zod.z.boolean().optional(),
-  is_public: zod.z.boolean().optional(),
-  is_upcoming: zod.z.boolean().optional(),
-  version: zod.z.string().optional(),
-  visibility: zod.z.string().optional(),
-  actions: zod.z.object({
-    read: zod.z.number().optional(),
-    read_bulk: zod.z.number().optional(),
-    write: zod.z.number().optional(),
-    search: zod.z.number().optional(),
-    search_or_write: zod.z.number().optional(),
-    search_and_write: zod.z.number().optional(),
-    filter: zod.z.number().optional()
-  }).optional(),
-  description: zod.z.string().optional(),
-  primary_color: zod.z.string().optional(),
-  secondary_color: zod.z.string().optional(),
-  classification: zod.z.string().optional(),
-  api_docs_url: zod.z.string().optional(),
-  image: zod.z.string().optional()
-});
-zod.z.object({
-  count: zod.z.number(),
-  next: zod.z.string().nullable().optional(),
-  previous: zod.z.string().nullable().optional(),
-  results: zod.z.array(ImplementationMetaSchema2)
-});
-var NeedChoicesResponseMetaSchema = zod.z.object({
-  page: zod.z.string().nullable().optional()
-});
-var NeedChoicesResponseLinksSchema = zod.z.object({
-  next: zod.z.string().nullable().optional(),
-  prev: zod.z.string().nullable().optional()
-});
-zod.z.object({
-  selected_api: zod.z.string().optional().describe(
-    "Something like `SlackAPI` (for Python apps) or `SplitwiseCLIAPI@1.0.0` (for CLI apps). Non-public apps are fine as long as the authed user can access them."
-  ),
-  authentication_id: zod.z.coerce.number().optional().describe(
-    "If the app needs auth, provide an `authentication_id` that has the `selected_api` of the app you want to run. Can be any auth visible to the user (including shared)."
-  ),
-  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe(
-    "Object that matches the input the node would normally get. Has all the same keys/types as the `needs` of the action."
-  ),
-  page: zod.z.number().optional().default(0),
-  prefill: zod.z.string().optional().describe(
-    "The prefill string to indicate what we're fetching choices for. Likely something like `spreadsheet.id.title`. Must be provided alongside `selected_api` if both `action_id` and `input_field_id` are not."
-  ),
-  action_id: zod.z.string().optional().describe(
-    "The id that will be used to lookup the Action for prefill lookup. If provided, `input_field_id` is required, else `prefill` must be provided."
-  ),
-  input_field_id: zod.z.string().optional().describe(
-    "The id (key) of the input field (Need) that dynamic choices are being retrieved for. If provided, `action_id` is required, else `prefill` must be provided."
-  )
-});
-zod.z.object({
-  success: zod.z.boolean(),
-  choices: zod.z.array(NeedChoicesSchema).optional(),
-  next_page: zod.z.number().optional(),
-  errors: zod.z.array(zod.z.string()).optional(),
-  meta: NeedChoicesResponseMetaSchema.optional(),
-  links: NeedChoicesResponseLinksSchema.optional()
-});
-
-// src/utils/string-utils.ts
-function toTitleCase(input) {
-  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_\-]+/g, " ").replace(/\s+/g, " ").trim().split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
-}
-function toSnakeCase(input) {
-  let result = input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[\s\-]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase();
-  if (/^[0-9]/.test(result)) {
-    result = "_" + result;
-  }
-  return result;
-}
-function stripPageSuffix(functionName) {
-  return functionName.replace(/Page$/, "");
-}
-
-// src/schemas/App.ts
-var AppItemSchema2 = withFormatter(
-  ImplementationMetaSchema2.omit({ name: true, id: true }).extend({
-    title: zod.z.string(),
-    // Mapped from name
-    key: zod.z.string(),
-    // Extracted from id (base part without version)
-    implementation_id: zod.z.string()
-    // Mapped from id (full versioned ID)
-  }),
-  {
-    format: (item) => {
-      const additionalKeys = [];
-      if (item.slug && item.slug !== item.key) {
-        additionalKeys.push(item.slug);
-        const snakeCaseSlug = toSnakeCase(item.slug);
-        if (snakeCaseSlug !== item.slug && snakeCaseSlug !== item.key) {
-          additionalKeys.push(snakeCaseSlug);
-        }
-      }
-      return {
-        title: item.title,
-        key: item.key,
-        keys: [item.key, ...additionalKeys],
-        description: item.description,
-        details: []
-      };
-    }
-  }
-);
-
-// src/utils/telemetry-utils.ts
-function createTelemetryCallback(emitMethodCalled, methodName) {
-  return {
-    onMethodCalled: (data) => {
-      emitMethodCalled({
-        method_name: methodName,
-        execution_duration_ms: data.durationMs,
-        success_flag: data.success,
-        error_message: data.error?.message ?? null,
-        error_type: data.error?.constructor.name ?? null,
-        argument_count: data.argumentCount,
-        is_paginated: data.isPaginated
-      });
-    }
-  };
-}
-
-// src/plugins/listApps/index.ts
-var listAppsPlugin = ({ context }) => {
-  async function listAppsPage(options) {
-    const { api, resolveAppKeys: resolveAppKeys2 } = context;
-    const appKeys = options.appKeys ?? [];
-    const appLocators = await resolveAppKeys2({
-      appKeys: [...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 (appKeys.length > 0 && appLocators.length === 0 && !options.search) {
-      return {
-        data: [],
-        nextCursor: void 0
-      };
-    }
-    const implementationIds = appLocators.map((locator) => {
-      const version = locator.version || "latest";
-      return `${locator.implementationName}@${version}`;
-    });
-    return await api.get("/api/v0/apps", {
-      searchParams: {
-        implementationIds: implementationIds.join(","),
-        ...options.search && { search: options.search },
-        pageSize: options.pageSize.toString(),
-        ...options.cursor && { cursor: options.cursor }
-      }
-    });
-  }
-  const methodName = stripPageSuffix(listAppsPage.name);
-  const listAppsDefinition = createPaginatedFunction(
-    listAppsPage,
-    ListAppsOptionsSchema,
-    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
-    methodName
-  );
-  return {
-    listApps: listAppsDefinition,
-    context: {
-      meta: {
-        listApps: {
-          categories: ["app"],
-          type: "list",
-          itemType: "App",
-          inputSchema: ListAppsOptionsSchema,
-          outputSchema: AppItemSchema2
-        }
-      }
-    }
-  };
-};
-
-// src/utils/domain-utils.ts
-function splitVersionedKey(versionedKey) {
-  const parts = versionedKey.split("@");
-  if (parts.length >= 2) {
-    const baseKey = parts[0];
-    const version = parts.slice(1).join("@");
-    return [baseKey, version];
-  }
-  return [versionedKey, void 0];
-}
-function normalizeImplementationMetaToAppItem(implementationMeta) {
-  const [selectedApi, appVersion] = splitVersionedKey(implementationMeta.id);
-  const { id, name, ...restOfImplementationMeta } = implementationMeta;
-  return {
-    ...restOfImplementationMeta,
-    title: name,
-    key: selectedApi,
-    implementation_id: id,
-    version: appVersion
-  };
-}
-function normalizeActionItem(action) {
-  const { name, type, selected_api: selectedApi } = action;
-  const [appKey, appVersion] = selectedApi ? splitVersionedKey(selectedApi) : ["", void 0];
-  return {
-    // Only include the fields we want - explicitly list them
-    id: action.id,
-    key: action.key,
-    description: action.description,
-    is_important: action.is_important,
-    is_hidden: action.is_hidden,
-    // Transformed fields
-    app_key: appKey,
-    app_version: appVersion,
-    action_type: type,
-    title: name,
-    // Map name to title
-    type: "action"
-  };
-}
-function isSlug(slug) {
-  return !!slug.match(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
-}
-function isSnakeCasedSlug(slug) {
-  if (slug.match(/^_[0-9]/)) {
-    slug = slug.slice(1);
-  }
-  return !!slug.match(/^[a-z0-9]+(?:_[a-z0-9]+)*$/);
-}
-function dashifySnakeCasedSlug(slug) {
-  if (!isSnakeCasedSlug(slug)) {
-    return slug;
-  }
-  if (slug.startsWith("_")) {
-    slug = slug.slice(1);
-  }
-  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;
-}
-var ListActionsSchema = zod.z.object({
-  appKey: AppKeyPropertySchema.describe(
-    "App key of actions to list (e.g., 'SlackCLIAPI' or slug like 'github')"
+  slug: zod.z.string(),
+  zap_usage_count: zod.z.number().nullable().optional()
+});
+var ServiceSchema = zod.z.object({
+  id: zod.z.number().optional(),
+  canonical_id: zod.z.string().optional(),
+  current_implementation_id: zod.z.string(),
+  name: zod.z.string(),
+  slug: zod.z.string(),
+  app_url: zod.z.string().optional(),
+  learn_more_url: zod.z.string().optional(),
+  description: zod.z.string(),
+  primary_color: zod.z.string(),
+  popularity: zod.z.number(),
+  image: zod.z.string().optional(),
+  images: zod.z.string().optional()
+});
+zod.z.object({
+  results: zod.z.array(ServiceSchema),
+  next: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional()
+});
+zod.z.object({
+  selected_api: zod.z.string(),
+  action: zod.z.string(),
+  type_of: zod.z.string(),
+  authentication_id: zod.z.number().optional(),
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+zod.z.object({
+  success: zod.z.boolean(),
+  needs: zod.z.array(NeedSchema).optional(),
+  errors: zod.z.array(zod.z.string()).optional(),
+  last_fetched_at: zod.z.string().optional(),
+  schema: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var ImplementationSchema = zod.z.object({
+  selected_api: zod.z.string(),
+  app_id: zod.z.number().optional(),
+  auth_type: zod.z.string().optional(),
+  auth_fields: zod.z.string().optional(),
+  actions: zod.z.array(ActionSchema).optional(),
+  is_deprecated: zod.z.boolean().optional(),
+  is_private_only: zod.z.boolean().optional(),
+  is_invite_only: zod.z.boolean().optional(),
+  is_beta: zod.z.boolean().optional().default(false),
+  is_premium: zod.z.boolean().optional().default(false),
+  is_hidden: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  slug: zod.z.string().optional(),
+  images: zod.z.record(zod.z.string(), zod.z.string().nullable()).optional(),
+  primary_color: zod.z.string().optional(),
+  secondary_color: zod.z.string().optional(),
+  current_implementation: zod.z.string().optional(),
+  other_implementations: zod.z.string().optional()
+});
+zod.z.object({
+  count: zod.z.number(),
+  next: zod.z.string().nullable().optional(),
+  previous: zod.z.string().nullable().optional(),
+  results: zod.z.array(ImplementationSchema)
+});
+var NeedChoicesResponseMetaSchema = zod.z.object({
+  page: zod.z.string().nullable().optional()
+});
+var NeedChoicesResponseLinksSchema = zod.z.object({
+  next: zod.z.string().nullable().optional(),
+  prev: zod.z.string().nullable().optional()
+});
+zod.z.object({
+  selected_api: zod.z.string().optional().describe(
+    "Something like `SlackAPI` (for Python apps) or `SplitwiseCLIAPI@1.0.0` (for CLI apps). Non-public apps are fine as long as the authed user can access them."
   ),
-  actionType: ActionTypePropertySchema.optional().describe(
-    "Filter actions by type"
+  authentication_id: zod.z.coerce.number().optional().describe(
+    "If the app needs auth, provide an `authentication_id` that has the `selected_api` of the app you want to run. Can be any auth visible to the user (including shared)."
   ),
-  pageSize: zod.z.number().min(1).optional().describe("Number of actions per page"),
-  maxItems: zod.z.number().min(1).optional().describe("Maximum total items to return across all pages"),
-  cursor: zod.z.string().optional().describe("Cursor to start from")
-}).merge(TelemetryMarkerSchema).describe("List all actions for a specific app");
+  params: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe(
+    "Object that matches the input the node would normally get. Has all the same keys/types as the `needs` of the action."
+  ),
+  page: zod.z.number().optional().default(0),
+  prefill: zod.z.string().optional().describe(
+    "The prefill string to indicate what we're fetching choices for. Likely something like `spreadsheet.id.title`. Must be provided alongside `selected_api` if both `action_id` and `input_field_id` are not."
+  ),
+  action_id: zod.z.string().optional().describe(
+    "The id that will be used to lookup the Action for prefill lookup. If provided, `input_field_id` is required, else `prefill` must be provided."
+  ),
+  input_field_id: zod.z.string().optional().describe(
+    "The id (key) of the input field (Need) that dynamic choices are being retrieved for. If provided, `action_id` is required, else `prefill` must be provided."
+  )
+});
+zod.z.object({
+  success: zod.z.boolean(),
+  choices: zod.z.array(NeedChoicesSchema).optional(),
+  next_page: zod.z.number().optional(),
+  errors: zod.z.array(zod.z.string()).optional(),
+  meta: NeedChoicesResponseMetaSchema.optional(),
+  links: NeedChoicesResponseLinksSchema.optional()
+});
+
+// src/schemas/Action.ts
 var ActionItemSchema = withFormatter(
   ActionSchema.omit({ type: true, name: true, selected_api: true }).extend({
     app_key: zod.z.string(),
@@ -2261,6 +2117,9 @@ var listAuthenticationsPlugin = ({ context }) => {
     if (options.owner) {
       searchParams.owner = options.owner;
     }
+    if (options.isExpired !== void 0) {
+      searchParams.isExpired = options.isExpired.toString();
+    }
     if (options.cursor) {
       searchParams.offset = options.cursor;
     }
@@ -2352,7 +2211,7 @@ var getAppPlugin = ({ sdk, context }) => {
           type: "item",
           itemType: "App",
           inputSchema: GetAppSchema,
-          outputSchema: AppItemSchema2,
+          outputSchema: AppItemSchema,
           resolvers: {
             appKey: appKeyResolver
           }
@@ -2442,14 +2301,14 @@ var getAuthenticationPlugin = ({ context }) => {
     }
   };
 };
-var FindFirstAuthenticationSchema = zod.z.object({
-  appKey: AppKeyPropertySchema.optional().describe(
-    "App key of authentication to find (e.g., 'SlackCLIAPI' or slug like 'github')"
-  ),
-  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"),
-  owner: zod.z.string().optional().describe("Filter by owner")
+
+// src/plugins/findFirstAuthentication/schemas.ts
+var FindFirstAuthenticationSchema = ListAuthenticationsQuerySchema.omit({
+  authenticationIds: true,
+  pageSize: true,
+  maxItems: true,
+  cursor: true,
+  _telemetry: true
 }).describe("Find the first authentication matching the criteria");
 
 // src/plugins/findFirstAuthentication/index.ts
@@ -2493,14 +2352,14 @@ var findFirstAuthenticationPlugin = ({ sdk, context }) => {
     }
   };
 };
-var FindUniqueAuthenticationSchema = zod.z.object({
-  appKey: AppKeyPropertySchema.optional().describe(
-    "App key of authentication to find (e.g., 'SlackCLIAPI' or slug like 'github')"
-  ),
-  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"),
-  owner: zod.z.string().optional().describe("Filter by owner")
+
+// src/plugins/findUniqueAuthentication/schemas.ts
+var FindUniqueAuthenticationSchema = ListAuthenticationsQuerySchema.omit({
+  authenticationIds: true,
+  pageSize: true,
+  maxItems: true,
+  cursor: true,
+  _telemetry: true
 }).describe("Find a unique authentication matching the criteria");
 
 // src/plugins/findUniqueAuthentication/index.ts
@@ -2903,8 +2762,11 @@ async function readManifestFromFile(filePath) {
     const resolvedPath = await resolve(filePath);
     const content = await readFile(resolvedPath);
     return parseManifestContent(content, resolvedPath);
-  } catch {
-    console.warn(`\u26A0\uFE0F Failed to read manifest from ${filePath}`);
+  } catch (error) {
+    const isFileNotFound = error && typeof error === "object" && "code" in error && error.code === "ENOENT" || error instanceof Error && error.message.includes("File not found");
+    if (!isFileNotFound) {
+      console.warn(`\u26A0\uFE0F Failed to read manifest from ${filePath}`);
+    }
     return null;
   }
 }
@@ -3617,36 +3479,29 @@ async function pollUntilComplete(options) {
   }
 }
 
-// src/auth.ts
-function getTokenFromEnv() {
-  return process.env.ZAPIER_TOKEN;
+// src/types/credentials.ts
+function isClientCredentials(credentials) {
+  return typeof credentials === "object" && credentials !== null && "clientId" in credentials && "clientSecret" in credentials;
 }
-async function getTokenFromCliLogin(options = {}) {
-  try {
-    const { getToken } = await import('@zapier/zapier-sdk-cli-login');
-    return await getToken(options);
-  } catch {
-    return void 0;
-  }
+function isPkceCredentials(credentials) {
+  return typeof credentials === "object" && credentials !== null && "clientId" in credentials && !("clientSecret" in credentials);
 }
-async function getTokenFromEnvOrConfig(options = {}) {
-  const envToken = getTokenFromEnv();
-  if (envToken) {
-    return envToken;
-  }
-  return getTokenFromCliLogin(options);
+function isCredentialsObject(credentials) {
+  return typeof credentials === "object" && credentials !== null && "clientId" in credentials;
 }
-async function resolveAuthToken(options = {}) {
-  if (options.token) {
-    return options.token;
-  }
-  if (options.getToken) {
-    const token = await options.getToken();
-    if (token) {
-      return token;
-    }
-  }
-  return getTokenFromEnvOrConfig(options);
+function isCredentialsFunction(credentials) {
+  return typeof credentials === "function";
+}
+
+// src/utils/logging.ts
+var loggedDeprecations = /* @__PURE__ */ new Set();
+function logDeprecation(message) {
+  if (loggedDeprecations.has(message)) return;
+  loggedDeprecations.add(message);
+  console.warn(`[zapier-sdk] Deprecation: ${message}`);
+}
+function resetDeprecationWarnings() {
+  loggedDeprecations.clear();
 }
 
 // src/utils/url-utils.ts
@@ -3695,174 +3550,276 @@ function getTrackingBaseUrl({
   return ZAPIER_BASE_URL;
 }
 
-// src/temporary-internal-core/utils/string-utils.ts
-function splitVersionedKey2(versionedKey) {
-  const parts = versionedKey.split("@");
-  if (parts.length >= 2) {
-    const baseKey = parts[0];
-    const version = parts.slice(1).join("@");
-    return [baseKey, version];
-  }
-  return [versionedKey, void 0];
+// src/credentials.ts
+function deriveAuthBaseUrl(sdkBaseUrl) {
+  if (!sdkBaseUrl) return void 0;
+  return getZapierBaseUrl(sdkBaseUrl);
 }
-
-// src/temporary-internal-core/utils/transformations.ts
-function transformImplementationMetaToAppItem(implementationMeta) {
-  const [selectedApi, appVersion] = splitVersionedKey2(implementationMeta.id);
-  const { id, name, ...restOfImplementationMeta } = implementationMeta;
+function normalizeCredentialsObject(obj, sdkBaseUrl) {
+  const resolvedBaseUrl = obj.baseUrl || deriveAuthBaseUrl(sdkBaseUrl);
+  if (obj.type === "client_credentials" || "clientSecret" in obj && obj.clientSecret) {
+    return {
+      type: "client_credentials",
+      clientId: obj.clientId,
+      clientSecret: obj.clientSecret,
+      baseUrl: resolvedBaseUrl,
+      scope: obj.scope
+    };
+  }
   return {
-    ...restOfImplementationMeta,
-    title: name,
-    key: selectedApi,
-    implementation_id: id,
-    version: appVersion
+    type: "pkce",
+    clientId: obj.clientId,
+    baseUrl: resolvedBaseUrl,
+    scope: obj.scope
   };
 }
-function extractPaginationCursor(response) {
-  if (!response.next) {
-    return void 0;
-  }
-  try {
-    const url = new URL(response.next);
-    const offset = url.searchParams.get("offset");
-    return offset || void 0;
-  } catch {
-    return void 0;
+function resolveCredentialsFromEnv(sdkBaseUrl) {
+  if (ZAPIER_CREDENTIALS) {
+    return ZAPIER_CREDENTIALS;
   }
-}
-
-// src/temporary-internal-core/handlers/listApps.ts
-var DEFAULT_PAGE_SIZE = 20;
-async function augmentWithSearchResults({
-  searchTerm,
-  implementationIds,
-  httpClient
-}) {
-  const searchResponse = await httpClient.get(
-    "/zapier/api/v4/implementations-meta/search/",
-    {
-      searchParams: { term: searchTerm }
-    }
-  );
-  const byImplementationName = /* @__PURE__ */ new Map();
-  for (const result of searchResponse.results) {
-    const [implementationName] = splitVersionedKey2(result.id);
-    const isPublic = result.visibility === "public";
-    const existing = byImplementationName.get(implementationName);
-    if (!existing || isPublic && !existing.isPublic) {
-      byImplementationName.set(implementationName, { result, isPublic });
+  if (ZAPIER_CREDENTIALS_CLIENT_ID) {
+    const resolvedBaseUrl = ZAPIER_CREDENTIALS_BASE_URL || deriveAuthBaseUrl(sdkBaseUrl);
+    if (ZAPIER_CREDENTIALS_CLIENT_SECRET) {
+      return {
+        type: "client_credentials",
+        clientId: ZAPIER_CREDENTIALS_CLIENT_ID,
+        clientSecret: ZAPIER_CREDENTIALS_CLIENT_SECRET,
+        baseUrl: resolvedBaseUrl,
+        scope: ZAPIER_CREDENTIALS_SCOPE
+      };
+    } else {
+      return {
+        type: "pkce",
+        clientId: ZAPIER_CREDENTIALS_CLIENT_ID,
+        baseUrl: resolvedBaseUrl,
+        scope: ZAPIER_CREDENTIALS_SCOPE
+      };
     }
   }
-  const searchResults = Array.from(byImplementationName.values()).map(
-    (entry) => transformImplementationMetaToAppItem(entry.result)
-  );
-  const implementationNameSet = new Set(
-    implementationIds.map((id) => {
-      const [name] = splitVersionedKey2(id);
-      return name;
-    })
-  );
-  const additionalIds = [];
-  for (const result of searchResults) {
-    const [implementationName] = splitVersionedKey2(result.key);
-    if (!implementationNameSet.has(implementationName)) {
-      implementationNameSet.add(implementationName);
-      additionalIds.push(result.implementation_id);
+  if (ZAPIER_TOKEN) {
+    logDeprecation(
+      "ZAPIER_TOKEN is deprecated. Use ZAPIER_CREDENTIALS instead."
+    );
+    return ZAPIER_TOKEN;
+  }
+  if (ZAPIER_AUTH_CLIENT_ID) {
+    logDeprecation(
+      "ZAPIER_AUTH_CLIENT_ID is deprecated. Use ZAPIER_CREDENTIALS_CLIENT_ID instead."
+    );
+    if (ZAPIER_AUTH_BASE_URL) {
+      logDeprecation(
+        "ZAPIER_AUTH_BASE_URL is deprecated. Use ZAPIER_CREDENTIALS_BASE_URL instead."
+      );
     }
+    const resolvedBaseUrl = ZAPIER_AUTH_BASE_URL || deriveAuthBaseUrl(sdkBaseUrl);
+    return {
+      type: "pkce",
+      clientId: ZAPIER_AUTH_CLIENT_ID,
+      baseUrl: resolvedBaseUrl
+    };
   }
-  return [...implementationIds, ...additionalIds];
+  return void 0;
 }
-var handleListApps = async ({ request, deps }) => {
-  const validatedRequest = ListAppsHandlerRequestSchema.parse(request);
-  const { httpClient } = deps;
-  let { implementationIds } = validatedRequest;
-  const pageSize = validatedRequest.pageSize ?? DEFAULT_PAGE_SIZE;
-  if (validatedRequest.search) {
-    implementationIds = await augmentWithSearchResults({
-      searchTerm: validatedRequest.search,
-      implementationIds,
-      httpClient
-    });
-  }
-  if (implementationIds.length === 0) {
-    if (validatedRequest.search) {
-      return {
-        data: [],
-        nextCursor: void 0
-      };
+async function resolveCredentials(options = {}) {
+  const { baseUrl } = options;
+  if (options.credentials !== void 0) {
+    if (isCredentialsFunction(options.credentials)) {
+      const resolved = await options.credentials();
+      if (typeof resolved === "function") {
+        throw new Error(
+          "Credentials function returned another function. Credentials functions must return a string or credentials object."
+        );
+      }
+      if (isCredentialsObject(resolved)) {
+        return normalizeCredentialsObject(resolved, baseUrl);
+      }
+      return resolved;
     }
-    const searchParams2 = {
-      latest_only: "true",
-      selected_apis: "",
-      limit: pageSize.toString()
-    };
-    if (validatedRequest.cursor) {
-      searchParams2.offset = validatedRequest.cursor;
+    if (isCredentialsObject(options.credentials)) {
+      return normalizeCredentialsObject(options.credentials, baseUrl);
     }
-    const implementationsResponse2 = await httpClient.get(
-      "/zapier/api/v4/implementations-meta/lookup/",
-      {
-        searchParams: searchParams2
-      }
+    return options.credentials;
+  }
+  if (options.token !== void 0) {
+    logDeprecation(
+      "The `token` option is deprecated. Use `credentials` instead."
     );
-    return {
-      data: implementationsResponse2.results.map(
-        transformImplementationMetaToAppItem
-      ),
-      nextCursor: extractPaginationCursor(implementationsResponse2)
-    };
+    return options.token;
   }
-  const searchParams = {
-    selected_apis: implementationIds.join(","),
-    limit: pageSize.toString()
-  };
-  if (validatedRequest.cursor) {
-    searchParams.offset = validatedRequest.cursor;
+  const envCredentials = resolveCredentialsFromEnv(baseUrl);
+  if (envCredentials !== void 0) {
+    return envCredentials;
   }
-  const implementationsResponse = await httpClient.get(
-    "/zapier/api/v4/implementations-meta/lookup/",
-    {
-      searchParams
-    }
-  );
-  return {
-    data: implementationsResponse.results.map(
-      transformImplementationMetaToAppItem
-    ),
-    nextCursor: extractPaginationCursor(implementationsResponse)
-  };
-};
+  return void 0;
+}
+function getBaseUrlFromCredentials(credentials) {
+  if (credentials && isCredentialsObject(credentials)) {
+    return credentials.baseUrl;
+  }
+  return void 0;
+}
+function getClientIdFromCredentials(credentials) {
+  if (credentials && isCredentialsObject(credentials)) {
+    return credentials.clientId;
+  }
+  return void 0;
+}
 
-// src/api/router.ts
-var routes = [
-  {
-    method: "GET",
-    pattern: /^\/api\/v0\/apps$/,
-    handler: handleListApps,
-    paramMap: []
+// src/auth.ts
+var tokenCache = /* @__PURE__ */ new Map();
+var pendingExchanges = /* @__PURE__ */ new Map();
+function clearTokenCache() {
+  tokenCache.clear();
+  pendingExchanges.clear();
+}
+var TOKEN_EXPIRATION_BUFFER = 5 * 60 * 1e3;
+function getCachedToken(clientId) {
+  const cached = tokenCache.get(clientId);
+  if (!cached) return void 0;
+  if (cached.expiresAt > Date.now() + TOKEN_EXPIRATION_BUFFER) {
+    return cached.accessToken;
+  }
+  tokenCache.delete(clientId);
+  return void 0;
+}
+function cacheToken(clientId, accessToken, expiresIn) {
+  tokenCache.set(clientId, {
+    accessToken,
+    expiresAt: Date.now() + expiresIn * 1e3
+  });
+}
+function invalidateCachedToken(clientId) {
+  tokenCache.delete(clientId);
+}
+function getTokenEndpointUrl(baseUrl) {
+  const base = baseUrl || ZAPIER_BASE_URL;
+  return `${base}/oauth/token/`;
+}
+async function exchangeClientCredentials(options) {
+  const { clientId, clientSecret, baseUrl, scope, onEvent } = options;
+  const fetchFn = options.fetch || globalThis.fetch;
+  const tokenUrl = getTokenEndpointUrl(baseUrl);
+  onEvent?.({
+    type: "auth_exchanging",
+    payload: {
+      message: "Exchanging client credentials for token...",
+      operation: "client_credentials"
+    },
+    timestamp: Date.now()
+  });
+  const response = await fetchFn(tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: clientId,
+      client_secret: clientSecret,
+      scope: scope || "external",
+      audience: "zapier.com"
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    onEvent?.({
+      type: "auth_error",
+      payload: {
+        message: `Client credentials exchange failed: ${response.status}`,
+        error: errorText,
+        operation: "client_credentials"
+      },
+      timestamp: Date.now()
+    });
+    throw new Error(
+      `Client credentials exchange failed: ${response.status} ${response.statusText}`
+    );
   }
-];
-function findMatchingRoute(routeList, method, path) {
-  for (const route of routeList) {
-    if (route.method !== method) {
-      continue;
-    }
-    const match = path.match(route.pattern);
-    if (match) {
-      const params = {};
-      route.paramMap.forEach((name, index) => {
-        params[name] = match[index + 1];
-      });
-      return {
-        handler: route.handler,
-        params
-      };
+  const data = await response.json();
+  if (!data.access_token) {
+    throw new Error("Client credentials response missing access_token");
+  }
+  const expiresIn = data.expires_in || 3600;
+  cacheToken(clientId, data.access_token, expiresIn);
+  onEvent?.({
+    type: "auth_success",
+    payload: {
+      message: "Client credentials exchange successful",
+      operation: "client_credentials"
+    },
+    timestamp: Date.now()
+  });
+  return data.access_token;
+}
+async function getTokenFromCliLogin(options) {
+  try {
+    const cliLogin = await import('@zapier/zapier-sdk-cli-login');
+    return await cliLogin.getToken(options);
+  } catch {
+    return void 0;
+  }
+}
+async function resolveAuthToken(options = {}) {
+  const credentials = await resolveCredentials({
+    credentials: options.credentials,
+    token: options.token
+  });
+  if (credentials !== void 0) {
+    return resolveAuthTokenFromCredentials(credentials, options);
+  }
+  return getTokenFromCliLogin({
+    onEvent: options.onEvent,
+    fetch: options.fetch
+  });
+}
+async function resolveAuthTokenFromCredentials(credentials, options) {
+  if (typeof credentials === "string") {
+    return credentials;
+  }
+  if (isClientCredentials(credentials)) {
+    const { clientId } = credentials;
+    const cached = getCachedToken(clientId);
+    if (cached) {
+      return cached;
+    }
+    const pending = pendingExchanges.get(clientId);
+    if (pending) {
+      return pending;
+    }
+    const exchangePromise = exchangeClientCredentials({
+      clientId: credentials.clientId,
+      clientSecret: credentials.clientSecret,
+      baseUrl: credentials.baseUrl || options.baseUrl,
+      scope: credentials.scope,
+      fetch: options.fetch,
+      onEvent: options.onEvent
+    }).finally(() => {
+      pendingExchanges.delete(clientId);
+    });
+    pendingExchanges.set(clientId, exchangePromise);
+    return exchangePromise;
+  }
+  if (isPkceCredentials(credentials)) {
+    const storedToken = await getTokenFromCliLogin({
+      onEvent: options.onEvent,
+      fetch: options.fetch,
+      credentials
+    });
+    if (storedToken) {
+      return storedToken;
     }
+    throw new Error(
+      "PKCE credentials require interactive login. Please run the 'login' command with the CLI first, or use client_credentials flow."
+    );
   }
-  return null;
+  throw new Error("Unknown credentials type");
 }
-function matchRoute(method, path) {
-  return findMatchingRoute(routes, method, path);
+async function invalidateCredentialsToken(options) {
+  const resolved = await resolveCredentials(options);
+  const clientId = getClientIdFromCredentials(resolved);
+  if (clientId) {
+    invalidateCachedToken(clientId);
+  }
 }
 
 // src/api/client.ts
@@ -3922,13 +3879,11 @@ var ZapierApiClient = class {
   // Helper to get a token from the different places it could be gotten
   async getAuthToken() {
     return resolveAuthToken({
+      credentials: this.options.credentials,
       token: this.options.token,
-      getToken: this.options.getToken,
       onEvent: this.options.onEvent,
       fetch: this.options.fetch,
-      baseUrl: this.options.baseUrl,
-      authBaseUrl: this.options.authBaseUrl,
-      authClientId: this.options.authClientId
+      baseUrl: this.options.baseUrl
     });
   }
   // Helper to handle responses
@@ -3966,10 +3921,16 @@ var ZapierApiClient = class {
     if (response.status === 401 || response.status === 403) {
       if (wasMissingAuthToken) {
         throw new ZapierAuthenticationError(
-          `Authentication required (HTTP ${response.status}). Please provide a token in options or set ZAPIER_TOKEN environment variable.`,
+          `Authentication required (HTTP ${response.status}). Please provide credentials in options or set ZAPIER_CREDENTIALS environment variable.`,
           errorOptions
         );
       }
+      if (response.status === 401) {
+        await invalidateCredentialsToken({
+          credentials: this.options.credentials,
+          token: this.options.token
+        });
+      }
       throw new ZapierAuthenticationError(message, errorOptions);
     }
     if (response.status === 400) {
@@ -4105,7 +4066,7 @@ var ZapierApiClient = class {
     if (options.authRequired) {
       if (headers.get("Authorization") == null && authToken == null) {
         throw new ZapierAuthenticationError(
-          `Authentication required but no token available. Please set ZAPIER_TOKEN, or run the 'login' command with the CLI.`
+          `Authentication required but no credentials available. Please set ZAPIER_CREDENTIALS, or run the 'login' command with the CLI.`
         );
       }
     }
@@ -4113,20 +4074,6 @@ var ZapierApiClient = class {
   }
   // Helper to perform HTTP requests with JSON handling
   async fetchJson(method, path, data, options = {}) {
-    const routeMatch = matchRoute(method, path);
-    if (routeMatch) {
-      const handlerRequest = {
-        ...typeof data === "object" ? data : {},
-        ...options.searchParams,
-        ...routeMatch.params
-      };
-      return routeMatch.handler({
-        request: handlerRequest,
-        deps: {
-          httpClient: this
-        }
-      });
-    }
     const headers = { ...options.headers };
     if (data && typeof data === "object") {
       headers["Content-Type"] = "application/json";
@@ -4195,27 +4142,28 @@ var apiPlugin = (params) => {
   const {
     fetch: customFetch = globalThis.fetch,
     baseUrl = ZAPIER_BASE_URL,
-    authBaseUrl,
-    authClientId,
+    credentials,
     token,
-    getToken,
     onEvent,
     debug = false
   } = params.context.options;
   const api = createZapierApi({
     baseUrl,
-    authBaseUrl,
-    authClientId,
+    credentials,
     token,
-    getToken,
     debug,
     fetch: customFetch,
     onEvent
   });
   return {
     context: {
-      api
+      api,
       // Provide API client in context for other plugins to use
+      resolveCredentials: () => resolveCredentials({
+        credentials,
+        token,
+        baseUrl
+      })
     }
   };
 };
@@ -4809,7 +4757,7 @@ function getCpuTime() {
 
 // package.json
 var package_default = {
-  version: "0.18.3"};
+  version: "0.19.0"};
 
 // src/plugins/eventEmission/builders.ts
 function createBaseEvent(context = {}) {
@@ -4982,11 +4930,9 @@ var eventEmissionPlugin = ({ context }) => {
   const getUserContext = (async () => {
     try {
       const token = await resolveAuthToken({
+        credentials: context.options.credentials,
         token: context.options.token,
-        getToken: context.options.getToken,
         baseUrl: context.options.baseUrl,
-        authBaseUrl: context.options.authBaseUrl,
-        authClientId: context.options.authClientId,
         onEvent: context.options.onEvent,
         fetch: context.options.fetch
       });
@@ -5265,7 +5211,15 @@ exports.OutputPropertySchema = OutputPropertySchema;
 exports.ParamsPropertySchema = ParamsPropertySchema;
 exports.RelayFetchSchema = RelayFetchSchema;
 exports.RelayRequestSchema = RelayRequestSchema;
+exports.ZAPIER_AUTH_BASE_URL = ZAPIER_AUTH_BASE_URL;
+exports.ZAPIER_AUTH_CLIENT_ID = ZAPIER_AUTH_CLIENT_ID;
 exports.ZAPIER_BASE_URL = ZAPIER_BASE_URL;
+exports.ZAPIER_CREDENTIALS = ZAPIER_CREDENTIALS;
+exports.ZAPIER_CREDENTIALS_BASE_URL = ZAPIER_CREDENTIALS_BASE_URL;
+exports.ZAPIER_CREDENTIALS_CLIENT_ID = ZAPIER_CREDENTIALS_CLIENT_ID;
+exports.ZAPIER_CREDENTIALS_CLIENT_SECRET = ZAPIER_CREDENTIALS_CLIENT_SECRET;
+exports.ZAPIER_CREDENTIALS_SCOPE = ZAPIER_CREDENTIALS_SCOPE;
+exports.ZAPIER_TOKEN = ZAPIER_TOKEN;
 exports.ZapierActionError = ZapierActionError;
 exports.ZapierApiError = ZapierApiError;
 exports.ZapierAppNotFoundError = ZapierAppNotFoundError;
@@ -5290,6 +5244,7 @@ exports.buildApplicationLifecycleEvent = buildApplicationLifecycleEvent;
 exports.buildErrorEvent = buildErrorEvent;
 exports.buildErrorEventWithContext = buildErrorEventWithContext;
 exports.buildMethodCalledEvent = buildMethodCalledEvent;
+exports.clearTokenCache = clearTokenCache;
 exports.createBaseEvent = createBaseEvent;
 exports.createFunction = createFunction;
 exports.createSdk = createSdk;
@@ -5304,7 +5259,9 @@ exports.generateEventId = generateEventId;
 exports.getActionPlugin = getActionPlugin;
 exports.getAppPlugin = getAppPlugin;
 exports.getAuthenticationPlugin = getAuthenticationPlugin;
+exports.getBaseUrlFromCredentials = getBaseUrlFromCredentials;
 exports.getCiPlatform = getCiPlatform;
+exports.getClientIdFromCredentials = getClientIdFromCredentials;
 exports.getCpuTime = getCpuTime;
 exports.getCurrentTimestamp = getCurrentTimestamp;
 exports.getMemoryUsage = getMemoryUsage;
@@ -5314,22 +5271,30 @@ exports.getPreferredManifestEntryKey = getPreferredManifestEntryKey;
 exports.getProfilePlugin = getProfilePlugin;
 exports.getReleaseId = getReleaseId;
 exports.getTokenFromCliLogin = getTokenFromCliLogin;
-exports.getTokenFromEnv = getTokenFromEnv;
-exports.getTokenFromEnvOrConfig = getTokenFromEnvOrConfig;
 exports.inputFieldKeyResolver = inputFieldKeyResolver;
 exports.inputsAllOptionalResolver = inputsAllOptionalResolver;
 exports.inputsResolver = inputsResolver;
+exports.invalidateCachedToken = invalidateCachedToken;
+exports.invalidateCredentialsToken = invalidateCredentialsToken;
 exports.isCi = isCi;
+exports.isClientCredentials = isClientCredentials;
+exports.isCredentialsFunction = isCredentialsFunction;
+exports.isCredentialsObject = isCredentialsObject;
+exports.isPkceCredentials = isPkceCredentials;
 exports.isPositional = isPositional;
 exports.listActionsPlugin = listActionsPlugin;
 exports.listAppsPlugin = listAppsPlugin;
 exports.listAuthenticationsPlugin = listAuthenticationsPlugin;
 exports.listInputFieldsPlugin = listInputFieldsPlugin;
+exports.logDeprecation = logDeprecation;
 exports.manifestPlugin = manifestPlugin;
 exports.readManifestFromFile = readManifestFromFile;
 exports.registryPlugin = registryPlugin;
 exports.requestPlugin = requestPlugin;
+exports.resetDeprecationWarnings = resetDeprecationWarnings;
 exports.resolveAuthToken = resolveAuthToken;
+exports.resolveCredentials = resolveCredentials;
+exports.resolveCredentialsFromEnv = resolveCredentialsFromEnv;
 exports.runActionPlugin = runActionPlugin;
 exports.toSnakeCase = toSnakeCase;
 exports.toTitleCase = toTitleCase;