RangeError: Maximum call stack size exceeded

[kracas]

I'm getting RangeError: Maximum call stack size exceeded error when converting a schema that has:

• .or(z.undefined())
• .or(z.null())
• z.any()

For example:

const schema1 = z.string().or(z.undefined());

const schema2 = z.number().or(z.null());

const schema3 = z.object({
  foo: z.string().or(z.undefined()),
});

const schema4 = z.any();

const schema5 = z.object({
  bar: z.any(),
});

[marcogbarcellos]

me too.

[marcogbarcellos]

I was able to build my own simple solution, just so if you get here you it may be helpful (it's not fully well tested and unfortunately i don't have time to debug this lib and submit a PR but at least i'm sharing here):

import { z } from 'zod';

/**
 * Custom implementation of Zod to Vertex AI schema conversion
 * that avoids recursive stack overflow issues
 */
export function customZodToVertexSchema(zodSchema: z.ZodTypeAny): any {
  // Handle null case
  if (!zodSchema) return null;

  // Track visited schemas to prevent infinite recursion
  const visited = new WeakMap();

  // Main conversion function
  function convert(schema: z.ZodTypeAny, depth = 0): any {
    console.log('convert', schema);
    // Prevent excessive recursion depth
    if (depth > 20) {
      console.warn('Exceeded maximum recursion depth in schema conversion');
      return { type: 'string' };
    }

    // Check if we've seen this schema before to prevent infinite recursion
    if (visited.has(schema)) {
      return visited.get(schema);
    }

    let result: any = null;

    try {
      // Handle different Zod schema types
      if (schema instanceof z.ZodString) {
        result = { type: 'string' };
      } else if (schema instanceof z.ZodNumber) {
        result = { type: 'number' };
      } else if (schema instanceof z.ZodBoolean) {
        result = { type: 'boolean' };
      } else if (schema instanceof z.ZodArray) {
        // Create a placeholder to break circular references
        result = { type: 'array' };
        visited.set(schema, result);

        // Safe access to element type
        const elementType = schema._def?.type;
        if (elementType) {
          result.items = convert(elementType, depth + 1);
        } else {
          result.items = { type: 'string' };
        }
      } else if (schema instanceof z.ZodObject) {
        // Create a placeholder to break circular references
        result = {
          type: 'object',
          properties: {},
        };
        visited.set(schema, result);

        // Safe access to shape
        const shape = schema._def?.shape?.();
        if (shape) {
          for (const [key, value] of Object.entries(shape)) {
            result.properties[key] = convert(value as z.ZodTypeAny, depth + 1);
          }
        }
      } else if (schema instanceof z.ZodEnum) {
        result = {
          type: 'string',
          enum: schema._def?.values || [],
        };
      } else if (
        schema instanceof z.ZodUnion ||
        schema instanceof z.ZodDiscriminatedUnion
      ) {
        // For unions, we simplify by using the first option or defaulting to string
        const options = schema._def?.options;
        if (Array.isArray(options) && options.length > 0) {
          result = convert(options[0], depth + 1);
        } else {
          result = { type: 'string' };
        }
      } else if (
        schema instanceof z.ZodOptional ||
        schema instanceof z.ZodNullable
      ) {
        // Handle optional fields by converting the inner type
        const innerType = schema._def?.innerType;
        if (innerType) {
          result = convert(innerType, depth + 1);
        } else {
          result = { type: 'string' };
        }
      } else if (schema instanceof z.ZodRecord) {
        // For records (dictionaries), we use a simple object type
        result = {
          type: 'object',
          additionalProperties: true,
        };

        // If we can access the value type, use it for additionalProperties
        const valueType = schema._def?.valueType;
        if (valueType) {
          result.additionalProperties = convert(valueType, depth + 1);
        }
      } else if (schema instanceof z.ZodDefault) {
        // Handle ZodDefault by unwrapping and converting the inner type
        const innerType = schema._def?.innerType;
        if (innerType) {
          result = convert(innerType, depth + 1);
        } else {
          result = { type: 'string' };
        }
      } else if (schema instanceof z.ZodAny) {
        // Handle ZodAny with a type that Vertex AI will accept
        // Empty object {} isn't accepted by Vertex AI - it requires a type
        result = {
          type: 'string',
          // Using format: any signals this can be any value
          format: 'any',
        };
      } else {
        // Default fallback for unsupported types
        console.warn(`Unsupported Zod schema type: ${schema.constructor.name}`);
        result = { type: 'string' };
      }
    } catch (error) {
      console.error('Error converting Zod schema to Vertex schema:', error);
      result = { type: 'string' };
    }

    // Store the result for this schema to prevent circular processing
    if (!visited.has(schema)) {
      visited.set(schema, result);
    }

    return result;
  }

  return convert(zodSchema);
}