@cartanova/qgrid-cli 2.5.3 → 2.5.5

package/bundle/dist/utils/providers/common/strictifier.js

@@ -1,4 +1,14 @@
+import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, UNSUPPORTED_REFERENCE_KEYWORDS } from "./json-schema-keywords.js";
 //#region src/utils/providers/common/strictifier.ts
+/**
+* JSON Schema → OpenAI strict JSON Schema 변환.
+*
+* OpenAI Responses API strict 모드 요구사항:
+*  - 모든 object 에 additionalProperties: false
+*  - 모든 object properties 를 required 에 포함
+*  - optional 필드 → anyOf [original, { type: 'null' }] 로 required 유지
+*  - recursive 처리 (nested objects, arrays, allOf/anyOf/oneOf)
+*/
 var StrictifierError = class extends Error {
 	path;
 	constructor(message, path) {
@@ -7,44 +17,245 @@ var StrictifierError = class extends Error {
 		this.name = "StrictifierError";
 	}
 };
-function strictify(schema) {
-	return strictifyNode(schema, "$");
+function strictify(schema, options = {}) {
+	if (options.provider === "openai" || options.provider === "anthropic") assertNormalizationCompatibility(schema, options.provider);
+	const result = strictifyNode(schema, "$", options.provider);
+	if (options.provider === "openai" || options.provider === "anthropic") assertNormalizationCompatibility(result, options.provider);
+	return result;
 }
-function strictifyNode(node, path) {
+/**
+* 위치 목록은 json-schema-keywords 가 소유하고, 여기서는 각 위치의 `normalizable` 여부만 얹는다.
+* normalizable=true 는 strictifyNode 가 그 위치를 실제로 재작성한다는 뜻이다. `not`/`if` 처럼
+* 재작성하면 caller 의미가 바뀌는 위치는 false 이고, 그 아래 tuple/`$ref` 는 정규화 대신 거부된다.
+*
+* `items`/`additionalItems` 는 tuple 판정과 함께 다뤄야 해서 아래 순회에서 개별 처리한다.
+*/
+const NON_NORMALIZABLE_POSITIONS = /* @__PURE__ */ new Set([
+	"dependentSchemas",
+	"patternProperties",
+	"additionalProperties",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+]);
+function positionEntries(keywords) {
+	return keywords.map((keyword) => [keyword, !NON_NORMALIZABLE_POSITIONS.has(keyword)]);
+}
+const SCHEMA_SCAN_MAP_KEYWORDS = positionEntries(SCHEMA_MAP_KEYWORDS);
+const SCHEMA_SCAN_ARRAY_KEYWORDS = positionEntries(SCHEMA_ARRAY_KEYWORDS);
+const SCHEMA_SCAN_SINGLE_KEYWORDS = positionEntries(SCHEMA_SINGLE_KEYWORDS.filter((keyword) => keyword !== "items" && keyword !== "additionalItems"));
+/**
+* Inspect every JSON Schema-bearing position without rewriting it.
+*
+* Positive positions already traversed by strictifyNode may normalize OpenAI tuples. Positions
+* such as `not` and `if` cannot be tightened without changing caller semantics, so positional
+* tuples there fail explicitly instead of leaking an unsupported provider schema. References
+* from those positions also fail because their definitions are normalized globally.
+*/
+function assertNormalizationCompatibility(schema, provider) {
+	const references = [];
+	const stack = [{
+		node: schema,
+		path: "$",
+		normalizable: true
+	}];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		const itemsValue = ownValue(current.node, "items");
+		const prefixItemsValue = ownValue(current.node, "prefixItems");
+		const legacyTuple = Array.isArray(itemsValue);
+		const prefixTuple = Array.isArray(prefixItemsValue);
+		assertUnsupportedReferenceKeywords(current.node, current.path);
+		collectSchemaReference(current, references);
+		if (legacyTuple || prefixTuple) {
+			if (provider === "anthropic" && (legacyTuple ? itemsValue : prefixItemsValue).length > 0) throw new StrictifierError("positional tuple schemas are not supported on Anthropic because Claude Code cannot preserve item positions", current.path);
+			if (!current.normalizable) throw new StrictifierError("positional tuple schemas are not supported in this schema position", current.path);
+			if (ownValue(current.node, "type") !== "array") throw new StrictifierError("positional tuple schemas must declare type \"array\"; express nullable tuples with anyOf", `${current.path}.type`);
+		}
+		for (const [keyword, keywordNormalizable] of SCHEMA_SCAN_MAP_KEYWORDS) {
+			const schemas = ownValue(current.node, keyword);
+			if (!isSchemaObject(schemas)) continue;
+			for (const [name, child] of Object.entries(schemas)) {
+				if (!isSchemaObject(child)) continue;
+				stack.push({
+					node: child,
+					path: `${current.path}.${keyword}.${name}`,
+					normalizable: current.normalizable && keywordNormalizable
+				});
+			}
+		}
+		const dependencies = ownValue(current.node, "dependencies");
+		if (isSchemaObject(dependencies)) for (const [name, child] of Object.entries(dependencies)) {
+			if (!isSchemaObject(child)) continue;
+			stack.push({
+				node: child,
+				path: `${current.path}.dependencies.${name}`,
+				normalizable: false
+			});
+		}
+		for (const [keyword, keywordNormalizable] of SCHEMA_SCAN_ARRAY_KEYWORDS) {
+			const schemas = ownValue(current.node, keyword);
+			if (!Array.isArray(schemas)) continue;
+			for (let index = 0; index < schemas.length; index += 1) {
+				const child = schemas[index];
+				if (!isSchemaObject(child)) continue;
+				stack.push({
+					node: child,
+					path: `${current.path}.${keyword}[${index}]`,
+					normalizable: current.normalizable && keywordNormalizable
+				});
+			}
+		}
+		const items = ownValue(current.node, "items");
+		if (isSchemaObject(items)) stack.push({
+			node: items,
+			path: `${current.path}.items`,
+			normalizable: current.normalizable
+		});
+		else if (Array.isArray(items)) for (let index = 0; index < items.length; index += 1) {
+			const child = items[index];
+			if (!isSchemaObject(child)) continue;
+			stack.push({
+				node: child,
+				path: `${current.path}.items[${index}]`,
+				normalizable: current.normalizable
+			});
+		}
+		const additionalItems = ownValue(current.node, "additionalItems");
+		if (isSchemaObject(additionalItems)) stack.push({
+			node: additionalItems,
+			path: `${current.path}.additionalItems`,
+			normalizable: current.normalizable && legacyTuple
+		});
+		for (const [keyword, keywordNormalizable] of SCHEMA_SCAN_SINGLE_KEYWORDS) {
+			const child = ownValue(current.node, keyword);
+			if (!isSchemaObject(child)) continue;
+			stack.push({
+				node: child,
+				path: `${current.path}.${keyword}`,
+				normalizable: current.normalizable && keywordNormalizable
+			});
+		}
+	}
+	assertReferenceTargets(schema, references);
+}
+function assertUnsupportedReferenceKeywords(schema, path) {
+	for (const keyword of UNSUPPORTED_REFERENCE_KEYWORDS) if (Object.hasOwn(schema, keyword)) throw new StrictifierError(`${keyword} is not supported`, `${path}.${keyword}`);
+}
+function collectSchemaReference(current, references) {
+	if (!Object.hasOwn(current.node, "$ref")) return;
+	const reference = current.node.$ref;
+	if (typeof reference !== "string") throw new StrictifierError("$ref must be a string", `${current.path}.$ref`);
+	if (!current.normalizable) throw new StrictifierError("schema references are not supported in this schema position", current.path);
+	references.push({
+		value: reference,
+		path: `${current.path}.$ref`
+	});
+}
+function assertReferenceTargets(root, references) {
+	for (const reference of references) {
+		const tokens = parseLocalJsonPointer(reference.value, reference.path);
+		if (!isDefinitionRootPointer(tokens)) throw new StrictifierError("$ref target must be the document root or a definition root", reference.path);
+		resolveDefinitionRoot(root, tokens, reference.path);
+	}
+}
+function isDefinitionRootPointer(tokens) {
+	if (tokens.length === 0) return true;
+	if (tokens.length % 2 !== 0) return false;
+	for (let index = 0; index < tokens.length; index += 2) if (tokens[index] !== "$defs" && tokens[index] !== "definitions") return false;
+	return true;
+}
+function parseLocalJsonPointer(reference, path) {
+	if (reference === "#") return [];
+	if (!reference.startsWith("#/")) throw new StrictifierError("only local root-relative JSON Pointer $ref values are supported", path);
+	let fragment;
+	try {
+		fragment = decodeURIComponent(reference.slice(1));
+	} catch {
+		throw new StrictifierError("$ref contains invalid percent encoding", path);
+	}
+	if (!fragment.startsWith("/")) throw new StrictifierError("only local root-relative JSON Pointer $ref values are supported", path);
+	return fragment.slice(1).split("/").map((token) => decodeJsonPointerToken(token, path));
+}
+function resolveDefinitionRoot(root, tokens, path) {
+	let current = root;
+	for (let index = 0; index < tokens.length; index += 2) {
+		const keyword = tokens[index];
+		const name = tokens[index + 1];
+		const definitions = ownValue(current, keyword);
+		if (!isSchemaObject(definitions) || !Object.hasOwn(definitions, name)) throw new StrictifierError("$ref does not resolve inside the caller schema", path);
+		const target = definitions[name];
+		if (!isSchemaObject(target)) throw new StrictifierError("$ref target must be an object schema", path);
+		current = target;
+	}
+}
+function decodeJsonPointerToken(rawToken, path) {
+	let token = "";
+	for (let index = 0; index < rawToken.length; index += 1) {
+		const character = rawToken[index];
+		if (character !== "~") {
+			token += character;
+			continue;
+		}
+		const escaped = rawToken[index + 1];
+		if (escaped === "0") token += "~";
+		else if (escaped === "1") token += "/";
+		else throw new StrictifierError("$ref contains an invalid JSON Pointer escape", path);
+		index += 1;
+	}
+	return token;
+}
+function strictifyNode(node, path, provider) {
 	if (typeof node !== "object" || node === null) return node;
-	const type = node.type;
-	if (type === "object" || node.properties) return strictifyObject(node, path);
-	if (type === "array") return strictifyArray(node, path);
-	if (node.anyOf) return {
-		...node,
-		anyOf: node.anyOf.map((s, i) => strictifyNode(s, `${path}.anyOf[${i}]`))
-	};
-	if (node.oneOf) return {
-		...node,
-		oneOf: node.oneOf.map((s, i) => strictifyNode(s, `${path}.oneOf[${i}]`))
-	};
-	if (node.allOf) return {
-		...node,
-		allOf: node.allOf.map((s, i) => strictifyNode(s, `${path}.allOf[${i}]`))
-	};
-	if (node.$ref) return { ...node };
-	return { ...node };
+	let result = strictifySchemaMaps(provider === "openai" ? omitKeys(node, ["$schema"]) : node, path, provider);
+	const type = ownValue(result, "type");
+	if (type === "object" || Object.hasOwn(result, "properties")) result = strictifyObject(result, path, provider);
+	if (type === "array" || Object.hasOwn(result, "items") || Object.hasOwn(result, "prefixItems")) result = strictifyArray(result, path, provider);
+	return strictifySchemaArrays(result, path, provider);
 }
-function strictifyObject(node, path) {
-	const properties = node.properties;
+const DEFINITION_MAP_KEYWORDS = ["$defs", "definitions"];
+function strictifySchemaMaps(node, path, provider) {
+	const result = { ...node };
+	for (const keyword of DEFINITION_MAP_KEYWORDS) {
+		const schemas = ownValue(node, keyword);
+		if (!isSchemaObject(schemas)) continue;
+		result[keyword] = Object.fromEntries(Object.entries(schemas).map(([name, schema]) => [name, isSchemaObject(schema) ? strictifyNode(schema, `${path}.${keyword}.${name}`, provider) : schema]));
+	}
+	return result;
+}
+const COMBINATOR_KEYWORDS = [
+	"anyOf",
+	"oneOf",
+	"allOf"
+];
+function strictifySchemaArrays(node, path, provider) {
+	const result = { ...node };
+	for (const keyword of COMBINATOR_KEYWORDS) {
+		const schemas = ownValue(node, keyword);
+		if (!schemas) continue;
+		result[keyword] = schemas.map((schema, index) => strictifyNode(schema, `${path}.${keyword}[${index}]`, provider));
+	}
+	return result;
+}
+function strictifyObject(node, path, provider) {
+	const properties = ownValue(node, "properties");
 	if (!properties) return {
 		...node,
 		additionalProperties: false
 	};
-	const existingRequired = new Set(node.required ?? []);
+	const existingRequired = new Set(ownValue(node, "required") ?? []);
 	const allKeys = Object.keys(properties);
-	const strictProps = {};
-	for (const key of allKeys) {
+	const strictProps = Object.fromEntries(allKeys.map((key) => {
 		const prop = properties[key];
-		const strictProp = strictifyNode(prop, `${path}.${key}`);
-		if (!existingRequired.has(key)) strictProps[key] = makeNullable(strictProp);
-		else strictProps[key] = strictProp;
-	}
+		const strictProp = strictifyNode(prop, `${path}.${key}`, provider);
+		return [key, existingRequired.has(key) ? strictProp : makeNullable(strictProp)];
+	}));
 	return {
 		...node,
 		type: "object",
@@ -53,24 +264,103 @@ function strictifyObject(node, path) {
 		additionalProperties: false
 	};
 }
-function strictifyArray(node, path) {
-	const items = node.items;
-	if (!items) return { ...node };
+const UNREACHABLE_TUPLE_TAIL_SCHEMA = { type: "string" };
+function strictifyArray(node, path, provider) {
+	if ((provider === "openai" || provider === "anthropic") && (Array.isArray(ownValue(node, "items")) || Array.isArray(ownValue(node, "prefixItems")))) return normalizeTuple(node, path, provider);
+	const result = { ...node };
+	const items = ownValue(node, "items");
+	if (Array.isArray(items)) result.items = items.map((schema, index) => strictifyNode(schema, `${path}.items[${index}]`, provider));
+	else if (items !== void 0) result.items = strictifyNode(items, `${path}.items`, provider);
+	const prefixItems = ownValue(node, "prefixItems");
+	if (Array.isArray(prefixItems)) result.prefixItems = prefixItems.map((schema, index) => strictifyNode(schema, `${path}.prefixItems[${index}]`, provider));
+	return result;
+}
+function normalizeTuple(node, path, provider) {
+	const items = ownValue(node, "items");
+	const prefixItems = ownValue(node, "prefixItems");
+	const legacyTuple = Array.isArray(items);
+	const prefixTuple = Array.isArray(prefixItems);
+	if (legacyTuple && prefixTuple) throw new StrictifierError("items and prefixItems tuple forms cannot be combined", path);
+	if (prefixTuple && Object.hasOwn(node, "additionalItems")) throw new StrictifierError("additionalItems cannot be combined with prefixItems", path);
+	const rawTuple = legacyTuple ? items : prefixItems;
+	const tuplePath = legacyTuple ? `${path}.items` : `${path}.prefixItems`;
+	const tuple = rawTuple.map((schema, index) => {
+		if (!isSchemaObject(schema)) throw new StrictifierError("boolean and non-object tuple member schemas are not supported", `${tuplePath}[${index}]`);
+		const memberPath = `${tuplePath}[${index}]`;
+		const member = strictifyNode(schema, memberPath, provider);
+		if (!hasProviderSchemaEntryPoint(member)) throw new StrictifierError("tuple member must define a provider-representable schema", memberPath);
+		return member;
+	});
+	const rawTail = legacyTuple ? ownValue(node, "additionalItems") : items;
+	if (rawTail === true) throw new StrictifierError("an unrestricted tuple rest is not supported", path);
+	if (rawTail !== void 0 && rawTail !== false && !isSchemaObject(rawTail)) throw new StrictifierError("tuple rest must be an object schema or false", path);
+	const tail = isSchemaObject(rawTail) ? strictifyNode(rawTail, legacyTuple ? `${path}.additionalItems` : `${path}.items`, provider) : void 0;
+	if (tail !== void 0 && !hasProviderSchemaEntryPoint(tail)) throw new StrictifierError("an unrestricted tuple rest is not supported", path);
+	const tailMode = tail !== void 0 ? "typed" : rawTail === false ? "closed" : "implicit";
+	const bounds = normalizeTupleBounds(node, tuple.length, tailMode, path);
 	return {
-		...node,
-		items: strictifyNode(items, `${path}.items`)
+		...omitKeys(node, [
+			"items",
+			"prefixItems",
+			"additionalItems",
+			"minItems",
+			"maxItems"
+		]),
+		...tuple.length > 0 ? { prefixItems: tuple } : {},
+		items: tail ?? UNREACHABLE_TUPLE_TAIL_SCHEMA,
+		...bounds
 	};
 }
+function normalizeTupleBounds(node, tupleLength, tailMode, path) {
+	const callerMinItems = integerBound(ownValue(node, "minItems"), "minItems", path);
+	const callerMaxItems = integerBound(ownValue(node, "maxItems"), "maxItems", path);
+	if (tailMode === "implicit" && callerMaxItems !== void 0 && callerMaxItems > tupleLength) throw new StrictifierError("implicit tuple rest cannot be represented when maxItems exceeds the tuple length", path);
+	const minItems = callerMinItems ?? (callerMaxItems === void 0 ? tupleLength : 0);
+	const maxItems = tailMode === "typed" ? callerMaxItems : Math.min(callerMaxItems ?? tupleLength, tupleLength);
+	if (maxItems !== void 0 && minItems > maxItems) throw new StrictifierError("tuple minItems cannot exceed maxItems", path);
+	return {
+		minItems,
+		...maxItems !== void 0 ? { maxItems } : {}
+	};
+}
+function integerBound(value, keyword, path) {
+	if (value === void 0) return void 0;
+	if (!Number.isSafeInteger(value) || value < 0) throw new StrictifierError(`${keyword} must be a non-negative safe integer`, path);
+	return value;
+}
+function isSchemaObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function ownValue(schema, keyword) {
+	return Object.hasOwn(schema, keyword) ? schema[keyword] : void 0;
+}
+const PROVIDER_SCHEMA_ENTRY_POINT_KEYWORDS = /* @__PURE__ */ new Set([
+	"type",
+	"$ref",
+	"properties",
+	"anyOf",
+	"oneOf",
+	"allOf"
+]);
+function hasProviderSchemaEntryPoint(schema) {
+	return Object.keys(schema).some((key) => PROVIDER_SCHEMA_ENTRY_POINT_KEYWORDS.has(key));
+}
+function omitKeys(node, keys) {
+	const omitted = new Set(keys);
+	return Object.fromEntries(Object.entries(node).filter(([key]) => !omitted.has(key)));
+}
 function makeNullable(schema) {
-	if (schema.type === "null") return schema;
-	if (schema.anyOf) {
-		const variants = schema.anyOf;
-		if (variants.some((v) => v.type === "null")) return schema;
+	if (ownValue(schema, "type") === "null") return schema;
+	const anyOf = ownValue(schema, "anyOf");
+	if (anyOf) {
+		const variants = anyOf;
+		if (variants.some((v) => ownValue(v, "type") === "null")) return schema;
 		return { anyOf: [...variants, { type: "null" }] };
 	}
-	if (schema.oneOf) {
-		const variants = schema.oneOf;
-		if (variants.some((v) => v.type === "null")) return schema;
+	const oneOf = ownValue(schema, "oneOf");
+	if (oneOf) {
+		const variants = oneOf;
+		if (variants.some((v) => ownValue(v, "type") === "null")) return schema;
 		return { oneOf: [...variants, { type: "null" }] };
 	}
 	return { anyOf: [schema, { type: "null" }] };
@@ -78,4 +368,4 @@ function makeNullable(schema) {
 //#endregion
 export { StrictifierError, strictify };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"strictifier.js","names":[],"sources":["../../../../src/utils/providers/common/strictifier.ts"],"sourcesContent":["/**\n * JSON Schema → OpenAI strict JSON Schema 변환.\n *\n * OpenAI Responses API strict 모드 요구사항:\n *  - 모든 object 에 additionalProperties: false\n *  - 모든 object properties 를 required 에 포함\n *  - optional 필드 → anyOf [original, { type: 'null' }] 로 required 유지\n *  - recursive 처리 (nested objects, arrays, allOf/anyOf/oneOf)\n */\n\nimport {\n  SCHEMA_ARRAY_KEYWORDS,\n  SCHEMA_MAP_KEYWORDS,\n  SCHEMA_SINGLE_KEYWORDS,\n  UNSUPPORTED_REFERENCE_KEYWORDS,\n} from \"./json-schema-keywords\";\n\nexport type JsonSchema = Record<string, unknown>;\n\nexport interface StrictifierOptions {\n  provider?: string;\n}\n\nexport class StrictifierError extends Error {\n  constructor(\n    message: string,\n    public path: string,\n  ) {\n    super(`strictifier: ${message} (at ${path})`);\n    this.name = \"StrictifierError\";\n  }\n}\n\nexport function strictify(schema: JsonSchema, options: StrictifierOptions = {}): JsonSchema {\n  if (options.provider === \"openai\" || options.provider === \"anthropic\") {\n    assertNormalizationCompatibility(schema, options.provider);\n  }\n  const result = strictifyNode(schema, \"$\", options.provider);\n  if (options.provider === \"openai\" || options.provider === \"anthropic\") {\n    assertNormalizationCompatibility(result, options.provider);\n  }\n  return result;\n}\n\n/**\n * 위치 목록은 json-schema-keywords 가 소유하고, 여기서는 각 위치의 `normalizable` 여부만 얹는다.\n * normalizable=true 는 strictifyNode 가 그 위치를 실제로 재작성한다는 뜻이다. `not`/`if` 처럼\n * 재작성하면 caller 의미가 바뀌는 위치는 false 이고, 그 아래 tuple/`$ref` 는 정규화 대신 거부된다.\n *\n * `items`/`additionalItems` 는 tuple 판정과 함께 다뤄야 해서 아래 순회에서 개별 처리한다.\n */\nconst NON_NORMALIZABLE_POSITIONS = new Set<string>([\n  \"dependentSchemas\",\n  \"patternProperties\",\n  \"additionalProperties\",\n  \"contains\",\n  \"contentSchema\",\n  \"else\",\n  \"if\",\n  \"not\",\n  \"propertyNames\",\n  \"then\",\n  \"unevaluatedItems\",\n  \"unevaluatedProperties\",\n]);\n\nfunction positionEntries(keywords: readonly string[]): ReadonlyArray<readonly [string, boolean]> {\n  return keywords.map((keyword) => [keyword, !NON_NORMALIZABLE_POSITIONS.has(keyword)] as const);\n}\n\nconst SCHEMA_SCAN_MAP_KEYWORDS = positionEntries(SCHEMA_MAP_KEYWORDS);\nconst SCHEMA_SCAN_ARRAY_KEYWORDS = positionEntries(SCHEMA_ARRAY_KEYWORDS);\n// items/additionalItems 는 tuple 분기에서 직접 다루므로 단일 위치 스캔에서 제외한다.\nconst SCHEMA_SCAN_SINGLE_KEYWORDS = positionEntries(\n  SCHEMA_SINGLE_KEYWORDS.filter((keyword) => keyword !== \"items\" && keyword !== \"additionalItems\"),\n);\n\n/**\n * Inspect every JSON Schema-bearing position without rewriting it.\n *\n * Positive positions already traversed by strictifyNode may normalize OpenAI tuples. Positions\n * such as `not` and `if` cannot be tightened without changing caller semantics, so positional\n * tuples there fail explicitly instead of leaking an unsupported provider schema. References\n * from those positions also fail because their definitions are normalized globally.\n */\nfunction assertNormalizationCompatibility(\n  schema: JsonSchema,\n  provider: \"openai\" | \"anthropic\",\n): void {\n  const references: Array<{ value: string; path: string }> = [];\n  const stack: Array<{ node: JsonSchema; path: string; normalizable: boolean }> = [\n    { node: schema, path: \"$\", normalizable: true },\n  ];\n\n  while (stack.length > 0) {\n    const current = stack.pop()!;\n    const itemsValue = ownValue(current.node, \"items\");\n    const prefixItemsValue = ownValue(current.node, \"prefixItems\");\n    const legacyTuple = Array.isArray(itemsValue);\n    const prefixTuple = Array.isArray(prefixItemsValue);\n\n    assertUnsupportedReferenceKeywords(current.node, current.path);\n    collectSchemaReference(current, references);\n\n    if (legacyTuple || prefixTuple) {\n      const tuple = (legacyTuple ? itemsValue : prefixItemsValue) as unknown[];\n      if (provider === \"anthropic\" && tuple.length > 0) {\n        throw new StrictifierError(\n          \"positional tuple schemas are not supported on Anthropic because Claude Code cannot preserve item positions\",\n          current.path,\n        );\n      }\n      if (!current.normalizable) {\n        throw new StrictifierError(\n          \"positional tuple schemas are not supported in this schema position\",\n          current.path,\n        );\n      }\n      if (ownValue(current.node, \"type\") !== \"array\") {\n        throw new StrictifierError(\n          'positional tuple schemas must declare type \"array\"; express nullable tuples with anyOf',\n          `${current.path}.type`,\n        );\n      }\n    }\n\n    for (const [keyword, keywordNormalizable] of SCHEMA_SCAN_MAP_KEYWORDS) {\n      const schemas = ownValue(current.node, keyword);\n      if (!isSchemaObject(schemas)) continue;\n      for (const [name, child] of Object.entries(schemas)) {\n        if (!isSchemaObject(child)) continue;\n        stack.push({\n          node: child,\n          path: `${current.path}.${keyword}.${name}`,\n          normalizable: current.normalizable && keywordNormalizable,\n        });\n      }\n    }\n\n    const dependencies = ownValue(current.node, \"dependencies\");\n    if (isSchemaObject(dependencies)) {\n      for (const [name, child] of Object.entries(dependencies)) {\n        if (!isSchemaObject(child)) continue;\n        stack.push({\n          node: child,\n          path: `${current.path}.dependencies.${name}`,\n          normalizable: false,\n        });\n      }\n    }\n\n    for (const [keyword, keywordNormalizable] of SCHEMA_SCAN_ARRAY_KEYWORDS) {\n      const schemas = ownValue(current.node, keyword);\n      if (!Array.isArray(schemas)) continue;\n      for (let index = 0; index < schemas.length; index += 1) {\n        const child = schemas[index];\n        if (!isSchemaObject(child)) continue;\n        stack.push({\n          node: child,\n          path: `${current.path}.${keyword}[${index}]`,\n          normalizable: current.normalizable && keywordNormalizable,\n        });\n      }\n    }\n\n    const items = ownValue(current.node, \"items\");\n    if (isSchemaObject(items)) {\n      stack.push({\n        node: items,\n        path: `${current.path}.items`,\n        normalizable: current.normalizable,\n      });\n    } else if (Array.isArray(items)) {\n      for (let index = 0; index < items.length; index += 1) {\n        const child = items[index];\n        if (!isSchemaObject(child)) continue;\n        stack.push({\n          node: child,\n          path: `${current.path}.items[${index}]`,\n          normalizable: current.normalizable,\n        });\n      }\n    }\n\n    const additionalItems = ownValue(current.node, \"additionalItems\");\n    if (isSchemaObject(additionalItems)) {\n      stack.push({\n        node: additionalItems,\n        path: `${current.path}.additionalItems`,\n        normalizable: current.normalizable && legacyTuple,\n      });\n    }\n\n    for (const [keyword, keywordNormalizable] of SCHEMA_SCAN_SINGLE_KEYWORDS) {\n      const child = ownValue(current.node, keyword);\n      if (!isSchemaObject(child)) continue;\n      stack.push({\n        node: child,\n        path: `${current.path}.${keyword}`,\n        normalizable: current.normalizable && keywordNormalizable,\n      });\n    }\n  }\n\n  assertReferenceTargets(schema, references);\n}\n\nfunction assertUnsupportedReferenceKeywords(schema: JsonSchema, path: string): void {\n  for (const keyword of UNSUPPORTED_REFERENCE_KEYWORDS) {\n    if (Object.hasOwn(schema, keyword)) {\n      throw new StrictifierError(`${keyword} is not supported`, `${path}.${keyword}`);\n    }\n  }\n}\n\nfunction collectSchemaReference(\n  current: { node: JsonSchema; path: string; normalizable: boolean },\n  references: Array<{ value: string; path: string }>,\n): void {\n  if (!Object.hasOwn(current.node, \"$ref\")) return;\n\n  const reference = current.node.$ref;\n  if (typeof reference !== \"string\") {\n    throw new StrictifierError(\"$ref must be a string\", `${current.path}.$ref`);\n  }\n  if (!current.normalizable) {\n    throw new StrictifierError(\n      \"schema references are not supported in this schema position\",\n      current.path,\n    );\n  }\n\n  references.push({ value: reference, path: `${current.path}.$ref` });\n}\n\nfunction assertReferenceTargets(\n  root: JsonSchema,\n  references: Array<{ value: string; path: string }>,\n): void {\n  for (const reference of references) {\n    const tokens = parseLocalJsonPointer(reference.value, reference.path);\n    if (!isDefinitionRootPointer(tokens)) {\n      throw new StrictifierError(\n        \"$ref target must be the document root or a definition root\",\n        reference.path,\n      );\n    }\n    resolveDefinitionRoot(root, tokens, reference.path);\n  }\n}\n\nfunction isDefinitionRootPointer(tokens: string[]): boolean {\n  if (tokens.length === 0) return true;\n  if (tokens.length % 2 !== 0) return false;\n\n  for (let index = 0; index < tokens.length; index += 2) {\n    if (tokens[index] !== \"$defs\" && tokens[index] !== \"definitions\") return false;\n  }\n  return true;\n}\n\nfunction parseLocalJsonPointer(reference: string, path: string): string[] {\n  if (reference === \"#\") return [];\n  if (!reference.startsWith(\"#/\")) {\n    throw new StrictifierError(\n      \"only local root-relative JSON Pointer $ref values are supported\",\n      path,\n    );\n  }\n\n  let fragment: string;\n  try {\n    fragment = decodeURIComponent(reference.slice(1));\n  } catch {\n    throw new StrictifierError(\"$ref contains invalid percent encoding\", path);\n  }\n  if (!fragment.startsWith(\"/\")) {\n    throw new StrictifierError(\n      \"only local root-relative JSON Pointer $ref values are supported\",\n      path,\n    );\n  }\n\n  return fragment\n    .slice(1)\n    .split(\"/\")\n    .map((token) => decodeJsonPointerToken(token, path));\n}\n\nfunction resolveDefinitionRoot(root: JsonSchema, tokens: string[], path: string): void {\n  let current = root;\n  for (let index = 0; index < tokens.length; index += 2) {\n    const keyword = tokens[index]!;\n    const name = tokens[index + 1]!;\n    const definitions = ownValue(current, keyword);\n    if (!isSchemaObject(definitions) || !Object.hasOwn(definitions, name)) {\n      throw new StrictifierError(\"$ref does not resolve inside the caller schema\", path);\n    }\n    const target = definitions[name];\n    if (!isSchemaObject(target)) {\n      throw new StrictifierError(\"$ref target must be an object schema\", path);\n    }\n    current = target;\n  }\n}\n\nfunction decodeJsonPointerToken(rawToken: string, path: string): string {\n  let token = \"\";\n  for (let index = 0; index < rawToken.length; index += 1) {\n    const character = rawToken[index]!;\n    if (character !== \"~\") {\n      token += character;\n      continue;\n    }\n\n    const escaped = rawToken[index + 1];\n    if (escaped === \"0\") {\n      token += \"~\";\n    } else if (escaped === \"1\") {\n      token += \"/\";\n    } else {\n      throw new StrictifierError(\"$ref contains an invalid JSON Pointer escape\", path);\n    }\n    index += 1;\n  }\n  return token;\n}\n\nfunction strictifyNode(node: JsonSchema, path: string, provider?: string): JsonSchema {\n  if (typeof node !== \"object\" || node === null) return node;\n\n  const dialectNeutralNode = provider === \"openai\" ? omitKeys(node, [\"$schema\"]) : node;\n  let result = strictifySchemaMaps(dialectNeutralNode, path, provider);\n  const type = ownValue(result, \"type\") as string | undefined;\n\n  if (type === \"object\" || Object.hasOwn(result, \"properties\")) {\n    result = strictifyObject(result, path, provider);\n  }\n\n  if (type === \"array\" || Object.hasOwn(result, \"items\") || Object.hasOwn(result, \"prefixItems\")) {\n    result = strictifyArray(result, path, provider);\n  }\n\n  return strictifySchemaArrays(result, path, provider);\n}\n\n// 재작성 패스는 정의 맵만 재귀한다. properties 는 strictifyObject 가 별도로 처리하므로\n// 공유 위치 목록(SCHEMA_MAP_KEYWORDS)과 의도적으로 범위가 다르다.\nconst DEFINITION_MAP_KEYWORDS = [\"$defs\", \"definitions\"] as const;\n\nfunction strictifySchemaMaps(node: JsonSchema, path: string, provider?: string): JsonSchema {\n  const result = { ...node };\n\n  for (const keyword of DEFINITION_MAP_KEYWORDS) {\n    const schemas = ownValue(node, keyword);\n    if (!isSchemaObject(schemas)) continue;\n\n    result[keyword] = Object.fromEntries(\n      Object.entries(schemas).map(([name, schema]) => [\n        name,\n        isSchemaObject(schema)\n          ? strictifyNode(schema, `${path}.${keyword}.${name}`, provider)\n          : schema,\n      ]),\n    );\n  }\n\n  return result;\n}\n\n// prefixItems 는 strictifyArray 의 tuple 경로가 다루므로 여기서는 조합 keyword 만 재귀한다.\nconst COMBINATOR_KEYWORDS = [\"anyOf\", \"oneOf\", \"allOf\"] as const;\n\nfunction strictifySchemaArrays(node: JsonSchema, path: string, provider?: string): JsonSchema {\n  const result = { ...node };\n\n  for (const keyword of COMBINATOR_KEYWORDS) {\n    const schemas = ownValue(node, keyword);\n    if (!schemas) continue;\n    result[keyword] = (schemas as JsonSchema[]).map((schema, index) =>\n      strictifyNode(schema, `${path}.${keyword}[${index}]`, provider),\n    );\n  }\n\n  return result;\n}\n\nfunction strictifyObject(node: JsonSchema, path: string, provider?: string): JsonSchema {\n  const properties = ownValue(node, \"properties\") as Record<string, JsonSchema> | undefined;\n  if (!properties) {\n    return { ...node, additionalProperties: false };\n  }\n\n  const existingRequired = new Set((ownValue(node, \"required\") as string[] | undefined) ?? []);\n  const allKeys = Object.keys(properties);\n\n  const strictProps = Object.fromEntries(\n    allKeys.map((key) => {\n      const prop = properties[key]!;\n      const strictProp = strictifyNode(prop, `${path}.${key}`, provider);\n\n      return [key, existingRequired.has(key) ? strictProp : makeNullable(strictProp)];\n    }),\n  ) as Record<string, JsonSchema>;\n\n  const result: JsonSchema = {\n    ...node,\n    type: \"object\",\n    properties: strictProps,\n    required: allKeys,\n    additionalProperties: false,\n  };\n\n  return result;\n}\n\nconst UNREACHABLE_TUPLE_TAIL_SCHEMA: JsonSchema = { type: \"string\" };\n\nfunction strictifyArray(node: JsonSchema, path: string, provider?: string): JsonSchema {\n  if (\n    (provider === \"openai\" || provider === \"anthropic\") &&\n    (Array.isArray(ownValue(node, \"items\")) || Array.isArray(ownValue(node, \"prefixItems\")))\n  ) {\n    return normalizeTuple(node, path, provider);\n  }\n\n  const result = { ...node };\n  const items = ownValue(node, \"items\") as JsonSchema | JsonSchema[] | undefined;\n\n  if (Array.isArray(items)) {\n    result.items = items.map((schema, index) =>\n      strictifyNode(schema, `${path}.items[${index}]`, provider),\n    );\n  } else if (items !== undefined) {\n    result.items = strictifyNode(items, `${path}.items`, provider);\n  }\n\n  const prefixItems = ownValue(node, \"prefixItems\") as JsonSchema[] | undefined;\n  if (Array.isArray(prefixItems)) {\n    result.prefixItems = prefixItems.map((schema, index) =>\n      strictifyNode(schema, `${path}.prefixItems[${index}]`, provider),\n    );\n  }\n\n  return result;\n}\n\nfunction normalizeTuple(\n  node: JsonSchema,\n  path: string,\n  provider: \"openai\" | \"anthropic\",\n): JsonSchema {\n  const items = ownValue(node, \"items\");\n  const prefixItems = ownValue(node, \"prefixItems\");\n  const legacyTuple = Array.isArray(items);\n  const prefixTuple = Array.isArray(prefixItems);\n  if (legacyTuple && prefixTuple) {\n    throw new StrictifierError(\"items and prefixItems tuple forms cannot be combined\", path);\n  }\n  if (prefixTuple && Object.hasOwn(node, \"additionalItems\")) {\n    throw new StrictifierError(\"additionalItems cannot be combined with prefixItems\", path);\n  }\n\n  const rawTuple = (legacyTuple ? items : prefixItems) as unknown[];\n  const tuplePath = legacyTuple ? `${path}.items` : `${path}.prefixItems`;\n  const tuple = rawTuple.map((schema, index) => {\n    if (!isSchemaObject(schema)) {\n      throw new StrictifierError(\n        \"boolean and non-object tuple member schemas are not supported\",\n        `${tuplePath}[${index}]`,\n      );\n    }\n    const memberPath = `${tuplePath}[${index}]`;\n    const member = strictifyNode(schema, memberPath, provider);\n    if (!hasProviderSchemaEntryPoint(member)) {\n      throw new StrictifierError(\n        \"tuple member must define a provider-representable schema\",\n        memberPath,\n      );\n    }\n    return member;\n  });\n\n  const rawTail = legacyTuple ? ownValue(node, \"additionalItems\") : items;\n  if (rawTail === true) {\n    throw new StrictifierError(\"an unrestricted tuple rest is not supported\", path);\n  }\n  if (rawTail !== undefined && rawTail !== false && !isSchemaObject(rawTail)) {\n    throw new StrictifierError(\"tuple rest must be an object schema or false\", path);\n  }\n\n  const tail = isSchemaObject(rawTail)\n    ? strictifyNode(rawTail, legacyTuple ? `${path}.additionalItems` : `${path}.items`, provider)\n    : undefined;\n  if (tail !== undefined && !hasProviderSchemaEntryPoint(tail)) {\n    throw new StrictifierError(\"an unrestricted tuple rest is not supported\", path);\n  }\n  const tailMode = tail !== undefined ? \"typed\" : rawTail === false ? \"closed\" : \"implicit\";\n  const bounds = normalizeTupleBounds(node, tuple.length, tailMode, path);\n  const base = omitKeys(node, [\"items\", \"prefixItems\", \"additionalItems\", \"minItems\", \"maxItems\"]);\n\n  // Anthropic 은 assertNormalizationCompatibility 가 비어 있지 않은 tuple 을 이미 거부했으므로\n  // 여기 도달하는 tuple 은 빈 tuple 뿐이고, 그 경우 prefixItems spread 는 자연히 생략된다 —\n  // provider 분기 없이 한 형태로 두 provider 모두를 표현한다.\n  return {\n    ...base,\n    ...(tuple.length > 0 ? { prefixItems: tuple } : {}),\n    items: tail ?? UNREACHABLE_TUPLE_TAIL_SCHEMA,\n    ...bounds,\n  };\n}\n\nfunction normalizeTupleBounds(\n  node: JsonSchema,\n  tupleLength: number,\n  tailMode: \"typed\" | \"closed\" | \"implicit\",\n  path: string,\n): { minItems: number; maxItems?: number } {\n  const callerMinItems = integerBound(ownValue(node, \"minItems\"), \"minItems\", path);\n  const callerMaxItems = integerBound(ownValue(node, \"maxItems\"), \"maxItems\", path);\n  if (tailMode === \"implicit\" && callerMaxItems !== undefined && callerMaxItems > tupleLength) {\n    throw new StrictifierError(\n      \"implicit tuple rest cannot be represented when maxItems exceeds the tuple length\",\n      path,\n    );\n  }\n\n  const minItems = callerMinItems ?? (callerMaxItems === undefined ? tupleLength : 0);\n  const maxItems =\n    tailMode === \"typed\" ? callerMaxItems : Math.min(callerMaxItems ?? tupleLength, tupleLength);\n\n  if (maxItems !== undefined && minItems > maxItems) {\n    throw new StrictifierError(\"tuple minItems cannot exceed maxItems\", path);\n  }\n\n  return {\n    minItems,\n    ...(maxItems !== undefined ? { maxItems } : {}),\n  };\n}\n\nfunction integerBound(value: unknown, keyword: string, path: string): number | undefined {\n  if (value === undefined) return undefined;\n  if (!Number.isSafeInteger(value) || (value as number) < 0) {\n    throw new StrictifierError(`${keyword} must be a non-negative safe integer`, path);\n  }\n  return value as number;\n}\n\nfunction isSchemaObject(value: unknown): value is JsonSchema {\n  return typeof value === \"object\" && value !== null && !Array.isArray(value);\n}\n\nfunction ownValue(schema: JsonSchema, keyword: string): unknown {\n  return Object.hasOwn(schema, keyword) ? schema[keyword] : undefined;\n}\n\nconst PROVIDER_SCHEMA_ENTRY_POINT_KEYWORDS = new Set([\n  \"type\",\n  \"$ref\",\n  \"properties\",\n  \"anyOf\",\n  \"oneOf\",\n  \"allOf\",\n]);\n\nfunction hasProviderSchemaEntryPoint(schema: JsonSchema): boolean {\n  return Object.keys(schema).some((key) => PROVIDER_SCHEMA_ENTRY_POINT_KEYWORDS.has(key));\n}\n\nfunction omitKeys(node: JsonSchema, keys: readonly string[]): JsonSchema {\n  const omitted = new Set(keys);\n  return Object.fromEntries(Object.entries(node).filter(([key]) => !omitted.has(key)));\n}\n\nfunction makeNullable(schema: JsonSchema): JsonSchema {\n  if (ownValue(schema, \"type\") === \"null\") return schema;\n\n  const anyOf = ownValue(schema, \"anyOf\");\n  if (anyOf) {\n    const variants = anyOf as JsonSchema[];\n    const hasNull = variants.some((v) => ownValue(v, \"type\") === \"null\");\n    if (hasNull) return schema;\n    return { anyOf: [...variants, { type: \"null\" }] };\n  }\n\n  const oneOf = ownValue(schema, \"oneOf\");\n  if (oneOf) {\n    const variants = oneOf as JsonSchema[];\n    const hasNull = variants.some((v) => ownValue(v, \"type\") === \"null\");\n    if (hasNull) return schema;\n    return { oneOf: [...variants, { type: \"null\" }] };\n  }\n\n  return { anyOf: [schema, { type: \"null\" }] };\n}\n"],"mappings":"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"}