@zapier/zapier-sdk 0.6.4 → 0.8.1

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

@@ -0,0 +1,537 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ZapierValidationError, ZapierApiError } from "../../types/errors";
+import { listInputFieldChoicesPlugin } from "./index";
+import { createSdk } from "../../sdk";
+import { GetActionSchema } from "../getAction/schemas";
+const mockChoices = [
+    {
+        key: "general",
+        label: "General Channel",
+        sample: "#general",
+        value: "general",
+    },
+    {
+        key: "random",
+        label: "Random Channel",
+        sample: "#random",
+        value: "random",
+    },
+    {
+        key: "dev",
+        label: "Development Channel",
+        sample: "#dev",
+        value: "dev",
+    },
+];
+const mockChoicesResponse = {
+    success: true,
+    choices: mockChoices,
+};
+const mockPaginatedChoicesResponse = {
+    success: true,
+    choices: mockChoices.slice(0, 2),
+    next_page: 1,
+};
+const mockExternalChoicesResponse = {
+    success: true,
+    choices: mockChoices,
+    meta: { page: "0" },
+    links: {
+        next: "https://api.zapier.com/api/v4/implementations/choices/?page=1",
+        prev: null,
+    },
+};
+describe("listInputFieldChoices plugin", () => {
+    let mockApiClient;
+    let mockGetAction;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockApiClient = {
+            post: vi.fn().mockResolvedValue(mockChoicesResponse),
+        };
+        mockGetAction = vi.fn().mockResolvedValue({
+            data: { id: "core:123", key: "send_message", action_type: "read" },
+        });
+    });
+    function createTestSdk() {
+        // Create a mock getAction plugin
+        const mockGetActionPlugin = () => ({
+            getAction: mockGetAction,
+            context: {
+                meta: {
+                    getAction: {
+                        inputSchema: GetActionSchema,
+                    },
+                },
+            },
+        });
+        // Build SDK with proper plugin composition
+        return createSdk({}, {}, { api: mockApiClient, meta: {} })
+            .addPlugin(mockGetActionPlugin)
+            .addPlugin(listInputFieldChoicesPlugin);
+    }
+    describe("schema validation", () => {
+        it("should throw validation error for missing inputFieldKey", async () => {
+            const sdk = createTestSdk();
+            try {
+                await sdk.listInputFieldChoices({
+                    appKey: "slack",
+                    actionType: "read",
+                    actionKey: "send_message",
+                    // Missing inputFieldKey
+                });
+                expect.fail("Expected ZapierValidationError to be thrown");
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(ZapierValidationError);
+            }
+        });
+        it("should throw validation error for missing actionKey", async () => {
+            const sdk = createTestSdk();
+            try {
+                await sdk.listInputFieldChoices({
+                    appKey: "slack",
+                    actionType: "read",
+                    inputFieldKey: "channel",
+                    // Missing actionKey
+                });
+                expect.fail("Expected ZapierValidationError to be thrown");
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(ZapierValidationError);
+            }
+        });
+        it("should pass validation with action method", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            expect(result.data).toBeDefined();
+        });
+        it("should pass validation with optional fields", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                authenticationId: 456,
+                inputs: { workspace: "my-team" },
+                page: 0,
+            });
+            expect(result.data).toBeDefined();
+        });
+        it("should throw validation error for empty string actionKey", async () => {
+            const sdk = createTestSdk();
+            try {
+                await sdk.listInputFieldChoices({
+                    appKey: "slack",
+                    actionType: "read",
+                    actionKey: "", // Empty string
+                    inputFieldKey: "channel",
+                });
+                expect.fail("Expected ZapierValidationError to be thrown");
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(ZapierValidationError);
+            }
+        });
+        it("should throw validation error for empty string inputFieldKey", async () => {
+            const sdk = createTestSdk();
+            try {
+                await sdk.listInputFieldChoices({
+                    appKey: "slack",
+                    actionType: "read",
+                    actionKey: "send_message",
+                    inputFieldKey: "", // Empty string
+                });
+                expect.fail("Expected ZapierValidationError to be thrown");
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(ZapierValidationError);
+            }
+        });
+    });
+    describe("API integration - action method", () => {
+        it("should call the correct API endpoint with action method", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            expect(mockGetAction).toHaveBeenCalledWith({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/choices/", {
+                action_id: "core:123",
+                input_field_id: "channel",
+                page: 0,
+                params: {},
+            });
+        });
+        it("should include authentication_id when provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                authenticationId: 456,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/choices/", {
+                action_id: "core:123",
+                input_field_id: "channel",
+                authentication_id: 456,
+                page: 0,
+                params: {},
+            });
+        });
+        it("should exclude authentication_id when null", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                authenticationId: null,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/choices/", {
+                action_id: "core:123",
+                input_field_id: "channel",
+                page: 0,
+                params: {},
+                // No authentication_id
+            });
+        });
+        it("should include inputs when provided", async () => {
+            const sdk = createTestSdk();
+            const inputs = { workspace: "my-team", board: "project" };
+            await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                inputs,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/choices/", {
+                action_id: "core:123",
+                input_field_id: "channel",
+                page: 0,
+                params: inputs,
+            });
+        });
+        it("should include page when provided", async () => {
+            const sdk = createTestSdk();
+            await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                page: 2,
+            });
+            expect(mockApiClient.post).toHaveBeenCalledWith("/api/v4/implementations/choices/", {
+                action_id: "core:123",
+                input_field_id: "channel",
+                page: 2,
+                params: {},
+            });
+        });
+    });
+    describe("data transformation", () => {
+        it("should transform choices to input field choice items correctly", async () => {
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            expect(result.data).toHaveLength(3);
+            // Check first choice transformation
+            expect(result.data[0]).toEqual({
+                key: "general",
+                label: "General Channel",
+                sample: "#general",
+                value: "general",
+            });
+            // Check second choice transformation
+            expect(result.data[1]).toEqual({
+                key: "random",
+                label: "Random Channel",
+                sample: "#random",
+                value: "random",
+            });
+        });
+        it("should handle choices with missing fields gracefully", async () => {
+            const sparseChoices = [
+                { key: "item1", label: "Item 1" },
+                { value: "item2", sample: "item2" },
+                { label: "Item 3" },
+            ];
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: true,
+                choices: sparseChoices,
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "item",
+            });
+            expect(result.data).toHaveLength(3);
+            expect(result.data[0]).toEqual({
+                key: "item1",
+                label: "Item 1",
+                sample: undefined,
+                value: undefined,
+            });
+            expect(result.data[1]).toEqual({
+                key: undefined,
+                label: undefined,
+                sample: "item2",
+                value: "item2",
+            });
+        });
+    });
+    describe("pagination handling", () => {
+        it("should handle next_page pagination correctly in the plugin", async () => {
+            mockApiClient.post = vi
+                .fn()
+                .mockResolvedValue(mockPaginatedChoicesResponse);
+            const sdk = createTestSdk();
+            // Test that the plugin correctly sets nextCursor when next_page is present
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+                pageSize: 2, // Set a small page size to test pagination behavior
+            });
+            const pages = [];
+            for await (const page of listChoicesResult) {
+                pages.push(page);
+                break; // Just get first page for testing
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].nextCursor).toBe("1");
+        });
+        it("should handle external action link-based pagination correctly in the plugin", async () => {
+            mockApiClient.post = vi
+                .fn()
+                .mockResolvedValue(mockExternalChoicesResponse);
+            const sdk = createTestSdk();
+            // Test that the plugin correctly extracts cursor from links.next
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "option",
+                pageSize: 3, // Set a small page size to test pagination behavior
+            });
+            const pages = [];
+            for await (const page of listChoicesResult) {
+                pages.push(page);
+                break; // Just get first page for testing
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].nextCursor).toBe("1"); // Extracted from links.next URL
+        });
+        it("should handle no pagination", async () => {
+            const sdk = createTestSdk();
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            const pages = [];
+            for await (const page of listChoicesResult) {
+                pages.push(page);
+                break; // Just get first page for testing
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].nextCursor).toBeUndefined();
+        });
+        it("should support async iteration over individual items", async () => {
+            const sdk = createTestSdk();
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            const items = [];
+            for await (const item of listChoicesResult.items()) {
+                items.push(item);
+            }
+            expect(items).toHaveLength(3);
+            expect(items[0].key).toBe("general");
+        });
+        it("should handle malformed links.next URL gracefully", async () => {
+            const malformedExternalResponse = {
+                success: true,
+                choices: mockChoices,
+                links: {
+                    next: "invalid-url-format", // Malformed URL
+                    prev: null,
+                },
+            };
+            mockApiClient.post = vi.fn().mockResolvedValue(malformedExternalResponse);
+            const sdk = createTestSdk();
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "option",
+            });
+            const pages = [];
+            for await (const page of listChoicesResult) {
+                pages.push(page);
+                break;
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].nextCursor).toBeUndefined(); // Should handle gracefully
+        });
+        it("should handle links.next URL without page parameter", async () => {
+            const noPageResponse = {
+                success: true,
+                choices: mockChoices,
+                links: {
+                    next: "https://api.zapier.com/api/v4/implementations/choices/", // No page param
+                    prev: null,
+                },
+            };
+            mockApiClient.post = vi.fn().mockResolvedValue(noPageResponse);
+            const sdk = createTestSdk();
+            const listChoicesResult = sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "option",
+            });
+            const pages = [];
+            for await (const page of listChoicesResult) {
+                pages.push(page);
+                break;
+            }
+            expect(pages).toHaveLength(1);
+            expect(pages[0].nextCursor).toBeUndefined();
+        });
+    });
+    describe("error handling", () => {
+        it("should throw ZapierApiError when API response indicates failure", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: false,
+                errors: ["Invalid field", "Missing authentication"],
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "invalid_field",
+            })).rejects.toThrow(ZapierApiError);
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "invalid_field",
+            })).rejects.toThrow("Failed to get input field choices: Invalid field, Missing authentication");
+        });
+        it("should handle API errors gracefully", async () => {
+            mockApiClient.post = vi
+                .fn()
+                .mockRejectedValue(new Error("Network error"));
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            })).rejects.toThrow("Network error");
+        });
+        it("should handle empty choices array response", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: true,
+                choices: [], // Empty choices
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            expect(result.data).toEqual([]);
+        });
+        it("should handle missing choices field in response", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: true,
+                // Missing choices field
+            });
+            const sdk = createTestSdk();
+            const result = await sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            });
+            expect(result.data).toEqual([]);
+        });
+        it("should treat missing success field as failure", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                // Missing success field (undefined)
+                choices: mockChoices,
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            })).rejects.toThrow("Failed to get input field choices: Unknown error");
+        });
+        it("should handle API response with errors but no error messages", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: false,
+                // Missing errors field
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            })).rejects.toThrow("Failed to get input field choices: Unknown error");
+        });
+        it("should handle API response with empty errors array", async () => {
+            mockApiClient.post = vi.fn().mockResolvedValue({
+                success: false,
+                errors: [], // Empty errors array
+            });
+            const sdk = createTestSdk();
+            await expect(sdk.listInputFieldChoices({
+                appKey: "slack",
+                actionType: "read",
+                actionKey: "send_message",
+                inputFieldKey: "channel",
+            })).rejects.toThrow("Failed to get input field choices: Unknown error");
+        });
+    });
+    describe("context and metadata", () => {
+        it("should provide context with meta information", () => {
+            const sdk = createTestSdk();
+            const context = sdk.getContext();
+            expect(context.meta.listInputFieldChoices).toBeDefined();
+            expect(context.meta.listInputFieldChoices.inputSchema).toBeDefined();
+        });
+    });
+});

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

@@ -0,0 +1,61 @@
+import { z } from "zod";
+import type { PaginatedSdkFunction } from "../../types/functions";
+import type { ZapierConfigurationError, ZapierApiError, ZapierAuthenticationError, ZapierAppNotFoundError, ZapierValidationError, ZapierUnknownError } from "../../types/errors";
+export declare const InputFieldChoiceItemSchema: z.ZodObject<{
+    key: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    sample: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    value?: string | undefined;
+    key?: string | undefined;
+    label?: string | undefined;
+    sample?: string | undefined;
+}, {
+    value?: string | undefined;
+    key?: string | undefined;
+    label?: string | undefined;
+    sample?: string | undefined;
+}>;
+export type InputFieldChoiceItem = z.infer<typeof InputFieldChoiceItemSchema>;
+export declare const ListInputFieldChoicesSchema: z.ZodObject<{
+    appKey: z.ZodString;
+    actionType: z.ZodEnum<["read", "read_bulk", "write", "run", "search", "search_or_write", "search_and_write", "filter"]>;
+    actionKey: z.ZodString;
+    inputFieldKey: z.ZodString;
+    authenticationId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    inputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    page: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    maxItems: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    appKey: string;
+    actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    actionKey: string;
+    inputFieldKey: string;
+    page?: number | undefined;
+    authenticationId?: number | null | undefined;
+    inputs?: Record<string, unknown> | undefined;
+    pageSize?: number | undefined;
+    maxItems?: number | undefined;
+}, {
+    appKey: string;
+    actionType: "filter" | "read" | "read_bulk" | "run" | "search" | "search_and_write" | "search_or_write" | "write";
+    actionKey: string;
+    inputFieldKey: string;
+    page?: number | undefined;
+    authenticationId?: number | null | undefined;
+    inputs?: Record<string, unknown> | undefined;
+    pageSize?: number | undefined;
+    maxItems?: number | undefined;
+}>;
+export type ListInputFieldChoicesOptions = z.infer<typeof ListInputFieldChoicesSchema>;
+export type ListInputFieldChoicesError = ZapierConfigurationError | ZapierApiError | ZapierAuthenticationError | ZapierAppNotFoundError | ZapierValidationError | ZapierUnknownError;
+export interface ListInputFieldChoicesPage {
+    data: InputFieldChoiceItem[];
+    nextCursor?: string;
+}
+export interface ListInputFieldChoicesSdkFunction {
+    listInputFieldChoices: PaginatedSdkFunction<ListInputFieldChoicesOptions, InputFieldChoiceItem>;
+}
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/plugins/listInputFieldChoices/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EACV,wBAAwB,EACxB,cAAc,EACd,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,oBAAoB,CAAC;AAM5B,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;EAuCtC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAM9E,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwCvC,CAAC;AAGF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,2BAA2B,CACnC,CAAC;AAGF,MAAM,MAAM,0BAA0B,GAClC,wBAAwB,GACxB,cAAc,GACd,yBAAyB,GACzB,sBAAsB,GACtB,qBAAqB,GACrB,kBAAkB,CAAC;AAGvB,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,oBAAoB,EAAE,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAGD,MAAM,WAAW,gCAAgC;IAC/C,qBAAqB,EAAE,oBAAoB,CACzC,4BAA4B,EAC5B,oBAAoB,CACrB,CAAC;CACH"}

package/dist/plugins/listInputFieldChoices/schemas.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { AuthenticationIdPropertySchema, AppKeyPropertySchema, ActionTypePropertySchema, ActionKeyPropertySchema, InputsPropertySchema, } from "../../types/properties";
+import { withFormatter, withOutputSchema } from "../../utils/schema-utils";
+// ============================================================================
+// Input Field Choice Item Schema
+// ============================================================================
+export const InputFieldChoiceItemSchema = withFormatter(z.object({
+    key: z.string().optional().describe("Unique key/value for the choice"),
+    label: z
+        .string()
+        .optional()
+        .describe("Human readable label for the choice"),
+    sample: z.string().optional().describe("Sample value for the choice"),
+    value: z
+        .string()
+        .optional()
+        .describe("Value to be submitted when selected"),
+}), {
+    format: (item) => {
+        const title = item.label || item.key || "Choice";
+        const subtitle = item.label && item.key && item.label !== item.key
+            ? `(${item.key})`
+            : undefined;
+        const details = [];
+        if (item.sample && item.sample !== item.key) {
+            details.push({ text: `Sample: ${item.sample}`, style: "dim" });
+        }
+        if (item.value && item.value !== item.key) {
+            details.push({ text: `Value: ${item.value}`, style: "normal" });
+        }
+        return {
+            title,
+            subtitle,
+            details,
+        };
+    },
+});
+// ============================================================================
+// Plugin Schema Definition
+// ============================================================================
+export const ListInputFieldChoicesSchema = withOutputSchema(z
+    .object({
+    // Required action identification
+    appKey: AppKeyPropertySchema,
+    actionType: ActionTypePropertySchema,
+    actionKey: ActionKeyPropertySchema,
+    // Input field specification
+    inputFieldKey: z
+        .string()
+        .min(1)
+        .describe("Input field key to get choices for."),
+    // Common parameters
+    authenticationId: AuthenticationIdPropertySchema.nullable().optional(),
+    inputs: InputsPropertySchema.optional().describe("Current input values that may affect available choices"),
+    page: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("Page number for paginated results"),
+    // Pagination options (SDK-level)
+    pageSize: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Number of choices per page"),
+    maxItems: z
+        .number()
+        .min(1)
+        .optional()
+        .describe("Maximum total items to return across all pages"),
+})
+    .describe("Get the available choices for a dynamic dropdown input field"), InputFieldChoiceItemSchema);