@aeye/core 0.2.0 → 0.3.0

package/dist/schema.js

@@ -153,163 +153,6 @@ function strictifySimple(schema, transform) {
     // For all other types (primitives, etc.), return as-is
     return schema;
 }
-/**
- * Modify a JSON Schema property to make it optional (accept null)
- *
- * @param prop - input JSON Schema property
- * @returns
- */
-const makeOptional = (prop) => {
-    if (prop.type) {
-        const values = Array.isArray(prop.type) ? prop.type : [prop.type];
-        if (!values.includes('null')) {
-            prop.type = [...values, 'null'];
-        }
-        return prop;
-    }
-    else if (prop.$ref) {
-        // If it's a $ref, wrap it in anyOf with null
-        return {
-            anyOf: [
-                { $ref: prop.$ref },
-                { type: 'null' }
-            ],
-        };
-    }
-    else if (prop.allOf) {
-        // If it's an allOf with a single entry containing a $ref, extract and wrap the $ref
-        // This handles the common case: { allOf: [{ $ref: "..." }] }
-        if (prop.allOf.length === 1 && prop.allOf[0].$ref) {
-            return {
-                anyOf: [
-                    { $ref: prop.allOf[0].$ref },
-                    { type: 'null' }
-                ],
-            };
-        }
-        // Otherwise preserve the allOf structure
-        return {
-            anyOf: [
-                { allOf: prop.allOf },
-                { type: 'null' }
-            ],
-        };
-    }
-    else {
-        const { title, description, default: defaultValue, ...rest } = prop;
-        return {
-            title,
-            description,
-            default: defaultValue,
-            anyOf: [
-                rest,
-                { type: 'null' }
-            ],
-        };
-    }
-};
-/**
- * Override function to modify JSON Schema generation
- * to make optional fields accept null values.
- */
-const typeOverride = ({ zodSchema, jsonSchema, path }) => {
-    if (jsonSchema.type === 'object' && zodSchema instanceof z.ZodObject) {
-        const properties = jsonSchema.properties || {};
-        const propertyKeys = Object.keys(properties);
-        const required = jsonSchema.required || [];
-        const optional = propertyKeys.filter((key) => !required.includes(key));
-        // Add null to optional fields (those not in required array)
-        for (const key of optional) {
-            properties[key] = makeOptional(properties[key]);
-        }
-        // Check fields that are required - if they use preprocess with optional, add null
-        for (const key of required) {
-            const fieldSchema = zodSchema.shape[key];
-            // Check if this is a ZodPipe (from preprocess) wrapping optional
-            if (fieldSchema instanceof z.ZodPipe) {
-                const outputSchema = fieldSchema.def.out;
-                if (outputSchema instanceof z.ZodOptional) {
-                    const prop = properties[key];
-                    // Skip empty objects - they're placeholders for recursive schemas that will be filled in later
-                    if (Object.keys(prop).length === 0) {
-                        continue;
-                    }
-                    properties[key] = makeOptional(prop);
-                }
-            }
-        }
-        jsonSchema.required = propertyKeys;
-        jsonSchema.additionalProperties = false;
-    }
-    // Convert allOf with single entry to that entry or anyOf.
-    // allOf is not supported by some AI schema parsers.
-    if (jsonSchema.allOf?.length) {
-        if (jsonSchema.allOf.length === 1) {
-            if (Object.keys(jsonSchema).length === 1) {
-                // Delete allOf first, THEN assign the content
-                const content = jsonSchema.allOf[0];
-                delete jsonSchema.allOf;
-                Object.assign(jsonSchema, content);
-            }
-            else {
-                jsonSchema.anyOf = jsonSchema.allOf;
-                delete jsonSchema.allOf;
-            }
-        }
-    }
-    // For anyOf with null, convert to type array
-    if (jsonSchema.anyOf?.length === 2) {
-        if (jsonSchema.anyOf[1].type === 'null'
-            && Object.keys(jsonSchema.anyOf[1]).length === 1
-            && jsonSchema.anyOf[0].type
-            && !Array.isArray(jsonSchema.anyOf[0].type)) {
-            const first = jsonSchema.anyOf[0];
-            const nullableType = [first.type, 'null'];
-            delete jsonSchema.anyOf;
-            Object.assign(jsonSchema, first);
-            // Set type after assign to avoid it being overwritten
-            jsonSchema.type = nullableType;
-        }
-    }
-    // anyOf in an anyOf - flatten
-    // BUT: Don't flatten if it would lose $ref or other important properties
-    if (jsonSchema.anyOf?.length) {
-        const newAnyOf = [];
-        for (const subSchema of jsonSchema.anyOf) {
-            // Check if this sub-schema has a nested anyOf that should be flattened
-            // Only flatten if:
-            // 1. The sub-schema has an anyOf property
-            // 2. The sub-schema has no other properties except anyOf (it's a pure wrapper)
-            // 3. None of the elements in the nested anyOf are $refs (which should be preserved)
-            const isPureAnyOfWrapper = subSchema.anyOf?.length && Object.keys(subSchema).length === 1;
-            const hasRefInNested = subSchema.anyOf?.some((nested) => nested.$ref);
-            if (isPureAnyOfWrapper && !hasRefInNested) {
-                // Safe to flatten
-                newAnyOf.push(...subSchema.anyOf);
-            }
-            else {
-                // Keep as-is
-                newAnyOf.push(subSchema);
-            }
-        }
-        jsonSchema.anyOf = newAnyOf;
-    }
-};
-/**
- * Converts a Zod schema to JSON Schema that's compatible with AI schemas.
- *
- * @param schema - input Zod schema
- * @returns - JSON Schema object
- */
-export function toJSONSchema(schema, strict) {
-    return z.toJSONSchema(schema, {
-        target: 'draft-7',
-        reused: 'ref',
-        io: 'input',
-        unrepresentable: 'any',
-        override: strict ? typeOverride : undefined,
-    });
-}
 /**
  * Converts a Zod schema to JSON Schema V2 with support for different provider formats.
  *
@@ -332,13 +175,15 @@ export function toJSONSchema(schema, strict) {
  * const jsonSchema = toJSONSchemaV2(strictSchema, { strict: true, format: 'openai' });
  * ```
  */
-export function toJSONSchemaV2(schema, options) {
-    const { strict, format = 'openai' } = options;
+export function toJSONSchema(schema, options) {
+    const resolvedOptions = typeof options === 'boolean' ? { strict: options } : options;
+    const { strict, format = 'openai' } = resolvedOptions;
     // Currently only OpenAI format is supported
     if (format !== 'openai') {
         throw new Error(`Unsupported format: ${format}. Currently only 'openai' is supported.`);
     }
     const context = {
+        root: schema,
         strict,
         format,
         definitions: new Map(),
@@ -346,7 +191,7 @@ export function toJSONSchemaV2(schema, options) {
         refCounter: 0,
         path: [],
     };
-    const result = convertSchema(schema, context);
+    const result = convert(schema, context);
     // Add definitions if any were created
     if (context.definitionSchemas.size > 0) {
         result.$defs = Object.fromEntries(context.definitionSchemas);
@@ -356,16 +201,95 @@ export function toJSONSchemaV2(schema, options) {
 /**
  * Main recursive conversion function
  */
-function convertSchema(schema, context) {
-    // Check if we've seen this schema before (for recursion)
-    if (context.definitions.has(schema)) {
-        const refName = context.definitions.get(schema);
-        return { $ref: `#/$defs/${refName}` };
+function convert(schema, context) {
+    // For lazy schemas, we need to check by aid first to handle .describe()/.optional() wrappers
+    // that create new objects but share the same lazy getter
+    let cacheKey = schema;
+    let unwrappedSchema = schema;
+    // Check if this is a lazy schema and extract metadata early
+    if (schema instanceof z.ZodLazy) {
+        const metadata = (schema instanceof z.ZodType) ? schema.meta() : null;
+        const aid = metadata?.aid;
+        // If there's an aid, check if we've already seen this aid
+        if (aid) {
+            for (const [cachedSchema, [js, jsId]] of context.definitions.entries()) {
+                if (cachedSchema instanceof z.ZodType) {
+                    const cachedMeta = cachedSchema.meta();
+                    if (cachedMeta?.aid === aid && jsId && js) {
+                        // Found a cached version with the same aid - use it
+                        if (schema === context.root) {
+                            return { $ref: `#` };
+                        }
+                        if (!context.definitionSchemas.has(jsId)) {
+                            context.definitionSchemas.set(jsId, { ...js });
+                            for (const prop in js) {
+                                delete js[prop];
+                            }
+                            js.$ref = `#/$defs/${jsId}`;
+                        }
+                        return { $ref: `#/$defs/${jsId}` };
+                    }
+                }
+            }
+        }
+        unwrappedSchema = schema.def.getter();
+    }
+    else {
+        // Check cache by object identity for non-lazy schemas
+        const [js, jsId] = context.definitions.get(schema) || [];
+        if (jsId && js) {
+            if (schema === context.root) {
+                return { $ref: `#` };
+            }
+            if (!context.definitionSchemas.has(jsId)) {
+                context.definitionSchemas.set(jsId, { ...js });
+                for (const prop in js) {
+                    delete js[prop];
+                }
+                js.$ref = `#/$defs/${jsId}`;
+            }
+            return { $ref: `#/$defs/${jsId}` };
+        }
+    }
+    // Capture metadata from the original schema
+    const metadata = {};
+    if (schema instanceof z.ZodType) {
+        Object.assign(metadata, schema.meta() || {});
+        if (!metadata.description && schema.description) {
+            metadata.description = schema.description;
+        }
     }
+    // If the schema has an 'aid' or 'id' in meta, promote it to a definition
+    const id = (metadata.aid ? String(metadata.aid) : 0) || metadata.id || `__schema${context.refCounter++}`;
+    const save = !!(metadata.aid || metadata.id) && context.root !== schema;
+    // A schema target - will hold either the converted schema or a $ref
+    const target = {};
+    // Before converting, register this schema to handle recursion
+    context.definitions.set(cacheKey, [target, id]);
+    // Convert the unwrapped schema
+    const result = convertSchema(unwrappedSchema, context);
+    Object.assign(result, metadata);
+    delete result.aid;
+    // Promote it because user requested it or it's recursive
+    if (save || context.definitionSchemas.has(id)) {
+        context.definitionSchemas.set(id, result);
+        target.$ref = `#/$defs/${id}`;
+    }
+    else {
+        // Inline schema
+        Object.assign(target, result);
+    }
+    return target;
+}
+/**
+ * Main conversion function
+ */
+function convertSchema(schema, context) {
+    // TODO: Map, Set, File, ReadOnly, Nan, Catch, Prefault, NonOptional, Transform, Function, Promise, Custom
     // Handle ZodOptional
     if (schema instanceof z.ZodOptional) {
         const innerSchema = schema.unwrap();
-        const innerJson = convertSchema(innerSchema, context);
+        const innerJson = convert(innerSchema, context);
         if (context.strict) {
             // In strict mode, optional fields become nullable
             return makeNullable(innerJson);
@@ -378,56 +302,19 @@ function convertSchema(schema, context) {
     // Handle ZodNullable
     if (schema instanceof z.ZodNullable) {
         const innerSchema = schema.unwrap();
-        const innerJson = convertSchema(innerSchema, context);
+        const innerJson = convert(innerSchema, context);
         return makeNullable(innerJson);
     }
     // Handle ZodObject
     if (schema instanceof z.ZodObject) {
-        // Check if this object is recursive (contains self-references through getters)
-        // If it has an 'aid' in meta, create a definition for it
-        const meta = schema.meta();
-        if (meta?.aid && !context.definitions.has(schema)) {
-            // Register this schema as a definition
-            const refName = meta.aid;
-            context.definitions.set(schema, refName);
-            // Convert the schema
-            const properties = {};
-            const required = [];
-            const shape = schema.shape;
-            for (const key in shape) {
-                const fieldSchema = shape[key];
-                const isOptional = fieldSchema instanceof z.ZodOptional ||
-                    (fieldSchema instanceof z.ZodPipe && fieldSchema.def.out instanceof z.ZodOptional);
-                properties[key] = convertSchema(fieldSchema, context);
-                // In strict mode, ALL fields are required (optional ones are nullable)
-                // In non-strict mode, only non-optional fields are required
-                if (context.strict || !isOptional) {
-                    required.push(key);
-                }
-            }
-            const schemaJson = {
-                type: 'object',
-                properties,
-                required,
-            };
-            if (context.strict) {
-                schemaJson.additionalProperties = false;
-            }
-            addMetadata(schemaJson, schema);
-            context.definitionSchemas.set(refName, schemaJson);
-            return { $ref: `#/$defs/${refName}` };
-        }
         const properties = {};
         const required = [];
         const shape = schema.shape;
         for (const key in shape) {
             const fieldSchema = shape[key];
-            const isOptional = fieldSchema instanceof z.ZodOptional ||
-                (fieldSchema instanceof z.ZodPipe && fieldSchema.def.out instanceof z.ZodOptional);
-            properties[key] = convertSchema(fieldSchema, context);
-            // In strict mode, ALL fields are required (optional ones are nullable)
-            // In non-strict mode, only non-optional fields are required
-            if (context.strict || !isOptional) {
+            const isRequired = context.strict || !isOptional(fieldSchema);
+            properties[key] = convert(fieldSchema, context);
+            if (isRequired) {
                 required.push(key);
             }
         }
@@ -436,35 +323,40 @@ function convertSchema(schema, context) {
             properties,
             required,
         };
-        if (context.strict) {
+        if (context.strict || schema.def.catchall?._zod.def.type === "never") {
             result.additionalProperties = false;
         }
-        return addMetadata(result, schema);
+        else if (schema.def.catchall) {
+            result.additionalProperties = convert(schema.def.catchall, context);
+        }
+        return result;
     }
     // Handle ZodArray
     if (schema instanceof z.ZodArray) {
-        const items = convertSchema(schema.element, context);
         const result = {
             type: 'array',
-            items,
+            items: convert(schema.element, context),
         };
-        return addMetadata(result, schema);
+        const { minimum, maximum } = schema._zod.bag;
+        if (typeof minimum === 'number') {
+            result.minItems = minimum;
+        }
+        if (typeof maximum === 'number') {
+            result.maxItems = maximum;
+        }
+        return result;
     }
     // Handle ZodRecord - convert to array of {key, value} pairs in strict mode
     if (schema instanceof z.ZodRecord) {
-        const keySchema = schema.keyType || z.string();
-        const valueSchema = schema.valueType;
         if (context.strict) {
             // In strict mode, records become arrays of {key, value} objects
-            const keyJson = convertSchema(keySchema, context);
-            const valueJson = convertSchema(valueSchema, context);
             return {
                 type: 'array',
                 items: {
                     type: 'object',
                     properties: {
-                        key: keyJson,
-                        value: valueJson,
+                        key: convert(schema.keyType, context),
+                        value: convert(schema.valueType, context),
                     },
                     required: ['key', 'value'],
                     additionalProperties: false,
@@ -473,198 +365,233 @@ function convertSchema(schema, context) {
         }
         else {
             // In non-strict mode, use additionalProperties
-            const valueJson = convertSchema(valueSchema, context);
             return {
                 type: 'object',
-                additionalProperties: valueJson,
+                propertyNames: convert(schema.keyType, context),
+                additionalProperties: convert(schema.valueType, context),
             };
         }
     }
     // Handle ZodUnion
     if (schema instanceof z.ZodUnion) {
-        const anyOf = schema.options.map((option) => convertSchema(option, context));
+        const anyOf = schema.options.map(option => convert(option, context));
         return { anyOf };
     }
     // Handle ZodDiscriminatedUnion
     if (schema instanceof z.ZodDiscriminatedUnion) {
-        const anyOf = schema.options.map((option) => convertSchema(option, context));
+        const anyOf = schema.options.map(option => convert(option, context));
         return { anyOf };
     }
     // Handle ZodIntersection - not supported in OpenAI strict mode, convert to anyOf
     if (schema instanceof z.ZodIntersection) {
-        if (context.strict && context.format === 'openai') {
-            // Convert intersection to anyOf for OpenAI compatibility
-            return {
-                anyOf: [
-                    convertSchema(schema.def.left, context),
-                    convertSchema(schema.def.right, context),
-                ],
-            };
-        }
-        // For non-strict, we could try to merge objects, but for now use anyOf
-        return {
-            anyOf: [
-                convertSchema(schema.def.left, context),
-                convertSchema(schema.def.right, context),
-            ],
-        };
+        const left = convert(schema.def.left, context);
+        const right = convert(schema.def.right, context);
+        const allOf = [
+            ...(left.allOf && Object.keys(left).length === 1 ? left.allOf : [left]),
+            ...(right.allOf && Object.keys(right).length === 1 ? right.allOf : [right]),
+        ];
+        // TODO merge types to support allOf directly for strict mode
+        return context.strict ? { anyOf: allOf } : { allOf };
     }
     // Handle ZodTuple
     if (schema instanceof z.ZodTuple) {
         // Tuples in JSON Schema can be represented as arrays with prefixItems
         // For simplicity, we'll use an array type
-        const items = schema.def.items.map((item) => convertSchema(item, context));
+        const items = schema.def.items.map(item => convert(item, context));
+        const rest = schema.def.rest ? convert(schema.def.rest, context) : undefined;
+        const result = { type: 'array' };
+        if (context.strict && rest) {
+            items.push(rest);
+        }
         // If all items are the same type, simplify to a single items schema
         if (items.length > 0 && items.every((item) => JSON.stringify(item) === JSON.stringify(items[0]))) {
-            return {
-                type: 'array',
-                items: items[0],
-            };
+            result.items = items[0];
         }
-        // Otherwise, use anyOf for the items
-        return {
-            type: 'array',
-            items: {
-                anyOf: items,
-            },
-        };
+        else {
+            if (context.strict) {
+                result.items = { anyOf: items };
+            }
+            else {
+                result.prefixItems = items;
+            }
+        }
+        if (!context.strict && rest) {
+            result.additionalItems = rest;
+        }
+        if (!rest) {
+            let minItems = items.length;
+            while (minItems > 0 && isOptional(schema.def.items[minItems - 1])) {
+                minItems--;
+            }
+            result.minItems = minItems;
+            result.maxItems = items.length;
+        }
+        const { minimum, maximum } = schema._zod.bag;
+        if (typeof minimum === 'number') {
+            result.minItems = minimum;
+        }
+        if (typeof maximum === 'number') {
+            result.maxItems = maximum;
+        }
+        return result;
     }
     // Handle ZodEnum
     if (schema instanceof z.ZodEnum) {
-        const result = {
-            type: 'string',
-            enum: schema.options,
-        };
-        return addMetadata(result, schema);
-    }
-    // Handle ZodNativeEnum
-    if (schema._def?.typeName === 'ZodNativeEnum') {
-        const enumValues = Object.values(schema._def.values);
+        const numericValues = Object.values(schema.def.entries).filter((v) => typeof v === "number");
+        const values = Object.entries(schema.def.entries)
+            .filter(([k, _]) => numericValues.indexOf(+k) === -1)
+            .map(([_, v]) => v);
         return {
-            type: typeof enumValues[0] === 'number' ? 'number' : 'string',
-            enum: enumValues,
+            type: values.every((v) => typeof v === 'number')
+                ? 'number'
+                : values.every((v) => typeof v === 'string')
+                    ? 'string'
+                    : undefined,
+            enum: values,
         };
     }
     // Handle ZodLiteral
     if (schema instanceof z.ZodLiteral) {
-        const value = schema.value;
+        const values = Array.from(schema.values).filter(v => v !== undefined && typeof v !== 'function' && typeof v !== 'symbol' && typeof v !== 'bigint');
+        const types = Array.from(new Set(values.map(v => v === null ? 'null' : typeof v)));
         return {
-            type: typeof value,
-            const: value,
+            ...(types.length === 1 ? { type: types[0] } : {}),
+            ...(values.length === 1 ? { const: values[0] } : { enum: values }),
         };
     }
     // Handle ZodDefault
     if (schema instanceof z.ZodDefault) {
-        const innerJson = convertSchema(schema.def.innerType, context);
-        innerJson.default = schema.def.defaultValue;
+        const innerJson = convert(schema.def.innerType, context);
+        innerJson.default = JSON.parse(JSON.stringify(schema.def.defaultValue));
         return innerJson;
     }
-    // Handle ZodLazy
+    // Handle ZodLazy - don't unwrap here, let convert() handle caching
+    // Just return empty schema since ZodLazy should be handled at convert() level
     if (schema instanceof z.ZodLazy) {
-        // Check if schema has an 'aid' in meta for custom definition name
-        const meta = schema.meta();
-        const refName = meta?.aid || `LazySchema${context.refCounter++}`;
-        context.definitions.set(schema, refName);
-        // Get the actual schema
-        const actualSchema = schema.def.getter();
-        const schemaJson = convertSchema(actualSchema, context);
-        context.definitionSchemas.set(refName, schemaJson);
-        return { $ref: `#/$defs/${refName}` };
+        // This shouldn't be reached because convert() handles ZodLazy before calling convertSchema
+        throw new Error('ZodLazy should be handled in convert(), not convertSchema()');
     }
     // Handle ZodCodec
     if (schema instanceof z.ZodCodec) {
         // For codecs, use the input schema for JSON Schema generation
-        return convertSchema(schema.def.in, context);
+        return convert(schema.def.in, context);
     }
     // Handle ZodPipe (from preprocess)
     if (schema instanceof z.ZodPipe) {
-        // For pipes, use the output schema if in strict mode (since strictify creates pipes for optional->nullable conversion)
-        // Otherwise use input schema
-        if (context.strict && schema.def.out instanceof z.ZodOptional) {
-            // This is from strictify - the output is optional, so we want nullable
-            const innerSchema = schema.def.out.unwrap();
-            const innerJson = convertSchema(innerSchema, context);
-            return makeNullable(innerJson);
-        }
-        return convertSchema(schema.def.in, context);
-    }
-    // Handle ZodTransform (from z.transform())
-    if (schema._def?.typeName === 'ZodTransform') {
-        // Use the input schema for JSON Schema generation
-        return convertSchema(schema._def.schema, context);
+        const innerType = schema.def.in._zod.def.type === "transform" ? schema.def.out : schema.def.in;
+        return convert(innerType, context);
     }
     // Handle primitive types
     if (schema instanceof z.ZodString) {
         const result = { type: 'string' };
-        // Add string constraints if present
-        const checks = schema._def.checks || [];
-        for (const check of checks) {
-            if (check.kind === 'regex') {
-                result.pattern = check.regex.source;
+        const { minimum, maximum, format, patterns, contentEncoding } = schema._zod.bag;
+        if (context.strict) {
+            const strictFormats = ['date-time', 'time', 'date', 'duration', 'email', 'hostname', 'ipv4', 'ipv6', 'uuid'];
+            if (typeof format === 'string' && strictFormats.includes(format)) {
+                result.format = format;
             }
-            else if (check.kind === 'email') {
-                result.format = 'email';
+            if (patterns && patterns.size > 0) {
+                result.pattern = Array.from(patterns)[0].source;
             }
-            else if (check.kind === 'url') {
-                result.format = 'uri';
+        }
+        else {
+            if (typeof minimum === 'number') {
+                result.minLength = minimum;
             }
-            else if (check.kind === 'uuid') {
-                result.format = 'uuid';
+            if (typeof maximum === 'number') {
+                result.maxLength = maximum;
             }
-            else if (check.kind === 'datetime') {
-                result.format = 'date-time';
+            if (typeof format === 'string') {
+                result.format = format;
             }
-        }
-        return addMetadata(result, schema);
-    }
-    if (schema instanceof z.ZodNumber) {
-        const result = { type: 'number' };
-        // Add number constraints if present
-        const checks = schema._def.checks || [];
-        for (const check of checks) {
-            if (check.kind === 'min') {
-                if (check.inclusive) {
-                    result.minimum = check.value;
-                }
-                else {
-                    result.exclusiveMinimum = check.value;
-                }
+            if (typeof contentEncoding === 'string') {
+                result.contentEncoding = contentEncoding;
             }
-            else if (check.kind === 'max') {
-                if (check.inclusive) {
-                    result.maximum = check.value;
+            if (patterns) {
+                if (patterns.size === 1) {
+                    result.pattern = Array.from(patterns)[0].source;
                 }
                 else {
-                    result.exclusiveMaximum = check.value;
+                    result.allOf = Array.from(patterns).map((regex) => ({
+                        type: 'string',
+                        pattern: regex.source,
+                    }));
                 }
             }
-            else if (check.kind === 'multipleOf') {
-                result.multipleOf = check.value;
-            }
         }
-        return addMetadata(result, schema);
+        return result;
     }
-    if (schema instanceof z.ZodBoolean) {
-        return addMetadata({ type: 'boolean' }, schema);
+    if (schema instanceof z.ZodNumber) {
+        const result = { type: 'number' };
+        // Add number constraints if present
+        const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = schema._zod.bag;
+        if (typeof format === 'string' && format.includes("int")) {
+            result.type = 'integer';
+        }
+        if (typeof exclusiveMinimum === 'number') {
+            result.exclusiveMinimum = exclusiveMinimum;
+        }
+        else if (typeof minimum === 'number') {
+            result.minimum = minimum;
+        }
+        if (typeof exclusiveMaximum === 'number') {
+            result.exclusiveMaximum = exclusiveMaximum;
+        }
+        else if (typeof maximum === 'number') {
+            result.maximum = maximum;
+        }
+        if (typeof multipleOf === 'number') {
+            result.multipleOf = multipleOf;
+        }
+        return result;
+    }
+    if (schema instanceof z.ZodBoolean || schema instanceof z.ZodSuccess) {
+        return { type: 'boolean' };
     }
     if (schema instanceof z.ZodBigInt) {
-        return addMetadata({ type: 'integer' }, schema);
+        return { type: 'integer' };
+    }
+    if (schema instanceof z.ZodDate || schema instanceof z.ZodISODateTime) {
+        return { type: 'string', format: 'date-time' };
+    }
+    if (schema instanceof z.ZodISODate) {
+        return { type: 'string', format: 'date' };
+    }
+    if (schema instanceof z.ZodISOTime) {
+        return { type: 'string', format: 'time' };
+    }
+    if (schema instanceof z.ZodISODuration) {
+        return { type: 'string', format: 'duration' };
     }
-    if (schema instanceof z.ZodDate) {
-        return addMetadata({ type: 'string', format: 'date-time' }, schema);
+    if (schema instanceof z.ZodEmail) {
+        return { type: 'string', format: 'email' };
+    }
+    if (schema instanceof z.ZodIPv4) {
+        return { type: 'string', format: 'ipv4' };
+    }
+    if (schema instanceof z.ZodIPv6) {
+        return { type: 'string', format: 'ipv6' };
+    }
+    if (schema instanceof z.ZodUUID) {
+        return { type: 'string', format: 'uuid' };
     }
     if (schema instanceof z.ZodNull) {
         return { type: 'null' };
     }
+    if (schema instanceof z.ZodTemplateLiteral) {
+        return { type: 'string', pattern: schema._zod.pattern?.source };
+    }
     if (schema instanceof z.ZodUndefined) {
         return { type: 'null' }; // Treat undefined as null in JSON
     }
     if (schema instanceof z.ZodAny) {
         return {}; // Any type has no constraints
     }
-    // Handle ZodEffects (transformations, refinements) - use inner schema
-    if (schema._def?.typeName === 'ZodEffects') {
-        return convertSchema(schema._def.schema, context);
+    if (schema instanceof z.ZodUnknown) {
+        return {}; // Unknown type has no constraints
+    }
+    if (schema instanceof z.ZodTransform) {
+        return {}; // Transforms are not represented in JSON Schema
     }
     // Fallback for unknown types
     console.warn(`Unknown Zod schema type: ${schema.constructor.name}`);
@@ -684,7 +611,30 @@ function makeNullable(schema) {
         };
     }
     if (schema.type) {
-        // Add null to the type
+        // Check if schema has type-specific properties that require anyOf structure
+        // Arrays have 'items', objects have 'properties', etc.
+        const hasTypeSpecificProps = schema.items !== undefined ||
+            schema.properties !== undefined ||
+            schema.additionalProperties !== undefined ||
+            schema.patternProperties !== undefined ||
+            schema.minItems !== undefined ||
+            schema.maxItems !== undefined ||
+            schema.minProperties !== undefined ||
+            schema.maxProperties !== undefined;
+        // If there are type-specific properties, must use anyOf to separate type schemas
+        if (hasTypeSpecificProps) {
+            // Extract type-specific properties based on the type
+            const { type, description, ...rest } = schema;
+            const baseType = Array.isArray(type) ? type[0] : type;
+            return {
+                anyOf: [
+                    { type: baseType, ...rest },
+                    { type: 'null' },
+                ],
+                ...(description ? { description } : {}),
+            };
+        }
+        // For simple types without type-specific properties, can use array notation
         const types = Array.isArray(schema.type) ? schema.type : [schema.type];
         if (!types.includes('null')) {
             return {
@@ -713,17 +663,7 @@ function makeNullable(schema) {
         ],
     };
 }
-/**
- * Adds metadata (description, meta) from Zod schema to JSON Schema
- */
-function addMetadata(jsonSchema, zodSchema) {
-    if (zodSchema.description) {
-        jsonSchema.description = zodSchema.description;
-    }
-    const meta = zodSchema.meta();
-    if (meta?.title) {
-        jsonSchema.title = meta.title;
-    }
-    return jsonSchema;
+function isOptional(schema) {
+    return schema._zod.optin !== undefined;
 }
 //# sourceMappingURL=schema.js.map