@typia/utils 12.0.2 → 13.0.0-dev.20260425

package/lib/converters/LlmSchemaConverter2.mjs

@@ -0,0 +1,551 @@
+import { __exports as LlmSchemaConverter } from '../_virtual/LlmSchemaConverter.mjs';
+import { __require as requireJsonDescriptor } from '../utils/internal/JsonDescriptor2.mjs';
+import { __require as requireLlmTypeChecker } from '../validators/LlmTypeChecker2.mjs';
+import { __require as requireOpenApiTypeChecker } from '../validators/OpenApiTypeChecker2.mjs';
+import { __require as requireLlmDescriptionInverter } from './internal/LlmDescriptionInverter2.mjs';
+import { __require as requireLlmParametersComposer } from './internal/LlmParametersComposer2.mjs';
+import { __require as requireOpenApiConstraintShifter } from './internal/OpenApiConstraintShifter2.mjs';
+
+var hasRequiredLlmSchemaConverter;
+
+function requireLlmSchemaConverter () {
+	if (hasRequiredLlmSchemaConverter) return LlmSchemaConverter;
+	hasRequiredLlmSchemaConverter = 1;
+	Object.defineProperty(LlmSchemaConverter, "__esModule", { value: true });
+	LlmSchemaConverter.LlmSchemaConverter = void 0;
+	const JsonDescriptor_1 = requireJsonDescriptor();
+	const LlmTypeChecker_1 = requireLlmTypeChecker();
+	const OpenApiTypeChecker_1 = requireOpenApiTypeChecker();
+	const LlmDescriptionInverter_1 = requireLlmDescriptionInverter();
+	const LlmParametersComposer_1 = requireLlmParametersComposer();
+	const OpenApiConstraintShifter_1 = requireOpenApiConstraintShifter();
+	/**
+	 * OpenAPI to LLM schema converter.
+	 *
+	 * `LlmSchemaConverter` converts OpenAPI JSON schemas to LLM-compatible
+	 * {@link ILlmSchema} format. LLMs don't fully support JSON Schema, so this
+	 * simplifies schemas by removing unsupported features (tuples, `const`, mixed
+	 * unions).
+	 *
+	 * Main functions:
+	 *
+	 * - {@link parameters}: Convert object schema to {@link ILlmSchema.IParameters}
+	 * - {@link schema}: Convert any schema to {@link ILlmSchema}
+	 * - {@link invert}: Extract constraints from description back to schema
+	 *
+	 * Configuration options ({@link ILlmSchema.IConfig}):
+	 *
+	 * - `strict`: OpenAI structured output mode (all properties required)
+	 *
+	 * @author Jeongho Nam - https://github.com/samchon
+	 */
+	var LlmSchemaConverter$1;
+	(function (LlmSchemaConverter) {
+	    /**
+	     * Get configuration with defaults applied.
+	     *
+	     * @param config Partial configuration
+	     * @returns Full configuration with defaults
+	     */
+	    LlmSchemaConverter.getConfig = (config) => { var _a; return ({
+	        strict: (_a = config === null || config === void 0 ? void 0 : config.strict) !== null && _a !== void 0 ? _a : false,
+	    }); };
+	    /* -----------------------------------------------------------
+	      CONVERTERS
+	    ----------------------------------------------------------- */
+	    /**
+	     * Convert OpenAPI object schema to LLM parameters schema.
+	     *
+	     * @param props.config Conversion configuration
+	     * @param props.components OpenAPI components for reference resolution
+	     * @param props.schema Object or reference schema to convert
+	     * @param props.accessor Error path accessor
+	     * @param props.refAccessor Reference path accessor
+	     * @returns Converted parameters or error
+	     */
+	    LlmSchemaConverter.parameters = (props) => {
+	        const config = LlmSchemaConverter.getConfig(props.config);
+	        const entity = LlmParametersComposer_1.LlmParametersFinder.parameters(Object.assign(Object.assign({}, props), { method: "LlmSchemaConverter.parameters" }));
+	        if (entity.success === false)
+	            return entity;
+	        const $defs = {};
+	        const result = transform(Object.assign(Object.assign({}, props), { config,
+	            $defs, schema: entity.value }));
+	        if (result.success === false)
+	            return result;
+	        return {
+	            success: true,
+	            value: Object.assign(Object.assign({}, result.value), { additionalProperties: false, $defs, description: OpenApiTypeChecker_1.OpenApiTypeChecker.isReference(props.schema)
+	                    ? JsonDescriptor_1.JsonDescriptor.cascade({
+	                        prefix: "#/components/schemas/",
+	                        components: props.components,
+	                        schema: Object.assign(Object.assign({}, props.schema), { description: result.value.description }),
+	                        escape: true,
+	                    })
+	                    : result.value.description }),
+	        };
+	    };
+	    /**
+	     * Convert OpenAPI schema to LLM schema.
+	     *
+	     * @param props.config Conversion configuration
+	     * @param props.components OpenAPI components for reference resolution
+	     * @param props.$defs Definition store (mutated with referenced types)
+	     * @param props.schema Schema to convert
+	     * @param props.accessor Error path accessor
+	     * @param props.refAccessor Reference path accessor
+	     * @returns Converted schema or error
+	     */
+	    LlmSchemaConverter.schema = (props) => transform({
+	        config: LlmSchemaConverter.getConfig(props.config),
+	        components: props.components,
+	        $defs: props.$defs,
+	        schema: props.schema,
+	        accessor: props.accessor,
+	        refAccessor: props.refAccessor,
+	    });
+	    const transform = (props) => {
+	        var _a, _b;
+	        // PREPARE ASSETS
+	        const union = [];
+	        const attribute = Object.assign({ title: props.schema.title, description: props.schema.description, deprecated: props.schema.deprecated, readOnly: props.schema.readOnly, writeOnly: props.schema.writeOnly, example: props.schema.example, examples: props.schema.examples }, Object.fromEntries(Object.entries(props.schema).filter(([key, value]) => key.startsWith("x-") && value !== undefined)));
+	        // VALIDADTE SCHEMA
+	        const reasons = [];
+	        OpenApiTypeChecker_1.OpenApiTypeChecker.visit({
+	            closure: (next, accessor) => {
+	                var _a;
+	                var _b;
+	                if (props.config.strict === true) {
+	                    // STRICT MODE VALIDATION
+	                    reasons.push(...validateStrict(next, accessor));
+	                }
+	                if (OpenApiTypeChecker_1.OpenApiTypeChecker.isTuple(next))
+	                    reasons.push({
+	                        accessor,
+	                        schema: next,
+	                        message: `LLM does not allow tuple type.`,
+	                    });
+	                else if (OpenApiTypeChecker_1.OpenApiTypeChecker.isReference(next)) {
+	                    // UNABLE TO FIND MATCHED REFERENCE
+	                    const key = (_b = next.$ref.split("#/components/schemas/")[1]) !== null && _b !== void 0 ? _b : next.$ref.split("/").at(-1);
+	                    if (((_a = props.components.schemas) === null || _a === void 0 ? void 0 : _a[key]) === undefined)
+	                        reasons.push({
+	                            schema: next,
+	                            accessor: accessor,
+	                            message: `unable to find reference type ${JSON.stringify(key)}.`,
+	                        });
+	                }
+	            },
+	            components: props.components,
+	            schema: props.schema,
+	            accessor: props.accessor,
+	            refAccessor: props.refAccessor,
+	        });
+	        if (reasons.length > 0)
+	            return {
+	                success: false,
+	                error: {
+	                    method: "LlmSchemaConverter.schema",
+	                    message: "Failed to compose LLM schema",
+	                    reasons,
+	                },
+	            };
+	        const convertConstant = (input) => {
+	            if (input.const === null)
+	                return {
+	                    type: "null",
+	                };
+	            if (typeof input.const === "boolean")
+	                return {
+	                    type: "boolean",
+	                    enum: [input.const],
+	                };
+	            if (typeof input.const === "string")
+	                return {
+	                    type: "string",
+	                    enum: [input.const],
+	                };
+	            if (typeof input.const === "number")
+	                return {
+	                    type: Number.isInteger(input.const) ? "integer" : "number",
+	                    enum: [input.const],
+	                };
+	            return null;
+	        };
+	        const visit = (input, accessor) => {
+	            var _a;
+	            var _b, _c, _d, _e;
+	            if (OpenApiTypeChecker_1.OpenApiTypeChecker.isOneOf(input)) {
+	                // UNION TYPE
+	                input.oneOf.forEach((s, i) => visit(s, `${accessor}.oneOf[${i}]`));
+	            }
+	            else if (OpenApiTypeChecker_1.OpenApiTypeChecker.isReference(input)) {
+	                // REFERENCE TYPE
+	                const key = (_b = input.$ref.split("#/components/schemas/")[1]) !== null && _b !== void 0 ? _b : input.$ref.split("/").at(-1);
+	                const target = (_a = props.components.schemas) === null || _a === void 0 ? void 0 : _a[key];
+	                if (target === undefined)
+	                    return;
+	                else {
+	                    // KEEP THE REFERENCE TYPE
+	                    const out = () => {
+	                        union.push(Object.assign(Object.assign({}, input), { $ref: `#/$defs/${key}` }));
+	                    };
+	                    if (props.$defs[key] !== undefined)
+	                        return out();
+	                    props.$defs[key] = {};
+	                    const converted = transform({
+	                        config: props.config,
+	                        components: props.components,
+	                        $defs: props.$defs,
+	                        schema: target,
+	                        refAccessor: props.refAccessor,
+	                        accessor: `${(_c = props.refAccessor) !== null && _c !== void 0 ? _c : "$def"}[${JSON.stringify(key)}]`,
+	                    });
+	                    if (converted.success === false)
+	                        return; // UNREACHABLE
+	                    props.$defs[key] = converted.value;
+	                    return out();
+	                }
+	            }
+	            else if (OpenApiTypeChecker_1.OpenApiTypeChecker.isObject(input)) {
+	                // OBJECT TYPE
+	                const properties = Object.fromEntries(Object.entries((_d = input.properties) !== null && _d !== void 0 ? _d : {})
+	                    .map(([key, value]) => {
+	                    var _a;
+	                    const converted = transform({
+	                        config: props.config,
+	                        components: props.components,
+	                        $defs: props.$defs,
+	                        schema: value,
+	                        refAccessor: props.refAccessor,
+	                        accessor: `${(_a = props.accessor) !== null && _a !== void 0 ? _a : "$input.schema"}.properties[${JSON.stringify(key)}]`,
+	                    });
+	                    if (converted.success === false) {
+	                        reasons.push(...converted.error.reasons);
+	                        return [key, null];
+	                    }
+	                    return [key, converted.value];
+	                })
+	                    .filter(([, value]) => value !== null));
+	                if (Object.values(properties).some((v) => v === null))
+	                    return;
+	                const additionalProperties = (() => {
+	                    if (typeof input.additionalProperties === "object" &&
+	                        input.additionalProperties !== null) {
+	                        const converted = transform({
+	                            config: props.config,
+	                            components: props.components,
+	                            $defs: props.$defs,
+	                            schema: input.additionalProperties,
+	                            refAccessor: props.refAccessor,
+	                            accessor: `${accessor}.additionalProperties`,
+	                        });
+	                        if (converted.success === false) {
+	                            reasons.push(...converted.error.reasons);
+	                            return null;
+	                        }
+	                        return converted.value;
+	                    }
+	                    return props.config.strict === true
+	                        ? false
+	                        : input.additionalProperties;
+	                })();
+	                if (additionalProperties === null)
+	                    return;
+	                union.push(Object.assign(Object.assign({}, input), { properties,
+	                    additionalProperties, required: (_e = input.required) !== null && _e !== void 0 ? _e : [], description: props.config.strict === true
+	                        ? JsonDescriptor_1.JsonDescriptor.take(input)
+	                        : input.description }));
+	            }
+	            else if (OpenApiTypeChecker_1.OpenApiTypeChecker.isArray(input)) {
+	                // ARRAY TYPE
+	                const items = transform({
+	                    config: props.config,
+	                    components: props.components,
+	                    $defs: props.$defs,
+	                    schema: input.items,
+	                    refAccessor: props.refAccessor,
+	                    accessor: `${accessor}.items`,
+	                });
+	                if (items.success === false) {
+	                    reasons.push(...items.error.reasons);
+	                    return;
+	                }
+	                union.push(props.config.strict === true
+	                    ? OpenApiConstraintShifter_1.OpenApiConstraintShifter.shiftArray(Object.assign(Object.assign({}, input), { items: items.value }))
+	                    : Object.assign(Object.assign({}, input), { items: items.value }));
+	            }
+	            else if (OpenApiTypeChecker_1.OpenApiTypeChecker.isConstant(input)) {
+	                const constant = convertConstant(input);
+	                if (constant !== null)
+	                    union.push(constant);
+	            }
+	            else if (OpenApiTypeChecker_1.OpenApiTypeChecker.isString(input))
+	                union.push(props.config.strict === true
+	                    ? OpenApiConstraintShifter_1.OpenApiConstraintShifter.shiftString(Object.assign({}, input))
+	                    : input);
+	            else if (OpenApiTypeChecker_1.OpenApiTypeChecker.isNumber(input) ||
+	                OpenApiTypeChecker_1.OpenApiTypeChecker.isInteger(input))
+	                union.push(props.config.strict === true
+	                    ? OpenApiConstraintShifter_1.OpenApiConstraintShifter.shiftNumeric(Object.assign({}, input))
+	                    : input);
+	            else if (OpenApiTypeChecker_1.OpenApiTypeChecker.isTuple(input))
+	                return; // UNREACHABLE
+	            else if (OpenApiTypeChecker_1.OpenApiTypeChecker.isConstant(input) === false)
+	                union.push(Object.assign({}, input));
+	        };
+	        visit(props.schema, (_a = props.accessor) !== null && _a !== void 0 ? _a : "$input.schema");
+	        const normalized = normalizeLlmUnion(union);
+	        if (reasons.length > 0)
+	            return {
+	                success: false,
+	                error: {
+	                    method: "LlmSchemaConverter.schema",
+	                    message: "Failed to compose LLM schema",
+	                    reasons,
+	                },
+	            };
+	        else if (normalized.length === 0)
+	            return {
+	                // unknown type
+	                success: true,
+	                value: Object.assign(Object.assign({}, attribute), { type: undefined }),
+	            };
+	        else if (normalized.length === 1)
+	            return {
+	                // single type
+	                success: true,
+	                value: Object.assign(Object.assign(Object.assign({}, attribute), normalized[0]), { description: props.config.strict === true &&
+	                        LlmTypeChecker_1.LlmTypeChecker.isReference(normalized[0])
+	                        ? undefined
+	                        : ((_b = normalized[0].description) !== null && _b !== void 0 ? _b : attribute.description) }),
+	            };
+	        return {
+	            success: true,
+	            value: Object.assign(Object.assign({}, attribute), { anyOf: normalized.map((u) => (Object.assign(Object.assign({}, u), { description: props.config.strict === true && LlmTypeChecker_1.LlmTypeChecker.isReference(u)
+	                        ? undefined
+	                        : u.description }))), "x-discriminator": OpenApiTypeChecker_1.OpenApiTypeChecker.isOneOf(props.schema) &&
+	                    props.schema.discriminator !== undefined &&
+	                    props.schema.oneOf.length === normalized.length &&
+	                    normalized.every((e) => LlmTypeChecker_1.LlmTypeChecker.isReference(e) || LlmTypeChecker_1.LlmTypeChecker.isNull(e))
+	                    ? {
+	                        propertyName: props.schema.discriminator.propertyName,
+	                        mapping: props.schema.discriminator.mapping !== undefined
+	                            ? Object.fromEntries(Object.entries(props.schema.discriminator.mapping).map(([key, value]) => [
+	                                key,
+	                                `#/$defs/${value.split("/").at(-1)}`,
+	                            ]))
+	                            : discriminatorMapping({
+	                                propertyName: props.schema.discriminator.propertyName,
+	                                refs: normalized.filter(LlmTypeChecker_1.LlmTypeChecker.isReference),
+	                                $defs: props.$defs,
+	                            }),
+	                    }
+	                    : undefined }),
+	        };
+	    };
+	    /* -----------------------------------------------------------
+	      INVERTERS
+	    ----------------------------------------------------------- */
+	    /**
+	     * Convert LLM schema back to OpenAPI schema.
+	     *
+	     * Restores constraint information from description tags and converts `$defs`
+	     * references to `#/components/schemas`.
+	     *
+	     * @param props.components Target components (mutated with definitions)
+	     * @param props.schema LLM schema to invert
+	     * @param props.$defs LLM schema definitions
+	     * @returns OpenAPI JSON schema
+	     */
+	    LlmSchemaConverter.invert = (props) => {
+	        const union = [];
+	        const attribute = Object.assign({ title: props.schema.title, description: props.schema.description, deprecated: props.schema.deprecated, readOnly: props.schema.readOnly, writeOnly: props.schema.writeOnly, example: props.schema.example, examples: props.schema.examples }, Object.fromEntries(Object.entries(props.schema).filter(([key, value]) => key.startsWith("x-") && value !== undefined)));
+	        const next = (schema) => LlmSchemaConverter.invert({
+	            components: props.components,
+	            $defs: props.$defs,
+	            schema,
+	        });
+	        const visit = (schema) => {
+	            var _a, _b, _c, _d;
+	            var _e, _f, _g;
+	            var _h;
+	            if (LlmTypeChecker_1.LlmTypeChecker.isArray(schema))
+	                union.push(Object.assign(Object.assign(Object.assign({}, schema), LlmDescriptionInverter_1.LlmDescriptionInverter.array(schema.description)), { items: next(schema.items) }));
+	            else if (LlmTypeChecker_1.LlmTypeChecker.isObject(schema))
+	                union.push(Object.assign(Object.assign({}, schema), { properties: Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [
+	                        key,
+	                        next(value),
+	                    ])), additionalProperties: typeof schema.additionalProperties === "object" &&
+	                        schema.additionalProperties !== null
+	                        ? next(schema.additionalProperties)
+	                        : schema.additionalProperties }));
+	            else if (LlmTypeChecker_1.LlmTypeChecker.isAnyOf(schema))
+	                schema.anyOf.forEach(visit);
+	            else if (LlmTypeChecker_1.LlmTypeChecker.isReference(schema)) {
+	                const key = (_e = schema.$ref.split("#/$defs/")[1]) !== null && _e !== void 0 ? _e : schema.$ref.split("/").at(-1);
+	                if (((_a = props.components.schemas) === null || _a === void 0 ? void 0 : _a[key]) === undefined) {
+	                    (_f = (_h = props.components).schemas) !== null && _f !== void 0 ? _f : (_h.schemas = {});
+	                    props.components.schemas[key] = {};
+	                    props.components.schemas[key] = next((_g = props.$defs[key]) !== null && _g !== void 0 ? _g : {});
+	                }
+	                union.push(Object.assign(Object.assign({}, schema), { $ref: `#/components/schemas/${key}` }));
+	            }
+	            else if (LlmTypeChecker_1.LlmTypeChecker.isBoolean(schema))
+	                if (!!((_b = schema.enum) === null || _b === void 0 ? void 0 : _b.length))
+	                    schema.enum.forEach((v) => union.push({
+	                        const: v,
+	                    }));
+	                else
+	                    union.push(schema);
+	            else if (LlmTypeChecker_1.LlmTypeChecker.isInteger(schema) ||
+	                LlmTypeChecker_1.LlmTypeChecker.isNumber(schema))
+	                if (!!((_c = schema.enum) === null || _c === void 0 ? void 0 : _c.length))
+	                    schema.enum.forEach((v) => union.push({
+	                        const: v,
+	                    }));
+	                else
+	                    union.push(Object.assign(Object.assign(Object.assign({}, schema), LlmDescriptionInverter_1.LlmDescriptionInverter.numeric(schema.description)), { enum: undefined }));
+	            else if (LlmTypeChecker_1.LlmTypeChecker.isString(schema))
+	                if (!!((_d = schema.enum) === null || _d === void 0 ? void 0 : _d.length))
+	                    schema.enum.forEach((v) => union.push({
+	                        const: v,
+	                    }));
+	                else
+	                    union.push(Object.assign(Object.assign(Object.assign({}, schema), LlmDescriptionInverter_1.LlmDescriptionInverter.string(schema.description)), { enum: undefined }));
+	            else
+	                union.push(Object.assign({}, schema));
+	        };
+	        visit(props.schema);
+	        return Object.assign(Object.assign({}, attribute), (union.length === 0
+	            ? { type: undefined }
+	            : union.length === 1
+	                ? Object.assign({}, union[0]) : {
+	                oneOf: union.map((u) => (Object.assign(Object.assign({}, u), { nullable: undefined }))),
+	                discriminator: LlmTypeChecker_1.LlmTypeChecker.isAnyOf(props.schema) &&
+	                    props.schema["x-discriminator"] !== undefined
+	                    ? {
+	                        propertyName: props.schema["x-discriminator"].propertyName,
+	                        mapping: props.schema["x-discriminator"].mapping !== undefined
+	                            ? Object.fromEntries(Object.entries(props.schema["x-discriminator"].mapping).map(([key, value]) => [
+	                                key,
+	                                `#/components/schemas/${value.split("/").at(-1)}`,
+	                            ]))
+	                            : undefined,
+	                    }
+	                    : undefined,
+	            }));
+	    };
+	})(LlmSchemaConverter$1 || (LlmSchemaConverter.LlmSchemaConverter = LlmSchemaConverter$1 = {}));
+	const discriminatorMapping = (props) => {
+	    const entries = props.refs.flatMap((ref) => {
+	        var _a;
+	        const key = (_a = ref.$ref.split("#/$defs/")[1]) !== null && _a !== void 0 ? _a : ref.$ref.split("/").at(-1);
+	        const schema = props.$defs[key];
+	        if (!schema || !LlmTypeChecker_1.LlmTypeChecker.isObject(schema))
+	            return [];
+	        const literals = llmDiscriminatorLiterals(schema.properties[props.propertyName], props.$defs);
+	        return literals.map((literal) => [literal, ref.$ref]);
+	    });
+	    return entries.length !== 0 ? Object.fromEntries(entries) : undefined;
+	};
+	const llmDiscriminatorLiterals = (schema, $defs) => {
+	    var _a, _b;
+	    if (schema === undefined)
+	        return [];
+	    if (LlmTypeChecker_1.LlmTypeChecker.isReference(schema)) {
+	        const key = (_a = schema.$ref.split("#/$defs/")[1]) !== null && _a !== void 0 ? _a : schema.$ref.split("/").at(-1);
+	        return llmDiscriminatorLiterals($defs[key], $defs);
+	    }
+	    if (LlmTypeChecker_1.LlmTypeChecker.isString(schema))
+	        return (_b = schema.enum) !== null && _b !== void 0 ? _b : [];
+	    if (LlmTypeChecker_1.LlmTypeChecker.isAnyOf(schema))
+	        return schema.anyOf.flatMap((child) => llmDiscriminatorLiterals(child, $defs));
+	    return [];
+	};
+	const normalizeLlmUnion = (union) => {
+	    if (union.length <= 1)
+	        return union;
+	    if (union.every(isEnumOnlyString)) {
+	        return [
+	            {
+	                type: "string",
+	                enum: uniqueEnumValues(union.flatMap((schema) => { var _a; return (_a = schema.enum) !== null && _a !== void 0 ? _a : []; })),
+	            },
+	        ];
+	    }
+	    if (union.every(isEnumOnlyBoolean)) {
+	        return [
+	            {
+	                type: "boolean",
+	                enum: uniqueEnumValues(union.flatMap((schema) => { var _a; return (_a = schema.enum) !== null && _a !== void 0 ? _a : []; })),
+	            },
+	        ];
+	    }
+	    if (union.every(isEnumOnlyInteger)) {
+	        return [
+	            {
+	                type: "integer",
+	                enum: uniqueEnumValues(union.flatMap((schema) => { var _a; return (_a = schema.enum) !== null && _a !== void 0 ? _a : []; })),
+	            },
+	        ];
+	    }
+	    if (union.every(isEnumOnlyNumber)) {
+	        return [
+	            {
+	                type: "number",
+	                enum: uniqueEnumValues(union.flatMap((schema) => { var _a; return (_a = schema.enum) !== null && _a !== void 0 ? _a : []; })),
+	            },
+	        ];
+	    }
+	    return union;
+	};
+	const isEnumOnlyString = (schema) => LlmTypeChecker_1.LlmTypeChecker.isString(schema) &&
+	    Array.isArray(schema.enum) &&
+	    schema.enum.length !== 0 &&
+	    primitiveSchemaHasOnlyEnum(schema);
+	const isEnumOnlyBoolean = (schema) => LlmTypeChecker_1.LlmTypeChecker.isBoolean(schema) &&
+	    Array.isArray(schema.enum) &&
+	    schema.enum.length !== 0 &&
+	    primitiveSchemaHasOnlyEnum(schema);
+	const isEnumOnlyInteger = (schema) => LlmTypeChecker_1.LlmTypeChecker.isInteger(schema) &&
+	    Array.isArray(schema.enum) &&
+	    schema.enum.length !== 0 &&
+	    primitiveSchemaHasOnlyEnum(schema);
+	const isEnumOnlyNumber = (schema) => LlmTypeChecker_1.LlmTypeChecker.isNumber(schema) &&
+	    Array.isArray(schema.enum) &&
+	    schema.enum.length !== 0 &&
+	    primitiveSchemaHasOnlyEnum(schema);
+	const primitiveSchemaHasOnlyEnum = (schema) => Object.entries(schema).every(([key, value]) => {
+	    if (value === undefined)
+	        return true;
+	    return key === "type" || key === "enum";
+	});
+	const uniqueEnumValues = (values) => Array.from(new Set(values));
+	const validateStrict = (schema, accessor) => {
+	    var _a;
+	    var _b;
+	    const reasons = [];
+	    if (OpenApiTypeChecker_1.OpenApiTypeChecker.isObject(schema)) {
+	        if (!!schema.additionalProperties)
+	            reasons.push({
+	                schema: schema,
+	                accessor: `${accessor}.additionalProperties`,
+	                message: "LLM does not allow additionalProperties in strict mode, the dynamic key typed object.",
+	            });
+	        for (const key of Object.keys((_b = schema.properties) !== null && _b !== void 0 ? _b : {}))
+	            if (((_a = schema.required) === null || _a === void 0 ? void 0 : _a.includes(key)) === false)
+	                reasons.push({
+	                    schema: schema,
+	                    accessor: `${accessor}.properties.${key}`,
+	                    message: "LLM does not allow optional properties in strict mode.",
+	                });
+	    }
+	    return reasons;
+	};
+	
+	return LlmSchemaConverter;
+}
+
+export { requireLlmSchemaConverter as __require };
+//# sourceMappingURL=LlmSchemaConverter2.mjs.map