@zapier/zapier-sdk 0.77.1 → 0.77.2

package/dist/plugins/request/index.js

@@ -1,28 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPluginMethod } from "kitcore";
-import { RelayRequestSchema } from "./schemas";
-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.
- */
-export const requestPlugin = definePlugin((sdk) => createPluginMethod(sdk, {
-    name: "request",
-    packages: ["cli", "mcp"],
-    categories: ["http"],
-    deprecation: { message: "Use fetch() instead." },
-    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, {
-            method,
-            body: body,
-            headers: headers,
-            connection: connection ?? connectionId ?? authenticationId,
-            callbackUrl,
-        });
-    },
-}));

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

@@ -1,46 +0,0 @@
-import { z } from "zod";
-export declare const RelayRequestSchema: z.ZodObject<{
-    url: z.ZodString;
-    method: z.ZodOptional<z.ZodEnum<{
-        POST: "POST";
-        GET: "GET";
-        DELETE: "DELETE";
-        PUT: "PUT";
-        PATCH: "PATCH";
-        HEAD: "HEAD";
-        OPTIONS: "OPTIONS";
-    }>>;
-    body: z.ZodOptional<z.ZodAny>;
-    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    callbackUrl: z.ZodOptional<z.ZodString>;
-    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 interface RelayRequestSdkFunction {
-    request: (options: RelayRequestOptions) => Promise<Response>;
-}
-export declare const RelayFetchSchema: z.ZodObject<{
-    url: z.ZodString;
-    method: z.ZodOptional<z.ZodEnum<{
-        POST: "POST";
-        GET: "GET";
-        DELETE: "DELETE";
-        PUT: "PUT";
-        PATCH: "PATCH";
-        HEAD: "HEAD";
-        OPTIONS: "OPTIONS";
-    }>>;
-    body: z.ZodOptional<z.ZodAny>;
-    connection: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    connectionId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    authenticationId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    callbackUrl: z.ZodOptional<z.ZodString>;
-    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 RelayFetchOptions = RelayRequestOptions;
-export interface RelayFetchSdkFunction {
-    fetch: (options: RelayFetchOptions) => Promise<Response>;
-}
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1 +0,0 @@
-{"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/request/schemas.js

@@ -1,42 +0,0 @@
-import { z } from "zod";
-import { ConnectionIdPropertySchema, ConnectionPropertySchema, AuthenticationIdPropertySchema, } from "../../types/properties";
-// Pure Zod schema for the request function
-export const RelayRequestSchema = z
-    .object({
-    url: z
-        .string()
-        .url()
-        .describe("The URL to request (will be proxied through Relay)"),
-    method: z
-        .enum(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"])
-        .optional()
-        .describe("HTTP method"),
-    body: z.any().optional().describe("Request body as a string"),
-    connection: ConnectionPropertySchema.optional(),
-    connectionId: ConnectionIdPropertySchema.optional().meta({
-        deprecated: true,
-    }),
-    /** @deprecated Use connection instead */
-    authenticationId: AuthenticationIdPropertySchema.optional().meta({
-        deprecated: true,
-    }),
-    callbackUrl: z
-        .string()
-        .url()
-        .optional()
-        .describe("URL to send async response to (makes request async)"),
-    headers: z
-        .union([
-        z.record(z.string(), z.string()),
-        z.instanceof(Headers),
-        z.array(z.tuple([z.string(), z.string()])),
-    ])
-        .optional()
-        .describe("Request headers"),
-})
-    .describe("Make authenticated HTTP requests through Zapier's Relay service")
-    .meta({
-    aliases: { connectionId: "connection", authenticationId: "connection" },
-});
-// Legacy exports for compatibility
-export const RelayFetchSchema = RelayRequestSchema;

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

@@ -1,313 +0,0 @@
-import type { ApiClient } from "../../api";
-import type { GetVersionedImplementationId } from "../manifest/schemas";
-import type { ConnectionsPluginProvides } from "../connections";
-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" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write";
-        action: string;
-    } | {
-        appKey: string;
-        actionType: "filter" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write";
-        actionKey: string;
-    } | undefined) => Promise<{
-        data: {
-            description: string;
-            key: string;
-            app_key: string;
-            action_type: "filter" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write";
-            title: string;
-            type: "action";
-            id?: string | undefined;
-            is_important?: boolean | undefined;
-            is_hidden?: boolean | undefined;
-            app_version?: string | undefined;
-        };
-    }>;
-} & {
-    context: {
-        meta: {
-            getAction: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    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: {
-            getApp: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listApps: (options?: ({
-        search?: string | undefined;
-        apps?: string[] | undefined;
-        appKeys?: string[] | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        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: {
-            listApps: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listActions: (options?: (({
-        app: string;
-        actionType?: "filter" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } | {
-        appKey: string;
-        actionType?: "filter" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    }) & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        description: string;
-        key: string;
-        app_key: string;
-        action_type: "filter" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write";
-        title: string;
-        type: "action";
-        id?: string | undefined;
-        is_important?: boolean | undefined;
-        is_hidden?: boolean | undefined;
-        app_version?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listActions: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    listConnections: (options?: ({
-        title?: string | undefined;
-        search?: string | undefined;
-        owner?: string | undefined;
-        app?: string | undefined;
-        appKey?: string | undefined;
-        connections?: string[] | undefined;
-        connectionIds?: string[] | undefined;
-        authenticationIds?: string[] | undefined;
-        account?: string | undefined;
-        accountId?: string | undefined;
-        includeShared?: boolean | undefined;
-        isExpired?: boolean | undefined;
-        expired?: boolean | undefined;
-        pageSize?: number | undefined;
-        maxItems?: number | undefined;
-        cursor?: string | undefined;
-    } & {
-        cursor?: string;
-        pageSize?: number;
-        maxItems?: number;
-    }) | undefined) => import("kitcore").PaginatedSdkResult<{
-        date: string;
-        is_invite_only: boolean;
-        is_private: boolean;
-        shared_with_all: boolean;
-        id: string;
-        account_id: string;
-        title?: string | null | undefined;
-        lastchanged?: string | undefined;
-        destination_selected_api?: string | null | undefined;
-        is_stale?: string | undefined;
-        is_shared?: string | undefined;
-        marked_stale_at?: string | null | undefined;
-        label?: string | null | undefined;
-        identifier?: string | null | undefined;
-        url?: string | undefined;
-        groups?: Record<string, unknown>[] | undefined;
-        members?: string | undefined;
-        permissions?: Record<string, boolean> | undefined;
-        public_id?: string | undefined;
-        account_public_id?: string | undefined;
-        customuser_public_id?: string | undefined;
-        implementation_id?: string | undefined;
-        profile_id?: string | undefined;
-        is_expired?: string | undefined;
-        expired_at?: string | null | undefined;
-        app_key?: string | undefined;
-        app_version?: string | undefined;
-    }>;
-} & {
-    context: {
-        meta: {
-            listConnections: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-} & {
-    context: {
-        api: ApiClient;
-        getVersionedImplementationId: GetVersionedImplementationId;
-    } & ConnectionsPluginProvides["context"];
-} & {
-    context: import("../eventEmission").EventEmissionContext;
-} & {
-    context: {
-        meta: Record<string, import("kitcore").PluginMeta>;
-    };
-}) => {
-    runAction: (options?: (({
-        app: string;
-        actionType: "filter" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_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" | "write" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_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("kitcore").PaginatedSdkResult<unknown>;
-} & {
-    context: {
-        meta: {
-            runAction: import("kitcore").PluginMeta<unknown>;
-        };
-    };
-};
-export type RunActionPluginProvides = ReturnType<typeof runActionPlugin>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/runAction/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAqB3C,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AACxE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gBAAgB,CAAC;AA6GhE,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAC3C,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOX;QACP,GAAG,EAAE,SAAS,CAAC;QACf,4BAA4B,EAAE,4BAA4B,CAAC;KAC5D,GAAG,yBAAyB,CAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwL/C,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/plugins/runAction/index.js

@@ -1,190 +0,0 @@
-import { definePlugin } from "kitcore";
-import { createPaginatedPluginMethod } from "kitcore";
-import { RunActionInputSchema } from "./schemas";
-import { ActionResultItemSchema } from "../../schemas/Run";
-import { actionResultItemFormatter } from "../../formatters/actionResult";
-import { ZapierValidationError, ZapierConfigurationError, ZapierActionError, } from "../../types/errors";
-import { appKeyResolver, actionTypeResolver, actionKeyResolver, connectionIdResolver, inputsResolver, } from "../../resolvers";
-import { resolveConnectionId } from "../../utils/domain-utils";
-import { DEFAULT_ACTION_TIMEOUT_MS } from "../../constants";
-import { setMethodMetadata } from "../eventEmission/method-metadata";
-import { buildActionRunContext } from "@zapier/policy-context";
-async function executeAction(actionOptions) {
-    const { api, selectedApi, actionId, actionKey, actionType, executionOptions, cursor, connectionId, timeoutMs, } = actionOptions;
-    // Step 1: POST to /actions/v1/runs to start execution
-    const runRequestData = {
-        selected_api: selectedApi,
-        action_id: actionId,
-        action_key: actionKey,
-        action_type: actionType,
-        inputs: executionOptions.inputs || {},
-    };
-    // Note: API still expects authentication_id, we just renamed the user-facing param
-    if (connectionId !== null && connectionId !== undefined) {
-        runRequestData.authentication_id = connectionId;
-    }
-    if (cursor) {
-        runRequestData.page = cursor;
-    }
-    const runRequest = {
-        data: runRequestData,
-    };
-    const runData = await api.post("/zapier/api/actions/v1/runs", runRequest, {
-        approvalContext: () => buildActionRunContext({
-            selected_api: selectedApi,
-            action_type: actionType,
-            action_key: actionKey,
-            connection_id: connectionId != null ? String(connectionId) : undefined,
-            // Cast: inputs is Record<string, unknown> at the SDK surface;
-            // buildActionRunContext validates it as JSON at runtime via zod
-            // (non-JSON values like Date/undefined are rejected there).
-            inputs: (executionOptions.inputs ?? {}),
-        }),
-    });
-    const runId = runData.data.id;
-    // Step 2: Poll GET /actions/v1/runs/{run_id} for results
-    return await api.poll(`/zapier/api/actions/v1/runs/${runId}`, {
-        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";
-        },
-        resultExtractor: (result) => result.data,
-    });
-}
-export const CONTEXT_CACHE_TTL_MS = 60000;
-export const CONTEXT_CACHE_MAX_SIZE = 500;
-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();
-    function evictIfNeeded() {
-        if (runActionContextCache.size < CONTEXT_CACHE_MAX_SIZE)
-            return;
-        const now = Date.now();
-        let oldestKey;
-        let oldestExpiry = Infinity;
-        let evictedAny = false;
-        for (const [key, entry] of runActionContextCache) {
-            if (now >= entry.expiresAt) {
-                runActionContextCache.delete(key);
-                evictedAny = true;
-            }
-            else if (entry.expiresAt < oldestExpiry) {
-                oldestExpiry = entry.expiresAt;
-                oldestKey = key;
-            }
-        }
-        if (!evictedAny && oldestKey) {
-            runActionContextCache.delete(oldestKey);
-        }
-    }
-    function getRunActionContext(options) {
-        const { appKey, actionKey, actionType } = options;
-        const contextKey = `${appKey}:${actionKey}:${actionType}`;
-        const cached = runActionContextCache.get(contextKey);
-        if (cached && Date.now() < cached.expiresAt) {
-            return cached.promise;
-        }
-        const pendingContext = resolveRunActionContext(options).catch((error) => {
-            const current = runActionContextCache.get(contextKey);
-            if (current?.promise === pendingContext) {
-                runActionContextCache.delete(contextKey);
-            }
-            throw error;
-        });
-        evictIfNeeded();
-        runActionContextCache.set(contextKey, {
-            promise: pendingContext,
-            expiresAt: Date.now() + CONTEXT_CACHE_TTL_MS,
-        });
-        return pendingContext;
-    }
-    async function resolveRunActionContext(options) {
-        const { appKey, actionKey, actionType } = options;
-        const selectedApi = await sdk.context.getVersionedImplementationId(appKey);
-        if (!selectedApi) {
-            throw new ZapierConfigurationError("No current_implementation_id found for app", { configType: "current_implementation_id" });
-        }
-        // Validate that the action exists using the getAction plugin
-        const actionData = await sdk.getAction({
-            app: appKey,
-            action: actionKey,
-            actionType,
-        });
-        // Validate action type matches
-        if (actionData.data.action_type !== actionType) {
-            throw new ZapierValidationError(`Action type mismatch: expected ${actionType}, got ${actionData.data.action_type}`);
-        }
-        return { selectedApi, actionId: actionData.data.id };
-    }
-    // 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,
-        formatter: actionResultItemFormatter,
-        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,
-            });
-            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 || [],
-                // Coerce to a string: the API returns a numeric page index, but
-                // `SdkPage.nextCursor` is a string (and the page guard enforces it).
-                nextCursor: result.next_page != null ? String(result.next_page) : undefined,
-            };
-        },
-    });
-});