@zapier/zapier-sdk-cli 0.0.2 → 0.1.0

package/dist/utils/parameter-resolver.js

@@ -7,6 +7,7 @@ exports.SchemaParameterResolver = void 0;
 const inquirer_1 = __importDefault(require("inquirer"));
 const chalk_1 = __importDefault(require("chalk"));
 const zod_1 = require("zod");
+const zapier_sdk_1 = require("@zapier/zapier-sdk");
 // ============================================================================
 // Schema Parameter Resolver
 // ============================================================================
@@ -14,55 +15,106 @@ class SchemaParameterResolver {
     async resolveParameters(schema, providedParams, sdk) {
         // 1. Try to parse with current parameters
         const parseResult = schema.safeParse(providedParams);
-        // Even if parsing succeeds, check if we should resolve optional but important parameters
-        const allResolvable = this.findAllResolvableParameters(schema);
-        const shouldResolveAnyway = allResolvable.filter((param) => {
+        // Get all schema parameters to check which ones have resolvers
+        const allParams = this.extractParametersFromSchema(schema);
+        const resolvableParams = allParams.filter((param) => (0, zapier_sdk_1.hasResolver)(param.name));
+        // Get all missing parameters that have resolvers
+        const missingResolvable = resolvableParams.filter((param) => {
             const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
-            // Resolve any parameters with resolvers even if optional, unless explicitly provided
-            return !hasValue && param.resolverMeta?.resolver;
+            return !hasValue;
         });
-        if (parseResult.success && shouldResolveAnyway.length === 0) {
+        // Determine which parameters are "functionally required" vs truly optional
+        // For run-action: appKey, actionType, actionKey are schema-required
+        // authenticationId and inputs are schema-optional but functionally needed
+        const functionallyRequired = missingResolvable.filter((param) => {
+            // Schema-required parameters are always functionally required
+            if (param.isRequired)
+                return true;
+            // For run-action, inputs and authenticationId are functionally required
+            // even though schema-optional
+            if (param.name === "inputs" || param.name === "authenticationId") {
+                return true;
+            }
+            return false;
+        });
+        const trulyOptional = missingResolvable.filter((param) => !functionallyRequired.includes(param));
+        if (parseResult.success && functionallyRequired.length === 0) {
             return parseResult.data;
         }
-        // 2. Analyze what's missing and can be resolved
-        let missingResolvable;
-        if (!parseResult.success) {
-            missingResolvable = this.findResolvableParameters(schema, parseResult.error, providedParams);
-        }
-        else {
-            // Schema parsing succeeded, but we want to resolve optional important parameters
-            missingResolvable = shouldResolveAnyway;
-        }
-        if (missingResolvable.length === 0) {
-            // No resolvable parameters, throw original error
-            throw parseResult.error;
+        if (functionallyRequired.length === 0) {
+            // No functionally required parameters missing, but check if we can parse
+            if (!parseResult.success) {
+                throw parseResult.error;
+            }
+            return parseResult.data;
         }
-        // 3. Resolve missing parameters interactively
+        // 2. Resolve functionally required parameters first
         const resolvedParams = { ...providedParams };
         const context = {
             sdk,
             currentParams: providedParams,
             resolvedParams,
         };
-        // Sort by dependency order (parameters that depend on others go last)
-        const sortedMissing = this.sortByDependencies(missingResolvable);
-        for (const missing of sortedMissing) {
-            try {
-                const value = await this.resolveParameter(missing, context);
-                this.setNestedValue(resolvedParams, missing.path, value);
-                // Update context with newly resolved value
-                context.resolvedParams = resolvedParams;
+        if (functionallyRequired.length > 0) {
+            const requiredParamNames = functionallyRequired.map((p) => p.name);
+            const requiredResolutionOrder = (0, zapier_sdk_1.getResolutionOrderForParams)(requiredParamNames);
+            const orderedRequiredParams = requiredResolutionOrder
+                .map((paramName) => functionallyRequired.find((p) => p.name === paramName))
+                .filter((param) => param !== undefined);
+            for (const param of orderedRequiredParams) {
+                try {
+                    const value = await this.resolveParameter(param, context);
+                    this.setNestedValue(resolvedParams, param.path, value);
+                    // Update context with newly resolved value
+                    context.resolvedParams = resolvedParams;
+                }
+                catch (error) {
+                    if (this.isUserCancellation(error)) {
+                        console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                        process.exit(0);
+                    }
+                    console.error(chalk_1.default.red(`Failed to resolve ${param.name}:`), error);
+                    throw error;
+                }
             }
-            catch (error) {
-                if (this.isUserCancellation(error)) {
-                    console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
-                    process.exit(0);
+        }
+        // 3. Ask user if they want to resolve truly optional parameters
+        if (trulyOptional.length > 0) {
+            const optionalNames = trulyOptional.map((p) => p.name).join(", ");
+            const shouldResolveOptional = await inquirer_1.default.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 = (0, zapier_sdk_1.getResolutionOrderForParams)(optionalParamNames);
+                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);
+                        this.setNestedValue(resolvedParams, param.path, value);
+                        // Update context with newly resolved value
+                        context.resolvedParams = resolvedParams;
+                    }
+                    catch (error) {
+                        if (this.isUserCancellation(error)) {
+                            console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                            process.exit(0);
+                        }
+                        console.error(chalk_1.default.red(`Failed to resolve ${param.name}:`), error);
+                        throw error;
+                    }
                 }
-                console.error(chalk_1.default.red(`Failed to resolve ${missing.name}:`), error);
-                throw error;
             }
         }
-        // 4. Validate final parameters
+        // 3. Validate final parameters
         const finalResult = schema.safeParse(resolvedParams);
         if (!finalResult.success) {
             console.error(chalk_1.default.red("❌ Parameter validation failed after resolution:"));
@@ -70,294 +122,173 @@ class SchemaParameterResolver {
         }
         return finalResult.data;
     }
-    findAllResolvableParameters(schema) {
-        const resolvable = [];
-        this.analyzeSchema(schema, [], resolvable);
-        return resolvable;
-    }
-    findResolvableParameters(schema, error, providedParams) {
-        const resolvable = this.findAllResolvableParameters(schema);
-        // Filter to only include parameters that are actually missing/invalid
-        const errorPaths = new Set(error.issues.map((issue) => issue.path.join(".")));
-        return resolvable.filter((param) => {
-            const paramPath = param.path.join(".");
-            const isErrorPath = errorPaths.has(paramPath);
-            const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
-            // Include if there's an error for this path or if it's required and missing
-            // Also include optional parameters that have resolvers and aren't provided
-            const shouldResolve = isErrorPath ||
-                (param.isRequired && !hasValue) ||
-                (!param.isRequired && !hasValue && param.resolverMeta?.resolver);
-            return shouldResolve;
-        });
-    }
-    analyzeSchema(schema, currentPath, resolvable) {
-        // Handle different Zod types
+    extractParametersFromSchema(schema) {
+        const parameters = [];
+        // Only handle ZodObject at the top level
         if (schema instanceof zod_1.z.ZodObject) {
             const shape = schema.shape;
-            Object.entries(shape).forEach(([key, fieldSchema]) => {
-                const fieldPath = [...currentPath, key];
-                this.analyzeSchemaField(key, fieldSchema, fieldPath, resolvable);
-            });
-        }
-        else if (schema instanceof zod_1.z.ZodOptional) {
-            this.analyzeSchema(schema.unwrap(), currentPath, resolvable);
-        }
-        else if (schema instanceof zod_1.z.ZodDefault) {
-            this.analyzeSchema(schema.removeDefault(), currentPath, resolvable);
+            for (const [key, fieldSchema] of Object.entries(shape)) {
+                const param = this.analyzeFieldSchema(key, fieldSchema);
+                if (param) {
+                    parameters.push(param);
+                }
+            }
         }
+        return parameters;
     }
-    analyzeSchemaField(name, schema, path, resolvable) {
-        const resolverMeta = schema._def.resolverMeta;
-        if (resolverMeta?.resolver) {
-            resolvable.push({
-                name,
-                path,
-                schema,
-                description: schema.description,
-                resolverMeta,
-                isRequired: !schema.isOptional(),
-            });
-        }
-        // Recursively analyze nested objects
-        if (schema instanceof zod_1.z.ZodObject) {
-            this.analyzeSchema(schema, path, resolvable);
-        }
-        else if (schema instanceof zod_1.z.ZodOptional) {
-            this.analyzeSchemaField(name, schema.unwrap(), path, resolvable);
-        }
-        else if (schema instanceof zod_1.z.ZodDefault) {
-            this.analyzeSchemaField(name, schema.removeDefault(), path, resolvable);
-        }
+    analyzeFieldSchema(fieldName, fieldSchema) {
+        let baseSchema = fieldSchema;
+        let isRequired = true;
+        // Check if field is optional or has default
+        if (baseSchema instanceof zod_1.z.ZodOptional) {
+            isRequired = false;
+            baseSchema = baseSchema._def.innerType;
+        }
+        if (baseSchema instanceof zod_1.z.ZodDefault) {
+            isRequired = false;
+            baseSchema = baseSchema._def.innerType;
+        }
+        return this.createResolvableParameter([fieldName], baseSchema, isRequired);
     }
-    sortByDependencies(parameters) {
-        // Simple topological sort based on 'depends' field
-        const sorted = [];
-        const remaining = [...parameters];
-        while (remaining.length > 0) {
-            const canResolve = remaining.filter((param) => {
-                const depends = param.resolverMeta?.resolver?.depends || [];
-                return depends.every((dep) => sorted.some((resolved) => resolved.name === dep));
-            });
-            if (canResolve.length === 0) {
-                // No more resolvable parameters, add remaining ones (circular dependency or no dependencies)
-                sorted.push(...remaining);
-                break;
-            }
-            sorted.push(...canResolve);
-            canResolve.forEach((param) => {
-                const index = remaining.indexOf(param);
-                remaining.splice(index, 1);
-            });
-        }
-        return sorted;
+    createResolvableParameter(path, schema, isRequired) {
+        if (path.length === 0)
+            return null;
+        const name = path[path.length - 1];
+        return {
+            name,
+            path,
+            schema,
+            description: schema.description,
+            isRequired,
+        };
     }
-    async resolveParameter(paramInfo, context) {
-        const resolver = paramInfo.resolverMeta?.resolver;
+    async resolveParameter(param, context) {
+        const resolver = (0, zapier_sdk_1.getResolver)(param.name);
         if (!resolver) {
-            return await this.promptStaticInput(paramInfo);
+            throw new Error(`No resolver found for parameter: ${param.name}`);
         }
+        console.log(chalk_1.default.blue(`\n🔍 Resolving ${param.name}...`));
         if (resolver.type === "static") {
-            return await this.promptStaticInput(paramInfo, resolver);
-        }
-        if (resolver.type === "dynamic") {
-            return await this.resolveDynamicParameter(paramInfo, resolver, context);
-        }
-        if (resolver.type === "fields") {
-            return await this.resolveFieldsParameter(paramInfo, resolver, context);
-        }
-        throw new Error(`Unknown resolver type: ${resolver.type}`);
-    }
-    async promptStaticInput(paramInfo, resolver) {
-        const promptConfig = {
-            type: resolver?.inputType === "editor"
-                ? "input"
-                : resolver?.inputType || "input",
-            name: "value",
-            message: `Enter ${paramInfo.description || paramInfo.name}${paramInfo.isRequired ? "" : " (optional)"}:`,
-        };
-        // Only use placeholder as default for required parameters
-        if (resolver?.placeholder && paramInfo.isRequired) {
-            promptConfig.default = resolver.placeholder;
-        }
-        // Add validation for required parameters
-        if (paramInfo.isRequired) {
-            promptConfig.validate = (input) => {
-                if (!input || (typeof input === "string" && input.trim() === "")) {
-                    return "This field is required. Please enter a value.";
-                }
-                return true;
+            // Static resolver - just prompt for input
+            const promptConfig = {
+                type: resolver.inputType === "password" ? "password" : "input",
+                name: param.name,
+                message: `Enter ${param.name}:`,
+                ...(resolver.placeholder && { default: resolver.placeholder }),
             };
+            const answers = await inquirer_1.default.prompt([promptConfig]);
+            return answers[param.name];
         }
-        // For editor-like prompts, provide helpful instructions
-        if (resolver?.inputType === "editor") {
-            promptConfig.message += " (JSON format)";
-        }
-        try {
-            const result = await inquirer_1.default.prompt([promptConfig]);
-            // For optional parameters, treat empty input as undefined
-            if (!paramInfo.isRequired &&
-                (!result.value || result.value.trim() === "")) {
-                return undefined;
-            }
-            // Try to parse JSON if it looks like JSON
-            if (typeof result.value === "string" &&
-                result.value.trim().startsWith("{")) {
-                try {
-                    return JSON.parse(result.value);
-                }
-                catch {
-                    console.warn(chalk_1.default.yellow("Warning: Could not parse as JSON, using as string"));
-                    return result.value;
-                }
-            }
-            return result.value;
-        }
-        catch (error) {
-            if (this.isUserCancellation(error)) {
-                console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
-                process.exit(0);
-            }
-            throw error;
-        }
-    }
-    async resolveDynamicParameter(paramInfo, resolver, context) {
-        console.log(chalk_1.default.gray(`Fetching options for ${paramInfo.name}...`));
-        try {
-            // Use the new fetch function approach
-            const options = await resolver.fetch(context.sdk, context.resolvedParams);
-            if (options.length === 0) {
-                console.log(chalk_1.default.yellow(`No options available for ${paramInfo.name}`));
-                return await this.promptStaticInput(paramInfo);
-            }
-            // Generate prompt configuration
-            const promptConfig = resolver.prompt(options, context.resolvedParams);
-            // Execute the prompt
-            let result;
+        else if (resolver.type === "dynamic") {
+            // Dynamic resolver - fetch options and prompt for selection
             try {
-                result = await inquirer_1.default.prompt([promptConfig]);
+                console.log(chalk_1.default.gray(`Fetching options for ${param.name}...`));
+                const items = await resolver.fetch(context.sdk, context.resolvedParams);
+                if (!items || items.length === 0) {
+                    throw new Error(`No options available for ${param.name}`);
+                }
+                const promptConfig = resolver.prompt(items, context.resolvedParams);
+                const answers = await inquirer_1.default.prompt([promptConfig]);
+                return answers[param.name];
             }
             catch (error) {
-                if (this.isUserCancellation(error)) {
-                    console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
-                    process.exit(0);
-                }
+                console.error(chalk_1.default.red(`Failed to fetch options for ${param.name}:`), error instanceof Error ? error.message : error);
                 throw error;
             }
-            let value = result[promptConfig.name || "value"];
-            // Handle JSON parsing if the value looks like JSON
-            if (typeof value === "string" && value.trim().startsWith("{")) {
-                try {
-                    value = JSON.parse(value);
-                }
-                catch {
-                    console.warn(chalk_1.default.yellow("Warning: Could not parse as JSON, using as string"));
-                }
-            }
-            return value;
         }
-        catch (error) {
-            if (this.isUserCancellation(error)) {
-                console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
-                process.exit(0);
-            }
-            if (error instanceof Error && error.message.includes("401")) {
-                console.log(chalk_1.default.yellow(`⚠️  Invalid auth token, falling back to manual input for ${paramInfo.name}`));
-            }
-            else {
-                console.error(chalk_1.default.red(`Failed to fetch options for ${paramInfo.name}:`), error);
-                console.log(chalk_1.default.yellow("Falling back to manual input..."));
-            }
-            return await this.promptStaticInput(paramInfo);
-        }
-    }
-    async resolveFieldsParameter(paramInfo, resolver, context) {
-        console.log(chalk_1.default.gray(`Fetching field definitions for ${paramInfo.name}...`));
-        try {
-            // Fetch field definitions using the resolver's fetch function
-            const fields = await resolver.fetch(context.sdk, context.resolvedParams);
-            if (fields.length === 0) {
-                console.log(chalk_1.default.yellow(`No input fields required for this action`));
-                return {};
-            }
-            console.log(chalk_1.default.blue(`\nConfiguring inputs for ${context.resolvedParams.app} ${context.resolvedParams.type} ${context.resolvedParams.action}:`));
-            const inputs = {};
-            // Separate required and optional fields
-            const requiredFields = fields.filter((field) => field.required);
-            const optionalFields = fields.filter((field) => !field.required);
-            // First, prompt for all required fields
-            if (requiredFields.length > 0) {
-                console.log(chalk_1.default.cyan(`\nRequired fields (${requiredFields.length}):`));
-                for (const field of requiredFields) {
-                    await this.promptForField(field, inputs);
-                }
-            }
-            // Then ask if user wants to configure optional fields
-            if (optionalFields.length > 0) {
-                console.log(chalk_1.default.gray(`\nThere are ${optionalFields.length} optional field(s) available.`));
-                let shouldConfigureOptional;
-                try {
-                    shouldConfigureOptional = await inquirer_1.default.prompt([
-                        {
-                            type: "confirm",
-                            name: "configure",
-                            message: "Would you like to configure optional fields?",
-                            default: false,
-                        },
-                    ]);
+        else if (resolver.type === "fields") {
+            // Fields resolver - fetch field definitions and prompt for each input
+            try {
+                console.log(chalk_1.default.gray(`Fetching input fields for ${param.name}...`));
+                const fields = await resolver.fetch(context.sdk, context.resolvedParams);
+                if (!fields || fields.length === 0) {
+                    console.log(chalk_1.default.yellow(`No input fields required for this action.`));
+                    return {};
                 }
-                catch (error) {
-                    if (this.isUserCancellation(error)) {
-                        console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
-                        process.exit(0);
+                const inputs = {};
+                // Separate required and optional fields
+                const requiredFields = fields.filter((field) => field.required);
+                const optionalFields = fields.filter((field) => !field.required);
+                // First, prompt for all required fields
+                if (requiredFields.length > 0) {
+                    console.log(chalk_1.default.blue(`\n📝 Please provide values for the following input fields:`));
+                    for (const field of requiredFields) {
+                        await this.promptForField(field, inputs);
                     }
-                    throw error;
                 }
-                if (shouldConfigureOptional.configure) {
-                    console.log(chalk_1.default.cyan(`\nOptional fields:`));
-                    for (const field of optionalFields) {
-                        await this.promptForField(field, inputs);
+                // Then ask if user wants to configure optional fields
+                if (optionalFields.length > 0) {
+                    console.log(chalk_1.default.gray(`\nThere are ${optionalFields.length} optional field(s) available.`));
+                    let shouldConfigureOptional;
+                    try {
+                        shouldConfigureOptional = await inquirer_1.default.prompt([
+                            {
+                                type: "confirm",
+                                name: "configure",
+                                message: "Would you like to configure optional fields?",
+                                default: false,
+                            },
+                        ]);
+                    }
+                    catch (error) {
+                        if (this.isUserCancellation(error)) {
+                            console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
+                            process.exit(0);
+                        }
+                        throw error;
+                    }
+                    if (shouldConfigureOptional.configure) {
+                        console.log(chalk_1.default.cyan(`\nOptional fields:`));
+                        for (const field of optionalFields) {
+                            await this.promptForField(field, inputs);
+                        }
                     }
                 }
+                return inputs;
             }
-            return inputs;
-        }
-        catch (error) {
-            if (this.isUserCancellation(error)) {
-                console.log(chalk_1.default.yellow("\n\nOperation cancelled by user"));
-                process.exit(0);
+            catch (error) {
+                console.error(chalk_1.default.red(`Failed to fetch fields for ${param.name}:`), error instanceof Error ? error.message : error);
+                throw error;
             }
-            console.error(chalk_1.default.red(`Failed to fetch field definitions for ${paramInfo.name}:`), error);
-            console.log(chalk_1.default.yellow("Falling back to manual JSON input..."));
-            return await this.promptStaticInput(paramInfo);
         }
+        throw new Error(`Unknown resolver type for ${param.name}`);
+    }
+    getNestedValue(obj, path) {
+        return path.reduce((current, key) => current?.[key], obj);
+    }
+    setNestedValue(obj, path, value) {
+        const lastKey = path[path.length - 1];
+        const parent = path.slice(0, -1).reduce((current, key) => {
+            if (!(key in current)) {
+                current[key] = {};
+            }
+            return current[key];
+        }, obj);
+        parent[lastKey] = value;
     }
     async promptForField(field, inputs) {
         const fieldPrompt = {
-            type: "input",
+            type: field.type === "boolean" ? "confirm" : "input",
             name: field.key,
             message: `${field.label || field.key}${field.required ? " (required)" : " (optional)"}:`,
+            ...(field.helpText && { prefix: chalk_1.default.gray(`ℹ ${field.helpText}\n`) }),
+            ...(field.default && { default: field.default }),
         };
-        // Add description/help text if available
-        if (field.help_text || field.description) {
-            fieldPrompt.message += `\n  ${chalk_1.default.dim(field.help_text || field.description)}`;
-        }
-        // Set default value
-        if (field.default !== undefined) {
-            fieldPrompt.default = field.default;
-        }
-        // Add validation for required fields
-        if (field.required) {
-            fieldPrompt.validate = (input) => {
-                if (!input || (typeof input === "string" && input.trim() === "")) {
-                    return "This field is required. Please enter a value.";
-                }
-                return true;
-            };
+        if (field.choices && field.choices.length > 0) {
+            fieldPrompt.type = "list";
+            fieldPrompt.choices = field.choices.map((choice) => ({
+                name: choice.label || choice.value,
+                value: choice.value,
+            }));
         }
-        let result;
         try {
-            result = await inquirer_1.default.prompt([fieldPrompt]);
+            const answer = await inquirer_1.default.prompt([fieldPrompt]);
+            if (answer[field.key] !== undefined && answer[field.key] !== "") {
+                inputs[field.key] = answer[field.key];
+            }
+            else if (field.required) {
+                throw new Error(`Required field ${field.key} cannot be empty`);
+            }
         }
         catch (error) {
             if (this.isUserCancellation(error)) {
@@ -366,48 +297,11 @@ class SchemaParameterResolver {
             }
             throw error;
         }
-        // Only include non-empty values
-        if (result[field.key] !== undefined && result[field.key] !== "") {
-            let value = result[field.key];
-            // Try to parse as appropriate type
-            if (field.type === "integer" && typeof value === "string") {
-                const parsed = parseInt(value, 10);
-                if (!isNaN(parsed))
-                    value = parsed;
-            }
-            else if (field.type === "number" && typeof value === "string") {
-                const parsed = parseFloat(value);
-                if (!isNaN(parsed))
-                    value = parsed;
-            }
-            else if (field.type === "boolean" && typeof value === "string") {
-                value = value.toLowerCase() === "true" || value === "1";
-            }
-            inputs[field.key] = value;
-        }
-    }
-    getNestedValue(obj, path) {
-        return path.reduce((current, key) => current?.[key], obj);
-    }
-    setNestedValue(obj, path, value) {
-        const lastKey = path[path.length - 1];
-        const parentPath = path.slice(0, -1);
-        const parent = parentPath.reduce((current, key) => {
-            if (!current[key]) {
-                current[key] = {};
-            }
-            return current[key];
-        }, obj);
-        parent[lastKey] = value;
     }
     isUserCancellation(error) {
-        // Check for various ways user cancellation can be detected
-        return (error &&
-            (error.name === "ExitPromptError" ||
-                error.message?.includes("User force closed the prompt") ||
-                error.message?.includes("SIGINT") ||
-                error.code === "SIGINT" ||
-                error.signal === "SIGINT"));
+        return (error?.name === "ExitPromptError" ||
+            error?.message?.includes("User force closed") ||
+            error?.isTTYError);
     }
 }
 exports.SchemaParameterResolver = SchemaParameterResolver;

package/dist/utils/schema-formatter.js

@@ -5,19 +5,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatItemsFromSchema = formatItemsFromSchema;
 const chalk_1 = __importDefault(require("chalk"));
-const zapier_sdk_1 = require("@zapier/zapier-sdk");
+function getFormatMetadata(schema) {
+    return schema?._def?.formatMeta;
+}
+function getOutputSchema(schema) {
+    return schema?._def?.outputSchema;
+}
 // ============================================================================
 // Generic Schema-Driven Formatter
 // ============================================================================
 function formatItemsFromSchema(inputSchema, items) {
     // Get the output schema and its format metadata
-    const outputSchema = (0, zapier_sdk_1.getOutputSchema)(inputSchema);
+    const outputSchema = getOutputSchema(inputSchema);
     if (!outputSchema) {
         // Fallback to generic formatting if no output schema
         formatItemsGeneric(items);
         return;
     }
-    const formatMeta = (0, zapier_sdk_1.getFormatMetadata)(outputSchema);
+    const formatMeta = getFormatMetadata(outputSchema);
     if (!formatMeta) {
         // Fallback to generic formatting if no format metadata
         formatItemsGeneric(items);