@zapier/zapier-sdk 0.4.1 → 0.5.0

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

@@ -0,0 +1,467 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError, ZapierAuthenticationError, ZapierConfigurationError, } from "../../types/errors";
+import { listActionsPlugin } from "./index";
+import { createSdk } from "../../sdk";
+import { GetAppSchema } from "../getApp/schemas";
+const mockAppResponse = {
+    data: {
+        slug: "slack",
+        name: "Slack",
+        current_implementation_id: "SlackCLIAPI@1.20.0",
+        key: "slack",
+        title: "Slack",
+        hex_color: "#4A154B",
+    },
+};
+const mockImplementationsResponse = {
+    results: [
+        {
+            slug: "slack",
+            selected_api: "slack",
+            actions: [
+                {
+                    key: "user_by_email",
+                    name: "Search User by Email",
+                    description: "Find a user by email address",
+                    type_of: "search",
+                    type: "search",
+                },
+                {
+                    key: "send_message",
+                    name: "Send Message",
+                    description: "Send a message to a channel",
+                    type_of: "write",
+                    type: "write",
+                },
+                {
+                    key: "create_channel",
+                    name: "Create Channel",
+                    description: "Create a new channel",
+                    type_of: "write",
+                    type: "write",
+                },
+            ],
+        },
+    ],
+    meta: {
+        next_cursor: null,
+    },
+};
+const mockEmptyImplementationsResponse = {
+    results: [],
+    meta: {
+        next_cursor: null,
+    },
+};
+describe("listActions plugin", () => {
+    let mockApiClient;
+    let mockGetApp;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockApiClient = {
+            get: vi.fn().mockResolvedValue(mockImplementationsResponse),
+        };
+        mockGetApp = vi.fn().mockResolvedValue(mockAppResponse);
+    });
+    function createTestSdk() {
+        // Create a proper plugin chain with context dependencies
+        const mockGetAppPlugin = () => ({
+            getApp: mockGetApp,
+            context: {
+                meta: {
+                    getApp: {
+                        inputSchema: GetAppSchema,
+                    },
+                },
+            },
+        });
+        // Build SDK with proper plugin composition, providing API in initial context
+        return createSdk({}, { api: mockApiClient, meta: {} })
+            .addPlugin(mockGetAppPlugin)
+            .addPlugin(listActionsPlugin);
+    }
+    describe("schema validation", () => {
+        it("should pass validation with valid appKey", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({ appKey: "slack" });
+            expect(result.data).toHaveLength(3);
+        });
+        it("should throw validation error for missing appKey", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listActions({});
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid appKey type", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listActions({
+                    appKey: 123,
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for empty appKey", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listActions({ appKey: "" });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid pageSize", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listActions({ appKey: "slack", pageSize: 0 });
+            }).toThrow(ZapierValidationError);
+            expect(() => {
+                sdk.listActions({ appKey: "slack", pageSize: -5 });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid maxItems", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listActions({ appKey: "slack", maxItems: 0 });
+            }).toThrow(ZapierValidationError);
+            expect(() => {
+                sdk.listActions({ appKey: "slack", maxItems: -10 });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should throw validation error for invalid actionType", () => {
+            const sdk = createTestSdk();
+            expect(() => {
+                sdk.listActions({
+                    appKey: "slack",
+                    actionType: "invalid-type",
+                });
+            }).toThrow(ZapierValidationError);
+        });
+        it("should pass validation with all valid fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({
+                appKey: "slack",
+                actionType: "write",
+                pageSize: 10,
+                maxItems: 50,
+            });
+            expect(result.data).toHaveLength(2); // Only write actions
+            expect(result.data.every((action) => action.action_type === "write")).toBe(true);
+        });
+    });
+    describe("actionType enum validation", () => {
+        const validActionTypes = [
+            "read",
+            "read_bulk",
+            "write",
+            "run",
+            "search",
+            "search_or_write",
+            "search_and_write",
+            "filter",
+        ];
+        validActionTypes.forEach((actionType) => {
+            it(`should accept valid actionType: ${actionType}`, async () => {
+                const mockResponse = {
+                    results: [
+                        {
+                            slug: "slack",
+                            actions: [
+                                {
+                                    key: "test_action",
+                                    name: "Test Action",
+                                    description: "Test description",
+                                    type_of: actionType,
+                                    type: actionType,
+                                },
+                            ],
+                        },
+                    ],
+                    meta: { next_cursor: null },
+                };
+                mockApiClient.get = vi.fn().mockResolvedValue(mockResponse);
+                const sdk = createTestSdk();
+                const result = await sdk.listActions({
+                    appKey: "slack",
+                    actionType: actionType,
+                });
+                expect(result.data).toHaveLength(1);
+                expect(result.data[0].action_type).toBe(actionType);
+            });
+        });
+    });
+    describe("data transformation", () => {
+        it("should transform implementation actions to ActionItem format", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({ appKey: "slack" });
+            const firstAction = result.data[0];
+            // Check all required ActionItem fields are present
+            expect(firstAction).toHaveProperty("key");
+            expect(firstAction).toHaveProperty("type", "action");
+            expect(firstAction).toHaveProperty("action_type");
+            expect(firstAction).toHaveProperty("title");
+            expect(firstAction).toHaveProperty("app_key", "slack");
+            expect(firstAction).toHaveProperty("description");
+            // Check that title is mapped from API name field
+            expect(firstAction.title).toBe("Search User by Email");
+            expect(firstAction.app_key).toBe("slack");
+            expect(firstAction.type).toBe("action");
+        });
+        it("should map type_of to action_type", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({ appKey: "slack" });
+            expect(result.data[0].action_type).toBe("search"); // From type_of field
+            expect(result.data[1].action_type).toBe("write"); // From type_of field
+        });
+        it("should fall back to type field if type_of is missing", async () => {
+            const mockResponseWithoutTypeOf = {
+                results: [
+                    {
+                        slug: "slack",
+                        actions: [
+                            {
+                                key: "test_action",
+                                name: "Test Action",
+                                description: "Test description",
+                                type: "read", // Only type field, no type_of
+                            },
+                        ],
+                    },
+                ],
+                meta: { next_cursor: null },
+            };
+            mockApiClient.get = vi.fn().mockResolvedValue(mockResponseWithoutTypeOf);
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({ appKey: "slack" });
+            expect(result.data[0].action_type).toBe("read"); // Falls back to type field
+        });
+        it("should handle actions with read type", async () => {
+            const mockResponseWithoutType = {
+                results: [
+                    {
+                        slug: "slack",
+                        actions: [
+                            {
+                                key: "test_action",
+                                name: "Test Action",
+                                description: "Test description",
+                                type: "read", // Provide the required type field
+                            },
+                        ],
+                    },
+                ],
+                meta: { next_cursor: null },
+            };
+            mockApiClient.get = vi.fn().mockResolvedValue(mockResponseWithoutType);
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({ appKey: "slack" });
+            expect(result.data[0].action_type).toBe("read"); // Should match provided type
+        });
+    });
+    describe("filtering", () => {
+        it("should filter actions by actionType", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({
+                appKey: "slack",
+                actionType: "write",
+            });
+            expect(result.data).toHaveLength(2);
+            expect(result.data.every((action) => action.action_type === "write")).toBe(true);
+            expect(result.data.map((action) => action.key)).toEqual([
+                "send_message",
+                "create_channel",
+            ]);
+        });
+        it("should return empty array when no actions match filter", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({
+                appKey: "slack",
+                actionType: "filter", // No actions of this type in mock data
+            });
+            expect(result.data).toHaveLength(0);
+        });
+        it("should return all actions when no actionType filter provided", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({ appKey: "slack" });
+            expect(result.data).toHaveLength(3); // All actions
+        });
+    });
+    describe("pagination", () => {
+        it("should handle maxItems limit", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({
+                appKey: "slack",
+                maxItems: 2,
+            });
+            expect(result.data).toHaveLength(2); // Limited to maxItems
+        });
+        it("should support async iteration over pages", async () => {
+            const sdk = createTestSdk();
+            const listActions = sdk.listActions({ appKey: "slack" });
+            const pages = [];
+            for await (const page of listActions) {
+                pages.push(page);
+                break; // Just get first page for testing
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].data).toHaveLength(3);
+            expect(pages[0].data[0].key).toBe("user_by_email");
+        });
+        it("should support async iteration over individual items", async () => {
+            const sdk = createTestSdk();
+            const listActions = sdk.listActions({
+                appKey: "slack",
+                maxItems: 2,
+            });
+            const items = [];
+            for await (const item of listActions.items()) {
+                items.push(item);
+            }
+            expect(items).toHaveLength(2);
+            expect(items[0].key).toBe("user_by_email");
+            expect(items[1].key).toBe("send_message");
+        });
+        it("should respect pageSize parameter", async () => {
+            const sdk = createTestSdk();
+            await sdk.listActions({
+                appKey: "slack",
+                pageSize: 10,
+            });
+            // Note: Since listActions doesn't actually use pagination internally,
+            // we just verify it accepts the parameter without error
+            expect(mockApiClient.get).toHaveBeenCalled();
+        });
+    });
+    describe("API integration", () => {
+        it("should call getApp to get implementation ID", async () => {
+            const sdk = createTestSdk();
+            await sdk.listActions({ appKey: "slack" });
+            expect(mockGetApp).toHaveBeenCalledWith({
+                appKey: "slack",
+            });
+        });
+        it("should pass correct search parameters to implementations API", async () => {
+            const sdk = createTestSdk();
+            await sdk.listActions({ appKey: "slack" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/implementations/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    global: "true",
+                    public_only: "true",
+                    selected_apis: "SlackCLIAPI", // Extracted from current_implementation_id
+                }),
+            }));
+        });
+    });
+    describe("error handling", () => {
+        it("should throw ZapierConfigurationError when app has no current_implementation_id", async () => {
+            mockGetApp.mockResolvedValue({
+                data: {
+                    ...mockAppResponse.data,
+                    current_implementation_id: undefined, // Missing implementation ID
+                },
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(ZapierConfigurationError);
+        });
+        it("should throw ZapierConfigurationError when current_implementation_id is empty", async () => {
+            mockGetApp.mockResolvedValue({
+                data: {
+                    ...mockAppResponse.data,
+                    current_implementation_id: "", // Empty implementation ID
+                },
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(ZapierConfigurationError);
+        });
+        it("should handle authentication error (401)", async () => {
+            mockApiClient.get = vi.fn().mockImplementation((_url, options) => {
+                if (options.customErrorHandler) {
+                    const error = options.customErrorHandler({ status: 401 });
+                    if (error) {
+                        throw error;
+                    }
+                }
+                throw new Error("Unauthorized");
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(ZapierAuthenticationError);
+        });
+        it("should handle forbidden error (403)", async () => {
+            mockApiClient.get = vi.fn().mockImplementation((_url, options) => {
+                if (options.customErrorHandler) {
+                    const error = options.customErrorHandler({ status: 403 });
+                    if (error) {
+                        throw error;
+                    }
+                }
+                throw new Error("Forbidden");
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listActions({ appKey: "slack" })).rejects.toThrow(ZapierAuthenticationError);
+        });
+        it("should return empty array when implementations API returns no results", async () => {
+            mockApiClient.get = vi
+                .fn()
+                .mockResolvedValue(mockEmptyImplementationsResponse);
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({ appKey: "slack" });
+            expect(result.data).toHaveLength(0);
+        });
+        it("should handle implementation without actions", async () => {
+            const mockResponseWithoutActions = {
+                results: [
+                    {
+                        slug: "slack",
+                        // No actions property
+                    },
+                ],
+                meta: { next_cursor: null },
+            };
+            mockApiClient.get = vi.fn().mockResolvedValue(mockResponseWithoutActions);
+            const sdk = createTestSdk();
+            const result = await sdk.listActions({ appKey: "slack" });
+            expect(result.data).toHaveLength(0);
+        });
+        it("should propagate getApp errors", async () => {
+            mockGetApp.mockRejectedValue(new Error("App not found"));
+            const sdk = createTestSdk();
+            await expect(sdk.listActions({ appKey: "nonexistent" })).rejects.toThrow("App not found");
+        });
+    });
+    describe("implementation ID extraction", () => {
+        it("should extract implementation name from versioned ID", async () => {
+            mockGetApp.mockResolvedValue({
+                data: {
+                    ...mockAppResponse.data,
+                    current_implementation_id: "CustomAPIName@2.5.0",
+                },
+            });
+            const sdk = createTestSdk();
+            await sdk.listActions({ appKey: "slack" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/implementations/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    selected_apis: "CustomAPIName", // Extracted name without version
+                }),
+            }));
+        });
+        it("should handle implementation ID without version", async () => {
+            mockGetApp.mockResolvedValue({
+                data: {
+                    ...mockAppResponse.data,
+                    current_implementation_id: "PlainAPIName",
+                },
+            });
+            const sdk = createTestSdk();
+            await sdk.listActions({ appKey: "slack" });
+            expect(mockApiClient.get).toHaveBeenCalledWith("/api/v4/implementations/", expect.objectContaining({
+                searchParams: expect.objectContaining({
+                    selected_apis: "PlainAPIName", // Used as-is
+                }),
+            }));
+        });
+    });
+    describe("context and metadata", () => {
+        it("should provide context with meta information", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.listActions).toBeDefined();
+            expect(context.meta.listActions.inputSchema).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import type { ActionItem } from "../../types/domain";
+import type { PaginatedSdkFunction } from "../../types/functions";
+export declare const ListActionsSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodOptional<z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    maxItems?: number | undefined;
+    pageSize?: number | undefined;
+    actionType?: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write" | undefined;
+}, {
+    appKey: string;
+    maxItems?: number | undefined;
+    pageSize?: number | undefined;
+    actionType?: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write" | undefined;
+}>;
+export type ListActionsOptions = z.infer<typeof ListActionsSchema>;
+export interface ListActionsPage {
+    data: ActionItem[];
+    nextCursor?: string;
+}
+export type ListActionsError = import("../../types/errors").ZapierAuthenticationError | import("../../types/errors").ZapierValidationError | import("../../types/errors").ZapierUnknownError;
+export interface ListActionsSdkFunction {
+    listActions: PaginatedSdkFunction<ListActionsOptions, ActionItem>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/listActions/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAGlE,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAsB7B,CAAC;AAGF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAGnE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,MAAM,gBAAgB,GACxB,OAAO,oBAAoB,EAAE,yBAAyB,GACtD,OAAO,oBAAoB,EAAE,qBAAqB,GAClD,OAAO,oBAAoB,EAAE,kBAAkB,CAAC;AAGpD,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,oBAAoB,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC;CACnE"}

package/dist/plugins/listActions/schemas.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { AppKeyPropertySchema, ActionTypePropertySchema, } from "../../types/properties";
+import { withOutputSchema } from "../../utils/schema-utils";
+import { ActionItemSchema } from "../../schemas/Action";
+// Pure Zod schema - no resolver metadata!
+export const ListActionsSchema = withOutputSchema(z
+    .object({
+    appKey: AppKeyPropertySchema.describe("App key of actions to list (e.g., 'SlackCLIAPI')"),
+    actionType: ActionTypePropertySchema.optional().describe("Filter actions by type"),
+    pageSize: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Number of actions per page"),
+    maxItems: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+})
+    .describe("List all actions for a specific app"), ActionItemSchema);

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

@@ -0,0 +1,28 @@
+import type { Plugin } from "../../types/plugin";
+import type { ApiClient } from "../../api/types";
+import { ListAppsSchema } from "./schemas";
+import type { ListAppsOptions } from "./schemas";
+import type { AppItem } from "../../types/domain";
+export interface ListAppsPluginProvides {
+    listApps: (options?: ListAppsOptions) => Promise<{
+        data: AppItem[];
+    }> & AsyncIterable<{
+        data: AppItem[];
+        nextCursor?: string;
+    }> & {
+        items(): AsyncIterable<AppItem>;
+    };
+    context: {
+        meta: {
+            listApps: {
+                inputSchema: typeof ListAppsSchema;
+            };
+        };
+    };
+}
+export declare const listAppsPlugin: Plugin<{}, // no SDK dependencies
+{
+    api: ApiClient;
+}, // requires api in context
+ListAppsPluginProvides>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/listApps/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,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;AASlD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,CAAC,OAAO,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC;QAAE,IAAI,EAAE,OAAO,EAAE,CAAA;KAAE,CAAC,GACnE,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;AAGD,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,EAAE,EAAE,sBAAsB;AAC1B;IAAE,GAAG,EAAE,SAAS,CAAA;CAAE,EAAE,0BAA0B;AAC9C,sBAAsB,CAwFvB,CAAC"}

package/dist/plugins/listApps/index.js

@@ -0,0 +1,62 @@
+import { createPaginatedFunction } from "../../utils/function-utils";
+import { ListAppsSchema } from "./schemas";
+import { groupAppKeysByType, normalizeImplementationMetaToAppItem, splitVersionedKey, } from "../../utils/domain-utils";
+import { extractCursor } from "../../utils/function-utils";
+// Direct plugin function - takes options + sdk + context in one object
+export const listAppsPlugin = ({ context }) => {
+    const listApps = createPaginatedFunction(async function listAppsPage(options) {
+        const api = context.api;
+        const opts = options;
+        const appKeys = [...(opts.appKeys ?? [])].map((key) => splitVersionedKey(key)[0]);
+        if (opts.search) {
+            const searchParams = {};
+            searchParams.term = opts.search;
+            const searchEnvelope = await api.get("/api/v4/implementations-meta/search/", {
+                searchParams,
+            });
+            const implementations = searchEnvelope.results.map(normalizeImplementationMetaToAppItem);
+            const appKeysSet = new Set(appKeys);
+            for (const implementation of implementations) {
+                if (!appKeysSet.has(implementation.key)) {
+                    appKeysSet.add(implementation.key);
+                    appKeys.push(implementation.key);
+                }
+            }
+        }
+        const searchParams = {};
+        if (opts.pageSize) {
+            searchParams.limit = opts.pageSize.toString();
+        }
+        searchParams.latest_only = "true";
+        if (opts.cursor) {
+            searchParams.offset = opts.cursor;
+        }
+        if (appKeys.length > 0) {
+            const groupedAppKeys = groupAppKeysByType(appKeys);
+            if (groupedAppKeys.selectedApi.length > 0) {
+                searchParams.selected_apis = groupedAppKeys.selectedApi.join(",");
+            }
+            if (groupedAppKeys.slug.length > 0) {
+                searchParams.slugs = groupedAppKeys.slug.join(",");
+            }
+        }
+        const implementationsEnvelope = await api.get("/api/v4/implementations-meta/lookup/", {
+            searchParams,
+        });
+        return {
+            data: implementationsEnvelope.results.map(normalizeImplementationMetaToAppItem),
+            nextCursor: extractCursor(implementationsEnvelope),
+        };
+    }, ListAppsSchema);
+    // Return flat structure - listApps goes directly to SDK
+    return {
+        listApps,
+        context: {
+            meta: {
+                listApps: {
+                    inputSchema: ListAppsSchema,
+                },
+            },
+        },
+    };
+};

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

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

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

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