@zapier/zapier-sdk 0.45.2 → 0.46.1

package/dist/plugins/request/index.d.ts

@@ -1,21 +1,67 @@
-import type { Plugin } from "../../types/plugin";
-import { RelayRequestSchema, type RelayRequestOptions } from "./schemas";
-import type { EventEmissionProvides } from "../eventEmission";
-import type { FetchPluginProvides } from "../fetch";
-export interface RequestPluginProvides {
-    request: (options: RelayRequestOptions) => Promise<Response>;
+/**
+ * @deprecated Use `sdk.fetch(url, init?)` instead. This plugin now delegates
+ * to the fetch plugin and is kept only for backward compatibility. It is
+ * hidden from the CLI/MCP registries.
+ */
+export declare const requestPlugin: (sdk: {
+    fetch: (url: string | URL, init?: import("../fetch").ZapierFetchInitOptions) => Promise<Response>;
     context: {
         meta: {
-            request: {
-                inputSchema: typeof RelayRequestSchema;
+            fetch: {
+                description: string;
+                packages: string[];
+                categories: string[];
+                returnType: string;
+                inputParameters: ({
+                    name: string;
+                    schema: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<URL, URL>]>;
+                } | {
+                    name: string;
+                    schema: import("zod").ZodOptional<import("zod").ZodObject<{
+                        method: import("zod").ZodOptional<import("zod").ZodEnum<{
+                            POST: "POST";
+                            GET: "GET";
+                            DELETE: "DELETE";
+                            PUT: "PUT";
+                            PATCH: "PATCH";
+                            HEAD: "HEAD";
+                            OPTIONS: "OPTIONS";
+                        }>>;
+                        headers: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+                        body: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodCustom<FormData, FormData>, import("zod").ZodCustom<URLSearchParams, URLSearchParams>, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>]>>;
+                        connectionId: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                        connection: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                        authenticationId: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber]>>;
+                        callbackUrl: import("zod").ZodOptional<import("zod").ZodString>;
+                        maxTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                    }, import("zod/v4/core").$strip>>;
+                })[];
             };
         };
     };
-}
-/**
- * @deprecated Use `sdk.fetch(url, init?)` instead. This plugin now delegates to the fetch plugin
- * and is kept only for backward compatibility. It is hidden from the CLI/MCP registries.
- */
-export declare const requestPlugin: Plugin<FetchPluginProvides & EventEmissionProvides, // requires fetch in SDK, eventEmission context for telemetry
-RequestPluginProvides>;
+} & {
+    context: import("../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../..").PluginMeta>;
+    };
+}) => {
+    request: (options?: {
+        url: string;
+        method?: "POST" | "GET" | "DELETE" | "PUT" | "PATCH" | "HEAD" | "OPTIONS" | undefined;
+        body?: any;
+        connection?: string | number | undefined;
+        connectionId?: string | number | undefined;
+        authenticationId?: string | number | undefined;
+        callbackUrl?: string | undefined;
+        headers?: [string, string][] | Record<string, string> | Headers | undefined;
+    } | undefined) => Promise<Response>;
+} & {
+    context: {
+        meta: {
+            request: import("../..").PluginMeta;
+        };
+    };
+};
+export type RequestPluginProvides = ReturnType<typeof requestPlugin>;
 //# sourceMappingURL=index.d.ts.map

package/dist/plugins/request/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEzE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAGpD,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC7D,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,OAAO,EAAE;gBACP,WAAW,EAAE,OAAO,kBAAkB,CAAC;aACxC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAChC,mBAAmB,GAAG,qBAAqB,EAAE,6DAA6D;AAC1G,qBAAqB,CA+CtB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/index.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BzB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/plugins/request/index.js

@@ -1,13 +1,19 @@
+import { definePlugin } from "../../utils/plugin-utils";
+import { createPluginMethod } from "../../utils/plugin-utils";
 import { RelayRequestSchema } from "./schemas";
-import { createFunction } from "../../utils/function-utils";
-import { createTelemetryCallback } from "../../utils/telemetry-utils";
 import { logDeprecation } from "../../utils/logging";
 /**
- * @deprecated Use `sdk.fetch(url, init?)` instead. This plugin now delegates to the fetch plugin
- * and is kept only for backward compatibility. It is hidden from the CLI/MCP registries.
+ * @deprecated Use `sdk.fetch(url, init?)` instead. This plugin now delegates
+ * to the fetch plugin and is kept only for backward compatibility. It is
+ * hidden from the CLI/MCP registries.
  */
-export const requestPlugin = (sdk) => {
-    async function request(options) {
+export const requestPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
+    name: "request",
+    packages: ["cli", "mcp"],
+    categories: ["http", "deprecated"],
+    returnType: "Response",
+    inputSchema: RelayRequestSchema,
+    handler: async ({ sdk, options }) => {
         logDeprecation("request() is deprecated. Use fetch() instead.");
         const { url, method, body, headers, connection, connectionId, authenticationId, callbackUrl, } = options;
         return sdk.fetch(url, {
@@ -17,19 +23,5 @@ export const requestPlugin = (sdk) => {
             connection: connection ?? connectionId ?? authenticationId,
             callbackUrl,
         });
-    }
-    const requestDefinition = createFunction(request, RelayRequestSchema, createTelemetryCallback(sdk.context.eventEmission.emitMethodCalled, request.name));
-    return {
-        request: requestDefinition,
-        context: {
-            meta: {
-                request: {
-                    packages: ["cli", "mcp"],
-                    categories: ["http", "deprecated"],
-                    returnType: "Response",
-                    inputSchema: RelayRequestSchema,
-                },
-            },
-        },
-    };
-};
+    },
+}));

package/dist/plugins/request/schemas.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import type { ZapierApiError, ZapierValidationError, ZapierUnknownError } from "../../types/errors";
 export declare const RelayRequestSchema: z.ZodObject<{
     url: z.ZodString;
     method: z.ZodOptional<z.ZodEnum<{
@@ -19,7 +18,6 @@ export declare const RelayRequestSchema: z.ZodObject<{
     headers: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodString>, z.ZodCustom<Headers, Headers>, z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>]>>;
 }, z.core.$strip>;
 export type RelayRequestOptions = z.infer<typeof RelayRequestSchema>;
-export type RelayRequestError = ZapierApiError | ZapierValidationError | ZapierUnknownError;
 export interface RelayRequestSdkFunction {
     request: (options: RelayRequestOptions) => Promise<Response>;
 }

package/dist/plugins/request/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAQ5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAoC3B,CAAC;AAGL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAGrE,MAAM,MAAM,iBAAiB,GACzB,cAAc,GACd,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC9D;AAGD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;iBAAqB,CAAC;AACnD,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AACpD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC1D"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/request/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAoC3B,CAAC;AAGL,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAGrE,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC9D;AAGD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;iBAAqB,CAAC;AACnD,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,CAAC;AACpD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC1D"}

package/dist/plugins/runAction/index.d.ts

@@ -1,36 +1,150 @@
-import type { Plugin } from "../../types/plugin";
 import type { ApiClient } from "../../api";
-import { RunActionSchema, type RunActionOptions } from "./schemas";
-import type { GetActionPluginProvides } from "../getAction";
-import type { GetAppPluginProvides } from "../getApp";
 import type { GetVersionedImplementationId } from "../manifest/schemas";
 import type { ConnectionsPluginProvides } from "../connections";
-import type { EventEmissionProvides } from "../eventEmission";
-export interface RunActionPluginProvides {
-    runAction: (options?: RunActionOptions) => Promise<{
-        data: any[];
-        nextCursor?: string;
-    }> & AsyncIterable<{
-        data: any[];
-        nextCursor?: string;
-    }> & {
-        items(): AsyncIterable<any>;
+export declare const CONTEXT_CACHE_TTL_MS = 60000;
+export declare const CONTEXT_CACHE_MAX_SIZE = 500;
+export declare const runActionPlugin: (sdk: {
+    getAction: (options?: {
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+    } | undefined) => Promise<{
+        data: {
+            description: string;
+            key: string;
+            app_key: string;
+            action_type: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+            title: string;
+            type: "action";
+            id?: string | undefined;
+            is_important?: boolean | undefined;
+            is_hidden?: boolean | undefined;
+            app_version?: string | undefined;
+        };
+    }>;
+} & {
+    context: {
+        meta: {
+            getAction: import("../..").PluginMeta;
+        };
     };
+} & {
+    getApp: (options?: {
+        app: string;
+    } | {
+        appKey: string;
+    } | undefined) => Promise<{
+        data: {
+            slug: string;
+            title: string;
+            key: string;
+            implementation_id: string;
+            description?: string | undefined;
+            is_hidden?: boolean | undefined;
+            auth_type?: string | undefined;
+            actions?: {
+                read?: number | undefined;
+                read_bulk?: number | undefined;
+                write?: number | undefined;
+                search?: number | undefined;
+                search_or_write?: number | undefined;
+                search_and_write?: number | undefined;
+                filter?: number | undefined;
+            } | undefined;
+            is_deprecated?: boolean | undefined;
+            is_beta?: boolean | undefined;
+            is_premium?: boolean | undefined;
+            age_in_days?: number | undefined;
+            banner?: string | undefined;
+            categories?: {
+                id: number;
+                name: string;
+                slug: string;
+            }[] | undefined;
+            images?: {
+                url_16x16?: string | undefined;
+                url_32x32?: string | undefined;
+                url_64x64?: string | undefined;
+                url_128x128?: string | undefined;
+            } | undefined;
+            popularity?: number | undefined;
+            has_filters?: boolean | undefined;
+            has_reads?: boolean | undefined;
+            has_searches?: boolean | undefined;
+            has_searches_or_writes?: boolean | undefined;
+            has_upfront_fields?: boolean | undefined;
+            has_writes?: boolean | undefined;
+            is_built_in?: boolean | undefined;
+            is_featured?: boolean | undefined;
+            is_invite?: boolean | undefined;
+            is_public?: boolean | undefined;
+            is_upcoming?: boolean | undefined;
+            visibility?: string | undefined;
+            primary_color?: string | undefined;
+            secondary_color?: string | undefined;
+            classification?: string | undefined;
+            api_docs_url?: string | undefined;
+            image?: string | undefined;
+            version?: string | undefined;
+        };
+    }>;
+} & {
     context: {
         meta: {
-            runAction: {
-                inputSchema: typeof RunActionSchema;
-            };
+            getApp: import("../..").PluginMeta;
         };
     };
-}
-export declare const CONTEXT_CACHE_TTL_MS = 60000;
-export declare const CONTEXT_CACHE_MAX_SIZE = 500;
-export declare const runActionPlugin: Plugin<GetActionPluginProvides & GetAppPluginProvides & {
+} & {
     context: {
         api: ApiClient;
         getVersionedImplementationId: GetVersionedImplementationId;
     } & ConnectionsPluginProvides["context"];
-} & EventEmissionProvides, // requires getAction and getApp in SDK, api, connections, and eventEmission in context
-RunActionPluginProvides>;
+} & {
+    context: import("../eventEmission").EventEmissionContext;
+} & {
+    context: {
+        meta: Record<string, import("../..").PluginMeta>;
+    };
+}) => {
+    runAction: (options?: (({
+        app: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        action: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        timeoutMs?: number | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    } | {
+        appKey: string;
+        actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+        actionKey: string;
+        connection?: string | number | undefined;
+        connectionId?: string | number | null | undefined;
+        authenticationId?: string | number | null | undefined;
+        inputs?: Record<string, unknown> | undefined;
+        timeoutMs?: number | undefined;
+        pageSize?: number | undefined;
+        maxItems?: number | undefined;
+        cursor?: string | undefined;
+    }) & {
+        cursor?: string;
+        pageSize?: number;
+        maxItems?: number;
+    }) | undefined) => import("../..").PaginatedSdkResult<unknown>;
+} & {
+    context: {
+        meta: {
+            runAction: import("../..").PluginMeta;
+        };
+    };
+};
+export type RunActionPluginProvides = ReturnType<typeof runActionPlugin>;
 //# sourceMappingURL=index.d.ts.map

package/dist/plugins/runAction/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/runAction/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EACL,eAAe,EAEf,KAAK,gBAAgB,EAEtB,MAAM,WAAW,CAAC;AAQnB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,WAAW,CAAC;AAQtD,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AAEhE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAS9D,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE,gBAAgB,KAAK,OAAO,CAAC;QACjD,IAAI,EAAE,GAAG,EAAE,CAAC;QACZ,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,GAAG,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QACpD,KAAK,IAAI,aAAa,CAAC,GAAG,CAAC,CAAC;KAC7B,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,SAAS,EAAE;gBACT,WAAW,EAAE,OAAO,eAAe,CAAC;aACrC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAkGD,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAC3C,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,eAAO,MAAM,eAAe,EAAE,MAAM,CAClC,uBAAuB,GACrB,oBAAoB,GAAG;IACrB,OAAO,EAAE;QACP,GAAG,EAAE,SAAS,CAAC;QACf,4BAA4B,EAAE,4BAA4B,CAAC;KAC5D,GAAG,yBAAyB,CAAC,SAAS,CAAC,CAAC;CAC1C,GAAG,qBAAqB,EAAE,uFAAuF;AACpH,uBAAuB,CAyMxB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/runAction/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAiB3C,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AA0GhE,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAC3C,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIX;QACP,GAAG,EAAE,SAAS,CAAC;QACf,4BAA4B,EAAE,4BAA4B,CAAC;KAC5D,GAAG,yBAAyB,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuL/C,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/plugins/runAction/index.js

@@ -1,11 +1,10 @@
-import { RunActionSchema, RunActionInputSchema, } from "./schemas";
+import { definePlugin } from "../../utils/plugin-utils";
+import { createPaginatedPluginMethod } from "../../utils/plugin-utils";
+import { RunActionInputSchema } from "./schemas";
 import { ActionResultItemSchema } from "../../schemas/Run";
 import { ZapierValidationError, ZapierConfigurationError, ZapierActionError, } from "../../types/errors";
-import { createPaginatedFunction } from "../../utils/function-utils";
 import { appKeyResolver, actionTypeResolver, actionKeyResolver, connectionIdResolver, inputsResolver, } from "../../resolvers";
-import { createTelemetryCallback } from "../../utils/telemetry-utils";
 import { resolveConnectionId } from "../../utils/domain-utils";
-import { stripPageSuffix } from "../../utils/string-utils";
 import { DEFAULT_ACTION_TIMEOUT_MS } from "../../constants";
 import { setMethodMetadata } from "../../utils/telemetry-context";
 import { buildActionRunContext } from "@zapier/policy-context";
@@ -46,6 +45,7 @@ async function executeAction(actionOptions) {
         successStatus: 200,
         pendingStatus: 202,
         timeoutMs: timeoutMs ?? DEFAULT_ACTION_TIMEOUT_MS,
+        resource: { type: "run", id: runId },
         isPending: (result) => {
             const data = result?.data;
             return data?.status === "waiting";
@@ -55,7 +55,7 @@ async function executeAction(actionOptions) {
 }
 export const CONTEXT_CACHE_TTL_MS = 60000;
 export const CONTEXT_CACHE_MAX_SIZE = 500;
-export const runActionPlugin = (sdk) => {
+export const runActionPlugin = definePlugin((sdk) => {
     // Intentionally kept inline — only this plugin needs this pattern today.
     // If a second plugin needs a bounded TTL cache, extract to a shared utility.
     const runActionContextCache = new Map();
@@ -119,80 +119,67 @@ export const runActionPlugin = (sdk) => {
         }
         return { selectedApi, actionId: actionData.data.id };
     }
-    async function runActionPage(options) {
-        const { api } = sdk.context;
-        const appKey = "app" in options ? options.app : options.appKey;
-        const actionKey = "action" in options ? options.action : options.actionKey;
-        const { actionType, connectionId, connection, authenticationId, inputs = {}, cursor, timeoutMs, } = options;
-        const resolvedConnectionId = await resolveConnectionId({
-            connectionId,
-            connection,
-            authenticationId,
-            resolveConnection: sdk.context.resolveConnection,
-        });
-        const { selectedApi, actionId } = await getRunActionContext({
-            appKey,
-            actionKey,
-            actionType,
-        });
-        setMethodMetadata({
-            selectedApi,
-            operationType: actionType,
-            operationKey: actionKey,
-        });
-        // Execute the action using the Actions API (supports all action types)
-        const result = await executeAction({
-            api,
-            selectedApi,
-            // 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 },
-            cursor,
-            connectionId: resolvedConnectionId,
-            timeoutMs,
-        });
-        // Check for errors in the result and throw if present
-        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}`, {
+    // No defaultPageSize — we leave the default to the Actions API rather
+    // than eagerly running more actions than the user intends to (and avoid
+    // hitting app rate limits).
+    return createPaginatedPluginMethod(sdk, {
+        name: "runAction",
+        categories: ["action"],
+        type: "list",
+        itemType: "ActionResult",
+        inputSchema: RunActionInputSchema,
+        outputSchema: ActionResultItemSchema,
+        resolvers: {
+            app: appKeyResolver,
+            actionType: actionTypeResolver,
+            action: actionKeyResolver,
+            connection: connectionIdResolver,
+            inputs: inputsResolver,
+        },
+        handler: async ({ sdk, options, }) => {
+            const { api } = sdk.context;
+            const appKey = "app" in options ? options.app : options.appKey;
+            const actionKey = "action" in options ? options.action : options.actionKey;
+            const { actionType, connectionId, connection, authenticationId, inputs = {}, cursor, timeoutMs, } = options;
+            const resolvedConnectionId = await resolveConnectionId({
+                connectionId,
+                connection,
+                authenticationId,
+                resolveConnection: sdk.context.resolveConnection,
+            });
+            const { selectedApi, actionId } = await getRunActionContext({
                 appKey,
                 actionKey,
+                actionType,
             });
-        }
-        return {
-            data: result.results || [],
-            nextCursor: result.next_page,
-        };
-    }
-    const methodName = stripPageSuffix(runActionPage.name);
-    // No defaultPageSize — we leave the default to the Actions API rather than
-    // eagerly running more actions than the user intends to
-    // (and avoid potentially hitting app rate limits).
-    const runActionDefinition = createPaginatedFunction(runActionPage, RunActionInputSchema, createTelemetryCallback(sdk.context.eventEmission.emitMethodCalled, methodName), methodName);
-    return {
-        runAction: runActionDefinition,
-        context: {
-            meta: {
-                runAction: {
-                    categories: ["action"],
-                    type: "list",
-                    itemType: "ActionResult",
-                    inputSchema: RunActionSchema,
-                    outputSchema: ActionResultItemSchema,
-                    resolvers: {
-                        app: appKeyResolver,
-                        actionType: actionTypeResolver,
-                        action: actionKeyResolver,
-                        connection: connectionIdResolver,
-                        inputs: inputsResolver,
-                    },
-                },
-            },
+            setMethodMetadata({
+                selectedApi,
+                operationType: actionType,
+                operationKey: actionKey,
+            });
+            const result = await executeAction({
+                api,
+                selectedApi,
+                // Some actions require the action ID, but it's not guaranteed
+                // available at retrieval time (legacy), so pass everything through.
+                actionId,
+                actionKey,
+                actionType,
+                executionOptions: { inputs },
+                cursor,
+                connectionId: resolvedConnectionId,
+                timeoutMs,
+            });
+            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: result.next_page,
+            };
         },
-    };
-};
+    });
+});

package/dist/plugins/runAction/schemas.d.ts

@@ -1,16 +1,14 @@
 import { z } from "zod";
-import type { PaginatedSdkFunction } from "../../types/functions";
-import type { ZapierActionError, ZapierValidationError, ZapierConfigurationError, ZapierUnknownError } from "../../types/errors";
 export declare const RunActionSchema: z.ZodObject<{
     app: z.ZodString & {
         _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
     };
     actionType: z.ZodEnum<{
-        search: "search";
         filter: "filter";
         read: "read";
         read_bulk: "read_bulk";
         run: "run";
+        search: "search";
         search_and_write: "search_and_write";
         search_or_write: "search_or_write";
         write: "write";
@@ -32,11 +30,11 @@ declare const RunActionSchemaDeprecated: z.ZodObject<{
         _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
     };
     actionType: z.ZodEnum<{
-        search: "search";
         filter: "filter";
         read: "read";
         read_bulk: "read_bulk";
         run: "run";
+        search: "search";
         search_and_write: "search_and_write";
         search_or_write: "search_or_write";
         write: "write";
@@ -56,11 +54,11 @@ export declare const RunActionInputSchema: z.ZodUnion<readonly [z.ZodObject<{
         _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
     };
     actionType: z.ZodEnum<{
-        search: "search";
         filter: "filter";
         read: "read";
         read_bulk: "read_bulk";
         run: "run";
+        search: "search";
         search_and_write: "search_and_write";
         search_or_write: "search_or_write";
         write: "write";
@@ -81,11 +79,11 @@ export declare const RunActionInputSchema: z.ZodUnion<readonly [z.ZodObject<{
         _def: z.core.$ZodStringDef & import("../..").PositionalMetadata;
     };
     actionType: z.ZodEnum<{
-        search: "search";
         filter: "filter";
         read: "read";
         read_bulk: "read_bulk";
         run: "run";
+        search: "search";
         search_and_write: "search_and_write";
         search_or_write: "search_or_write";
         write: "write";
@@ -106,13 +104,5 @@ export type RunActionOptions = z.infer<typeof RunActionSchema> | (Omit<z.infer<t
     /** @deprecated Use `action` instead. */
     actionKey: z.infer<typeof RunActionSchemaDeprecated>["actionKey"];
 });
-export interface RunActionPage {
-    data: unknown[];
-    nextCursor?: string;
-}
-export type RunActionError = ZapierActionError | ZapierValidationError | ZapierConfigurationError | ZapierUnknownError;
-export interface RunActionSdkFunction {
-    runAction: PaginatedSdkFunction<RunActionOptions, unknown>;
-}
 export {};
 //# sourceMappingURL=schemas.d.ts.map

package/dist/plugins/runAction/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/runAction/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACrB,wBAAwB,EACxB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAiC5B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;iBAexB,CAAC;AAGL,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;iBAMF,CAAC;AAG9B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAEA,CAAC;AAGlC,MAAM,MAAM,gBAAgB,GACxB,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GAC/B,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC,GAAG;IACzE,qCAAqC;IACrC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC5D,wCAAwC;IACxC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC,WAAW,CAAC,CAAC;CACnE,CAAC,CAAC;AAGP,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,MAAM,cAAc,GACtB,iBAAiB,GACjB,qBAAqB,GACrB,wBAAwB,GACxB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,oBAAoB,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;CAC5D"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/runAction/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6CxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;iBAexB,CAAC;AAGL,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;iBAMF,CAAC;AAG9B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAEA,CAAC;AAGlC,MAAM,MAAM,gBAAgB,GACxB,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,GAC/B,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,EAAE,QAAQ,GAAG,WAAW,CAAC,GAAG;IACzE,qCAAqC;IACrC,MAAM,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC5D,wCAAwC;IACxC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC,WAAW,CAAC,CAAC;CACnE,CAAC,CAAC"}