@zapier/zapier-sdk 0.15.9 → 0.15.11

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) {
   const pageFunction = createPageFunction(coreFn);
   const functionName = 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
@@ -1238,46 +1338,67 @@ 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) {
-    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 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
+        ];
       }
-    });
-  }, ListAppsOptionsSchema);
+      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 }
+        }
+      });
+    },
+    ListAppsOptionsSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, "listApps")
+  );
   return {
     listApps,
     context: {
@@ -1423,7 +1544,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,78 +1778,86 @@ var inputFieldKeyResolver = {
 
 // src/plugins/listActions/index.ts
 var listActionsPlugin = ({ context }) => {
-  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 methodMeta = {
+    categories: ["action"],
+    type: "list",
+    itemType: "Action",
+    inputSchema: ListActionsSchema,
+    outputSchema: ActionItemSchema,
+    resolvers: {
+      appKey: appKeyResolver,
+      actionType: actionTypeResolver
     }
-    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 }
-            );
+  };
+  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;
           }
-          if (status === 403) {
-            return new ZapierAuthenticationError(
-              `Access forbidden. Your token may not have the required scopes to list implementations. (HTTP ${status})`,
-              { statusCode: status }
-            );
+        }
+      );
+      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 void 0;
         }
       }
-    );
-    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));
-        }
+      if (options.actionType) {
+        allActions = allActions.filter(
+          (action) => action.action_type === options.actionType
+        );
       }
-    }
-    if (options.actionType) {
-      allActions = allActions.filter(
-        (action) => action.action_type === options.actionType
-      );
-    }
-    return {
-      data: allActions,
-      nextCursor: void 0
-    };
-  }, ListActionsSchema);
+      return {
+        data: allActions,
+        nextCursor: void 0
+      };
+    },
+    ListActionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "listActions"
+    )
+  );
   return {
     listActions,
     context: {
       meta: {
-        listActions: {
-          categories: ["action"],
-          type: "list",
-          itemType: "Action",
-          inputSchema: ListActionsSchema,
-          outputSchema: ActionItemSchema,
-          resolvers: {
-            appKey: appKeyResolver,
-            actionType: actionTypeResolver
-          }
-        }
+        listActions: methodMeta
       }
     }
   };
@@ -2058,7 +2187,11 @@ var listInputFieldsPlugin = ({ sdk, context }) => {
         // No pagination needed since we return all input fields
       };
     },
-    ListInputFieldsSchema
+    ListInputFieldsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "listInputFields"
+    )
   );
   return {
     listInputFields,
@@ -2096,7 +2229,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(
     {
@@ -2207,7 +2340,11 @@ var listAuthenticationsPlugin = ({ context }) => {
         nextCursor: extractCursor(data)
       };
     },
-    ListAuthenticationsSchema
+    ListAuthenticationsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "listAuthentications"
+    )
   );
   return {
     listAuthentications,
@@ -2234,18 +2371,25 @@ 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();
-    for await (const app of appsIterator) {
-      return {
-        data: app
-      };
-    }
-    throw new ZapierAppNotFoundError("App not found", {
-      appKey: options.appKey
-    });
-  }, GetAppSchema);
+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
+      });
+    },
+    GetAppSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, "getApp")
+  );
   return {
     getApp,
     context: {
@@ -2268,22 +2412,29 @@ 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) {
-    const { actionKey, actionType, appKey } = options;
-    for await (const action of sdk.listActions({ appKey }).items()) {
-      if ((action.key === actionKey || action.id === actionKey) && action.action_type === actionType) {
-        return { data: action };
+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 };
+        }
       }
-    }
-    throw new ZapierResourceNotFoundError(
-      `Action not found: ${actionKey} with type ${actionType}`,
-      { resourceType: "Action", resourceId: `${actionKey} (${actionType})` }
-    );
-  }, GetActionSchema);
+      throw new ZapierResourceNotFoundError(
+        `Action not found: ${actionKey} with type ${actionType}`,
+        { resourceType: "Action", resourceId: `${actionKey} (${actionType})` }
+      );
+    },
+    GetActionSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "getAction"
+    )
+  );
   return {
     getAction,
     context: {
@@ -2360,12 +2511,19 @@ zod.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}`
-    );
-  }, GetAuthenticationOptionsSchema);
+  const getAuthentication = createFunction(
+    async function getAuthentication2(options) {
+      const { api } = context;
+      return await api.get(
+        `/api/v0/authentications/${options.authenticationId}`
+      );
+    },
+    GetAuthenticationOptionsSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "getAuthentication"
+    )
+  );
   return {
     getAuthentication,
     context: {
@@ -2395,12 +2553,13 @@ var FindFirstAuthenticationSchema = zod.z.object({
 }).describe("Find the first authentication matching the criteria");
 
 // src/plugins/findFirstAuthentication/index.ts
-var findFirstAuthenticationPlugin = ({ sdk }) => {
+var findFirstAuthenticationPlugin = ({ sdk, context }) => {
   const findFirstAuthentication = createFunction(
     async function findFirstAuthentication2(options = {}) {
       const authsResponse = await sdk.listAuthentications({
         ...options,
-        maxItems: 1
+        maxItems: 1,
+        _telemetry: { isNested: true }
       });
       if (authsResponse.data.length === 0) {
         throw new ZapierResourceNotFoundError(
@@ -2412,7 +2571,11 @@ var findFirstAuthenticationPlugin = ({ sdk }) => {
         data: authsResponse.data[0]
       };
     },
-    FindFirstAuthenticationSchema
+    FindFirstAuthenticationSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "findFirstAuthentication"
+    )
   );
   return {
     findFirstAuthentication,
@@ -2440,13 +2603,14 @@ var FindUniqueAuthenticationSchema = zod.z.object({
 }).describe("Find a unique authentication matching the criteria");
 
 // src/plugins/findUniqueAuthentication/index.ts
-var findUniqueAuthenticationPlugin = ({ sdk }) => {
+var findUniqueAuthenticationPlugin = ({ sdk, context }) => {
   const findUniqueAuthentication = createFunction(
     async function findUniqueAuthentication2(options = {}) {
       const authsResponse = await sdk.listAuthentications({
         ...options,
-        maxItems: 2
+        maxItems: 2,
         // Get up to 2 to check for uniqueness
+        _telemetry: { isNested: true }
       });
       if (authsResponse.data.length === 0) {
         throw new ZapierResourceNotFoundError(
@@ -2463,7 +2627,11 @@ var findUniqueAuthenticationPlugin = ({ sdk }) => {
         data: authsResponse.data[0]
       };
     },
-    FindUniqueAuthenticationSchema
+    FindUniqueAuthenticationSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "findUniqueAuthentication"
+    )
   );
   return {
     findUniqueAuthentication,
@@ -2537,52 +2705,63 @@ 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({
-      appKey,
-      actionKey,
-      actionType
-    });
-    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}`, {
+  const runAction = createPaginatedFunction(
+    async function runActionPage(options) {
+      const { api } = context;
+      const {
         appKey,
-        actionKey
+        actionKey,
+        actionType,
+        authenticationId,
+        inputs = {}
+      } = options;
+      const actionData = await sdk.getAction({
+        appKey,
+        actionKey,
+        actionType,
+        _telemetry: { isNested: true }
       });
-    }
-    return {
-      data: result.results || [],
-      nextCursor: void 0
-      // No pagination implemented yet
-    };
-  }, RunActionSchema);
+      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
+      };
+    },
+    RunActionSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "runAction"
+    )
+  );
   return {
     runAction,
     context: {
@@ -2621,7 +2800,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,40 +2810,44 @@ 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;
+  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;
-    }
-    return await api.fetch(relayPath, {
-      method,
-      body,
-      headers
-    });
-  }, RelayRequestSchema);
+      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
+      });
+    },
+    RelayRequestSchema,
+    createTelemetryCallback(context.eventEmission.emitMethodCalled, "request")
+  );
   return {
     request,
     context: {
@@ -3169,23 +3352,30 @@ 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
-      }
-    };
-  }, GetProfileSchema);
+  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
+        }
+      };
+    },
+    GetProfileSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "getProfile"
+    )
+  );
   return {
     getProfile,
     context: {
@@ -4464,7 +4654,11 @@ var getInputFieldsSchemaPlugin = ({ sdk, context }) => {
         data: needsData.schema || {}
       };
     },
-    GetInputFieldsSchemaSchema
+    GetInputFieldsSchemaSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "getInputFieldsSchema"
+    )
   );
   return {
     getInputFieldsSchema,
@@ -4536,85 +4730,92 @@ 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 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
       );
-    }
-    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`
+      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 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;
+      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;
         }
-      } catch {
-        nextCursor = void 0;
       }
-    }
-    return {
-      data: choices,
-      nextCursor
-    };
-  }, ListInputFieldChoicesSchema);
+      return {
+        data: choices,
+        nextCursor
+      };
+    },
+    ListInputFieldChoicesSchema,
+    createTelemetryCallback(
+      context.eventEmission.emitMethodCalled,
+      "listInputFieldChoices"
+    )
+  );
   return {
     listInputFieldChoices,
     context: {
@@ -4790,7 +4991,7 @@ function getCpuTime() {
 
 // package.json
 var package_default = {
-  version: "0.15.9"};
+  version: "0.15.11"};
 
 // src/plugins/eventEmission/builders.ts
 function createBaseEvent(context = {}) {
@@ -4829,7 +5030,6 @@ function buildApplicationLifecycleEvent(data, context = {}) {
     sdk_version: package_default.version,
     cli_version: null,
     memory_usage_bytes: data.memory_usage_bytes ?? getMemoryUsage(),
-    peak_memory_usage_bytes: data.peak_memory_usage_bytes ?? getMemoryUsage(),
     cpu_time_ms: data.cpu_time_ms ?? getCpuTime(),
     os_platform: osInfo.platform,
     os_release: osInfo.release,
@@ -4859,11 +5059,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 {
@@ -4965,7 +5198,9 @@ var eventEmissionPlugin = ({ context }) => {
             identity_id: null,
             visitor_id: null,
             correlation_id: null
-          })
+          }),
+          emitMethodCalled: () => {
+          }
         }
       }
     };
@@ -5117,7 +5352,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
+          );
+        }
       }
     }
   };
@@ -5216,6 +5460,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;