@typia/utils 13.0.0-dev.20260427-2 → 13.0.0-dev.20260430

package/lib/utils/internal/coerceLlmArguments2.mjs

@@ -1,262 +1,282 @@
-import { __exports as coerceLlmArguments } from '../../_virtual/coerceLlmArguments.mjs';
-import { __require as requireLlmTypeChecker } from '../../validators/LlmTypeChecker2.mjs';
-import { __require as requireParseLenientJson } from './parseLenientJson2.mjs';
+import { __exports as coerceLlmArguments$1 } from '../../_virtual/coerceLlmArguments.mjs';
+import '../../validators/LlmTypeChecker2.mjs';
+import './parseLenientJson2.mjs';
+import { __exports as LlmTypeChecker } from '../../_virtual/LlmTypeChecker.mjs';
+import { __exports as parseLenientJson } from '../../_virtual/parseLenientJson.mjs';
 
-var hasRequiredCoerceLlmArguments;
-
-function requireCoerceLlmArguments () {
-	if (hasRequiredCoerceLlmArguments) return coerceLlmArguments;
-	hasRequiredCoerceLlmArguments = 1;
-	Object.defineProperty(coerceLlmArguments, "__esModule", { value: true });
-	coerceLlmArguments.coerceLlmArguments = coerceLlmArguments$1;
-	const LlmTypeChecker_1 = requireLlmTypeChecker();
-	const parseLenientJson_1 = requireParseLenientJson();
-	/**
-	 * Coerce LLM arguments by parsing double-stringified JSON values.
-	 *
-	 * When LLM produces stringified JSON for non-string schema types, this function
-	 * attempts to parse them using the lenient JSON parser.
-	 *
-	 * Only applies coercion when value is string but schema expects non-string.
-	 * Type validation is handled separately by `ILlmFunction.validate`.
-	 *
-	 * @param value Parsed JSON value (potentially with stringified nested values)
-	 * @param parameters LLM parameters schema
-	 * @returns Coerced value with double-stringified JSON parsed
-	 * @internal
-	 */
-	function coerceLlmArguments$1(value, parameters) {
-	    return coerceValue(value, parameters, parameters.$defs);
-	}
-	function coerceValue(value, schema, $defs) {
-	    // Resolve reference
-	    if (LlmTypeChecker_1.LlmTypeChecker.isReference(schema)) {
-	        const key = schema.$ref.replace("#/$defs/", "");
-	        const resolved = $defs === null || $defs === void 0 ? void 0 : $defs[key];
-	        if (resolved !== undefined) {
-	            return coerceValue(value, resolved, $defs);
-	        }
-	        return value;
-	    }
-	    // Handle anyOf
-	    if (LlmTypeChecker_1.LlmTypeChecker.isAnyOf(schema)) {
-	        // Value is string
-	        if (typeof value === "string") {
-	            // If string is in union, don't parse - it's valid as-is
-	            const hasString = schema.anyOf.some((s) => LlmTypeChecker_1.LlmTypeChecker.isString(resolveSchema(s, $defs)));
-	            if (hasString) {
-	                return value;
-	            }
-	            // String value but no string in union - try to parse
-	            const parsed = (0, parseLenientJson_1.parseLenientJson)(value);
-	            if (parsed.success) {
-	                // Find uniquely matching schema via type + x-discriminator
-	                const matched = findMatchingAnyOfSchema(parsed.data, schema, $defs);
-	                if (matched !== undefined) {
-	                    return coerceValue(parsed.data, matched, $defs);
-	                }
-	                return parsed.data;
-	            }
-	            // JSON parse failed - try "n" -> false or null
-	            if (value.length === 1 && value.toLowerCase() === "n") {
-	                const hasBoolean = schema.anyOf.some((s) => LlmTypeChecker_1.LlmTypeChecker.isBoolean(resolveSchema(s, $defs)));
-	                const hasNull = schema.anyOf.some((s) => LlmTypeChecker_1.LlmTypeChecker.isNull(resolveSchema(s, $defs)));
-	                if (hasBoolean && !hasNull)
-	                    return false;
-	                else if (hasNull && !hasBoolean)
-	                    return null;
-	                return value;
-	            }
-	        }
-	        // Value is object - find matching schema via discriminated union
-	        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-	            const matched = findMatchingObjectInAnyOf(value, schema, $defs);
-	            if (matched !== undefined) {
-	                return coerceValue(value, matched, $defs);
-	            }
-	            return value;
-	        }
-	        // Value is array - find matching array schema (only if unambiguous)
-	        if (Array.isArray(value)) {
-	            const arraySchemas = schema.anyOf.filter((s) => LlmTypeChecker_1.LlmTypeChecker.isArray(resolveSchema(s, $defs)));
-	            if (arraySchemas.length === 1) {
-	                return coerceValue(value, arraySchemas[0], $defs);
-	            }
-	            // Multiple or no array schemas - skip coercion
-	            return value;
-	        }
-	        // Non-string primitive or no matching schema - return as-is
-	        return value;
-	    }
-	    // String schema - no coercion needed (value stays as-is)
-	    if (LlmTypeChecker_1.LlmTypeChecker.isString(schema)) {
-	        return value;
-	    }
-	    // Unknown schema - no coercion needed
-	    if (LlmTypeChecker_1.LlmTypeChecker.isUnknown(schema)) {
-	        return value;
-	    }
-	    // Value is string but schema is non-string - try to parse
-	    if (typeof value === "string") {
-	        const parsed = (0, parseLenientJson_1.parseLenientJson)(value);
-	        if (parsed.success) {
-	            // Continue coercion on the parsed value (for nested stringified values)
-	            return coerceValue(parsed.data, schema, $defs);
-	        }
-	        // JSON parse failed - try "n" -> false for boolean schema
-	        if (value.length === 1 && value.toLowerCase() === "n") {
-	            if (LlmTypeChecker_1.LlmTypeChecker.isNull(schema))
-	                return null;
-	            if (LlmTypeChecker_1.LlmTypeChecker.isBoolean(schema))
-	                return false;
-	        }
-	        // Parse failed, return original - validate will catch type error
-	        return value;
-	    }
-	    // Value is array and schema is array - recurse into items
-	    if (Array.isArray(value) && LlmTypeChecker_1.LlmTypeChecker.isArray(schema)) {
-	        return value.map((item) => coerceValue(item, schema.items, $defs));
-	    }
-	    // Value is object and schema is object - recurse into properties
-	    if (typeof value === "object" &&
-	        value !== null &&
-	        !Array.isArray(value) &&
-	        LlmTypeChecker_1.LlmTypeChecker.isObject(schema)) {
-	        return coerceObject(value, schema, $defs);
-	    }
-	    // Everything else (null, boolean, number, integer) - return as-is
-	    return value;
-	}
-	function coerceObject(value, schema, $defs) {
-	    const result = {};
-	    // Coerce known properties
-	    for (const [key, propSchema] of Object.entries(schema.properties)) {
-	        if (key in value) {
-	            result[key] = coerceValue(value[key], propSchema, $defs);
-	        }
-	    }
-	    // Preserve additional properties - let validation handle rejection
-	    const additionalSchema = typeof schema.additionalProperties === "object"
-	        ? schema.additionalProperties
-	        : undefined;
-	    for (const key of Object.keys(value)) {
-	        if (!(key in schema.properties)) {
-	            result[key] = additionalSchema
-	                ? coerceValue(value[key], additionalSchema, $defs)
-	                : value[key];
-	        }
-	    }
-	    return result;
-	}
-	function resolveSchema(schema, $defs) {
-	    if (LlmTypeChecker_1.LlmTypeChecker.isReference(schema)) {
-	        const key = schema.$ref.replace("#/$defs/", "");
-	        const resolved = $defs === null || $defs === void 0 ? void 0 : $defs[key];
-	        if (resolved !== undefined) {
-	            return resolveSchema(resolved, $defs);
-	        }
-	    }
-	    return schema;
-	}
-	/**
-	 * Check if value roughly matches the expected schema type. Used for anyOf
-	 * matching after parsing.
-	 */
-	function matchesSchemaType(value, schema, $defs) {
-	    if (LlmTypeChecker_1.LlmTypeChecker.isReference(schema)) {
-	        const key = schema.$ref.replace("#/$defs/", "");
-	        const resolved = $defs === null || $defs === void 0 ? void 0 : $defs[key];
-	        if (resolved)
-	            return matchesSchemaType(value, resolved, $defs);
-	        return false;
-	    }
-	    if (LlmTypeChecker_1.LlmTypeChecker.isNull(schema))
-	        return value === null;
-	    if (LlmTypeChecker_1.LlmTypeChecker.isBoolean(schema))
-	        return typeof value === "boolean";
-	    if (LlmTypeChecker_1.LlmTypeChecker.isInteger(schema))
-	        return typeof value === "number" && Number.isInteger(value);
-	    if (LlmTypeChecker_1.LlmTypeChecker.isNumber(schema))
-	        return typeof value === "number";
-	    if (LlmTypeChecker_1.LlmTypeChecker.isString(schema))
-	        return typeof value === "string";
-	    if (LlmTypeChecker_1.LlmTypeChecker.isArray(schema))
-	        return Array.isArray(value);
-	    if (LlmTypeChecker_1.LlmTypeChecker.isObject(schema))
-	        return typeof value === "object" && value !== null && !Array.isArray(value);
-	    if (LlmTypeChecker_1.LlmTypeChecker.isUnknown(schema))
-	        return true;
-	    if (LlmTypeChecker_1.LlmTypeChecker.isAnyOf(schema))
-	        return schema.anyOf.some((s) => matchesSchemaType(value, s, $defs));
-	    return false;
-	}
-	/**
-	 * Find the uniquely matching schema for a value among anyOf alternatives. Uses
-	 * `x-discriminator` for object disambiguation. Returns undefined if no unique
-	 * match can be determined.
-	 */
-	function findMatchingAnyOfSchema(value, schema, $defs) {
-	    const matching = schema.anyOf.filter((s) => matchesSchemaType(value, s, $defs));
-	    if (matching.length === 1)
-	        return matching[0];
-	    if (matching.length === 0)
-	        return undefined;
-	    // Multiple type matches - try x-discriminator for objects
-	    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-	        return findMatchingObjectInAnyOf(value, schema, $defs);
-	    }
-	    return undefined;
-	}
-	/**
-	 * Find the matching object schema among anyOf using `x-discriminator`. If only
-	 * one object schema exists, returns it directly. If multiple exist but no
-	 * x-discriminator, gives up.
-	 */
-	function findMatchingObjectInAnyOf(value, schema, $defs) {
-	    var _a, _b;
-	    const objectSchemas = schema.anyOf.filter((s) => LlmTypeChecker_1.LlmTypeChecker.isObject(resolveSchema(s, $defs)));
-	    if (objectSchemas.length === 0)
-	        return undefined;
-	    if (objectSchemas.length === 1)
-	        return objectSchemas[0];
-	    // Multiple object schemas - require x-discriminator
-	    const discriminator = schema["x-discriminator"];
-	    if (discriminator === undefined)
-	        return undefined;
-	    const key = discriminator.propertyName;
-	    const discriminatorValue = value[key];
-	    // Use mapping for direct $ref lookup
-	    if (discriminator.mapping !== undefined &&
-	        typeof discriminatorValue === "string") {
-	        const ref = discriminator.mapping[discriminatorValue];
-	        if (ref !== undefined) {
-	            for (const s of schema.anyOf) {
-	                if (LlmTypeChecker_1.LlmTypeChecker.isReference(s) && s.$ref === ref) {
-	                    return s;
-	                }
-	            }
-	        }
-	        return undefined;
-	    }
-	    // No mapping - match by enum values on the discriminator property
-	    for (const s of objectSchemas) {
-	        const resolved = resolveSchema(s, $defs);
-	        if (!LlmTypeChecker_1.LlmTypeChecker.isObject(resolved))
-	            continue;
-	        const propSchema = (_a = resolved.properties) === null || _a === void 0 ? void 0 : _a[key];
-	        if (propSchema === undefined)
-	            continue;
-	        const resolvedProp = resolveSchema(propSchema, $defs);
-	        if (LlmTypeChecker_1.LlmTypeChecker.isString(resolvedProp) &&
-	            ((_b = resolvedProp.enum) === null || _b === void 0 ? void 0 : _b.includes(discriminatorValue))) {
-	            return s;
-	        }
-	    }
-	    return undefined;
-	}
-	
-	return coerceLlmArguments;
+Object.defineProperty(coerceLlmArguments$1, "__esModule", { value: true });
+var coerceLlmArguments_2 = coerceLlmArguments$1.coerceLlmArguments = coerceLlmArguments;
+const LlmTypeChecker_1 = LlmTypeChecker;
+const parseLenientJson_1 = parseLenientJson;
+/**
+ * Coerce LLM arguments by parsing double-stringified JSON values.
+ *
+ * When LLM produces stringified JSON for non-string schema types, this function
+ * attempts to parse them using the lenient JSON parser.
+ *
+ * Only applies coercion when value is string but schema expects non-string.
+ * Type validation is handled separately by `ILlmFunction.validate`.
+ *
+ * @param value Parsed JSON value (potentially with stringified nested values)
+ * @param parameters LLM parameters schema
+ * @returns Coerced value with double-stringified JSON parsed
+ * @internal
+ */
+function coerceLlmArguments(value, parameters) {
+    return coerceValue(value, parameters, parameters.$defs);
+}
+function coerceValue(value, schema, $defs) {
+    // Resolve reference
+    if (LlmTypeChecker_1.LlmTypeChecker.isReference(schema)) {
+        const key = schema.$ref.replace("#/$defs/", "");
+        const resolved = $defs === null || $defs === void 0 ? void 0 : $defs[key];
+        if (resolved !== undefined) {
+            return coerceValue(value, resolved, $defs);
+        }
+        return value;
+    }
+    // Handle anyOf
+    if (LlmTypeChecker_1.LlmTypeChecker.isAnyOf(schema)) {
+        // Value is string
+        if (typeof value === "string") {
+            // If string is in union, don't parse - it's valid as-is
+            const hasString = schema.anyOf.some((s) => LlmTypeChecker_1.LlmTypeChecker.isString(resolveSchema(s, $defs)));
+            if (hasString) {
+                return value;
+            }
+            // String value but no string in union - try to parse
+            const parsed = (0, parseLenientJson_1.parseLenientJson)(value);
+            if (parsed.success) {
+                // Find uniquely matching schema via type + x-discriminator
+                const matched = findMatchingAnyOfSchema(parsed.data, schema, $defs);
+                if (matched !== undefined) {
+                    return coerceValue(parsed.data, matched, $defs);
+                }
+                return parsed.data;
+            }
+            // JSON parse failed - try "n" -> false or null
+            if (value.length === 1 && value.toLowerCase() === "n") {
+                const hasBoolean = schema.anyOf.some((s) => LlmTypeChecker_1.LlmTypeChecker.isBoolean(resolveSchema(s, $defs)));
+                const hasNull = schema.anyOf.some((s) => LlmTypeChecker_1.LlmTypeChecker.isNull(resolveSchema(s, $defs)));
+                if (hasBoolean && !hasNull)
+                    return false;
+                else if (hasNull && !hasBoolean)
+                    return null;
+                return value;
+            }
+        }
+        // Value is object - find matching schema via discriminated union
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            const matched = findMatchingObjectInAnyOf(value, schema, $defs);
+            if (matched !== undefined) {
+                return coerceValue(value, matched, $defs);
+            }
+            return value;
+        }
+        // Value is array - find matching array schema (only if unambiguous)
+        if (Array.isArray(value)) {
+            const arraySchemas = schema.anyOf.filter((s) => LlmTypeChecker_1.LlmTypeChecker.isArray(resolveSchema(s, $defs)));
+            if (arraySchemas.length === 1) {
+                return coerceValue(value, arraySchemas[0], $defs);
+            }
+            // Multiple or no array schemas - skip coercion
+            return value;
+        }
+        // Non-string primitive or no matching schema - return as-is
+        return value;
+    }
+    // String schema - no coercion needed (value stays as-is)
+    if (LlmTypeChecker_1.LlmTypeChecker.isString(schema)) {
+        return value;
+    }
+    // Unknown schema - no coercion needed
+    if (LlmTypeChecker_1.LlmTypeChecker.isUnknown(schema)) {
+        return value;
+    }
+    // Value is string but schema is non-string - try to parse
+    if (typeof value === "string") {
+        const parsed = (0, parseLenientJson_1.parseLenientJson)(value);
+        if (parsed.success) {
+            // Continue coercion on the parsed value (for nested stringified values)
+            return coerceValue(parsed.data, schema, $defs);
+        }
+        // JSON parse failed - try "n" -> false for boolean schema
+        if (value.length === 1 && value.toLowerCase() === "n") {
+            if (LlmTypeChecker_1.LlmTypeChecker.isNull(schema))
+                return null;
+            if (LlmTypeChecker_1.LlmTypeChecker.isBoolean(schema))
+                return false;
+        }
+        // Parse failed, return original - validate will catch type error
+        return value;
+    }
+    // Value is array and schema is array - recurse into items
+    if (Array.isArray(value) && LlmTypeChecker_1.LlmTypeChecker.isArray(schema)) {
+        return value.map((item) => coerceValue(item, schema.items, $defs));
+    }
+    // Value is object and schema is object - recurse into properties
+    if (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        LlmTypeChecker_1.LlmTypeChecker.isObject(schema)) {
+        return coerceObject(value, schema, $defs);
+    }
+    // Everything else (null, boolean, number, integer) - return as-is
+    return value;
+}
+function coerceObject(value, schema, $defs) {
+    const result = {};
+    // Coerce known properties
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (key in value) {
+            result[key] = coerceValue(value[key], propSchema, $defs);
+        }
+    }
+    // Preserve additional properties - let validation handle rejection
+    const additionalSchema = typeof schema.additionalProperties === "object"
+        ? schema.additionalProperties
+        : undefined;
+    for (const key of Object.keys(value)) {
+        if (!(key in schema.properties)) {
+            result[key] = additionalSchema
+                ? coerceValue(value[key], additionalSchema, $defs)
+                : coerceLoose(value[key]);
+        }
+    }
+    return result;
+}
+function coerceLoose(value) {
+    if (typeof value === "string") {
+        const parsed = (0, parseLenientJson_1.parseLenientJson)(value);
+        if (parsed.success)
+            return coerceLoose(parsed.data);
+        if (value === "true")
+            return true;
+        if (value === "false")
+            return false;
+        if (/^-?\d+(?:\.\d+)?$/.test(value))
+            return Number(value);
+        return value;
+    }
+    if (Array.isArray(value))
+        return value.map(coerceLoose);
+    if (value !== null && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([key, val]) => [
+            key,
+            coerceLoose(val),
+        ]));
+    return value;
+}
+function resolveSchema(schema, $defs) {
+    if (LlmTypeChecker_1.LlmTypeChecker.isReference(schema)) {
+        const key = schema.$ref.replace("#/$defs/", "");
+        const resolved = $defs === null || $defs === void 0 ? void 0 : $defs[key];
+        if (resolved !== undefined) {
+            return resolveSchema(resolved, $defs);
+        }
+    }
+    return schema;
+}
+/**
+ * Check if value roughly matches the expected schema type. Used for anyOf
+ * matching after parsing.
+ */
+function matchesSchemaType(value, schema, $defs) {
+    if (LlmTypeChecker_1.LlmTypeChecker.isReference(schema)) {
+        const key = schema.$ref.replace("#/$defs/", "");
+        const resolved = $defs === null || $defs === void 0 ? void 0 : $defs[key];
+        if (resolved)
+            return matchesSchemaType(value, resolved, $defs);
+        return false;
+    }
+    if (LlmTypeChecker_1.LlmTypeChecker.isNull(schema))
+        return value === null;
+    if (LlmTypeChecker_1.LlmTypeChecker.isBoolean(schema))
+        return typeof value === "boolean";
+    if (LlmTypeChecker_1.LlmTypeChecker.isInteger(schema))
+        return typeof value === "number" && Number.isInteger(value);
+    if (LlmTypeChecker_1.LlmTypeChecker.isNumber(schema))
+        return typeof value === "number";
+    if (LlmTypeChecker_1.LlmTypeChecker.isString(schema))
+        return typeof value === "string";
+    if (LlmTypeChecker_1.LlmTypeChecker.isArray(schema))
+        return Array.isArray(value);
+    if (LlmTypeChecker_1.LlmTypeChecker.isObject(schema))
+        return typeof value === "object" && value !== null && !Array.isArray(value);
+    if (LlmTypeChecker_1.LlmTypeChecker.isUnknown(schema))
+        return true;
+    if (LlmTypeChecker_1.LlmTypeChecker.isAnyOf(schema))
+        return schema.anyOf.some((s) => matchesSchemaType(value, s, $defs));
+    return false;
+}
+/**
+ * Find the uniquely matching schema for a value among anyOf alternatives. Uses
+ * `x-discriminator` for object disambiguation. Returns undefined if no unique
+ * match can be determined.
+ */
+function findMatchingAnyOfSchema(value, schema, $defs) {
+    const matching = schema.anyOf.filter((s) => matchesSchemaType(value, s, $defs));
+    if (matching.length === 1)
+        return matching[0];
+    if (matching.length === 0)
+        return undefined;
+    // Multiple type matches - try x-discriminator for objects
+    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        return findMatchingObjectInAnyOf(value, schema, $defs);
+    }
+    return undefined;
+}
+/**
+ * Find the matching object schema among anyOf using `x-discriminator`. If only
+ * one object schema exists, returns it directly. If multiple exist but no
+ * x-discriminator, gives up.
+ */
+function findMatchingObjectInAnyOf(value, schema, $defs) {
+    var _a, _b;
+    const objectSchemas = schema.anyOf.filter((s) => LlmTypeChecker_1.LlmTypeChecker.isObject(resolveSchema(s, $defs)));
+    if (objectSchemas.length === 0)
+        return undefined;
+    if (objectSchemas.length === 1)
+        return objectSchemas[0];
+    // Multiple object schemas - require x-discriminator
+    const discriminator = schema["x-discriminator"];
+    if (discriminator === undefined)
+        return undefined;
+    const key = discriminator.propertyName;
+    const discriminatorValue = value[key];
+    // Use mapping for direct $ref lookup
+    if (discriminator.mapping !== undefined &&
+        typeof discriminatorValue === "string") {
+        const ref = discriminator.mapping[discriminatorValue];
+        if (ref !== undefined) {
+            for (const s of schema.anyOf) {
+                if (LlmTypeChecker_1.LlmTypeChecker.isReference(s) && s.$ref === ref) {
+                    return s;
+                }
+            }
+        }
+        return undefined;
+    }
+    // No mapping - match by enum values on the discriminator property
+    for (const s of objectSchemas) {
+        const resolved = resolveSchema(s, $defs);
+        if (!LlmTypeChecker_1.LlmTypeChecker.isObject(resolved))
+            continue;
+        const propSchema = (_a = resolved.properties) === null || _a === void 0 ? void 0 : _a[key];
+        if (propSchema === undefined)
+            continue;
+        const resolvedProp = resolveSchema(propSchema, $defs);
+        if ("const" in resolvedProp &&
+            resolvedProp.const === discriminatorValue) {
+            return s;
+        }
+        if (LlmTypeChecker_1.LlmTypeChecker.isString(resolvedProp) &&
+            ((_b = resolvedProp.enum) === null || _b === void 0 ? void 0 : _b.includes(discriminatorValue))) {
+            return s;
+        }
+    }
+    return undefined;
 }
 
-export { requireCoerceLlmArguments as __require };
+export { coerceLlmArguments_2 as coerceLlmArguments, coerceLlmArguments$1 as default };
 //# sourceMappingURL=coerceLlmArguments2.mjs.map