@zapier/zapier-sdk 0.15.0 → 0.15.2

package/dist/plugins/getApp/index.test.js

@@ -39,7 +39,7 @@ describe("getApp plugin", () => {
             // Mock the API client to handle both resolveAppKeys and listApps calls
             context.api.get = vi
                 .fn()
-                // First call: resolveAppKeys may call to resolve slug to implementation name
+                // First call: resolveAppKeys calls listAppsForSlugsPage which expects raw API format
                 .mockResolvedValueOnce({
                 results: [
                     {
@@ -49,27 +49,25 @@ describe("getApp plugin", () => {
                         primary_color: "#4A154B",
                         categories: ["communication"],
                         slug: "slack",
-                        key: "SlackCLIAPI",
-                        version: "1.0.0",
                     },
                 ],
                 next: null,
             })
-                // Second call: listApps main API call
+                // Second call: listApps goes through handler which returns transformed format
                 .mockResolvedValueOnce({
-                results: [
+                data: [
                     {
-                        id: "SlackCLIAPI@1.0.0",
-                        name: "Slack",
+                        title: "Slack",
+                        key: "SlackCLIAPI",
+                        implementation_id: "SlackCLIAPI@1.0.0",
                         description: "Team communication",
                         primary_color: "#4A154B",
                         categories: ["communication"],
                         slug: "slack",
-                        key: "SlackCLIAPI",
                         version: "1.0.0",
                     },
                 ],
-                next: null,
+                nextCursor: undefined,
             });
             const result = await sdk.getApp({
                 appKey: "slack",
@@ -92,10 +90,10 @@ describe("getApp plugin", () => {
                 results: [],
                 next: null,
             })
-                // Second call: listApps main API call
+                // Second call: listApps main API call (returns transformed format)
                 .mockResolvedValueOnce({
-                results: [],
-                next: null,
+                data: [],
+                nextCursor: undefined,
             });
             await expect(sdk.getApp({
                 appKey: "nonexistent-app",
@@ -109,7 +107,7 @@ describe("getApp plugin", () => {
             // Mock the API client to handle both resolveAppKeys and listApps calls
             context.api.get = vi
                 .fn()
-                // First call: resolveAppKeys may call to resolve slug to implementation name
+                // First call: resolveAppKeys calls listAppsForSlugsPage which expects raw API format
                 .mockResolvedValueOnce({
                 results: [
                     {
@@ -119,27 +117,25 @@ describe("getApp plugin", () => {
                         primary_color: "#FF0000",
                         categories: ["testing"],
                         slug: "test",
-                        key: "TestCLIAPI",
-                        version: "1.0.0",
                     },
                 ],
                 next: null,
             })
-                // Second call: listApps main API call
+                // Second call: listApps goes through handler which returns transformed format
                 .mockResolvedValueOnce({
-                results: [
+                data: [
                     {
-                        id: "TestCLIAPI@1.0.0",
-                        name: "Test App",
+                        title: "Test App",
+                        key: "TestCLIAPI",
+                        implementation_id: "TestCLIAPI@1.0.0",
                         description: "Test description",
                         primary_color: "#FF0000",
                         categories: ["testing"],
                         slug: "test",
-                        key: "TestCLIAPI",
                         version: "1.0.0",
                     },
                 ],
-                next: null,
+                nextCursor: undefined,
             });
             const result = await sdk.getApp({
                 appKey: "test",

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

@@ -0,0 +1,22 @@
+import type { Plugin, GetSdkType } from "../../types/plugin";
+import type { ApiClient } from "../../api";
+import { GetInputFieldsSchemaSchema, type GetInputFieldsSchemaOptions as GetInputFieldsSchemaOptions } from "./schemas";
+import type { GetActionPluginProvides } from "../getAction";
+import type { GetVersionedImplementationId } from "../manifest/schemas";
+export interface GetInputFieldsSchemaPluginProvides {
+    getInputFieldsSchema: (options: GetInputFieldsSchemaOptions) => Promise<{
+        data: Record<string, unknown>;
+    }>;
+    context: {
+        meta: {
+            getInputFieldsSchema: {
+                inputSchema: typeof GetInputFieldsSchemaSchema;
+            };
+        };
+    };
+}
+export declare const getInputFieldsSchemaPlugin: Plugin<GetSdkType<GetActionPluginProvides>, {
+    api: ApiClient;
+    getVersionedImplementationId: GetVersionedImplementationId;
+}, GetInputFieldsSchemaPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/getInputFieldsSchema/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EACL,0BAA0B,EAC1B,KAAK,2BAA2B,IAAI,2BAA2B,EAChE,MAAM,WAAW,CAAC;AAGnB,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAUxE,MAAM,WAAW,kCAAkC;IACjD,oBAAoB,EAAE,CACpB,OAAO,EAAE,2BAA2B,KACjC,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;IAChD,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,oBAAoB,EAAE;gBACpB,WAAW,EAAE,OAAO,0BAA0B,CAAC;aAChD,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,0BAA0B,EAAE,MAAM,CAC7C,UAAU,CAAC,uBAAuB,CAAC,EACnC;IACE,GAAG,EAAE,SAAS,CAAC;IACf,4BAA4B,EAAE,4BAA4B,CAAC;CAC5D,EACD,kCAAkC,CAmEnC,CAAC"}

package/dist/plugins/getInputFieldsSchema/index.js

@@ -0,0 +1,51 @@
+import { GetInputFieldsSchemaSchema, } from "./schemas";
+import { ZapierConfigurationError } from "../../types/errors";
+import { createFunction } from "../../utils/function-utils";
+import { appKeyResolver, actionTypeResolver, actionKeyResolver, authenticationIdResolver, inputsAllOptionalResolver, } from "../../resolvers";
+import { fetchImplementationNeeds } from "../../services/implementations";
+export const getInputFieldsSchemaPlugin = ({ sdk, context }) => {
+    const getInputFieldsSchema = createFunction(async function getInputFieldsSchema(options) {
+        const { api, getVersionedImplementationId } = context;
+        const { appKey, actionKey, actionType, authenticationId = null, inputs, } = options;
+        const selectedApi = await getVersionedImplementationId(appKey);
+        if (!selectedApi) {
+            throw new ZapierConfigurationError("No current_implementation_id found for app", { configType: "current_implementation_id" });
+        }
+        const { data: action } = await sdk.getAction({
+            appKey,
+            actionType,
+            actionKey,
+        });
+        const needsData = await fetchImplementationNeeds({
+            api,
+            selectedApi,
+            action: action.key,
+            actionType,
+            authenticationId,
+            inputs,
+        });
+        return {
+            data: needsData.schema || {},
+        };
+    }, GetInputFieldsSchemaSchema);
+    return {
+        getInputFieldsSchema,
+        context: {
+            meta: {
+                getInputFieldsSchema: {
+                    categories: ["action"],
+                    type: "item",
+                    itemType: "InputSchema",
+                    inputSchema: GetInputFieldsSchemaSchema,
+                    resolvers: {
+                        appKey: appKeyResolver,
+                        actionType: actionTypeResolver,
+                        actionKey: actionKeyResolver,
+                        authenticationId: authenticationIdResolver,
+                        inputs: inputsAllOptionalResolver,
+                    },
+                },
+            },
+        },
+    };
+};

package/dist/plugins/getInputFieldsSchema/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/plugins/getInputFieldsSchema/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../src/plugins/getInputFieldsSchema/index.test.ts"],"names":[],"mappings":""}

package/dist/plugins/getInputFieldsSchema/index.test.js

@@ -0,0 +1,288 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError, ZapierConfigurationError, ZapierApiError, } from "../../types/errors";
+import { getInputFieldsSchemaPlugin } from "./index";
+import { getActionPlugin } from "../getAction";
+import { getAppPlugin } from "../getApp";
+import { listActionsPlugin } from "../listActions";
+import { listAppsPlugin } from "../listApps";
+import { createSdk } from "../../sdk";
+const mockSchema = {
+    type: "object",
+    properties: {
+        message: {
+            type: "string",
+            title: "Message",
+            description: "The message to send",
+        },
+        channel: {
+            type: "string",
+            title: "Channel",
+            description: "The channel to send to",
+        },
+        tags: {
+            type: "array",
+            items: {
+                type: "string",
+            },
+            title: "Tags",
+            description: "List of tags",
+        },
+    },
+    required: ["message", "channel"],
+};
+const mockNeedsResponse = {
+    success: true,
+    needs: [],
+    schema: mockSchema,
+};
+const mockActionsResponse = {
+    results: [
+        {
+            slug: "slack",
+            selected_api: "slack",
+            actions: [
+                {
+                    key: "send_message",
+                    name: "Send Message",
+                    description: "Send a message to a channel",
+                    type_of: "write",
+                    type: "write",
+                    id: "core:12345",
+                },
+            ],
+        },
+    ],
+    meta: {
+        next_cursor: null,
+    },
+};
+describe("getInputFieldsSchema plugin", () => {
+    let mockApiClient;
+    let mockGetVersionedImplementationId;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockApiClient = {
+            get: vi.fn().mockResolvedValue(mockActionsResponse),
+            post: vi.fn().mockResolvedValue(mockNeedsResponse),
+        };
+        mockGetVersionedImplementationId = vi
+            .fn()
+            .mockResolvedValue("SlackCLIAPI@1.21.1");
+    });
+    function createTestSdk() {
+        return createSdk({}, {}, {
+            api: mockApiClient,
+            meta: {},
+            getVersionedImplementationId: mockGetVersionedImplementationId,
+        })
+            .addPlugin(listAppsPlugin)
+            .addPlugin(listActionsPlugin)
+            .addPlugin(getAppPlugin)
+            .addPlugin(getActionPlugin)
+            .addPlugin(getInputFieldsSchemaPlugin);
+    }
+    describe("schema validation", () => {
+        it("should throw validation error for missing required fields", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getInputFieldsSchema({
+            // Missing required fields
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid field types", async () => {
+            const sdk = createTestSdk();
+            await expect(sdk.getInputFieldsSchema({
+                appKey: 123,
+                actionType: "write",
+                actionKey: "send_message",
+            })).rejects.toThrow(ZapierValidationError);
+        });
+        it("should pass validation with all required fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            expect(result.data).toBeDefined();
+        });
+        it("should pass validation with optional fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                authenticationId: 123,
+                inputs: { channel: "#general" },
+            });
+            expect(result.data).toBeDefined();
+        });
+    });
+    describe("API integration", () => {
+        it("should call the correct API endpoint", async () => {
+            const sdk = createTestSdk();
+            await sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", {
+                selected_api: "SlackCLIAPI@1.21.1",
+                action: "send_message",
+                type_of: "write",
+                params: {},
+            });
+        });
+        it("should include authentication_id when provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                authenticationId: 123,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", {
+                selected_api: "SlackCLIAPI@1.21.1",
+                action: "send_message",
+                type_of: "write",
+                params: {},
+                authentication_id: 123,
+            });
+        });
+        it("should exclude authentication_id when null", async () => {
+            const sdk = createTestSdk();
+            await sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                authenticationId: null,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", {
+                selected_api: "SlackCLIAPI@1.21.1",
+                action: "send_message",
+                type_of: "write",
+                params: {},
+                // No authentication_id
+            });
+        });
+        it("should include inputs when provided", async () => {
+            const sdk = createTestSdk();
+            const inputs = { channel: "#general", message: "test" };
+            await sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+                inputs,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/zapier/api/v4/implementations/needs/", {
+                selected_api: "SlackCLIAPI@1.21.1",
+                action: "send_message",
+                type_of: "write",
+                params: inputs,
+            });
+        });
+    });
+    describe("data return", () => {
+        it("should return the schema object from the API response", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            expect(result.data).toEqual(mockSchema);
+        });
+        it("should return empty object when schema is not present", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: true,
+                needs: [],
+                // No schema field
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            expect(result.data).toEqual({});
+        });
+        it("should handle complex schema structures", async () => {
+            const complexSchema = {
+                type: "object",
+                properties: {
+                    user: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            age: { type: "number" },
+                        },
+                        required: ["name"],
+                    },
+                    tags: {
+                        type: "array",
+                        items: { type: "string" },
+                    },
+                },
+                required: ["user"],
+            };
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: true,
+                needs: [],
+                schema: complexSchema,
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            });
+            expect(result.data).toEqual(complexSchema);
+        });
+    });
+    describe("error handling", () => {
+        it("should throw ZapierConfigurationError when app has no current_implementation_id", async () => {
+            mockGetVersionedImplementationId.mockResolvedValue(null);
+            const sdk = createTestSdk();
+            await expect(sdk.getInputFieldsSchema({
+                appKey: "invalid",
+                actionType: "write",
+                actionKey: "send_message",
+            })).rejects.toThrow(ZapierConfigurationError);
+        });
+        it("should throw ZapierApiError when API response indicates failure", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: false,
+                errors: ["Authentication failed", "Invalid credentials"],
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            })).rejects.toThrow(ZapierApiError);
+            await expect(sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            })).rejects.toThrow("Failed to get input fields: Authentication failed, Invalid credentials");
+        });
+        it("should handle API errors gracefully", async () => {
+            mockApiClient.post = vi
+                .fn()
+                .mockRejectedValue(new Error("Network error"));
+            const sdk = createTestSdk();
+            await expect(sdk.getInputFieldsSchema({
+                appKey: "slack",
+                actionType: "write",
+                actionKey: "send_message",
+            })).rejects.toThrow("Network error");
+        });
+    });
+    describe("context and metadata", () => {
+        it("should provide context with meta information", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.getInputFieldsSchema).toBeDefined();
+            expect(context.meta.getInputFieldsSchema.inputSchema).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import type { ZapierConfigurationError, ZapierApiError, ZapierAuthenticationError, ZapierAppNotFoundError, ZapierValidationError, ZapierUnknownError } from "../../types/errors";
+export declare const GetInputFieldsSchemaSchema: z.ZodObject<{
+    appKey: z.ZodString & {
+        _def: z.ZodStringDef & import("../..").PositionalMetadata;
+    };
+    actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
+    actionKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "search" | "filter" | "read" | "read_bulk" | "run" | "search_and_write" | "search_or_write" | "write";
+    actionKey: string;
+    authenticationId?: number | null | undefined;
+    inputs?: Record<string, unknown> | undefined;
+}, {
+    appKey: string;
+    actionType: "search" | "filter" | "read" | "read_bulk" | "run" | "search_and_write" | "search_or_write" | "write";
+    actionKey: string;
+    authenticationId?: number | null | undefined;
+    inputs?: Record<string, unknown> | undefined;
+}>;
+export type GetInputFieldsSchemaOptions = z.infer<typeof GetInputFieldsSchemaSchema>;
+export type GetInputFieldsSchemaError = ZapierConfigurationError | ZapierApiError | ZapierAuthenticationError | ZapierAppNotFoundError | ZapierValidationError | ZapierUnknownError;
+export interface GetInputFieldsSchemaSdkFunction {
+    getInputFieldsSchema: (options: GetInputFieldsSchemaOptions) => Promise<{
+        data: Record<string, unknown>;
+    }>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/getInputFieldsSchema/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,OAAO,KAAK,EACV,wBAAwB,EACxB,cAAc,EACd,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;EAsBpC,CAAC;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAC/C,OAAO,0BAA0B,CAClC,CAAC;AAEF,MAAM,MAAM,yBAAyB,GACjC,wBAAwB,GACxB,cAAc,GACd,yBAAyB,GACzB,sBAAsB,GACtB,qBAAqB,GACrB,kBAAkB,CAAC;AAEvB,MAAM,WAAW,+BAA+B;IAC9C,oBAAoB,EAAE,CACpB,OAAO,EAAE,2BAA2B,KACjC,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,CAAC,CAAC;CACjD"}

package/dist/plugins/getInputFieldsSchema/schemas.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { AppKeyPropertySchema, ActionTypePropertySchema, ActionKeyPropertySchema, AuthenticationIdPropertySchema, InputsPropertySchema, } from "../../types/properties";
+export const GetInputFieldsSchemaSchema = z
+    .object({
+    appKey: AppKeyPropertySchema.describe("App key (e.g., 'SlackCLIAPI' or slug like 'github') to get the input schema for"),
+    actionType: ActionTypePropertySchema.describe("Action type that matches the action's defined type"),
+    actionKey: ActionKeyPropertySchema.describe("Action key to get the input schema for"),
+    authenticationId: AuthenticationIdPropertySchema.nullable()
+        .optional()
+        .describe("Authentication ID to use when fetching the schema. Required if the action needs authentication to determine available fields."),
+    inputs: InputsPropertySchema.optional().describe("Current input values that may affect the schema (e.g., when fields depend on other field values)"),
+})
+    .describe("Get the JSON Schema representation of input fields for an action. Returns a JSON Schema object describing the structure, types, and validation rules for the action's input parameters.");

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

@@ -12,15 +12,15 @@ export declare const ListActionsSchema: z.ZodObject<{
     cursor: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     appKey: string;
-    cursor?: string | undefined;
-    maxItems?: number | undefined;
     pageSize?: number | undefined;
+    maxItems?: number | undefined;
+    cursor?: string | undefined;
     actionType?: "search" | "filter" | "read" | "read_bulk" | "run" | "search_and_write" | "search_or_write" | "write" | undefined;
 }, {
     appKey: string;
-    cursor?: string | undefined;
-    maxItems?: number | undefined;
     pageSize?: number | undefined;
+    maxItems?: number | undefined;
+    cursor?: string | undefined;
     actionType?: "search" | "filter" | "read" | "read_bulk" | "run" | "search_and_write" | "search_or_write" | "write" | undefined;
 }>;
 export type ListActionsOptions = z.infer<typeof ListActionsSchema>;

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

@@ -1,7 +1,5 @@
 import type { GetContextType, Plugin } from "../../types/plugin";
-import { ListAppsSchema } from "./schemas";
-import type { ListAppsOptions } from "./schemas";
-import type { AppItem } from "../../types/domain";
+import { ListAppsSchema, type ListAppsOptions, type AppItem } from "./schemas";
 import type { ManifestPluginProvides } from "../manifest";
 import type { ApiPluginProvides } from "../api";
 export interface ListAppsPluginProvides {

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/listApps/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjE,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,KAAK,EAAE,eAAe,EAAgB,MAAM,WAAW,CAAC;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAWlD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAEhD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC;QAC/C,IAAI,EAAE,OAAO,EAAE,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,OAAO,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QACxD,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;KACjC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,QAAQ,EAAE;gBACR,WAAW,EAAE,OAAO,cAAc,CAAC;aACpC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EACF,cAAc,CAAC,iBAAiB,GAAG,sBAAsB,CAAC,EAC1D,sBAAsB,CAwHvB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/listApps/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjE,OAAO,EACL,cAAc,EACd,KAAK,eAAe,EAEpB,KAAK,OAAO,EACb,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,QAAQ,CAAC;AAEhD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC;QAC/C,IAAI,EAAE,OAAO,EAAE,CAAC;QAChB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC,GACA,aAAa,CAAC;QAAE,IAAI,EAAE,OAAO,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,GAAG;QACxD,KAAK,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC;KACjC,CAAC;IACJ,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,QAAQ,EAAE;gBACR,WAAW,EAAE,OAAO,cAAc,CAAC;aACpC,CAAC;SACH,CAAC;KACH,CAAC;CACH;AAED,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EACF,cAAc,CAAC,iBAAiB,GAAG,sBAAsB,CAAC,EAC1D,sBAAsB,CAwEvB,CAAC"}

package/dist/plugins/listApps/index.js

@@ -1,8 +1,6 @@
 import { createPaginatedFunction } from "../../utils/function-utils";
-import { ListAppsSchema } from "./schemas";
+import { ListAppsSchema, } from "./schemas";
 import { AppItemSchema } from "../../schemas/App";
-import { normalizeImplementationMetaToAppItem, splitVersionedKey, toAppLocator, toImplementationId, } from "../../utils/domain-utils";
-import { extractCursor } from "../../utils/function-utils";
 export const listAppsPlugin = ({ context }) => {
     const listApps = createPaginatedFunction(async function listAppsPage(options) {
         const { api, resolveAppKeys } = context;
@@ -25,53 +23,29 @@ export const listAppsPlugin = ({ context }) => {
         if (duplicatedLookupAppKeys.length > 0) {
             throw new Error(`Duplicate lookup app keys found: ${duplicatedLookupAppKeys.join(", ")}`);
         }
-        if (options.search) {
-            const searchParams = {};
-            searchParams.term = options.search;
-            const searchEnvelope = await api.get("/zapier/api/v4/implementations-meta/search/", {
-                searchParams,
-            });
-            const implementations = searchEnvelope.results.map(normalizeImplementationMetaToAppItem);
-            const implementationNameSet = new Set(appLocators.map((locator) => locator.implementationName));
-            for (const implementation of implementations) {
-                const [implementationName] = splitVersionedKey(implementation.key);
-                if (!implementationNameSet.has(implementationName)) {
-                    implementationNameSet.add(implementationName);
-                    appLocators.push({
-                        ...toAppLocator(implementation.key),
-                        implementationName,
-                    });
-                }
-            }
-        }
-        const searchParams = {};
-        if (options.pageSize) {
-            searchParams.limit = options.pageSize.toString();
-        }
-        if (appLocators.length === 0) {
-            searchParams.latest_only = "true";
-        }
-        if (options.cursor) {
-            searchParams.offset = options.cursor;
-        }
-        searchParams.selected_apis = appLocators
-            .map((locator) => toImplementationId(locator))
-            .join(",");
-        // If we have app keys, but they resolved to an empty list, then we need to short-circuit and return an empty list.
-        // Otherwise, the API will return all apps, since no selected_apis are provided.
-        if (appKeys.length > 0 && appLocators.length === 0) {
+        // Step 2: Early return if user provided appKeys but they resolved to nothing AND no search
+        // This prevents the handler from returning all apps when the user explicitly filtered
+        // If search is provided, let the handler augment with search results
+        if (appKeys.length > 0 && appLocators.length === 0 && !options.search) {
             return {
                 data: [],
                 nextCursor: undefined,
             };
         }
-        const implementationsEnvelope = await api.get("/zapier/api/v4/implementations-meta/lookup/", {
-            searchParams,
+        const implementationIds = appLocators.map((locator) => {
+            const version = locator.version || "latest";
+            return `${locator.implementationName}@${version}`;
+        });
+        // Call the API, which will be routed to the handler via handlerOverride in pathConfig.
+        // When the handler is migrated to sdkapi, this same API call will go over the network.
+        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 }),
+            },
         });
-        return {
-            data: implementationsEnvelope.results.map(normalizeImplementationMetaToAppItem),
-            nextCursor: extractCursor(implementationsEnvelope),
-        };
     }, ListAppsSchema);
     // Return flat structure - listApps goes directly to SDK
     return {