@zapier/zapier-sdk-cli 0.35.1 → 0.36.1

package/dist/src/utils/parameter-resolver.js

@@ -1,5 +1,6 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
+import ora from "ora";
 import { z } from "zod";
 import { runWithTelemetryContext, } from "@zapier/zapier-sdk";
 import { isPositional } from "@zapier/zapier-sdk";
@@ -61,9 +62,31 @@ function getLocalResolutionOrderForParams(paramNames, resolvers) {
 // Schema Parameter Resolver
 // ============================================================================
 export class SchemaParameterResolver {
+    constructor() {
+        this.debug = false;
+        this.spinner = null;
+    }
+    debugLog(message) {
+        if (this.debug) {
+            this.stopSpinner();
+            console.log(chalk.gray(`[Zapier CLI] ${message}`));
+        }
+    }
+    startSpinner() {
+        if (!this.debug && !this.spinner) {
+            this.spinner = ora({ text: "", spinner: "dots" }).start();
+        }
+    }
+    stopSpinner() {
+        if (this.spinner) {
+            this.spinner.stop();
+            this.spinner = null;
+        }
+    }
     async resolveParameters(schema, providedParams, sdk, functionName, options) {
         return runWithTelemetryContext(async () => {
-            const interactiveMode = options?.interactiveMode ?? true;
+            this.debug = options?.debug ?? false;
+            const interactiveMode = (options?.interactiveMode ?? true) && !!process.stdin.isTTY;
             // 1. Try to parse with current parameters
             const parseResult = schema.safeParse(providedParams);
             // Get all schema parameters to check which ones have resolvers
@@ -74,47 +97,28 @@ export class SchemaParameterResolver {
                 const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
                 return !hasValue;
             });
-            // Determine parameter resolution categories:
-            // - functionally required: must be provided (inputs)
-            // - always prompt: should be prompted for but can be skipped (connectionId)
-            // - truly optional: only ask if user wants to be prompted
-            const functionallyRequired = missingResolvable.filter((param) => {
-                // Schema-required parameters are always functionally required
+            // Split missing resolvable params into required vs optional.
+            // "inputs" is treated as required in interactive mode.
+            const required = missingResolvable.filter((param) => {
                 if (param.isRequired)
                     return true;
-                // Keep inputs prompting in interactive mode, but do not force it in
-                // non-interactive mode (--json), where optional inputs should remain optional.
-                if (param.name === "inputs") {
+                if (param.name === "inputs")
                     return interactiveMode;
-                }
-                return false;
-            });
-            // Parameters that should always be prompted for directly, but can be skipped
-            const alwaysPrompt = missingResolvable.filter((param) => {
-                if (functionallyRequired.includes(param))
-                    return false;
-                // connectionId should always be prompted for (since it's usually needed)
-                // but can be skipped with "Continue without connection"
-                if (param.name === "connectionId") {
-                    return true;
-                }
                 return false;
             });
-            const trulyOptional = missingResolvable.filter((param) => !functionallyRequired.includes(param) &&
-                !alwaysPrompt.includes(param));
+            const optional = missingResolvable.filter((param) => !required.includes(param));
             if (parseResult.success &&
-                functionallyRequired.length === 0 &&
-                alwaysPrompt.length === 0) {
+                required.length === 0 &&
+                optional.length === 0) {
                 return parseResult.data;
             }
-            if (functionallyRequired.length === 0 && alwaysPrompt.length === 0) {
-                // No functionally required parameters missing, but check if we can parse
+            if (required.length === 0 && optional.length === 0) {
                 if (!parseResult.success) {
                     throw new ZapierCliValidationError(formatZodError(parseResult.error));
                 }
                 return parseResult.data;
             }
-            // 2. Resolve functionally required parameters first
+            // 2. Resolve required parameters
             const resolvedParams = { ...providedParams };
             const context = {
                 sdk,
@@ -122,24 +126,16 @@ export class SchemaParameterResolver {
                 resolvedParams,
                 functionName,
             };
-            // Get local resolvers for this function
             const localResolvers = this.getLocalResolvers(sdk, functionName);
-            if (functionallyRequired.length > 0) {
-                const requiredParamNames = functionallyRequired.map((p) => p.name);
+            if (required.length > 0) {
+                const requiredParamNames = required.map((p) => p.name);
                 const requiredResolutionOrder = getLocalResolutionOrderForParams(requiredParamNames, localResolvers);
                 // Find all parameters that need to be resolved (including dependencies)
-                // from the available resolvable parameters
                 const orderedRequiredParams = requiredResolutionOrder
                     .map((paramName) => {
-                    // First try to find in functionally required
-                    let param = functionallyRequired.find((p) => p.name === paramName);
-                    // If not found, try always prompt (for dependencies like connectionId)
+                    let param = required.find((p) => p.name === paramName);
                     if (!param) {
-                        param = alwaysPrompt.find((p) => p.name === paramName);
-                    }
-                    // If not found, try truly optional (for other dependencies)
-                    if (!param) {
-                        param = trulyOptional.find((p) => p.name === paramName);
+                        param = optional.find((p) => p.name === paramName);
                     }
                     return param;
                 })
@@ -152,7 +148,6 @@ export class SchemaParameterResolver {
                         try {
                             const value = await this.resolveParameter(param, context, functionName);
                             this.setNestedValue(resolvedParams, param.path, value);
-                            // Update context with newly resolved value
                             context.resolvedParams = resolvedParams;
                         }
                         catch (error) {
@@ -164,26 +159,25 @@ export class SchemaParameterResolver {
                         }
                     }
                 }
-                // Remove resolved dependencies from other categories to avoid double-prompting
+                // Remove resolved dependencies from optional to avoid double-prompting
                 const resolvedParamNames = new Set(orderedRequiredParams.map((p) => p.name));
-                alwaysPrompt.splice(0, alwaysPrompt.length, ...alwaysPrompt.filter((p) => !resolvedParamNames.has(p.name)));
-                trulyOptional.splice(0, trulyOptional.length, ...trulyOptional.filter((p) => !resolvedParamNames.has(p.name)));
-            }
-            // 3. Resolve parameters that should always be prompted for (but can be skipped).
-            // Skipped entirely in non-interactive mode - if connectionId was needed, it should
-            // have been passed explicitly via --connection-id.
-            if (interactiveMode && alwaysPrompt.length > 0) {
-                const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
-                const alwaysPromptResolutionOrder = getLocalResolutionOrderForParams(alwaysPromptNames, localResolvers);
-                const orderedAlwaysPromptParams = alwaysPromptResolutionOrder
-                    .map((paramName) => alwaysPrompt.find((p) => p.name === paramName))
+                optional.splice(0, optional.length, ...optional.filter((p) => !resolvedParamNames.has(p.name)));
+            }
+            // 3. Resolve optional parameters individually (each is skippable).
+            // Skipped in non-interactive mode.
+            if (interactiveMode && optional.length > 0) {
+                const optionalParamNames = optional.map((p) => p.name);
+                const optionalResolutionOrder = getLocalResolutionOrderForParams(optionalParamNames, localResolvers);
+                const orderedOptionalParams = optionalResolutionOrder
+                    .map((paramName) => optional.find((p) => p.name === paramName))
                     .filter((param) => param !== undefined);
-                for (const param of orderedAlwaysPromptParams) {
+                for (const param of orderedOptionalParams) {
                     try {
-                        const value = await this.resolveParameter(param, context, functionName);
-                        this.setNestedValue(resolvedParams, param.path, value);
-                        // Update context with newly resolved value
-                        context.resolvedParams = resolvedParams;
+                        const value = await this.resolveParameter(param, context, functionName, { isOptional: true });
+                        if (value !== undefined) {
+                            this.setNestedValue(resolvedParams, param.path, value);
+                            context.resolvedParams = resolvedParams;
+                        }
                     }
                     catch (error) {
                         if (this.isUserCancellation(error)) {
@@ -194,42 +188,7 @@ export class SchemaParameterResolver {
                     }
                 }
             }
-            // 4. Ask user if they want to resolve truly optional parameters (skipped in non-interactive mode)
-            if (interactiveMode && trulyOptional.length > 0) {
-                const optionalNames = trulyOptional.map((p) => p.name).join(", ");
-                const shouldResolveOptional = await inquirer.prompt([
-                    {
-                        type: "confirm",
-                        name: "resolveOptional",
-                        message: `Would you like to be prompted for optional parameters (${optionalNames})?`,
-                        default: false,
-                    },
-                ]);
-                if (shouldResolveOptional.resolveOptional) {
-                    // Resolve optional parameters using their resolvers
-                    const optionalParamNames = trulyOptional.map((p) => p.name);
-                    const optionalResolutionOrder = getLocalResolutionOrderForParams(optionalParamNames, localResolvers);
-                    const orderedOptionalParams = optionalResolutionOrder
-                        .map((paramName) => trulyOptional.find((p) => p.name === paramName))
-                        .filter((param) => param !== undefined);
-                    for (const param of orderedOptionalParams) {
-                        try {
-                            const value = await this.resolveParameter(param, context, functionName);
-                            this.setNestedValue(resolvedParams, param.path, value);
-                            // Update context with newly resolved value
-                            context.resolvedParams = resolvedParams;
-                        }
-                        catch (error) {
-                            if (this.isUserCancellation(error)) {
-                                console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                                throw new ZapierCliUserCancellationError();
-                            }
-                            throw error;
-                        }
-                    }
-                }
-            }
-            // 5. Validate final parameters
+            // 4. Validate final parameters
             const finalResult = schema.safeParse(resolvedParams);
             if (!finalResult.success) {
                 throw new ZapierCliValidationError(`Parameter validation failed: ${formatZodError(finalResult.error)}`);
@@ -321,48 +280,97 @@ export class SchemaParameterResolver {
             throw new ZapierCliMissingParametersError(missingParams);
         }
     }
-    async resolveParameter(param, context, functionName) {
+    async resolveParameter(param, context, functionName, options) {
         const resolver = this.getResolver(param.name, context.sdk, functionName);
         if (!resolver) {
             throw new Error(`No resolver found for parameter: ${param.name}`);
         }
-        console.log(chalk.blue(`\n🔍 Resolving ${param.name}...`));
+        return this.resolveWithResolver(resolver, param, context, {
+            isOptional: options?.isOptional,
+        });
+    }
+    async resolveWithResolver(resolver, param, context, options = {}) {
+        const { arrayIndex, isOptional } = options;
+        const inArrayContext = arrayIndex != null;
+        const promptLabel = inArrayContext
+            ? `${param.name}[${arrayIndex}]`
+            : param.name;
+        const promptName = inArrayContext ? "value" : param.name;
+        this.debugLog(`Resolving ${promptLabel}${isOptional ? " (optional)" : ""}`);
         if (resolver.type === "static") {
             const staticResolver = resolver;
             const promptConfig = {
                 type: staticResolver.inputType === "password" ? "password" : "input",
-                name: param.name,
-                message: `Enter ${param.name}:`,
+                name: promptName,
+                message: `Enter ${promptLabel}${isOptional ? " (optional)" : ""}:`,
                 ...(staticResolver.placeholder && {
                     default: staticResolver.placeholder,
                 }),
             };
+            this.stopSpinner();
             const answers = await inquirer.prompt([promptConfig]);
-            return answers[param.name];
+            const value = answers[promptName];
+            if (isOptional && (value === undefined || value === "")) {
+                return undefined;
+            }
+            return value;
         }
         else if (resolver.type === "dynamic") {
             const dynamicResolver = resolver;
+            this.startSpinner();
             const autoResolution = await this.tryAutoResolve(dynamicResolver, context);
             if (autoResolution != null) {
+                this.stopSpinner();
                 return autoResolution.resolvedValue;
             }
-            // Only show "Fetching..." for required parameters that typically have many options
-            if (param.isRequired && param.name !== "connectionId") {
-                console.log(chalk.gray(`Fetching options for ${param.name}...`));
+            this.debugLog(`Fetching options for ${promptLabel}`);
+            const fetchResult = await dynamicResolver.fetch(context.sdk, context.resolvedParams);
+            const items = Array.isArray(fetchResult)
+                ? fetchResult
+                : (fetchResult?.data ?? []);
+            const promptConfig = dynamicResolver.prompt(items, context.resolvedParams);
+            promptConfig.name = promptName;
+            // Inject a skip option for optional parameters
+            this.stopSpinner();
+            if (isOptional && promptConfig.choices) {
+                const SKIP_SENTINEL = Symbol("SKIP");
+                promptConfig.choices = [
+                    { name: chalk.dim("(Skip)"), value: SKIP_SENTINEL },
+                    ...promptConfig.choices,
+                ];
+                const answers = await inquirer.prompt([promptConfig]);
+                const value = answers[promptName];
+                if (value === SKIP_SENTINEL) {
+                    return undefined;
+                }
+                return value;
             }
-            const items = await dynamicResolver.fetch(context.sdk, context.resolvedParams);
-            // Let the resolver's prompt handle empty lists (e.g., connectionId can show "skip connection")
-            const safeItems = items || [];
-            const promptConfig = dynamicResolver.prompt(safeItems, context.resolvedParams);
             const answers = await inquirer.prompt([promptConfig]);
-            return answers[param.name];
+            return answers[promptName];
         }
         else if (resolver.type === "fields") {
-            return await this.resolveFieldsRecursively(resolver, context, param);
+            if (isOptional && !inArrayContext) {
+                this.stopSpinner();
+                const { confirm } = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "confirm",
+                        message: `Add ${promptLabel}?`,
+                        default: false,
+                    },
+                ]);
+                if (!confirm) {
+                    return undefined;
+                }
+            }
+            return await this.resolveFieldsRecursively(resolver, context, param, { inArrayContext });
+        }
+        else if (resolver.type === "array") {
+            return await this.resolveArrayRecursively(resolver, context, param);
         }
-        throw new Error(`Unknown resolver type for ${param.name}`);
+        throw new Error(`Unknown resolver type for ${promptLabel}`);
     }
-    async resolveFieldsRecursively(resolver, context, param) {
+    async resolveFieldsRecursively(resolver, context, param, options = {}) {
         const inputs = {};
         let processedFieldKeys = new Set();
         let iteration = 0;
@@ -377,8 +385,10 @@ export class SchemaParameterResolver {
                     inputs,
                 },
             };
-            console.log(chalk.gray(`Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`));
+            this.debugLog(`Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}`);
+            this.startSpinner();
             const rootFieldItems = await resolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
+            this.stopSpinner();
             if (!rootFieldItems || rootFieldItems.length === 0) {
                 if (iteration === 1) {
                     console.log(chalk.yellow(`No input fields required for this action.`));
@@ -386,7 +396,7 @@ export class SchemaParameterResolver {
                 break;
             }
             // Process fields recursively, maintaining fieldset structure
-            const fieldStats = await this.processFieldItems(rootFieldItems, inputs, processedFieldKeys, [], iteration, updatedContext);
+            const fieldStats = await this.processFieldItems(rootFieldItems, inputs, processedFieldKeys, [], iteration, updatedContext, { inArrayContext: options.inArrayContext });
             // If no new fields were processed, we're done
             if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
                 break;
@@ -399,13 +409,56 @@ export class SchemaParameterResolver {
         if (iteration >= maxIterations) {
             console.log(chalk.yellow(`\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`));
         }
+        // Apply transform if provided
+        if (resolver.transform) {
+            return resolver.transform(inputs);
+        }
         return inputs;
     }
+    /**
+     * Resolves an array parameter by repeatedly prompting for items until user says no
+     */
+    async resolveArrayRecursively(resolver, context, param) {
+        const items = [];
+        const minItems = resolver.minItems ?? 0;
+        const maxItems = resolver.maxItems ?? Infinity;
+        while (items.length < maxItems) {
+            const currentIndex = items.length;
+            // Skip confirmation if we haven't hit minItems yet - just collect the item
+            if (currentIndex >= minItems) {
+                this.stopSpinner();
+                const confirmAnswer = await inquirer.prompt([
+                    {
+                        type: "confirm",
+                        name: "addItem",
+                        message: `Add ${param.name}[${currentIndex}]?`,
+                        default: false,
+                    },
+                ]);
+                if (!confirmAnswer.addItem) {
+                    break;
+                }
+            }
+            // Fetch the inner resolver for this item
+            const innerResolver = await resolver.fetch(context.sdk, context.resolvedParams);
+            const itemValue = await this.resolveWithResolver(innerResolver, param, context, { arrayIndex: currentIndex });
+            items.push(itemValue);
+            // Update context with current array for subsequent iterations
+            context.resolvedParams = {
+                ...context.resolvedParams,
+                [param.name]: items,
+            };
+        }
+        if (items.length >= maxItems) {
+            console.log(chalk.gray(`Maximum of ${maxItems} items reached.`));
+        }
+        return items;
+    }
     /**
      * Recursively processes fieldsets and their fields, maintaining natural structure
      * and creating nested inputs as needed (e.g., fieldset "foo" becomes inputs.foo = [{}])
      */
-    async processFieldItems(items, targetInputs, processedFieldKeys, fieldsetPath = [], iteration = 1, context) {
+    async processFieldItems(items, targetInputs, processedFieldKeys, fieldsetPath = [], iteration = 1, context, options = {}) {
         let newRequiredCount = 0;
         let newOptionalCount = 0;
         let optionalSkipped = false;
@@ -423,7 +476,7 @@ export class SchemaParameterResolver {
                 // Process fields within this fieldset recursively
                 const fieldsetTarget = targetInputs[typedItem.key][0];
                 const nestedPath = [...fieldsetPath, fieldsetTitle];
-                const nestedStats = await this.processFieldItems(typedItem.fields, fieldsetTarget, processedFieldKeys, nestedPath, iteration, context);
+                const nestedStats = await this.processFieldItems(typedItem.fields, fieldsetTarget, processedFieldKeys, nestedPath, iteration, context, options);
                 newRequiredCount += nestedStats.newRequired;
                 newOptionalCount += nestedStats.newOptional;
                 if (nestedStats.optionalSkipped) {
@@ -439,11 +492,18 @@ export class SchemaParameterResolver {
                 if (isRequired) {
                     // Process required field immediately
                     newRequiredCount++;
-                    if (newRequiredCount === 1 && fieldsetPath.length === 0) {
-                        // Only show this message once at root level
-                        console.log(chalk.blue(`\n📝 Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`));
+                    if (typedItem.resolver && context) {
+                        const param = {
+                            name: typedItem.key,
+                            path: [typedItem.key],
+                            schema: z.unknown(),
+                            isRequired: true,
+                        };
+                        targetInputs[typedItem.key] = await this.resolveWithResolver(typedItem.resolver, param, context, { isOptional: false });
+                    }
+                    else {
+                        await this.promptForField(typedItem, targetInputs, context);
                     }
-                    await this.promptForField(typedItem, targetInputs, context);
                     processedFieldKeys.add(typedItem.key);
                 }
                 else {
@@ -464,39 +524,49 @@ export class SchemaParameterResolver {
             });
             if (optionalFields.length > 0) {
                 const pathContext = fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
-                console.log(chalk.gray(`\nThere are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`));
-                try {
-                    const shouldConfigureOptional = await inquirer.prompt([
-                        {
-                            type: "confirm",
-                            name: "configure",
-                            message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields${pathContext}?`,
-                            default: false,
-                        },
-                    ]);
-                    if (shouldConfigureOptional.configure) {
-                        console.log(chalk.cyan(`\nOptional fields${pathContext}:`));
-                        for (const field of optionalFields) {
-                            await this.promptForField(field, targetInputs, context);
-                            const typedField = field;
-                            processedFieldKeys.add(typedField.key);
-                        }
-                    }
-                    else {
-                        optionalSkipped = true;
-                        // Mark these fields as processed even if skipped to avoid re-asking
-                        optionalFields.forEach((field) => {
-                            const typedField = field;
-                            processedFieldKeys.add(typedField.key);
-                        });
+                // In array context, prompt for all fields directly without confirmation
+                if (options.inArrayContext) {
+                    for (const field of optionalFields) {
+                        await this.promptForField(field, targetInputs, context);
+                        const typedField = field;
+                        processedFieldKeys.add(typedField.key);
                     }
                 }
-                catch (error) {
-                    if (this.isUserCancellation(error)) {
-                        console.log(chalk.yellow("\n\nOperation cancelled by user"));
-                        throw new ZapierCliUserCancellationError();
+                else {
+                    console.log(chalk.gray(`\nThere are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`));
+                    try {
+                        const shouldConfigureOptional = await inquirer.prompt([
+                            {
+                                type: "confirm",
+                                name: "configure",
+                                message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields${pathContext}?`,
+                                default: false,
+                            },
+                        ]);
+                        if (shouldConfigureOptional.configure) {
+                            console.log(chalk.cyan(`\nOptional fields${pathContext}:`));
+                            for (const field of optionalFields) {
+                                await this.promptForField(field, targetInputs, context);
+                                const typedField = field;
+                                processedFieldKeys.add(typedField.key);
+                            }
+                        }
+                        else {
+                            optionalSkipped = true;
+                            // Mark these fields as processed even if skipped to avoid re-asking
+                            optionalFields.forEach((field) => {
+                                const typedField = field;
+                                processedFieldKeys.add(typedField.key);
+                            });
+                        }
+                    }
+                    catch (error) {
+                        if (this.isUserCancellation(error)) {
+                            console.log(chalk.yellow("\n\nOperation cancelled by user"));
+                            throw new ZapierCliUserCancellationError();
+                        }
+                        throw error;
                     }
-                    throw error;
                 }
             }
         }
@@ -533,9 +603,10 @@ export class SchemaParameterResolver {
             isRequired: fieldObj.is_required || false,
             defaultValue: fieldObj.default_value ?? fieldObj.default,
             valueType,
-            hasDropdown: fieldObj.format === "SELECT",
+            hasDropdown: fieldObj.format === "SELECT" || Boolean(fieldObj.choices),
             isMultiSelect: Boolean(valueType === "array" ||
                 (fieldObj.items && fieldObj.items.type !== undefined)),
+            inlineChoices: fieldObj.choices,
         };
     }
     /**
@@ -543,9 +614,10 @@ export class SchemaParameterResolver {
      */
     async fetchChoices(fieldMeta, inputs, context, cursor) {
         try {
-            console.log(chalk.gray(cursor
-                ? `  Fetching more choices...`
-                : `  Fetching choices for ${fieldMeta.title}...`));
+            this.debugLog(cursor
+                ? `Fetching more choices for ${fieldMeta.title}`
+                : `Fetching choices for ${fieldMeta.title}`);
+            this.startSpinner();
             const page = await context.sdk.listInputFieldChoices({
                 appKey: context.resolvedParams.appKey,
                 actionKey: context.resolvedParams.actionKey,
@@ -555,12 +627,13 @@ export class SchemaParameterResolver {
                 inputs,
                 ...(cursor && { cursor }),
             });
+            this.stopSpinner();
             const choices = page.data.map((choice) => ({
                 label: choice.label || choice.key || String(choice.value),
                 value: choice.value ?? choice.key,
             }));
             if (choices.length === 0 && !cursor) {
-                console.log(chalk.yellow(`  No choices available for ${fieldMeta.title}`));
+                console.log(chalk.yellow(`No choices available for ${fieldMeta.title}`));
             }
             return {
                 choices,
@@ -568,7 +641,8 @@ export class SchemaParameterResolver {
             };
         }
         catch (error) {
-            console.warn(chalk.yellow(`  ⚠️  Failed to fetch choices for ${fieldMeta.title}:`), error);
+            this.stopSpinner();
+            console.warn(chalk.yellow(`Failed to fetch choices for ${fieldMeta.title}:`), error);
             return { choices: [] };
         }
     }
@@ -576,6 +650,7 @@ export class SchemaParameterResolver {
      * Prompt user with choices (handles both single and multi-select with pagination)
      */
     async promptWithChoices({ fieldMeta, choices: initialChoices, nextCursor: initialCursor, inputs, context, }) {
+        this.stopSpinner();
         const choices = [...initialChoices];
         let nextCursor = initialCursor;
         const LOAD_MORE_SENTINEL = Symbol("LOAD_MORE");
@@ -647,6 +722,31 @@ export class SchemaParameterResolver {
                     ? Boolean(fieldMeta.defaultValue)
                     : undefined;
         }
+        else if (fieldMeta.valueType === "array") {
+            promptConfig.type = "input";
+            promptConfig.default = fieldMeta.defaultValue;
+            promptConfig.message = `${fieldMeta.title}${fieldMeta.isRequired ? " (required)" : " (optional)"} (JSON array or comma-separated):`;
+            promptConfig.validate = (input) => {
+                if (fieldMeta.isRequired && !input) {
+                    return "This field is required";
+                }
+                return true;
+            };
+            promptConfig.filter = (input) => {
+                if (!input)
+                    return input;
+                const trimmed = input.trim();
+                if (trimmed.startsWith("[")) {
+                    try {
+                        return JSON.parse(trimmed);
+                    }
+                    catch {
+                        // Fall through to comma-separated
+                    }
+                }
+                return trimmed.split(",").map((s) => s.trim());
+            };
+        }
         else {
             promptConfig.type = "input";
             promptConfig.default = fieldMeta.defaultValue;
@@ -695,10 +795,15 @@ export class SchemaParameterResolver {
     }
     async promptForField(field, inputs, context) {
         const fieldMeta = this.extractFieldMetadata(field);
-        // Fetch choices if field has dropdown
+        // Get choices - either inline or fetched from API
         let choices = [];
         let nextCursor;
-        if (fieldMeta.hasDropdown && context) {
+        if (fieldMeta.inlineChoices) {
+            // Use inline choices directly
+            choices = fieldMeta.inlineChoices;
+        }
+        else if (fieldMeta.hasDropdown && context) {
+            // Fetch choices from API
             const result = await this.fetchChoices(fieldMeta, inputs, context);
             choices = result.choices;
             nextCursor = result.nextCursor;

package/dist/src/utils/schema-formatter.d.ts

@@ -1,6 +1,11 @@
 import type { z } from "zod";
+import type { OutputFormatter, ZapierSdk } from "@zapier/zapier-sdk";
 export declare function formatJsonOutput(data: unknown): void;
 export declare function formatItemsFromSchema(functionInfo: {
     inputSchema: z.ZodType;
     outputSchema?: z.ZodType;
-}, items: unknown[], startingNumber?: number): void;
+}, items: unknown[], startingNumber?: number, options?: {
+    formatter?: OutputFormatter;
+    sdk?: ZapierSdk;
+    params?: Record<string, unknown>;
+}): Promise<void>;