@zapier/zapier-sdk 0.15.10 → 0.15.12

package/dist/index.cjs

@@ -390,24 +390,49 @@ var FetchInitSchema = zod.z.object({
 }).optional().describe("Fetch options including authentication");
 
 // src/plugins/fetch/index.ts
-var fetchPlugin = ({ sdk }) => {
+var fetchPlugin = ({ sdk, context }) => {
   return {
     fetch: async function fetch2(url, init) {
-      const {
-        authenticationId,
-        callbackUrl,
-        authenticationTemplate,
-        ...fetchInit
-      } = init || {};
-      return sdk.request({
-        url: url.toString(),
-        method: fetchInit.method,
-        body: fetchInit.body,
-        headers: fetchInit.headers,
-        authenticationId,
-        callbackUrl,
-        authenticationTemplate
-      });
+      const startTime = Date.now();
+      try {
+        const {
+          authenticationId,
+          callbackUrl,
+          authenticationTemplate,
+          ...fetchInit
+        } = init || {};
+        const result = await sdk.request({
+          url: url.toString(),
+          method: fetchInit.method,
+          body: fetchInit.body,
+          headers: fetchInit.headers,
+          authenticationId,
+          callbackUrl,
+          authenticationTemplate,
+          _telemetry: { isNested: true }
+        });
+        context.eventEmission.emitMethodCalled({
+          method_name: "fetch",
+          execution_duration_ms: Date.now() - startTime,
+          success_flag: true,
+          error_message: null,
+          error_type: null,
+          argument_count: init ? 2 : 1,
+          is_paginated: false
+        });
+        return result;
+      } catch (error) {
+        context.eventEmission.emitMethodCalled({
+          method_name: "fetch",
+          execution_duration_ms: Date.now() - startTime,
+          success_flag: false,
+          error_message: error instanceof Error ? error.message : String(error),
+          error_type: error instanceof Error ? error.constructor.name : "Unknown",
+          argument_count: init ? 2 : 1,
+          is_paginated: false
+        });
+        throw error;
+      }
     },
     context: {
       meta: {
@@ -596,6 +621,11 @@ var validateOptions = (schema, options) => {
 };
 
 // src/utils/function-utils.ts
+var TelemetryMarkerSchema = zod.z.object({
+  _telemetry: zod.z.object({
+    isNested: zod.z.boolean().optional()
+  }).optional()
+});
 function extractCursor(data) {
   if (!data?.next) {
     return void 0;
@@ -615,22 +645,64 @@ function normalizeError(error) {
   const message = error instanceof Error ? error.message : String(error);
   return new ZapierUnknownError(`Unknown error: ${message}`, { cause: error });
 }
-function createFunction(coreFn, schema) {
+function createFunction(coreFn, schema, telemetry) {
   const functionName = coreFn.name;
   const namedFunctions = {
     [functionName]: async function(options) {
+      const startTime = Date.now();
+      const normalizedOptions = options ?? {};
+      const isNested = normalizedOptions?._telemetry?.isNested === true;
       try {
-        const normalizedOptions = options ?? {};
         if (schema) {
           const validatedOptions = validateOptions(schema, normalizedOptions);
-          return await coreFn({
+          const result2 = await coreFn({
             ...normalizedOptions,
             ...validatedOptions
           });
+          if (!isNested && telemetry?.onMethodCalled) {
+            const argumentCount = Object.keys(
+              normalizedOptions
+            ).filter((k) => k !== "_telemetry").length;
+            telemetry.onMethodCalled({
+              methodName: functionName,
+              durationMs: Date.now() - startTime,
+              success: true,
+              argumentCount,
+              isPaginated: false
+            });
+          }
+          return result2;
+        }
+        const result = await coreFn(normalizedOptions);
+        if (!isNested && telemetry?.onMethodCalled) {
+          const argumentCount = Object.keys(normalizedOptions).filter(
+            (k) => k !== "_telemetry"
+          ).length;
+          telemetry.onMethodCalled({
+            methodName: functionName,
+            durationMs: Date.now() - startTime,
+            success: true,
+            argumentCount,
+            isPaginated: false
+          });
         }
-        return await coreFn(normalizedOptions);
+        return result;
       } catch (error) {
-        throw normalizeError(error);
+        const normalizedError = normalizeError(error);
+        if (!isNested && telemetry?.onMethodCalled) {
+          const argumentCount = Object.keys(normalizedOptions).filter(
+            (k) => k !== "_telemetry"
+          ).length;
+          telemetry.onMethodCalled({
+            methodName: functionName,
+            durationMs: Date.now() - startTime,
+            success: false,
+            error: normalizedError,
+            argumentCount,
+            isPaginated: false
+          });
+        }
+        throw normalizedError;
       }
     }
   };
@@ -660,13 +732,15 @@ function createPageFunction(coreFn) {
   };
   return namedFunctions[functionName];
 }
-function createPaginatedFunction(coreFn, schema) {
+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) {
+      const startTime = Date.now();
       const normalizedOptions = options ?? {};
+      const isNested = normalizedOptions?._telemetry?.isNested === true;
       const validatedOptions = {
         ...normalizedOptions,
         ...validator ? validator(normalizedOptions) : normalizedOptions
@@ -683,6 +757,32 @@ function createPaginatedFunction(coreFn, schema) {
         }
         return result.value;
       });
+      if (!isNested && telemetry?.onMethodCalled) {
+        firstPagePromise.then(() => {
+          const argumentCount = Object.keys(
+            normalizedOptions
+          ).filter((k) => k !== "_telemetry").length;
+          telemetry.onMethodCalled({
+            methodName: functionName,
+            durationMs: Date.now() - startTime,
+            success: true,
+            argumentCount,
+            isPaginated: true
+          });
+        }).catch((error) => {
+          const argumentCount = Object.keys(
+            normalizedOptions
+          ).filter((k) => k !== "_telemetry").length;
+          telemetry.onMethodCalled({
+            methodName: functionName,
+            durationMs: Date.now() - startTime,
+            success: false,
+            error: error instanceof Error ? error : new Error(String(error)),
+            argumentCount,
+            isPaginated: true
+          });
+        });
+      }
       return Object.assign(firstPagePromise, {
         [Symbol.asyncIterator]: async function* () {
           yield await firstPagePromise;
@@ -780,7 +880,7 @@ var ListAppsOptionsSchema = zod.z.object({
   pageSize: zod.z.number().min(1).optional().describe("Number of apps 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")
-}).describe("List all available apps with optional filtering");
+}).merge(TelemetryMarkerSchema).describe("List all available apps with optional filtering");
 var AppItemSchema = ImplementationMetaSchema.omit({
   name: true,
   id: true
@@ -1206,6 +1306,9 @@ function toSnakeCase(input) {
   }
   return result;
 }
+function stripPageSuffix(functionName) {
+  return functionName.replace(/Page$/, "");
+}
 
 // src/schemas/App.ts
 var AppItemSchema2 = withFormatter(
@@ -1238,9 +1341,26 @@ var AppItemSchema2 = withFormatter(
   }
 );
 
+// 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 }) => {
-  const listApps = createPaginatedFunction(async function listAppsPage(options) {
+  async function listAppsPage(options) {
     const { api, resolveAppKeys: resolveAppKeys2 } = context;
     const appKeys = options.appKeys ?? [];
     const appLocators = await resolveAppKeys2({
@@ -1277,9 +1397,16 @@ var listAppsPlugin = ({ context }) => {
         ...options.cursor && { cursor: options.cursor }
       }
     });
-  }, ListAppsOptionsSchema);
+  }
+  const methodName = stripPageSuffix(listAppsPage.name);
+  const listAppsDefinition = createPaginatedFunction(
+    listAppsPage,
+    ListAppsOptionsSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
+  );
   return {
-    listApps,
+    listApps: listAppsDefinition,
     context: {
       meta: {
         listApps: {
@@ -1423,7 +1550,7 @@ var ListActionsSchema = zod.z.object({
   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")
-}).describe("List all actions for a specific app");
+}).merge(TelemetryMarkerSchema).describe("List all actions for a specific app");
 var ActionItemSchema = withFormatter(
   ActionSchema.omit({ type: true, name: true, selected_api: true }).extend({
     app_key: zod.z.string(),
@@ -1657,7 +1784,18 @@ var inputFieldKeyResolver = {
 
 // src/plugins/listActions/index.ts
 var listActionsPlugin = ({ context }) => {
-  const listActions = createPaginatedFunction(async function listActionsPage(options) {
+  const methodMeta = {
+    categories: ["action"],
+    type: "list",
+    itemType: "Action",
+    inputSchema: ListActionsSchema,
+    outputSchema: ActionItemSchema,
+    resolvers: {
+      appKey: appKeyResolver,
+      actionType: actionTypeResolver
+    }
+  };
+  async function listActionsPage(options) {
     const { api, getVersionedImplementationId } = context;
     const selectedApi = await getVersionedImplementationId(options.appKey);
     if (!selectedApi) {
@@ -1713,22 +1851,19 @@ var listActionsPlugin = ({ context }) => {
       data: allActions,
       nextCursor: void 0
     };
-  }, ListActionsSchema);
+  }
+  const methodName = stripPageSuffix(listActionsPage.name);
+  const listActionsDefinition = createPaginatedFunction(
+    listActionsPage,
+    ListActionsSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
+  );
   return {
-    listActions,
+    listActions: listActionsDefinition,
     context: {
       meta: {
-        listActions: {
-          categories: ["action"],
-          type: "list",
-          itemType: "Action",
-          inputSchema: ListActionsSchema,
-          outputSchema: ActionItemSchema,
-          resolvers: {
-            appKey: appKeyResolver,
-            actionType: actionTypeResolver
-          }
-        }
+        listActions: methodMeta
       }
     }
   };
@@ -2021,47 +2156,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
-      };
-    },
-    ListInputFieldsSchema
+  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, methodName),
+    methodName
   );
   return {
-    listInputFields,
+    listInputFields: listInputFieldsDefinition,
     context: {
       meta: {
         listInputFields: {
@@ -2096,7 +2235,7 @@ var ListAuthenticationsSchema = zod.z.object({
   pageSize: zod.z.number().min(1).optional().describe("Number of authentications 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")
-}).describe("List available authentications with optional filtering");
+}).merge(TelemetryMarkerSchema).describe("List available authentications with optional filtering");
 var AuthenticationItemSchema = withFormatter(
   AuthenticationSchema.omit({ selected_api: true, customuser_id: true }).extend(
     {
@@ -2143,74 +2282,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)
-      };
-    },
-    ListAuthenticationsSchema
+    }
+    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, methodName),
+    methodName
   );
   return {
-    listAuthentications,
+    listAuthentications: listAuthenticationsDefinition,
     context: {
       meta: {
         listAuthentications: {
@@ -2234,9 +2377,12 @@ var GetAppSchema = zod.z.object({
 }).describe("Get detailed information about a specific app");
 
 // src/plugins/getApp/index.ts
-var getAppPlugin = ({ sdk }) => {
-  const getApp = createFunction(async function getApp2(options) {
-    const appsIterator = sdk.listApps({ appKeys: [options.appKey] }).items();
+var getAppPlugin = ({ sdk, context }) => {
+  async function getApp(options) {
+    const appsIterator = sdk.listApps({
+      appKeys: [options.appKey],
+      _telemetry: { isNested: true }
+    }).items();
     for await (const app of appsIterator) {
       return {
         data: app
@@ -2245,9 +2391,17 @@ var getAppPlugin = ({ sdk }) => {
     throw new ZapierAppNotFoundError("App not found", {
       appKey: options.appKey
     });
-  }, GetAppSchema);
-  return {
+  }
+  const getAppDefinition = createFunction(
     getApp,
+    GetAppSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      getApp.name
+    )
+  );
+  return {
+    getApp: getAppDefinition,
     context: {
       meta: {
         getApp: {
@@ -2268,13 +2422,13 @@ var GetActionSchema = zod.z.object({
   appKey: AppKeyPropertySchema,
   actionType: ActionTypePropertySchema,
   actionKey: ActionKeyPropertySchema
-}).describe("Get detailed information about a specific action");
+}).merge(TelemetryMarkerSchema).describe("Get detailed information about a specific action");
 
 // src/plugins/getAction/index.ts
-var getActionPlugin = ({ sdk }) => {
-  const getAction = createFunction(async function getAction2(options) {
+var getActionPlugin = ({ sdk, context }) => {
+  async function getAction(options) {
     const { actionKey, actionType, appKey } = options;
-    for await (const action of sdk.listActions({ appKey }).items()) {
+    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 };
       }
@@ -2283,9 +2437,17 @@ var getActionPlugin = ({ sdk }) => {
       `Action not found: ${actionKey} with type ${actionType}`,
       { resourceType: "Action", resourceId: `${actionKey} (${actionType})` }
     );
-  }, GetActionSchema);
-  return {
+  }
+  const getActionDefinition = createFunction(
     getAction,
+    GetActionSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      getAction.name
+    )
+  );
+  return {
+    getAction: getActionDefinition,
     context: {
       meta: {
         getAction: {
@@ -2360,14 +2522,22 @@ zod.z.object({
 
 // src/plugins/getAuthentication/index.ts
 var getAuthenticationPlugin = ({ context }) => {
-  const getAuthentication = createFunction(async function getAuthentication2(options) {
+  async function getAuthentication(options) {
     const { api } = context;
     return await api.get(
       `/api/v0/authentications/${options.authenticationId}`
     );
-  }, GetAuthenticationOptionsSchema);
-  return {
+  }
+  const getAuthenticationDefinition = createFunction(
     getAuthentication,
+    GetAuthenticationOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      getAuthentication.name
+    )
+  );
+  return {
+    getAuthentication: getAuthenticationDefinition,
     context: {
       meta: {
         getAuthentication: {
@@ -2395,27 +2565,33 @@ var FindFirstAuthenticationSchema = zod.z.object({
 }).describe("Find the first authentication matching the criteria");
 
 // src/plugins/findFirstAuthentication/index.ts
-var findFirstAuthenticationPlugin = ({ sdk }) => {
-  const findFirstAuthentication = createFunction(
-    async function findFirstAuthentication2(options = {}) {
-      const authsResponse = await sdk.listAuthentications({
-        ...options,
-        maxItems: 1
-      });
-      if (authsResponse.data.length === 0) {
-        throw new ZapierResourceNotFoundError(
-          "No authentication found matching the specified criteria",
-          { resourceType: "Authentication" }
-        );
-      }
-      return {
-        data: authsResponse.data[0]
-      };
-    },
-    FindFirstAuthenticationSchema
+var findFirstAuthenticationPlugin = ({ sdk, context }) => {
+  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.name
+    )
   );
   return {
-    findFirstAuthentication,
+    findFirstAuthentication: findFirstAuthenticationDefinition,
     context: {
       meta: {
         findFirstAuthentication: {
@@ -2440,33 +2616,39 @@ var FindUniqueAuthenticationSchema = zod.z.object({
 }).describe("Find a unique authentication matching the criteria");
 
 // src/plugins/findUniqueAuthentication/index.ts
-var findUniqueAuthenticationPlugin = ({ sdk }) => {
-  const findUniqueAuthentication = createFunction(
-    async function findUniqueAuthentication2(options = {}) {
-      const authsResponse = await sdk.listAuthentications({
-        ...options,
-        maxItems: 2
-        // Get up to 2 to check for uniqueness
-      });
-      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]
-      };
-    },
-    FindUniqueAuthenticationSchema
+var findUniqueAuthenticationPlugin = ({ sdk, context }) => {
+  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.name
+    )
   );
   return {
-    findUniqueAuthentication,
+    findUniqueAuthentication: findUniqueAuthenticationDefinition,
     context: {
       meta: {
         findUniqueAuthentication: {
@@ -2537,7 +2719,7 @@ async function executeAction(actionOptions) {
   });
 }
 var runActionPlugin = ({ sdk, context }) => {
-  const runAction = createPaginatedFunction(async function runActionPage(options) {
+  async function runActionPage(options) {
     const { api } = context;
     const {
       appKey,
@@ -2549,7 +2731,8 @@ var runActionPlugin = ({ sdk, context }) => {
     const actionData = await sdk.getAction({
       appKey,
       actionKey,
-      actionType
+      actionType,
+      _telemetry: { isNested: true }
     });
     if (actionData.data.action_type !== actionType) {
       throw new ZapierValidationError(
@@ -2582,9 +2765,16 @@ var runActionPlugin = ({ sdk, context }) => {
       nextCursor: void 0
       // No pagination implemented yet
     };
-  }, RunActionSchema);
+  }
+  const methodName = stripPageSuffix(runActionPage.name);
+  const runActionDefinition = createPaginatedFunction(
+    runActionPage,
+    RunActionSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
+  );
   return {
-    runAction,
+    runAction: runActionDefinition,
     context: {
       meta: {
         runAction: {
@@ -2621,7 +2811,7 @@ var RelayRequestSchema = zod.z.object({
   ]).optional().describe("Request headers")
 }).extend({
   relayBaseUrl: zod.z.string().optional().describe("Base URL for Relay service")
-}).describe("Make authenticated HTTP requests through Zapier's Relay service");
+}).merge(TelemetryMarkerSchema).describe("Make authenticated HTTP requests through Zapier's Relay service");
 var RelayFetchSchema = RelayRequestSchema;
 
 // src/plugins/request/index.ts
@@ -2631,7 +2821,7 @@ function transformUrlToRelayPath(url) {
   return relayPath;
 }
 var requestPlugin = ({ context }) => {
-  const request = createFunction(async function request2(options) {
+  async function request(options) {
     const { api } = context;
     const {
       url,
@@ -2664,9 +2854,17 @@ var requestPlugin = ({ context }) => {
       body,
       headers
     });
-  }, RelayRequestSchema);
-  return {
+  }
+  const requestDefinition = createFunction(
     request,
+    RelayRequestSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      request.name
+    )
+  );
+  return {
+    request: requestDefinition,
     context: {
       meta: {
         request: {
@@ -3169,7 +3367,7 @@ var UserProfileItemSchema = withFormatter(
 
 // src/plugins/getProfile/index.ts
 var getProfilePlugin = ({ context }) => {
-  const getProfile = createFunction(async function getProfile2() {
+  async function getProfile() {
     const profile = await context.api.get(
       "/zapier/api/v4/profile/",
       {
@@ -3185,9 +3383,17 @@ var getProfilePlugin = ({ context }) => {
         // Computed field
       }
     };
-  }, GetProfileSchema);
-  return {
+  }
+  const getProfileDefinition = createFunction(
     getProfile,
+    GetProfileSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      getProfile.name
+    )
+  );
+  return {
+    getProfile: getProfileDefinition,
     context: {
       meta: {
         getProfile: {
@@ -4430,44 +4636,49 @@ var GetInputFieldsSchemaSchema = zod.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 || {}
-      };
-    },
-    GetInputFieldsSchemaSchema
+  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.name
+    )
   );
   return {
-    getInputFieldsSchema,
+    getInputFieldsSchema: getInputFieldsSchemaDefinition,
     context: {
       meta: {
         getInputFieldsSchema: {
@@ -4536,7 +4747,7 @@ function transformNeedChoicesToInputFieldChoiceItem(choice) {
   };
 }
 var listInputFieldChoicesPlugin = ({ context, sdk }) => {
-  const listInputFieldChoices = createPaginatedFunction(async function listInputFieldChoicesPage(options) {
+  async function listInputFieldChoicesPage(options) {
     const { api, getVersionedImplementationId } = context;
     const {
       appKey,
@@ -4614,9 +4825,16 @@ var listInputFieldChoicesPlugin = ({ context, sdk }) => {
       data: choices,
       nextCursor
     };
-  }, ListInputFieldChoicesSchema);
+  }
+  const methodName = stripPageSuffix(listInputFieldChoicesPage.name);
+  const listInputFieldChoicesDefinition = createPaginatedFunction(
+    listInputFieldChoicesPage,
+    ListInputFieldChoicesSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, methodName),
+    methodName
+  );
   return {
-    listInputFieldChoices,
+    listInputFieldChoices: listInputFieldChoicesDefinition,
     context: {
       meta: {
         listInputFieldChoices: {
@@ -4790,7 +5008,7 @@ function getCpuTime() {
 
 // package.json
 var package_default = {
-  version: "0.15.10"};
+  version: "0.15.12"};
 
 // src/plugins/eventEmission/builders.ts
 function createBaseEvent(context = {}) {
@@ -4858,11 +5076,44 @@ function buildErrorEventWithContext(data, context = {}) {
     ...data
   };
 }
+function buildMethodCalledEvent(data, context = {}) {
+  return {
+    ...createBaseEvent(context),
+    method_name: data.method_name ?? null,
+    method_module: data.method_module ?? null,
+    execution_duration_ms: data.execution_duration_ms,
+    success_flag: data.success_flag,
+    error_message: data.error_message ?? null,
+    error_type: data.error_type ?? null,
+    argument_count: data.argument_count,
+    is_paginated: data.is_paginated ?? false,
+    sdk_version: package_default.version,
+    environment: context.environment ?? (process?.env?.NODE_ENV || null),
+    selected_api: context.selected_api ?? null,
+    app_id: context.app_id ?? null,
+    app_version_id: context.app_version_id ?? null,
+    zap_id: context.zap_id ?? null,
+    node_id: context.node_id ?? null,
+    operation_type: null,
+    operation_key: null,
+    call_context: null,
+    is_retry: false,
+    retry_attempt: null,
+    argument_types: null,
+    return_type: null,
+    caller_method: null,
+    call_stack_depth: null,
+    is_synchronous: false,
+    cpu_time_ms: null,
+    memory_usage_bytes: null
+  };
+}
 
 // src/plugins/eventEmission/index.ts
 var TELEMETRY_EMIT_TIMEOUT_MS = 300;
 var APPLICATION_LIFECYCLE_EVENT_SUBJECT = "platform.sdk.ApplicationLifecycleEvent";
 var ERROR_OCCURRED_EVENT_SUBJECT = "platform.sdk.ErrorOccurredEvent";
+var METHOD_CALLED_EVENT_SUBJECT = "platform.sdk.MethodCalledEvent";
 var transportStates = /* @__PURE__ */ new WeakMap();
 async function silentEmit(transport, subject, event, userContextPromise) {
   try {
@@ -4964,7 +5215,9 @@ var eventEmissionPlugin = ({ context }) => {
             identity_id: null,
             visitor_id: null,
             correlation_id: null
-          })
+          }),
+          emitMethodCalled: () => {
+          }
         }
       }
     };
@@ -5116,7 +5369,16 @@ var eventEmissionPlugin = ({ context }) => {
         emit: (subject, event) => {
           silentEmit(transport, subject, event, getUserContext);
         },
-        createBaseEvent: createBaseEventHelper
+        createBaseEvent: createBaseEventHelper,
+        emitMethodCalled: (data) => {
+          const event = buildMethodCalledEvent(data);
+          silentEmit(
+            transport,
+            METHOD_CALLED_EVENT_SUBJECT,
+            event,
+            getUserContext
+          );
+        }
       }
     }
   };
@@ -5215,6 +5477,7 @@ exports.batch = batch;
 exports.buildApplicationLifecycleEvent = buildApplicationLifecycleEvent;
 exports.buildErrorEvent = buildErrorEvent;
 exports.buildErrorEventWithContext = buildErrorEventWithContext;
+exports.buildMethodCalledEvent = buildMethodCalledEvent;
 exports.createBaseEvent = createBaseEvent;
 exports.createFunction = createFunction;
 exports.createSdk = createSdk;