@cartanova/qgrid-cli 2.5.4 → 2.5.6

package/bundle/dist/application/qgrid/tool-emulation-schema.js

@@ -1,3 +1,4 @@
+import { SCHEMA_ARRAY_KEYWORDS, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, UNSUPPORTED_REFERENCE_KEYWORDS } from "../../utils/providers/common/json-schema-keywords.js";
 //#region src/application/qgrid/tool-emulation-schema.ts
 const USER_OUTPUT_DEFINITION = "__qgrid_user_output";
 const USER_OUTPUT_REF = `#/$defs/${USER_OUTPUT_DEFINITION}`;
@@ -60,43 +61,14 @@ function buildToolCallSchema(tools, answerSchema) {
 function rebaseUserOutputSchema(schema) {
 	return rewriteSchemaNode(schema, "$");
 }
-const SCHEMA_MAP_KEYWORDS = /* @__PURE__ */ new Set([
-	"$defs",
-	"definitions",
-	"dependentSchemas",
-	"patternProperties",
-	"properties"
-]);
-const SCHEMA_ARRAY_KEYWORDS = /* @__PURE__ */ new Set([
-	"allOf",
-	"anyOf",
-	"oneOf",
-	"prefixItems"
-]);
-const SCHEMA_KEYWORDS = /* @__PURE__ */ new Set([
-	"additionalItems",
-	"additionalProperties",
-	"contains",
-	"contentSchema",
-	"else",
-	"if",
-	"items",
-	"not",
-	"propertyNames",
-	"then",
-	"unevaluatedItems",
-	"unevaluatedProperties"
-]);
+const MAP_KEYWORDS = new Set(SCHEMA_MAP_KEYWORDS);
+const ARRAY_KEYWORDS = new Set(SCHEMA_ARRAY_KEYWORDS);
+const SINGLE_KEYWORDS = new Set(SCHEMA_SINGLE_KEYWORDS);
 function rewriteSchemaNode(value, path) {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
 	const source = value;
 	const result = { ...source };
-	for (const unsupportedKeyword of [
-		"$id",
-		"$dynamicRef",
-		"$recursiveRef",
-		"$recursiveAnchor"
-	]) if (unsupportedKeyword in source) throw new ToolSchemaCompositionError(`${unsupportedKeyword} is not supported`, `${path}.${unsupportedKeyword}`);
+	for (const unsupportedKeyword of UNSUPPORTED_REFERENCE_KEYWORDS) if (Object.hasOwn(source, unsupportedKeyword)) throw new ToolSchemaCompositionError(`${unsupportedKeyword} is not supported`, `${path}.${unsupportedKeyword}`);
 	if ("$ref" in source) {
 		const ref = source.$ref;
 		if (typeof ref !== "string" || ref !== "#" && !ref.startsWith("#/")) throw new ToolSchemaCompositionError("only root-relative JSON Pointer $ref values are supported", `${path}.$ref`);
@@ -104,10 +76,10 @@ function rewriteSchemaNode(value, path) {
 	}
 	for (const [keyword, child] of Object.entries(source)) {
 		const keywordPath = `${path}.${keyword}`;
-		if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(child)) result[keyword] = Object.fromEntries(Object.entries(child).map(([name, schema]) => [name, rewriteSchemaNode(schema, `${keywordPath}.${name}`)]));
+		if (MAP_KEYWORDS.has(keyword) && isJsonObject(child)) result[keyword] = Object.fromEntries(Object.entries(child).map(([name, schema]) => [name, rewriteSchemaNode(schema, `${keywordPath}.${name}`)]));
 		else if (keyword === "dependencies" && isJsonObject(child)) result[keyword] = Object.fromEntries(Object.entries(child).map(([name, dependency]) => [name, Array.isArray(dependency) ? dependency : rewriteSchemaNode(dependency, `${keywordPath}.${name}`)]));
-		else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(child)) result[keyword] = child.map((schema, index) => rewriteSchemaNode(schema, `${keywordPath}[${index}]`));
-		else if (SCHEMA_KEYWORDS.has(keyword)) if (keyword === "items" && Array.isArray(child)) result[keyword] = child.map((schema, index) => rewriteSchemaNode(schema, `${keywordPath}[${index}]`));
+		else if (ARRAY_KEYWORDS.has(keyword) && Array.isArray(child)) result[keyword] = child.map((schema, index) => rewriteSchemaNode(schema, `${keywordPath}[${index}]`));
+		else if (SINGLE_KEYWORDS.has(keyword)) if (keyword === "items" && Array.isArray(child)) result[keyword] = child.map((schema, index) => rewriteSchemaNode(schema, `${keywordPath}[${index}]`));
 		else result[keyword] = rewriteSchemaNode(child, keywordPath);
 	}
 	return result;
@@ -118,4 +90,4 @@ function isJsonObject(value) {
 //#endregion
 export { ToolSchemaCompositionError, buildToolCallSchema };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tool-emulation-schema.js","names":[],"sources":["../../../src/application/qgrid/tool-emulation-schema.ts"],"sourcesContent":["import { type JsonValue } from \"../../codex-protocol/serde_json/JsonValue\";\nimport { type QgridTool } from \"./qgrid.types\";\n\nconst USER_OUTPUT_DEFINITION = \"__qgrid_user_output\";\nconst USER_OUTPUT_REF = `#/$defs/${USER_OUTPUT_DEFINITION}`;\n\nexport class ToolSchemaCompositionError extends Error {\n  constructor(\n    message: string,\n    public path: string,\n  ) {\n    super(`tool schema composition: ${message} (at ${path})`);\n    this.name = \"ToolSchemaCompositionError\";\n  }\n}\n\nexport function buildToolCallSchema(tools: QgridTool[], answerSchema?: JsonValue): JsonValue {\n  const toolDescriptions = tools\n    .map((tool) => {\n      const schema = JSON.stringify(tool.inputSchema);\n      return `- ${tool.name}: ${tool.description ?? \"\"}\\n  inputSchema: ${schema}`;\n    })\n    .join(\"\\n\");\n\n  const normalizedAnswerSchema =\n    answerSchema === undefined ? undefined : rebaseUserOutputSchema(answerSchema);\n\n  return {\n    type: \"object\",\n    description:\n      \"Use this schema only through StructuredOutput. Do not invoke listed client tools as native Claude Code tools. To request client-side tool execution, set action to tool_call and include toolCalls. Use action answer only when no further client tool result is needed.\",\n    properties: {\n      action: {\n        type: \"string\",\n        enum: [\"answer\", \"tool_call\"],\n        description:\n          \"Use tool_call to request client-side tool execution through this structured output. Use answer only for a final answer.\",\n      },\n      answer: {\n        anyOf: [\n          normalizedAnswerSchema === undefined ? { type: \"string\" } : { $ref: USER_OUTPUT_REF },\n          { type: \"null\" },\n        ],\n      },\n      toolCalls: {\n        description:\n          \"Client-side tool calls requested through structured output. Do not call these tools as native Claude Code tools.\",\n        anyOf: [\n          {\n            type: \"array\",\n            items: {\n              type: \"object\",\n              properties: {\n                toolName: {\n                  type: \"string\",\n                  enum: tools.map((tool) => tool.name),\n                  description: `Client-side tool name to request through structured output. Do not call this as a native Claude Code tool.\\n${toolDescriptions}`,\n                },\n                args: {\n                  type: \"string\",\n                  description: \"Tool arguments as a JSON string for the client-side tool.\",\n                },\n              },\n              required: [\"toolName\", \"args\"],\n              additionalProperties: false,\n            },\n          },\n          { type: \"null\" },\n        ],\n      },\n    },\n    required: [\"action\", \"answer\", \"toolCalls\"],\n    additionalProperties: false,\n    ...(normalizedAnswerSchema === undefined\n      ? {}\n      : {\n          $defs: {\n            [USER_OUTPUT_DEFINITION]: normalizedAnswerSchema,\n          },\n        }),\n  };\n}\n\nfunction rebaseUserOutputSchema(schema: JsonValue): JsonValue {\n  return rewriteSchemaNode(schema, \"$\");\n}\n\nconst SCHEMA_MAP_KEYWORDS = new Set([\n  \"$defs\",\n  \"definitions\",\n  \"dependentSchemas\",\n  \"patternProperties\",\n  \"properties\",\n]);\nconst SCHEMA_ARRAY_KEYWORDS = new Set([\"allOf\", \"anyOf\", \"oneOf\", \"prefixItems\"]);\nconst SCHEMA_KEYWORDS = new Set([\n  \"additionalItems\",\n  \"additionalProperties\",\n  \"contains\",\n  \"contentSchema\",\n  \"else\",\n  \"if\",\n  \"items\",\n  \"not\",\n  \"propertyNames\",\n  \"then\",\n  \"unevaluatedItems\",\n  \"unevaluatedProperties\",\n]);\n\nfunction rewriteSchemaNode(value: JsonValue, path: string): JsonValue {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) return value;\n\n  const source = value as Record<string, JsonValue>;\n  const result: Record<string, JsonValue> = { ...source };\n\n  for (const unsupportedKeyword of [\"$id\", \"$dynamicRef\", \"$recursiveRef\", \"$recursiveAnchor\"]) {\n    if (unsupportedKeyword in source) {\n      throw new ToolSchemaCompositionError(\n        `${unsupportedKeyword} is not supported`,\n        `${path}.${unsupportedKeyword}`,\n      );\n    }\n  }\n\n  if (\"$ref\" in source) {\n    const ref = source.$ref;\n    if (typeof ref !== \"string\" || (ref !== \"#\" && !ref.startsWith(\"#/\"))) {\n      throw new ToolSchemaCompositionError(\n        \"only root-relative JSON Pointer $ref values are supported\",\n        `${path}.$ref`,\n      );\n    }\n    result.$ref = `${USER_OUTPUT_REF}${ref.slice(1)}`;\n  }\n\n  for (const [keyword, child] of Object.entries(source)) {\n    const keywordPath = `${path}.${keyword}`;\n\n    if (SCHEMA_MAP_KEYWORDS.has(keyword) && isJsonObject(child)) {\n      result[keyword] = Object.fromEntries(\n        Object.entries(child).map(([name, schema]) => [\n          name,\n          rewriteSchemaNode(schema, `${keywordPath}.${name}`),\n        ]),\n      ) as JsonValue;\n    } else if (keyword === \"dependencies\" && isJsonObject(child)) {\n      result[keyword] = Object.fromEntries(\n        Object.entries(child).map(([name, dependency]) => [\n          name,\n          Array.isArray(dependency)\n            ? dependency\n            : rewriteSchemaNode(dependency, `${keywordPath}.${name}`),\n        ]),\n      ) as JsonValue;\n    } else if (SCHEMA_ARRAY_KEYWORDS.has(keyword) && Array.isArray(child)) {\n      result[keyword] = child.map((schema, index) =>\n        rewriteSchemaNode(schema, `${keywordPath}[${index}]`),\n      ) as JsonValue;\n    } else if (SCHEMA_KEYWORDS.has(keyword)) {\n      if (keyword === \"items\" && Array.isArray(child)) {\n        result[keyword] = child.map((schema, index) =>\n          rewriteSchemaNode(schema, `${keywordPath}[${index}]`),\n        ) as JsonValue;\n      } else {\n        result[keyword] = rewriteSchemaNode(child, keywordPath);\n      }\n    }\n  }\n\n  return result as JsonValue;\n}\n\nfunction isJsonObject(value: JsonValue): value is Record<string, JsonValue> {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"tool-emulation-schema.js","names":[],"sources":["../../../src/application/qgrid/tool-emulation-schema.ts"],"sourcesContent":["/**\n * tool envelope + 사용자 output 스키마 합성 (요청 방향). 응답 해석은 tool-emulation.ts.\n *\n * tools 가 있어도 최종 answer 가 사용자 스키마로 강제되게 하려고 envelope 의 answer 브랜치에\n * 사용자 스키마를 심는다. 통째로 중첩할 수 없는 이유는 `$ref` 가 문서 절대 경로이기 때문 —\n * `#` 은 \"이 조각의 루트\"가 아니라 \"최종 문서의 루트\"라, 그대로 넣으면 포인터가 envelope 을\n * 가리켜 조용히 엉뚱한 걸 검증하게 된다. 그래서 예약 이름 아래로 옮기고 로컬 포인터를 재작성한다.\n *\n * 배경·실측·예시·거부 목록은 스킬 문서를 볼 것:\n *   packages/cli/skills/qgrid/references/tool-calling-and-multiturn.md\n *   → \"Composing Tools With A User Output Schema\"\n */\n\nimport { type JsonValue } from \"../../codex-protocol/serde_json/JsonValue\";\nimport {\n  SCHEMA_ARRAY_KEYWORDS,\n  SCHEMA_DEPENDENCIES_KEYWORD,\n  SCHEMA_MAP_KEYWORDS,\n  SCHEMA_SINGLE_KEYWORDS,\n  UNSUPPORTED_REFERENCE_KEYWORDS,\n} from \"../../utils/providers/common/json-schema-keywords\";\nimport { type QgridTool } from \"./qgrid.types\";\n\nconst USER_OUTPUT_DEFINITION = \"__qgrid_user_output\";\nconst USER_OUTPUT_REF = `#/$defs/${USER_OUTPUT_DEFINITION}`;\n\nexport class ToolSchemaCompositionError extends Error {\n  constructor(\n    message: string,\n    public path: string,\n  ) {\n    super(`tool schema composition: ${message} (at ${path})`);\n    this.name = \"ToolSchemaCompositionError\";\n  }\n}\n\nexport function buildToolCallSchema(tools: QgridTool[], answerSchema?: JsonValue): JsonValue {\n  const toolDescriptions = tools\n    .map((tool) => {\n      const schema = JSON.stringify(tool.inputSchema);\n      return `- ${tool.name}: ${tool.description ?? \"\"}\\n  inputSchema: ${schema}`;\n    })\n    .join(\"\\n\");\n\n  const normalizedAnswerSchema =\n    answerSchema === undefined ? undefined : rebaseUserOutputSchema(answerSchema);\n\n  return {\n    type: \"object\",\n    description:\n      \"Use this schema only through StructuredOutput. Do not invoke listed client tools as native Claude Code tools. To request client-side tool execution, set action to tool_call and include toolCalls. Use action answer only when no further client tool result is needed.\",\n    properties: {\n      action: {\n        type: \"string\",\n        enum: [\"answer\", \"tool_call\"],\n        description:\n          \"Use tool_call to request client-side tool execution through this structured output. Use answer only for a final answer.\",\n      },\n      answer: {\n        anyOf: [\n          normalizedAnswerSchema === undefined ? { type: \"string\" } : { $ref: USER_OUTPUT_REF },\n          { type: \"null\" },\n        ],\n      },\n      toolCalls: {\n        description:\n          \"Client-side tool calls requested through structured output. Do not call these tools as native Claude Code tools.\",\n        anyOf: [\n          {\n            type: \"array\",\n            items: {\n              type: \"object\",\n              properties: {\n                toolName: {\n                  type: \"string\",\n                  enum: tools.map((tool) => tool.name),\n                  description: `Client-side tool name to request through structured output. Do not call this as a native Claude Code tool.\\n${toolDescriptions}`,\n                },\n                args: {\n                  type: \"string\",\n                  description: \"Tool arguments as a JSON string for the client-side tool.\",\n                },\n              },\n              required: [\"toolName\", \"args\"],\n              additionalProperties: false,\n            },\n          },\n          { type: \"null\" },\n        ],\n      },\n    },\n    required: [\"action\", \"answer\", \"toolCalls\"],\n    additionalProperties: false,\n    ...(normalizedAnswerSchema === undefined\n      ? {}\n      : {\n          $defs: {\n            [USER_OUTPUT_DEFINITION]: normalizedAnswerSchema,\n          },\n        }),\n  };\n}\n\nfunction rebaseUserOutputSchema(schema: JsonValue): JsonValue {\n  return rewriteSchemaNode(schema, \"$\");\n}\n\nconst MAP_KEYWORDS = new Set<string>(SCHEMA_MAP_KEYWORDS);\nconst ARRAY_KEYWORDS = new Set<string>(SCHEMA_ARRAY_KEYWORDS);\nconst SINGLE_KEYWORDS = new Set<string>(SCHEMA_SINGLE_KEYWORDS);\n\nfunction rewriteSchemaNode(value: JsonValue, path: string): JsonValue {\n  if (value === null || typeof value !== \"object\" || Array.isArray(value)) return value;\n\n  const source = value as Record<string, JsonValue>;\n  const result: Record<string, JsonValue> = { ...source };\n\n  for (const unsupportedKeyword of UNSUPPORTED_REFERENCE_KEYWORDS) {\n    if (Object.hasOwn(source, unsupportedKeyword)) {\n      throw new ToolSchemaCompositionError(\n        `${unsupportedKeyword} is not supported`,\n        `${path}.${unsupportedKeyword}`,\n      );\n    }\n  }\n\n  if (\"$ref\" in source) {\n    const ref = source.$ref;\n    if (typeof ref !== \"string\" || (ref !== \"#\" && !ref.startsWith(\"#/\"))) {\n      throw new ToolSchemaCompositionError(\n        \"only root-relative JSON Pointer $ref values are supported\",\n        `${path}.$ref`,\n      );\n    }\n    result.$ref = `${USER_OUTPUT_REF}${ref.slice(1)}`;\n  }\n\n  for (const [keyword, child] of Object.entries(source)) {\n    const keywordPath = `${path}.${keyword}`;\n\n    if (MAP_KEYWORDS.has(keyword) && isJsonObject(child)) {\n      result[keyword] = Object.fromEntries(\n        Object.entries(child).map(([name, schema]) => [\n          name,\n          rewriteSchemaNode(schema, `${keywordPath}.${name}`),\n        ]),\n      ) as JsonValue;\n    } else if (keyword === SCHEMA_DEPENDENCIES_KEYWORD && isJsonObject(child)) {\n      result[keyword] = Object.fromEntries(\n        Object.entries(child).map(([name, dependency]) => [\n          name,\n          Array.isArray(dependency)\n            ? dependency\n            : rewriteSchemaNode(dependency, `${keywordPath}.${name}`),\n        ]),\n      ) as JsonValue;\n    } else if (ARRAY_KEYWORDS.has(keyword) && Array.isArray(child)) {\n      result[keyword] = child.map((schema, index) =>\n        rewriteSchemaNode(schema, `${keywordPath}[${index}]`),\n      ) as JsonValue;\n    } else if (SINGLE_KEYWORDS.has(keyword)) {\n      if (keyword === \"items\" && Array.isArray(child)) {\n        result[keyword] = child.map((schema, index) =>\n          rewriteSchemaNode(schema, `${keywordPath}[${index}]`),\n        ) as JsonValue;\n      } else {\n        result[keyword] = rewriteSchemaNode(child, keywordPath);\n      }\n    }\n  }\n\n  return result as JsonValue;\n}\n\nfunction isJsonObject(value: JsonValue): value is Record<string, JsonValue> {\n  return value !== null && typeof value === \"object\" && !Array.isArray(value);\n}\n"],"mappings":"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"}

package/bundle/dist/utils/providers/common/json-schema-keywords.js

@@ -0,0 +1,77 @@
+//#region src/utils/providers/common/json-schema-keywords.ts
+/**
+* JSON Schema 하위 스키마 위치 목록 — qgrid 의 스키마 순회 3곳이 공유하는 단일 정본.
+*
+*  - `tool-emulation-schema.rewriteSchemaNode`: 사용자 스키마의 local `$ref` 를 namespace 로 rebase
+*  - `strictifier.assertNormalizationCompatibility`: provider 표현 가능성 검사
+*  - `strictifier.strictifyNode`: strict 재작성
+*
+* 세 소비자가 각자 테이블을 들고 있으면 새 keyword 를 한쪽에만 추가하는 순간 조용히 어긋난다.
+* 재작성 패스가 훑지 않는 위치의 `$ref` 는 rebase 되지 않은 채 남고, 검사 패스가 놓친 위치의
+* tuple 은 정규화 없이 provider 로 샌다. 실제로 통합 전 `additionalItems` 가 그 상태였다.
+* 위치 목록은 여기서만 관리한다.
+*
+* 왜 이런 순회가 필요한지는 스킬 문서 참고:
+*   packages/cli/skills/qgrid/references/tool-calling-and-multiturn.md
+*
+* 소비자별로 다른 것은 위치 목록이 아니라 **각 위치를 어떻게 다루는가** 이므로(strictifier 의
+* `normalizable` 플래그 등) 그 판단은 각 소비자가 이 목록 위에 얹는다.
+*/
+/** 이름 → 하위 스키마 맵. 예: `properties`, `$defs`. */
+const SCHEMA_MAP_KEYWORDS = [
+	"$defs",
+	"definitions",
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+];
+/** 하위 스키마 배열. 예: `anyOf`, `prefixItems`. */
+const SCHEMA_ARRAY_KEYWORDS = [
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+];
+/**
+* 하위 스키마 하나를 직접 갖는 위치. `items` 와 `additionalItems` 는 Draft-7 tuple 형식에서
+* 배열이 올 수 있으므로 소비자가 배열 분기를 따로 처리한다.
+*/
+const SCHEMA_SINGLE_KEYWORDS = [
+	"additionalItems",
+	"additionalProperties",
+	"contains",
+	"contentSchema",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+];
+/**
+* Draft-7 `dependencies` 는 값이 스키마이거나 property 이름 배열이라 위 분류에 들어가지 않는다.
+* 배열 형태는 스키마가 아니므로 순회 대상이 아니다.
+*/
+const SCHEMA_DEPENDENCIES_KEYWORD = "dependencies";
+/**
+* qgrid 가 거부하는 참조/식별 keyword.
+*
+* 사용자 스키마는 envelope 의 `$defs` 아래로 옮겨지고 정의는 전역적으로 정규화되므로, base URI 를
+* 새로 선언하거나(`$id`) 런타임 스코프로 대상이 정해지는 참조(`$dynamicRef` 등)는 옮긴 뒤의 의미를
+* 보장할 수 없다. 조용히 잘못 rebase 하는 대신 명시적으로 거부한다.
+*/
+const UNSUPPORTED_REFERENCE_KEYWORDS = [
+	"$id",
+	"id",
+	"$anchor",
+	"$dynamicAnchor",
+	"$recursiveAnchor",
+	"$dynamicRef",
+	"$recursiveRef"
+];
+//#endregion
+export { SCHEMA_ARRAY_KEYWORDS, SCHEMA_DEPENDENCIES_KEYWORD, SCHEMA_MAP_KEYWORDS, SCHEMA_SINGLE_KEYWORDS, UNSUPPORTED_REFERENCE_KEYWORDS };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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) {
@@ -13,31 +23,33 @@ function strictify(schema, options = {}) {
 	if (options.provider === "openai" || options.provider === "anthropic") assertNormalizationCompatibility(result, options.provider);
 	return result;
 }
-const SCHEMA_SCAN_MAP_KEYWORDS = [
-	["$defs", true],
-	["definitions", true],
-	["properties", true],
-	["dependentSchemas", false],
-	["patternProperties", false]
-];
-const SCHEMA_SCAN_ARRAY_KEYWORDS = [
-	["allOf", true],
-	["anyOf", true],
-	["oneOf", true],
-	["prefixItems", true]
-];
-const SCHEMA_SCAN_SINGLE_KEYWORDS = [
-	["additionalProperties", false],
-	["contains", false],
-	["contentSchema", false],
-	["else", false],
-	["if", false],
-	["not", false],
-	["propertyNames", false],
-	["then", false],
-	["unevaluatedItems", false],
-	["unevaluatedProperties", false]
-];
+/**
+* 위치 목록은 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.
 *
@@ -133,15 +145,6 @@ function assertNormalizationCompatibility(schema, provider) {
 	}
 	assertReferenceTargets(schema, references);
 }
-const UNSUPPORTED_REFERENCE_KEYWORDS = [
-	"$id",
-	"id",
-	"$anchor",
-	"$dynamicAnchor",
-	"$recursiveAnchor",
-	"$dynamicRef",
-	"$recursiveRef"
-];
 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}`);
 }
@@ -216,24 +219,24 @@ function strictifyNode(node, path, provider) {
 	if (type === "array" || Object.hasOwn(result, "items") || Object.hasOwn(result, "prefixItems")) result = strictifyArray(result, path, provider);
 	return strictifySchemaArrays(result, path, provider);
 }
-const SCHEMA_MAP_KEYWORDS = ["$defs", "definitions"];
+const DEFINITION_MAP_KEYWORDS = ["$defs", "definitions"];
 function strictifySchemaMaps(node, path, provider) {
 	const result = { ...node };
-	for (const keyword of SCHEMA_MAP_KEYWORDS) {
+	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 SCHEMA_ARRAY_KEYWORDS = [
+const COMBINATOR_KEYWORDS = [
 	"anyOf",
 	"oneOf",
 	"allOf"
 ];
 function strictifySchemaArrays(node, path, provider) {
 	const result = { ...node };
-	for (const keyword of SCHEMA_ARRAY_KEYWORDS) {
+	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));
@@ -365,4 +368,4 @@ function makeNullable(schema) {
 //#endregion
 export { StrictifierError, strictify };
 
-//# 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\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\nconst SCHEMA_SCAN_MAP_KEYWORDS = [\n  [\"$defs\", true],\n  [\"definitions\", true],\n  [\"properties\", true],\n  [\"dependentSchemas\", false],\n  [\"patternProperties\", false],\n] as const;\nconst SCHEMA_SCAN_ARRAY_KEYWORDS = [\n  [\"allOf\", true],\n  [\"anyOf\", true],\n  [\"oneOf\", true],\n  [\"prefixItems\", true],\n] as const;\nconst SCHEMA_SCAN_SINGLE_KEYWORDS = [\n  [\"additionalProperties\", false],\n  [\"contains\", false],\n  [\"contentSchema\", false],\n  [\"else\", false],\n  [\"if\", false],\n  [\"not\", false],\n  [\"propertyNames\", false],\n  [\"then\", false],\n  [\"unevaluatedItems\", false],\n  [\"unevaluatedProperties\", false],\n] as const;\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\nconst UNSUPPORTED_REFERENCE_KEYWORDS = [\n  \"$id\",\n  \"id\",\n  \"$anchor\",\n  \"$dynamicAnchor\",\n  \"$recursiveAnchor\",\n  \"$dynamicRef\",\n  \"$recursiveRef\",\n] as const;\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\nconst SCHEMA_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 SCHEMA_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\nconst SCHEMA_ARRAY_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 SCHEMA_ARRAY_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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"}
+//# 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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"}

package/bundle/dist/utils/providers/openai/openai-worker-pool-config.js

@@ -1,7 +1,7 @@
 //#region src/utils/providers/openai/openai-worker-pool-config.ts
 const MAX_OPENAI_WORKERS_PER_TOKEN = 20;
-const DEFAULT_OPENAI_MIN_WORKERS_PER_TOKEN = 5;
-const DEFAULT_OPENAI_MAX_WORKERS_PER_TOKEN = 15;
+const DEFAULT_OPENAI_MIN_WORKERS_PER_TOKEN = 1;
+const DEFAULT_OPENAI_MAX_WORKERS_PER_TOKEN = 3;
 const OPENAI_WORKER_BASE_RSS_GIB = .71;
 const OPENAI_WORKER_RSS_GIB = .157;
 function boundedInteger(value, fallback, min, max) {
@@ -34,4 +34,4 @@ function estimateOpenAIWorkerRssGiB(totalWorkers) {
 //#endregion
 export { MAX_OPENAI_WORKERS_PER_TOKEN, OPENAI_WORKER_BASE_RSS_GIB, OPENAI_WORKER_RSS_GIB, estimateOpenAIWorkerRssGiB, resolveOpenAIWorkerPoolConfig };
 
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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