@zapier/zapier-sdk-cli 0.8.4 → 0.10.0

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

@@ -1,6 +1,6 @@
 export { loginPlugin } from "./login";
 export { logoutPlugin } from "./logout";
 export { mcpPlugin } from "./mcp";
-export { generateTypesPlugin } from "./generateTypes";
 export { bundleCodePlugin } from "./bundleCode";
-export { getConfigPathPlugin } from "./getConfigPath";
+export { getLoginConfigPathPlugin } from "./getLoginConfigPath";
+export { addPlugin } from "./add";

package/dist/src/plugins/index.js

@@ -1,6 +1,6 @@
 export { loginPlugin } from "./login";
 export { logoutPlugin } from "./logout";
 export { mcpPlugin } from "./mcp";
-export { generateTypesPlugin } from "./generateTypes";
 export { bundleCodePlugin } from "./bundleCode";
-export { getConfigPathPlugin } from "./getConfigPath";
+export { getLoginConfigPathPlugin } from "./getLoginConfigPath";
+export { addPlugin } from "./add";

package/dist/src/sdk.js

@@ -1,5 +1,5 @@
 import { createZapierSdkWithoutRegistry, registryPlugin, } from "@zapier/zapier-sdk";
-import { loginPlugin, logoutPlugin, mcpPlugin, generateTypesPlugin, bundleCodePlugin, getConfigPathPlugin, } from "./plugins/index";
+import { loginPlugin, logoutPlugin, mcpPlugin, bundleCodePlugin, getLoginConfigPathPlugin, addPlugin, } from "./plugins/index";
 /**
  * Create a Zapier SDK instance configured specifically for the CLI
  * Includes all CLI-specific plugins in addition to the standard SDK functionality
@@ -10,9 +10,9 @@ export function createZapierCliSdk(options = {}) {
         debug: options.debug,
     });
     // Add CLI-specific plugins before registry
-    sdk = sdk.addPlugin(generateTypesPlugin);
     sdk = sdk.addPlugin(bundleCodePlugin);
-    sdk = sdk.addPlugin(getConfigPathPlugin);
+    sdk = sdk.addPlugin(getLoginConfigPathPlugin);
+    sdk = sdk.addPlugin(addPlugin);
     sdk = sdk.addPlugin(mcpPlugin);
     sdk = sdk.addPlugin(loginPlugin);
     sdk = sdk.addPlugin(logoutPlugin);

package/dist/src/utils/cli-generator-utils.d.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { type FunctionRegistryEntry } from "@zapier/zapier-sdk";
 export interface CliParameter {
     name: string;
     type: "string" | "number" | "boolean" | "array";
@@ -9,5 +10,5 @@ export interface CliParameter {
     hasResolver?: boolean;
     isPositional?: boolean;
 }
-export declare function analyzeZodSchema(schema: z.ZodSchema): CliParameter[];
+export declare function analyzeZodSchema(schema: z.ZodSchema, functionInfo?: FunctionRegistryEntry): CliParameter[];
 export declare function convertCliArgsToSdkParams(parameters: CliParameter[], positionalArgs: unknown[], options: Record<string, unknown>): Record<string, unknown>;

package/dist/src/utils/cli-generator-utils.js

@@ -1,14 +1,14 @@
 import { z } from "zod";
-import { hasResolver, isPositional } from "@zapier/zapier-sdk";
+import { isPositional } from "@zapier/zapier-sdk";
 // ============================================================================
 // Schema Analysis
 // ============================================================================
-export function analyzeZodSchema(schema) {
+export function analyzeZodSchema(schema, functionInfo) {
     const parameters = [];
     if (schema instanceof z.ZodObject) {
         const shape = schema.shape;
         for (const [key, fieldSchema] of Object.entries(shape)) {
-            const param = analyzeZodField(key, fieldSchema);
+            const param = analyzeZodField(key, fieldSchema, functionInfo);
             if (param) {
                 parameters.push(param);
             }
@@ -16,7 +16,7 @@ export function analyzeZodSchema(schema) {
     }
     return parameters;
 }
-function analyzeZodField(name, schema) {
+function analyzeZodField(name, schema, functionInfo) {
     let baseSchema = schema;
     let required = true;
     let defaultValue = undefined;
@@ -53,6 +53,12 @@ function analyzeZodField(name, schema) {
         // Handle Record<string, any> as JSON string input
         paramType = "string";
     }
+    // Check if this parameter has a resolver
+    let paramHasResolver = false;
+    // Check function-specific resolvers first
+    if (functionInfo?.resolvers?.[name]) {
+        paramHasResolver = true;
+    }
     // Extract resolver metadata
     return {
         name,
@@ -61,7 +67,7 @@ function analyzeZodField(name, schema) {
         description: schema.description,
         default: defaultValue,
         choices,
-        hasResolver: hasResolver(name),
+        hasResolver: paramHasResolver,
         isPositional: isPositional(schema),
     };
 }

package/dist/src/utils/cli-generator.js

@@ -1,34 +1,13 @@
 import { z } from "zod";
-import { hasResolver, isPositional, formatErrorMessage, ZapierError, } from "@zapier/zapier-sdk";
+import { isPositional, formatErrorMessage, ZapierError, } from "@zapier/zapier-sdk";
 import { SchemaParameterResolver } from "./parameter-resolver";
-import { formatItemsFromSchema } from "./schema-formatter";
+import { formatItemsFromSchema, formatJsonOutput } from "./schema-formatter";
 import chalk from "chalk";
-import util from "util";
 import inquirer from "inquirer";
 // ============================================================================
-// JSON Formatting
-// ============================================================================
-function formatJsonOutput(data) {
-    // Don't print anything for undefined results (commands that just perform actions)
-    if (data === undefined) {
-        return;
-    }
-    // Show success message for action results
-    if (data &&
-        typeof data === "object" &&
-        !Array.isArray(data) &&
-        (data.success !== undefined ||
-            data.id ||
-            data.status)) {
-        console.log(chalk.green("✅ Action completed successfully!\n"));
-    }
-    // Use util.inspect for colored output
-    console.log(util.inspect(data, { colors: true, depth: null, breakLength: 80 }));
-}
-// ============================================================================
 // Schema Analysis
 // ============================================================================
-function analyzeZodSchema(schema) {
+function analyzeZodSchema(schema, functionInfo) {
     const parameters = [];
     // Handle ZodEffects (schemas with .refine(), .transform(), etc.)
     if (schema._def &&
@@ -37,12 +16,12 @@ function analyzeZodSchema(schema) {
         // Get the underlying schema
         const innerSchema = schema
             ._def.schema;
-        return analyzeZodSchema(innerSchema);
+        return analyzeZodSchema(innerSchema, functionInfo);
     }
     if (schema instanceof z.ZodObject) {
         const shape = schema.shape;
         for (const [key, fieldSchema] of Object.entries(shape)) {
-            const param = analyzeZodField(key, fieldSchema);
+            const param = analyzeZodField(key, fieldSchema, functionInfo);
             if (param) {
                 parameters.push(param);
             }
@@ -50,7 +29,7 @@ function analyzeZodSchema(schema) {
     }
     return parameters;
 }
-function analyzeZodField(name, schema) {
+function analyzeZodField(name, schema, functionInfo) {
     let baseSchema = schema;
     let required = true;
     let defaultValue = undefined;
@@ -98,6 +77,12 @@ function analyzeZodField(name, schema) {
         // Handle Record<string, any> as JSON string input
         paramType = "string";
     }
+    // Check if this parameter has a resolver
+    let paramHasResolver = false;
+    // Check function-specific resolvers first
+    if (functionInfo?.resolvers?.[name]) {
+        paramHasResolver = true;
+    }
     // Extract resolver metadata
     return {
         name,
@@ -106,7 +91,7 @@ function analyzeZodField(name, schema) {
         description: schema.description,
         default: defaultValue,
         choices,
-        hasResolver: hasResolver(name),
+        hasResolver: paramHasResolver,
         isPositional: isPositional(schema),
     };
 }
@@ -145,7 +130,7 @@ export function generateCliCommands(program, sdk) {
         }
         // Convert methodName to kebab-case CLI command
         const cliCommandName = methodNameToCliCommand(fnInfo.name);
-        const config = createCommandConfig(cliCommandName, fnInfo.name, fnInfo.inputSchema, sdk);
+        const config = createCommandConfig(cliCommandName, fnInfo, sdk);
         addCommand(program, cliCommandName, config);
     });
     // Override the help display to show commands grouped by category
@@ -200,8 +185,9 @@ export function generateCliCommands(program, sdk) {
         },
     });
 }
-function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
-    const parameters = analyzeZodSchema(schema);
+function createCommandConfig(cliCommandName, functionInfo, sdk) {
+    const schema = functionInfo.inputSchema;
+    const parameters = analyzeZodSchema(schema, functionInfo);
     const description = schema.description || `${cliCommandName} command`;
     const handler = async (...args) => {
         try {
@@ -209,7 +195,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
             const commandObj = args[args.length - 1];
             const options = commandObj.opts();
             // Check if this is a list command for pagination
-            const isListCommand = cliCommandName.startsWith("list-");
+            const isListCommand = functionInfo.type === "list";
             const hasPaginationParams = parameters.some((p) => p.name === "maxItems" || p.name === "pageSize");
             const hasUserSpecifiedMaxItems = "maxItems" in options && options.maxItems !== undefined;
             const shouldUseJson = options.json;
@@ -217,7 +203,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
             const rawParams = convertCliArgsToSdkParams(parameters, args.slice(0, -1), options);
             // Resolve missing parameters interactively using schema metadata
             const resolver = new SchemaParameterResolver();
-            const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk);
+            const resolvedParams = await resolver.resolveParameters(schema, rawParams, sdk, functionInfo.name);
             // Handle paginated list commands with async iteration
             if (isListCommand &&
                 hasPaginationParams &&
@@ -225,8 +211,8 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
                 !hasUserSpecifiedMaxItems) {
                 // Get the async iterable directly from the SDK method call (don't await it! that breaks the next page behavior)
                 const sdkObj = sdk;
-                const sdkIterator = sdkObj[sdkMethodName](resolvedParams);
-                await handlePaginatedListWithAsyncIteration(sdkMethodName, sdkIterator, schema);
+                const sdkIterator = sdkObj[functionInfo.name](resolvedParams);
+                await handlePaginatedListWithAsyncIteration(functionInfo.name, sdkIterator, functionInfo);
             }
             else {
                 // Special handling for commands that write to files
@@ -234,14 +220,14 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
                 if (hasOutputFile) {
                     // Call the SDK method for file output commands
                     const sdkObj = sdk;
-                    await sdkObj[sdkMethodName](resolvedParams);
+                    await sdkObj[functionInfo.name](resolvedParams);
                     console.log(chalk.green(`✅ ${cliCommandName} completed successfully!`));
                     console.log(chalk.gray(`Output written to: ${hasOutputFile}`));
                     return;
                 }
                 // Call the SDK method and handle non-paginated results
                 const sdkObj = sdk;
-                const result = await sdkObj[sdkMethodName](resolvedParams);
+                const result = await sdkObj[functionInfo.name](resolvedParams);
                 const items = result?.data
                     ? result.data
                     : result;
@@ -249,7 +235,7 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
                     console.log(JSON.stringify(items, null, 2));
                 }
                 else if (isListCommand) {
-                    formatNonPaginatedResults(items, resolvedParams.maxItems, hasUserSpecifiedMaxItems, shouldUseJson, schema, sdkMethodName);
+                    formatNonPaginatedResults(items, resolvedParams.maxItems, hasUserSpecifiedMaxItems, shouldUseJson, functionInfo);
                 }
                 else {
                     formatJsonOutput(items);
@@ -294,6 +280,8 @@ function createCommandConfig(cliCommandName, sdkMethodName, schema, sdk) {
 }
 function addCommand(program, commandName, config) {
     const command = program.command(commandName).description(config.description);
+    // Track whether we've already used a positional array parameter
+    let hasPositionalArray = false;
     // Add parameters to command
     config.parameters.forEach((param) => {
         // Convert camelCase to kebab-case for CLI display
@@ -302,6 +290,19 @@ function addCommand(program, commandName, config) {
             // Required parameters with resolvers become optional positional arguments (resolver handles prompting)
             command.argument(`[${kebabName}]`, param.description || `${kebabName} parameter`);
         }
+        else if (param.required &&
+            param.type === "array" &&
+            !hasPositionalArray) {
+            // First required array parameter becomes a variadic positional argument
+            hasPositionalArray = true;
+            command.argument(`<${kebabName}...>`, param.description || `${kebabName} parameter`);
+        }
+        else if (param.required && param.type === "array") {
+            // Subsequent required array parameters become required flags
+            const flags = [`--${kebabName}`];
+            const flagSignature = flags.join(", ") + ` <values...>`;
+            command.requiredOption(flagSignature, param.description || `${kebabName} parameter (required)`);
+        }
         else if (param.required) {
             // Required parameters without resolvers become required positional arguments
             command.argument(`<${kebabName}>`, param.description || `${kebabName} parameter`);
@@ -358,6 +359,10 @@ function convertCliArgsToSdkParams(parameters, positionalArgs, options) {
     return sdkParams;
 }
 function convertValue(value, type) {
+    // Don't convert undefined values - let the resolver system handle them
+    if (value === undefined) {
+        return undefined;
+    }
     switch (type) {
         case "number":
             return Number(value);
@@ -383,11 +388,11 @@ function convertValue(value, type) {
 // ============================================================================
 // Pagination Handlers
 // ============================================================================
-async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, schema) {
-    const itemName = getItemNameFromMethod(sdkMethodName);
+async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, functionInfo) {
+    const itemName = getItemNameFromMethod(functionInfo);
     let totalShown = 0;
     let pageCount = 0;
-    console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
+    console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`));
     try {
         // Use async iteration to go through pages
         for await (const page of sdkResult) {
@@ -407,11 +412,11 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
             // Clear screen for subsequent pages (not the first)
             if (pageCount > 1) {
                 console.clear();
-                console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName)}\n`));
+                console.log(chalk.blue(`📋 ${getListTitleFromMethod(sdkMethodName, functionInfo)}\n`));
             }
-            // Format and display items using schema
-            if (schema) {
-                formatItemsFromSchema(schema, items, totalShown);
+            // Format and display items using function info
+            if (functionInfo) {
+                formatItemsFromSchema(functionInfo, items, totalShown);
             }
             else {
                 formatItemsGeneric(items, totalShown);
@@ -447,8 +452,8 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
                 console.log(chalk.yellow(`No ${itemName} found.`));
                 return;
             }
-            if (schema) {
-                formatItemsFromSchema(schema, items, 0);
+            if (functionInfo) {
+                formatItemsFromSchema(functionInfo, items, 0);
             }
             else {
                 formatItemsGeneric(items, 0);
@@ -460,7 +465,7 @@ async function handlePaginatedListWithAsyncIteration(sdkMethodName, sdkResult, s
         }
     }
 }
-function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, schema, methodName) {
+function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxItems, useRawJson, functionInfo) {
     if (!Array.isArray(result)) {
         if (useRawJson) {
             console.log(JSON.stringify(result, null, 2));
@@ -474,15 +479,15 @@ function formatNonPaginatedResults(result, requestedMaxItems, userSpecifiedMaxIt
         console.log(JSON.stringify(result, null, 2));
         return;
     }
-    const itemName = methodName ? getItemNameFromMethod(methodName) : "items";
+    const itemName = functionInfo ? getItemNameFromMethod(functionInfo) : "items";
     if (result.length === 0) {
         console.log(chalk.yellow(`No ${itemName} found.`));
         return;
     }
     console.log(chalk.green(`\n✅ Found ${result.length} ${itemName}:\n`));
-    // Use schema for formatting
-    if (schema) {
-        formatItemsFromSchema(schema, result);
+    // Use function info for formatting
+    if (functionInfo) {
+        formatItemsFromSchema(functionInfo, result);
     }
     else {
         // Fallback to generic formatting
@@ -509,20 +514,15 @@ function formatItemsGeneric(items, startingNumber = 0) {
     });
 }
 // Generic helper functions that infer from schema description or method name
-function getItemNameFromMethod(methodName) {
-    // Extract from method name: listApps -> apps, listActions -> actions
-    const listMatch = methodName.match(/^list(.+)$/);
-    if (listMatch) {
-        return listMatch[1].toLowerCase();
+function getItemNameFromMethod(functionInfo) {
+    if (functionInfo.itemType) {
+        return `${functionInfo.itemType} items`;
     }
-    // Fallback to generic
     return "items";
 }
-function getListTitleFromMethod(methodName) {
-    const itemName = getItemNameFromMethod(methodName);
-    if (itemName === "items")
-        return "Available Items";
-    // Capitalize first letter: apps -> Apps
-    const capitalized = itemName.charAt(0).toUpperCase() + itemName.slice(1);
-    return `Available ${capitalized}`;
+function getListTitleFromMethod(methodName, functionInfo) {
+    if (functionInfo.itemType) {
+        return `Available ${functionInfo.itemType} items`;
+    }
+    return `${methodName} items`;
 }

package/dist/src/utils/parameter-resolver.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { ZapierSdk } from "@zapier/zapier-sdk";
 export declare class SchemaParameterResolver {
-    resolveParameters(schema: z.ZodSchema, providedParams: unknown, sdk: ZapierSdk): Promise<unknown>;
+    resolveParameters(schema: z.ZodSchema, providedParams: unknown, sdk: ZapierSdk, functionName?: string): Promise<unknown>;
     private extractParametersFromSchema;
     private analyzeFieldSchema;
     private createResolvableParameter;
@@ -11,4 +11,7 @@ export declare class SchemaParameterResolver {
     private setNestedValue;
     private promptForField;
     private isUserCancellation;
+    private hasResolver;
+    private getResolver;
+    private getLocalResolvers;
 }

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

@@ -1,17 +1,59 @@
 import inquirer from "inquirer";
 import chalk from "chalk";
 import { z } from "zod";
-import { getResolver, hasResolver, getResolutionOrderForParams, } from "@zapier/zapier-sdk";
+// ============================================================================
+// Local Resolution Helper Functions
+// ============================================================================
+/**
+ * Resolve dependency chain for a parameter using local resolvers
+ * Returns parameters in the order they need to be resolved
+ */
+function getLocalResolutionOrder(paramName, resolvers, resolved = new Set()) {
+    const resolver = resolvers[paramName];
+    if (!resolver || resolver.type === "static") {
+        return [paramName];
+    }
+    const order = [];
+    if ("depends" in resolver && resolver.depends) {
+        for (const dependency of resolver.depends) {
+            if (!resolved.has(dependency)) {
+                order.push(...getLocalResolutionOrder(dependency, resolvers, resolved));
+                resolved.add(dependency);
+            }
+        }
+    }
+    if (!resolved.has(paramName)) {
+        order.push(paramName);
+        resolved.add(paramName);
+    }
+    return order;
+}
+/**
+ * Get resolution order for multiple parameters using local resolvers
+ */
+function getLocalResolutionOrderForParams(paramNames, resolvers) {
+    const resolved = new Set();
+    const order = [];
+    for (const paramName of paramNames) {
+        const paramOrder = getLocalResolutionOrder(paramName, resolvers, resolved);
+        for (const param of paramOrder) {
+            if (!order.includes(param)) {
+                order.push(param);
+            }
+        }
+    }
+    return order;
+}
 // ============================================================================
 // Schema Parameter Resolver
 // ============================================================================
 export class SchemaParameterResolver {
-    async resolveParameters(schema, providedParams, sdk) {
+    async resolveParameters(schema, providedParams, sdk, functionName) {
         // 1. Try to parse with current parameters
         const parseResult = schema.safeParse(providedParams);
         // Get all schema parameters to check which ones have resolvers
         const allParams = this.extractParametersFromSchema(schema);
-        const resolvableParams = allParams.filter((param) => hasResolver(param.name));
+        const resolvableParams = allParams.filter((param) => this.hasResolver(param.name, sdk, functionName));
         // Get all missing parameters that have resolvers
         const missingResolvable = resolvableParams.filter((param) => {
             const hasValue = this.getNestedValue(providedParams, param.path) !== undefined;
@@ -61,10 +103,13 @@ export class SchemaParameterResolver {
             sdk,
             currentParams: providedParams,
             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);
-            const requiredResolutionOrder = getResolutionOrderForParams(requiredParamNames);
+            const requiredResolutionOrder = getLocalResolutionOrderForParams(requiredParamNames, localResolvers);
             // Find all parameters that need to be resolved (including dependencies)
             // from the available resolvable parameters
             const orderedRequiredParams = requiredResolutionOrder
@@ -84,7 +129,7 @@ export class SchemaParameterResolver {
                 .filter((param) => param !== undefined);
             for (const param of orderedRequiredParams) {
                 try {
-                    const value = await this.resolveParameter(param, context);
+                    const value = await this.resolveParameter(param, context, functionName);
                     this.setNestedValue(resolvedParams, param.path, value);
                     // Update context with newly resolved value
                     context.resolvedParams = resolvedParams;
@@ -105,13 +150,13 @@ export class SchemaParameterResolver {
         // 3. Resolve parameters that should always be prompted for (but can be skipped)
         if (alwaysPrompt.length > 0) {
             const alwaysPromptNames = alwaysPrompt.map((p) => p.name);
-            const alwaysPromptResolutionOrder = getResolutionOrderForParams(alwaysPromptNames);
+            const alwaysPromptResolutionOrder = getLocalResolutionOrderForParams(alwaysPromptNames, localResolvers);
             const orderedAlwaysPromptParams = alwaysPromptResolutionOrder
                 .map((paramName) => alwaysPrompt.find((p) => p.name === paramName))
                 .filter((param) => param !== undefined);
             for (const param of orderedAlwaysPromptParams) {
                 try {
-                    const value = await this.resolveParameter(param, context);
+                    const value = await this.resolveParameter(param, context, functionName);
                     this.setNestedValue(resolvedParams, param.path, value);
                     // Update context with newly resolved value
                     context.resolvedParams = resolvedParams;
@@ -139,13 +184,13 @@ export class SchemaParameterResolver {
             if (shouldResolveOptional.resolveOptional) {
                 // Resolve optional parameters using their resolvers
                 const optionalParamNames = trulyOptional.map((p) => p.name);
-                const optionalResolutionOrder = getResolutionOrderForParams(optionalParamNames);
+                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);
+                        const value = await this.resolveParameter(param, context, functionName);
                         this.setNestedValue(resolvedParams, param.path, value);
                         // Update context with newly resolved value
                         context.resolvedParams = resolvedParams;
@@ -208,8 +253,8 @@ export class SchemaParameterResolver {
             isRequired,
         };
     }
-    async resolveParameter(param, context) {
-        const resolver = getResolver(param.name);
+    async resolveParameter(param, context, functionName) {
+        const resolver = this.getResolver(param.name, context.sdk, functionName);
         if (!resolver) {
             throw new Error(`No resolver found for parameter: ${param.name}`);
         }
@@ -285,8 +330,8 @@ export class SchemaParameterResolver {
                 break;
             }
             // Separate new required and optional fields
-            const newRequiredFields = newFields.filter((field) => field.required);
-            const newOptionalFields = newFields.filter((field) => !field.required);
+            const newRequiredFields = newFields.filter((field) => field.is_required);
+            const newOptionalFields = newFields.filter((field) => !field.is_required);
             // Prompt for new required fields
             if (newRequiredFields.length > 0) {
                 console.log(chalk.blue(`\n📝 Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`));
@@ -358,7 +403,7 @@ export class SchemaParameterResolver {
         const fieldPrompt = {
             type: fieldObj.type === "boolean" ? "confirm" : "input",
             name: fieldObj.key,
-            message: `${fieldObj.label || fieldObj.key}${fieldObj.required ? " (required)" : " (optional)"}:`,
+            message: `${fieldObj.label || fieldObj.key}${fieldObj.is_required ? " (required)" : " (optional)"}:`,
         };
         if (fieldObj.helpText) {
             fieldPrompt.prefix = chalk.gray(`ℹ ${fieldObj.helpText}\n`);
@@ -381,7 +426,7 @@ export class SchemaParameterResolver {
             if (answer[fieldObj.key] !== undefined && answer[fieldObj.key] !== "") {
                 inputs[fieldObj.key] = answer[fieldObj.key];
             }
-            else if (fieldObj.required) {
+            else if (fieldObj.is_required) {
                 throw new Error(`Required field ${fieldObj.key} cannot be empty`);
             }
         }
@@ -399,4 +444,36 @@ export class SchemaParameterResolver {
             errorObj?.message?.includes("User force closed") ||
             errorObj?.isTTYError === true);
     }
+    hasResolver(paramName, sdk, functionName) {
+        // Check plugin-specific resolvers first
+        if (functionName && typeof sdk.getRegistry === "function") {
+            const registry = sdk.getRegistry();
+            const functionInfo = registry.functions.find((f) => f.name === functionName);
+            if (functionInfo && functionInfo.resolvers?.[paramName]) {
+                return true;
+            }
+        }
+        // No global registry fallback
+        return false;
+    }
+    getResolver(paramName, sdk, functionName) {
+        // Check plugin-specific resolvers first
+        if (functionName && typeof sdk.getRegistry === "function") {
+            const registry = sdk.getRegistry();
+            const functionInfo = registry.functions.find((f) => f.name === functionName);
+            if (functionInfo && functionInfo.resolvers?.[paramName]) {
+                return functionInfo.resolvers[paramName];
+            }
+        }
+        // No global registry fallback
+        return null;
+    }
+    getLocalResolvers(sdk, functionName) {
+        if (!functionName || typeof sdk.getRegistry !== "function") {
+            return {};
+        }
+        const registry = sdk.getRegistry();
+        const functionInfo = registry.functions.find((f) => f.name === functionName);
+        return functionInfo?.resolvers || {};
+    }
 }

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

@@ -1,2 +1,6 @@
 import type { z } from "zod";
-export declare function formatItemsFromSchema(inputSchema: z.ZodType, items: unknown[], startingNumber?: number): void;
+export declare function formatJsonOutput(data: unknown): void;
+export declare function formatItemsFromSchema(functionInfo: {
+    inputSchema: z.ZodType;
+    outputSchema?: z.ZodType;
+}, items: unknown[], startingNumber?: number): void;