@zapier/zapier-sdk-cli 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @zapier/zapier-sdk-cli
 
+## 0.11.0
+
+### Minor Changes
+
+- 12c6d3d: Return nested fields with fieldsets instead of flat fields. Also have CLI properly create line items from fieldsets for run-action.
+
+### Patch Changes
+
+- Updated dependencies [12c6d3d]
+  - @zapier/zapier-sdk@0.11.0
+  - @zapier/zapier-sdk-mcp@0.3.8
+
 ## 0.10.0
 
 ### Minor Changes

package/dist/cli.cjs

@@ -336,7 +336,7 @@ var SchemaParameterResolver = class {
     const inputs = {};
     let processedFieldKeys = /* @__PURE__ */ new Set();
     let iteration = 0;
-    const maxIterations = 5;
+    const maxIterations = 10;
     while (iteration < maxIterations) {
       iteration++;
       const updatedContext = {
@@ -351,11 +351,11 @@ var SchemaParameterResolver = class {
           `Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`
         )
       );
-      const fields = await typedResolver.fetch(
+      const rootFieldItems = await typedResolver.fetch(
         updatedContext.sdk,
         updatedContext.resolvedParams
       );
-      if (!fields || fields.length === 0) {
+      if (!rootFieldItems || rootFieldItems.length === 0) {
         if (iteration === 1) {
           console.log(
             chalk3__default.default.yellow(`No input fields required for this action.`)
@@ -363,47 +363,125 @@ var SchemaParameterResolver = class {
         }
         break;
       }
-      const newFields = fields.filter(
-        (field) => !(field.key && processedFieldKeys.has(field.key))
+      const fieldStats = await this.processFieldItems(
+        rootFieldItems,
+        inputs,
+        processedFieldKeys,
+        [],
+        iteration
       );
-      if (newFields.length === 0) {
+      if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
         break;
       }
-      const newRequiredFields = newFields.filter(
-        (field) => field.is_required
-      );
-      const newOptionalFields = newFields.filter(
-        (field) => !field.is_required
+      if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
+        break;
+      }
+    }
+    if (iteration >= maxIterations) {
+      console.log(
+        chalk3__default.default.yellow(
+          `
+\u26A0\uFE0F  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`
+        )
       );
-      if (newRequiredFields.length > 0) {
+    }
+    return inputs;
+  }
+  /**
+   * 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) {
+    let newRequiredCount = 0;
+    let newOptionalCount = 0;
+    let optionalSkipped = false;
+    for (const item of items) {
+      const typedItem = item;
+      if (typedItem.type === "fieldset" && typedItem.fields && typedItem.key) {
+        const fieldsetTitle = typedItem.title || typedItem.key;
+        const pathDisplay = fieldsetPath.length > 0 ? ` (in ${fieldsetPath.join(" > ")})` : "";
         console.log(
-          chalk3__default.default.blue(
+          chalk3__default.default.cyan(
             `
-\u{1F4DD} Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`
+\u{1F4C1} Processing fieldset: ${fieldsetTitle}${pathDisplay}`
           )
         );
-        for (const field of newRequiredFields) {
-          await this.promptForField(field, inputs);
-          processedFieldKeys.add(field.key);
+        if (!targetInputs[typedItem.key]) {
+          targetInputs[typedItem.key] = [{}];
+        }
+        const fieldsetTarget = targetInputs[typedItem.key][0];
+        const nestedPath = [...fieldsetPath, fieldsetTitle];
+        const nestedStats = await this.processFieldItems(
+          typedItem.fields,
+          fieldsetTarget,
+          processedFieldKeys,
+          nestedPath,
+          iteration
+        );
+        newRequiredCount += nestedStats.newRequired;
+        newOptionalCount += nestedStats.newOptional;
+        if (nestedStats.optionalSkipped) {
+          optionalSkipped = true;
+        }
+      } else if (typedItem.type === "input_field" && typedItem.key) {
+        if (processedFieldKeys.has(typedItem.key)) {
+          continue;
+        }
+        const isRequired = typedItem.is_required || false;
+        if (isRequired) {
+          newRequiredCount++;
+          if (newRequiredCount === 1 && fieldsetPath.length === 0) {
+            console.log(
+              chalk3__default.default.blue(
+                `
+\u{1F4DD} Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`
+              )
+            );
+          }
+          await this.promptForField(typedItem, targetInputs);
+          processedFieldKeys.add(typedItem.key);
+        } else {
+          newOptionalCount++;
         }
       }
-      let shouldConfigureOptional = { configure: false };
-      if (newOptionalFields.length > 0) {
+    }
+    if (newOptionalCount > 0) {
+      const optionalFields = items.filter((item) => {
+        const typedItem = item;
+        return typedItem.type === "input_field" && typedItem.key && !typedItem.is_required && !processedFieldKeys.has(typedItem.key);
+      });
+      if (optionalFields.length > 0) {
+        const pathContext = fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
         console.log(
           chalk3__default.default.gray(
             `
-There are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available.`
+There are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`
           )
         );
         try {
-          shouldConfigureOptional = await inquirer__default.default.prompt([
+          const shouldConfigureOptional = await inquirer__default.default.prompt([
             {
               type: "confirm",
               name: "configure",
-              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields?`,
+              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields${pathContext}?`,
               default: false
             }
           ]);
+          if (shouldConfigureOptional.configure) {
+            console.log(chalk3__default.default.cyan(`
+Optional fields${pathContext}:`));
+            for (const field of optionalFields) {
+              await this.promptForField(field, targetInputs);
+              const typedField = field;
+              processedFieldKeys.add(typedField.key);
+            }
+          } else {
+            optionalSkipped = true;
+            optionalFields.forEach((field) => {
+              const typedField = field;
+              processedFieldKeys.add(typedField.key);
+            });
+          }
         } catch (error) {
           if (this.isUserCancellation(error)) {
             console.log(chalk3__default.default.yellow("\n\nOperation cancelled by user"));
@@ -411,32 +489,13 @@ There are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}opt
           }
           throw error;
         }
-        if (shouldConfigureOptional.configure) {
-          console.log(chalk3__default.default.cyan(`
-Optional fields:`));
-          for (const field of newOptionalFields) {
-            await this.promptForField(field, inputs);
-            processedFieldKeys.add(field.key);
-          }
-        } else {
-          newOptionalFields.forEach(
-            (field) => processedFieldKeys.add(field.key)
-          );
-        }
       }
-      if (newRequiredFields.length === 0 && (!newOptionalFields.length || !shouldConfigureOptional.configure)) {
-        break;
-      }
-    }
-    if (iteration >= maxIterations) {
-      console.log(
-        chalk3__default.default.yellow(
-          `
-\u26A0\uFE0F  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`
-        )
-      );
     }
-    return inputs;
+    return {
+      newRequired: newRequiredCount,
+      newOptional: newOptionalCount,
+      optionalSkipped
+    };
   }
   getNestedValue(obj, path2) {
     return path2.reduce(
@@ -2228,7 +2287,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default = {
-  version: "0.10.0"};
+  version: "0.11.0"};
 
 // src/cli.ts
 var program = new commander.Command();

package/dist/cli.mjs

@@ -303,7 +303,7 @@ var SchemaParameterResolver = class {
     const inputs = {};
     let processedFieldKeys = /* @__PURE__ */ new Set();
     let iteration = 0;
-    const maxIterations = 5;
+    const maxIterations = 10;
     while (iteration < maxIterations) {
       iteration++;
       const updatedContext = {
@@ -318,11 +318,11 @@ var SchemaParameterResolver = class {
           `Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`
         )
       );
-      const fields = await typedResolver.fetch(
+      const rootFieldItems = await typedResolver.fetch(
         updatedContext.sdk,
         updatedContext.resolvedParams
       );
-      if (!fields || fields.length === 0) {
+      if (!rootFieldItems || rootFieldItems.length === 0) {
         if (iteration === 1) {
           console.log(
             chalk3.yellow(`No input fields required for this action.`)
@@ -330,47 +330,125 @@ var SchemaParameterResolver = class {
         }
         break;
       }
-      const newFields = fields.filter(
-        (field) => !(field.key && processedFieldKeys.has(field.key))
+      const fieldStats = await this.processFieldItems(
+        rootFieldItems,
+        inputs,
+        processedFieldKeys,
+        [],
+        iteration
       );
-      if (newFields.length === 0) {
+      if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
         break;
       }
-      const newRequiredFields = newFields.filter(
-        (field) => field.is_required
-      );
-      const newOptionalFields = newFields.filter(
-        (field) => !field.is_required
+      if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
+        break;
+      }
+    }
+    if (iteration >= maxIterations) {
+      console.log(
+        chalk3.yellow(
+          `
+\u26A0\uFE0F  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`
+        )
       );
-      if (newRequiredFields.length > 0) {
+    }
+    return inputs;
+  }
+  /**
+   * 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) {
+    let newRequiredCount = 0;
+    let newOptionalCount = 0;
+    let optionalSkipped = false;
+    for (const item of items) {
+      const typedItem = item;
+      if (typedItem.type === "fieldset" && typedItem.fields && typedItem.key) {
+        const fieldsetTitle = typedItem.title || typedItem.key;
+        const pathDisplay = fieldsetPath.length > 0 ? ` (in ${fieldsetPath.join(" > ")})` : "";
         console.log(
-          chalk3.blue(
+          chalk3.cyan(
             `
-\u{1F4DD} Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`
+\u{1F4C1} Processing fieldset: ${fieldsetTitle}${pathDisplay}`
           )
         );
-        for (const field of newRequiredFields) {
-          await this.promptForField(field, inputs);
-          processedFieldKeys.add(field.key);
+        if (!targetInputs[typedItem.key]) {
+          targetInputs[typedItem.key] = [{}];
+        }
+        const fieldsetTarget = targetInputs[typedItem.key][0];
+        const nestedPath = [...fieldsetPath, fieldsetTitle];
+        const nestedStats = await this.processFieldItems(
+          typedItem.fields,
+          fieldsetTarget,
+          processedFieldKeys,
+          nestedPath,
+          iteration
+        );
+        newRequiredCount += nestedStats.newRequired;
+        newOptionalCount += nestedStats.newOptional;
+        if (nestedStats.optionalSkipped) {
+          optionalSkipped = true;
+        }
+      } else if (typedItem.type === "input_field" && typedItem.key) {
+        if (processedFieldKeys.has(typedItem.key)) {
+          continue;
+        }
+        const isRequired = typedItem.is_required || false;
+        if (isRequired) {
+          newRequiredCount++;
+          if (newRequiredCount === 1 && fieldsetPath.length === 0) {
+            console.log(
+              chalk3.blue(
+                `
+\u{1F4DD} Please provide values for the following ${iteration === 1 ? "" : "additional "}input fields:`
+              )
+            );
+          }
+          await this.promptForField(typedItem, targetInputs);
+          processedFieldKeys.add(typedItem.key);
+        } else {
+          newOptionalCount++;
         }
       }
-      let shouldConfigureOptional = { configure: false };
-      if (newOptionalFields.length > 0) {
+    }
+    if (newOptionalCount > 0) {
+      const optionalFields = items.filter((item) => {
+        const typedItem = item;
+        return typedItem.type === "input_field" && typedItem.key && !typedItem.is_required && !processedFieldKeys.has(typedItem.key);
+      });
+      if (optionalFields.length > 0) {
+        const pathContext = fieldsetPath.length > 0 ? ` in ${fieldsetPath.join(" > ")}` : "";
         console.log(
           chalk3.gray(
             `
-There are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available.`
+There are ${optionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available${pathContext}.`
           )
         );
         try {
-          shouldConfigureOptional = await inquirer.prompt([
+          const shouldConfigureOptional = await inquirer.prompt([
             {
               type: "confirm",
               name: "configure",
-              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields?`,
+              message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields${pathContext}?`,
               default: false
             }
           ]);
+          if (shouldConfigureOptional.configure) {
+            console.log(chalk3.cyan(`
+Optional fields${pathContext}:`));
+            for (const field of optionalFields) {
+              await this.promptForField(field, targetInputs);
+              const typedField = field;
+              processedFieldKeys.add(typedField.key);
+            }
+          } else {
+            optionalSkipped = true;
+            optionalFields.forEach((field) => {
+              const typedField = field;
+              processedFieldKeys.add(typedField.key);
+            });
+          }
         } catch (error) {
           if (this.isUserCancellation(error)) {
             console.log(chalk3.yellow("\n\nOperation cancelled by user"));
@@ -378,32 +456,13 @@ There are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}opt
           }
           throw error;
         }
-        if (shouldConfigureOptional.configure) {
-          console.log(chalk3.cyan(`
-Optional fields:`));
-          for (const field of newOptionalFields) {
-            await this.promptForField(field, inputs);
-            processedFieldKeys.add(field.key);
-          }
-        } else {
-          newOptionalFields.forEach(
-            (field) => processedFieldKeys.add(field.key)
-          );
-        }
       }
-      if (newRequiredFields.length === 0 && (!newOptionalFields.length || !shouldConfigureOptional.configure)) {
-        break;
-      }
-    }
-    if (iteration >= maxIterations) {
-      console.log(
-        chalk3.yellow(
-          `
-\u26A0\uFE0F  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`
-        )
-      );
     }
-    return inputs;
+    return {
+      newRequired: newRequiredCount,
+      newOptional: newOptionalCount,
+      optionalSkipped
+    };
   }
   getNestedValue(obj, path2) {
     return path2.reduce(
@@ -2195,7 +2254,7 @@ function createZapierCliSdk(options = {}) {
 
 // package.json
 var package_default = {
-  version: "0.10.0"};
+  version: "0.11.0"};
 
 // src/cli.ts
 var program = new Command();

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zapier/zapier-sdk-cli",
-    "version": "0.10.0",
+    "version": "0.11.0",
     "description": "Command line interface for Zapier SDK",
     "main": "dist/index.cjs",
     "module": "dist/index.mjs",

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

@@ -7,6 +7,11 @@ export declare class SchemaParameterResolver {
     private createResolvableParameter;
     private resolveParameter;
     private resolveFieldsRecursively;
+    /**
+     * Recursively processes fieldsets and their fields, maintaining natural structure
+     * and creating nested inputs as needed (e.g., fieldset "foo" becomes inputs.foo = [{}])
+     */
+    private processFieldItems;
     private getNestedValue;
     private setNestedValue;
     private promptForField;

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

@@ -303,7 +303,7 @@ export class SchemaParameterResolver {
         const inputs = {};
         let processedFieldKeys = new Set();
         let iteration = 0;
-        const maxIterations = 5; // Prevent infinite loops
+        const maxIterations = 10; // Prevent infinite loops
         while (iteration < maxIterations) {
             iteration++;
             // Update context with current inputs so they're passed to listInputFields
@@ -315,44 +315,118 @@ export class SchemaParameterResolver {
                 },
             };
             console.log(chalk.gray(`Fetching input fields for ${param.name}${iteration > 1 ? ` (iteration ${iteration})` : ""}...`));
-            const fields = await typedResolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
-            if (!fields || fields.length === 0) {
+            const rootFieldItems = await typedResolver.fetch(updatedContext.sdk, updatedContext.resolvedParams);
+            if (!rootFieldItems || rootFieldItems.length === 0) {
                 if (iteration === 1) {
                     console.log(chalk.yellow(`No input fields required for this action.`));
                 }
                 break;
             }
-            // Find new fields that we haven't processed yet
-            const newFields = fields.filter((field) => !(field.key &&
-                processedFieldKeys.has(field.key)));
-            if (newFields.length === 0) {
-                // No new fields, we're done
+            // Process fields recursively, maintaining fieldset structure
+            const fieldStats = await this.processFieldItems(rootFieldItems, inputs, processedFieldKeys, [], iteration);
+            // If no new fields were processed, we're done
+            if (fieldStats.newRequired === 0 && fieldStats.newOptional === 0) {
                 break;
             }
-            // Separate new required and optional fields
-            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:`));
-                for (const field of newRequiredFields) {
-                    await this.promptForField(field, inputs);
-                    processedFieldKeys.add(field.key);
+            // If we only processed optional fields and skipped them, no need to re-fetch
+            if (fieldStats.newRequired === 0 && fieldStats.optionalSkipped) {
+                break;
+            }
+        }
+        if (iteration >= maxIterations) {
+            console.log(chalk.yellow(`\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`));
+        }
+        return inputs;
+    }
+    /**
+     * 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) {
+        let newRequiredCount = 0;
+        let newOptionalCount = 0;
+        let optionalSkipped = false;
+        for (const item of items) {
+            const typedItem = item;
+            if (typedItem.type === "fieldset" && typedItem.fields && typedItem.key) {
+                // Show fieldset context to user
+                const fieldsetTitle = typedItem.title || typedItem.key;
+                const pathDisplay = fieldsetPath.length > 0 ? ` (in ${fieldsetPath.join(" > ")})` : "";
+                console.log(chalk.cyan(`\n📁 Processing fieldset: ${fieldsetTitle}${pathDisplay}`));
+                // Create fieldset array in target inputs if it doesn't exist
+                if (!targetInputs[typedItem.key]) {
+                    targetInputs[typedItem.key] = [{}];
+                }
+                // 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);
+                newRequiredCount += nestedStats.newRequired;
+                newOptionalCount += nestedStats.newOptional;
+                if (nestedStats.optionalSkipped) {
+                    optionalSkipped = true;
+                }
+            }
+            else if (typedItem.type === "input_field" && typedItem.key) {
+                // Skip if already processed
+                if (processedFieldKeys.has(typedItem.key)) {
+                    continue;
+                }
+                const isRequired = typedItem.is_required || false;
+                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:`));
+                    }
+                    await this.promptForField(typedItem, targetInputs);
+                    processedFieldKeys.add(typedItem.key);
+                }
+                else {
+                    // Collect optional fields for batch processing
+                    newOptionalCount++;
                 }
             }
-            // Ask about optional fields
-            let shouldConfigureOptional = { configure: false };
-            if (newOptionalFields.length > 0) {
-                console.log(chalk.gray(`\nThere are ${newOptionalFields.length} ${iteration === 1 ? "" : "additional "}optional field(s) available.`));
+            // Skip info fields - they're for display only
+        }
+        // Handle optional fields after processing all required fields
+        if (newOptionalCount > 0) {
+            const optionalFields = items.filter((item) => {
+                const typedItem = item;
+                return (typedItem.type === "input_field" &&
+                    typedItem.key &&
+                    !typedItem.is_required &&
+                    !processedFieldKeys.has(typedItem.key));
+            });
+            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 {
-                    shouldConfigureOptional = await inquirer.prompt([
+                    const shouldConfigureOptional = await inquirer.prompt([
                         {
                             type: "confirm",
                             name: "configure",
-                            message: `Would you like to configure ${iteration === 1 ? "" : "these additional "}optional fields?`,
+                            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);
+                            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)) {
@@ -361,28 +435,13 @@ export class SchemaParameterResolver {
                     }
                     throw error;
                 }
-                if (shouldConfigureOptional.configure) {
-                    console.log(chalk.cyan(`\nOptional fields:`));
-                    for (const field of newOptionalFields) {
-                        await this.promptForField(field, inputs);
-                        processedFieldKeys.add(field.key);
-                    }
-                }
-                else {
-                    // Mark these fields as processed even if skipped to avoid re-asking
-                    newOptionalFields.forEach((field) => processedFieldKeys.add(field.key));
-                }
             }
-            // If we only processed optional fields and skipped them, no need to re-fetch
-            if (newRequiredFields.length === 0 &&
-                (!newOptionalFields.length || !shouldConfigureOptional.configure)) {
-                break;
-            }
-        }
-        if (iteration >= maxIterations) {
-            console.log(chalk.yellow(`\n⚠️  Maximum field resolution iterations reached. Some dynamic fields may not have been discovered.`));
         }
-        return inputs;
+        return {
+            newRequired: newRequiredCount,
+            newOptional: newOptionalCount,
+            optionalSkipped,
+        };
     }
     getNestedValue(obj, path) {
         return path.reduce((current, key) => current?.[key], obj);