@zapier/zapier-sdk 0.15.11 → 0.15.12

package/dist/index.mjs

@@ -710,9 +710,9 @@ function createPageFunction(coreFn) {
   };
   return namedFunctions[functionName];
 }
-function createPaginatedFunction(coreFn, schema, telemetry) {
+function createPaginatedFunction(coreFn, schema, telemetry, explicitFunctionName) {
   const pageFunction = createPageFunction(coreFn);
-  const functionName = coreFn.name;
+  const functionName = explicitFunctionName || coreFn.name;
   const validator = schema ? createValidator(schema) : null;
   const namedFunctions = {
     [functionName]: function(options) {
@@ -1284,6 +1284,9 @@ function toSnakeCase(input) {
   }
   return result;
 }
+function stripPageSuffix(functionName) {
+  return functionName.replace(/Page$/, "");
+}
 
 // src/schemas/App.ts
 var AppItemSchema2 = withFormatter(
@@ -1335,50 +1338,53 @@ function createTelemetryCallback(emitMethodCalled, methodName) {
 
 // src/plugins/listApps/index.ts
 var listAppsPlugin = ({ context }) => {
-  const listApps = createPaginatedFunction(
-    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
-        };
+  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 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, "listApps")
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
   );
   return {
-    listApps,
+    listApps: listAppsDefinition,
     context: {
       meta: {
         listApps: {
@@ -1767,72 +1773,72 @@ var listActionsPlugin = ({ context }) => {
       actionType: actionTypeResolver
     }
   };
-  const listActions = createPaginatedFunction(
-    async function listActionsPage(options) {
-      const { api, getVersionedImplementationId } = context;
-      const selectedApi = await getVersionedImplementationId(options.appKey);
-      if (!selectedApi) {
-        throw new ZapierConfigurationError(
-          "No current_implementation_id found for app",
-          { configType: "current_implementation_id" }
-        );
-      }
-      const searchParams = {
-        global: "true",
-        public_only: "true",
-        selected_apis: selectedApi
-      };
-      const data = await api.get(
-        "/zapier/api/v4/implementations/",
-        {
-          searchParams,
-          customErrorHandler: ({ status }) => {
-            if (status === 401) {
-              return new ZapierAuthenticationError(
-                `Authentication failed. Your token may not have permission to access implementations or may be expired. (HTTP ${status})`,
-                { statusCode: status }
-              );
-            }
-            if (status === 403) {
-              return new ZapierAuthenticationError(
-                `Access forbidden. Your token may not have the required scopes to list implementations. (HTTP ${status})`,
-                { statusCode: status }
-              );
-            }
-            return void 0;
-          }
-        }
+  async function listActionsPage(options) {
+    const { api, getVersionedImplementationId } = context;
+    const selectedApi = await getVersionedImplementationId(options.appKey);
+    if (!selectedApi) {
+      throw new ZapierConfigurationError(
+        "No current_implementation_id found for app",
+        { configType: "current_implementation_id" }
       );
-      let allActions = [];
-      for (const implementation of data.results || []) {
-        if (implementation.actions) {
-          for (const action of implementation.actions) {
-            const actionWithContext = {
-              ...action,
-              selected_api: action.selected_api || implementation.selected_api
-            };
-            allActions.push(normalizeActionItem(actionWithContext));
+    }
+    const searchParams = {
+      global: "true",
+      public_only: "true",
+      selected_apis: selectedApi
+    };
+    const data = await api.get(
+      "/zapier/api/v4/implementations/",
+      {
+        searchParams,
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to access implementations or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
           }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to list implementations. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          return void 0;
         }
       }
-      if (options.actionType) {
-        allActions = allActions.filter(
-          (action) => action.action_type === options.actionType
-        );
+    );
+    let allActions = [];
+    for (const implementation of data.results || []) {
+      if (implementation.actions) {
+        for (const action of implementation.actions) {
+          const actionWithContext = {
+            ...action,
+            selected_api: action.selected_api || implementation.selected_api
+          };
+          allActions.push(normalizeActionItem(actionWithContext));
+        }
       }
-      return {
-        data: allActions,
-        nextCursor: void 0
-      };
-    },
+    }
+    if (options.actionType) {
+      allActions = allActions.filter(
+        (action) => action.action_type === options.actionType
+      );
+    }
+    return {
+      data: allActions,
+      nextCursor: void 0
+    };
+  }
+  const methodName = stripPageSuffix(listActionsPage.name);
+  const listActionsDefinition = createPaginatedFunction(
+    listActionsPage,
     ListActionsSchema,
-    createTelemetryCallback(
-      context.eventEmission.emitMethodCalled,
-      "listActions"
-    )
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
   );
   return {
-    listActions,
+    listActions: listActionsDefinition,
     context: {
       meta: {
         listActions: methodMeta
@@ -2128,51 +2134,51 @@ function transformNeedsToFields(needs) {
   return rootFields;
 }
 var listInputFieldsPlugin = ({ sdk, context }) => {
-  const listInputFields = createPaginatedFunction(
-    async function listInputFieldsPage(options) {
-      const { api, getVersionedImplementationId } = context;
-      const {
-        appKey,
-        actionKey,
-        actionType,
-        authenticationId = null,
-        inputs
-      } = options;
-      const selectedApi = await getVersionedImplementationId(appKey);
-      if (!selectedApi) {
-        throw new ZapierConfigurationError(
-          "No current_implementation_id found for app",
-          { configType: "current_implementation_id" }
-        );
-      }
-      const { data: action } = await sdk.getAction({
-        appKey,
-        actionType,
-        actionKey
-      });
-      const needsData = await fetchImplementationNeeds({
-        api,
-        selectedApi,
-        action: action.key,
-        actionType,
-        authenticationId,
-        inputs
-      });
-      const rootFieldset = transformNeedsToFields(needsData.needs || []);
-      return {
-        data: rootFieldset,
-        nextCursor: void 0
-        // No pagination needed since we return all input fields
-      };
-    },
+  async function listInputFieldsPage(options) {
+    const { api, getVersionedImplementationId } = context;
+    const {
+      appKey,
+      actionKey,
+      actionType,
+      authenticationId = null,
+      inputs
+    } = options;
+    const selectedApi = await getVersionedImplementationId(appKey);
+    if (!selectedApi) {
+      throw new ZapierConfigurationError(
+        "No current_implementation_id found for app",
+        { configType: "current_implementation_id" }
+      );
+    }
+    const { data: action } = await sdk.getAction({
+      appKey,
+      actionType,
+      actionKey
+    });
+    const needsData = await fetchImplementationNeeds({
+      api,
+      selectedApi,
+      action: action.key,
+      actionType,
+      authenticationId,
+      inputs
+    });
+    const rootFieldset = transformNeedsToFields(needsData.needs || []);
+    return {
+      data: rootFieldset,
+      nextCursor: void 0
+      // No pagination needed since we return all input fields
+    };
+  }
+  const methodName = stripPageSuffix(listInputFieldsPage.name);
+  const listInputFieldsDefinition = createPaginatedFunction(
+    listInputFieldsPage,
     ListInputFieldsSchema,
-    createTelemetryCallback(
-      context.eventEmission.emitMethodCalled,
-      "listInputFields"
-    )
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
   );
   return {
-    listInputFields,
+    listInputFields: listInputFieldsDefinition,
     context: {
       meta: {
         listInputFields: {
@@ -2254,78 +2260,78 @@ var AuthenticationItemSchema = withFormatter(
 
 // src/plugins/listAuthentications/index.ts
 var listAuthenticationsPlugin = ({ context }) => {
-  const listAuthentications = createPaginatedFunction(
-    async function listAuthenticationsPage(options) {
-      const { api, getVersionedImplementationId } = context;
-      const searchParams = {};
-      if (options.appKey) {
-        const implementationId = await getVersionedImplementationId(
-          options.appKey
-        );
-        if (implementationId) {
-          const [versionlessSelectedApi] = splitVersionedKey(implementationId);
-          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) {
-        searchParams.search = options.title;
-      }
-      if (options.accountId) {
-        searchParams.account_id = options.accountId;
-      }
-      if (options.owner) {
-        searchParams.owner = options.owner;
-      }
-      searchParams.limit = options.pageSize.toString();
-      if (options.cursor) {
-        searchParams.offset = options.cursor;
-      }
-      const data = await api.get(
-        "/zapier/api/v4/authentications/",
-        {
-          searchParams,
-          customErrorHandler: ({ status }) => {
-            if (status === 401) {
-              return new ZapierAuthenticationError(
-                `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${status})`,
-                { statusCode: status }
-              );
-            }
-            if (status === 403) {
-              return new ZapierAuthenticationError(
-                `Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${status})`,
-                { statusCode: status }
-              );
-            }
-            return void 0;
-          },
-          authRequired: true
-        }
-      );
-      let auths = (data.results || []).map(
-        (auth) => normalizeAuthenticationItem(auth)
+  async function listAuthenticationsPage(options) {
+    const { api, getVersionedImplementationId } = context;
+    const searchParams = {};
+    if (options.appKey) {
+      const implementationId = await getVersionedImplementationId(
+        options.appKey
       );
-      if (options.title) {
-        auths = auths.filter((auth) => auth.title === options.title);
+      if (implementationId) {
+        const [versionlessSelectedApi] = splitVersionedKey(implementationId);
+        searchParams.versionless_selected_api = versionlessSelectedApi;
       }
-      return {
-        data: auths,
-        nextCursor: extractCursor(data)
-      };
-    },
+    }
+    if (options.authenticationIds && options.authenticationIds.length > 0) {
+      searchParams.ids = options.authenticationIds.join(",");
+    }
+    if (options.search) {
+      searchParams.search = options.search;
+    } else if (options.title) {
+      searchParams.search = options.title;
+    }
+    if (options.accountId) {
+      searchParams.account_id = options.accountId;
+    }
+    if (options.owner) {
+      searchParams.owner = options.owner;
+    }
+    searchParams.limit = options.pageSize.toString();
+    if (options.cursor) {
+      searchParams.offset = options.cursor;
+    }
+    const data = await api.get(
+      "/zapier/api/v4/authentications/",
+      {
+        searchParams,
+        customErrorHandler: ({ status }) => {
+          if (status === 401) {
+            return new ZapierAuthenticationError(
+              `Authentication failed. Your token may not have permission to access authentications or may be expired. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          if (status === 403) {
+            return new ZapierAuthenticationError(
+              `Access forbidden. Your token may not have the required scopes to list authentications. (HTTP ${status})`,
+              { statusCode: status }
+            );
+          }
+          return void 0;
+        },
+        authRequired: true
+      }
+    );
+    let auths = (data.results || []).map(
+      (auth) => normalizeAuthenticationItem(auth)
+    );
+    if (options.title) {
+      auths = auths.filter((auth) => auth.title === options.title);
+    }
+    return {
+      data: auths,
+      nextCursor: extractCursor(data)
+    };
+  }
+  const methodName = stripPageSuffix(listAuthenticationsPage.name);
+  const listAuthenticationsDefinition = createPaginatedFunction(
+    listAuthenticationsPage,
     ListAuthenticationsSchema,
-    createTelemetryCallback(
-      context.eventEmission.emitMethodCalled,
-      "listAuthentications"
-    )
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
   );
   return {
-    listAuthentications,
+    listAuthentications: listAuthenticationsDefinition,
     context: {
       meta: {
         listAuthentications: {
@@ -2350,26 +2356,30 @@ var GetAppSchema = z.object({
 
 // src/plugins/getApp/index.ts
 var getAppPlugin = ({ sdk, context }) => {
-  const getApp = createFunction(
-    async function getApp2(options) {
-      const appsIterator = sdk.listApps({
-        appKeys: [options.appKey],
-        _telemetry: { isNested: true }
-      }).items();
-      for await (const app of appsIterator) {
-        return {
-          data: app
-        };
-      }
-      throw new ZapierAppNotFoundError("App not found", {
-        appKey: options.appKey
-      });
-    },
+  async function getApp(options) {
+    const appsIterator = sdk.listApps({
+      appKeys: [options.appKey],
+      _telemetry: { isNested: true }
+    }).items();
+    for await (const app of appsIterator) {
+      return {
+        data: app
+      };
+    }
+    throw new ZapierAppNotFoundError("App not found", {
+      appKey: options.appKey
+    });
+  }
+  const getAppDefinition = createFunction(
+    getApp,
     GetAppSchema,
-    createTelemetryCallback(context.eventEmission.emitMethodCalled, "getApp")
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      getApp.name
+    )
   );
   return {
-    getApp,
+    getApp: getAppDefinition,
     context: {
       meta: {
         getApp: {
@@ -2394,27 +2404,28 @@ var GetActionSchema = z.object({
 
 // src/plugins/getAction/index.ts
 var getActionPlugin = ({ sdk, context }) => {
-  const getAction = createFunction(
-    async function getAction2(options) {
-      const { actionKey, actionType, appKey } = options;
-      for await (const action of sdk.listActions({ appKey, _telemetry: { isNested: true } }).items()) {
-        if ((action.key === actionKey || action.id === actionKey) && action.action_type === actionType) {
-          return { data: action };
-        }
+  async function getAction(options) {
+    const { actionKey, actionType, appKey } = options;
+    for await (const action of sdk.listActions({ appKey, _telemetry: { isNested: true } }).items()) {
+      if ((action.key === actionKey || action.id === actionKey) && action.action_type === actionType) {
+        return { data: action };
       }
-      throw new ZapierResourceNotFoundError(
-        `Action not found: ${actionKey} with type ${actionType}`,
-        { resourceType: "Action", resourceId: `${actionKey} (${actionType})` }
-      );
-    },
+    }
+    throw new ZapierResourceNotFoundError(
+      `Action not found: ${actionKey} with type ${actionType}`,
+      { resourceType: "Action", resourceId: `${actionKey} (${actionType})` }
+    );
+  }
+  const getActionDefinition = createFunction(
+    getAction,
     GetActionSchema,
     createTelemetryCallback(
       context.eventEmission.emitMethodCalled,
-      "getAction"
+      getAction.name
     )
   );
   return {
-    getAction,
+    getAction: getActionDefinition,
     context: {
       meta: {
         getAction: {
@@ -2489,21 +2500,22 @@ z.object({
 
 // src/plugins/getAuthentication/index.ts
 var getAuthenticationPlugin = ({ context }) => {
-  const getAuthentication = createFunction(
-    async function getAuthentication2(options) {
-      const { api } = context;
-      return await api.get(
-        `/api/v0/authentications/${options.authenticationId}`
-      );
-    },
+  async function getAuthentication(options) {
+    const { api } = context;
+    return await api.get(
+      `/api/v0/authentications/${options.authenticationId}`
+    );
+  }
+  const getAuthenticationDefinition = createFunction(
+    getAuthentication,
     GetAuthenticationOptionsSchema,
     createTelemetryCallback(
       context.eventEmission.emitMethodCalled,
-      "getAuthentication"
+      getAuthentication.name
     )
   );
   return {
-    getAuthentication,
+    getAuthentication: getAuthenticationDefinition,
     context: {
       meta: {
         getAuthentication: {
@@ -2532,31 +2544,32 @@ var FindFirstAuthenticationSchema = z.object({
 
 // src/plugins/findFirstAuthentication/index.ts
 var findFirstAuthenticationPlugin = ({ sdk, context }) => {
-  const findFirstAuthentication = createFunction(
-    async function findFirstAuthentication2(options = {}) {
-      const authsResponse = await sdk.listAuthentications({
-        ...options,
-        maxItems: 1,
-        _telemetry: { isNested: true }
-      });
-      if (authsResponse.data.length === 0) {
-        throw new ZapierResourceNotFoundError(
-          "No authentication found matching the specified criteria",
-          { resourceType: "Authentication" }
-        );
-      }
-      return {
-        data: authsResponse.data[0]
-      };
-    },
+  async function findFirstAuthentication(options = {}) {
+    const authsResponse = await sdk.listAuthentications({
+      ...options,
+      maxItems: 1,
+      _telemetry: { isNested: true }
+    });
+    if (authsResponse.data.length === 0) {
+      throw new ZapierResourceNotFoundError(
+        "No authentication found matching the specified criteria",
+        { resourceType: "Authentication" }
+      );
+    }
+    return {
+      data: authsResponse.data[0]
+    };
+  }
+  const findFirstAuthenticationDefinition = createFunction(
+    findFirstAuthentication,
     FindFirstAuthenticationSchema,
     createTelemetryCallback(
       context.eventEmission.emitMethodCalled,
-      "findFirstAuthentication"
+      findFirstAuthentication.name
     )
   );
   return {
-    findFirstAuthentication,
+    findFirstAuthentication: findFirstAuthenticationDefinition,
     context: {
       meta: {
         findFirstAuthentication: {
@@ -2582,37 +2595,38 @@ var FindUniqueAuthenticationSchema = z.object({
 
 // src/plugins/findUniqueAuthentication/index.ts
 var findUniqueAuthenticationPlugin = ({ sdk, context }) => {
-  const findUniqueAuthentication = createFunction(
-    async function findUniqueAuthentication2(options = {}) {
-      const authsResponse = await sdk.listAuthentications({
-        ...options,
-        maxItems: 2,
-        // Get up to 2 to check for uniqueness
-        _telemetry: { isNested: true }
-      });
-      if (authsResponse.data.length === 0) {
-        throw new ZapierResourceNotFoundError(
-          "No authentication found matching the specified criteria",
-          { resourceType: "Authentication" }
-        );
-      }
-      if (authsResponse.data.length > 1) {
-        throw new ZapierValidationError(
-          "Multiple authentications found matching the specified criteria. Expected exactly one."
-        );
-      }
-      return {
-        data: authsResponse.data[0]
-      };
-    },
+  async function findUniqueAuthentication(options = {}) {
+    const authsResponse = await sdk.listAuthentications({
+      ...options,
+      maxItems: 2,
+      // Get up to 2 to check for uniqueness
+      _telemetry: { isNested: true }
+    });
+    if (authsResponse.data.length === 0) {
+      throw new ZapierResourceNotFoundError(
+        "No authentication found matching the specified criteria",
+        { resourceType: "Authentication" }
+      );
+    }
+    if (authsResponse.data.length > 1) {
+      throw new ZapierValidationError(
+        "Multiple authentications found matching the specified criteria. Expected exactly one."
+      );
+    }
+    return {
+      data: authsResponse.data[0]
+    };
+  }
+  const findUniqueAuthenticationDefinition = createFunction(
+    findUniqueAuthentication,
     FindUniqueAuthenticationSchema,
     createTelemetryCallback(
       context.eventEmission.emitMethodCalled,
-      "findUniqueAuthentication"
+      findUniqueAuthentication.name
     )
   );
   return {
-    findUniqueAuthentication,
+    findUniqueAuthentication: findUniqueAuthenticationDefinition,
     context: {
       meta: {
         findUniqueAuthentication: {
@@ -2683,65 +2697,62 @@ async function executeAction(actionOptions) {
   });
 }
 var runActionPlugin = ({ sdk, context }) => {
-  const runAction = createPaginatedFunction(
-    async function runActionPage(options) {
-      const { api } = context;
-      const {
-        appKey,
-        actionKey,
-        actionType,
-        authenticationId,
-        inputs = {}
-      } = options;
-      const actionData = await sdk.getAction({
+  async function runActionPage(options) {
+    const { api } = context;
+    const {
+      appKey,
+      actionKey,
+      actionType,
+      authenticationId,
+      inputs = {}
+    } = options;
+    const actionData = await sdk.getAction({
+      appKey,
+      actionKey,
+      actionType,
+      _telemetry: { isNested: true }
+    });
+    if (actionData.data.action_type !== actionType) {
+      throw new ZapierValidationError(
+        `Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`
+      );
+    }
+    const actionId = actionData.data.id;
+    const result = await executeAction({
+      api,
+      context,
+      appKey,
+      // Some actions require the action ID to run them, but technically the ID is not guaranteed to be available when
+      // we retrieve actions (probably legacy reasons), so we just pass along all the things!
+      actionId,
+      actionKey,
+      actionType,
+      executionOptions: { inputs },
+      authenticationId});
+    if (result.errors && result.errors.length > 0) {
+      const errorMessage = result.errors.map(
+        (error) => error.detail || error.title || "Unknown error"
+      ).join("; ");
+      throw new ZapierActionError(`Action execution failed: ${errorMessage}`, {
         appKey,
-        actionKey,
-        actionType,
-        _telemetry: { isNested: true }
+        actionKey
       });
-      if (actionData.data.action_type !== actionType) {
-        throw new ZapierValidationError(
-          `Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`
-        );
-      }
-      const actionId = actionData.data.id;
-      const result = await executeAction({
-        api,
-        context,
-        appKey,
-        // Some actions require the action ID to run them, but technically the ID is not guaranteed to be available when
-        // we retrieve actions (probably legacy reasons), so we just pass along all the things!
-        actionId,
-        actionKey,
-        actionType,
-        executionOptions: { inputs },
-        authenticationId});
-      if (result.errors && result.errors.length > 0) {
-        const errorMessage = result.errors.map(
-          (error) => error.detail || error.title || "Unknown error"
-        ).join("; ");
-        throw new ZapierActionError(
-          `Action execution failed: ${errorMessage}`,
-          {
-            appKey,
-            actionKey
-          }
-        );
-      }
-      return {
-        data: result.results || [],
-        nextCursor: void 0
-        // No pagination implemented yet
-      };
-    },
+    }
+    return {
+      data: result.results || [],
+      nextCursor: void 0
+      // No pagination implemented yet
+    };
+  }
+  const methodName = stripPageSuffix(runActionPage.name);
+  const runActionDefinition = createPaginatedFunction(
+    runActionPage,
     RunActionSchema,
-    createTelemetryCallback(
-      context.eventEmission.emitMethodCalled,
-      "runAction"
-    )
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
   );
   return {
-    runAction,
+    runAction: runActionDefinition,
     context: {
       meta: {
         runAction: {
@@ -2788,46 +2799,50 @@ function transformUrlToRelayPath(url) {
   return relayPath;
 }
 var requestPlugin = ({ context }) => {
-  const request = createFunction(
-    async function request2(options) {
-      const { api } = context;
-      const {
-        url,
-        method = "GET",
-        body,
-        headers: optionsHeaders,
-        authenticationId,
-        callbackUrl,
-        authenticationTemplate
-      } = options;
-      const relayPath = transformUrlToRelayPath(url);
-      const headers = {};
-      if (optionsHeaders) {
-        const headerEntries = optionsHeaders instanceof Headers ? Array.from(optionsHeaders.entries()) : Array.isArray(optionsHeaders) ? optionsHeaders : Object.entries(optionsHeaders);
-        for (const [key, value] of headerEntries) {
-          headers[key] = value;
-        }
-      }
-      if (authenticationId) {
-        headers["X-Relay-Authentication-Id"] = authenticationId.toString();
-      }
-      if (callbackUrl) {
-        headers["X-Relay-Callback-Url"] = callbackUrl;
-      }
-      if (authenticationTemplate) {
-        headers["X-Authentication-Template"] = authenticationTemplate;
+  async function request(options) {
+    const { api } = context;
+    const {
+      url,
+      method = "GET",
+      body,
+      headers: optionsHeaders,
+      authenticationId,
+      callbackUrl,
+      authenticationTemplate
+    } = options;
+    const relayPath = transformUrlToRelayPath(url);
+    const headers = {};
+    if (optionsHeaders) {
+      const headerEntries = optionsHeaders instanceof Headers ? Array.from(optionsHeaders.entries()) : Array.isArray(optionsHeaders) ? optionsHeaders : Object.entries(optionsHeaders);
+      for (const [key, value] of headerEntries) {
+        headers[key] = value;
       }
-      return await api.fetch(relayPath, {
-        method,
-        body,
-        headers
-      });
-    },
+    }
+    if (authenticationId) {
+      headers["X-Relay-Authentication-Id"] = authenticationId.toString();
+    }
+    if (callbackUrl) {
+      headers["X-Relay-Callback-Url"] = callbackUrl;
+    }
+    if (authenticationTemplate) {
+      headers["X-Authentication-Template"] = authenticationTemplate;
+    }
+    return await api.fetch(relayPath, {
+      method,
+      body,
+      headers
+    });
+  }
+  const requestDefinition = createFunction(
+    request,
     RelayRequestSchema,
-    createTelemetryCallback(context.eventEmission.emitMethodCalled, "request")
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      request.name
+    )
   );
   return {
-    request,
+    request: requestDefinition,
     context: {
       meta: {
         request: {
@@ -3330,32 +3345,33 @@ var UserProfileItemSchema = withFormatter(
 
 // src/plugins/getProfile/index.ts
 var getProfilePlugin = ({ context }) => {
-  const getProfile = createFunction(
-    async function getProfile2() {
-      const profile = await context.api.get(
-        "/zapier/api/v4/profile/",
-        {
-          authRequired: true
-        }
-      );
-      const { user_id: _unusedUserId, ...data } = profile;
-      return {
-        data: {
-          ...data,
-          // Pass through all API response fields
-          full_name: `${profile.first_name} ${profile.last_name}`
-          // Computed field
-        }
-      };
-    },
+  async function getProfile() {
+    const profile = await context.api.get(
+      "/zapier/api/v4/profile/",
+      {
+        authRequired: true
+      }
+    );
+    const { user_id: _unusedUserId, ...data } = profile;
+    return {
+      data: {
+        ...data,
+        // Pass through all API response fields
+        full_name: `${profile.first_name} ${profile.last_name}`
+        // Computed field
+      }
+    };
+  }
+  const getProfileDefinition = createFunction(
+    getProfile,
     GetProfileSchema,
     createTelemetryCallback(
       context.eventEmission.emitMethodCalled,
-      "getProfile"
+      getProfile.name
     )
   );
   return {
-    getProfile,
+    getProfile: getProfileDefinition,
     context: {
       meta: {
         getProfile: {
@@ -4598,48 +4614,49 @@ var GetInputFieldsSchemaSchema = z.object({
 
 // src/plugins/getInputFieldsSchema/index.ts
 var getInputFieldsSchemaPlugin = ({ sdk, context }) => {
-  const getInputFieldsSchema = createFunction(
-    async function getInputFieldsSchema2(options) {
-      const { api, getVersionedImplementationId } = context;
-      const {
-        appKey,
-        actionKey,
-        actionType,
-        authenticationId = null,
-        inputs
-      } = options;
-      const selectedApi = await getVersionedImplementationId(appKey);
-      if (!selectedApi) {
-        throw new ZapierConfigurationError(
-          "No current_implementation_id found for app",
-          { configType: "current_implementation_id" }
-        );
-      }
-      const { data: action } = await sdk.getAction({
-        appKey,
-        actionType,
-        actionKey
-      });
-      const needsData = await fetchImplementationNeeds({
-        api,
-        selectedApi,
-        action: action.key,
-        actionType,
-        authenticationId,
-        inputs
-      });
-      return {
-        data: needsData.schema || {}
-      };
-    },
+  async function getInputFieldsSchema(options) {
+    const { api, getVersionedImplementationId } = context;
+    const {
+      appKey,
+      actionKey,
+      actionType,
+      authenticationId = null,
+      inputs
+    } = options;
+    const selectedApi = await getVersionedImplementationId(appKey);
+    if (!selectedApi) {
+      throw new ZapierConfigurationError(
+        "No current_implementation_id found for app",
+        { configType: "current_implementation_id" }
+      );
+    }
+    const { data: action } = await sdk.getAction({
+      appKey,
+      actionType,
+      actionKey
+    });
+    const needsData = await fetchImplementationNeeds({
+      api,
+      selectedApi,
+      action: action.key,
+      actionType,
+      authenticationId,
+      inputs
+    });
+    return {
+      data: needsData.schema || {}
+    };
+  }
+  const getInputFieldsSchemaDefinition = createFunction(
+    getInputFieldsSchema,
     GetInputFieldsSchemaSchema,
     createTelemetryCallback(
       context.eventEmission.emitMethodCalled,
-      "getInputFieldsSchema"
+      getInputFieldsSchema.name
     )
   );
   return {
-    getInputFieldsSchema,
+    getInputFieldsSchema: getInputFieldsSchemaDefinition,
     context: {
       meta: {
         getInputFieldsSchema: {
@@ -4708,94 +4725,94 @@ function transformNeedChoicesToInputFieldChoiceItem(choice) {
   };
 }
 var listInputFieldChoicesPlugin = ({ context, sdk }) => {
-  const listInputFieldChoices = createPaginatedFunction(
-    async function listInputFieldChoicesPage(options) {
-      const { api, getVersionedImplementationId } = context;
-      const {
-        appKey,
-        actionType,
-        actionKey,
-        inputFieldKey,
-        authenticationId = null,
-        inputs,
-        page,
-        cursor
-      } = options;
-      const selectedApi = await getVersionedImplementationId(appKey);
-      if (!selectedApi) {
-        throw new ZapierConfigurationError(
-          "No current_implementation_id found for app",
-          { configType: "current_implementation_id" }
-        );
-      }
-      const { data: action } = await sdk.getAction({
-        appKey,
-        actionType,
-        actionKey
-      });
-      const needsData = await fetchImplementationNeeds({
-        api,
-        selectedApi,
-        action: action.key,
-        actionType,
-        authenticationId,
-        inputs
-      });
-      const targetNeed = needsData.needs?.find(
-        (need) => need.key === inputFieldKey
+  async function listInputFieldChoicesPage(options) {
+    const { api, getVersionedImplementationId } = context;
+    const {
+      appKey,
+      actionType,
+      actionKey,
+      inputFieldKey,
+      authenticationId = null,
+      inputs,
+      page,
+      cursor
+    } = options;
+    const selectedApi = await getVersionedImplementationId(appKey);
+    if (!selectedApi) {
+      throw new ZapierConfigurationError(
+        "No current_implementation_id found for app",
+        { configType: "current_implementation_id" }
       );
-      if (targetNeed?.choices && targetNeed.choices.length > 0) {
-        return {
-          data: targetNeed.choices.map(
-            transformNeedChoicesToInputFieldChoiceItem
-          ),
-          nextCursor: void 0
-        };
-      }
-      if (!action.id) {
-        throw new ZapierApiError(
-          `Action ${actionKey} does not have an ID - cannot retrieve input field choices`
-        );
-      }
-      const requestPage = cursor ? parseInt(cursor, 10) : page ?? 0;
-      const choicesData = await fetchImplementationChoices({
-        api,
-        actionId: action.id,
-        inputFieldId: inputFieldKey,
-        authenticationId,
-        inputs,
-        page: requestPage
-      });
-      const choices = (choicesData.choices || []).map(
-        transformNeedChoicesToInputFieldChoiceItem
+    }
+    const { data: action } = await sdk.getAction({
+      appKey,
+      actionType,
+      actionKey
+    });
+    const needsData = await fetchImplementationNeeds({
+      api,
+      selectedApi,
+      action: action.key,
+      actionType,
+      authenticationId,
+      inputs
+    });
+    const targetNeed = needsData.needs?.find(
+      (need) => need.key === inputFieldKey
+    );
+    if (targetNeed?.choices && targetNeed.choices.length > 0) {
+      return {
+        data: targetNeed.choices.map(
+          transformNeedChoicesToInputFieldChoiceItem
+        ),
+        nextCursor: void 0
+      };
+    }
+    if (!action.id) {
+      throw new ZapierApiError(
+        `Action ${actionKey} does not have an ID - cannot retrieve input field choices`
       );
-      let nextCursor;
-      if (choicesData.next_page != null) {
-        nextCursor = choicesData.next_page.toString();
-      } else if (choicesData.links?.next) {
-        try {
-          const nextUrl = new URL(choicesData.links.next);
-          const nextPage = nextUrl.searchParams.get("page");
-          if (nextPage) {
-            nextCursor = nextPage;
-          }
-        } catch {
-          nextCursor = void 0;
+    }
+    const requestPage = cursor ? parseInt(cursor, 10) : page ?? 0;
+    const choicesData = await fetchImplementationChoices({
+      api,
+      actionId: action.id,
+      inputFieldId: inputFieldKey,
+      authenticationId,
+      inputs,
+      page: requestPage
+    });
+    const choices = (choicesData.choices || []).map(
+      transformNeedChoicesToInputFieldChoiceItem
+    );
+    let nextCursor;
+    if (choicesData.next_page != null) {
+      nextCursor = choicesData.next_page.toString();
+    } else if (choicesData.links?.next) {
+      try {
+        const nextUrl = new URL(choicesData.links.next);
+        const nextPage = nextUrl.searchParams.get("page");
+        if (nextPage) {
+          nextCursor = nextPage;
         }
+      } catch {
+        nextCursor = void 0;
       }
-      return {
-        data: choices,
-        nextCursor
-      };
-    },
+    }
+    return {
+      data: choices,
+      nextCursor
+    };
+  }
+  const methodName = stripPageSuffix(listInputFieldChoicesPage.name);
+  const listInputFieldChoicesDefinition = createPaginatedFunction(
+    listInputFieldChoicesPage,
     ListInputFieldChoicesSchema,
-    createTelemetryCallback(
-      context.eventEmission.emitMethodCalled,
-      "listInputFieldChoices"
-    )
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
   );
   return {
-    listInputFieldChoices,
+    listInputFieldChoices: listInputFieldChoicesDefinition,
     context: {
       meta: {
         listInputFieldChoices: {
@@ -4969,7 +4986,7 @@ function getCpuTime() {
 
 // package.json
 var package_default = {
-  version: "0.15.11"};
+  version: "0.15.12"};
 
 // src/plugins/eventEmission/builders.ts
 function createBaseEvent(context = {}) {