@illuma-ai/agents 1.1.21 → 1.1.22

package/src/schemas/schema-preparation.test.js

@@ -1,370 +0,0 @@
-// src/schemas/schema-preparation.test.ts
-import { prepareSchemaForProvider } from './validate';
-import { Providers } from '@/common';
-describe('prepareSchemaForProvider', () => {
-    describe('basic passthrough', () => {
-        it('returns schema unchanged when strict is false', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    name: { type: 'string' },
-                },
-            };
-            const { schema: result, warnings } = prepareSchemaForProvider(schema, Providers.OPENAI, false);
-            expect(result).toEqual(schema);
-            expect(warnings).toEqual([]);
-        });
-        it('returns schema with additionalProperties already set', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    name: { type: 'string' },
-                },
-                required: ['name'],
-                additionalProperties: false,
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.OPENAI);
-            expect(result.additionalProperties).toBe(false);
-        });
-    });
-    describe('additionalProperties enforcement', () => {
-        it('adds additionalProperties: false to root object', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    name: { type: 'string' },
-                },
-            };
-            const { schema: result, warnings } = prepareSchemaForProvider(schema, Providers.ANTHROPIC);
-            expect(result.additionalProperties).toBe(false);
-            // Root object doesn't produce a warning for additionalProperties
-        });
-        it('adds additionalProperties: false to nested objects', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    address: {
-                        type: 'object',
-                        properties: {
-                            street: { type: 'string' },
-                            city: { type: 'string' },
-                        },
-                    },
-                },
-                additionalProperties: false,
-            };
-            const { schema: result, warnings } = prepareSchemaForProvider(schema, Providers.OPENAI);
-            const addressProp = result.properties.address;
-            expect(addressProp.additionalProperties).toBe(false);
-            expect(warnings.some(w => w.includes('additionalProperties'))).toBe(true);
-        });
-        it('adds additionalProperties: false to deeply nested objects', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    level1: {
-                        type: 'object',
-                        properties: {
-                            level2: {
-                                type: 'object',
-                                properties: {
-                                    value: { type: 'string' },
-                                },
-                            },
-                        },
-                    },
-                },
-                additionalProperties: false,
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.ANTHROPIC);
-            const level1 = result.properties.level1;
-            expect(level1.additionalProperties).toBe(false);
-            const level2 = level1.properties.level2;
-            expect(level2.additionalProperties).toBe(false);
-        });
-    });
-    describe('required properties enforcement', () => {
-        it('adds all properties to required when missing', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    name: { type: 'string' },
-                    age: { type: 'number' },
-                },
-            };
-            const { schema: result, warnings } = prepareSchemaForProvider(schema, Providers.OPENAI);
-            expect(result.required).toEqual(expect.arrayContaining(['name', 'age']));
-            expect(warnings.some(w => w.includes('required'))).toBe(true);
-        });
-        it('adds missing properties to existing required array', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    name: { type: 'string' },
-                    age: { type: 'number' },
-                    email: { type: 'string' },
-                },
-                required: ['name'],
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.ANTHROPIC);
-            expect(result.required).toEqual(expect.arrayContaining(['name', 'age', 'email']));
-        });
-        it('does not duplicate already-required properties', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    name: { type: 'string' },
-                    age: { type: 'number' },
-                },
-                required: ['name', 'age'],
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.OPENAI);
-            expect(result.required).toEqual(['name', 'age']);
-        });
-        it('adds required to nested objects', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    person: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string' },
-                            age: { type: 'number' },
-                        },
-                    },
-                },
-                additionalProperties: false,
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.OPENAI);
-            const person = result.properties.person;
-            expect(person.required).toEqual(expect.arrayContaining(['name', 'age']));
-        });
-    });
-    describe('numeric constraint stripping', () => {
-        it('strips minimum/maximum from number properties', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    age: { type: 'number', minimum: 0, maximum: 150 },
-                },
-                required: ['age'],
-                additionalProperties: false,
-            };
-            const { schema: result, warnings } = prepareSchemaForProvider(schema, Providers.ANTHROPIC);
-            const ageProp = result.properties.age;
-            expect(ageProp.minimum).toBeUndefined();
-            expect(ageProp.maximum).toBeUndefined();
-            expect(ageProp.description).toContain('minimum: 0');
-            expect(ageProp.description).toContain('maximum: 150');
-            expect(warnings.some(w => w.includes('minimum'))).toBe(true);
-            expect(warnings.some(w => w.includes('maximum'))).toBe(true);
-        });
-        it('strips multipleOf from integer properties', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    count: { type: 'integer', multipleOf: 5 },
-                },
-                required: ['count'],
-                additionalProperties: false,
-            };
-            const { schema: result, warnings } = prepareSchemaForProvider(schema, Providers.OPENAI);
-            const countProp = result.properties.count;
-            expect(countProp.multipleOf).toBeUndefined();
-            expect(countProp.description).toContain('multipleOf: 5');
-            expect(warnings.some(w => w.includes('multipleOf'))).toBe(true);
-        });
-        it('appends to existing description when stripping constraints', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    score: { type: 'number', description: 'User score', minimum: 0, maximum: 100 },
-                },
-                required: ['score'],
-                additionalProperties: false,
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.ANTHROPIC);
-            const scoreProp = result.properties.score;
-            expect(scoreProp.description).toContain('User score');
-            expect(scoreProp.description).toContain('minimum: 0');
-        });
-    });
-    describe('string constraint stripping', () => {
-        it('strips minLength/maxLength from string properties', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', minLength: 1, maxLength: 100 },
-                },
-                required: ['name'],
-                additionalProperties: false,
-            };
-            const { schema: result, warnings } = prepareSchemaForProvider(schema, Providers.OPENAI);
-            const nameProp = result.properties.name;
-            expect(nameProp.minLength).toBeUndefined();
-            expect(nameProp.maxLength).toBeUndefined();
-            expect(nameProp.description).toContain('minLength: 1');
-            expect(nameProp.description).toContain('maxLength: 100');
-            expect(warnings.length).toBeGreaterThan(0);
-        });
-        it('strips pattern from string properties', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    email: { type: 'string', pattern: '^[a-z]+@[a-z]+\\.[a-z]+$' },
-                },
-                required: ['email'],
-                additionalProperties: false,
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.ANTHROPIC);
-            const emailProp = result.properties.email;
-            expect(emailProp.pattern).toBeUndefined();
-            expect(emailProp.description).toContain('pattern:');
-        });
-    });
-    describe('array constraint stripping', () => {
-        it('strips minItems/maxItems from array properties', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    tags: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 10 },
-                },
-                required: ['tags'],
-                additionalProperties: false,
-            };
-            const { schema: result, warnings } = prepareSchemaForProvider(schema, Providers.OPENAI);
-            const tagsProp = result.properties.tags;
-            expect(tagsProp.minItems).toBeUndefined();
-            expect(tagsProp.maxItems).toBeUndefined();
-            expect(tagsProp.description).toContain('minItems: 1');
-            expect(warnings.some(w => w.includes('minItems'))).toBe(true);
-        });
-    });
-    describe('array items with object schemas', () => {
-        it('prepares object schemas inside array items', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    people: {
-                        type: 'array',
-                        items: {
-                            type: 'object',
-                            properties: {
-                                name: { type: 'string' },
-                                age: { type: 'number' },
-                            },
-                        },
-                    },
-                },
-                additionalProperties: false,
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.OPENAI);
-            const peopleProp = result.properties.people;
-            const items = peopleProp.items;
-            expect(items.additionalProperties).toBe(false);
-            expect(items.required).toEqual(expect.arrayContaining(['name', 'age']));
-        });
-    });
-    describe('anyOf handling', () => {
-        it('prepares object schemas within anyOf', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    result: {
-                        anyOf: [
-                            { type: 'object', properties: { value: { type: 'string' } } },
-                            { type: 'null' },
-                        ],
-                    },
-                },
-                additionalProperties: false,
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.ANTHROPIC);
-            const resultProp = result.properties.result;
-            const anyOf = resultProp.anyOf;
-            const objectVariant = anyOf.find(v => v.type === 'object');
-            expect(objectVariant?.additionalProperties).toBe(false);
-        });
-    });
-    describe('$defs handling', () => {
-        it('prepares schemas in $defs', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    item: { $ref: '#/$defs/Item' },
-                },
-                $defs: {
-                    Item: {
-                        type: 'object',
-                        properties: {
-                            id: { type: 'string' },
-                            name: { type: 'string' },
-                        },
-                    },
-                },
-                additionalProperties: false,
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.OPENAI);
-            const defs = result.$defs;
-            expect(defs.Item.additionalProperties).toBe(false);
-            expect(defs.Item.required).toEqual(expect.arrayContaining(['id', 'name']));
-        });
-    });
-    describe('nesting depth warnings', () => {
-        it('warns when nesting exceeds OpenAI limit of 5', () => {
-            // Build a deeply nested schema
-            let innermost = { type: 'string' };
-            for (let i = 0; i < 7; i++) {
-                innermost = {
-                    type: 'object',
-                    properties: { nested: innermost },
-                    additionalProperties: false,
-                    required: ['nested'],
-                };
-            }
-            const { warnings } = prepareSchemaForProvider(innermost, Providers.OPENAI);
-            expect(warnings.some(w => w.includes('nesting depth') && w.includes('exceeds'))).toBe(true);
-        });
-        it('does not warn about nesting depth for Anthropic', () => {
-            let innermost = { type: 'string' };
-            for (let i = 0; i < 7; i++) {
-                innermost = {
-                    type: 'object',
-                    properties: { nested: innermost },
-                    additionalProperties: false,
-                    required: ['nested'],
-                };
-            }
-            const { warnings } = prepareSchemaForProvider(innermost, Providers.ANTHROPIC);
-            expect(warnings.some(w => w.includes('nesting depth'))).toBe(false);
-        });
-    });
-    describe('provider-specific behavior', () => {
-        it('works correctly for Bedrock', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', maxLength: 50 },
-                    score: { type: 'number', minimum: 0 },
-                },
-            };
-            const { schema: result } = prepareSchemaForProvider(schema, Providers.BEDROCK);
-            expect(result.additionalProperties).toBe(false);
-            expect(result.required).toEqual(expect.arrayContaining(['name', 'score']));
-            const nameProp = result.properties.name;
-            expect(nameProp.maxLength).toBeUndefined();
-        });
-        it('does not mutate the original schema', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    name: { type: 'string', minLength: 1 },
-                },
-            };
-            const original = JSON.parse(JSON.stringify(schema));
-            prepareSchemaForProvider(schema, Providers.OPENAI);
-            expect(schema).toEqual(original);
-        });
-    });
-});
-//# sourceMappingURL=schema-preparation.test.js.map

package/src/schemas/validate.js

@@ -1,314 +0,0 @@
-import { Providers } from '@/common';
-/**
- * Validates structured output against a JSON Schema.
- *
- * @param output - The output to validate
- * @param schema - JSON Schema to validate against
- * @returns Validation result with success flag and data or error
- */
-export function validateStructuredOutput(output, schema) {
-    try {
-        // Parse output if it's a string
-        const data = typeof output === 'string' ? JSON.parse(output) : output;
-        // Basic JSON Schema validation
-        const errors = validateAgainstJsonSchema(data, schema);
-        if (errors.length > 0) {
-            return {
-                success: false,
-                error: `Validation failed: ${errors.join('; ')}`,
-                raw: data,
-            };
-        }
-        return {
-            success: true,
-            data: data,
-        };
-    }
-    catch (e) {
-        return {
-            success: false,
-            error: `Failed to parse output: ${e.message}`,
-            raw: output,
-        };
-    }
-}
-/**
- * Validates data against a JSON Schema (simplified implementation).
- * For complex schemas, consider using ajv or similar library.
- */
-function validateAgainstJsonSchema(data, schema, path = '') {
-    const errors = [];
-    if (schema.type === 'object' && typeof data !== 'object') {
-        errors.push(`${path || 'root'}: expected object, got ${typeof data}`);
-        return errors;
-    }
-    if (schema.type === 'array' && !Array.isArray(data)) {
-        errors.push(`${path || 'root'}: expected array, got ${typeof data}`);
-        return errors;
-    }
-    if (schema.type === 'string' && typeof data !== 'string') {
-        errors.push(`${path || 'root'}: expected string, got ${typeof data}`);
-        return errors;
-    }
-    if (schema.type === 'number' && typeof data !== 'number') {
-        errors.push(`${path || 'root'}: expected number, got ${typeof data}`);
-        return errors;
-    }
-    if (schema.type === 'boolean' && typeof data !== 'boolean') {
-        errors.push(`${path || 'root'}: expected boolean, got ${typeof data}`);
-        return errors;
-    }
-    // Validate required properties
-    if (schema.type === 'object' &&
-        Array.isArray(schema.required) &&
-        typeof data === 'object' &&
-        data !== null) {
-        for (const requiredProp of schema.required) {
-            if (!(requiredProp in data)) {
-                errors.push(`${path || 'root'}: missing required property '${requiredProp}'`);
-            }
-        }
-    }
-    // Validate nested properties
-    if (schema.type === 'object' &&
-        schema.properties &&
-        typeof data === 'object' &&
-        data !== null) {
-        const properties = schema.properties;
-        for (const [key, propSchema] of Object.entries(properties)) {
-            if (key in data) {
-                const nestedErrors = validateAgainstJsonSchema(data[key], propSchema, path ? `${path}.${key}` : key);
-                errors.push(...nestedErrors);
-            }
-        }
-    }
-    // Validate array items
-    if (schema.type === 'array' && schema.items && Array.isArray(data)) {
-        const itemSchema = schema.items;
-        for (let i = 0; i < data.length; i++) {
-            const nestedErrors = validateAgainstJsonSchema(data[i], itemSchema, `${path || 'root'}[${i}]`);
-            errors.push(...nestedErrors);
-        }
-    }
-    // Validate enum values
-    if (schema.enum && Array.isArray(schema.enum)) {
-        if (!schema.enum.includes(data)) {
-            errors.push(`${path || 'root'}: value '${data}' not in enum [${schema.enum.join(', ')}]`);
-        }
-    }
-    return errors;
-}
-/**
- * Converts a Zod schema to JSON Schema format.
- * This is a simplified converter for common types.
- */
-export function zodToJsonSchema(zodSchema) {
-    // Use the zod-to-json-schema library if available
-    // For now, provide a basic implementation
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { zodToJsonSchema: convert } = require('zod-to-json-schema');
-        return convert(zodSchema);
-    }
-    catch {
-        // Fallback: return a generic object schema
-        return {
-            type: 'object',
-            additionalProperties: true,
-        };
-    }
-}
-/**
- * Creates a structured output error message for retry.
- */
-export function createValidationErrorMessage(result, customMessage) {
-    if (customMessage) {
-        return customMessage;
-    }
-    return `The response did not match the expected schema. Error: ${result.error}. Please try again and ensure your response exactly matches the required format.`;
-}
-/**
- * Checks if a value is a valid JSON Schema object.
- */
-export function isValidJsonSchema(value) {
-    if (typeof value !== 'object' || value === null) {
-        return false;
-    }
-    const schema = value;
-    // Basic check: must have a type or properties
-    return (typeof schema.type === 'string' ||
-        typeof schema.properties === 'object' ||
-        typeof schema.$schema === 'string');
-}
-/**
- * Normalizes a JSON Schema by adding defaults and cleaning up.
- */
-export function normalizeJsonSchema(schema, config) {
-    const normalized = { ...schema };
-    // Ensure type is set
-    if (!normalized.type && normalized.properties) {
-        normalized.type = 'object';
-    }
-    // Add title from config name
-    if (config?.name && !normalized.title) {
-        normalized.title = config.name;
-    }
-    // Add description from config
-    if (config?.description && !normalized.description) {
-        normalized.description = config.description;
-    }
-    // Enable additionalProperties: false for strict mode
-    if (config?.strict !== false && normalized.type === 'object') {
-        normalized.additionalProperties = normalized.additionalProperties ?? false;
-    }
-    return normalized;
-}
-/**
- * Keywords unsupported by native structured output providers.
- * These are stripped from schemas and moved to description fields when strict mode is enabled.
- */
-const UNSUPPORTED_NUMERIC_KEYWORDS = ['minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf'];
-const UNSUPPORTED_STRING_KEYWORDS = ['minLength', 'maxLength', 'pattern', 'format'];
-const UNSUPPORTED_ARRAY_KEYWORDS = ['minItems', 'maxItems', 'uniqueItems'];
-const UNSUPPORTED_OBJECT_KEYWORDS = ['minProperties', 'maxProperties', 'patternProperties'];
-/**
- * Prepares a JSON Schema for a specific provider's native structured output API.
- *
- * This function normalizes the schema to comply with provider-specific requirements:
- * - Adds `additionalProperties: false` recursively to all objects (required by all providers in strict mode)
- * - Ensures all properties are listed in `required` (required by OpenAI and Anthropic)
- * - Strips unsupported constraint keywords (minimum, maxLength, etc.) and moves them to description
- * - Returns warnings for any modifications made
- *
- * @param schema - The original JSON Schema
- * @param provider - The LLM provider
- * @param strict - Whether strict mode is enabled (default: true)
- * @returns The prepared schema and any warnings
- */
-export function prepareSchemaForProvider(schema, provider, strict = true) {
-    const warnings = [];
-    if (!strict) {
-        return { schema: { ...schema }, warnings };
-    }
-    const prepared = prepareObjectRecursive(schema, '', provider, warnings);
-    return { schema: prepared, warnings };
-}
-/**
- * Recursively prepares a schema node for native structured output.
- */
-function prepareObjectRecursive(schema, path, provider, warnings, depth = 0) {
-    const result = { ...schema };
-    const currentPath = path || 'root';
-    // Warn on deep nesting (OpenAI limit is 5)
-    if (depth > 5 && (provider === Providers.OPENAI || provider === Providers.AZURE)) {
-        warnings.push(`${currentPath}: nesting depth ${depth} exceeds OpenAI's limit of 5 levels`);
-    }
-    // Handle object type
-    if (result.type === 'object' || (result.properties && !result.type)) {
-        if (!result.type) {
-            result.type = 'object';
-        }
-        // Add additionalProperties: false
-        if (result.additionalProperties !== false) {
-            result.additionalProperties = false;
-            if (path) {
-                warnings.push(`${currentPath}: set additionalProperties to false for strict mode`);
-            }
-        }
-        // Ensure all properties are in required
-        if (result.properties && typeof result.properties === 'object') {
-            const properties = result.properties;
-            const propertyNames = Object.keys(properties);
-            const currentRequired = Array.isArray(result.required) ? result.required : [];
-            const missingRequired = propertyNames.filter(name => !currentRequired.includes(name));
-            if (missingRequired.length > 0) {
-                result.required = [...currentRequired, ...missingRequired];
-                warnings.push(`${currentPath}: added ${missingRequired.join(', ')} to required (all properties must be required for strict mode; use type union with null for optional fields)`);
-            }
-            // Recursively prepare nested properties
-            const preparedProperties = {};
-            for (const [key, propSchema] of Object.entries(properties)) {
-                preparedProperties[key] = preparePropertySchema(propSchema, path ? `${path}.${key}` : key, provider, warnings, depth + 1);
-            }
-            result.properties = preparedProperties;
-        }
-    }
-    // Handle array type
-    if (result.type === 'array' && result.items && typeof result.items === 'object') {
-        result.items = preparePropertySchema(result.items, `${currentPath}[]`, provider, warnings, depth + 1);
-        // Strip unsupported array keywords
-        for (const keyword of UNSUPPORTED_ARRAY_KEYWORDS) {
-            if (keyword in result) {
-                appendToDescription(result, `${keyword}: ${result[keyword]}`);
-                delete result[keyword];
-                warnings.push(`${currentPath}: moved unsupported keyword '${keyword}' to description`);
-            }
-        }
-    }
-    // Handle anyOf
-    if (Array.isArray(result.anyOf)) {
-        result.anyOf = result.anyOf.map((variant, i) => preparePropertySchema(variant, `${currentPath}.anyOf[${i}]`, provider, warnings, depth + 1));
-    }
-    // Handle $defs / definitions
-    for (const defsKey of ['$defs', 'definitions']) {
-        if (result[defsKey] && typeof result[defsKey] === 'object') {
-            const defs = result[defsKey];
-            const preparedDefs = {};
-            for (const [key, defSchema] of Object.entries(defs)) {
-                preparedDefs[key] = preparePropertySchema(defSchema, `${defsKey}.${key}`, provider, warnings, depth);
-            }
-            result[defsKey] = preparedDefs;
-        }
-    }
-    return result;
-}
-/**
- * Prepares a single property schema, stripping unsupported keywords based on type.
- */
-function preparePropertySchema(schema, path, provider, warnings, depth) {
-    const result = { ...schema };
-    // Strip unsupported numeric keywords
-    if (result.type === 'number' || result.type === 'integer') {
-        for (const keyword of UNSUPPORTED_NUMERIC_KEYWORDS) {
-            if (keyword in result) {
-                appendToDescription(result, `${keyword}: ${result[keyword]}`);
-                delete result[keyword];
-                warnings.push(`${path}: moved unsupported keyword '${keyword}' to description`);
-            }
-        }
-    }
-    // Strip unsupported string keywords
-    if (result.type === 'string') {
-        for (const keyword of UNSUPPORTED_STRING_KEYWORDS) {
-            if (keyword in result) {
-                appendToDescription(result, `${keyword}: ${result[keyword]}`);
-                delete result[keyword];
-                warnings.push(`${path}: moved unsupported keyword '${keyword}' to description`);
-            }
-        }
-    }
-    // Strip unsupported object keywords
-    if (result.type === 'object') {
-        for (const keyword of UNSUPPORTED_OBJECT_KEYWORDS) {
-            if (keyword in result) {
-                appendToDescription(result, `${keyword}: ${result[keyword]}`);
-                delete result[keyword];
-                warnings.push(`${path}: moved unsupported keyword '${keyword}' to description`);
-            }
-        }
-    }
-    // Recursively handle nested objects and arrays
-    if (result.type === 'object' || result.properties || result.type === 'array' || result.anyOf || result.$defs || result.definitions) {
-        return prepareObjectRecursive(result, path, provider, warnings, depth);
-    }
-    return result;
-}
-/**
- * Appends a constraint description to the schema's description field.
- */
-function appendToDescription(schema, constraint) {
-    const existing = typeof schema.description === 'string' ? schema.description : '';
-    const constraintNote = `[Constraint: ${constraint}]`;
-    schema.description = existing ? `${existing} ${constraintNote}` : constraintNote;
-}
-//# sourceMappingURL=validate.js.map