@zapier/zapier-sdk-cli 0.15.13 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @zapier/zapier-sdk-cli
 
+## 0.16.0
+
+### Minor Changes
+
+- 24ae4f0: Upgrade to Zod 4
+  - Update all packages to use Zod 4
+  - Migrate internal API access from `_def` to `_zod.def`
+  - Update `z.record()` calls to include explicit key types
+  - Fix schema introspection for documentation generation and CLI
+  - Update MCP schema converter for Zod 4 structure
+
+### Patch Changes
+
+- Updated dependencies [24ae4f0]
+  - @zapier/zapier-sdk-mcp@0.4.0
+  - @zapier/zapier-sdk@0.16.0
+
+## 0.15.14
+
+### Patch Changes
+
+- d08fa90: Add proper license
+- Updated dependencies [d08fa90]
+  - @zapier/zapier-sdk-cli-login@0.3.5
+  - @zapier/zapier-sdk-mcp@0.3.39
+  - @zapier/zapier-sdk@0.15.13
+
 ## 0.15.13
 
 ### Patch Changes

package/LICENSE

@@ -0,0 +1,2 @@
+Copyright (c) Zapier, Inc.
+The Zapier SDK is part of Zapier's services.  By downloading, installing, accessing, or using any part of the Zapier SDK you agree to the Zapier Terms of Service, which can be found at: https://zapier.com/tos, or such other agreement between you and Zapier governing Zapier services (as applicable).  If you do not agree to the Zapier Terms of Service (or do not have another governing agreement in place with Zapier), you may not download, install, access, or use the Zapier SDK.

package/dist/cli.cjs

@@ -293,11 +293,11 @@ var SchemaParameterResolver = class {
     let isRequired = true;
     if (baseSchema instanceof zod.z.ZodOptional) {
       isRequired = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     }
     if (baseSchema instanceof zod.z.ZodDefault) {
       isRequired = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     }
     return this.createResolvableParameter([fieldName], baseSchema, isRequired);
   }
@@ -786,10 +786,10 @@ Optional fields${pathContext}:`));
   }
 };
 function getFormatMetadata(schema) {
-  return schema?._def?.formatMeta;
+  return schema?._zod?.def?.formatMeta;
 }
 function getOutputSchema(schema) {
-  return schema?._def?.outputSchema;
+  return schema?._zod?.def?.outputSchema;
 }
 function formatJsonOutput(data) {
   if (data === void 0) {
@@ -878,9 +878,9 @@ function formatItemsGeneric(items, startingNumber = 0) {
 }
 function analyzeZodSchema(schema, functionInfo) {
   const parameters = [];
-  if (schema._def && schema._def.typeName === "ZodEffects") {
-    const innerSchema = schema._def.schema;
-    return analyzeZodSchema(innerSchema, functionInfo);
+  const schemaDef = schema._zod?.def;
+  if (schemaDef?.type === "effect" && schemaDef.innerType) {
+    return analyzeZodSchema(schemaDef.innerType, functionInfo);
   }
   if (schema instanceof zod.z.ZodObject) {
     const shape = schema.shape;
@@ -904,14 +904,17 @@ function analyzeZodField(name, schema, functionInfo) {
   while (true) {
     if (baseSchema instanceof zod.z.ZodOptional) {
       required = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     } else if (baseSchema instanceof zod.z.ZodDefault) {
       required = false;
-      defaultValue = baseSchema._def.defaultValue();
-      baseSchema = baseSchema._def.innerType;
-    } else if (baseSchema._def && baseSchema._def.typeName === "ZodNullable") {
-      baseSchema = baseSchema._def.innerType;
+      defaultValue = baseSchema._zod.def.defaultValue();
+      baseSchema = baseSchema._zod.def.innerType;
     } else {
+      const zodDef = baseSchema._zod?.def;
+      if (zodDef?.typeName === "ZodNullable" && zodDef.innerType) {
+        baseSchema = zodDef.innerType;
+        continue;
+      }
       break;
     }
   }
@@ -927,7 +930,7 @@ function analyzeZodField(name, schema, functionInfo) {
     paramType = "array";
   } else if (baseSchema instanceof zod.z.ZodEnum) {
     paramType = "string";
-    choices = baseSchema._def.values;
+    choices = baseSchema.options;
   } else if (baseSchema instanceof zod.z.ZodRecord) {
     paramType = "string";
   }
@@ -1625,7 +1628,7 @@ var LoginSchema = zod.z.object({
 
 // package.json
 var package_default = {
-  version: "0.15.13"};
+  version: "0.16.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -2904,7 +2907,7 @@ function createZapierCliSdk(options = {}) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.15.13"};
+  version: "0.16.0"};
 function detectPackageManager(cwd = process.cwd()) {
   const ua = process.env.npm_config_user_agent;
   if (ua) {

package/dist/cli.mjs

@@ -257,11 +257,11 @@ var SchemaParameterResolver = class {
     let isRequired = true;
     if (baseSchema instanceof z.ZodOptional) {
       isRequired = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     }
     if (baseSchema instanceof z.ZodDefault) {
       isRequired = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     }
     return this.createResolvableParameter([fieldName], baseSchema, isRequired);
   }
@@ -750,10 +750,10 @@ Optional fields${pathContext}:`));
   }
 };
 function getFormatMetadata(schema) {
-  return schema?._def?.formatMeta;
+  return schema?._zod?.def?.formatMeta;
 }
 function getOutputSchema(schema) {
-  return schema?._def?.outputSchema;
+  return schema?._zod?.def?.outputSchema;
 }
 function formatJsonOutput(data) {
   if (data === void 0) {
@@ -842,9 +842,9 @@ function formatItemsGeneric(items, startingNumber = 0) {
 }
 function analyzeZodSchema(schema, functionInfo) {
   const parameters = [];
-  if (schema._def && schema._def.typeName === "ZodEffects") {
-    const innerSchema = schema._def.schema;
-    return analyzeZodSchema(innerSchema, functionInfo);
+  const schemaDef = schema._zod?.def;
+  if (schemaDef?.type === "effect" && schemaDef.innerType) {
+    return analyzeZodSchema(schemaDef.innerType, functionInfo);
   }
   if (schema instanceof z.ZodObject) {
     const shape = schema.shape;
@@ -868,14 +868,17 @@ function analyzeZodField(name, schema, functionInfo) {
   while (true) {
     if (baseSchema instanceof z.ZodOptional) {
       required = false;
-      baseSchema = baseSchema._def.innerType;
+      baseSchema = baseSchema._zod.def.innerType;
     } else if (baseSchema instanceof z.ZodDefault) {
       required = false;
-      defaultValue = baseSchema._def.defaultValue();
-      baseSchema = baseSchema._def.innerType;
-    } else if (baseSchema._def && baseSchema._def.typeName === "ZodNullable") {
-      baseSchema = baseSchema._def.innerType;
+      defaultValue = baseSchema._zod.def.defaultValue();
+      baseSchema = baseSchema._zod.def.innerType;
     } else {
+      const zodDef = baseSchema._zod?.def;
+      if (zodDef?.typeName === "ZodNullable" && zodDef.innerType) {
+        baseSchema = zodDef.innerType;
+        continue;
+      }
       break;
     }
   }
@@ -891,7 +894,7 @@ function analyzeZodField(name, schema, functionInfo) {
     paramType = "array";
   } else if (baseSchema instanceof z.ZodEnum) {
     paramType = "string";
-    choices = baseSchema._def.values;
+    choices = baseSchema.options;
   } else if (baseSchema instanceof z.ZodRecord) {
     paramType = "string";
   }
@@ -1589,7 +1592,7 @@ var LoginSchema = z.object({
 
 // package.json
 var package_default = {
-  version: "0.15.13"};
+  version: "0.16.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {
@@ -2868,7 +2871,7 @@ function createZapierCliSdk(options = {}) {
 // package.json with { type: 'json' }
 var package_default2 = {
   name: "@zapier/zapier-sdk-cli",
-  version: "0.15.13"};
+  version: "0.16.0"};
 function detectPackageManager(cwd = process.cwd()) {
   const ua = process.env.npm_config_user_agent;
   if (ua) {

package/dist/index.cjs

@@ -291,7 +291,7 @@ var LoginSchema = zod.z.object({
 
 // package.json
 var package_default = {
-  version: "0.15.13"};
+  version: "0.16.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {

package/dist/index.d.mts

@@ -2,18 +2,10 @@ import { AppItem, Manifest, GetSdkType, ZapierSdk, ZapierSdkOptions, BaseEvent }
 import { z } from 'zod';
 
 declare const BuildManifestSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
+    appKeys: z.ZodArray<z.ZodString>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     configPath: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 type BuildManifestOptions = z.infer<typeof BuildManifestSchema> & {
     onProgress?: (event: ManifestBuildProgressEvent) => void;
 };
@@ -64,21 +56,11 @@ interface BuildManifestPluginProvides {
 }
 
 declare const GenerateAppTypesSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
-    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    appKeys: z.ZodArray<z.ZodString>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     typesOutputDirectory: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}>;
+}, z.core.$strip>;
 type GenerateAppTypesOptions = z.infer<typeof GenerateAppTypesSchema> & {
     onProgress?: (event: AppTypesProgressEvent) => void;
 };

package/dist/index.d.ts

@@ -2,18 +2,10 @@ import { AppItem, Manifest, GetSdkType, ZapierSdk, ZapierSdkOptions, BaseEvent }
 import { z } from 'zod';
 
 declare const BuildManifestSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
+    appKeys: z.ZodArray<z.ZodString>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     configPath: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 type BuildManifestOptions = z.infer<typeof BuildManifestSchema> & {
     onProgress?: (event: ManifestBuildProgressEvent) => void;
 };
@@ -64,21 +56,11 @@ interface BuildManifestPluginProvides {
 }
 
 declare const GenerateAppTypesSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
-    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    appKeys: z.ZodArray<z.ZodString>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     typesOutputDirectory: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}>;
+}, z.core.$strip>;
 type GenerateAppTypesOptions = z.infer<typeof GenerateAppTypesSchema> & {
     onProgress?: (event: AppTypesProgressEvent) => void;
 };

package/dist/index.mjs

@@ -260,7 +260,7 @@ var LoginSchema = z.object({
 
 // package.json
 var package_default = {
-  version: "0.15.13"};
+  version: "0.16.0"};
 
 // src/telemetry/builders.ts
 function createCliBaseEvent(context = {}) {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@zapier/zapier-sdk-cli",
-    "version": "0.15.13",
+    "version": "0.16.0",
     "description": "Command line interface for Zapier SDK",
     "main": "dist/index.cjs",
     "module": "dist/index.mjs",
@@ -35,7 +35,7 @@
         "sdk"
     ],
     "author": "",
-    "license": "ISC",
+    "license": "SEE LICENSE IN LICENSE",
     "publishConfig": {
         "access": "restricted"
     },
@@ -58,7 +58,7 @@
         "pkce-challenge": "^5.0.0",
         "semver": "^7.7.3",
         "typescript": "^5.8.3",
-        "zod": "^3.25.67"
+        "zod": "4.2.1"
     },
     "devDependencies": {
         "@types/express": "^5.0.3",

package/dist/src/plugins/add/schemas.d.ts

@@ -1,18 +1,8 @@
 import { z } from "zod";
 export declare const AddSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
-    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    appKeys: z.ZodArray<z.ZodString>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     configPath: z.ZodOptional<z.ZodString>;
     typesOutput: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    configPath?: string | undefined;
-    typesOutput?: string | undefined;
-}, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    configPath?: string | undefined;
-    typesOutput?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type AddOptions = z.infer<typeof AddSchema>;

package/dist/src/plugins/buildManifest/schemas.d.ts

@@ -1,18 +1,10 @@
 import { z } from "zod";
 import type { AppItem, Manifest } from "@zapier/zapier-sdk";
 export declare const BuildManifestSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
+    appKeys: z.ZodArray<z.ZodString>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     configPath: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}, {
-    appKeys: string[];
-    configPath?: string | undefined;
-    skipWrite?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type BuildManifestOptions = z.infer<typeof BuildManifestSchema> & {
     onProgress?: (event: ManifestBuildProgressEvent) => void;
 };

package/dist/src/plugins/bundleCode/schemas.d.ts

@@ -6,19 +6,5 @@ export declare const BundleCodeSchema: z.ZodObject<{
     minify: z.ZodOptional<z.ZodBoolean>;
     target: z.ZodOptional<z.ZodString>;
     cjs: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    input: string;
-    string?: boolean | undefined;
-    output?: string | undefined;
-    minify?: boolean | undefined;
-    target?: string | undefined;
-    cjs?: boolean | undefined;
-}, {
-    input: string;
-    string?: boolean | undefined;
-    output?: string | undefined;
-    minify?: boolean | undefined;
-    target?: string | undefined;
-    cjs?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export type BundleCodeOptions = z.infer<typeof BundleCodeSchema>;

package/dist/src/plugins/generateAppTypes/schemas.d.ts

@@ -1,21 +1,11 @@
 import { z } from "zod";
 import type { AppItem } from "@zapier/zapier-sdk";
 export declare const GenerateAppTypesSchema: z.ZodObject<{
-    appKeys: z.ZodArray<z.ZodString, "many">;
-    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    appKeys: z.ZodArray<z.ZodString>;
+    authenticationIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
     skipWrite: z.ZodOptional<z.ZodBoolean>;
     typesOutputDirectory: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}, {
-    appKeys: string[];
-    authenticationIds?: string[] | undefined;
-    skipWrite?: boolean | undefined;
-    typesOutputDirectory?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type GenerateAppTypesOptions = z.infer<typeof GenerateAppTypesSchema> & {
     onProgress?: (event: AppTypesProgressEvent) => void;
 };

package/dist/src/plugins/getLoginConfigPath/schemas.d.ts

@@ -1,3 +1,3 @@
 import { z } from "zod";
-export declare const GetLoginConfigPathSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const GetLoginConfigPathSchema: z.ZodObject<{}, z.core.$strip>;
 export type GetLoginConfigPathOptions = z.infer<typeof GetLoginConfigPathSchema>;

package/dist/src/plugins/login/schemas.d.ts

@@ -1,9 +1,5 @@
 import { z } from "zod";
 export declare const LoginSchema: z.ZodObject<{
     timeout: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    timeout?: string | undefined;
-}, {
-    timeout?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type LoginOptions = z.infer<typeof LoginSchema>;

package/dist/src/plugins/logout/schemas.d.ts

@@ -1,3 +1,3 @@
 import { z } from "zod";
-export declare const LogoutSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const LogoutSchema: z.ZodObject<{}, z.core.$strip>;
 export type LogoutOptions = z.infer<typeof LogoutSchema>;

package/dist/src/plugins/mcp/schemas.d.ts

@@ -1,9 +1,5 @@
 import { z } from "zod";
 export declare const McpSchema: z.ZodObject<{
     port: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    port?: string | undefined;
-}, {
-    port?: string | undefined;
-}>;
+}, z.core.$strip>;
 export type McpOptions = z.infer<typeof McpSchema>;

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

@@ -23,12 +23,12 @@ function analyzeZodField(name, schema, functionInfo) {
     // Unwrap optional and default wrappers
     if (baseSchema instanceof z.ZodOptional) {
         required = false;
-        baseSchema = baseSchema._def.innerType;
+        baseSchema = baseSchema._zod.def.innerType;
     }
     if (baseSchema instanceof z.ZodDefault) {
         required = false;
-        defaultValue = baseSchema._def.defaultValue();
-        baseSchema = baseSchema._def.innerType;
+        defaultValue = baseSchema._zod.def.defaultValue();
+        baseSchema = baseSchema._zod.def.innerType;
     }
     // Determine parameter type
     let paramType = "string";
@@ -47,7 +47,7 @@ function analyzeZodField(name, schema, functionInfo) {
     }
     else if (baseSchema instanceof z.ZodEnum) {
         paramType = "string";
-        choices = baseSchema._def.values;
+        choices = baseSchema.options;
     }
     else if (baseSchema instanceof z.ZodRecord) {
         // Handle Record<string, any> as JSON string input

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

@@ -11,13 +11,10 @@ import { ZapierCliError, ZapierCliExitError } from "./errors";
 function analyzeZodSchema(schema, functionInfo) {
     const parameters = [];
     // Handle ZodEffects (schemas with .refine(), .transform(), etc.)
-    if (schema._def &&
-        schema._def.typeName ===
-            "ZodEffects") {
-        // Get the underlying schema
-        const innerSchema = schema
-            ._def.schema;
-        return analyzeZodSchema(innerSchema, functionInfo);
+    // In Zod, effects have type "effect" and inner schema is accessed via innerType
+    const schemaDef = schema._zod?.def;
+    if (schemaDef?.type === "effect" && schemaDef.innerType) {
+        return analyzeZodSchema(schemaDef.innerType, functionInfo);
     }
     if (schema instanceof z.ZodObject) {
         const shape = schema.shape;
@@ -38,21 +35,22 @@ function analyzeZodField(name, schema, functionInfo) {
     while (true) {
         if (baseSchema instanceof z.ZodOptional) {
             required = false;
-            baseSchema = baseSchema._def.innerType;
+            baseSchema = baseSchema._zod.def.innerType;
         }
         else if (baseSchema instanceof z.ZodDefault) {
             required = false;
-            defaultValue = baseSchema._def.defaultValue();
-            baseSchema = baseSchema._def.innerType;
-        }
-        else if (baseSchema._def &&
-            baseSchema._def
-                .typeName === "ZodNullable") {
-            // nullable doesn't affect CLI required status, but we need to unwrap it to get the base type
-            baseSchema = baseSchema._def.innerType;
+            defaultValue = baseSchema._zod.def.defaultValue();
+            baseSchema = baseSchema._zod.def.innerType;
         }
         else {
-            break; // No more wrappers to unwrap
+            // Check for ZodNullable - nullable doesn't affect CLI required status, but we need to unwrap it to get the base type
+            const zodDef = baseSchema._zod?.def;
+            if (zodDef?.typeName === "ZodNullable" && zodDef.innerType) {
+                baseSchema = zodDef.innerType;
+                continue;
+            }
+            // No more wrappers to unwrap
+            break;
         }
     }
     // Determine parameter type
@@ -72,7 +70,7 @@ function analyzeZodField(name, schema, functionInfo) {
     }
     else if (baseSchema instanceof z.ZodEnum) {
         paramType = "string";
-        choices = baseSchema._def.values;
+        choices = baseSchema.options;
     }
     else if (baseSchema instanceof z.ZodRecord) {
         // Handle Record<string, any> as JSON string input

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

@@ -234,11 +234,11 @@ export class SchemaParameterResolver {
         // Check if field is optional or has default
         if (baseSchema instanceof z.ZodOptional) {
             isRequired = false;
-            baseSchema = baseSchema._def.innerType;
+            baseSchema = baseSchema._zod.def.innerType;
         }
         if (baseSchema instanceof z.ZodDefault) {
             isRequired = false;
-            baseSchema = baseSchema._def.innerType;
+            baseSchema = baseSchema._zod.def.innerType;
         }
         return this.createResolvableParameter([fieldName], baseSchema, isRequired);
     }

package/dist/src/utils/schema-formatter.js

@@ -3,11 +3,12 @@ import util from "util";
 // These functions are internal to SDK, implementing basic formatting fallback
 // TODO: Consider exposing these utilities or implementing proper CLI formatting
 function getFormatMetadata(schema) {
-    return schema?._def
-        ?.formatMeta;
+    return schema?._zod
+        ?.def?.formatMeta;
 }
 function getOutputSchema(schema) {
-    return schema?._def?.outputSchema;
+    return schema?._zod?.def
+        ?.outputSchema;
 }
 // ============================================================================
 // JSON Formatting